@constellation-network/node-pilot 0.0.8 → 0.0.9

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

@@ -1,4 +1,5 @@
-import { EnvCommonInfo, EnvLayerInfo, NetworkType } from "../config-store.js";
+import { EnvCombinedInfo, EnvInfo } 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;
+export declare function getLayerEnvFileContent(layer: TessellationLayer, env: EnvCombinedInfo): string;
+export declare function getKeyFileContent(env: EnvInfo): string;
+export declare function getObjectToEnvContent(obj: object): string;

package/dist/helpers/env-templates.js

@@ -1,33 +1,41 @@
-export function getLayerEnvFileContent(layer, network, commonInfo, layerInfo) {
+export function getLayerEnvFileContent(layer, env) {
     return `
+DEBUG=${process.env.DEBUG || ''}
+NODE_PILOT_SESSION=${Date.now()}
+
 # Node
-CL_EXTERNAL_IP=${commonInfo.CL_EXTERNAL_IP}
-CL_DOCKER_JAVA_OPTS='${layerInfo.CL_DOCKER_JAVA_OPTS}'
+CL_ARCHIVE_NODE=${env.CL_ARCHIVE_NODE || ''}
+CL_EXTERNAL_IP=${env.CL_EXTERNAL_IP}
+CL_DOCKER_JAVA_OPTS='${env.CL_DOCKER_JAVA_OPTS}'
 CL_KEYSTORE='/app/key.p12'
-CL_KEYALIAS='${commonInfo.CL_KEYALIAS}'
-CL_PASSWORD='${commonInfo.CL_PASSWORD}'
+CL_KEYALIAS='${env.CL_KEYALIAS}'
+CL_PASSWORD='${env.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}
+CL_LB=${env.CL_LB}
+CL_APP_ENV=${env.CL_APP_ENV}
+CL_COLLATERAL=${env.CL_COLLATERAL}
+CL_L0_PEER_HTTP_PORT=${env.CL_L0_PEER_HTTP_PORT}
+CL_L0_PEER_HTTP_HOST=${env.CL_L0_PEER_HTTP_HOST}
+CL_L0_PEER_ID=${env.CL_L0_PEER_ID}
+CL_GLOBAL_L0_PEER_HTTP_PORT=${env.CL_GLOBAL_L0_PEER_HTTP_PORT}
+CL_GLOBAL_L0_PEER_HOST=${env.CL_GLOBAL_L0_PEER_HOST}
+CL_GLOBAL_L0_PEER_ID=${env.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}
+CL_PUBLIC_HTTP_PORT=${env.CL_PUBLIC_HTTP_PORT}
+CL_P2P_HTTP_PORT=${env.CL_P2P_HTTP_PORT}
+CL_CLI_HTTP_PORT=${env.CL_CLI_HTTP_PORT}
 `;
 }
-export function getKeyFileContent(commonInfo) {
+export function getKeyFileContent(env) {
     return `
-export CL_KEYSTORE='${commonInfo.CL_KEYSTORE}'
-export CL_KEYALIAS='${commonInfo.CL_KEYALIAS}'
-export CL_PASSWORD='${commonInfo.CL_PASSWORD}'
+export CL_KEYSTORE='${env.CL_KEYSTORE}'
+export CL_KEYALIAS='${env.CL_KEYALIAS}'
+export CL_PASSWORD='${env.CL_PASSWORD}'
 `;
 }
+export function getObjectToEnvContent(obj) {
+    return Object.entries(obj).map(([k, v]) => `${k}='${v}'`).join('\n') + '\n';
+}

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

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

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

@@ -7,12 +7,27 @@ 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";
+import { getObjectToEnvContent } from "./env-templates.js";
 export const keyFileHelper = {
+    async changePassword(newPassword) {
+        const { projectDir } = configStore.getProjectInfo();
+        const keyFilePath = path.join(projectDir, "key.p12");
+        if (!fs.existsSync(keyFilePath)) {
+            clm.error('No key file found. Please generate a new key file first.');
+        }
+        const { CL_PASSWORD: currentPassword } = configStore.getEnvInfo();
+        if (currentPassword === newPassword) {
+            clm.error('The new password is the same as the current password. Please try again with a different password.');
+        }
+        await shellService.runCommand(`keytool -importkeystore -srckeystore ${keyFilePath} -srcstoretype PKCS12 -srcstorepass '${currentPassword}' -destkeystore ${path.join(projectDir, "temp.p12")} -deststoretype PKCS12 -deststorepass '${newPassword}' -destkeypass '${newPassword}'`);
+        await this.promptSaveBackup({ CL_KEYALIAS: 'alias', CL_KEYSTORE: keyFilePath, CL_PASSWORD: newPassword });
+    },
     async generate() {
         const { projectDir } = configStore.getProjectInfo();
         const keyFilePath = path.join(projectDir, "key.p12");
+        let modifier = '';
         if (fs.existsSync(keyFilePath)) {
+            modifier = 'new ';
             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 });
@@ -22,31 +37,26 @@ export const keyFileHelper = {
                 process.exit(0);
             }
         }
-        const keyPassword = await password({ message: 'Enter the key file password:', validate: value => value.length > 0 });
+        const keyPassword = await password({ message: `Enter the ${modifier}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);
+        configStore.setEnvInfo(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'))}`);
-        }
+        await this.promptSaveBackup(env);
     },
     async getAddress() {
         const { projectDir } = configStore.getProjectInfo();
-        const env = configStore.getEnvCommonInfo();
+        const env = configStore.getEnvInfo();
         return shellService.runCommandWithOutput(`java -jar ${projectDir}/dist/wallet.jar show-address`, env);
     },
     async getId() {
         const { projectDir } = configStore.getProjectInfo();
-        const env = configStore.getEnvCommonInfo();
+        const env = configStore.getEnvInfo();
         return shellService.runCommandWithOutput(`java -jar ${projectDir}/dist/wallet.jar show-id`, env);
     },
     async importKeyFile() {
@@ -72,17 +82,17 @@ export const keyFileHelper = {
         // 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 });
+        configStore.setEnvInfo({ 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.error('Failed to unlock the key file. Please check your key file information and try again.');
+            // await this.promptForKeyFile();
+            // return;
         }
         clm.postStep('Key file imported successfully.\n');
     },
@@ -108,6 +118,8 @@ export const keyFileHelper = {
             await this.importKeyFile();
             await this.showKeyFileInfo(false);
         }
+        configStore.setProjectFlag('duplicateNodeIdChecked', false);
+        configStore.setProjectFlag('seedListChecked', false);
     },
     async promptIfNoKeyFile() {
         const { projectDir } = configStore.getProjectInfo();
@@ -117,12 +129,35 @@ export const keyFileHelper = {
         }
         await this.promptForKeyFile();
     },
+    async promptSaveBackup(env) {
+        const { projectDir } = configStore.getProjectInfo();
+        const keyFilePath = path.join(projectDir, "key.p12");
+        const { dagAddress, nodeId } = configStore.getProjectInfo();
+        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') {
+            const homeKeyPath = path.join(os.homedir(), 'key.p12');
+            const homeKeyInfoPath = path.join(os.homedir(), 'key-info');
+            if (fs.existsSync(homeKeyPath)) {
+                const backupUniqueName = new Date().toISOString().replaceAll(':', '-');
+                const backupKeyName = `key-${backupUniqueName}.p12`;
+                const backupKeyPath = path.join(os.homedir(), backupKeyName);
+                fs.renameSync(homeKeyPath, backupKeyPath);
+                clm.postStep(`An existing key file was found in your home directory and has been renamed to ${chalk.cyan(backupKeyName)}`);
+                if (fs.existsSync(homeKeyInfoPath)) {
+                    fs.renameSync(homeKeyInfoPath, path.join(os.homedir(), `key-info-${backupUniqueName}`));
+                }
+            }
+            fs.cpSync(keyFilePath, homeKeyPath);
+            fs.writeFileSync(path.join(os.homedir(), 'key-info'), getObjectToEnvContent({ ...env, CL_KEYSTORE: 'key.p12', CL_PASSWORD: '****', NODE_ADDRESS: dagAddress, NODE_ID: nodeId }));
+            clm.postStep(`A copy of the Key file has been saved to your home directory - ${chalk.cyan(homeKeyPath)}`);
+        }
+    },
     async showKeyFileInfo(prompt4ShowPassword = true) {
         clm.preStep('Current 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();
+        const { CL_KEYALIAS, CL_KEYSTORE, CL_PASSWORD } = configStore.getEnvInfo();
         configHelper.showEnvInfo('CL_KEYSTORE', CL_KEYSTORE || '');
         configHelper.showEnvInfo('CL_KEYALIAS', CL_KEYALIAS || '');
         configHelper.showEnvInfo('CL_PASSWORD', '*********');

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

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

package/dist/helpers/project-helper.js

@@ -5,50 +5,46 @@ import path from "node:path";
 import { fileURLToPath } from 'node:url';
 import { clm } from "../clm.js";
 import { configStore } from "../config-store.js";
+import { githubService } from "../services/github-service.js";
 import { configHelper } from "./config-helper.js";
 import { getLayerEnvFileContent } from "./env-templates.js";
-import { githubHelper } from "./github-helper.js";
 export const projectHelper = {
     async generateLayerEnvFiles(layers) {
         const { layersToRun, projectDir } = configStore.getProjectInfo();
-        const { type } = configStore.getNetworkInfo();
-        const commonInfo = configStore.getEnvCommonInfo();
+        const { type: network } = configStore.getNetworkInfo();
+        const envInfo = configStore.getEnvInfo();
+        const envNetworkInfo = configStore.getEnvNetworkInfo(network);
         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);
+        for (const layer of layers) {
+            const filePath = path.join(projectDir, `${layer}.env`);
+            const envLayerInfo = configStore.getEnvLayerInfo(network, layer);
+            const fileContents = getLayerEnvFileContent(layer, { ...envInfo, ...envNetworkInfo, ...envLayerInfo });
             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() {
+    importEnvFiles() {
         const { projectDir } = configStore.getProjectInfo();
         const possibleNetworks = ['mainnet', 'testnet', 'integrationnet'];
+        const possibleLayers = ['gl0', 'gl1', 'ml0', 'cl1', 'dl1'];
         const supportedTypes = [];
-        const networkEnvInfo = {};
-        for (const n of possibleNetworks) {
-            const filePath = path.join(projectDir, 'networks', `${n}.env`);
+        for (const network of possibleNetworks) {
+            const filePath = path.join(projectDir, 'networks', network, 'network.env');
             if (fs.existsSync(filePath)) {
-                supportedTypes.push(n);
-                networkEnvInfo[n] = configHelper.parseEnvFile(filePath);
+                supportedTypes.push(network);
+                configStore.setEnvNetworkInfo(network, configHelper.parseEnvFile(filePath));
+            }
+            for (const layer of possibleLayers) {
+                const filePath = path.join(projectDir, 'networks', network, `${layer}.env`);
+                if (fs.existsSync(filePath)) {
+                    configStore.setEnvLayerInfo(network, layer, 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
     },
@@ -57,10 +53,7 @@ export const projectHelper = {
         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 });
+        await this.installProject(name, projectFolder);
     },
     //  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
@@ -75,15 +68,21 @@ export const projectHelper = {
         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();
+        this.importEnvFiles();
+    },
+    async installProject(name, projectFolder) {
+        if (!configStore.hasProjects()) {
+            // On first install, copy scripts
+            const scriptsFolder = path.resolve(path.dirname(fileURLToPath(import.meta.url)), `../../scripts`);
+            const projectDir = path.join(configStore.getAppDir(), 'scripts');
+            clm.debug(`Installing node pilot scripts from ${scriptsFolder} to ${projectDir}`);
+            fs.mkdirSync(projectDir, { recursive: true });
+            fs.cpSync(scriptsFolder, projectDir, { recursive: true });
+        }
+        await configStore.applyNewProjectStore(name);
+        const { projectDir } = configStore.getProjectInfo();
+        clm.debug(`Installing project from ${projectFolder} to ${projectDir}`);
+        fs.cpSync(projectFolder, projectDir, { recursive: true });
     },
     async selectProject() {
         // prompt user to install hypergraph or metagraph
@@ -124,7 +123,7 @@ export const projectHelper = {
                 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)) {
+                if (await githubService.hasAssetInRelease('node-pilot', userRepo)) {
                     await this.installFromGithub(userRepo);
                 }
                 else {

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

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

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>;
 };