@zgeoff/atc 0.1.12 → 1.0.0

package/src/client/keys.ts

@@ -0,0 +1,111 @@
+export const KEY = {
+  tab: 0x09,
+  ctrlC: 0x03,
+  ctrlU: 0x15,
+  esc: 0x1b,
+  enter: 0x0d,
+  backspace: 0x7f,
+} as const;
+
+export function isUp(buf: Buffer): boolean {
+  return buf.toString() === '\u001B[A' || buf.toString() === '\u001BOA';
+}
+
+export function isDown(buf: Buffer): boolean {
+  return buf.toString() === '\u001B[B' || buf.toString() === '\u001BOB';
+}
+
+export interface TextEditOptions {
+  readonly isLeaderKey: (buf: Buffer) => boolean;
+
+  // Only a screen with a list under its input answers the arrow keys; a
+  // plain prompt treats them as unprintable noise.
+  readonly moves: boolean;
+}
+
+export type TextEdit =
+  | { readonly kind: 'none' }
+  | { readonly kind: 'submit'; readonly value: string }
+  | { readonly kind: 'cancel' }
+  | { readonly kind: 'leader' }
+  | { readonly kind: 'move'; readonly delta: 1 | -1 }
+  | { readonly kind: 'input'; readonly value: string };
+
+/**
+ * What one stdin chunk does to a text-entry screen, decided without touching
+ * the screen. The caller owns the input string and applies the answer.
+ */
+export function planTextEdit(
+  buf: Buffer,
+  input: string,
+  opts: Readonly<TextEditOptions>,
+): TextEdit {
+  // Pasted chunks arrive as one buffer: read it character by character so a
+  // trailing newline still submits. Escape sequences stay intact.
+  if (buf.length > 1 && buf[0] !== KEY.esc) {
+    let value = input;
+
+    for (const ch of buf.toString()) {
+      const edit = planKeyEdit(Buffer.from(ch), value, opts);
+
+      if (edit.kind === 'input') {
+        value = edit.value;
+        continue;
+      }
+
+      if (edit.kind !== 'none') {
+        return edit;
+      }
+    }
+
+    return value === input ? { kind: 'none' } : { kind: 'input', value };
+  }
+
+  return planKeyEdit(buf, input, opts);
+}
+
+function planKeyEdit(buf: Buffer, input: string, opts: Readonly<TextEditOptions>): TextEdit {
+  if (buf[0] === KEY.esc && buf.length === 1) {
+    return { kind: 'cancel' };
+  }
+
+  if (opts.isLeaderKey(buf)) {
+    return { kind: 'leader' };
+  }
+
+  if (buf[0] === KEY.enter) {
+    return { kind: 'submit', value: input };
+  }
+
+  if (buf[0] === KEY.backspace) {
+    return { kind: 'input', value: input.slice(0, -1) };
+  }
+
+  if (buf[0] === KEY.ctrlU) {
+    return { kind: 'input', value: '' };
+  }
+
+  if (opts.moves) {
+    if (isDown(buf)) {
+      return { kind: 'move', delta: 1 };
+    }
+
+    if (isUp(buf)) {
+      return { kind: 'move', delta: -1 };
+    }
+  }
+
+  const text = buf.toString();
+
+  return isPrintable(text) ? { kind: 'input', value: input + text } : { kind: 'none' };
+}
+
+function isPrintable(text: string): boolean {
+  for (const c of text) {
+    if (c < ' ' || c === '\u007F') {
+      return false;
+    }
+  }
+
+  return true;
+}

package/src/client/parse-daemon-event.ts

