@bastani/atomic 0.6.6-0 → 0.6.6

package/src/sdk/providers/copilot.test.ts

@@ -0,0 +1,365 @@
+import { afterEach, beforeEach, describe, expect, test } from "bun:test";
+import { chmodSync, mkdirSync, mkdtempSync, symlinkSync, writeFileSync } from "node:fs";
+import { join } from "node:path";
+import { tmpdir } from "node:os";
+import {
+  copilotSubprocessEnv,
+  copilotSdkLaunchOptions,
+  enumeratePathCandidates,
+  isCopilotShim,
+  resolveCopilotCliPath,
+} from "./copilot.ts";
+
+// ── helpers ──────────────────────────────────────────────────────────────────
+
+function makeTempCopilotBin(): { dir: string; bin: string } {
+  const dir = mkdtempSync(join(tmpdir(), "atomic-copilot-test-"));
+  const bin = join(dir, "copilot");
+  writeFileSync(bin, "#!/bin/sh\necho copilot\n", { encoding: "utf-8" });
+  chmodSync(bin, 0o755);
+  return { dir, bin };
+}
+
+function makeEmptyTempDir(): string {
+  return mkdtempSync(join(tmpdir(), "atomic-copilot-empty-"));
+}
+
+/** Creates a dir with a `copilot` file that has a node shebang (shim). */
+function makeNodeShimDir(): string {
+  const dir = mkdtempSync(join(tmpdir(), "atomic-copilot-shim-"));
+  const bin = join(dir, "copilot");
+  writeFileSync(bin, "#!/usr/bin/env node\nconsole.log('shim');\n", { encoding: "utf-8" });
+  chmodSync(bin, 0o755);
+  return dir;
+}
+
+/** Creates a dir with a `copilot` file that has a .js extension. */
+function makeJsExtensionDir(): string {
+  const dir = mkdtempSync(join(tmpdir(), "atomic-copilot-jsext-"));
+  const bin = join(dir, "copilot.js");
+  writeFileSync(bin, "#!/usr/bin/env node\n", { encoding: "utf-8" });
+  chmodSync(bin, 0o755);
+  return dir;
+}
+
+/** Creates a node_modules/.bin/copilot symlink pointing to a .js loader file. */
+function makeNpmLoaderShimDir(): { dir: string; bin: string; target: string } {
+  const dir = mkdtempSync(join(tmpdir(), "atomic-copilot-npmloader-"));
+  const binDir = join(dir, "node_modules", ".bin");
+  mkdirSync(binDir, { recursive: true });
+  const target = join(dir, "npm-loader.js");
+  writeFileSync(target, "// npm-loader.js shim\n", { encoding: "utf-8" });
+  const bin = join(binDir, "copilot");
+  symlinkSync(target, bin);
+  return { dir, bin, target };
+}
+
+/** Creates a dir with a `copilot` file containing npm-loader.js marker in header. */
+function makeNpmLoaderMarkerDir(): string {
+  const dir = mkdtempSync(join(tmpdir(), "atomic-copilot-npmmarker-"));
+  const bin = join(dir, "copilot");
+  writeFileSync(bin, "#!/bin/sh\n# loads npm-loader.js\n", { encoding: "utf-8" });
+  chmodSync(bin, 0o755);
+  return dir;
+}
+
+// ── resolveCopilotCliPath ─────────────────────────────────────────────────
+
+describe("resolveCopilotCliPath", () => {
+  let origCliPath: string | undefined;
+  let origPath: string | undefined;
+
+  beforeEach(() => {
+    origCliPath = process.env["COPILOT_CLI_PATH"];
+    origPath = process.env["PATH"];
+  });
+
+  afterEach(() => {
+    if (origCliPath === undefined) {
+      delete process.env["COPILOT_CLI_PATH"];
+    } else {
+      process.env["COPILOT_CLI_PATH"] = origCliPath;
+    }
+    if (origPath === undefined) {
+      delete process.env["PATH"];
+    } else {
+      process.env["PATH"] = origPath;
+    }
+  });
+
+  test("COPILOT_CLI_PATH env var takes precedence over PATH", () => {
+    const explicit = "/custom/bin/copilot";
+    process.env["COPILOT_CLI_PATH"] = explicit;
+    // even if PATH has a copilot binary, the env var wins
+    expect(resolveCopilotCliPath()).toBe(explicit);
+  });
+
+  test("PATH-resolved copilot binary populates cliPath when env var unset", () => {
+    delete process.env["COPILOT_CLI_PATH"];
+    const { dir, bin } = makeTempCopilotBin();
+    process.env["PATH"] = `${dir}:${origPath ?? ""}`;
+    const result = resolveCopilotCliPath();
+    expect(result).toBe(bin);
+  });
+
+  test("returns undefined when copilot not on PATH and env var unset", () => {
+    delete process.env["COPILOT_CLI_PATH"];
+    const emptyDir = makeEmptyTempDir();
+    process.env["PATH"] = emptyDir;
+    const result = resolveCopilotCliPath();
+    expect(result).toBeUndefined();
+  });
+});
+
+// ── copilotSubprocessEnv ──────────────────────────────────────────────────
+
+describe("copilotSubprocessEnv", () => {
+  test("NODE_NO_WARNINGS is set to '1'", () => {
+    const env = copilotSubprocessEnv({});
+    expect(env["NODE_NO_WARNINGS"]).toBe("1");
+  });
+
+  test("UTF-8 locale defaults applied when base env empty", () => {
+    const env = copilotSubprocessEnv({});
+    expect(env["LANG"]).toBe("en_US.UTF-8");
+    expect(env["LC_ALL"]).toBe("en_US.UTF-8");
+    expect(env["LC_CTYPE"]).toBe("en_US.UTF-8");
+  });
+
+  test("UTF-8 env vars from base merged into result", () => {
+    const base = {
+      LANG: "fr_FR.UTF-8",
+      LC_ALL: "fr_FR.UTF-8",
+      LC_CTYPE: "fr_FR.UTF-8",
+      MY_CUSTOM: "hello",
+    };
+    const env = copilotSubprocessEnv(base);
+    expect(env["LANG"]).toBe("fr_FR.UTF-8");
+    expect(env["LC_ALL"]).toBe("fr_FR.UTF-8");
+    expect(env["MY_CUSTOM"]).toBe("hello");
+    expect(env["NODE_NO_WARNINGS"]).toBe("1");
+  });
+
+  test("NODE_NO_WARNINGS=1 overrides any base value", () => {
+    const env = copilotSubprocessEnv({ NODE_NO_WARNINGS: "0" });
+    expect(env["NODE_NO_WARNINGS"]).toBe("1");
+  });
+
+  test("returns fresh object per call (no shared state)", () => {
+    const a = copilotSubprocessEnv({});
+    const b = copilotSubprocessEnv({});
+    expect(a).not.toBe(b);
+  });
+});
+
+// ── copilotSdkLaunchOptions ───────────────────────────────────────────────
+
+describe("copilotSdkLaunchOptions", () => {
+  let origCliPath: string | undefined;
+  let origPath: string | undefined;
+
+  beforeEach(() => {
+    origCliPath = process.env["COPILOT_CLI_PATH"];
+    origPath = process.env["PATH"];
+  });
+
+  afterEach(() => {
+    if (origCliPath === undefined) {
+      delete process.env["COPILOT_CLI_PATH"];
+    } else {
+      process.env["COPILOT_CLI_PATH"] = origCliPath;
+    }
+    if (origPath === undefined) {
+      delete process.env["PATH"];
+    } else {
+      process.env["PATH"] = origPath;
+    }
+  });
+
+  test("env contains NODE_NO_WARNINGS=1", () => {
+    const opts = copilotSdkLaunchOptions();
+    expect(opts.env?.["NODE_NO_WARNINGS"]).toBe("1");
+  });
+
+  test("cliPath populated from COPILOT_CLI_PATH", () => {
+    process.env["COPILOT_CLI_PATH"] = "/my/copilot";
+    const opts = copilotSdkLaunchOptions();
+    expect(opts.cliPath).toBe("/my/copilot");
+  });
+
+  test("cliPath omitted when copilot not resolvable", () => {
+    delete process.env["COPILOT_CLI_PATH"];
+    const emptyDir = makeEmptyTempDir();
+    process.env["PATH"] = emptyDir;
+    const opts = copilotSdkLaunchOptions();
+    expect("cliPath" in opts).toBe(false);
+  });
+
+  test("cliPath populated from PATH-resolved binary", () => {
+    delete process.env["COPILOT_CLI_PATH"];
+    const { dir, bin } = makeTempCopilotBin();
+    process.env["PATH"] = `${dir}:${origPath ?? ""}`;
+    const opts = copilotSdkLaunchOptions();
+    expect(opts.cliPath).toBe(bin);
+  });
+
+  test("cliPath omitted when only shim on PATH", () => {
+    delete process.env["COPILOT_CLI_PATH"];
+    const shimDir = makeNodeShimDir();
+    process.env["PATH"] = shimDir;
+    const opts = copilotSdkLaunchOptions();
+    expect("cliPath" in opts).toBe(false);
+  });
+});
+
+// ── isCopilotShim ─────────────────────────────────────────────────────────
+
+describe("isCopilotShim", () => {
+  test("returns true for .js extension", () => {
+    const dir = mkdtempSync(join(tmpdir(), "atomic-shim-jsext-"));
+    const p = join(dir, "copilot.js");
+    writeFileSync(p, "#!/usr/bin/env node\n", { encoding: "utf-8" });
+    expect(isCopilotShim(p)).toBe(true);
+  });
+
+  test("returns true for .mjs extension", () => {
+    const dir = mkdtempSync(join(tmpdir(), "atomic-shim-mjs-"));
+    const p = join(dir, "copilot.mjs");
+    writeFileSync(p, "export default {}\n", { encoding: "utf-8" });
+    expect(isCopilotShim(p)).toBe(true);
+  });
+
+  test("returns true for .cjs extension", () => {
+    const dir = mkdtempSync(join(tmpdir(), "atomic-shim-cjs-"));
+    const p = join(dir, "copilot.cjs");
+    writeFileSync(p, "module.exports = {}\n", { encoding: "utf-8" });
+    expect(isCopilotShim(p)).toBe(true);
+  });
+
+  test("returns true for #!/usr/bin/env node shebang", () => {
+    const dir = mkdtempSync(join(tmpdir(), "atomic-shim-shebang-"));
+    const p = join(dir, "copilot");
+    writeFileSync(p, "#!/usr/bin/env node\nconsole.log('hi');\n", { encoding: "utf-8" });
+    chmodSync(p, 0o755);
+    expect(isCopilotShim(p)).toBe(true);
+  });
+
+  test("returns true for #!/usr/bin/node shebang", () => {
+    const dir = mkdtempSync(join(tmpdir(), "atomic-shim-shebang2-"));
+    const p = join(dir, "copilot");
+    writeFileSync(p, "#!/usr/bin/node\nconsole.log('hi');\n", { encoding: "utf-8" });
+    chmodSync(p, 0o755);
+    expect(isCopilotShim(p)).toBe(true);
+  });
+
+  test("returns true when header contains npm-loader.js marker", () => {
+    const dir = mkdtempSync(join(tmpdir(), "atomic-shim-marker-"));
+    const p = join(dir, "copilot");
+    writeFileSync(p, "#!/bin/sh\n# loads npm-loader.js internally\n", { encoding: "utf-8" });
+    chmodSync(p, 0o755);
+    expect(isCopilotShim(p)).toBe(true);
+  });
+
+  test("returns true for node_modules/.bin/copilot symlink pointing to .js file", () => {
+    const { bin } = makeNpmLoaderShimDir();
+    expect(isCopilotShim(bin)).toBe(true);
+  });
+
+  test("returns false for plain shell script binary", () => {
+    const dir = mkdtempSync(join(tmpdir(), "atomic-shim-shell-"));
+    const p = join(dir, "copilot");
+    writeFileSync(p, "#!/bin/sh\necho copilot\n", { encoding: "utf-8" });
+    chmodSync(p, 0o755);
+    expect(isCopilotShim(p)).toBe(false);
+  });
+
+  test("returns false for missing file (let SDK surface the error)", () => {
+    expect(isCopilotShim("/nonexistent/path/copilot")).toBe(false);
+  });
+});
+
+// ── enumeratePathCandidates ───────────────────────────────────────────────
+
+describe("enumeratePathCandidates", () => {
+  test("returns empty array when PATH has no matching binary", () => {
+    const empty = makeEmptyTempDir();
+    expect(enumeratePathCandidates("copilot", empty)).toEqual([]);
+  });
+
+  test("returns single match when one dir has binary", () => {
+    const { dir, bin } = makeTempCopilotBin();
+    const result = enumeratePathCandidates("copilot", dir);
+    expect(result).toEqual([bin]);
+  });
+
+  test("returns ordered matches from multiple PATH dirs", () => {
+    const { dir: dir1, bin: bin1 } = makeTempCopilotBin();
+    const { dir: dir2, bin: bin2 } = makeTempCopilotBin();
+    const result = enumeratePathCandidates("copilot", `${dir1}:${dir2}`);
+    expect(result).toEqual([bin1, bin2]);
+  });
+
+  test("skips dirs that do not contain the binary", () => {
+    const empty = makeEmptyTempDir();
+    const { dir, bin } = makeTempCopilotBin();
+    const result = enumeratePathCandidates("copilot", `${empty}:${dir}`);
+    expect(result).toEqual([bin]);
+  });
+});
+
+// ── resolveCopilotCliPath shim rejection ──────────────────────────────────
+
+describe("resolveCopilotCliPath shim rejection", () => {
+  let origCliPath: string | undefined;
+  let origPath: string | undefined;
+
+  beforeEach(() => {
+    origCliPath = process.env["COPILOT_CLI_PATH"];
+    origPath = process.env["PATH"];
+    delete process.env["COPILOT_CLI_PATH"];
+  });
+
+  afterEach(() => {
+    if (origCliPath === undefined) {
+      delete process.env["COPILOT_CLI_PATH"];
+    } else {
+      process.env["COPILOT_CLI_PATH"] = origCliPath;
+    }
+    if (origPath === undefined) {
+      delete process.env["PATH"];
+    } else {
+      process.env["PATH"] = origPath;
+    }
+  });
+
+  test("returns undefined when only node-shebang shim exists on PATH", () => {
+    process.env["PATH"] = makeNodeShimDir();
+    expect(resolveCopilotCliPath()).toBeUndefined();
+  });
+
+  test("returns undefined when only npm-loader.js symlink shim on PATH", () => {
+    const { dir } = makeNpmLoaderShimDir();
+    const binDir = join(dir, "node_modules", ".bin");
+    process.env["PATH"] = binDir;
+    expect(resolveCopilotCliPath()).toBeUndefined();
+  });
+
+  test("returns undefined when only npm-loader.js marker shim on PATH", () => {
+    process.env["PATH"] = makeNpmLoaderMarkerDir();
+    expect(resolveCopilotCliPath()).toBeUndefined();
+  });
+
+  test("skips shim and returns second PATH candidate (real binary)", () => {
+    const shimDir = makeNodeShimDir();
+    const { dir: realDir, bin: realBin } = makeTempCopilotBin();
+    process.env["PATH"] = `${shimDir}:${realDir}`;
+    expect(resolveCopilotCliPath()).toBe(realBin);
+  });
+
+  test("returns first non-shim when multiple real binaries on PATH", () => {
+    const { dir: dir1, bin: bin1 } = makeTempCopilotBin();
+    const { dir: dir2 } = makeTempCopilotBin();
+    process.env["PATH"] = `${dir1}:${dir2}`;
+    expect(resolveCopilotCliPath()).toBe(bin1);
+  });
+});

