@powerhousedao/ph-cli 0.40.7-dev.0 → 0.40.7-dev.3

package/dist/package.json

@@ -1,6 +1,6 @@
 {
     "name": "@powerhousedao/ph-cli",
-    "version": "0.40.7-dev.0",
+    "version": "0.40.7-dev.3",
     "description": "",
     "license": "AGPL-3.0-only",
     "type": "module",
@@ -19,7 +19,9 @@
         "prepublishOnly": "npm run build",
         "lint": "eslint .",
         "lint:nx": "eslint . --fix --quiet",
-        "lint:fix": "eslint --fix"
+        "lint:fix": "eslint --fix",
+        "test": "vitest run",
+        "test:watch": "vitest watch"
     },
     "keywords": [],
     "author": "",

package/dist/src/commands/__tests__/update.test.d.ts

@@ -0,0 +1,2 @@
+export {};
+//# sourceMappingURL=update.test.d.ts.map

package/dist/src/commands/__tests__/update.test.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"update.test.d.ts","sourceRoot":"","sources":["../../../../src/commands/__tests__/update.test.ts"],"names":[],"mappings":""}

package/dist/src/commands/__tests__/update.test.js

@@ -0,0 +1,152 @@
+import { Command } from "commander";
+import * as childProcess from "node:child_process";
+import * as fs from "node:fs";
+import path from "node:path";
+import { beforeEach, describe, expect, it, vi } from "vitest";
+import { findContainerDirectory, getPackageManagerFromLockfile, getProjectInfo, } from "../../utils.js";
+import { updateCommand } from "../update.js";
+// Mock dependencies
+vi.mock("node:fs");
+vi.mock("node:child_process");
+vi.mock("../install.js", () => ({
+    installDependency: vi.fn(),
+}));
+// Import installDependency after mocking
+import { installDependency } from "../install.js";
+vi.mock("../../utils.js", () => ({
+    packageManagers: {
+        pnpm: {
+            buildAffected: "pnpm run build:affected",
+            updateCommand: "pnpm update {{dependency}}",
+            installCommand: "pnpm install {{dependency}}",
+            workspaceOption: "--workspace-root",
+            lockfile: "pnpm-lock.yaml",
+        },
+    },
+    getPackageManagerFromLockfile: vi.fn(),
+    getProjectInfo: vi.fn(),
+    findContainerDirectory: vi.fn(),
+}));
+describe("updateCommand", () => {
+    let program;
+    beforeEach(() => {
+        vi.clearAllMocks();
+        vi.restoreAllMocks();
+        program = new Command();
+        updateCommand(program);
+        // Mock utils functions
+        vi.mocked(getPackageManagerFromLockfile).mockReturnValue("pnpm");
+        vi.mocked(getProjectInfo).mockReturnValue({
+            path: "/test/project",
+        });
+        vi.mocked(findContainerDirectory).mockReturnValue("/user/powerhouse/monorepo");
+        // Mock fs.readFileSync for package.json
+        vi.mocked(fs.readFileSync).mockImplementation((filePath) => {
+            if (filePath === path.join("/test/project", "package.json")) {
+                return JSON.stringify({
+                    dependencies: {
+                        "@powerhousedao/builder-tools": "link:/user/powerhouse/monorepo/packages/builder-tools",
+                    },
+                });
+            }
+            throw new Error(`Unexpected file read: ${String(filePath)}`);
+        });
+        // Mock fs.existsSync to return true for test paths
+        vi.spyOn(fs, "existsSync").mockImplementation((p) => {
+            const validPaths = [
+                "/test/project",
+                "/user/powerhouse/monorepo",
+                "/test/project/package.json",
+                path.join("/test/project", "package.json"),
+                path.join("/test/project", "pnpm-lock.yaml"),
+            ];
+            return validPaths.includes(p);
+        });
+        // Mock execSync
+        vi.mocked(childProcess.execSync).mockReturnValue(Buffer.from(""));
+        // Mock installDependency
+        vi.mocked(installDependency).mockImplementation(() => { });
+    });
+    it("should register the update command with correct options", () => {
+        const cmd = program.commands.find((c) => c.name() === "update");
+        expect(cmd).toBeDefined();
+        expect(cmd?.description()).toContain("update your dependencies");
+        // Get options from the command definition, not from parsed args
+        const options = cmd?.options.map((opt) => opt.attributeName());
+        expect(options).toContain("force");
+        expect(options).toContain("packageManager");
+        expect(options).toContain("debug");
+    });
+    it("should execute update command with local dependencies", async () => {
+        const cmd = program.commands.find((c) => c.name() === "update");
+        await cmd?.parseAsync(["node", "test"]);
+        expect(childProcess.execSync).toHaveBeenCalledWith("pnpm run build:affected", expect.objectContaining({
+            stdio: "inherit",
+            cwd: "/user/powerhouse/monorepo",
+        }));
+    });
+    it("should execute update command with force flag", async () => {
+        // Mock fs.readFileSync for the specific package.json read in this test
+        vi.mocked(fs.readFileSync).mockImplementation((filePath) => {
+            if (filePath === path.join("/test/project", "package.json")) {
+                return JSON.stringify({
+                    dependencies: {},
+                    devDependencies: {},
+                });
+            }
+            throw new Error(`Unexpected file read: ${String(filePath)}`);
+        });
+        // Mock fs.existsSync to return true for test paths
+        vi.spyOn(fs, "existsSync").mockImplementation((p) => {
+            const validPaths = [
+                "/test/project",
+                "/user/powerhouse/monorepo",
+                "/test/project/package.json",
+                path.join("/test/project", "package.json"),
+                path.join("/test/project", "pnpm-lock.yaml"),
+            ];
+            return validPaths.includes(p);
+        });
+        const cmd = program.commands.find((c) => c.name() === "update");
+        await cmd?.parseAsync(["node", "test", "--force", "prod"]);
+        // When using --force, it should call installDependency with the latest versions
+        expect(installDependency).toHaveBeenCalledWith("pnpm", [
+            "@powerhousedao/common@latest",
+            "@powerhousedao/design-system@latest",
+            "@powerhousedao/reactor-browser@latest",
+            "@powerhousedao/builder-tools@latest",
+            "@powerhousedao/codegen@latest",
+            "@powerhousedao/reactor-api@latest",
+            "@powerhousedao/reactor-local@latest",
+            "@powerhousedao/scalars@latest",
+            "@powerhousedao/ph-cli@latest",
+        ], "/test/project");
+    });
+    it("should handle debug flag", async () => {
+        const consoleSpy = vi.spyOn(console, "log");
+        const cmd = program.commands.find((c) => c.name() === "update");
+        await cmd?.parseAsync(["node", "test", "--debug"]);
+        expect(consoleSpy).toHaveBeenCalledWith(">>> options", expect.any(Object));
+    });
+    it("should execute update command without local dependencies", async () => {
+        // Mock fs.readFileSync to return package.json without local dependencies
+        vi.mocked(fs.readFileSync).mockImplementation((filePath) => {
+            if (filePath === path.join("/test/project", "package.json")) {
+                return JSON.stringify({
+                    dependencies: {
+                        "@powerhousedao/builder-tools": "^0.40.0",
+                        "@powerhousedao/common": "^0.40.0",
+                    },
+                });
+            }
+            throw new Error(`Unexpected file read: ${String(filePath)}`);
+        });
+        const cmd = program.commands.find((c) => c.name() === "update");
+        await cmd?.parseAsync(["node", "test"]);
+        // Should call execSync with pnpm update for all dependencies
+        expect(childProcess.execSync).toHaveBeenCalledWith("pnpm update @powerhousedao/common @powerhousedao/design-system @powerhousedao/reactor-browser @powerhousedao/builder-tools @powerhousedao/codegen @powerhousedao/reactor-api @powerhousedao/reactor-local @powerhousedao/scalars @powerhousedao/ph-cli", expect.objectContaining({
+            stdio: "inherit",
+            cwd: "/test/project",
+        }));
+    });
+});

