relaybrain 0.0.0-stage → 0.2.0

package/backend/lib/installHooks.js

@@ -0,0 +1,309 @@
+const fs = require("fs");
+const path = require("path");
+const os = require("os");
+const { EDIT, READ } = require("./editMatchers");
+const { installProjectRelay, installGlobalRelay } = require("./installAgentRelay");
+
+function repoRoot() {
+  return path.join(__dirname, "..", "..");
+}
+
+function nodeCmd(scriptRel) {
+  const abs = path.join(repoRoot(), scriptRel).replace(/\\/g, "/");
+  return `node "${abs}"`;
+}
+
+function writeJson(file, value) {
+  fs.mkdirSync(path.dirname(file), { recursive: true });
+  fs.writeFileSync(file, JSON.stringify(value, null, 2));
+}
+
+function installProjectHooks(workspacePath) {
+  if (!workspacePath) return;
+  const claude = nodeCmd("hooks/relay-claude-pre-tool.js");
+  const claudePost = nodeCmd("hooks/relay-claude-post-tool.js");
+  const claudeStop = nodeCmd("hooks/relay-claude-stop.js");
+  const cursor = nodeCmd("hooks/relay-cursor-pre-tool.js");
+  const cursorPost = nodeCmd("hooks/relay-cursor-post-tool.js");
+  const cursorStop = nodeCmd("hooks/relay-cursor-stop.js");
+  const codex = nodeCmd("hooks/relay-codex-pre-tool.js");
+  const codexPost = nodeCmd("hooks/relay-codex-post-tool.js");
+  const codexStop = nodeCmd("hooks/relay-codex-stop.js");
+  const copilot = nodeCmd("hooks/relay-copilot-pre-tool.js");
+  const copilotPost = nodeCmd("hooks/relay-copilot-post-tool.js");
+  const copilotStop = nodeCmd("hooks/relay-copilot-stop.js");
+  const anti = nodeCmd("hooks/relay-antigravity-pre-tool.js");
+  const antiPost = nodeCmd("hooks/relay-antigravity-post-tool.js");
+  const antiStop = nodeCmd("hooks/relay-antigravity-stop.js");
+
+  writeJson(path.join(workspacePath, ".claude", "settings.json"), {
+    hooks: {
+      PreToolUse: [
+        {
+          matcher: EDIT.claude,
+          hooks: [{ type: "command", command: claude }],
+        },
+        {
+          matcher: READ.claude,
+          hooks: [{ type: "command", command: nodeCmd("hooks/relay-claude-pre-read.js") }],
+        },
+      ],
+      PostToolUse: [
+        {
+          matcher: EDIT.claude,
+          hooks: [{ type: "command", command: claudePost }],
+        },
+      ],
+      Stop: [{ matcher: "*", hooks: [{ type: "command", command: claudeStop }] }],
+    },
+  });
+
+  writeJson(path.join(workspacePath, ".cursor", "hooks.json"), {
+    version: 1,
+    hooks: {
+      preToolUse: [
+        {
+          command: cursor,
+          matcher: EDIT.cursor,
+          timeout: 10,
+        },
+        {
+          command: nodeCmd("hooks/relay-cursor-pre-read.js"),
+          matcher: READ.cursor,
+          timeout: 10,
+        },
+      ],
+      postToolUse: [
+        {
+          command: cursorPost,
+          matcher: EDIT.cursor,
+          timeout: 10,
+        },
+      ],
+      // Documented Cursor read hook. Payload: { file_path, content }. Matcher
+      // filters by tool type (Read, TabRead, …). Fail-open by default: reporting
+      // a read must never be able to stop the agent from reading.
+      beforeReadFile: [
+        {
+          command: nodeCmd("hooks/relay-cursor-pre-read.js"),
+          matcher: "Read",
+          timeout: 10,
+        },
+      ],
+      stop: [{ command: cursorStop, loop_limit: 1 }],
+    },
+  });
+
+  // No read hook for Codex: it exposes no read or search tool, so file reads
+  // arrive as shell commands under the Bash matcher. Matching Bash to sniff
+  // reads out of a command line would report greps and cats as "reads" and miss
+  // everything else, so Codex contributes edits only.
+  writeJson(path.join(workspacePath, ".codex", "hooks.json"), {
+    hooks: {
+      PreToolUse: [
+        {
+          matcher: EDIT.codex,
+          hooks: [{ type: "command", command: codex, timeout: 10 }],
+        },
+      ],
+      PostToolUse: [
+        {
+          matcher: EDIT.codex,
+          hooks: [{ type: "command", command: codexPost, timeout: 10 }],
+        },
+      ],
+      Stop: [{ hooks: [{ type: "command", command: codexStop, timeout: 120 }] }],
+    },
+  });
+
+  writeJson(path.join(workspacePath, ".github", "hooks", "relay-os.json"), {
+    version: 1,
+    hooks: {
+      preToolUse: [
+        {
+          type: "command",
+          bash: copilot,
+          powershell: copilot,
+          matcher: EDIT.copilot,
+          cwd: ".",
+          timeoutSec: 10,
+        },
+        {
+          type: "command",
+          bash: nodeCmd("hooks/relay-copilot-pre-read.js"),
+          powershell: nodeCmd("hooks/relay-copilot-pre-read.js"),
+          matcher: READ.copilot,
+          cwd: ".",
+          timeoutSec: 10,
+        },
+      ],
+      postToolUse: [
+        {
+          type: "command",
+          bash: copilotPost,
+          powershell: copilotPost,
+          matcher: EDIT.copilot,
+          cwd: ".",
+          timeoutSec: 10,
+        },
+      ],
+      agentStop: [
+        {
+          type: "command",
+          bash: copilotStop,
+          powershell: copilotStop,
+          cwd: ".",
+          timeoutSec: 120,
+        },
+      ],
+    },
+  });
+
+  writeJson(path.join(workspacePath, ".agents", "hooks.json"), antigravityHooks(anti, antiPost, antiStop));
+  try {
+    installProjectRelay(workspacePath);
+  } catch {
+    /* instructions + MCP are best-effort */
+  }
+}
+
+/**
+ * Antigravity's config is keyed by hook NAME at the top level, and each name
+ * maps to its events — `{"relay": {"PreToolUse": [...]}}`. We were writing
+ * `{"hooks": {...}}`, which only worked by accident, as a hook that happened to
+ * be named "hooks".
+ *
+ * The event shapes also differ from each other: PreToolUse and PostToolUse take
+ * a matcher group wrapping a `hooks` array, while Stop takes the handler
+ * directly.
+ */
+function antigravityHooks(pre, post, stop) {
+  return {
+    relay: {
+      PreToolUse: [
+        {
+          matcher: EDIT.antigravity,
+          hooks: [{ type: "command", command: pre, timeout: 10 }],
+        },
+        {
+          matcher: READ.antigravity,
+          hooks: [{ type: "command", command: nodeCmd("hooks/relay-antigravity-pre-read.js"), timeout: 10 }],
+        },
+      ],
+      PostToolUse: [
+        {
+          matcher: EDIT.antigravity,
+          hooks: [{ type: "command", command: post, timeout: 10 }],
+        },
+      ],
+      Stop: [{ type: "command", command: stop, timeout: 120 }],
+    },
+  };
+}
+
+function mergeClaudeSettings(file, preCmd, postCmd, stopCmd) {
+  let existing = {};
+  try {
+    existing = JSON.parse(fs.readFileSync(file, "utf8"));
+  } catch {
+    existing = {};
+  }
+  existing.hooks = existing.hooks || {};
+  existing.hooks.PreToolUse = [
+    {
+      matcher: EDIT.claude,
+      hooks: [{ type: "command", command: preCmd }],
+    },
+    {
+      matcher: READ.claude,
+      hooks: [{ type: "command", command: nodeCmd("hooks/relay-claude-pre-read.js") }],
+    },
+  ];
+  existing.hooks.PostToolUse = [
+    {
+      matcher: EDIT.claude,
+      hooks: [{ type: "command", command: postCmd }],
+    },
+  ];
+  existing.hooks.Stop = [{ matcher: "*", hooks: [{ type: "command", command: stopCmd }] }];
+  writeJson(file, existing);
+}
+
+function installGlobalHooks() {
+  const home = os.homedir();
+  mergeClaudeSettings(
+    path.join(home, ".claude", "settings.json"),
+    nodeCmd("hooks/relay-claude-pre-tool.js"),
+    nodeCmd("hooks/relay-claude-post-tool.js"),
+    nodeCmd("hooks/relay-claude-stop.js")
+  );
+  writeJson(path.join(home, ".cursor", "hooks.json"), {
+    version: 1,
+    hooks: {
+      preToolUse: [
+        {
+          command: nodeCmd("hooks/relay-cursor-pre-tool.js"),
+          matcher: EDIT.cursor,
+          timeout: 10,
+        },
+        {
+          command: nodeCmd("hooks/relay-cursor-pre-read.js"),
+          matcher: READ.cursor,
+          timeout: 10,
+        },
+      ],
+      postToolUse: [
+        {
+          command: nodeCmd("hooks/relay-cursor-post-tool.js"),
+          matcher: EDIT.cursor,
+          timeout: 10,
+        },
+      ],
+      beforeReadFile: [
+        {
+          command: nodeCmd("hooks/relay-cursor-pre-read.js"),
+          matcher: "Read",
+          timeout: 10,
+        },
+      ],
+      stop: [{ command: nodeCmd("hooks/relay-cursor-stop.js"), loop_limit: 1 }],
+    },
+  });
+  writeJson(path.join(home, ".codex", "hooks.json"), {
+    hooks: {
+      PreToolUse: [
+        {
+          matcher: EDIT.codex,
+          hooks: [{ type: "command", command: nodeCmd("hooks/relay-codex-pre-tool.js"), timeout: 10 }],
+        },
+      ],
+      PostToolUse: [
+        {
+          matcher: EDIT.codex,
+          hooks: [{ type: "command", command: nodeCmd("hooks/relay-codex-post-tool.js"), timeout: 10 }],
+        },
+      ],
+      Stop: [
+        {
+          hooks: [{ type: "command", command: nodeCmd("hooks/relay-codex-stop.js"), timeout: 120 }],
+        },
+      ],
+    },
+  });
+  const antigravity = antigravityHooks(
+    nodeCmd("hooks/relay-antigravity-pre-tool.js"),
+    nodeCmd("hooks/relay-antigravity-post-tool.js"),
+    nodeCmd("hooks/relay-antigravity-stop.js")
+  );
+  // Antigravity reads global hooks from ~/.gemini/config, either directly or
+  // from a plugin bundle under it.
+  writeJson(path.join(home, ".gemini", "config", "plugins", "relay", "hooks.json"), antigravity);
+  writeJson(path.join(home, ".gemini", "config", "hooks.json"), antigravity);
+  try {
+    installGlobalRelay();
+  } catch {
+    /* global MCP is best-effort */
+  }
+}
+
+module.exports = { installProjectHooks, installGlobalHooks };

