genlayer 0.0.17 → 0.0.18

package/package.json

@@ -1,8 +1,11 @@
 {
   "name": "genlayer",
-  "version": "0.0.17",
+  "version": "0.0.18",
   "description": "GenLayer Command Line Tool",
   "main": "src/index.ts",
+  "bin": {
+    "genlayer": "./dist/index.js"
+  },
   "scripts": {
     "test": "jest",
     "dev": "cross-env NODE_ENV=development node esbuild.config.js",
@@ -32,6 +35,7 @@
     "@types/jest": "^29.5.12",
     "@types/node": "^20.12.7",
     "@types/sinon": "^17.0.3",
+    "@types/uuid": "^9.0.8",
     "@typescript-eslint/eslint-plugin": "^7.7.0",
     "@typescript-eslint/parser": "^7.7.0",
     "cross-env": "^7.0.3",
@@ -50,6 +54,7 @@
   "dependencies": {
     "commander": "^12.0.0",
     "inquirer": "^9.2.19",
-    "node-fetch": "^3.3.2"
+    "node-fetch": "^3.3.2",
+    "uuid": "^9.0.1"
   }
 }

package/src/commands/general/init.ts

@@ -1,24 +1,105 @@
 import inquirer from "inquirer";
 
+import {
+  initializeDatabase,
+  checkRequirements,
+  downloadSimulator,
+  runSimulator,
+  waitForSimulatorToBeReady,
+  updateSimulator,
+} from "@/lib/services/simulator";
 export interface InitActionOptions {
   numValidators: number;
 }
 
+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";
+  }
+  if (!docker) {
+    return "Docker is not installed. Please install Docker and try again.\n";
+  }
+  return "";
+}
+
 export async function initAction(options: InitActionOptions) {
-  console.log("Initializing GenLayer CLI...");
-  console.log("Number of validators:", options.numValidators);
+  console.log(`Initializing GenLayer CLI with ${options.numValidators} validators`);
 
+  // Check if git and docker are installed
+  try {
+    const {git, docker} = await checkRequirements();
+    const errorMessage = getRequirementsErrorMessage({git, docker});
+    if (errorMessage) {
+      console.error(errorMessage);
+      return;
+    }
+  } catch (error) {
+    console.error(error);
+    return;
+  }
+
+  // Ask for confirmation on downloading the GenLayer Simulator from GitHub
   const answers = await inquirer.prompt([
     {
       type: "confirm",
-      name: "confirmDelete",
+      name: "confirmDownload",
       message: `This action is going to download the GenLayer Simulator from GitHub. Do you want to continue?`,
-      default: false,
+      default: true,
     },
   ]);
 
-  if (!answers.confirmDelete) {
+  if (!answers.confirmDownload) {
     console.log("Aborted!");
     return;
   }
+
+  // Download the GenLayer Simulator from GitHub
+  console.log(`Downloading GenLayer Simulator from GitHub...`);
+  try {
+    const {wasInstalled} = await downloadSimulator();
+    if (wasInstalled) {
+      await updateSimulator();
+    }
+  } catch (error) {
+    console.error(error);
+    return;
+  }
+
+  // Run the GenLayer Simulator
+  console.log("Running the GenLayer Simulator...");
+  try {
+    await runSimulator();
+  } catch (error) {
+    console.error(error);
+    return;
+  }
+
+  try {
+    const initialized = await waitForSimulatorToBeReady();
+    if (!initialized) {
+      console.error("Unable to initialize the GenLayer simulator. Please try again.");
+      return;
+    }
+    console.log("Simulator is running!");
+  } catch (error) {
+    console.error(error);
+    return;
+  }
+
+  // Initialize the database
+  console.log("Initializing the database...");
+  try {
+    const {createResponse, tablesResponse} = await initializeDatabase();
+    if (!createResponse || !tablesResponse) {
+      console.error("Unable to initialize the database. Please try again.");
+      return;
+    }
+  } catch (error) {
+    console.error(error);
+    return;
+  }
+  console.log("GenLayer simulator initialized successfully!");
 }

package/src/index.ts

@@ -1,3 +1,4 @@
+#!/usr/bin/env node
 import {program} from "commander";
 
 import {CLI_DESCRIPTION} from "@/lib/config/text";

package/src/lib/clients/jsonRpcClient.ts

@@ -1,19 +1,42 @@
 import fetch from "node-fetch";
+import {v4 as uuidv4} from "uuid";
 
 import {DEFAULT_JSON_RPC_URL} from "../config/simulator";
 
-export async function requestJsonRpc(method: string, body: object) {
-  try {
-    const response = await fetch(DEFAULT_JSON_RPC_URL, {
-      method,
-      body: JSON.stringify(body),
-    });
+export interface JsonRPCParams {
+  method: string;
+  params: any[];
+}
+
+export class JsonRpcClient {
+  serverUrl: string;
+
+  constructor(serverUrl: string) {
+    this.serverUrl = serverUrl;
+  }
+
+  async request({method, params}: JsonRPCParams): Promise<any | null> {
+    try {
+      const response = await fetch(this.serverUrl, {
+        method: "POST",
+        headers: {
+          "Content-Type": "application/json",
+        },
+        body: JSON.stringify({
+          jsonrpc: "2.0",
+          id: uuidv4(),
+          method,
+          params,
+        }),
+      });
 
-    if (response.ok) {
-      return response.json();
+      if (response.ok) {
+        return response.json();
+      }
+    } catch (error: any) {
+      throw new Error(`Fetch Error: ${error.message}`);
     }
-  } catch (error: any) {
-    throw new Error(`Fetch Error: ${error.message}`);
+    return null;
   }
-  return null;
 }
+export const rpcClient = new JsonRpcClient(DEFAULT_JSON_RPC_URL);

package/src/lib/clients/system.ts

@@ -0,0 +1,57 @@
+import util from "node:util";
+import {PromiseWithChild, exec} from "child_process";
+import os from "os";
+
+import {RunningPlatform, AVAILABLE_PLATFORMS} from "@/lib/config/simulator";
+import {MissingRequirementError} from "../errors/missingRequirement";
+
+const asyncExec = util.promisify(exec);
+
+export async function checkCommand(command: string, toolName: string): Promise<void> {
+  const {stderr} = await asyncExec(command);
+  if (stderr) {
+    throw new MissingRequirementError(toolName);
+  }
+  console.log(`${toolName} is installed.`);
+}
+
+type ExecuteCommandResult = {
+  stdout: string;
+  stderr: string;
+};
+
+export function executeCommand(command: string, toolName: string): Promise<ExecuteCommandResult> {
+  try {
+    return asyncExec(command);
+  } catch (error: any) {
+    throw new Error(`Error executing ${toolName}: ${error.message}`);
+  }
+}
+
+type ExecuteCommandInNewTerminalInput = {
+  [key in RunningPlatform]: string;
+};
+
+export function executeCommandInNewTerminal(
+  cmdsByPlatform: ExecuteCommandInNewTerminalInput,
+): PromiseWithChild<{stdout: string; stderr: string}> {
+  const runningPlatform = getPlatform();
+  const command = cmdsByPlatform[runningPlatform];
+  try {
+    return asyncExec(command);
+  } catch (error: any) {
+    throw new Error(`Error executing command ${command}`);
+  }
+}
+
+export function getHomeDirectory(): string {
+  return os.homedir();
+}
+
+function getPlatform(): RunningPlatform {
+  const currentPlatform = process.platform as RunningPlatform;
+  if (!AVAILABLE_PLATFORMS.includes(currentPlatform)) {
+    throw new Error(`Unsupported platform: ${currentPlatform}`);
+  }
+  return currentPlatform;
+}

package/src/lib/config/simulator.ts

@@ -1 +1,10 @@
-export const DEFAULT_JSON_RPC_URL = "http://localhost:8545";
+export const DEFAULT_JSON_RPC_URL = "http://localhost:4000/api";
+export const DEFAULT_REPO_GH_URL = "git@github.com:yeagerai/genlayer-simulator.git";
+export const DEFAULT_RUN_SIMULATOR_COMMAND = (simulatorLocation: string) => ({
+  darwin: `osascript -e 'tell application "Terminal" to do script "cd ${simulatorLocation} && cp .env.example .env && docker compose build && docker compose up"'`,
+  win32: `start cmd.exe /k "cd ${simulatorLocation} && xcopy .env.example .env && docker compose build && docker compose up"`,
+  linux: `x-terminal-emulator -e 'bash -c "cd ${simulatorLocation} && cp .env.example .env && docker compose build && docker compose up"'`,
+});
+export const AVAILABLE_PLATFORMS = ["darwin", "win32", "linux"] as const;
+export type RunningPlatform = (typeof AVAILABLE_PLATFORMS)[number];
+export const STARTING_TIMEOUT_WAIT_CYLCE = 2000;

package/src/lib/errors/jsonRpcClientError.ts

@@ -0,0 +1,9 @@
+export class MissingRequirementError extends Error {
+  requirement: string;
+
+  constructor(requirement: string) {
+    super(`${requirement} is not installed. Please install ${requirement}.`);
+    this.name = "MissingRequirement";
+    this.requirement = requirement;
+  }
+}

package/src/lib/errors/missingRequirement.ts

@@ -0,0 +1,9 @@
+export class MissingRequirementError extends Error {
+  requirement: string;
+
+  constructor(requirement: string) {
+    super(`${requirement} is not installed. Please install ${requirement}.`);
+    this.name = "MissingRequirement";
+    this.requirement = requirement;
+  }
+}

package/src/lib/services/simulator.ts

@@ -0,0 +1,118 @@
+import {rpcClient} from "@/lib/clients/jsonRpcClient";
+import {
+  DEFAULT_REPO_GH_URL,
+  DEFAULT_RUN_SIMULATOR_COMMAND,
+  STARTING_TIMEOUT_WAIT_CYLCE,
+} from "@/lib/config/simulator";
+import {
+  checkCommand,
+  getHomeDirectory,
+  executeCommand,
+  executeCommandInNewTerminal,
+} from "@/lib/clients/system";
+import {MissingRequirementError} from "../errors/missingRequirement";
+
+// Private helper functions
+function getSimulatorLocation(): string {
+  return `${getHomeDirectory()}/genlayer-simulator`;
+}
+
+function sleep(millliseconds: number): Promise<void> {
+  return new Promise(resolve => setTimeout(resolve, millliseconds));
+}
+
+// Public functions
+export async function checkRequirements(): 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;
+  } catch (error) {
+    if (!(error instanceof MissingRequirementError)) {
+      throw error;
+    }
+  }
+
+  return requirementsInstalled;
+}
+
+type DownloadSimulatorResultType = {
+  wasInstalled: boolean;
+};
+
+export async function downloadSimulator(): Promise<DownloadSimulatorResultType> {
+  const simulatorLocation = getSimulatorLocation();
+
+  try {
+    await executeCommand(`git clone ${DEFAULT_REPO_GH_URL} ${simulatorLocation}`, "git");
+  } catch (error: any) {
+    if (error.toString().includes("already exists and is not an empty directory")) {
+      return {wasInstalled: true};
+    }
+    throw error;
+  }
+  return {wasInstalled: false};
+}
+
+export async function updateSimulator(): Promise<DownloadSimulatorResultType> {
+  const simulatorLocation = getSimulatorLocation();
+
+  try {
+    await executeCommand(`cd ${simulatorLocation} && git pull`, "git");
+  } catch (error: any) {
+    if (error.toString().includes("already exists and is not an empty directory")) {
+      return {wasInstalled: true};
+    }
+    throw error;
+  }
+  return {wasInstalled: false};
+}
+
+export function runSimulator(): Promise<{stdout: string; stderr: string}> {
+  const simulatorLocation = getSimulatorLocation();
+  const commandsByPlatform = DEFAULT_RUN_SIMULATOR_COMMAND(simulatorLocation);
+  return executeCommandInNewTerminal(commandsByPlatform);
+}
+
+export async function waitForSimulatorToBeReady(retries: number = 10): Promise<boolean> {
+  try {
+    const response = await rpcClient.request({method: "ping", params: []});
+    if (response && response.result.status === "OK") {
+      return true;
+    }
+    if (retries > 0) {
+      await sleep(STARTING_TIMEOUT_WAIT_CYLCE);
+      return waitForSimulatorToBeReady(retries - 1);
+    }
+  } catch (error: any) {
+    if (error.message.includes("ECONNREFUSED") && retries > 0) {
+      await sleep(STARTING_TIMEOUT_WAIT_CYLCE * 2);
+      return waitForSimulatorToBeReady(retries - 1);
+    }
+  }
+
+  return false;
+}
+
+type InitializeDatabaseResultType = {
+  createResponse: any;
+  tablesResponse: any;
+};
+
+export async function initializeDatabase(): Promise<InitializeDatabaseResultType> {
+  const createResponse = await rpcClient.request({method: "create_db", params: []});
+  const tablesResponse = await rpcClient.request({method: "create_tables", params: []});
+  return {createResponse, tablesResponse};
+}

package/tests/commands/init.test.ts

@@ -11,6 +11,7 @@ const action = jest.fn();
 describe("init command", () => {
   initializeGeneralCommands(program);
   const initCommand = getCommand("init");
+  initCommand?.action(action);
 
   beforeEach(() => {
     jest.clearAllMocks();
@@ -20,11 +21,11 @@ describe("init command", () => {
     jest.restoreAllMocks();
   });
 
-  test("doesn't have required arguments nor options", async () => {
+  test("doesn't have required arguments nor options", () => {
     expect(() => program.parse(["node", "test", "init"])).not.toThrow();
   });
 
-  test("option -n, --numValidators is accepted", async () => {
+  test("option -n, --numValidators is accepted", () => {
     expect(() => program.parse(["node", "test", "init", "-n", "10"])).not.toThrow();
     expect(() => program.parse(["node", "test", "init", "--numValidators", "10"])).not.toThrow();
   });
@@ -45,10 +46,8 @@ describe("init command", () => {
     );
   });
 
-  test("action is called", async () => {
-    // Given
-    initCommand?.action(action);
-    // When
+  test("action is called", () => {
+    // Given When
     program.parse(["node", "test", "init"]);
     // Then
     expect(action).toHaveBeenCalledTimes(1);