@zgeoff/atc 0.1.0

package/src/cli.ts

@@ -0,0 +1,101 @@
+// atc CLI entry: no subcommand opens the client TUI; `hook-report` and
+// `statusline` are the commands injected into wrangled sessions.
+import { defineCommand, runMain } from 'citty';
+import pkg from '../package.json';
+import { getBuild } from './get-build';
+
+const main = defineCommand({
+  meta: {
+    name: 'atc',
+    version: pkg.version,
+    description: 'Terminal control tower for Claude Code sessions',
+  },
+  default: 'tui',
+  subCommands: {
+    tui: () =>
+      defineCommand({
+        meta: {
+          name: 'tui',
+          description: 'Open the session list client',
+          hidden: true,
+        },
+        async run() {
+          await import('./index');
+        },
+      }),
+    mcp: () =>
+      defineCommand({
+        meta: {
+          name: 'mcp',
+          description: 'Run an MCP server over stdio exposing the fleet as tools',
+        },
+        async run() {
+          const server = await import('./mcp-server');
+
+          await server.runMCPServer(getBuild());
+        },
+      }),
+    daemon: () =>
+      defineCommand({
+        meta: {
+          name: 'daemon',
+          description: 'Run the atc daemon in the foreground',
+        },
+        async run() {
+          const daemon = await import('./daemon');
+          const config = await import('./config');
+          const claude = await import('./claude-adapter');
+          const headless = await import('./start-headless-run');
+
+          // Test harnesses shrink the outbound queue to force overflow
+          // deterministically; unset means the production default.
+          const queueBytes = Number(process.env['ATC_QUEUE_BYTES']);
+
+          const handle = daemon.startDaemon({
+            headlessRunner: (runOpts, hooks) => headless.startHeadlessRun(runOpts, hooks),
+            socketPath: config.daemonSocketPath,
+            reporterSocketPath: config.socketPath,
+            build: getBuild(),
+            adapter: new claude.ClaudeAdapter(config.loadConfig()),
+            dbPath: config.dbFile,
+            legacyFleetPath: config.legacyFleetFile,
+            pidPath: config.daemonPidFile,
+            ...(Number.isFinite(queueBytes) && queueBytes > 0 ? { queueBytes } : {}),
+          });
+
+          process.on('SIGTERM', () => {
+            handle.stop();
+            process.exit(0);
+          });
+        },
+      }),
+    'hook-report': () =>
+      defineCommand({
+        meta: {
+          name: 'hook-report',
+          description: 'Forward a hook event from a wrangled session to the atc socket',
+          hidden: true,
+        },
+        async run() {
+          const reporter = await import('./hook-report');
+
+          await reporter.runHookReport();
+        },
+      }),
+    statusline: () =>
+      defineCommand({
+        meta: {
+          name: 'statusline',
+          description: 'Render the chained statusline for a wrangled session',
+          hidden: true,
+        },
+        async run() {
+          const statusline = await import('./statusline');
+
+          await statusline.runStatusline();
+        },
+      }),
+  },
+});
+
+await runMain(main);

package/src/collect-clean-env.ts

@@ -0,0 +1,21 @@
+/**
+ * The process environment with any enclosing Claude Code session scrubbed
+ * out. A claude spawned with those variables intact behaves as a child of
+ * the enclosing session — its transcript lands inside the parent's instead
+ * of its own project directory, which breaks resume and handoff.
+ */
+export function collectCleanEnv(
+  extra: Readonly<Record<string, string>> = {},
+): Record<string, string> {
+  const env: Record<string, string> = {};
+
+  for (const [key, value] of Object.entries(process.env)) {
+    if (value === undefined || key === 'CLAUDECODE' || key.startsWith('CLAUDE_CODE_')) {
+      continue;
+    }
+
+    env[key] = value;
+  }
+
+  return { ...env, ...extra };
+}

package/src/config.ts

