@zgeoff/atc 0.1.0

package/src/state-store.ts

@@ -0,0 +1,131 @@
+import { Database } from 'bun:sqlite';
+import { existsSync, readFileSync } from 'node:fs';
+import type { HookEvent } from './hooks';
+import { isRecord } from './report';
+import type { FleetEntry } from './sessions';
+
+/**
+ * Daemon state in one SQLite store: the restorable fleet, the hook-event
+ * debug trail, and the spawn-directory history. 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.
+ */
+export class StateStore {
+  private readonly db: Database;
+
+  constructor(dbPath: string, legacyFleetPath?: string) {
+    this.db = new Database(dbPath, { create: true });
+
+    this.db.run('PRAGMA journal_mode = WAL;');
+
+    this.db.run(`
+      CREATE TABLE IF NOT EXISTS fleet (
+        claude_id TEXT PRIMARY KEY,
+        name TEXT NOT NULL,
+        cwd TEXT NOT NULL
+      );
+      CREATE TABLE IF NOT EXISTS events (
+        id INTEGER PRIMARY KEY AUTOINCREMENT,
+        ts TEXT NOT NULL,
+        atc_id TEXT NOT NULL,
+        event TEXT NOT NULL,
+        message TEXT,
+        session_id TEXT
+      );
+      CREATE TABLE IF NOT EXISTS spawn_history (
+        cwd TEXT PRIMARY KEY,
+        last_spawn INTEGER NOT NULL
+      );
+    `);
+
+    if (legacyFleetPath !== undefined) {
+      this.adoptLegacyFleet(legacyFleetPath);
+    }
+  }
+
+  loadFleet(): FleetEntry[] {
+    const rows = this.db
+      .query<{ claude_id: string; name: string; cwd: string }, []>(
+        'SELECT claude_id, name, cwd FROM fleet',
+      )
+      .all();
+
+    return rows.map((row) => ({ claudeId: row.claude_id, name: row.name, cwd: row.cwd }));
+  }
+
+  writeFleet(entries: readonly FleetEntry[]): void {
+    const replace = this.db.transaction((all: readonly FleetEntry[]) => {
+      this.db.run('DELETE FROM fleet');
+
+      const insert = this.db.query(
+        'INSERT OR REPLACE INTO fleet (claude_id, name, cwd) VALUES (?1, ?2, ?3)',
+      );
+
+      for (const entry of all) {
+        insert.run(entry.claudeId, entry.name, entry.cwd);
+      }
+    });
+
+    replace(entries);
+  }
+
+  recordEvent(e: HookEvent): void {
+    const rawMessage = e.payload['message'];
+    const rawSessionID = e.payload['session_id'];
+    const message = typeof rawMessage === 'string' ? rawMessage : null;
+    const sessionID = typeof rawSessionID === 'string' ? rawSessionID : null;
+
+    this.db
+      .query(
+        'INSERT INTO events (ts, atc_id, event, message, session_id) VALUES (?1, ?2, ?3, ?4, ?5)',
+      )
+      .run(new Date().toISOString(), e.atcId, e.event, message, sessionID);
+  }
+
+  recordSpawnDir(cwd: string): void {
+    this.db
+      .query(
+        'INSERT INTO spawn_history (cwd, last_spawn) VALUES (?1, ?2) ON CONFLICT(cwd) DO UPDATE SET last_spawn = ?2',
+      )
+      .run(cwd, Date.now());
+  }
+
+  collectSpawnDirs(): string[] {
+    const rows = this.db
+      .query<{ cwd: string }, []>('SELECT cwd FROM spawn_history ORDER BY last_spawn DESC')
+      .all();
+
+    return rows.map((row) => row.cwd);
+  }
+
+  stop(): void {
+    this.db.close();
+  }
+
+  private adoptLegacyFleet(legacyFleetPath: string): void {
+    const count = this.db.query<{ n: number }, []>('SELECT COUNT(*) AS n FROM fleet').get();
+
+    if (count === null || count.n > 0 || !existsSync(legacyFleetPath)) {
+      return;
+    }
+
+    try {
+      const parsed: unknown = JSON.parse(readFileSync(legacyFleetPath, 'utf8'));
+
+      if (!Array.isArray(parsed)) {
+        return;
+      }
+
+      const entries = parsed.filter(
+        (entry): entry is FleetEntry =>
+          isRecord(entry) &&
+          typeof entry['name'] === 'string' &&
+          typeof entry['cwd'] === 'string' &&
+          typeof entry['claudeId'] === 'string',
+      );
+
+      this.writeFleet(entries);
+    } catch {}
+  }
+}

