relaybrain 0.0.0-stage → 0.2.1

package/backend/lib/falkor/write.js

@@ -0,0 +1,281 @@
+// Parameterized batch writers. Labels/relationship types are constants here; every
+// value travels as a parameter. Counters are only bumped for nodes this batch created
+// (batch token), so replaying any batch is a no-op.
+const crypto = require("crypto");
+
+const CHUNK = 400;
+const TRANSCRIPT_EDIT_AGENTS = new Set(["Claude Code", "Cursor", "Codex", "Antigravity", "Copilot"]);
+
+function token() {
+  return crypto.randomBytes(8).toString("hex");
+}
+
+function chunks(rows, size = CHUNK) {
+  const out = [];
+  for (let i = 0; i < rows.length; i += size) out.push(rows.slice(i, i + size));
+  return out;
+}
+
+function dedupe(rows, key) {
+  const seen = new Map();
+  for (const row of rows) if (row && row[key] != null) seen.set(row[key], row);
+  return [...seen.values()];
+}
+
+async function each(client, projectId, query, rows, extra = {}) {
+  const results = [];
+  for (const part of chunks(rows)) {
+    const data = await client.write(projectId, query, { rows: part, ...extra });
+    results.push(...data);
+  }
+  return results;
+}
+
+const SESSIONS = `
+UNWIND $rows AS r
+MERGE (p:Person {key: r.login})
+  ON CREATE SET p.login = r.loginRaw, p.firstSeen = r.startedAt
+SET p.lastSeen = CASE WHEN p.lastSeen IS NULL OR r.lastAt > p.lastSeen THEN r.lastAt ELSE p.lastSeen END
+MERGE (a:Agent {key: r.agentKey})
+  ON CREATE SET a.label = r.label, a.login = r.login, a.firstSeen = r.startedAt
+SET a.lastSeen = CASE WHEN a.lastSeen IS NULL OR r.lastAt > a.lastSeen THEN r.lastAt ELSE a.lastSeen END
+MERGE (p)-[:RUNS]->(a)
+MERGE (s:Session {key: r.sessionKey})
+  ON CREATE SET s.sessionId = r.sessionId, s.label = r.label, s.bucket = r.bucket,
+                s.turnCount = 0, s.editCount = 0, s.startedAt = r.startedAt
+SET s.login = r.login, s.stub = false,
+    s.startedAt = CASE WHEN s.startedAt IS NULL OR r.startedAt < s.startedAt THEN r.startedAt ELSE s.startedAt END,
+    s.lastAt = CASE WHEN s.lastAt IS NULL OR r.lastAt > s.lastAt THEN r.lastAt ELSE s.lastAt END,
+    s.thinkingCount = CASE WHEN s.thinkingCount IS NULL OR r.thinkingCount > s.thinkingCount THEN r.thinkingCount ELSE s.thinkingCount END,
+    s.title = coalesce(s.title, r.title)
+FOREACH (_ IN CASE WHEN r.intentAt IS NOT NULL AND (s.intentAt IS NULL OR r.intentAt >= s.intentAt) THEN [1] ELSE [] END |
+  SET s.intent = r.intent, s.intentAt = r.intentAt)
+MERGE (a)-[:RAN]->(s)
+RETURN count(s) AS n`;
+
+const TURNS = `
+UNWIND $rows AS r
+MATCH (s:Session {key: r.sessionKey})
+MERGE (t:Turn {key: r.turnKey})
+  ON CREATE SET t.ts = r.ts, t.role = r.role, t.kind = r.kind, t.text = r.text,
+                t.seq = r.seq, t.tsSynthetic = r.tsSynthetic, t._b = $batch
+MERGE (s)-[:HAS_TURN]->(t)
+RETURN r.sessionKey AS sessionKey, coalesce(t._b = $batch, false) AS created`;
+
+const EDITS = `
+UNWIND $rows AS r
+MERGE (p:Person {key: r.login})
+  ON CREATE SET p.login = r.loginRaw, p.firstSeen = r.ts
+MERGE (a:Agent {key: r.agentKey})
+  ON CREATE SET a.label = r.label, a.login = r.login, a.firstSeen = r.ts
+MERGE (p)-[:RUNS]->(a)
+MERGE (e:Edit {key: r.editKey})
+  ON CREATE SET e.source = r.source, e.ts = r.ts, e.tool = r.tool, e.diffHead = r.diffHead,
+                e.added = r.added, e.removed = r.removed, e.tsSynthetic = r.tsSynthetic,
+                e.orphan = r.orphan, e.lamport = r.lamport, e.sha256 = r.sha256, e._b = $batch
+MERGE (e)-[:BY]->(a)
+WITH r, e
+OPTIONAL MATCH (s:Session {key: r.sessionKey})
+FOREACH (_ IN CASE WHEN s IS NULL THEN [] ELSE [1] END | MERGE (s)-[:MADE]->(e))
+RETURN r.editKey AS editKey, coalesce(e._b = $batch, false) AS created`;
+
+// One real change often arrives twice: transcript code_edit (intent) and watcher patch (disk truth).
+const SAME_CHANGE = `
+UNWIND $rows AS r
+MATCH (p:Edit {source: 'patch'})-[:MODIFIED]->(f:File {key: r.fileKey})
+MATCH (p)-[:BY]->(a:Agent {key: r.agentKey})
+WHERE NOT (p)-[:SAME_CHANGE]->()
+MATCH (t:Edit {source: 'transcript'})-[:MODIFIED]->(f)
+MATCH (t)-[:BY]->(a)
+WHERE abs(t.ts - p.ts) <= $windowMs
+RETURN p.key AS patchKey, t.key AS editKey, abs(t.ts - p.ts) AS gap,
+       p.diffHead AS patchDiff, t.diffHead AS editDiff, coalesce(t.tsSynthetic, false) AS synthetic`;
+
+const LINK_SAME_CHANGE = `
+UNWIND $rows AS r
+MATCH (p:Edit {key: r.patchKey})
+MATCH (t:Edit {key: r.editKey})
+MERGE (p)-[s:SAME_CHANGE]->(t)
+SET s.gapMs = r.gap, s.method = r.method
+RETURN count(s) AS n`;
+
+const SAME_CHANGE_EXACT_MS = 15_000;
+const SAME_CHANGE_CONTENT_MS = 10 * 60 * 1000;
+
+function addedLines(diff) {
+  const out = new Set();
+  for (const line of String(diff || "").split("\n")) {
+    if (!line.startsWith("+") || line.startsWith("+++")) continue;
+    const s = line.slice(1).trim();
+    if (s.length >= 8) out.add(s);
+  }
+  return out;
+}
+
+/**
+ * Picks the transcript edit each watcher patch duplicates: the nearest one within 15 s, or,
+ * when transcript times are approximate (Cursor's minute-precision stamps), one within 10 min
+ * that added the same lines.
+ */
+function matchSameChange(candidates) {
+  const byPatch = new Map();
+  for (const c of candidates) {
+    if (!byPatch.has(c.patchKey)) byPatch.set(c.patchKey, []);
+    byPatch.get(c.patchKey).push(c);
+  }
+  const links = [];
+  for (const list of byPatch.values()) {
+    const timed = list.filter((c) => c.gap <= SAME_CHANGE_EXACT_MS).sort((a, b) => a.gap - b.gap)[0];
+    if (timed) {
+      links.push({ patchKey: timed.patchKey, editKey: timed.editKey, gap: timed.gap, method: "time" });
+      continue;
+    }
+    const patchLines = addedLines(list[0].patchDiff);
+    if (!patchLines.size) continue;
+    let best = null;
+    for (const c of list) {
+      let shared = 0;
+      for (const l of addedLines(c.editDiff)) if (patchLines.has(l)) shared += 1;
+      if (shared && (!best || shared > best.shared || (shared === best.shared && c.gap < best.gap))) best = { ...c, shared };
+    }
+    if (best) links.push({ patchKey: best.patchKey, editKey: best.editKey, gap: best.gap, method: "content" });
+  }
+  return links;
+}
+
+const EDIT_FILES = `
+UNWIND $rows AS r
+MATCH (e:Edit {key: r.editKey})
+MERGE (f:File {key: r.fileKey})
+  ON CREATE SET f.editCount = 0
+SET f.path = r.path, f.ext = r.ext
+MERGE (e)-[:MODIFIED]->(f)
+RETURN count(e) AS n`;
+
+const FILE_COUNTS = `
+UNWIND $rows AS r
+MATCH (f:File {key: r.fileKey})
+SET f.editCount = coalesce(f.editCount, 0) + r.n,
+    f.lastEditAt = CASE WHEN f.lastEditAt IS NULL OR r.lastAt > f.lastEditAt THEN r.lastAt ELSE f.lastEditAt END
+RETURN count(f) AS n`;
+
+const TOUCHED = `
+UNWIND $rows AS r
+MATCH (a:Agent {key: r.agentKey})
+MATCH (f:File {key: r.fileKey})
+MERGE (a)-[t:TOUCHED]->(f)
+  ON CREATE SET t.count = 0, t.firstAt = r.firstAt, t.lastAt = r.lastAt
+SET t.count = t.count + r.n,
+    t.firstAt = CASE WHEN r.firstAt < t.firstAt THEN r.firstAt ELSE t.firstAt END,
+    t.lastAt = CASE WHEN r.lastAt > t.lastAt THEN r.lastAt ELSE t.lastAt END
+RETURN count(t) AS n`;
+
+const SESSION_COUNTS = `
+UNWIND $rows AS r
+MATCH (s:Session {key: r.sessionKey})
+SET s.turnCount = coalesce(s.turnCount, 0) + r.turns,
+    s.editCount = coalesce(s.editCount, 0) + r.edits
+RETURN count(s) AS n`;
+
+const PROMPTS = `
+UNWIND $rows AS r
+MATCH (e:Edit {key: r.editKey})
+OPTIONAL MATCH (u:Turn {key: r.promptKey})
+FOREACH (_ IN CASE WHEN u IS NULL THEN [] ELSE [1] END |
+  MERGE (e)-[p:PROMPTED_BY]->(u)
+  SET p.gapMs = r.promptGap, p.stale = r.promptStale, p.confidence = r.promptConfidence, p.via = r.promptVia)
+WITH e, r
+OPTIONAL MATCH (x:Turn {key: r.explainKey})
+FOREACH (_ IN CASE WHEN x IS NULL THEN [] ELSE [1] END |
+  MERGE (e)-[q:EXPLAINED_BY]->(x)
+  SET q.gapMs = r.explainGap)
+RETURN count(e) AS n`;
+
+function tally(rows, keyOf, init, add) {
+  const map = new Map();
+  for (const row of rows) {
+    const k = keyOf(row);
+    if (k == null) continue;
+    if (!map.has(k)) map.set(k, init(row));
+    add(map.get(k), row);
+  }
+  return [...map.values()];
+}
+
+/**
+ * Writes one projected history batch in dependency order:
+ * people/agents/sessions → turns → edits → files/touches → counters → prompt links.
+ */
+async function writeProjection(client, projectId, projection) {
+  const batch = token();
+  const sessions = dedupe(projection.sessions, "sessionKey");
+  const turns = dedupe(projection.turns, "turnKey");
+  const edits = dedupe(projection.edits, "editKey").map((e) => ({ source: "transcript", lamport: null, sha256: null, ...e }));
+
+  if (sessions.length) await each(client, projectId, SESSIONS, sessions);
+
+  const turnResults = turns.length ? await each(client, projectId, TURNS, turns, { batch }) : [];
+  const editResults = edits.length ? await each(client, projectId, EDITS, edits, { batch }) : [];
+
+  const createdEdit = new Set(editResults.filter((r) => r.created).map((r) => r.editKey));
+  const fileRows = edits.filter((e) => e.fileKey);
+  if (fileRows.length) await each(client, projectId, EDIT_FILES, fileRows);
+
+  // These agents' transcripts already record each edit, so their watcher patch is the same change twice.
+  const counted = (e) => e.source !== "patch" || !TRANSCRIPT_EDIT_AGENTS.has(e.label);
+  const freshFileRows = fileRows.filter((e) => createdEdit.has(e.editKey) && counted(e));
+  const fileCounts = tally(
+    freshFileRows,
+    (e) => e.fileKey,
+    (e) => ({ fileKey: e.fileKey, n: 0, lastAt: e.ts }),
+    (acc, e) => {
+      acc.n += 1;
+      acc.lastAt = Math.max(acc.lastAt, e.ts);
+    }
+  );
+  if (fileCounts.length) await each(client, projectId, FILE_COUNTS, fileCounts);
+
+  const touches = tally(
+    freshFileRows,
+    (e) => `${e.agentKey}|${e.fileKey}`,
+    (e) => ({ agentKey: e.agentKey, fileKey: e.fileKey, n: 0, firstAt: e.ts, lastAt: e.ts }),
+    (acc, e) => {
+      acc.n += 1;
+      acc.firstAt = Math.min(acc.firstAt, e.ts);
+      acc.lastAt = Math.max(acc.lastAt, e.ts);
+    }
+  );
+  if (touches.length) await each(client, projectId, TOUCHED, touches);
+
+  const counters = new Map();
+  const bump = (sessionKey, field) => {
+    if (!counters.has(sessionKey)) counters.set(sessionKey, { sessionKey, turns: 0, edits: 0 });
+    counters.get(sessionKey)[field] += 1;
+  };
+  for (const r of turnResults) if (r.created) bump(r.sessionKey, "turns");
+  for (const e of edits) if (e.sessionKey && createdEdit.has(e.editKey) && counted(e)) bump(e.sessionKey, "edits");
+  if (counters.size) await each(client, projectId, SESSION_COUNTS, [...counters.values()]);
+
+  const linked = edits.filter((e) => e.promptKey || e.explainKey);
+  if (linked.length) await each(client, projectId, PROMPTS, linked);
+
+  const pairs = dedupe(
+    fileRows.map((e) => ({ k: `${e.agentKey}|${e.fileKey}`, agentKey: e.agentKey, fileKey: e.fileKey })),
+    "k"
+  );
+  if (pairs.length) {
+    const candidates = await each(client, projectId, SAME_CHANGE, pairs, { windowMs: SAME_CHANGE_CONTENT_MS });
+    const links = matchSameChange(candidates);
+    if (links.length) await each(client, projectId, LINK_SAME_CHANGE, links);
+  }
+
+  return {
+    sessions: sessions.length,
+    turns: turns.length,
+    turnsCreated: turnResults.filter((r) => r.created).length,
+    edits: edits.length,
+    editsCreated: createdEdit.size,
+  };
+}
+
+module.exports = { writeProjection, each, chunks, dedupe, token, matchSameChange };

