@zgeoff/atc 3.4.0 → 3.4.2

package/src/test-utils/start-stub-unanswering-unix-listener.ts

@@ -0,0 +1,38 @@
+import { registerTestCleanup } from './register-test-cleanup';
+
+interface StubUnansweringUnixListener {
+  // What each read took from any connection, decoded, in arrival order.
+  readonly received: readonly string[];
+
+  readonly [Symbol.dispose]: () => void;
+}
+
+/**
+ * A stand-in for a daemon socket that takes a connection and never answers
+ * it: it listens on the unix socket path, records what each read takes from
+ * a connection, sends nothing back, and keeps the connection open. It
+ * stops, dropping every connection it holds, once the current test
+ * finishes, so it must run inside a test; disposal stops it sooner, and a
+ * second stop does nothing.
+ */
+export function startStubUnansweringUnixListener(path: string): StubUnansweringUnixListener {
+  const received: string[] = [];
+
+  const server = Bun.listen({
+    unix: path,
+    socket: {
+      data(_socket, data) {
+        received.push(data.toString());
+      },
+    },
+  });
+
+  const stop = registerTestCleanup(() => {
+    server.stop(true);
+  });
+
+  return {
+    received,
+    [Symbol.dispose]: stop,
+  };
+}

package/src/test-utils/start-test-daemon.ts

@@ -4,6 +4,7 @@ import { DaemonClient } from '../client/daemon-client';
 import { startDaemon } from '../daemon/daemon';
 import type { DaemonHandle, DaemonOptions } from '../daemon/daemon';
 import type { EventMsg } from '../protocol/protocol';
