@zgeoff/atc 1.0.3 → 2.1.0

package/src/shared/collect-hooks.ts

@@ -0,0 +1,90 @@
+import { homedir } from 'node:os';
+import { z } from 'zod';
+import { isRecord } from './report';
+
+/**
+ * One configured hook: a shell command the daemon runs when the named wire
+ * event broadcasts. `dir` narrows it to sessions whose repo root or working
+ * directory sits at or under that path; `timeout` caps the run in
+ * milliseconds before the process is killed.
+ */
+export interface HookEntry {
+  readonly command: string;
+  readonly dir?: string;
+  readonly timeout?: number;
+}
+
+export type HooksConfig = Readonly<Record<string, readonly HookEntry[]>>;
+
+// One hook entry's keys. A wrong-typed optional field parses to undefined
+// rather than failing the entry, so a hook with one bad field still runs
+// with the default for it.
+const HOOK_ENTRY_SCHEMA = z.object({
+  command: buildOptionalNonEmptyString(),
+  dir: buildOptionalNonEmptyString(),
+  timeout: buildOptionalPositiveNumber(),
+});
+
+/**
+ * Reads the hooks map, keyed by wire-event name. An entry without a command
+ * is left out; an event name with no valid entries is dropped. Unknown event
+ * names are kept as written — they never fire, and a future daemon that
+ * emits them starts firing without a config change. A `dir` is stored with
+ * `~` expanded and trailing slashes trimmed, ready for path matching.
+ */
+export function collectHooks(raw: unknown): HooksConfig {
+  if (!isRecord(raw)) {
+    return {};
+  }
+
+  const hooks: Record<string, readonly HookEntry[]> = {};
+
+  for (const [event, value] of Object.entries(raw)) {
+    if (event === '' || !Array.isArray(value)) {
+      continue;
+    }
+
+    const entries: HookEntry[] = [];
+
+    for (const item of value) {
+      const parsed = HOOK_ENTRY_SCHEMA.safeParse(item);
+
+      if (!parsed.success || parsed.data.command === undefined) {
+        continue;
+      }
+
+      entries.push({
+        command: parsed.data.command,
+        ...(parsed.data.dir === undefined ? {} : { dir: normalizeHookDir(parsed.data.dir) }),
+        ...(parsed.data.timeout === undefined ? {} : { timeout: parsed.data.timeout }),
+      });
+    }
+
+    if (entries.length > 0) {
+      hooks[event] = entries;
+    }
+  }
+
+  return hooks;
+}
+
+function normalizeHookDir(dir: string): string {
+  const expanded = dir === '~' ? homedir() : dir.replace(/^~\//u, `${homedir()}/`);
+  const trimmed = expanded.replace(/\/+$/u, '');
+
+  return trimmed === '' ? '/' : trimmed;
+}
+
+function buildOptionalNonEmptyString() {
+  return z.preprocess(
+    (v) => (typeof v === 'string' && v !== '' ? v : undefined),
+    z.string().optional(),
+  );
+}
+
+function buildOptionalPositiveNumber() {
+  return z.preprocess(
+    (v) => (typeof v === 'number' && Number.isFinite(v) && v > 0 ? v : undefined),
+    z.number().optional(),
+  );
+}

package/src/shared/config.ts

@@ -6,6 +6,8 @@ import { buildOptionalString } from './build-optional-string';
 import { buildOptionalStringArray } from './build-optional-string-array';
 import { collectGateways } from './collect-gateways';
 import type { GatewayConfig } from './collect-gateways';
+import { collectHooks } from './collect-hooks';
+import type { HooksConfig } from './collect-hooks';
 
 export interface Config {
   claudeBin: string;
@@ -15,6 +17,7 @@ export interface Config {
   codexBin: string;
   codexArgs: string[];
   gateways: GatewayConfig[];
+  hooks: HooksConfig;
   leader: LeaderKey;
 }
 
@@ -31,6 +34,7 @@ const DEFAULTS: Config = {
   codexBin: 'codex',
   codexArgs: [],
   gateways: [],
+  hooks: {},
   leader: { code: 0, label: '^Space' },
 };
 
@@ -39,6 +43,7 @@ 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 eventsSocketPath = join(process.env['XDG_RUNTIME_DIR'] ?? stateDir, 'atc-events.sock');
 export const statusFile = join(stateDir, 'status.json');
 export const dbFile = join(stateDir, 'atc.db');
 export const legacyFleetFile = join(stateDir, 'fleet.json');
@@ -55,6 +60,7 @@ const CONFIG_SCHEMA = z.object({
   codexBin: buildOptionalString(),
   codexArgs: buildOptionalStringArray(),
   gateways: z.unknown().optional(),
+  hooks: z.unknown().optional(),
   leader: buildOptionalString(),
 });
 
@@ -97,11 +103,12 @@ export function parseConfig(raw: unknown): Config {
   const codexBin = parsed.data.codexBin ?? DEFAULTS.codexBin;
   const codexArgs = parsed.data.codexArgs ?? DEFAULTS.codexArgs;
   const gateways = collectGateways(parsed.data.gateways, claudeBin, claudeArgs);
+  const hooks = collectHooks(parsed.data.hooks);
 
   const leader =
     (parsed.data.leader === undefined ? null : decodeLeader(parsed.data.leader)) ?? DEFAULTS.leader;
 
-  return { claudeBin, claudeArgs, grokBin, grokArgs, codexBin, codexArgs, gateways, leader };
+  return { claudeBin, claudeArgs, grokBin, grokArgs, codexBin, codexArgs, gateways, hooks, leader };
 }
 
 // Control bytes the terminal needs for its own input: enter, tab, and esc