package/backend/lib/githubLogin.js

@@ -0,0 +1,108 @@
+const { spawn } = require("child_process");
+const { loadRegistry, saveRegistry, saveSession, loadSession } = require("./store");
+const { authorizeUrl, exchangeCode } = require("./githubOAuth");
+
+function runGh(args) {
+  return new Promise((resolve, reject) => {
+    const child = spawn("gh", args, { stdio: ["ignore", "pipe", "pipe"], windowsHide: true, shell: false });
+    let out = "";
+    let err = "";
+    child.stdout.on("data", (c) => (out += c));
+    child.stderr.on("data", (c) => (err += c));
+    child.on("error", () => reject(new Error("GitHub CLI (gh) is not installed")));
+    child.on("exit", (code) => {
+      if (code === 0) resolve(out.trim());
+      else reject(new Error(err.trim() || `gh exited ${code}`));
+    });
+  });
+}
+
+function upsertUser(user) {
+  const reg = loadRegistry();
+  const idx = reg.users.findIndex((u) => u.login === user.login || u.id === user.id);
+  if (idx >= 0) reg.users[idx] = { ...reg.users[idx], ...user };
+  else reg.users.unshift(user);
+  saveRegistry(reg);
+  saveSession({ ...loadSession(), userId: user.id, login: user.login });
+  return user;
+}
+
+async function loginFromGh() {
+  const raw = await runGh(["api", "user"]);
+  const gh = JSON.parse(raw);
+  return upsertUser({
+    id: `gh_${gh.id}`,
+    login: gh.login,
+    name: gh.name || gh.login,
+    avatarUrl: gh.avatar_url,
+  });
+}
+
+async function loginDeviceFlow() {
+  const clientId = process.env.GITHUB_CLIENT_ID;
+  if (!clientId) throw new Error("no_device_flow");
+  const res = await fetch("https://github.com/login/device/code", {
+    method: "POST",
+    headers: { Accept: "application/json", "Content-Type": "application/json" },
+    body: JSON.stringify({ client_id: clientId, scope: "read:user repo" }),
+  });
+  const device = await res.json();
+  if (!device.device_code) throw new Error(device.error || "device_code_failed");
+  return device;
+}
+
+async function pollDevice(device) {
+  const clientId = process.env.GITHUB_CLIENT_ID;
+  const started = Date.now();
+  const interval = (device.interval || 5) * 1000;
+  while (Date.now() - started < (device.expires_in || 900) * 1000) {
+    await new Promise((r) => setTimeout(r, interval));
+    const res = await fetch("https://github.com/login/oauth/access_token", {
+      method: "POST",
+      headers: { Accept: "application/json", "Content-Type": "application/json" },
+      body: JSON.stringify({
+        client_id: clientId,
+        device_code: device.device_code,
+        grant_type: "urn:ietf:params:oauth:grant-type:device_code",
+      }),
+    });
+    const body = await res.json();
+    if (body.access_token) {
+      const userRes = await fetch("https://api.github.com/user", {
+        headers: { Authorization: `Bearer ${body.access_token}`, "User-Agent": "relay-it" },
+      });
+      const gh = await userRes.json();
+      return upsertUser({
+        id: `gh_${gh.id}`,
+        login: gh.login,
+        name: gh.name || gh.login,
+        avatarUrl: gh.avatar_url,
+      });
+    }
+    if (body.error === "authorization_pending") continue;
+    if (body.error === "slow_down") continue;
+    throw new Error(body.error_description || body.error || "device_denied");
+  }
+  throw new Error("device_expired");
+}
+
+function logout() {
+  saveSession({ userId: null, login: null, projectId: loadSession().projectId });
+}
+
+function whoami() {
+  const session = loadSession();
+  const user = loadRegistry().users.find((u) => u.id === session.userId || u.login === session.login);
+  return { session, user: user || null };
+}
+
+module.exports = {
+  loginFromGh,
+  loginDeviceFlow,
+  pollDevice,
+  upsertUser,
+  logout,
+  whoami,
+  authorizeUrl,
+  exchangeCode,
+};

