@constellation-network/node-pilot 0.0.8 → 0.0.10

package/dist/helpers/prompt-helper.js

@@ -3,22 +3,16 @@ import chalk from "chalk";
 import { clm } from "../clm.js";
 import { configStore } from "../config-store.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 { type: currentNetwork } = configStore.getNetworkInfo();
         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' });
+            configStore.setEnvLayerInfo(currentNetwork, layersToRun[0], { CL_DOCKER_JAVA_OPTS: '-Xms1024M -Xmx7G -Xss256K' });
         }
         else if (name === 'hypergraph') {
             // prompt to use all detected memory
@@ -31,11 +25,16 @@ export const promptHelper = {
                 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` });
+            const { supportedTypes } = configStore.getNetworkInfo();
+            for (const type of supportedTypes) {
+                const network = type.toUpperCase();
+                const logMethod = type === currentNetwork ? clm.postStep : clm.debug;
+                logMethod(`${network}:: ${layersToRun[0]} memory allocation: ${mainLayerMem}GB`);
+                configStore.setEnvLayerInfo(type, layersToRun[0], { CL_DOCKER_JAVA_OPTS: `-Xms1024M -Xmx${mainLayerMem}G -Xss256K` });
+                if (subLayerMem) {
+                    logMethod(`${network}:: ${layersToRun[1]} memory allocation: ${subLayerMem}GB`);
+                    configStore.setEnvLayerInfo(type, layersToRun[1], { CL_DOCKER_JAVA_OPTS: `-Xms1024M -Xmx${subLayerMem}G -Xss256K` });
+                }
             }
         }
     },
@@ -67,7 +66,7 @@ export const promptHelper = {
         }
         if (supportedTypes.length === 1) {
             configStore.setNetworkInfo({ type: supportedTypes[0], version: "latest" });
-            configStore.setEnvCommonInfo(configStore.getNetworkEnvInfo(supportedTypes[0]));
+            // configStore.setEnvNetworkInfo(configStore.getNetworkEnvInfo(supportedTypes[0]));
             return;
         }
         const networkType = await select({
@@ -79,6 +78,7 @@ export const promptHelper = {
             message: 'Select network type:'
         });
         configStore.setNetworkInfo({ type: networkType, version: "latest" });
-        configStore.setEnvCommonInfo(configStore.getNetworkEnvInfo(networkType));
+        configStore.setProjectFlag('duplicateNodeIdChecked', false);
+        configStore.setProjectFlag('seedListChecked', false);
     }
 };

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

@@ -0,0 +1,17 @@
+export declare const archiverService: {
+    checkLogsForMissingSnapshots(): Promise<void>;
+    getArchiveSnapshotInfo(): Promise<{
+        clusterOrdinal: number;
+        distance: number;
+        endOrdinal: number;
+        startOrdinal: number;
+        total: number;
+        url: string;
+    }>;
+    getDownloadedSnapshotRange(): {
+        chunkOrdinal: number;
+        endOrdinal: number;
+        startOrdinal: number;
+    };
+    syncToLatestSnapshot(): Promise<void>;
+};

package/dist/services/archiver-service.js

@@ -0,0 +1,104 @@
+import chalk from "chalk";
+import fs from "node:fs";
+import path from "node:path";
+import { clm } from "../clm.js";
+import { configStore } from "../config-store.js";
+import { clusterService } from "./cluster-service.js";
+import { FastforwardService } from "./fastforward-service.js";
+import { shellService } from "./shell-service.js";
+// http://5.161.243.241:7777/hash.txt
+const remoteIndexMap = {
+    integrationnet: "http://5.161.243.241:7777",
+    mainnet: "http://128.140.33.142:7777",
+    testnet: "http://65.108.87.84:7777"
+};
+export const archiverService = {
+    async checkLogsForMissingSnapshots() {
+        const { projectDir } = configStore.getProjectInfo();
+        const dataDir = path.join(projectDir, 'app-data', 'gl0-logs', 'app.log');
+        const result = await shellService.runCommandWithOutput(`grep -i 'Global snapshot not found for ordinal' ${dataDir}`).catch(() => '');
+        let oldestOrdinal = Number.MAX_SAFE_INTEGER;
+        for (const line of result.split('\n')) {
+            const number = line.match(/\d+/);
+            if (number) {
+                oldestOrdinal = Math.min(oldestOrdinal, Number(number[0]));
+            }
+        }
+        console.log(`Oldest ordinal: ${oldestOrdinal}`);
+    },
+    async getArchiveSnapshotInfo() {
+        const { type } = configStore.getNetworkInfo();
+        const clusterOrdinal = await clusterService.getSourceNodeLatestOrdinal('gl0');
+        return fetch(remoteIndexMap[type] + '/hash.txt')
+            .then(res => res.text())
+            .then(txt => {
+            const lines = txt.trim().split('\n');
+            const lastLine = lines.at(-1);
+            const filename = lastLine.split(' ')[1];
+            const parseName = filename.split('.')[0].split('-');
+            const startOrdinal = Number(parseName.at(1)?.slice(1));
+            const endOrdinal = parseName.length < 4 ? startOrdinal + 20_000 - 1 : Number(parseName.at(3)?.slice(1));
+            const distance = clusterOrdinal - endOrdinal;
+            const total = endOrdinal - startOrdinal + 1;
+            clm.debug(`Cluster Ordinal: ${chalk.yellow(clusterOrdinal)}, Archive End Ordinal: ${chalk.yellow(endOrdinal)}, Total Archive Snapshots: ${chalk.yellow(total)}, Distance: ${chalk.yellow(distance)}`);
+            return { clusterOrdinal, distance, endOrdinal, startOrdinal, total, url: remoteIndexMap[type] + '/' + filename };
+        });
+    },
+    getDownloadedSnapshotRange() {
+        const { projectDir } = configStore.getProjectInfo();
+        const dataDir = path.join(projectDir, 'app-data', 'gl0-data', 'incremental_snapshot', 'ordinal');
+        const result = { chunkOrdinal: 0, endOrdinal: 0, startOrdinal: 0 };
+        if (!fs.existsSync(dataDir)) {
+            return result;
+        }
+        // get last filename in directory
+        let files = fs.readdirSync(dataDir);
+        if (files.length === 0)
+            return result;
+        const latestChunk = files.sort().at(-1);
+        if (!latestChunk)
+            return result;
+        result.chunkOrdinal = Number(latestChunk);
+        files = fs.readdirSync(path.join(dataDir, latestChunk));
+        if (files.length === 0)
+            return result;
+        const filesSorted = files.sort();
+        const firstFile = filesSorted.at(0);
+        const lastFile = filesSorted.at(-1);
+        result.startOrdinal = Number(firstFile);
+        result.endOrdinal = Number(lastFile);
+        return result;
+    },
+    async syncToLatestSnapshot() {
+        const { clusterOrdinal, distance: archiveDistance, endOrdinal: remoteArchiveEndOrdinal, startOrdinal: remoteArchiveStartOrdinal, total, url } = await this.getArchiveSnapshotInfo();
+        if (archiveDistance > 1000) {
+            clm.preStep('Archive is far behind cluster. Initiating fast forward...');
+            await FastforwardService.synctoLatestSnapshot();
+            return;
+        }
+        const { endOrdinal: localEndOrdinal, startOrdinal: localStartOrdinal } = this.getDownloadedSnapshotRange();
+        const localDistanceFromCluster = clusterOrdinal - localEndOrdinal;
+        // if archive can improve local's snapshot range
+        const needToSync = remoteArchiveStartOrdinal < localStartOrdinal || remoteArchiveEndOrdinal > localEndOrdinal;
+        if (!needToSync) {
+            clm.step(`Already near latest ordinal. Skipping sync. Distance: ${localDistanceFromCluster}`);
+            return;
+        }
+        const requiredOldestOrdinal = clusterOrdinal - 10_000;
+        const archiveStartOrdinalMeetsOldestRequirement = remoteArchiveStartOrdinal <= requiredOldestOrdinal;
+        if (!archiveStartOrdinalMeetsOldestRequirement) {
+            clm.preStep('Archive is not in the optimal range, but proceeding with available data.');
+        }
+        const { projectDir } = configStore.getProjectInfo();
+        const dataDir = path.join(projectDir, 'app-data', 'gl0-data');
+        fs.mkdirSync(dataDir, { recursive: true });
+        clm.preStep(`Downloading latest snapshot archive ${chalk.yellow(remoteArchiveStartOrdinal)}-${chalk.yellow(remoteArchiveEndOrdinal)}; distance from cluster: ${chalk.yellow(archiveDistance)}\nCurrent oldest local ordinal: ${chalk.yellow(localStartOrdinal)}, Latest cluster ordinal: ${chalk.yellow(clusterOrdinal)}`);
+        // await shellService.runCommand(`curl -L ${url} -o ${dataDir}/snapshot.tar.gz`);
+        await shellService.runCommand(`wget --progress=bar:force -O ${dataDir}/snapshot.tar.gz ${url}`);
+        clm.preStep(`Extracting snapshot...`);
+        await shellService.runCommand(`tar -xf ${dataDir}/snapshot.tar.gz -C ${dataDir}`);
+        await shellService.runCommand(`rm ${dataDir}/snapshot.tar.gz`);
+        clm.postStep(`Total snapshots downloaded: ${chalk.yellow(total)}, Synced to ordinal: ${chalk.yellow(remoteArchiveEndOrdinal)}, Cluster Ordinal: ${chalk.yellow(clusterOrdinal)}, Distance from cluster: ${chalk.yellow(archiveDistance)}`);
+        clm.postStep(`Snapshot downloaded and extracted successfully.`);
+    }
+};

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

@@ -1,10 +1,14 @@
-import { ClusterConsensusInfo, ClusterInfo, NodeInfo } from "../types.js";
+import { ClusterConsensusInfo, ClusterInfo, NodeInfo, TessellationLayer } from "../types.js";
 export declare const clusterService: {
     fastForwardSnapshot(): Promise<void>;
-    getClusterInfo(): Promise<ClusterInfo[]>;
-    getLatestConsensus(): Promise<ClusterConsensusInfo>;
-    getLatestOrdinal(): Promise<any>;
-    getNodeInfo(): Promise<NodeInfo>;
+    getClusterInfo(layer?: TessellationLayer): Promise<ClusterInfo[]>;
+    getClusterNodeInfo(layer?: TessellationLayer): Promise<NodeInfo>;
+    getLatestConsensusInfo(layer?: TessellationLayer): Promise<ClusterConsensusInfo>;
+    getLayer0(): "gl0" | "ml0";
     getReleaseVersion(): Promise<string>;
-    getSourceNodeInfo(): Promise<NodeInfo>;
+    getSourceNodeInfo(layer: TessellationLayer): Promise<NodeInfo>;
+    getSourceNodeLatestOrdinal(layer: TessellationLayer): Promise<number>;
+    getSourceNodeOrdinalHash(layer: TessellationLayer, ordinal: number): Promise<string>;
+    makeClusterRequest(path: string, layer?: TessellationLayer): Promise<any>;
+    makeSourceNodeRequest(path: string, layer: TessellationLayer): Promise<any>;
 };

package/dist/services/cluster-service.js

@@ -1,4 +1,5 @@
 import { input } from "@inquirer/prompts";
+import { clm } from "../clm.js";
 import { configStore } from "../config-store.js";
 import { FastforwardService } from "./fastforward-service.js";
 export const clusterService = {
@@ -21,57 +22,56 @@ export const clusterService = {
             configStore.setProjectInfo({ fastForward: true });
         }
         await FastforwardService.synctoLatestSnapshot();
+        // await archiverService.syncToLatestSnapshot()
+        //     .catch(() => {
+        //         clm.warn(`Failed to download latest snapshots using Starchiver. Using fast forward to latest snapshot.`);
+        //         clusterService.fastForwardSnapshot();
+        //     })
     },
-    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 getClusterInfo(layer) {
+        return this.makeClusterRequest('cluster/info', layer);
     },
-    async getLatestConsensus() {
-        const { type } = configStore.getNetworkInfo();
-        return fetch(`https://l0-lb-${type}.constellationnetwork.io/consensus/latest/peers`)
-            .then(res => {
-            if (res.ok)
-                return res.json();
-            return 0;
-        })
-            .catch(() => 0);
+    async getClusterNodeInfo(layer) {
+        return this.makeClusterRequest('node/info', layer);
     },
-    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 getLatestConsensusInfo(layer) {
+        return this.makeClusterRequest('consensus/latest/peers', layer);
     },
-    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" }));
+    getLayer0() {
+        return configStore.getProjectInfo().layersToRun.includes('gl0') ? 'gl0' : 'ml0';
     },
     async getReleaseVersion() {
-        return this.getNodeInfo().then(i => i.version);
+        return this.getClusterNodeInfo().then(i => i.version);
+    },
+    async getSourceNodeInfo(layer) {
+        return this.makeSourceNodeRequest('node/info', layer);
+    },
+    async getSourceNodeLatestOrdinal(layer) {
+        return this.makeSourceNodeRequest('global-snapshots/latest', layer).then(i => i.value.ordinal);
     },
-    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`);
-        });
+    async getSourceNodeOrdinalHash(layer, ordinal) {
+        return this.makeSourceNodeRequest(`global-snapshots/${ordinal}/hash`, layer);
+    },
+    async makeClusterRequest(path, layer) {
+        layer = layer || this.getLayer0();
+        const { type } = configStore.getNetworkInfo();
+        const envLayerInfo = configStore.getEnvLayerInfo(type, layer);
+        if (envLayerInfo.CL_LB) {
+            return fetch(`${envLayerInfo.CL_LB}/${path}`)
+                .then(res => res.json())
+                .catch(() => {
+                clm.debug(`Failed to get node info from ${envLayerInfo.CL_LB}. Attempting source node...`);
+                return this.makeSourceNodeRequest(path, layer);
+            });
+        }
+        return this.makeSourceNodeRequest(path, layer);
+    },
+    async makeSourceNodeRequest(path, layer) {
+        const { type } = configStore.getNetworkInfo();
+        const { CL_PUBLIC_HTTP_PORT } = configStore.getEnvLayerInfo(type, layer);
+        const { CL_L0_PEER_HTTP_HOST } = configStore.getEnvNetworkInfo(type);
+        clm.debug(`http://${CL_L0_PEER_HTTP_HOST}:${CL_PUBLIC_HTTP_PORT}/${path}`);
+        return fetch(`http://${CL_L0_PEER_HTTP_HOST}:${CL_PUBLIC_HTTP_PORT}/${path}`)
+            .then(res => res.json());
     }
 };

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

