@constellation-network/node-pilot 0.0.1

package/dist/helpers/config-helper.js

@@ -0,0 +1,39 @@
+import chalk from "chalk";
+import dotenv from "dotenv";
+import fs from "node:fs";
+import path from "node:path";
+import { clm } from "../clm.js";
+import { configStore } from "../config-store.js";
+export const configHelper = {
+    assertProject(prefix = '') {
+        if (configStore.hasProjects())
+            return;
+        clm.error(prefix + 'Please create a new project first.');
+    },
+    async getReleaseInfo() {
+        const { projectDir } = configStore.getProjectInfo();
+        const lastInstallVersion = path.resolve(projectDir, "dist/version.sh");
+        if (!fs.existsSync(lastInstallVersion)) {
+            return;
+        }
+        const versionObj = this.parseEnvFile(lastInstallVersion);
+        return {
+            network: versionObj.RELEASE_NETWORK_TYPE,
+            version: versionObj.RELEASE_NETWORK_VERSION
+        };
+    },
+    parseEnvFile(filePath) {
+        const fileStr = fs.readFileSync(filePath, 'utf8');
+        return dotenv.parse(fileStr);
+    },
+    showEnvInfo(name, value) {
+        console.log(`${chalk.white(name)}=${chalk.cyan(value)}`);
+    },
+    showEnvInfoList(list) {
+        const formatted = list.map(i => {
+            const value = (i.name === 'CL_PASSWORD') ? '************' : i.value;
+            return `${chalk.white(i.name)}=${chalk.cyan(value || '')}`;
+        }).join('\n');
+        console.log(formatted);
+    }
+};

package/dist/helpers/docker-helper.d.ts

@@ -0,0 +1,7 @@
+export declare const dockerHelper: {
+    dockerBuild(): Promise<void>;
+    dockerDown(): Promise<void>;
+    dockerRestart(): Promise<void>;
+    dockerUp(): Promise<void>;
+    isRunning(): Promise<boolean>;
+};

package/dist/helpers/docker-helper.js

@@ -0,0 +1,37 @@
+import { clm } from "../clm.js";
+import { configStore } from "../config-store.js";
+import { shellService } from "../services/shell-service.js";
+import { projectHelper } from "./project-helper.js";
+export const dockerHelper = {
+    async dockerBuild() {
+        if (shellService.existsScript('scripts/docker-build.sh')) {
+            clm.preStep('Building the node container...');
+            await shellService.runCommand('bash scripts/docker-build.sh');
+        }
+    },
+    async dockerDown() {
+        await run('down');
+    },
+    async dockerRestart() {
+        await run('restart');
+    },
+    async dockerUp() {
+        // If docker is already running, stop it
+        if (await this.isRunning()) {
+            await this.dockerDown();
+        }
+        await projectHelper.generateLayerEnvFiles();
+        // const userId = await shellService.runCommandWithOutput('echo "$(id -u):$(id -g)"')
+        // console.log('Setting DOCKER_USER_ID to', userId);
+        // configStore.setDockerEnvInfo({ DOCKER_USER_ID: userId });
+        await run('up -d');
+    },
+    async isRunning() {
+        return shellService.runCommand('docker ps | grep entrypoint.sh', undefined, true).then(() => true).catch(() => false);
+    }
+};
+function run(command, layers) {
+    const { layersToRun } = configStore.getProjectInfo();
+    const args = (layers || layersToRun).map(l => `--profile ${l}`).join(' ');
+    return shellService.runCommand(`docker compose ${args} ${command}`, configStore.getDockerEnvInfo());
+}

package/dist/helpers/env-templates.d.ts

@@ -0,0 +1,4 @@
+import { EnvCommonInfo, EnvLayerInfo, NetworkType } from "../config-store.js";
+import { TessellationLayer } from "../types.js";
+export declare function getLayerEnvFileContent(layer: TessellationLayer, network: NetworkType, commonInfo: EnvCommonInfo, layerInfo: EnvLayerInfo): string;
+export declare function getKeyFileContent(commonInfo: EnvCommonInfo): string;

package/dist/helpers/env-templates.js

