@constellation-network/node-pilot 0.0.1

package/README.md

@@ -0,0 +1,213 @@
+@constellation-network/node-pilot
+=================
+
+A new CLI generated with oclif
+
+
+[![oclif](https://img.shields.io/badge/cli-oclif-brightgreen.svg)](https://oclif.io)
+[![Version](https://img.shields.io/npm/v/@constellation-network/node-pilot.svg)](https://npmjs.org/package/@constellation-network/node-pilot)
+[![Downloads/week](https://img.shields.io/npm/dw/@constellation-network/node-pilot.svg)](https://npmjs.org/package/@constellation-network/node-pilot)
+
+
+<!-- toc -->
+* [Usage](#usage)
+* [Commands](#commands)
+<!-- tocstop -->
+# Usage
+<!-- usage -->
+```sh-session
+$ npm install -g @constellation-network/node-pilot
+$ cpilot COMMAND
+running command...
+$ cpilot (--version|-v)
+@constellation-network/node-pilot/0.0.1 darwin-arm64 node-v22.15.0
+$ cpilot --help [COMMAND]
+USAGE
+  $ cpilot COMMAND
+...
+```
+<!-- usagestop -->
+# Commands
+<!-- commands -->
+* [`cpilot config`](#cpilot-config)
+* [`cpilot config get [NAME]`](#cpilot-config-get-name)
+* [`cpilot config set NAME VALUE`](#cpilot-config-set-name-value)
+* [`cpilot help [COMMAND]`](#cpilot-help-command)
+* [`cpilot info`](#cpilot-info)
+* [`cpilot logs [LAYER]`](#cpilot-logs-layer)
+* [`cpilot restart`](#cpilot-restart)
+* [`cpilot shutdown`](#cpilot-shutdown)
+* [`cpilot status`](#cpilot-status)
+
+## `cpilot config`
+
+Update configuration settings
+
+```
+USAGE
+  $ cpilot config
+
+DESCRIPTION
+  Update configuration settings
+
+EXAMPLES
+  $ cpilot config
+```
+
+_See code: [src/commands/config.ts](https://github.com/Constellation-Labs/node-pilot/blob/v0.0.1/src/commands/config.ts)_
+
+## `cpilot config get [NAME]`
+
+Show all configuration settings or a specific one
+
+```
+USAGE
+  $ cpilot config get [NAME]
+
+ARGUMENTS
+  NAME  configuration to get
+
+DESCRIPTION
+  Show all configuration settings or a specific one
+
+EXAMPLES
+  $ cpilot config get
+
+  $ cpilot config get CL_EXTERNAL_IP
+
+  $ cpilot config get gl0:CL_PUBLIC_HTTP_PORT
+```
+
+_See code: [src/commands/config/get.ts](https://github.com/Constellation-Labs/node-pilot/blob/v0.0.1/src/commands/config/get.ts)_
+
+## `cpilot config set NAME VALUE`
+
+Set a configuration setting
+
+```
+USAGE
+  $ cpilot config set NAME VALUE
+
+ARGUMENTS
+  NAME   configuration name
+  VALUE  the value to set to the configuration
+
+DESCRIPTION
+  Set a configuration setting
+
+EXAMPLES
+  $ cpilot config set CL_EXTERNAL_IP 127.0.0.1
+
+  $ cpilot config set gl0:CL_PUBLIC_HTTP_PORT 9000
+```
+
+_See code: [src/commands/config/set.ts](https://github.com/Constellation-Labs/node-pilot/blob/v0.0.1/src/commands/config/set.ts)_
+
+## `cpilot help [COMMAND]`
+
+Display help for cpilot.
+
+```
+USAGE
+  $ cpilot help [COMMAND...] [-n]
+
+ARGUMENTS
+  COMMAND...  Command to show help for.
+
+FLAGS
+  -n, --nested-commands  Include all nested commands in the output.
+
+DESCRIPTION
+  Display help for cpilot.
+```
+
+_See code: [@oclif/plugin-help](https://github.com/oclif/plugin-help/blob/v6.2.32/src/commands/help.ts)_
+
+## `cpilot info`
+
+Display general info about the validator node
+
+```
+USAGE
+  $ cpilot info
+
+DESCRIPTION
+  Display general info about the validator node
+
+EXAMPLES
+  $ cpilot info
+```
+
+_See code: [src/commands/info.ts](https://github.com/Constellation-Labs/node-pilot/blob/v0.0.1/src/commands/info.ts)_
+
+## `cpilot logs [LAYER]`
+
+view validator node runtime logs
+
+```
+USAGE
+  $ cpilot logs [LAYER] [-f]
+
+ARGUMENTS
+  LAYER  network layer to view. e.g. gl0
+
+FLAGS
+  -f, --follow  continuously wait for additional data to be appended
+
+DESCRIPTION
+  view validator node runtime logs
+
+EXAMPLES
+  $ cpilot logs
+```
+
+_See code: [src/commands/logs.ts](https://github.com/Constellation-Labs/node-pilot/blob/v0.0.1/src/commands/logs.ts)_
+
+## `cpilot restart`
+
+A full shutdown of the validator node, then restart
+
+```
+USAGE
+  $ cpilot restart
+
+DESCRIPTION
+  A full shutdown of the validator node, then restart
+
+EXAMPLES
+  $ cpilot restart
+```
+
+_See code: [src/commands/restart.ts](https://github.com/Constellation-Labs/node-pilot/blob/v0.0.1/src/commands/restart.ts)_
+
+## `cpilot shutdown`
+
+A full shutdown of the validator node
+
+```
+USAGE
+  $ cpilot shutdown
+
+DESCRIPTION
+  A full shutdown of the validator node
+
+EXAMPLES
+  $ cpilot shutdown
+```
+
+_See code: [src/commands/shutdown.ts](https://github.com/Constellation-Labs/node-pilot/blob/v0.0.1/src/commands/shutdown.ts)_
+
+## `cpilot status`
+
+Display node status and configuration settings
+
+```
+USAGE
+  $ cpilot status
+
+DESCRIPTION
+  Display node status and configuration settings
+```
+
+_See code: [src/commands/status.ts](https://github.com/Constellation-Labs/node-pilot/blob/v0.0.1/src/commands/status.ts)_
+<!-- commandsstop -->

package/bin/dev.cmd

@@ -0,0 +1,3 @@
+@echo off
+
+node --loader ts-node/esm --no-warnings=ExperimentalWarning "%~dp0\dev" %*

package/bin/dev.js

@@ -0,0 +1,19 @@
+#!/usr/bin/env -S node --loader ts-node/esm --disable-warning=ExperimentalWarning --disable-warning=DeprecationWarning
+const skipDefaultCommand = {
+    '--help': true, '--version': true, '-h': true, '-v': true,
+}
+if (process.argv.length === 2) {
+    process.argv[2] = 'status';
+}
+else if (process.argv.length > 2 && process.argv[2].startsWith('-') && !skipDefaultCommand[process.argv[2]]) {
+    process.argv.splice(2, 0 , 'status');
+}
+
+import {execute} from '@oclif/core'
+
+await execute({development: true, dir: import.meta.url})
+
+// eslint-disable-next-line no-warning-comments
+// TODO
+// cpilot config set project pacaswap-metagraph
+// cpilot config --project pacaswap-metagraph

package/bin/run.cmd

@@ -0,0 +1,3 @@
+@echo off
+
+node "%~dp0\run" %*

package/bin/run.js

@@ -0,0 +1,15 @@
+#!/usr/bin/env node
+
+const skipDefaultCommand = {
+    '--help': true, '--version': true, '-h': true, '-v': true,
+}
+if (process.argv.length === 2) {
+    process.argv[2] = 'status';
+}
+else if (process.argv.length > 2 && process.argv[2].startsWith('-') && !skipDefaultCommand[process.argv[2]]) {
+    process.argv.splice(2, 0 , 'status');
+}
+
+import {execute} from '@oclif/core'
+
+await execute({dir: import.meta.url})

package/dist/checks/check-hardware.d.ts

@@ -0,0 +1,3 @@
+export declare const checkHardware: {
+    systemRequirements(): Promise<void>;
+};

package/dist/checks/check-hardware.js

@@ -0,0 +1,50 @@
+import chalk from "chalk";
+import fs from "node:fs";
+import os from "node:os";
+import ttyTable from "tty-table";
+import { clm } from "../clm.js";
+import { configStore } from "../config-store.js";
+import { promptHelper } from "../helpers/prompt-helper.js";
+export const checkHardware = {
+    async systemRequirements() {
+        clm.preStep('Checking hardware requirements...');
+        // Retrieve disk space
+        const r = fs.statfsSync('/');
+        const totalSpaceGB = (r.bsize * r.blocks / (1024 * 1024 * 1024)).toFixed(2);
+        // const usage = diskusage.checkSync(os.homedir());
+        // const usableSpaceGB = (usage.total / (1024 * 1024 * 1024)).toFixed(2);
+        // Retrieve sys memory
+        const totalMemoryBytes = os.totalmem();
+        const totalMemoryGB = (totalMemoryBytes / (1024 * 1024 * 1024)).toFixed(2);
+        // Retrieve number of CPU cores
+        const numOfCores = os.availableParallelism();
+        let allPassed = true;
+        const formatActual = (value, recommended, units = '') => {
+            const passed = Number(value) >= recommended;
+            allPassed = allPassed && passed;
+            return passed ? chalk.greenBright(value + units) : chalk.redBright(value + units);
+        };
+        // eslint-disable-next-line unicorn/consistent-function-scoping
+        const fc = (value) => chalk.white(value);
+        const header = [
+            { headerColor: 'white', value: 'HARDWARE' },
+            { headerColor: 'white', value: 'RECOMMENDED' },
+            { headerColor: 'white', value: 'ACTUAL' },
+        ];
+        const rows = [
+            [fc("Disk size"), fc("320 GB"), formatActual(totalSpaceGB, 320, " GB")],
+            [fc("System memory"), fc("8 GB"), formatActual(totalMemoryGB, 8, " GB")],
+            [fc("CPU cores"), fc("8 cores"), formatActual(numOfCores, 8, " cores")],
+        ];
+        clm.echo(ttyTable(header, rows).render() + "\n");
+        if (allPassed) {
+            clm.postStep(" ✅ System requirements check passed  ✅\n");
+            await promptHelper.doYouWishToContinue();
+        }
+        else {
+            clm.warn("System recommendations not met. The validator node may not function properly.\n");
+            await promptHelper.doYouWishToContinue('n');
+        }
+        configStore.setSystemInfo({ cores: numOfCores, disk: totalSpaceGB, memory: totalMemoryGB, platform: os.platform() });
+    }
+};

package/dist/checks/check-initial-setup.d.ts

@@ -0,0 +1,3 @@
+export declare const checkInitialSetup: {
+    firstTimeRun(): Promise<void>;
+};

package/dist/checks/check-initial-setup.js

@@ -0,0 +1,15 @@
+import chalk from "chalk";
+import { configStore } from "../config-store.js";
+import { checkHardware } from "./check-hardware.js";
+export const checkInitialSetup = {
+    async firstTimeRun() {
+        if (configStore.getSystemInfo() !== null) {
+            return;
+        }
+        console.log(chalk.white("\n ****************************************"));
+        console.log("          " + chalk.white("CONSTELLATION NETWORK") + "        ");
+        console.log("               " + chalk.white("NODE PILOT") + "              ");
+        console.log(chalk.white(" ****************************************"));
+        await checkHardware.systemRequirements();
+    },
+};

package/dist/checks/check-layers.d.ts

@@ -0,0 +1,7 @@
+import { TessellationLayer } from "../types.js";
+export declare const checkLayers: {
+    layersReadyToJoin(): Promise<void>;
+    layersRunning(): Promise<void>;
+    layersStatus(): Promise<void>;
+    nodeReadyToJoin(layer: TessellationLayer): Promise<void>;
+};

package/dist/checks/check-layers.js

@@ -0,0 +1,87 @@
+import { input } from "@inquirer/prompts";
+import chalk from "chalk";
+import { clm } from "../clm.js";
+import { configStore } from "../config-store.js";
+import { dockerHelper } from "../helpers/docker-helper.js";
+import { nodeService } from "../services/node-service.js";
+export const checkLayers = {
+    async layersReadyToJoin() {
+        const { layersToRun } = configStore.getProjectInfo();
+        for (const layer of layersToRun) {
+            // eslint-disable-next-line no-await-in-loop
+            await this.nodeReadyToJoin(layer);
+        }
+    },
+    async layersRunning() {
+        const { layersToRun } = configStore.getProjectInfo();
+        const promises = layersToRun.map(l => nodeService.getNodeInfo(l));
+        const results = await Promise.all(promises);
+        const notRunningLayers = results.filter(r => r.state === "Unavailable");
+        if (notRunningLayers.length === layersToRun.length) {
+            const single = layersToRun.length === 1;
+            if (single) {
+                clm.preStep(`The Validator Node is not running.`);
+            }
+            else {
+                clm.preStep(`All the Validator Node layers [${layersToRun}] are not running.`);
+            }
+            await input({ default: 'y', message: 'Would you like to start the validator(s)? (y/n): ' }).then(async (answer) => {
+                if (answer.toLowerCase() === 'y') {
+                    await dockerHelper.dockerBuild();
+                    clm.preStep('Starting the node...');
+                    await dockerHelper.dockerUp();
+                    await nodeService.pollForLayersState(layersToRun);
+                }
+                else {
+                    clm.postStep('Node not started.');
+                }
+            });
+        }
+        else if (notRunningLayers.length > 0) {
+            const layersNotRunning = notRunningLayers.map(r => r.layer);
+            clm.preStep('The following Validator Node layers are not running: ' + chalk.cyan(layersNotRunning.join(', ')));
+            await input({ default: 'y', message: 'Would you like to restart the docker containers? (y/n): ' }).then(async (answer) => {
+                if (answer.toLowerCase() === 'y') {
+                    clm.preStep('Restarting docker containers...');
+                    await dockerHelper.dockerUp();
+                    await nodeService.pollForLayersState(layersToRun);
+                }
+                else {
+                    clm.echo('Node not started.');
+                }
+            });
+        }
+        else {
+            const single = layersToRun.length === 1;
+            if (single) {
+                clm.postStep(`The Validator Node is running.`);
+            }
+            else {
+                clm.postStep(`All Validator Node layers are running: ${layersToRun.join(', ')}.`);
+            }
+        }
+    },
+    async layersStatus() {
+        const { layersToRun } = configStore.getProjectInfo();
+        const promises = layersToRun.map(l => nodeService.getNodeInfo(l));
+        const results = await Promise.all(promises);
+        const states = results.map(r => r.state);
+        clm.preStep("-----------------------");
+        clm.preStep(" VALIDATOR NODE STATUS ");
+        clm.preStep("-----------------------");
+        for (const [i, layer] of layersToRun.entries()) {
+            const state = states[i];
+            clm.step(` "${layer.toUpperCase()}" is "${state}"`);
+        }
+    },
+    async nodeReadyToJoin(layer) {
+        const status = await nodeService.getNodeInfo(layer);
+        if (status.state === "ReadyToJoin") {
+            await input({ default: 'y', message: `The validator node layer "${layer.toUpperCase()}" is ready to join the cluster. Would you like to join now? (y/n): ` }).then(async (answer) => {
+                if (answer.toLowerCase() === 'y') {
+                    await nodeService.joinCluster(layer);
+                }
+            });
+        }
+    },
+};

package/dist/checks/check-network.d.ts

@@ -0,0 +1,6 @@
+export declare const checkNetwork: {
+    configureIpAddress(): Promise<void>;
+    detectExternalIpAddress(): Promise<void>;
+    enterIpAddressManually(): Promise<string>;
+    fetchIPAddress(): Promise<string>;
+};

package/dist/checks/check-network.js

@@ -0,0 +1,72 @@
+import { input, select } from "@inquirer/prompts";
+import chalk from "chalk";
+import { clm } from "../clm.js";
+import { configStore } from "../config-store.js";
+export const checkNetwork = {
+    async configureIpAddress() {
+        const { CL_EXTERNAL_IP: currentIpAddress } = configStore.getEnvCommonInfo();
+        const detectedIpAddress = await checkNetwork.fetchIPAddress().catch(() => '');
+        if (!currentIpAddress && !detectedIpAddress) {
+            const newIpAddress = await checkNetwork.enterIpAddressManually();
+            configStore.setEnvCommonInfo({ CL_EXTERNAL_IP: newIpAddress });
+            return;
+        }
+        if (currentIpAddress) {
+            clm.postStep("\nIP address is currently set to: " + chalk.cyan(currentIpAddress));
+        }
+        if (detectedIpAddress) {
+            clm.postStep("\nDetected IP address: " + chalk.cyan(detectedIpAddress) + "\n");
+        }
+        const choices = [{
+                disabled: !currentIpAddress,
+                name: 'Keep current IP address',
+                value: 'current'
+            }, {
+                disabled: !detectedIpAddress,
+                name: 'Use detected IP address',
+                value: 'detected'
+            }, {
+                name: 'Enter IP address manually:',
+                value: 'manual'
+            }];
+        const answer = await select({ choices, message: '' });
+        let selectedIpAddress = currentIpAddress;
+        if (answer === 'detected') {
+            selectedIpAddress = detectedIpAddress;
+        }
+        else if (answer === 'manual') {
+            selectedIpAddress = await checkNetwork.enterIpAddressManually();
+        }
+        configStore.setEnvCommonInfo({ CL_EXTERNAL_IP: selectedIpAddress });
+    },
+    async detectExternalIpAddress() {
+        const externalIp = await this.fetchIPAddress()
+            .catch(error => {
+            clm.warn(`Error while detecting your IP address: ${error.message}`);
+            return this.enterIpAddressManually();
+        });
+        clm.postStep("\nExternal IP address: " + chalk.cyan(externalIp) + "\n");
+        configStore.setEnvCommonInfo({ CL_EXTERNAL_IP: externalIp });
+    },
+    async enterIpAddressManually() {
+        return input({
+            message: 'Please enter the IP address manually:',
+            validate(value) {
+                // Basic validation for IP address format
+                const ipRegex = /^(?:(?:25[0-5]|2[0-4][0-9]|[01]?[0-9][0-9]?)\.){3}(?:25[0-5]|2[0-4][0-9]|[01]?[0-9][0-9]?)$/;
+                if (ipRegex.test(value.trim())) {
+                    return true;
+                }
+                return 'Please enter a valid IP address (e.g., 192.168.1.1)';
+            }
+        });
+    },
+    async fetchIPAddress() {
+        return fetch('https://ifconfig.me/ip')
+            .then(res => {
+            if (res.ok)
+                return res.text();
+            throw new Error('Failed to fetch IP address');
+        });
+    }
+};

package/dist/checks/check-project.d.ts

@@ -0,0 +1,6 @@
+export declare const checkProject: {
+    projectInstallation(): Promise<void>;
+    releaseVersion(): Promise<void>;
+    runInstall(): Promise<boolean>;
+    runUpgrade(): Promise<void>;
+};

package/dist/checks/check-project.js

@@ -0,0 +1,108 @@
+import { input, select } from "@inquirer/prompts";
+import { clm } from "../clm.js";
+import { configStore } from "../config-store.js";
+import { configHelper } from "../helpers/config-helper.js";
+import { dockerHelper } from "../helpers/docker-helper.js";
+import { promptHelper } from "../helpers/prompt-helper.js";
+import { clusterService } from "../services/cluster-service.js";
+import { nodeService } from "../services/node-service.js";
+import { shellService } from "../services/shell-service.js";
+import { checkNetwork } from "./check-network.js";
+export const checkProject = {
+    async projectInstallation() {
+        let updateNetworkType = false;
+        let updateLayers = false;
+        if (!configStore.hasProjects() || process.env.PILOT_ENV === 'test') {
+            await promptHelper.selectProject();
+            await checkNetwork.configureIpAddress();
+            updateNetworkType = true;
+            updateLayers = true;
+        }
+        const { layersToRun } = configStore.getProjectInfo();
+        const { type } = configStore.getNetworkInfo();
+        if (!type || updateNetworkType) {
+            await promptHelper.selectNetwork();
+            updateLayers = true;
+        }
+        if (!layersToRun || updateLayers) {
+            await promptHelper.selectLayers();
+            await promptHelper.configureJavaMemoryArguments();
+        }
+    },
+    async releaseVersion() {
+        const nInfo = configStore.getNetworkInfo();
+        if (!nInfo.type) {
+            await this.projectInstallation();
+        }
+        let requiresInstall = false;
+        const rInfo = await configHelper.getReleaseInfo();
+        if (!rInfo) {
+            requiresInstall = true;
+        }
+        else if (rInfo.network !== nInfo.type) {
+            clm.preStep(`Network type has changed between user configuration and the node installation`);
+            const selectedNetwork = await select({
+                choices: [
+                    { name: `Keep current (${rInfo.network})`, value: rInfo.network },
+                    { name: `Switch to ${nInfo.type}`, value: nInfo.type }
+                ],
+                message: 'Select network type:'
+            });
+            configStore.setNetworkInfo({
+                type: selectedNetwork,
+                version: selectedNetwork === rInfo.network ? rInfo.version : nInfo.version
+            });
+            if (selectedNetwork !== rInfo.network) {
+                requiresInstall = true;
+            }
+        }
+        else if (rInfo.version !== nInfo.version) {
+            configStore.setNetworkInfo({ type: rInfo.network, version: rInfo.version });
+        }
+        const clusterVersionInfo = await clusterService.getReleaseVersion();
+        if (!requiresInstall) {
+            const nInfo = configStore.getNetworkInfo();
+            if (nInfo.version !== clusterVersionInfo) {
+                const answer = await input({
+                    default: 'y',
+                    message: `A new required network version has been detected. Do you want to upgrade now? (y/n): `
+                });
+                if (answer !== 'y') {
+                    process.exit(0);
+                }
+                requiresInstall = true;
+            }
+        }
+        if (requiresInstall) {
+            await this.runInstall();
+        }
+    },
+    async runInstall() {
+        const nInfo = configStore.getNetworkInfo();
+        let rInfo = await configHelper.getReleaseInfo();
+        if (rInfo && rInfo.network === nInfo.type) {
+            clm.postStep(`Network files are already installed for ${nInfo.type}`);
+            return false;
+        }
+        const nodeInfo = await nodeService.getNodeInfo('first');
+        const isRunning = nodeInfo.state !== 'Unavailable';
+        if (isRunning) {
+            await dockerHelper.dockerDown();
+        }
+        clm.preStep('Running install script...');
+        const silent = false; // !process.env.DEBUG;
+        await shellService.runCommand(`scripts/install.sh ${nInfo.type}`, undefined, silent); // different for metagraphs
+        rInfo = await configHelper.getReleaseInfo();
+        configStore.setNetworkInfo({
+            type: rInfo.network,
+            version: rInfo.version
+        });
+        return true;
+    },
+    async runUpgrade() {
+        const changed = await this.runInstall();
+        if (changed) {
+            await dockerHelper.dockerBuild();
+        }
+    }
+};

package/dist/clm.d.ts

@@ -0,0 +1,9 @@
+export declare const clm: {
+    debug(msg: string): void;
+    echo(msg: string): void;
+    error(msg: string, silent?: boolean): never;
+    postStep(s: string): void;
+    preStep(s: string): void;
+    step(msg: string): void;
+    warn(msg: string): void;
+};

package/dist/clm.js

@@ -0,0 +1,30 @@
+import chalk from "chalk";
+/*
+    Command Line Messaging with color styling
+ */
+export const clm = {
+    debug(msg) {
+        if (process.env.DEBUG === 'true') {
+            console.log('[debug]', msg);
+        }
+    },
+    echo(msg) {
+        console.log(msg);
+    },
+    error(msg, silent = true) {
+        console.error(chalk.red(msg));
+        process.exit(silent ? 0 : 1);
+    },
+    postStep(s) {
+        console.log(chalk.green(s));
+    },
+    preStep(s) {
+        console.log('\n', chalk.italic(chalk.green(s)));
+    },
+    step(msg) {
+        console.warn(chalk.whiteBright(msg));
+    },
+    warn(msg) {
+        console.warn(chalk.red(msg));
+    }
+};

package/dist/commands/config/get.d.ts

@@ -0,0 +1,9 @@
+import { Command } from '@oclif/core';
+export default class ConfigGet extends Command {
+    static args: {
+        name: import("@oclif/core/interfaces").Arg<string | undefined, Record<string, unknown>>;
+    };
+    static description: string;
+    static examples: string[];
+    run(): Promise<void>;
+}