@powerhousedao/ph-cli 0.33.2-dev.0 → 0.34.2-dev.0

package/dist/src/commands/service.js

@@ -0,0 +1,141 @@
+import { getConfig } from "@powerhousedao/config/powerhouse";
+import { Argument } from "commander";
+import { execSync } from "node:child_process";
+import path from "node:path";
+import { fileURLToPath } from "node:url";
+import pm2 from "pm2";
+const actions = ["start", "stop", "status", "list", "startup", "unstartup"];
+const services = ["switchboard", "connect", "all"];
+let switchboardPort = 8442;
+let connectPort = 8443;
+export const manageService = async (action, service) => {
+    try {
+        const config = getConfig();
+        if (config.reactor?.port) {
+            switchboardPort = config.reactor.port;
+        }
+        if (config.studio?.port) {
+            connectPort = config.studio.port;
+        }
+        pm2.connect((err) => {
+            switch (action) {
+                case "start":
+                    startServices(service);
+                    break;
+                case "stop":
+                    stopServices(service);
+                    break;
+                case "startup":
+                    startupServices();
+                    break;
+                case "unstartup":
+                    unstartupServices();
+                    break;
+                default:
+                    statusServices();
+                    break;
+            }
+        });
+    }
+    catch (error) {
+        console.error(error);
+    }
+};
+export function serviceCommand(program) {
+    program
+        .command("service")
+        .description("Manage services")
+        .addArgument(new Argument("action").choices(actions).default("list"))
+        .addArgument(new Argument("service").choices(services).argOptional().default("all"))
+        .action(manageService);
+}
+function startServices(service) {
+    if (service === "switchboard" || service === "all") {
+        const switchboardOptions = {
+            name: "switchboard",
+            script: "npx ph-cli switchboard",
+        };
+        console.log("Starting Switchboard...");
+        pm2.start(switchboardOptions, (err) => {
+            if (err) {
+                console.log(err.name);
+                // throw new Error(err.message);
+            }
+            dumpServices();
+        });
+        console.log("Switchboard started");
+    }
+    if (service === "connect" || service === "all") {
+        const connectOptions = {
+            name: "connect",
+            script: "npx ph-cli connect",
+            args: ["--port", connectPort.toString()],
+        };
+        console.log("Starting connect...");
+        pm2.start(connectOptions, (err) => {
+            if (err) {
+                throw new Error(err.message);
+            }
+            dumpServices();
+        });
+        console.log("Connect started");
+    }
+}
+function dumpServices() {
+    pm2.dump((err) => {
+        if (err) {
+            throw new Error(err.message);
+        }
+        statusServices();
+    });
+}
+function stopServices(service) {
+    if (service === "all" || service === "connect") {
+        pm2.stop("connect", (err) => {
+            if (err) {
+                throw new Error(err.message);
+            }
+            dumpServices();
+        });
+    }
+    if (service === "all" || service === "switchboard") {
+        pm2.stop("switchboard", (err) => {
+            if (err) {
+                throw new Error(err.message);
+            }
+            dumpServices();
+        });
+    }
+}
+function statusServices() {
+    pm2.list((err, list) => {
+        const formattedList = list.map((item) => {
+            return {
+                id: item.pm_id,
+                name: item.name,
+                pid: item.pid,
+                uptime: item.pm2_env?.pm_uptime,
+                restarts: item.pm2_env?.unstable_restarts,
+                status: item.pm2_env?.status,
+                mem: item.monit?.memory,
+                cpu: item.monit?.cpu,
+            };
+        });
+        console.table(formattedList);
+        process.exit(0);
+    });
+}
+function startupServices() {
+    const dirname = import.meta.dirname || path.dirname(fileURLToPath(import.meta.url));
+    const scriptPath = path.join(dirname, "..", "scripts", "service-startup.sh");
+    const result = execSync(`bash ${scriptPath}`).toString();
+    console.log(result);
+    process.exit(0);
+}
+function unstartupServices() {
+    const dirname = import.meta.dirname || path.dirname(fileURLToPath(import.meta.url));
+    const scriptPath = path.join(dirname, "..", "scripts", "service-unstartup.sh");
+    const result = execSync(`bash ${scriptPath}`).toString();
+    console.log(result);
+    process.exit(0);
+}

package/dist/src/commands/switchboard.d.ts