@@ -0,0 +1,33 @@
+export function getLayerEnvFileContent(layer, network, commonInfo, layerInfo) {
+    return `
+# Node
+CL_EXTERNAL_IP=${commonInfo.CL_EXTERNAL_IP}
+CL_DOCKER_JAVA_OPTS="${layerInfo.CL_DOCKER_JAVA_OPTS}"
+CL_KEYSTORE="/app/key.p12"
+CL_KEYALIAS="${commonInfo.CL_KEYALIAS}"
+CL_PASSWORD="${commonInfo.CL_PASSWORD}"
+CL_TESSELATION_LAYER=${layer}
+
+# NETWORK
+CL_APP_ENV=${commonInfo.CL_APP_ENV}
+CL_COLLATERAL=${network === 'mainnet' ? 25000000000000 : 0}
+CL_L0_PEER_HTTP_PORT=${commonInfo.CL_L0_PEER_HTTP_PORT}
+CL_L0_PEER_HTTP_HOST=${commonInfo.CL_L0_PEER_HTTP_HOST}
+CL_L0_PEER_ID=${commonInfo.CL_L0_PEER_ID}
+CL_GLOBAL_L0_PEER_HTTP_PORT=${commonInfo.CL_GLOBAL_L0_PEER_HTTP_PORT}
+CL_GLOBAL_L0_PEER_HOST=${commonInfo.CL_GLOBAL_L0_PEER_HOST}
+CL_GLOBAL_L0_PEER_ID=${commonInfo.CL_GLOBAL_L0_PEER_ID}
+
+# LAYER
+CL_PUBLIC_HTTP_PORT=${layerInfo.CL_PUBLIC_HTTP_PORT}
+CL_P2P_HTTP_PORT=${layerInfo.CL_P2P_HTTP_PORT}
+CL_CLI_HTTP_PORT=${layerInfo.CL_CLI_HTTP_PORT}
+`;
+}
+export function getKeyFileContent(commonInfo) {
+    return `
+export CL_KEYSTORE="${commonInfo.CL_KEYSTORE}"
+export CL_KEYALIAS="${commonInfo.CL_KEYALIAS}"
+export CL_PASSWORD="${commonInfo.CL_PASSWORD}"
+`;
+}

package/dist/helpers/github-helper.d.ts

@@ -0,0 +1,3 @@
+export declare const githubHelper: {
+    hasAssetInRelease(assetName: string, repo: string): Promise<boolean>;
+};

package/dist/helpers/github-helper.js

@@ -0,0 +1,13 @@
+export const githubHelper = {
+    hasAssetInRelease(assetName, repo) {
+        return fetch(`https://api.github.com/repos/${repo}/releases/latest`)
+            .then(async (res) => {
+            if (res.ok) {
+                const json = await res.json();
+                return json.assets.some(a => a.name.includes(assetName));
+            }
+            return false;
+        })
+            .catch(() => false);
+    }
+};

package/dist/helpers/key-file-helper.d.ts

@@ -0,0 +1,9 @@
+export declare const keyFileHelper: {
+    generate(): Promise<void>;
+    getAddress(): Promise<string>;
+    getId(): Promise<string>;
+    importKeyFile(): Promise<void>;
+    promptForKeyFile(): Promise<void>;
+    promptIfNoKeyFile(): Promise<void>;
+    showKeyFileInfo(prompt4ShowPassword?: boolean): Promise<void>;
+};

package/dist/helpers/key-file-helper.js