package/dist/src/commands/__tests__/use.test.d.ts

@@ -0,0 +1,2 @@
+export {};
+//# sourceMappingURL=use.test.d.ts.map

package/dist/src/commands/__tests__/use.test.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"use.test.d.ts","sourceRoot":"","sources":["../../../../src/commands/__tests__/use.test.ts"],"names":[],"mappings":""}

package/dist/src/commands/__tests__/use.test.js

@@ -0,0 +1,130 @@
+import { Command } from "commander";
+import * as fs from "node:fs";
+import path from "node:path";
+import { beforeEach, describe, expect, it, vi } from "vitest";
+import { getPackageManagerFromLockfile, getProjectInfo, } from "../../utils.js";
+import { useCommand } from "../use.js";
+// Mock dependencies
+vi.mock("node:fs");
+vi.mock("../install.js", () => ({
+    installDependency: vi.fn(),
+}));
+// Import installDependency after mocking
+import { installDependency } from "../install.js";
+vi.mock("../../utils.js", () => ({
+    packageManagers: {
+        pnpm: {
+            buildAffected: "pnpm run build:affected",
+            updateCommand: "pnpm update {{dependency}}",
+            installCommand: "pnpm install {{dependency}}",
+            workspaceOption: "--workspace-root",
+            lockfile: "pnpm-lock.yaml",
+        },
+    },
+    getPackageManagerFromLockfile: vi.fn(),
+    getProjectInfo: vi.fn(),
+}));
+describe("useCommand", () => {
+    let program;
+    beforeEach(() => {
+        vi.clearAllMocks();
+        vi.restoreAllMocks();
+        program = new Command();
+        useCommand(program);
+        // Mock utils functions
+        vi.mocked(getPackageManagerFromLockfile).mockReturnValue("pnpm");
+        vi.mocked(getProjectInfo).mockReturnValue({
+            path: "/test/project",
+        });
+        // Mock fs.existsSync to return true for test paths
+        vi.spyOn(fs, "existsSync").mockImplementation((p) => {
+            const validPaths = [
+                "/test/project",
+                "/test/project/package.json",
+                path.join("/test/project", "package.json"),
+                path.join("/test/project", "pnpm-lock.yaml"),
+            ];
+            return validPaths.includes(p);
+        });
+        // Mock installDependency
+        vi.mocked(installDependency).mockImplementation(() => { });
+    });
+    it("should register the use command with correct options", () => {
+        const cmd = program.commands.find((c) => c.name() === "use");
+        expect(cmd).toBeDefined();
+        expect(cmd?.description()).toContain("change your environment");
+        const options = cmd?.options.map((opt) => opt.attributeName());
+        expect(options).toContain("dev");
+        expect(options).toContain("prod");
+        expect(options).toContain("latest");
+        expect(options).toContain("local");
+        expect(options).toContain("packageManager");
+        expect(options).toContain("debug");
+    });
+    it("should execute use command with dev environment", async () => {
+        const cmd = program.commands.find((c) => c.name() === "use");
+        await cmd?.parseAsync(["node", "test", "--dev"]);
+        expect(installDependency).toHaveBeenCalledWith("pnpm", [
+            "@powerhousedao/common@dev",
+            "@powerhousedao/design-system@dev",
+            "@powerhousedao/reactor-browser@dev",
+            "@powerhousedao/builder-tools@dev",
+            "@powerhousedao/codegen@dev",
+            "@powerhousedao/reactor-api@dev",
+            "@powerhousedao/reactor-local@dev",
+            "@powerhousedao/scalars@dev",
+            "@powerhousedao/ph-cli@dev",
+        ], "/test/project");
+    });
+    it("should execute use command with prod environment", async () => {
+        const cmd = program.commands.find((c) => c.name() === "use");
+        await cmd?.parseAsync(["node", "test", "--prod"]);
+        expect(installDependency).toHaveBeenCalledWith("pnpm", [
+            "@powerhousedao/common@latest",
+            "@powerhousedao/design-system@latest",
+            "@powerhousedao/reactor-browser@latest",
+            "@powerhousedao/builder-tools@latest",
+            "@powerhousedao/codegen@latest",
+            "@powerhousedao/reactor-api@latest",
+            "@powerhousedao/reactor-local@latest",
+            "@powerhousedao/scalars@latest",
+            "@powerhousedao/ph-cli@latest",
+        ], "/test/project");
+    });
+    it("should execute use command with local environment", async () => {
+        const cmd = program.commands.find((c) => c.name() === "use");
+        await cmd?.parseAsync(["node", "test", "--local", "/path/to/local"]);
+        expect(installDependency).toHaveBeenCalledWith("pnpm", [
+            "/path/to/local/packages/common",
+            "/path/to/local/packages/design-system",
+            "/path/to/local/packages/reactor-browser",
+            "/path/to/local/packages/builder-tools",
+            "/path/to/local/packages/codegen",
+            "/path/to/local/packages/reactor-api",
+            "/path/to/local/packages/reactor-local",
+            "/path/to/local/packages/scalars",
+            "/path/to/local/clis/ph-cli",
+        ], "/test/project");
+    });
+    it("should handle debug flag", async () => {
+        const consoleSpy = vi.spyOn(console, "log");
+        const cmd = program.commands.find((c) => c.name() === "use");
+        await cmd?.parseAsync(["node", "test", "--dev", "--debug"]);
+        expect(consoleSpy).toHaveBeenCalledWith(">>> options", expect.any(Object));
+    });
+    it("should throw error when no environment is specified", async () => {
+        const cmd = program.commands.find((c) => c.name() === "use");
+        await expect(cmd?.parseAsync(["node", "test"])).rejects.toThrow("❌ Please specify an environment");
+    });
+    it("should use specified package manager", async () => {
+        const cmd = program.commands.find((c) => c.name() === "use");
+        await cmd?.parseAsync([
+            "node",
+            "test",
+            "--dev",
+            "--package-manager",
+            "npm",
+        ]);
+        expect(installDependency).toHaveBeenCalledWith("npm", expect.any(Array), "/test/project");
+    });
+});

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

