@zgeoff/atc 2.5.1 → 2.7.0

package/src/daemon/daemon-connection.ts

@@ -1,5 +1,7 @@
 import { basename } from 'node:path';
 import type { AgentAdapter, AgentID, SpawnOptions } from '../agents/agent-adapter';
+import { decodeCursor } from '../protocol/decode-cursor';
+import { encodeCursor } from '../protocol/encode-cursor';
 import { OutboundQueue } from '../protocol/outbound-queue';
 import type { SocketWriter } from '../protocol/outbound-queue';
 import { parseRequestParams } from '../protocol/parse-request-params';
@@ -11,9 +13,13 @@ import {
   encodeMessage,
 } from '../protocol/protocol';
 import type { ErrorCode, EventMsg, RequestMsg } from '../protocol/protocol';
+import type { MessageID } from '../shared/message-id';
 import type { SessionID } from '../shared/session-id';
 import type { FleetEntry } from '../store/fleet-entry';
+import type { MessageRecord } from '../store/message-record';
 import type { Dims } from './attach-registry';
+import type { FleetEvent } from './build-fleet-events';
+import type { TranscriptPage, TranscriptPosition } from './load-transcript-page';
 import type { AnswerResult } from './permission-registry';
 import type { ScreenText } from './screen-model';
 import type { SessionDescriptor } from './sessions';
@@ -30,6 +36,21 @@ interface SpawnParams {
   readonly parent: SessionID | null;
 }
 
