agenter-app 1.0.2 → 1.1.0

package/server.js

@@ -9,6 +9,10 @@ const os = require('node:os');
 const crypto = require('node:crypto');
 const { spawn, execFile } = require('node:child_process');
 const openDashboard = require('./lib/open-dashboard');
+const { truncate, describeTool, readTail, readHead, parseCodexItem, readTranscript, lastAssistantText, transcriptInfo } = require('./lib/transcript');
+const { normalizeLimits, codexWindowLabel } = require('./lib/limits');
+const { buildDiffs } = require('./lib/diff');
+const { getToken, sameToken } = require('./lib/token');
 
 const PORT = Number(process.env.AGENTER_PORT) || 4317;
 const HOST = '127.0.0.1';
@@ -23,6 +27,8 @@ const MAX_ACTIVITY = 200;
 const DISCONNECT_GRACE_MS = 15000;
 // If you switch away from the dashboard (to VS Code, say) this long, same thing.
 const BLUR_GRACE_MS = 5000;
+// While this exists hook.js won't restart the server, so an app you quit stays quit.
+const STOPPED_FILE = path.join(SETTINGS_DIR, 'stopped');
 const DISCOVER_INTERVAL_MS = 30000;
 const DISCOVER_FULL_SCAN_MS = 5 * 60 * 1000; // when a file watcher catches changes in between
 // Plan usage (5-hour session / weekly limits) comes from the same endpoint Claude
@@ -49,224 +55,6 @@ const saveSettings = () => {
   fs.writeFileSync(SETTINGS_FILE, JSON.stringify(settings, null, 2));
 };
 
