@constellation-network/node-pilot 0.0.1

package/dist/commands/config/get.js

@@ -0,0 +1,37 @@
+import { Args, Command } from '@oclif/core';
+import { commonEnvNames, configStore, layerEnvNames } from "../../config-store.js";
+import { configHelper } from "../../helpers/config-helper.js";
+export default class ConfigGet extends Command {
+    static args = {
+        name: Args.string({ description: 'configuration to get' }),
+    };
+    static description = 'Show all configuration settings or a specific one';
+    static examples = [
+        '<%= config.bin %> <%= command.id %>',
+        '<%= config.bin %> <%= command.id %> CL_EXTERNAL_IP',
+        '<%= config.bin %> <%= command.id %> gl0:CL_PUBLIC_HTTP_PORT',
+    ];
+    async run() {
+        configHelper.assertProject('No configuration found. ');
+        const { args } = await this.parse(ConfigGet);
+        const info = configStore.getEnvInfo();
+        const { layersToRun } = configStore.getProjectInfo();
+        const common = info.common;
+        const layers = info.layers;
+        if (Object.keys(args).length === 0 || args.name === undefined) {
+            const commonsList = Object.keys(commonEnvNames).sort().map(k => ({ name: k, value: common[k] }));
+            const layersList = layersToRun.map(l => (Object.keys(layerEnvNames).map(k => ({ name: `${l}:${k}`, value: layers[l][k] }))));
+            // const layersList = layersToRun.map(l => (Object.keys(layerEnvNames).map(k => `${l}:${k}="${green(layers[l][k] || '')}"`)))
+            configHelper.showEnvInfoList(commonsList);
+            configHelper.showEnvInfoList(layersList.flat());
+        }
+        else if (args.name.includes(':')) {
+            const [layer, name] = args.name.split(':');
+            configHelper.showEnvInfo(args.name, layers[layer][name]);
+        }
+        else {
+            // const props = keyof EnvCommonInfo
+            configHelper.showEnvInfo(args.name, common[args.name]);
+        }
+    }
+}

package/dist/commands/config/set.d.ts

@@ -0,0 +1,11 @@
+import { Command } from '@oclif/core';
+export default class ConfigSet extends Command {
+    static args: {
+        name: import("@oclif/core/interfaces").Arg<string, Record<string, unknown>>;
+        value: import("@oclif/core/interfaces").Arg<string, Record<string, unknown>>;
+    };
+    static description: string;
+    static examples: string[];
+    logErrorAndExit(message: string): void;
+    run(): Promise<void>;
+}

package/dist/commands/config/set.js

@@ -0,0 +1,41 @@
+import { Args, Command } from '@oclif/core';
+import { commonEnvNames, configStore, layerEnvNames } from "../../config-store.js";
+import { configHelper } from "../../helpers/config-helper.js";
+export default class ConfigSet extends Command {
+    static args = {
+        name: Args.string({ description: 'configuration name', required: true }),
+        value: Args.string({ description: 'the value to set to the configuration', required: true }),
+    };
+    static description = 'Set a configuration setting';
+    static examples = [
+        '<%= 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.includes(':')) {
+            const [layer, name] = args.name.split(':');
+            if (!layersToRun.includes(layer)) {
+                this.logErrorAndExit(`Invalid layer: ${layer}. Available layers: ${layersToRun.join(',')}`);
+            }
+            const validLayer = layer;
+            if (!Object.hasOwn(layerEnvNames, name)) {
+                this.logErrorAndExit(`Invalid layer configuration name: ${name}`);
+            }
+            configStore.setEnvLayerInfo(validLayer, { [name]: args.value });
+        }
+        else {
+            const { name } = args;
+            if (!Object.hasOwn(commonEnvNames, name)) {
+                this.logErrorAndExit(`Invalid configuration name: ${name}`);
+            }
+            configStore.setEnvCommonInfo({ [name]: args.value });
+        }
+    }
+}

package/dist/commands/config.d.ts

@@ -0,0 +1,6 @@
+import { Command } from '@oclif/core';
+export default class Config extends Command {
+    static description: string;
+    static examples: string[];
+    run(): Promise<void>;
+}

package/dist/commands/config.js

@@ -0,0 +1,65 @@
+import { select } from '@inquirer/prompts';
+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";
+export default class Config extends Command {
+    static description = 'Update configuration settings';
+    static examples = [
+        '<%= config.bin %> <%= command.id %>'
+    ];
+    async run() {
+        configHelper.assertProject('No configuration found. ');
+        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' },
+            ],
+            message: 'What would you like to change?:',
+        });
+        // eslint-disable-next-line unicorn/prefer-switch
+        if (answer === 'autoRestart') {
+            await promptHelper.configureAutoRestart();
+        }
+        else if (answer === 'externalIp') {
+            await checkNetwork.configureIpAddress();
+        }
+        else if (answer === 'javaMemory') {
+            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 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 promptHelper.selectLayers();
+            await promptHelper.configureJavaMemoryArguments();
+        }
+        else if (answer === 'network') {
+            await promptHelper.selectNetwork();
+            await checkProject.runInstall();
+        }
+    }
+}

