@zgeoff/atc 3.4.0 → 3.4.1

package/src/sources/github/run-gh.ts

@@ -5,6 +5,12 @@ export interface GHRun {
   readonly timedOut: boolean;
 }
 
+interface GHRunOptions {
+  // Called with the pid of the started gh right after it starts; that pid
+  // is also its process group's id.
+  readonly onSpawn?: (pid: number) => void;
+}
+
 /**
  * Runs gh with arguments until it exits or the signal aborts, killing its
  * whole process group on abort, so a wrapper or extension leaves no process
@@ -15,6 +21,7 @@ export async function runGH(
   bin: string,
   signal: Readonly<AbortSignal>,
   args: readonly string[],
+  options: GHRunOptions = {},
 ): Promise<GHRun> {
   const proc = Bun.spawn([bin, ...args], {
     env: {
@@ -34,6 +41,8 @@ export async function runGH(
     detached: true,
   });
 
+  options.onSpawn?.(proc.pid);
+
   const finished = Promise.all([
     new Response(proc.stdout).text(),
     new Response(proc.stderr).text(),

package/src/test-utils/build-mock-execution-target.ts

@@ -0,0 +1,25 @@
+import { faker } from '@faker-js/faker';
+import type { ExecutionTarget } from '../daemon/build-execution-targets';
+import { mergeDeep } from './merge-deep';
+import type { MockOverrides } from './mock-overrides';
+
+/**
+ * A local-pty execution target with an arbitrary id and identity, no
+ * options, and no provider, as a target of a kind this daemon lacks has.
+ * Overrides merge into fresh defaults at every depth; a provider override
+ * replaces the default whole.
+ */
+export function buildMockExecutionTarget(
+  overrides: MockOverrides<ExecutionTarget, keyof ExecutionTarget> = {},
+): ExecutionTarget {
+  return mergeDeep<ExecutionTarget>(
+    {
+      id: faker.word.noun(),
+      kind: 'local-pty',
+      options: {},
+      identity: `local-pty:${faker.string.uuid()}`,
+      provider: null,
+    },
+    overrides,
+  );
+}

package/src/test-utils/build-mock-imp-session-request.ts

@@ -0,0 +1,53 @@
+import { faker } from '@faker-js/faker';
+import type { ImpSessionRequest } from '../daemon/imp-port';
+
+/**
+ * The request that starts a process on an imp.
+ */
+type StartRequest = Extract<ImpSessionRequest, { readonly kind: 'start' }>;
+
+/**
+ * The request that attaches to a process already running on an imp.
+ */
+type AttachRequest = Extract<ImpSessionRequest, { readonly kind: 'attach' }>;
+
+type AttachOverrides = Partial<AttachRequest> & { readonly kind: 'attach' };
+
+/**
+ * A request that starts `true` on an imp with an empty environment, or, for
+ * an override of kind `attach`, one that attaches without waking the imp.
+ * Either carries no resume point and no requirements, and an arbitrary imp
+ * name, session name, and terminal size; a start's directory is arbitrary
+ * too. Each override replaces the default of its field.
+ */
+export function buildMockImpSessionRequest(overrides?: Partial<StartRequest>): StartRequest;
+export function buildMockImpSessionRequest(overrides: AttachOverrides): AttachRequest;
+
+export function buildMockImpSessionRequest(
+  overrides: Partial<StartRequest> | AttachOverrides = {},
+): ImpSessionRequest {
+  const name = `imp-${faker.string.alpha({ length: 6, casing: 'lower' })}`;
+  const session = faker.string.uuid();
+  const cols = faker.number.int({ min: 20, max: 300 });
+  const rows = faker.number.int({ min: 5, max: 100 });
+
+  return isAttachOverrides(overrides)
+    ? { name, session, cols, rows, wake: false, ...overrides }
+    : {
+        kind: 'start',
+        name,
+        session,
+        argv: ['true'],
+        env: {},
+        cwd: faker.system.directoryPath(),
+        cols,
+        rows,
+        ...overrides,
+      };
+}
+
+function isAttachOverrides(
+  overrides: Partial<StartRequest> | AttachOverrides,
+): overrides is AttachOverrides {
+  return overrides.kind === 'attach';
+}