@@ -0,0 +1,136 @@
+import { input, password, select } from "@inquirer/prompts";
+import chalk from "chalk";
+import fs from "node:fs";
+import os from "node:os";
+import path from "node:path";
+import { clm } from "../clm.js";
+import { configStore } from "../config-store.js";
+import { shellService } from "../services/shell-service.js";
+import { configHelper } from "./config-helper.js";
+import { getKeyFileContent } from "./env-templates.js";
+export const keyFileHelper = {
+    async generate() {
+        const { projectDir } = configStore.getProjectInfo();
+        const keyFilePath = path.join(projectDir, "key.p12");
+        if (fs.existsSync(keyFilePath)) {
+            const answer = await input({ default: 'n', message: 'A key file already exists. Do you want to overwrite it? (y/n): ' });
+            if (answer.toLowerCase() === 'y') {
+                fs.rmSync(keyFilePath, { force: true });
+            }
+            else {
+                clm.echo('Key file generation cancelled.');
+                process.exit(0);
+            }
+        }
+        const keyPassword = await password({ message: 'Enter the key file password:', validate: value => value.length > 0 });
+        const env = {
+            CL_KEYALIAS: "alias", CL_KEYSTORE: keyFilePath, CL_PASSWORD: keyPassword
+        };
+        await shellService.runCommand(`java -jar ${projectDir}/dist/keytool.jar generate`, env);
+        configStore.setEnvCommonInfo(env);
+        const dagAddress = await this.getAddress();
+        const nodeId = await this.getId();
+        configStore.setProjectInfo({ dagAddress, nodeId });
+        clm.postStep('Key file generated successfully.\n');
+        const answer = await input({ default: 'y', message: 'Would you like to save a backup of the key file to your home directory? (y/n): ' });
+        if (answer.toLowerCase() === 'y') {
+            fs.cpSync(keyFilePath, path.join(os.homedir(), 'key.p12'));
+            fs.writeFileSync(path.join(os.homedir(), 'key-env.sh'), getKeyFileContent({ ...env, CL_KEYSTORE: 'key.p12' }));
+            clm.postStep(`A copy of the Key file has been saved to your home directory - ${chalk.cyan(path.join(os.homedir(), 'key.p12'))}`);
+        }
+    },
+    async getAddress() {
+        const { projectDir } = configStore.getProjectInfo();
+        const env = configStore.getEnvCommonInfo();
+        return shellService.runCommandWithOutput(`java -jar ${projectDir}/dist/wallet.jar show-address`, env);
+    },
+    async getId() {
+        const { projectDir } = configStore.getProjectInfo();
+        const env = configStore.getEnvCommonInfo();
+        return shellService.runCommandWithOutput(`java -jar ${projectDir}/dist/wallet.jar show-id`, env);
+    },
+    async importKeyFile() {
+        const userKeyPath = await input({
+            message: 'Enter the path to your key file:',
+            validate(value) {
+                const fullPath = shellService.resolvePath(value.trim());
+                if (!fs.existsSync(fullPath)) {
+                    return `${fullPath} does not exist. Please provide a valid path.`;
+                }
+                return true;
+            }
+        });
+        const { projectDir } = configStore.getProjectInfo();
+        const fullPath = shellService.resolvePath(userKeyPath.trim());
+        const keyStorePath = path.join(projectDir, "key.p12");
+        try {
+            fs.copyFileSync(fullPath, keyStorePath);
+        }
+        catch (error) {
+            clm.error('Failed to import key file:' + error);
+        }
+        // prompt for password
+        const keyPassword = await password({ message: 'Enter the key file password:' });
+        const keyAlias = await input({ message: 'Enter the key file alias:' });
+        configStore.setEnvCommonInfo({ CL_KEYALIAS: keyAlias, CL_KEYSTORE: keyStorePath, CL_PASSWORD: keyPassword });
+        try {
+            const dagAddress = await this.getAddress();
+            const nodeId = await this.getId();
+            configStore.setProjectInfo({ dagAddress, nodeId });
+        }
+        catch {
+            clm.warn('Failed to unlock the key file. Please check your key file information and try again.');
+            fs.rmSync(keyStorePath);
+            await this.promptForKeyFile();
+            return;
+        }
+        clm.postStep('Key file imported successfully.\n');
+    },
+    async promptForKeyFile() {
+        const choices = [
+            { name: 'Generate a new key file', value: 'generate' },
+            { name: 'Import an existing key file', value: 'import' }
+        ];
+        const { projectDir } = configStore.getProjectInfo();
+        const keyFilePath = path.join(projectDir, "key.p12");
+        if (fs.existsSync(keyFilePath)) {
+            choices.push({ name: 'Skip', value: 'skip' });
+        }
+        else {
+            clm.preStep('A key file is required to run the node.');
+        }
+        const answer = await select({ choices, message: 'Choose an option:' });
+        if (answer === 'generate') {
+            await this.generate();
+            await this.showKeyFileInfo();
+        }
+        else if (answer === 'import') {
+            await this.importKeyFile();
+            await this.showKeyFileInfo(false);
+        }
+    },
+    async promptIfNoKeyFile() {
+        const { projectDir } = configStore.getProjectInfo();
+        const keyFilePath = path.join(projectDir, "key.p12");
+        if (fs.existsSync(keyFilePath)) {
+            return;
+        }
+        await this.promptForKeyFile();
+    },
+    async showKeyFileInfo(prompt4ShowPassword = true) {
+        clm.preStep('Key File Information:');
+        const { dagAddress, nodeId } = configStore.getProjectInfo();
+        configHelper.showEnvInfo('Node ID', nodeId);
+        configHelper.showEnvInfo('DAG Address', dagAddress);
+        const { CL_KEYALIAS, CL_KEYSTORE, CL_PASSWORD } = configStore.getEnvCommonInfo();
+        configHelper.showEnvInfo('CL_KEYSTORE', CL_KEYSTORE || '');
+        configHelper.showEnvInfo('CL_KEYALIAS', CL_KEYALIAS || '');
+        configHelper.showEnvInfo('CL_PASSWORD', '*********');
+        if (prompt4ShowPassword) {
+            const show = await input({ default: 'n', message: 'Show the password for the key file (y/n):' });
+            if (show === 'y') {
+                configHelper.showEnvInfo('CL_PASSWORD', CL_PASSWORD || '');
+            }
+        }
+    }
+};

