@zgeoff/atc 3.3.1 → 3.4.0

package/src/client/boot-daemon.ts

@@ -11,6 +11,8 @@ import { getBuild } from '../shared/get-build';
 import { isProcessAlive } from '../shared/is-process-alive';
 import { makeSingleFlight } from '../shared/make-single-flight';
 import { spawnATCDetached } from '../shared/spawn-atc-detached';
+import { systemClock } from '../shared/system-clock';
+import type { Clock } from '../shared/system-clock';
 import { toAgentID } from '../shared/to-agent-id';
 import { DaemonClient } from './daemon-client';
 import { formatProtocolMismatch } from './format-protocol-mismatch';
@@ -42,6 +44,15 @@ export interface DaemonBootOptions {
   // manager starts beside a managed daemon sets it, so the two never race
   // for the state directory.
   readonly waitForDaemonMs?: number;
+
+  // Called once per boot, when a waiting boot first finds no daemon and
+  // starts to wait instead of starting one; a retry after a protocol
+  // mismatch that waits again does not call it a second time.
+  readonly onWaitForDaemon?: () => void;
+
+  // The time and the timers a waiting boot reads for its deadline and its
+  // polls; the wall clock when absent.
+  readonly clock?: Clock;
 }
 
 /**
@@ -59,10 +70,23 @@ export interface DaemonBootOptions {
  * its own boot would otherwise flag daemons that are already current.
  */
 export async function bootDaemonClient(options: DaemonBootOptions = {}): Promise<DaemonBoot> {
+  let waited = false;
+  const clock = options.clock ?? systemClock;
+
   const wait =
     options.waitForDaemonMs === undefined
       ? null
-      : { deadline: Date.now() + options.waitForDaemonMs, timeoutMs: options.waitForDaemonMs };
+      : {
+          deadline: clock.now() + options.waitForDaemonMs,
+          timeoutMs: options.waitForDaemonMs,
+          clock,
+          onWait: () => {
+            if (!waited) {
+              waited = true;
+              options.onWaitForDaemon?.();
+            }
+          },
+        };
 
   for (let attempt = 0; attempt < 2; attempt++) {
     const build = getBuild();
@@ -142,10 +166,15 @@ async function openOrBootDaemon(): Promise<OpenedDaemon> {
 interface DaemonWait {
   readonly deadline: number;
   readonly timeoutMs: number;
+  readonly clock: Clock;
+
+  // Called on every miss; the boot reports only the first to its caller.
+  readonly onWait: () => void;
 }
 
 /**
  * Polls the known sockets until a daemon answers, and never starts one.
+ * Each miss reports that the wait goes on.
  */
 async function waitForDaemon(wait: DaemonWait): Promise<OpenedDaemon> {
   for (;;) {
@@ -155,11 +184,17 @@ async function waitForDaemon(wait: DaemonWait): Promise<OpenedDaemon> {
       return opened;
     }
 
-    if (Date.now() >= wait.deadline) {
+    wait.onWait();
+
+    if (wait.clock.now() >= wait.deadline) {
       throw new Error(formatWaitFailure(wait.timeoutMs));
     }
 
-    await Bun.sleep(100);
+    const polled = Promise.withResolvers<void>();
+
+    wait.clock.schedule(polled.resolve, 100);
+
+    await polled.promise;
   }
 }
 
@@ -172,21 +207,19 @@ async function waitForHello(
   sendHello: () => Promise<Readonly<Record<string, unknown>>>,
   wait: DaemonWait,
 ): Promise<Readonly<Record<string, unknown>>> {
-  let timer: ReturnType<typeof setTimeout> | undefined;
-
-  const expired = new Promise<never>((_resolve, reject) => {
-    timer = setTimeout(
-      () => {
-        reject(new Error(formatWaitFailure(wait.timeoutMs)));
-      },
-      Math.max(0, wait.deadline - Date.now()),
-    );
-  });
+  const expired = Promise.withResolvers<never>();
+
+  const cancel = wait.clock.schedule(
+    () => {
+      expired.reject(new Error(formatWaitFailure(wait.timeoutMs)));
+    },
+    Math.max(0, wait.deadline - wait.clock.now()),
+  );
 
   try {
-    return await Promise.race([sendHello(), expired]);
+    return await Promise.race([sendHello(), expired.promise]);
   } finally {
-    clearTimeout(timer);
+    cancel();
   }
 }
 

package/src/client/dirs.ts

@@ -8,13 +8,15 @@ import { collectRootDirs } from '../shared/collect-root-dirs';
  * to find a directory: where the client runs, then the daemon's spawn
  * history (most recent first), then the configured roots, then zoxide's
  * frecency list. A path that no longer exists is dropped, a duplicate keeps
- * its first position, and an empty merge falls back to the home directory.
+ * its first position, and an empty merge falls back to the home directory:
+ * `home` when given, otherwise the account's.
  */
 export interface DirSources {
   readonly cwd: string;
   readonly recent: readonly string[];
   readonly roots: readonly string[];
   readonly zoxide: readonly string[];
+  readonly home?: string;
 }
 
 export function collectDirs(sources: DirSources): string[] {
@@ -35,7 +37,7 @@ export function collectDirs(sources: DirSources): string[] {
   }
 
   if (found.length === 0) {
-    found.push(homedir());
+    found.push(sources.home ?? homedir());
   }
 
   return found;

package/src/client/index.ts

@@ -7,7 +7,7 @@ import type { EventMsg } from '../protocol/protocol';
 import { sortGroupedSessionViews } from '../protocol/sort-grouped-session-views';
 import { sortSessionViews } from '../protocol/sort-session-views';
 import type { AgentID } from '../shared/agent-id';
-import { loadConfig } from '../shared/config';
+import { configFile, loadConfig } from '../shared/config';
 import { makeSingleFlight } from '../shared/make-single-flight';
 import { bootDaemonClient } from './boot-daemon';
 import { buildClientMachine } from './build-client-machine';
@@ -16,6 +16,7 @@ import { collectTargetPicks } from './collect-target-picks';
 import { findFuzzyScore, formatDir } from './dirs';
 import type { ProtocolMismatch } from './format-protocol-mismatch';
 import { KEY, isDown, isUp, planTextEdit } from './keys';
+import { logClientEvent } from './log-client-event';
 import { parseDaemonEvent } from './parse-daemon-event';
 import { pickTabTarget } from './pick-tab-target';
 import { resolveAgentMetadata } from './resolve-agent-metadata';
@@ -341,6 +342,15 @@ const picker = new SpawnPicker<MirrorSession>({
   toMirrorSession,
   upsertMirror,
   hasDaemonFeature,
+  write: (chunk) => {
+    process.stdout.write(chunk);
+  },
+  cwd: process.cwd(),
+  configPath: configFile,
+  onDropAnswer: (kind) => {
+    logClientEvent(`dropped ${kind} answer`);
+  },
+  log: logClientEvent,
 });
 
 function openPicker(resume: boolean) {
@@ -721,6 +731,12 @@ function applyOverlayKey(buf: Buffer) {
     return;
   }
 
+  if (ch === 'H') {
+    logClientEvent('ignored H on a session that cannot eject');
+
+    return;
+  }
+
   if (ch === 'P' && sel !== undefined && sel.resumable && (sel.kind === 'headless' || !sel.alive)) {
     void adoptSession(sel.id);
 

package/src/client/log-client-event.ts

@@ -0,0 +1,20 @@
+import { appendFileSync } from 'node:fs';
+
+/**
+ * Appends one line, a decision the client took without drawing anything, to
+ * the file `ATC_CLIENT_LOG` holds, and does nothing when the variable is
+ * unset or empty. A write that fails is dropped, so the log never stops the
+ * client. It writes off the screen because the client's stdout and stderr
+ * are the terminal it draws on.
+ */
+export function logClientEvent(line: string): void {
+  const path = process.env['ATC_CLIENT_LOG'];
+
+  if (path === undefined || path === '') {
+    return;
+  }
+
+  try {
+    appendFileSync(path, `${line}\n`);
+  } catch {}
+}