linear-grab-bridge 0.8.0 → 0.10.0

package/linear-grab-bridge.mjs

@@ -5,13 +5,20 @@
  *
  *   npx linear-grab-bridge [--port 4577] [--dir .] [--claude claude]
  *
- * Each task spawns a headless `claude -p` session (stream-json output) in the
- * repo directory. The browser polls task status over localhost. Zero deps.
+ * v0.9: interactive sessions. Each task runs `claude -p` with stream-json
+ * INPUT + OUTPUT — the session stays alive after each result, so the panel
+ * can send follow-up messages, switch models (applied via --resume respawn),
+ * read live token/context usage, and copy a `claude --resume <id>` command.
+ * Task history persists to ~/.linear-grab/ across restarts. Zero deps.
  * Binds 127.0.0.1 only — never exposed to the network.
  */
 import { createServer } from 'node:http';
-import { spawn } from 'node:child_process';
+import { spawn, execFile } from 'node:child_process';
 import { randomUUID } from 'node:crypto';
+import { createHash } from 'node:crypto';
+import { mkdirSync, readFileSync, writeFileSync } from 'node:fs';
+import { homedir } from 'node:os';
+import { join } from 'node:path';
 
 const argv = process.argv.slice(2);
 const flag = (name, fallback) => {
@@ -21,19 +28,82 @@ const flag = (name, fallback) => {
 const PORT = Number(flag('--port', '4577'));
 const DIR = flag('--dir', process.cwd());
 const CLAUDE_BIN = flag('--claude', 'claude');
-const VERSION = '0.8.0';
-const MAX_TAIL = 200;
+const VERSION = '0.10.0';
+
+/** Best-effort command runner (git/gh introspection). Never throws. */
+function run(cmd, args) {
+  return new Promise((resolve) => {
+    execFile(cmd, args, { cwd: DIR, timeout: 8_000, maxBuffer: 2_000_000 }, (err, stdout) =>
+      resolve(err ? null : stdout.toString()),
+    );
+  });
+}
+const MAX_TAIL = 300;
+const IDLE_KILL_MS = 30 * 60_000; // free an idle interactive session after 30min (resumable)
 
 /** @type {Map<string, any>} */
 const tasks = new Map();
 
+// ---- persistence -----------------------------------------------------------
+
+const HISTORY_DIR = join(homedir(), '.linear-grab');
+const HISTORY_FILE = join(
+  HISTORY_DIR,
+  `bridge-${createHash('sha1').update(DIR).digest('hex').slice(0, 10)}.json`,
+);
+
+function loadHistory() {
+  try {
+    const items = JSON.parse(readFileSync(HISTORY_FILE, 'utf8'));
+    for (const t of items) {
+      tasks.set(t.id, { ...t, child: null, alive: false });
+    }
+    console.log(`  history: ${items.length} past task(s) loaded`);
+  } catch {
+    /* first run */
+  }
+}
+
+let saveTimer = null;
+function saveHistory() {
+  if (saveTimer) return;
+  saveTimer = setTimeout(() => {
+    saveTimer = null;
+    try {
+      mkdirSync(HISTORY_DIR, { recursive: true });
+      const items = [...tasks.values()]
+        .sort((a, b) => b.startedAt - a.startedAt)
+        .slice(0, 100)
+        .map((t) => ({
+          id: t.id,
+          title: t.title,
+          status: t.status === 'running' ? 'stopped' : t.status,
+          startedAt: t.startedAt,
+          endedAt: t.endedAt,
+          lastText: t.lastText,
+          result: t.result,
+          sessionId: t.sessionId ?? null,
+          model: t.model ?? null,
+          usage: t.usage ?? null,
+          startCommit: t.startCommit ?? null,
+          subagents: t.subagents ?? 0,
+          tail: (t.tail ?? []).slice(-60),
+        }));
+      writeFileSync(HISTORY_FILE, JSON.stringify(items));
+    } catch {
+      /* best-effort */
+    }
+  }, 600);
+}
+
+// ---- helpers ---------------------------------------------------------------
+
 const CORS = {
   'Access-Control-Allow-Origin': '*',
   'Access-Control-Allow-Methods': 'GET,POST,OPTIONS',
   'Access-Control-Allow-Headers': 'content-type,x-upload-url,x-upload-headers',
 };
 
-/** Upload proxy targets — Linear's storage only (SSRF guard). */
 const UPLOAD_HOSTS = /(^|\.)uploads\.linear\.app$|(^|\.)storage\.googleapis\.com$/;
 
 function json(res, code, obj) {
@@ -67,36 +137,60 @@ function summary(t) {
     startedAt: t.startedAt,
     endedAt: t.endedAt ?? null,
     lastText: t.lastText,
-    result: t.status === 'done' ? t.result?.slice(0, 2000) ?? null : null,
+    result: t.status === 'done' ? (t.result?.slice(0, 2000) ?? null) : null,
+    sessionId: t.sessionId ?? null,
+    model: t.model ?? null,
+    pendingModel: t.pendingModel ?? null,
+    alive: !!t.alive,
+    usage: t.usage ?? null,
+    subagents: t.subagents ?? 0,
+    permissionMode: t.permissionMode ?? 'acceptEdits',
   };
 }
 
-function startTask({ title, prompt }) {
-  const id = randomUUID().slice(0, 8);
-  const task = {
-    id,
-    title: String(title ?? 'Task').slice(0, 200),
-    status: 'running',
-    startedAt: Date.now(),
-    endedAt: null,
-    lastText: 'Starting Claude Code…',
-    tail: [],
-    result: null,
-    child: null,
-  };
-  tasks.set(id, task);
+function pushTail(task, kind, text) {
+  task.tail.push({ at: Date.now(), kind, text });
+  if (task.tail.length > MAX_TAIL) task.tail.shift();
+  saveHistory();
+}
 
-  // Headless Claude Code: prompt over stdin (avoids argv limits), streamed
-  // JSON events out. acceptEdits lets it actually work unattended; pass extra
-  // flags via --claude-args if you need a different permission posture.
-  const child = spawn(
-    CLAUDE_BIN,
-    ['-p', '--output-format', 'stream-json', '--verbose', '--permission-mode', 'acceptEdits'],
-    { cwd: DIR, stdio: ['pipe', 'pipe', 'pipe'] },
+function userMessageLine(text) {
+  return (
+    JSON.stringify({
+      type: 'user',
+      message: { role: 'user', content: [{ type: 'text', text }] },
+    }) + '\n'
   );
+}
+
+// ---- claude process management ---------------------------------------------
+
+function startProcess(task, { resume, initialText }) {
+  const args = [
+    '-p',
+    '--output-format',
+    'stream-json',
+    '--input-format',
+    'stream-json',
+    '--verbose',
+    '--permission-mode',
+    task.permissionMode || 'acceptEdits',
+  ];
+  if (task.model) args.push('--model', task.model);
+  if (resume) args.push('--resume', resume);
+
+  const child = spawn(CLAUDE_BIN, args, {
+    cwd: DIR,
+    stdio: ['pipe', 'pipe', 'pipe'],
+    env: { ...process.env, ...(task.env ?? {}) },
+  });
   task.child = child;
-  child.stdin.write(String(prompt ?? ''));
-  child.stdin.end();
+  task.alive = true;
+  task.pendingModel = null;
+  if (initialText) {
+    child.stdin.write(userMessageLine(initialText));
+    task.status = 'running';
+  }
 
   let buffer = '';
   child.stdout.on('data', (chunk) => {
@@ -107,58 +201,219 @@ function startTask({ title, prompt }) {
       buffer = buffer.slice(nl + 1);
       if (!line) continue;
       try {
-        const event = JSON.parse(line);
-        ingest(task, event);
+        ingest(task, JSON.parse(line));
       } catch {
-        pushTail(task, line.slice(0, 500));
+        pushTail(task, 'raw', line.slice(0, 500));
       }
     }
   });
-  child.stderr.on('data', (chunk) => pushTail(task, `[stderr] ${String(chunk).slice(0, 500)}`));
+  child.stderr.on('data', (chunk) => pushTail(task, 'stderr', String(chunk).slice(0, 500)));
   child.on('error', (err) => {
     task.status = 'error';
+    task.alive = false;
     task.endedAt = Date.now();
     task.lastText = `Failed to launch "${CLAUDE_BIN}" — is Claude Code installed and on PATH? (${err.message})`;
+    saveHistory();
   });
   child.on('exit', (code) => {
+    task.alive = false;
+    task.child = null;
     if (task.status === 'running') {
       task.status = code === 0 ? 'done' : 'error';
       if (task.status === 'error') task.lastText = `Exited with code ${code}. ${task.lastText}`;
+      task.endedAt = Date.now();
     }
-    task.endedAt = Date.now();
-    task.child = null;
+    saveHistory();
   });
-  return task;
-}
 
-function pushTail(task, text) {
-  task.tail.push({ at: Date.now(), text });
-  if (task.tail.length > MAX_TAIL) task.tail.shift();
+  // Free idle sessions eventually — they stay resumable via --resume.
+  clearTimeout(task.idleTimer);
+  task.idleTimer = setInterval(() => {
+    if (task.alive && task.status !== 'running' && Date.now() - (task.lastActivity ?? 0) > IDLE_KILL_MS) {
+      try {
+        task.child?.stdin.end();
+        task.child?.kill('SIGTERM');
+      } catch {
+        /* already gone */
+      }
+      clearInterval(task.idleTimer);
+    }
+  }, 60_000);
 }
 
 function ingest(task, event) {
-  // stream-json events: system/init, assistant messages, tool use, final result.
+  task.lastActivity = Date.now();
+  if (event.type === 'system' && event.subtype === 'init') {
+    task.sessionId = event.session_id ?? task.sessionId;
+    if (!task.model && event.model) task.model = event.model;
+    saveHistory();
+    return;
+  }
   if (event.type === 'assistant') {
-    const parts = event.message?.content ?? [];
-    for (const p of parts) {
+    const usage = event.message?.usage;
+    if (usage) {
+      const context =
+        (usage.input_tokens ?? 0) +
+        (usage.cache_read_input_tokens ?? 0) +
+        (usage.cache_creation_input_tokens ?? 0);
+      task.usage = {
+        ...(task.usage ?? { outputTokens: 0, costUsd: 0 }),
+        contextTokens: context,
+        outputTokens: (task.usage?.outputTokens ?? 0) + (usage.output_tokens ?? 0),
+      };
+    }
+    for (const p of event.message?.content ?? []) {
       if (p.type === 'text' && p.text?.trim()) {
         task.lastText = p.text.trim().slice(0, 300);
-        pushTail(task, task.lastText);
+        pushTail(task, 'assistant', p.text.trim().slice(0, 2000));
       } else if (p.type === 'tool_use') {
-        const label = `→ ${p.name}${p.input?.file_path ? ` ${p.input.file_path}` : ''}`;
-        task.lastText = label.slice(0, 300);
-        pushTail(task, label.slice(0, 500));
+        // Subagent fan-out is worth surfacing distinctly.
+        if (p.name === 'Task' || p.name === 'Agent') {
+          task.subagents = (task.subagents ?? 0) + 1;
+          const label = `⛓ subagent #${task.subagents}: ${String(p.input?.description ?? p.input?.prompt ?? '').slice(0, 140)}`;
+          task.lastText = label.slice(0, 300);
+          pushTail(task, 'subagent', label.slice(0, 500));
+        } else {
+          const label = `→ ${p.name}${p.input?.file_path ? ` ${p.input.file_path}` : p.input?.command ? ` ${String(p.input.command).slice(0, 120)}` : ''}`;
+          task.lastText = label.slice(0, 300);
+          pushTail(task, 'tool', label.slice(0, 500));
+        }
       }
     }
-  } else if (event.type === 'result') {
+    return;
+  }
+  if (event.type === 'result') {
     task.result = typeof event.result === 'string' ? event.result : JSON.stringify(event.result);
     task.lastText = (task.result ?? '').slice(0, 300) || task.lastText;
     task.status = event.is_error ? 'error' : 'done';
     task.endedAt = Date.now();
-    pushTail(task, `[result] ${(task.result ?? '').slice(0, 1000)}`);
+    if (event.usage || event.total_cost_usd != null) {
+      task.usage = {
+        ...(task.usage ?? {}),
+        costUsd: (task.usage?.costUsd ?? 0) + (event.total_cost_usd ?? 0),
+      };
+    }
+    pushTail(task, 'result', (task.result ?? '').slice(0, 2000));
+    // Session stays ALIVE for follow-up messages (multi-turn stream-json).
+    return;
+  }
+}
+
+function startTask({ title, prompt, model, env, permissionMode }) {
+  const id = randomUUID().slice(0, 8);
+  const task = {
+    id,
+    permissionMode: ['acceptEdits', 'bypassPermissions', 'default', 'plan'].includes(
+      String(permissionMode),
+    )
+      ? String(permissionMode)
+      : 'acceptEdits',
+    title: String(title ?? 'Task').slice(0, 200),
+    status: 'running',
+    startedAt: Date.now(),
+    endedAt: null,
+    lastText: 'Starting Claude Code…',
+    tail: [],
+    result: null,
+    child: null,
+    alive: false,
+    sessionId: null,
+    model: model ? String(model) : null,
+    env: env && typeof env === 'object' ? env : null,
+    usage: null,
+    lastActivity: Date.now(),
+  };
+  tasks.set(id, task);
+  pushTail(task, 'user', String(prompt ?? '').slice(0, 2000));
+  // Snapshot HEAD so the Changes view can attribute work to this task.
+  void run('git', ['rev-parse', 'HEAD']).then((out) => {
+    task.startCommit = out?.trim() || null;
+  });
+  startProcess(task, { initialText: String(prompt ?? '') });
+  return task;
+}
+
+/** What this task changed: files (+/−), branch, untracked, matching PRs. */
+async function computeDiff(task) {
+  const branch = (await run('git', ['branch', '--show-current']))?.trim() ?? '';
+  const base = task.startCommit;
+  const numstat = (await run('git', ['diff', '--numstat', ...(base ? [base] : [])])) ?? '';
+  const files = numstat
+    .split('\n')
+    .filter(Boolean)
+    .map((line) => {
+      const [a, d, ...path] = line.split('\t');
+      return {
+        path: path.join('\t'),
+        added: a === '-' ? 0 : Number(a),
+        deleted: d === '-' ? 0 : Number(d),
+        binary: a === '-',
+      };
+    })
+    .filter((f) => f.path);
+  const untracked = ((await run('git', ['status', '--porcelain'])) ?? '')
+    .split('\n')
+    .filter((l) => l.startsWith('??'))
+    .map((l) => l.slice(3).trim())
+    .filter(Boolean)
+    .slice(0, 40);
+
+  // PRs: by current head branch AND by the issue identifier in the title.
+  const prs = new Map();
+  const ident = task.title.match(/^([A-Z][A-Z0-9]*-\d+)/)?.[1];
+  for (const args of [
+    branch ? ['pr', 'list', '--head', branch, '--state', 'all', '--json', 'url,title,state', '--limit', '3'] : null,
+    ident ? ['pr', 'list', '--search', ident, '--state', 'all', '--json', 'url,title,state', '--limit', '3'] : null,
+  ]) {
+    if (!args) continue;
+    try {
+      const out = await run('gh', args);
+      for (const pr of JSON.parse(out ?? '[]')) prs.set(pr.url, pr);
+    } catch {
+      /* gh missing or not a repo with remote */
+    }
+  }
+
+  return {
+    branch,
+    baseCommit: base ?? null,
+    files: files.slice(0, 60),
+    untracked,
+    totalAdded: files.reduce((n, f) => n + f.added, 0),
+    totalDeleted: files.reduce((n, f) => n + f.deleted, 0),
+    prs: [...prs.values()],
+  };
+}
+
+/** Send a follow-up. Respawns via --resume when the process is gone or a model
+    change is pending — that's also how model switches take effect. */
+function sendMessage(task, text) {
+  pushTail(task, 'user', text.slice(0, 2000));
+  const needsRespawn = !task.alive || !!task.pendingModel;
+  if (needsRespawn) {
+    if (task.pendingModel) task.model = task.pendingModel;
+    if (task.alive && task.child) {
+      try {
+        task.child.stdin.end();
+        task.child.kill('SIGTERM');
+      } catch {
+        /* ignore */
+      }
+    }
+    if (!task.sessionId) throw new Error('No session to resume');
+    task.status = 'running';
+    task.endedAt = null;
+    startProcess(task, { resume: task.sessionId, initialText: text });
+  } else {
+    task.child.stdin.write(userMessageLine(text));
+    task.status = 'running';
+    task.endedAt = null;
   }
+  saveHistory();
 }
 
+// ---- HTTP ------------------------------------------------------------------
+
 createServer(async (req, res) => {
   try {
     if (req.method === 'OPTIONS') {
@@ -183,29 +438,70 @@ createServer(async (req, res) => {
     if (req.method === 'GET' && detail) {
       const t = tasks.get(detail[1]);
       return t
-        ? json(res, 200, { ...summary(t), tail: t.tail.slice(-60) })
+        ? json(res, 200, { ...summary(t), tail: (t.tail ?? []).slice(-120) })
         : json(res, 404, { error: 'not found' });
     }
+    const diff = url.pathname.match(/^\/tasks\/([\w-]+)\/diff$/);
+    if (req.method === 'GET' && diff) {
+      const t = tasks.get(diff[1]);
+      if (!t) return json(res, 404, { error: 'not found' });
+      return json(res, 200, await computeDiff(t));
+    }
     const stop = url.pathname.match(/^\/tasks\/([\w-]+)\/stop$/);
     if (req.method === 'POST' && stop) {
       const t = tasks.get(stop[1]);
-      if (t?.child && t.status === 'running') {
-        t.child.kill('SIGTERM');
-        t.status = 'stopped';
-        t.endedAt = Date.now();
-        t.lastText = 'Stopped from the panel.';
+      if (t?.child && t.alive) {
+        try {
+          t.child.stdin.end();
+          t.child.kill('SIGTERM');
+        } catch {
+          /* ignore */
+        }
+        if (t.status === 'running') {
+          t.status = 'stopped';
+          t.endedAt = Date.now();
+          t.lastText = 'Stopped from the panel.';
+        }
+        saveHistory();
       }
       return json(res, 200, { ok: true });
     }
+    const message = url.pathname.match(/^\/tasks\/([\w-]+)\/message$/);
+    if (req.method === 'POST' && message) {
+      const t = tasks.get(message[1]);
+      if (!t) return json(res, 404, { error: 'not found' });
+      const body = await readBody(req);
+      if (!body.text) return json(res, 400, { error: 'text required' });
+      try {
+        sendMessage(t, String(body.text));
+        return json(res, 200, summary(t));
+      } catch (err) {
+        return json(res, 409, { error: err instanceof Error ? err.message : String(err) });
+      }
+    }
+    const model = url.pathname.match(/^\/tasks\/([\w-]+)\/model$/);
+    if (req.method === 'POST' && model) {
+      const t = tasks.get(model[1]);
+      if (!t) return json(res, 404, { error: 'not found' });
+      const body = await readBody(req);
+      // Takes effect on the NEXT message (resume respawn) — killing an
+      // in-flight turn to switch models would lose work.
+      t.pendingModel = body.model ? String(body.model) : null;
+      if (!t.alive && t.pendingModel) {
+        t.model = t.pendingModel;
+        t.pendingModel = null;
+      }
+      saveHistory();
+      return json(res, 200, summary(t));
+    }
     if (req.method === 'POST' && url.pathname === '/tasks') {
       const body = await readBody(req);
       if (!body.prompt) return json(res, 400, { error: 'prompt required' });
       const task = startTask(body);
       return json(res, 201, summary(task));
     }
-    // Upload proxy: browsers can't PUT to Linear's storage (its endpoint has
-    // no CORS support) — this local process can. Panel sends the signed URL +
-    // headers it got from the fileUpload mutation; we relay the bytes.
+    // Upload proxy: browsers can't PUT to Linear's storage (no CORS there) —
+    // this local process can. SSRF-guarded to Linear storage hosts.
     if (req.method === 'POST' && url.pathname === '/put') {
       const target = String(req.headers['x-upload-url'] ?? '');
       let host = '';
@@ -241,5 +537,6 @@ createServer(async (req, res) => {
   console.log(`linear-grab bridge v${VERSION}`);
   console.log(`  repo:   ${DIR}`);
   console.log(`  listen: http://127.0.0.1:${PORT}  (localhost only)`);
-  console.log(`  tasks run: ${CLAUDE_BIN} -p --permission-mode acceptEdits`);
+  console.log(`  tasks run: ${CLAUDE_BIN} -p (interactive stream-json, acceptEdits)`);
+  loadHistory();
 });

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "linear-grab-bridge",
-  "version": "0.8.0",
+  "version": "0.10.0",
   "description": "Local bridge for Linear Grab — delegate issues from the browser panel to headless Claude Code sessions running in your repo, with live status and an upload relay.",
   "type": "module",
   "bin": {