@@ -1 +1 @@
-{"version":3,"file":"connect.d.ts","sourceRoot":"","sources":["../../../src/commands/connect.ts"],"names":[],"mappings":"AAAA,OAAO,EAAE,KAAK,OAAO,EAAE,MAAM,WAAW,CAAC;AACzC,OAAO,EAAE,KAAK,cAAc,EAAE,MAAM,wBAAwB,CAAC;AAC7D,OAAO,EAAE,KAAK,iBAAiB,EAAE,MAAM,aAAa,CAAC;AAQrD,eAAO,MAAM,OAAO,EAAE,iBAAiB,CACrC;IAAC,cAAc;CAAC,EAChB,OAAO,CAAC,IAAI,CAAC,CAGd,CAAC;AAEF,wBAAgB,cAAc,CAAC,OAAO,EAAE,OAAO,QAuB9C"}
+{"version":3,"file":"connect.d.ts","sourceRoot":"","sources":["../../../src/commands/connect.ts"],"names":[],"mappings":"AAAA,OAAO,EAAE,KAAK,OAAO,EAAE,MAAM,WAAW,CAAC;AACzC,OAAO,EAAE,KAAK,cAAc,EAAE,MAAM,wBAAwB,CAAC;AAC7D,OAAO,EAAE,KAAK,iBAAiB,EAAE,MAAM,aAAa,CAAC;AAQrD,eAAO,MAAM,OAAO,EAAE,iBAAiB,CACrC;IAAC,cAAc;CAAC,EAChB,OAAO,CAAC,IAAI,CAAC,CAGd,CAAC;AAEF,wBAAgB,cAAc,CAAC,OAAO,EAAE,OAAO,QAe9C"}