@@ -0,0 +1,114 @@
+import { match } from 'ts-pattern';
+import { z } from 'zod';
+import type { EventMsg } from '../protocol/protocol';
+import { toMirrorSession } from './to-mirror-session';
+import type { MirrorSession } from './to-mirror-session';
+
+export type DaemonEvent =
+  | { readonly ev: 'session.added'; readonly session: MirrorSession }
+  | { readonly ev: 'session.state'; readonly session: MirrorSession }
+  | {
+      readonly ev: 'session.renamed';
+      readonly s: string;
+      readonly name: string;
+      readonly namedBy: 'user' | 'auto' | 'agent';
+    }
+  | { readonly ev: 'session.removed'; readonly s: string }
+  | {
+      readonly ev: 'session.resized';
+      readonly s: string;
+      readonly cols: number;
+      readonly rows: number;
+    }
+  | { readonly ev: 'session.output'; readonly s: string; readonly seq: number; readonly d: string }
+  | { readonly ev: 'session.desync'; readonly s: string; readonly dropped: number }
+  | {
+      readonly ev: 'permission.requested';
+      readonly request: string;
+      readonly s: string;
+      readonly message: string;
+      readonly respondable: boolean;
+    }
+  | { readonly ev: 'permission.resolved'; readonly request: string; readonly decision: string };
+
+// Every variant is a looseObject so unrecognized keys never fail a match —
+// additive evolution on a known event still parses.
+const DAEMON_EVENT_SCHEMA = z.discriminatedUnion('ev', [
+  z.looseObject({ ev: z.literal('session.added'), session: z.unknown() }),
+  z.looseObject({ ev: z.literal('session.state'), session: z.unknown() }),
+  z.looseObject({
+    ev: z.literal('session.renamed'),
+    s: z.string(),
+    name: z.string(),
+    namedBy: z.enum(['user', 'auto', 'agent']),
+  }),
+  z.looseObject({ ev: z.literal('session.removed'), s: z.string() }),
+  z.looseObject({
+    ev: z.literal('session.resized'),
+    s: z.string(),
+    cols: z.number(),
+    rows: z.number(),
+  }),
+  z.looseObject({
+    ev: z.literal('session.output'),
+    s: z.string(),
+    seq: z.number(),
+    d: z.string(),
+  }),
+  z.looseObject({ ev: z.literal('session.desync'), s: z.string(), dropped: z.number() }),
+  z.looseObject({
+    ev: z.literal('permission.requested'),
+    request: z.string(),
+    s: z.string(),
+    message: z.string(),
+    respondable: z.boolean(),
+  }),
+  z.looseObject({
+    ev: z.literal('permission.resolved'),
+    request: z.string(),
+    decision: z.string(),
+  }),
+]);
+
+/**
+ * Turns a raw event line into the typed union, or null when the kind is
+ * unrecognized or a known kind's payload is malformed. Total by design: a
+ * miss is dropped by the caller, never thrown.
+ */
+export function parseDaemonEvent(raw: EventMsg): DaemonEvent | null {
+  const parsed = DAEMON_EVENT_SCHEMA.safeParse(raw);
+
+  if (!parsed.success) {
+    return null;
+  }
+
+  return match(parsed.data)
+    .with({ ev: 'session.added' }, { ev: 'session.state' }, (d) => {
+      const session = toMirrorSession(d.session);
+
+      return session === null ? null : { ev: d.ev, session };
+    })
+    .with({ ev: 'session.renamed' }, (d) => ({
+      ev: d.ev,
+      s: d.s,
+      name: d.name,
+      namedBy: d.namedBy,
+    }))
+    .with({ ev: 'session.removed' }, (d) => ({ ev: d.ev, s: d.s }))
+    .with({ ev: 'session.resized' }, (d) => ({ ev: d.ev, s: d.s, cols: d.cols, rows: d.rows }))
+    .with({ ev: 'session.output' }, (d) => ({ ev: d.ev, s: d.s, seq: d.seq, d: d.d }))
+    .with({ ev: 'session.desync' }, (d) => ({ ev: d.ev, s: d.s, dropped: d.dropped }))
+    .with({ ev: 'permission.requested' }, (d) => ({
+      ev: d.ev,
+      request: d.request,
+      s: d.s,
+      message: d.message,
+      respondable: d.respondable,
+    }))
+    .with({ ev: 'permission.resolved' }, (d) => ({
+      ev: d.ev,
+      request: d.request,
+      decision: d.decision,
+    }))
+    .exhaustive();
+}

package/src/{pick-tab-target.ts → client/pick-tab-target.ts}

