@zgeoff/atc 0.1.12 → 1.0.0

package/src/{attach-registry.ts → daemon/attach-registry.ts}

@@ -1,3 +1,5 @@
+import type { SessionID } from '../shared/session-id';
+
 export interface Dims {
   readonly cols: number;
   readonly rows: number;
@@ -10,16 +12,16 @@ export interface Dims {
  * the whole screen.
  */
 export class AttachRegistry<TClient> {
-  private readonly bySession = new Map<string, Map<TClient, Dims>>();
+  private readonly bySession = new Map<SessionID, Map<TClient, Dims>>();
 
-  attach(sessionID: string, client: TClient, dims: Dims): void {
+  attach(sessionID: SessionID, client: TClient, dims: Dims): void {
     const clients = this.bySession.get(sessionID) ?? new Map<TClient, Dims>();
 
     clients.set(client, dims);
     this.bySession.set(sessionID, clients);
   }
 
-  detach(sessionID: string, client: TClient): void {
+  detach(sessionID: SessionID, client: TClient): void {
     const clients = this.bySession.get(sessionID);
 
     clients?.delete(client);
@@ -29,8 +31,8 @@ export class AttachRegistry<TClient> {
     }
   }
 
-  detachAll(client: TClient): string[] {
-    const affected: string[] = [];
+  detachAll(client: TClient): SessionID[] {
+    const affected: SessionID[] = [];
 
     for (const [sessionID, clients] of this.bySession) {
       if (clients.delete(client)) {
@@ -45,15 +47,15 @@ export class AttachRegistry<TClient> {
     return affected;
   }
 
-  removeSession(sessionID: string): void {
+  removeSession(sessionID: SessionID): void {
     this.bySession.delete(sessionID);
   }
 
-  hasClient(sessionID: string, client: TClient): boolean {
+  hasClient(sessionID: SessionID, client: TClient): boolean {
     return this.bySession.get(sessionID)?.has(client) ?? false;
   }
 
-  updateDims(sessionID: string, client: TClient, dims: Dims): boolean {
+  updateDims(sessionID: SessionID, client: TClient, dims: Dims): boolean {
     const clients = this.bySession.get(sessionID);
 
     if (clients === undefined || !clients.has(client)) {
@@ -65,11 +67,11 @@ export class AttachRegistry<TClient> {
     return true;
   }
 
-  collectClients(sessionID: string): TClient[] {
+  collectClients(sessionID: SessionID): TClient[] {
     return [...(this.bySession.get(sessionID)?.keys() ?? [])];
   }
 
-  findEffectiveDims(sessionID: string): Dims | null {
+  findEffectiveDims(sessionID: SessionID): Dims | null {
     const clients = this.bySession.get(sessionID);
 
     if (clients === undefined || clients.size === 0) {

package/src/daemon/build-session-event.ts

@@ -0,0 +1,43 @@
+import { PROTOCOL_V } from '../protocol/protocol';
+import type { EventMsg } from '../protocol/protocol';
+import type { SessionID } from '../shared/session-id';
+import type { Session, SessionDescriptor, SessionEventKind, SessionManager } from './sessions';
+
+/**
+ * Builds the wire event for a session-manager notification, or null when the
+ * notification carries no descriptor to send: `added` and `state` fold in
+ * the current descriptor and skip emitting if the session is gone by the
+ * time the descriptor is collected.
+ */
+export function buildSessionEvent(
+  mgr: SessionManager,
+  kind: SessionEventKind,
+  s: Session,
+): EventMsg | null {
+  const builders: Record<SessionEventKind, () => EventMsg | null> = {
+    added: () => {
+      const session = findDescriptor(mgr, s.id);
+
+      return session === null ? null : { v: PROTOCOL_V, ev: 'session.added', session };
+    },
+    state: () => {
+      const session = findDescriptor(mgr, s.id);
+
+      return session === null ? null : { v: PROTOCOL_V, ev: 'session.state', session };
+    },
+    renamed: () => ({
+      v: PROTOCOL_V,
+      ev: 'session.renamed',
+      s: s.id,
+      name: s.name,
+      namedBy: s.namedBy,
+    }),
+    removed: () => ({ v: PROTOCOL_V, ev: 'session.removed', s: s.id }),
+  };
+
+  return builders[kind]();
+}
+
+function findDescriptor(mgr: SessionManager, id: SessionID): SessionDescriptor | null {
+  return mgr.collectDescriptors().find((x) => x.id === id) ?? null;
+}

package/src/{daemon-connection.ts → daemon/daemon-connection.ts}

@@ -1,12 +1,21 @@
 import { basename } from 'node:path';
-import type { AgentAdapter, AgentKind } from './agent-adapter';
+import type { AgentAdapter, AgentID, SpawnOptions } from '../agents/agent-adapter';
+import { OutboundQueue } from '../protocol/outbound-queue';
+import type { SocketWriter } from '../protocol/outbound-queue';
+import { parseRequestParams } from '../protocol/parse-request-params';
+import {
+  MAX_CHUNK,
+  MAX_LINE,
+  PROTOCOL_V,
+  decodeMessage,
+  encodeMessage,
+} from '../protocol/protocol';
+import type { ErrorCode, EventMsg, RequestMsg } from '../protocol/protocol';
+import type { SessionID } from '../shared/session-id';
+import type { FleetEntry } from '../store/fleet-entry';
 import type { Dims } from './attach-registry';
-import { OutboundQueue } from './outbound-queue';
-import type { SocketWriter } from './outbound-queue';
 import type { AnswerResult } from './permission-registry';
-import { MAX_CHUNK, MAX_LINE, PROTOCOL_V, decodeMessage, encodeMessage } from './protocol';
-import type { ErrorCode, EventMsg, RequestMsg } from './protocol';
-import type { FleetEntry, SessionDescriptor } from './sessions';
+import type { SessionDescriptor } from './sessions';
 
 interface SpawnParams {
   readonly cwd: string;
@@ -14,56 +23,56 @@ interface SpawnParams {
   readonly prompt: string;
   readonly cols: number;
   readonly rows: number;
-  readonly resume: boolean | string;
+  readonly resume: SpawnOptions['resume'];
   readonly namedBy: 'user' | 'auto';
-  readonly agent: AgentKind;
+  readonly agent: AgentID;
 }
 
 export interface DaemonContext {
   readonly build: string;
   readonly collectSessions: () => SessionDescriptor[];
-  readonly collectSpawnDirs: () => string[];
-  readonly collectFleet: () => FleetEntry[];
-  readonly loadLastUsedAgent: () => AgentKind;
-  readonly findAdapter: (kind: AgentKind) => AgentAdapter | null;
+  readonly collectSpawnDirs: () => Promise<string[]>;
+  readonly collectFleet: () => Promise<FleetEntry[]>;
+  readonly loadLastUsedAgent: () => Promise<AgentID>;
+  readonly findAdapter: (id: AgentID) => AgentAdapter | null;
   readonly spawnSession: (p: SpawnParams) => SessionDescriptor;
-  readonly killSession: (id: string) => boolean;
-  readonly updateSession: (id: string, name?: string, pinned?: boolean) => boolean;
+  readonly killSession: (id: SessionID) => Promise<boolean>;
+  readonly updateSession: (id: SessionID, name?: string, pinned?: boolean) => boolean;
   readonly quitDaemon: () => void;
-  readonly ackSession: (id: string) => boolean;
-  readonly buildResumeCommand: (id: string) => string | null;
+  readonly ackSession: (id: SessionID) => boolean;
+  readonly buildResumeCommand: (id: SessionID) => string | null;
   readonly answerPermission: (request: string, decision: string) => AnswerResult;
-  readonly restoreFleet: (cols: number, rows: number) => number;
+  readonly restoreFleet: (cols: number, rows: number) => Promise<number>;
   readonly attachSession: (
     client: OutputClient,
-    sessionID: string,
+    sessionID: SessionID,
     dims: Dims,
   ) => 'ok' | 'missing' | 'dead';
-  readonly detachSession: (client: OutputClient, sessionID: string) => void;
+  readonly detachSession: (client: OutputClient, sessionID: SessionID) => void;
   readonly detachClient: (client: OutputClient) => void;
   readonly writeSessionInput: (
-    sessionID: string,
+    sessionID: SessionID,
     data: string,
   ) => 'busy' | 'ok' | 'missing' | 'dead';
   readonly ejectSession: (
-    id: string,
+    id: SessionID,
     prompt: string,
   ) => 'ok' | 'missing' | 'unsupported' | 'no_transcript';
   readonly adoptSession: (
-    id: string,
+    id: SessionID,
     cols: number,
     rows: number,
   ) => 'ok' | 'missing' | 'no_transcript';
-  readonly resizeSession: (client: OutputClient, sessionID: string, dims: Dims) => boolean;
-  readonly resyncClient: (sessionID: string, client: OutputClient) => Promise<void>;
+  readonly resizeSession: (client: OutputClient, sessionID: SessionID, dims: Dims) => boolean;
+  readonly resyncClient: (sessionID: SessionID, client: OutputClient) => Promise<void>;
   readonly queueBytes?: number;
-  readonly getEffectiveDims: (sessionID: string) => Dims;
+  readonly getEffectiveDims: (sessionID: SessionID) => Dims;
 }
 
 // The slice of a connection the attach bookkeeping needs: identity plus the
 // ability to receive output events.
 export interface OutputClient {
-  readonly sendOutput: (sessionID: string, event: EventMsg, byteLength: number) => void;
+  readonly sendOutput: (sessionID: SessionID, event: EventMsg, byteLength: number) => void;
 }
 
 interface PeerSocket extends SocketWriter {
@@ -81,7 +90,12 @@ export class DaemonConnection {
 
   private helloed = false;
 
-  private readonly desynced = new Map<string, number>();
+  // The handshake answer is written before any other response on this
+  // connection, even though building it reads the store: a request that
+  // arrives while that read is in flight waits behind it.
+  private helloAnswered: Promise<void> = Promise.resolve();
+
+  private readonly desynced = new Map<SessionID, number>();
 
   constructor(peer: PeerSocket, ctx: DaemonContext) {
     this.peer = peer;
@@ -100,7 +114,7 @@ export class DaemonConnection {
   // this client and resynchronizes with a repaint once the queue drains. An
   // intermediate chunk is never dropped without that resync, because a byte
   // stream cut mid-escape corrupts the client's terminal state.
-  sendOutput(sessionID: string, event: EventMsg, byteLength: number): void {
+  sendOutput(sessionID: SessionID, event: EventMsg, byteLength: number): void {
     if (!this.helloed) {
       return;
     }
@@ -187,12 +201,28 @@ export class DaemonConnection {
       return false;
     }
 
-    this.applyRequest(req);
+    this.answerAsync(req.id, () => this.applyRequest(req));
 
     return true;
   }
 
-  private applyRequest(req: RequestMsg): void {
+  // A store query that rejects must end one request, never the daemon: a
+  // floating promise here would take the whole process down with it.
+  private answerAsync(id: number, answered: () => Promise<void>): void {
+    void (async () => {
+      try {
+        await answered();
+      } catch (error) {
+        const reason = error instanceof Error ? error.message : String(error);
+
+        this.sendErr(id, 'internal', reason);
+      }
+    })();
+  }
+
+  private async applyRequest(req: RequestMsg): Promise<void> {
+    await this.helloAnswered;
+
     switch (req.m) {
       case 'daemon.ping': {
         this.sendOk(req.id, {});
@@ -205,12 +235,12 @@ export class DaemonConnection {
         return;
       }
       case 'dirs.list': {
-        this.sendOk(req.id, { dirs: this.ctx.collectSpawnDirs() });
+        this.sendOk(req.id, { dirs: await this.ctx.collectSpawnDirs() });
 
         return;
       }
       case 'fleet.list': {
-        this.sendOk(req.id, { fleet: this.ctx.collectFleet() });
+        this.sendOk(req.id, { fleet: await this.ctx.collectFleet() });
 
         return;
       }
@@ -226,11 +256,17 @@ export class DaemonConnection {
         return;
       }
       case 'session.update': {
-        const sessionID = typeof req.p?.['session'] === 'string' ? req.p['session'] : '';
-        const name = typeof req.p?.['name'] === 'string' ? req.p['name'] : undefined;
-        const pinned = typeof req.p?.['pinned'] === 'boolean' ? req.p['pinned'] : undefined;
+        const parsed = parseRequestParams('session.update', req.p);
+
+        if (!parsed.ok) {
+          this.sendErr(req.id, 'bad_args', parsed.message);
+
+          return;
+        }
+
+        const sessionID = parsed.data.session;
 
-        if (this.ctx.updateSession(sessionID, name, pinned)) {
+        if (this.ctx.updateSession(sessionID, parsed.data.name, parsed.data.pinned)) {
           this.sendOk(req.id, {});
         } else {
           this.sendErr(req.id, 'no_such_session', `no session '${sessionID}'`);
@@ -239,17 +275,25 @@ export class DaemonConnection {
         return;
       }
       case 'session.kill': {
-        this.applySessionVerb(req, this.ctx.killSession);
+        await this.applySessionVerb(req, 'session.kill', this.ctx.killSession);
 
         return;
       }
       case 'session.ack': {
-        this.applySessionVerb(req, this.ctx.ackSession);
+        await this.applySessionVerb(req, 'session.ack', this.ctx.ackSession);
 
         return;
       }
       case 'session.resumeCommand': {
-        const id = typeof req.p?.['session'] === 'string' ? req.p['session'] : '';
+        const parsed = parseRequestParams('session.resumeCommand', req.p);
+
+        if (!parsed.ok) {
+          this.sendErr(req.id, 'bad_args', parsed.message);
+
+          return;
+        }
+
+        const id = parsed.data.session;
         const command = this.ctx.buildResumeCommand(id);
 
         if (command === null) {
@@ -261,14 +305,16 @@ export class DaemonConnection {
         return;
       }
       case 'session.eject': {
-        const sessionID = typeof req.p?.['session'] === 'string' ? req.p['session'] : '';
+        const parsed = parseRequestParams('session.eject', req.p);
 
-        const prompt =
-          typeof req.p?.['prompt'] === 'string' && req.p['prompt'] !== ''
-            ? req.p['prompt']
-            : 'Continue the task autonomously. Verify your work as you go and stop when it is complete.';
+        if (!parsed.ok) {
+          this.sendErr(req.id, 'bad_args', parsed.message);
+
+          return;
+        }
 
-        const result = this.ctx.ejectSession(sessionID, prompt);
+        const sessionID = parsed.data.session;
+        const result = this.ctx.ejectSession(sessionID, parsed.data.prompt);
 
         if (result === 'ok') {
           this.sendOk(req.id, {});
@@ -291,10 +337,16 @@ export class DaemonConnection {
         return;
       }
       case 'session.adopt': {
-        const sessionID = typeof req.p?.['session'] === 'string' ? req.p['session'] : '';
-        const cols = typeof req.p?.['cols'] === 'number' ? req.p['cols'] : 80;
-        const rows = typeof req.p?.['rows'] === 'number' ? req.p['rows'] : 24;
-        const adoptResult = this.ctx.adoptSession(sessionID, cols, rows);
+        const parsed = parseRequestParams('session.adopt', req.p);
+
+        if (!parsed.ok) {
+          this.sendErr(req.id, 'bad_args', parsed.message);
+
+          return;
+        }
+
+        const sessionID = parsed.data.session;
+        const adoptResult = this.ctx.adoptSession(sessionID, parsed.data.cols, parsed.data.rows);
 
         if (adoptResult === 'ok') {
           this.sendOk(req.id, {});
@@ -320,9 +372,15 @@ export class DaemonConnection {
         return;
       }
       case 'session.detach': {
-        const sessionID = typeof req.p?.['session'] === 'string' ? req.p['session'] : '';
+        const parsed = parseRequestParams('session.detach', req.p);
 
-        this.ctx.detachSession(this, sessionID);
+        if (!parsed.ok) {
+          this.sendErr(req.id, 'bad_args', parsed.message);
+
+          return;
+        }
+
+        this.ctx.detachSession(this, parsed.data.session);
         this.sendOk(req.id, {});
 
         return;
@@ -343,10 +401,17 @@ export class DaemonConnection {
         return;
       }
       case 'fleet.restore': {
-        const cols = typeof req.p?.['cols'] === 'number' ? req.p['cols'] : 80;
-        const rows = typeof req.p?.['rows'] === 'number' ? req.p['rows'] : 24;
+        const parsed = parseRequestParams('fleet.restore', req.p);
+
+        if (!parsed.ok) {
+          this.sendErr(req.id, 'bad_args', parsed.message);
 
-        this.sendOk(req.id, { restored: this.ctx.restoreFleet(cols, rows) });
+          return;
+        }
+
+        this.sendOk(req.id, {
+          restored: await this.ctx.restoreFleet(parsed.data.cols, parsed.data.rows),
+        });
 
         return;
       }
@@ -357,36 +422,17 @@ export class DaemonConnection {
   }
 
   private applySpawn(req: RequestMsg): void {
-    const cwd = req.p?.['cwd'];
+    const parsed = parseRequestParams('session.spawn', req.p);
 
-    if (typeof cwd !== 'string' || cwd === '') {
-      this.sendErr(req.id, 'bad_args', 'session.spawn requires a cwd');
+    if (!parsed.ok) {
+      this.sendErr(req.id, 'bad_args', parsed.message);
 
       return;
     }
 
-    const name = typeof req.p?.['name'] === 'string' ? req.p['name'] : '';
-    const rawResume = req.p?.['resume'];
-    let resume: boolean | string = false;
-
-    if (typeof rawResume === 'boolean' || typeof rawResume === 'string') {
-      resume = rawResume;
-    }
-
-    const rawAgent = req.p?.['agent'];
-
-    if (
-      rawAgent !== undefined &&
-      rawAgent !== 'claude' &&
-      rawAgent !== 'grok' &&
-      rawAgent !== 'codex'
-    ) {
-      this.sendErr(req.id, 'bad_args', "session.spawn agent must be 'claude', 'grok', or 'codex'");
-
-      return;
-    }
-
-    const agent: AgentKind = rawAgent === 'grok' || rawAgent === 'codex' ? rawAgent : 'claude';
+    const cwd = parsed.data.cwd;
+    const name = parsed.data.name;
+    const agent: AgentID = parsed.data.agent ?? 'claude';
 
     if (this.ctx.findAdapter(agent) === null) {
       this.sendErr(req.id, 'unsupported', `no adapter for agent '${agent}'`);
@@ -397,10 +443,10 @@ export class DaemonConnection {
     const session = this.ctx.spawnSession({
       cwd,
       name: name === '' ? basename(cwd) : name,
-      prompt: typeof req.p?.['prompt'] === 'string' ? req.p['prompt'] : '',
-      cols: typeof req.p?.['cols'] === 'number' ? req.p['cols'] : 80,
-      rows: typeof req.p?.['rows'] === 'number' ? req.p['rows'] : 24,
-      resume,
+      prompt: parsed.data.prompt,
+      cols: parsed.data.cols,
+      rows: parsed.data.rows,
+      resume: parsed.data.resume,
       namedBy: name === '' ? 'auto' : 'user',
       agent,
     });
@@ -409,10 +455,20 @@ export class DaemonConnection {
   }
 
   private applyAttach(req: RequestMsg): void {
-    const sessionID = typeof req.p?.['session'] === 'string' ? req.p['session'] : '';
-    const cols = typeof req.p?.['cols'] === 'number' ? req.p['cols'] : 80;
-    const rows = typeof req.p?.['rows'] === 'number' ? req.p['rows'] : 24;
-    const result = this.ctx.attachSession(this, sessionID, { cols, rows });
+    const parsed = parseRequestParams('session.attach', req.p);
+
+    if (!parsed.ok) {
+      this.sendErr(req.id, 'bad_args', parsed.message);
+
+      return;
+    }
+
+    const sessionID = parsed.data.session;
+
+    const result = this.ctx.attachSession(this, sessionID, {
+      cols: parsed.data.cols,
+      rows: parsed.data.rows,
+    });
 
     if (result === 'missing') {
       this.sendErr(req.id, 'no_such_session', `no session '${sessionID}'`);
@@ -432,9 +488,16 @@ export class DaemonConnection {
   }
 
   private applyInput(req: RequestMsg): void {
-    const sessionID = typeof req.p?.['session'] === 'string' ? req.p['session'] : '';
-    const data = typeof req.p?.['d'] === 'string' ? req.p['d'] : '';
-    const result = this.ctx.writeSessionInput(sessionID, data);
+    const parsed = parseRequestParams('session.input', req.p);
+
+    if (!parsed.ok) {
+      this.sendErr(req.id, 'bad_args', parsed.message);
+
+      return;
+    }
+
+    const sessionID = parsed.data.session;
+    const result = this.ctx.writeSessionInput(sessionID, parsed.data.d);
 
     if (result === 'missing') {
       this.sendErr(req.id, 'no_such_session', `no session '${sessionID}'`);
@@ -462,17 +525,19 @@ export class DaemonConnection {
   }
 
   private applyResize(req: RequestMsg): void {
-    const sessionID = typeof req.p?.['session'] === 'string' ? req.p['session'] : '';
-    const cols = typeof req.p?.['cols'] === 'number' ? req.p['cols'] : 0;
-    const rows = typeof req.p?.['rows'] === 'number' ? req.p['rows'] : 0;
+    const parsed = parseRequestParams('session.resize', req.p);
 
-    if (cols < 1 || rows < 1) {
-      this.sendErr(req.id, 'bad_args', 'session.resize requires positive cols and rows');
+    if (!parsed.ok) {
+      this.sendErr(req.id, 'bad_args', parsed.message);
 
       return;
     }
 
-    if (!this.ctx.resizeSession(this, sessionID, { cols, rows })) {
+    const sessionID = parsed.data.session;
+
+    if (
+      !this.ctx.resizeSession(this, sessionID, { cols: parsed.data.cols, rows: parsed.data.rows })
+    ) {
       this.sendErr(req.id, 'bad_args', `not attached to session '${sessionID}'`);
 
       return;
@@ -482,15 +547,16 @@ export class DaemonConnection {
   }
 
   private applyPermissionRespond(req: RequestMsg): void {
-    const request = typeof req.p?.['request'] === 'string' ? req.p['request'] : '';
-    const decision = typeof req.p?.['decision'] === 'string' ? req.p['decision'] : '';
+    const parsed = parseRequestParams('permission.respond', req.p);
 
-    if (request === '' || decision === '') {
-      this.sendErr(req.id, 'bad_args', 'permission.respond requires a request and a decision');
+    if (!parsed.ok) {
+      this.sendErr(req.id, 'bad_args', parsed.message);
 
       return;
     }
 
+    const request = parsed.data.request;
+    const decision = parsed.data.decision;
     const result = this.ctx.answerPermission(request, decision);
 
     switch (result) {
@@ -515,10 +581,24 @@ export class DaemonConnection {
     }
   }
 
-  private applySessionVerb(req: RequestMsg, verb: (id: string) => boolean): void {
-    const id = typeof req.p?.['session'] === 'string' ? req.p['session'] : '';
+  private async applySessionVerb(
+    req: RequestMsg,
+    method: 'session.kill' | 'session.ack',
+    verb: (id: SessionID) => boolean | Promise<boolean>,
+  ): Promise<void> {
+    const parsed = parseRequestParams(method, req.p);
+
+    if (!parsed.ok) {
+      this.sendErr(req.id, 'bad_args', parsed.message);
+
+      return;
+    }
+
+    const id = parsed.data.session;
 
-    if (verb(id)) {
+    const ok = await verb(id);
+
+    if (ok) {
       this.sendOk(req.id, {});
     } else {
       this.sendErr(req.id, 'no_such_session', `no session '${id}'`);
@@ -526,7 +606,8 @@ export class DaemonConnection {
   }
 
   private applyHello(req: RequestMsg): boolean {
-    const client = typeof req.p?.['client'] === 'string' ? req.p['client'] : 'unknown client';
+    const parsedHello = parseRequestParams('daemon.hello', req.p);
+    const client = parsedHello.ok ? parsedHello.data.client : 'unknown client';
 
     if (req.v !== PROTOCOL_V) {
       this.sendErr(
@@ -539,14 +620,19 @@ export class DaemonConnection {
     }
 
     this.helloed = true;
+    this.helloAnswered = this.sendHelloOk(req.id);
+
+    this.answerAsync(req.id, () => this.helloAnswered);
 
-    this.sendOk(req.id, {
+    return true;
+  }
+
+  private async sendHelloOk(id: number): Promise<void> {
+    this.sendOk(id, {
       daemon: this.ctx.build,
       limits: { maxLine: MAX_LINE, maxChunk: MAX_CHUNK },
-      lastUsedAgent: this.ctx.loadLastUsedAgent(),
+      lastUsedAgent: await this.ctx.loadLastUsedAgent(),
     });
-
-    return true;
   }
 
   private sendOk(id: number, ok: Readonly<Record<string, unknown>>): void {