Support absolute targetPackagePath independent of cwd (#204)

`targetPackagePath` was resolved with `path.join(process.cwd(),
targetPackagePath)` and the workspace root pinned to `process.cwd()`, so
callers had to guarantee the process runs at the workspace root. An
absolute path produced a broken join.

An absolute `targetPackagePath` now targets that directory directly, and
the workspace root is resolved the same way as the
no-`targetPackagePath` case: from the `workspaceRoot` setting, or
auto-detected by walking upward from the target package directory.
Relative paths keep their exact existing semantics, so this is purely
additive — absolute paths were previously a broken input nobody could
depend on.

Motivation: the firebase-tools PR upstreaming the isolate integration
(firebase/firebase-tools#10996) got review feedback that its isolate
call breaks when the CLI runs from a subdirectory of the project. With
this change firebase-tools can pass its already-resolved absolute source
directory and be correct from any cwd, without a `process.chdir`
workaround.

Decisions:
- Gated the new behavior on `path.isAbsolute` rather than changing
relative-path semantics, to stay non-breaking for existing configs.
- With an absolute path, `workspaceRoot` is honored instead of ignored
(it was only ignored before because cwd was assumed to be the root).

Author: 0x80

docs/configuration.md

@@ -130,8 +130,14 @@ Only when you decide to place the isolate configuration in the root of the
 monorepo, you use this setting to point it to the target you want to isolate,
 e.g. `./packages/my-firebase-package`.
 
-If this option is used the `workspaceRoot` setting will be ignored and assumed
-to be the current working directory.
+If this option is set to a relative path, the `workspaceRoot` setting will be
+ignored and the workspace root is assumed to be the current working directory.
+
+The path can also be absolute, which makes isolation independent of the
+current working directory. In that case the workspace root is resolved the
+same way as when `targetPackagePath` is omitted: from the `workspaceRoot`
+setting, or otherwise auto-detected by walking upward from the target package
+directory.
 
 ### tsconfigPath
 
@@ -168,5 +174,6 @@ You only need to set this explicitly when auto-detection fails, for example
 when the target package is nested more than a few levels deep inside the
 workspace.
 
-When you use the `targetPackagePath` option, this setting is ignored and the
-workspace root is assumed to be the current working directory.
+When you set the `targetPackagePath` option to a relative path, this setting
+is ignored and the workspace root is assumed to be the current working
+directory. With an absolute `targetPackagePath` this setting is honored.

src/lib/config.test.ts

@@ -2,7 +2,12 @@ import fs from "fs-extra";
 import path from "node:path";
 import os from "node:os";
 import { afterEach, beforeEach, describe, expect, it, vi } from "vitest";
-import { defineConfig, loadConfigFromFile } from "./config";
+import {
+  defineConfig,
+  type IsolateConfigResolved,
+  loadConfigFromFile,
+  resolveWorkspacePaths,
+} from "./config";
 
 /** Shared mock logger instance so assertions can check calls. */
 const mockLogger = {
@@ -161,3 +166,99 @@ describe("defineConfig", () => {
     expect(result).toBe(input);
   });
 });
+
+describe("resolveWorkspacePaths", () => {
+  /** The required config fields; path-related options are added per test. */
+  const baseConfig: IsolateConfigResolved = {
+    includeDevDependencies: false,
+    isolateDirName: "isolate",
+    logLevel: "info",
+    tsconfigPath: "./tsconfig.json",
+    forceNpm: false,
+  };
+
+  let tempDir: string;
+  let originalCwd: string;
+
+  beforeEach(async () => {
+    originalCwd = process.cwd();
+    const dir = await fs.mkdtemp(path.join(os.tmpdir(), "isolate-paths-test-"));
+    /**
+     * Resolve symlinks (macOS tmpdir) so comparisons against process.cwd()
+     * and detected roots are stable.
+     */
+    tempDir = await fs.realpath(dir);
+    /** Bound upward workspace detection to the fixture. */
+    await fs.mkdir(path.join(tempDir, ".git"));
+  });
+
+  afterEach(async () => {
+    process.chdir(originalCwd);
+    await fs.remove(tempDir);
+  });
+
+  it("treats a relative targetPackagePath as cwd-relative with cwd as workspace root", () => {
+    process.chdir(tempDir);
+
+    const result = resolveWorkspacePaths({
+      ...baseConfig,
+      targetPackagePath: "./packages/functions",
+    });
+
+    expect(result.targetPackageDir).toBe(
+      path.join(tempDir, "./packages/functions"),
+    );
+    expect(result.workspaceRootDir).toBe(tempDir);
+  });
+
+  it("uses an absolute targetPackagePath independent of cwd and auto-detects the workspace root", async () => {
+    await fs.writeFile(
+      path.join(tempDir, "pnpm-workspace.yaml"),
+      "packages:\n  - packages/*\n",
+    );
+    const targetPackageDir = path.join(tempDir, "packages", "functions");
+    await fs.mkdirp(targetPackageDir);
+    await fs.writeFile(
+      path.join(targetPackageDir, "package.json"),
+      '{"name":"functions"}',
+    );
+    /** Run from an unrelated directory to prove cwd independence. */
+    process.chdir(os.tmpdir());
+
+    const result = resolveWorkspacePaths({
+      ...baseConfig,
+      targetPackagePath: targetPackageDir,
+    });
+
+    expect(result.targetPackageDir).toBe(targetPackageDir);
+    expect(result.workspaceRootDir).toBe(tempDir);
+  });
+
+  it("honors the workspaceRoot setting for an absolute targetPackagePath", async () => {
+    const targetPackageDir = path.join(tempDir, "packages", "functions");
+    await fs.mkdirp(targetPackageDir);
+    process.chdir(os.tmpdir());
+
+    const result = resolveWorkspacePaths({
+      ...baseConfig,
+      targetPackagePath: targetPackageDir,
+      workspaceRoot: "../..",
+    });
+
+    expect(result.targetPackageDir).toBe(targetPackageDir);
+    expect(result.workspaceRootDir).toBe(path.join(targetPackageDir, "../.."));
+  });
+
+  it("throws for an absolute targetPackagePath when no workspace root is found", async () => {
+    const targetPackageDir = path.join(tempDir, "packages", "functions");
+    await fs.mkdirp(targetPackageDir);
+    process.chdir(os.tmpdir());
+
+    expect(() =>
+      resolveWorkspacePaths({
+        ...baseConfig,
+        targetPackagePath: targetPackageDir,
+      }),
+    ).toThrow(/Failed to auto-detect monorepo workspace root/);
+  });
+});

src/lib/config.ts

@@ -12,6 +12,15 @@ export type IsolateConfigResolved = {
   includeDevDependencies: boolean;
   isolateDirName: string;
   logLevel: LogLevel;
+  /**
+   * Path to the package that should be isolated. A relative path is resolved
+   * against the current working directory, which is then assumed to be the
+   * workspace root. An absolute path makes isolation independent of the
+   * current working directory; the workspace root is then taken from
+   * `workspaceRoot` or auto-detected by walking upward from the target
+   * package directory. When omitted, the current working directory is the
+   * target package.
+   */
   targetPackagePath?: string;
   tsconfigPath: string;
   workspacePackages?: string[];
@@ -175,18 +184,21 @@ function validateConfig(config: IsolateConfig) {
 
 /**
  * Resolve the target package directory and workspace root directory from the
- * configuration. When targetPackagePath is set, the config is assumed to live
- * at the workspace root. Otherwise it lives in the target package directory.
- *
- * When `workspaceRoot` is not explicitly set, auto-detect the monorepo root by
- * walking upward from the target package directory.
+ * configuration. When targetPackagePath is a relative path, it is resolved
+ * against the current working directory and the config is assumed to live at
+ * the workspace root. When targetPackagePath is an absolute path, the current
+ * working directory is irrelevant and the workspace root is resolved like it
+ * is for the no-targetPackagePath case: from the `workspaceRoot` setting, or
+ * otherwise auto-detected by walking upward from the target package directory.
  */
 export function resolveWorkspacePaths(config: IsolateConfigResolved) {
   const targetPackageDir = config.targetPackagePath
-    ? path.join(process.cwd(), config.targetPackagePath)
+    ? path.isAbsolute(config.targetPackagePath)
+      ? config.targetPackagePath
+      : path.join(process.cwd(), config.targetPackagePath)
     : process.cwd();
 
-  if (config.targetPackagePath) {
+  if (config.targetPackagePath && !path.isAbsolute(config.targetPackagePath)) {
     return { targetPackageDir, workspaceRootDir: process.cwd() };
   }