@@ -1,5 +1,5 @@
-import type { SessionState } from './sessions';
-import { sortSessionViews } from './sessions';
+import type { SessionState } from '../daemon/sessions';
+import { sortSessionViews } from '../daemon/sessions';
 
 interface TabCandidate {
   readonly id: string;

package/src/client/spawn-picker.ts

@@ -0,0 +1,305 @@
+import type { AgentID } from '../agents/agent-adapter';
+import { loadConfig } from '../shared/config';
+import { collectAgentPicks } from './collect-agent-picks';
+import type { AgentPick } from './collect-agent-picks';
+import { collectDirs, formatDir, formatDirName, pickMatches } from './dirs';
+import { planTextEdit } from './keys';
+import { ansi, cols, drawPicker } from './ui';
+
+type PickerStep = 'agent' | 'dir' | 'name' | 'prompt';
+
+// What the flow borrows from the client that owns the screen, the daemon
+// connection and the fleet mirror.
+export interface SpawnPickerDeps<TMirror> {
+  readonly sendRequest: (
+    m: string,
+    p?: Readonly<Record<string, unknown>>,
+  ) => Promise<Readonly<Record<string, unknown>>>;
+  readonly ptyRows: () => number;
+  readonly isLeaderKey: (buf: Buffer) => boolean;
+  readonly getLastUsedAgent: () => AgentID;
+  readonly scheduleStatus: () => void;
+  readonly toBase: () => void;
+  readonly attach: (sessionID: string) => Promise<void>;
+  readonly toMirrorSession: (value: unknown) => TMirror | null;
+  readonly upsertMirror: (session: Readonly<TMirror>) => void;
+}
+
+/**
+ * The modal flow behind n and r: agent, then directory, then name, then an
+ * optional first prompt. Every path out of it either attaches the new
+ * session or returns the client to the screen it came from.
+ */
+export class SpawnPicker<TMirror extends { readonly id: string }> {
+  private readonly deps: SpawnPickerDeps<TMirror>;
+
+  private step: PickerStep = 'agent';
+
+  private input = '';
+
+  private selected = 0;
+
+  // The installed agents, collected each time the menu opens so a config
+  // edit or a fresh install lands without a client restart.
+  private picks: AgentPick[] = [];
+
+  private dirs: string[] = [];
+
+  private dir = '';
+
+  private name = '';
+
+  private resume = false;
+
+  private agent: AgentID = 'claude';
+
+  constructor(deps: SpawnPickerDeps<TMirror>) {
+    this.deps = deps;
+  }
+
+  open(resume = false) {
+    this.resume = resume;
+    this.picks = collectAgentPicks(loadConfig());
+    this.input = '';
+
+    // A last-used agent that is no longer installed is not in the menu, so
+    // the selection falls to the first one that is.
+    this.selected = Math.max(
+      0,
+      this.picks.findIndex((p) => p.agent === this.deps.getLastUsedAgent()),
+    );
+
+    this.agent = this.picks[this.selected]?.agent ?? this.deps.getLastUsedAgent();
+    this.step = 'agent';
+
+    process.stdout.write(ansi.clear);
+    this.render();
+  }
+
+  applyKey(buf: Buffer) {
+    const edit = planTextEdit(buf, this.input, {
+      isLeaderKey: this.deps.isLeaderKey,
+      moves: this.step === 'agent' || this.step === 'dir',
+    });
+
+    switch (edit.kind) {
+      case 'none': {
+        return;
+      }
+      case 'cancel': {
+        this.applyCancel();
+
+        return;
+      }
+      case 'leader': {
+        this.deps.toBase();
+
+        return;
+      }
+      case 'submit': {
+        this.input = edit.value;
+
+        this.applySubmit();
+
+        return;
+      }
+      case 'move': {
+        this.selected = edit.delta === 1 ? this.selected + 1 : Math.max(0, this.selected - 1);
+
+        this.render();
+
+        return;
+      }
+      case 'input': {
+        this.input = edit.value;
+
+        this.render();
+      }
+    }
+  }
+
+  render() {
+    const verb = this.resume ? 'adopt' : 'spawn';
+
+    if (this.step === 'agent') {
+      this.selected = Math.min(this.selected, this.picks.length - 1);
+
+      // An empty menu means every configured binary is missing, so the hint
+      // carries the fix instead of the movement keys.
+      const hint =
+        this.picks.length === 0
+          ? 'no agent CLI found — set claudeBin, grokBin, or codexBin in config.json · esc cancel'
+          : '↑↓ move · ⏎ select · esc cancel';
+
+      drawPicker({
+        title: `${verb}: agent`,
+        items: this.picks.map((p) => p.label),
+        selected: this.selected,
+        input: this.input,
+        hint,
+      });
+    } else if (this.step === 'dir') {
+      const items = pickMatches(this.dirs, this.input).map((d) => formatDir(d));
+
+      this.selected = Math.min(this.selected, Math.max(0, Math.min(items.length, 10) - 1));
+
+      drawPicker({
+        title: `${verb}: directory`,
+        items,
+        selected: this.selected,
+        input: this.input,
+        hint: 'type to filter · ↑↓ move · ⏎ select · esc cancel',
+      });
+    } else if (this.step === 'name') {
+      drawPicker({
+        title: `${verb}: name`,
+        items: [],
+        selected: -1,
+        input: this.input,
+        placeholder: formatDirName(this.dir),
+        hint: `session name for ${formatDir(this.dir)} · ⏎ accept · esc back`,
+      });
+    } else {
+      drawPicker({
+        title: 'spawn: initial prompt',
+        items: [],
+        selected: -1,
+        input: this.input,
+        placeholder: 'optional — ⏎ to start interactive',
+        hint: 'first message for the session · ⏎ spawn · esc back',
+      });
+    }
+
+    this.deps.scheduleStatus();
+  }
+
+  private applyCancel() {
+    if (this.step === 'agent') {
+      this.deps.toBase();
+
+      return;
+    }
+
+    this.input = '';
+
+    if (this.step === 'dir') {
+      this.selected = Math.max(
+        0,
+        this.picks.findIndex((p) => p.agent === this.agent),
+      );
+
+      this.step = 'agent';
+    } else if (this.step === 'name') {
+      this.step = 'dir';
+    } else {
+      this.step = 'name';
+    }
+
+    process.stdout.write(ansi.clear);
+    this.render();
+  }
+
+  private applySubmit() {
+    if (this.step === 'agent') {
+      const pick = this.picks[this.selected];
+
+      // With no agent installed the menu is empty and there is nothing to
+      // spawn.
+      if (pick === undefined) {
+        return;
+      }
+
+      this.agent = pick.agent;
+      void this.openDirStep();
+
+      return;
+    }
+
+    if (this.step === 'dir') {
+      const items = pickMatches(this.dirs, this.input);
+      const raw = this.input.trim();
+      let chosen = items[this.selected] ?? null;
+
+      if (chosen === null && (raw.startsWith('/') || raw.startsWith('~'))) {
+        chosen = raw.replace(/^~/u, process.env['HOME'] ?? '~');
+      }
+
+      if (chosen === null) {
+        return;
+      }
+
+      this.dir = chosen;
+      this.input = '';
+      this.step = 'name';
+    } else if (this.step === 'name') {
+      this.name = this.input.trim();
+      this.input = '';
+
+      // Adopt skips the prompt step: the agent's own resume picker opens
+      // inside the new PTY.
+      if (this.resume) {
+        void this.spawn('');
+
+        return;
+      }
+
+      this.step = 'prompt';
+    } else {
+      void this.spawn(this.input.trim());
+
+      return;
+    }
+
+    process.stdout.write(ansi.clear);
+    this.render();
+  }
+
+  private async openDirStep() {
+    let recent: string[] = [];
+
+    try {
+      const answer = await this.deps.sendRequest('dirs.list');
+
+      const dirs = answer['dirs'];
+
+      if (Array.isArray(dirs)) {
+        recent = dirs.filter((d): d is string => typeof d === 'string');
+      }
+    } catch {}
+
+    this.dirs = await collectDirs(recent);
+
+    this.input = '';
+    this.selected = 0;
+    this.step = 'dir';
+
+    process.stdout.write(ansi.clear);
+    this.render();
+  }
+
+  private async spawn(prompt: string) {
+    try {
+      const ok = await this.deps.sendRequest('session.spawn', {
+        cwd: this.dir,
+        name: this.name,
+        prompt,
+        cols: cols(),
+        rows: this.deps.ptyRows(),
+        ...(this.resume ? { resume: true } : {}),
+        agent: this.agent,
+      });
+
+      const spawned = this.deps.toMirrorSession(ok['session']);
+
+      if (spawned !== null) {
+        this.deps.upsertMirror(spawned);
+
+        await this.deps.attach(spawned.id);
+
+        return;
+      }
+    } catch {}
+
+    this.deps.toBase();
+  }
+}

package/src/client/to-mirror-session.ts

@@ -0,0 +1,65 @@
+import { z } from 'zod';
+import { toAgentID } from '../agents/agent-adapter';
+import type { AgentID } from '../agents/agent-adapter';
+import type { SessionState } from '../daemon/sessions';
+
+export interface MirrorSession {
+  id: string;
+  name: string;
+  cwd: string;
+  pinned: boolean;
+  lastAttachedAt: number;
+  repoRoot: string;
+  state: SessionState;
+  unread: boolean;
+  lastMsg: string;
+  createdAt: number;
+  kind: 'pty' | 'headless';
+  alive: boolean;
+  resumable: boolean;
+  canEject: boolean;
+  agent: AgentID;
+}
+
+// Only the fields a mirror can't function without; an unparseable descriptor
+// is skipped rather than thrown into the event loop. Unknown keys pass
+// through so the lenient fallbacks below can still read them.
+const REQUIRED_MIRROR_FIELDS_SCHEMA = z.looseObject({
+  id: z.string(),
+  name: z.string(),
+  cwd: z.string(),
+  state: z.enum(['running', 'needs_you', 'done', 'exited']),
+  unread: z.boolean(),
+  lastMsg: z.string(),
+  createdAt: z.number(),
+  alive: z.boolean(),
+});
+
+export function toMirrorSession(value: unknown): MirrorSession | null {
+  const parsed = REQUIRED_MIRROR_FIELDS_SCHEMA.safeParse(value);
+
+  if (!parsed.success) {
+    return null;
+  }
+
+  const record = parsed.data;
+
+  return {
+    id: record.id,
+    name: record.name,
+    cwd: record.cwd,
+    pinned: record['pinned'] === true,
+    lastAttachedAt:
+      typeof record['lastAttachedAt'] === 'number' ? record['lastAttachedAt'] : record.createdAt,
+    repoRoot: typeof record['repoRoot'] === 'string' ? record['repoRoot'] : record.cwd,
+    state: record.state,
+    unread: record.unread,
+    lastMsg: record.lastMsg,
+    createdAt: record.createdAt,
+    kind: record['kind'] === 'headless' ? 'headless' : 'pty',
+    alive: record.alive,
+    resumable: typeof record['agentSessionID'] === 'string',
+    canEject: record['canEject'] === true,
+    agent: toAgentID(record['agent']),
+  };
+}

package/src/{ui.ts → client/ui.ts}

@@ -1,9 +1,9 @@
-import type { AgentKind } from './agent-adapter';
+import type { AgentID } from '../agents/agent-adapter';
+import { PINNED_GROUP_KEY } from '../daemon/sessions';
+import type { SessionState } from '../daemon/sessions';
+import { RESET_INPUT_MODES } from '../shared/reset-input-modes';
 import { formatDir } from './dirs';
 import { formatOverlayAgentMark } from './format-overlay-agent-mark';
-import { RESET_INPUT_MODES } from './reset-input-modes';
-import { PINNED_GROUP_KEY } from './sessions';
-import type { SessionState } from './sessions';
 
 // The slice of a session the drawing layer needs; satisfied by both the
 // daemon's sessions and the wire descriptors a client mirrors.
@@ -163,13 +163,18 @@ export interface OverlaySessionView extends SessionView {
   readonly alive: boolean;
   readonly kind: 'pty' | 'headless';
   readonly resumable: boolean;
-  readonly agent: AgentKind;
+  readonly canEject: boolean;
+  readonly agent: AgentID;
   readonly pinned: boolean;
   readonly repoRoot: string;
 }
 
 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>>;
   selected: number;
   confirmKill: boolean;
   filter: string | null;
@@ -209,8 +214,8 @@ export function drawOverlay(view: OverlayView) {
     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);
-    const styledMark = mark === 'g' ? `${ESC}[90m${mark}${ESC}[0m` : mark;
+    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;
 
@@ -269,7 +274,7 @@ export function buildOverlayHint(s: OverlaySessionView | undefined): string {
       actions.push('a ack');
     }
 
-    if (s.agent === 'claude') {
+    if (s.canEject) {
       actions.push('H headless');
     }