@zgeoff/atc 0.1.0

package/src/get-build.ts

@@ -0,0 +1,32 @@
+import { readdirSync, statSync } from 'node:fs';
+import { join } from 'node:path';
+import pkg from '../package.json';
+
+/**
+ * The build identity used in the protocol handshake. The version alone
+ * never changes between pulls, so the newest mtime across the source tree
+ * (or the compiled binary's) is folded in — a client and daemon from
+ * different checkouts of the same version still read as different builds,
+ * which is what triggers the stale-daemon restart. Any source file counts:
+ * a stamp taken from a single file misses every change that lands
+ * elsewhere and leaves stale daemons in service.
+ */
+export function getBuild(): string {
+  let stamp = 0;
+
+  try {
+    for (const entry of readdirSync(import.meta.dir)) {
+      if (entry.endsWith('.ts')) {
+        stamp = Math.max(stamp, statSync(join(import.meta.dir, entry)).mtimeMs);
+      }
+    }
+  } catch {}
+
+  if (stamp === 0) {
+    try {
+      stamp = statSync(process.execPath).mtimeMs;
+    } catch {}
+  }
+
+  return `atc/${pkg.version}+${Math.round(stamp).toString(36)}`;
+}

package/src/hook-report.ts

@@ -0,0 +1,31 @@
+import { isRecord, sendReport } from './report';
+
+/**
+ * Runs as a Claude Code hook inside wrangled sessions. Reads the hook event
+ * from stdin and forwards it to the atc unix socket. Always exits 0 so it
+ * never blocks the session it reports on.
+ */
+export async function runHookReport(): Promise<void> {
+  const sock = process.env['ATC_SOCKET'];
+  const atcId = process.env['ATC_SESSION_ID'];
+
+  if (sock !== undefined && sock !== '' && atcId !== undefined && atcId !== '') {
+    const raw = await new Response(Bun.stdin.stream()).text();
+
+    let payload: Record<string, unknown> = {};
+
+    try {
+      const parsed: unknown = JSON.parse(raw);
+
+      if (isRecord(parsed)) {
+        payload = parsed;
+      }
+    } catch {}
+
+    const line = `${JSON.stringify({ atcId, event: payload['hook_event_name'], payload })}\n`;
+
+    await sendReport(sock, line, 2000);
+  }
+
+  process.exit(0);
+}

package/src/hooks.ts

@@ -0,0 +1,54 @@
+import { unlinkSync } from 'node:fs';
+import { socketPath } from './config';
+import { isRecord } from './report';
+
+export interface HookEvent {
+  atcId: string;
+  event: string;
+  payload: Record<string, unknown>;
+}
+
+export function startHookServer(onEvent: (e: HookEvent) => void, path: string = socketPath) {
+  try {
+    unlinkSync(path);
+  } catch {}
+
+  return Bun.listen<string>({
+    unix: path,
+    socket: {
+      data(socket, buf) {
+        const buffered = (socket.data ?? '') + buf.toString();
+        const lines = buffered.split('\n');
+
+        socket.data = lines.pop() ?? '';
+
+        for (const line of lines) {
+          if (line.trim() === '') {
+            continue;
+          }
+
+          try {
+            const parsed: unknown = JSON.parse(line);
+
+            if (
+              isRecord(parsed) &&
+              typeof parsed['atcId'] === 'string' &&
+              typeof parsed['event'] === 'string' &&
+              isRecord(parsed['payload'])
+            ) {
+              onEvent({
+                atcId: parsed['atcId'],
+                event: parsed['event'],
+                payload: parsed['payload'],
+              });
+            }
+          } catch {}
+        }
+      },
+      open(socket) {
+        socket.data = '';
+      },
+      error() {},
+    },
+  });
+}