@constellation-network/node-pilot 0.0.7 → 0.0.9

package/dist/config-store.d.ts

@@ -1,92 +1,109 @@
-import { TessellationLayer } from "./types.js";
+import { ClusterStats, TessellationLayer } from "./types.js";
 declare class ConfigStore {
     private pilotStore;
     private projectStore;
     constructor();
     applyNewProjectStore(name: string): Promise<void>;
     changeProjectStore(name: string): void;
+    getAppDir(): string;
     getDockerEnvInfo(): object;
-    getEnvCommonInfo(): EnvCommonInfo;
     getEnvInfo(): EnvInfo;
-    getEnvLayerInfo(layer: TessellationLayer): EnvLayerInfo;
+    getEnvLayerInfo(network: NetworkType, layer: TessellationLayer): EnvLayerInfo;
+    getEnvNetworkInfo(network: NetworkType): EnvNetworkInfo;
     getLayerPortInfo(layer: TessellationLayer): PortInfo;
-    getNetworkEnvInfo(network: NetworkType): EnvCommonInfo;
     getNetworkInfo(): NetworkInfo;
     getProjectInfo(): ProjectInfo;
+    getProjects(): string[];
     getSystemInfo(): SystemInfo;
+    hasProjectFlag(name: string): any;
     hasProjects(): boolean;
+    setClusterStats(info: Partial<ClusterStats>): void;
     setDockerEnvInfo(info: Partial<{
         DOCKER_IMAGE_VERSION: string;
         DOCKER_USER_ID: string;
     }>): void;
-    setEnvCommonInfo(info: Partial<EnvCommonInfo>): void;
-    setEnvInfo(info: DeepPartial<EnvInfo>): void;
-    setEnvLayerInfo(layer: TessellationLayer, info: Partial<EnvLayerInfo>): void;
-    setNetworkEnvInfo(info: NetworkEnvInfo): void;
+    setEnvInfo(info: Partial<EnvInfo>): void;
+    setEnvLayerInfo(network: NetworkType, layer: TessellationLayer, info: Partial<EnvLayerInfo>): void;
+    setEnvNetworkInfo(network: NetworkType, info: Partial<EnvNetworkInfo>): void;
     setNetworkInfo(info: Partial<NetworkInfo>): void;
+    setProjectFlag(name: string, value: boolean): any;
     setProjectInfo(info: Partial<ProjectInfo>): void;
-    setSystemInfo(info: SystemInfo): void;
+    setSystemInfo(info: Partial<SystemInfo>): void;
+    private getPilotInfo;
+    private setPilotInfo;
 }
 export declare const configStore: ConfigStore;
