@constellation-network/node-pilot 0.0.8 → 0.0.9

package/dist/commands/config/set.js

@@ -1,5 +1,7 @@
 import { Args, Command } from '@oclif/core';
-import { commonEnvNames, configStore, layerEnvNames } from "../../config-store.js";
+import chalk from "chalk";
+import { clm } from "../../clm.js";
+import { configStore, layerEnvNames, networkEnvNames } from "../../config-store.js";
 import { configHelper } from "../../helpers/config-helper.js";
 export default class ConfigSet extends Command {
     static args = {
@@ -11,31 +13,31 @@ export default class ConfigSet extends Command {
         '<%= config.bin %> <%= command.id %> CL_EXTERNAL_IP 127.0.0.1',
         '<%= config.bin %> <%= command.id %> gl0:CL_PUBLIC_HTTP_PORT 9000',
     ];
-    logErrorAndExit(message) {
-        this.log(message);
-        this.exit(0);
-    }
     async run() {
         configHelper.assertProject('No configuration found. ');
         const { args } = await this.parse(ConfigSet);
         const { layersToRun } = configStore.getProjectInfo();
+        if (args.name.startsWith('key')) {
+            clm.error(`Key properties cannot be set directly. Please run ${chalk.cyan('cpilot config')} and select ${chalk.cyan('Key Info')} to manage the key file.`);
+        }
+        const { type: network } = configStore.getNetworkInfo();
         if (args.name.includes(':')) {
             const [layer, name] = args.name.split(':');
             if (!layersToRun.includes(layer)) {
-                this.logErrorAndExit(`Invalid layer: ${layer}. Available layers: ${layersToRun.join(',')}`);
+                clm.error(`Invalid layer: ${layer}. Available layers: ${layersToRun.join(',')}`);
             }
             const validLayer = layer;
             if (!Object.hasOwn(layerEnvNames, name)) {
-                this.logErrorAndExit(`Invalid layer configuration name: ${name}`);
+                clm.error(`Invalid layer configuration name: ${name}. Valid names are: ${Object.keys(layerEnvNames).join(', ')}`);
             }
-            configStore.setEnvLayerInfo(validLayer, { [name]: args.value });
+            configStore.setEnvLayerInfo(network, validLayer, { [name]: args.value });
         }
         else {
             const { name } = args;
-            if (!Object.hasOwn(commonEnvNames, name)) {
-                this.logErrorAndExit(`Invalid configuration name: ${name}`);
+            if (!Object.hasOwn(networkEnvNames, name)) {
+                clm.error(`Invalid configuration name: ${name}. Valid names are: ${Object.keys(networkEnvNames).join(', ')}`);
             }
-            configStore.setEnvCommonInfo({ [name]: args.value });
+            configStore.setEnvNetworkInfo(network, { [name]: args.value });
         }
     }
 }

package/dist/commands/config.js

@@ -3,11 +3,10 @@ import { Command } from '@oclif/core';
 import { checkNetwork } from "../checks/check-network.js";
 import { checkProject } from "../checks/check-project.js";
 import { clm } from "../clm.js";
-import { configStore } from "../config-store.js";
 import { configHelper } from "../helpers/config-helper.js";
-import { dockerHelper } from "../helpers/docker-helper.js";
 import { keyFileHelper } from "../helpers/key-file-helper.js";
 import { promptHelper } from "../helpers/prompt-helper.js";
+import { dockerService } from "../services/docker-service.js";
 export default class Config extends Command {
     static description = 'Update configuration settings';
     static examples = [
@@ -15,51 +14,47 @@ export default class Config extends Command {
     ];
     async run() {
         configHelper.assertProject('No configuration found. ');
-        let { name } = configStore.getProjectInfo();
-        name = name.charAt(0).toUpperCase() + name.slice(1);
+        // let {name} = configStore.getProjectInfo();
+        // name = name.charAt(0).toUpperCase() + name.slice(1);
         const answer = await select({
             choices: [
-                { name: 'Auto Restart', value: 'autoRestart' },
                 { name: 'External IP Address', value: 'externalIp' },
                 { name: 'Java Memory', value: 'javaMemory' },
                 { name: 'Key File', value: 'keyFile' },
-                { name: `${name} - Layers To Run`, value: 'layersToRun' },
-                { name: `Network (mainnet, testnet or intnet)`, value: 'network' },
+                { name: 'Layers To Run', value: 'layersToRun' },
+                { name: `Network`, value: 'network' },
             ],
             message: 'What would you like to change?:',
         });
         // eslint-disable-next-line unicorn/prefer-switch
-        if (answer === 'autoRestart') {
-            await promptHelper.configureAutoRestart();
-        }
-        else if (answer === 'externalIp') {
+        if (answer === 'externalIp') {
             await checkNetwork.configureIpAddress();
         }
         else if (answer === 'javaMemory') {
+            await shutdownNodeIfRunning();
             await promptHelper.configureJavaMemoryArguments();
-            if (await dockerHelper.isRunning()) {
-                clm.preStep('The validator node must be restarted before changes can be applied.');
-                await promptHelper.doYouWishToContinue();
-                await dockerHelper.dockerDown();
-                await dockerHelper.dockerUp();
-            }
         }
         else if (answer === 'keyFile') {
+            await shutdownNodeIfRunning();
             await keyFileHelper.showKeyFileInfo();
             await keyFileHelper.promptForKeyFile();
         }
         else if (answer === 'layersToRun') {
-            if (await dockerHelper.isRunning()) {
-                clm.preStep('The validator node must be stopped first.');
-                await promptHelper.doYouWishToContinue();
-                await dockerHelper.dockerDown();
-            }
+            await shutdownNodeIfRunning();
             await promptHelper.selectLayers();
             await promptHelper.configureJavaMemoryArguments();
         }
         else if (answer === 'network') {
+            await shutdownNodeIfRunning();
             await promptHelper.selectNetwork();
             await checkProject.runInstall();
         }
     }
 }
+async function shutdownNodeIfRunning() {
+    if (await dockerService.isRunning()) {
+        clm.preStep('The validator node must be stopped first.');
+        await promptHelper.doYouWishToContinue();
+        await dockerService.dockerDown();
+    }
+}

package/dist/commands/info.js

@@ -10,10 +10,13 @@ export default class Info extends Command {
         configHelper.assertProject('No project info found. ');
         const projectInfo = configStore.getProjectInfo();
         const networkInfo = configStore.getNetworkInfo();
+        const { CL_EXTERNAL_IP: currentIpAddress } = configStore.getEnvInfo();
         // Project Name
         configHelper.showEnvInfo('Project Name', projectInfo.name);
         // DAG Address
         configHelper.showEnvInfo('DAG Address', projectInfo.dagAddress);
+        // External IP Address
+        configHelper.showEnvInfo('External IP Address', currentIpAddress);
         // Node ID
         configHelper.showEnvInfo('Node ID', projectInfo.nodeId);
         // Layers to Run
@@ -26,7 +29,5 @@ export default class Info extends Command {
         configHelper.showEnvInfo('Project Directory', projectInfo.projectDir);
         // Fast Forward
         configHelper.showEnvInfo('Fast Forward Enabled', (projectInfo.fastForward === undefined || Boolean(projectInfo.fastForward)).toString());
-        // Auto Restart
-        configHelper.showEnvInfo('Auto Restart Enabled', Boolean(projectInfo.autoRestart).toString());
     }
 }

package/dist/commands/logs.d.ts

@@ -1,7 +1,7 @@
 import { Command } from '@oclif/core';
 export default class Logs extends Command {
     static args: {
-        layer: import("@oclif/core/interfaces").Arg<string | undefined, Record<string, unknown>>;
+        layer: import("@oclif/core/interfaces").Arg<string, Record<string, unknown>>;
     };
     static description: string;
     static examples: string[];

package/dist/commands/logs.js

@@ -5,7 +5,7 @@ import { configHelper } from "../helpers/config-helper.js";
 import { shellService } from "../services/shell-service.js";
 export default class Logs extends Command {
     static args = {
-        layer: Args.string({ description: 'network layer to view. e.g. gl0' }),
+        layer: Args.string({ description: 'network layer to view. e.g. gl0', required: true }),
     };
     static description = 'view validator node runtime logs';
     static examples = [
@@ -17,14 +17,18 @@ export default class Logs extends Command {
     };
     async run() {
         configHelper.assertProject('No project found. ');
-        const { flags } = await this.parse(Logs);
+        const { args, flags } = await this.parse(Logs);
         const numOfLines = Number.isNaN(Number(flags.numOfLines)) ? 100 : Number(flags.numOfLines);
+        const { layersToRun } = configStore.getProjectInfo();
+        if (!layersToRun.includes(args.layer)) {
+            this.error(`Invalid layer: ${args.layer}. Available layers: ${layersToRun.join(',')}`);
+        }
         let tailFlag = flags.numOfLines ? `-n ${numOfLines}` : '-n 100';
         if (flags.follow) {
             tailFlag = ' -f';
         }
         const { projectDir } = configStore.getProjectInfo();
-        const logPath = path.join(projectDir, 'app-data', 'gl0-logs', 'app.log');
+        const logPath = path.join(projectDir, 'app-data', `${args.layer}-logs`, 'app.log');
         await shellService.runCommand(`tail ${tailFlag} ${logPath}`).catch(() => 1);
     }
 }

package/dist/commands/restart.d.ts

@@ -1,5 +1,8 @@
-import { Command } from '@oclif/core';
-export default class Restart extends Command {
+import { BaseCommand } from "../base-command.js";
+export default class Restart extends BaseCommand {
+    static args: {
+        layer: import("@oclif/core/interfaces").Arg<string | undefined, Record<string, unknown>>;
+    };
     static description: string;
     static examples: string[];
     run(): Promise<void>;

package/dist/commands/restart.js

@@ -1,25 +1,45 @@
-import { Command } from '@oclif/core';
+import { Args } from '@oclif/core';
+import { BaseCommand } from "../base-command.js";
 import { checkProject } from "../checks/check-project.js";
 import { clm } from "../clm.js";
 import { configStore } from "../config-store.js";
 import { configHelper } from "../helpers/config-helper.js";
-import { dockerHelper } from "../helpers/docker-helper.js";
+import { dockerService } from "../services/docker-service.js";
 import { nodeService } from "../services/node-service.js";
-export default class Restart extends Command {
+export default class Restart extends BaseCommand {
+    static args = {
+        layer: Args.string({ description: 'network layer to view. e.g. gl0' }),
+    };
     static description = 'A full shutdown of the validator node, then restart';
     static examples = [
         '<%= config.bin %> <%= command.id %>',
     ];
     async run() {
+        const { args, flags } = await this.parse(Restart);
+        this.checkProject(flags);
         configHelper.assertProject('No project found. ');
         const { layersToRun } = configStore.getProjectInfo();
+        if (!await dockerService.isRunning()) {
+            this.error('The validator node is not running.');
+        }
+        if (args && args.layer) {
+            const layer = args.layer;
+            if (!layersToRun.includes(layer)) {
+                this.error(`Invalid layer: ${layer}. Available layers: ${layersToRun.join(',')}`);
+            }
+            await nodeService.leaveCluster(layer);
+            await nodeService.pollForLayersState([layer], 'Offline');
+            clm.preStep(`Restarting ${layer.toUpperCase()}...`);
+            await dockerService.dockerRestart(layer);
+            return;
+        }
         await nodeService.leaveClusterAllLayers();
         await nodeService.pollForLayersState(layersToRun, 'Offline');
         clm.preStep('Stopping the node...');
-        await dockerHelper.dockerDown();
+        await dockerService.dockerDown();
         clm.preStep('Checking for a new version...');
         await checkProject.runUpgrade();
         clm.preStep('Starting the node...');
-        await dockerHelper.dockerUp();
+        await dockerService.dockerUp();
     }
 }

package/dist/commands/shutdown.js

@@ -1,8 +1,8 @@
 import { Command } from '@oclif/core';
 import { configStore } from "../config-store.js";
-import { dockerHelper } from "../helpers/docker-helper.js";
-import { nodeService } from "../services/node-service.js";
 import { configHelper } from "../helpers/config-helper.js";
+import { dockerService } from "../services/docker-service.js";
+import { nodeService } from "../services/node-service.js";
 export default class Shutdown extends Command {
     static description = 'A full shutdown of the validator node';
     static examples = [
@@ -13,6 +13,6 @@ export default class Shutdown extends Command {
         const { layersToRun } = configStore.getProjectInfo();
         await nodeService.leaveClusterAllLayers();
         await nodeService.pollForLayersState(layersToRun, 'Offline');
-        await dockerHelper.dockerDown();
+        await dockerService.dockerDown();
     }
 }

package/dist/commands/status.js

@@ -4,6 +4,7 @@ import { checkLayers } from "../checks/check-layers.js";
 import { checkNetwork } from "../checks/check-network.js";
 import { checkNodeCtl } from "../checks/check-node-ctl.js";
 import { checkProject } from "../checks/check-project.js";
+import { checkWallet } from "../checks/check-wallet.js";
 import { keyFileHelper } from "../helpers/key-file-helper.js";
 export default class Status extends Command {
     // eslint-disable-next-line no-warning-comments
@@ -16,10 +17,13 @@ export default class Status extends Command {
 export async function checkInstallationAndConfigurationStatus() {
     await checkInitialSetup.firstTimeRun();
     await checkProject.projectInstallation();
+    await checkNetwork.isNetworkConnectable();
     await checkProject.releaseVersion();
     await checkNodeCtl.check4Migration();
     await keyFileHelper.promptIfNoKeyFile();
     await checkNetwork.checkSeedList();
+    await checkNetwork.checkForExistingNodeIdInCluster();
+    await checkWallet.checkCollateral();
     await checkLayers.layersRunning();
     await checkLayers.layersReadyToJoin();
     await checkLayers.layersStatus();

package/dist/commands/test.js

@@ -3,16 +3,24 @@ import dotenv from "dotenv";
 import fs from "node:fs";
 import path from "node:path";
 import { fileURLToPath } from "node:url";
+import { archiverService } from "../services/archiver-service.js";
 import { getRandomNode } from "../services/get-random-node.js";
-import { checkNodeCtl } from "../checks/check-node-ctl.js";
 export default class Test extends Command {
     static description = 'node pilot test command';
     static hidden = true;
     async run() {
-        await checkNodeCtl.importKeyInfo(path.resolve('/Users/ffox/Projects/Constellation/node-pilot/cn-config.yaml'));
+        // await checkNodeCtl.importKeyInfo(path.resolve('/Users/ffox/Projects/Constellation/node-pilot/cn-config.yaml'));
+        // await this.testRandomNode();
+        // const info = await archiverService.getArchiveSnapshotInfo();
+        // console.log(info);
+        // const ordinal = archiverService.getDownloadedSnapshotRange();
+        // console.log(ordinal)
+        //
+        // await archiverService.syncToLatestSnapshot();
+        await archiverService.checkLogsForMissingSnapshots();
     }
     async testRandomNode() {
-        const filePath = path.resolve(path.dirname(fileURLToPath(import.meta.url)), `../../projects/hypergraph/networks/mainnet.env`);
+        const filePath = path.resolve(path.dirname(fileURLToPath(import.meta.url)), `../../projects/hypergraph/networks/mainnet/source-nodes.env`);
         const conetent = fs.readFileSync(filePath);
         const parsed = dotenv.parse(conetent);
         const nodes = ['1', '2', '3'].map(i => {

package/dist/config-store.d.ts

@@ -1,80 +1,97 @@
-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): boolean;
+    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: 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;
 };
@@ -87,9 +104,6 @@ export type SystemInfo = {
 };
 export type NetworkType = 'integrationnet' | 'mainnet' | 'testnet';
 export type ProjectInfo = {
-    autoRestart: boolean;
-    autoStart: boolean;
-    autoUpdate: boolean;
     dagAddress: string;
     fastForward: boolean;
     homeDir: string;
@@ -103,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,83 +41,102 @@ 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(layer) {
-        const envInfo = this.projectStore.getItem('env');
+    getEnvLayerInfo(network, layer) {
+        const envInfo = this.projectStore.getItem('layer-env');
+        if (!envInfo)
+            return { [network]: {} };
+        return envInfo[network][layer] || {};
+    }
+    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] !== undefined;
+        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');
@@ -137,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) {