package/backend/lib/githubOAuth.js

@@ -0,0 +1,42 @@
+async function exchangeCode(code, redirectUri) {
+  const clientId = process.env.GITHUB_CLIENT_ID;
+  const secret = process.env.GITHUB_CLIENT_SECRET;
+  if (!clientId || !secret) return { error: "oauth_not_configured" };
+  const tokenRes = await fetch("https://github.com/login/oauth/access_token", {
+    method: "POST",
+    headers: { Accept: "application/json", "Content-Type": "application/json" },
+    body: JSON.stringify({
+      client_id: clientId,
+      client_secret: secret,
+      code,
+      redirect_uri: redirectUri,
+    }),
+  });
+  const token = await tokenRes.json();
+  if (!token.access_token) return { error: "token_failed", detail: token };
+  const userRes = await fetch("https://api.github.com/user", {
+    headers: { Authorization: `Bearer ${token.access_token}`, "User-Agent": "relay-it" },
+  });
+  const gh = await userRes.json();
+  return {
+    user: {
+      id: `gh_${gh.id}`,
+      login: gh.login,
+      name: gh.name || gh.login,
+      avatarUrl: gh.avatar_url,
+    },
+  };
+}
+
+function authorizeUrl(redirectUri) {
+  const clientId = process.env.GITHUB_CLIENT_ID;
+  if (!clientId) return null;
+  const q = new URLSearchParams({
+    client_id: clientId,
+    redirect_uri: redirectUri,
+    scope: "read:user",
+  });
+  return `https://github.com/login/oauth/authorize?${q}`;
+}
+
+module.exports = { exchangeCode, authorizeUrl };