@@ -0,0 +1,34 @@
+import { LocalReactor, StartServerOptions } from "@powerhousedao/reactor-local";
+import { Command } from "commander";
+import { CommandActionType } from "../types.js";
+export type SwitchboardOptions = StartServerOptions & {
+    configFile?: string;
+    generate?: boolean;
+    watch?: boolean;
+    dbPath?: string;
+};
+export declare const DefaultSwitchboardOptions: {
+    dev: boolean;
+    port: number;
+    storagePath: string;
+    dbPath: string;
+    drive: {
+        global: {
+            id: string;
+            name: string;
+            icon: string;
+            slug: string;
+        };
+        local: {
+            availableOffline: true;
+            listeners: never[];
+            sharingType: string;
+            triggers: never[];
+        };
+    };
+};
+export declare const switchboard: CommandActionType<[
+    SwitchboardOptions
+], Promise<LocalReactor>>;
+export declare function reactorCommand(program: Command): void;
+//# sourceMappingURL=switchboard.d.ts.map

package/dist/src/commands/switchboard.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"switchboard.d.ts","sourceRoot":"","sources":["../../../src/commands/switchboard.ts"],"names":[],"mappings":"AAEA,OAAO,EAEL,YAAY,EAEZ,kBAAkB,EACnB,MAAM,8BAA8B,CAAC;AACtC,OAAO,EAAE,OAAO,EAAE,MAAM,WAAW,CAAC;AACpC,OAAO,EAAE,iBAAiB,EAAE,MAAM,aAAa,CAAC;AAEhD,MAAM,MAAM,kBAAkB,GAAG,kBAAkB,GAAG;IACpD,UAAU,CAAC,EAAE,MAAM,CAAC;IACpB,QAAQ,CAAC,EAAE,OAAO,CAAC;IACnB,KAAK,CAAC,EAAE,OAAO,CAAC;IAChB,MAAM,CAAC,EAAE,MAAM,CAAC;CACjB,CAAC;AAEF,eAAO,MAAM,yBAAyB;;;;;;;;;;;;;;;;;;;CAGrC,CAAC;AA0DF,eAAO,MAAM,WAAW,EAAE,iBAAiB,CACzC;IAAC,kBAAkB;CAAC,EACpB,OAAO,CAAC,YAAY,CAAC,CAGtB,CAAC;AAEF,wBAAgB,cAAc,CAAC,OAAO,EAAE,OAAO,QA0B9C"}

package/dist/src/commands/switchboard.js

@@ -0,0 +1,82 @@
+import { generateFromFile } from "@powerhousedao/codegen";
+import { getConfig } from "@powerhousedao/config/powerhouse";
+import { DefaultStartServerOptions, startServer, } from "@powerhousedao/reactor-local";
+export const DefaultSwitchboardOptions = {
+    ...DefaultStartServerOptions,
+    dev: true,
+};
+async function startLocalSwitchboard(switchboardOptions) {
+    const baseConfig = getConfig(switchboardOptions.configFile);
+    const options = {
+        ...DefaultSwitchboardOptions,
+        ...switchboardOptions,
+    };
+    const { https } = baseConfig.reactor ?? { https: false };
+    const reactor = await startServer({
+        ...options,
+        https,
+        logLevel: baseConfig.logLevel,
+    });
+    if (options.generate) {
+        await addGenerateTransmitter(reactor, baseConfig);
+    }
+    return reactor;
+}
+async function addGenerateTransmitter(reactor, config) {
+    return reactor.addListener("powerhouse", {
+        onStrands: async function (strands) {
+            const documentPaths = new Set();
+            for (const strand of strands) {
+                documentPaths.add(reactor.getDocumentPath(strand.driveId, strand.documentId));
+            }
+            for (const path of documentPaths) {
+                await generateFromFile(path, config);
+            }
+            return Promise.resolve();
+        },
+        onDisconnect: () => Promise.resolve(),
+    }, {
+        filter: {
+            documentType: ["powerhouse/document-model"],
+            scope: ["global"],
+            branch: ["*"],
+            documentId: ["*"],
+        },
+        block: false,
+        listenerId: "reactor-local-document-model-generator",
+        label: "reactor-local-document-model-generator",
+    });
+}
+export const switchboard = (options) => {
+    return startLocalSwitchboard(options);
+};
+export function reactorCommand(program) {
+    program
+        .command("switchboard")
+        .alias("reactor")
+        .description("Starts local switchboard")
+        .option("--port <PORT>", "port to host the api", "4001")
+        .option("--config-file <configFile>", "Path to the powerhouse.config.js file", "./powerhouse.config.json")
+        .option("--generate", "generate code when document model is updated")
+        .option("--db-path <DB_PATH>", "path to the database")
+        .option("--https-key-file <HTTPS_KEY_FILE>", "path to the ssl key file")
+        .option("--https-cert-file <HTTPS_CERT_FILE>", "path to the ssl cert file")
+        .option("-w, --watch", "if the reactor should watch for local changes to document models and processors")
+        .option("--packages <packages...>", "list of packages to be loaded, if defined then packages on config file are ignored")
+        .action(async (...args) => {
+        await switchboard(...args);
+    });
+}
+if (process.argv.at(2) === "spawn") {
+    const optionsArg = process.argv.at(3);
+    const options = optionsArg
+        ? JSON.parse(optionsArg)
+        : {};
+    startLocalSwitchboard(options)
+        .then((switchboard) => {
+        process.send?.(`driveUrl:${switchboard.driveUrl}`);
+    })
+        .catch((e) => {
+        throw e;
+    });
+}