package/backend/lib/lamport.js

@@ -0,0 +1,14 @@
+const clocks = new Map();
+
+function tick(workspaceId, incoming = 0) {
+  const key = workspaceId || "global";
+  const next = Math.max((clocks.get(key) || 0) + 1, Number(incoming) + 1);
+  clocks.set(key, next);
+  return next;
+}
+
+function peek(workspaceId) {
+  return clocks.get(workspaceId || "global") || 0;
+}
+
+module.exports = { tick, peek };

package/backend/lib/localBrowse.js

@@ -0,0 +1,109 @@
+// Backs the "Add workspace" window: a local directory browser and the signed-in
+// GitHub account's repositories. These used to be Next.js server routes; living
+// here lets Mission Control ship as a static build that `relay serve` hosts.
+// Both are host-only — a room member must never browse the host's disk.
+
+const fs = require("fs");
+const path = require("path");
+const { spawn } = require("child_process");
+
+function listDrives() {
+  const drives = [];
+  for (let c = 65; c <= 90; c++) {
+    const root = `${String.fromCharCode(c)}:\\`;
+    try {
+      if (fs.existsSync(root)) drives.push({ name: root, path: root, isDir: true });
+    } catch {
+      /* drive not ready */
+    }
+  }
+  return drives;
+}
+
+async function listDir(dir) {
+  if (!dir) {
+    const entries = process.platform === "win32" ? listDrives() : [{ name: "/", path: "/", isDir: true }];
+    return { status: 200, body: { path: null, parent: null, entries } };
+  }
+  const resolved = path.resolve(dir);
+  try {
+    const dirents = await fs.promises.readdir(resolved, { withFileTypes: true });
+    const entries = dirents
+      .map((d) => ({ name: d.name, path: path.join(resolved, d.name), isDir: d.isDirectory() }))
+      .sort((a, b) => (a.isDir === b.isDir ? a.name.localeCompare(b.name) : a.isDir ? -1 : 1));
+    const parent = path.dirname(resolved);
+    return { status: 200, body: { path: resolved, parent: parent === resolved ? null : parent, entries } };
+  } catch (err) {
+    return { status: 400, body: { error: err.message } };
+  }
+}
+
+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 = "";
+    const timer = setTimeout(() => {
+      child.kill();
+      reject(new Error("gh timed out"));
+    }, 25_000);
+    child.stdout.on("data", (c) => (out += c));
+    child.stderr.on("data", (c) => (err += c));
+    child.on("error", () => {
+      clearTimeout(timer);
+      reject(new Error("gh_not_installed"));
+    });
+    child.on("exit", (code) => {
+      clearTimeout(timer);
+      if (code === 0) resolve(out.trim());
+      else reject(new Error(err.trim() || `gh exited ${code}`));
+    });
+  });
+}
+
+function classify(message) {
+  if (message === "gh_not_installed") return "gh_not_installed";
+  if (/not logged|authentication|gh auth login|HTTP 401/i.test(message)) return "gh_not_authenticated";
+  return message;
+}
+
+const CACHE_MS = 60_000;
+let cache = null;
+
+async function listGithubRepos({ refresh = false } = {}) {
+  if (!refresh && cache && Date.now() - cache.at < CACHE_MS) return cache.body;
+  try {
+    const raw = await runGh([
+      "api",
+      "user/repos?per_page=100&sort=updated&affiliation=owner,collaborator,organization_member",
+      "--paginate",
+    ]);
+    // --paginate concatenates JSON arrays; normalise "][" joins into one array.
+    const list = JSON.parse(raw.replace(/\]\s*\[/g, ","));
+    const repos = list.map((r) => ({
+      id: `gh_${r.id}`,
+      name: r.name,
+      fullName: r.full_name,
+      owner: r.owner?.login ?? null,
+      ownerAvatarUrl: r.owner?.avatar_url ?? null,
+      description: r.description,
+      private: Boolean(r.private),
+      fork: Boolean(r.fork),
+      language: r.language,
+      defaultBranch: r.default_branch,
+      cloneUrl: r.clone_url,
+      sshUrl: r.ssh_url,
+      htmlUrl: r.html_url,
+      updatedAt: r.pushed_at || r.updated_at,
+      stars: r.stargazers_count || 0,
+    }));
+    const body = { repos, error: null };
+    cache = { at: Date.now(), body };
+    return body;
+  } catch (err) {
+    // Never 500 here — the window renders a helpful empty state off `error`.
+    return { repos: [], error: classify(err.message) };
+  }
+}
+
+module.exports = { listDir, listGithubRepos };