package/backend/lib/githubRepo.js

@@ -0,0 +1,117 @@
+const { spawn } = require("child_process");
+
+// In-memory only — a per-repo cache is enough to stop every dashboard poll
+// (RelayContext polls on an interval) from re-hitting GitHub's API/gh CLI.
+const CACHE_MS = 60_000;
+const cache = new Map(); // "owner/repo" -> { at, data }
+
+function runGh(args) {
+  return new Promise((resolve, reject) => {
+    const child = spawn("gh", args, { stdio: ["ignore", "pipe", "pipe"], windowsHide: true, shell: false });
+    let out = "";
+    let err = "";
+    child.stdout.on("data", (c) => (out += c));
+    child.stderr.on("data", (c) => (err += c));
+    child.on("error", () => reject(new Error("gh_not_installed")));
+    child.on("exit", (code) => {
+      if (code === 0) resolve(out.trim());
+      else reject(new Error(err.trim() || `gh exited ${code}`));
+    });
+  });
+}
+
+// Matches both https://github.com/owner/repo(.git) and git@github.com:owner/repo(.git)
+function parseGithubRepo(remoteUrl) {
+  if (!remoteUrl) return null;
+  const m = String(remoteUrl).match(/github\.com[/:]([^/]+)\/([^/.]+)(?:\.git)?\/?$/i);
+  if (!m) return null;
+  return { owner: m[1], repo: m[2] };
+}
+
+function permissionOf(u) {
+  if (u.role_name) return u.role_name;
+  if (u.permissions?.admin) return "admin";
+  if (u.permissions?.push) return "write";
+  if (u.permissions?.pull) return "read";
+  return null;
+}
+
+async function fetchCollaboratorsRaw(owner, repo) {
+  try {
+    // Requires push access on the repo (via `gh auth login`) — this is the
+    // real "who can push here" collaborator list, avatars included.
+    const raw = await runGh(["api", `repos/${owner}/${repo}/collaborators`, "--paginate"]);
+    const list = JSON.parse(raw);
+    return list.map((u) => ({
+      id: `gh_${u.id}`,
+      login: u.login,
+      name: u.login,
+      avatarUrl: u.avatar_url,
+      permission: permissionOf(u),
+      source: "collaborators",
+    }));
+  } catch {
+    // Fallback for when `gh` isn't installed/authed, or the caller lacks push
+    // access: public contributor list needs no auth at all. Not the same set
+    // as real collaborators (it's activity-based, no pending/read-only
+    // invites) but better than an empty panel.
+    try {
+      const res = await fetch(`https://api.github.com/repos/${owner}/${repo}/contributors`, {
+        headers: { "User-Agent": "relay-it" },
+      });
+      if (!res.ok) throw new Error(`http_${res.status}`);
+      const list = await res.json();
+      return list.map((u) => ({
+        id: `gh_${u.id}`,
+        login: u.login,
+        name: u.login,
+        avatarUrl: u.avatar_url,
+        permission: null,
+        source: "contributors-fallback",
+      }));
+    } catch {
+      return [];
+    }
+  }
+}
+
+function fetchCollaborators(remoteUrl) {
+  const parsed = parseGithubRepo(remoteUrl);
+  if (!parsed) return Promise.resolve([]);
+  const key = `${parsed.owner}/${parsed.repo}`;
+  const hit = cache.get(key);
+  if (hit && Date.now() - hit.at < CACHE_MS && hit.data.length) return Promise.resolve(hit.data);
+  return fetchCollaboratorsRaw(parsed.owner, parsed.repo).then((data) => {
+    const prev = cache.get(key);
+    const prevAuth = (prev?.data || []).filter((c) => c.source === "collaborators");
+    const nextAuth = (data || []).filter((c) => c.source === "collaborators");
+    // Prefer a real collaborator list. A later contributors-fallback (gh
+    // flaked, no push access this poll) must not shrink a roster we already had.
+    if (nextAuth.length) {
+      cache.set(key, { at: Date.now(), data });
+      return data;
+    }
+    if (prevAuth.length) {
+      cache.set(key, { at: Date.now(), data: prev.data });
+      return prev.data;
+    }
+    if (data.length) {
+      cache.set(key, { at: Date.now(), data });
+      return data;
+    }
+    if (prev?.data?.length) {
+      cache.set(key, { at: Date.now(), data: prev.data });
+      return prev.data;
+    }
+    cache.set(key, { at: Date.now(), data: [] });
+    return [];
+  });
+}
+
+function peekCollaborators(remoteUrl) {
+  const parsed = parseGithubRepo(remoteUrl);
+  if (!parsed) return [];
+  return cache.get(`${parsed.owner}/${parsed.repo}`)?.data || [];
+}
+
+module.exports = { fetchCollaborators, peekCollaborators, parseGithubRepo };