package/dist/src/commands/uninstall.d.ts

@@ -0,0 +1,15 @@
+import { Command } from "commander";
+import { CommandActionType } from "../types.js";
+import { PackageManager } from "../utils.js";
+export declare function uninstallDependency(packageManager: PackageManager, dependencies: string[], projectPath: string, workspace?: boolean): void;
+export declare const uninstall: CommandActionType<[
+    string[] | undefined,
+    {
+        debug?: boolean;
+        global?: boolean;
+        workspace?: boolean;
+        packageManager?: string;
+    }
+]>;
+export declare function uninstallCommand(program: Command): void;
+//# sourceMappingURL=uninstall.d.ts.map

package/dist/src/commands/uninstall.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"uninstall.d.ts","sourceRoot":"","sources":["../../../src/commands/uninstall.ts"],"names":[],"mappings":"AAAA,OAAO,EAAE,OAAO,EAAE,MAAM,WAAW,CAAC;AAIpC,OAAO,EAAE,iBAAiB,EAAE,MAAM,aAAa,CAAC;AAChD,OAAO,EAGL,cAAc,EAIf,MAAM,aAAa,CAAC;AAErB,wBAAgB,mBAAmB,CACjC,cAAc,EAAE,cAAc,EAC9B,YAAY,EAAE,MAAM,EAAE,EACtB,WAAW,EAAE,MAAM,EACnB,SAAS,CAAC,EAAE,OAAO,QAuBpB;AAED,eAAO,MAAM,SAAS,EAAE,iBAAiB,CACvC;IACE,MAAM,EAAE,GAAG,SAAS;IACpB;QACE,KAAK,CAAC,EAAE,OAAO,CAAC;QAChB,MAAM,CAAC,EAAE,OAAO,CAAC;QACjB,SAAS,CAAC,EAAE,OAAO,CAAC;QACpB,cAAc,CAAC,EAAE,MAAM,CAAC;KACzB;CACF,CAmEF,CAAC;AAEF,wBAAgB,gBAAgB,CAAC,OAAO,EAAE,OAAO,QAiBhD"}

package/dist/src/commands/uninstall.js

