@constellation-network/node-pilot 0.18.0-testnet → 0.18.1-intnet

package/dist/config-store.js

@@ -1,10 +1,6 @@
-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 packageJson from '../package.json' with { type: 'json' };
-import { clm } from "./clm.js";
 const pilotReleaseInfo = { name: packageJson.name, version: packageJson.version };
 class EmptyStorage extends JSONStorage {
     constructor() { super("/tmp"); }
@@ -12,52 +8,7 @@ class EmptyStorage extends JSONStorage {
     setItem(_key, _value) { }
 }
 class ConfigStore {
-    pilotStore;
-    projectStore;
-    constructor() {
-        const appDir = path.join(os.homedir(), '.node-pilot');
-        if (!fs.existsSync(appDir)) {
-            fs.mkdirSync(path.join(appDir, 'logs'), { 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: [], restarting: 0, running: [] });
-        }
-        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.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 });
-    }
-    getActiveProject() {
-        const { project } = this.pilotStore.getItem('pilot');
-        return project;
-    }
-    getAppDir() {
-        const { appDir } = this.pilotStore.getItem('pilot');
-        return appDir;
-    }
+    projectStore = new EmptyStorage();
     getDockerEnvInfo() {
         return this.projectStore.getItem('docker');
     }
@@ -82,7 +33,7 @@ class ConfigStore {
         return { CLI: layerInfo.CL_CLI_HTTP_PORT, P2P: layerInfo.CL_P2P_HTTP_PORT, PUBLIC: layerInfo.CL_PUBLIC_HTTP_PORT };
     }
     getNetworkInfo() {
-        return this.projectStore.getItem('network');
+        return this.projectStore.getItem('network') || {};
     }
     getPilotReleaseInfo() {
         return pilotReleaseInfo;
@@ -90,45 +41,10 @@ class ConfigStore {
     getProjectInfo() {
         return this.projectStore.getItem('project') || {};
     }
-    getProjects() {
-        const { projects } = this.pilotStore.getItem('pilot');
-        return projects;
-    }
-    getRunningProjects() {
-        const { running } = this.pilotStore.getItem('pilot');
-        return running;
-    }
-    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;
-    }
-    isRestarting() {
-        const { restarting } = this.pilotStore.getItem('pilot');
-        if (restarting && restarting + 1000 * 60 * 5 < Date.now()) {
-            this.setIsRestarting(0);
-            return false;
-        }
-        return restarting > 0;
-    }
-    setActiveProject(name) {
-        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.`);
-        }
-    }
     setClusterStats(info) {
         const oldInfo = this.projectStore.getItem('cluster-stats');
         this.projectStore.setItem('cluster-stats', { ...oldInfo, ...info });
@@ -155,13 +71,14 @@ class ConfigStore {
             networks = {};
         this.projectStore.setItem('network-env', { ...networks, [network]: { ...networks[network], ...info } });
     }
-    setIsRestarting(val) {
-        this.setPilotInfo({ restarting: val });
-    }
     setNetworkInfo(info) {
         const oldInfo = this.projectStore.getItem('network');
         this.projectStore.setItem('network', { ...oldInfo, ...info });
     }
+    setProjectConfig(config) {
+        const projectExists = fs.existsSync(config);
+        this.projectStore = projectExists ? new JSONStorage(config) : new EmptyStorage();
+    }
     setProjectFlag(name, value) {
         const flags = this.projectStore.getItem('flags') || {};
         flags[name] = value;
@@ -172,31 +89,6 @@ class ConfigStore {
         const oldInfo = this.projectStore.getItem('project');
         this.projectStore.setItem('project', { ...oldInfo, ...info });
     }
-    setProjectStatusToRunning(isRunning) {
-        const { project, running } = this.pilotStore.getItem('pilot');
-        if (isRunning) {
-            if (running.includes(project))
-                return;
-            this.setPilotInfo({ running: [...running, project] });
-        }
-        else {
-            if (!running.includes(project))
-                return;
-            running.splice(running.indexOf(project), 1);
-            this.setPilotInfo({ running });
-        }
-    }
-    setSystemInfo(info) {
-        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 envNames = {
@@ -214,7 +106,7 @@ export const networkEnvNames = {
     CL_L0_PEER_HTTP_PORT: 1,
     CL_L0_PEER_ID: 1,
     CL_L0_PEER_P2P_PORT: 1,
-    CL_L0_TOKEN_IDENTIFIER: 1,
+    CL_L0_TOKEN_IDENTIFIER: 1
 };
 // NETWORK LAYER
 export const layerEnvNames = {
@@ -229,5 +121,6 @@ export const layerEnvNames = {
     CL_L0_PEER_P2P_PORT: 1,
     CL_LB: 1,
     CL_P2P_HTTP_PORT: 1,
-    CL_PUBLIC_HTTP_PORT: 1
+    CL_PUBLIC_HTTP_PORT: 1,
+    CL_SOURCE_HTTP_PORT: 1
 };

package/dist/helpers/config-helper.js

@@ -4,9 +4,10 @@ import fs from "node:fs";
 import path from "node:path";
 import { clm } from "../clm.js";
 import { configStore } from "../config-store.js";
+import { pilotManager } from "./pilot-manager.js";
 export const configHelper = {
     assertProject(prefix = '') {
-        if (configStore.hasProjects())
+        if (pilotManager.hasProjects())
             return;
         clm.error(prefix + 'Please create a new project first.');
     },

package/dist/helpers/pilot-manager.d.ts

@@ -0,0 +1,23 @@
+import { SystemInfo } from "../config-store.js";
+export declare class PilotManager {
+    private pilotStore;
+    constructor();
+    applyNewProjectStore(name: string, type: 'hypergraph' | 'metagraph'): Promise<void>;
+    getActiveProject(): string;
+    getAppDir(): string;
+    getProjectDir(project: string): string;
+    getProjects(): string[];
+    getRunningProjects(): string[];
+    getSystemInfo(): SystemInfo;
+    hasProjects(): boolean;
+    isProjectInstalled(): boolean;
+    isRestarting(): boolean;
+    removeProject(name: string): Promise<void>;
+    setActiveProject(name: string, isNewProject?: boolean): void;
+    setIsRestarting(val: number): void;
+    setProjectStatusToRunning(isRunning: boolean): void;
+    setSystemInfo(info: Partial<SystemInfo>): void;
+    private getPilotInfo;
+    private setPilotInfo;
+}
+export declare const pilotManager: PilotManager;

package/dist/helpers/pilot-manager.js

@@ -0,0 +1,170 @@
+import { input } from "@inquirer/prompts";
+import chalk from "chalk";
+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";
+import { configStore } from "../config-store.js";
+import { shellService } from "../services/shell-service.js";
+import { promptHelper } from "./prompt-helper.js";
+export class PilotManager {
+    pilotStore;
+    constructor() {
+        const appDir = path.join(os.homedir(), '.node-pilot');
+        if (!fs.existsSync(appDir)) {
+            fs.mkdirSync(path.join(appDir, 'logs'), { 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: [], restarting: 0, running: [] });
+        }
+        const { project } = this.pilotStore.getItem('pilot');
+        const projectPath = path.join(appDir, project, 'config');
+        configStore.setProjectConfig(projectPath);
+    }
+    async applyNewProjectStore(name, type) {
+        const { appDir, projects } = this.pilotStore.getItem('pilot');
+        const projectDir = path.join(appDir, name);
+        if (projects.includes(name)) {
+            if (fs.existsSync(projectDir)) {
+                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.setPilotInfo({ project: name });
+                }
+                else {
+                    clm.error(`Project ${name} already exists.`);
+                }
+            }
+            else {
+                this.setPilotInfo({ project: name });
+            }
+        }
+        else {
+            this.setPilotInfo({ project: name, projects: [...projects, name] });
+        }
+        fs.mkdirSync(path.join(projectDir, 'config'), { recursive: true });
+        // this.projectStore = new JSONStorage(path.join(projectDir,'config'));
+        configStore.setProjectConfig(path.join(projectDir, 'config'));
+        configStore.setDockerEnvInfo({ DOCKER_IMAGE_VERSION: 'test' });
+        configStore.setProjectInfo({ name, projectDir, type });
+    }
+    getActiveProject() {
+        const { project } = this.pilotStore.getItem('pilot');
+        return project;
+    }
+    getAppDir() {
+        const { appDir } = this.pilotStore.getItem('pilot');
+        return appDir;
+    }
+    getProjectDir(project) {
+        const { appDir } = this.pilotStore.getItem('pilot');
+        const dir = path.join(appDir, project);
+        if (fs.existsSync(dir))
+            return dir;
+        throw new Error(`Project ${project} doesn't exist.`);
+    }
+    getProjects() {
+        const { projects } = this.pilotStore.getItem('pilot');
+        return projects;
+    }
+    getRunningProjects() {
+        const { running } = this.pilotStore.getItem('pilot');
+        return running;
+    }
+    getSystemInfo() {
+        return this.pilotStore.getItem('system');
+    }
+    hasProjects() {
+        const { projects } = this.pilotStore.getItem('pilot');
+        return projects.length > 0;
+    }
+    isProjectInstalled() {
+        const { appDir, projects } = this.pilotStore.getItem('pilot');
+        const activeProject = this.getActiveProject();
+        return projects.includes(activeProject) && fs.existsSync(path.join(appDir, activeProject));
+    }
+    isRestarting() {
+        const { restarting } = this.pilotStore.getItem('pilot');
+        if (restarting && restarting + 1000 * 60 * 5 < Date.now()) {
+            this.setIsRestarting(0);
+            return false;
+        }
+        return restarting > 0;
+    }
+    async removeProject(name) {
+        let { project, projects } = this.pilotStore.getItem('pilot');
+        projects.splice(projects.indexOf(name), 1);
+        if (projects.length === 0) {
+            clm.error(`Project ${name} cannot be removed as it is the only active project.`);
+        }
+        if (project === name) {
+            project = projects[0];
+            if (project) {
+                clm.postStep(`Active project has been changed to ${project}`);
+            }
+        }
+        try {
+            const projectDir = this.getProjectDir(name);
+            clm.warn(`WARNING: This will remove all data and logs associated with the project ${chalk.cyan(name)}. Use with caution.`);
+            await promptHelper.doYouWishToContinue();
+            clm.warn('Running with "sudo" which may request your password...');
+            await shellService.runCommand(`sudo rm -rf ${projectDir}`);
+        }
+        catch {
+            clm.warn(`Project ${name} not found.`);
+        }
+        this.setPilotInfo({ project, projects });
+    }
+    setActiveProject(name, isNewProject = false) {
+        const { appDir, project, projects } = this.pilotStore.getItem('pilot');
+        if (projects && projects.includes(name)) {
+            if (project === name)
+                return;
+            configStore.setProjectConfig(path.join(appDir, name, 'config'));
+            this.setPilotInfo({ project: name });
+        }
+        else if (isNewProject) {
+            this.setPilotInfo({ project: name });
+        }
+        else {
+            throw new Error(`Project ${name} doesn't exist.`);
+        }
+    }
+    setIsRestarting(val) {
+        this.setPilotInfo({ restarting: val });
+    }
+    setProjectStatusToRunning(isRunning) {
+        const { project, running } = this.pilotStore.getItem('pilot');
+        if (isRunning) {
+            if (running.includes(project))
+                return;
+            this.setPilotInfo({ running: [...running, project] });
+        }
+        else {
+            if (!running.includes(project))
+                return;
+            running.splice(running.indexOf(project), 1);
+            this.setPilotInfo({ running });
+        }
+    }
+    setSystemInfo(info) {
+        const oldInfo = this.pilotStore.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 pilotManager = new PilotManager();

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

@@ -3,12 +3,13 @@ export declare const projectHelper: {
     cleanup(layers: TessellationLayer[], deleteData: boolean, deleteLogs: boolean, deleteJars: boolean): Promise<void>;
     generateLayerEnvFiles(layers?: TessellationLayer[]): Promise<void>;
     importEnvFiles(): void;
-    installEmbedded(name: string): Promise<void>;
+    installEmbedded(embeddedName: string, projectName: string, projectType: "hypergraph" | "metagraph"): Promise<void>;
     installFromGithub(_repo: string): Promise<never>;
     installHypergraph(): Promise<void>;
-    installProject(name: string, projectFolder: string): Promise<void>;
+    installProject(name: string, type: "hypergraph" | "metagraph", projectFolder: string): Promise<void>;
     prepareDataFolder(): void;
     selectProject(): Promise<void>;
+    updateDockerEnv(): void;
     upgradeEmbedded(name: string): void;
     upgradeHypergraph(): void;
     upgradeProject(name: string, projectFolder: string): void;

package/dist/helpers/project-helper.js

@@ -9,6 +9,7 @@ import { githubService } from "../services/github-service.js";
 import { shellService } from "../services/shell-service.js";
 import { configHelper } from "./config-helper.js";
 import { getLayerEnvFileContent } from "./env-templates.js";
+import { pilotManager } from "./pilot-manager.js";
 import { promptHelper } from "./prompt-helper.js";
 export const projectHelper = {
     async cleanup(layers, deleteData, deleteLogs, deleteJars) {
@@ -73,12 +74,12 @@ export const projectHelper = {
         // eslint-disable-next-line no-warning-comments
         // TODO: verify all required env variables are present
     },
-    async installEmbedded(name) {
-        const projectFolder = path.resolve(path.dirname(fileURLToPath(import.meta.url)), `../../projects/${name}`);
+    async installEmbedded(embeddedName, projectName, projectType) {
+        const projectFolder = path.resolve(path.dirname(fileURLToPath(import.meta.url)), `../../projects/${embeddedName}`);
         if (!fs.existsSync(projectFolder)) {
             clm.error(`Project folder not found: ${projectFolder}`);
         }
-        await this.installProject(name, projectFolder);
+        await this.installProject(projectName, projectType, projectFolder);
         // Set the project version to match the latest Pilot version. This prevents previous migration scripts from running.
         configStore.setProjectInfo({ version: configStore.getPilotReleaseInfo().version });
     },
@@ -88,28 +89,21 @@ export const projectHelper = {
         throw new Error('installFromGithub - Not implemented');
     },
     async installHypergraph() {
-        await this.installEmbedded('hypergraph');
+        const name = pilotManager.getActiveProject() || 'hypergraph';
+        await this.installEmbedded('hypergraph', name, 'hypergraph');
         this.prepareDataFolder();
-        // const {projectDir} = configStore.getProjectInfo();
-        // const {platform} = configStore.getSystemInfo();
-        //
-        // if (platform === 'linux') {
-        //     const layerDir = path.join(projectDir,'gl0');
-        //     // set permission for group "docker" on the layer folder and any subfolders created later
-        //     await shellService.runCommand(`sudo setfacl -Rm g:docker:rwX -dm g:docker:rwX ${layerDir}`)
-        // }
         this.importEnvFiles();
     },
-    async installProject(name, projectFolder) {
-        if (!configStore.hasProjects()) {
+    async installProject(name, type, projectFolder) {
+        if (!pilotManager.hasProjects()) {
             // On first install, copy scripts
             const scriptsFolder = path.resolve(path.dirname(fileURLToPath(import.meta.url)), `../../scripts`);
-            const projectDir = path.join(configStore.getAppDir(), 'scripts');
+            const projectDir = path.join(pilotManager.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);
+        await pilotManager.applyNewProjectStore(name, type);
         const { projectDir } = configStore.getProjectInfo();
         clm.debug(`Installing project from ${projectFolder} to ${projectDir}`);
         fs.cpSync(projectFolder, projectDir, { recursive: true });
@@ -146,7 +140,7 @@ export const projectHelper = {
             });
             const ghRepoRegex = /^https?:\/\/(?:www\.)?github\.com\/([A-Za-z0-9](?:-?[A-Za-z0-9]){0,38})\/([A-Za-z0-9._-]+)(?:\.git)?\/?$/;
             if (project === 'dor') {
-                await this.installEmbedded('dor');
+                await this.installEmbedded('dor', 'dor', 'metagraph');
             }
             else if (project === 'custom') {
                 let repo = await input({
@@ -173,6 +167,33 @@ export const projectHelper = {
             }
         }
     },
+    updateDockerEnv() {
+        const { type: network } = configStore.getNetworkInfo();
+        let CL_GL0_PUBLIC_PORT = '';
+        let CL_GL0_P2P_PORT = '';
+        let CL_GL1_PUBLIC_PORT = '';
+        let CL_GL1_P2P_PORT = '';
+        const { layersToRun } = configStore.getProjectInfo();
+        for (const layer of layersToRun) {
+            const info = configStore.getEnvLayerInfo(network, layer);
+            switch (layer) {
+                case 'gl0': {
+                    CL_GL0_P2P_PORT = info.CL_P2P_HTTP_PORT;
+                    CL_GL0_PUBLIC_PORT = info.CL_PUBLIC_HTTP_PORT;
+                    break;
+                }
+                case 'gl1': {
+                    CL_GL1_P2P_PORT = info.CL_P2P_HTTP_PORT;
+                    CL_GL1_PUBLIC_PORT = info.CL_PUBLIC_HTTP_PORT;
+                    break;
+                }
+            }
+        }
+        configStore.setDockerEnvInfo({
+            CL_GL0_P2P_PORT, CL_GL0_PUBLIC_PORT,
+            CL_GL1_P2P_PORT, CL_GL1_PUBLIC_PORT
+        });
+    },
     upgradeEmbedded(name) {
         const projectFolder = path.resolve(path.dirname(fileURLToPath(import.meta.url)), `../../projects/${name}`);
         if (!fs.existsSync(projectFolder)) {
@@ -183,6 +204,7 @@ export const projectHelper = {
     upgradeHypergraph() {
         this.upgradeEmbedded('hypergraph');
         this.importEnvFiles();
+        this.updateDockerEnv();
     },
     upgradeProject(name, projectFolder) {
         const { projectDir } = configStore.getProjectInfo();

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

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

package/dist/helpers/prompt-helper.js

@@ -1,10 +1,22 @@
-import { checkbox, input, select } from "@inquirer/prompts";
+import { checkbox, input, number, select } from "@inquirer/prompts";
 import chalk from "chalk";
 import { clm } from "../clm.js";
 import { configStore } from "../config-store.js";
 import { dockerService } from "../services/docker-service.js";
 import { nodeService } from "../services/node-service.js";
 export const promptHelper = {
+    async configurePorts() {
+        const defaults = { cl1: [9300, 9301], dl1: [9400, 9401], gl0: [9000, 9001], gl1: [9100, 9101], ml0: [9200, 9201] };
+        const { layersToRun } = configStore.getProjectInfo();
+        const { type: network } = configStore.getNetworkInfo();
+        for (const layer of layersToRun) {
+            // eslint-disable-next-line no-await-in-loop
+            const port1 = await number({ default: defaults[layer][0], message: `${layer} Public Port:`, required: true, validate: v => v !== undefined && v > 0 && v <= 65_535 });
+            // eslint-disable-next-line no-await-in-loop
+            const port2 = await number({ default: defaults[layer][1], message: `${layer} P2P Port:`, required: true, validate: v => v !== undefined && v > 0 && v <= 65_535 });
+            configStore.setEnvLayerInfo(network, layer, { CL_P2P_HTTP_PORT: port2.toString(), CL_PUBLIC_HTTP_PORT: port1.toString() });
+        }
+    },
     async confirmPrompt(msg) {
         const result = await input({
             default: 'y',
@@ -34,8 +46,8 @@ export const promptHelper = {
         }
     },
     async selectLayers() {
-        const { name } = configStore.getProjectInfo();
-        const choices = name === 'hypergraph' ? ['gl0', 'gl1'] : ['ml0', 'cl1', 'dl1'];
+        const { name, type } = configStore.getProjectInfo();
+        const choices = type === 'hypergraph' ? ['gl0', 'gl1'] : ['ml0', 'cl1', 'dl1'];
         const result = await checkbox({ choices, message: `Select network layers to run for ${chalk.cyan(name)}:`, validate: v => v.length > 0 });
         configStore.setProjectInfo({ layersToRun: result });
     },

package/dist/helpers/service-log.js

@@ -1,12 +1,12 @@
 import fs from "node:fs";
 import path from "node:path";
-import { configStore } from "../config-store.js";
+import { pilotManager } from "./pilot-manager.js";
 export const serviceLog = {
     error(s) {
         this.log(s);
     },
     log(s) {
-        const appDir = configStore.getAppDir();
+        const appDir = pilotManager.getAppDir();
         const logFile = path.join(appDir, 'logs', 'service.log');
         fs.appendFileSync(logFile, s + '\n');
     },

package/dist/helpers/status-table.js

@@ -5,6 +5,7 @@ import os from "node:os";
 import ttyTable from "tty-table";
 import { clm } from "../clm.js";
 import { configStore } from "../config-store.js";
+import { pilotManager } from "./pilot-manager.js";
 import { formatTimeAgo, glHeader1, glHeader2, statusTableHeader } from "./status-table-helper.js";
 export class StatusTable {
     alreadyRendered = false;
@@ -35,21 +36,21 @@ export class StatusTable {
     }
     getProjectInfo() {
         const appPath = os.homedir() + '/.node-pilot';
-        const activeProject = configStore.getActiveProject();
-        const projects = configStore.getRunningProjects();
+        const activeProject = pilotManager.getActiveProject();
+        const projects = pilotManager.getRunningProjects();
         if (!activeProject || projects.length === 0) {
             clm.error("No projects are running.");
         }
         const info = [];
         for (const project of projects) {
-            configStore.setActiveProject(project);
+            pilotManager.setActiveProject(project);
             const { layersToRun } = configStore.getProjectInfo();
             const { type: network } = configStore.getNetworkInfo();
             for (const layer of layersToRun) {
                 info.push({ layer, network, path: `${appPath}/${project}/${layer}/data/health-check/node`, project });
             }
         }
-        configStore.setActiveProject(activeProject);
+        pilotManager.setActiveProject(activeProject);
         return info;
     }
     async monitorNarrow() {

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

@@ -10,8 +10,9 @@ export declare const clusterService: {
     getSourceNodeInfo(layer: TessellationLayer): Promise<NodeInfo>;
     getSourceNodeLatestOrdinal(layer: TessellationLayer): Promise<number>;
     getSourceNodeOrdinalHash(layer: TessellationLayer, ordinal: number): Promise<string>;
-    makeClusterRequestGet(path: string, layer?: TessellationLayer): Promise<any>;
+    makeClusterRequestGet(path: string, layer?: TessellationLayer, params?: string): Promise<any>;
     makeClusterRequestPost(path: string, body: string, layer?: TessellationLayer): Promise<any>;
+    makeRandomSourceNodeRequest(path: string, layer: TessellationLayer): Promise<any>;
     makeSourceNodeRequest(path: string, layer: TessellationLayer): Promise<any>;
     postNodeParams(body: string, layer?: TessellationLayer): Promise<string>;
 };