@preziosiraffaele/agent-watch 0.2.0

package/dist/aw.js

@@ -0,0 +1,780 @@
+// @bun
+// packages/agent-core/src/protocol.ts
+var DEFAULT_DAEMON_HOST = "127.0.0.1";
+var DEFAULT_DAEMON_PORT = 3847;
+var DEFAULT_DAEMON_URL = `http://${DEFAULT_DAEMON_HOST}:${DEFAULT_DAEMON_PORT}`;
+var ENV = {
+  LAUNCH_ID: "AGENT_WATCH_LAUNCH_ID",
+  DAEMON_URL: "AGENT_WATCH_DAEMON_URL",
+  DAEMON_PORT: "AGENT_WATCH_DAEMON_PORT",
+  DAEMON_HOST: "AGENT_WATCH_DAEMON_HOST"
+};
+var SUPPORTED_AGENTS = ["claude", "codex", "agent"];
+function isSupportedAgent(name) {
+  return SUPPORTED_AGENTS.includes(name);
+}
+function daemonUrlFromEnv(env) {
+  const direct = env[ENV.DAEMON_URL];
+  if (direct)
+    return direct;
+  const port = env[ENV.DAEMON_PORT] ?? String(DEFAULT_DAEMON_PORT);
+  const host = env[ENV.DAEMON_HOST] ?? DEFAULT_DAEMON_HOST;
+  return `http://${host}:${port}`;
+}
+// packages/agent-core/src/states.ts
+var STATES = {
+  SESSION_STARTED: "session_started",
+  WORKING: "working",
+  RUNNING_TOOL: "running_tool",
+  RUNNING_SHELL: "running_shell",
+  NEEDS_APPROVAL: "needs_approval",
+  EDITED_FILE: "edited_file",
+  WAITING: "waiting",
+  IDLE: "idle",
+  STALE: "stale",
+  EXITED: "exited",
+  FAILED: "failed"
+};
+var STALE_AFTER_MS = 30 * 60 * 1000;
+// packages/agent-core/src/events.ts
+var CLAUDE_STATE = {
+  SessionStart: STATES.SESSION_STARTED,
+  UserPromptSubmit: STATES.WORKING,
+  UserPromptExpansion: STATES.WORKING,
+  PreToolUse: STATES.RUNNING_TOOL,
+  PermissionRequest: STATES.NEEDS_APPROVAL,
+  PermissionDenied: STATES.WORKING,
+  PostToolUse: STATES.WORKING,
+  PostToolUseFailure: STATES.WORKING,
+  PostToolBatch: STATES.WORKING,
+  Notification: STATES.WAITING,
+  SubagentStart: STATES.RUNNING_TOOL,
+  SubagentStop: STATES.IDLE,
+  TaskCreated: STATES.RUNNING_TOOL,
+  TaskCompleted: STATES.WORKING,
+  Stop: STATES.IDLE,
+  StopFailure: STATES.IDLE,
+  SessionEnd: STATES.IDLE
+};
+var CODEX_STATE = {
+  SessionStart: STATES.SESSION_STARTED,
+  UserPromptSubmit: STATES.WORKING,
+  PreToolUse: STATES.RUNNING_TOOL,
+  PermissionRequest: STATES.NEEDS_APPROVAL,
+  PostToolUse: STATES.WORKING,
+  Stop: STATES.IDLE
+};
+var AGENT_STATE = {
+  sessionStart: STATES.SESSION_STARTED,
+  beforeSubmitPrompt: STATES.WORKING,
+  preToolUse: STATES.RUNNING_TOOL,
+  beforeShellExecution: STATES.RUNNING_SHELL,
+  afterShellExecution: STATES.WORKING,
+  beforeMCPExecution: STATES.RUNNING_TOOL,
+  afterMCPExecution: STATES.WORKING,
+  beforeReadFile: STATES.RUNNING_TOOL,
+  afterFileEdit: STATES.EDITED_FILE,
+  postToolUse: STATES.WORKING,
+  postToolUseFailure: STATES.WORKING,
+  subagentStart: STATES.RUNNING_TOOL,
+  subagentStop: STATES.WORKING,
+  stop: STATES.IDLE,
+  sessionEnd: STATES.IDLE
+};
+var CLAUDE_EVENTS = Object.keys(CLAUDE_STATE);
+var CODEX_EVENTS = Object.keys(CODEX_STATE);
+var AGENT_EVENTS = Object.keys(AGENT_STATE);
+// packages/agent-core/src/daemon-state.ts
+import { mkdirSync, readFileSync, renameSync, rmSync, writeFileSync } from "fs";
+import { homedir } from "os";
+import { dirname, join } from "path";
+var DAEMON_STATE_VERSION = 1;
+var DAEMON_RUNTIME_DIR_NAME = ".agent-watch";
+var DAEMON_STATE_FILE_NAME = "daemon.json";
+function daemonRuntimeDir(home = homedir()) {
+  return join(home, DAEMON_RUNTIME_DIR_NAME);
+}
+function daemonStatePath(runtimeDir = daemonRuntimeDir()) {
+  return join(runtimeDir, DAEMON_STATE_FILE_NAME);
+}
+function readDaemonState(path = daemonStatePath()) {
+  try {
+    const parsed = JSON.parse(readFileSync(path, "utf8"));
+    return parseDaemonState(parsed);
+  } catch {
+    return null;
+  }
+}
+function parseDaemonState(value) {
+  if (!value || typeof value !== "object" || Array.isArray(value))
+    return null;
+  const data = value;
+  if (data.version !== DAEMON_STATE_VERSION)
+    return null;
+  if (typeof data.url !== "string" || !data.url)
+    return null;
+  if (typeof data.pid !== "number" || !Number.isInteger(data.pid) || data.pid <= 0)
+    return null;
+  if (typeof data.started_at !== "string" || !data.started_at)
+    return null;
+  return {
+    version: DAEMON_STATE_VERSION,
+    url: data.url,
+    pid: data.pid,
+    started_at: data.started_at
+  };
+}
+// packages/aw/src/commands/launch.ts
+import { spawn as spawn2 } from "child_process";
+
+// packages/aw/src/daemon.ts
+import { spawn } from "child_process";
+import { mkdirSync as mkdirSync2, existsSync, openSync } from "fs";
+import { join as join2, resolve } from "path";
+function createDaemonClient(url) {
+  const post = async (path, body) => {
+    const response = await fetch(`${url}${path}`, {
+      method: "POST",
+      headers: { "content-type": "application/json" },
+      body: JSON.stringify(body)
+    });
+    if (!response.ok)
+      throw new Error(`POST ${path} failed: ${response.status}`);
+    return await response.json();
+  };
+  return {
+    url,
+    async registerLaunch(reg) {
+      const body = {
+        agent: reg.agent,
+        folder: reg.folder,
+        title: reg.title ?? null,
+        nvim_server: reg.nvim?.server ?? null,
+        nvim_terminal_bufnr: reg.nvim?.terminalBufnr ?? null
+      };
+      return post("/launches", body);
+    },
+    async updateLaunch(id, patch) {
+      const response = await fetch(`${url}/launches/${id}`, {
+        method: "PATCH",
+        headers: { "content-type": "application/json" },
+        body: JSON.stringify(patch)
+      });
+      if (response.status === 404)
+        return null;
+      if (!response.ok)
+        throw new Error(`PATCH /launches/${id} failed: ${response.status}`);
+      return await response.json();
+    },
+    async deleteLaunch(id) {
+      const response = await fetch(`${url}/launches/${id}`, { method: "DELETE" });
+      if (response.status === 404)
+        return false;
+      if (!response.ok)
+        throw new Error(`DELETE /launches/${id} failed: ${response.status}`);
+      return true;
+    },
+    async listAgents(filters) {
+      const qs = filters ? new URLSearchParams(filters).toString() : "";
+      const response = await fetch(`${url}/agents${qs ? `?${qs}` : ""}`);
+      if (!response.ok)
+        throw new Error(`GET /agents failed: ${response.status}`);
+      const body = await response.json();
+      return body.agents;
+    },
+    async health() {
+      try {
+        const response = await fetch(`${url}/healthz`);
+        return response.ok;
+      } catch {
+        return false;
+      }
+    },
+    async shutdown() {
+      try {
+        const response = await fetch(`${url}/shutdown`, { method: "POST" });
+        return response.ok;
+      } catch {
+        return false;
+      }
+    }
+  };
+}
+async function ensureDaemonRunning(options = {}) {
+  const candidate = await findHealthyDaemon(options);
+  if (candidate)
+    return candidate;
+  const url = options.url ?? daemonUrlFromEnv(process.env);
+  const client = createDaemonClient(url);
+  spawnDaemon(options.daemonBin, options.runtimeDir);
+  const deadline = Date.now() + (options.startTimeoutMs ?? 5000);
+  while (Date.now() < deadline) {
+    if (await client.health())
+      return client;
+    await new Promise((resolve2) => setTimeout(resolve2, 100));
+  }
+  throw new Error(`Could not start agent-watchd on ${url}`);
+}
+async function findHealthyDaemon(options) {
+  const explicitUrl = options.url ?? process.env[ENV.DAEMON_URL];
+  if (explicitUrl) {
+    const client = createDaemonClient(explicitUrl);
+    if (await client.health())
+      return client;
+  }
+  const state = readDaemonState(options.statePath ?? daemonStatePath());
+  if (state) {
+    const client = createDaemonClient(state.url);
+    if (await client.health())
+      return client;
+  }
+  const defaultUrl = daemonUrlFromEnv(process.env);
+  if (defaultUrl !== explicitUrl) {
+    const client = createDaemonClient(defaultUrl);
+    if (await client.health())
+      return client;
+  }
+  return null;
+}
+function spawnDaemon(daemonEntryPath, runtimeDir = daemonRuntimeDir()) {
+  mkdirSync2(runtimeDir, { recursive: true });
+  const entry = daemonEntryPath ?? resolveDaemonEntry();
+  const log = openSync(join2(runtimeDir, "agent-watchd.log"), "a");
+  const child = spawn(process.execPath, [entry], {
+    detached: true,
+    stdio: ["ignore", log, log],
+    env: process.env
+  });
+  child.unref();
+}
+function resolveDaemonEntry() {
+  const fromPackage = resolve(import.meta.dir, "..", "..", "agent-watchd", "src", "index.ts");
+  if (existsSync(fromPackage))
+    return fromPackage;
+  const fromBin = resolve(import.meta.dir, "..", "..", "..", "bin", "agent-watchd");
+  if (existsSync(fromBin))
+    return fromBin;
+  const fromPath = Bun.which("agent-watchd");
+  if (fromPath)
+    return fromPath;
+  throw new Error("Could not locate agent-watchd entrypoint");
+}
+
+// packages/aw/src/nvim.ts
+function nvimContextFromEnv(env) {
+  return {
+    server: env.NVIM ?? null,
+    terminalBufnr: null
+  };
+}
+function mergeNvim(base, override) {
+  return {
+    server: override.server ?? base.server,
+    terminalBufnr: override.terminalBufnr ?? base.terminalBufnr
+  };
+}
+
+// packages/aw/src/commands/launch.ts
+function parseLaunchArgv(argv) {
+  const rest = [];
+  let title = null;
+  let nvimServer = null;
+  let nvimBufnr = null;
+  let separatorSeen = false;
+  for (let i = 0;i < argv.length; i++) {
+    const arg = argv[i] ?? "";
+    if (separatorSeen) {
+      rest.push(arg);
+      continue;
+    }
+    if (arg === "--") {
+      separatorSeen = true;
+      continue;
+    }
+    if (arg === "--title") {
+      title = argv[++i] ?? "";
+      continue;
+    }
+    if (arg.startsWith("--title=")) {
+      title = arg.slice("--title=".length);
+      continue;
+    }
+    if (arg === "--nvim-server") {
+      nvimServer = argv[++i] ?? "";
+      continue;
+    }
+    if (arg.startsWith("--nvim-server=")) {
+      nvimServer = arg.slice("--nvim-server=".length);
+      continue;
+    }
+    if (arg === "--nvim-bufnr") {
+      nvimBufnr = argv[++i] ?? "";
+      continue;
+    }
+    if (arg.startsWith("--nvim-bufnr=")) {
+      nvimBufnr = arg.slice("--nvim-bufnr=".length);
+      continue;
+    }
+    rest.push(arg);
+  }
+  return {
+    title: title || null,
+    nvim: { server: nvimServer, terminalBufnr: nvimBufnr },
+    rest
+  };
+}
+async function runLaunch(args) {
+  const parsed = parseLaunchArgv(args.argv);
+  const executable = Bun.which(args.agent);
+  if (!executable) {
+    process.stderr.write(`Could not find ${args.agent} on PATH.
+`);
+    return 1;
+  }
+  const client = await ensureDaemonRunning();
+  const baseNvim = nvimContextFromEnv(process.env);
+  const nvim = mergeNvim(baseNvim, parsed.nvim);
+  const record = await client.registerLaunch({
+    agent: args.agent,
+    folder: process.cwd(),
+    title: parsed.title,
+    nvim
+  });
+  const env = { ...process.env };
+  env[ENV.LAUNCH_ID] = String(record.id);
+  env[ENV.DAEMON_URL] = client.url;
+  const child = spawn2(executable, parsed.rest, { stdio: "inherit", env });
+  const cleanupSignals = ["SIGINT", "SIGTERM", "SIGHUP"];
+  for (const signal of cleanupSignals) {
+    process.on(signal, () => {
+      if (!child.killed)
+        child.kill(signal);
+    });
+  }
+  if (typeof child.pid === "number") {
+    client.updateLaunch(record.id, { agent_process_pid: child.pid }).catch(() => {
+      return;
+    });
+  }
+  return await new Promise((resolve2) => {
+    child.on("exit", (code, signal) => {
+      const exitCode = signal ? 128 + signalNumber(signal) : code ?? 0;
+      client.deleteLaunch(record.id).catch(() => {
+        return;
+      }).finally(() => resolve2(exitCode));
+    });
+    child.on("error", (err) => {
+      process.stderr.write(`Could not launch ${args.agent}: ${err.message}
+`);
+      client.deleteLaunch(record.id).catch(() => {
+        return;
+      }).finally(() => resolve2(1));
+    });
+  });
+}
+function signalNumber(signal) {
+  const map = { SIGHUP: 1, SIGINT: 2, SIGTERM: 15 };
+  return map[signal] ?? 0;
+}
+
+// packages/aw/src/render.ts
+import { homedir as homedir2 } from "os";
+var HOME = homedir2();
+var COLUMNS = {
+  id: {
+    label: "ID",
+    width: 5,
+    value: (row) => String(row.id)
+  },
+  agent: {
+    label: "AGENT",
+    width: 8,
+    value: (row) => trunc(row.agent || "-", 7)
+  },
+  state: {
+    label: "STATE",
+    width: 16,
+    colorState: true,
+    value: (row) => row.state || "-"
+  },
+  title: {
+    label: "TITLE",
+    width: 22,
+    value: (row) => trunc(row.title || "-", 21)
+  },
+  repo: {
+    label: "REPO",
+    width: 18,
+    value: (row) => trunc(row.repo || "-", 17)
+  },
+  branch: {
+    label: "BRANCH",
+    width: 18,
+    value: (row) => trunc(row.branch || "-", 17)
+  },
+  folder: {
+    label: "FOLDER",
+    width: 24,
+    dynamic: true,
+    value: (row, width) => trunc(shortHome(row.folder || "-"), width)
+  }
+};
+var STATE_COLORS = {
+  idle: 32,
+  working: 36,
+  running_tool: 33,
+  running_shell: 33,
+  needs_approval: 31,
+  edited_file: 35,
+  session_started: 34,
+  waiting: 36,
+  stale: 90,
+  exited: 90,
+  failed: 31
+};
+var DEFAULT_COLUMNS = ["id", "agent", "state", "title", "repo", "branch", "folder"];
+function renderTable(records, options) {
+  const columns = options.columns ?? DEFAULT_COLUMNS;
+  const dynamicColumn = columns.find((name) => COLUMNS[name]?.dynamic) ?? columns[columns.length - 1];
+  const fixedWidth = columns.filter((name) => name !== dynamicColumn).reduce((total, name) => total + (COLUMNS[name]?.width ?? 0), 0);
+  const dynamicWidth = Math.max(12, options.width - fixedWidth - 5);
+  const widths = new Map;
+  for (const name of columns) {
+    widths.set(name, name === dynamicColumn ? dynamicWidth : COLUMNS[name]?.width ?? 0);
+  }
+  const lines = [];
+  lines.push(columns.map((name) => {
+    const width = widths.get(name) ?? 0;
+    const def = COLUMNS[name];
+    return name === dynamicColumn ? trunc(def?.label ?? name, width) : pad(def?.label ?? name, width);
+  }).join(""));
+  if (records.length === 0) {
+    lines.push("(no agent sessions found)");
+  } else {
+    for (const row of records) {
+      lines.push(columns.map((name) => {
+        const width = widths.get(name) ?? 0;
+        const def = COLUMNS[name];
+        if (!def)
+          return pad("-", width);
+        const raw = def.value(row, width);
+        if (def.colorState && options.color) {
+          const colored = colorize(raw);
+          return pad(colored, width, raw.length);
+        }
+        return name === dynamicColumn ? trunc(raw, width) : pad(raw, width);
+      }).join(""));
+    }
+  }
+  return `${lines.join(`
+`)}
+`;
+}
+function colorize(state) {
+  const code = STATE_COLORS[state] ?? 37;
+  return `\x1B[${code}m${state}\x1B[0m`;
+}
+function trunc(value, width) {
+  if (value.length <= width)
+    return value;
+  if (width <= 3)
+    return value.slice(0, width);
+  return `${value.slice(0, width - 3)}...`;
+}
+function pad(value, width, visibleLength) {
+  const length = visibleLength ?? value.length;
+  if (length >= width)
+    return value;
+  return value + " ".repeat(width - length);
+}
+function shortHome(value) {
+  if (HOME && value.startsWith(HOME))
+    return `~${value.slice(HOME.length)}`;
+  return value;
+}
+
+// packages/aw/src/commands/stream.ts
+var FOOTER = `
+Press Ctrl+C to exit.
+`;
+async function runStream() {
+  const client = await ensureDaemonRunning();
+  let stop = false;
+  process.on("SIGINT", () => {
+    stop = true;
+    process.stdout.write(`
+`);
+    process.exit(0);
+  });
+  while (!stop) {
+    let records;
+    try {
+      records = await client.listAgents();
+    } catch (err) {
+      process.stderr.write(`Could not reach daemon: ${err.message}
+`);
+      return 1;
+    }
+    process.stdout.write("\x1B[2J\x1B[H");
+    process.stdout.write(renderTable(records, {
+      color: process.stdout.isTTY ?? false,
+      width: process.stdout.columns ?? 100
+    }));
+    process.stdout.write(FOOTER);
+    await new Promise((resolve2) => setTimeout(resolve2, 1000));
+  }
+  return 0;
+}
+
+// packages/aw/src/commands/hooks.ts
+import { homedir as homedir3 } from "os";
+import { join as join3 } from "path";
+
+// packages/aw/src/config-patch/claude.ts
+import { mkdirSync as mkdirSync3, readFileSync as readFileSync2, writeFileSync as writeFileSync2, copyFileSync, existsSync as existsSync2 } from "fs";
+import { dirname as dirname2 } from "path";
+function patchClaudeSettings(file) {
+  mkdirSync3(dirname2(file), { recursive: true });
+  const backup = `${file}.agent-watch.bak`;
+  if (existsSync2(file) && !existsSync2(backup))
+    copyFileSync(file, backup);
+  const parsed = readSettings(file);
+  parsed.hooks ??= {};
+  for (const event of CLAUDE_EVENTS) {
+    const command = curlCommand("claude", event);
+    const groups = parsed.hooks[event] ?? [];
+    const filtered = groups.filter((group) => !groupHasAgentWatch(group));
+    filtered.push({ hooks: [{ type: "command", command }] });
+    parsed.hooks[event] = filtered;
+  }
+  writeFileSync2(file, `${JSON.stringify(parsed, null, 2)}
+`);
+}
+function readSettings(file) {
+  if (!existsSync2(file))
+    return {};
+  try {
+    const data = JSON.parse(readFileSync2(file, "utf8"));
+    if (data && typeof data === "object" && !Array.isArray(data)) {
+      return data;
+    }
+    return {};
+  } catch {
+    return {};
+  }
+}
+function groupHasAgentWatch(group) {
+  if (!Array.isArray(group?.hooks))
+    return false;
+  return group.hooks.some((hook) => {
+    const command = typeof hook?.command === "string" ? hook.command : "";
+    return command.includes("AGENT_WATCH_DAEMON_URL") || command.includes("agent-watch");
+  });
+}
+function curlCommand(provider, event) {
+  return [
+    "curl -sS -X POST",
+    `"$AGENT_WATCH_DAEMON_URL/hooks/${provider}?launch_id=$AGENT_WATCH_LAUNCH_ID&event=${event}"`,
+    "-H 'content-type: application/json'",
+    "--data-binary @-",
+    ">/dev/null || true"
+  ].join(" ");
+}
+
+// packages/aw/src/config-patch/codex.ts
+import { mkdirSync as mkdirSync4, readFileSync as readFileSync3, writeFileSync as writeFileSync3, copyFileSync as copyFileSync2, existsSync as existsSync3 } from "fs";
+import { dirname as dirname3 } from "path";
+var BEGIN = "# BEGIN agent-watch codex hooks";
+var END = "# END agent-watch codex hooks";
+function patchCodexConfig(file) {
+  mkdirSync4(dirname3(file), { recursive: true });
+  const backup = `${file}.agent-watch.bak`;
+  if (existsSync3(file) && !existsSync3(backup))
+    copyFileSync2(file, backup);
+  let content = existsSync3(file) ? readFileSync3(file, "utf8") : "";
+  content = ensureCodexFeatures(content);
+  content = removeManagedBlock(content).trimEnd();
+  content += `
+
+${BEGIN}
+${codexHookBlock()}
+${END}
+`;
+  writeFileSync3(file, content);
+}
+function ensureCodexFeatures(content) {
+  if (/^\s*\[features\]/m.test(content)) {
+    if (/^\s*codex_hooks\s*=/m.test(content)) {
+      return content.replace(/^\s*codex_hooks\s*=.*$/m, "codex_hooks = true");
+    }
+    return content.replace(/^\s*\[features\]\s*$/m, `[features]
+codex_hooks = true`);
+  }
+  return `[features]
+codex_hooks = true
+
+${content}`;
+}
+function removeManagedBlock(content) {
+  const escapedBegin = BEGIN.replace(/[.*+?^${}()|[\]\\]/g, "\\$&");
+  const escapedEnd = END.replace(/[.*+?^${}()|[\]\\]/g, "\\$&");
+  return content.replace(new RegExp(`\\n?${escapedBegin}[\\s\\S]*?${escapedEnd}\\n?`, "g"), `
+`);
+}
+function codexHookBlock() {
+  return CODEX_EVENTS.map((event) => {
+    const matcher = event === "PreToolUse" || event === "PermissionRequest" || event === "PostToolUse" ? `matcher = "*"
+` : "";
+    const command = curlCommand("codex", event);
+    return `[[hooks.${event}]]
+${matcher}hooks = [{ type = "command", command = ${quote(command)} }]`;
+  }).join(`
+
+`);
+}
+function quote(value) {
+  return `"${value.replace(/\\/g, "\\\\").replace(/"/g, "\\\"")}"`;
+}
+
+// packages/aw/src/config-patch/agent.ts
+import { mkdirSync as mkdirSync5, readFileSync as readFileSync4, writeFileSync as writeFileSync4, copyFileSync as copyFileSync3, existsSync as existsSync4 } from "fs";
+import { dirname as dirname4 } from "path";
+function patchAgentHooks(file) {
+  mkdirSync5(dirname4(file), { recursive: true });
+  const backup = `${file}.agent-watch.bak`;
+  if (existsSync4(file) && !existsSync4(backup))
+    copyFileSync3(file, backup);
+  const parsed = readHooks(file);
+  parsed.version = 1;
+  parsed.hooks ??= {};
+  for (const event of AGENT_EVENTS) {
+    const command = curlCommand("agent", event);
+    const entries = parsed.hooks[event] ?? [];
+    const filtered = entries.filter((hook) => !isAgentWatchHook(hook));
+    filtered.push({ command });
+    parsed.hooks[event] = filtered;
+  }
+  writeFileSync4(file, `${JSON.stringify(parsed, null, 2)}
+`);
+}
+function readHooks(file) {
+  if (!existsSync4(file))
+    return {};
+  try {
+    const parsed = JSON.parse(readFileSync4(file, "utf8"));
+    if (parsed && typeof parsed === "object" && !Array.isArray(parsed)) {
+      return parsed;
+    }
+    return {};
+  } catch {
+    return {};
+  }
+}
+function isAgentWatchHook(hook) {
+  const command = typeof hook?.command === "string" ? hook.command : "";
+  return command.includes("AGENT_WATCH_DAEMON_URL") || command.includes("agent-watch");
+}
+
+// packages/aw/src/commands/hooks.ts
+var HOME2 = homedir3();
+function runHooksInstall(provider) {
+  if (provider === "claude") {
+    const file = join3(HOME2, ".claude", "settings.json");
+    patchClaudeSettings(file);
+    process.stdout.write(`Patched ${file}
+`);
+    return 0;
+  }
+  if (provider === "codex") {
+    const file = join3(HOME2, ".codex", "config.toml");
+    patchCodexConfig(file);
+    process.stdout.write(`Patched ${file}
+`);
+    return 0;
+  }
+  if (provider === "agent") {
+    const file = join3(HOME2, ".cursor", "hooks.json");
+    patchAgentHooks(file);
+    process.stdout.write(`Patched ${file}
+`);
+    return 0;
+  }
+  process.stderr.write(`Unknown provider: ${provider}
+`);
+  return 1;
+}
+
+// packages/aw/src/commands/stop.ts
+async function runStop() {
+  const url = daemonUrlFromEnv(process.env);
+  const client = createDaemonClient(url);
+  if (!await client.health()) {
+    process.stdout.write(`agent-watchd is not running
+`);
+    return 0;
+  }
+  await client.shutdown();
+  if (await waitUntilStopped(client, 5000)) {
+    process.stdout.write(`agent-watchd stopped
+`);
+    return 0;
+  }
+  process.stderr.write(`Timed out waiting for agent-watchd to stop
+`);
+  return 1;
+}
+async function waitUntilStopped(client, timeoutMs) {
+  const deadline = Date.now() + timeoutMs;
+  while (Date.now() < deadline) {
+    if (!await client.health()) {
+      return true;
+    }
+    await new Promise((resolve2) => setTimeout(resolve2, 100));
+  }
+  return false;
+}
+
+// packages/aw/src/index.ts
+var HELP = `aw \u2014 launcher and live view for terminal AI coding agents.
+
+Usage:
+  aw claude [--title <title>] [--nvim-server <addr>] [--nvim-bufnr <nr>] [-- claude args...]
+  aw codex  [--title <title>] [--nvim-server <addr>] [--nvim-bufnr <nr>] [-- codex args...]
+  aw agent  [--title <title>] [--nvim-server <addr>] [--nvim-bufnr <nr>] [-- agent args...]
+  aw stream
+  aw stop
+  aw hooks install <claude|codex|agent>
+  aw help
+`;
+async function main(argv) {
+  const [command, ...rest] = argv;
+  if (!command || command === "help" || command === "--help" || command === "-h") {
+    process.stdout.write(HELP);
+    return 0;
+  }
+  if (isSupportedAgent(command)) {
+    return runLaunch({ agent: command, argv: rest });
+  }
+  if (command === "stream") {
+    return runStream();
+  }
+  if (command === "stop") {
+    return runStop();
+  }
+  if (command === "hooks") {
+    const [sub, provider] = rest;
+    if (sub !== "install" || !provider) {
+      process.stderr.write(`Usage: aw hooks install <claude|codex|cursor>
+`);
+      return 1;
+    }
+    return runHooksInstall(provider);
+  }
+  process.stderr.write(`Unknown command: ${command}
+
+${HELP}`);
+  return 1;
+}
+export {
+  main
+};