+import { registerTestCleanup } from './register-test-cleanup';
 import { setupTempDir } from './setup-temp-dir';
 
 /**
@@ -60,12 +61,21 @@ const BUILD = 'atc/test-build';
  * connection. `stop` closes every client and stops the daemon; `restart`
  * does the same, then boots on the same paths and state with the options
  * given or the last ones, and opens a new main client. Disposal stops what
- * is running and removes the directory; hold the result with `await using`.
+ * is running and removes the directory. That disposal runs once the current
+ * test finishes, so it must run inside a test; disposing sooner runs it
+ * then, and a second disposal does nothing. A first boot that fails runs it
+ * before the start rejects.
  */
 export async function startTestDaemon(config: TestDaemonConfig = {}) {
-  await using stack = new AsyncDisposableStack();
+  const tmp = setupTempDir(config.prefix ?? 'atc-test-daemon-');
 
-  const tmp = stack.use(setupTempDir(config.prefix ?? 'atc-test-daemon-'));
+  // Registered after the directory, so it releases first: the daemon stops
+  // before its directory is removed.
+  const stack = new AsyncDisposableStack();
+
+  const dispose = registerTestCleanup(() => stack.disposeAsync());
+
+  stack.use(tmp);
 
   const paths: TestDaemonPaths = {
     dir: tmp.dir,
@@ -141,9 +151,13 @@ export async function startTestDaemon(config: TestDaemonConfig = {}) {
     return { daemon, client };
   };
 
-  let current = await boot();
+  // A boot that fails stops what it started and removes the directory
+  // before the start rejects.
+  let current = await boot().catch(async (error: unknown) => {
+    await dispose();
 
-  const owned = stack.move();
+    throw error;
+  });
 
   return {
     ...paths,
@@ -210,6 +224,6 @@ export async function startTestDaemon(config: TestDaemonConfig = {}) {
 
       current = await boot();
     },
-    [Symbol.asyncDispose]: () => owned.disposeAsync(),
+    [Symbol.asyncDispose]: dispose,
   };
 }

package/src/test-utils/start-tui-harness.ts

@@ -6,6 +6,7 @@ import { buildStubTUIClaude } from './build-stub-tui-claude';
 import { buildStubTUIGrok } from './build-stub-tui-grok';
 import { createStubBin } from './create-stub-bin';
 import { mergeDeep } from './merge-deep';
+import { registerTestCleanup } from './register-test-cleanup';
 import { setupTempDir } from './setup-temp-dir';
 import { waitFor } from './wait-for';
 
@@ -37,15 +38,24 @@ interface TUIHarnessOptions {
  * transports the fixture repositories need, with the fields given laid over
  * them. `env` is the environment the client runs with, so a daemon started
  * with it serves the client. A wait made before the client draws anything
- * gets `bootMs` for that first byte. Disposal stops the client and the daemon in
- * the home and removes it; hold the result with `await using`.
+ * gets `bootMs` for that first byte. Disposal stops the client and the
+ * daemon in the home and removes it. That disposal runs once the current
+ * test finishes, so it must run inside a test; disposing sooner runs it
+ * then, and a second disposal does nothing.
  */
 export function startTUIHarness(options: TUIHarnessOptions = {}) {
-  using setup = new DisposableStack();
+  const tmp = setupTempDir('atc-tui-');
+
+  // Registered after the home, so it releases first: the client and its
+  // daemon stop before their home is removed.
+  const owned = new AsyncDisposableStack();
+
+  const dispose = registerTestCleanup(() => owned.disposeAsync());
+
+  owned.use(tmp);
 
   // The client boots with this home as its cwd and lists it first in the
   // picker, so the path is resolved the way the client reports it.
-  const tmp = setup.use(setupTempDir('atc-tui-'));
   const home = realpathSync(tmp.dir);
   const configPath = join(home, '.config', 'atc', 'config.json');
   const clientLogPath = join(home, 'client.log');
@@ -97,9 +107,6 @@ export function startTUIHarness(options: TUIHarnessOptions = {}) {
   // the interaction budget.
   let firstOutputAt: number | null = null;
 
-  const owned = new AsyncDisposableStack();
-
-  owned.use(setup.move());
   owned.defer(() => stopClientAndDaemon(home, pty, firstOutputAt === null));
 
   return {
@@ -218,7 +225,7 @@ export function startTUIHarness(options: TUIHarnessOptions = {}) {
       );
     },
 
-    [Symbol.asyncDispose]: () => owned.disposeAsync(),
+    [Symbol.asyncDispose]: dispose,
   };
 }
 

package/src/test-utils/subscribe-to-socket-lines.ts

@@ -1,4 +1,5 @@
 import { OutboundQueue } from '../protocol/outbound-queue';
+import { registerTestCleanup } from './register-test-cleanup';
 import { waitFor } from './wait-for';
 
 interface SocketLines {
@@ -16,15 +17,26 @@ interface SocketLines {
 interface SocketLinesOptions {
   // How many unsent bytes the connection holds before it refuses a write.
   readonly queueBytes?: number;
+
+  // The clock a line wait reads its deadline from; the wall clock when absent.
+  readonly now?: () => number;
+
+  // Waits out the interval between a line wait's polls; a real sleep when
+  // absent.
+  readonly wait?: (ms: number) => Promise<void>;
 }
 
 /**
  * Connects to a unix socket and collects every complete newline-terminated
  * line it sends, buffering a partial line across reads. `write` sends the
  * whole of what it is given, the rest going out as the socket drains,
- * and throws instead when the unsent bytes already fill the queue. `waitForLine` polls until the collected count reaches
- * `count` and returns the lines, throwing when `timeoutMs` passes first or
- * the connection closes short of the count. Disposal ends the connection.
+ * and throws instead when the unsent bytes already fill the queue.
+ * `waitForLine` polls until the collected count reaches `count` and returns
+ * the lines, throwing when `timeoutMs` passes first or the connection
+ * closes short of the count; a stub clock passed as `now` and `wait` steps
+ * that timeout without waiting it out. The connection ends once the current
+ * test finishes, so it must run inside a test; disposal ends it sooner, and
+ * a second end does nothing.
  */
 export async function subscribeToSocketLines(
   path: string,
@@ -60,6 +72,10 @@ export async function subscribeToSocketLines(
     },
   });
 
+  const stop = registerTestCleanup(() => {
+    socket.end();
+  });
+
   // The default leaves room for the largest payload a test sends in one
   // piece.
   queue = new OutboundQueue(socket, options.queueBytes ?? 8 * 1024 * 1024);
@@ -93,13 +109,17 @@ export async function subscribeToSocketLines(
             requireLines(count);
           }
         },
-        { timeoutMs },
+        {
+          timeoutMs,
+          now: options.now ?? Date.now,
+          wait: options.wait ?? Bun.sleep,
+        },
       );
 
       return requireLines(count);
     },
     [Symbol.asyncDispose]: () => {
-      socket.end();
+      stop();
 
       return Promise.resolve();
     },