private saveFiles(contractName: string, indexCode: string, dappCode: string) {
    const indexFilePath = path.join(this.embark.fs.dappPath(), "app", `${contractName}.html`);
    const dappFilePath = path.join(this.embark.fs.dappPath(), "app", `${contractName}.js`);

    if (!this.options.overwrite && (this.embark.fs.existsSync(indexFilePath) || this.embark.fs.existsSync(dappFilePath))) {
      return [];
    }

    this.embark.fs.writeFileSync(indexFilePath, indexCode);
    this.embark.fs.writeFileSync(dappFilePath, dappCode);

    this.embark.logger.info(__(`${indexFilePath} generated`));
    this.embark.logger.info(__(`${dappFilePath} generated`));
    return [indexFilePath, dappFilePath];
  }

      Object.keys(this.associationAttributes(contractName)).forEach((associationName) => {
        if (associationName === contractName) {
          this.logger.error(__(`${contractName} is referring to himself.`));
          process.exit(1);
        }

        if (!contractNames.includes(associationName)) {
          this.logger.error(__(`${contractName} not found. Please make sure it is in the description.`));
          process.exit(1);
        }

        if (Object.keys(this.data[associationName]).includes(contractName)) {
          this.logger.error(__(`${associationName} has a cyclic dependencies with ${contractName}.`));
          process.exit(1);
        }
      });

  public validate() {
    if (!scaffoldingSchema(this.data)) {
      this.logger.error(__("The scaffolding schema is not valid:"));
      this.logger.error(ajv.errorsText(scaffoldingSchema.errors));
      process.exit(1);
    }

    const contractNames = Object.keys(this.data);
    contractNames.forEach((contractName) => {
      if (contractName[0] !== contractName[0].toUpperCase()) {
        this.logger.error(__(`${contractName} must be capitalized.`));
        process.exit(1);
      }
      Object.keys(this.associationAttributes(contractName)).forEach((associationName) => {
        if (associationName === contractName) {
          this.logger.error(__(`${contractName} is referring to himself.`));
          process.exit(1);
        }

        if (!contractNames.includes(associationName)) {
          this.logger.error(__(`${contractName} not found. Please make sure it is in the description.`));
          process.exit(1);
        }

        if (Object.keys(this.data[associationName]).includes(contractName)) {
          this.logger.error(__(`${associationName} has a cyclic dependencies with ${contractName}.`));
          process.exit(1);
        }
      });
    });
  }

  private registerConsoleCommands() {
    this.embark.registerConsoleCommand({
      description: __("Start or stop the API"),
      matches: ["api start"],
      process: (cmd: string, callback: () => void) => {
        this.embark.events.request("api:start", callback);
      },
      usage: "api start/stop",
    });

    this.embark.registerConsoleCommand({
      matches: ["api stop"],
      process: (cmd: string, callback: () => void) => {
        this.embark.events.request("api:stop", callback);
      },
    });

    this.embark.registerConsoleCommand({
      matches: ["log api on"],
      process: (cmd: string, callback: () => void) => {
        this.embark.events.request("logs:api:enable", callback);
      },
    });

    this.embark.registerConsoleCommand({
      matches: ["log api off"],
      process: (cmd: string, callback: () => void) => {
        this.embark.events.request("logs:api:disable", callback);
      },
    });
  }

  constructor(private embark: Embark, private options: any) {
    this.embark.events.emit("status", __("Starting API & Cockpit UI"));
    findNextPort(DEFAULT_PORT).then((port: any) => {
      this.port = port;
      this.apiUrl = `http://${DEFAULT_HOSTNAME}:${this.port}`;

      this.api = new Server(this.embark, this.port, dockerHostSwap(DEFAULT_HOSTNAME), options.plugins);

      this.listenToCommands();
      this.registerConsoleCommands();

      this.embark.events.request("processes:register", "api", {
        launchFn: (cb: (error: Error | null, message: string) => void) => {
          this.api.start()
            .then(() => cb(null, __("Cockpit UI available at %s", this.apiUrl)))
            .catch((error: Error) => cb(error, ""));
        },
        stopFn: (cb: (error: Error | null, message: string) => void) => {
          this.api.stop()
            .then(() => cb(null, __("Cockpit UI stopped")))
            .catch((error: Error) => cb(error, ""));
        },
      });

      this.embark.events.request("processes:launch", "api", (error: Error | null, message: string) => {
        if (error) {
          this.embark.logger.error(error.message);
        } else {
          this.embark.logger.info(message);
        }
        this.setServiceCheck();
      });
    });
  }

 process: (cmd: string, callback: (err?: string|object, output?: string) => void) => {
   if (!this.cmdDebugger) {
     this.embark.logger.warn(NO_DEBUG_SESSION);
     return callback();
   }
   this.cmdDebugger = null;
   this.embark.logger.info(__("The debug session has been stopped"));
   this.cmdDebugger.unload();
 },

 }, (err: Error, result: boolean) => {
   if (err) {
     return next(err);
   }
   if (!result) {
     // No compiler was compatible
     return next(new Error(__("No installed compiler was compatible with your version of %s files", extension)));
   }
   next();
 });

  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);
  }

  private saveFile(contractName: string, code: string) {
    const filename = `${contractName}.sol`;
    const contractDirs = this.embark.config.embarkConfig.contracts;
    const contractDir = Array.isArray(contractDirs) ? contractDirs[0] : contractDirs;
    const filePath = this.embark.fs.dappPath(contractDir.replace(/\*/g, ""), filename);
    if (!this.options.overwrite && this.embark.fs.existsSync(filePath)) {
      this.embark.logger.error(__(`The contract ${contractName} already exists, skipping.`));
      return;
    }

    this.embark.fs.writeFileSync(filePath, code);
    return filePath;
  }

 private registerConsoleCommands() {
   this.embark.registerConsoleCommand({
     description: __("display console commands history"),
     matches: (cmd: string) => {
       const [cmdName] = cmd.split(" ");
       return cmdName === "history";
     },
     process: (cmd: string, callback: any) => {
       const [_cmdName, length] = cmd.split(" ");
       this.getHistory(length, callback);
     },
     usage: "history [optionalLength]",
   });
 }