+interface SessionRecord {
+  readonly session: SessionDescriptor;
+  readonly prompt: string | null;
+  readonly lastActivityAt: number;
+  readonly pending: { readonly message: string } | null;
+  readonly result: string | null;
+}
+
+// A transcript page with the file it came from, so a cursor into a replaced
+// transcript is distinguishable from one into a grown transcript.
+interface SessionTranscriptRead {
+  readonly path: string;
+  readonly page: TranscriptPage;
+}
+
 export interface DaemonContext {
   readonly build: string;
   readonly collectSessions: () => SessionDescriptor[];
@@ -70,6 +91,29 @@ export interface DaemonContext {
   readonly resyncClient: (sessionID: SessionID, client: OutputClient) => Promise<void>;
   readonly queueBytes?: number;
   readonly getEffectiveDims: (sessionID: SessionID) => Dims;
+  readonly readSessionRecord: (id: SessionID) => Promise<SessionRecord | 'missing'>;
+  readonly loadSessionTranscript: (
+    id: SessionID,
+    from: TranscriptPosition | null,
+    limit: number,
+  ) => Promise<SessionTranscriptRead | 'missing' | 'unsupported'>;
+  readonly readEvents: (
+    afterID: number | null,
+    limit: number,
+    waitMs: number,
+  ) => Promise<FleetEvent[]>;
+  readonly writeSessionMessage: (
+    sessionID: SessionID,
+    from: string,
+    text: string,
+  ) => Promise<MessageRecord | 'missing' | 'dead' | 'unsupported' | 'no_tap'>;
+  readonly readMessage: (messageID: MessageID) => Promise<MessageView | null>;
+  readonly attachTap: (client: TapClient, sessionID: SessionID) => 'ok' | 'missing' | 'unsupported';
+  readonly ackMessage: (
+    client: TapClient,
+    sessionID: SessionID,
+    messageID: MessageID,
+  ) => Promise<MessageRecord | 'not_tapping' | 'unknown'>;
 }
 
 // The slice of a connection the attach bookkeeping needs: identity plus the
@@ -78,6 +122,18 @@ export interface OutputClient {
   readonly sendOutput: (sessionID: SessionID, event: EventMsg, byteLength: number) => void;
 }
 
+// One message as `message.get` reports it: the session it belongs to now and
+// every field of the record.
+interface MessageView {
+  readonly session: SessionID;
+  readonly record: MessageRecord;
+}
+
+// The slice of a connection a tap subscription needs.
+export interface TapClient {
+  readonly sendEvent: (event: EventMsg) => void;
+}
+
 interface PeerSocket extends SocketWriter {
   readonly end: () => void;
 }
@@ -91,6 +147,8 @@ export class DaemonConnection {
 
   private buffer = '';
 
+  private readonly decoder = new TextDecoder();
+
   private helloed = false;
 
   // The handshake answer is written before any other response on this
@@ -135,6 +193,13 @@ export class DaemonConnection {
     }
   }
 
+  // Decodes with state kept across reads, so a multi-byte character split
+  // between two reads decodes whole.
+  // oxlint-disable-next-line prefer-readonly-parameter-types -- a socket read buffer has no readonly form
+  decodeChunk(buf: Uint8Array): string {
+    return this.decoder.decode(buf, { stream: true });
+  }
+
   applyChunk(chunk: string): void {
     const buffered = this.buffer + chunk;
 
@@ -433,6 +498,26 @@ export class DaemonConnection {
 
         return;
       }
+      case 'session.message': {
+        await this.applySessionMessage(req);
+
+        return;
+      }
+      case 'session.tap': {
+        this.applyTap(req);
+
+        return;
+      }
+      case 'message.get': {
+        await this.applyMessageGet(req);
+
+        return;
+      }
+      case 'message.ack': {
+        await this.applyMessageAck(req);
+
+        return;
+      }
       case 'fleet.restore': {
         const parsed = parseRequestParams('fleet.restore', req.p);
 
@@ -448,6 +533,21 @@ export class DaemonConnection {
 
         return;
       }
+      case 'session.get': {
+        await this.applySessionGet(req);
+
+        return;
+      }
+      case 'session.read': {
+        await this.applySessionRead(req);
+
+        return;
+      }
+      case 'events.read': {
+        await this.applyEventsRead(req);
+
+        return;
+      }
       default: {
         this.sendErr(req.id, 'unknown_method', `unknown method '${req.m}'`);
       }
@@ -631,6 +731,243 @@ export class DaemonConnection {
     }
   }
 
+  private async applySessionGet(req: RequestMsg): Promise<void> {
+    const parsed = parseRequestParams('session.get', req.p);
+
+    if (!parsed.ok) {
+      this.sendErr(req.id, 'bad_args', parsed.message);
+
+      return;
+    }
+
+    const id = parsed.data.session;
+
+    const record = await this.ctx.readSessionRecord(id);
+
+    if (record === 'missing') {
+      this.sendErr(req.id, 'no_such_session', `no session '${id}'`);
+
+      return;
+    }
+
+    this.sendOk(req.id, { ...record });
+  }
+
+  private async applySessionRead(req: RequestMsg): Promise<void> {
+    const parsed = parseRequestParams('session.read', req.p);
+
+    if (!parsed.ok) {
+      this.sendErr(req.id, 'bad_args', parsed.message);
+
+      return;
+    }
+
+    const id = parsed.data.session;
+    let from: TranscriptPosition | null = null;
+
+    if (parsed.data.cursor !== undefined) {
+      const decoded = decodeCursor(parsed.data.cursor);
+
+      if (decoded === null || decoded.kind !== 'transcript') {
+        this.sendErr(req.id, 'bad_args', `'${parsed.data.cursor}' is not a session.read cursor`);
+
+        return;
+      }
+
+      from = { path: decoded.path, offset: decoded.offset };
+    }
+
+    const read = await this.ctx.loadSessionTranscript(id, from, parsed.data.limit);
+
+    if (read === 'missing') {
+      this.sendErr(req.id, 'no_such_session', `no session '${id}'`);
+    } else if (read === 'unsupported') {
+      this.sendErr(
+        req.id,
+        'unsupported',
+        `session '${id}' runs an agent whose transcript atc cannot read`,
+      );
+    } else {
+      this.sendOk(req.id, {
+        rows: read.page.rows,
+        cursor: encodeCursor({ kind: 'transcript', path: read.path, offset: read.page.offset }),
+        more: read.page.more,
+      });
+    }
+  }
+
+  private async applyEventsRead(req: RequestMsg): Promise<void> {
+    const parsed = parseRequestParams('events.read', req.p);
+
+    if (!parsed.ok) {
+      this.sendErr(req.id, 'bad_args', parsed.message);
+
+      return;
+    }
+
+    let afterID: number | null = null;
+
+    if (parsed.data.cursor !== undefined) {
+      const decoded = decodeCursor(parsed.data.cursor);
+
+      if (decoded === null || decoded.kind !== 'events') {
+        this.sendErr(req.id, 'bad_args', `'${parsed.data.cursor}' is not an events.read cursor`);
+
+        return;
+      }
+
+      afterID = decoded.id;
+    }
+
+    const events = await this.ctx.readEvents(afterID, parsed.data.limit, parsed.data.waitMs);
+
+    const last = events.at(-1);
+
+    // A cursor always comes back so a client can long-poll from an empty trail.
+    this.sendOk(req.id, {
+      events,
+      cursor: last === undefined ? encodeCursor({ kind: 'events', id: afterID ?? 0 }) : last.cursor,
+    });
+  }
+
+  private async applySessionMessage(req: RequestMsg): Promise<void> {
+    const parsed = parseRequestParams('session.message', req.p);
+
+    if (!parsed.ok) {
+      this.sendErr(req.id, 'bad_args', parsed.message);
+
+      return;
+    }
+
+    const sessionID = parsed.data.session;
+
+    const result = await this.ctx.writeSessionMessage(
+      sessionID,
+      parsed.data.from,
+      parsed.data.text,
+    );
+
+    if (result === 'missing') {
+      this.sendErr(req.id, 'no_such_session', `no session '${sessionID}'`);
+
+      return;
+    }
+
+    if (result === 'dead') {
+      this.sendErr(req.id, 'session_dead', `session '${sessionID}' has no live process`);
+
+      return;
+    }
+
+    if (result === 'unsupported') {
+      this.sendErr(
+        req.id,
+        'unsupported',
+        `session '${sessionID}' cannot take messages: its agent has no message tap`,
+      );
+
+      return;
+    }
+
+    if (result === 'no_tap') {
+      this.sendErr(req.id, 'unsupported', `session '${sessionID}' never attached a message tap`);
+
+      return;
+    }
+
+    this.sendOk(req.id, { message: result.id, status: result.status });
+  }
+
+  private applyTap(req: RequestMsg): void {
+    const parsed = parseRequestParams('session.tap', req.p);
+
+    if (!parsed.ok) {
+      this.sendErr(req.id, 'bad_args', parsed.message);
+
+      return;
+    }
+
+    const sessionID = parsed.data.session;
+    const result = this.ctx.attachTap(this, sessionID);
+
+    if (result === 'missing') {
+      this.sendErr(req.id, 'no_such_session', `no session '${sessionID}'`);
+
+      return;
+    }
+
+    if (result === 'unsupported') {
+      this.sendErr(req.id, 'unsupported', `session '${sessionID}' cannot take messages`);
+
+      return;
+    }
+
+    this.sendOk(req.id, {});
+  }
+
+  private async applyMessageGet(req: RequestMsg): Promise<void> {
+    const parsed = parseRequestParams('message.get', req.p);
+
+    if (!parsed.ok) {
+      this.sendErr(req.id, 'bad_args', parsed.message);
+
+      return;
+    }
+
+    const messageID = parsed.data.message;
+
+    const view = await this.ctx.readMessage(messageID);
+
+    if (view === null) {
+      this.sendErr(req.id, 'bad_args', `no message '${messageID}'`);
+
+      return;
+    }
+
+    const record = view.record;
+
+    this.sendOk(req.id, {
+      message: record.id,
+      session: view.session,
+      from: record.from,
+      text: record.text,
+      status: record.status,
+      sentAt: record.sentAt,
+      ...(record.deliveredAt === undefined ? {} : { deliveredAt: record.deliveredAt }),
+      ...(record.answeredAt === undefined ? {} : { answeredAt: record.answeredAt }),
+      ...(record.answer === undefined ? {} : { answer: record.answer }),
+    });
+  }
+
+  private async applyMessageAck(req: RequestMsg): Promise<void> {
+    const parsed = parseRequestParams('message.ack', req.p);
+
+    if (!parsed.ok) {
+      this.sendErr(req.id, 'bad_args', parsed.message);
+
+      return;
+    }
+
+    const sessionID = parsed.data.session;
+    const messageID = parsed.data.message;
+
+    const result = await this.ctx.ackMessage(this, sessionID, messageID);
+
+    if (result === 'not_tapping') {
+      this.sendErr(req.id, 'bad_args', `this connection is not tapping session '${sessionID}'`);
+
+      return;
+    }
+
+    if (result === 'unknown') {
+      this.sendErr(req.id, 'bad_args', `no message '${messageID}' for session '${sessionID}'`);
+
+      return;
+    }
+
+    this.sendOk(req.id, { message: result.id, status: result.status });
+  }
+
   private async applySessionVerb(
     req: RequestMsg,
     method: 'session.kill' | 'session.ack',