@@ -0,0 +1,80 @@
+import { execSync } from "node:child_process";
+import fs from "node:fs";
+import { getPackageManagerFromLockfile, getProjectInfo, packageManagers, SUPPORTED_PACKAGE_MANAGERS, updateConfigFile, } from "../utils.js";
+export function uninstallDependency(packageManager, dependencies, projectPath, workspace) {
+    if (!fs.existsSync(projectPath)) {
+        throw new Error(`Project path not found: ${projectPath}`);
+    }
+    const manager = packageManagers[packageManager];
+    let uninstallCommand = manager.uninstallCommand.replace("{{dependency}}", dependencies.join(" "));
+    if (workspace) {
+        uninstallCommand += ` ${manager.workspaceOption}`;
+    }
+    const commandOptions = { cwd: projectPath };
+    execSync(uninstallCommand, {
+        stdio: "inherit",
+        ...commandOptions,
+    });
+}
+export const uninstall = (dependencies, options) => {
+    if (options.debug) {
+        console.log(">>> command arguments", { dependencies, options });
+    }
+    if (!dependencies || dependencies.length === 0) {
+        throw new Error("❌ Dependency name is required");
+    }
+    if (options.packageManager &&
+        !SUPPORTED_PACKAGE_MANAGERS.includes(options.packageManager)) {
+        throw new Error("❌ Unsupported package manager. Supported package managers: npm, yarn, pnpm, bun");
+    }
+    const projectInfo = getProjectInfo(options.debug);
+    if (options.debug) {
+        console.log("\n>>> projectInfo", projectInfo);
+    }
+    const isGlobal = options.global || projectInfo.isGlobal;
+    const packageManager = options.packageManager || getPackageManagerFromLockfile(projectInfo.path);
+    if (options.debug) {
+        console.log("\n>>> uninstallDependency arguments:");
+        console.log(">>> packageManager", packageManager);
+        console.log(">>> dependencies", dependencies);
+        console.log(">>> isGlobal", isGlobal);
+        console.log(">>> projectPath", projectInfo.path);
+        console.log(">>> workspace", options.workspace);
+    }
+    try {
+        console.log("Uninstalling dependencies 📦 ...");
+        uninstallDependency(packageManager, dependencies, projectInfo.path, options.workspace);
+        console.log("Dependency uninstalled successfully 🎉");
+    }
+    catch (error) {
+        console.error("❌ Failed to uninstall dependencies");
+        throw error;
+    }
+    if (options.debug) {
+        console.log("\n>>> updateConfigFile arguments:");
+        console.log(">>> dependencies", dependencies);
+        console.log(">>> projectPath", projectInfo.path);
+        console.log(">>> task", "uninstall");
+    }
+    try {
+        console.log("⚙️ Updating powerhouse config file...");
+        updateConfigFile(dependencies, projectInfo.path, "uninstall");
+        console.log("Config file updated successfully 🎉");
+    }
+    catch (error) {
+        console.error("❌ Failed to update config file");
+        throw error;
+    }
+};
+export function uninstallCommand(program) {
+    program
+        .command("uninstall")
+        .alias("remove")
+        .description("Uninstall a powerhouse dependency")
+        .argument("[dependencies...]", "Names of the dependencies to remove")
+        .option("-g, --global", "Remove the dependency globally")
+        .option("--debug", "Show additional logs")
+        .option("-w, --workspace", "Remove the dependency in the workspace (use this option for monorepos)")
+        .option("--package-manager <packageManager>", "force package manager to use")
+        .action(uninstall);
+}

package/dist/src/index.d.ts

@@ -0,0 +1,3 @@
+export * from "./commands/index.js";
+export * from "./utils.js";
+//# sourceMappingURL=index.d.ts.map

package/dist/src/index.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"index.d.ts","sourceRoot":"","sources":["../../src/index.ts"],"names":[],"mappings":"AAAA,cAAc,qBAAqB,CAAC;AACpC,cAAc,YAAY,CAAC"}

package/dist/src/index.js

@@ -0,0 +1,2 @@
+export * from "./commands/index.js";
+export * from "./utils.js";

package/dist/src/types.d.ts

@@ -0,0 +1,2 @@
+export type CommandActionType<Args extends any[], Return = void> = (...args: Args) => Return | Promise<Return>;
+//# sourceMappingURL=types.d.ts.map

package/dist/src/types.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"types.d.ts","sourceRoot":"","sources":["../../src/types.ts"],"names":[],"mappings":"AAAA,MAAM,MAAM,iBAAiB,CAAC,IAAI,SAAS,GAAG,EAAE,EAAE,MAAM,GAAG,IAAI,IAAI,CACjE,GAAG,IAAI,EAAE,IAAI,KACV,MAAM,GAAG,OAAO,CAAC,MAAM,CAAC,CAAC"}

package/dist/src/types.js

@@ -0,0 +1 @@
+export {};

package/dist/src/utils.d.ts

