genlayer 0.12.1 → 0.12.2-beta.1

package/src/commands/general/init.ts

@@ -1,8 +1,10 @@
 import inquirer from "inquirer";
-import {ISimulatorService} from "../../lib/interfaces/ISimulatorService";
-import {AI_PROVIDERS_CONFIG, AiProviders} from "../../lib/config/simulator";
+import { DistinctQuestion } from "inquirer";
+import { ISimulatorService } from "../../lib/interfaces/ISimulatorService";
+import { AI_PROVIDERS_CONFIG, AiProviders } from "../../lib/config/simulator";
 import { OllamaAction } from "../update/ollama";
-import { ConfigFileManager } from "../../lib/config/ConfigFileManager";
+import { BaseAction } from "../../lib/actions/BaseAction";
+import { SimulatorService } from "../../lib/services/simulator";
 
 export interface InitActionOptions {
   numValidators: number;
@@ -11,217 +13,162 @@ export interface InitActionOptions {
   localnetVersion: string;
 }
 
-function getRequirementsErrorMessage({docker}: Record<string, boolean>): string {
-
+function getRequirementsErrorMessage({ docker }: Record<string, boolean>): string {
   if (!docker) {
     return "Docker is not installed. Please install Docker and try again.\n";
   }
-
   return "";
 }
 
-function getVersionErrorMessage({docker, node}: Record<string, string>): string {
+function getVersionErrorMessage({ docker, node }: Record<string, string>): string {
   let message = "";
 
   if (docker) {
     message += `Docker version ${docker} or higher is required. Please update Docker and try again.\n`;
   }
-
   if (node) {
     message += `Node version ${node} or higher is required. Please update Node and try again.\n`;
   }
-
   return message;
 }
 
-export async function initAction(options: InitActionOptions, simulatorService: ISimulatorService) {
-  simulatorService.setComposeOptions(options.headless);
-
-  let localnetVersion = options.localnetVersion;
-
-  if(localnetVersion !== 'latest'){
-    localnetVersion = simulatorService.normalizeLocalnetVersion(localnetVersion);
+export class InitAction extends BaseAction {
+  private simulatorService: ISimulatorService;
+  constructor() {
+    super();
+    this.simulatorService = new SimulatorService();
   }
-  await simulatorService.checkCliVersion();
-
-  // Check if requirements are installed
-  try {
-    const requirementsInstalled = await simulatorService.checkInstallRequirements();
-    const requirementErrorMessage = getRequirementsErrorMessage(requirementsInstalled);
-
-    if (requirementErrorMessage) {
-      console.error(requirementErrorMessage);
-      return;
-    }
-  } catch (error) {
-    console.error(error);
-    return;
-  }
-
-  // Check if the versions are correct
-  try {
-    const missingVersions = await simulatorService.checkVersionRequirements();
-    const versionErrorMessage = getVersionErrorMessage(missingVersions);
 
-    if (versionErrorMessage) {
-      console.error(versionErrorMessage);
-      return;
-    }
-  } catch (error) {
-    console.error(error);
-    return;
-  }
-
-  // Ask for confirmation on reseting the GenLayer Simulator from GitHub
-  const resetAnswers = await inquirer.prompt([
-    {
-      type: "confirm",
-      name: "confirmReset",
-      message: `This command is going to reset GenLayer docker images and containers, providers API Keys, and GenLayer database (accounts, transactions, validators and logs). Contract code (gpy files) will be kept. Do you want to continue?`,
-      default: true,
-    },
-  ]);
-
-  if (!resetAnswers.confirmReset) {
-    console.log("Aborted!");
-    return;
-  }
-
-  console.log(`Initializing GenLayer CLI with ${options.numValidators} validators`);
-
-  // Reset Docker containers and images
-  console.log(`Resetting Docker containers and images...`);
-  try {
-    await simulatorService.resetDockerContainers();
-    await simulatorService.resetDockerImages();
-  } catch (error) {
-    console.error(error);
-    return;
-  }
+  public async execute(options: InitActionOptions): Promise<void> {
+    try {
+      this.simulatorService.setComposeOptions(options.headless);
+      let localnetVersion = options.localnetVersion;
+      if (localnetVersion !== "latest") {
+        localnetVersion = this.simulatorService.normalizeLocalnetVersion(localnetVersion);
+      }
+
+      this.startSpinner("Checking CLI version...");
+      await this.simulatorService.checkCliVersion();
+
+      this.setSpinnerText("Checking installation requirements...");
+      const requirementsInstalled = await this.simulatorService.checkInstallRequirements();
+      const requirementErrorMessage = getRequirementsErrorMessage(requirementsInstalled);
+      if (requirementErrorMessage) {
+        this.failSpinner(requirementErrorMessage);
+        return;
+      }
+
+      this.setSpinnerText("Checking version requirements...");
+      const missingVersions = await this.simulatorService.checkVersionRequirements();
+      const versionErrorMessage = getVersionErrorMessage(missingVersions);
+      if (versionErrorMessage) {
+        this.failSpinner(versionErrorMessage);
+        return;
+      }
+      this.stopSpinner();
+
+      // Confirm reset action with the user using BaseAction's confirm prompt
+      await this.confirmPrompt(
+        `This command is going to reset GenLayer docker images and containers, providers API Keys, and GenLayer database (accounts, transactions, validators and logs). Contract code (gpy files) will be kept. Do you want to continue?`
+      );
 
-  // Check LLM configuration
-  const questions = [
-    {
-      type: "checkbox",
-      name: "selectedLlmProviders",
-      message: "Select which LLM providers do you want to use:",
-      choices: simulatorService.getAiProvidersOptions(true),
-      validate: function (answer: string[]) {
-        if (answer.length < 1) {
-          return "You must choose at least one option.";
-        }
-        return true;
-      },
-    },
-  ];
-
-  // Since ollama runs locally we can run it here and then look for the other providers
-  const llmProvidersAnswer = await inquirer.prompt(questions);
-  const selectedLlmProviders = llmProvidersAnswer.selectedLlmProviders as AiProviders[];
-
-  // Gather the API Keys
-  const aiProvidersEnvVars: Record<string, string> = {};
-  const configurableAiProviders = selectedLlmProviders.filter(
-    (provider: AiProviders) => AI_PROVIDERS_CONFIG[provider].envVar,
-  );
-  for (let i = 0; i < configurableAiProviders.length; i++) {
-    const provider = configurableAiProviders[i];
-    const providerConfig = AI_PROVIDERS_CONFIG[provider];
-    const questions = [
-      {
-        type: "input",
-        name: providerConfig.cliOptionValue,
-        message: `Please enter your ${providerConfig.name} API Key:`,
-        validate: function (value: string) {
-          if (value.length) {
-            return true;
-          }
-          return `Please enter a valid API Key for ${providerConfig.name}.`;
+      this.logInfo(`Initializing GenLayer CLI with ${options.numValidators} validators`);
+
+      // Reset Docker containers and images
+      this.startSpinner("Resetting Docker containers and images...");
+      await this.simulatorService.resetDockerContainers();
+      await this.simulatorService.resetDockerImages();
+      this.stopSpinner();
+
+      const llmQuestions: DistinctQuestion[] = [
+        {
+          type: "checkbox",
+          name: "selectedLlmProviders",
+          message: "Select which LLM providers do you want to use:",
+          choices: this.simulatorService.getAiProvidersOptions(true),
+          validate: (answer) =>
+            answer.length < 1 ? "You must choose at least one option." : true,
         },
-      },
-    ];
-
-    const apiKeyAnswer = await inquirer.prompt(questions);
-    aiProvidersEnvVars[providerConfig.envVar!] = apiKeyAnswer[providerConfig.cliOptionValue];
-  }
-
-  console.log("Configuring GenLayer Simulator environment...");
-  simulatorService.addConfigToEnvFile(aiProvidersEnvVars);
-  simulatorService.addConfigToEnvFile({LOCALNETVERSION: localnetVersion});
-
-  // Run the GenLayer Simulator
-  console.log("Running the GenLayer Simulator...");
-  try {
-    // eslint-disable-next-line @typescript-eslint/no-floating-promises
-    await simulatorService.runSimulator();
-  } catch (error) {
-    console.error(error);
-    return;
-  }
-
-  try {
-    const {initialized, errorCode, errorMessage} = await simulatorService.waitForSimulatorToBeReady();
-    if (!initialized && errorCode === "ERROR") {
-      console.log(errorMessage);
-      console.error("Unable to initialize the GenLayer simulator. Please try again.");
-      return;
-    }
-    if (!initialized && errorCode === "TIMEOUT") {
-      console.error(
-        "The simulator is taking too long to initialize. Please try again after the simulator is ready.",
+      ];
+      const llmProvidersAnswer = await inquirer.prompt(llmQuestions);
+      const selectedLlmProviders = llmProvidersAnswer.selectedLlmProviders as AiProviders[];
+
+      let defaultOllamaModel = this.getConfig().defaultOllamaModel;
+      const aiProvidersEnvVars: Record<string, string> = {};
+      const configurableAiProviders = selectedLlmProviders.filter(
+        (provider: AiProviders) => AI_PROVIDERS_CONFIG[provider].envVar
       );
-      return;
-    }
-    console.log("Simulator is running!");
-  } catch (error) {
-    console.error(error);
-    return;
-  }
-
-  // Ollama doesn't need changes in configuration, we just run it
-  if (selectedLlmProviders.includes("ollama")) {
-
-    const ollamaAction = new OllamaAction();
-    const configManager = new ConfigFileManager();
-    const config = configManager.getConfig()
-    let ollamaModel = config.defaultOllamaModel;
-
-    if(!config.defaultOllamaModel){
-      configManager.writeConfig('defaultOllamaModel', 'llama3');
-      ollamaModel = 'llama3'
-    }
-
-    console.log(`Pulling ${ollamaModel} from Ollama...`);
-
-    await ollamaAction.updateModel(ollamaModel);
-  }
+      for (const provider of configurableAiProviders) {
+        const providerConfig = AI_PROVIDERS_CONFIG[provider];
+        const keyQuestion: DistinctQuestion[] = [
+          {
+            type: "input",
+            name: providerConfig.cliOptionValue,
+            message: `Please enter your ${providerConfig.name} API Key:`,
+            validate: (value: string) =>
+              value.length ? true : `Please enter a valid API Key for ${providerConfig.name}.`,
+          },
+        ];
+        const apiKeyAnswer = await inquirer.prompt(keyQuestion);
+        aiProvidersEnvVars[providerConfig.envVar!] = apiKeyAnswer[providerConfig.cliOptionValue];
+      }
+
+      this.startSpinner("Configuring GenLayer Localnet environment...");
+      this.simulatorService.addConfigToEnvFile(aiProvidersEnvVars);
+      this.simulatorService.addConfigToEnvFile({ LOCALNETVERSION: localnetVersion });
+
+      this.setSpinnerText("Running GenLayer Localnet...");
+      await this.simulatorService.runSimulator();
+
+      this.setSpinnerText("Waiting for localnet to be ready...");
+      const { initialized, errorCode, errorMessage } =
+        await this.simulatorService.waitForSimulatorToBeReady();
+      if (!initialized) {
+        if (errorCode === "ERROR") {
+          this.failSpinner(`Unable to initialize the GenLayer Localnet: ${errorMessage}`);
+          return;
+        }
+        if (errorCode === "TIMEOUT") {
+          this.failSpinner(
+            "The localnet is taking too long to initialize. Please try again after the localnet is ready."
+          );
+          return;
+        }
+      }
 
-  // Initializing validators
-  console.log("Initializing validators...");
-  try {
-    //remove all validators
-    await simulatorService.deleteAllValidators();
-    // create random validators
-    await simulatorService.createRandomValidators(Number(options.numValidators), selectedLlmProviders);
-  } catch (error) {
-    console.error("Unable to initialize the validators.");
-    console.error(error);
-    return;
-  }
+      this.stopSpinner();
 
-  if(options.resetDb){
-    await simulatorService.cleanDatabase()
-  }
+      if (selectedLlmProviders.includes("ollama")) {
+        const ollamaAction = new OllamaAction();
+        if (!defaultOllamaModel) {
+          this.writeConfig("defaultOllamaModel", "llama3");
+          defaultOllamaModel = "llama3";
+        }
+        await ollamaAction.updateModel(defaultOllamaModel);
+      }
+
+      this.startSpinner("Initializing validators...");
+      await this.simulatorService.deleteAllValidators();
+      await this.simulatorService.createRandomValidators(
+        Number(options.numValidators),
+        selectedLlmProviders
+      );
 
-  // Simulator ready
-  let successMessage = "GenLayer simulator initialized successfully! "
-  successMessage += options.headless ? '' :  `Go to ${simulatorService.getFrontendUrl()} in your browser to access it.`;
-  console.log(successMessage);
-  try {
-    if(!options.headless){
-      await simulatorService.openFrontend();
+      if (options.resetDb) {
+        this.setSpinnerText("Cleaning database...");
+        await this.simulatorService.cleanDatabase();
+      }
+
+      let successMessage = "GenLayer Localnet initialized successfully! ";
+      if (!options.headless) {
+        successMessage += `Go to ${this.simulatorService.getFrontendUrl()} in your browser to access it.`;
+      }
+      if (!options.headless) {
+        await this.simulatorService.openFrontend();
+      }
+      this.succeedSpinner(successMessage);
+    } catch (error) {
+      this.failSpinner("An error occurred during initialization.", error);
     }
-  } catch (error) {
-    console.error(error);
   }
 }

package/src/commands/general/start.ts

@@ -1,104 +1,103 @@
 import inquirer from "inquirer";
-
-import {ISimulatorService} from "../../lib/interfaces/ISimulatorService";
+import { ISimulatorService } from "../../lib/interfaces/ISimulatorService";
+import { DistinctQuestion } from "inquirer";
+import { BaseAction } from "../../lib/actions/BaseAction";
+import { SimulatorService } from "../../lib/services/simulator";
 
 export interface StartActionOptions {
   resetValidators: boolean;
   numValidators: number;
   headless: boolean;
-  resetDb: boolean
+  resetDb: boolean;
 }
 
-export async function startAction(options: StartActionOptions, simulatorService: ISimulatorService) {
-  const {resetValidators, numValidators, headless, resetDb} = options;
+export class StartAction extends BaseAction {
+  private simulatorService: ISimulatorService;
 
-  simulatorService.setComposeOptions(headless);
+  constructor() {
+    super();
+    this.simulatorService = new SimulatorService();
+  }
 
-  await simulatorService.checkCliVersion();
+  async execute(options: StartActionOptions) {
+    const { resetValidators, numValidators, headless, resetDb } = options;
 
-  const restartValidatorsHintText = resetValidators
-    ? `creating new ${numValidators} random validators`
-    : "keeping the existing validators";
+    this.simulatorService.setComposeOptions(headless);
+    this.startSpinner("Checking CLI version...");
+    await this.simulatorService.checkCliVersion();
 
-  console.log(`Starting GenLayer simulator ${restartValidatorsHintText}`);
+    const restartValidatorsHintText = resetValidators
+      ? `creating new ${numValidators} random validators`
+      : "keeping the existing validators";
+    this.setSpinnerText(`Starting GenLayer Localnet (${restartValidatorsHintText})...`);
 
-  try {
-    await simulatorService.runSimulator();
-  } catch (error) {
-    console.error(error);
-    return;
-  }
-
-  try {
-    const {initialized, errorCode, errorMessage} = await simulatorService.waitForSimulatorToBeReady();
-    if (!initialized && errorCode === "ERROR") {
-      console.log(errorMessage);
-      console.error("Unable to initialize the GenLayer simulator. Please try again.");
-      return;
-    }
-    if (!initialized && errorCode === "TIMEOUT") {
-      console.error(
-        "The simulator is taking too long to initialize. Please try again after the simulator is ready.",
-      );
+    try {
+      await this.simulatorService.runSimulator();
+    } catch (error) {
+      this.failSpinner("Error starting the simulator", error);
       return;
     }
-    console.log("Simulator is running!");
-  } catch (error) {
-    console.error(error);
-    return;
-  }
-
-  if(resetDb){
-    await simulatorService.cleanDatabase()
-  }
 
-  if (resetValidators) {
-    // Initializing validators
-    console.log("Initializing validators...");
     try {
-      //remove all validators
-      await simulatorService.deleteAllValidators();
-      const questions = [
-        {
-          type: "checkbox",
-          name: "selectedLlmProviders",
-          message: "Select which LLM providers do you want to use:",
-          choices: simulatorService.getAiProvidersOptions(false),
-          validate: function (answer: string[]) {
-            if (answer.length < 1) {
-              return "You must choose at least one option.";
-            }
-            return true;
-          },
-        },
-      ];
+      this.setSpinnerText("Waiting for the simulator to be ready...");
+      const { initialized, errorCode, errorMessage } = await this.simulatorService.waitForSimulatorToBeReady();
 
-      // Since ollama runs locally we can run it here and then look for the other providers
-      const llmProvidersAnswer = await inquirer.prompt(questions);
+      if (!initialized) {
+        if (errorCode === "ERROR") {
+          this.failSpinner("Unable to initialize the GenLayer simulator.", errorMessage);
+          return;
+        }
+        if (errorCode === "TIMEOUT") {
+          this.failSpinner("The simulator is taking too long to initialize. Please try again later.");
+          return;
+        }
+      }
 
-      // create random validators
-      await simulatorService.createRandomValidators(
-        Number(options.numValidators),
-        llmProvidersAnswer.selectedLlmProviders,
-      );
     } catch (error) {
-      console.error("Unable to initialize the validators.");
-      console.error(error);
+      this.failSpinner("Error waiting for the simulator to be ready", error);
       return;
     }
-    console.log("New random validators successfully created...");
-  }
 
-  // Simulator ready
-  let successMessage = "GenLayer simulator initialized successfully! "
-  successMessage += headless ? '' :  `Go to ${simulatorService.getFrontendUrl()} in your browser to access it.`;
-  console.log(successMessage);
-  try {
-    if(!headless) {
-      await simulatorService.openFrontend();
+    if (resetDb) {
+      this.setSpinnerText("Resetting database...");
+      await this.simulatorService.cleanDatabase();
+    }
+
+    if (resetValidators) {
+      this.setSpinnerText("Initializing validators...");
+      try {
+        await this.simulatorService.deleteAllValidators();
+
+        const questions: DistinctQuestion[] = [
+          {
+            type: "checkbox",
+            name: "selectedLlmProviders",
+            message: "Select which LLM providers do you want to use:",
+            choices: this.simulatorService.getAiProvidersOptions(false),
+            validate: (answer) => (answer.length < 1 ? "You must choose at least one option." : true),
+          },
+        ];
+
+        const llmProvidersAnswer = await inquirer.prompt(questions);
+        await this.simulatorService.createRandomValidators(numValidators, llmProvidersAnswer.selectedLlmProviders);
+      } catch (error) {
+        this.failSpinner("Unable to initialize the validators", error);
+        return;
+      }
     }
 
-  } catch (error) {
-    console.error(error);
+    let successMessage = "GenLayer simulator initialized successfully! ";
+    successMessage += headless ? "" : `Go to ${this.simulatorService.getFrontendUrl()} in your browser to access it.`;
+    this.succeedSpinner(successMessage);
+
+    if (!headless) {
+      try {
+        this.startSpinner("Opening frontend...");
+        await this.simulatorService.openFrontend();
+        this.succeedSpinner("Frontend opened successfully");
+      } catch (error) {
+        this.failSpinner("Error opening the frontend", error);
+      }
+    }
   }
 }

package/src/commands/general/stop.ts

@@ -11,15 +11,16 @@ export class StopAction extends BaseAction {
   }
 
   public async stop(): Promise<void> {
-    try{
+    try {
       await this.confirmPrompt(
         "Are you sure you want to stop all running GenLayer containers? This will halt all active processes."
       );
-      console.log(`Stopping Docker containers...`);
+
+      this.startSpinner("Stopping Docker containers...");
       await this.simulatorService.stopDockerContainers();
-      console.log(`All running GenLayer containers have been successfully stopped.`);
-    }catch (error) {
-      console.error("An error occurred while stopping the containers:", error)
+      this.succeedSpinner("All running GenLayer containers have been successfully stopped.");
+    } catch (error) {
+      this.failSpinner("An error occurred while stopping the containers.", error);
     }
   }
 }

package/src/commands/keygen/create.ts

@@ -1,26 +1,25 @@
 import { writeFileSync, existsSync } from "fs";
 import { ethers } from "ethers";
-import { ConfigFileManager } from "../../lib/config/ConfigFileManager";
+import { BaseAction } from "../../lib/actions/BaseAction";
 
 export interface CreateKeypairOptions {
   output: string;
   overwrite: boolean;
 }
 
-export class KeypairCreator {
-  private filePathManager: ConfigFileManager;
+export class KeypairCreator extends BaseAction{
 
   constructor() {
-    this.filePathManager = new ConfigFileManager();
+    super()
   }
 
   createKeypairAction(options: CreateKeypairOptions) {
     try {
-
-      const outputPath = this.filePathManager.getFilePath(options.output);
+      this.startSpinner(`Creating keypair...`);
+      const outputPath = this.getFilePath(options.output);
 
       if(existsSync(outputPath) && !options.overwrite) {
-        console.warn(
+        this.failSpinner(
           `The file at ${outputPath} already exists. Use the '--overwrite' option to replace it.`
         );
         return;
@@ -34,11 +33,10 @@ export class KeypairCreator {
 
       writeFileSync(outputPath, JSON.stringify(keypairData, null, 2));
 
-      this.filePathManager.writeConfig('keyPairPath', outputPath);
-      console.log(`Keypair successfully created and saved to: ${outputPath}`);
+      this.writeConfig('keyPairPath', outputPath);
+      this.succeedSpinner(`Keypair successfully created and saved to: ${outputPath}`);
     } catch (error) {
-      console.error("Failed to generate keypair:", error);
-      process.exit(1);
+      this.failSpinner("Failed to generate keypair:", error);
     }
   }
 }

package/src/commands/update/index.ts

@@ -1,6 +1,5 @@
 import { Command } from "commander";
 import { OllamaAction } from "./ollama";
-import { ConfigFileManager } from "../../lib/config/ConfigFileManager";
 
 export function initializeUpdateCommands(program: Command) {
   const updateCommand = program
@@ -10,19 +9,15 @@ export function initializeUpdateCommands(program: Command) {
   updateCommand
     .command("ollama")
     .description("Manage Ollama models (update or remove)")
-    .option("--model [model-name]", "Specify the model to update or remove")
+    .option("--model [model-name]", "Specify the model to update or remove", '')
     .option("--remove", "Remove the specified model instead of updating")
     .action(async (options) => {
-      const configManager = new ConfigFileManager();
-      const config = configManager.getConfig()
-
-      const modelName = options.model || config.defaultOllamaModel;
       const ollamaAction = new OllamaAction();
 
       if (options.remove) {
-        await ollamaAction.removeModel(modelName);
+        await ollamaAction.removeModel(options.model);
       } else {
-        await ollamaAction.updateModel(modelName);
+        await ollamaAction.updateModel(options.model);
       }
     });