package/backend/lib/memorySync.js

@@ -0,0 +1,63 @@
+const crypto = require("crypto");
+const { loadMemory, saveMemory, id } = require("./store");
+
+function appendStopTurn(projectId, { agent, ownerLogin, sessionId, messages, edits }) {
+  const memory = loadMemory(projectId);
+  const ts = Date.now();
+  const mineLogin = ownerLogin;
+  const chatId = `chat_${sessionId || id("sess")}`;
+  let thread = memory.chats.find((c) => c.id === chatId);
+  if (!thread) {
+    thread = { id: chatId, agent, ownerLogin, mine: true, messages: [] };
+    memory.chats.unshift(thread);
+  }
+  for (const m of messages || []) thread.messages.push(m);
+
+  const events = (messages || []).map((m) => ({
+    type: m.role === "user" ? "user" : m.role === "tool" ? "edit" : "assistant",
+    text: m.text,
+    file: m.file,
+  }));
+  memory.timeline.unshift({
+    id: id("seg"),
+    agent,
+    ownerLogin,
+    mine: true,
+    ts,
+    title: `Stop sync · ${agent}`,
+    events,
+  });
+
+  for (const edit of edits || []) {
+    memory.edits.unshift({
+      id: id("e"),
+      agent,
+      ownerLogin,
+      mine: true,
+      file: edit.file,
+      ts,
+      diff: edit.diff || "",
+    });
+    memory.activity.unshift({
+      id: id("a"),
+      kind: "edit",
+      agent,
+      ownerLogin,
+      mine: true,
+      text: `Edited ${edit.file}`,
+      ts,
+    });
+  }
+
+  memory.stats = memory.stats || {};
+  memory.stats.events = (memory.stats.events || 0) + 1;
+  memory.stats.patches = memory.edits.length;
+  saveMemory(projectId, memory);
+  return memory;
+}
+
+function clientEventId(ts, filepath, index) {
+  return crypto.createHash("sha256").update(`${ts}|${filepath}|${index}`).digest("hex");
+}
+
+module.exports = { appendStopTurn, clientEventId };

