ph-cmd 0.43.9-dev.1 → 0.43.9-dev.4

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

@@ -44,6 +44,8 @@ describe("updateCommand", () => {
                 return JSON.stringify({
                     dependencies: {
                         "@powerhousedao/builder-tools": "link:/user/powerhouse/monorepo/packages/builder-tools",
+                        "@powerhousedao/common": "^0.40.0",
+                        "@powerhousedao/design-system": "^0.40.0",
                     },
                 });
             }
@@ -88,37 +90,18 @@ describe("updateCommand", () => {
         vi.mocked(fs.readFileSync).mockImplementation((filePath) => {
             if (filePath === path.join("/test/project", "package.json")) {
                 return JSON.stringify({
-                    dependencies: {},
-                    devDependencies: {},
+                    dependencies: {
+                        "@powerhousedao/common": "^0.40.0",
+                        "@powerhousedao/design-system": "^0.40.0",
+                    },
                 });
             }
             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");
+        expect(installDependency).toHaveBeenCalledWith("pnpm", ["@powerhousedao/common@latest", "@powerhousedao/design-system@latest"], "/test/project");
     });
     it("should handle debug flag", async () => {
         const consoleSpy = vi.spyOn(console, "log");
@@ -141,10 +124,28 @@ describe("updateCommand", () => {
         });
         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({
+        // Should call execSync with pnpm update for only the installed dependencies (sorted alphabetically)
+        expect(childProcess.execSync).toHaveBeenCalledWith("pnpm update @powerhousedao/builder-tools @powerhousedao/common", expect.objectContaining({
             stdio: "inherit",
             cwd: "/test/project",
         }));
     });
+    it("should show message when no Powerhouse dependencies are found", async () => {
+        // Mock fs.readFileSync to return package.json without any Powerhouse dependencies
+        vi.mocked(fs.readFileSync).mockImplementation((filePath) => {
+            if (filePath === path.join("/test/project", "package.json")) {
+                return JSON.stringify({
+                    dependencies: {
+                        "some-other-package": "^1.0.0",
+                    },
+                });
+            }
+            throw new Error(`Unexpected file read: ${String(filePath)}`);
+        });
+        const consoleSpy = vi.spyOn(console, "log");
+        const cmd = program.commands.find((c) => c.name() === "update");
+        await cmd?.parseAsync(["node", "test"]);
+        expect(consoleSpy).toHaveBeenCalledWith("ℹ️ No Powerhouse dependencies found to update");
+        expect(childProcess.execSync).not.toHaveBeenCalled();
+    });
 });

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

@@ -44,6 +44,26 @@ describe("useCommand", () => {
             ];
             return validPaths.includes(p);
         });
+        // Mock fs.readFileSync to return a test package.json
+        vi.spyOn(fs, "readFileSync").mockImplementation((p) => {
+            if (p === path.join("/test/project", "package.json")) {
+                return JSON.stringify({
+                    dependencies: {
+                        "@powerhousedao/common": "1.0.0",
+                        "@powerhousedao/design-system": "1.0.0",
+                        "@powerhousedao/reactor-browser": "1.0.0",
+                        "document-model": "1.0.0",
+                        "document-drive": "1.0.0",
+                        "some-other-package": "1.0.0",
+                    },
+                    devDependencies: {
+                        "@powerhousedao/builder-tools": "1.0.0",
+                        "@powerhousedao/codegen": "1.0.0",
+                    },
+                });
+            }
+            return "";
+        });
         // Mock installDependency
         vi.mocked(installDependency).mockImplementation(() => { });
     });
