genlayer 0.5.0 → 0.5.1-beta.0

package/docker-compose.yml

@@ -0,0 +1,144 @@
+version: "3.8"
+
+services:
+  frontend:
+    image: yeagerai/simulator-frontend:latest
+    ports:
+      - "${FRONTEND_PORT:-8080}:8080"
+    environment:
+      - VITE_*
+    volumes:
+      - ./.env:/app/.env
+    depends_on:
+      jsonrpc:
+        condition: service_healthy
+    expose:
+      - "${FRONTEND_PORT:-8080}"
+    restart: always
+    security_opt:
+      - "no-new-privileges=true"
+    logging:
+      driver: "json-file"
+      options:
+        max-size: "10m"
+        max-file: "3"
+
+
+  jsonrpc:
+    image: yeagerai/simulator-jsonrpc:latest
+    environment:
+      - FLASK_SERVER_PORT=${RPCPORT:-5000}
+      - PYTHONUNBUFFERED=1
+      - RPCDEBUGPORT=${RPCDEBUGPORT:-5001}
+      - WEBREQUESTPORT=${WEBREQUESTPORT:-5002}
+      - WEBREQUESTHOST=${WEBREQUESTHOST:-localhost}
+      - WEBREQUESTPROTOCOL=${WEBREQUESTPROTOCOL:-http}
+    ports:
+      - "${RPCPORT:-5000}:${RPCPORT:-5000}"
+      - "${RPCDEBUGPORT:-5001}:${RPCDEBUGPORT:-5001}"
+    volumes:
+      - ./.env:/app/.env
+    healthcheck:
+      test: [ "CMD", "python", "backend/healthcheck.py", "--port", "${RPCPORT}" ]
+      interval: 30s
+      timeout: 10s
+      retries: 3
+      start_period: 30s
+    depends_on:
+      database-migration:
+        condition: service_completed_successfully
+      webrequest:
+        condition: service_healthy
+    expose:
+      - "${RPCPORT:-5000}"
+    restart: always
+    security_opt:
+      - "no-new-privileges=true"
+    logging:
+      driver: "json-file"
+      options:
+        max-size: "10m"
+        max-file: "3"
+    deploy:
+      replicas: ${JSONRPC_REPLICAS:-1}
+
+  webrequest:
+    image: yeagerai/simulator-webrequest:latest
+    shm_size: 2gb
+    environment:
+      - FLASK_SERVER_PORT=${WEBREQUESTPORT:-5002}
+      - WEBREQUESTSELENIUMPORT=${WEBREQUESTSELENIUMPORT:-4444}
+      - PYTHONUNBUFFERED=1
+      - WEBREQUESTPORT=${WEBREQUESTPORT}
+      - WEBREQUESTHOST=${WEBREQUESTHOST}
+      - WEBREQUESTPROTOCOL=${WEBREQUESTPROTOCOL}
+    expose:
+      - "${WEBREQUESTPORT:-5002}:${WEBREQUESTPORT:-5002}"
+      - "${WEBREQUESTSELENIUMPORT:-4444}:${WEBREQUESTSELENIUMPORT:-4444}"
+    volumes:
+      - ./.env:/app/webrequest/.env
+    depends_on:
+      ollama:
+        condition: service_started
+    restart: always
+    security_opt:
+      - "no-new-privileges=true"
+    logging:
+      driver: "json-file"
+      options:
+        max-size: "10m"
+        max-file: "3"
+
+  ollama:
+    image: ollama/ollama:0.3.11
+    ports:
+      - 11434:11434
+    container_name: ollama
+    tty: true
+    restart: always
+    security_opt:
+      - "no-new-privileges=true"
+    logging:
+      driver: "json-file"
+      options:
+        max-size: "10m"
+        max-file: "3"
+
+  postgres:
+    image: postgres:16-alpine
+    ports:
+      - "${DBPORT:-5432}:5432"
+    environment:
+      - POSTGRES_USER=${DBUSER:-postgres}
+      - POSTGRES_PASSWORD=${DBPASSWORD:-postgres}
+      - POSTGRES_DB=${DBNAME:-simulator_db}
+    healthcheck:
+      test: pg_isready -U ${DBUSER:-postgres} -d ${DBNAME:-simulator_db}
+      interval: 10s
+      timeout: 3s
+      retries: 3
+    restart: always
+    security_opt:
+      - "no-new-privileges=true"
+    logging:
+      driver: "json-file"
+      options:
+        max-size: "10m"
+        max-file: "3"
+
+    # Uncomment the following lines if you want your DB to persist
+    # volumes:
+    #   - "./data/postgres:/var/lib/postgresql/data"
+
+  database-migration:
+    image: yeagerai/simulator-database-migration:latest
+    environment:
+      - DB_URL=postgresql://${DBUSER:-postgres}:${DBPASSWORD:-postgres}@postgres/${DBNAME:-simulator_db}
+      - WEBREQUESTPORT=${WEBREQUESTPORT:-5002}
+      - WEBREQUESTHOST=${WEBREQUESTHOST:-localhost}
+      - WEBREQUESTPROTOCOL=${WEBREQUESTPROTOCOL:-http}
+    depends_on:
+      postgres:
+        condition: service_healthy
+      webrequest:
+        condition: service_healthy

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "genlayer",
-  "version": "0.5.0",
+  "version": "0.5.1-beta.0",
   "description": "GenLayer Command Line Tool",
   "main": "src/index.ts",
   "bin": {
@@ -13,7 +13,8 @@
     "dev": "cross-env NODE_ENV=development node esbuild.config.js",
     "build": "cross-env NODE_ENV=production node esbuild.config.js",
     "release": "release-it --ci",
-    "release-beta": "release-it --ci --preRelease=beta"
+    "release-beta": "release-it --ci --preRelease=beta",
+    "postinstall": "node ./scripts/postinstall.js"
   },
   "repository": {
     "type": "git",

package/scripts/postinstall.js

@@ -0,0 +1,18 @@
+#!/usr/bin/env node
+
+const fs = require('fs');
+const path = require('path');
+
+const envExamplePath = path.resolve(__dirname, '../.env.example');
+const envPath = path.resolve(__dirname, '../.env');
+
+try {
+  if (fs.existsSync(envPath)) {
+    console.log(`⚠️  .env file already exists. Skipping creation.`);
+  } else {
+    fs.copyFileSync(envExamplePath, envPath);
+    console.log(`✅  .env file created successfully from .env.example.`);
+  }
+} catch (error) {
+  console.error(`❌  Error during post-install script: ${error.message}`);
+}

package/src/commands/general/index.ts

@@ -10,8 +10,6 @@ export function initializeGeneralCommands(program: Command) {
     .command("init")
     .description("Initialize the GenLayer Environment")
     .option("--numValidators <numValidators>", "Number of validators", "5")
-    .option("--branch <branch>", "Branch", "main")
-    .option("--location <folder>", "Location where it will be installed", process.cwd())
     .option("--headless", "Headless mode", false)
     .option("--reset-db", "Reset Database", false)
     .action((options: InitActionOptions) => initAction(options, simulatorService));
@@ -21,8 +19,6 @@ export function initializeGeneralCommands(program: Command) {
     .description("Starts GenLayer's simulator")
     .option("--reset-validators", "Remove all current validators and create new random ones", false)
     .option("--numValidators <numValidators>", "Number of validators", "5")
-    .option("--branch <branch>", "Branch", "main")
-    .option("--location <folder>", "Location where it will be installed", process.cwd())
     .option("--headless", "Headless mode", false)
     .option("--reset-db", "Reset Database", false)
     .action((options: StartActionOptions) => startAction(options, simulatorService));

package/src/commands/general/init.ts

@@ -4,19 +4,12 @@ import {ISimulatorService} from "../../lib/interfaces/ISimulatorService";
 import {AI_PROVIDERS_CONFIG, AiProviders} from "../../lib/config/simulator";
 export interface InitActionOptions {
   numValidators: number;
-  branch: string;
-  location: string;
   headless: boolean;
   resetDb: boolean;
 }
 
-function getRequirementsErrorMessage({git, docker}: Record<string, boolean>): string {
-  if (!git && !docker) {
-    return "Git and Docker are not installed. Please install them and try again.\n";
-  }
-  if (!git) {
-    return "Git is not installed. Please install Git and try again.\n";
-  }
+function getRequirementsErrorMessage({docker}: Record<string, boolean>): string {
+
   if (!docker) {
     return "Docker is not installed. Please install Docker and try again.\n";
   }
@@ -39,7 +32,6 @@ function getVersionErrorMessage({docker, node}: Record<string, string>): string
 }
 
 export async function initAction(options: InitActionOptions, simulatorService: ISimulatorService) {
-  simulatorService.setSimulatorLocation(options.location);
   simulatorService.setComposeOptions(options.headless);
 
   await simulatorService.checkCliVersion();
@@ -99,33 +91,6 @@ export async function initAction(options: InitActionOptions, simulatorService: I
     return;
   }
 
-  // Ask for confirmation on downloading the GenLayer Simulator from GitHub
-  const answers = await inquirer.prompt([
-    {
-      type: "confirm",
-      name: "confirmDownload",
-      message: `This action is going to download the GenLayer Simulator from GitHub (branch ${options.branch}) into "${simulatorService.getSimulatorLocation()}". Do you want to continue?`,
-      default: true,
-    },
-  ]);
-
-  if (!answers.confirmDownload) {
-    console.log("Aborted!");
-    return;
-  }
-
-  // Download the GenLayer Simulator from GitHub
-  console.log(`Downloading GenLayer Simulator from GitHub...`);
-  try {
-    const {wasInstalled} = await simulatorService.downloadSimulator(options.branch);
-    if (wasInstalled) {
-      await simulatorService.updateSimulator(options.branch);
-    }
-  } catch (error) {
-    console.error(error);
-    return;
-  }
-
   // Check LLM configuration
   const questions = [
     {
@@ -173,12 +138,8 @@ export async function initAction(options: InitActionOptions, simulatorService: I
   }
 
   console.log("Configuring GenLayer Simulator environment...");
-  try {
-    await simulatorService.configSimulator(aiProvidersEnvVars);
-  } catch (error) {
-    console.error(error);
-    return;
-  }
+  simulatorService.addConfigToEnvFile(aiProvidersEnvVars);
+
 
   // Run the GenLayer Simulator
   console.log("Running the GenLayer Simulator...");

package/src/commands/general/start.ts

@@ -5,17 +5,14 @@ import {ISimulatorService} from "../../lib/interfaces/ISimulatorService";
 export interface StartActionOptions {
   resetValidators: boolean;
   numValidators: number;
-  branch: string;
-  location: string;
   headless: boolean;
   resetDb: boolean
 }
 
 export async function startAction(options: StartActionOptions, simulatorService: ISimulatorService) {
-  const {resetValidators, numValidators, branch, location, headless, resetDb} = options;
-  // Update simulator location with user input
+  const {resetValidators, numValidators, headless, resetDb} = options;
+
   simulatorService.setComposeOptions(headless);
-  simulatorService.setSimulatorLocation(location);
 
   await simulatorService.checkCliVersion();
 
@@ -25,17 +22,6 @@ export async function startAction(options: StartActionOptions, simulatorService:
 
   console.log(`Starting GenLayer simulator ${restartValidatorsHintText}`);
 
-  // Update the simulator to the latest version
-  console.log(`Updating GenLayer Simulator...`);
-  try {
-    await simulatorService.updateSimulator(branch);
-  } catch (error) {
-    console.error(error);
-    return;
-  }
-
-  // Run the GenLayer Simulator
-  console.log("Running the GenLayer Simulator...");
   try {
     await simulatorService.runSimulator();
   } catch (error) {

package/src/lib/config/simulator.ts

@@ -1,10 +1,9 @@
 export const DEFAULT_JSON_RPC_URL = "http://localhost:4000/api";
-export const DEFAULT_REPO_GH_URL = "https://github.com/yeagerai/genlayer-simulator.git";
-export const DOCKER_IMAGES_AND_CONTAINERS_NAME_PREFIX = "/genlayer-simulator-";
-export const DEFAULT_RUN_SIMULATOR_COMMAND = (simulatorLocation: string, options: string) => ({
-  darwin: `osascript -e 'tell application "Terminal" to do script "cd ${simulatorLocation} && docker compose build && docker compose up ${options}"'`,
-  win32: `start cmd.exe /c "cd /d ${simulatorLocation} && docker compose build && docker compose up && pause ${options}"`,
-  linux: `nohup bash -c 'cd ${simulatorLocation} && docker compose build && docker compose up -d ${options}'`,
+export const DOCKER_IMAGES_AND_CONTAINERS_NAME_PREFIX = "/genlayer-cli-";
+export const DEFAULT_RUN_SIMULATOR_COMMAND = (location: string, options: string) => ({
+  darwin: `osascript -e 'tell application "Terminal" to do script "cd ${location} && docker compose build && docker compose up ${options}"'`,
+  win32: `start cmd.exe /c "cd /d ${location} && docker compose build && docker compose up && pause ${options}"`,
+  linux: `nohup bash -c 'cd ${location} && docker compose build && docker compose up -d ${options}'`,
 });
 export const DEFAULT_RUN_DOCKER_COMMAND = {
   darwin: "open -a Docker",

package/src/lib/interfaces/ISimulatorService.ts

@@ -1,16 +1,11 @@
 import {AiProviders} from "../config/simulator";
 
 export interface ISimulatorService {
-  setSimulatorLocation(location: string): void;
-  getSimulatorLocation(): string;
   setComposeOptions(headless: boolean): void;
   getComposeOptions(): string;
   checkInstallRequirements(): Promise<Record<string, boolean>>;
   checkVersionRequirements(): Promise<Record<string, string>>;
-  downloadSimulator(branch?: string): Promise<DownloadSimulatorResultType>;
-  updateSimulator(branch?: string): Promise<boolean>;
   pullOllamaModel(): Promise<boolean>;
-  configSimulator(newConfig: Record<string, string>): Promise<boolean>;
   runSimulator(): Promise<{stdout: string; stderr: string}>;
   waitForSimulatorToBeReady(retries?: number): Promise<WaitForSimulatorToBeReadyResultType>;
   createRandomValidators(numValidators: number, llmProviders: AiProviders[]): Promise<any>;
@@ -22,11 +17,9 @@ export interface ISimulatorService {
   resetDockerImages(): Promise<boolean>;
   checkCliVersion(): Promise<void>;
   cleanDatabase(): Promise<boolean>;
+  addConfigToEnvFile(newConfig: Record<string, string>): void;
 }
 
-export type DownloadSimulatorResultType = {
-  wasInstalled: boolean;
-};
 
 export type WaitForSimulatorToBeReadyResultType = {
   initialized: boolean;

package/src/lib/services/simulator.ts

@@ -8,7 +8,6 @@ import pkg from '../../../package.json'
 
 import {rpcClient} from "../clients/jsonRpcClient";
 import {
-  DEFAULT_REPO_GH_URL,
   DOCKER_IMAGES_AND_CONTAINERS_NAME_PREFIX,
   DEFAULT_RUN_SIMULATOR_COMMAND,
   DEFAULT_RUN_DOCKER_COMMAND,
@@ -28,7 +27,6 @@ import {MissingRequirementError} from "../errors/missingRequirement";
 
 import {
   ISimulatorService,
-  DownloadSimulatorResultType,
   WaitForSimulatorToBeReadyResultType,
 } from "../interfaces/ISimulatorService";
 import {VersionRequiredError} from "../errors/versionRequired";
@@ -41,39 +39,16 @@ function sleep(millliseconds: number): Promise<void> {
 export class SimulatorService implements ISimulatorService {
   private composeOptions: string
   private docker: Docker;
-  public simulatorLocation: string;
+  public location: string;
 
   constructor() {
-    this.simulatorLocation = "";
+    this.location = path.resolve(__dirname, '..');
     this.composeOptions = "";
     this.docker = new Docker();
   }
 
-  public setSimulatorLocation(location: string): void {
-    this.simulatorLocation = location;
-  }
-
-  public getSimulatorLocation(): string {
-    return this.simulatorLocation;
-  }
-
-  public setComposeOptions(headless: boolean): void {
-    this.composeOptions = headless ? '--scale frontend=0' : '';
-  }
-
-  public getComposeOptions(): string {
-    return this.composeOptions;
-  }
-
-  private readEnvConfigValue(key: string): string {
-    const envFilePath = path.join(this.simulatorLocation, ".env");
-    // Transform the config string to object
-    const envConfig = dotenv.parse(fs.readFileSync(envFilePath, "utf8"));
-    return envConfig[key];
-  }
-
-  private addConfigToEnvFile(newConfig: Record<string, string>): void {
-    const envFilePath = path.join(this.simulatorLocation, ".env");
+  public addConfigToEnvFile(newConfig: Record<string, string>): void {
+    const envFilePath = path.join(this.location, ".env");
 
     // Create a backup of the original .env file
     fs.writeFileSync(`${envFilePath}.bak`, fs.readFileSync(envFilePath));
@@ -95,6 +70,21 @@ export class SimulatorService implements ISimulatorService {
     fs.writeFileSync(envFilePath, updatedConfig);
   }
 
+  public setComposeOptions(headless: boolean): void {
+    this.composeOptions = headless ? '--scale frontend=0' : '';
+  }
+
+  public getComposeOptions(): string {
+    return this.composeOptions;
+  }
+
+  private readEnvConfigValue(key: string): string {
+    const envFilePath = path.join(this.location, ".env");
+    // Transform the config string to object
+    const envConfig = dotenv.parse(fs.readFileSync(envFilePath, "utf8"));
+    return envConfig[key];
+  }
+
   public async checkCliVersion(): Promise<void> {
     const update = await updateCheck(pkg);
     if (update && update.latest !== pkg.version) {
@@ -104,19 +94,9 @@ export class SimulatorService implements ISimulatorService {
 
   public async checkInstallRequirements(): Promise<Record<string, boolean>> {
     const requirementsInstalled = {
-      git: false,
       docker: false,
     };
 
-    try {
-      await checkCommand("git --version", "git");
-      requirementsInstalled.git = true;
-    } catch (error) {
-      if (!(error instanceof MissingRequirementError)) {
-        throw error;
-      }
-    }
-
     try {
       await checkCommand("docker --version", "docker");
       requirementsInstalled.docker = true;
@@ -126,7 +106,6 @@ export class SimulatorService implements ISimulatorService {
       }
     }
 
-
     if (requirementsInstalled.docker) {
       try {
         await this.docker.ping()
@@ -173,62 +152,41 @@ export class SimulatorService implements ISimulatorService {
     }
   }
 
-  public async downloadSimulator(branch: string = "main"): Promise<DownloadSimulatorResultType> {
+  public async pullOllamaModel(): Promise<boolean> {
     try {
-      const gitCommand = `git clone -b ${branch} ${DEFAULT_REPO_GH_URL} ${this.simulatorLocation}`;
-      const cmdsByPlatform = {darwin: gitCommand, win32: gitCommand, linux: gitCommand};
-      await executeCommand(cmdsByPlatform, "git");
-    } catch (error: any) {
-      const simulatorLocationExists = fs.existsSync(this.simulatorLocation);
-      if (simulatorLocationExists) {
-        return {wasInstalled: true};
-      }
-      throw error;
+      const ollamaContainer = this.docker.getContainer("ollama");
+
+      // Create the exec instance
+      const exec = await ollamaContainer.exec({
+        Cmd: ["ollama", "pull", "llama3"],
+        AttachStdout: true,
+        AttachStderr: true,
+      });
+
+      // Start the exec instance and attach to the stream
+      const stream = await exec.start({ Detach: false, Tty: false });
+
+      // Collect and log the output
+      stream.on("data", (chunk) => {
+        console.log(chunk.toString());
+      });
+
+      await new Promise<void>((resolve, reject) => {
+        stream.on("end", resolve);
+        stream.on("error", reject);
+      });
+
+      console.log("Command executed successfully");
+      return true;
+    } catch (error) {
+      console.error("Error executing ollama pull llama3:", error);
+      return false;
     }
-    return {wasInstalled: false};
   }
 
-  public async updateSimulator(branch: string = "main"): Promise<boolean> {
-    const gitCleanCommand = `git -C  "${this.simulatorLocation}" clean -f`;
-    const cleanCmdsByPlatform = {darwin: gitCleanCommand, win32: gitCleanCommand, linux: gitCleanCommand};
-    await executeCommand(cleanCmdsByPlatform, "git");
-
-    const gitFetchCommand = `git -C  "${this.simulatorLocation}" fetch`;
-    const fetchCmdsByPlatform = {darwin: gitFetchCommand, win32: gitFetchCommand, linux: gitFetchCommand};
-    await executeCommand(fetchCmdsByPlatform, "git");
-
-    const gitCheckoutCommand = `git -C  "${this.simulatorLocation}" checkout ${branch}`;
-    const checkoutCmdsByPlatform = {
-      darwin: gitCheckoutCommand,
-      win32: gitCheckoutCommand,
-      linux: gitCheckoutCommand,
-    };
-    await executeCommand(checkoutCmdsByPlatform, "git");
-
-    const gitPullCommand = `git -C  "${this.simulatorLocation}" pull`;
-    const pullCmdsByPlatform = {darwin: gitPullCommand, win32: gitPullCommand, linux: gitPullCommand};
-    await executeCommand(pullCmdsByPlatform, "git");
-    return true;
-  }
-
-  public async pullOllamaModel(): Promise<boolean> {
-    const ollamaContainer = this.docker.getContainer("ollama");
-    await ollamaContainer.exec({
-      Cmd: ["ollama", "pull", "llama3"],
-    });
-    return true;
-  }
-
-  public async configSimulator(newConfig: Record<string, string>): Promise<boolean> {
-    const envExample = path.join(this.simulatorLocation, ".env.example");
-    const envFilePath = path.join(this.simulatorLocation, ".env");
-    fs.copyFileSync(envExample, envFilePath);
-    this.addConfigToEnvFile(newConfig);
-    return true;
-  }
 
   public runSimulator(): Promise<{stdout: string; stderr: string}> {
-    const commandsByPlatform = DEFAULT_RUN_SIMULATOR_COMMAND(this.simulatorLocation, this.getComposeOptions());
+    const commandsByPlatform = DEFAULT_RUN_SIMULATOR_COMMAND(this.location, this.getComposeOptions());
     return executeCommand(commandsByPlatform);
   }