@@ -0,0 +1,9 @@
+import { TessellationLayer } from "../types.js";
+export declare const dockerService: {
+    dockerBuild(): Promise<void>;
+    dockerDown(): Promise<void>;
+    dockerRestart(layer: TessellationLayer): Promise<void>;
+    dockerStartLayers(layers: TessellationLayer[]): Promise<void>;
+    dockerUp(): Promise<void>;
+    isRunning(): Promise<boolean>;
+};

package/dist/{helpers/docker-helper.js → services/docker-service.js}

@@ -1,9 +1,9 @@
 import ora from "ora";
 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 = {
+import { projectHelper } from "../helpers/project-helper.js";
+import { shellService } from "./shell-service.js";
+export const dockerService = {
     async dockerBuild() {
         if (shellService.existsProjectScript('scripts/docker-build.sh')) {
             const silent = !process.env.DEBUG;
@@ -24,9 +24,13 @@ export const dockerHelper = {
     },
     async dockerDown() {
         await run('down');
+        configStore.setProjectStatusToRunning(false);
     },
-    async dockerRestart() {
-        await run('restart');
+    async dockerRestart(layer) {
+        await run('restart', [layer]);
+    },
+    async dockerStartLayers(layers) {
+        await run('up -d', layers);
     },
     async dockerUp() {
         // If docker is already running, stop it
@@ -34,13 +38,11 @@ export const dockerHelper = {
             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');
+        configStore.setProjectStatusToRunning(true);
     },
     async isRunning() {
-        return shellService.runCommand('docker ps | grep entrypoint.sh', undefined, true).then(Boolean).catch(() => false);
+        return shellService.runProjectCommand('docker compose ps -q | grep .', undefined, true).then(Boolean).catch(() => false);
     }
 };
 function run(command, layers) {

package/dist/services/fastforward-service.js

@@ -19,9 +19,9 @@ export class FastforwardService {
         this.dataDir = path.join(projectDir, 'app-data', 'gl0-data'); // gl0
         fs.mkdirSync(this.tmpDir, { recursive: true });
         fs.mkdirSync(this.dataDir, { recursive: true });
-        const env = configStore.getEnvCommonInfo();
+        const env = configStore.getEnvNetworkInfo(type);
         // this.lbUrl = `https://l0-lb-${this.network}.constellationnetwork.io`;
-        this.lbUrl = `http://${env.CL_GLOBAL_L0_PEER_HOST}:${env.CL_GLOBAL_L0_PEER_HTTP_PORT}`;
+        this.lbUrl = `http://${env.CL_L0_PEER_HTTP_HOST}:${env.CL_L0_PEER_HTTP_PORT}`;
     }
     static async synctoLatestSnapshot() {
         const ffs = new FastforwardService();
@@ -38,7 +38,7 @@ export class FastforwardService {
         fs.writeFileSync(path.join(snapshotInfoDir, ordinal.toString()), compressedSnapshotInfo);
         fs.writeFileSync(path.join(this.tmpDir, ordinal.toString() + '.c'), compressedSnapshotIncremental);
         await this.saveSnapshotFiles(ordinal.toString(), hash);
-        clm.postStep('Fastforward completed.');
+        clm.postStep(`Fastforward to snapshot "${ordinal}" completed.`);
     }
     async fetchLatestSnapshot() {
         const url = `${this.lbUrl}/global-snapshots/latest/combined`;

package/dist/services/get-random-node.js

@@ -1,7 +1,7 @@
 export const getRandomNode = (nodes) => {
     const randomNodeIndex = Math.floor(Math.random() * nodes.length);
     const node = nodes[randomNodeIndex];
-    console.log(`Getting random node from ${nodes.length} nodes: ${node.host}`);
+    console.log(`Getting random node from ${nodes.length} nodes: ${node.host}:${node.publicPort}`);
     return fetch(`http://${node.host}:${node.publicPort}/node/info`)
         .then(async (res) => {
         if (res.ok)

package/dist/{helpers/github-helper.d.ts → services/github-service.d.ts}

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

package/dist/{helpers/github-helper.js → services/github-service.js}

@@ -1,4 +1,4 @@
-export const githubHelper = {
+export const githubService = {
     hasAssetInRelease(assetName, repo) {
         return fetch(`https://api.github.com/repos/${repo}/releases/latest`)
             .then(async (res) => {

package/dist/services/node-service.js

@@ -1,3 +1,4 @@
+import chalk from "chalk";
 import { clm } from "../clm.js";
 import { configStore } from "../config-store.js";
 import { clusterService } from "./cluster-service.js";
@@ -48,7 +49,7 @@ export const nodeService = {
             return;
         }
         const layerPortInfo = configStore.getLayerPortInfo(layer);
-        const peerInfo = await clusterService.getSourceNodeInfo();
+        const peerInfo = await clusterService.getClusterNodeInfo(layer);
         const nodeId = peerInfo.id;
         const nodeIp = peerInfo.host;
         const cliPort = layerPortInfo.CLI;
@@ -105,25 +106,24 @@ export const nodeService = {
         for (let i = 1; i <= 60; i++) {
             // eslint-disable-next-line no-await-in-loop
             const { state } = await this.getNodeInfo(layer);
-            if (state === "Unavailable" || state === "ReadyToJoin") {
-                if (expectedState === 'Offline')
-                    return true;
-                clm.echo(`     Validator Node is not running.`);
-            }
-            if (layer === 'gl0' && expectedState === 'Ready' && state === "WaitingForDownload") {
-                clm.echo(`    [${layer}] Attempt ${i}: Current state is "${state}"`);
-            }
-            else {
-                clm.echo(`    [${layer}] Attempt ${i}: Current state is "${state}"`);
-            }
+            if (expectedState === 'Offline' && (state === "Unavailable" || state === "ReadyToJoin" || state === "SessionStarted"))
+                return true;
+            clm.echoRepeatLine(`[${layer}] ${chalk.bgGray.cyan('Attempt ' + i)}: Current state is "${state}"                       `);
+            // eslint-disable-next-line no-await-in-loop
+            await sleep(0.5);
+            clm.echoRepeatLine(`[${layer}] Attempt ${i}: Current state is "${state}"                       `);
             if (state === expectedState) {
-                clm.postStep(`    ${layer} is ${expectedState}`);
+                clm.postStep(`${layer} is ${expectedState}`);
                 return true;
             }
+            if (state === "Unavailable" && i > 2) {
+                clm.warn(`${layer} is not connectable. Please try again later.`);
+                return false;
+            }
             // eslint-disable-next-line no-await-in-loop
             await sleep(5);
         }
-        clm.warn(`    ${layer} is not ${expectedState} after 5 minutes`);
+        clm.warn(`${layer} is not ${expectedState} after 5 minutes`);
         return false;
     }
 };

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

@@ -0,0 +1 @@
+export declare const notifyService: {};

package/dist/services/notify-service.js

@@ -0,0 +1 @@
+export const notifyService = {};

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

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

package/dist/services/systemd-service.js

@@ -0,0 +1,45 @@
+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 { shellService } from "./shell-service.js";
+const INSTALL_PATH = '/etc/systemd/system/';
+export const systemdService = {
+    async install() {
+        const { platform } = configStore.getSystemInfo();
+        if (platform !== 'linux') {
+            clm.warn('Node Pilot services can only be installed on Linux systems. Skipping systemd service installation.\n');
+            return;
+        }
+        const projectFolder = path.resolve(path.dirname(fileURLToPath(import.meta.url)), `../../scripts/services`);
+        if (!fs.existsSync(projectFolder)) {
+            clm.error(`Node Pilot services's folder not found: ${projectFolder}`);
+        }
+        const restarterPath = path.join(INSTALL_PATH, 'node-pilot-restarter.service');
+        const updaterPath = path.join(INSTALL_PATH, 'node-pilot-updater.service');
+        let restarterInstalled = false;
+        let updaterInstalled = false;
+        if (!fs.existsSync(restarterPath)) {
+            fs.cpSync(path.join(projectFolder, 'node-pilot-restarter.service'), path.join(INSTALL_PATH, 'node-pilot-restarter.service'));
+            clm.step('Node Pilot restarter service installed successfully.');
+            restarterInstalled = true;
+        }
+        if (!fs.existsSync(updaterPath)) {
+            fs.cpSync(path.join(projectFolder, 'node-pilot-updater.service'), path.join(INSTALL_PATH, 'node-pilot-updater.service'));
+            clm.step('Node Pilot updater service installed successfully.');
+            updaterInstalled = true;
+        }
+        if (restarterInstalled || updaterInstalled) {
+            await shellService.runCommand('systemctl daemon-reload');
+        }
+        if (restarterInstalled) {
+            await shellService.runCommand('systemctl enable node-pilot-restarter.service');
+            clm.step('Node Pilot restarter service enabled successfully.');
+        }
+        if (updaterInstalled) {
+            await shellService.runCommand('systemctl enable node-pilot-updater.service');
+            clm.step('Node Pilot updater service enabled successfully.');
+        }
+    }
+};

package/dist/test.d.ts

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

package/dist/test.js

@@ -0,0 +1,50 @@
+import * as crypto from "node:crypto";
+// convert base64 to hex
+const val = 'MIGHAgEAMBMGByqGSM49AgEGCCqGSM49AwEHBG0wawIBAQQgeYLAOmnJ6FYQ3Uddr6lq5PEVgoiAdWIJ89x6fx3n8JihRANCAASNoaVq/vT5k5Akdzjv8ifybl9icGnMKRpeyZhOxTMnwxGjxANTuKLfUGWUOEngV6HaWGxgkXTU/VXRma+mu0hD';
+// const val = 'MIGHAgEAMBMGByqGSM49AgEGCCqGSM49AwEHBG0wawIBAQQgKy/2tKuoO5V0iXJmTlaWPl9PeDo8TO5ZD+JmD3pOlzihRANCAASffXYMsILTOYSM4pEuBiYO1RR/hfuO+k4WvnNup21HT7CGThWfRjIemS3QDMHncK0Shsy43nb6kD9Fo8DTKpI6';
+const der = Buffer.from(val, 'base64').toString('hex');
+console.log(der);
+// convert DER to PEM
+const ecKey = crypto.createPrivateKey({
+    encoding: "base64",
+    format: "der",
+    key: val,
+    type: "pkcs8",
+});
+console.log(ecKey.export({ 'format': 'jwk' }));
+// Generate an RSA key pair
+const { privateKey, publicKey } = crypto.generateKeyPairSync('rsa', {
+    modulusLength: 2048, // Recommended key size
+    privateKeyEncoding: {
+        format: 'der', // DER encoding for binary output
+        type: 'pkcs8' // PKCS#8 format
+    },
+    publicKeyEncoding: {
+        format: 'der',
+        type: 'spki' // SubjectPublicKeyInfo
+    }
+});
+// The 'privateKey' variable now holds a Buffer containing the PKCS#8 DER private key.
+// To get the Base64 encoded string:
+const privateKeyBase64 = privateKey.toString('base64');
+console.log('PKCS#8 DER Private Key (Base64):');
+console.log(privateKeyBase64);
+// openssl pkcs8 -inform DER -in privatekey.der -outform PEM -out privatekey.pem
+// openssl pkcs8 -inform DER -in privatekey.der -nocrypt -out privatekey.pem -traditional
+async function createP256Pkcs8DerBase64PrivateKey() {
+    // Generate an ECDSA key pair with the P-256 named curve
+    const keyPair = await crypto.subtle.generateKey({
+        name: 'ECDSA',
+        namedCurve: 'P-256',
+    }, true, // extractable
+    ['sign', 'verify']);
+    // Export the private key in PKCS#8 DER format
+    const privateKeyDerBuffer = await crypto.subtle.exportKey('pkcs8', // format
+    keyPair.privateKey);
+    console.log('PKCS#8 DER Private Key (DER Buffer): ' + Buffer.from(privateKeyDerBuffer).toString('hex'));
+    // Convert the DER buffer to a Base64 encoded string
+    const privateKeyBase64 = Buffer.from(privateKeyDerBuffer).toString('base64');
+    console.log('PKCS#8 DER Private Key (Base64):' + privateKeyBase64);
+    return privateKeyBase64;
+}
+await createP256Pkcs8DerBase64PrivateKey();

package/dist/types.d.ts

@@ -32,6 +32,12 @@ export type ClusterConsensusInfo = {
         state: 'Ready';
     }[];
 };
+export type ClusterStats = {
+    ordinal: number;
+    ready: number;
+    startTime: string;
+    total: number;
+};
 export type NodeStatusInfo = {
     clusterSession: string;
     id: string;

package/install-dependencies.sh

@@ -59,8 +59,6 @@ check_docker() {
   fi
   
   echo "⚠️ Docker not found. Will attempt to install Docker."
-
-  # curl -fsSL https://raw.githubusercontent.com/Constellation-Labs/node-pilot/refs/heads/main/install.sh -o install-node-pilot.sh; source install-node-pilot.sh
   
   case "$(uname)" in
     Linux)