@zgeoff/atc 2.27.0 → 2.29.0

package/src/client/ui.ts

@@ -3,9 +3,11 @@ import type { SessionState } from '../protocol/session-state';
 import type { AgentID } from '../shared/agent-id';
 import { RESET_INPUT_MODES } from '../shared/reset-input-modes';
 import { formatDir } from './dirs';
-import { formatOverlayAgentMark } from './format-overlay-agent-mark';
+import { planOverlayColumns } from './plan-overlay-columns';
+import type { OverlayColumnPlan } from './plan-overlay-columns';
 import { planVacatedRows } from './plan-vacated-rows';
 import type { BoxExtent } from './plan-vacated-rows';
+import type { HarnessLifecycle } from './to-mirror-session';
 
 // The slice of a session the drawing layer needs; satisfied by both the
 // daemon's sessions and the wire descriptors a client mirrors.
@@ -39,13 +41,6 @@ const GLYPH: Record<SessionState, string> = {
   exited: `${ESC}[90m✗${ESC}[0m`,
 };
 
-const STATE_LABEL: Record<SessionState, string> = {
-  needs_you: 'NEEDS YOU',
-  running: 'running',
-  done: 'done',
-  exited: 'exited',
-};
-
 function out(s: string) {
   process.stdout.write(s);
 }
@@ -65,6 +60,14 @@ export function cols(): number {
   return process.stdout.columns || 80;
 }
 
+/**
+ * The width of the picker box, borders included. An item row holds 4
+ * columns fewer.
+ */
+export function getPickerWidth(): number {
+  return Math.min(cols() - 4, 90);
+}
+
 export function rows(): number {
   return process.stdout.rows || 24;
 }