package/dist/commands/info.d.ts

@@ -0,0 +1,6 @@
+import { Command } from '@oclif/core';
+export default class Info extends Command {
+    static description: string;
+    static examples: string[];
+    run(): Promise<void>;
+}

package/dist/commands/info.js

@@ -0,0 +1,32 @@
+import { Command } from '@oclif/core';
+import { configStore } from "../config-store.js";
+import { configHelper } from "../helpers/config-helper.js";
+export default class Info extends Command {
+    static description = 'Display general info about the validator node';
+    static examples = [
+        '<%= config.bin %> <%= command.id %>',
+    ];
+    async run() {
+        configHelper.assertProject('No project info found. ');
+        const projectInfo = configStore.getProjectInfo();
+        const networkInfo = configStore.getNetworkInfo();
+        // Project Name
+        configHelper.showEnvInfo('Project Name', projectInfo.name);
+        // DAG Address
+        configHelper.showEnvInfo('DAG Address', projectInfo.dagAddress);
+        // Node ID
+        configHelper.showEnvInfo('Node ID', projectInfo.nodeId);
+        // Layers to Run
+        configHelper.showEnvInfo('Layers to Run', projectInfo.layersToRun.join(', '));
+        // Network type
+        configHelper.showEnvInfo('Network', networkInfo.type);
+        // Network version
+        configHelper.showEnvInfo('Network Version', networkInfo.version);
+        // Project Directory
+        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

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

package/dist/commands/logs.js

@@ -0,0 +1,28 @@
+import { Args, Command, Flags } from '@oclif/core';
+import path from "node:path";
+import { shellService } from "../services/shell-service.js";
+import { configStore } from "../config-store.js";
+import { configHelper } from "../helpers/config-helper.js";
+export default class Logs extends Command {
+    static args = {
+        layer: Args.string({ description: 'network layer to view. e.g. gl0' }),
+    };
+    static description = 'view validator node runtime logs';
+    static examples = [
+        '<%= config.bin %> <%= command.id %>',
+    ];
+    static flags = {
+        follow: Flags.boolean({ char: 'f', description: 'continuously wait for additional data to be appended' }),
+    };
+    async run() {
+        configHelper.assertProject('No project found. ');
+        let tailFlag = '';
+        const { flags } = await this.parse(Logs);
+        if (flags.follow) {
+            tailFlag = '-f';
+        }
+        const { projectDir } = configStore.getProjectInfo();
+        const logPath = path.join(projectDir, 'app-data', 'gl0-logs', 'app.log');
+        await shellService.runCommand(`tail ${tailFlag} ${logPath}`).catch(() => 1);
+    }
+}

package/dist/commands/restart.d.ts

@@ -0,0 +1,6 @@
+import { Command } from '@oclif/core';
+export default class Restart extends Command {
+    static description: string;
+    static examples: string[];
+    run(): Promise<void>;
+}

package/dist/commands/restart.js

@@ -0,0 +1,25 @@
+import { Command } from '@oclif/core';
+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 { nodeService } from "../services/node-service.js";
+export default class Restart extends Command {
+    static description = 'A full shutdown of the validator node, then restart';
+    static examples = [
+        '<%= config.bin %> <%= command.id %>',
+    ];
+    async run() {
+        configHelper.assertProject('No project found. ');
+        const { layersToRun } = configStore.getProjectInfo();
+        await nodeService.leaveClusterAllLayers();
+        await nodeService.pollForLayersState(layersToRun, 'Offline');
+        clm.preStep('Stopping the node...');
+        await dockerHelper.dockerDown();
+        clm.preStep('Checking for a new version...');
+        await checkProject.runUpgrade();
+        clm.preStep('Starting the node...');
+        await dockerHelper.dockerUp();
+    }
+}

package/dist/commands/shutdown.d.ts

@@ -0,0 +1,6 @@
+import { Command } from '@oclif/core';
+export default class Shutdown extends Command {
+    static description: string;
+    static examples: string[];
+    run(): Promise<void>;
+}

package/dist/commands/shutdown.js

@@ -0,0 +1,18 @@
+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";
+export default class Shutdown extends Command {
+    static description = 'A full shutdown of the validator node';
+    static examples = [
+        '<%= config.bin %> <%= command.id %>',
+    ];
+    async run() {
+        configHelper.assertProject('No project found. ');
+        const { layersToRun } = configStore.getProjectInfo();
+        await nodeService.leaveClusterAllLayers();
+        await nodeService.pollForLayersState(layersToRun, 'Offline');
+        await dockerHelper.dockerDown();
+    }
+}

package/dist/commands/status.d.ts

@@ -0,0 +1,6 @@
+import { Command } from '@oclif/core';
+export default class Status extends Command {
+    static description: string;
+    run(): Promise<void>;
+}
+export declare function checkInstallationAndConfigurationStatus(): Promise<void>;

package/dist/commands/status.js

@@ -0,0 +1,22 @@
+import { Command } from '@oclif/core';
+import { checkInitialSetup } from "../checks/check-initial-setup.js";
+import { checkLayers } from "../checks/check-layers.js";
+import { checkProject } from "../checks/check-project.js";
+import { keyFileHelper } from "../helpers/key-file-helper.js";
+export default class Status extends Command {
+    // eslint-disable-next-line no-warning-comments
+    // TODO add -f flag to continuously monitor status
+    static description = 'Display node status and configuration settings';
+    async run() {
+        await checkInstallationAndConfigurationStatus();
+    }
+}
+export async function checkInstallationAndConfigurationStatus() {
+    await checkInitialSetup.firstTimeRun();
+    await checkProject.projectInstallation();
+    await checkProject.releaseVersion();
+    await keyFileHelper.promptIfNoKeyFile();
+    await checkLayers.layersRunning();
+    await checkLayers.layersReadyToJoin();
+    await checkLayers.layersStatus();
+}

package/dist/commands/test.d.ts

@@ -0,0 +1,6 @@
+import { Command } from "@oclif/core";
+export default class Test extends Command {
+    static description: string;
+    static hidden: boolean;
+    run(): Promise<void>;
+}

package/dist/commands/test.js

@@ -0,0 +1,13 @@
+import { Command } from "@oclif/core";
+import fs from "node:fs";
+export default class Test extends Command {
+    static description = 'node pilot test command';
+    static hidden = true;
+    async run() {
+        // await promptHelper.configureJavaMemoryArguments();
+        const r = fs.statfsSync('/');
+        const totalSpace = (r.bsize * r.blocks / (1024 * 1024 * 1024)).toFixed(2);
+        const totalFreeSpace = (r.bsize * r.bfree / (1024 * 1024 * 1024)).toFixed(2);
+        console.log(totalSpace, totalFreeSpace);
+    }
+}

package/dist/config-store.d.ts

@@ -0,0 +1,109 @@
+import { TessellationLayer } from "./types.js";
+declare class ConfigStore {
+    private pilotStore;
+    private projectStore;
+    constructor();
+    applyNewProjectStore(name: string): Promise<void>;
+    changeProjectStore(name: string): void;
+    getDockerEnvInfo(): object;
+    getEnvCommonInfo(): EnvCommonInfo;
+    getEnvInfo(): EnvInfo;
+    getEnvLayerInfo(layer: TessellationLayer): EnvLayerInfo;
+    getLayerPortInfo(layer: TessellationLayer): PortInfo;
+    getNetworkEnvInfo(network: NetworkType): EnvCommonInfo;
+    getNetworkInfo(): NetworkInfo;
+    getProjectInfo(): ProjectInfo;
+    getSystemInfo(): SystemInfo;
+    hasProjects(): boolean;
+    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;
+    setNetworkInfo(info: Partial<NetworkInfo>): void;
+    setProjectInfo(info: Partial<ProjectInfo>): void;
+    setSystemInfo(info: SystemInfo): void;
+}
+export declare const configStore: ConfigStore;
+type DeepPartial<T> = {
+    [P in keyof T]?: T[P] extends object ? DeepPartial<T[P]> : T[P];
+};
+export type EnvInfo = {
+    common: EnvCommonInfo;
+    layers: Record<TessellationLayer, EnvLayerInfo>;
+};
+export type EnvCommonInfo = {
+    CL_APP_ENV: string;
+    CL_EXTERNAL_IP: string;
+    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: {
+    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_TOKEN_IDENTIFIER: number;
+    CL_PASSWORD: number;
+};
+export type EnvLayerInfo = {
+    CL_CLI_HTTP_PORT: string;
+    CL_DOCKER_JAVA_OPTS: 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_P2P_HTTP_PORT: number;
+    CL_PUBLIC_HTTP_PORT: number;
+};
+export type SystemInfo = {
+    cores?: number;
+    disk?: string;
+    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;
+    layersToRun: TessellationLayer[];
+    name: string;
+    nodeId: string;
+    projectDir: string;
+};
+export type NetworkInfo = {
+    supportedTypes: NetworkType[];
+    type: NetworkType;
+    version: string;
+};
+export type NetworkEnvInfo = Record<NetworkType, EnvCommonInfo>;
+export type PortInfo = {
+    CLI: string;
+    P2P: string;
+    PUBLIC: string;
+};
+export {};

package/dist/config-store.js

@@ -0,0 +1,151 @@
+import { input } from "@inquirer/prompts";
+import { JSONStorage } from "node-localstorage";
+import fs from "node:fs";
+import os from "node:os";
+import path from "node:path";
+import { clm } from "./clm.js";
+class EmptyStorage extends JSONStorage {
+    constructor() { super("/tmp"); }
+    getItem(_key) { return null; }
+    setItem(_key, _value) { }
+}
+class ConfigStore {
+    pilotStore;
+    projectStore;
+    constructor() {
+        const appDir = path.join(os.homedir(), '.node-pilot');
+        if (!fs.existsSync(appDir)) {
+            fs.mkdirSync(appDir, { recursive: true });
+        }
+        this.pilotStore = new JSONStorage(path.join(appDir, 'config'));
+        const appInfo = this.pilotStore.getItem('pilot');
+        if (!appInfo) {
+            this.pilotStore.setItem('pilot', { appDir, project: 'undefined', projects: [] });
+        }
+        const { project } = this.pilotStore.getItem('pilot');
+        this.projectStore = project === 'undefined' ? new EmptyStorage() : new JSONStorage(path.join(appDir, project, 'config'));
+    }
+    async applyNewProjectStore(name) {
+        const { appDir, projects } = this.pilotStore.getItem('pilot');
+        const projectDir = path.join(appDir, name);
+        if (projects.includes(name)) {
+            const answer = await input({ default: 'n', message: `Project ${name} already exists. Do you want to reinstall? (y/n):` });
+            if (answer === 'y') {
+                this.projectStore = new JSONStorage(path.join(projectDir, 'config'));
+                this.projectStore.clear();
+                fs.rmSync(projectDir, { force: true, recursive: true });
+                this.pilotStore.setItem('pilot', { appDir, project: name, projects });
+            }
+            else {
+                clm.error(`Project ${name} already exists.`);
+            }
+        }
+        else {
+            this.pilotStore.setItem('pilot', { appDir, 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');
+        if (projects && projects.includes(name)) {
+            this.projectStore = new JSONStorage(path.join(appDir, name, 'config'));
+        }
+        else {
+            throw new Error(`Project ${name} doesn't exist.`);
+        }
+    }
+    getDockerEnvInfo() {
+        return this.projectStore.getItem('docker');
+    }
+    getEnvCommonInfo() {
+        return this.projectStore.getItem('env')?.common;
+    }
+    getEnvInfo() {
+        return this.projectStore.getItem('env');
+    }
+    getEnvLayerInfo(layer) {
+        const envInfo = this.projectStore.getItem('env');
+        if (!envInfo)
+            return {};
+        return { ...envInfo.common, ...envInfo.layers[layer] };
+    }
+    getLayerPortInfo(layer) {
+        const layerInfo = this.getEnvLayerInfo(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');
+    }
+    getSystemInfo() {
+        return this.pilotStore.getItem('system');
+    }
+    hasProjects() {
+        const { projects } = this.pilotStore.getItem('pilot');
+        return projects.length > 0;
+    }
+    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 } } });
+    }
+    setNetworkEnvInfo(info) {
+        const oldInfo = this.projectStore.getItem('network-env');
+        this.projectStore.setItem('network-env', { ...oldInfo, ...info });
+    }
+    setNetworkInfo(info) {
+        const oldInfo = this.projectStore.getItem('network');
+        this.projectStore.setItem('network', { ...oldInfo, ...info });
+    }
+    setProjectInfo(info) {
+        const oldInfo = this.projectStore.getItem('project');
+        this.projectStore.setItem('project', { ...oldInfo, ...info });
+    }
+    setSystemInfo(info) {
+        const oldInfo = this.projectStore.getItem('system');
+        this.pilotStore.setItem('system', { ...oldInfo, ...info });
+    }
+}
+export const configStore = new ConfigStore();
+export const commonEnvNames = {
+    CL_APP_ENV: 1,
+    CL_EXTERNAL_IP: 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_TOKEN_IDENTIFIER: 1,
+    CL_PASSWORD: 1
+};
+export const layerEnvNames = {
+    CL_CLI_HTTP_PORT: 1,
+    CL_DOCKER_JAVA_OPTS: 1,
+    CL_P2P_HTTP_PORT: 1,
+    CL_PUBLIC_HTTP_PORT: 1,
+};

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

@@ -0,0 +1,14 @@
+import dotenv from "dotenv";
+export declare const configHelper: {
+    assertProject(prefix?: string): void;
+    getReleaseInfo(): Promise<{
+        network: string;
+        version: string;
+    } | undefined>;
+    parseEnvFile(filePath: string): dotenv.DotenvParseOutput;
+    showEnvInfo(name: string, value: string): void;
+    showEnvInfoList(list: {
+        name: string;
+        value: string;
+    }[]): void;
+};