@@ -0,0 +1,57 @@
+import { existsSync, mkdirSync, readFileSync, writeFileSync } from 'node:fs';
+import { homedir } from 'node:os';
+import { join } from 'node:path';
+import { isRecord } from './report';
+
+export interface Config {
+  claudeBin: string;
+  claudeArgs: string[];
+}
+
+const DEFAULTS: Config = {
+  claudeBin: 'claude',
+  claudeArgs: [],
+};
+
+const configDir = join(homedir(), '.config', 'atc');
+
+export const stateDir = join(homedir(), '.local', 'state', 'atc');
+export const socketPath = join(process.env['XDG_RUNTIME_DIR'] ?? stateDir, 'atc.sock');
+export const daemonSocketPath = join(process.env['XDG_RUNTIME_DIR'] ?? stateDir, 'atc-daemon.sock');
+export const statusFile = join(stateDir, 'status.json');
+export const dbFile = join(stateDir, 'atc.db');
+export const legacyFleetFile = join(stateDir, 'fleet.json');
+export const daemonPidFile = join(process.env['XDG_RUNTIME_DIR'] ?? stateDir, 'atc-daemon.pid');
+
+export function loadConfig(): Config {
+  mkdirSync(configDir, { recursive: true });
+  mkdirSync(stateDir, { recursive: true });
+
+  const file = join(configDir, 'config.json');
+
+  if (!existsSync(file)) {
+    writeFileSync(file, `${JSON.stringify(DEFAULTS, null, 2)}\n`);
+
+    return { ...DEFAULTS };
+  }
+
+  try {
+    const raw = readFileSync(file, 'utf8');
+    const parsed: unknown = JSON.parse(raw);
+
+    if (!isRecord(parsed)) {
+      return { ...DEFAULTS };
+    }
+
+    const claudeBin =
+      typeof parsed['claudeBin'] === 'string' ? parsed['claudeBin'] : DEFAULTS.claudeBin;
+
+    const claudeArgs = Array.isArray(parsed['claudeArgs'])
+      ? parsed['claudeArgs'].filter((a): a is string => typeof a === 'string')
+      : DEFAULTS.claudeArgs;
+
+    return { claudeBin, claudeArgs };
+  } catch {
+    return { ...DEFAULTS };
+  }
+}

package/src/daemon-client.ts

@@ -0,0 +1,131 @@
+import { DaemonError } from './daemon-error';
+import { OutboundQueue } from './outbound-queue';
+import { PROTOCOL_V, decodeMessage, encodeMessage } from './protocol';
+import type { EventMsg, ResponseMsg } from './protocol';
+
+interface Pending {
+  readonly resolve: (ok: Readonly<Record<string, unknown>>) => void;
+  readonly reject: (err: Readonly<DaemonError>) => void;
+}
+
+/**
+ * A protocol connection to the daemon: correlated request/response plus an
+ * event callback. `open` connects the socket; `sendHello` completes the
+ * handshake and must come first.
+ */
+export class DaemonClient {
+  onEvent: (event: EventMsg) => void = () => {};
+
+  private queue: OutboundQueue | null = null;
+
+  private buffer = '';
+
+  private nextID = 1;
+
+  private readonly pending = new Map<number, Pending>();
+
+  private socket: { end: () => void } | null = null;
+
+  static async open(socketPath: string): Promise<DaemonClient> {
+    const client = new DaemonClient();
+
+    const socket = await Bun.connect({
+      unix: socketPath,
+      socket: {
+        data(_s, buf) {
+          client.applyChunk(buf.toString());
+        },
+        drain() {
+          client.queue?.drain();
+        },
+        close() {
+          client.drainPending('connection closed');
+        },
+        error() {},
+      },
+    });
+
+    client.socket = socket;
+
+    client.queue = new OutboundQueue(socket, 8 * 1024 * 1024);
+
+    return client;
+  }
+
+  sendHello(build: string): Promise<Readonly<Record<string, unknown>>> {
+    return this.sendRequest('daemon.hello', { client: build, auth: { scheme: 'none' } });
+  }
+
+  sendRequest(
+    m: string,
+    p?: Readonly<Record<string, unknown>>,
+  ): Promise<Readonly<Record<string, unknown>>> {
+    const id = this.nextID++;
+    const resolvers = Promise.withResolvers<Readonly<Record<string, unknown>>>();
+
+    this.pending.set(id, { resolve: resolvers.resolve, reject: resolvers.reject });
+    this.queue?.send(encodeMessage({ v: PROTOCOL_V, id, m, ...(p === undefined ? {} : { p }) }));
+
+    return resolvers.promise;
+  }
+
+  stop(): void {
+    this.socket?.end();
+    this.drainPending('client closed');
+  }
+
+  private applyChunk(chunk: string): void {
+    this.buffer += chunk;
+
+    const lines = this.buffer.split('\n');
+
+    this.buffer = lines.pop() ?? '';
+
+    for (const line of lines) {
+      if (line.trim() === '') {
+        continue;
+      }
+
+      this.applyLine(line);
+    }
+  }
+
+  private applyLine(line: string): void {
+    const decoded = decodeMessage(line);
+
+    if (decoded.kind === 'event') {
+      this.onEvent(decoded.msg);
+
+      return;
+    }
+
+    if (decoded.kind !== 'response') {
+      return;
+    }
+
+    this.applyResponse(decoded.msg);
+  }
+
+  private applyResponse(msg: ResponseMsg): void {
+    const waiter = this.pending.get(msg.id);
+
+    if (waiter === undefined) {
+      return;
+    }
+
+    this.pending.delete(msg.id);
+
+    if (msg.err === undefined) {
+      waiter.resolve(msg.ok ?? {});
+    } else {
+      waiter.reject(new DaemonError(msg.err.code, msg.err.msg));
+    }
+  }
+
+  private drainPending(reason: string): void {
+    for (const [id, waiter] of this.pending) {
+      this.pending.delete(id);
+      waiter.reject(new DaemonError('internal', reason));
+    }
+  }
+}