genlayer 0.1.3 → 0.2.0

package/CHANGELOG.md

@@ -1,5 +1,19 @@
 
 
+## 0.2.0 (2024-11-14)
+
+
+### Features
+
+* adding headless option to cli ([#128](https://github.com/yeagerai/genlayer-cli/issues/128)) ([d9bfbc2](https://github.com/yeagerai/genlayer-cli/commit/d9bfbc2dc2bcb8a4673f419d868f2c41d8396bd8))
+
+## 0.1.4 (2024-11-12)
+
+
+### Bug Fixes
+
+* changing linux command to fix display issue and fixing waiting simulator issue ([#127](https://github.com/yeagerai/genlayer-cli/issues/127)) ([721eebf](https://github.com/yeagerai/genlayer-cli/commit/721eebfea758a0897f23afd60b5767c59d593eb1))
+
 ## 0.1.3 (2024-11-08)
 
 ## 0.1.2 (2024-11-08)

package/dist/index.js

@@ -39699,7 +39699,7 @@ var {
 } = import_index.default;
 
 // package.json
-var version = "0.1.3";
+var version = "0.2.0";
 
 // src/lib/config/text.ts
 var CLI_DESCRIPTION = "GenLayer CLI is a development environment for the GenLayer ecosystem. It allows developers to interact with the protocol by creating accounts, sending transactions, and working with Intelligent Contracts by testing, debugging, and deploying them.";
@@ -39764,10 +39764,10 @@ var v4_default = v4;
 var DEFAULT_JSON_RPC_URL = "http://localhost:4000/api";
 var DEFAULT_REPO_GH_URL = "https://github.com/yeagerai/genlayer-simulator.git";
 var DOCKER_IMAGES_AND_CONTAINERS_NAME_PREFIX = "genlayer-simulator-";
-var DEFAULT_RUN_SIMULATOR_COMMAND = (simulatorLocation) => ({
-  darwin: `osascript -e 'tell application "Terminal" to do script "cd ${simulatorLocation} && docker compose build && docker compose up"'`,
-  win32: `start cmd.exe /c "cd /d ${simulatorLocation} && docker compose build && docker compose up && pause"`,
-  linux: `x-terminal-emulator -e bash -c 'cd ${simulatorLocation} && docker compose build && docker compose up; echo "Press enter to exit"; read'`
+var DEFAULT_RUN_SIMULATOR_COMMAND = (simulatorLocation, options) => ({
+  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}'`
 });
 var DEFAULT_PULL_OLLAMA_COMMAND = (simulatorLocation) => ({
   darwin: `cd ${simulatorLocation} && docker exec ollama ollama pull llama3`,
@@ -40418,8 +40418,10 @@ function sleep(millliseconds) {
 }
 var SimulatorService = class {
   constructor() {
+    __publicField(this, "composeOptions");
     __publicField(this, "simulatorLocation");
     this.simulatorLocation = "";
+    this.composeOptions = "";
   }
   setSimulatorLocation(location) {
     this.simulatorLocation = location;
@@ -40427,6 +40429,12 @@ var SimulatorService = class {
   getSimulatorLocation() {
     return this.simulatorLocation;
   }
+  setComposeOptions(headless) {
+    this.composeOptions = headless ? "--scale frontend=0" : "";
+  }
+  getComposeOptions() {
+    return this.composeOptions;
+  }
   readEnvConfigValue(key) {
     const envFilePath = path2.join(this.simulatorLocation, ".env");
     const envConfig = dotenv.parse(fs5.readFileSync(envFilePath, "utf8"));
@@ -40563,7 +40571,7 @@ var SimulatorService = class {
     });
   }
   runSimulator() {
-    const commandsByPlatform = DEFAULT_RUN_SIMULATOR_COMMAND(this.simulatorLocation);
+    const commandsByPlatform = DEFAULT_RUN_SIMULATOR_COMMAND(this.simulatorLocation, this.getComposeOptions());
     return executeCommand(commandsByPlatform);
   }
   waitForSimulatorToBeReady() {
@@ -40572,7 +40580,7 @@ var SimulatorService = class {
       console.log("Waiting for the simulator to start up...");
       try {
         const response = yield rpcClient.request({ method: "ping", params: [] });
-        if (((_a = response == null ? void 0 : response.result) == null ? void 0 : _a.status) === "OK" || ((_c = (_b = response == null ? void 0 : response.result) == null ? void 0 : _b.data) == null ? void 0 : _c.status) === "OK") {
+        if ((response == null ? void 0 : response.result) === "OK" || ((_a = response == null ? void 0 : response.result) == null ? void 0 : _a.status) === "OK" || ((_c = (_b = response == null ? void 0 : response.result) == null ? void 0 : _b.data) == null ? void 0 : _c.status) === "OK") {
           return { initialized: true };
         }
         if (retries > 0) {
@@ -43260,6 +43268,7 @@ function getVersionErrorMessage({ docker, node }) {
 function initAction(options, simulatorService) {
   return __async(this, null, function* () {
     simulatorService.setSimulatorLocation(options.location);
+    simulatorService.setComposeOptions(options.headless);
     try {
       const requirementsInstalled = yield simulatorService.checkInstallRequirements();
       const requirementErrorMessage = getRequirementsErrorMessage(requirementsInstalled);
@@ -43413,7 +43422,9 @@ function initAction(options, simulatorService) {
       `GenLayer simulator initialized successfully! Go to ${simulatorService.getFrontendUrl()} in your browser to access it.`
     );
     try {
-      simulatorService.openFrontend();
+      if (!options.headless) {
+        yield simulatorService.openFrontend();
+      }
     } catch (error) {
       console.error(error);
     }
@@ -43423,7 +43434,8 @@ function initAction(options, simulatorService) {
 // src/commands/general/start.ts
 function startAction(options, simulatorService) {
   return __async(this, null, function* () {
-    const { resetValidators, numValidators, branch, location } = options;
+    const { resetValidators, numValidators, branch, location, headless } = options;
+    simulatorService.setComposeOptions(headless);
     simulatorService.setSimulatorLocation(location);
     const restartValidatorsHintText = resetValidators ? `creating new ${numValidators} random validators` : "keeping the existing validators";
     console.log(`Starting GenLayer simulator ${restartValidatorsHintText}`);
@@ -43493,7 +43505,9 @@ function startAction(options, simulatorService) {
       `GenLayer simulator initialized successfully! Go to ${simulatorService.getFrontendUrl()} in your browser to access it.`
     );
     try {
-      yield simulatorService.openFrontend();
+      if (!headless) {
+        yield simulatorService.openFrontend();
+      }
     } catch (error) {
       console.error(error);
     }
@@ -43502,8 +43516,8 @@ function startAction(options, simulatorService) {
 
 // src/commands/general/index.ts
 function initializeGeneralCommands(program2) {
-  program2.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()).action((options) => initAction(options, simulator_default));
-  program2.command("up").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()).action((options) => startAction(options, simulator_default));
+  program2.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).action((options) => initAction(options, simulator_default));
+  program2.command("up").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).action((options) => startAction(options, simulator_default));
   return program2;
 }
 

package/package.json

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

package/src/commands/general/index.ts

@@ -12,6 +12,7 @@ export function initializeGeneralCommands(program: Command) {
     .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)
     .action((options: InitActionOptions) => initAction(options, simulatorService));
 
   program
@@ -21,6 +22,7 @@ export function initializeGeneralCommands(program: Command) {
     .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)
     .action((options: StartActionOptions) => startAction(options, simulatorService));
 
   return program;

package/src/commands/general/init.ts

@@ -6,7 +6,7 @@ export interface InitActionOptions {
   numValidators: number;
   branch: string;
   location: string;
-
+  headless: boolean;
 }
 
 function getRequirementsErrorMessage({git, docker}: Record<string, boolean>): string {
@@ -38,9 +38,8 @@ function getVersionErrorMessage({docker, node}: Record<string, string>): string
 }
 
 export async function initAction(options: InitActionOptions, simulatorService: ISimulatorService) {
-  // Update simulator location with user input
   simulatorService.setSimulatorLocation(options.location);
-
+  simulatorService.setComposeOptions(options.headless);
 
   // Check if requirements are installed
   try {
@@ -231,8 +230,9 @@ export async function initAction(options: InitActionOptions, simulatorService: I
     `GenLayer simulator initialized successfully! Go to ${simulatorService.getFrontendUrl()} in your browser to access it.`,
   );
   try {
-    // eslint-disable-next-line @typescript-eslint/no-floating-promises
-    simulatorService.openFrontend();
+    if(!options.headless){
+      await simulatorService.openFrontend();
+    }
   } catch (error) {
     console.error(error);
   }

package/src/commands/general/start.ts

@@ -7,11 +7,13 @@ export interface StartActionOptions {
   numValidators: number;
   branch: string;
   location: string;
+  headless: boolean;
 }
 
 export async function startAction(options: StartActionOptions, simulatorService: ISimulatorService) {
-  const {resetValidators, numValidators, branch, location} = options;
+  const {resetValidators, numValidators, branch, location, headless} = options;
   // Update simulator location with user input
+  simulatorService.setComposeOptions(headless);
   simulatorService.setSimulatorLocation(location);
 
 
@@ -100,7 +102,9 @@ export async function startAction(options: StartActionOptions, simulatorService:
     `GenLayer simulator initialized successfully! Go to ${simulatorService.getFrontendUrl()} in your browser to access it.`,
   );
   try {
-    await simulatorService.openFrontend();
+    if(!headless) {
+      await simulatorService.openFrontend();
+    }
 
   } catch (error) {
     console.error(error);

package/src/lib/config/simulator.ts

@@ -1,10 +1,10 @@
 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) => ({
-  darwin: `osascript -e 'tell application "Terminal" to do script "cd ${simulatorLocation} && docker compose build && docker compose up"'`,
-  win32: `start cmd.exe /c "cd /d ${simulatorLocation} && docker compose build && docker compose up && pause"`,
-  linux: `x-terminal-emulator -e bash -c 'cd ${simulatorLocation} && docker compose build && docker compose up; echo "Press enter to exit"; read'`,
+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 DEFAULT_PULL_OLLAMA_COMMAND = (simulatorLocation: string) => ({
   darwin: `cd ${simulatorLocation} && docker exec ollama ollama pull llama3`,

package/src/lib/interfaces/ISimulatorService.ts

@@ -3,6 +3,8 @@ 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>;

package/src/lib/services/simulator.ts

@@ -41,10 +41,12 @@ function sleep(millliseconds: number): Promise<void> {
 }
 
 export class SimulatorService implements ISimulatorService {
+  private composeOptions: string
   public simulatorLocation: string;
 
   constructor() {
     this.simulatorLocation = "";
+    this.composeOptions = "";
   }
 
   public setSimulatorLocation(location: string): void {
@@ -55,6 +57,14 @@ export class SimulatorService implements ISimulatorService {
     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
@@ -209,7 +219,7 @@ export class SimulatorService implements ISimulatorService {
   }
 
   public runSimulator(): Promise<{stdout: string; stderr: string}> {
-    const commandsByPlatform = DEFAULT_RUN_SIMULATOR_COMMAND(this.simulatorLocation);
+    const commandsByPlatform = DEFAULT_RUN_SIMULATOR_COMMAND(this.simulatorLocation, this.getComposeOptions());
     return executeCommand(commandsByPlatform);
   }
 
@@ -221,7 +231,7 @@ export class SimulatorService implements ISimulatorService {
       const response = await rpcClient.request({method: "ping", params: []});
 
       //Compatibility with current simulator version
-      if (response?.result?.status === "OK" || response?.result?.data?.status === "OK") {
+      if (response?.result === "OK" || response?.result?.status === "OK" || response?.result?.data?.status === "OK") {
         return { initialized: true };
       }
       if (retries > 0) {

package/tests/actions/init.test.ts

@@ -7,7 +7,7 @@ import {mkdtempSync} from "fs";
 import {join} from "path";
 
 const tempDir = mkdtempSync(join(tmpdir(), "test-initAction-"));
-const defaultActionOptions = { numValidators: 5, branch: "main", location: tempDir };
+const defaultActionOptions = { numValidators: 5, branch: "main", location: tempDir, headless: false };
 
 describe("init action", () => {
   let error: ReturnType<any>;
@@ -422,4 +422,4 @@ describe("init action", () => {
 
     expect(error).toHaveBeenCalledWith(errorMsg);
   });
-});
+});

package/tests/actions/start.test.ts

@@ -13,7 +13,8 @@ describe("startAction - Additional Tests", () => {
     resetValidators: false,
     numValidators: 5,
     branch: "main",
-    location: ''
+    location: '',
+    headless: false,
   };
 
   beforeEach(() => {
@@ -29,6 +30,7 @@ describe("startAction - Additional Tests", () => {
       createRandomValidators: vi.fn().mockResolvedValue(undefined),
       openFrontend: vi.fn().mockResolvedValue(undefined),
       setSimulatorLocation: vi.fn().mockResolvedValue(undefined),
+      setComposeOptions: vi.fn(),
       getAiProvidersOptions: vi.fn(() => [
         { name: "Provider A", value: "providerA" },
         { name: "Provider B", value: "providerB" },

package/tests/commands/init.test.ts

@@ -2,6 +2,9 @@ import { Command } from "commander";
 import { vi, describe, beforeEach, afterEach, test, expect } from "vitest";
 import { initializeGeneralCommands } from "../../src/commands/general";
 import { getCommand, getCommandOption } from "../utils";
+import simulatorService from  '../../src/lib/services/simulator'
+
+const openFrontendSpy = vi.spyOn(simulatorService, "openFrontend");
 
 vi.mock("inquirer", () => ({
   prompt: vi.fn(() => {}),
@@ -71,6 +74,13 @@ describe("init command", () => {
   test("action is called", async () => {
     program.parse(["node", "test", "init"]);
     expect(action).toHaveBeenCalledTimes(1);
-    expect(action).toHaveBeenCalledWith({ numValidators: "5", branch: "main", location: process.cwd() });
+    expect(action).toHaveBeenCalledWith({ numValidators: "5", branch: "main", location: process.cwd(), headless: false });
+  });
+
+  test("option --headless is accepted", async () => {
+    program.parse(["node", "test", "init", "--headless"]);
+    expect(action).toHaveBeenCalledTimes(1);
+    expect(action).toHaveBeenCalledWith({ numValidators: "5", branch: "main", location: process.cwd(), headless: true });
+    expect(openFrontendSpy).not.toHaveBeenCalled();
   });
 });

package/tests/commands/up.test.ts

@@ -2,6 +2,9 @@ import { Command } from "commander";
 import { vi, describe, beforeEach, afterEach, test, expect } from "vitest";
 import { initializeGeneralCommands } from "../../src/commands/general";
 import { getCommand, getCommandOption } from "../utils";
+import simulatorService from  '../../src/lib/services/simulator'
+
+const openFrontendSpy = vi.spyOn(simulatorService, "openFrontend");
 
 const action = vi.fn();
 
@@ -69,7 +72,7 @@ describe("up command", () => {
   test("action is called with default options", async () => {
     program.parse(["node", "test", "up"]);
     expect(action).toHaveBeenCalledTimes(1);
-    expect(action).toHaveBeenCalledWith({ resetValidators: false, numValidators: "5", branch: "main", location: process.cwd() });
+    expect(action).toHaveBeenCalledWith({ resetValidators: false, numValidators: "5", branch: "main", location: process.cwd(), headless: false });
   });
 
   test("action is called with custom options", async () => {
@@ -82,6 +85,8 @@ describe("up command", () => {
       "10",
       "--branch",
       "development",
+      "--headless",
+      "true"
     ]);
     expect(action).toHaveBeenCalledTimes(1);
     expect(action).toHaveBeenCalledWith({
@@ -89,6 +94,8 @@ describe("up command", () => {
       numValidators: "10",
       branch: "development",
       location: process.cwd(),
+      headless: true,
     });
+    expect(openFrontendSpy).not.toHaveBeenCalled();
   });
 });

package/tests/services/simulator.test.ts

@@ -23,6 +23,7 @@ import {
 } from "../../src/lib/config/simulator";
 import { rpcClient } from "../../src/lib/clients/jsonRpcClient";
 import * as semver from "semver";
+import {getCommandOption} from "@@/tests/utils";
 
 
 vi.mock("fs");
@@ -104,20 +105,27 @@ describe("SimulatorService - Basic Tests", () => {
     expect(fs.existsSync).toHaveBeenCalled();
   });
 
-  test("should return initialized true when simulator responds with OK", async () => {
+  test("should return initialized true when simulator responds with OK (result.status = OK)", async () => {
     vi.mocked(rpcClient.request).mockResolvedValueOnce({ result: {status: 'OK'} });
     const result = await simulatorService.waitForSimulatorToBeReady(STARTING_TIMEOUT_ATTEMPTS);
     expect(result).toEqual({ initialized: true });
     expect(rpcClient.request).toHaveBeenCalledWith({ method: "ping", params: [] });
   });
 
-  test("should return initialized true when simulator responds with OK (different json structure)", async () => {
+  test("should return initialized true when simulator responds with OK (result.data.status = OK)", async () => {
     vi.mocked(rpcClient.request).mockResolvedValueOnce({ result: {data: {status: 'OK'}} });
     const result = await simulatorService.waitForSimulatorToBeReady(STARTING_TIMEOUT_ATTEMPTS);
     expect(result).toEqual({ initialized: true });
     expect(rpcClient.request).toHaveBeenCalledWith({ method: "ping", params: [] });
   });
 
+  test("should return initialized true when simulator responds with OK (result = OK)", async () => {
+    vi.mocked(rpcClient.request).mockResolvedValueOnce({ result: 'OK' });
+    const result = await simulatorService.waitForSimulatorToBeReady(STARTING_TIMEOUT_ATTEMPTS);
+    expect(result).toEqual({ initialized: true });
+    expect(rpcClient.request).toHaveBeenCalledWith({ method: "ping", params: [] });
+  });
+
   test("should return initialized false with errorCode TIMEOUT after retries", async () => {
     vi.mocked(rpcClient.request).mockResolvedValue(undefined);
     const result = await simulatorService.waitForSimulatorToBeReady(1);
@@ -148,7 +156,20 @@ describe("SimulatorService - Basic Tests", () => {
       stderr: "",
     });
     const result = await simulatorService.runSimulator();
-    const expectedCommand = DEFAULT_RUN_SIMULATOR_COMMAND("/mock/home/genlayer-simulator");
+    const expectedCommand = DEFAULT_RUN_SIMULATOR_COMMAND("/mock/home/genlayer-simulator", '');
+    expect(executeCommand).toHaveBeenCalledWith(expectedCommand);
+    expect(result).toEqual({ stdout: "Simulator started", stderr: "" });
+  });
+
+  test("should execute the correct run simulator command based on headless option", async () => {
+    (executeCommand as Mock).mockResolvedValue({
+      stdout: "Simulator started",
+      stderr: "",
+    });
+    simulatorService.setComposeOptions(true)
+    const commandOption = simulatorService.getComposeOptions();
+    const result = await simulatorService.runSimulator();
+    const expectedCommand = DEFAULT_RUN_SIMULATOR_COMMAND("/mock/home/genlayer-simulator", commandOption);
     expect(executeCommand).toHaveBeenCalledWith(expectedCommand);
     expect(result).toEqual({ stdout: "Simulator started", stderr: "" });
   });