isolate-package 1.27.0 → 1.28.1

package/src/lib/patches/copy-patches.ts

@@ -28,11 +28,11 @@ export async function copyPatches({
   let workspaceRootManifest: PackageManifest;
   try {
     workspaceRootManifest = await readTypedJson<PackageManifest>(
-      path.join(workspaceRootDir, "package.json")
+      path.join(workspaceRootDir, "package.json"),
     );
   } catch (error) {
     log.warn(
-      `Could not read workspace root package.json: ${error instanceof Error ? error.message : String(error)}`
+      `Could not read workspace root package.json: ${error instanceof Error ? error.message : String(error)}`,
     );
     return {};
   }
@@ -45,7 +45,7 @@ export async function copyPatches({
   }
 
   log.debug(
-    `Found ${Object.keys(patchedDependencies).length} patched dependencies in workspace`
+    `Found ${Object.keys(patchedDependencies).length} patched dependencies in workspace`,
   );
 
   const filteredPatches = filterPatchedDependencies({
@@ -69,7 +69,7 @@ export async function copyPatches({
 
     if (!fs.existsSync(sourcePatchPath)) {
       log.warn(
-        `Patch file not found: ${getRootRelativeLogPath(sourcePatchPath, workspaceRootDir)}`
+        `Patch file not found: ${getRootRelativeLogPath(sourcePatchPath, workspaceRootDir)}`,
       );
       continue;
     }
@@ -106,7 +106,7 @@ export async function copyPatches({
  * Since the file content is the same after copying, the hash remains valid.
  */
 async function readLockfilePatchedDependencies(
-  workspaceRootDir: string
+  workspaceRootDir: string,
 ): Promise<Record<string, PatchFile> | undefined> {
   try {
     const { majorVersion } = usePackageManager();

package/src/lib/registry/create-packages-registry.ts

@@ -13,19 +13,19 @@ import { findPackagesGlobs } from "./helpers";
  */
 export async function createPackagesRegistry(
   workspaceRootDir: string,
-  workspacePackagesOverride: string[] | undefined
+  workspacePackagesOverride: string[] | undefined,
 ): Promise<PackagesRegistry> {
   const log = useLogger();
 
   if (workspacePackagesOverride) {
     log.debug(
-      `Override workspace packages via config: ${workspacePackagesOverride.join(", ")}`
+      `Override workspace packages via config: ${workspacePackagesOverride.join(", ")}`,
     );
   }
 
   const allPackages = listWorkspacePackages(
     workspacePackagesOverride,
-    workspaceRootDir
+    workspaceRootDir,
   );
 
   const registry: PackagesRegistry = (
@@ -36,14 +36,14 @@ export async function createPackagesRegistry(
 
         if (!fs.existsSync(manifestPath)) {
           log.warn(
-            `Ignoring directory ${rootRelativeDir} because it does not contain a package.json file`
+            `Ignoring directory ${rootRelativeDir} because it does not contain a package.json file`,
           );
           return;
         } else {
           log.debug(`Registering package ${rootRelativeDir}`);
 
           const manifest = await readTypedJson<PackageManifest>(
-            path.join(absoluteDir, "package.json")
+            path.join(absoluteDir, "package.json"),
           );
 
           return {
@@ -52,7 +52,7 @@ export async function createPackagesRegistry(
             absoluteDir,
           };
         }
-      })
+      }),
     )
   ).reduce<PackagesRegistry>((acc, info) => {
     if (info) {
@@ -70,27 +70,25 @@ type RushConfig = {
 
 function listWorkspacePackages(
   workspacePackagesOverride: string[] | undefined,
-  workspaceRootDir: string
+  workspaceRootDir: string,
 ) {
   if (isRushWorkspace(workspaceRootDir)) {
     const rushConfig = readTypedJsonSync<RushConfig>(
-      path.join(workspaceRootDir, "rush.json")
+      path.join(workspaceRootDir, "rush.json"),
     );
 
     return rushConfig.projects.map(({ projectFolder }) => projectFolder);
   } else {
-    const currentDir = process.cwd();
-    process.chdir(workspaceRootDir);
-
     const packagesGlobs =
       workspacePackagesOverride ?? findPackagesGlobs(workspaceRootDir);
 
     const allPackages = packagesGlobs
-      .flatMap((glob) => globSync(glob))
+      .flatMap((glob) => globSync(glob, { cwd: workspaceRootDir }))
       /** Make sure to filter any loose files that might hang around. */
-      .filter((dir) => fs.lstatSync(dir).isDirectory());
+      .filter((dir) =>
+        fs.lstatSync(path.join(workspaceRootDir, dir)).isDirectory(),
+      );
 
-    process.chdir(currentDir);
     return allPackages;
   }
 }

package/src/lib/registry/helpers/find-packages-globs.ts

@@ -21,18 +21,18 @@ export function findPackagesGlobs(workspaceRootDir: string) {
   switch (packageManager.name) {
     case "pnpm": {
       const workspaceConfig = readTypedYamlSync<{ packages: string[] }>(
-        path.join(workspaceRootDir, "pnpm-workspace.yaml")
+        path.join(workspaceRootDir, "pnpm-workspace.yaml"),
       );
 
       if (!workspaceConfig) {
         throw new Error(
-          "pnpm-workspace.yaml file is empty. Please specify packages configuration."
+          "pnpm-workspace.yaml file is empty. Please specify packages configuration.",
         );
       }
 
       assert(
         workspaceConfig.packages,
-        "packages property must be defined in pnpm-workspace.yaml"
+        "packages property must be defined in pnpm-workspace.yaml",
       );
 
       const { packages: globs } = workspaceConfig;
@@ -45,16 +45,16 @@ export function findPackagesGlobs(workspaceRootDir: string) {
     case "npm": {
       const workspaceRootManifestPath = path.join(
         workspaceRootDir,
-        "package.json"
+        "package.json",
       );
 
       const { workspaces } = readTypedJsonSync<{ workspaces: string[] }>(
-        workspaceRootManifestPath
+        workspaceRootManifestPath,
       );
 
       if (!workspaces) {
         throw new Error(
-          `No workspaces field found in ${workspaceRootManifestPath}`
+          `No workspaces field found in ${workspaceRootManifestPath}`,
         );
       }
 
@@ -70,7 +70,7 @@ export function findPackagesGlobs(workspaceRootDir: string) {
 
         assert(
           workspacesObject.packages,
-          "workspaces.packages must be an array"
+          "workspaces.packages must be an array",
         );
 
         return workspacesObject.packages;

package/src/lib/registry/list-internal-packages.test.ts

@@ -0,0 +1,291 @@
+import { afterEach, describe, expect, it, vi } from "vitest";
+import type { PackageManifest, PackagesRegistry } from "~/lib/types";
+import { listInternalPackages } from "./list-internal-packages";
+
+const mockWarn = vi.fn();
+
+vi.mock("~/lib/logger", () => ({
+  useLogger: () => ({
+    debug: vi.fn(),
+    info: vi.fn(),
+    warn: mockWarn,
+    error: vi.fn(),
+  }),
+}));
+
+/** Helper to create a minimal WorkspacePackageInfo entry */
+function entry(manifest: PackageManifest) {
+  return {
+    absoluteDir: `/workspace/packages/${manifest.name}`,
+    rootRelativeDir: `packages/${manifest.name}`,
+    manifest,
+  };
+}
+
+describe("listInternalPackages", () => {
+  afterEach(() => {
+    mockWarn.mockClear();
+  });
+
+  it("should return an empty array when there are no internal dependencies", () => {
+    const manifest: PackageManifest = {
+      name: "app",
+      version: "1.0.0",
+      dependencies: { lodash: "^4.0.0" },
+    };
+
+    const registry: PackagesRegistry = {
+      app: entry(manifest),
+    };
+
+    const result = listInternalPackages(manifest, registry);
+    expect(result).toEqual([]);
+    expect(mockWarn).not.toHaveBeenCalled();
+  });
+
+  it("should resolve a simple internal dependency", () => {
+    const utilsManifest: PackageManifest = {
+      name: "utils",
+      version: "1.0.0",
+    };
+
+    const appManifest: PackageManifest = {
+      name: "app",
+      version: "1.0.0",
+      dependencies: { utils: "workspace:*", lodash: "^4.0.0" },
+    };
+
+    const registry: PackagesRegistry = {
+      app: entry(appManifest),
+      utils: entry(utilsManifest),
+    };
+
+    const result = listInternalPackages(appManifest, registry);
+    expect(result).toEqual(["utils"]);
+    expect(mockWarn).not.toHaveBeenCalled();
+  });
+
+  it("should recursively resolve transitive internal dependencies", () => {
+    const coreManifest: PackageManifest = {
+      name: "core",
+      version: "1.0.0",
+    };
+
+    const utilsManifest: PackageManifest = {
+      name: "utils",
+      version: "1.0.0",
+      dependencies: { core: "workspace:*" },
+    };
+
+    const appManifest: PackageManifest = {
+      name: "app",
+      version: "1.0.0",
+      dependencies: { utils: "workspace:*" },
+    };
+
+    const registry: PackagesRegistry = {
+      app: entry(appManifest),
+      utils: entry(utilsManifest),
+      core: entry(coreManifest),
+    };
+
+    const result = listInternalPackages(appManifest, registry);
+    expect(result).toEqual(expect.arrayContaining(["utils", "core"]));
+    expect(result).toHaveLength(2);
+    expect(mockWarn).not.toHaveBeenCalled();
+  });
+
+  it("should deduplicate diamond dependencies without warning", () => {
+    const coreManifest: PackageManifest = {
+      name: "core",
+      version: "1.0.0",
+    };
+
+    const utilsManifest: PackageManifest = {
+      name: "utils",
+      version: "1.0.0",
+      dependencies: { core: "workspace:*" },
+    };
+
+    const helpersManifest: PackageManifest = {
+      name: "helpers",
+      version: "1.0.0",
+      dependencies: { core: "workspace:*" },
+    };
+
+    const appManifest: PackageManifest = {
+      name: "app",
+      version: "1.0.0",
+      dependencies: { utils: "workspace:*", helpers: "workspace:*" },
+    };
+
+    const registry: PackagesRegistry = {
+      app: entry(appManifest),
+      utils: entry(utilsManifest),
+      helpers: entry(helpersManifest),
+      core: entry(coreManifest),
+    };
+
+    const result = listInternalPackages(appManifest, registry);
+    expect(result).toEqual(
+      expect.arrayContaining(["utils", "helpers", "core"]),
+    );
+    expect(result).toHaveLength(3);
+    expect(mockWarn).not.toHaveBeenCalled();
+  });
+
+  it("should detect a two-node cycle and log a warning", () => {
+    /** A depends on B, B depends on A */
+    const bManifest: PackageManifest = {
+      name: "b",
+      version: "1.0.0",
+      dependencies: { a: "workspace:*" },
+    };
+
+    const aManifest: PackageManifest = {
+      name: "a",
+      version: "1.0.0",
+      dependencies: { b: "workspace:*" },
+    };
+
+    const appManifest: PackageManifest = {
+      name: "app",
+      version: "1.0.0",
+      dependencies: { a: "workspace:*" },
+    };
+
+    const registry: PackagesRegistry = {
+      app: entry(appManifest),
+      a: entry(aManifest),
+      b: entry(bManifest),
+    };
+
+    const result = listInternalPackages(appManifest, registry);
+    expect(result).toEqual(expect.arrayContaining(["a", "b"]));
+    expect(result).toHaveLength(2);
+    /** Chain: app → a → b → a */
+    expect(mockWarn).toHaveBeenCalledWith(
+      expect.stringContaining("app → a → b → a"),
+    );
+  });
+
+  it("should detect a cycle in nested dependencies and log a warning", () => {
+    /** App depends on A, A depends on B, B depends on C, C depends on B */
+    const cManifest: PackageManifest = {
+      name: "c",
+      version: "1.0.0",
+      dependencies: { b: "workspace:*" },
+    };
+
+    const bManifest: PackageManifest = {
+      name: "b",
+      version: "1.0.0",
+      dependencies: { c: "workspace:*" },
+    };
+
+    const aManifest: PackageManifest = {
+      name: "a",
+      version: "1.0.0",
+      dependencies: { b: "workspace:*" },
+    };
+
+    const appManifest: PackageManifest = {
+      name: "app",
+      version: "1.0.0",
+      dependencies: { a: "workspace:*" },
+    };
+
+    const registry: PackagesRegistry = {
+      app: entry(appManifest),
+      a: entry(aManifest),
+      b: entry(bManifest),
+      c: entry(cManifest),
+    };
+
+    const result = listInternalPackages(appManifest, registry);
+    expect(result).toEqual(expect.arrayContaining(["a", "b", "c"]));
+    expect(result).toHaveLength(3);
+    /** Chain: app → a → b → c → b */
+    expect(mockWarn).toHaveBeenCalledWith(
+      expect.stringContaining("app → a → b → c → b"),
+    );
+  });
+
+  it("should include devDependencies and handle cycles in them", () => {
+    const devLibManifest: PackageManifest = {
+      name: "dev-lib",
+      version: "1.0.0",
+      dependencies: { app: "workspace:*" },
+    };
+
+    const appManifest: PackageManifest = {
+      name: "app",
+      version: "1.0.0",
+      dependencies: { lodash: "^4.0.0" },
+      devDependencies: { "dev-lib": "workspace:*" },
+    };
+
+    const registry: PackagesRegistry = {
+      app: entry(appManifest),
+      "dev-lib": entry(devLibManifest),
+    };
+
+    /** Without devDependencies — should not find dev-lib */
+    const withoutDev = listInternalPackages(appManifest, registry);
+    expect(withoutDev).toEqual([]);
+    expect(mockWarn).not.toHaveBeenCalled();
+
+    /** With devDependencies — should find dev-lib and detect the cycle back to app */
+    const withDev = listInternalPackages(appManifest, registry, {
+      includeDevDependencies: true,
+    });
+    expect(withDev).toEqual(["dev-lib"]);
+    /** Chain: app → dev-lib → app */
+    expect(mockWarn).toHaveBeenCalledWith(
+      expect.stringContaining("app → dev-lib → app"),
+    );
+  });
+
+  it("should handle name clash that creates a false cycle (issue #138)", () => {
+    /**
+     * Reproduces the crash from issue #138: internal "config" depends on
+     * "server", and "server" depends on the npm "config" package. Because
+     * both the internal and external package share the name "config", the
+     * tool misidentifies the external reference as internal, creating a
+     * cycle: config → server → config. Without cycle detection this causes
+     * "Maximum call stack size exceeded".
+     */
+    const configManifest: PackageManifest = {
+      name: "config",
+      version: "1.0.0",
+      dependencies: { server: "workspace:*" },
+    };
+
+    const serverManifest: PackageManifest = {
+      name: "server",
+      version: "1.0.0",
+      /** Intended as npm "config", but misidentified as the internal one */
+      dependencies: { config: "^3.0.0" },
+    };
+
+    const appManifest: PackageManifest = {
+      name: "app",
+      version: "1.0.0",
+      dependencies: { config: "workspace:*" },
+    };
+
+    const registry: PackagesRegistry = {
+      app: entry(appManifest),
+      server: entry(serverManifest),
+      config: entry(configManifest),
+    };
+
+    const result = listInternalPackages(appManifest, registry);
+    expect(result).toEqual(expect.arrayContaining(["config", "server"]));
+    expect(result).toHaveLength(2);
+    /** The false cycle config → server → config is detected and warned about */
+    expect(mockWarn).toHaveBeenCalledWith(
+      expect.stringContaining("app → config → server → config"),
+    );
+  });
+});

package/src/lib/registry/list-internal-packages.ts

@@ -1,20 +1,19 @@
 import { got } from "get-or-throw";
-import { unique } from "remeda";
+import { useLogger } from "../logger";
 import type { PackageManifest, PackagesRegistry } from "../types";
 
 /**
- * Recursively list all the packages from dependencies (and optionally
- * devDependencies) that are found in the monorepo.
- *
- * Here we do not need to rely on packages being declared with "workspace:" in
- * the package manifest. We can simply compare the package names with the list
- * of packages that were found via the workspace glob patterns and add them to
- * the registry.
+ * Recursively collect internal packages, tracking visited nodes and the current
+ * ancestor chain to detect cycles. When a cycle is detected, the cyclic
+ * reference is not followed, preventing infinite recursion, and a warning is
+ * logged.
  */
-export function listInternalPackages(
+function collectInternalPackages(
   manifest: PackageManifest,
   packagesRegistry: PackagesRegistry,
-  { includeDevDependencies = false } = {}
+  includeDevDependencies: boolean,
+  visited: Set<string>,
+  ancestors: Set<string>,
 ): string[] {
   const allWorkspacePackageNames = Object.keys(packagesRegistry);
 
@@ -27,14 +26,67 @@ export function listInternalPackages(
       : Object.keys(manifest.dependencies ?? {})
   ).filter((name) => allWorkspacePackageNames.includes(name));
 
-  const nestedInternalPackageNames = internalPackageNames.flatMap(
-    (packageName) =>
-      listInternalPackages(
-        got(packagesRegistry, packageName).manifest,
-        packagesRegistry,
-        { includeDevDependencies }
-      )
+  const result: string[] = [];
+
+  for (const packageName of internalPackageNames) {
+    if (ancestors.has(packageName)) {
+      /** Cycle detected — log a warning, skip adding and recursion */
+      const chain = [...ancestors, packageName].join(" → ");
+      const log = useLogger();
+      log.warn(
+        `Circular dependency detected: ${chain}. This is likely caused by a workspace package name clashing with an external npm dependency.`,
+      );
+      continue;
+    }
+
+    if (visited.has(packageName)) {
+      /** Already fully processed (diamond dependency) — skip silently */
+      continue;
+    }
+
+    result.push(packageName);
+
+    ancestors.add(packageName);
+    const nested = collectInternalPackages(
+      got(packagesRegistry, packageName).manifest,
+      packagesRegistry,
+      includeDevDependencies,
+      visited,
+      ancestors,
+    );
+    ancestors.delete(packageName);
+    visited.add(packageName);
+
+    result.push(...nested);
+  }
+
+  return result;
+}
+
+/**
+ * Recursively list all the packages from dependencies (and optionally
+ * devDependencies) that are found in the monorepo.
+ *
+ * Here we do not need to rely on packages being declared with "workspace:" in
+ * the package manifest. We can simply compare the package names with the list
+ * of packages that were found via the workspace glob patterns and add them to
+ * the registry.
+ */
+export function listInternalPackages(
+  manifest: PackageManifest,
+  packagesRegistry: PackagesRegistry,
+  { includeDevDependencies = false } = {},
+): string[] {
+  const visited = new Set<string>();
+  const ancestors = new Set<string>(manifest.name ? [manifest.name] : []);
+
+  const result = collectInternalPackages(
+    manifest,
+    packagesRegistry,
+    includeDevDependencies,
+    visited,
+    ancestors,
   );
 
-  return unique(internalPackageNames.concat(nestedInternalPackageNames));
+  return [...new Set(result)];
 }

package/src/lib/utils/filter-object-undefined.test.ts

@@ -8,7 +8,7 @@ describe("filterObjectUndefined", () => {
         a: "a",
         b: undefined,
         c: "c",
-      })
+      }),
     ).toEqual({
       a: "a",
       c: "c",

package/src/lib/utils/filter-object-undefined.ts

@@ -1,5 +1,5 @@
 export function filterObjectUndefined(object: Record<string, unknown>) {
   return Object.fromEntries(
-    Object.entries(object).filter(([_, value]) => value !== undefined)
+    Object.entries(object).filter(([_, value]) => value !== undefined),
   );
 }

package/src/lib/utils/filter-patched-dependencies.ts

@@ -50,13 +50,13 @@ export function filterPatchedDependencies<T>({
 
     /** Package not found in dependencies or devDependencies */
     log.debug(
-      `Excluding patch: ${packageSpec} (package "${packageName}" not in target dependencies)`
+      `Excluding patch: ${packageSpec} (package "${packageName}" not in target dependencies)`,
     );
     excludedCount++;
   }
 
   log.debug(
-    `Filtered patches: ${includedCount} included, ${excludedCount} excluded`
+    `Filtered patches: ${includedCount} included, ${excludedCount} excluded`,
   );
 
   return Object.keys(filteredPatches).length > 0 ? filteredPatches : undefined;

package/src/lib/utils/json.ts

@@ -7,13 +7,13 @@ export function readTypedJsonSync<T>(filePath: string) {
   try {
     const rawContent = fs.readFileSync(filePath, "utf-8");
     const data = JSON.parse(
-      stripJsonComments(rawContent, { trailingCommas: true })
+      stripJsonComments(rawContent, { trailingCommas: true }),
     ) as T;
     return data;
   } catch (err) {
     throw new Error(
       `Failed to read JSON from ${filePath}: ${getErrorMessage(err)}`,
-      { cause: err }
+      { cause: err },
     );
   }
 }
@@ -22,13 +22,13 @@ export async function readTypedJson<T>(filePath: string) {
   try {
     const rawContent = await fs.readFile(filePath, "utf-8");
     const data = JSON.parse(
-      stripJsonComments(rawContent, { trailingCommas: true })
+      stripJsonComments(rawContent, { trailingCommas: true }),
     ) as T;
     return data;
   } catch (err) {
     throw new Error(
       `Failed to read JSON from ${filePath}: ${getErrorMessage(err)}`,
-      { cause: err }
+      { cause: err },
     );
   }
 }

package/src/lib/utils/pack.ts

@@ -32,7 +32,7 @@ export async function pack(srcDir: string, dstDir: string) {
             }
 
             resolve(stdout);
-          }
+          },
         );
       })
     : await new Promise<string>((resolve, reject) => {
@@ -45,7 +45,7 @@ export async function pack(srcDir: string, dstDir: string) {
             }
 
             resolve(stdout);
-          }
+          },
         );
       });
 
@@ -61,7 +61,7 @@ export async function pack(srcDir: string, dstDir: string) {
 
   if (!fs.existsSync(filePath)) {
     log.error(
-      `The response from pack could not be resolved to an existing file: ${filePath}`
+      `The response from pack could not be resolved to an existing file: ${filePath}`,
     );
   } else {
     log.debug(`Packed (temp)/${fileName}`);

package/src/lib/utils/yaml.ts

@@ -11,7 +11,7 @@ export function readTypedYamlSync<T>(filePath: string) {
   } catch (err) {
     throw new Error(
       `Failed to read YAML from ${filePath}: ${getErrorMessage(err)}`,
-      { cause: err }
+      { cause: err },
     );
   }
 }