-// ---------- helpers ----------
-
-const truncate = (s, n) => {
-  s = String(s ?? '');
-  return s.length > n ? s.slice(0, n) + `\n… (${s.length - n} more chars)` : s;
-};
-
-function describeTool(name, input = {}) {
-  if (!input || typeof input !== 'object') return '';
-  if (input.command) return input.command;
-  if (name === 'AskUserQuestion' && Array.isArray(input.questions)) return input.questions.map((q) => q.question).join(' / ');
-  if (input.file_path) return input.file_path;
-  if (input.notebook_path) return input.notebook_path;
-  if (input.pattern) return input.pattern + (input.path ? `  in ${input.path}` : '');
-  if (input.url) return input.url;
-  if (input.query) return input.query;
-  if (input.description) return input.description;
-  if (input.prompt) return input.prompt;
-  return JSON.stringify(input);
-}
-
-function readTail(file, maxBytes) {
-  const fd = fs.openSync(file, 'r');
-  try {
-    const size = fs.fstatSync(fd).size;
-    const start = Math.max(0, size - maxBytes);
-    const buf = Buffer.alloc(size - start);
-    fs.readSync(fd, buf, 0, buf.length, start);
-    let text = buf.toString('utf8');
-    if (start > 0) text = text.slice(text.indexOf('\n') + 1); // drop the partial first line
-    return text;
-  } finally {
-    fs.closeSync(fd);
-  }
-}
-
-const resultText = (content) =>
-  typeof content === 'string'
-    ? content
-    : Array.isArray(content)
-      ? content.map((c) => (c.type === 'text' ? c.text : `[${c.type}]`)).join('\n')
-      : '';
-
-const isNoise = (text) => /^\s*<(system-reminder|ide_|command-|local-command)/.test(text);
-
-// Appends the messages in these transcript lines to out (metadata and noise skipped).
-// Reads both Claude Code transcripts and Codex rollouts.
-function parseLines(text, out) {
-  for (const line of text.split('\n')) {
-    if (!line.trim()) continue;
-    let e;
-    try {
-      e = JSON.parse(line);
-    } catch {
-      continue;
-    }
-    if (e.type === 'response_item') {
-      parseCodexItem(e, out);
-      continue;
-    }
-    if ((e.type !== 'user' && e.type !== 'assistant') || e.isMeta || !e.message) continue;
-    const ts = e.timestamp;
-    const content = e.message.content;
-    if (typeof content === 'string') {
-      if (!isNoise(content)) out.push({ role: e.type, kind: 'text', text: content, ts });
-      continue;
-    }
-    if (!Array.isArray(content)) continue;
-    for (const b of content) {
-      if (b.type === 'text' && b.text?.trim() && !isNoise(b.text)) out.push({ role: e.type, kind: 'text', text: b.text, ts });
-      else if (b.type === 'tool_use') out.push({ role: 'assistant', kind: 'tool', id: b.id, name: b.name, text: describeTool(b.name, b.input), ts });
-      else if (b.type === 'tool_result') out.push({ role: 'tool', kind: 'result', toolUseId: b.tool_use_id, text: resultText(b.content), isError: !!b.is_error, ts });
-    }
-  }
-  return out;
-}
-
-// Codex's exec tool takes a small script; the shell command inside it is what's worth showing.
-function describeCodexCall(name, input) {
-  const raw = String(input ?? '');
-  if (name === 'wait') return 'Waiting for the running command';
-  const m = raw.match(/\bcmd\s*:\s*(["'`])((?:\\.|(?!\1)[^\\])*)\1/);
-  if (m) return m[2].replace(/\\(.)/g, (_, c) => ({ n: '\n', t: '\t' })[c] ?? c);
-  // Other built-in tools called from the script: name them, plus the search query if any.
-  const call = raw.match(/\btools\.(\w+)\(/)?.[1];
-  if (call === 'write_stdin') return 'Sending input to the running command';
-  if (call) {
-    const q = raw.match(/\bq\s*:\s*(["'`])((?:\\.|(?!\1)[^\\])*)\1/)?.[2];
-    return call.replace(/__/g, ' ') + (q ? `: ${q}` : '');
-  }
-  try {
-    const args = JSON.parse(raw);
-    if (args && typeof args === 'object') return describeTool(name, args);
-  } catch {}
-  return raw.split('\n')[0];
-}
-
-const codexOutput = (o) => (typeof o === 'string' ? o : Array.isArray(o) ? o.map((c) => c.text ?? `[${c.type}]`).join('\n') : '');
-
-function parseCodexItem(e, out) {
-  const p = e.payload || {};
-  const ts = e.timestamp;
-  if (p.type === 'message' && (p.role === 'user' || p.role === 'assistant')) {
-    // Only what you typed: Codex also sends context (environment, open pages) as user messages.
-    const kinds = p.internal_chat_message_metadata_passthrough?.content_item_kinds;
-    (p.content || []).forEach((c, i) => {
-      const text = c.text?.trim();
-      if (!text) return;
-      if (p.role === 'user' && (kinds ? kinds[i] !== 'user.text' : text.startsWith('<'))) return;
-      // The VS Code extension wraps what you typed in IDE context (open tabs etc.).
-      const typed = p.role === 'user' ? c.text.match(/^#+ My request:\s*\n([\s\S]*)$/m)?.[1] : null;
-      out.push({ role: p.role, kind: 'text', text: typed?.trim() || c.text, ts });
-    });
-  } else if (p.type === 'function_call' || p.type === 'custom_tool_call') {
-    out.push({ role: 'assistant', kind: 'tool', id: p.call_id, name: p.name, text: describeCodexCall(p.name, p.arguments ?? p.input), ts });
-  } else if (p.type === 'function_call_output' || p.type === 'custom_tool_call_output') {
-    out.push({ role: 'tool', kind: 'result', toolUseId: p.call_id, text: codexOutput(p.output), isError: false, ts });
-  }
-}
-
-const clipMessage = (m) => ({ ...m, text: truncate(m.text, m.kind === 'result' ? 4000 : 20000) });
-
-function parseTranscript(file, limit = 120) {
-  if (!file || !fs.existsSync(file)) return [];
-  return parseLines(readTail(file, TRANSCRIPT_TAIL), []).slice(-limit).map(clipMessage);
-}
-
-// The conversation open on the dashboard is read incrementally: each request parses
-// only the bytes appended since the last one. Messages get increasing seq numbers so
-// the dashboard can ask for just the new ones; epoch changes if the file is replaced.
-const TRANSCRIPT_TAIL = 2 * 1024 * 1024;
-const TRANSCRIPT_KEEP = 400;
-const TRANSCRIPT_FILES = 8;
-const transcriptCache = new Map(); // file -> { epoch, offset, rest, dropFirstLine, seq, messages }
-
-function readTranscript(file) {
-  let size;
-  try {
-    size = fs.statSync(file).size;
-  } catch {
-    return null;
-  }
-  let c = transcriptCache.get(file);
-  if (!c || size < c.offset) {
-    const offset = Math.max(0, size - TRANSCRIPT_TAIL);
-    c = { epoch: crypto.randomUUID(), offset, rest: Buffer.alloc(0), dropFirstLine: offset > 0, seq: 0, messages: [] };
-  }
-  transcriptCache.delete(file); // most recently used goes last
-  transcriptCache.set(file, c);
-  if (transcriptCache.size > TRANSCRIPT_FILES) transcriptCache.delete(transcriptCache.keys().next().value);
-  if (size === c.offset) return c;
-
-  const fd = fs.openSync(file, 'r');
-  let buf;
-  try {
-    buf = Buffer.alloc(size - c.offset);
-    fs.readSync(fd, buf, 0, buf.length, c.offset);
-  } finally {
-    fs.closeSync(fd);
-  }
-  c.offset = size;
-  buf = Buffer.concat([c.rest, buf]);
-  let start = 0;
-  if (c.dropFirstLine) {
-    start = buf.indexOf(10) + 1; // we started mid-file: skip the partial first line
-    if (start) c.dropFirstLine = false;
-  }
-  // Only complete lines. Splitting on the newline byte never cuts a UTF-8 character.
-  const end = Math.max(start, buf.lastIndexOf(10) + 1);
-  c.rest = Buffer.from(buf.subarray(end));
-  for (const m of parseLines(buf.toString('utf8', start, end), [])) c.messages.push({ ...clipMessage(m), seq: ++c.seq });
-  if (c.messages.length > TRANSCRIPT_KEEP) c.messages.splice(0, c.messages.length - TRANSCRIPT_KEEP);
-  return c;
-}
-
-function lastAssistantText(file) {
-  const msgs = parseTranscript(file, 400);
-  for (let i = msgs.length - 1; i >= 0; i--) if (msgs[i].role === 'assistant' && msgs[i].kind === 'text') return msgs[i].text;
-  return '';
-}
-
-function readHead(file, maxBytes) {
-  const fd = fs.openSync(file, 'r');
-  try {
-    const buf = Buffer.alloc(Math.min(maxBytes, fs.fstatSync(fd).size));
-    fs.readSync(fd, buf, 0, buf.length, 0);
-    return buf.toString('utf8');
-  } finally {
-    fs.closeSync(fd);
-  }
-}
-
-const firstText = (content) =>
-  typeof content === 'string' ? content : Array.isArray(content) ? content.find((b) => b.type === 'text' && !isNoise(b.text || ''))?.text || '' : '';
-
-// cwd and a title (Claude's summary, else the first prompt) from the start of a transcript.
-function transcriptInfo(file) {
-  let cwd = '';
-  let prompt = '';
-  let summary = '';
-  for (const line of readHead(file, 256 * 1024).split('\n')) {
-    let e;
-    try {
-      e = JSON.parse(line);
-    } catch {
-      continue;
-    }
-    if (!cwd && e.cwd) cwd = e.cwd;
-    if (e.type === 'summary' && e.summary && !summary) summary = e.summary;
-    if (!prompt && e.type === 'user' && !e.isMeta) {
-      const t = firstText(e.message?.content);
-      if (t && !isNoise(t)) prompt = t;
-    }
-    if (cwd && prompt) break;
-  }
-  return { cwd, title: (summary || prompt).split('\n')[0].slice(0, 140) };
-}
-
 // ---------- sessions ----------
 
 const newSession = (id) => ({ id, agent: 'claude', cwd: '', project: '', title: '', transcriptPath: '', status: 'idle', hold: null, startedAt: Date.now(), lastEventAt: 0, lastAction: '', permissionMode: '', activity: [], queue: [] });
@@ -392,19 +180,6 @@ function startDiscovery() {
 // ---------- plan usage ----------
 
 let usage = null; // { fetchedAt, plan, limits: [...], error }
-const LIMIT_LABELS = { session: '5-hour session', weekly_all: 'Weekly · all models', weekly_opus: 'Weekly · Opus', weekly_sonnet: 'Weekly · Sonnet' };
-
-function normalizeLimits(j) {
-  if (Array.isArray(j.limits) && j.limits.length) {
-    return j.limits
-      .filter((l) => typeof l.percent === 'number')
-      .map((l) => ({ kind: l.kind, label: LIMIT_LABELS[l.kind] || String(l.kind).replace(/_/g, ' '), percent: l.percent, severity: l.severity || null, resetsAt: l.resets_at || null }));
-  }
-  // Older response shape.
-  const pick = (key, kind) => j[key] && typeof j[key].utilization === 'number' && { kind, label: LIMIT_LABELS[kind], percent: j[key].utilization, severity: null, resetsAt: j[key].resets_at || null };
-  return [pick('five_hour', 'session'), pick('seven_day', 'weekly_all'), pick('seven_day_opus', 'weekly_opus'), pick('seven_day_sonnet', 'weekly_sonnet')].filter(Boolean);
-}
-
 // The usage endpoint is rate-limited per account (Claude Code's /usage calls it too).
 // After a 429 we wait before asking again, longer each time, instead of keeping the
 // limit tripped by retrying every couple of minutes.
@@ -567,9 +342,12 @@ async function checkRollout(file) {
     s.codexTurnOpen = tail.turnOpen;
     s.status = codexStatus(s);
     const last = tail.last;
+    // While working, only a running tool is current; the last reply may be from the previous turn.
     s.lastAction =
-      s.status === 'working' && last?.kind === 'tool'
-        ? `${last.name}: ${last.text.split('\n')[0]}`.slice(0, 160)
+      s.status === 'working'
+        ? last?.kind === 'tool'
+          ? `${last.name}: ${last.text.split('\n')[0]}`.slice(0, 160)
+          : ''
         : (lastAssistantText(file) || '').split('\n')[0].slice(0, 160);
     return true;
   } catch {
@@ -666,14 +444,6 @@ function startCodexDiscovery() {
 // Codex records your plan limits with every turn (the same numbers its /status shows).
 let codexUsage = null; // { updatedAt, plan, limits, credits }
 
-function codexWindowLabel(minutes) {
-  if (minutes === 300) return '5-hour session';
-  if (minutes === 10080) return 'Weekly';
-  if (minutes % 1440 === 0) return `${minutes / 1440}-day`;
-  if (minutes % 60 === 0) return `${minutes / 60}-hour`;
-  return `${minutes}-minute`;
-}
-
 function noteCodexLimits(rl, at) {
   if (codexUsage && at <= codexUsage.updatedAt) return;
   const limits = [];
@@ -779,7 +549,9 @@ async function findApps(cwd) {
 function addActivity(s, kind, text, extra = {}) {
   s.activity.push({ t: Date.now(), kind, text: truncate(text, 4000), ...extra });
   if (s.activity.length > MAX_ACTIVITY) s.activity.splice(0, s.activity.length - MAX_ACTIVITY);
-  s.lastAction = (extra.tool ? `${extra.tool}: ` : '') + String(text).split('\n')[0].slice(0, 160);
+  // lastAction is what the agent is doing. A prompt is what you said, so it starts blank
+  // (the dashboard shows "Working…") until the agent reports something.
+  s.lastAction = kind === 'prompt' ? '' : (extra.tool ? `${extra.tool}: ` : '') + String(text).split('\n')[0].slice(0, 160);
 }
 
 // Who drives a session: 'vscode' (Agenter only answers inside VS Code's turns) or
@@ -798,7 +570,8 @@ function hold(s, kind, data, payload, res) {
   const item = { id: crypto.randomUUID(), sessionId: s.id, kind, createdAt: Date.now(), headless: runners.has(s.id), ...data };
   const entry = { item, res, payload, timer: null };
   const minutes = Number(settings.holdMinutes) || 0;
-  if (minutes > 0) {
+  // A turn Agenter runs has no VS Code to go back to, so it waits for your answer.
+  if (minutes > 0 && !item.headless) {
     item.releaseAt = item.createdAt + minutes * 60000;
     entry.timer = setTimeout(() => respond(item.id, 'pass', { auto: true }), minutes * 60000);
   }
@@ -815,6 +588,17 @@ function hold(s, kind, data, payload, res) {
   broadcast();
 }
 
+// A turn Agenter ran is over, so anything it was waiting on can't be answered any more.
+function releaseRun(s) {
+  for (const [id, e] of [...pending]) {
+    if (e.item.sessionId !== s.id || !e.item.headless) continue;
+    clearTimeout(e.timer);
+    pending.delete(id);
+    e.res.writeHead(200, { 'content-type': 'application/json' });
+    e.res.end('{}');
+  }
+}
+
 // action: allow | always | deny | answer | reply | pass
 function respond(id, action, body = {}) {
   const entry = pending.get(id);
@@ -888,6 +672,30 @@ function onAttentionChanged() {
   }, clients.size ? BLUR_GRACE_MS : DISCONNECT_GRACE_MS);
 }
 
+// Quit, from the tray. Open windows close themselves on the 'quit' event.
+function stopServer() {
+  for (const c of clients.keys()) c.write('event: quit\ndata: {}\n\n');
+  for (const id of [...pending.keys()]) respond(id, 'pass');
+  for (const child of runners.values()) {
+    child.interrupted = true;
+    killRun(child);
+  }
+  fs.mkdirSync(SETTINGS_DIR, { recursive: true });
+  fs.writeFileSync(STOPPED_FILE, '');
+  // Long enough for the hooks to receive those answers.
+  setTimeout(() => process.exit(0), 300);
+}
+
+// The tray icon. It watches this process, so it goes away when the server does.
+function startTray() {
+  if (process.platform !== 'win32' || process.env.AGENTER_TRAY === '0') return;
+  const args = ['-NoProfile', '-ExecutionPolicy', 'Bypass', '-STA', '-WindowStyle', 'Hidden', '-File', path.join(__dirname, 'scripts', 'tray.ps1'), '-ServerPid', String(process.pid), '-Node', process.execPath, '-Port', String(PORT)];
+  // Not detached: PowerShell exits at once without a console.
+  const child = spawn('powershell.exe', args, { stdio: 'ignore', windowsHide: true });
+  child.on('error', () => {});
+  child.unref();
+}
+
 // ---------- steering ----------
 // Messages typed in the dashboard while Claude isn't waiting for a reply. Hooks only run
 // at events, so they wait here and go out with the next one: after the current tool
@@ -965,6 +773,7 @@ function startRun(s, text, { fresh = false } = {}) {
   child.on('error', (e) => (err = e.message));
   child.on('close', (code) => {
     runners.delete(s.id);
+    releaseRun(s);
     if (code && !child.interrupted) addActivity(s, 'notice', `Claude stopped with an error${err.trim() ? `: ${err.trim()}` : ''}`);
     if (child.interrupted) addActivity(s, 'notice', 'Stopped from Agenter');
     settleStatus(s, 'idle');
@@ -978,6 +787,12 @@ function startRun(s, text, { fresh = false } = {}) {
   return true;
 }
 
+// Ends a turn along with what it started: tools, and hooks still waiting on the dashboard.
+function killRun(child) {
+  if (process.platform !== 'win32') return child.kill();
+  execFile('taskkill', ['/pid', String(child.pid), '/T', '/F'], { windowsHide: true }, (err) => err && child.kill());
+}
+
 // ---------- steering Codex ----------
 // Driven from the Codex app (default): `codex queue` hands the message to Codex, which runs
 // it as the next turn of that session in the VS Code extension or the desktop app.
@@ -1016,22 +831,37 @@ function findCodex() {
   return null;
 }
 
+// Windows only runs a .cmd through a shell, which would treat your message as commands.
+// npm's codex.cmd just starts a script with Node, so start that script directly.
+function codexCommand(bin) {
+  if (!bin.endsWith('.cmd')) return [bin];
+  try {
+    const script = fs.readFileSync(bin, 'utf8').match(/"%~?dp0%?[\\/]([^"]+\.js)"/i)?.[1];
+    if (script) return [process.execPath, path.join(path.dirname(bin), script)];
+  } catch {}
+  return null;
+}
+
 async function steerCodex(s, text) {
+  // A turn Agenter is running keeps the session here, even if the switch moved since it started.
+  if (runners.has(s.id)) {
+    // `exec` can't take messages mid-turn; this runs as the next turn.
+    s.queue.push({ id: crypto.randomUUID(), text, t: Date.now() });
+    broadcast();
+    return 'queued';
+  }
   if (driveOf(s) === 'agenter') {
-    if (runners.has(s.id)) {
-      // `exec` can't take messages mid-turn; this runs as the next turn.
-      s.queue.push({ id: crypto.randomUUID(), text, t: Date.now() });
-      broadcast();
-      return 'queued';
-    }
     if (!(await startCodexRun(s, text))) return 'no-codex';
     addActivity(s, 'prompt', text, { fromDashboard: true });
     return 'started';
   }
   const bin = findCodex();
   if (!bin) return 'no-codex';
+  const command = codexCommand(bin);
+  if (!command) return 'error';
+  const [file, ...prefix] = command;
   return new Promise((resolve) => {
-    execFile(bin, ['queue', '--thread', s.id, '--message', text], { windowsHide: true, timeout: 30000, shell: bin.endsWith('.cmd') }, (err) => {
+    execFile(file, [...prefix, 'queue', '--thread', s.id, '--message', text], { windowsHide: true, timeout: 30000 }, (err) => {
       if (err) return resolve('error');
       addActivity(s, 'prompt', text, { fromDashboard: true });
       resolve('codex-queued');
@@ -1085,6 +915,7 @@ function startCodexRun(s, text, { fresh = false } = {}) {
       // Never got going (Codex missing a login, bad folder…): report why to whoever asked.
       if (runners.get(s.id) !== child) return resolve(fresh ? { error: failure || err.trim().split('\n').pop() || `Codex exited (${code}).` } : false);
       runners.delete(s.id);
+      releaseRun(s);
       s.codexTurnOpen = false;
       if ((code || failure) && !child.interrupted) addActivity(s, 'notice', `Codex stopped with an error${failure || err.trim() ? `: ${failure || err.trim().split('\n').pop()}` : ''}`);
       if (child.interrupted) addActivity(s, 'notice', 'Stopped from Agenter');
@@ -1146,7 +977,8 @@ function handleHook(p, res) {
     case 'PermissionRequest':
       if (watching && p.tool_name !== 'AskUserQuestion') {
         const canAlways = Array.isArray(p.permission_suggestions) && p.permission_suggestions.length > 0;
-        return hold(s, 'permission', { tool: p.tool_name, input: p.tool_input, canAlways }, p, res);
+        const diffs = buildDiffs(p.tool_name, p.tool_input, { cwd: p.cwd || s.cwd });
+        return hold(s, 'permission', { tool: p.tool_name, input: p.tool_input, canAlways, ...(diffs && { diffs }) }, p, res);
       }
       s.status = 'vscode';
       break;
@@ -1229,11 +1061,29 @@ const json = (res, code, obj) => {
 const STATIC = {
   '/': ['index.html', 'text/html; charset=utf-8'],
   '/app.js': ['app.js', 'text/javascript; charset=utf-8'],
+  '/theme.js': ['theme.js', 'text/javascript; charset=utf-8'],
   '/style.css': ['style.css', 'text/css; charset=utf-8'],
   '/icon.png': ['icon.png', 'image/png'],
   '/favicon.ico': ['agenter.ico', 'image/x-icon'],
 };
 
+// frame-src stays open for http(s): Preview shows whatever app address you type.
+const CSP = [
+  "default-src 'none'",
+  "script-src 'self'",
+  "style-src-elem 'self' https://fonts.googleapis.com",
+  "style-src-attr 'unsafe-inline'",
+  'font-src https://fonts.gstatic.com',
+  "img-src 'self' data:",
+  "connect-src 'self'",
+  'frame-src http: https:',
+  "base-uri 'none'",
+  "form-action 'none'",
+  "frame-ancestors 'none'",
+].join('; ');
+
+const TOKEN = require.main === module ? getToken() : '';
+
 const ALLOWED_HOSTS = new Set([`127.0.0.1:${PORT}`, `localhost:${PORT}`]);
 const ALLOWED_ORIGINS = new Set([...ALLOWED_HOSTS].map((h) => `http://${h}`));
 
@@ -1243,6 +1093,10 @@ const server = http.createServer(async (req, res) => {
     return json(res, 403, { error: 'forbidden' });
   }
   const url = new URL(req.url, `http://${req.headers.host}`);
+  // The page itself holds no secrets. Everything else needs the token; a custom header also
+  // forces a CORS preflight, which we never approve. EventSource can't set headers.
+  const given = req.headers['x-agenter-token'] ?? (url.pathname === '/events' ? url.searchParams.get('token') : null);
+  if (!(req.method === 'GET' && STATIC[url.pathname]) && !sameToken(given, TOKEN)) return json(res, 401, { error: 'unauthorized' });
 
   try {
     if (req.method === 'POST' && url.pathname === '/hook') {
@@ -1251,7 +1105,7 @@ const server = http.createServer(async (req, res) => {
 
     if (req.method === 'GET' && STATIC[url.pathname]) {
       const [file, type] = STATIC[url.pathname];
-      res.writeHead(200, { 'content-type': type, 'cache-control': 'no-store' });
+      res.writeHead(200, { 'content-type': type, 'cache-control': 'no-store', 'content-security-policy': CSP });
       return res.end(fs.readFileSync(path.join(PUBLIC_DIR, file)));
     }
 
@@ -1288,10 +1142,12 @@ const server = http.createServer(async (req, res) => {
     }
 
     if (req.method === 'POST' && url.pathname.startsWith('/api/')) {
-      // A custom header forces a CORS preflight, which we never approve.
-      if (req.headers['x-agenter'] !== '1') return json(res, 403, { error: 'forbidden' });
       const body = await readBody(req);
 
+      if (url.pathname === '/api/quit') {
+        stopServer();
+        return json(res, 200, {});
+      }
       if (url.pathname === '/api/respond') {
         const s = sessions.get(pending.get(body.id)?.item.sessionId);
         const ok = respond(body.id, body.action, body);
@@ -1373,7 +1229,7 @@ const server = http.createServer(async (req, res) => {
         const child = runners.get(body.sessionId);
         if (child) {
           child.interrupted = true;
-          child.kill();
+          killRun(child);
         }
         return json(res, child ? 200 : 404, {});
       }
@@ -1420,17 +1276,29 @@ const server = http.createServer(async (req, res) => {
 });
 
 server.requestTimeout = 0; // hooks can legitimately wait a long time for you
-server.on('error', (err) => {
-  if (err.code === 'EADDRINUSE') console.error(`Port ${PORT} is busy. Is Agenter already running? (Set AGENTER_PORT to use another port.)`);
-  else console.error(err);
-  process.exit(1);
-});
-server.listen(PORT, HOST, () => {
-  const url = `http://localhost:${PORT}`;
-  console.log(`Agenter dashboard: ${url}`);
-  startDiscovery();
-  startCodexDiscovery();
-  fetchUsage();
-  setInterval(fetchUsage, USAGE_INTERVAL_MS);
-  if (!process.argv.includes('--no-open')) openDashboard(url);
-});
+// Only listen when run directly; the tests load this file to drive the hook and steering logic.
+if (require.main === module) {
+  server.on('error', (err) => {
+    if (err.code === 'EADDRINUSE') console.error(`Port ${PORT} is busy. Is Agenter already running? (Set AGENTER_PORT to use another port.)`);
+    else console.error(err);
+    process.exit(1);
+  });
+  server.listen(PORT, HOST, () => {
+    const url = `http://localhost:${PORT}`;
+    console.log(`Agenter dashboard: ${url}`);
+    fs.rmSync(STOPPED_FILE, { force: true });
+    startTray();
+    startDiscovery();
+    startCodexDiscovery();
+    fetchUsage();
+    setInterval(fetchUsage, USAGE_INTERVAL_MS);
+    if (!process.argv.includes('--no-open')) openDashboard(url);
+  });
+}
+
+module.exports = {
+  sessions, pending, clients, runners, dismissed,
+  get settings() { return settings; },
+  handleHook, hold, respond, steer, takeQueue, touchSession, snapshot, driveOf, effectiveHold,
+  findClaude, findCodex, codexCommand, releaseRun,
+};