relaybrain 0.0.0-stage → 0.2.0

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 };

package/backend/lib/installAgentRelay.js

@@ -0,0 +1,235 @@
+/**
+ * Patch relay-os instructions + Relay MCP into every supported agent surface.
+ * Cursor · Claude Code · Codex · Copilot CLI · Antigravity
+ */
+const fs = require("fs");
+const path = require("path");
+const os = require("os");
+const { relayOsBlock, agentBootstrap, RELAY_OS_BEGIN, RELAY_OS_END } = require("./relayOsBlock");
+
+function repoRoot() {
+  return path.join(__dirname, "..", "..");
+}
+
+function mcpServerScript() {
+  return path.join(repoRoot(), "backend", "mcp", "server.js");
+}
+
+function relayMcpEnv(workspacePath, agentLabel) {
+  const env = {};
+  if (workspacePath) env.RELAY_WORKSPACE_PATH = path.resolve(workspacePath);
+  // The stdio server can't otherwise tell which agent is calling it.
+  if (agentLabel) env.RELAY_AGENT_LABEL = agentLabel;
+  return env;
+}
+
+function relayStdioMcp(workspacePath, agentLabel) {
+  const script = mcpServerScript();
+  return {
+    command: process.execPath,
+    args: [script],
+    env: relayMcpEnv(workspacePath, agentLabel),
+  };
+}
+
+function readText(file) {
+  try {
+    return fs.readFileSync(file, "utf8");
+  } catch {
+    return "";
+  }
+}
+
+function writeText(file, text) {
+  fs.mkdirSync(path.dirname(file), { recursive: true });
+  fs.writeFileSync(file, text);
+}
+
+function patchRelayOsBlock(filePath, block) {
+  const existing = readText(filePath);
+  const begin = existing.indexOf(RELAY_OS_BEGIN);
+  const end = existing.indexOf(RELAY_OS_END);
+  if (begin >= 0 && end > begin) {
+    writeText(filePath, `${existing.slice(0, begin)}${block}${existing.slice(end + RELAY_OS_END.length)}`);
+    return "updated";
+  }
+  const trimmed = existing.trimEnd();
+  const sep = trimmed ? "\n\n" : "";
+  writeText(filePath, `${trimmed}${sep}${block}\n`);
+  return trimmed ? "appended" : "created";
+}
+
+function mergeJsonMcp(filePath, entry, { copilotType } = {}) {
+  let data = {};
+  try {
+    data = JSON.parse(readText(filePath) || "{}");
+  } catch {
+    data = {};
+  }
+  data.mcpServers = data.mcpServers && typeof data.mcpServers === "object" ? data.mcpServers : {};
+  const relay = copilotType
+    ? { type: "local", ...entry, tools: ["*"] }
+    : { ...entry };
+  data.mcpServers.relay = relay;
+  writeText(filePath, `${JSON.stringify(data, null, 2)}\n`);
+}
+
+function mergeClaudeMcp(settingsPath, entry) {
+  let data = {};
+  try {
+    data = JSON.parse(readText(settingsPath) || "{}");
+  } catch {
+    data = {};
+  }
+  data.mcpServers = data.mcpServers && typeof data.mcpServers === "object" ? data.mcpServers : {};
+  data.mcpServers.relay = entry;
+  writeText(settingsPath, `${JSON.stringify(data, null, 2)}\n`);
+}
+
+function mergeCodexMcp(configPath, workspacePath) {
+  const node = process.execPath.replace(/\\/g, "/");
+  const script = mcpServerScript().replace(/\\/g, "/");
+  const ws = path.resolve(workspacePath).replace(/\\/g, "/");
+  const envLines = [`RELAY_WORKSPACE_PATH = "${ws.replace(/"/g, '\\"')}"`, `RELAY_AGENT_LABEL = "Codex"`];
+  const block = `[mcp_servers.relay]
+command = "${node.replace(/"/g, '\\"')}"
+args = ["${script.replace(/"/g, '\\"')}"]
+
+[mcp_servers.relay.env]
+${envLines.join("\n")}
+`;
+  let text = readText(configPath);
+  const marker = "[mcp_servers.relay]";
+  const idx = text.indexOf(marker);
+  if (idx >= 0) {
+    // Skip our own [mcp_servers.relay.env] table, or the old one survives and TOML sees it twice.
+    const next = text.slice(idx + marker.length).search(/\n\[(?!mcp_servers\.relay(\.env)?\])/);
+    text = next >= 0 ? `${text.slice(0, idx)}${block}${text.slice(idx + marker.length + next)}` : `${text.slice(0, idx)}${block}`;
+  } else {
+    text = `${text.trimEnd()}\n\n${block}`;
+  }
+  writeText(configPath, text.endsWith("\n") ? text : `${text}\n`);
+}
+
+function cursorMdc(block) {
+  return `---
+description: Relay coordination — room context, locks, /relay ask
+alwaysApply: true
+---
+
+${block}
+`;
+}
+
+function ensureRelayDir(workspacePath) {
+  fs.mkdirSync(path.join(workspacePath, ".relay"), { recursive: true });
+  writeText(path.join(workspacePath, ".relay", "AGENT_BOOTSTRAP.md"), agentBootstrap(workspacePath));
+}
+
+function installProjectRelay(workspacePath) {
+  if (!workspacePath) return { ok: false, error: "workspace_required" };
+  const resolved = path.resolve(workspacePath);
+  const block = relayOsBlock();
+  const mcpFor = (label) => relayStdioMcp(resolved, label);
+  const results = { instructions: {}, mcp: {} };
+
+  const instructionTargets = [
+    path.join(resolved, "AGENTS.md"),
+    path.join(resolved, "CLAUDE.md"),
+    path.join(resolved, ".github", "copilot-instructions.md"),
+    path.join(resolved, ".cursorrules"),
+  ];
+  for (const file of instructionTargets) {
+    try {
+      results.instructions[path.relative(resolved, file)] = patchRelayOsBlock(file, block);
+    } catch (err) {
+      results.instructions[path.relative(resolved, file)] = String(err.message || err);
+    }
+  }
+
+  try {
+    writeText(path.join(resolved, ".cursor", "rules", "relay.mdc"), cursorMdc(block));
+    results.instructions[".cursor/rules/relay.mdc"] = "created";
+  } catch (err) {
+    results.instructions[".cursor/rules/relay.mdc"] = String(err.message || err);
+  }
+
+  ensureRelayDir(resolved);
+
+  try {
+    mergeJsonMcp(path.join(resolved, ".cursor", "mcp.json"), mcpFor("Cursor"));
+    results.mcp[".cursor/mcp.json"] = "ok";
+  } catch (err) {
+    results.mcp[".cursor/mcp.json"] = String(err.message || err);
+  }
+
+  try {
+    mergeClaudeMcp(path.join(resolved, ".claude", "settings.json"), mcpFor("Claude Code"));
+    results.mcp[".claude/settings.json"] = "ok";
+  } catch (err) {
+    results.mcp[".claude/settings.json"] = String(err.message || err);
+  }
+
+  try {
+    mergeCodexMcp(path.join(resolved, ".codex", "config.toml"), resolved);
+    results.mcp[".codex/config.toml"] = "ok";
+  } catch (err) {
+    results.mcp[".codex/config.toml"] = String(err.message || err);
+  }
+
+  try {
+    mergeJsonMcp(path.join(resolved, ".github", "mcp.json"), mcpFor("Copilot"), { copilotType: true });
+    results.mcp[".github/mcp.json"] = "ok";
+  } catch (err) {
+    results.mcp[".github/mcp.json"] = String(err.message || err);
+  }
+
+  try {
+    mergeJsonMcp(path.join(resolved, ".agents", "mcp_config.json"), mcpFor("Antigravity"));
+    results.mcp[".agents/mcp_config.json"] = "ok";
+  } catch (err) {
+    results.mcp[".agents/mcp_config.json"] = String(err.message || err);
+  }
+
+  return { ok: true, workspace: resolved, results };
+}
+
+function installGlobalRelay() {
+  const home = os.homedir();
+  const mcpFor = (label) => relayStdioMcp(null, label);
+  const results = {};
+  try {
+    mergeJsonMcp(path.join(home, ".cursor", "mcp.json"), mcpFor("Cursor"));
+    results["~/.cursor/mcp.json"] = "ok";
+  } catch (err) {
+    results["~/.cursor/mcp.json"] = String(err.message || err);
+  }
+  try {
+    mergeClaudeMcp(path.join(home, ".claude", "settings.json"), mcpFor("Claude Code"));
+    results["~/.claude/settings.json"] = "ok";
+  } catch (err) {
+    results["~/.claude/settings.json"] = String(err.message || err);
+  }
+  try {
+    mergeCodexMcp(path.join(home, ".codex", "config.toml"), home);
+    results["~/.codex/config.toml"] = "ok";
+  } catch (err) {
+    results["~/.codex/config.toml"] = String(err.message || err);
+  }
+  try {
+    const copilotPath = path.join(home, ".copilot", "mcp-config.json");
+    mergeJsonMcp(copilotPath, mcpFor("Copilot"), { copilotType: true });
+    results["~/.copilot/mcp-config.json"] = "ok";
+  } catch (err) {
+    results["~/.copilot/mcp-config.json"] = String(err.message || err);
+  }
+  return results;
+}
+
+module.exports = {
+  installProjectRelay,
+  installGlobalRelay,
+  relayStdioMcp,
+  patchRelayOsBlock,
+  relayOsBlock,
+};