package/backend/lib/notices.js

@@ -0,0 +1,143 @@
+const crypto = require("crypto");
+const path = require("path");
+const { dataDir } = require("./paths");
+const { readJson, writeJson } = require("./store");
+
+const MAX = 80;
+
+function noticesPath() {
+  return path.join(dataDir(), "notices.json");
+}
+
+function load() {
+  const rows = readJson(noticesPath(), []);
+  return Array.isArray(rows) ? rows : [];
+}
+
+function save(rows) {
+  writeJson(noticesPath(), rows.slice(0, MAX));
+  return rows;
+}
+
+function prune(rows, now = Date.now()) {
+  return rows.filter((n) => {
+    if (n.dismissedAt && now - n.dismissedAt > 7 * 24 * 60 * 60 * 1000) return false;
+    if (n.readAt && !n.dismissedAt && now - n.readAt > 14 * 24 * 60 * 60 * 1000) return false;
+    return true;
+  });
+}
+
+function view(row) {
+  return {
+    id: row.id,
+    type: row.type,
+    key: row.key,
+    title: row.title,
+    body: row.body || "",
+    action: row.action || null,
+    payload: row.payload || null,
+    workspaceId: row.workspaceId || null,
+    ts: row.ts,
+    readAt: row.readAt || null,
+    dismissedAt: row.dismissedAt || null,
+  };
+}
+
+function listNotices({ includeDismissed } = {}) {
+  return prune(load())
+    .filter((n) => includeDismissed || !n.dismissedAt)
+    .sort((a, b) => (b.ts || 0) - (a.ts || 0))
+    .map(view);
+}
+
+function unreadCount() {
+  return listNotices().filter((n) => !n.readAt).length;
+}
+
+/**
+ * Inserts a notice unless one with the same key is already sitting unread.
+ * `revive` reopens a read/dismissed row (host came back, teammate rejoined).
+ */
+function pushNotice(input, { revive } = {}) {
+  if (!input?.type || !input?.key || !input?.title) return null;
+  const now = Date.now();
+  const rows = prune(load(), now);
+  const existing = rows.find((n) => n.key === input.key);
+  if (existing && !revive) return null;
+  if (existing && revive) {
+    existing.title = input.title;
+    existing.body = input.body || existing.body || "";
+    existing.action = input.action || existing.action || null;
+    existing.payload = input.payload || existing.payload || null;
+    existing.workspaceId = input.workspaceId || existing.workspaceId || null;
+    existing.ts = now;
+    existing.readAt = null;
+    existing.dismissedAt = null;
+    save(rows);
+    return view(existing);
+  }
+  const row = {
+    id: `ntc_${crypto.randomBytes(6).toString("hex")}`,
+    type: input.type,
+    key: input.key,
+    title: input.title,
+    body: input.body || "",
+    action: input.action || null,
+    payload: input.payload || null,
+    workspaceId: input.workspaceId || null,
+    ts: now,
+    readAt: null,
+    dismissedAt: null,
+  };
+  save([row, ...rows.filter((n) => n.key !== input.key)]);
+  return view(row);
+}
+
+function markRead(id) {
+  const rows = load();
+  const row = rows.find((n) => n.id === id);
+  if (!row || row.readAt) return row ? view(row) : null;
+  row.readAt = Date.now();
+  save(rows);
+  return view(row);
+}
+
+function markAllRead() {
+  const now = Date.now();
+  const rows = load().map((n) => (n.readAt || n.dismissedAt ? n : { ...n, readAt: now }));
+  save(rows);
+  return listNotices();
+}
+
+function dismissNotice(id) {
+  const rows = load();
+  const row = rows.find((n) => n.id === id);
+  if (!row) return null;
+  row.dismissedAt = Date.now();
+  row.readAt = row.readAt || row.dismissedAt;
+  save(rows);
+  return view(row);
+}
+
+function dismissByKey(key) {
+  if (!key) return 0;
+  const now = Date.now();
+  let count = 0;
+  const rows = load().map((n) => {
+    if (n.key !== key || n.dismissedAt) return n;
+    count += 1;
+    return { ...n, dismissedAt: now, readAt: n.readAt || now };
+  });
+  if (count) save(rows);
+  return count;
+}
+
+module.exports = {
+  listNotices,
+  unreadCount,
+  pushNotice,
+  markRead,
+  markAllRead,
+  dismissNotice,
+  dismissByKey,
+};