package/backend/lib/harvest.js

@@ -0,0 +1,85 @@
+const fs = require("fs");
+const path = require("path");
+const os = require("os");
+
+function readJsonl(file) {
+  if (!file || !fs.existsSync(file)) return [];
+  return fs
+    .readFileSync(file, "utf8")
+    .split("\n")
+    .filter(Boolean)
+    .map((line) => {
+      try {
+        return JSON.parse(line);
+      } catch {
+        return null;
+      }
+    })
+    .filter(Boolean);
+}
+
+function normalizeMessages(rows) {
+  const messages = [];
+  const edits = [];
+  for (const row of rows) {
+    const role = row.role || row.type || row.message?.role;
+    const text =
+      row.text ||
+      row.content ||
+      row.message?.content ||
+      (Array.isArray(row.message?.content) ? row.message.content.map((c) => c.text || "").join("\n") : "");
+    if (role === "user" || role === "assistant" || role === "human") {
+      messages.push({ role: role === "human" ? "user" : role, text: String(text || "").slice(0, 4000) });
+    }
+    const file =
+      row.tool_input?.file_path ||
+      row.tool_input?.target_file ||
+      row.message?.tool_use?.input?.file_path ||
+      null;
+    if (file && (role === "tool" || row.type === "tool_use" || row.tool_name)) {
+      edits.push({ file: String(file).replace(/\\/g, "/"), diff: "" });
+      messages.push({ role: "tool", text: `Edit ${file}`, file });
+    }
+  }
+  return { messages, edits };
+}
+
+function findCursorTranscript(sessionId) {
+  if (!sessionId) return null;
+  const roots = [
+    path.join(os.homedir(), ".cursor", "projects"),
+    path.join(os.homedir(), ".cursor-tutor"),
+  ];
+  for (const root of roots) {
+    if (!fs.existsSync(root)) continue;
+    const stack = [root];
+    let walked = 0;
+    while (stack.length && walked < 400) {
+      walked += 1;
+      const dir = stack.pop();
+      let entries = [];
+      try {
+        entries = fs.readdirSync(dir, { withFileTypes: true });
+      } catch {
+        continue;
+      }
+      for (const e of entries) {
+        const full = path.join(dir, e.name);
+        if (e.isDirectory() && e.name !== "node_modules") stack.push(full);
+        else if (e.name.includes(sessionId) && e.name.endsWith(".jsonl")) return full;
+      }
+    }
+  }
+  return null;
+}
+
+function harvest({ transcript_path, sessionId, conversationId }) {
+  const file = transcript_path || findCursorTranscript(sessionId || conversationId);
+  if (!file) return { messages: [], edits: [], source: null };
+  const rows = readJsonl(file);
+  const parsed = normalizeMessages(rows);
+  parsed.source = file;
+  return parsed;
+}
+
+module.exports = { harvest, readJsonl, normalizeMessages };

package/backend/lib/httpServer.js

@@ -0,0 +1,27 @@
+/** Next's rewrite proxy reuses sockets; Node's 5s keep-alive closes them first → ECONNRESET. */
+function hardenHttpServer(server) {
+  server.keepAliveTimeout = 65_000;
+  server.headersTimeout = 66_000;
+  server.requestTimeout = 0;
+  server.timeout = 0;
+  server.on("error", (err) => {
+    console.error("[relay-api]", err.message);
+    process.exitCode = 1;
+  });
+  server.on("clientError", (err, socket) => {
+    if (err?.code === "ECONNRESET" || !socket || socket.destroyed) return;
+    try {
+      socket.end("HTTP/1.1 400 Bad Request\r\n\r\n");
+    } catch {
+      /* already closed */
+    }
+  });
+  return server;
+}
+
+function apiErrorHandler(err, _req, res, _next) {
+  console.error("[relay-api]", err);
+  if (!res.headersSent) res.status(500).json({ error: String(err.message || err) });
+}
+
+module.exports = { hardenHttpServer, apiErrorHandler };