package/src/test-utils/build-mock-message-record.ts

@@ -3,13 +3,17 @@ import { toMessageID } from '../shared/to-message-id';
 import { toSessionID } from '../shared/to-session-id';
 import type { MessageRecord } from '../store/message-record';
 
+type MessageRecordOverrides = {
+  readonly [K in keyof MessageRecord]?: MessageRecord[K] | undefined;
+};
+
 /**
  * A message accepted for a session and not yet delivered: a fresh message
  * id and a fresh atc id, an arbitrary sender, text, and send time, and no
  * agent session id, delivery, answer, or turn. An override replaces the
- * field it names.
+ * field it names, and an override of undefined leaves that field out.
  */
-export function buildMockMessageRecord(overrides: Partial<MessageRecord> = {}): MessageRecord {
+export function buildMockMessageRecord(overrides: MessageRecordOverrides = {}): MessageRecord {
   return {
     id: toMessageID(faker.string.uuid()),
     atcID: toSessionID(faker.string.uuid()),
@@ -17,6 +21,6 @@ export function buildMockMessageRecord(overrides: Partial<MessageRecord> = {}):
     text: faker.lorem.sentence(),
     status: 'accepted',
     sentAt: faker.date.past().getTime(),
-    ...overrides,
+    ...Object.fromEntries(Object.entries(overrides).filter(([, value]) => value !== undefined)),
   };
 }

package/src/test-utils/build-mock-stored-event.ts

@@ -0,0 +1,20 @@
+import { faker } from '@faker-js/faker';
+import { toSessionID } from '../shared/to-session-id';
+import type { StoredEvent } from '../store/state-store';
+
+/**
+ * A row of the event trail as the store reads it back: a `turn-done` event
+ * with an arbitrary row id, time, and fresh atc id, and no agent session
+ * id, detail, message, or label. Each override replaces the default of its field.
+ */
+export function buildMockStoredEvent(overrides: Partial<StoredEvent> = {}): StoredEvent {
+  return {
+    id: faker.number.int({ min: 1, max: 1_000_000 }),
+    at: faker.date.past().getTime(),
+    atcID: toSessionID(faker.string.uuid()),
+    agentSessionID: null,
+    kind: 'turn-done',
+    detail: null,
+    ...overrides,
+  };
+}

package/src/test-utils/build-mock-stored-row.ts

@@ -0,0 +1,23 @@
+import { faker } from '@faker-js/faker';
+import type { StoredRow } from '../read-stored-rows';
+import { mergeDeep } from './merge-deep';
+import type { MockOverrides } from './mock-overrides';
+
+/**
+ * A fleet row a daemon has stored, for a live session with a fresh id, an
+ * arbitrary name, and no known agent session id. Overrides replace the
+ * defaults field by field.
+ */
+export function buildMockStoredRow(
+  overrides: MockOverrides<StoredRow, keyof StoredRow> = {},
+): StoredRow {
+  return mergeDeep<StoredRow>(
+    {
+      id: faker.string.uuid(),
+      name: faker.word.noun(),
+      exited: false,
+      agentSessionID: null,
+    },
+    overrides,
+  );
+}

package/src/test-utils/build-stub-brokered-gateway-adapter.ts

@@ -0,0 +1,50 @@
+import type { AgentAdapter } from '../agents/agent-adapter';
+import { buildMockAgentAdapter } from './build-mock-agent-adapter';
+
+/**
+ * An agent adapter `glm` for daemon tests that only starts behind impd's
+ * broker and takes the credential of a GLM gateway from it: the auth
+ * profile `glm`, a custom bearer secret `glm` for api.z.ai, behind the
+ * gateway at https://api.z.ai/api/anthropic with the placeholder
+ * `ANTHROPIC_AUTH_TOKEN`. Every guest spawn sleeps, with the binding's
+ * variables, when it has one, and `CLAUDE_CONFIG_DIR` set to
+ * `claude-config` in the guest folder. Every other member is the plain
+ * agent adapter's.
+ */
+export function buildStubBrokeredGatewayAdapter(): AgentAdapter {
+  return buildMockAgentAdapter({
+    id: 'glm',
+    planGuestSpawn: (_opts, guest) => ({
+      bin: 'sleep',
+      args: ['30'],
+      files: {},
+      env: { ...guest.auth?.env, CLAUDE_CONFIG_DIR: `${guest.dir}/claude-config` },
+    }),
+    findAuthSelection: () => ({
+      brokerRequired: true,
+      gateway: {
+        id: 'glm',
+        baseURL: 'https://api.z.ai/api/anthropic',
+        auth: {
+          profiles: ['glm'],
+          placeholderEnv: { ANTHROPIC_AUTH_TOKEN: 'imp-broker-placeholder' },
+        },
+      },
+      profiles: new Map([
+        [
+          'glm',
+          {
+            name: 'glm',
+            secret: 'glm',
+            kind: 'custom',
+            host: 'api.z.ai',
+            header: 'authorization',
+            scheme: 'bearer',
+            env: {},
+            dependencies: [],
+          },
+        ],
+      ]),
+    }),
+  });
+}

package/src/test-utils/build-stub-mcp-stdio-server.ts

@@ -0,0 +1,20 @@
+/**
+ * The script of a stand-in `atc mcp` server on stdio that answers each line
+ * it reads with the next of `replies`, printed as given, whether JSON or
+ * not, and reads stdin without answering once the replies run out. It
+ * exits without a reply when stdin ends before a line arrives. Before
+ * it reads anything, it records its pid in the file at its own path with
+ * `.pid` appended, moving the file into place so it appears whole.
+ */
+export function buildStubMCPStdioServer(replies: readonly string[]): string {
+  const answers = replies
+    .map((reply) => `read -r _ || exit 0\nprintf '%s\\n' ${toShellLiteral(reply)}\n`)
+    .join('');
+
+  return `#!/usr/bin/env bash\necho $$ > "$0.pid.tmp"\nmv "$0.pid.tmp" "$0.pid"\n${answers}exec cat > /dev/null\n`;
+}
+
+// Quotes a value for the shell as one word, whatever it holds.
+function toShellLiteral(value: string): string {
+  return `'${value.replaceAll("'", String.raw`'\''`)}'`;
+}

package/src/test-utils/build-stub-recording-filter.ts

@@ -0,0 +1,9 @@
+/**
+ * The script of a stand-in git filter driver that records each run by
+ * appending the line `ran` to the record file and passes its input through
+ * unchanged, as a smudge filter that changes nothing does, so a test can
+ * tell whether git ran a filter the host configured.
+ */
+export function buildStubRecordingFilter(record: string): string {
+  return `#!/bin/sh\necho ran >> '${record}'\ncat\n`;
+}

package/src/test-utils/build-stub-recording-git.ts

@@ -0,0 +1,8 @@
+/**
+ * The script of a stand-in `git` that records each run by appending the
+ * line `ran` to the record file, then exits 0 without doing anything else,
+ * so a test can tell whether the code under test ran git at all.
+ */
+export function buildStubRecordingGit(record: string): string {
+  return `#!/bin/sh\necho ran >> '${record}'\n`;
+}

package/src/test-utils/create-git-fixture.ts

@@ -22,17 +22,16 @@ interface GitFixtureConfig {
  *
  * The first call in a process builds a template pair under the test home,
  * and each call copies it, so a fixture costs a copy instead of a run of
- * git commands. Disposal removes the directory; hold the result with
- * `await using`.
+ * git commands. The directory is removed once the current test finishes,
+ * so it must run inside a test; disposal removes it sooner, and a second
+ * removal does nothing.
  */
 export async function createGitFixture(config: GitFixtureConfig = {}) {
   const env = buildGitEnv(process.env);
 
   const template = await resolveTemplate();
 
-  await using stack = new AsyncDisposableStack();
-
-  const tmp = stack.use(setupTempDir(config.prefix ?? 'atc-git-fixture-'));
+  const tmp = setupTempDir(config.prefix ?? 'atc-git-fixture-');
   const upstream = join(tmp.dir, 'upstream.git');
   const work = join(tmp.dir, 'work');
 
@@ -51,15 +50,13 @@ export async function createGitFixture(config: GitFixtureConfig = {}) {
     ),
   );
 
-  const owned = stack.move();
-
   return {
     dir: tmp.dir,
     env,
     upstream,
     work,
     sha: template.sha,
-    [Symbol.asyncDispose]: () => owned.disposeAsync(),
+    [Symbol.asyncDispose]: tmp[Symbol.asyncDispose],
   };
 }
 

package/src/test-utils/create-stub-echo-claude.ts

@@ -0,0 +1,21 @@
+import { createStubBin } from './create-stub-bin';
+
+/**
+ * Creates a stand-in for the Claude CLI as `fake-claude` under the directory
+ * and returns its path. It prints `UP:<pid>`, then reads one line at a time
+ * and prints `GOT:<line>:<pid>` after each, so a test sees which process
+ * took its input. A `quit` line ends it with exit code 3.
+ */
+export function createStubEchoClaude(dir: string): string {
+  return createStubBin(
+    dir,
+    'fake-claude',
+    `#!/usr/bin/env bash
+echo "UP:$$"
+while read -r line; do
+  if [ "$line" = "quit" ]; then exit 3; fi
+  echo "GOT:$line:$$"
+done
+`,
+  );
+}

package/src/test-utils/{build-stub-imp-port.ts → create-stub-imp-port.ts}

@@ -29,6 +29,7 @@ import type {
 import { ImpPortError } from '../daemon/imp-port-error';
 import { isImpNameAllowed } from '../daemon/is-imp-name-allowed';
 import { isBrokerVariable } from '../shared/is-broker-variable';
+import { registerTestCleanup } from './register-test-cleanup';
 
 // impd keeps exactly this many bytes of each generation's output.
 const RING_BYTES = 262_144;
@@ -51,7 +52,7 @@ interface StubCommandHold {
 }
 
 /**
- * The impd stand-in the factory below builds, one per call.
+ * The impd stand-in the factory below creates, one per call.
  */
 class StubImpPort implements ImpPort {
   // Every port call, in order, as `<call> <imp> [<detail>]`.
@@ -60,6 +61,9 @@ class StubImpPort implements ImpPort {
   // Every session request the port received, in order.
   readonly sessionRequests: ImpSessionRequest[] = [];
 
+  // The spec of every imp create the port received, in order.
+  readonly createSpecs: ImpCreateSpec[] = [];
+
   features: ImpFeatures = {
     sessionOffsets: true,
     leases: true,
@@ -153,6 +157,9 @@ class StubImpPort implements ImpPort {
     readonly done: PromiseWithResolvers<void>;
   } | null = null;
 
+  // How many commands wait on a command hold.
+  private heldCommands = 0;
+
   // Commands whose argv holds this text exit 1 without running, or null.
   private commandFailure: string | null = null;
 
@@ -294,6 +301,7 @@ class StubImpPort implements ImpPort {
 
   createImp(spec: ImpCreateSpec): Promise<ImpView> {
     this.calls.push(`imps.create ${spec.name}`);
+    this.createSpecs.push(spec);
 
     if (this.imps.has(spec.name)) {
       return Promise.reject(
@@ -591,7 +599,11 @@ class StubImpPort implements ImpPort {
     if (hold !== null && line.includes(hold.match)) {
       hold.entered.resolve(line);
 
+      this.heldCommands += 1;
+
       await hold.done.promise;
+
+      this.heldCommands -= 1;
     }
 
     if (this.commandFailure !== null && line.includes(this.commandFailure)) {
@@ -1054,6 +1066,11 @@ class StubImpPort implements ImpPort {
     return { entered: hold.entered.promise, stop, [Symbol.dispose]: stop };
   }
 
+  // How many commands wait for their command hold to stop.
+  countHeldCommands(): number {
+    return this.heldCommands;
+  }
+
   // Lets every command the active hold holds run, and the next at once.
   stopCommandHold(): void {
     const hold = this.commandHold;
@@ -1604,7 +1621,7 @@ class StubImpPort implements ImpPort {
 }
 
 /**
- * Builds an in-process stand-in for impd behind the imp port, calling impd
+ * Creates an in-process stand-in for impd behind the imp port, calling impd
  * as the principal, `token:atc` when absent. Each imp is a set of
  * real `bun-pty` processes on this machine; a sleeping imp stops them with
  * SIGSTOP and a wake continues them, so a memory wake keeps each process
@@ -1622,10 +1639,18 @@ class StubImpPort implements ImpPort {
  * `PRECONDITION_FAILED` and reason `broker_not_ready`, and runs nothing,
  * while the broker fails or the imp holds no grant, when the start sets a
  * broker variable, and when it would join a process that started without
- * the broker required.
+ * the broker required. Once the current test finishes, the stand-in kills
+ * every process and stops every forward it holds, so it must be created inside
+ * a test; disposal does so sooner, and a second disposal does nothing.
  */
-export function buildStubImpPort(principal = 'token:atc'): StubImpPort {
-  return new StubImpPort(principal);
+export function createStubImpPort(principal = 'token:atc'): StubImpPort {
+  const port = new StubImpPort(principal);
+
+  registerTestCleanup(() => {
+    port[Symbol.dispose]();
+  });
+
+  return port;
 }
 
 interface StubLease {

package/src/test-utils/create-stub-recording-codex.ts

@@ -0,0 +1,20 @@
+import { join } from 'node:path';
+import { createStubBin } from './create-stub-bin';
+
+/**
+ * Creates a stand-in for the Codex CLI as `fake-codex` under the directory
+ * and returns its path. Each start appends one line to `codex-starts.log`
+ * under the same directory: the `CODEX_HOME` it started with, then its
+ * arguments, separated by spaces. It then stays up without reporting
+ * anything. The log exists only once a start has run, so a test proves that
+ * no harness started by its absence.
+ */
+export function createStubRecordingCodex(dir: string): string {
+  const log = join(dir, 'codex-starts.log');
+
+  return createStubBin(
+    dir,
+    'fake-codex',
+    `#!/bin/sh\necho "$CODEX_HOME $*" >> '${log}'\nexec sleep 30\n`,
+  );
+}

package/src/test-utils/create-stub-shared-server-codex.ts

@@ -0,0 +1,56 @@
+import { join } from 'node:path';
+import { createStubBin } from './create-stub-bin';
+
+interface StubSharedServerCodexConfig {
+  // The command atc runs as; the stub reports each hook through its
+  // `hook-report --agent codex`, as the hook entries atc prints for Codex do.
+  readonly atc: readonly string[];
+
+  // The composer script the stub finishes in.
+  readonly composer: string;
+}
+
+/**
+ * Creates a stand-in for a Codex CLI that shares one background server
+ * between its terminals, as `fake-codex` under the directory, and returns
+ * its path. Without `--no-daemon`, the first start records its own
+ * `ATC_SESSION_ID` and `ATC_SOCKET` in `codex-shared-server.env` under the
+ * directory, as the server it starts keeps its environment, and every start
+ * runs its hooks with the recorded pair, as Codex runs hooks inside that
+ * server. With `--no-daemon`, a start runs its hooks with its own pair. The
+ * stub prints its arguments, reports a `SessionStart` for its thread, which
+ * is `fake-thread-<its own ATC_SESSION_ID>` or the id after `resume`, then
+ * a `Stop` whose last message is `done <thread>`, then runs the composer.
+ */
+export function createStubSharedServerCodex(
+  dir: string,
+  config: StubSharedServerCodexConfig,
+): string {
+  const report = `${config.atc.map((part) => `"${part}"`).join(' ')} hook-report --agent codex`;
+  const server = join(dir, 'codex-shared-server.env');
+
+  return createStubBin(
+    dir,
+    'fake-codex',
+    `#!/usr/bin/env bash
+echo "FAKE_CODEX_UP args: $*"
+thread="fake-thread-$ATC_SESSION_ID"
+source=startup
+prev=''
+for arg in "$@"; do
+  if [ "$prev" = resume ]; then thread="$arg"; source=resume; fi
+  prev="$arg"
+done
+case " $* " in
+  *' --no-daemon '*) ;;
+  *)
+    (set -o noclobber; printf 'ATC_SESSION_ID=%q\\nATC_SOCKET=%q\\n' "$ATC_SESSION_ID" "$ATC_SOCKET" > '${server}') 2>/dev/null
+    . '${server}'
+    ;;
+esac
+printf '{"hook_event_name":"SessionStart","session_id":"%s","source":"%s"}' "$thread" "$source" | ${report}
+printf '{"hook_event_name":"Stop","session_id":"%s","last_assistant_message":"done %s"}' "$thread" "$thread" | ${report}
+exec "${process.execPath}" "${config.composer}"
+`,
+  );
+}

package/src/test-utils/create-stub-systemd.ts

@@ -1,6 +1,7 @@
 import { chmodSync, mkdirSync, mkdtempSync, readFileSync, rmSync, writeFileSync } from 'node:fs';
 import { tmpdir } from 'node:os';
 import { join } from 'node:path';
+import { registerTestCleanup } from './register-test-cleanup';
 
 interface StubSystemd {
   // The directory that holds the stand-in `systemctl` and `systemd-run`, to put
@@ -34,10 +35,17 @@ interface StubSystemd {
  * `atcCommand daemon` in the background. `systemd-run` runs the command after
  * `--` in the background with only the `--setenv` variables, as a transient
  * unit sees them, and appends its output to the `StandardOutput=append:`
- * file. Every call is logged.
+ * file. Every call is logged. The stand-ins' directory is removed once the
+ * current test finishes, so it must run inside a test; disposal removes it
+ * sooner, and a second removal does nothing.
  */
 export function createStubSystemd(atcCommand: readonly string[]): StubSystemd {
   const root = mkdtempSync(join(tmpdir(), 'atc-stub-systemd-'));
+
+  const remove = registerTestCleanup(() => {
+    rmSync(root, { recursive: true, force: true });
+  });
+
   const binDir = join(root, 'bin');
   const procRoot = join(root, 'proc');
   const atcLine = atcCommand.map((part) => `"${part}"`).join(' ');
@@ -118,8 +126,6 @@ exit 0
         `0::/user.slice/user-${process.getuid?.() ?? 0}.slice/user@${process.getuid?.() ?? 0}.service/app.slice/${unit}\n`,
       );
     },
-    [Symbol.dispose]: () => {
-      rmSync(root, { recursive: true, force: true });
-    },
+    [Symbol.dispose]: remove,
   };
 }

package/src/test-utils/get-only-imp-name.ts

@@ -1,4 +1,4 @@
-import type { buildStubImpPort } from './build-stub-imp-port';
+import type { createStubImpPort } from './create-stub-imp-port';
 
 /**
  * Returns the name of the one imp a stub imp port holds, and throws when
@@ -6,7 +6,7 @@ import type { buildStubImpPort } from './build-stub-imp-port';
  * reads another's.
  */
 export function getOnlyImpName(
-  port: Readonly<Pick<ReturnType<typeof buildStubImpPort>, 'collectImpNames'>>,
+  port: Readonly<Pick<ReturnType<typeof createStubImpPort>, 'collectImpNames'>>,
 ): string {
   const names = port.collectImpNames();
   const [name] = names;

package/src/test-utils/register-test-cleanup.ts

@@ -0,0 +1,63 @@
+import { onTestFinished } from 'bun:test';
+
+// The releases the current test registered, in registration order; null
+// before its first registration and once its hook has started.
+let pending: (() => unknown)[] | null = null;
+
+/**
+ * Registers the release of a resource a test just acquired, to run once the
+ * current test finishes, and returns that release for the resource's own
+ * stop and dispose members. Every release a test registers runs from one
+ * hook, last registered first, as `using` declarations release, so a
+ * directory made before a process that lives in it is removed only after
+ * that process stops. A release that throws stops none of the others: the
+ * hook rethrows once every release has run, as an `AggregateError` when
+ * more than one threw. The returned release runs its callback once: every
+ * later call, from the hook or from the test, returns what the first call
+ * returned. Bun runs the hook after every `afterEach`, so a release works
+ * from the paths and handles it captured. Throws outside a test, where
+ * nothing would run the hook.
+ */
+export function registerTestCleanup<T>(release: () => T): () => T {
+  let released: { readonly value: T } | null = null;
+
+  const releaseOnce = (): T => {
+    released ??= { value: release() };
+
+    return released.value;
+  };
+
+  if (pending === null) {
+    onTestFinished(releasePending);
+
+    pending = [];
+  }
+
+  pending.push(releaseOnce);
+
+  return releaseOnce;
+}
+
+async function releasePending(): Promise<void> {
+  const releases = pending ?? [];
+
+  pending = null;
+
+  const errors: unknown[] = [];
+
+  for (const release of releases.toReversed()) {
+    try {
+      await release();
+    } catch (error) {
+      errors.push(error);
+    }
+  }
+
+  if (errors.length === 1) {
+    throw errors[0];
+  }
+
+  if (errors.length > 1) {
+    throw new AggregateError(errors, 'more than one test cleanup failed');
+  }
+}

package/src/test-utils/run-legacy-daemon.ts

@@ -23,7 +23,7 @@ function main() {
     throw new Error('usage: run-legacy-daemon.ts <socket path> <state dir>');
   }
 
-  startStubLegacyDaemon(socketPath, { protocol: PROTOCOL_V + 1 });
+  startStubLegacyDaemon(socketPath, { protocol: PROTOCOL_V + 1, owner: 'caller' });
 
   const session = Bun.spawn(['sleep', '60']);
 

package/src/test-utils/run-mcp-authorization.ts

@@ -18,6 +18,9 @@ interface MCPAuthorizationRequest {
 }
 
 interface MCPAuthorization {
+  // The consent page the approval code sent the browser to.
+  readonly consent: URL;
+
   // Where the consent page sent the browser back to.
   readonly callback: URL;
   readonly code: string;
@@ -29,9 +32,9 @@ interface MCPAuthorization {
  * browser and the operator do: opens the authorization request with PKCE,
  * types the approval code the server printed into the login page, and ticks
  * the given scopes on the consent page. Each request starts with no cookies,
- * as a fresh browser would. Returns where the browser landed and what a token
- * request needs, and throws when any step's response lacks the value the next
- * step depends on.
+ * as a fresh browser would. Returns the consent page it passed, where the
+ * browser landed, and what a token request needs, and throws when any step's
+ * response lacks the value the next step depends on.
  */
 export async function runMCPAuthorization(
   server: MCPAuthorizationServer,
@@ -114,5 +117,5 @@ export async function runMCPAuthorization(
     throw new Error(`the consent redirect holds no authorization code: ${location}`);
   }
 
-  return { callback, code, verifier };
+  return { consent, callback, code, verifier };
 }