@@ -186,14 +189,25 @@ export interface OverlaySessionView extends SessionView {
   readonly agent: AgentID;
   readonly pinned: boolean;
   readonly repoRoot: string;
+  readonly target: string;
+  readonly model: string | null;
+
+  // Where the session's harness stands, apart from the attention its state
+  // carries: running, suspended inside a sleeping host, or exited.
+  readonly harness: HarnessLifecycle;
 }
 
 export interface OverlayView {
   sessions: readonly OverlaySessionView[];
 
-  // The overlay column character per agent id, for the ids that do not use
-  // the built-in one.
-  agentMarks: Readonly<Record<AgentID, string>>;
+  // The readable name per agent id, and each agent's tier-alias map, from
+  // the daemon's `agents.list` answer over the config.
+  agentLabels: Readonly<Record<AgentID, string>>;
+  agentModels: Readonly<Record<AgentID, Readonly<Record<string, string>>>>;
+
+  // Whether more than one execution target is available to spawn on, which
+  // is what brings the target column in.
+  showTarget: boolean;
   selected: number;
   confirmKill: boolean;
 
@@ -205,6 +219,67 @@ export interface OverlayView {
   grouped: boolean;
 }
 
+// A daemon-supplied id or alias can name an inherited property, so map
+// reads go through an own-property check instead of indexing blindly.
+function readMapValue<V>(map: Readonly<Record<string, V>>, key: string): V | undefined {
+  return Object.hasOwn(map, key) ? map[key] : undefined;
+}
+
+// A session's model as the row draws it: the daemon answer's alias target,
+// or the raw model string when the answer maps nothing for it.
+function resolveModelAlias(
+  models: Readonly<Record<AgentID, Readonly<Record<string, string>>>>,
+  agent: AgentID,
+  model: string,
+): string {
+  const aliases = readMapValue(models, agent);
+
+  return aliases === undefined ? model : (readMapValue(aliases, model) ?? model);
+}
+
+// A session row draws status (the attention glyph plus the unread mark),
+// pin, name, the flat view's directory, then the target, harness, model,
+// harness lifecycle, and last event columns the width plan allows.
+export function buildSessionRow(
+  s: Readonly<OverlaySessionView>,
+  plan: Readonly<OverlayColumnPlan>,
+  view: Readonly<OverlayView>,
+  sel: boolean,
+): Row {
+  const sub = s.parent !== null && view.sessions.some((x) => x.id === s.parent);
+
+  const name =
+    plan.nameWidth >= 4 && sub
+      ? `↳ ${truncate(s.name, plan.nameWidth - 2)}`.padEnd(plan.nameWidth)
+      : truncate(s.name, plan.nameWidth).padEnd(plan.nameWidth);
+
+  const dir =
+    plan.dirWidth > 0 ? truncate(formatDir(s.cwd), plan.dirWidth).padEnd(plan.dirWidth) : '';
+
+  const target =
+    plan.targetWidth > 0 ? truncate(s.target, plan.targetWidth).padEnd(plan.targetWidth) : '';
+
+  const label = readMapValue(view.agentLabels, s.agent) ?? s.agent;
+  const harness = truncate(label, plan.harnessWidth).padEnd(plan.harnessWidth);
+  const resolved = s.model === null ? '' : resolveModelAlias(view.agentModels, s.agent, s.model);
+
+  const model =
+    plan.modelWidth > 0 ? truncate(resolved, plan.modelWidth).padEnd(plan.modelWidth) : '';
+
+  const lifecycle = truncate(s.harness, plan.lifecycleWidth).padEnd(plan.lifecycleWidth);
+  const event = truncate(s.lastMsg, plan.eventWidth).padEnd(plan.eventWidth);
+  const cells = [name, dir, target, harness, model, lifecycle, event].filter((cell) => cell !== '');
+  const body = cells.join(' ');
+  const styledBody = sel ? `${ESC}[7m${body}${ESC}[0m` : body;
+  const unread = s.unread ? `${ESC}[1;33m!${ESC}[0m` : ' ';
+  const pin = s.pinned ? `${ESC}[93m⋆${ESC}[0m` : ' ';
+
+  return {
+    styled: `${GLYPH[s.state]}${unread}${pin} ${styledBody}`,
+    width: 4 + body.length,
+  };
+}
+
 export function drawOverlay(view: OverlayView) {
   const width = Math.min(cols() - 4, 90);
   const rowsList: Row[] = [boxTop(width, 'sessions')];
@@ -215,6 +290,35 @@ export function drawOverlay(view: OverlayView) {
     rowsList.push(dimRow(width, empty));
   }
 
+  // The harness label and the model each row would draw, so the columns
+  // take the width of what is actually on screen.
+  const harnessMax = Math.max(
+    0,
+    ...view.sessions.map((s) => (readMapValue(view.agentLabels, s.agent) ?? s.agent).length),
+  );
+
+  const modelMax = Math.max(
+    0,
+    ...view.sessions.map((s) => {
+      if (s.model === null) {
+        return 0;
+      }
+
+      return resolveModelAlias(view.agentModels, s.agent, s.model).length;
+    }),
+  );
+
+  const targetMax = Math.max(0, ...view.sessions.map((s) => s.target.length));
+
+  const plan = planOverlayColumns({
+    innerWidth: width - 4,
+    grouped: view.grouped,
+    showTarget: view.showTarget,
+    targetMax,
+    harnessMax,
+    modelMax,
+  });
+
   // The grouped view clusters sessions under dim repository headers, with
   // pinned sessions leading in their own cluster; the flat view shows a
   // directory column instead. The rows keep the sorted order either way. A
@@ -231,22 +335,9 @@ export function drawOverlay(view: OverlayView) {
       rowsList.push(dimRow(width, `▸ ${s.pinned ? 'pinned' : formatDir(s.repoRoot)}`));
     }
 
-    const sel = i === view.selected;
-    const name = (sub ? `↳ ${truncate(s.name, 14)}` : truncate(s.name, 16)).padEnd(16);
-    const state = STATE_LABEL[s.state].padEnd(9);
-    const dir = view.grouped ? '' : ` ${truncate(formatDir(s.cwd), 18).padEnd(18)}`;
-    const msgWidth = Math.max(4, width - 4 - 4 - 17 - 10 - (view.grouped ? 0 : 19));
-    const msg = truncate(s.lastMsg, msgWidth).padEnd(msgWidth);
-    const unread = s.unread ? `${ESC}[1;33m!${ESC}[0m` : ' ';
-    const pin = s.pinned ? `${ESC}[93m⋆${ESC}[0m` : ' ';
-    const mark = formatOverlayAgentMark(s.agent, view.agentMarks);
-    const styledMark = mark === ' ' ? mark : `${ESC}[90m${mark}${ESC}[0m`;
-    const body = `${name} ${state}${dir} ${msg}`;
-    const styledBody = sel ? `${ESC}[7m${body}${ESC}[0m` : body;
+    const row = buildSessionRow(s, plan, view, i === view.selected);
 
-    rowsList.push(
-      boxRow(width, `${GLYPH[s.state]}${unread}${pin}${styledMark}${styledBody}`, 4 + body.length),
-    );
+    rowsList.push(boxRow(width, row.styled, row.width));
   }
 
   rowsList.push(boxDivider(width));
@@ -363,7 +454,6 @@ export function drawHelp() {
     'p  pin or unpin — pinned sessions stay on top',
     '    a sub-session pins with its parent',
     'g  toggle grouping by repository',
-    '    Grok rows show a dim g after the pin mark',
     'n  new session',
     'r  adopt an external session',
     '/  filter · ↑↓/jk move · q quit',
@@ -393,7 +483,7 @@ export interface PickerView {
 }
 
 export function drawPicker(view: PickerView) {
-  const width = Math.min(cols() - 4, 90);
+  const width = getPickerWidth();
   const rowsList: Row[] = [boxTop(width, view.title)];
   const shown = view.items.slice(0, 10);
 

package/src/daemon/{make-non-blocking-log.ts → create-non-blocking-log.ts}

@@ -9,7 +9,17 @@ const MAX_QUEUED_BYTES = 64 * 1024;
 const writeAsync = promisify(write);
 
 /**
- * Makes a log that writes each line to a file descriptor without ever
+ * A log that never blocks the event loop. `log` queues one line, and
+ * `drain` resolves once every queued line is written or the given number of
+ * milliseconds has passed, whichever comes first.
+ */
+export interface NonBlockingLog {
+  readonly log: (line: string) => void;
+  readonly drain: (timeoutMs: number) => Promise<void>;
+}
+
+/**
+ * Creates a log that writes each line to a file descriptor without ever
  * blocking the event loop, so a reader that stops reading stalls nothing
  * but the log. Each write goes through the asynchronous node:fs write,
  * which Bun runs on its thread pool, one write at a time. Lines that
@@ -17,13 +27,22 @@ const writeAsync = promisify(write);
  * next write after the drops starts with one `atc log dropped=N` line. A
  * failed write drops its lines and counts them the same way, and the next
  * line logged writes again.
+ *
+ * A write to a full pipe that nobody reads never returns, and it keeps the
+ * process alive until the process calls exit. A process that shuts down
+ * drains the log with a timeout and then exits: every queued line reaches a
+ * reader that keeps reading, and an unread pipe holds the exit back no
+ * longer than the timeout.
  */
-export function makeNonBlockingLog(fd: number): (line: string) => void {
+export function createNonBlockingLog(fd: number): NonBlockingLog {
   let queue: string[] = [];
   let queuedBytes = 0;
   let dropped = 0;
   let writing = false;
 
+  // The drains that wait for the log to have nothing left to write.
+  let idleWaiters: (() => void)[] = [];
+
   const recordLine = (line: string): boolean => {
     const text = `${line}\n`;
     const bytes = Buffer.byteLength(text);
@@ -43,6 +62,8 @@ export function makeNonBlockingLog(fd: number): (line: string) => void {
     if (queue.length === 0 && dropped === 0) {
       writing = false;
 
+      releaseIdleWaiters();
+
       return;
     }
 
@@ -70,22 +91,59 @@ export function makeNonBlockingLog(fd: number): (line: string) => void {
         rest = rest.subarray(result.bytesWritten);
       }
     } catch {
+      // A drain stops waiting here too: the next write would most likely
+      // fail the same way, and the lines it would carry stay counted.
       dropped += lineCount;
       writing = false;
 
+      releaseIdleWaiters();
+
       return;
     }
 
     writeNext();
   };
 
-  return (line) => {
-    if (!recordLine(line)) {
-      dropped++;
-    }
+  const releaseIdleWaiters = (): void => {
+    const waiters = idleWaiters;
+
+    idleWaiters = [];
 
-    if (!writing) {
-      writeNext();
+    for (const resolve of waiters) {
+      resolve();
     }
   };
+
+  return {
+    log: (line) => {
+      if (!recordLine(line)) {
+        dropped++;
+      }
+
+      if (!writing) {
+        writeNext();
+      }
+    },
+    drain: async (timeoutMs) => {
+      // Lines left behind by a failed write wait for the next line logged,
+      // so a drain writes them itself.
+      if (!writing) {
+        writeNext();
+      }
+
+      if (!writing) {
+        return;
+      }
+
+      const idle = Promise.withResolvers<void>();
+
+      idleWaiters.push(idle.resolve);
+
+      const timer = setTimeout(idle.resolve, timeoutMs);
+
+      await idle.promise;
+
+      clearTimeout(timer);
+    },
+  };
 }

package/src/daemon/daemon-connection.ts

@@ -7,6 +7,7 @@ import { LineDecoder } from '../protocol/line-decoder';
 import { OutboundQueue } from '../protocol/outbound-queue';
 import type { SocketWriter } from '../protocol/outbound-queue';
 import { parseRequestParams } from '../protocol/parse-request-params';
+import type { RequestMethod } from '../protocol/parse-request-params';
 import {
   MAX_CHUNK,
   MAX_LINE,
@@ -26,6 +27,7 @@ import { buildTargetForbiddenError } from './build-target-forbidden-error';
 import type { DaemonContext, SpawnParams } from './daemon-context';
 import type { TranscriptPosition } from './load-transcript-page';
 import { parseSpawnOverrides } from './parse-spawn-overrides';
+import { REQUEST_ACCESS_CLASSES } from './request-access-classes';
 import { TargetAccess } from './target-access';
 
 // The targets a request may use and the namespace of its idempotency keys.
@@ -34,15 +36,6 @@ interface RequestScope {
   readonly keyNamespace: string;
 }
 
-// The requests that act on the whole daemon, or on the credentials a
-// session's host may use, which only its owner may make.
-const OWNER_METHODS: ReadonlySet<string> = new Set([
-  'daemon.quit',
-  'fleet.restore',
-  'session.auth.revoke',
-  'session.auth.rebind',
-]);
-
 // What a limited connection is sent for one event, and the sessions that
 // event moved out of its view.
 interface ViewUpdate {
@@ -316,7 +309,7 @@ export class DaemonConnection {
 
     const scope = this.findRequestScope(req);
 
-    if (scope !== null && OWNER_METHODS.has(req.m)) {
+    if (scope !== null && isOwnerOnlyMethod(req.m)) {
       this.sendErr(req.id, 'unauthorized', `${req.m} is open to the daemon's owner only`);
 
       return true;
@@ -379,7 +372,7 @@ export class DaemonConnection {
       return;
     }
 
-    if (OWNER_METHODS.has(req.m)) {
+    if (isOwnerOnlyMethod(req.m)) {
       this.sendErr(req.id, 'unauthorized', `${req.m} is open to the daemon's owner only`);
 
       return;
@@ -548,6 +541,12 @@ export class DaemonConnection {
   private async applyRequest(req: RequestMsg, ctx: DaemonContext): Promise<void> {
     await this.helloAnswered;
 
+    if (!isRequestMethod(req.m)) {
+      this.sendErr(req.id, 'unknown_method', `unknown method '${req.m}'`);
+
+      return;
+    }
+
     switch (req.m) {
       case 'daemon.ping': {
         this.sendOk(req.id, {});
@@ -908,7 +907,10 @@ export class DaemonConnection {
 
         return;
       }
-      default: {
+
+      // The handshake is answered before a request is admitted, so it never
+      // runs as one.
+      case 'daemon.hello': {
         this.sendErr(req.id, 'unknown_method', `unknown method '${req.m}'`);
       }
     }
@@ -1779,6 +1781,17 @@ export class DaemonConnection {
   }
 }
 
+// Whether a request method is open to the daemon's owner alone. A method
+// the protocol does not define is not: it runs as no request and is
+// answered as unknown.
+function isOwnerOnlyMethod(method: string): boolean {
+  return isRequestMethod(method) && REQUEST_ACCESS_CLASSES[method] === 'owner';
+}
+
+function isRequestMethod(method: string): method is RequestMethod {
+  return Object.hasOwn(REQUEST_ACCESS_CLASSES, method);
+}
+
 // The token of a handshake's `auth: { scheme: "bearer", token }`, or null
 // when its params hold none.
 function findBearerToken(p: Readonly<Record<string, unknown>> | undefined): string | null {

package/src/daemon/daemon.ts

@@ -48,6 +48,8 @@ import { buildTargetAccess } from './build-target-access';
 import { buildTargetForbiddenError } from './build-target-forbidden-error';
 import { buildTargetList } from './build-target-list';
 import { claimDaemonLock } from './claim-daemon-lock';
+import { createNonBlockingLog } from './create-non-blocking-log';
+import type { NonBlockingLog } from './create-non-blocking-log';
 import { DaemonConnection } from './daemon-connection';
 import type {
   DaemonContext,
@@ -69,7 +71,6 @@ import { loadListenerTokens } from './load-listener-tokens';
 import { loadTranscriptPage } from './load-transcript-page';
 import { makeHookRunner } from './make-hook-runner';
 import type { HookScope } from './make-hook-runner';
-import { makeNonBlockingLog } from './make-non-blocking-log';
 import { materializeWorkspace } from './materialize-workspace';
 import { mintMessageID } from './mint-message-id';
 import { mintSessionID } from './mint-session-id';
@@ -253,6 +254,10 @@ const MAX_REFUSAL_WINDOWS = 1024;
 // Where the TCP listener logs when the daemon is given no log.
 const STDERR_FD = 2;
 
+// How long a stopping daemon waits for the TCP listener's log to write the
+// lines it still holds, so an unread stderr delays the exit no longer.
+const LOG_DRAIN_TIMEOUT_MS = 1000;
+
 // How long startup waits for a daemon that is shutting down to release the
 // state lock before refusing to start.
 const LOCK_WAIT_MS = 2000;
@@ -2082,8 +2087,15 @@ export async function startDaemon(opts: DaemonOptions): Promise<DaemonHandle> {
   // refuses the start before any client can connect, and releases what the
   // daemon holds, the lock included.
   let tcpListener: TCPListener | null = null;
+  let listenerLog: NonBlockingLog | null = null;
 
   if (opts.listen !== undefined && listenTokens !== null) {
+    // A given log writes as it is called, so it has nothing to drain.
+    listenerLog =
+      opts.log === undefined
+        ? createNonBlockingLog(STDERR_FD)
+        : { log: opts.log, drain: () => Promise.resolve() };
+
     try {
       tcpListener = startTCPListener({
         host: opts.listen.host,
@@ -2099,7 +2111,7 @@ export async function startDaemon(opts: DaemonOptions): Promise<DaemonHandle> {
           return connection;
         },
         closeConnection: detachConnection,
-        log: opts.log ?? makeNonBlockingLog(STDERR_FD),
+        log: listenerLog.log,
         now: opts.listen.now ?? Date.now,
         refusalLogIntervalMs: opts.listen.refusalLogIntervalMs ?? REFUSAL_LOG_INTERVAL_MS,
         maxRefusalWindows: opts.listen.maxRefusalWindows ?? MAX_REFUSAL_WINDOWS,
@@ -2167,6 +2179,11 @@ export async function startDaemon(opts: DaemonOptions): Promise<DaemonHandle> {
     server.stop(true);
 
     await releaseResources();
+
+    // The stopped listener logs no more lines, so this writes the ones the
+    // log still holds, waiting no longer than the timeout when nothing reads
+    // stderr.
+    await listenerLog?.drain(LOG_DRAIN_TIMEOUT_MS);
   };
 
   writeDaemonRecord(recordPath, {

package/src/daemon/materialize-workspace.ts

@@ -326,7 +326,7 @@ async function resolveSource(
     await requireNoOriginRewriteCredentials(source.path);
 
     const resolved = await resolvePathSource(source.path, {
-      allowDirty: source.allowDirty ?? 'refuse',
+      ...(source.allowDirty === undefined ? {} : { allowDirty: source.allowDirty }),
       transports,
     });
 

package/src/daemon/request-access-classes.ts

@@ -0,0 +1,54 @@
+import type { RequestMethod } from '../protocol/parse-request-params';
+
+/**
+ * Who may make a request: `owner` is the daemon's owner alone, and
+ * `principal` is also open to a principal, which runs it through the
+ * context scoped to that principal.
+ */
+export type RequestAccessClass = 'owner' | 'principal';
+
+/**
+ * The access class of every request method, checked when a request is
+ * admitted and before it runs. The type takes every method the protocol
+ * defines, so a method without a class fails typecheck. Owner-class
+ * methods act on the whole daemon, or on the credentials a session's host
+ * may use.
+ */
+export const REQUEST_ACCESS_CLASSES: Readonly<Record<RequestMethod, RequestAccessClass>> = {
+  'daemon.hello': 'principal',
+  'daemon.ping': 'principal',
+  'daemon.quit': 'owner',
+  'session.list': 'principal',
+  'dirs.list': 'principal',
+  'agents.list': 'principal',
+  'sources.list': 'principal',
+  'sources.interpret': 'principal',
+  'git.probe': 'principal',
+  'fleet.list': 'principal',
+  'fleet.restore': 'owner',
+  'session.spawn': 'principal',
+  'session.kill': 'principal',
+  'session.ack': 'principal',
+  'session.forget': 'principal',
+  'session.resumeCommand': 'principal',
+  'session.auth.revoke': 'owner',
+  'session.auth.rebind': 'owner',
+  'session.update': 'principal',
+  'session.attach': 'principal',
+  'session.detach': 'principal',
+  'session.input': 'principal',
+  'session.submit': 'principal',
+  'session.resize': 'principal',
+  'session.screen': 'principal',
+  'session.eject': 'principal',
+  'session.adopt': 'principal',
+  'permission.respond': 'principal',
+  'session.get': 'principal',
+  'session.read': 'principal',
+  'events.read': 'principal',
+  'session.message': 'principal',
+  'session.tap': 'principal',
+  'message.get': 'principal',
+  'report.get': 'principal',
+  'message.ack': 'principal',
+};