package/dist/helpers/project-helper.d.ts

@@ -0,0 +1,9 @@
+import { TessellationLayer } from "../types.js";
+export declare const projectHelper: {
+    generateLayerEnvFiles(layers?: TessellationLayer[]): Promise<void>;
+    importLayerEnvFiles(): Promise<void>;
+    importNetworkEnvFiles(): Promise<void>;
+    installEmbedded(name: string): Promise<void>;
+    installFromGithub(_repo: string): Promise<never>;
+    installHypergraph(): Promise<void>;
+};

package/dist/helpers/project-helper.js

@@ -0,0 +1,85 @@
+import fs from "node:fs";
+import path from "node:path";
+import { fileURLToPath } from 'node:url';
+import { clm } from "../clm.js";
+import { configStore } from "../config-store.js";
+import { configHelper } from "./config-helper.js";
+import { getLayerEnvFileContent } from "./env-templates.js";
+export const projectHelper = {
+    async generateLayerEnvFiles(layers) {
+        const { layersToRun, projectDir } = configStore.getProjectInfo();
+        const { type } = configStore.getNetworkInfo();
+        const commonInfo = configStore.getEnvCommonInfo();
+        layers = layers || layersToRun;
+        for (const n of layers) {
+            const filePath = path.join(projectDir, `${n}.env`);
+            const envInfo = configStore.getEnvLayerInfo(n);
+            const fileContents = getLayerEnvFileContent(n, type, commonInfo, envInfo);
+            clm.debug(`Writing layer env file: ${filePath}`);
+            fs.writeFileSync(filePath, fileContents);
+        }
+    },
+    async importLayerEnvFiles() {
+        const { projectDir } = configStore.getProjectInfo();
+        const possibleLayers = ['gl0', 'gl1', 'ml0', 'cl1', 'dl1'];
+        for (const n of possibleLayers) {
+            const filePath = path.join(projectDir, 'layers', `${n}.env`);
+            if (fs.existsSync(filePath)) {
+                configStore.setEnvLayerInfo(n, configHelper.parseEnvFile(filePath));
+            }
+        }
+    },
+    async importNetworkEnvFiles() {
+        const { projectDir } = configStore.getProjectInfo();
+        const possibleNetworks = ['mainnet', 'testnet', 'integrationnet'];
+        const supportedTypes = [];
+        const networkEnvInfo = {};
+        for (const n of possibleNetworks) {
+            const filePath = path.join(projectDir, 'networks', `${n}.env`);
+            if (fs.existsSync(filePath)) {
+                supportedTypes.push(n);
+                networkEnvInfo[n] = configHelper.parseEnvFile(filePath);
+            }
+        }
+        if (supportedTypes.length === 0) {
+            clm.error('No supported networks found in the project folder.');
+        }
+        configStore.setNetworkInfo({ supportedTypes });
+        configStore.setNetworkEnvInfo(networkEnvInfo);
+        // eslint-disable-next-line no-warning-comments
+        // TODO: verify all required env variables are present
+    },
+    async installEmbedded(name) {
+        const projectFolder = path.resolve(path.dirname(fileURLToPath(import.meta.url)), `../../projects/${name}`);
+        if (!fs.existsSync(projectFolder)) {
+            clm.error(`Project folder not found: ${projectFolder}`);
+        }
+        await configStore.applyNewProjectStore(name);
+        const { projectDir } = configStore.getProjectInfo();
+        clm.debug(`Installing project from ${projectFolder} to ${projectDir}`);
+        fs.cpSync(projectFolder, projectDir, { recursive: true });
+    },
+    //  curl -s https://api.github.com/repos/Constellation-Labs/pacaswap-metagraph/releases/latest | jq -r '.assets[] | select(.name | contains("node-pilot"))'
+    //  use .tag_name for the release version
+    async installFromGithub(_repo) {
+        throw new Error('installFromGithub - Not implemented');
+    },
+    async installHypergraph() {
+        await this.installEmbedded('hypergraph');
+        const { projectDir } = configStore.getProjectInfo();
+        // Create app-data folders for fast forward feature before Docker does
+        const gl0DataDir = path.join(projectDir, 'app-data', 'gl0-data');
+        fs.mkdirSync(path.join(gl0DataDir, 'incremental_snapshot'), { recursive: true });
+        fs.mkdirSync(path.join(gl0DataDir, 'snapshot_info'));
+        fs.mkdirSync(path.join(gl0DataDir, 'tmp'));
+        // Set hypergraph layer defaults
+        configStore.setEnvLayerInfo('gl0', {
+            CL_CLI_HTTP_PORT: '9002', CL_DOCKER_JAVA_OPTS: '-Xms1024M -Xmx7G -Xss256K', CL_P2P_HTTP_PORT: '9001', CL_PUBLIC_HTTP_PORT: '9000'
+        });
+        configStore.setEnvLayerInfo('gl1', {
+            CL_CLI_HTTP_PORT: '9102', CL_DOCKER_JAVA_OPTS: '-Xms1024M -Xmx3G -Xss256K', CL_P2P_HTTP_PORT: '9101', CL_PUBLIC_HTTP_PORT: '9100'
+        });
+        await this.importNetworkEnvFiles();
+        await this.importLayerEnvFiles();
+    }
+};