package/src/sdk/providers/copilot.ts

@@ -5,27 +5,135 @@
  * `s.client` and `s.session` instead of manual SDK client creation.
  */
 
-import type { SessionConfig as CopilotSessionConfig } from "@github/copilot-sdk";
+import { closeSync, existsSync, openSync, readSync, realpathSync } from "node:fs";
+import { delimiter, join, sep } from "node:path";
+import type {
+  CopilotClientOptions,
+  SessionConfig as CopilotSessionConfig,
+} from "@github/copilot-sdk";
+import { normalizedTerminalEnv } from "../../lib/terminal-env.ts";
+import { getCommandPath } from "../../services/system/detect.ts";
 import { createProviderValidator } from "../types.ts";
 
+const JS_EXT_RE = /\.(js|mjs|cjs)$/i;
+const NODE_SHEBANG_RE = /^#!.*\bnode\b/;
+const NPM_LOADER_MARKER = "npm-loader.js";
+const HEADER_BYTES = 256;
+
+/**
+ * Read the first {@link HEADER_BYTES} of a file as a UTF-8 string.
+ * Returns `null` on any filesystem error (file missing, not readable, etc.).
+ */
+function readCandidateHeader(filePath: string): string | null {
+  let fd: number | undefined;
+  try {
+    fd = openSync(filePath, "r");
+    const buffer = Buffer.alloc(HEADER_BYTES);
+    const bytesRead = readSync(fd, buffer, 0, HEADER_BYTES, 0);
+    return buffer.subarray(0, bytesRead).toString("utf8");
+  } catch {
+    return null;
+  } finally {
+    if (fd !== undefined) closeSync(fd);
+  }
+}
+
+/**
+ * Resolve symlink chain to final target path.
+ * Returns the original path on any filesystem error.
+ */
+function safeRealpath(filePath: string): string {
+  try {
+    return realpathSync(filePath);
+  } catch {
+    return filePath;
+  }
+}
+
 /**
- * Env inherited by the Copilot CLI subprocess the SDK spawns.
+ * Return `true` when `candidate` is a Node.js / npm-loader JavaScript shim
+ * that should not be passed to the Copilot SDK as the CLI executable.
  *
- * `NODE_NO_WARNINGS=1` silences the
- * `ExperimentalWarning: SQLite is an experimental feature` banner that
- * Node prints via the CLI's bundled `require("node:sqlite")`. The SDK
- * pipes the subprocess's stderr through `process.stderr` with a
- * `[CLI subprocess]` prefix, so without this override the warning
- * leaks into every `atomic chat -a copilot` and `atomic workflow -a
- * copilot` invocation.
+ * Filesystem errors for a given candidate are treated as "not a shim" so
+ * that the SDK can surface the real error (e.g. permission denied, ENOENT).
+ */
+export function isCopilotShim(candidate: string): boolean {
+  if (JS_EXT_RE.test(candidate)) return true;
+
+  if (candidate.includes(`node_modules${sep}.bin`) || candidate.includes("node_modules/.bin")) {
+    const real = safeRealpath(candidate);
+    if (JS_EXT_RE.test(real)) return true;
+  }
+
+  const header = readCandidateHeader(candidate);
+  if (header === null) return false;
+
+  return NODE_SHEBANG_RE.test(header) || header.includes(NPM_LOADER_MARKER);
+}
+
+/**
+ * Build the subprocess environment for the Copilot CLI process.
+ * Normalises locale to UTF-8 and suppresses Node.js deprecation warnings.
+ */
+export function copilotSubprocessEnv(
+  baseEnv: NodeJS.ProcessEnv = process.env,
+): Record<string, string | undefined> {
+  return { ...normalizedTerminalEnv(baseEnv), NODE_NO_WARNINGS: "1" };
+}
+
+/**
+ * Enumerate every existing `cmd` candidate across PATH order.
+ */
+export function enumeratePathCandidates(cmd: string, pathEnv: string): string[] {
+  const dirs = pathEnv.split(delimiter).filter(Boolean);
+  const results: string[] = [];
+  for (const dir of dirs) {
+    const full = join(dir, cmd);
+    if (existsSync(full)) results.push(full);
+  }
+  return results;
+}
+
+export type CommandPathResolver = (cmd: string) => string | null;
+
+export function resolveCopilotCliPath(
+  resolveCommandPath: CommandPathResolver = getCommandPath,
+): string | undefined {
+  const envPath = process.env["COPILOT_CLI_PATH"];
+  if (envPath) return envPath;
+
+  const primary = resolveCommandPath("copilot");
+  if (primary === null) return undefined;
+  if (!isCopilotShim(primary)) return primary;
+
+  const pathEnv = process.env["PATH"] ?? "";
+  const candidates = enumeratePathCandidates("copilot", pathEnv);
+  for (const candidate of candidates) {
+    if (!isCopilotShim(candidate)) return candidate;
+  }
+
+  return undefined;
+}
+
+/**
+ * Build options suitable for `new CopilotClient(...)`.
  *
- * The SDK uses `options.env ?? process.env` as-is (no merge) when
- * spawning, so we must fold the existing env in ourselves. Returns a
- * fresh object per call so callers can layer additional env without
- * mutating shared state.
+ * Includes:
+ * - `env` from {@link copilotSubprocessEnv} (UTF-8 locale + `NODE_NO_WARNINGS=1`).
+ * - `cliPath` from {@link resolveCopilotCliPath} when resolvable; omitted
+ *   otherwise so the SDK falls back to its bundled CLI.
  */
