@zgeoff/atc 0.1.9 → 0.1.10

package/src/index.ts

@@ -10,16 +10,24 @@ import { countSessionStates, sortGroupedSessionViews, sortSessionViews } from '.
 import type { SessionState } from './sessions';
 import { ansi, cols, drawHelp, drawHome, drawOverlay, drawPicker, drawStatusBar, rows } from './ui';
 
+type AgentKind = 'claude' | 'grok';
+
 type Mode =
   | 'home'
   | 'attached'
   | 'overlay'
   | 'help'
+  | 'picker-agent'
   | 'picker-dir'
   | 'picker-name'
   | 'picker-prompt'
   | 'picker-eject';
 
+const AGENT_PICKS = [
+  { agent: 'claude' as const, label: 'Claude' },
+  { agent: 'grok' as const, label: 'Grok' },
+];
+
 interface MirrorSession {
   id: string;
   name: string;
@@ -31,9 +39,10 @@ interface MirrorSession {
   unread: boolean;
   lastMsg: string;
   createdAt: number;
-  kind: 'pty' | 'jsonl';
+  kind: 'pty' | 'headless';
   alive: boolean;
   resumable: boolean;
+  agent: AgentKind;
 }
 
 let mode: Mode = 'home';
@@ -58,6 +67,8 @@ let pickerSelected = 0;
 let spawnDir = '';
 let spawnName = '';
 let spawnResume = false;
+let spawnAgent: AgentKind = 'claude';
+let lastUsedAgent: AgentKind = 'claude';
 const stdout = process.stdout;
 
 // Full height: the atc status bar only exists on home/overlay screens;
@@ -251,7 +262,17 @@ function openOverlay() {
 function renderPicker() {
   const verb = spawnResume ? 'adopt' : 'spawn';
 
-  if (mode === 'picker-dir') {
+  if (mode === 'picker-agent') {
+    pickerSelected = Math.min(pickerSelected, AGENT_PICKS.length - 1);
+
+    drawPicker({
+      title: `${verb}: agent`,
+      items: AGENT_PICKS.map((pick) => pick.label),
+      selected: pickerSelected,
+      input: pickerInput,
+      hint: '↑↓ move · ⏎ select · esc cancel',
+    });
+  } else if (mode === 'picker-dir') {
     const items = pickMatches(allDirs, pickerInput).map((d) => formatDir(d));
 
     pickerSelected = Math.min(pickerSelected, Math.max(0, Math.min(items.length, 10) - 1));
@@ -295,9 +316,19 @@ function renderPicker() {
   scheduleStatus();
 }
 
-async function openDirPicker(resume = false) {
+function openAgentPicker(resume = false) {
   spawnResume = resume;
+  spawnAgent = lastUsedAgent;
+  pickerInput = '';
+  pickerSelected = lastUsedAgent === 'grok' ? 1 : 0;
+  mode = 'picker-agent';
 
+  stdout.write(ansi.clear);
+
+  renderPicker();
+}
+
+async function openDirPicker() {
   let recent: string[] = [];
 
   try {
@@ -344,6 +375,7 @@ async function spawnFromPicker(prompt: string) {
       cols: cols(),
       rows: ptyRows(),
       ...(spawnResume ? { resume: true } : {}),
+      agent: spawnAgent,
     });
 
     const spawned = toMirrorSession(ok['session']);
@@ -407,9 +439,10 @@ function toMirrorSession(value: unknown): MirrorSession | null {
     unread: value['unread'],
     lastMsg: value['lastMsg'],
     createdAt: value['createdAt'],
-    kind: value['kind'] === 'jsonl' ? 'jsonl' : 'pty',
+    kind: value['kind'] === 'headless' ? 'headless' : 'pty',
     alive: value['alive'],
-    resumable: typeof value['claudeId'] === 'string',
+    resumable: typeof value['agentSessionID'] === 'string',
+    agent: value['agent'] === 'grok' ? 'grok' : 'claude',
   };
 }
 
@@ -429,6 +462,7 @@ function upsertMirror(d: Readonly<MirrorSession>) {
     existing.kind = d.kind;
     existing.alive = d.alive;
     existing.resumable = d.resumable;
+    existing.agent = d.agent;
   }
 }
 
@@ -487,7 +521,7 @@ function applyDaemonEvent(e: EventMsg) {
           s.alive = false;
         }
 
-        if (e['kind'] === 'pty' || e['kind'] === 'jsonl') {
+        if (e['kind'] === 'pty' || e['kind'] === 'headless') {
           s.kind = e['kind'];
         }
 
@@ -507,7 +541,15 @@ function applyDaemonEvent(e: EventMsg) {
           s.lastMsg = e['lastMsg'];
         }
 
-        if (typeof e['claudeId'] === 'string') {
+        if (e['agent'] === 'grok' || e['agent'] === 'claude') {
+          s.agent = e['agent'];
+        }
+
+        if (typeof e['agentSessionID'] === 'string') {
+          if (!s.resumable) {
+            lastUsedAgent = s.agent;
+          }
+
           s.resumable = true;
         }
       }
@@ -735,7 +777,7 @@ function applyOverlayKey(buf: Buffer) {
   }
 
   if (ch === 'n') {
-    void openDirPicker();
+    openAgentPicker();
 
     return;
   }
@@ -772,7 +814,7 @@ function applyOverlayKey(buf: Buffer) {
     return;
   }
 
-  if (ch === 'H' && sel !== undefined && sel.kind === 'pty' && sel.alive) {
+  if (ch === 'H' && sel !== undefined && sel.kind === 'pty' && sel.alive && sel.agent !== 'grok') {
     ejectTarget = sel.id;
     pickerInput = '';
     mode = 'picker-eject';
@@ -784,14 +826,14 @@ function applyOverlayKey(buf: Buffer) {
     return;
   }
 
-  if (ch === 'P' && sel !== undefined && sel.resumable && (sel.kind === 'jsonl' || !sel.alive)) {
+  if (ch === 'P' && sel !== undefined && sel.resumable && (sel.kind === 'headless' || !sel.alive)) {
     void adoptSession(sel.id);
 
     return;
   }
 
   if (ch === 'r') {
-    void openDirPicker(true);
+    openAgentPicker(true);
 
     return;
   }
@@ -893,7 +935,7 @@ function applyTextKey(buf: Buffer, onSubmit: () => void, onCancel: () => void) {
     return;
   }
 
-  if (mode === 'picker-dir') {
+  if (mode === 'picker-dir' || mode === 'picker-agent') {
     if (isDown(buf)) {
       pickerSelected++;
 
@@ -933,6 +975,7 @@ const boot = await bootDaemonClient();
 let client = boot.client;
 let daemonStale = boot.stale;
 
+lastUsedAgent = boot.lastUsedAgent;
 client.onEvent = applyDaemonEvent;
 
 await refreshMirror();
@@ -989,6 +1032,7 @@ async function restartDaemon() {
 
   client = next.client;
   daemonStale = next.stale;
+  lastUsedAgent = next.lastUsedAgent;
   client.onEvent = applyDaemonEvent;
 
   await sendQuiet('fleet.restore', { cols: cols(), rows: ptyRows() });
@@ -1032,13 +1076,13 @@ process.stdin.on('data', (buf: Buffer) => {
       const ch = buf.toString();
 
       if (ch === 'n') {
-        void openDirPicker();
+        openAgentPicker();
 
         return;
       }
 
       if (ch === 'r') {
-        void openDirPicker(true);
+        openAgentPicker(true);
 
         return;
       }
@@ -1065,6 +1109,20 @@ process.stdin.on('data', (buf: Buffer) => {
 
       return;
     }
+    case 'picker-agent': {
+      applyTextKey(
+        buf,
+        () => {
+          spawnAgent = AGENT_PICKS[pickerSelected]?.agent ?? 'claude';
+          void openDirPicker();
+        },
+        () => {
+          toBase();
+        },
+      );
+
+      return;
+    }
     case 'picker-dir': {
       applyTextKey(
         buf,
@@ -1090,7 +1148,13 @@ process.stdin.on('data', (buf: Buffer) => {
           renderPicker();
         },
         () => {
-          toBase();
+          pickerInput = '';
+          pickerSelected = spawnAgent === 'grok' ? 1 : 0;
+          mode = 'picker-agent';
+
+          stdout.write(ansi.clear);
+
+          renderPicker();
         },
       );
 

package/src/mcp-server.ts

@@ -43,13 +43,18 @@ const TOOLS: readonly MCPTool[] = [
   {
     name: 'atc_session_spawn',
     description:
-      'Spawn a new Claude Code session in a directory. Returns the new session descriptor. Give it a prompt to start it working immediately.',
+      'Spawn a new session in a directory. Optional agent is claude or grok; omitted agent is always Claude, never the TUI last-used value. Returns the new session descriptor. Give it a prompt to start it working immediately.',
     inputSchema: {
       type: 'object',
       properties: {
         cwd: { type: 'string', description: 'Absolute path of the working directory' },
         name: { type: 'string', description: 'Session name; defaults to the directory basename' },
         prompt: { type: 'string', description: 'First message for the session' },
+        agent: {
+          type: 'string',
+          enum: ['claude', 'grok'],
+          description: 'Which agent CLI to spawn; defaults to claude',
+        },
       },
       required: ['cwd'],
       additionalProperties: false,
@@ -236,10 +241,17 @@ async function runTool(
       return JSON.stringify(ok['sessions'], null, 2);
     }
     case 'atc_session_spawn': {
+      const rawAgent = args['agent'];
+
+      if (rawAgent !== undefined && rawAgent !== 'claude' && rawAgent !== 'grok') {
+        throw new Error("agent must be 'claude' or 'grok'");
+      }
+
       const ok = await client.sendRequest('session.spawn', {
         cwd: args['cwd'],
         ...(typeof args['name'] === 'string' ? { name: args['name'] } : {}),
         ...(typeof args['prompt'] === 'string' ? { prompt: args['prompt'] } : {}),
+        ...(rawAgent === 'claude' || rawAgent === 'grok' ? { agent: rawAgent } : {}),
         cols: 100,
         rows: 30,
       });

package/src/normalize-hook-event.ts

@@ -0,0 +1,11 @@
+/**
+ * Canonicalize a hook event name to PascalCase. Claude already sends
+ * PascalCase (`SessionStart`); Grok sends snake_case (`session_start`).
+ * Restore stagger and the adapter switch compare the PascalCase form.
+ */
+export function normalizeHookEventName(raw: string): string {
+  return raw
+    .split('_')
+    .map((part) => `${part.charAt(0).toUpperCase()}${part.slice(1)}`)
+    .join('');
+}

package/src/pick-tab-target.ts

@@ -8,7 +8,7 @@ interface TabCandidate {
   readonly lastAttachedAt: number;
   readonly createdAt: number;
   readonly alive: boolean;
-  readonly kind: 'pty' | 'jsonl';
+  readonly kind: 'pty' | 'headless';
 }
 
 /**

package/src/print-grok-hook-file.ts

@@ -0,0 +1,27 @@
+import { buildCLICommand } from './build-cli-command';
+
+const GROK_HOOK_EVENTS = [
+  'SessionStart',
+  'SessionEnd',
+  'UserPromptSubmit',
+  'Stop',
+  'StopFailure',
+  'StopCancelled',
+  'Notification',
+] as const;
+
+/**
+ * Print the Grok hook file to stdout. The operator copies it to
+ * `$GROK_HOME/hooks/atc-reporter.json`; atc never writes that path.
+ */
+export function printGrokHookFile(): void {
+  process.stdout.write(buildGrokHookFile());
+}
+
+function buildGrokHookFile(): string {
+  const cmd = buildCLICommand('hook-report');
+  const entry = [{ hooks: [{ type: 'command', command: cmd, timeout: 5 }] }];
+  const hooks = Object.fromEntries(GROK_HOOK_EVENTS.map((event) => [event, entry]));
+
+  return `${JSON.stringify({ hooks }, null, 2)}\n`;
+}

package/src/protocol.ts

@@ -5,7 +5,7 @@ import { isRecord } from './report';
  * per line. Three message kinds, distinguished by which fields are present —
  * request (id + m), response (id + ok or err), event (ev).
  */
-export const PROTOCOL_V = 1;
+export const PROTOCOL_V = 2;
 
 // Control lines are capped before buffering; PTY output is split into chunks
 // so a queued response is delayed by at most one chunk.

package/src/sessions.ts

@@ -2,7 +2,8 @@ import { readFileSync, writeFileSync } from 'node:fs';
 import { join } from 'node:path';
 import { spawn } from 'bun-pty';
 import type { IPty } from 'bun-pty';
-import type { AgentAdapter } from './agent-adapter';
+import { toAgentKind } from './agent-adapter';
+import type { AdapterEvent, AgentAdapter, AgentKind } from './agent-adapter';
 import { collectCleanEnv } from './collect-clean-env';
 import { socketPath, stateDir, statusFile } from './config';
 import type { HookEvent } from './hooks';
@@ -23,13 +24,14 @@ export interface SessionDescriptor {
   readonly unread: boolean;
   readonly lastMsg: string;
   readonly lastDetail?: string;
-  readonly claudeId?: string;
+  readonly agentSessionID?: string;
+  readonly agent: AgentKind;
   readonly pinned: boolean;
   readonly lastAttachedAt: number;
   readonly repoRoot: string;
   readonly namedBy: 'user' | 'auto' | 'agent';
   readonly createdAt: number;
-  readonly kind: 'pty' | 'jsonl';
+  readonly kind: 'pty' | 'headless';
   readonly alive: boolean;
 }
 
@@ -37,13 +39,14 @@ export interface Session {
   id: string;
   name: string;
   cwd: string;
-  kind: 'pty' | 'jsonl';
+  kind: 'pty' | 'headless';
   pty: IPty | null;
   state: SessionState;
   unread: boolean;
   lastMsg: string;
   lastDetail?: string;
-  claudeId?: string;
+  agentSessionID?: string;
+  agent: AgentKind;
   transcriptSource?: string;
   pinned: boolean;
 
@@ -66,7 +69,8 @@ let counter = 0;
 export interface FleetEntry {
   readonly name: string;
   readonly cwd: string;
-  readonly claudeId: string;
+  readonly agentSessionID: string;
+  readonly agent: AgentKind;
   readonly pinned?: boolean;
   readonly lastAttachedAt?: number;
 }
@@ -87,6 +91,29 @@ const jsonFleetStore: FleetStore = {
   },
 };
 
+export function parseFleetEntry(raw: unknown): FleetEntry | undefined {
+  if (!isRecord(raw) || typeof raw['name'] !== 'string' || typeof raw['cwd'] !== 'string') {
+    return undefined;
+  }
+
+  // Fleet files written before the id key was agent-neutral carry it under
+  // its Claude-era name.
+  const agentSessionID = raw['agentSessionID'] ?? raw['claudeId'];
+
+  if (typeof agentSessionID !== 'string') {
+    return undefined;
+  }
+
+  return {
+    name: raw['name'],
+    cwd: raw['cwd'],
+    agentSessionID,
+    agent: toAgentKind(raw['agent']),
+    ...(raw['pinned'] === true ? { pinned: true } : {}),
+    ...(typeof raw['lastAttachedAt'] === 'number' ? { lastAttachedAt: raw['lastAttachedAt'] } : {}),
+  };
+}
+
 function loadFleet(): FleetEntry[] {
   try {
     const parsed: unknown = JSON.parse(readFileSync(fleetFile, 'utf8'));
@@ -95,13 +122,17 @@ function loadFleet(): FleetEntry[] {
       return [];
     }
 
-    return parsed.filter(
-      (entry): entry is FleetEntry =>
-        isRecord(entry) &&
-        typeof entry['name'] === 'string' &&
-        typeof entry['cwd'] === 'string' &&
-        typeof entry['claudeId'] === 'string',
-    );
+    const entries: FleetEntry[] = [];
+
+    for (const entry of parsed) {
+      const parsedEntry = parseFleetEntry(entry);
+
+      if (parsedEntry !== undefined) {
+        entries.push(parsedEntry);
+      }
+    }
+
+    return entries;
   } catch {
     return [];
   }
@@ -118,31 +149,51 @@ export class SessionManager {
 
   onEvent: (kind: SessionEventKind, s: Session) => void = () => {};
 
-  private readonly adapter: AgentAdapter;
+  private readonly fallback: AgentAdapter;
+
+  private readonly adapters: Partial<Readonly<Record<AgentKind, AgentAdapter>>>;
 
   private readonly store: FleetStore;
 
   private readonly statusPath: string;
 
-  constructor(adapter: AgentAdapter, store: FleetStore = jsonFleetStore, statusPath = statusFile) {
-    this.adapter = adapter;
+  constructor(
+    fallback: AgentAdapter,
+    store: FleetStore = jsonFleetStore,
+    statusPath: string | undefined = statusFile,
+    adapters: Partial<Readonly<Record<AgentKind, AgentAdapter>>> = {},
+  ) {
+    this.fallback = fallback;
+    this.adapters = adapters;
     this.store = store;
-    this.statusPath = statusPath;
+    this.statusPath = statusPath ?? statusFile;
+  }
+
+  /**
+   * Adapter for this kind, or null when none is registered. Never returns a
+   * different kind than the one asked for.
+   */
+  findAdapter(kind: AgentKind): AgentAdapter | null {
+    if (kind === 'claude') {
+      return this.adapters.claude ?? this.fallback;
+    }
+
+    return this.adapters[kind] ?? null;
   }
 
   // Hands a live terminal session off to a headless run: the terminal dies,
-  // the record lives on as a jsonl session and keeps its screen history.
+  // the record lives on as a headless session and keeps its screen history.
   yankHeadless(id: string): Session | null {
     const s = this.sessions.find((x) => x.id === id);
 
-    if (!s || s.pty === null || s.claudeId === undefined) {
+    if (!s || s.pty === null || s.agentSessionID === undefined) {
       return null;
     }
 
     const pty = s.pty;
 
     s.pty = null;
-    s.kind = 'jsonl';
+    s.kind = 'headless';
     s.state = 'running';
     s.lastMsg = 'ejected to headless';
 
@@ -161,12 +212,13 @@ export class SessionManager {
       id: `s${++counter}-${Date.now().toString(36)}`,
       name: entry.name,
       cwd: entry.cwd,
-      kind: 'jsonl',
+      kind: 'headless',
       pty: null,
       state: 'running',
       unread: false,
       lastMsg: 'waiting to restore',
-      claudeId: entry.claudeId,
+      agentSessionID: entry.agentSessionID,
+      agent: entry.agent,
       pinned: entry.pinned ?? false,
       lastAttachedAt: entry.lastAttachedAt ?? Date.now(),
       repoRoot: resolveRepoRoot(entry.cwd),
@@ -186,11 +238,17 @@ export class SessionManager {
   adoptTerminal(id: string, cols: number, rows: number): Session | null {
     const s = this.sessions.find((x) => x.id === id);
 
-    if (!s || s.pty !== null || s.claudeId === undefined) {
+    if (!s || s.pty !== null || s.agentSessionID === undefined) {
+      return null;
+    }
+
+    const adapter = this.findAdapter(s.agent);
+
+    if (adapter === null) {
       return null;
     }
 
-    const plan = this.adapter.planSpawn({ prompt: '', resume: s.claudeId });
+    const plan = adapter.planSpawn({ prompt: '', resume: s.agentSessionID });
 
     const pty = spawn(plan.bin, plan.args, {
       name: 'xterm-256color',
@@ -264,7 +322,7 @@ export class SessionManager {
   updateSurfaceState(id: string, state: SessionState, msg: string) {
     const s = this.sessions.find((x) => x.id === id);
 
-    if (!s || s.kind !== 'jsonl') {
+    if (!s || s.kind !== 'headless') {
       return;
     }
 
@@ -314,9 +372,16 @@ export class SessionManager {
     rows: number,
     resume: boolean | string = false,
     namedBy: 'user' | 'auto' = 'auto',
+    agent: AgentKind = 'claude',
   ): Session {
+    const adapter = this.findAdapter(agent);
+
+    if (adapter === null) {
+      throw new Error(`no adapter for agent '${agent}'`);
+    }
+
     const id = `s${++counter}-${Date.now().toString(36)}`;
-    const plan = this.adapter.planSpawn({ prompt, resume });
+    const plan = adapter.planSpawn({ prompt, resume });
 
     const pty = spawn(plan.bin, plan.args, {
       name: 'xterm-256color',
@@ -341,7 +406,8 @@ export class SessionManager {
       state: 'running',
       unread: false,
       lastMsg: initialMsg,
-      ...(typeof resume === 'string' ? { claudeId: resume } : {}),
+      ...(typeof resume === 'string' ? { agentSessionID: resume } : {}),
+      agent,
       pinned: false,
       lastAttachedAt: Date.now(),
       repoRoot: resolveRepoRoot(cwd),
@@ -385,32 +451,46 @@ export class SessionManager {
       unread: s.unread,
       lastMsg: s.lastMsg,
       ...(s.lastDetail === undefined ? {} : { lastDetail: s.lastDetail }),
-      ...(s.claudeId === undefined ? {} : { claudeId: s.claudeId }),
+      ...(s.agentSessionID === undefined ? {} : { agentSessionID: s.agentSessionID }),
+      agent: s.agent,
       pinned: s.pinned,
       lastAttachedAt: s.lastAttachedAt,
       repoRoot: s.repoRoot,
       namedBy: s.namedBy,
       createdAt: s.createdAt,
       kind: s.kind,
-      alive: s.pty !== null || (s.kind === 'jsonl' && s.state !== 'exited'),
+      alive: s.pty !== null || (s.kind === 'headless' && s.state !== 'exited'),
     }));
   }
 
-  applyHook(e: HookEvent) {
+  // Returns the normalized event kind so the caller can key lifecycle
+  // bookkeeping on it, or null when no session or adapter matches.
+  applyHook(e: HookEvent): AdapterEvent['kind'] | null {
     const s = this.sessions.find((x) => x.id === e.atcId);
 
+    if (!s) {
+      return null;
+    }
+
+    const adapter = this.findAdapter(s.agent);
+
+    if (adapter === null) {
+      return null;
+    }
+
+    const ev = adapter.normalizeHook(e);
+
     // Reporters belong to the terminal process; once a session is headless,
     // late reports from the dying terminal must not clobber its state.
-    if (!s || s.kind === 'jsonl') {
-      return;
+    if (s.kind === 'headless') {
+      return ev.kind;
     }
 
-    const ev = this.adapter.normalizeHook(e);
     const focused = this.focusedId === s.id;
     let dirty = false;
 
-    if (ev.agentSessionID !== undefined && s.claudeId !== ev.agentSessionID) {
-      s.claudeId = ev.agentSessionID;
+    if (ev.agentSessionID !== undefined && s.agentSessionID !== ev.agentSessionID) {
+      s.agentSessionID = ev.agentSessionID;
 
       this.writeFleet();
 
@@ -421,8 +501,11 @@ export class SessionManager {
       s.lastDetail = ev.detail;
     }
 
+    if (ev.transcriptSource !== undefined) {
+      s.transcriptSource = ev.transcriptSource;
+    }
+
     if (ev.nameSource !== undefined) {
-      s.transcriptSource = ev.nameSource;
       void this.refreshName(s, ev.nameSource);
     }
 
@@ -481,10 +564,18 @@ export class SessionManager {
       this.onEvent('state', s);
       this.emitChange();
     }
+
+    return ev.kind;
   }
 
   private async refreshName(s: Session, source: string) {
-    const update = await this.adapter.loadName(source, s.namedBy);
+    const adapter = this.findAdapter(s.agent);
+
+    if (adapter === null) {
+      return;
+    }
+
+    const update = await adapter.loadName(source, s.namedBy);
 
     if (update === null || update.name === '' || update.name === s.name) {
       return;
@@ -509,7 +600,7 @@ export class SessionManager {
       return null;
     }
 
-    return this.adapter.buildResumeCommand(s.cwd, s.claudeId);
+    return this.findAdapter(s.agent)?.buildResumeCommand(s.cwd, s.agentSessionID) ?? null;
   }
 
   attach(id: string) {
@@ -605,13 +696,14 @@ export class SessionManager {
     const fleet: FleetEntry[] = [];
 
     for (const s of this.sessions) {
-      const live = s.pty !== null || (s.kind === 'jsonl' && s.state !== 'exited');
+      const live = s.pty !== null || (s.kind === 'headless' && s.state !== 'exited');
 
-      if (live && s.claudeId !== undefined) {
+      if (live && s.agentSessionID !== undefined) {
         fleet.push({
           name: s.name,
           cwd: s.cwd,
-          claudeId: s.claudeId,
+          agentSessionID: s.agentSessionID,
+          agent: s.agent,
           ...(s.pinned ? { pinned: true } : {}),
           lastAttachedAt: s.lastAttachedAt,
         });