package/dist/helpers/prompt-helper.d.ts

@@ -0,0 +1,8 @@
+export declare const promptHelper: {
+    configureAutoRestart(): Promise<void>;
+    configureJavaMemoryArguments(): Promise<void>;
+    doYouWishToContinue(defaultAnswer?: "n" | "y"): Promise<void>;
+    selectLayers(): Promise<void>;
+    selectNetwork(): Promise<void>;
+    selectProject(): Promise<void>;
+};

package/dist/helpers/prompt-helper.js

@@ -0,0 +1,135 @@
+import { checkbox, input, number, select } from "@inquirer/prompts";
+import chalk from "chalk";
+import { clm } from "../clm.js";
+import { configStore } from "../config-store.js";
+import { githubHelper } from "./github-helper.js";
+import { projectHelper } from "./project-helper.js";
+export const promptHelper = {
+    async configureAutoRestart() {
+        const answer = await input({
+            default: 'y',
+            message: 'Do you want to enable auto-restart? (y/n): '
+        });
+        configStore.setProjectInfo({ autoRestart: answer === 'y' });
+    },
+    async configureJavaMemoryArguments() {
+        const { memory } = configStore.getSystemInfo();
+        const { layersToRun, name } = configStore.getProjectInfo();
+        const xmx = Number(memory);
+        if (xmx === 8 && layersToRun.length > 1) {
+            clm.warn('Minimum 8GB memory detected. Only a single layer will be allowed to run');
+            await promptHelper.doYouWishToContinue();
+            configStore.setProjectInfo({ layersToRun: [layersToRun[0]] });
+            configStore.setEnvLayerInfo(layersToRun[0], { CL_DOCKER_JAVA_OPTS: '-Xms1024M -Xmx7G -Xss256K' });
+        }
+        else if (name === 'hypergraph') {
+            // prompt to use all detected memory
+            let answer = await number({
+                default: xmx - 1,
+                message: `How much of the detected memory (${xmx}GB) do you want to use?: `,
+                validate: v => v !== undefined && v >= 4 && v <= xmx
+            });
+            if (answer === xmx)
+                answer--;
+            const subLayerMem = layersToRun.length > 1 ? Math.floor(answer / 3) : 0;
+            const mainLayerMem = answer - subLayerMem;
+            clm.postStep(`${layersToRun[0]} memory allocation: ${mainLayerMem}GB`);
+            configStore.setEnvLayerInfo(layersToRun[0], { CL_DOCKER_JAVA_OPTS: `-Xms1024M -Xmx${mainLayerMem}G -Xss256K` });
+            if (subLayerMem) {
+                clm.postStep(`${layersToRun[1]} memory allocation: ${subLayerMem}GB`);
+                configStore.setEnvLayerInfo(layersToRun[1], { CL_DOCKER_JAVA_OPTS: `-Xms1024M -Xmx${subLayerMem}G -Xss256K` });
+            }
+        }
+    },
+    async doYouWishToContinue(defaultAnswer = 'y') {
+        const result = await input({
+            default: defaultAnswer,
+            message: 'Do you wish to continue? (y/n)',
+            validate(value) {
+                if (value.toLowerCase() === 'y' || value.toLowerCase() === 'n') {
+                    return true;
+                }
+                return 'Please enter "y" or "n"';
+            }
+        });
+        if (result.toLowerCase() === 'n') {
+            process.exit(0);
+        }
+    },
+    async selectLayers() {
+        const { name } = configStore.getProjectInfo();
+        const choices = name === 'hypergraph' ? ['gl0', 'gl1'] : ['ml0', 'cl1', 'dl1'];
+        const result = await checkbox({ choices, message: `Select network layers to run for ${chalk.cyan(name)}:`, validate: v => v.length > 0 });
+        configStore.setProjectInfo({ layersToRun: result });
+    },
+    async selectNetwork() {
+        const { supportedTypes } = configStore.getNetworkInfo();
+        if (supportedTypes.length === 0) {
+            throw new Error('No supported networks found');
+        }
+        if (supportedTypes.length === 1) {
+            configStore.setNetworkInfo({ type: supportedTypes[0], version: "latest" });
+            configStore.setEnvCommonInfo(configStore.getNetworkEnvInfo(supportedTypes[0]));
+            return;
+        }
+        const networkType = await select({
+            choices: [
+                { disabled: !supportedTypes.includes('mainnet'), name: 'Mainnet', value: 'mainnet' },
+                { disabled: !supportedTypes.includes('testnet'), name: 'Testnet', value: 'testnet' },
+                { disabled: !supportedTypes.includes('integrationnet'), name: 'Integrationnet', value: 'integrationnet' }
+            ],
+            message: 'Select network type:'
+        });
+        configStore.setNetworkInfo({ type: networkType, version: "latest" });
+        configStore.setEnvCommonInfo(configStore.getNetworkEnvInfo(networkType));
+    },
+    async selectProject() {
+        // prompt user to install hypergraph or metagraph
+        const networkType = await select({
+            choices: [
+                { name: 'Hypergraph (Global layer)', value: 'hypergraph' },
+                { disabled: true, name: 'Metagraph (Dor, Pacaswap, and more)', value: 'metagraph' },
+            ],
+            message: 'Select network:'
+        });
+        if (networkType === 'hypergraph') {
+            await projectHelper.installHypergraph();
+        }
+        else if (networkType === 'metagraph') {
+            const project = await select({
+                choices: [
+                    { name: 'Dor', value: 'dor' },
+                    { name: 'Custom (Enter repo)', value: 'custom' },
+                ],
+                message: 'Select metagraph:'
+            });
+            const ghRepoRegex = /^https?:\/\/(?:www\.)?github\.com\/([A-Za-z0-9](?:-?[A-Za-z0-9]){0,38})\/([A-Za-z0-9._-]+)(?:\.git)?\/?$/;
+            if (project === 'dor') {
+                await projectHelper.installEmbedded('dor');
+            }
+            else if (project === 'custom') {
+                let repo = await input({
+                    message: `Enter Github repository URL:`,
+                    validate(value) {
+                        const m = value.trim().match(ghRepoRegex);
+                        if (m)
+                            return true;
+                        return 'Please enter a valid Github repo URL (e.g., https://github.com/user/repo or .git)';
+                    }
+                });
+                if (repo.endsWith('.git'))
+                    repo = repo.slice(0, -4);
+                const m = repo.trim().match(ghRepoRegex);
+                const userRepo = `${m[1]}/${m[2]}`; // owner/repo
+                clm.preStep(`Installing from Github repository: ${chalk.cyan(userRepo)}`);
+                if (await githubHelper.hasAssetInRelease('node-pilot', userRepo)) {
+                    await projectHelper.installFromGithub(userRepo);
+                }
+                else {
+                    clm.warn(`The repository ${repo} does not contain a release asset with the name "node-pilot"`);
+                    await this.selectProject();
+                }
+            }
+        }
+    }
+};