-type DeepPartial<T> = {
-    [P in keyof T]?: T[P] extends object ? DeepPartial<T[P]> : T[P];
+export type EnvInfo = EnvKeyInfo & {
+    CL_ARCHIVE_NODE: boolean;
+    CL_EXTERNAL_IP: string;
 };
-export type EnvInfo = {
-    common: EnvCommonInfo;
-    layers: Record<TessellationLayer, EnvLayerInfo>;
+export declare const envNames: {
+    CL_EXTERNAL_IP: number;
+    CL_KEYALIAS: number;
+    CL_KEYSTORE: number;
+    CL_PASSWORD: number;
 };
-export type EnvCommonInfo = {
+export type EnvCombinedInfo = EnvInfo & EnvLayerInfo & EnvNetworkInfo;
+export type EnvNetworkInfo = EnvPeerInfo & {
     CL_APP_ENV: string;
-    CL_EXTERNAL_IP: string;
+    CL_COLLATERAL: string;
+    CL_L0_TOKEN_IDENTIFIER: string;
+};
+export type EnvKeyInfo = {
+    CL_KEYALIAS: string;
+    CL_KEYSTORE: string;
+    CL_PASSWORD: string;
+};
+export type EnvPeerInfo = {
     CL_GLOBAL_L0_PEER_HOST: string;
     CL_GLOBAL_L0_PEER_HTTP_PORT: string;
     CL_GLOBAL_L0_PEER_ID: string;
-    CL_KEYALIAS: string;
-    CL_KEYSTORE: string;
     CL_L0_PEER_HTTP_HOST: string;
     CL_L0_PEER_HTTP_PORT: string;
     CL_L0_PEER_ID: string;
     CL_L0_PEER_P2P_PORT: string;
-    CL_L0_TOKEN_IDENTIFIER: string;
-    CL_PASSWORD: string;
 };
-export declare const commonEnvNames: {
+export declare const networkEnvNames: {
     CL_APP_ENV: number;
-    CL_EXTERNAL_IP: number;
     CL_GLOBAL_L0_PEER_HOST: number;
     CL_GLOBAL_L0_PEER_HTTP_PORT: number;
     CL_GLOBAL_L0_PEER_ID: number;
-    CL_KEYALIAS: number;
-    CL_KEYSTORE: number;
     CL_L0_PEER_HTTP_HOST: number;
     CL_L0_PEER_HTTP_PORT: number;
     CL_L0_PEER_ID: number;
+    CL_L0_PEER_P2P_PORT: number;
     CL_L0_TOKEN_IDENTIFIER: number;
-    CL_PASSWORD: number;
 };
-export type EnvLayerInfo = {
+export type EnvLayerInfo = EnvPeerInfo & {
     CL_CLI_HTTP_PORT: string;
     CL_DOCKER_JAVA_OPTS: string;
+    CL_LB: string;
     CL_P2P_HTTP_PORT: string;
     CL_PUBLIC_HTTP_PORT: string;
 };
 export declare const layerEnvNames: {
     CL_CLI_HTTP_PORT: number;
     CL_DOCKER_JAVA_OPTS: number;
+    CL_GLOBAL_L0_PEER_HOST: number;
+    CL_GLOBAL_L0_PEER_HTTP_PORT: number;
+    CL_GLOBAL_L0_PEER_ID: number;
+    CL_L0_PEER_HTTP_HOST: number;
+    CL_L0_PEER_HTTP_PORT: number;
+    CL_L0_PEER_ID: number;
+    CL_L0_PEER_P2P_PORT: number;
+    CL_LB: number;
     CL_P2P_HTTP_PORT: number;
     CL_PUBLIC_HTTP_PORT: number;
 };
 export type SystemInfo = {
-    cores?: number;
-    disk?: string;
-    memory?: string;
-    platform?: string;
+    cores: number;
+    disk: string;
+    isDockerInstalled: boolean;
+    memory: string;
+    platform: string;
 };
 export type NetworkType = 'integrationnet' | 'mainnet' | 'testnet';
 export type ProjectInfo = {
-    autoRestart: boolean;
-    autoStart: boolean;
-    autoUpdate: boolean;
     dagAddress: string;
     fastForward: boolean;
     homeDir: string;
@@ -100,7 +117,6 @@ export type NetworkInfo = {
     type: NetworkType;
     version: string;
 };
-export type NetworkEnvInfo = Record<NetworkType, EnvCommonInfo>;
 export type PortInfo = {
     CLI: string;
     P2P: string;

package/dist/config-store.js

@@ -41,84 +41,113 @@ class ConfigStore {
             }
         }
         else {
-            this.pilotStore.setItem('pilot', { appDir, project: name, projects: [...projects, name] });
+            this.setPilotInfo({ project: name, projects: [...projects, name] });
         }
         fs.mkdirSync(path.join(projectDir, 'config'), { recursive: true });
         this.projectStore = new JSONStorage(path.join(projectDir, 'config'));
         this.setDockerEnvInfo({ DOCKER_IMAGE_VERSION: 'test' });
         this.setProjectInfo({ name, projectDir });
-        this.setEnvInfo({ common: { CL_GLOBAL_L0_PEER_HTTP_PORT: '9000' }, layers: { gl0: { CL_PUBLIC_HTTP_PORT: "9000" } } });
     }
     changeProjectStore(name) {
-        const { appDir, projects } = this.pilotStore.getItem('pilot');
+        const { appDir, project, projects } = this.pilotStore.getItem('pilot');
         if (projects && projects.includes(name)) {
+            if (project === name)
+                return;
             this.projectStore = new JSONStorage(path.join(appDir, name, 'config'));
+            this.setPilotInfo({ project: name });
         }
         else {
             throw new Error(`Project ${name} doesn't exist.`);
         }
     }
+    getAppDir() {
+        const { appDir } = this.pilotStore.getItem('pilot');
+        return appDir;
+    }
     getDockerEnvInfo() {
         return this.projectStore.getItem('docker');
     }
-    getEnvCommonInfo() {
-        return this.projectStore.getItem('env')?.common;
-    }
     getEnvInfo() {
-        return this.projectStore.getItem('env');
+        return this.projectStore.getItem('env') || {};
+    }
+    getEnvLayerInfo(network, layer) {
+        const envInfo = this.projectStore.getItem('layer-env');
+        if (!envInfo)
+            return { [network]: {} };
+        return envInfo[network][layer] || {};
     }
-    getEnvLayerInfo(layer) {
-        const envInfo = this.projectStore.getItem('env');
+    getEnvNetworkInfo(network) {
+        const envInfo = this.projectStore.getItem('network-env');
         if (!envInfo)
             return {};
-        return { ...envInfo.common, ...envInfo.layers[layer] };
+        return envInfo[network];
     }
     getLayerPortInfo(layer) {
-        const layerInfo = this.getEnvLayerInfo(layer);
+        const { type: network } = this.getNetworkInfo();
+        const layerInfo = this.getEnvLayerInfo(network, layer);
         return { CLI: layerInfo.CL_CLI_HTTP_PORT, P2P: layerInfo.CL_P2P_HTTP_PORT, PUBLIC: layerInfo.CL_PUBLIC_HTTP_PORT };
     }
-    getNetworkEnvInfo(network) {
-        const info = this.projectStore.getItem('network-env');
-        return info ? info[network] : {};
-    }
     getNetworkInfo() {
         return this.projectStore.getItem('network');
     }
     getProjectInfo() {
         return this.projectStore.getItem('project');
     }
+    getProjects() {
+        const { projects } = this.pilotStore.getItem('pilot');
+        return projects;
+    }
     getSystemInfo() {
         return this.pilotStore.getItem('system');
     }
+    hasProjectFlag(name) {
+        const flags = this.projectStore.getItem('flags') || {};
+        return flags[name] || false;
+    }
     hasProjects() {
         const { projects } = this.pilotStore.getItem('pilot');
         return projects.length > 0;
     }
+    // setCurrentEnvNetworkInfo(info: Partial<EnvNetworkInfo>) {
+    //     const {type} = this.getNetworkInfo();
+    //     this.setEnvNetworkInfo(type, info);
+    // }
+    setClusterStats(info) {
+        const oldInfo = this.projectStore.getItem('cluster-stats');
+        this.projectStore.setItem('cluster-stats', { ...oldInfo, ...info });
+    }
     setDockerEnvInfo(info) {
         const oldInfo = this.projectStore.getItem('docker');
         this.projectStore.setItem('docker', { ...oldInfo, ...info });
     }
-    setEnvCommonInfo(info) {
-        const oldInfo = this.projectStore.getItem('env');
-        this.projectStore.setItem('env', { common: { ...oldInfo.common, ...info }, layers: oldInfo.layers });
-    }
     setEnvInfo(info) {
         const oldInfo = this.projectStore.getItem('env');
         this.projectStore.setItem('env', { ...oldInfo, ...info });
     }
-    setEnvLayerInfo(layer, info) {
-        const envInfo = this.projectStore.getItem('env');
-        const { common, layers } = envInfo;
-        this.projectStore.setItem('env', { common, layers: { ...layers, [layer]: { ...layers[layer], ...info } } });
+    setEnvLayerInfo(network, layer, info) {
+        let layers = this.projectStore.getItem('layer-env');
+        if (!layers)
+            layers = {};
+        if (!layers[network])
+            layers[network] = {};
+        this.projectStore.setItem('layer-env', { ...layers, [network]: { ...layers[network], [layer]: { ...layers[network][layer], ...info } } });
     }
-    setNetworkEnvInfo(info) {
-        const oldInfo = this.projectStore.getItem('network-env');
-        this.projectStore.setItem('network-env', { ...oldInfo, ...info });
+    setEnvNetworkInfo(network, info) {
+        let networks = this.projectStore.getItem('network-env');
+        if (!networks)
+            networks = {};
+        this.projectStore.setItem('network-env', { ...networks, [network]: { ...networks[network], ...info } });
     }
     setNetworkInfo(info) {
         const oldInfo = this.projectStore.getItem('network');
         this.projectStore.setItem('network', { ...oldInfo, ...info });
     }
+    setProjectFlag(name, value) {
+        const flags = this.projectStore.getItem('flags') || {};
+        flags[name] = value;
+        this.projectStore.setItem('flags', flags);
+        return flags;
+    }
     setProjectInfo(info) {
         const oldInfo = this.projectStore.getItem('project');
         this.projectStore.setItem('project', { ...oldInfo, ...info });
@@ -127,25 +156,44 @@ class ConfigStore {
         const oldInfo = this.projectStore.getItem('system');
         this.pilotStore.setItem('system', { ...oldInfo, ...info });
     }
+    getPilotInfo() {
+        return this.pilotStore.getItem('pilot');
+    }
+    setPilotInfo(info) {
+        const oldInfo = this.pilotStore.getItem('pilot');
+        this.pilotStore.setItem('pilot', { ...oldInfo, ...info });
+    }
 }
 export const configStore = new ConfigStore();
-export const commonEnvNames = {
-    CL_APP_ENV: 1,
+export const envNames = {
     CL_EXTERNAL_IP: 1,
+    CL_KEYALIAS: 1,
+    CL_KEYSTORE: 1,
+    CL_PASSWORD: 1
+};
+export const networkEnvNames = {
+    CL_APP_ENV: 1,
     CL_GLOBAL_L0_PEER_HOST: 1,
     CL_GLOBAL_L0_PEER_HTTP_PORT: 1,
     CL_GLOBAL_L0_PEER_ID: 1,
-    CL_KEYALIAS: 1,
-    CL_KEYSTORE: 1,
     CL_L0_PEER_HTTP_HOST: 1,
     CL_L0_PEER_HTTP_PORT: 1,
     CL_L0_PEER_ID: 1,
+    CL_L0_PEER_P2P_PORT: 1,
     CL_L0_TOKEN_IDENTIFIER: 1,
-    CL_PASSWORD: 1
 };
+// NETWORK LAYER
 export const layerEnvNames = {
     CL_CLI_HTTP_PORT: 1,
     CL_DOCKER_JAVA_OPTS: 1,
+    CL_GLOBAL_L0_PEER_HOST: 1,
+    CL_GLOBAL_L0_PEER_HTTP_PORT: 1,
+    CL_GLOBAL_L0_PEER_ID: 1,
+    CL_L0_PEER_HTTP_HOST: 1,
+    CL_L0_PEER_HTTP_PORT: 1,
+    CL_L0_PEER_ID: 1,
+    CL_L0_PEER_P2P_PORT: 1,
+    CL_LB: 1,
     CL_P2P_HTTP_PORT: 1,
-    CL_PUBLIC_HTTP_PORT: 1,
+    CL_PUBLIC_HTTP_PORT: 1
 };

package/dist/helpers/config-helper.js

@@ -18,8 +18,8 @@ export const configHelper = {
         }
         const versionObj = this.parseEnvFile(lastInstallVersion);
         return {
-            network: versionObj.RELEASE_NETWORK_TYPE,
-            version: versionObj.RELEASE_NETWORK_VERSION
+            network: versionObj.INSTALLED_NETWORK_TYPE,
+            version: versionObj.INSTALLED_NETWORK_VERSION
         };
     },
     parseEnvFile(filePath) {

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('Key File Information:');
+        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,9 +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>;
 };