@zgeoff/atc 2.6.0 → 2.7.0

package/src/shared/report.ts

@@ -4,12 +4,28 @@
 async function sendLine(sock: string, line: string): Promise<void> {
   const resolvers = Promise.withResolvers<void>();
 
+  const bytes = new TextEncoder().encode(line);
+
+  let written = 0;
+
   await Bun.connect({
     unix: sock,
     socket: {
+      // A write returns the bytes the socket accepted and drops the rest, so
+      // a line larger than the socket buffer goes out across drain calls.
       open(s) {
-        s.write(line);
-        s.end();
+        written += s.write(bytes.subarray(written));
+
+        if (written >= bytes.length) {
+          s.end();
+        }
+      },
+      drain(s) {
+        written += s.write(bytes.subarray(written));
+
+        if (written >= bytes.length) {
+          s.end();
+        }
       },
       close() {
         resolvers.resolve();

package/src/shared/to-message-id.ts

@@ -0,0 +1,11 @@
+import type { MessageID } from './message-id';
+
+/**
+ * Trusts a string as an atc message id. This is the one point in the
+ * codebase where a plain string becomes a `MessageID`, and it adds no
+ * runtime check: the caller asserts the string identifies an atc message.
+ */
+export function toMessageID(id: string): MessageID {
+  // oxlint-disable-next-line no-unsafe-type-assertion -- the one point where a string is trusted as a MessageID
+  return id as MessageID;
+}

package/src/store/message-owner.ts

@@ -0,0 +1,9 @@
+import type { AgentSessionID } from '../shared/agent-session-id';
+import type { SessionID } from '../shared/session-id';
+
+// Which session a message belongs to: the atc id it was sent to, or the
+// agent session id that survives a restore's re-minted atc id.
+export interface MessageOwner {
+  readonly atcID: SessionID;
+  readonly agentSessionID?: AgentSessionID;
+}

package/src/store/message-record.ts

@@ -0,0 +1,18 @@
+import type { AgentSessionID } from '../shared/agent-session-id';
+import type { MessageID } from '../shared/message-id';
+import type { SessionID } from '../shared/session-id';
+
+export type MessageStatus = 'accepted' | 'delivered' | 'answered';
+
+export interface MessageRecord {
+  readonly id: MessageID;
+  readonly atcID: SessionID;
+  readonly agentSessionID?: AgentSessionID;
+  readonly from: string;
+  readonly text: string;
+  readonly status: MessageStatus;
+  readonly sentAt: number;
+  readonly deliveredAt?: number;
+  readonly answeredAt?: number;
+  readonly answer?: string;
+}

package/src/store/run-migrations.ts

@@ -2,6 +2,7 @@ import { sql } from 'kysely';
 import type { Generated, Kysely } from 'kysely';
 import { DEFAULT_MIGRATION_TABLE, Migrator } from 'kysely/migration';
 import type { Migration, MigrationProvider, MigrationResultSet } from 'kysely/migration';
+import type { MessageStatus } from './message-record';
 
 interface FleetTable {
   agent_session_id: string;
@@ -38,6 +39,19 @@ interface PrefsTable {
   value: string;
 }
 
+interface MessagesTable {
+  id: string;
+  atc_id: string;
+  agent_session_id: string | null;
+  sender: string;
+  text: string;
+  status: MessageStatus;
+  sent_at: number;
+  delivered_at: number | null;
+  answered_at: number | null;
+  answer: string | null;
+}
+
 /**
  * The state store's schema: what the query builder and the migration
  * ladder both build against.
@@ -47,13 +61,14 @@ export interface StateStoreSchema {
   events: EventsTable;
   spawn_history: SpawnHistoryTable;
   prefs: PrefsTable;
+  messages: MessagesTable;
 }
 
 // Every shape the fleet table has shipped with: the oldest carries only
 // agent_session_id under its Claude-era name plus name and cwd, and each
 // later step adds one column the daemon grew to depend on. events later gains
-// columns of its own, while spawn_history and prefs have carried one shape
-// since they were added.
+// columns of its own, while spawn_history, prefs, and messages have carried one
+// shape since they were added.
 const MIGRATIONS: Record<string, Migration> = {
   '001_create_initial_schema': {
     async up(db: Kysely<StateStoreSchema>) {
@@ -166,6 +181,41 @@ const MIGRATIONS: Record<string, Migration> = {
       );
     },
   },
+  '011_create_messages': {
+    async up(db: Kysely<StateStoreSchema>) {
+      await db.schema
+        .createTable('messages')
+        .ifNotExists()
+        .addColumn('id', 'text', (c) => c.primaryKey())
+        .addColumn('atc_id', 'text', (c) => c.notNull())
+        .addColumn('agent_session_id', 'text')
+        .addColumn('sender', 'text', (c) => c.notNull())
+        .addColumn('text', 'text', (c) => c.notNull())
+        .addColumn('status', 'text', (c) => c.notNull())
+        .addColumn('sent_at', 'integer', (c) => c.notNull())
+        .addColumn('delivered_at', 'integer')
+        .addColumn('answered_at', 'integer')
+        .addColumn('answer', 'text')
+        .execute();
+    },
+  },
+  '012_index_messages_by_owner': {
+    async up(db: Kysely<StateStoreSchema>) {
+      await db.schema
+        .createIndex('messages_atc_id_status_sent_at')
+        .ifNotExists()
+        .on('messages')
+        .columns(['atc_id', 'status', 'sent_at'])
+        .execute();
+
+      await db.schema
+        .createIndex('messages_agent_session_id_status_sent_at')
+        .ifNotExists()
+        .on('messages')
+        .columns(['agent_session_id', 'status', 'sent_at'])
+        .execute();
+    },
+  },
 };
 
 const PROVIDER: MigrationProvider = {

package/src/store/state-store.ts

@@ -1,16 +1,21 @@
 import { Database } from 'bun:sqlite';
 import { existsSync, readFileSync } from 'node:fs';
 import { Kysely, SqliteAdapter, SqliteIntrospector, SqliteQueryCompiler, sql } from 'kysely';
+import type { Expression, ExpressionBuilder, SqlBool } from 'kysely';
 import { toAgentID } from '../agents/agent-adapter';
 import type { AdapterEvent, AgentID } from '../agents/agent-adapter';
 import type { HookEvent } from '../daemon/hooks';
 import type { AgentSessionID } from '../shared/agent-session-id';
+import type { MessageID } from '../shared/message-id';
 import type { SessionID } from '../shared/session-id';
 import { toAgentSessionID } from '../shared/to-agent-session-id';
+import { toMessageID } from '../shared/to-message-id';
 import { toSessionID } from '../shared/to-session-id';
 import { BunSqliteDriver } from './bun-sqlite-driver';
 import { parseFleetEntry } from './fleet-entry';
 import type { FleetEntry, FleetEntryUpdate } from './fleet-entry';
+import type { MessageOwner } from './message-owner';
+import type { MessageRecord } from './message-record';
 import { runMigrations } from './run-migrations';
 import type { StateStoreSchema } from './run-migrations';
 
@@ -32,8 +37,8 @@ export interface StoredEvent {
 
 /**
  * Daemon state in one SQLite store: the restorable fleet, the hook-event
- * trail that events.read and lastActivityAt read, and the spawn-directory
- * history. The statusline contract
+ * trail that events.read and lastActivityAt read, the spawn-directory
+ * history, and the per-session message inbox. The statusline contract
  * file (status.json) stays a plain file because reporters inside wrangled
  * sessions read it without speaking to the daemon. An existing fleet.json
  * seeds the fleet table once, so upgrading never loses a restorable fleet.
@@ -293,6 +298,115 @@ export class StateStore {
       .execute();
   }
 
+  // oxlint-disable-next-line prefer-readonly-parameter-types -- every field is readonly; the branded id has no readonly form to wrap it in
+  async writeMessage(record: MessageRecord): Promise<void> {
+    await this.db
+      .insertInto('messages')
+      .values({
+        id: record.id,
+        atc_id: record.atcID,
+        agent_session_id: record.agentSessionID ?? null,
+        sender: record.from,
+        text: record.text,
+        status: record.status,
+        sent_at: record.sentAt,
+        delivered_at: record.deliveredAt ?? null,
+        answered_at: record.answeredAt ?? null,
+        answer: record.answer ?? null,
+      })
+      .execute();
+  }
+
+  async collectPendingMessages(owner: MessageOwner): Promise<MessageRecord[]> {
+    const rows = await this.db
+      .selectFrom('messages')
+      .selectAll()
+      .where('status', '=', 'accepted')
+      .where((eb) => buildOwnerFilter(eb, owner))
+      .orderBy('sent_at', 'asc')
+      .orderBy(sql`rowid`, 'asc')
+      .execute();
+
+    return rows.map((row) => toMessageRecord(row));
+  }
+
+  async findMessage(id: MessageID, owner: MessageOwner): Promise<MessageRecord | null> {
+    const row = await this.db
+      .selectFrom('messages')
+      .selectAll()
+      .where('id', '=', id)
+      .where((eb) => buildOwnerFilter(eb, owner))
+      .executeTakeFirst();
+
+    return row === undefined ? null : toMessageRecord(row);
+  }
+
+  async findMessageByID(id: MessageID): Promise<MessageRecord | null> {
+    const row = await this.db
+      .selectFrom('messages')
+      .selectAll()
+      .where('id', '=', id)
+      .executeTakeFirst();
+
+    return row === undefined ? null : toMessageRecord(row);
+  }
+
+  async updateMessageDelivered(
+    id: MessageID,
+    owner: MessageOwner,
+    at: number,
+  ): Promise<MessageRecord | null> {
+    const row = await this.db
+      .updateTable('messages')
+      .set({ status: 'delivered', delivered_at: at })
+      .where('id', '=', id)
+      .where('status', '=', 'accepted')
+      .where((eb) => buildOwnerFilter(eb, owner))
+      .returningAll()
+      .executeTakeFirst();
+
+    return row === undefined ? null : toMessageRecord(row);
+  }
+
+  async updateMessageAnswered(
+    id: MessageID,
+    owner: MessageOwner,
+    answer: string,
+    at: number,
+  ): Promise<MessageRecord | null> {
+    const row = await this.db
+      .updateTable('messages')
+      .set({ status: 'answered', answered_at: at, answer })
+      .where('id', '=', id)
+      .where('status', 'in', ['accepted', 'delivered'])
+      .where((eb) => buildOwnerFilter(eb, owner))
+      .returningAll()
+      .executeTakeFirst();
+
+    return row === undefined ? null : toMessageRecord(row);
+  }
+
+  // Messages sent before the agent reported its session id carry no agent
+  // session id; this stamps them once it is known, and moves every message
+  // from a previous agent session id to a changed one.
+  async updateMessageOwner(
+    atcID: SessionID,
+    previous: AgentSessionID | undefined,
+    next: AgentSessionID,
+  ): Promise<void> {
+    await this.db
+      .updateTable('messages')
+      .set({ agent_session_id: next })
+      .where((eb) => {
+        const unstamped = eb.and([eb('atc_id', '=', atcID), eb('agent_session_id', 'is', null)]);
+
+        return previous === undefined
+          ? unstamped
+          : eb.or([unstamped, eb('agent_session_id', '=', previous)]);
+      })
+      .execute();
+  }
+
   async stop(): Promise<void> {
     await this.db.destroy();
 
@@ -361,3 +475,31 @@ function buildStoredEvents(rows: readonly EventRow[]): StoredEvent[] {
 
   return events;
 }
+
+function buildOwnerFilter(
+  eb: ExpressionBuilder<StateStoreSchema, 'messages'>, // oxlint-disable-line prefer-readonly-parameter-types -- a kysely expression builder bound to a live query; not meaningfully freezable
+  owner: MessageOwner,
+): Expression<SqlBool> {
+  const byAtcID = eb('atc_id', '=', owner.atcID);
+
+  return owner.agentSessionID === undefined
+    ? byAtcID
+    : eb.or([byAtcID, eb('agent_session_id', '=', owner.agentSessionID)]);
+}
+
+function toMessageRecord(row: Readonly<StateStoreSchema['messages']>): MessageRecord {
+  return {
+    id: toMessageID(row.id),
+    atcID: toSessionID(row.atc_id),
+    ...(row.agent_session_id === null
+      ? {}
+      : { agentSessionID: toAgentSessionID(row.agent_session_id) }),
+    from: row.sender,
+    text: row.text,
+    status: row.status,
+    sentAt: row.sent_at,
+    ...(row.delivered_at === null ? {} : { deliveredAt: row.delivered_at }),
+    ...(row.answered_at === null ? {} : { answeredAt: row.answered_at }),
+    ...(row.answer === null ? {} : { answer: row.answer }),
+  };
+}

package/src/tap.ts

@@ -0,0 +1,120 @@
+import { z } from 'zod';
+import { DaemonClient } from './client/daemon-client';
+import { DaemonError } from './protocol/daemon-error';
+import { daemonSocketPath } from './shared/config';
+import { getBuild } from './shared/get-build';
+
+const INBOX_MESSAGE_SCHEMA = z.looseObject({
+  message: z.string(),
+  from: z.string(),
+  text: z.string(),
+  sentAt: z.number(),
+});
+
+interface InboxMessage {
+  readonly message: string;
+  readonly from: string;
+  readonly text: string;
+  readonly sentAt: number;
+}
+
+/**
+ * Streams one session's inbox to stdout, one NDJSON line per message, and
+ * acks each message once its line is written. It talks to the daemon that
+ * is already running and never boots one: a tap runs inside the session it
+ * serves, so a restart from here would take the whole fleet down. Exits 1
+ * with a hint when no daemon listens or the session cannot be tapped, and
+ * 0 once the daemon closes the connection or ends the subscription because
+ * another tap replaced it or the session was removed.
+ */
+export async function runTap(session: string): Promise<void> {
+  let client: DaemonClient;
+
+  try {
+    client = await DaemonClient.open(daemonSocketPath);
+  } catch {
+    console.error(`atc tap: no daemon at ${daemonSocketPath} — start atc first`);
+    process.exit(1);
+  }
+
+  const closed = Promise.withResolvers<void>();
+  let written: Promise<void> = Promise.resolve();
+
+  client.onClose = () => {
+    closed.resolve();
+  };
+
+  client.onEvent = (event) => {
+    if (event.ev === 'InboxClosed' && event['s'] === session) {
+      closed.resolve();
+
+      return;
+    }
+
+    if (event.ev !== 'InboxMessage' || event['s'] !== session) {
+      return;
+    }
+
+    const parsed = INBOX_MESSAGE_SCHEMA.safeParse(event);
+
+    if (!parsed.success) {
+      return;
+    }
+
+    const msg: InboxMessage = {
+      message: parsed.data.message,
+      from: parsed.data.from,
+      text: parsed.data.text,
+      sentAt: parsed.data.sentAt,
+    };
+
+    const previous = written;
+
+    written = (async () => {
+      await previous;
+      await ackInboxMessage(client, session, msg);
+    })();
+  };
+
+  try {
+    await client.sendHello(getBuild());
+    await client.sendRequest('session.tap', { session });
+  } catch (error) {
+    console.error(`atc tap: ${formatError(error)}`);
+    client.stop();
+    process.exit(1);
+  }
+
+  await closed.promise;
+  await written;
+
+  process.exit(0);
+}
+
+interface RequestSender {
+  readonly sendRequest: DaemonClient['sendRequest'];
+}
+
+async function ackInboxMessage(
+  client: RequestSender,
+  session: string,
+  msg: InboxMessage,
+): Promise<void> {
+  const line = `${JSON.stringify({ id: msg.message, from: msg.from, text: msg.text, sentAt: msg.sentAt })}\n`;
+
+  try {
+    await Bun.write(Bun.stdout, line);
+  } catch {
+    process.exit(1);
+  }
+
+  try {
+    await client.sendRequest('message.ack', { session, message: msg.message });
+  } catch (error) {
+    console.error(`atc tap: ${formatError(error)}`);
+  }
+}
+
+function formatError(error: unknown): string {
+  return error instanceof DaemonError ? `${error.code}: ${error.message}` : String(error);
+}