package/dist/index.d.ts

@@ -0,0 +1 @@
+export { run } from '@oclif/core';

package/dist/index.js

@@ -0,0 +1 @@
+export { run } from '@oclif/core';

package/dist/info/cluster-info.d.ts

@@ -0,0 +1 @@
+export {};

package/dist/info/cluster-info.js

@@ -0,0 +1,16 @@
+/* DISPLAY INFORMATION ABOUT THE CLUSTER
+1. number of nodes in cluster
+2. your node id
+3. is your node included in seedlist
+4. is your node in the cluster
+6. version of the node
+ */
+export {};
+/* Verify cluster information (Health-check)
+
+1. version match
+2. included in seedlist
+3. included in cluster
+4. majority ordinal
+5. majority snapshot hash matches
+*/

package/dist/services/cluster-service.d.ts

@@ -0,0 +1,9 @@
+import { ClusterInfo, NodeInfo } from "../types.js";
+export declare const clusterService: {
+    fastForwardSnapshot(): Promise<void>;
+    getClusterInfo(): Promise<ClusterInfo[]>;
+    getLatestOrdinal(): Promise<any>;
+    getNodeInfo(): Promise<NodeInfo>;
+    getReleaseVersion(): Promise<string>;
+    getSourceNodeInfo(): Promise<NodeInfo>;
+};