@@ -0,0 +1,47 @@
+export declare const POWERHOUSE_CONFIG_FILE = "powerhouse.config.json";
+export declare const POWERHOUSE_GLOBAL_DIR: string;
+export declare const SUPPORTED_PACKAGE_MANAGERS: string[];
+export declare const packageManagers: {
+    bun: {
+        globalPathRegexp: RegExp;
+        installCommand: string;
+        uninstallCommand: string;
+        workspaceOption: string;
+        lockfile: string;
+    };
+    pnpm: {
+        globalPathRegexp: RegExp;
+        installCommand: string;
+        uninstallCommand: string;
+        workspaceOption: string;
+        lockfile: string;
+    };
+    yarn: {
+        globalPathRegexp: RegExp;
+        installCommand: string;
+        uninstallCommand: string;
+        workspaceOption: string;
+        lockfile: string;
+    };
+    npm: {
+        installCommand: string;
+        uninstallCommand: string;
+        workspaceOption: string;
+        lockfile: string;
+    };
+};
+type PathValidation = (dir: string) => boolean;
+export type PackageManager = "npm" | "yarn" | "pnpm" | "bun";
+export type ProjectInfo = {
+    isGlobal: boolean;
+    path: string;
+};
+export declare function defaultPathValidation(): boolean;
+export declare function isPowerhouseProject(dir: string): boolean;
+export declare function findNodeProjectRoot(dir: string, pathValidation?: PathValidation): string | null;
+export declare function getProjectInfo(debug?: boolean): ProjectInfo;
+export declare function getPackageManagerFromLockfile(dir: string): PackageManager;
+export declare function getPackageManagerFromPath(dir: string): PackageManager;
+export declare function updateConfigFile(dependencies: string[], projectPath: string, task?: "install" | "uninstall"): void;
+export { getConfig } from "@powerhousedao/config/powerhouse";
+//# sourceMappingURL=utils.d.ts.map

package/dist/src/utils.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"utils.d.ts","sourceRoot":"","sources":["../../src/utils.ts"],"names":[],"mappings":"AAKA,eAAO,MAAM,sBAAsB,2BAA2B,CAAC;AAC/D,eAAO,MAAM,qBAAqB,QAA8B,CAAC;AACjE,eAAO,MAAM,0BAA0B,UAAiC,CAAC;AAEzE,eAAO,MAAM,eAAe;;;;;;;;;;;;;;;;;;;;;;;;;;;;CA4B3B,CAAC;AAEF,KAAK,cAAc,GAAG,CAAC,GAAG,EAAE,MAAM,KAAK,OAAO,CAAC;AAE/C,MAAM,MAAM,cAAc,GAAG,KAAK,GAAG,MAAM,GAAG,MAAM,GAAG,KAAK,CAAC;AAE7D,MAAM,MAAM,WAAW,GAAG;IACxB,QAAQ,EAAE,OAAO,CAAC;IAClB,IAAI,EAAE,MAAM,CAAC;CACd,CAAC;AAEF,wBAAgB,qBAAqB,YAEpC;AAED,wBAAgB,mBAAmB,CAAC,GAAG,EAAE,MAAM,WAI9C;AAED,wBAAgB,mBAAmB,CACjC,GAAG,EAAE,MAAM,EACX,cAAc,GAAE,cAAsC,iBAevD;AAED,wBAAgB,cAAc,CAAC,KAAK,CAAC,EAAE,OAAO,GAAG,WAAW,CAoB3D;AAED,wBAAgB,6BAA6B,CAAC,GAAG,EAAE,MAAM,GAAG,cAAc,CAUzE;AAED,wBAAgB,yBAAyB,CAAC,GAAG,EAAE,MAAM,GAAG,cAAc,CAYrE;AAED,wBAAgB,gBAAgB,CAC9B,YAAY,EAAE,MAAM,EAAE,EACtB,WAAW,EAAE,MAAM,EACnB,IAAI,GAAE,SAAS,GAAG,WAAuB,QA+B1C;AAED,OAAO,EAAE,SAAS,EAAE,MAAM,kCAAkC,CAAC"}

package/dist/src/utils.js