package/src/statusline.ts

@@ -0,0 +1,103 @@
+import { readFileSync } from 'node:fs';
+import { homedir } from 'node:os';
+import { join } from 'node:path';
+import { statusFile } from './config';
+import { isRecord, sendReport } from './report';
+
+/**
+ * Runs as the statusLine command injected into wrangled sessions. Chains the
+ * user's own statusline (from ~/.claude/settings.json), appends the atc fleet
+ * segment, and heartbeats the session id back to the atc socket. Always
+ * exits 0 so it never breaks the session it renders for.
+ */
+export async function runStatusline(): Promise<void> {
+  const raw = await new Response(Bun.stdin.stream()).text();
+
+  const sock = process.env['ATC_SOCKET'];
+  const atcId = process.env['ATC_SESSION_ID'];
+
+  if (sock !== undefined && sock !== '' && atcId !== undefined && atcId !== '') {
+    let payload: Record<string, unknown> = {};
+
+    try {
+      const parsed: unknown = JSON.parse(raw);
+
+      if (isRecord(parsed)) {
+        payload = parsed;
+      }
+    } catch {}
+
+    const line = `${JSON.stringify({ atcId, event: 'Statusline', payload })}\n`;
+
+    await sendReport(sock, line, 500);
+  }
+
+  let chained = '';
+
+  try {
+    const settingsPath = join(homedir(), '.claude', 'settings.json');
+    const rawSettings = readFileSync(settingsPath, 'utf8');
+    const settings: unknown = JSON.parse(rawSettings);
+    const statusLine = isRecord(settings) ? settings['statusLine'] : undefined;
+    const cmd = isRecord(statusLine) ? statusLine['command'] : undefined;
+
+    if (typeof cmd === 'string' && cmd !== '' && !isSelfCommand(cmd)) {
+      const proc = Bun.spawn(['bash', '-c', cmd], {
+        stdin: new TextEncoder().encode(raw),
+        stdout: 'pipe',
+        stderr: 'ignore',
+      });
+
+      const timer = setTimeout(() => {
+        proc.kill();
+      }, 1500);
+
+      const text = await new Response(proc.stdout).text();
+
+      chained = text.trimEnd();
+
+      clearTimeout(timer);
+    }
+  } catch {}
+
+  let segment = '';
+
+  try {
+    const status: unknown = JSON.parse(readFileSync(statusFile, 'utf8'));
+
+    if (isRecord(status)) {
+      const needsYou = typeof status['needs_you'] === 'number' ? status['needs_you'] : 0;
+      const done = typeof status['done'] === 'number' ? status['done'] : 0;
+      const running = typeof status['running'] === 'number' ? status['running'] : 0;
+      const urgent = typeof status['urgent'] === 'string' ? status['urgent'] : '';
+      const parts: string[] = [];
+
+      if (needsYou > 0) {
+        const who = urgent === '' ? '' : `: ${urgent}`;
+
+        parts.push(`\u001B[1;31m● ${needsYou} need you${who}\u001B[0m`);
+      }
+
+      if (done > 0) {
+        parts.push(`\u001B[32m✓ ${done}\u001B[0m`);
+      }
+
+      if (running > 0) {
+        parts.push(`\u001B[36m◐ ${running}\u001B[0m`);
+      }
+
+      segment = parts.join(' ');
+    }
+  } catch {}
+
+  const line = [chained, segment].filter((part) => part !== '').join(' \u001B[90m▏\u001B[0m ');
+
+  console.log(line);
+  process.exit(0);
+}
+
+// A user statusline that is atc's own injected command would chain into
+// itself; the injected command always ends with the bare subcommand.
+function isSelfCommand(cmd: string): boolean {
+  return cmd.includes('statusline.ts') || cmd.trimEnd().endsWith(' statusline');
+}

