constructor(embark: Embark, options: any) {
    this.embark = embark;
    this.events = options.events;
    this.plugins = options.plugins;
    this.version = options.version;
    this.logger = options.logger;
    this.fs = embark.fs;
    this.ipc = options.ipc;
    this.config = options.config;
    this.history = [];
    this.cmdHistoryFile = options.cmdHistoryFile || this.fs.dappPath(".embark", "cmd_history");
    this.providerReady = false;
    this.loadHistory();

    if (this.ipc.isServer()) {
      this.ipc.on("console:executeCmd", (cmd: string, cb: any) => {
        this.executeCmd(cmd, (err: string, result: any) => {
          let error = null;
          if (err) {
            // reformat for IPC reply
            error = { name: "Console error", message: err, stack: err };
          }
          cb(error, result);
        });
      });
      this.ipc.on("console:history:save", true, (cmd: string) => {
        this.saveHistory(cmd, true);
      });
    }
    this.events.setCommandHandler("console:executeCmd", this.executeCmd.bind(this));
    this.events.setCommandHandler("console:history", (cb: any) => this.getHistory(this.cmdHistorySize(), cb));
    this.events.setCommandHandler("console:provider:ready", (cb: any) => {
      if (this.providerReady || this.isEmbarkConsole) {
        return cb();
      }
      this.events.once("console:provider:done", cb);
    });
    this.registerConsoleCommands();

    if (this.isEmbarkConsole) {
      return;
    }
    this.registerEmbarkJs((err?: Error |  null) => {
      if (err) {
        return this.logger.error(err);
      }
      this.providerReady = true;
      this.events.emit("console:provider:done");
    });
    this.registerApi();

    this.suggestions = new Suggestions(embark, options);
  }

 this.registerEmbarkJs((err?: Error |  null) => {
   if (err) {
     return this.logger.error(err);
   }
   this.providerReady = true;
   this.events.emit("console:provider:done");
 });

  private saveHistory(cmd: string, fromIpcClient = false) {
    const history = this.history;
    if (fromIpcClient) {
      if (history[history.length - 1] !== cmd) {
        history.push(cmd);
      }
      this.events.emit("console:history:save", cmd);
      return this.ipc.broadcast("console:history:save", cmd, true);
    }

    history.push(cmd);
    if (this.ipc.isServer()) {
      this.ipc.broadcast("console:history:save", cmd, true);
    } else if (this.ipc.connected) {
      this.ipc.client.emit("console:history:save", cmd);
    }

    if (this.fs.existsSync(dirname(this.cmdHistoryFile))) {
      this.fs.writeFileSync(
        this.cmdHistoryFile,
        history
          .slice(Math.max(0, history.length - this.cmdHistorySize()))
          .reverse()
          .filter((line: string) => line.trim())
          .join("\n"),
      );
    }
  }

  private executeCmd(cmd: string, callback: any) {
    // if this is the embark console process, send the command to the process
    // running all the needed services (ie the process running `embark run`)
    if (this.isEmbarkConsole) {
      return this.ipc.request("console:executeCmd", cmd, callback);
    }

    if (!(cmd.split(" ")[0] === "history" || cmd === __("history"))) {
      this.saveHistory(cmd);
    }
    const plugins = this.plugins.getPluginsProperty("console", "console");
    const helpDescriptions = [];
    for (const plugin of plugins) {
      if (plugin.description) {
        helpDescriptions.push({
          description: plugin.description,
          matches: plugin.matches,
          usage: plugin.usage,
        });
      }
      if (plugin.matches) {
        const isFunction = typeof plugin.matches === "function";
        if ((isFunction && plugin.matches.call(this, cmd))
          || (!isFunction && plugin.matches.includes(cmd))) {
          return plugin.process.call(this, cmd, callback);
        }
        continue;
      }

      const pluginResult = plugin.call(this, cmd, {});

      if (typeof pluginResult !== "object") {
        if (pluginResult !== false && pluginResult !== "false" && pluginResult !== undefined) {
          this.logger.warn("[DEPRECATED] In future versions of embark, we expect the console command to return an object " +
            "having 2 functions: match and process." +
            " The documentation with example can be found here: https://embark.status.im/docs/plugin_reference.html#embark-registerConsoleCommand-callback-options");
          return callback(null, pluginResult);
        }
      } else if (pluginResult.match()) {
        return pluginResult.process(callback);
      }
    }

    const output = this.processEmbarkCmd(cmd, helpDescriptions);
    if (output) {
      return callback(null, output);
    }

    this.events.request("runcode:eval", cmd, (err: Error, result: any) => {
      if (err) {
        return callback(err.message);
      }
      callback(null, result);
    }, true);
  }

 (next: any) => {
   if (this.isEmbarkConsole) {
     return next();
   }
   const connectCode = `EmbarkJS.Blockchain.connectConsole((err) => {
     if(err) throw new Error("[VM]: Error connecting to blockchain. " + err);
   });`;
   this.events.request("runcode:eval", connectCode, (err: Error, _result: any) => {
     cb(err);
   });
 },

 (next: any) => {
   const waitingForReady = setTimeout(() => {
     this.logger.warn(__("Waiting for the blockchain connector to be ready..."));
     // TODO add docs link to how to install one
     this.logger.warn(__("If you did not install a blockchain connector, stop this process and install one"));
   }, 5000);
   this.events.request("blockchain:connector:ready", () => {
     clearTimeout(waitingForReady);
     next();
   });
 },