@@ -64,10 +84,8 @@ describe("useCommand", () => {
             "@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",
+            "document-model@dev",
+            "document-drive@dev",
         ], "/test/project");
     });
     it("should execute use command with prod environment", async () => {
@@ -79,10 +97,8 @@ describe("useCommand", () => {
             "@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",
+            "document-model@latest",
+            "document-drive@latest",
         ], "/test/project");
     });
     it("should execute use command with local environment", async () => {
@@ -94,10 +110,8 @@ describe("useCommand", () => {
             "/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",
+            "/path/to/local/packages/document-model",
+            "/path/to/local/packages/document-drive",
         ], "/test/project");
     });
     it("should handle debug flag", async () => {
@@ -105,6 +119,9 @@ describe("useCommand", () => {
         const cmd = program.commands.find((c) => c.name() === "use");
         await cmd?.parseAsync(["node", "test", "dev", "--debug"]);
         expect(consoleSpy).toHaveBeenCalledWith(">>> options", expect.any(Object));
+        expect(consoleSpy).toHaveBeenCalledWith(">>> projectInfo", expect.any(Object));
+        expect(consoleSpy).toHaveBeenCalledWith(">>> pkgManager", "pnpm");
+        expect(consoleSpy).toHaveBeenCalledWith(">>> dependencies to update", expect.any(Array));
     });
     it("should throw error when no environment is specified", async () => {
         const cmd = program.commands.find((c) => c.name() === "use");
@@ -119,4 +136,90 @@ describe("useCommand", () => {
         await cmd?.parseAsync(["node", "test", "dev", "--package-manager", "npm"]);
         expect(installDependency).toHaveBeenCalledWith("npm", expect.any(Array), "/test/project");
     });
+    it("should not update dependencies that are not installed", async () => {
+        const cmd = program.commands.find((c) => c.name() === "use");
+        await cmd?.parseAsync(["node", "test", "dev"]);
+        // Verify that only installed dependencies are updated
+        const call = vi.mocked(installDependency).mock.calls[0];
+        const updatedDependencies = call[1];
+        expect(updatedDependencies).not.toContain("@powerhousedao/reactor-api@dev");
+        expect(updatedDependencies).not.toContain("@powerhousedao/reactor-local@dev");
+        expect(updatedDependencies).not.toContain("@powerhousedao/scalars@dev");
+        expect(updatedDependencies).not.toContain("@powerhousedao/ph-cli@dev");
+    });
+    it("should show message when no Powerhouse dependencies are found", async () => {
+        // Mock package.json with no Powerhouse dependencies
+        vi.spyOn(fs, "readFileSync").mockImplementation((p) => {
+            if (p === path.join("/test/project", "package.json")) {
+                return JSON.stringify({
+                    dependencies: {
+                        "some-other-package": "1.0.0",
+                    },
+                });
+            }
+            return "";
+        });
+        const consoleSpy = vi.spyOn(console, "log");
+        const cmd = program.commands.find((c) => c.name() === "use");
+        await cmd?.parseAsync(["node", "test", "dev"]);
+        expect(consoleSpy).toHaveBeenCalledWith("ℹ️ No Powerhouse dependencies found to update");
+        expect(installDependency).not.toHaveBeenCalled();
+    });
+    it("should handle special packages without @powerhousedao prefix", async () => {
+        // Mock package.json with only special packages
+        vi.spyOn(fs, "readFileSync").mockImplementation((p) => {
+            if (p === path.join("/test/project", "package.json")) {
+                return JSON.stringify({
+                    dependencies: {
+                        "document-model": "1.0.0",
+                        "document-drive": "1.0.0",
+                    },
+                });
+            }
+            return "";
+        });
+        const cmd = program.commands.find((c) => c.name() === "use");
+        await cmd?.parseAsync(["node", "test", "dev"]);
+        expect(installDependency).toHaveBeenCalledWith("pnpm", ["document-model@dev", "document-drive@dev"], "/test/project");
+    });
+    it("should update only existing @powerhousedao dependencies", async () => {
+        // Mock package.json with only common and design-system
+        vi.spyOn(fs, "readFileSync").mockImplementation((p) => {
+            if (p === path.join("/test/project", "package.json")) {
+                return JSON.stringify({
+                    dependencies: {
+                        "@powerhousedao/common": "1.0.0",
+                        "@powerhousedao/design-system": "1.0.0",
+                    },
+                });
+            }
+            return "";
+        });
+        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"], "/test/project");
+    });
+    it("should update only existing document-model and document-drive without adding @powerhousedao prefix", async () => {
+        // Mock package.json with only document-model and document-drive
+        vi.spyOn(fs, "readFileSync").mockImplementation((p) => {
+            if (p === path.join("/test/project", "package.json")) {
+                return JSON.stringify({
+                    dependencies: {
+                        "document-model": "1.0.0",
+                        "document-drive": "1.0.0",
+                    },
+                });
+            }
+            return "";
+        });
+        const cmd = program.commands.find((c) => c.name() === "use");
+        await cmd?.parseAsync(["node", "test", "dev"]);
+        const updatedDependencies = vi.mocked(installDependency).mock.calls[0][1];
+        expect(updatedDependencies).toEqual([
+            "document-model@dev",
+            "document-drive@dev",
+        ]);
+        expect(updatedDependencies).not.toContain("@powerhousedao/document-model@dev");
+        expect(updatedDependencies).not.toContain("@powerhousedao/document-drive@dev");
+    });
 });

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

@@ -1 +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,CAmDF,CAAC;AAEF,wBAAgB,aAAa,CAAC,OAAO,EAAE,OAAO,QA4B7C"}
+{"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;AAsFrD,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,CA6DF,CAAC;AAEF,wBAAgB,aAAa,CAAC,OAAO,EAAE,OAAO,QA6B7C"}

package/dist/src/commands/update.js

@@ -23,8 +23,8 @@ const getLocalDependencyPath = (projectPath) => {
     const packageJson = JSON.parse(fs.readFileSync(path.join(projectPath, "package.json"), "utf-8"));
     // filter dependencies
     const filteredDependencies = Object.entries({
-        ...packageJson.dependencies,
-        ...packageJson.devDependencies,
+        ...(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)
@@ -33,6 +33,18 @@ const getLocalDependencyPath = (projectPath) => {
         .replace(FILE_PROTOCOL, "")
         .replace(LINK_PROTOCOL, "");
 };
+const getInstalledDependencies = (projectPath) => {
+    // read package json from projectInfo.path
+    const packageJson = JSON.parse(fs.readFileSync(path.join(projectPath, "package.json"), "utf-8"));
+    // Get all installed Powerhouse dependencies
+    const installedDeps = Object.keys({
+        ...(packageJson.dependencies || {}),
+        ...(packageJson.devDependencies || {}),
+    })
+        .filter((name) => PH_PROJECT_DEPENDENCIES.includes(name))
+        .sort(); // Sort dependencies alphabetically
+    return installedDeps;
+};
 export const update = (options) => {
     const { force, packageManager, debug } = options;
     if (debug) {
@@ -59,9 +71,17 @@ export const update = (options) => {
         updatePackageJson(env, undefined, pkgManagerName, debug);
         return;
     }
+    const installedDeps = getInstalledDependencies(projectInfo.path);
+    if (installedDeps.length === 0) {
+        console.log("ℹ️ No Powerhouse dependencies found to update");
+        return;
+    }
     const pkgManager = packageManagers[pkgManagerName];
-    const deps = PH_PROJECT_DEPENDENCIES.join(" ");
+    const deps = installedDeps.join(" ");
     const updateCommand = pkgManager.updateCommand.replace("{{dependency}}", deps);
+    if (options.debug) {
+        console.log(">>> dependencies to update", installedDeps);
+    }
     const commandOptions = { cwd: projectInfo.path };
     execSync(updateCommand, {
         stdio: "inherit",
@@ -71,6 +91,7 @@ export const update = (options) => {
 export function updateCommand(program) {
     program
         .command("update")
+        .alias("up")
         .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")

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

@@ -2,12 +2,15 @@ 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 SPECIAL_PACKAGES: string[];
 export declare const PACKAGES: string[];
+export declare const CLIS: string[];
+export declare const APPS: string[];
 export declare const PH_PROJECT_DEPENDENCIES: string[];
 export declare const PH_PROJECT_LOCAL_DEPENDENCIES: string[];
 export declare const ENV_MAP: {
     dev: string;
+    staging: string;
     prod: string;
     latest: string;
 };
@@ -22,6 +25,7 @@ export declare const use: CommandActionType<[
         local?: string;
         debug?: boolean;
         latest?: boolean;
+        force?: boolean;
         packageManager?: string;
     }
 ]>;

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

@@ -1 +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,EAIL,KAAK,cAAc,EACpB,MAAM,aAAa,CAAC;AAErB,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,MAAM,GAAG,SAAS;IAClB,MAAM,GAAG,SAAS;IAClB;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,CA0BF,CAAC;AAEF,wBAAgB,UAAU,CAAC,OAAO,EAAE,OAAO,QAoB1C"}
+{"version":3,"file":"use.d.ts","sourceRoot":"","sources":["../../../src/commands/use.ts"],"names":[],"mappings":"AAAA,OAAO,EAAE,KAAK,OAAO,EAAE,MAAM,WAAW,CAAC;AAGzC,OAAO,EAAE,KAAK,iBAAiB,EAAE,MAAM,aAAa,CAAC;AACrD,OAAO,EAIL,KAAK,cAAc,EACpB,MAAM,aAAa,CAAC;AAErB,eAAO,MAAM,GAAG,mBAAmB,CAAC;AAGpC,eAAO,MAAM,gBAAgB,UAAuC,CAAC;AAGrE,eAAO,MAAM,QAAQ,UAapB,CAAC;AAEF,eAAO,MAAM,IAAI,UAAuB,CAAC;AAEzC,eAAO,MAAM,IAAI,UAA6B,CAAC;AAE/C,eAAO,MAAM,uBAAuB,UAOnC,CAAC;AAEF,eAAO,MAAM,6BAA6B,UAIzC,CAAC;AAEF,eAAO,MAAM,OAAO;;;;;CAKnB,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,SAgEhB,CAAC;AAEF,eAAO,MAAM,GAAG,EAAE,iBAAiB,CACjC;IACE,MAAM,GAAG,SAAS;IAClB,MAAM,GAAG,SAAS;IAClB;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,KAAK,CAAC,EAAE,OAAO,CAAC;QAChB,cAAc,CAAC,EAAE,MAAM,CAAC;KACzB;CACF,CA4BF,CAAC;AAEF,wBAAgB,UAAU,CAAC,OAAO,EAAE,OAAO,QAqB1C"}

package/dist/src/commands/use.js

@@ -1,7 +1,10 @@
+import { readFileSync } from "node:fs";
 import path from "node:path";
 import { getPackageManagerFromLockfile, getProjectInfo, installDependency, } from "../utils.js";
 export const ORG = "@powerhousedao";
-export const CLIS = ["ph-cli"];
+// Special packages that don't use the @powerhousedao organization
+export const SPECIAL_PACKAGES = ["document-model", "document-drive"];
+// Dynamically list all packages, clis, and apps
 export const PACKAGES = [
     "common",
     "design-system",
@@ -11,37 +14,73 @@ export const PACKAGES = [
     "reactor-api",
     "reactor-local",
     "scalars",
+    "switchboard-gui",
+    "renown",
+    "config",
+    ...SPECIAL_PACKAGES,
 ];
+export const CLIS = ["ph-cli", "ph-cmd"];
+export const APPS = ["switchboard", "connect"];
 export const PH_PROJECT_DEPENDENCIES = [
-    ...PACKAGES.map((dependency) => `${ORG}/${dependency}`),
+    ...PACKAGES.filter((pkg) => !SPECIAL_PACKAGES.includes(pkg)).map((dependency) => `${ORG}/${dependency}`),
+    ...SPECIAL_PACKAGES,
     ...CLIS.map((dependency) => `${ORG}/${dependency}`),
+    ...APPS.map((dependency) => `${ORG}/${dependency}`),
 ];
 export const PH_PROJECT_LOCAL_DEPENDENCIES = [
     ...PACKAGES.map((dependency) => path.join("packages", dependency)),
     ...CLIS.map((dependency) => path.join("clis", dependency)),
+    ...APPS.map((dependency) => path.join("apps", dependency)),
 ];
 export const ENV_MAP = {
     dev: "dev",
+    staging: "staging",
     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);
     }
+    // Read the project's package.json
+    const packageJsonPath = path.join(projectInfo.path, "package.json");
+    const packageJsonContent = readFileSync(packageJsonPath, "utf-8");
+    const packageJson = JSON.parse(packageJsonContent);
+    const existingDependencies = {
+        ...(packageJson.dependencies || {}),
+        ...(packageJson.devDependencies || {}),
+    };
+    const dependencies = [];
     if (localPath) {
-        const localPathDependencies = PH_PROJECT_LOCAL_DEPENDENCIES.map((dependency) => path.join(localPath, dependency));
-        dependencies.push(...localPathDependencies);
+        // For local path, only include dependencies that exist in package.json
+        PH_PROJECT_LOCAL_DEPENDENCIES.forEach((dependency) => {
+            const fullPath = path.join(localPath, dependency);
+            const packageName = path.basename(dependency);
+            const depName = SPECIAL_PACKAGES.includes(packageName)
+                ? packageName
+                : `${ORG}/${packageName}`;
+            if (existingDependencies[depName]) {
+                dependencies.push(fullPath);
+            }
+        });
     }
     else {
-        dependencies.push(...PH_PROJECT_DEPENDENCIES.map((dependency) => `${dependency}@${ENV_MAP[env]}`));
+        // For remote dependencies, only include those that exist in package.json
+        PH_PROJECT_DEPENDENCIES.forEach((dependency) => {
+            if (existingDependencies[dependency]) {
+                dependencies.push(`${dependency}@${ENV_MAP[env]}`);
+            }
+        });
     }
     if (debug) {
-        console.log(">>> dependencies", dependencies);
+        console.log(">>> dependencies to update", dependencies);
+    }
+    if (dependencies.length === 0) {
+        console.log("ℹ️ No Powerhouse dependencies found to update");
+        return;
     }
     try {
         console.log("⚙️ Updating dependencies...");
@@ -55,8 +94,10 @@ export const updatePackageJson = (env, localPath, packageManager, debug) => {
 };
 export const use = (environment, localPath, options) => {
     if (!environment ||
-        (environment !== "local" && !Object.keys(ENV_MAP).includes(environment))) {
-        throw new Error("❌ Invalid environment, please use one of the following: latest, dev, prod, local");
+        (!options.force &&
+            environment !== "local" &&
+            !Object.keys(ENV_MAP).includes(environment))) {
+        throw new Error(`❌ Invalid environment, use --force or use one of the following: ${Object.keys(ENV_MAP).join(", ")}`);
     }
     if (environment === "local" && !localPath) {
         throw new Error("❌ Local environment requires a local path, please specify the path to the local environment");
@@ -74,6 +115,7 @@ export function useCommand(program) {
         .description("Allows you to change your environment (latest, development, production, local)")
         .argument("<environment>", "The environment to use (latest, dev, prod, local)")
         .argument("[localPath]", "The path to the local environment (you have to specify the path to the local environment)")
+        .option("--force", "force environment to use")
         .option("--package-manager <packageManager>", "force package manager to use")
         .option("--debug", "Show additional logs")
         .action(use);