package/src/ui.ts

@@ -0,0 +1,341 @@
+import { formatDir } from './dirs';
+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.
+interface SessionView {
+  readonly name: string;
+  readonly cwd: string;
+  readonly state: SessionState;
+  readonly unread: boolean;
+  readonly lastMsg: string;
+}
+
+const ESC = '\u001B';
+
+export const ansi = {
+  altScreenOn: `${ESC}[?1049h`,
+  altScreenOff: `${ESC}[?1049l`,
+  clear: `${ESC}[2J${ESC}[H`,
+  hideCursor: `${ESC}[?25l`,
+  showCursor: `${ESC}[?25h`,
+  saveCursor: `${ESC}7`,
+  restoreCursor: `${ESC}8`,
+  reset: `${ESC}[0m`,
+  moveTo: (row: number, col: number) => `${ESC}[${row};${col}H`,
+};
+
+const GLYPH: Record<SessionState, string> = {
+  needs_you: `${ESC}[31m●${ESC}[0m`,
+  running: `${ESC}[36m◐${ESC}[0m`,
+  done: `${ESC}[32m✓${ESC}[0m`,
+  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);
+}
+
+function truncate(s: string, max: number): string {
+  // oxlint-disable-next-line no-control-regex -- stripping ANSI/newline control bytes is the point
+  const clean = s.replaceAll(/[\r\n\u001B]+/gu, ' ');
+
+  if (max <= 0) {
+    return '';
+  }
+
+  return clean.length <= max ? clean : `${clean.slice(0, Math.max(0, max - 1))}…`;
+}
+
+export function cols(): number {
+  return process.stdout.columns || 80;
+}
+
+export function rows(): number {
+  return process.stdout.rows || 24;
+}
+
+export interface StatusView {
+  readonly counts: Readonly<Record<SessionState, number>>;
+  readonly focusedName: string | null;
+  readonly urgentName: string | null;
+}
+
+export function drawStatusBar(view: StatusView) {
+  const c = view.counts;
+  const width = cols();
+  const left = ` atc ▏${view.focusedName ?? 'no session'} `;
+  const parts: string[] = [];
+
+  if (c.needs_you > 0) {
+    const who = view.urgentName === null ? '' : `: ${view.urgentName}`;
+
+    parts.push(`● ${c.needs_you} need you${who}`);
+  }
+
+  if (c.done > 0) {
+    parts.push(`✓ ${c.done} done`);
+  }
+
+  if (c.running > 0) {
+    parts.push(`◐ ${c.running} running`);
+  }
+
+  if (c.exited > 0) {
+    parts.push(`✗ ${c.exited}`);
+  }
+
+  const joined = parts.join(' ▏');
+  const right = ` ${joined === '' ? 'idle' : joined} ▏^Space `;
+  const pad = Math.max(1, width - left.length - right.length);
+  const bg = c.needs_you > 0 ? `${ESC}[1;97;41m` : `${ESC}[30;47m`;
+  const text = truncate(left + ' '.repeat(pad) + right, width).padEnd(width);
+
+  out(ansi.saveCursor + ansi.moveTo(rows(), 1) + bg + text + ansi.reset + ansi.restoreCursor);
+}
+
+// All box rows are built as {styled, plainWidth} pairs so centering and edge
+// alignment never depend on ANSI-stripped length math at draw time.
+interface Row {
+  readonly styled: string;
+  readonly width: number;
+}
+
+function drawBox(rowsList: readonly Row[]) {
+  const boxWidth = Math.max(...rowsList.map((r) => r.width));
+  const top = Math.max(1, Math.floor((rows() - 1 - rowsList.length) / 2));
+  const left = Math.max(1, Math.floor((cols() - boxWidth) / 2));
+  let buf = ansi.hideCursor;
+
+  for (const [i, r] of rowsList.entries()) {
+    buf += ansi.moveTo(top + i, left) + r.styled;
+  }
+
+  out(buf);
+}
+
+function boxTop(width: number, title: string): Row {
+  const t = ` ${title} `;
+
+  return { styled: `┌${t}${'─'.repeat(Math.max(0, width - 2 - t.length))}┐`, width };
+}
+
+function boxDivider(width: number): Row {
+  return { styled: `├${'─'.repeat(width - 2)}┤`, width };
+}
+
+function boxBottom(width: number): Row {
+  return { styled: `└${'─'.repeat(width - 2)}┘`, width };
+}
+
+function boxRow(width: number, styledContent: string, contentPlainLen: number): Row {
+  const pad = ' '.repeat(Math.max(0, width - 4 - contentPlainLen));
+
+  return { styled: `│ ${styledContent}${pad} │`, width };
+}
+
+function dimRow(width: number, text: string): Row {
+  const t = truncate(text, width - 4);
+
+  return boxRow(width, `${ESC}[90m${t}${ESC}[0m`, t.length);
+}
+
+// Selection-dependent hints need the liveness facts of each row.
+export interface OverlaySessionView extends SessionView {
+  readonly alive: boolean;
+  readonly kind: 'pty' | 'jsonl';
+  readonly resumable: boolean;
+}
+
+export interface OverlayView {
+  sessions: readonly OverlaySessionView[];
+  selected: number;
+  confirmKill: boolean;
+  filter: string | null;
+}
+
+export function drawOverlay(view: OverlayView) {
+  const width = Math.min(cols() - 4, 90);
+  const rowsList: Row[] = [boxTop(width, 'sessions')];
+
+  if (view.sessions.length === 0) {
+    const empty = view.filter === null ? 'no sessions — n to spawn' : 'no matches';
+
+    rowsList.push(dimRow(width, empty));
+  }
+
+  for (const [i, s] of view.sessions.entries()) {
+    const sel = i === view.selected;
+    const name = truncate(s.name, 16).padEnd(16);
+    const state = STATE_LABEL[s.state].padEnd(9);
+    const dir = truncate(formatDir(s.cwd), 18).padEnd(18);
+    const msgWidth = Math.max(4, width - 4 - 2 - 17 - 10 - 19);
+    const msg = truncate(s.lastMsg, msgWidth).padEnd(msgWidth);
+    const unread = s.unread ? `${ESC}[1;33m!${ESC}[0m` : ' ';
+    const body = `${name} ${state} ${dir} ${msg}`;
+    const styledBody = sel ? `${ESC}[7m${body}${ESC}[0m` : body;
+
+    rowsList.push(boxRow(width, `${GLYPH[s.state]}${unread}${styledBody}`, 2 + body.length));
+  }
+
+  rowsList.push(boxDivider(width));
+
+  if (view.filter !== null) {
+    const pattern = truncate(view.filter, width - 8);
+
+    rowsList.push(
+      boxRow(width, `/ ${pattern}${ESC}[93m█${ESC}[0m`, 2 + pattern.length + 1),
+      boxDivider(width),
+    );
+  }
+
+  let hint = buildOverlayHint(view.sessions[view.selected]);
+
+  if (view.filter !== null) {
+    hint = 'type to filter · ↑↓ move · ⏎ attach · esc clear';
+  }
+
+  if (view.confirmKill) {
+    hint = 'kill selected session? y / n';
+  }
+
+  rowsList.push(dimRow(width, hint), boxBottom(width));
+
+  drawBox(rowsList);
+}
+
+const GLOBAL_HINT = 'n new · ? keys';
+
+// Only the actions valid for the selected row appear; the full reference
+// lives behind ?.
+function buildOverlayHint(s: OverlaySessionView | undefined): string {
+  if (s === undefined) {
+    return GLOBAL_HINT;
+  }
+
+  const actions: string[] = [];
+
+  if (s.kind === 'jsonl' && s.alive) {
+    actions.push('P reattach', 'K kill');
+  } else if (s.alive) {
+    actions.push('⏎ attach');
+
+    if (s.state === 'needs_you') {
+      actions.push('a ack');
+    }
+
+    actions.push('H headless', 'y yank', 'Y eject', 'K kill');
+  } else {
+    if (s.resumable) {
+      actions.push('P revive', 'y yank');
+    }
+
+    actions.push('K forget');
+  }
+
+  return `${actions.join(' · ')} ▏ ${GLOBAL_HINT}`;
+}
+
+export function drawHelp() {
+  const width = Math.min(cols() - 4, 60);
+
+  const lines = [
+    '⏎  attach the selected session',
+    'a  ack its notification without attaching',
+    'H  eject to a headless run',
+    'P  revive a dead or headless session',
+    'y  yank the resume command to the clipboard',
+    'Y  yank the resume command, then kill here',
+    'K  kill (K again on a dead session forgets it)',
+    'n  new session',
+    'r  adopt an external session',
+    '/  filter · ↑↓/jk move · q quit',
+  ];
+
+  const rowsList: Row[] = [boxTop(width, 'keys')];
+
+  for (const line of lines) {
+    rowsList.push(boxRow(width, line, line.length));
+  }
+
+  rowsList.push(boxDivider(width), dimRow(width, 'esc/? back'), boxBottom(width));
+
+  drawBox(rowsList);
+}
+
+export interface PickerView {
+  title: string;
+  items: readonly string[];
+  selected: number;
+  input: string;
+  placeholder?: string;
+  hint: string;
+}
+
+export function drawPicker(view: PickerView) {
+  const width = Math.min(cols() - 4, 90);
+  const rowsList: Row[] = [boxTop(width, view.title)];
+  const shown = view.items.slice(0, 10);
+
+  for (const [i, item] of shown.entries()) {
+    const sel = i === view.selected;
+    const t = truncate(item, width - 4);
+    const styled = sel ? `${ESC}[7m${t.padEnd(width - 4)}${ESC}[0m` : t;
+    const plainLen = sel ? width - 4 : t.length;
+
+    rowsList.push(boxRow(width, styled, plainLen));
+  }
+
+  const inputShown = truncate(view.input, width - 8);
+  let inputStyled: string;
+  let inputLen: number;
+
+  if (inputShown === '' && view.placeholder !== undefined && view.placeholder !== '') {
+    const ph = truncate(view.placeholder, width - 8);
+
+    inputStyled = `> ${ESC}[93m█${ESC}[0m${ESC}[90m ${ph}${ESC}[0m`;
+    inputLen = 2 + 1 + 1 + ph.length;
+  } else {
+    inputStyled = `> ${inputShown}${ESC}[93m█${ESC}[0m`;
+    inputLen = 2 + inputShown.length + 1;
+  }
+
+  rowsList.push(
+    boxRow(width, inputStyled, inputLen),
+    boxDivider(width),
+    dimRow(width, view.hint),
+    boxBottom(width),
+  );
+
+  drawBox(rowsList);
+}
+
+export function drawHome(fleetCount = 0) {
+  out(ansi.clear + ansi.hideCursor);
+
+  const msgs = [
+    'atc — control tower for claude sessions',
+    '',
+    'n       spawn a session',
+    'r       adopt an existing session (claude --resume)',
+    ...(fleetCount > 0 ? [`R       restore last fleet (${fleetCount} sessions)`] : []),
+    '^Space  session list',
+    'q       quit',
+  ];
+
+  const top = Math.max(1, Math.floor((rows() - 1 - msgs.length) / 2));
+
+  for (const [i, m] of msgs.entries()) {
+    const left = Math.max(1, Math.floor((cols() - m.length) / 2));
+    const styled = i === 0 ? `${ESC}[1m${m}${ESC}[0m` : `${ESC}[90m${m}${ESC}[0m`;
+
+    out(ansi.moveTo(top + i, left) + styled);
+  }
+}