-export function copilotSubprocessEnv(): Record<string, string | undefined> {
-  return { ...process.env, NODE_NO_WARNINGS: "1" };
+export function copilotSdkLaunchOptions(
+  resolveCommandPath: CommandPathResolver = getCommandPath,
+): CopilotClientOptions {
+  const options: CopilotClientOptions = {
+    env: copilotSubprocessEnv(),
+  };
+  const cliPath = resolveCopilotCliPath(resolveCommandPath);
+  if (cliPath !== undefined) {
+    options.cliPath = cliPath;
+  }
+  return options;
 }
 
 /**

package/src/sdk/runtime/cc-debounce.ts

@@ -18,9 +18,9 @@
  * confirmation.
  */
 
-import { tmpdir } from "node:os";
 import { join } from "node:path";
 import { readFileSync, writeFileSync } from "node:fs";
+import { ensureAtomicTempDir } from "../../lib/atomic-temp.ts";
 
 /** Quiet period (ms) the user must leave between presses for the next
  *  one to be forwarded. Must exceed every integrated agent's exit-confirm
@@ -44,7 +44,7 @@ export function shouldForward(
  *  something with shell metacharacters. */
 function stateFileFor(paneId: string): string {
   const safe = paneId.replace(/[^a-zA-Z0-9_%-]/g, "_");
-  return join(tmpdir(), `atomic-cc-${safe}`);
+  return join(ensureAtomicTempDir(), `atomic-cc-${safe}`);
 }
 
 function readLastPress(stateFile: string): number {

package/src/sdk/runtime/executor.test.ts

@@ -1046,6 +1046,22 @@ describe("buildPaneCommand", () => {
     expect(command).not.toContain("--port");
   });
 
+  test("claude: scopes temp files to the user's Atomic temp directory", () => {
+    const { envVars } = buildPaneCommand("claude");
+    expect(envVars.TMPDIR).toMatch(/\/\.atomic\/tmp$/);
+    expect(envVars.TMP).toBe(envVars.TMPDIR);
+    expect(envVars.TEMP).toBe(envVars.TMPDIR);
+  });
+
+  test("claude: explicit temp env overrides the Atomic default", () => {
+    const { envVars } = buildPaneCommand("claude", {
+      envVars: { TMPDIR: "/custom/tmp", TMP: "/custom/tmp", TEMP: "/custom/tmp" },
+    });
+    expect(envVars.TMPDIR).toBe("/custom/tmp");
+    expect(envVars.TMP).toBe("/custom/tmp");
+    expect(envVars.TEMP).toBe("/custom/tmp");
+  });
+
   test("overrides.envVars merges with defaults for copilot", () => {
     const { envVars } = buildPaneCommand("copilot", {
       envVars: { MY_VAR: "hello" },
@@ -1074,6 +1090,19 @@ describe("buildPaneCommand", () => {
     const { command } = buildPaneCommand("opencode", {}, ["--extra-flag"]);
     expect(command).not.toContain("--extra-flag");
   });
+
+  test("copilot: respects COPILOT_CLI_PATH env var for binary resolution", () => {
+    const origCliPath = process.env["COPILOT_CLI_PATH"];
+    process.env["COPILOT_CLI_PATH"] = "/custom/path/copilot";
+    try {
+      const { command } = buildPaneCommand("copilot");
+      // The command should start with the COPILOT_CLI_PATH binary.
+      expect(command.startsWith("/custom/path/copilot ")).toBe(true);
+    } finally {
+      if (origCliPath === undefined) delete process.env["COPILOT_CLI_PATH"];
+      else process.env["COPILOT_CLI_PATH"] = origCliPath;
+    }
+  });
 });
 
 // ---------------------------------------------------------------------------
@@ -1250,4 +1279,43 @@ describe("waitForServer", () => {
     const result = await waitForServer("copilot", "%0");
     expect(result).toBe("localhost:50001");
   });
+
+  test("copilot: probe does not pass useLoggedInUser to CopilotClient (external server owns auth)", async () => {
+    mock.module("./tmux.ts", () => ({
+      capturePane: () => PANE_CONTENT_READY,
+      getPanePid: () => 12345,
+      spawnMuxAttach: () => {},
+    }));
+
+    mock.module("./port-discovery.ts", () => ({
+      getListeningPortForPid: async () => 50002,
+      PORT_DISCOVERY_TIMEOUT_MS: 100,
+    }));
+
+    let capturedOptions: unknown;
+    mock.module("@github/copilot-sdk", () => ({
+      CopilotClient: class {
+        constructor(opts: unknown) {
+          capturedOptions = opts;
+        }
+        start() {
+          return Promise.resolve();
+        }
+        listSessions() {
+          return Promise.resolve([]);
+        }
+        stop() {
+          return Promise.resolve();
+        }
+      },
+    }));
+
+    await waitForServer("copilot", "%0");
+    const opts = capturedOptions as Record<string, unknown>;
+    expect(opts).toBeDefined();
+    // cliUrl must be set — connecting to an existing server
+    expect(opts["cliUrl"]).toBe("localhost:50002");
+    // useLoggedInUser must NOT be set — external server owns auth
+    expect(Object.prototype.hasOwnProperty.call(opts, "useLoggedInUser")).toBe(false);
+  });
 });