@misha_misha/agentwatch 0.0.1

package/dist/index.js

@@ -0,0 +1,1210 @@
+#!/usr/bin/env node
+import {
+  detectAgents
+} from "./chunk-LF76VUCL.js";
+import {
+  claudeProjectsDir,
+  detectWorkspaceRoot
+} from "./chunk-EMMMIDXY.js";
+
+// src/index.tsx
+import { render } from "ink";
+
+// src/ui/App.tsx
+import { useEffect, useReducer, useState } from "react";
+import { Box as Box5, Text as Text5, useApp, useInput } from "ink";
+
+// src/ui/Timeline.tsx
+import { Box, Text } from "ink";
+import { jsx, jsxs } from "react/jsx-runtime";
+function Timeline({ events }) {
+  const header = /* @__PURE__ */ jsx(Box, { children: /* @__PURE__ */ jsxs(Text, { bold: true, dimColor: true, children: [
+    "TIME     ",
+    pad("AGENT", 10),
+    " ",
+    pad("TYPE", 13),
+    " ",
+    "EVENT"
+  ] }) });
+  if (events.length === 0) {
+    return /* @__PURE__ */ jsxs(Box, { flexDirection: "column", children: [
+      header,
+      /* @__PURE__ */ jsx(Box, { marginTop: 1, children: /* @__PURE__ */ jsx(Text, { dimColor: true, children: "waiting for activity\u2026 use Claude Code or edit a file in your workspace" }) })
+    ] });
+  }
+  const visible = events.slice(0, 40);
+  return /* @__PURE__ */ jsxs(Box, { flexDirection: "column", children: [
+    header,
+    visible.map((e) => /* @__PURE__ */ jsx(EventRow, { event: e }, e.id))
+  ] });
+}
+function EventRow({ event }) {
+  const time = event.ts.slice(11, 19);
+  const line = event.summary ?? event.path ?? event.cmd ?? event.tool ?? event.type;
+  return /* @__PURE__ */ jsx(Box, { children: /* @__PURE__ */ jsxs(Text, { wrap: "truncate", children: [
+    /* @__PURE__ */ jsxs(Text, { dimColor: true, children: [
+      time,
+      " "
+    ] }),
+    /* @__PURE__ */ jsxs(Text, { color: agentColor(event.agent), children: [
+      pad(event.agent, 10),
+      " "
+    ] }),
+    /* @__PURE__ */ jsxs(Text, { color: riskColor(event.riskScore), children: [
+      pad(event.type, 13),
+      " "
+    ] }),
+    /* @__PURE__ */ jsx(Text, { children: line })
+  ] }) });
+}
+function agentColor(a) {
+  switch (a) {
+    case "claude-code":
+      return "cyan";
+    case "codex":
+      return "green";
+    case "cursor":
+      return "magenta";
+    case "gemini":
+      return "blue";
+    case "openclaw":
+      return "yellow";
+    default:
+      return "gray";
+  }
+}
+function riskColor(r) {
+  if (r >= 8) return "red";
+  if (r >= 5) return "yellow";
+  if (r >= 3) return "white";
+  return "gray";
+}
+function pad(s, n) {
+  if (s.length >= n) return s.slice(0, n);
+  return s + " ".repeat(n - s.length);
+}
+
+// src/ui/AgentPanel.tsx
+import { Box as Box2, Text as Text2 } from "ink";
+import { jsx as jsx2, jsxs as jsxs2 } from "react/jsx-runtime";
+function AgentPanel({ agents, events }) {
+  return /* @__PURE__ */ jsxs2(Box2, { flexDirection: "column", borderStyle: "single", paddingX: 1, children: [
+    /* @__PURE__ */ jsx2(Text2, { bold: true, children: "Agents" }),
+    agents.map((a) => {
+      const count = events.filter((e) => e.agent === a.name).length;
+      const last = events.find((e) => e.agent === a.name);
+      return /* @__PURE__ */ jsxs2(Box2, { flexDirection: "column", marginTop: 1, children: [
+        /* @__PURE__ */ jsxs2(Text2, { color: a.present ? "green" : "gray", children: [
+          a.present ? "\u25CF" : "\u25CB",
+          " ",
+          a.label
+        ] }),
+        /* @__PURE__ */ jsxs2(Text2, { dimColor: true, children: [
+          "  ",
+          a.present ? "installed" : "not detected"
+        ] }),
+        a.present && /* @__PURE__ */ jsxs2(Text2, { dimColor: true, children: [
+          "  ",
+          "events: ",
+          count,
+          last ? `, last ${last.ts.slice(11, 19)}` : ""
+        ] })
+      ] }, a.name);
+    })
+  ] });
+}
+
+// src/ui/Header.tsx
+import { Box as Box3, Text as Text3 } from "ink";
+import { Fragment, jsx as jsx3, jsxs as jsxs3 } from "react/jsx-runtime";
+function Header({ workspace, eventCount, filter, paused }) {
+  return /* @__PURE__ */ jsxs3(Box3, { flexDirection: "row", justifyContent: "space-between", marginBottom: 1, children: [
+    /* @__PURE__ */ jsxs3(Text3, { children: [
+      /* @__PURE__ */ jsx3(Text3, { bold: true, color: "cyan", children: "agentwatch " }),
+      /* @__PURE__ */ jsx3(Text3, { dimColor: true, children: "v0.0.1" })
+    ] }),
+    /* @__PURE__ */ jsxs3(Text3, { children: [
+      /* @__PURE__ */ jsx3(Text3, { dimColor: true, children: "workspace: " }),
+      /* @__PURE__ */ jsx3(Text3, { children: workspace }),
+      /* @__PURE__ */ jsx3(Text3, { dimColor: true, children: "  events: " }),
+      /* @__PURE__ */ jsx3(Text3, { children: eventCount }),
+      filter && /* @__PURE__ */ jsxs3(Fragment, { children: [
+        /* @__PURE__ */ jsx3(Text3, { dimColor: true, children: "  filter: " }),
+        /* @__PURE__ */ jsx3(Text3, { color: "yellow", children: filter })
+      ] }),
+      paused && /* @__PURE__ */ jsxs3(Fragment, { children: [
+        /* @__PURE__ */ jsx3(Text3, { dimColor: true, children: "  " }),
+        /* @__PURE__ */ jsx3(Text3, { color: "red", children: "[PAUSED]" })
+      ] })
+    ] })
+  ] });
+}
+
+// src/ui/PermissionView.tsx
+import { Box as Box4, Text as Text4 } from "ink";
+import { jsx as jsx4, jsxs as jsxs4 } from "react/jsx-runtime";
+function PermissionView({ permissions }) {
+  if (permissions.length === 0) {
+    return /* @__PURE__ */ jsxs4(Box4, { flexDirection: "column", borderStyle: "double", paddingX: 1, children: [
+      /* @__PURE__ */ jsx4(Text4, { bold: true, color: "cyan", children: "Permissions \u2014 Claude Code" }),
+      /* @__PURE__ */ jsx4(Text4, { dimColor: true, children: "No settings.json found at ~/.claude/ or project .claude/" }),
+      /* @__PURE__ */ jsx4(Text4, { dimColor: true, children: "Press p to close." })
+    ] });
+  }
+  return /* @__PURE__ */ jsxs4(Box4, { flexDirection: "column", borderStyle: "double", paddingX: 1, children: [
+    /* @__PURE__ */ jsx4(Text4, { bold: true, color: "cyan", children: "Permissions \u2014 Claude Code" }),
+    permissions.map((p) => /* @__PURE__ */ jsx4(Block, { perms: p }, p.source)),
+    /* @__PURE__ */ jsx4(Box4, { marginTop: 1, children: /* @__PURE__ */ jsx4(Text4, { dimColor: true, children: "Press p to close. These are the permissions Claude Code uses on your machine." }) })
+  ] });
+}
+function Block({ perms }) {
+  return /* @__PURE__ */ jsxs4(Box4, { flexDirection: "column", marginTop: 1, children: [
+    /* @__PURE__ */ jsxs4(Text4, { children: [
+      /* @__PURE__ */ jsx4(Text4, { dimColor: true, children: "source: " }),
+      /* @__PURE__ */ jsx4(Text4, { children: perms.source })
+    ] }),
+    /* @__PURE__ */ jsxs4(Text4, { children: [
+      /* @__PURE__ */ jsx4(Text4, { dimColor: true, children: "defaultMode: " }),
+      /* @__PURE__ */ jsx4(Text4, { color: modeColor(perms.defaultMode), children: perms.defaultMode })
+    ] }),
+    /* @__PURE__ */ jsxs4(Box4, { marginTop: 1, flexDirection: "column", children: [
+      /* @__PURE__ */ jsxs4(Text4, { bold: true, color: "green", children: [
+        "CAN (",
+        perms.allow.length,
+        ")"
+      ] }),
+      perms.allow.length === 0 ? /* @__PURE__ */ jsx4(Text4, { dimColor: true, children: "  (none \u2014 defaultMode applies)" }) : perms.allow.map((a, i) => /* @__PURE__ */ jsxs4(Text4, { children: [
+        "  ",
+        /* @__PURE__ */ jsx4(Text4, { color: "green", children: "\u2713" }),
+        " ",
+        a
+      ] }, i))
+    ] }),
+    /* @__PURE__ */ jsxs4(Box4, { marginTop: 1, flexDirection: "column", children: [
+      /* @__PURE__ */ jsxs4(Text4, { bold: true, color: "red", children: [
+        "CANNOT (",
+        perms.deny.length,
+        ")"
+      ] }),
+      perms.deny.length === 0 ? /* @__PURE__ */ jsx4(Text4, { dimColor: true, children: "  (none \u2014 no explicit denies)" }) : perms.deny.map((d, i) => /* @__PURE__ */ jsxs4(Text4, { children: [
+        "  ",
+        /* @__PURE__ */ jsx4(Text4, { color: "red", children: "\u2717" }),
+        " ",
+        d
+      ] }, i))
+    ] }),
+    perms.additionalDirectories.length > 0 && /* @__PURE__ */ jsxs4(Box4, { marginTop: 1, flexDirection: "column", children: [
+      /* @__PURE__ */ jsx4(Text4, { bold: true, children: "Additional writable directories" }),
+      perms.additionalDirectories.map((d, i) => /* @__PURE__ */ jsxs4(Text4, { children: [
+        "  \u2022 ",
+        d
+      ] }, i))
+    ] }),
+    perms.flags.length > 0 && /* @__PURE__ */ jsxs4(Box4, { marginTop: 1, flexDirection: "column", children: [
+      /* @__PURE__ */ jsx4(Text4, { bold: true, color: "yellow", children: "\u26A0 Flags" }),
+      perms.flags.map((f, i) => /* @__PURE__ */ jsxs4(Text4, { color: f.level === "risk" ? "red" : "yellow", children: [
+        "  ",
+        f.level === "risk" ? "\u2717" : "!",
+        " ",
+        f.message
+      ] }, i))
+    ] })
+  ] });
+}
+function modeColor(mode) {
+  if (mode === "auto" || mode === "bypassPermissions") return "red";
+  if (mode === "ask") return "green";
+  return "yellow";
+}
+
+// src/adapters/claude-code.ts
+import chokidar from "chokidar";
+import { createReadStream, existsSync, statSync } from "fs";
+import { createInterface } from "readline";
+import { basename, sep } from "path";
+
+// src/schema.ts
+function riskOf(type, path, cmd) {
+  if (type === "shell_exec") {
+    if (cmd && /\b(rm|sudo|curl|wget|chmod|chown)\b/.test(cmd)) return 9;
+    return 6;
+  }
+  if (type === "file_write" || type === "file_change") {
+    if (path && /\.(env|key|pem|credentials)/.test(path)) return 9;
+    if (path && /(^|\/)(\.ssh|\.aws|\.gnupg)\//.test(path)) return 10;
+    return 4;
+  }
+  if (type === "file_read") {
+    if (path && /\.(env|key|pem|credentials)/.test(path)) return 7;
+    return 2;
+  }
+  if (type === "tool_call") return 3;
+  return 1;
+}
+
+// src/util/ids.ts
+var counter = 0;
+function nextId() {
+  counter += 1;
+  return `${Date.now().toString(36)}-${counter.toString(36)}`;
+}
+
+// src/adapters/claude-code.ts
+var BACKFILL_BYTES = 64 * 1024;
+function startClaudeAdapter(emit) {
+  const dir = claudeProjectsDir();
+  if (!existsSync(dir)) {
+    return () => {
+    };
+  }
+  const cursors = /* @__PURE__ */ new Map();
+  const sessionRe = /[\\/]projects[\\/][^\\/]+[\\/][^\\/]+\.jsonl$/;
+  const watcher = chokidar.watch(dir, {
+    persistent: true,
+    ignoreInitial: false,
+    depth: 3
+  });
+  const process2 = (file, isInitialAdd) => {
+    if (!sessionRe.test(file)) return;
+    const size = safeSize(file);
+    let cursor = cursors.get(file);
+    if (!cursor) {
+      const start2 = isInitialAdd ? Math.max(0, size - BACKFILL_BYTES) : size;
+      cursor = { offset: start2 };
+      cursors.set(file, cursor);
+    }
+    if (size <= cursor.offset) return;
+    const start = cursor.offset;
+    const stream = createReadStream(file, {
+      start,
+      end: size - 1,
+      encoding: "utf8"
+    });
+    const sessionId = basename(file, ".jsonl");
+    const project = extractProject(file);
+    let consumed = 0;
+    let skippedFirst = false;
+    const rl = createInterface({ input: stream, crlfDelay: Infinity });
+    rl.on("line", (line) => {
+      consumed += Buffer.byteLength(line, "utf8") + 1;
+      if (isInitialAdd && start > 0 && !skippedFirst) {
+        skippedFirst = true;
+        return;
+      }
+      if (!line.trim()) return;
+      try {
+        const obj = JSON.parse(line);
+        const event = translateClaudeLine(obj, sessionId, project);
+        if (event) emit(event);
+      } catch {
+      }
+    });
+    rl.on("close", () => {
+      cursor.offset = start + consumed;
+    });
+  };
+  watcher.on("add", (f) => process2(f, true));
+  watcher.on("change", (f) => process2(f, false));
+  watcher.on("error", (err) => {
+    if (typeof err === "object" && err !== null) {
+      const code = err.code;
+      if (code === "EMFILE" || code === "ENOSPC" || code === "EACCES") return;
+    }
+    console.error("[agentwatch/claude]", String(err));
+  });
+  return () => {
+    void watcher.close();
+  };
+}
+function extractProject(file) {
+  const parts = file.split(sep);
+  const projIdx = parts.lastIndexOf("projects");
+  if (projIdx >= 0 && parts[projIdx + 1]) {
+    const dir = parts[projIdx + 1];
+    const segs = dir.split("-").filter(Boolean);
+    return segs[segs.length - 1] ?? dir;
+  }
+  return "";
+}
+function safeSize(file) {
+  try {
+    return statSync(file).size;
+  } catch {
+    return 0;
+  }
+}
+function translateClaudeLine(obj, sessionId, project = "") {
+  if (!obj || typeof obj !== "object") return null;
+  const o = obj;
+  const ts = typeof o.timestamp === "string" && o.timestamp || (/* @__PURE__ */ new Date()).toISOString();
+  const prefix = project ? `[${project}] ` : "";
+  const role = o.role ?? o.message?.role;
+  const type = o.type;
+  const content = o.message?.content;
+  if (type === "tool_result" || type === "summary") return null;
+  if (type === "worktree-state" || type === "compact") return null;
+  if (type === "assistant" || role === "assistant") {
+    const toolUse = findToolUse(content);
+    if (toolUse) {
+      const evType = inferToolType(toolUse.name);
+      const summary = buildToolSummary(toolUse);
+      return {
+        id: nextId(),
+        ts,
+        agent: "claude-code",
+        type: evType,
+        path: toolUse.path,
+        cmd: toolUse.cmd,
+        tool: toolUse.name,
+        summary: prefix + summary,
+        sessionId,
+        riskScore: riskOf(evType, toolUse.path, toolUse.cmd)
+      };
+    }
+    const text = extractText(content);
+    if (!text) return null;
+    return {
+      id: nextId(),
+      ts,
+      agent: "claude-code",
+      type: "response",
+      summary: prefix + truncate(text),
+      sessionId,
+      riskScore: riskOf("response")
+    };
+  }
+  if (type === "user" || role === "user") {
+    const text = extractUserText(content);
+    if (!text) return null;
+    return {
+      id: nextId(),
+      ts,
+      agent: "claude-code",
+      type: "prompt",
+      summary: prefix + truncate(text),
+      sessionId,
+      riskScore: riskOf("prompt")
+    };
+  }
+  return null;
+}
+function findToolUse(content) {
+  if (!Array.isArray(content)) return null;
+  for (const c of content) {
+    if (typeof c !== "object" || c === null) continue;
+    const rec = c;
+    if (rec.type !== "tool_use") continue;
+    const name = typeof rec.name === "string" ? rec.name : "unknown";
+    const input = rec.input ?? {};
+    const path = typeof input.file_path === "string" ? input.file_path : typeof input.path === "string" ? input.path : void 0;
+    const cmd = typeof input.command === "string" ? input.command : void 0;
+    return { name, path, cmd, input };
+  }
+  return null;
+}
+function buildToolSummary(t) {
+  if (/^Bash/i.test(t.name) && t.cmd) return `Bash: ${truncate(t.cmd, 100)}`;
+  if (/^(Write|Edit|MultiEdit|Read)/i.test(t.name) && t.path) {
+    return `${t.name}: ${t.path}`;
+  }
+  if (/^(Grep|Glob)/i.test(t.name)) {
+    const pat = typeof t.input.pattern === "string" ? t.input.pattern : typeof t.input.glob === "string" ? t.input.glob : "";
+    return `${t.name}: ${truncate(pat, 100)}`;
+  }
+  if (/^Task/i.test(t.name)) {
+    const desc = typeof t.input.description === "string" ? t.input.description : "";
+    return `Task: ${truncate(desc, 100)}`;
+  }
+  if (/^WebFetch/i.test(t.name)) {
+    const url = typeof t.input.url === "string" ? t.input.url : "";
+    return `WebFetch: ${url}`;
+  }
+  const firstVal = Object.values(t.input).find(
+    (v) => typeof v === "string"
+  );
+  return firstVal ? `${t.name}: ${truncate(firstVal, 100)}` : t.name;
+}
+function extractText(content) {
+  if (typeof content === "string") return content;
+  if (!Array.isArray(content)) return "";
+  const parts = [];
+  for (const c of content) {
+    if (typeof c !== "object" || c === null) continue;
+    const rec = c;
+    if (rec.type === "text" && typeof rec.text === "string") {
+      parts.push(rec.text);
+    } else if (rec.type === "thinking" && typeof rec.thinking === "string") {
+      parts.push(rec.thinking);
+    }
+  }
+  return parts.join(" ").trim();
+}
+function extractUserText(content) {
+  if (typeof content === "string") return content.trim();
+  if (!Array.isArray(content)) return "";
+  const parts = [];
+  for (const c of content) {
+    if (typeof c !== "object" || c === null) continue;
+    const rec = c;
+    if (rec.type === "text" && typeof rec.text === "string") {
+      parts.push(rec.text);
+    }
+  }
+  return parts.join(" ").trim();
+}
+function inferToolType(name) {
+  if (/^Bash/i.test(name)) return "shell_exec";
+  if (/^(Read|Grep|Glob)/i.test(name)) return "file_read";
+  if (/^(Write|Edit|MultiEdit)/i.test(name)) return "file_write";
+  return "tool_call";
+}
+function truncate(s, max = 140) {
+  const clean = s.replace(/\s+/g, " ").trim();
+  if (!clean) return "";
+  return clean.length <= max ? clean : clean.slice(0, max - 1) + "\u2026";
+}
+
+// src/adapters/openclaw.ts
+import chokidar2 from "chokidar";
+import { createReadStream as createReadStream2, existsSync as existsSync2, statSync as statSync2 } from "fs";
+import { createInterface as createInterface2 } from "readline";
+import { basename as basename2, join, sep as sep2 } from "path";
+import { homedir } from "os";
+var sessionCwd = /* @__PURE__ */ new Map();
+function startOpenClawAdapter(emit) {
+  const root = join(homedir(), ".openclaw");
+  if (!existsSync2(root)) return () => {
+  };
+  const cursors = /* @__PURE__ */ new Map();
+  const stoppers = [];
+  const agentsDir = join(root, "agents");
+  const sessionRe = /[\\/]agents[\\/][^\\/]+[\\/]sessions[\\/][^\\/]+\.jsonl$/;
+  const sessionsWatcher = chokidar2.watch(agentsDir, {
+    persistent: true,
+    ignoreInitial: false,
+    depth: 4,
+    ignored: (p) => /\.reset\./.test(p)
+  });
+  const handleSession = (f, initial) => {
+    if (!sessionRe.test(f)) return;
+    processSession(f, initial, cursors, emit);
+  };
+  sessionsWatcher.on("add", (f) => handleSession(f, true));
+  sessionsWatcher.on("change", (f) => handleSession(f, false));
+  sessionsWatcher.on("error", swallow);
+  stoppers.push(() => {
+    void sessionsWatcher.close();
+  });
+  const auditPath = join(root, "logs", "config-audit.jsonl");
+  const auditWatcher = chokidar2.watch(auditPath, {
+    persistent: true,
+    ignoreInitial: false
+  });
+  auditWatcher.on("add", (f) => processAudit(f, true, cursors, emit));
+  auditWatcher.on("change", (f) => processAudit(f, false, cursors, emit));
+  auditWatcher.on("error", swallow);
+  stoppers.push(() => {
+    void auditWatcher.close();
+  });
+  return () => {
+    for (const s of stoppers) s();
+  };
+}
+function processSession(file, startFromEnd, cursors, emit) {
+  const subAgent = extractSubAgent(file);
+  const sessionId = basename2(file, ".jsonl");
+  streamLines(file, startFromEnd, cursors, (line) => {
+    let obj;
+    try {
+      obj = JSON.parse(line);
+    } catch {
+      return;
+    }
+    const event = translateSession(obj, subAgent, sessionId);
+    if (event) emit(event);
+  });
+}
+function processAudit(file, startFromEnd, cursors, emit) {
+  streamLines(file, startFromEnd, cursors, (line) => {
+    let obj;
+    try {
+      obj = JSON.parse(line);
+    } catch {
+      return;
+    }
+    const event = translateAudit(obj);
+    if (event) emit(event);
+  });
+}
+var BACKFILL_BYTES2 = 64 * 1024;
+function streamLines(file, isInitialAdd, cursors, onLine) {
+  const size = safeSize2(file);
+  let cursor = cursors.get(file);
+  if (!cursor) {
+    const backfillStart = Math.max(0, size - BACKFILL_BYTES2);
+    cursor = { offset: isInitialAdd ? backfillStart : size };
+    cursors.set(file, cursor);
+  }
+  if (size <= cursor.offset) return;
+  const start = cursor.offset;
+  const stream = createReadStream2(file, {
+    start,
+    end: size - 1,
+    encoding: "utf8"
+  });
+  let consumed = 0;
+  let skippedFirst = false;
+  const rl = createInterface2({ input: stream, crlfDelay: Infinity });
+  rl.on("line", (line) => {
+    consumed += Buffer.byteLength(line, "utf8") + 1;
+    if (isInitialAdd && start > 0 && !skippedFirst) {
+      skippedFirst = true;
+      return;
+    }
+    if (line.trim()) onLine(line);
+  });
+  rl.on("close", () => {
+    cursor.offset = start + consumed;
+  });
+}
+function swallow(err) {
+  if (typeof err !== "object" || err === null) return;
+  const code = err.code;
+  if (code === "EMFILE" || code === "ENOSPC" || code === "EACCES") return;
+  console.error("[agentwatch/openclaw]", String(err));
+}
+function safeSize2(file) {
+  try {
+    return statSync2(file).size;
+  } catch {
+    return 0;
+  }
+}
+function extractSubAgent(file) {
+  const parts = file.split(sep2);
+  const agentsIdx = parts.lastIndexOf("agents");
+  if (agentsIdx >= 0 && parts[agentsIdx + 1]) return parts[agentsIdx + 1];
+  return "unknown";
+}
+function translateSession(obj, subAgent, sessionId) {
+  if (!obj || typeof obj !== "object") return null;
+  const o = obj;
+  const ts = typeof o.timestamp === "string" && o.timestamp || (/* @__PURE__ */ new Date()).toISOString();
+  const t = o.type;
+  const projectLabel = () => {
+    const cwd = sessionCwd.get(sessionId);
+    if (!cwd) return "";
+    const b = cwd.split("/").filter(Boolean).pop();
+    return b ? `[${b}] ` : "";
+  };
+  const base = (type, fields = {}) => {
+    const prefix = projectLabel();
+    const rawSummary = fields.summary ?? "";
+    return {
+      id: nextId(),
+      ts,
+      agent: "openclaw",
+      type,
+      tool: `openclaw:${subAgent}`,
+      sessionId,
+      riskScore: riskOf(type, fields.path, fields.cmd),
+      ...fields,
+      summary: rawSummary ? prefix + rawSummary : prefix + type
+    };
+  };
+  if (t === "session") {
+    const cwd = typeof o.cwd === "string" ? o.cwd : void 0;
+    if (cwd) sessionCwd.set(sessionId, cwd);
+    return base("session_start", {
+      path: cwd,
+      summary: `openclaw/${subAgent} session started${cwd ? ` in ${cwd}` : ""}`
+    });
+  }
+  if (t === "model_change") {
+    const model = typeof o.modelId === "string" ? o.modelId : "";
+    const provider = typeof o.provider === "string" ? o.provider : "";
+    return base("tool_call", {
+      summary: `model \u2192 ${provider}/${model}`,
+      tool: `openclaw:${subAgent}:model`
+    });
+  }
+  if (t === "message") {
+    const msg = o.message;
+    const role = msg?.role;
+    const content = msg?.content;
+    const text = extractText2(content);
+    if (role === "user") {
+      return base("prompt", { summary: truncate2(text) });
+    }
+    if (role === "assistant") {
+      const toolUse = extractToolUse(content);
+      if (toolUse) {
+        const type = inferToolType2(toolUse.name);
+        return base(type, {
+          tool: `openclaw:${subAgent}:${toolUse.name}`,
+          path: toolUse.path,
+          cmd: toolUse.cmd,
+          summary: truncate2(toolUse.summary)
+        });
+      }
+      if (!text) return null;
+      return base("response", { summary: truncate2(text) });
+    }
+  }
+  return null;
+}
+function translateAudit(obj) {
+  if (!obj || typeof obj !== "object") return null;
+  const o = obj;
+  const ts = typeof o.ts === "string" && o.ts || (/* @__PURE__ */ new Date()).toISOString();
+  const event = typeof o.event === "string" ? o.event : "config.event";
+  const configPath = typeof o.configPath === "string" ? o.configPath : void 0;
+  const cwd = typeof o.cwd === "string" ? o.cwd : void 0;
+  const argv = Array.isArray(o.argv) ? o.argv.join(" ") : "";
+  const suspicious = Array.isArray(o.suspicious) && o.suspicious.length > 0;
+  return {
+    id: nextId(),
+    ts,
+    agent: "openclaw",
+    type: "file_write",
+    tool: `openclaw:audit:${event}`,
+    path: configPath,
+    cmd: argv,
+    summary: `${event}${configPath ? ` ${basename2(configPath)}` : ""}${cwd ? ` (cwd: ${cwd})` : ""}`,
+    // audit writes are inherently sensitive; suspicious flag bumps to max
+    riskScore: suspicious ? 10 : Math.max(5, riskOf("file_write", configPath))
+  };
+}
+function extractText2(content) {
+  if (typeof content === "string") return content;
+  if (!Array.isArray(content)) return "";
+  return content.filter(
+    (c) => typeof c === "object" && c !== null && c.type === "text"
+  ).map((c) => c.text).join(" ");
+}
+function extractToolUse(content) {
+  if (!Array.isArray(content)) return null;
+  for (const c of content) {
+    if (typeof c === "object" && c !== null && c.type === "tool_use") {
+      const r = c;
+      const name = typeof r.name === "string" ? r.name : "unknown";
+      const input = r.input ?? {};
+      const path = typeof input.file_path === "string" ? input.file_path : typeof input.path === "string" ? input.path : void 0;
+      const cmd = typeof input.command === "string" ? input.command : void 0;
+      const summary = cmd ?? path ?? name;
+      return { name, path, cmd, summary };
+    }
+  }
+  return null;
+}
+function inferToolType2(name) {
+  if (/^Bash|^Shell|^Exec/i.test(name)) return "shell_exec";
+  if (/^Read|^View|^Open/i.test(name)) return "file_read";
+  if (/^(Write|Edit|MultiEdit|Create)/i.test(name)) return "file_write";
+  return "tool_call";
+}
+function truncate2(s, max = 140) {
+  const clean = s.replace(/\s+/g, " ").trim();
+  if (!clean) return "";
+  return clean.length <= max ? clean : clean.slice(0, max - 1) + "\u2026";
+}
+
+// src/adapters/cursor.ts
+import chokidar3 from "chokidar";
+import {
+  readFileSync,
+  existsSync as existsSync3,
+  readdirSync,
+  statSync as statSync3
+} from "fs";
+import { homedir as homedir2 } from "os";
+import { join as join2 } from "path";
+function startCursorAdapter(workspace, emit) {
+  const cursorDir = join2(homedir2(), ".cursor");
+  const installed = existsSync3(cursorDir);
+  const status = {
+    installed,
+    mcpServers: [],
+    cursorRulesFiles: []
+  };
+  if (!installed) return { stop: () => {
+  }, status };
+  const stoppers = [];
+  const lastRecentFiles = /* @__PURE__ */ new Set();
+  const emitEvent = (type, summary, opts = {}) => {
+    emit({
+      id: nextId(),
+      ts: (/* @__PURE__ */ new Date()).toISOString(),
+      agent: "cursor",
+      type,
+      tool: "cursor",
+      summary,
+      riskScore: riskOf(type, opts.path, opts.cmd),
+      ...opts
+    });
+  };
+  const mcpPath = join2(cursorDir, "mcp.json");
+  if (existsSync3(mcpPath)) {
+    status.mcpServers = readMcpServers(mcpPath);
+    const w = chokidar3.watch(mcpPath, {
+      persistent: true,
+      ignoreInitial: true
+    });
+    w.on("change", () => {
+      status.mcpServers = readMcpServers(mcpPath);
+      emitEvent(
+        "file_write",
+        `Cursor MCP changed: ${status.mcpServers.length} server(s) (${status.mcpServers.join(", ") || "none"})`,
+        { path: mcpPath, tool: "cursor:mcp" }
+      );
+    });
+    w.on("error", swallow2);
+    stoppers.push(() => {
+      void w.close();
+    });
+  }
+  const permPath = join2(cursorDir, "cli-config.json");
+  if (existsSync3(permPath)) {
+    status.permissions = readPermissions(permPath);
+    const w = chokidar3.watch(permPath, {
+      persistent: true,
+      ignoreInitial: true
+    });
+    w.on("change", () => {
+      status.permissions = readPermissions(permPath);
+      const p = status.permissions;
+      emitEvent(
+        "file_write",
+        `Cursor permissions changed: mode=${p?.approvalMode}, sandbox=${p?.sandboxMode}, allow=${p?.allowCount}, deny=${p?.denyCount}`,
+        { path: permPath, tool: "cursor:permissions" }
+      );
+    });
+    w.on("error", swallow2);
+    stoppers.push(() => {
+      void w.close();
+    });
+  }
+  const stateFile = join2(cursorDir, "ide_state.json");
+  if (existsSync3(stateFile)) {
+    for (const p of readRecentFiles(stateFile)) lastRecentFiles.add(p);
+    const w = chokidar3.watch(stateFile, {
+      persistent: true,
+      ignoreInitial: true
+    });
+    w.on("change", () => {
+      const recent = readRecentFiles(stateFile);
+      for (const path of recent) {
+        if (lastRecentFiles.has(path)) continue;
+        lastRecentFiles.add(path);
+        const project = extractProject2(path);
+        emitEvent("file_read", project ? `[${project}] ${path}` : path, {
+          tool: "cursor:ide_state",
+          path
+        });
+      }
+    });
+    w.on("error", swallow2);
+    stoppers.push(() => {
+      void w.close();
+    });
+  }
+  const rulesFiles = discoverCursorrules(workspace);
+  status.cursorRulesFiles = rulesFiles;
+  for (const path of rulesFiles) {
+    const w = chokidar3.watch(path, {
+      persistent: true,
+      ignoreInitial: true
+    });
+    w.on("change", () => {
+      const project = extractProject2(path);
+      emitEvent(
+        "file_write",
+        `${project ? `[${project}] ` : ""}.cursorrules edited`,
+        { tool: "cursor:rules", path }
+      );
+    });
+    w.on("error", swallow2);
+    stoppers.push(() => {
+      void w.close();
+    });
+  }
+  return {
+    stop: () => {
+      for (const s of stoppers) s();
+    },
+    status
+  };
+}
+function swallow2(err) {
+  if (typeof err !== "object" || err === null) return;
+  const code = err.code;
+  if (code === "EMFILE" || code === "ENOSPC" || code === "EACCES") return;
+  console.error("[agentwatch/cursor]", String(err));
+}
+function readMcpServers(path) {
+  try {
+    const obj = JSON.parse(readFileSync(path, "utf8"));
+    return Object.keys(obj.mcpServers ?? {});
+  } catch {
+    return [];
+  }
+}
+function readPermissions(path) {
+  try {
+    const obj = JSON.parse(readFileSync(path, "utf8"));
+    const perms = obj.permissions ?? {};
+    const sandbox = obj.sandbox?.mode;
+    return {
+      approvalMode: String(obj.approvalMode ?? "unknown"),
+      sandboxMode: String(sandbox ?? "unknown"),
+      allowCount: Array.isArray(perms.allow) ? perms.allow.length : 0,
+      denyCount: Array.isArray(perms.deny) ? perms.deny.length : 0
+    };
+  } catch {
+    return void 0;
+  }
+}
+function readRecentFiles(stateFile) {
+  try {
+    const obj = JSON.parse(readFileSync(stateFile, "utf8"));
+    const list = obj.recentlyViewedFiles;
+    if (!Array.isArray(list)) return [];
+    return list.map((r) => {
+      if (typeof r !== "object" || r === null) return void 0;
+      const rec = r;
+      if (typeof rec.absolutePath === "string") return rec.absolutePath;
+      if (typeof rec.relativePath === "string") return rec.relativePath;
+      return void 0;
+    }).filter((x) => typeof x === "string").slice(0, 20);
+  } catch {
+    return [];
+  }
+}
+function discoverCursorrules(workspace) {
+  const hits = [];
+  if (!existsSync3(workspace)) return hits;
+  const rootRules = join2(workspace, ".cursorrules");
+  if (existsSync3(rootRules)) hits.push(rootRules);
+  let entries = [];
+  try {
+    entries = readdirSync(workspace);
+  } catch {
+    return hits;
+  }
+  for (const name of entries) {
+    if (name.startsWith(".")) continue;
+    if (name === "node_modules") continue;
+    const dir = join2(workspace, name);
+    try {
+      if (!statSync3(dir).isDirectory()) continue;
+    } catch {
+      continue;
+    }
+    const candidate = join2(dir, ".cursorrules");
+    if (existsSync3(candidate)) hits.push(candidate);
+  }
+  return hits;
+}
+function extractProject2(path) {
+  const segs = path.split("/").filter(Boolean);
+  const ideaIdx = segs.indexOf("IdeaProjects");
+  if (ideaIdx >= 0 && segs[ideaIdx + 1]) return segs[ideaIdx + 1];
+  return segs[segs.length - 2] ?? "";
+}
+
+// src/adapters/fs-watcher.ts
+import chokidar4 from "chokidar";
+var DEFAULT_IGNORES = [
+  /(^|[/\\])node_modules([/\\]|$)/,
+  /(^|[/\\])\.git([/\\]|$)/,
+  /(^|[/\\])dist([/\\]|$)/,
+  /(^|[/\\])build([/\\]|$)/,
+  /(^|[/\\])\.next([/\\]|$)/,
+  /(^|[/\\])\.cache([/\\]|$)/,
+  /(^|[/\\])\.turbo([/\\]|$)/,
+  /(^|[/\\])target([/\\]|$)/,
+  /(^|[/\\])coverage([/\\]|$)/,
+  /(^|[/\\])\.venv([/\\]|$)/,
+  /(^|[/\\])venv([/\\]|$)/,
+  /(^|[/\\])__pycache__([/\\]|$)/,
+  /(^|[/\\])\.pytest_cache([/\\]|$)/,
+  /(^|[/\\])\.idea([/\\]|$)/,
+  /(^|[/\\])\.vscode([/\\]|$)/,
+  /(^|[/\\])\.DS_Store$/,
+  /\.log$/,
+  /\.lock$/,
+  /package-lock\.json$/,
+  /pnpm-lock\.yaml$/,
+  /yarn\.lock$/,
+  /bun\.lockb$/
+];
+function startFsAdapter(root, emit) {
+  const watcher = chokidar4.watch(root, {
+    persistent: true,
+    ignoreInitial: true,
+    ignored: (p) => DEFAULT_IGNORES.some((r) => r.test(p)),
+    depth: 3
+  });
+  watcher.on("error", (err) => {
+    if (isSuppressible(err)) return;
+    console.error("[agentwatch/fs]", String(err));
+  });
+  const emitFs = (path) => {
+    const event = {
+      id: nextId(),
+      ts: (/* @__PURE__ */ new Date()).toISOString(),
+      agent: "unknown",
+      type: "file_change",
+      path,
+      summary: path,
+      riskScore: riskOf("file_change", path)
+    };
+    emit(event);
+  };
+  watcher.on("add", emitFs);
+  watcher.on("change", emitFs);
+  return () => {
+    void watcher.close();
+  };
+}
+function isSuppressible(err) {
+  if (typeof err !== "object" || err === null) return false;
+  const code = err.code;
+  return code === "EMFILE" || code === "ENOSPC" || code === "EACCES";
+}
+
+// src/util/claude-permissions.ts
+import { existsSync as existsSync4, readFileSync as readFileSync2 } from "fs";
+import { homedir as homedir3 } from "os";
+import { join as join3 } from "path";
+function readClaudePermissions(workspace) {
+  const sources = [join3(homedir3(), ".claude", "settings.json")];
+  if (workspace) {
+    sources.push(join3(workspace, ".claude", "settings.json"));
+    sources.push(join3(workspace, ".claude", "settings.local.json"));
+  }
+  const out = [];
+  for (const path of sources) {
+    const parsed = readOne(path);
+    if (parsed) out.push(parsed);
+  }
+  return out;
+}
+function readOne(path) {
+  if (!existsSync4(path)) return null;
+  try {
+    const raw = readFileSync2(path, "utf8");
+    const obj = JSON.parse(raw);
+    const perms = obj.permissions ?? {};
+    const allow = toStringArray(perms.allow);
+    const deny = toStringArray(perms.deny);
+    const defaultMode = typeof perms.defaultMode === "string" ? perms.defaultMode : "default";
+    const additionalDirectories = toStringArray(perms.additionalDirectories);
+    return {
+      source: path,
+      allow,
+      deny,
+      defaultMode,
+      additionalDirectories,
+      flags: assessRisk({ allow, deny, defaultMode })
+    };
+  } catch {
+    return null;
+  }
+}
+function toStringArray(v) {
+  if (!Array.isArray(v)) return [];
+  return v.filter((x) => typeof x === "string");
+}
+function assessRisk({
+  allow,
+  deny,
+  defaultMode
+}) {
+  const flags = [];
+  if (allow.some((a) => /^Bash\(\*\)$/i.test(a))) {
+    flags.push({
+      level: "risk",
+      message: "Bash(*) allows arbitrary shell \u2014 any command not explicitly denied will run"
+    });
+  }
+  if (allow.some((a) => /^Write$/i.test(a) || /^Edit$/i.test(a))) {
+    if (!deny.some((d) => /(^|[\s(])~\/\.ssh|\.aws|\.gnupg/.test(d))) {
+      flags.push({
+        level: "warn",
+        message: "Write/Edit allowed with no deny rule for ~/.ssh, ~/.aws, ~/.gnupg"
+      });
+    }
+  }
+  if (deny.length === 0) {
+    flags.push({
+      level: "warn",
+      message: "deny list is empty \u2014 no guardrails against destructive commands"
+    });
+  }
+  if (defaultMode === "auto" || defaultMode === "bypassPermissions") {
+    flags.push({
+      level: "warn",
+      message: `defaultMode=${defaultMode} \u2014 anything not in allow/deny runs without prompting`
+    });
+  }
+  return flags;
+}
+
+// src/ui/App.tsx
+import { jsx as jsx5, jsxs as jsxs5 } from "react/jsx-runtime";
+var MAX_EVENTS = 500;
+function findInsertIdx(events, ts) {
+  let lo = 0;
+  let hi = events.length;
+  while (lo < hi) {
+    const mid = lo + hi >>> 1;
+    if (events[mid].ts > ts) lo = mid + 1;
+    else hi = mid;
+  }
+  return lo;
+}
+function reducer(state, action) {
+  switch (action.type) {
+    case "event": {
+      if (state.paused) return state;
+      const next = state.events.slice();
+      const idx = findInsertIdx(next, action.event.ts);
+      next.splice(idx, 0, action.event);
+      if (next.length > MAX_EVENTS) next.length = MAX_EVENTS;
+      return { ...state, events: next };
+    }
+    case "toggle-agents":
+      return { ...state, showAgents: !state.showAgents };
+    case "toggle-permissions":
+      return { ...state, showPermissions: !state.showPermissions };
+    case "cycle-filter": {
+      const idx = state.filterAgent ? action.agents.indexOf(state.filterAgent) : -1;
+      const next = idx + 1 >= action.agents.length ? null : action.agents[idx + 1];
+      return { ...state, filterAgent: next ?? null };
+    }
+    case "toggle-pause":
+      return { ...state, paused: !state.paused };
+    case "clear":
+      return { ...state, events: [] };
+  }
+}
+function App() {
+  const { exit } = useApp();
+  const [workspace] = useState(detectWorkspaceRoot());
+  const [agents] = useState(detectAgents());
+  const [permissions] = useState(() => readClaudePermissions(workspace));
+  const [state, dispatch] = useReducer(reducer, {
+    events: [],
+    filterAgent: null,
+    showAgents: true,
+    showPermissions: false,
+    paused: false
+  });
+  useEffect(() => {
+    const onEvent = (e) => dispatch({ type: "event", event: e });
+    const stopClaude = startClaudeAdapter(onEvent);
+    const stopOpenClaw = startOpenClawAdapter(onEvent);
+    const cursor = startCursorAdapter(workspace, onEvent);
+    const stopFs = startFsAdapter(workspace, onEvent);
+    return () => {
+      stopClaude();
+      stopOpenClaw();
+      cursor.stop();
+      stopFs();
+    };
+  }, [workspace]);
+  useInput((input, key) => {
+    if (input === "q" || key.ctrl && input === "c") {
+      exit();
+      setImmediate(() => process.exit(0));
+      return;
+    }
+    if (input === "a") dispatch({ type: "toggle-agents" });
+    if (input === "f") {
+      const presentAgents = agents.filter((a) => a.present).map((a) => a.name);
+      const pool = presentAgents.length ? presentAgents : ["claude-code", "unknown"];
+      dispatch({ type: "cycle-filter", agents: pool });
+    }
+    if (input === " ") dispatch({ type: "toggle-pause" });
+    if (input === "p") dispatch({ type: "toggle-permissions" });
+    if (input === "c") dispatch({ type: "clear" });
+  });
+  const filtered = state.filterAgent ? state.events.filter((e) => e.agent === state.filterAgent) : state.events;
+  return /* @__PURE__ */ jsxs5(Box5, { flexDirection: "column", children: [
+    /* @__PURE__ */ jsx5(
+      Header,
+      {
+        workspace,
+        eventCount: state.events.length,
+        filter: state.filterAgent,
+        paused: state.paused
+      }
+    ),
+    state.showPermissions ? /* @__PURE__ */ jsx5(PermissionView, { permissions }) : /* @__PURE__ */ jsxs5(Box5, { flexDirection: "row", children: [
+      /* @__PURE__ */ jsx5(Box5, { flexGrow: 1, flexDirection: "column", children: /* @__PURE__ */ jsx5(Timeline, { events: filtered }) }),
+      state.showAgents && /* @__PURE__ */ jsx5(Box5, { width: 32, marginLeft: 1, children: /* @__PURE__ */ jsx5(AgentPanel, { agents, events: state.events }) })
+    ] }),
+    /* @__PURE__ */ jsx5(Box5, { marginTop: 1, children: /* @__PURE__ */ jsxs5(Text5, { dimColor: true, children: [
+      "[q] quit  [a] agents  [f] filter  [p] permissions  [space] ",
+      state.paused ? "resume" : "pause",
+      "  [c] clear"
+    ] }) })
+  ] });
+}
+
+// src/index.tsx
+import { jsx as jsx6 } from "react/jsx-runtime";
+var arg = process.argv[2];
+var ENTER_ALT_SCREEN = "\x1B[?1049h\x1B[2J\x1B[H";
+var LEAVE_ALT_SCREEN = "\x1B[?1049l";
+function enterAltScreen() {
+  if (process.stdout.isTTY) process.stdout.write(ENTER_ALT_SCREEN);
+}
+function leaveAltScreen() {
+  if (process.stdout.isTTY) process.stdout.write(LEAVE_ALT_SCREEN);
+}
+if (arg === "--help" || arg === "-h") {
+  console.log(`agentwatch \u2014 local observability for AI coding agents
+
+Usage:
+  agentwatch          launch the TUI
+  agentwatch doctor   detect installed agents and print readiness
+  agentwatch --help   show this help
+
+Hotkeys inside the TUI:
+  q       quit
+  a       toggle agent panel
+  f       cycle agent filter
+  p       pause / resume event stream
+  c       clear events
+
+Environment:
+  WORKSPACE_ROOT  override the detected workspace root
+`);
+  process.exit(0);
+}
+if (arg === "doctor") {
+  const { detectAgents: detectAgents2 } = await import("./detect-57ZQXQNN.js");
+  const { detectWorkspaceRoot: detectWorkspaceRoot2 } = await import("./workspace-N6FQVHKD.js");
+  const agents = detectAgents2();
+  console.log(`workspace: ${detectWorkspaceRoot2()}
+`);
+  console.log("agents:");
+  for (const a of agents) {
+    const mark = a.present ? "\u25CF" : "\u25CB";
+    const status = a.present ? "installed" : "not detected";
+    console.log(`  ${mark} ${a.label.padEnd(14)} ${status}`);
+    if (a.configPath) console.log(`    config: ${a.configPath}`);
+  }
+  process.exit(0);
+}
+enterAltScreen();
+for (const sig of ["exit", "SIGINT", "SIGTERM", "SIGHUP"]) {
+  process.on(sig, () => {
+    leaveAltScreen();
+    if (sig !== "exit") process.exit(0);
+  });
+}
+var { waitUntilExit } = render(/* @__PURE__ */ jsx6(App, {}));
+waitUntilExit().finally(() => leaveAltScreen());