genlayer 0.12.1 → 0.12.2-beta.0

package/src/commands/update/ollama.ts

@@ -1,72 +1,71 @@
 import Docker from "dockerode";
 import { rpcClient } from "../../lib/clients/jsonRpcClient";
+import { BaseAction } from "../../lib/actions/BaseAction";
 
-export class OllamaAction {
+export class OllamaAction extends BaseAction {
   private docker: Docker;
 
   constructor() {
+    super();
     this.docker = new Docker();
   }
 
   async updateModel(modelName: string) {
-    const providersAndModels = await rpcClient.request({
-      method: "sim_getProvidersAndModels",
-      params: [],
-    });
-
-    const existingOllamaProvider = providersAndModels.result.find(
-      (entry: any) => entry.plugin === "ollama"
-    );
+    try {
+      this.startSpinner(`Updating model "${modelName}"...`);
 
-    if (!existingOllamaProvider) {
-      throw new Error("No existing 'ollama' provider found. Unable to add/update a model.");
-    }
+      if(!modelName){
+        modelName = this.getConfig().defaultOllamaModel;
+      }
 
-    await this.executeModelCommand(
-      "pull",
-      modelName,
-      `Model "${modelName}" updated successfully`
-    );
-
-    const existingModel = providersAndModels.result.some(
-      (entry: any) =>
-        entry.plugin === "ollama" && entry.model === modelName
-    );
-
-    if (!existingModel) {
-      console.log(`Model "${modelName}" not found in Provider Presets. Adding...`);
-
-      const newModelConfig = {
-        config: existingOllamaProvider.config,
-        model: modelName,
-        plugin: "ollama",
-        plugin_config: existingOllamaProvider.plugin_config,
-        provider: "ollama",
-      };
-
-      await rpcClient.request({
-        method: "sim_addProvider",
-        params: [newModelConfig],
+      const providersAndModels = await rpcClient.request({
+        method: "sim_getProvidersAndModels",
+        params: [],
       });
 
-      console.log(`Model "${modelName}" added successfully.`);
+      const existingOllamaProvider = providersAndModels.result.find(
+        (entry: any) => entry.plugin === "ollama"
+      );
+
+      if (!existingOllamaProvider) {
+        return this.failSpinner("No existing 'ollama' provider found. Unable to add/update a model.");
+      }
+
+      await this.executeModelCommand("pull", modelName, `Model "${modelName}" updated successfully`);
+
+      const existingModel = providersAndModels.result.some(
+        (entry: any) => entry.plugin === "ollama" && entry.model === modelName
+      );
+      if (!existingModel) {
+        this.startSpinner(`Adding model "${modelName}" to Provider Presets...`);
+
+        const newModelConfig = {
+          config: existingOllamaProvider.config,
+          model: modelName,
+          plugin: "ollama",
+          plugin_config: existingOllamaProvider.plugin_config,
+          provider: "ollama",
+        };
+
+        await rpcClient.request({
+          method: "sim_addProvider",
+          params: [newModelConfig],
+        });
+        this.succeedSpinner(`Model "${modelName}" added to Provider Presets successfully.`);
+      }
+    } catch (error) {
+      this.failSpinner(`Error updating model "${modelName}"`, error);
     }
   }
 
   async removeModel(modelName: string) {
-    await this.executeModelCommand(
-      "rm",
-      modelName,
-      `Model "${modelName}" removed successfully`
-    );
+    await this.executeModelCommand("rm", modelName, `Model "${modelName}" removed successfully`);
   }
 
-  private async executeModelCommand(
-    command: string,
-    modelName: string,
-    successMessage: string
-  ) {
+  private async executeModelCommand(command: string, modelName: string, successMessage: string) {
     try {
+      this.startSpinner(`Executing '${command}' command on model "${modelName}"...`);
+
       let success = false;
       const ollamaContainer = this.docker.getContainer("ollama");
       const exec = await ollamaContainer.exec({
@@ -74,12 +73,13 @@ export class OllamaAction {
         AttachStdout: true,
         AttachStderr: true,
       });
-      const stream = await exec.start({Detach: false, Tty: false});
+      const stream = await exec.start({ Detach: false, Tty: false });
 
       stream.on("data", (chunk: any) => {
-        const chunkStr = chunk.toString();
-        console.log(chunkStr);
-        if (chunkStr.includes("success") || chunkStr.includes("deleted")) {
+        const output = chunk.toString();
+        this.setSpinnerText(output.trim());
+
+        if (output.includes("success") || output.includes("deleted")) {
           success = true;
         }
       });
@@ -87,17 +87,17 @@ export class OllamaAction {
       await new Promise<void>((resolve, reject) => {
         stream.on("end", () => {
           if (success) {
+            this.succeedSpinner(successMessage);
             resolve();
           } else {
+            this.failSpinner(`Failed to execute '${command}' on model "${modelName}".`);
             reject('internal error');
           }
         });
         stream.on("error", reject);
       });
-
-      console.log(successMessage);
-    }catch (error) {
-      console.error(`Error executing command "${command}" on model "${modelName}":`, error);
+    } catch (error) {
+      this.failSpinner(`Error executing command "${command}" on model "${modelName}"`, error);
     }
   }
 }

package/src/commands/validators/validators.ts

@@ -31,26 +31,25 @@ export class ValidatorsAction extends BaseAction {
   public async getValidator(options: ValidatorOptions): Promise<void> {
     try {
       if (options.address) {
-        console.log(`Fetching validator with address: ${options.address}`);
+        this.startSpinner(`Fetching validator with address: ${options.address}`);
 
         const result = await rpcClient.request({
           method: "sim_getValidator",
           params: [options.address],
         });
 
-        console.log("Validator Details:", result.result);
+        this.succeedSpinner(`Successfully fetched validator with address: ${options.address}`, result.result);
       } else {
-        console.log("Fetching all validators...");
+        this.startSpinner(`Fetching all validators...`);
 
         const result = await rpcClient.request({
           method: "sim_getAllValidators",
           params: [],
         });
-
-        console.log("All Validators:", result.result);
+        this.succeedSpinner('Successfully fetched all validators.', result.result)
       }
     } catch (error) {
-      console.error("Error fetching validators:", error);
+      this.failSpinner("Error fetching validators", error);
     }
   }
 
@@ -58,65 +57,60 @@ export class ValidatorsAction extends BaseAction {
     try {
       if (options.address) {
         await this.confirmPrompt(`This command will delete the validator with the address: ${options.address}. Do you want to continue?`);
-        console.log(`Deleting validator with address: ${options.address}`);
+        this.startSpinner(`Deleting validator with address: ${options.address}`);
 
         const result = await rpcClient.request({
           method: "sim_deleteValidator",
           params: [options.address],
         });
 
-        console.log("Deleted Address:", result.result);
+        this.succeedSpinner(`Deleted Address: ${result.result}`);
       } else {
         await this.confirmPrompt(`This command will delete all validators. Do you want to continue?`);
-        console.log("Deleting all validators...");
+        this.startSpinner("Deleting all validators...");
 
         await rpcClient.request({
           method: "sim_deleteAllValidators",
           params: [],
         });
 
-        console.log("Successfully deleted all validators");
+        this.succeedSpinner("Successfully deleted all validators");
       }
     } catch (error) {
-      console.error("Error deleting validators:", error);
+      this.failSpinner("Error deleting validators", error);
     }
   }
 
   public async countValidators(): Promise<void> {
     try {
-      console.log("Counting all validators...");
+      this.startSpinner("Counting all validators...");
 
       const result = await rpcClient.request({
         method: "sim_countValidators",
         params: [],
       });
-
-      console.log("Total Validators:", result.result);
+      this.succeedSpinner(`Total Validators: ${result.result}`);
     } catch (error) {
-      console.error("Error counting validators:", error);
+      this.failSpinner("Error counting validators", error);
     }
   }
 
   public async updateValidator(options: UpdateValidatorOptions): Promise<void> {
     try {
-      console.log(`Fetching validator with address: ${options.address}...`);
+      this.startSpinner(`Fetching validator with address: ${options.address}...`);
       const currentValidator = await rpcClient.request({
         method: "sim_getValidator",
         params: [options.address],
       });
 
-      if (!currentValidator.result) {
-        throw new Error(`Validator with address ${options.address} not found.`);
-      }
-
-      console.log("Current Validator Details:", currentValidator.result);
+      this.log("Current Validator Details:", currentValidator.result);
 
       const parsedStake = options.stake
         ? parseInt(options.stake, 10)
         : currentValidator.result.stake;
 
       if (isNaN(parsedStake) || parsedStake < 0) {
-        return console.error("Invalid stake value. Stake must be a positive integer.");
+        return this.failSpinner("Invalid stake value. Stake must be a positive integer.");
       }
 
       const updatedValidator = {
@@ -127,7 +121,9 @@ export class ValidatorsAction extends BaseAction {
         config: options.config ? JSON.parse(options.config) : currentValidator.result.config,
       };
 
-      console.log("Updated Validator Details:", updatedValidator);
+      this.log("Updated Validator Details:", updatedValidator);
+
+      this.setSpinnerText('Updating Validator...');
 
       const result = await rpcClient.request({
         method: "sim_updateValidator",
@@ -140,9 +136,9 @@ export class ValidatorsAction extends BaseAction {
         ],
       });
 
-      console.log("Validator successfully updated:", result.result);
+      this.succeedSpinner("Validator successfully updated", result.result);
     } catch (error) {
-      console.error("Error updating validator:", error);
+      this.failSpinner("Error updating validator", error);
     }
   }
 
@@ -150,21 +146,21 @@ export class ValidatorsAction extends BaseAction {
     try {
       const count = parseInt(options.count, 10);
       if (isNaN(count) || count < 1) {
-        return console.error("Invalid count. Please provide a positive integer.");
+        return this.logError("Invalid count. Please provide a positive integer.");
       }
 
-      console.log(`Creating ${count} random validator(s)...`);
-      console.log(`Providers: ${options.providers.length > 0 ? options.providers.join(", ") : "None"}`);
-      console.log(`Models: ${options.models.length > 0 ? options.models.join(", ") : "None"}`);
+      this.startSpinner(`Creating ${count} random validator(s)...`);
+      this.log(`Providers: ${options.providers.length > 0 ? options.providers.join(", ") : "All"}`);
+      this.log(`Models: ${options.models.length > 0 ? options.models.join(", ") : "All"}`);
 
       const result = await rpcClient.request({
         method: "sim_createRandomValidators",
         params: [count, 1, 10, options.providers, options.models],
       });
 
-      console.log("Random validators successfully created:", result.result);
+      this.succeedSpinner("Random validators successfully created", result.result);
     } catch (error) {
-      console.error("Error creating random validators:", error);
+      this.failSpinner("Error creating random validators", error);
     }
   }
 
@@ -172,22 +168,23 @@ export class ValidatorsAction extends BaseAction {
     try {
       const stake = parseInt(options.stake, 10);
       if (isNaN(stake) || stake < 1) {
-        return console.error("Invalid stake. Please provide a positive integer.");
+        return this.logError("Invalid stake. Please provide a positive integer.");
       }
 
       if (options.model && !options.provider) {
-        return console.error("You must specify a provider if using a model.");
+        return this.logError("You must specify a provider if using a model.");
       }
 
-      console.log("Fetching available providers and models...");
+      this.startSpinner("Fetching available providers and models...");
 
       const providersAndModels = await rpcClient.request({
         method: "sim_getProvidersAndModels",
         params: [],
       });
+      this.stopSpinner();
 
       if (!providersAndModels.result || providersAndModels.result.length === 0) {
-        return console.error("No providers or models available.");
+        return this.logError("No providers or models available.");
       }
 
       const availableProviders = [
@@ -218,7 +215,7 @@ export class ValidatorsAction extends BaseAction {
       );
 
       if (availableModels.length === 0) {
-        return console.error("No models available for the selected provider.");
+        return this.logError("No models available for the selected provider.");
       }
 
       let model = options.model;
@@ -241,34 +238,30 @@ export class ValidatorsAction extends BaseAction {
       );
 
       if (!modelDetails) {
-        return console.error("Selected model details not found.");
+        return this.logError("Selected model details not found.");
       }
 
       const config = options.config ? JSON.parse(options.config) : modelDetails.config;
-
-      console.log("Creating validator with the following details:");
-      console.log(`Stake: ${stake}`);
-      console.log(`Provider: ${modelDetails.provider}`);
-      console.log(`Model: ${modelDetails.model}`);
-      console.log(`Config:`, config);
-      console.log(`Plugin:`, modelDetails.plugin);
-      console.log(`Plugin Config:`, modelDetails.plugin_config);
+      const params = [
+        stake,
+        modelDetails.provider,
+        modelDetails.model,
+        config,
+        modelDetails.plugin,
+        modelDetails.plugin_config,
+      ]
+
+      this.log("Validator details:", params);
+      this.startSpinner('Creating validator...');
 
       const result = await rpcClient.request({
         method: "sim_createValidator",
-        params: [
-          stake,
-          modelDetails.provider,
-          modelDetails.model,
-          config,
-          modelDetails.plugin,
-          modelDetails.plugin_config,
-        ],
+        params,
       });
 
-      console.log("Validator successfully created:", result.result);
+      this.succeedSpinner("Validator successfully created:", result.result);
     } catch (error) {
-      console.error("Error creating validator:", error);
+      this.failSpinner("Error creating validator", error);
     }
   }
 }

package/src/lib/actions/BaseAction.ts

@@ -1,19 +1,90 @@
+import { ConfigFileManager } from "../../lib/config/ConfigFileManager";
+import ora, { Ora } from "ora";
+import chalk from "chalk";
 import inquirer from "inquirer";
 
-export class BaseAction {
+
+export class BaseAction extends ConfigFileManager {
+  private spinner: Ora;
+
+  constructor() {
+    super()
+    this.spinner = ora({ text: "", spinner: "dots" });
+  }
+
   protected async confirmPrompt(message: string): Promise<void> {
     const answer = await inquirer.prompt([
       {
         type: "confirm",
         name: "confirmAction",
-        message: message,
+        message: chalk.yellow(message),
         default: true,
       },
     ]);
 
     if (!answer.confirmAction) {
-      console.log("Operation aborted!");
+      this.logError("Operation aborted!");
       process.exit(0);
     }
   }
-}
+
+  private formatOutput(data: any): string {
+    if (data instanceof Error) {
+      const errorDetails = {
+        name: data.name,
+        message: data.message,
+        ...(Object.keys(data).length ? data : {}),
+      };
+      return JSON.stringify(errorDetails, null, 2);
+    }
+    return typeof data === "object" ? JSON.stringify(data, null, 2) : String(data);
+  }
+
+  protected log(message: string, data?: any): void {
+    console.log(chalk.white(`\n${message}`));
+    if (data) console.log(this.formatOutput(data));
+  }
+
+  protected logSuccess(message: string, data?: any): void {
+    console.log(chalk.green(`\n✔ ${message}`));
+    if (data) console.log(chalk.green(this.formatOutput(data)));
+  }
+
+  protected logInfo(message: string, data?: any): void {
+    console.log(chalk.blue(`\nℹ ${message}`));
+    if (data) console.log(chalk.blue(this.formatOutput(data)));
+  }
+
+  protected logWarning(message: string, data?: any): void {
+    console.log(chalk.yellow(`\n⚠ ${message}`));
+    if (data) console.log(chalk.yellow(this.formatOutput(data)));
+  }
+
+  protected logError(message: string, error?: any): void {
+    console.error(chalk.red(`\n✖ ${message}`));
+    if (error) console.error(chalk.red(this.formatOutput(error)));
+  }
+
+  protected startSpinner(message: string) {
+    this.spinner.text = chalk.blue(`${message}`);
+    this.spinner.start();
+  }
+
+  protected succeedSpinner(message: string, data?: any): void {
+    if (data) this.log('Result:', data);
+    this.spinner.succeed(chalk.green(message));
+  }
+
+  protected failSpinner(message: string, error?:any): void {
+    if (error) this.log('Error:', error);
+    this.spinner.fail(chalk.red(message));
+  }
+
+  protected stopSpinner(): void {
+    this.spinner.stop();
+  }
+
+  protected setSpinnerText(message: string): void {
+    this.spinner.text = chalk.blue(message);
+  }
+}

package/src/lib/config/simulator.ts

@@ -32,7 +32,7 @@ export type AiProvidersConfigType = {
 export const AI_PROVIDERS_CONFIG: AiProvidersConfigType = {
   ollama: {
     name: "Ollama",
-    hint: "(This will download and run a local instance of Llama 3)",
+    hint: "(By default, this will download and run a local instance of Llama 3)",
     cliOptionValue: "ollama",
   },
   openai: {

package/src/lib/services/simulator.ts

@@ -4,6 +4,7 @@ import * as dotenv from "dotenv";
 import * as path from "path";
 import * as semver from "semver";
 import updateCheck from "update-check";
+import { fileURLToPath } from "url";
 import pkg from '../../../package.json'
 
 import {rpcClient} from "../clients/jsonRpcClient";
@@ -43,7 +44,8 @@ export class SimulatorService implements ISimulatorService {
   public location: string;
 
   constructor() {
-    this.location = path.resolve(__dirname, '..');
+    const __filename = fileURLToPath(import.meta.url);
+    this.location = path.resolve(path.dirname(__filename), '..');
     this.composeOptions = "";
     this.docker = new Docker();
   }
@@ -184,7 +186,6 @@ export class SimulatorService implements ISimulatorService {
   public async waitForSimulatorToBeReady(
     retries: number = STARTING_TIMEOUT_ATTEMPTS,
   ): Promise<WaitForSimulatorToBeReadyResultType> {
-    console.log("Waiting for the simulator to start up...");
     try {
       const response = await rpcClient.request({method: "ping", params: []});
 

package/tests/actions/create.test.ts

@@ -13,13 +13,6 @@ vi.mock("ethers", () => ({
   },
 }));
 
-vi.mock("../../src/lib/config/ConfigFileManager", () => ({
-  ConfigFileManager: vi.fn().mockImplementation(() => ({
-    getFilePath: vi.fn((fileName) => `/mocked/path/${fileName}`),
-    writeConfig: vi.fn(),
-  })),
-}));
-
 describe("KeypairCreator", () => {
   let keypairCreator: KeypairCreator;
 
@@ -31,6 +24,11 @@ describe("KeypairCreator", () => {
 
   beforeEach(() => {
     vi.clearAllMocks();
+    vi.spyOn(keypairCreator as any, "startSpinner").mockImplementation(() => {});
+    vi.spyOn(keypairCreator as any, "succeedSpinner").mockImplementation(() => {});
+    vi.spyOn(keypairCreator as any, "failSpinner").mockImplementation(() => {});
+    vi.spyOn(keypairCreator as any, "writeConfig").mockImplementation(() => {});
+    vi.spyOn(keypairCreator as any, "getFilePath").mockImplementation((fileName) => `/mocked/path/${fileName}`);
     vi.mocked(ethers.Wallet.createRandom).mockReturnValue(mockWallet);
   });
 
@@ -39,15 +37,15 @@ describe("KeypairCreator", () => {
   });
 
   test("successfully creates and saves a keypair", () => {
-    const consoleLogSpy = vi.spyOn(console, "log");
     vi.mocked(existsSync).mockReturnValue(false);
     const options = { output: "keypair.json", overwrite: false };
 
     keypairCreator.createKeypairAction(options);
 
+    expect(keypairCreator["startSpinner"]).toHaveBeenCalledWith("Creating keypair...");
     expect(ethers.Wallet.createRandom).toHaveBeenCalledTimes(1);
+    expect(keypairCreator["getFilePath"]).toHaveBeenCalledWith("keypair.json");
 
-    expect(keypairCreator["filePathManager"].getFilePath).toHaveBeenCalledWith("keypair.json");
 
     expect(writeFileSync).toHaveBeenCalledWith(
       "/mocked/path/keypair.json",
@@ -61,20 +59,17 @@ describe("KeypairCreator", () => {
       )
     );
 
-    expect(keypairCreator["filePathManager"].writeConfig).toHaveBeenCalledWith(
+    expect(keypairCreator["writeConfig"]).toHaveBeenCalledWith(
       "keyPairPath",
       "/mocked/path/keypair.json"
     );
 
-    expect(consoleLogSpy).toHaveBeenCalledWith(
+    expect(keypairCreator["succeedSpinner"]).toHaveBeenCalledWith(
       "Keypair successfully created and saved to: /mocked/path/keypair.json"
     );
   });
 
   test("skips creation if file exists and overwrite is false", () => {
-
-
-    const consoleWarnSpy = vi.spyOn(console, "warn");
     vi.mocked(existsSync).mockReturnValue(true);
     const options = { output: "keypair.json", overwrite: false };
 
@@ -82,21 +77,20 @@ describe("KeypairCreator", () => {
 
     expect(ethers.Wallet.createRandom).not.toHaveBeenCalled();
     expect(writeFileSync).not.toHaveBeenCalled();
-    expect(consoleWarnSpy).toHaveBeenCalledWith(
+    expect(keypairCreator["failSpinner"]).toHaveBeenCalledWith(
       "The file at /mocked/path/keypair.json already exists. Use the '--overwrite' option to replace it."
     );
   });
 
   test("overwrites the file if overwrite is true", () => {
-    const consoleLogSpy = vi.spyOn(console, "log");
     vi.mocked(existsSync).mockReturnValue(true);
     const options = { output: "keypair.json", overwrite: true };
 
     keypairCreator.createKeypairAction(options);
 
+    expect(keypairCreator["startSpinner"]).toHaveBeenCalledWith("Creating keypair...");
     expect(ethers.Wallet.createRandom).toHaveBeenCalledTimes(1);
-
-    expect(keypairCreator["filePathManager"].getFilePath).toHaveBeenCalledWith("keypair.json");
+    expect(keypairCreator["getFilePath"]).toHaveBeenCalledWith("keypair.json");
 
     expect(writeFileSync).toHaveBeenCalledWith(
       "/mocked/path/keypair.json",
@@ -110,31 +104,25 @@ describe("KeypairCreator", () => {
       )
     );
 
-    expect(keypairCreator["filePathManager"].writeConfig).toHaveBeenCalledWith(
+    expect(keypairCreator["writeConfig"]).toHaveBeenCalledWith(
       "keyPairPath",
       "/mocked/path/keypair.json"
     );
 
-    expect(consoleLogSpy).toHaveBeenCalledWith(
+    expect(keypairCreator["succeedSpinner"]).toHaveBeenCalledWith(
       "Keypair successfully created and saved to: /mocked/path/keypair.json"
     );
   });
 
   test("handles errors during keypair creation", () => {
-    const consoleErrorSpy = vi.spyOn(console, "error");
-    const processExitSpy = vi.spyOn(process, "exit").mockImplementation(() => {
-      throw new Error("process.exit");
-    });
+    const mockError = new Error("Mocked write error");
 
     vi.mocked(writeFileSync).mockImplementation(() => {
-      throw new Error("Mocked write error");
+      throw mockError;
     });
 
-    expect(() => {
-      keypairCreator.createKeypairAction({ output: "keypair.json", overwrite: true });
-    }).toThrowError("process.exit");
+    keypairCreator.createKeypairAction({ output: "keypair.json", overwrite: true });
 
-    expect(consoleErrorSpy).toHaveBeenCalledWith("Failed to generate keypair:", expect.any(Error));
-    expect(processExitSpy).toHaveBeenCalledWith(1);
+    expect(keypairCreator["failSpinner"]).toHaveBeenCalledWith("Failed to generate keypair:", mockError);
   });
 });