agenttop 0.3.0

package/dist/index.js

@@ -0,0 +1,1390 @@
+#!/usr/bin/env node
+import {
+  SecurityEngine,
+  Watcher,
+  clearNickname,
+  discoverSessions,
+  getNicknames,
+  isFirstRun,
+  loadConfig,
+  resolveAlertLogPath,
+  rotateLogFile,
+  saveConfig,
+  setNickname,
+  startMcpServer
+} from "./chunk-4I4UZNKS.js";
+
+// src/index.tsx
+import { readFileSync as readFileSync4 } from "fs";
+import { join as join4, dirname as dirname4 } from "path";
+import { fileURLToPath as fileURLToPath3 } from "url";
+import React9 from "react";
+import { render } from "ink";
+
+// src/ui/App.tsx
+import { useState as useState7, useEffect as useEffect5, useCallback as useCallback3 } from "react";
+import { Box as Box8, Text as Text8, useApp, useInput as useInput2, useStdout } from "ink";
+
+// src/hooks/installer.ts
+import { existsSync, readFileSync, writeFileSync, copyFileSync, mkdirSync, chmodSync } from "fs";
+import { join, dirname } from "path";
+import { homedir } from "os";
+import { fileURLToPath } from "url";
+var HOOK_FILENAME = "agenttop-guard.py";
+var SETTINGS_PATH = join(homedir(), ".claude", "settings.json");
+var getHookSource = () => {
+  const thisFile = fileURLToPath(import.meta.url);
+  const srcHooksDir = join(dirname(thisFile), "..", "src", "hooks");
+  const distHooksDir = join(dirname(thisFile), "hooks");
+  for (const dir of [distHooksDir, srcHooksDir]) {
+    const path = join(dir, HOOK_FILENAME);
+    if (existsSync(path)) return path;
+  }
+  const npmGlobalPath = join(dirname(thisFile), "..", "hooks", HOOK_FILENAME);
+  if (existsSync(npmGlobalPath)) return npmGlobalPath;
+  throw new Error(`cannot find ${HOOK_FILENAME} \u2014 is agenttop installed correctly?`);
+};
+var getHookTarget = () => {
+  const claudeHooksDir = join(homedir(), ".claude", "hooks");
+  mkdirSync(claudeHooksDir, { recursive: true });
+  return join(claudeHooksDir, HOOK_FILENAME);
+};
+var readSettings = () => {
+  if (!existsSync(SETTINGS_PATH)) {
+    return {};
+  }
+  try {
+    return JSON.parse(readFileSync(SETTINGS_PATH, "utf-8"));
+  } catch {
+    return {};
+  }
+};
+var writeSettings = (settings) => {
+  mkdirSync(dirname(SETTINGS_PATH), { recursive: true });
+  writeFileSync(SETTINGS_PATH, JSON.stringify(settings, null, 2) + "\n");
+};
+var installHooks = () => {
+  const source = getHookSource();
+  const target = getHookTarget();
+  copyFileSync(source, target);
+  chmodSync(target, 493);
+  const settings = readSettings();
+  const hooks = settings.hooks ?? {};
+  const postToolUse = hooks.PostToolUse ?? [];
+  const hookCommand = target;
+  const allToolsMatcher = postToolUse.find(
+    (entry) => entry.matcher === "Bash|Read|Grep|Glob|WebFetch|WebSearch"
+  );
+  if (allToolsMatcher) {
+    const alreadyInstalled = allToolsMatcher.hooks.some((h) => h.command.includes("agenttop-guard"));
+    if (alreadyInstalled) {
+      process.stdout.write("agenttop hooks already installed\n");
+      return;
+    }
+    allToolsMatcher.hooks.push({ type: "command", command: hookCommand });
+  } else {
+    postToolUse.push({
+      matcher: "Bash|Read|Grep|Glob|WebFetch|WebSearch",
+      hooks: [{ type: "command", command: hookCommand }]
+    });
+  }
+  hooks.PostToolUse = postToolUse;
+  settings.hooks = hooks;
+  writeSettings(settings);
+  process.stdout.write(`agenttop hooks installed:
+`);
+  process.stdout.write(`  hook: ${target}
+`);
+  process.stdout.write(`  settings: ${SETTINGS_PATH}
+`);
+  process.stdout.write(`  matcher: PostToolUse (Bash|Read|Grep|Glob|WebFetch|WebSearch)
+`);
+};
+var uninstallHooks = () => {
+  const settings = readSettings();
+  const hooks = settings.hooks ?? {};
+  const postToolUse = hooks.PostToolUse ?? [];
+  let removed = false;
+  for (const entry of postToolUse) {
+    const before = entry.hooks.length;
+    entry.hooks = entry.hooks.filter((h) => !h.command.includes("agenttop-guard"));
+    if (entry.hooks.length < before) removed = true;
+  }
+  hooks.PostToolUse = postToolUse.filter((e) => e.hooks.length > 0);
+  settings.hooks = hooks;
+  writeSettings(settings);
+  if (removed) {
+    process.stdout.write("agenttop hooks removed from Claude Code settings\n");
+  } else {
+    process.stdout.write("agenttop hooks were not installed\n");
+  }
+};
+
+// src/install-mcp.ts
+import { readFileSync as readFileSync2, writeFileSync as writeFileSync2, mkdirSync as mkdirSync2 } from "fs";
+import { join as join2 } from "path";
+import { homedir as homedir2 } from "os";
+var installMcpConfig = () => {
+  const settingsPath = join2(homedir2(), ".claude", "settings.json");
+  let settings = {};
+  try {
+    settings = JSON.parse(readFileSync2(settingsPath, "utf-8"));
+  } catch {
+  }
+  const mcpServers = settings.mcpServers ?? {};
+  mcpServers.agenttop = { command: "agenttop", args: ["--mcp"] };
+  settings.mcpServers = mcpServers;
+  mkdirSync2(join2(homedir2(), ".claude"), { recursive: true });
+  writeFileSync2(settingsPath, JSON.stringify(settings, null, 2) + "\n");
+  process.stdout.write("agenttop MCP server registered in Claude Code settings\n");
+  process.stdout.write(`  settings: ${settingsPath}
+`);
+};
+
+// src/updates.ts
+import { execSync, exec } from "child_process";
+import { readFileSync as readFileSync3 } from "fs";
+import { join as join3, dirname as dirname2 } from "path";
+import { fileURLToPath as fileURLToPath2 } from "url";
+var getPackageVersion = () => {
+  try {
+    const thisFile = fileURLToPath2(import.meta.url);
+    const pkgPath = join3(dirname2(thisFile), "..", "package.json");
+    const pkg = JSON.parse(readFileSync3(pkgPath, "utf-8"));
+    return pkg.version || "0.0.0";
+  } catch {
+    return "0.0.0";
+  }
+};
+var checkForUpdate = () => {
+  const current = getPackageVersion();
+  try {
+    const latest = execSync("npm view agenttop version", { encoding: "utf-8", timeout: 5e3 }).trim();
+    return {
+      current,
+      latest,
+      available: latest !== current && compareVersions(latest, current) > 0
+    };
+  } catch {
+    return { current, latest: current, available: false };
+  }
+};
+var installUpdate = () => {
+  return new Promise((resolve, reject) => {
+    exec("npm install -g agenttop@latest", { timeout: 6e4 }, (err, stdout) => {
+      if (err) {
+        reject(err);
+      } else {
+        resolve(stdout.trim());
+      }
+    });
+  });
+};
+var compareVersions = (a, b) => {
+  const pa = a.split(".").map(Number);
+  const pb = b.split(".").map(Number);
+  for (let i = 0; i < 3; i++) {
+    const da = pa[i] ?? 0;
+    const db = pb[i] ?? 0;
+    if (da > db) return 1;
+    if (da < db) return -1;
+  }
+  return 0;
+};
+
+// src/ui/components/StatusBar.tsx
+import React, { useState, useEffect } from "react";
+import { Box, Text } from "ink";
+
+// src/ui/theme.ts
+var colors = {
+  primary: "#61AFEF",
+  secondary: "#98C379",
+  accent: "#C678DD",
+  warning: "#E5C07B",
+  error: "#E06C75",
+  critical: "#FF0000",
+  muted: "#5C6370",
+  text: "#ABB2BF",
+  bright: "#FFFFFF",
+  border: "#3E4451",
+  selected: "#2C313A",
+  header: "#61AFEF"
+};
+var severityColors = {
+  info: colors.muted,
+  warn: colors.warning,
+  high: colors.error,
+  critical: colors.critical
+};
+var toolColors = {
+  Bash: colors.error,
+  Read: colors.secondary,
+  Write: colors.accent,
+  Edit: colors.accent,
+  Grep: colors.primary,
+  Glob: colors.primary,
+  Task: colors.warning,
+  WebFetch: colors.warning,
+  WebSearch: colors.warning
+};
+var getToolColor = (toolName) => toolColors[toolName] || colors.text;
+
+// src/ui/components/StatusBar.tsx
+import { jsx, jsxs } from "react/jsx-runtime";
+var StatusBar = React.memo(({ sessionCount, alertCount, version, updateInfo }) => {
+  const [time, setTime] = useState(/* @__PURE__ */ new Date());
+  useEffect(() => {
+    const interval = setInterval(() => setTime(/* @__PURE__ */ new Date()), 1e3);
+    return () => clearInterval(interval);
+  }, []);
+  const timeStr = time.toLocaleTimeString("en-GB", { hour12: false });
+  return /* @__PURE__ */ jsxs(Box, { borderStyle: "single", borderColor: colors.border, paddingX: 1, justifyContent: "space-between", children: [
+    /* @__PURE__ */ jsxs(Text, { color: colors.header, bold: true, children: [
+      "agenttop v",
+      version
+    ] }),
+    /* @__PURE__ */ jsxs(Text, { color: colors.text, children: [
+      sessionCount,
+      " session",
+      sessionCount !== 1 ? "s" : ""
+    ] }),
+    alertCount > 0 && /* @__PURE__ */ jsxs(Text, { color: colors.error, bold: true, children: [
+      alertCount,
+      " alert",
+      alertCount !== 1 ? "s" : ""
+    ] }),
+    updateInfo?.available && /* @__PURE__ */ jsxs(Text, { color: colors.secondary, children: [
+      "v",
+      updateInfo.latest,
+      " available (u)"
+    ] }),
+    /* @__PURE__ */ jsx(Text, { color: colors.muted, children: timeStr })
+  ] });
+});
+
+// src/ui/components/SessionList.tsx
+import React2 from "react";
+import { Box as Box2, Text as Text2 } from "ink";
+import { jsx as jsx2, jsxs as jsxs2 } from "react/jsx-runtime";
+var formatModel = (model) => {
+  if (model.includes("opus")) return "opus";
+  if (model.includes("sonnet")) return "sonnet";
+  if (model.includes("haiku")) return "haiku";
+  return model.slice(0, 8);
+};
+var formatProject = (project) => {
+  const parts = project.split("/");
+  const last = parts[parts.length - 1] || project;
+  return last.length > 18 ? last.slice(0, 17) + "\u2026" : last;
+};
+var formatTokens = (n) => {
+  if (n >= 1e6) return (n / 1e6).toFixed(1) + "M";
+  if (n >= 1e3) return (n / 1e3).toFixed(1) + "k";
+  return String(n);
+};
+var SessionList = React2.memo(({ sessions, selectedIndex, focused, filter }) => {
+  return /* @__PURE__ */ jsxs2(Box2, { flexDirection: "column", width: 28, borderStyle: "single", borderColor: focused ? colors.primary : colors.border, children: [
+    /* @__PURE__ */ jsxs2(Box2, { paddingX: 1, children: [
+      /* @__PURE__ */ jsx2(Text2, { color: colors.header, bold: true, children: "SESSIONS" }),
+      filter && /* @__PURE__ */ jsxs2(Text2, { color: colors.muted, children: [
+        " [",
+        filter,
+        "]"
+      ] })
+    ] }),
+    sessions.length === 0 && /* @__PURE__ */ jsx2(Box2, { paddingX: 1, paddingY: 1, children: /* @__PURE__ */ jsx2(Text2, { color: colors.muted, italic: true, children: filter ? "No matching sessions" : "No active sessions" }) }),
+    sessions.map((session, i) => {
+      const isSelected = i === selectedIndex;
+      const indicator = isSelected ? ">" : " ";
+      const displayName = session.nickname || session.slug;
+      const totalIn = session.usage.inputTokens + session.usage.cacheReadTokens;
+      return /* @__PURE__ */ jsxs2(Box2, { flexDirection: "column", paddingX: 1, paddingY: 0, children: [
+        /* @__PURE__ */ jsxs2(
+          Text2,
+          {
+            color: isSelected ? colors.bright : colors.text,
+            bold: isSelected,
+            backgroundColor: isSelected ? colors.selected : void 0,
+            children: [
+              indicator,
+              " ",
+              displayName
+            ]
+          }
+        ),
+        session.nickname && /* @__PURE__ */ jsxs2(Text2, { color: colors.muted, children: [
+          "  ",
+          session.slug
+        ] }),
+        /* @__PURE__ */ jsxs2(Text2, { color: colors.muted, children: [
+          "  ",
+          formatProject(session.project),
+          " | ",
+          formatModel(session.model)
+        ] }),
+        /* @__PURE__ */ jsxs2(Text2, { color: colors.muted, children: [
+          "  ",
+          "CPU ",
+          session.cpu,
+          "% | ",
+          session.memMB,
+          "MB | ",
+          session.agentCount,
+          " ag"
+        ] }),
+        /* @__PURE__ */ jsxs2(Text2, { color: colors.muted, children: [
+          "  ",
+          formatTokens(totalIn),
+          " in | ",
+          formatTokens(session.usage.outputTokens),
+          " out"
+        ] })
+      ] }, session.sessionId);
+    })
+  ] });
+});
+
+// src/ui/components/ActivityFeed.tsx
+import React3 from "react";
+import { Box as Box3, Text as Text3 } from "ink";
+import { jsx as jsx3, jsxs as jsxs3 } from "react/jsx-runtime";
+var formatTime = (ts) => {
+  const d = new Date(ts);
+  return d.toLocaleTimeString("en-GB", { hour12: false });
+};
+var summarizeInput = (call) => {
+  const input = call.toolInput;
+  switch (call.toolName) {
+    case "Bash":
+      return String(input.command || "").slice(0, 50);
+    case "Read":
+    case "Write":
+    case "Edit":
+      return String(input.file_path || "").split("/").slice(-2).join("/");
+    case "Grep":
+      return `pattern="${String(input.pattern || "").slice(0, 30)}"`;
+    case "Glob":
+      return String(input.pattern || "").slice(0, 40);
+    case "Task":
+      return String(input.description || "").slice(0, 40);
+    case "WebFetch":
+    case "WebSearch":
+      return String(input.url || input.query || "").slice(0, 40);
+    default:
+      return JSON.stringify(input).slice(0, 40);
+  }
+};
+var ActivityFeed = React3.memo(
+  ({ events, sessionSlug, focused, height, scrollOffset }) => {
+    const viewportRows = height - 2;
+    const totalEvents = events.length;
+    const start = Math.max(0, totalEvents - viewportRows - scrollOffset);
+    const end = start + viewportRows;
+    const visible = events.slice(start, end);
+    const isAtBottom = scrollOffset === 0;
+    const isAtTop = start === 0;
+    const canScroll = totalEvents > viewportRows;
+    return /* @__PURE__ */ jsxs3(
+      Box3,
+      {
+        flexDirection: "column",
+        flexGrow: 1,
+        borderStyle: "single",
+        borderColor: focused ? colors.primary : colors.border,
+        children: [
+          /* @__PURE__ */ jsxs3(Box3, { paddingX: 1, justifyContent: "space-between", children: [
+            /* @__PURE__ */ jsxs3(Box3, { children: [
+              /* @__PURE__ */ jsx3(Text3, { color: colors.header, bold: true, children: "ACTIVITY" }),
+              sessionSlug && /* @__PURE__ */ jsxs3(Text3, { color: colors.muted, children: [
+                " (",
+                sessionSlug,
+                ")"
+              ] })
+            ] }),
+            focused && canScroll && !isAtBottom && /* @__PURE__ */ jsxs3(Text3, { color: colors.muted, children: [
+              "[",
+              totalEvents - end + viewportRows,
+              "/",
+              totalEvents,
+              "]"
+            ] })
+          ] }),
+          visible.length === 0 && /* @__PURE__ */ jsx3(Box3, { paddingX: 1, paddingY: 1, children: /* @__PURE__ */ jsx3(Text3, { color: colors.muted, italic: true, children: sessionSlug ? "Waiting for activity..." : "Select a session" }) }),
+          visible.map((event, i) => /* @__PURE__ */ jsxs3(Box3, { paddingX: 1, children: [
+            /* @__PURE__ */ jsxs3(Text3, { color: colors.muted, children: [
+              formatTime(event.timestamp),
+              " "
+            ] }),
+            /* @__PURE__ */ jsx3(Text3, { color: getToolColor(event.toolName), bold: true, children: event.toolName.padEnd(8) }),
+            /* @__PURE__ */ jsxs3(Text3, { color: colors.text, children: [
+              " ",
+              summarizeInput(event)
+            ] })
+          ] }, `${event.timestamp}-${i}`)),
+          focused && canScroll && !isAtTop && visible.length > 0 && /* @__PURE__ */ jsx3(Box3, { paddingX: 1, justifyContent: "flex-end", children: /* @__PURE__ */ jsx3(Text3, { color: colors.muted, children: isAtBottom ? "" : "G:bottom " }) })
+        ]
+      }
+    );
+  }
+);
+
+// src/ui/components/AlertBar.tsx
+import React4 from "react";
+import { Box as Box4, Text as Text4 } from "ink";
+import { jsx as jsx4, jsxs as jsxs4 } from "react/jsx-runtime";
+var formatTime2 = (ts) => {
+  const d = new Date(ts);
+  return d.toLocaleTimeString("en-GB", { hour12: false });
+};
+var severityIcon = {
+  info: "i",
+  warn: "!",
+  high: "!!",
+  critical: "!!!"
+};
+var AlertBar = React4.memo(({ alerts, maxVisible = 4 }) => {
+  const visible = alerts.slice(-maxVisible);
+  return /* @__PURE__ */ jsxs4(Box4, { flexDirection: "column", borderStyle: "single", borderColor: alerts.length > 0 ? colors.error : colors.border, children: [
+    /* @__PURE__ */ jsxs4(Box4, { paddingX: 1, children: [
+      /* @__PURE__ */ jsx4(Text4, { color: colors.error, bold: true, children: "ALERTS" }),
+      alerts.length === 0 && /* @__PURE__ */ jsx4(Text4, { color: colors.muted, children: " (none)" })
+    ] }),
+    visible.map((alert, i) => /* @__PURE__ */ jsxs4(Box4, { paddingX: 1, children: [
+      /* @__PURE__ */ jsxs4(Text4, { color: severityColors[alert.severity] || colors.text, children: [
+        "[",
+        severityIcon[alert.severity] || "?",
+        "]"
+      ] }),
+      /* @__PURE__ */ jsxs4(Text4, { color: colors.muted, children: [
+        " ",
+        formatTime2(alert.timestamp),
+        " "
+      ] }),
+      /* @__PURE__ */ jsxs4(Text4, { color: colors.warning, children: [
+        alert.sessionSlug,
+        ": "
+      ] }),
+      /* @__PURE__ */ jsx4(Text4, { color: colors.text, children: alert.message.slice(0, 60) })
+    ] }, alert.id || i))
+  ] });
+});
+
+// src/ui/components/SessionDetail.tsx
+import React5 from "react";
+import { Box as Box5, Text as Text5 } from "ink";
+import { jsx as jsx5, jsxs as jsxs5 } from "react/jsx-runtime";
+var formatTokens2 = (n) => {
+  if (n >= 1e6) return (n / 1e6).toFixed(1) + "M";
+  if (n >= 1e3) return (n / 1e3).toFixed(1) + "k";
+  return String(n);
+};
+var formatUptime = (startTime) => {
+  const ms = Date.now() - startTime;
+  const secs = Math.floor(ms / 1e3);
+  const mins = Math.floor(secs / 60);
+  const hours = Math.floor(mins / 60);
+  if (hours > 0) return `${hours}h ${mins % 60}m`;
+  if (mins > 0) return `${mins}m ${secs % 60}s`;
+  return `${secs}s`;
+};
+var formatModel2 = (model) => {
+  if (model.includes("opus")) return "opus";
+  if (model.includes("sonnet")) return "sonnet";
+  if (model.includes("haiku")) return "haiku";
+  return model.slice(0, 20);
+};
+var SessionDetail = React5.memo(({ session, focused }) => {
+  const totalInput = session.usage.inputTokens + session.usage.cacheCreationTokens + session.usage.cacheReadTokens;
+  const totalTokens = totalInput + session.usage.outputTokens;
+  const cacheHitRate = totalInput > 0 ? (session.usage.cacheReadTokens / totalInput * 100).toFixed(0) : "0";
+  return /* @__PURE__ */ jsxs5(
+    Box5,
+    {
+      flexDirection: "column",
+      flexGrow: 1,
+      borderStyle: "single",
+      borderColor: focused ? colors.primary : colors.border,
+      children: [
+        /* @__PURE__ */ jsxs5(Box5, { paddingX: 1, children: [
+          /* @__PURE__ */ jsx5(Text5, { color: colors.header, bold: true, children: "SESSION DETAIL" }),
+          /* @__PURE__ */ jsx5(Text5, { color: colors.muted, children: " (Esc to return)" })
+        ] }),
+        /* @__PURE__ */ jsxs5(Box5, { flexDirection: "column", paddingX: 2, paddingY: 1, children: [
+          /* @__PURE__ */ jsxs5(Box5, { children: [
+            /* @__PURE__ */ jsx5(Text5, { color: colors.muted, children: "slug:      " }),
+            /* @__PURE__ */ jsx5(Text5, { color: colors.bright, bold: true, children: session.slug })
+          ] }),
+          session.nickname && /* @__PURE__ */ jsxs5(Box5, { children: [
+            /* @__PURE__ */ jsx5(Text5, { color: colors.muted, children: "nickname:  " }),
+            /* @__PURE__ */ jsx5(Text5, { color: colors.secondary, children: session.nickname })
+          ] }),
+          /* @__PURE__ */ jsxs5(Box5, { children: [
+            /* @__PURE__ */ jsx5(Text5, { color: colors.muted, children: "model:     " }),
+            /* @__PURE__ */ jsx5(Text5, { color: colors.text, children: formatModel2(session.model) })
+          ] }),
+          /* @__PURE__ */ jsxs5(Box5, { children: [
+            /* @__PURE__ */ jsx5(Text5, { color: colors.muted, children: "cwd:       " }),
+            /* @__PURE__ */ jsx5(Text5, { color: colors.text, children: session.cwd })
+          ] }),
+          session.gitBranch && /* @__PURE__ */ jsxs5(Box5, { children: [
+            /* @__PURE__ */ jsx5(Text5, { color: colors.muted, children: "branch:    " }),
+            /* @__PURE__ */ jsx5(Text5, { color: colors.secondary, children: session.gitBranch })
+          ] }),
+          /* @__PURE__ */ jsxs5(Box5, { children: [
+            /* @__PURE__ */ jsx5(Text5, { color: colors.muted, children: "version:   " }),
+            /* @__PURE__ */ jsx5(Text5, { color: colors.text, children: session.version || "unknown" })
+          ] }),
+          /* @__PURE__ */ jsxs5(Box5, { children: [
+            /* @__PURE__ */ jsx5(Text5, { color: colors.muted, children: "pid:       " }),
+            /* @__PURE__ */ jsx5(Text5, { color: colors.text, children: session.pid ?? "not running" })
+          ] }),
+          /* @__PURE__ */ jsxs5(Box5, { children: [
+            /* @__PURE__ */ jsx5(Text5, { color: colors.muted, children: "cpu:       " }),
+            /* @__PURE__ */ jsxs5(Text5, { color: colors.text, children: [
+              session.cpu,
+              "%"
+            ] })
+          ] }),
+          /* @__PURE__ */ jsxs5(Box5, { children: [
+            /* @__PURE__ */ jsx5(Text5, { color: colors.muted, children: "memory:    " }),
+            /* @__PURE__ */ jsxs5(Text5, { color: colors.text, children: [
+              session.memMB,
+              "MB"
+            ] })
+          ] }),
+          /* @__PURE__ */ jsxs5(Box5, { children: [
+            /* @__PURE__ */ jsx5(Text5, { color: colors.muted, children: "uptime:    " }),
+            /* @__PURE__ */ jsx5(Text5, { color: colors.text, children: formatUptime(session.startTime) })
+          ] }),
+          /* @__PURE__ */ jsxs5(Box5, { children: [
+            /* @__PURE__ */ jsx5(Text5, { color: colors.muted, children: "agents:    " }),
+            /* @__PURE__ */ jsx5(Text5, { color: colors.text, children: session.agentCount })
+          ] }),
+          /* @__PURE__ */ jsx5(Box5, { marginTop: 1, children: /* @__PURE__ */ jsx5(Text5, { color: colors.header, bold: true, children: "Token usage" }) }),
+          /* @__PURE__ */ jsxs5(Box5, { children: [
+            /* @__PURE__ */ jsx5(Text5, { color: colors.muted, children: "  input:       " }),
+            /* @__PURE__ */ jsx5(Text5, { color: colors.text, children: formatTokens2(session.usage.inputTokens) })
+          ] }),
+          /* @__PURE__ */ jsxs5(Box5, { children: [
+            /* @__PURE__ */ jsx5(Text5, { color: colors.muted, children: "  output:      " }),
+            /* @__PURE__ */ jsx5(Text5, { color: colors.text, children: formatTokens2(session.usage.outputTokens) })
+          ] }),
+          /* @__PURE__ */ jsxs5(Box5, { children: [
+            /* @__PURE__ */ jsx5(Text5, { color: colors.muted, children: "  cache write:  " }),
+            /* @__PURE__ */ jsx5(Text5, { color: colors.text, children: formatTokens2(session.usage.cacheCreationTokens) })
+          ] }),
+          /* @__PURE__ */ jsxs5(Box5, { children: [
+            /* @__PURE__ */ jsx5(Text5, { color: colors.muted, children: "  cache read:   " }),
+            /* @__PURE__ */ jsx5(Text5, { color: colors.text, children: formatTokens2(session.usage.cacheReadTokens) })
+          ] }),
+          /* @__PURE__ */ jsxs5(Box5, { children: [
+            /* @__PURE__ */ jsx5(Text5, { color: colors.muted, children: "  cache hit:    " }),
+            /* @__PURE__ */ jsxs5(Text5, { color: session.usage.cacheReadTokens > 0 ? colors.secondary : colors.text, children: [
+              cacheHitRate,
+              "%"
+            ] })
+          ] }),
+          /* @__PURE__ */ jsxs5(Box5, { children: [
+            /* @__PURE__ */ jsx5(Text5, { color: colors.muted, children: "  total:        " }),
+            /* @__PURE__ */ jsx5(Text5, { color: colors.bright, bold: true, children: formatTokens2(totalTokens) })
+          ] })
+        ] })
+      ]
+    }
+  );
+});
+
+// src/ui/components/SetupModal.tsx
+import React6, { useState as useState2 } from "react";
+import { Box as Box6, Text as Text6, useInput } from "ink";
+import { jsx as jsx6, jsxs as jsxs6 } from "react/jsx-runtime";
+var OPTIONS = [
+  { label: "Yes", value: "yes" },
+  { label: "Not now", value: "not_now" },
+  { label: "Don't ask again", value: "dismiss" }
+];
+var SetupModal = React6.memo(({ steps, onComplete }) => {
+  const [stepIndex, setStepIndex] = useState2(0);
+  const [selectedOption, setSelectedOption] = useState2(0);
+  const [results, setResults] = useState2([]);
+  const step = steps[stepIndex];
+  useInput((_input, key) => {
+    if (key.upArrow) {
+      setSelectedOption((i) => Math.max(0, i - 1));
+    }
+    if (key.downArrow) {
+      setSelectedOption((i) => Math.min(OPTIONS.length - 1, i + 1));
+    }
+    if (key.return) {
+      const choice = OPTIONS[selectedOption].value;
+      const newResults = [...results, choice];
+      if (stepIndex + 1 >= steps.length) {
+        onComplete(newResults);
+      } else {
+        setResults(newResults);
+        setStepIndex(stepIndex + 1);
+        setSelectedOption(0);
+      }
+    }
+  });
+  if (!step) return null;
+  return /* @__PURE__ */ jsx6(Box6, { flexDirection: "column", paddingX: 4, paddingY: 2, children: /* @__PURE__ */ jsxs6(Box6, { borderStyle: "round", borderColor: colors.primary, flexDirection: "column", paddingX: 3, paddingY: 1, children: [
+    /* @__PURE__ */ jsx6(Box6, { marginBottom: 1, children: /* @__PURE__ */ jsxs6(Text6, { color: colors.header, bold: true, children: [
+      "agenttop setup (",
+      stepIndex + 1,
+      "/",
+      steps.length,
+      ")"
+    ] }) }),
+    /* @__PURE__ */ jsx6(Box6, { marginBottom: 1, children: /* @__PURE__ */ jsx6(Text6, { color: colors.bright, bold: true, children: step.title }) }),
+    /* @__PURE__ */ jsx6(Box6, { marginBottom: 1, children: /* @__PURE__ */ jsx6(Text6, { color: colors.text, children: step.description }) }),
+    OPTIONS.map((opt, i) => /* @__PURE__ */ jsx6(Box6, { children: /* @__PURE__ */ jsxs6(Text6, { color: i === selectedOption ? colors.primary : colors.muted, children: [
+      i === selectedOption ? "> " : "  ",
+      opt.label
+    ] }) }, opt.value)),
+    /* @__PURE__ */ jsx6(Box6, { marginTop: 1, children: /* @__PURE__ */ jsx6(Text6, { color: colors.muted, children: "Use arrow keys + Enter to select" }) })
+  ] }) });
+});
+
+// src/ui/components/FooterBar.tsx
+import React7 from "react";
+import { Box as Box7, Text as Text7 } from "ink";
+import { jsx as jsx7, jsxs as jsxs7 } from "react/jsx-runtime";
+var label = (key) => {
+  if (key === "tab") return "tab";
+  if (key === "shift+tab") return "S-tab";
+  if (key === "enter") return "enter";
+  return key;
+};
+var FooterBar = React7.memo(({ keybindings, updateStatus }) => /* @__PURE__ */ jsxs7(Box7, { paddingX: 1, children: [
+  /* @__PURE__ */ jsx7(Box7, { marginRight: 2, children: /* @__PURE__ */ jsxs7(Text7, { color: "#5C6370", children: [
+    label(keybindings.quit),
+    ":quit"
+  ] }) }),
+  /* @__PURE__ */ jsx7(Box7, { marginRight: 2, children: /* @__PURE__ */ jsxs7(Text7, { color: "#5C6370", children: [
+    label(keybindings.navDown),
+    "/",
+    label(keybindings.navUp),
+    ":nav"
+  ] }) }),
+  /* @__PURE__ */ jsx7(Box7, { marginRight: 2, children: /* @__PURE__ */ jsxs7(Text7, { color: "#5C6370", children: [
+    label(keybindings.panelNext),
+    ":panel"
+  ] }) }),
+  /* @__PURE__ */ jsx7(Box7, { marginRight: 2, children: /* @__PURE__ */ jsxs7(Text7, { color: "#5C6370", children: [
+    label(keybindings.filter),
+    ":filter"
+  ] }) }),
+  /* @__PURE__ */ jsx7(Box7, { marginRight: 2, children: /* @__PURE__ */ jsxs7(Text7, { color: "#5C6370", children: [
+    label(keybindings.nickname),
+    ":name"
+  ] }) }),
+  /* @__PURE__ */ jsx7(Box7, { marginRight: 2, children: /* @__PURE__ */ jsxs7(Text7, { color: "#5C6370", children: [
+    label(keybindings.detail),
+    ":detail"
+  ] }) }),
+  updateStatus && /* @__PURE__ */ jsx7(Box7, { marginRight: 2, children: /* @__PURE__ */ jsx7(Text7, { color: colors.secondary, children: updateStatus }) })
+] }));
+
+// src/ui/hooks/useSessions.ts
+import { useState as useState3, useEffect as useEffect2, useCallback, useRef } from "react";
+var ACTIVE_POLL_MS = 1e4;
+var IDLE_POLL_MS = 3e4;
+var useSessions = (allUsers, filter) => {
+  const [sessions, setSessions] = useState3([]);
+  const [selectedIndex, setSelectedIndex] = useState3(0);
+  const usageOverrides = useRef(/* @__PURE__ */ new Map());
+  const refresh = useCallback(() => {
+    const found = discoverSessions(allUsers);
+    const nicknames = getNicknames();
+    const enriched = found.map((s) => {
+      const override = usageOverrides.current.get(s.sessionId);
+      return {
+        ...s,
+        nickname: nicknames[s.sessionId],
+        usage: override ? {
+          inputTokens: s.usage.inputTokens + override.inputTokens,
+          cacheCreationTokens: s.usage.cacheCreationTokens + override.cacheCreationTokens,
+          cacheReadTokens: s.usage.cacheReadTokens + override.cacheReadTokens,
+          outputTokens: s.usage.outputTokens + override.outputTokens
+        } : s.usage
+      };
+    });
+    let filtered = enriched;
+    if (filter) {
+      const lower = filter.toLowerCase();
+      filtered = enriched.filter(
+        (s) => s.slug.toLowerCase().includes(lower) || s.nickname?.toLowerCase().includes(lower) || s.project.toLowerCase().includes(lower) || s.model.toLowerCase().includes(lower)
+      );
+    }
+    setSessions(filtered);
+  }, [allUsers, filter]);
+  useEffect2(() => {
+    refresh();
+    const pollMs = sessions.length > 0 ? ACTIVE_POLL_MS : IDLE_POLL_MS;
+    const interval = setInterval(refresh, pollMs);
+    return () => clearInterval(interval);
+  }, [refresh, sessions.length > 0]);
+  const selectedSession = sessions[selectedIndex] ?? null;
+  const selectNext = useCallback(() => {
+    setSelectedIndex((i) => Math.min(i + 1, Math.max(0, sessions.length - 1)));
+  }, [sessions.length]);
+  const selectPrev = useCallback(() => {
+    setSelectedIndex((i) => Math.max(i - 1, 0));
+  }, []);
+  const selectIndex = useCallback((i) => {
+    setSelectedIndex(i);
+  }, []);
+  const addUsage = useCallback((sessionId, usage) => {
+    const existing = usageOverrides.current.get(sessionId);
+    if (existing) {
+      usageOverrides.current.set(sessionId, {
+        inputTokens: existing.inputTokens + usage.inputTokens,
+        cacheCreationTokens: existing.cacheCreationTokens + usage.cacheCreationTokens,
+        cacheReadTokens: existing.cacheReadTokens + usage.cacheReadTokens,
+        outputTokens: existing.outputTokens + usage.outputTokens
+      });
+    } else {
+      usageOverrides.current.set(sessionId, usage);
+    }
+  }, []);
+  return { sessions, selectedSession, selectedIndex, selectNext, selectPrev, selectIndex, refresh, addUsage };
+};
+
+// src/ui/hooks/useActivityStream.ts
+import { useState as useState4, useEffect as useEffect3, useRef as useRef2 } from "react";
+var MAX_EVENTS = 200;
+var useActivityStream = (session, allUsers) => {
+  const [events, setEvents] = useState4([]);
+  const watcherRef = useRef2(null);
+  useEffect3(() => {
+    setEvents([]);
+    if (!session) return;
+    const existingCalls = [];
+    const tempWatcher = new Watcher(() => {
+    }, allUsers);
+    for (const file of session.outputFiles) {
+      existingCalls.push(...tempWatcher.readExisting(file));
+    }
+    setEvents(existingCalls.slice(-MAX_EVENTS));
+    const handler = (calls) => {
+      const sessionCalls = calls.filter((c) => c.sessionId === session.sessionId);
+      if (sessionCalls.length === 0) return;
+      setEvents((prev) => [...prev, ...sessionCalls].slice(-MAX_EVENTS));
+    };
+    const watcher = new Watcher(handler, allUsers);
+    watcherRef.current = watcher;
+    watcher.start();
+    return () => {
+      watcher.stop();
+      watcherRef.current = null;
+    };
+  }, [session?.sessionId, allUsers]);
+  return events;
+};
+
+// src/ui/hooks/useAlerts.ts
+import { useState as useState5, useEffect as useEffect4, useRef as useRef3 } from "react";
+
+// src/notifications.ts
+import { exec as exec2 } from "child_process";
+import { platform } from "os";
+var SEVERITY_ORDER = {
+  info: 0,
+  warn: 1,
+  high: 2,
+  critical: 3
+};
+var RATE_LIMIT_MS = 3e4;
+var lastDesktopNotification = 0;
+var notify = (alert, config) => {
+  if (SEVERITY_ORDER[alert.severity] < SEVERITY_ORDER[config.minSeverity]) return;
+  if (config.bell) {
+    process.stdout.write("\x07");
+  }
+  if (config.desktop) {
+    const now = Date.now();
+    if (now - lastDesktopNotification < RATE_LIMIT_MS) return;
+    lastDesktopNotification = now;
+    const title = `agenttop: ${alert.severity} alert`;
+    const body = `${alert.sessionSlug}: ${alert.message.slice(0, 100)}`;
+    const os = platform();
+    if (os === "linux") {
+      exec2(`notify-send ${JSON.stringify(title)} ${JSON.stringify(body)}`, { timeout: 3e3 });
+    } else if (os === "darwin") {
+      exec2(`osascript -e 'display notification ${JSON.stringify(body)} with title ${JSON.stringify(title)}'`, {
+        timeout: 3e3
+      });
+    }
+  }
+};
+
+// src/alerts/logger.ts
+import { appendFileSync, mkdirSync as mkdirSync3 } from "fs";
+import { dirname as dirname3 } from "path";
+var AlertLogger = class {
+  logPath;
+  writeCount = 0;
+  constructor(config) {
+    this.logPath = resolveAlertLogPath(config);
+    mkdirSync3(dirname3(this.logPath), { recursive: true });
+  }
+  log(alert) {
+    const entry = {
+      timestamp: new Date(alert.timestamp).toISOString(),
+      severity: alert.severity,
+      rule: alert.rule,
+      message: alert.message,
+      sessionSlug: alert.sessionSlug,
+      sessionId: alert.sessionId
+    };
+    try {
+      appendFileSync(this.logPath, JSON.stringify(entry) + "\n");
+      this.writeCount++;
+      if (this.writeCount % 100 === 0) {
+        rotateLogFile(this.logPath);
+      }
+    } catch {
+    }
+  }
+};
+
+// src/ui/hooks/useAlerts.ts
+var MAX_ALERTS = 100;
+var useAlerts = (enabled, alertLevel, allUsers, config) => {
+  const [alerts, setAlerts] = useState5([]);
+  const engineRef = useRef3(new SecurityEngine(alertLevel));
+  const watcherRef = useRef3(null);
+  const loggerRef = useRef3(null);
+  useEffect4(() => {
+    if (!enabled) return;
+    engineRef.current = new SecurityEngine(alertLevel);
+    if (config?.alerts.enabled) {
+      loggerRef.current = new AlertLogger(config);
+    }
+    const securityHandler = (events) => {
+      const newAlerts = [];
+      for (const event of events) {
+        newAlerts.push(...engineRef.current.analyzeEvent(event));
+      }
+      if (newAlerts.length > 0) {
+        for (const alert of newAlerts) {
+          if (config) {
+            notify(alert, config.notifications);
+          }
+          loggerRef.current?.log(alert);
+        }
+        setAlerts((prev) => [...prev, ...newAlerts].slice(-MAX_ALERTS));
+      }
+    };
+    const watcher = new Watcher(() => {
+    }, allUsers, securityHandler);
+    watcherRef.current = watcher;
+    watcher.start();
+    return () => {
+      watcher.stop();
+      watcherRef.current = null;
+      loggerRef.current = null;
+    };
+  }, [enabled, alertLevel, allUsers]);
+  const clearAlerts = () => setAlerts([]);
+  return { alerts, clearAlerts };
+};
+
+// src/ui/hooks/useTextInput.ts
+import { useState as useState6, useCallback as useCallback2 } from "react";
+var useTextInput = (onConfirm) => {
+  const [value, setValue] = useState6("");
+  const [isActive, setIsActive] = useState6(false);
+  const start = useCallback2((initial = "") => {
+    setValue(initial);
+    setIsActive(true);
+  }, []);
+  const cancel = useCallback2(() => {
+    setValue("");
+    setIsActive(false);
+  }, []);
+  const confirm = useCallback2(() => {
+    const result = value;
+    setIsActive(false);
+    setValue("");
+    onConfirm?.(result);
+    return result;
+  }, [value, onConfirm]);
+  const handleInput = useCallback2(
+    (input, key) => {
+      if (!isActive) return false;
+      if (key.escape) {
+        cancel();
+        return true;
+      }
+      if (key.return) {
+        confirm();
+        return true;
+      }
+      if (key.backspace || key.delete) {
+        setValue((v) => v.slice(0, -1));
+        return true;
+      }
+      if (input && input.length === 1 && input >= " ") {
+        setValue((v) => v + input);
+        return true;
+      }
+      return true;
+    },
+    [isActive, cancel, confirm]
+  );
+  return { value, isActive, start, cancel, confirm, handleInput };
+};
+
+// src/ui/App.tsx
+import { jsx as jsx8, jsxs as jsxs8 } from "react/jsx-runtime";
+var matchKey = (binding, input, key) => {
+  if (binding === "tab") return Boolean(key.tab);
+  if (binding === "shift+tab") return Boolean(key.shift && key.tab);
+  if (binding === "enter") return Boolean(key.return);
+  return input === binding;
+};
+var App = ({ options, config, version, firstRun }) => {
+  const { exit } = useApp();
+  const { stdout } = useStdout();
+  const termHeight = stdout?.rows ?? 40;
+  const kb = config.keybindings;
+  const [activePanel, setActivePanel] = useState7("sessions");
+  const [activityScroll, setActivityScroll] = useState7(0);
+  const [inputMode, setInputMode] = useState7("normal");
+  const [showSetup, setShowSetup] = useState7(firstRun);
+  const [filter, setFilter] = useState7("");
+  const [updateInfo, setUpdateInfo] = useState7(null);
+  const [updateStatus, setUpdateStatus] = useState7("");
+  const [showDetail, setShowDetail] = useState7(false);
+  const { sessions, selectedSession, selectedIndex, selectNext, selectPrev } = useSessions(
+    options.allUsers,
+    filter || void 0
+  );
+  const events = useActivityStream(selectedSession, options.allUsers);
+  const { alerts } = useAlerts(!options.noSecurity, options.alertLevel, options.allUsers, config);
+  const nicknameInput = useTextInput((value) => {
+    if (selectedSession && value.trim()) setNickname(selectedSession.sessionId, value.trim());
+    setInputMode("normal");
+  });
+  const filterInput = useTextInput((value) => {
+    setFilter(value);
+    setInputMode("normal");
+  });
+  useEffect5(() => {
+    if (options.noUpdates || !config.updates.checkOnLaunch) return;
+    try {
+      const i = checkForUpdate();
+      if (i.available) setUpdateInfo(i);
+    } catch {
+    }
+    const iv = setInterval(() => {
+      try {
+        const i = checkForUpdate();
+        if (i.available) setUpdateInfo(i);
+      } catch {
+      }
+    }, config.updates.checkInterval);
+    return () => clearInterval(iv);
+  }, []);
+  const alertHeight = options.noSecurity ? 0 : 6;
+  const mainHeight = termHeight - 3 - alertHeight - 1 - (inputMode !== "normal" ? 1 : 0);
+  const viewportRows = mainHeight - 2;
+  const maxScroll = Math.max(0, events.length - viewportRows);
+  useEffect5(() => {
+    setActivityScroll(0);
+  }, [selectedSession?.sessionId]);
+  const handleSetupComplete = useCallback3(
+    (results) => {
+      const nc = { ...config };
+      const [hc, mc] = results;
+      if (hc === "yes") {
+        try {
+          installHooks();
+        } catch {
+        }
+        nc.prompts.hook = "installed";
+      } else if (hc === "dismiss") nc.prompts.hook = "dismissed";
+      if (mc === "yes") {
+        try {
+          installMcpConfig();
+        } catch {
+        }
+        nc.prompts.mcp = "installed";
+      } else if (mc === "dismiss") nc.prompts.mcp = "dismissed";
+      saveConfig(nc);
+      setShowSetup(false);
+    },
+    [config]
+  );
+  const switchPanel = useCallback3((_dir) => {
+    setActivePanel((p) => p === "sessions" ? "activity" : "sessions");
+  }, []);
+  useInput2((input, key) => {
+    if (showSetup) return;
+    if (inputMode === "nickname") {
+      nicknameInput.handleInput(input, key);
+      return;
+    }
+    if (inputMode === "filter") {
+      if (key.escape) {
+        setFilter("");
+        setInputMode("normal");
+        filterInput.cancel();
+        return;
+      }
+      filterInput.handleInput(input, key);
+      return;
+    }
+    if (matchKey(kb.quit, input, key)) {
+      exit();
+      return;
+    }
+    if (showDetail) {
+      if (key.escape || key.return || key.leftArrow) {
+        setShowDetail(false);
+      }
+      return;
+    }
+    if (matchKey(kb.detail, input, key) && selectedSession && activePanel === "sessions") {
+      setShowDetail(true);
+      return;
+    }
+    if (matchKey(kb.panelNext, input, key) || key.rightArrow) {
+      switchPanel("next");
+      return;
+    }
+    if (matchKey(kb.panelPrev, input, key) || key.leftArrow) {
+      switchPanel("prev");
+      return;
+    }
+    if (matchKey(kb.nickname, input, key) && selectedSession) {
+      setInputMode("nickname");
+      nicknameInput.start(selectedSession.nickname || "");
+      return;
+    }
+    if (matchKey(kb.clearNickname, input, key) && selectedSession) {
+      clearNickname(selectedSession.sessionId);
+      return;
+    }
+    if (matchKey(kb.filter, input, key)) {
+      setInputMode("filter");
+      filterInput.start(filter);
+      return;
+    }
+    if (key.escape && filter) {
+      setFilter("");
+      return;
+    }
+    if (matchKey(kb.update, input, key) && updateInfo?.available) {
+      setUpdateStatus("updating...");
+      installUpdate().then(() => setUpdateStatus(`updated to v${updateInfo.latest} \u2014 restart to apply`)).catch(() => setUpdateStatus("update failed"));
+      return;
+    }
+    if (activePanel === "sessions") {
+      if (matchKey(kb.navDown, input, key) || key.downArrow) selectNext();
+      if (matchKey(kb.navUp, input, key) || key.upArrow) selectPrev();
+    }
+    if (activePanel === "activity") {
+      if (matchKey(kb.navUp, input, key) || key.upArrow) setActivityScroll((s) => Math.min(s + 1, maxScroll));
+      if (matchKey(kb.navDown, input, key) || key.downArrow) setActivityScroll((s) => Math.max(s - 1, 0));
+      if (matchKey(kb.scrollBottom, input, key) || key.end) setActivityScroll(0);
+      if (matchKey(kb.scrollTop, input, key) || key.home) setActivityScroll(maxScroll);
+    }
+  });
+  if (showSetup) {
+    const steps = [];
+    if (config.prompts.hook === "pending")
+      steps.push({
+        title: "Install Claude Code hook?",
+        description: "Adds a PostToolUse hook that blocks prompt injection attempts in real-time."
+      });
+    if (config.prompts.mcp === "pending")
+      steps.push({
+        title: "Install MCP server?",
+        description: "Registers agenttop as an MCP server so Claude Code can query session status and alerts."
+      });
+    if (steps.length === 0) {
+      setShowSetup(false);
+      return null;
+    }
+    return /* @__PURE__ */ jsx8(SetupModal, { steps, onComplete: handleSetupComplete });
+  }
+  const rightPanel = showDetail && selectedSession ? /* @__PURE__ */ jsx8(SessionDetail, { session: selectedSession, focused: activePanel === "activity", height: mainHeight }) : /* @__PURE__ */ jsx8(
+    ActivityFeed,
+    {
+      events,
+      sessionSlug: selectedSession?.slug ?? null,
+      focused: activePanel === "activity",
+      height: mainHeight,
+      scrollOffset: activityScroll
+    }
+  );
+  return /* @__PURE__ */ jsxs8(Box8, { flexDirection: "column", height: termHeight, children: [
+    /* @__PURE__ */ jsx8(StatusBar, { sessionCount: sessions.length, alertCount: alerts.length, version, updateInfo }),
+    /* @__PURE__ */ jsxs8(Box8, { flexGrow: 1, height: mainHeight, children: [
+      /* @__PURE__ */ jsx8(
+        SessionList,
+        {
+          sessions,
+          selectedIndex,
+          focused: activePanel === "sessions",
+          filter: filter || void 0
+        }
+      ),
+      rightPanel
+    ] }),
+    !options.noSecurity && /* @__PURE__ */ jsx8(AlertBar, { alerts }),
+    inputMode === "nickname" && /* @__PURE__ */ jsxs8(Box8, { paddingX: 1, children: [
+      /* @__PURE__ */ jsx8(Text8, { color: colors.primary, children: "nickname: " }),
+      /* @__PURE__ */ jsx8(Text8, { color: colors.bright, children: nicknameInput.value }),
+      /* @__PURE__ */ jsx8(Text8, { color: colors.muted, children: "_" })
+    ] }),
+    inputMode === "filter" && /* @__PURE__ */ jsxs8(Box8, { paddingX: 1, children: [
+      /* @__PURE__ */ jsx8(Text8, { color: colors.primary, children: "/" }),
+      /* @__PURE__ */ jsx8(Text8, { color: colors.bright, children: filterInput.value }),
+      /* @__PURE__ */ jsx8(Text8, { color: colors.muted, children: "_" })
+    ] }),
+    inputMode === "normal" && /* @__PURE__ */ jsx8(FooterBar, { keybindings: kb, updateStatus })
+  ] });
+};
+
+// src/stream.ts
+var write = (msg) => {
+  process.stdout.write(msg + "\n");
+};
+var formatTokens3 = (n) => {
+  if (n >= 1e6) return (n / 1e6).toFixed(1) + "M";
+  if (n >= 1e3) return (n / 1e3).toFixed(1) + "k";
+  return String(n);
+};
+var runStreamMode = (options, isJson) => {
+  const engine = options.noSecurity ? null : new SecurityEngine(options.alertLevel);
+  const sessions = discoverSessions(options.allUsers);
+  if (isJson) {
+    write(JSON.stringify({ type: "sessions", data: sessions }));
+  } else {
+    for (const s of sessions) {
+      write(
+        `SESSION ${s.slug} | ${s.model} | ${s.cwd} | CPU ${s.cpu}% | ${s.memMB}MB | ${formatTokens3(s.usage.inputTokens)} in / ${formatTokens3(s.usage.outputTokens)} out`
+      );
+    }
+  }
+  const handler = (calls) => {
+    for (const call of calls) {
+      if (isJson) {
+        write(JSON.stringify({ type: "tool_call", data: call }));
+      } else {
+        const ts = new Date(call.timestamp).toLocaleTimeString("en-GB", { hour12: false });
+        const input = call.toolName === "Bash" ? String(call.toolInput.command || "").slice(0, 80) : JSON.stringify(call.toolInput).slice(0, 80);
+        write(`${ts} ${call.slug} ${call.toolName.padEnd(8)} ${input}`);
+      }
+    }
+  };
+  const securityHandler = engine ? (events) => {
+    for (const event of events) {
+      const alerts = engine.analyzeEvent(event);
+      for (const alert of alerts) {
+        if (isJson) {
+          write(JSON.stringify({ type: "alert", data: alert }));
+        } else {
+          const ts = new Date(alert.timestamp).toLocaleTimeString("en-GB", { hour12: false });
+          write(`ALERT ${ts} [${alert.severity}] ${alert.sessionSlug}: ${alert.message}`);
+        }
+      }
+    }
+  } : void 0;
+  const usageHandler = (sessionId, usage) => {
+    if (isJson) {
+      write(JSON.stringify({ type: "usage", data: { sessionId, usage } }));
+    } else {
+      write(
+        `USAGE ${sessionId.slice(0, 12)} +${formatTokens3(usage.inputTokens)} in / +${formatTokens3(usage.outputTokens)} out`
+      );
+    }
+  };
+  const watcher = new Watcher(handler, options.allUsers, securityHandler, usageHandler);
+  watcher.start();
+  process.on("SIGINT", () => {
+    watcher.stop();
+    process.exit(0);
+  });
+  process.on("SIGTERM", () => {
+    watcher.stop();
+    process.exit(0);
+  });
+};
+
+// src/index.tsx
+var getVersion = () => {
+  try {
+    const thisFile = fileURLToPath3(import.meta.url);
+    const pkgPath = join4(dirname4(thisFile), "..", "package.json");
+    const pkg = JSON.parse(readFileSync4(pkgPath, "utf-8"));
+    return pkg.version || "0.0.0";
+  } catch {
+    return "0.0.0";
+  }
+};
+var VERSION = getVersion();
+var HELP = `agenttop v${VERSION} -- Real-time dashboard for AI coding agent sessions
+
+Usage: agenttop [options]
+
+Options:
+  --all-users          Monitor all users (root only)
+  --no-security        Disable security analysis
+  --json               Stream events as JSON lines (no TUI)
+  --plain              Stream events as plain text (no TUI)
+  --alert-level <l>    Minimum: info|warn|high|critical (default: warn)
+  --no-notify          Disable all notifications
+  --no-alert-log       Disable alert file logging
+  --no-updates         Disable update checks
+  --poll-interval <ms> Session discovery interval (default: 10000)
+  --mcp                Start as MCP server (for Claude Code integration)
+  --install-mcp        Register agenttop as MCP server in Claude Code
+  --install-hooks      Install Claude Code PostToolUse hook for active protection
+  --uninstall-hooks    Remove agenttop hooks from Claude Code
+  --version            Show version
+  --help               Show this help
+
+Streaming modes (--json / --plain):
+  Stream session events to stdout for piping into other tools.
+  --json outputs one JSON object per line (JSONL format).
+  --plain outputs human-readable lines.
+
+  Examples:
+    agenttop --json | jq 'select(.type == "alert")'
+    agenttop --plain | grep ALERT
+    agenttop --json --no-security   # stream tool calls only
+`;
+var write2 = (msg) => {
+  process.stdout.write(msg + "\n");
+};
+var parseArgs = (argv) => {
+  const args = argv.slice(2);
+  const options = {
+    allUsers: false,
+    noSecurity: false,
+    json: false,
+    plain: false,
+    alertLevel: "warn",
+    installHooks: false,
+    uninstallHooks: false,
+    help: false,
+    version: false,
+    noNotify: false,
+    noAlertLog: false,
+    noUpdates: false,
+    pollInterval: 1e4,
+    mcp: false,
+    installMcp: false
+  };
+  for (let i = 0; i < args.length; i++) {
+    switch (args[i]) {
+      case "--all-users":
+        options.allUsers = true;
+        break;
+      case "--no-security":
+        options.noSecurity = true;
+        break;
+      case "--json":
+        options.json = true;
+        break;
+      case "--plain":
+        options.plain = true;
+        break;
+      case "--alert-level":
+        i++;
+        if (["info", "warn", "high", "critical"].includes(args[i])) {
+          options.alertLevel = args[i];
+        }
+        break;
+      case "--no-notify":
+        options.noNotify = true;
+        break;
+      case "--no-alert-log":
+        options.noAlertLog = true;
+        break;
+      case "--no-updates":
+        options.noUpdates = true;
+        break;
+      case "--poll-interval":
+        i++;
+        {
+          const n = parseInt(args[i], 10);
+          if (n > 0) options.pollInterval = n;
+        }
+        break;
+      case "--mcp":
+        options.mcp = true;
+        break;
+      case "--install-mcp":
+        options.installMcp = true;
+        break;
+      case "--install-hooks":
+        options.installHooks = true;
+        break;
+      case "--uninstall-hooks":
+        options.uninstallHooks = true;
+        break;
+      case "--version":
+        options.version = true;
+        break;
+      case "--help":
+        options.help = true;
+        break;
+    }
+  }
+  return options;
+};
+var main = () => {
+  const options = parseArgs(process.argv);
+  if (options.version) {
+    write2(`agenttop v${VERSION}`);
+    process.exit(0);
+  }
+  if (options.help) {
+    write2(HELP);
+    process.exit(0);
+  }
+  if (options.installHooks) {
+    installHooks();
+    process.exit(0);
+  }
+  if (options.uninstallHooks) {
+    uninstallHooks();
+    process.exit(0);
+  }
+  if (options.installMcp) {
+    installMcpConfig();
+    process.exit(0);
+  }
+  if (options.mcp) {
+    startMcpServer(options.allUsers, options.noSecurity).catch((err) => {
+      process.stderr.write(`mcp server error: ${err}
+`);
+      process.exit(1);
+    });
+    return;
+  }
+  if (options.json || options.plain) {
+    runStreamMode(options, options.json);
+    return;
+  }
+  const config = loadConfig();
+  const firstRun = isFirstRun();
+  if (options.noNotify) {
+    config.notifications.bell = false;
+    config.notifications.desktop = false;
+  }
+  if (options.noAlertLog) config.alerts.enabled = false;
+  if (options.noUpdates) config.updates.checkOnLaunch = false;
+  if (options.noSecurity) config.security.enabled = false;
+  if (firstRun) saveConfig(config);
+  render(React9.createElement(App, { options, config, version: VERSION, firstRun }));
+};
+main();
+//# sourceMappingURL=index.js.map