genlayer 0.10.1 → 0.11.0

package/CHANGELOG.md

@@ -1,5 +1,19 @@
 
 
+## 0.11.0 (2025-01-31)
+
+
+### Features
+
+* Enhance Ollama Command Workflow and Default Model Handling ([#171](https://github.com/yeagerai/genlayer-cli/issues/171)) ([3dc7a96](https://github.com/yeagerai/genlayer-cli/commit/3dc7a9673ada8116b1fb99e089439a75e06237ec))
+
+## 0.10.2 (2025-01-30)
+
+
+### Bug Fixes
+
+* updated studio version ([#174](https://github.com/yeagerai/genlayer-cli/issues/174)) ([e70e7f2](https://github.com/yeagerai/genlayer-cli/commit/e70e7f2e549abc9c9633ae066820fb272c9334ee))
+
 ## 0.10.1 (2025-01-29)
 
 

package/dist/index.js

@@ -54537,7 +54537,7 @@ var {
 } = import_index.default;
 
 // package.json
-var version = "0.10.1";
+var version = "0.11.0";
 var package_default = {
   name: "genlayer",
   version,
@@ -54678,7 +54678,7 @@ function v4(options, buf, offset) {
 var v4_default = v4;
 
 // src/lib/config/simulator.ts
-var localnetCompatibleVersion = "v0.34.3";
+var localnetCompatibleVersion = "v0.35.2";
 var DEFAULT_JSON_RPC_URL = "http://localhost:4000/api";
 var CONTAINERS_NAME_PREFIX = "/genlayer-";
 var IMAGES_NAME_PREFIX = "yeagerai";
@@ -54726,26 +54726,23 @@ var JsonRpcClient = class {
     this.serverUrl = serverUrl;
   }
   async request({ method, params }) {
-    try {
-      const response = await (0, import_node_fetch.default)(this.serverUrl, {
-        method: "POST",
-        headers: {
-          "Content-Type": "application/json"
-        },
-        body: JSON.stringify({
-          jsonrpc: "2.0",
-          id: v4_default(),
-          method,
-          params
-        })
-      });
-      if (response.ok) {
-        return response.json();
-      }
-    } catch (error) {
-      throw new Error(`Fetch Error: ${error.message}`);
+    const response = await (0, import_node_fetch.default)(this.serverUrl, {
+      method: "POST",
+      headers: {
+        "Content-Type": "application/json"
+      },
+      body: JSON.stringify({
+        jsonrpc: "2.0",
+        id: v4_default(),
+        method,
+        params
+      })
+    });
+    if (response.ok) {
+      return response.json();
     }
-    return null;
+    const result = await response.json();
+    throw new Error(result?.error?.message || response.statusText);
   }
 };
 var rpcClient = new JsonRpcClient(DEFAULT_JSON_RPC_URL);
@@ -55382,12 +55379,12 @@ Run npm install -g genlayer to update
   }
   createRandomValidators(numValidators, llmProviders) {
     return rpcClient.request({
-      method: "create_random_validators",
+      method: "sim_createRandomValidators",
       params: [numValidators, 1, 10, llmProviders]
     });
   }
   deleteAllValidators() {
-    return rpcClient.request({ method: "delete_all_validators", params: [] });
+    return rpcClient.request({ method: "sim_deleteAllValidators", params: [] });
   }
   getAiProvidersOptions(withHint = true) {
     return Object.values(AI_PROVIDERS_CONFIG).map((providerConfig) => {
@@ -57584,13 +57581,50 @@ var OllamaAction = class {
     this.docker = new import_dockerode2.default();
   }
   async updateModel(modelName) {
-    await this.executeModelCommand("pull", modelName, `Model "${modelName}" updated successfully`);
+    const providersAndModels = await rpcClient.request({
+      method: "sim_getProvidersAndModels",
+      params: []
+    });
+    const existingOllamaProvider = providersAndModels.result.find(
+      (entry) => entry.plugin === "ollama"
+    );
+    if (!existingOllamaProvider) {
+      throw new Error("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) => 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]
+      });
+      console.log(`Model "${modelName}" added successfully.`);
+    }
   }
   async removeModel(modelName) {
-    await this.executeModelCommand("rm", modelName, `Model "${modelName}" removed successfully`);
+    await this.executeModelCommand(
+      "rm",
+      modelName,
+      `Model "${modelName}" removed successfully`
+    );
   }
   async executeModelCommand(command, modelName, successMessage) {
     try {
+      let success = false;
       const ollamaContainer = this.docker.getContainer("ollama");
       const exec2 = await ollamaContainer.exec({
         Cmd: ["ollama", command, modelName],
@@ -57599,10 +57633,20 @@ var OllamaAction = class {
       });
       const stream = await exec2.start({ Detach: false, Tty: false });
       stream.on("data", (chunk) => {
-        console.log(chunk.toString());
+        const chunkStr = chunk.toString();
+        console.log(chunkStr);
+        if (chunkStr.includes("success") || chunkStr.includes("deleted")) {
+          success = true;
+        }
       });
       await new Promise((resolve2, reject) => {
-        stream.on("end", resolve2);
+        stream.on("end", () => {
+          if (success) {
+            resolve2();
+          } else {
+            reject("internal error");
+          }
+        });
         stream.on("error", reject);
       });
       console.log(successMessage);
@@ -57796,7 +57840,11 @@ async function initAction(options, simulatorService) {
     const ollamaAction = new OllamaAction();
     const configManager = new ConfigFileManager();
     const config = configManager.getConfig();
-    let ollamaModel = config.defaultOllamaModel || "llama3";
+    let ollamaModel = config.defaultOllamaModel;
+    if (!config.defaultOllamaModel) {
+      configManager.writeConfig("defaultOllamaModel", "llama3");
+      ollamaModel = "llama3";
+    }
     console.log(`Pulling ${ollamaModel} from Ollama...`);
     await ollamaAction.updateModel(ollamaModel);
   }
@@ -86776,11 +86824,280 @@ function initializeConfigCommands(program2) {
   return program2;
 }
 
+// src/lib/actions/BaseAction.ts
+var BaseAction = class {
+  async confirmPrompt(message) {
+    const answer = await lib_default.prompt([
+      {
+        type: "confirm",
+        name: "confirmAction",
+        message,
+        default: true
+      }
+    ]);
+    if (!answer.confirmAction) {
+      console.log("Operation aborted!");
+      process.exit(0);
+    }
+  }
+};
+
+// src/commands/validators/validators.ts
+var ValidatorsAction = class extends BaseAction {
+  async getValidator(options) {
+    try {
+      if (options.address) {
+        console.log(`Fetching validator with address: ${options.address}`);
+        const result = await rpcClient.request({
+          method: "sim_getValidator",
+          params: [options.address]
+        });
+        console.log("Validator Details:", result.result);
+      } else {
+        console.log("Fetching all validators...");
+        const result = await rpcClient.request({
+          method: "sim_getAllValidators",
+          params: []
+        });
+        console.log("All Validators:", result.result);
+      }
+    } catch (error) {
+      console.error("Error fetching validators:", error);
+    }
+  }
+  async deleteValidator(options) {
+    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}`);
+        const result = await rpcClient.request({
+          method: "sim_deleteValidator",
+          params: [options.address]
+        });
+        console.log("Deleted Address:", result.result);
+      } else {
+        await this.confirmPrompt(`This command will delete all validators. Do you want to continue?`);
+        console.log("Deleting all validators...");
+        await rpcClient.request({
+          method: "sim_deleteAllValidators",
+          params: []
+        });
+        console.log("Successfully deleted all validators");
+      }
+    } catch (error) {
+      console.error("Error deleting validators:", error);
+    }
+  }
+  async countValidators() {
+    try {
+      console.log("Counting all validators...");
+      const result = await rpcClient.request({
+        method: "sim_countValidators",
+        params: []
+      });
+      console.log("Total Validators:", result.result);
+    } catch (error) {
+      console.error("Error counting validators:", error);
+    }
+  }
+  async updateValidator(options) {
+    try {
+      console.log(`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);
+      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.");
+      }
+      const updatedValidator = {
+        address: options.address,
+        stake: options.stake || currentValidator.result.stake,
+        provider: options.provider || currentValidator.result.provider,
+        model: options.model || currentValidator.result.model,
+        config: options.config ? JSON.parse(options.config) : currentValidator.result.config
+      };
+      console.log("Updated Validator Details:", updatedValidator);
+      const result = await rpcClient.request({
+        method: "sim_updateValidator",
+        params: [
+          updatedValidator.address,
+          updatedValidator.stake,
+          updatedValidator.provider,
+          updatedValidator.model,
+          updatedValidator.config
+        ]
+      });
+      console.log("Validator successfully updated:", result.result);
+    } catch (error) {
+      console.error("Error updating validator:", error);
+    }
+  }
+  async createRandomValidators(options) {
+    try {
+      const count = parseInt(options.count, 10);
+      if (isNaN(count) || count < 1) {
+        return console.error("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"}`);
+      const result = await rpcClient.request({
+        method: "sim_createRandomValidators",
+        params: [count, 1, 10, options.providers, options.models]
+      });
+      console.log("Random validators successfully created:", result.result);
+    } catch (error) {
+      console.error("Error creating random validators:", error);
+    }
+  }
+  async createValidator(options) {
+    try {
+      const stake = parseInt(options.stake, 10);
+      if (isNaN(stake) || stake < 1) {
+        return console.error("Invalid stake. Please provide a positive integer.");
+      }
+      if (options.model && !options.provider) {
+        return console.error("You must specify a provider if using a model.");
+      }
+      console.log("Fetching available providers and models...");
+      const providersAndModels = await rpcClient.request({
+        method: "sim_getProvidersAndModels",
+        params: []
+      });
+      if (!providersAndModels.result || providersAndModels.result.length === 0) {
+        return console.error("No providers or models available.");
+      }
+      const availableProviders = [
+        ...new Map(
+          providersAndModels.result.filter((entry) => entry.is_available).map((entry) => [entry.provider, entry])
+        ).values()
+      ];
+      let provider = options.provider;
+      if (!provider) {
+        const { selectedProvider } = await lib_default.prompt([
+          {
+            type: "list",
+            name: "selectedProvider",
+            message: "Select a provider:",
+            choices: availableProviders.map((entry) => entry.provider)
+          }
+        ]);
+        provider = selectedProvider;
+      }
+      const availableModels = providersAndModels.result.filter(
+        (entry) => entry.provider === provider && entry.is_model_available
+      );
+      if (availableModels.length === 0) {
+        return console.error("No models available for the selected provider.");
+      }
+      let model = options.model;
+      if (!model) {
+        const { selectedModel } = await lib_default.prompt([
+          {
+            type: "list",
+            name: "selectedModel",
+            message: "Select a model:",
+            choices: availableModels.map((entry) => entry.model)
+          }
+        ]);
+        model = selectedModel;
+      }
+      const modelDetails = availableModels.find(
+        (entry) => entry.model === model
+      );
+      if (!modelDetails) {
+        return console.error("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 result = await rpcClient.request({
+        method: "sim_createValidator",
+        params: [
+          stake,
+          modelDetails.provider,
+          modelDetails.model,
+          config,
+          modelDetails.plugin,
+          modelDetails.plugin_config
+        ]
+      });
+      console.log("Validator successfully created:", result.result);
+    } catch (error) {
+      console.error("Error creating validator:", error);
+    }
+  }
+};
+
+// src/commands/validators/index.ts
+function initializeValidatorCommands(program2) {
+  const validatorsAction = new ValidatorsAction();
+  const validatorsCommand = program2.command("validators").description("Manage validator operations");
+  validatorsCommand.command("get").description("Retrieve details of a specific validator or all validators").option("--address <validatorAddress>", "The address of the validator to retrieve (omit to retrieve all validators)").action(async (options) => {
+    await validatorsAction.getValidator({ address: options.address });
+  });
+  validatorsCommand.command("delete").description("Delete a specific validator or all validators").option("--address <validatorAddress>", "The address of the validator to delete (omit to delete all validators)").action(async (options) => {
+    await validatorsAction.deleteValidator({ address: options.address });
+  });
+  validatorsCommand.command("count").description("Count all validators").action(async () => {
+    await validatorsAction.countValidators();
+  });
+  validatorsCommand.command("update <validatorAddress>").description("Update a validator's details").option("--stake <stake>", "New stake for the validator").option("--provider <provider>", "New provider for the validator").option("--model <model>", "New model for the validator").option("--config <config>", "New JSON config for the validator").action(async (validatorAddress, options) => {
+    await validatorsAction.updateValidator({
+      address: validatorAddress,
+      stake: options.stake,
+      provider: options.provider,
+      model: options.model,
+      config: options.config
+    });
+  });
+  validatorsCommand.command("create-random").description("Create random validators").option("--count <count>", "Number of validators to create", "1").option(
+    "--providers <providers...>",
+    "Space-separated list of provider names (e.g., openai ollama)",
+    []
+  ).option(
+    "--models <models...>",
+    "Space-separated list of model names (e.g., gpt-4 gpt-4o)",
+    []
+  ).action(async (options) => {
+    await validatorsAction.createRandomValidators({
+      count: options.count,
+      providers: options.providers,
+      models: options.models
+    });
+  });
+  validatorsCommand.command("create").description("Create a new validator").option("--stake <stake>", "Stake amount for the validator (default: 1)", "1").option(
+    "--config <config>",
+    `Optional JSON configuration for the validator (e.g., '{"max_tokens": 500, "temperature": 0.75}')`
+  ).option("--provider <provider>", "Specify the provider for the validator").option("--model <model>", "Specify the model for the validator").action(async (options) => {
+    await validatorsAction.createValidator({
+      stake: options.stake,
+      config: options.config,
+      provider: options.provider,
+      model: options.model
+    });
+  });
+  return program2;
+}
+
 // src/commands/update/index.ts
 function initializeUpdateCommands(program2) {
   const updateCommand = program2.command("update").description("Update resources like models or configurations");
   updateCommand.command("ollama").description("Manage Ollama models (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 modelName = options.model || "default-model";
+    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);
@@ -86799,6 +87116,7 @@ function initializeCLI() {
   initializeContractsCommands(program);
   initializeConfigCommands(program);
   initializeUpdateCommands(program);
+  initializeValidatorCommands(program);
   program.parse(process.argv);
 }
 initializeCLI();

package/docker-compose.yml

@@ -61,6 +61,9 @@ services:
         max-file: "3"
     deploy:
       replicas: ${JSONRPC_REPLICAS:-1}
+    volumes:
+      - hardhat_artifacts:/app/hardhat/artifacts
+      - hardhat_deployments:/app/hardhat/deployments
 
   webrequest:
     image: yeagerai/simulator-webrequest:${LOCALNETVERSION:-latest}
@@ -144,8 +147,15 @@ services:
         condition: service_healthy
 
   hardhat:
-    image: yeagerai/simulator-hardhat
+    image: yeagerai/simulator-hardhat:${LOCALNETVERSION:-latest}
     ports:
       - "${HARDHAT_PORT:-8545}:8545"
     environment:
-      - HARDHAT_NETWORK=hardhat
+      - HARDHAT_NETWORK=hardhat
+    volumes:
+      - hardhat_artifacts:/app/artifacts
+      - hardhat_deployments:/app/deployments
+
+volumes:
+  hardhat_artifacts:
+  hardhat_deployments:

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "genlayer",
-  "version": "0.10.1",
+  "version": "0.11.0",
   "description": "GenLayer Command Line Tool",
   "main": "src/index.ts",
   "bin": {

package/src/commands/general/init.ts

@@ -184,8 +184,12 @@ export async function initAction(options: InitActionOptions, simulatorService: I
     const ollamaAction = new OllamaAction();
     const configManager = new ConfigFileManager();
     const config = configManager.getConfig()
+    let ollamaModel = config.defaultOllamaModel;
 
-    let ollamaModel = config.defaultOllamaModel || 'llama3';
+    if(!config.defaultOllamaModel){
+      configManager.writeConfig('defaultOllamaModel', 'llama3');
+      ollamaModel = 'llama3'
+    }
 
     console.log(`Pulling ${ollamaModel} from Ollama...`);
 

package/src/commands/update/index.ts

@@ -1,5 +1,6 @@
 import { Command } from "commander";
 import { OllamaAction } from "./ollama";
+import { ConfigFileManager } from "../../lib/config/ConfigFileManager";
 
 export function initializeUpdateCommands(program: Command) {
   const updateCommand = program
@@ -12,7 +13,10 @@ export function initializeUpdateCommands(program: Command) {
     .option("--model [model-name]", "Specify the model to update or remove")
     .option("--remove", "Remove the specified model instead of updating")
     .action(async (options) => {
-      const modelName = options.model || "default-model";
+      const configManager = new ConfigFileManager();
+      const config = configManager.getConfig()
+
+      const modelName = options.model || config.defaultOllamaModel;
       const ollamaAction = new OllamaAction();
 
       if (options.remove) {

package/src/commands/update/ollama.ts

@@ -1,4 +1,5 @@
-import Docker from "dockerode"
+import Docker from "dockerode";
+import { rpcClient } from "../../lib/clients/jsonRpcClient";
 
 export class OllamaAction {
   private docker: Docker;
@@ -8,34 +9,94 @@ export class OllamaAction {
   }
 
   async updateModel(modelName: string) {
-    await this.executeModelCommand("pull", modelName, `Model "${modelName}" updated successfully`);
+    const providersAndModels = await rpcClient.request({
+      method: "sim_getProvidersAndModels",
+      params: [],
+    });
+
+    const existingOllamaProvider = providersAndModels.result.find(
+      (entry: any) => entry.plugin === "ollama"
+    );
+
+    if (!existingOllamaProvider) {
+      throw new Error("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) {
+      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],
+      });
+
+      console.log(`Model "${modelName}" added successfully.`);
+    }
   }
 
   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 {
+      let success = false;
       const ollamaContainer = this.docker.getContainer("ollama");
       const exec = await ollamaContainer.exec({
         Cmd: ["ollama", command, modelName],
         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) => {
-        console.log(chunk.toString());
+        const chunkStr = chunk.toString();
+        console.log(chunkStr);
+        if (chunkStr.includes("success") || chunkStr.includes("deleted")) {
+          success = true;
+        }
       });
 
       await new Promise<void>((resolve, reject) => {
-        stream.on("end", resolve);
+        stream.on("end", () => {
+          if (success) {
+            resolve();
+          } else {
+            reject('internal error');
+          }
+        });
         stream.on("error", reject);
       });
 
       console.log(successMessage);
-    } catch (error) {
+    }catch (error) {
       console.error(`Error executing command "${command}" on model "${modelName}":`, error);
     }
   }