package/dist/src/commands/connect.js

@@ -15,8 +15,6 @@ export function connectCommand(program) {
         .option("--https", "Enable HTTPS")
         .option("--open", "Open the browser")
         .option("--config-file <configFile>", "Path to the powerhouse.config.js file")
-        .option("-le, --local-editors <localEditors>", "Link local document editors path")
-        .option("-ld, --local-documents <localDocuments>", "Link local documents path")
         .action(async (...args) => {
         await connect(...args);
     });

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

@@ -1 +1 @@
-{"version":3,"file":"index.d.ts","sourceRoot":"","sources":["../../../src/commands/index.ts"],"names":[],"mappings":"AAAA,OAAO,EAAE,KAAK,OAAO,EAAE,MAAM,WAAW,CAAC;AACzC,OAAO,EAAE,cAAc,EAAE,MAAM,cAAc,CAAC;AAY9C,eAAO,MAAM,QAAQ,2BAYpB,CAAC;AAEF,MAAM,CAAC,OAAO,UAAU,gBAAgB,CAAC,OAAO,EAAE,OAAO,QAExD"}
+{"version":3,"file":"index.d.ts","sourceRoot":"","sources":["../../../src/commands/index.ts"],"names":[],"mappings":"AAAA,OAAO,EAAE,KAAK,OAAO,EAAE,MAAM,WAAW,CAAC;AACzC,OAAO,EAAE,cAAc,EAAE,MAAM,cAAc,CAAC;AAc9C,eAAO,MAAM,QAAQ,2BAcpB,CAAC;AAEF,MAAM,CAAC,OAAO,UAAU,gBAAgB,CAAC,OAAO,EAAE,OAAO,QAExD"}

package/dist/src/commands/index.js

@@ -8,6 +8,8 @@ import { listCommand } from "./list.js";
 import { serviceCommand } from "./service.js";
 import { reactorCommand } from "./switchboard.js";
 import { uninstallCommand } from "./uninstall.js";
+import { updateCommand } from "./update.js";
+import { useCommand } from "./use.js";
 import { versionCommand } from "./version.js";
 export const commands = [
     // devCommand,
@@ -21,6 +23,8 @@ export const commands = [
     listCommand,
     inspectCommand,
     versionCommand,
+    useCommand,
+    updateCommand,
 ];
 export default function registerCommands(program) {
     commands.forEach((command) => command(program));

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

@@ -1,9 +1,6 @@
 import { type Command } from "commander";
 import { type InspectOptions } from "../services/inspect.js";
 import { type CommandActionType } from "../types.js";
-export declare const inspect: CommandActionType<[
-    string,
-    InspectOptions
-]>;
+export declare const inspect: CommandActionType<[string, InspectOptions]>;
 export declare function inspectCommand(program: Command): void;
 //# sourceMappingURL=inspect.d.ts.map

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

@@ -1 +1 @@
-{"version":3,"file":"inspect.d.ts","sourceRoot":"","sources":["../../../src/commands/inspect.ts"],"names":[],"mappings":"AAAA,OAAO,EAAE,KAAK,OAAO,EAAE,MAAM,WAAW,CAAC;AACzC,OAAO,EAAE,KAAK,cAAc,EAAE,MAAM,wBAAwB,CAAC;AAC7D,OAAO,EAAE,KAAK,iBAAiB,EAAE,MAAM,aAAa,CAAC;AAQrD,eAAO,MAAM,OAAO,EAAE,iBAAiB,CACrC;IAAC,MAAM;IAAE,cAAc;CAAC,CAGzB,CAAC;AAEF,wBAAgB,cAAc,CAAC,OAAO,EAAE,OAAO,QAQ9C"}
+{"version":3,"file":"inspect.d.ts","sourceRoot":"","sources":["../../../src/commands/inspect.ts"],"names":[],"mappings":"AAAA,OAAO,EAAE,KAAK,OAAO,EAAE,MAAM,WAAW,CAAC;AACzC,OAAO,EAAE,KAAK,cAAc,EAAE,MAAM,wBAAwB,CAAC;AAC7D,OAAO,EAAE,KAAK,iBAAiB,EAAE,MAAM,aAAa,CAAC;AAQrD,eAAO,MAAM,OAAO,EAAE,iBAAiB,CAAC,CAAC,MAAM,EAAE,cAAc,CAAC,CAK/D,CAAC;AAEF,wBAAgB,cAAc,CAAC,OAAO,EAAE,OAAO,QAQ9C"}

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

@@ -0,0 +1,11 @@
+import { type Command } from "commander";
+import { type CommandActionType } from "../types.js";
+export declare const update: CommandActionType<[
+    {
+        force?: string;
+        debug?: boolean;
+        packageManager?: string;
+    }
+]>;
+export declare function updateCommand(program: Command): void;
+//# sourceMappingURL=update.d.ts.map

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

@@ -0,0 +1 @@
+{"version":3,"file":"update.d.ts","sourceRoot":"","sources":["../../../src/commands/update.ts"],"names":[],"mappings":"AAAA,OAAO,EAAE,KAAK,OAAO,EAAE,MAAM,WAAW,CAAC;AAIzC,OAAO,EAAE,KAAK,iBAAiB,EAAE,MAAM,aAAa,CAAC;AAqErD,eAAO,MAAM,MAAM,EAAE,iBAAiB,CACpC;IACE;QACE,KAAK,CAAC,EAAE,MAAM,CAAC;QACf,KAAK,CAAC,EAAE,OAAO,CAAC;QAChB,cAAc,CAAC,EAAE,MAAM,CAAC;KACzB;CACF,CAqDF,CAAC;AAEF,wBAAgB,aAAa,CAAC,OAAO,EAAE,OAAO,QA4B7C"}

package/dist/src/commands/update.js

@@ -0,0 +1,89 @@
+import { execSync } from "node:child_process";
+import fs from "node:fs";
+import path from "node:path";
+import { findContainerDirectory, getPackageManagerFromLockfile, getProjectInfo, packageManagers, } from "../utils.js";
+import { ENV_MAP, PH_PROJECT_DEPENDENCIES, updatePackageJson, } from "./use.js";
+const FILE_PROTOCOL = "file:";
+const LINK_PROTOCOL = "link:";
+const MONOREPO_FILE = "pnpm-workspace.yaml";
+const buildLocalDependencies = (localDependencyPath, pkgManagerName) => {
+    const monorepoPath = findContainerDirectory(localDependencyPath, MONOREPO_FILE);
+    if (!monorepoPath) {
+        throw new Error("Monorepo root directory not found");
+    }
+    const pkgManager = packageManagers[pkgManagerName];
+    console.log("⚙️ Building local dependencies...");
+    execSync(pkgManager.buildAffected, {
+        stdio: "inherit",
+        cwd: monorepoPath,
+    });
+};
+const getLocalDependencyPath = (projectPath) => {
+    // read package json from projectInfo.path
+    const packageJson = JSON.parse(fs.readFileSync(path.join(projectPath, "package.json"), "utf-8"));
+    // filter dependencies
+    const filteredDependencies = Object.entries({
+        ...packageJson.dependencies,
+        ...packageJson.devDependencies,
+    }).filter(([name]) => PH_PROJECT_DEPENDENCIES.includes(name));
+    const [_, localDependencyPath] = filteredDependencies.find(([_, version]) => version.startsWith(FILE_PROTOCOL) || version.startsWith(LINK_PROTOCOL)) || [null, null];
+    if (!localDependencyPath)
+        return null;
+    return localDependencyPath
+        .replace(FILE_PROTOCOL, "")
+        .replace(LINK_PROTOCOL, "");
+};
+export const update = (options) => {
+    const { force, packageManager, debug } = options;
+    if (debug) {
+        console.log(">>> options", options);
+    }
+    const projectInfo = getProjectInfo();
+    const pkgManagerName = (packageManager ||
+        getPackageManagerFromLockfile(projectInfo.path));
+    const localDependencyPath = getLocalDependencyPath(projectInfo.path);
+    if (debug) {
+        console.log(">>> projectInfo", projectInfo);
+        console.log(">>> pkgManagerName", pkgManagerName);
+        console.log(">>> localDependencyPath", localDependencyPath);
+    }
+    if (localDependencyPath) {
+        buildLocalDependencies(localDependencyPath, pkgManagerName);
+    }
+    if (force) {
+        const supportedEnvs = Object.keys(ENV_MAP);
+        if (!supportedEnvs.includes(force)) {
+            throw new Error(`Invalid environment: ${force}, supported envs: ${supportedEnvs.join(", ")}`);
+        }
+        const env = force;
+        updatePackageJson(env, undefined, pkgManagerName, debug);
+        return;
+    }
+    const pkgManager = packageManagers[pkgManagerName];
+    const deps = PH_PROJECT_DEPENDENCIES.join(" ");
+    const updateCommand = pkgManager.updateCommand.replace("{{dependency}}", deps);
+    console.log(updateCommand);
+    const commandOptions = { cwd: projectInfo.path };
+    execSync(updateCommand, {
+        stdio: "inherit",
+        ...commandOptions,
+    });
+};
+export function updateCommand(program) {
+    program
+        .command("update")
+        .description("Allows you to update your dependencies to the latest version based on the specified range in package.json. If you want to update to the latest available version, use the --force flag.")
+        .option("--force <env>", "Force update to latest available version for the environment specified (dev, prod, latest)")
+        .option("--package-manager <packageManager>", "force package manager to use")
+        .option("--debug", "Show additional logs")
+        .addHelpText("after", `
+Examples:
+  $ ph-cli update                          # Update dependencies based on package.json ranges
+  $ ph-cli update --force dev              # Force update to latest dev version available
+  $ ph-cli update --force prod             # Force update to latest stable version available (same as latest)
+  $ ph-cli update --force latest           # Force update to latest stable version available (same as prod)
+  $ ph-cli update --package-manager pnpm   # Specify package manager to use
+  $ ph-cli update --debug                  # Show debug information during update
+    `)
+        .action(update);
+}

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

@@ -0,0 +1,27 @@
+import { type Command } from "commander";
+import { type CommandActionType } from "../types.js";
+import { type PackageManager } from "../utils.js";
+export declare const ORG = "@powerhousedao";
+export declare const CLIS: string[];
+export declare const PACKAGES: string[];
+export declare const PH_PROJECT_DEPENDENCIES: string[];
+export declare const PH_PROJECT_LOCAL_DEPENDENCIES: string[];
+export declare const ENV_MAP: {
+    dev: string;
+    prod: string;
+    latest: string;
+};
+export type Environment = keyof typeof ENV_MAP;
+export declare const updatePackageJson: (env: Environment, localPath?: string, packageManager?: PackageManager, debug?: boolean) => void;
+export declare const use: CommandActionType<[
+    {
+        dev?: boolean;
+        prod?: boolean;
+        local?: string;
+        debug?: boolean;
+        latest?: boolean;
+        packageManager?: string;
+    }
+]>;
+export declare function useCommand(program: Command): void;
+//# sourceMappingURL=use.d.ts.map

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

@@ -0,0 +1 @@
+{"version":3,"file":"use.d.ts","sourceRoot":"","sources":["../../../src/commands/use.ts"],"names":[],"mappings":"AAAA,OAAO,EAAE,KAAK,OAAO,EAAE,MAAM,WAAW,CAAC;AAEzC,OAAO,EAAE,KAAK,iBAAiB,EAAE,MAAM,aAAa,CAAC;AACrD,OAAO,EAGL,KAAK,cAAc,EACpB,MAAM,aAAa,CAAC;AAGrB,eAAO,MAAM,GAAG,mBAAmB,CAAC;AACpC,eAAO,MAAM,IAAI,UAAa,CAAC;AAC/B,eAAO,MAAM,QAAQ,UASpB,CAAC;AAEF,eAAO,MAAM,uBAAuB,UAGnC,CAAC;AAEF,eAAO,MAAM,6BAA6B,UAGzC,CAAC;AAEF,eAAO,MAAM,OAAO;;;;CAInB,CAAC;AAGF,MAAM,MAAM,WAAW,GAAG,MAAM,OAAO,OAAO,CAAC;AAE/C,eAAO,MAAM,iBAAiB,GAC5B,KAAK,WAAW,EAChB,YAAY,MAAM,EAClB,iBAAiB,cAAc,EAC/B,QAAQ,OAAO,SAuChB,CAAC;AAEF,eAAO,MAAM,GAAG,EAAE,iBAAiB,CACjC;IACE;QACE,GAAG,CAAC,EAAE,OAAO,CAAC;QACd,IAAI,CAAC,EAAE,OAAO,CAAC;QACf,KAAK,CAAC,EAAE,MAAM,CAAC;QACf,KAAK,CAAC,EAAE,OAAO,CAAC;QAChB,MAAM,CAAC,EAAE,OAAO,CAAC;QACjB,cAAc,CAAC,EAAE,MAAM,CAAC;KACzB;CACF,CAwBF,CAAC;AAEF,wBAAgB,UAAU,CAAC,OAAO,EAAE,OAAO,QAmB1C"}

package/dist/src/commands/use.js

@@ -0,0 +1,82 @@
+import path from "node:path";
+import { getPackageManagerFromLockfile, getProjectInfo, } from "../utils.js";
+import { installDependency } from "./install.js";
+export const ORG = "@powerhousedao";
+export const CLIS = ["ph-cli"];
+export const PACKAGES = [
+    "common",
+    "design-system",
+    "reactor-browser",
+    "builder-tools",
+    "codegen",
+    "reactor-api",
+    "reactor-local",
+    "scalars",
+];
+export const PH_PROJECT_DEPENDENCIES = [
+    ...PACKAGES.map((dependency) => `${ORG}/${dependency}`),
+    ...CLIS.map((dependency) => `${ORG}/${dependency}`),
+];
+export const PH_PROJECT_LOCAL_DEPENDENCIES = [
+    ...PACKAGES.map((dependency) => path.join("packages", dependency)),
+    ...CLIS.map((dependency) => path.join("clis", dependency)),
+];
+export const ENV_MAP = {
+    dev: "dev",
+    prod: "latest",
+    latest: "latest",
+};
+export const updatePackageJson = (env, localPath, packageManager, debug) => {
+    const dependencies = [];
+    const projectInfo = getProjectInfo();
+    const pkgManager = packageManager || getPackageManagerFromLockfile(projectInfo.path);
+    if (debug) {
+        console.log(">>> projectInfo", projectInfo);
+        console.log(">>> pkgManager", pkgManager);
+    }
+    if (localPath) {
+        const localPathDependencies = PH_PROJECT_LOCAL_DEPENDENCIES.map((dependency) => path.join(localPath, dependency));
+        dependencies.push(...localPathDependencies);
+    }
+    else {
+        dependencies.push(...PH_PROJECT_DEPENDENCIES.map((dependency) => `${dependency}@${ENV_MAP[env]}`));
+    }
+    if (debug) {
+        console.log(">>> dependencies", dependencies);
+    }
+    try {
+        console.log("⚙️ Updating dependencies...");
+        installDependency(pkgManager, dependencies, projectInfo.path);
+        console.log("✅ Dependencies updated successfully");
+    }
+    catch (error) {
+        console.error("❌ Failed to update dependencies");
+        throw error;
+    }
+};
+export const use = (options) => {
+    const { dev, prod, latest, local, packageManager, debug } = options;
+    const develop = dev ? "dev" : null;
+    const production = prod ? "prod" : null;
+    const latestEnv = latest ? "latest" : null;
+    const env = develop || production || latestEnv;
+    if (debug) {
+        console.log(">>> options", options);
+    }
+    if (!env && !local) {
+        throw new Error("❌ Please specify an environment");
+    }
+    updatePackageJson(env || "dev", local, packageManager, debug);
+};
+export function useCommand(program) {
+    program
+        .command("use")
+        .description("Allows you to change your environment (latest, development, production, local)")
+        .option("-d, --dev", "Use development environment")
+        .option("-p, --prod", "Use production environment")
+        .option("--latest", "Use latest environment")
+        .option("-l, --local <localPath>", "Use local environment (you have to specify the path to the local environment)")
+        .option("--package-manager <packageManager>", "force package manager to use")
+        .option("--debug", "Show additional logs")
+        .action(use);
+}

package/dist/src/services/connect.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"connect.d.ts","sourceRoot":"","sources":["../../../src/services/connect.ts"],"names":[],"mappings":"AAAA,OAAO,EACL,KAAK,oBAAoB,EAE1B,MAAM,6CAA6C,CAAC;AAKrD,MAAM,MAAM,cAAc,GAAG,oBAAoB,CAAC;AAElD,wBAAsB,YAAY,CAAC,cAAc,EAAE,cAAc,6BAYhE"}
+{"version":3,"file":"connect.d.ts","sourceRoot":"","sources":["../../../src/services/connect.ts"],"names":[],"mappings":"AAAA,OAAO,EACL,KAAK,oBAAoB,EAE1B,MAAM,6CAA6C,CAAC;AAKrD,MAAM,MAAM,cAAc,GAAG,oBAAoB,CAAC;AAElD,wBAAsB,YAAY,CAAC,cAAc,EAAE,cAAc,6BAUhE"}

package/dist/src/services/connect.js

@@ -3,13 +3,11 @@ import { getConfig } from "@powerhousedao/config/powerhouse";
 import packageJson from "../../package.json" with { type: "json" };
 const version = packageJson.version;
 export async function startConnect(connectOptions) {
-    const { documentModelsDir, editorsDir, packages, studio, logLevel } = getConfig(connectOptions.configFile);
+    const { packages, studio, logLevel } = getConfig(connectOptions.configFile);
     return await startConnectStudio({
         port: studio?.port?.toString() || undefined,
         packages,
         phCliVersion: typeof version === "string" ? version : undefined,
-        localDocuments: documentModelsDir || undefined,
-        localEditors: editorsDir || undefined,
         open: studio?.openBrowser,
         logLevel: logLevel,
         ...connectOptions,

package/dist/src/services/dev.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"dev.d.ts","sourceRoot":"","sources":["../../../src/services/dev.ts"],"names":[],"mappings":"AAcA,MAAM,MAAM,UAAU,GAAG;IACvB,QAAQ,CAAC,EAAE,OAAO,CAAC;IACnB,KAAK,CAAC,EAAE,OAAO,CAAC;IAChB,eAAe,CAAC,EAAE,MAAM,CAAC;IACzB,UAAU,CAAC,EAAE,MAAM,CAAC;IACpB,YAAY,CAAC,EAAE,MAAM,CAAC;IACtB,aAAa,CAAC,EAAE,MAAM,CAAC;CACxB,CAAC;AA4EF,wBAAsB,QAAQ,CAAC,EAC7B,QAAQ,EACR,KAAK,EACL,eAAgD,EAChD,UAAU,GACX,EAAE,UAAU,iBAcZ"}
+{"version":3,"file":"dev.d.ts","sourceRoot":"","sources":["../../../src/services/dev.ts"],"names":[],"mappings":"AAcA,MAAM,MAAM,UAAU,GAAG;IACvB,QAAQ,CAAC,EAAE,OAAO,CAAC;IACnB,KAAK,CAAC,EAAE,OAAO,CAAC;IAChB,eAAe,CAAC,EAAE,MAAM,CAAC;IACzB,UAAU,CAAC,EAAE,MAAM,CAAC;IACpB,YAAY,CAAC,EAAE,MAAM,CAAC;IACtB,aAAa,CAAC,EAAE,MAAM,CAAC;CACxB,CAAC;AA0EF,wBAAsB,QAAQ,CAAC,EAC7B,QAAQ,EACR,KAAK,EACL,eAAgD,EAChD,UAAU,GACX,EAAE,UAAU,iBAcZ"}

package/dist/src/services/dev.js

@@ -40,8 +40,6 @@ async function spawnConnect(options, localReactorUrl) {
         env: {
             ...process.env,
             // TODO add studio variables?
-            LOCAL_DOCUMENT_MODELS: options?.localDocuments,
-            LOCAL_DOCUMENT_EDITORS: options?.localEditors,
             PH_CONNECT_DEFAULT_DRIVES_URL: localReactorUrl,
         },
     });