package/dist/services/cluster-service.js

@@ -0,0 +1,67 @@
+import { input } from "@inquirer/prompts";
+import { configStore } from "../config-store.js";
+import { FastforwardService } from "./fastforward-service.js";
+export const clusterService = {
+    async fastForwardSnapshot() {
+        const { fastForward } = configStore.getProjectInfo();
+        if (fastForward === false) {
+            return;
+        }
+        if (!configStore.getProjectInfo().layersToRun.includes('gl0')) {
+            return;
+        }
+        if (fastForward === undefined) {
+            const answer = await input({
+                default: 'y', message: 'Do you want to use the snapshot fast forward feature? (y/n): '
+            });
+            if (answer !== 'y') {
+                configStore.setProjectInfo({ fastForward: false });
+                return;
+            }
+            configStore.setProjectInfo({ fastForward: true });
+        }
+        await FastforwardService.synctoLatestSnapshot();
+    },
+    async getClusterInfo() {
+        const { type } = configStore.getNetworkInfo();
+        return fetch(`https://l0-lb-${type}.constellationnetwork.io/cluster/info`)
+            .then(res => {
+            if (res.ok)
+                return res.json();
+            throw new Error(`Failed`);
+        })
+            .catch(() => []);
+    },
+    async getLatestOrdinal() {
+        const { type } = configStore.getNetworkInfo();
+        return fetch(`https://l0-lb-${type}.constellationnetwork.io/global-snapshots/latest`)
+            .then(res => {
+            if (res.ok)
+                return res.json().then(i => (i?.value?.ordinal || 0));
+            return 0;
+        })
+            .catch(() => 0);
+    },
+    async getNodeInfo() {
+        const { type } = configStore.getNetworkInfo();
+        return fetch(`https://l0-lb-${type}.constellationnetwork.io/node/info`)
+            .then(res => {
+            if (res.ok)
+                return res.json();
+            throw new Error(`Failed`);
+        })
+            .catch(() => ({ state: "Unavailable" }));
+    },
+    async getReleaseVersion() {
+        return this.getNodeInfo().then(i => i.version);
+    },
+    async getSourceNodeInfo() {
+        const { CL_L0_PEER_HTTP_HOST, CL_L0_PEER_HTTP_PORT } = configStore.getEnvCommonInfo();
+        return fetch(`http://${CL_L0_PEER_HTTP_HOST}:${CL_L0_PEER_HTTP_PORT}/node/info`)
+            .then(res => {
+            if (res.ok)
+                return res.json();
+            throw new Error(`Failed`);
+        });
+    }
+};

package/dist/services/fastforward-service.d.ts

@@ -0,0 +1,14 @@
+import 'json-bigint-patch';
+export declare class FastforwardService {
+    private readonly dataDir;
+    private readonly lbUrl;
+    private readonly network;
+    private readonly tmpDir;
+    constructor();
+    static synctoLatestSnapshot(): Promise<void>;
+    runFastForwardSnapshot(): Promise<void>;
+    private fetchLatestSnapshot;
+    private fetchSnapshot;
+    private fetchSnapshotHash;
+    private saveSnapshotFiles;
+}