@@ -0,0 +1,114 @@
+import fs from "node:fs";
+import { homedir } from "node:os";
+import path, { dirname } from "node:path";
+export const POWERHOUSE_CONFIG_FILE = "powerhouse.config.json";
+export const POWERHOUSE_GLOBAL_DIR = path.join(homedir(), ".ph");
+export const SUPPORTED_PACKAGE_MANAGERS = ["npm", "yarn", "pnpm", "bun"];
+export const packageManagers = {
+    bun: {
+        globalPathRegexp: /[\\/].bun[\\/]/,
+        installCommand: "bun add {{dependency}}",
+        uninstallCommand: "bun remove {{dependency}}",
+        workspaceOption: "",
+        lockfile: "bun.lock",
+    },
+    pnpm: {
+        globalPathRegexp: /[\\/]pnpm[\\/]/,
+        installCommand: "pnpm add {{dependency}}",
+        uninstallCommand: "pnpm remove {{dependency}}",
+        workspaceOption: "--workspace-root",
+        lockfile: "pnpm-lock.yaml",
+    },
+    yarn: {
+        globalPathRegexp: /[\\/]yarn[\\/]/,
+        installCommand: "yarn add {{dependency}}",
+        uninstallCommand: "yarn remove {{dependency}}",
+        workspaceOption: "-W",
+        lockfile: "yarn.lock",
+    },
+    npm: {
+        installCommand: "npm install {{dependency}}",
+        uninstallCommand: "npm uninstall {{dependency}}",
+        workspaceOption: "",
+        lockfile: "package-lock.json",
+    },
+};
+export function defaultPathValidation() {
+    return true;
+}
+export function isPowerhouseProject(dir) {
+    const powerhouseConfigPath = path.join(dir, POWERHOUSE_CONFIG_FILE);
+    return fs.existsSync(powerhouseConfigPath);
+}
+export function findNodeProjectRoot(dir, pathValidation = defaultPathValidation) {
+    const packageJsonPath = path.join(dir, "package.json");
+    if (fs.existsSync(packageJsonPath) && pathValidation(dir)) {
+        return dir;
+    }
+    const parentDir = dirname(dir);
+    if (parentDir === dir) {
+        return null;
+    }
+    return findNodeProjectRoot(parentDir, pathValidation);
+}
+export function getProjectInfo(debug) {
+    const currentPath = process.cwd();
+    if (debug) {
+        console.log(">>> currentPath", currentPath);
+    }
+    const projectPath = findNodeProjectRoot(currentPath, isPowerhouseProject);
+    if (!projectPath) {
+        return {
+            isGlobal: true,
+            path: POWERHOUSE_GLOBAL_DIR,
+        };
+    }
+    return {
+        isGlobal: false,
+        path: projectPath,
+    };
+}
+export function getPackageManagerFromLockfile(dir) {
+    if (fs.existsSync(path.join(dir, packageManagers.pnpm.lockfile))) {
+        return "pnpm";
+    }
+    else if (fs.existsSync(path.join(dir, packageManagers.yarn.lockfile))) {
+        return "yarn";
+    }
+    else if (fs.existsSync(path.join(dir, packageManagers.bun.lockfile))) {
+        return "bun";
+    }
+    return "npm";
+}
+export function getPackageManagerFromPath(dir) {
+    const lowerCasePath = dir.toLowerCase();
+    if (packageManagers.bun.globalPathRegexp.test(lowerCasePath)) {
+        return "bun";
+    }
+    else if (packageManagers.pnpm.globalPathRegexp.test(lowerCasePath)) {
+        return "pnpm";
+    }
+    else if (packageManagers.yarn.globalPathRegexp.test(lowerCasePath)) {
+        return "yarn";
+    }
+    return "npm";
+}
+export function updateConfigFile(dependencies, projectPath, task = "install") {
+    const configPath = path.join(projectPath, POWERHOUSE_CONFIG_FILE);
+    const isInstall = task === "install";
+    if (!fs.existsSync(configPath)) {
+        throw new Error(`powerhouse.config.json file not found. projectPath: ${projectPath}`);
+    }
+    const config = JSON.parse(fs.readFileSync(configPath, "utf-8"));
+    const mappedPackages = dependencies.map((dep) => ({
+        packageName: dep,
+    }));
+    const updatedConfig = {
+        ...config,
+        packages: isInstall
+            ? [...(config.packages || []), ...mappedPackages]
+            : [...(config.packages || [])].filter((pkg) => !dependencies.includes(pkg.packageName)),
+    };
+    fs.writeFileSync(configPath, JSON.stringify(updatedConfig, null, 2));
+}
+export { getConfig } from "@powerhousedao/config/powerhouse";