relaybrain 0.0.0-stage → 0.2.1

package/backend/coordinator/server.js

@@ -0,0 +1,179 @@
+#!/usr/bin/env node
+const http = require("http");
+const express = require("express");
+const fs = require("fs");
+const path = require("path");
+const { LockTable, sameOwner, normalizeFile } = require("./lockTable");
+const { coordinatorStatePath, locksDirFor, homeRelayDir } = require("../lib/paths");
+const { softBlock } = require("../lib/depGraph");
+const { initTreeSitter } = require("../lib/treeSitterImports");
+const { ingest: ingestSupergraph, snapshot: superSnapshot } = require("../lib/supergraph");
+const { Presence } = require("../lib/presence");
+
+function parseArgs(argv) {
+  const args = { port: process.env.RELAY_COORDINATOR_PORT || 0, workspacePath: null };
+  for (let i = 2; i < argv.length; i++) {
+    const a = argv[i];
+    if (a === "--port") args.port = Number(argv[++i]);
+    else if (!a.startsWith("-")) args.workspacePath = a;
+  }
+  return args;
+}
+
+function createCoordinator({ workspacePath, preferredPort } = {}) {
+  const locksDir = workspacePath
+    ? locksDirFor(workspacePath)
+    : path.join(homeRelayDir(), "locks");
+  const lockTable = new LockTable({ locksDir, workspacePath });
+  lockTable.loadFromDisk();
+  lockTable.startCleanup();
+  const presence = new Presence();
+
+  const app = express();
+  app.use(express.json({ limit: "1mb" }));
+  const startedAt = Date.now();
+
+  app.get("/health", (_req, res) => {
+    res.json({
+      ok: true,
+      port: app.get("port"),
+      uptime: (Date.now() - startedAt) / 1000,
+      workspacePath: workspacePath || null,
+    });
+  });
+
+  app.post("/claim", (req, res) => {
+    const body = req.body || {};
+    const files = Array.isArray(body.files) && body.files.length ? body.files : [body.file];
+    const warnings = [];
+    for (const file of files.filter(Boolean)) {
+      const blocked = softBlock(lockTable, body.workspaceId || workspacePath, body.agentId, file);
+      const held = blocked?.file ? lockTable.getLock(blocked.file, body.workspaceId || workspacePath) : null;
+      if (blocked && !(held && sameOwner(held.agentId, body.agentId))) {
+        warnings.push(blocked.reason || blocked.holder || String(blocked));
+      }
+    }
+    const result = lockTable.claim(body);
+    if (warnings.length && result.allowed) result.warning = result.warning || warnings[0];
+    res.status(result.allowed ? 200 : 409).json(result);
+  });
+
+  app.post("/heartbeat", (req, res) => {
+    res.json(lockTable.heartbeat(req.body || {}));
+  });
+
+  app.post("/escalate", (req, res) => {
+    const locks = req.body?.locks || [];
+    const results = locks.map((lock) => lockTable.escalateRegister(lock));
+    res.json({ results });
+  });
+
+  app.post("/presence", (req, res) => {
+    const { workspaceId, userId, action } = req.body || {};
+    const out =
+      action === "leave"
+        ? presence.leave(workspaceId, userId)
+        : presence.join(workspaceId, userId);
+    if (out.escalated) {
+      const snapshot = lockTable.list(workspaceId);
+      for (const lock of snapshot) lockTable.escalateRegister(lock);
+    }
+    res.json(out);
+  });
+
+  app.post("/patch", (req, res) => {
+    lockTable.emit("patch", req.body || {});
+    res.json({ ok: true });
+  });
+
+  app.post("/graph", (req, res) => {
+    res.json(ingestSupergraph(req.body?.workspaceId, req.body || {}));
+  });
+
+  app.get("/graph", (req, res) => {
+    res.json(superSnapshot(req.query.workspaceId));
+  });
+
+  app.post("/release", (req, res) => {
+    res.json(lockTable.release(req.body || {}));
+  });
+
+  app.post("/release-all", (req, res) => {
+    res.json(lockTable.releaseAll(req.body?.agentId, req.body?.workspaceId));
+  });
+
+  app.get("/status", (_req, res) => {
+    res.json({ ...lockTable.status(), uptime: (Date.now() - startedAt) / 1000 });
+  });
+
+  app.get("/stream", (req, res) => {
+    res.setHeader("Content-Type", "text/event-stream");
+    res.setHeader("Cache-Control", "no-cache");
+    res.setHeader("Connection", "keep-alive");
+    res.flushHeaders?.();
+    res.write(`data: ${JSON.stringify(lockTable.status())}\n\n`);
+    const listener = () => res.write(`data: ${JSON.stringify(lockTable.status())}\n\n`);
+    lockTable.on("change", listener);
+    req.on("close", () => lockTable.off("change", listener));
+  });
+
+  const server = http.createServer(app);
+  return { app, server, lockTable, presence, preferredPort: Number(preferredPort) || 0 };
+}
+
+function writeState(workspacePath, port, extra = {}) {
+  const state = { port, ...extra, startedAt: new Date().toISOString(), pid: process.pid };
+  const targets = [coordinatorStatePath(null)];
+  if (workspacePath) targets.push(coordinatorStatePath(workspacePath));
+  for (const file of targets) {
+    fs.mkdirSync(path.dirname(file), { recursive: true });
+    fs.writeFileSync(file, JSON.stringify(state, null, 2));
+  }
+}
+
+async function listen(server, preferredPort) {
+  const tryPort = async (port) =>
+    new Promise((resolve, reject) => {
+      const onError = (err) => {
+        server.off("listening", onListen);
+        reject(err);
+      };
+      const onListen = () => {
+        server.off("error", onError);
+        resolve(server.address().port);
+      };
+      server.once("error", onError);
+      server.once("listening", onListen);
+      server.listen(port, "127.0.0.1");
+    });
+
+  try {
+    return await tryPort(preferredPort || 0);
+  } catch (err) {
+    if (err.code === "EADDRINUSE") return tryPort(0);
+    throw err;
+  }
+}
+
+async function startStandalone() {
+  await initTreeSitter();
+  const args = parseArgs(process.argv);
+  const { app, server, lockTable } = createCoordinator({
+    workspacePath: args.workspacePath,
+    preferredPort: args.port,
+  });
+  const port = await listen(server, Number(args.port) || 0);
+  app.set("port", port);
+  writeState(args.workspacePath, port);
+  console.log(`[relay-coordinator] listening on 127.0.0.1:${port}`);
+  return { port, lockTable, server };
+}
+
+if (require.main === module) {
+  startStandalone().catch((err) => {
+    console.error(err);
+    process.exit(1);
+  });
+}
+
+module.exports = { createCoordinator, listen, writeState, startStandalone };

package/backend/lib/centralAuth.js

@@ -0,0 +1,62 @@
+const crypto = require("crypto");
+const os = require("os");
+const path = require("path");
+const { readJson, writeJson } = require("./store");
+
+function hashKey(raw) {
+  return crypto.createHash("sha256").update(raw).digest("hex");
+}
+
+function adminKey() {
+  // No insecure fallback: Central admin access is disabled entirely unless the
+  // operator explicitly sets RELAY_CENTRAL_ADMIN_KEY. A hardcoded default here
+  // would be a publicly known admin credential for every install.
+  return process.env.RELAY_CENTRAL_ADMIN_KEY || null;
+}
+
+function sameSecret(a, b) {
+  const bufA = Buffer.from(String(a));
+  const bufB = Buffer.from(String(b));
+  if (bufA.length !== bufB.length) return false;
+  return crypto.timingSafeEqual(bufA, bufB);
+}
+
+function registryPath() {
+  return path.join(os.homedir(), ".relay-os", "central", "central-projects.json");
+}
+
+function loadProjects() {
+  return readJson(registryPath(), []);
+}
+
+function saveProjects(list) {
+  writeJson(registryPath(), list);
+}
+
+function createProject(name) {
+  const raw = `central_${crypto.randomBytes(24).toString("hex")}`;
+  const project = {
+    id: `p_${crypto.randomBytes(8).toString("hex")}`,
+    name: name || "relay-project",
+    apiKeyHash: hashKey(raw),
+    keyPrefix: raw.slice(0, 12),
+    createdAt: new Date().toISOString(),
+  };
+  const list = loadProjects();
+  list.push(project);
+  saveProjects(list);
+  return { project, apiKey: raw };
+}
+
+function resolveAuth(header) {
+  const token = String(header || "").replace(/^Bearer\s+/i, "").trim();
+  if (!token) return { ok: false };
+  const key = adminKey();
+  if (key && sameSecret(token, key)) return { ok: true, admin: true };
+  const hashed = hashKey(token);
+  const project = loadProjects().find((p) => p.apiKeyHash === hashed);
+  if (!project) return { ok: false };
+  return { ok: true, admin: false, project };
+}
+
+module.exports = { hashKey, adminKey, loadProjects, createProject, resolveAuth, registryPath };

package/backend/lib/centralStore.js

@@ -0,0 +1,112 @@
+const fs = require("fs");
+const os = require("os");
+const path = require("path");
+
+const projectStates = new Map();
+const initPromises = new Map();
+
+function eventsPath(projectId) {
+  const dir = path.join(os.homedir(), ".relay-os", "central", "events");
+  fs.mkdirSync(dir, { recursive: true });
+  return path.join(dir, `${projectId}.jsonl`);
+}
+
+async function _initProjectState(projectId) {
+  const file = eventsPath(projectId);
+  let lastEventId = 0;
+  const clientEventIds = new Set();
+  if (fs.existsSync(file)) {
+    const lines = fs.readFileSync(file, "utf8").split("\n").filter(Boolean);
+    for (const line of lines) {
+      try {
+        const ev = JSON.parse(line);
+        if (ev.event_id > lastEventId) lastEventId = ev.event_id;
+        if (ev.client_event_id) clientEventIds.add(ev.client_event_id);
+      } catch {
+        /* skip */
+      }
+    }
+  }
+  return { lastEventId, clientEventIds, queue: Promise.resolve() };
+}
+
+async function _getProjectState(projectId) {
+  if (projectStates.has(projectId)) return projectStates.get(projectId);
+  if (!initPromises.has(projectId)) {
+    initPromises.set(
+      projectId,
+      _initProjectState(projectId).then((state) => {
+        projectStates.set(projectId, state);
+        initPromises.delete(projectId);
+        return state;
+      })
+    );
+  }
+  return initPromises.get(projectId);
+}
+
+async function appendEvent(projectId, event) {
+  const state = await _getProjectState(projectId);
+  state.queue = state.queue
+    .then(async () => {
+      if (event.client_event_id && state.clientEventIds.has(event.client_event_id)) {
+        return { ...event, ignoredAsDuplicate: true };
+      }
+      state.lastEventId += 1;
+      const stored = {
+        ...event,
+        event_id: state.lastEventId,
+        project_id: projectId,
+        ts: event.ts || new Date().toISOString(),
+      };
+      fs.appendFileSync(eventsPath(projectId), JSON.stringify(stored) + "\n");
+      if (stored.client_event_id) state.clientEventIds.add(stored.client_event_id);
+      return stored;
+    })
+    .catch((err) => {
+      state.queue = Promise.resolve();
+      throw err;
+    });
+  return state.queue;
+}
+
+async function listEvents(projectId, { since = 0, limit = 200, kind } = {}) {
+  await _getProjectState(projectId);
+  const file = eventsPath(projectId);
+  if (!fs.existsSync(file)) return [];
+  const out = [];
+  for (const line of fs.readFileSync(file, "utf8").split("\n")) {
+    if (!line) continue;
+    try {
+      const ev = JSON.parse(line);
+      if (ev.event_id <= Number(since || 0)) continue;
+      if (kind && ev.kind !== kind) continue;
+      out.push(ev);
+      if (out.length >= Number(limit)) break;
+    } catch {
+      /* skip */
+    }
+  }
+  return out;
+}
+
+function jsonContext(events) {
+  const changes = events.filter((e) => e.kind === "change").slice(-200).reverse();
+  const decisions = {};
+  const tasks = {};
+  const agents = {};
+  for (const e of events) {
+    if (e.kind === "decision" && e.decision_id) decisions[e.decision_id] = e;
+    if (e.kind === "task" && e.task_id) tasks[e.task_id] = e;
+    const key = `${e.user || "unknown"}@${e.agent_source || "agent"}`;
+    agents[key] = { key, lastSeen: e.ts };
+  }
+  return {
+    changes,
+    decisions: Object.values(decisions),
+    tasks: Object.values(tasks),
+    agents: Object.values(agents).sort((a, b) => String(b.lastSeen).localeCompare(String(a.lastSeen))),
+  };
+}
+
+module.exports = { appendEvent, listEvents, jsonContext, eventsPath };

package/backend/lib/centralSync.js

@@ -0,0 +1,88 @@
+const fs = require("fs");
+const path = require("path");
+const { clientEventId } = require("./memorySync");
+
+function configPath(workspacePath) {
+  return path.join(workspacePath, ".relay", "central-config.json");
+}
+
+function loadConfig(workspacePath) {
+  try {
+    return JSON.parse(fs.readFileSync(configPath(workspacePath), "utf8"));
+  } catch {
+    return null;
+  }
+}
+
+function saveConfig(workspacePath, cfg) {
+  fs.mkdirSync(path.dirname(configPath(workspacePath)), { recursive: true });
+  fs.writeFileSync(configPath(workspacePath), JSON.stringify(cfg, null, 2));
+}
+
+async function pushLocalEdits(workspacePath, projectId, memory) {
+  const cfg = loadConfig(workspacePath);
+  if (!cfg?.serverUrl || !cfg.apiKey || !cfg.projectId) return { pushed: 0, skipped: true };
+  const last = cfg.lastPushedEventTs || 0;
+  const edits = (memory.edits || []).filter((e) => e.ts > last);
+  let pushed = 0;
+  let latest = last;
+  for (let i = 0; i < edits.length; i++) {
+    const e = edits[i];
+    const body = {
+      kind: "change",
+      client_event_id: clientEventId(e.ts, e.file, i),
+      user: e.ownerLogin,
+      content: e.diff || e.file,
+      file: e.file,
+      agent_source: e.agent,
+      ts: new Date(e.ts).toISOString(),
+    };
+    const res = await fetch(`${cfg.serverUrl}/api/central/projects/${cfg.projectId}/events`, {
+      method: "POST",
+      headers: { Authorization: `Bearer ${cfg.apiKey}`, "Content-Type": "application/json" },
+      body: JSON.stringify(body),
+    });
+    if (!res.ok) break;
+    pushed += 1;
+    latest = Math.max(latest, e.ts);
+  }
+  cfg.lastPushedEventTs = latest;
+  saveConfig(workspacePath, cfg);
+  return { pushed };
+}
+
+async function pullCentralChanges(workspacePath) {
+  const cfg = loadConfig(workspacePath);
+  if (!cfg?.serverUrl || !cfg.apiKey || !cfg.projectId) return { pulled: 0, skipped: true };
+  const since = cfg.lastPulledCentralEventId || 0;
+  const res = await fetch(
+    `${cfg.serverUrl}/api/central/projects/${cfg.projectId}/events?since=${since}&limit=500`,
+    { headers: { Authorization: `Bearer ${cfg.apiKey}` } }
+  );
+  if (!res.ok) return { pulled: 0, error: res.status };
+  const body = await res.json();
+  const events = body.events || [];
+  if (!events.length) return { pulled: 0 };
+  const file = path.join(workspacePath, ".relay", "central_events.jsonl");
+  fs.mkdirSync(path.dirname(file), { recursive: true });
+  let last = since;
+  for (const ev of events) {
+    fs.appendFileSync(file, JSON.stringify(ev) + "\n");
+    if (ev.event_id > last) last = ev.event_id;
+  }
+  cfg.lastPulledCentralEventId = last;
+  saveConfig(workspacePath, cfg);
+  const ctx = jsonContextSafe(events);
+  fs.writeFileSync(path.join(workspacePath, ".relay", "central_context.json"), JSON.stringify(ctx, null, 2));
+  return { pulled: events.length, last };
+}
+
+function jsonContextSafe(events) {
+  try {
+    return require("./centralStore").jsonContext(events);
+  } catch {
+    return { changes: events.filter((e) => e.kind === "change") };
+  }
+}
+
+module.exports = { loadConfig, saveConfig, pushLocalEdits, pullCentralChanges };

package/backend/lib/cloneRepo.js

@@ -0,0 +1,108 @@
+const { spawn, execFileSync } = require("child_process");
+const fs = require("fs");
+const path = require("path");
+const os = require("os");
+const crypto = require("crypto");
+const { loadRegistry, saveRegistry, saveMemory, saveSession, loadSession, id } = require("./store");
+const { emptyMemory, initials } = require("./seed");
+const { installProjectHooks } = require("./installHooks");
+const { homeRelayDir } = require("./paths");
+
+function runGit(args, cwd) {
+  return new Promise((resolve, reject) => {
+    const child = spawn("git", args, { cwd: cwd || process.cwd(), stdio: "inherit", shell: false, windowsHide: true });
+    child.on("error", reject);
+    child.on("exit", (code) => {
+      if (code === 0) resolve();
+      else reject(new Error(`git ${args[0]} exited ${code}`));
+    });
+  });
+}
+
+function defaultCloneDir(remoteUrl) {
+  const name = String(remoteUrl || "")
+    .replace(/\.git$/, "")
+    .split(/[/\\]/)
+    .filter(Boolean)
+    .pop() || "repo";
+  return path.join(os.homedir(), "Documents", "GitHub", name);
+}
+
+function registerProject({ name, workspacePath, remoteUrl, mode }) {
+  const reg = loadRegistry();
+  const existing = reg.projects.find((p) => p.path === workspacePath);
+  if (existing) return existing;
+  const project = {
+    id: id("proj"),
+    name: name || path.basename(workspacePath || "workspace"),
+    initials: initials(name || workspacePath || "WS"),
+    color: mode === "clone" ? "#a78bfa" : "#34d399",
+    path: workspacePath,
+    remoteUrl: remoteUrl || null,
+    apiKey: "rl_" + crypto.randomBytes(12).toString("hex"),
+    createdAt: Date.now(),
+    lastSyncAt: Date.now(),
+  };
+  fs.mkdirSync(path.join(workspacePath, ".relay"), { recursive: true });
+  try {
+    installProjectHooks(workspacePath);
+  } catch {
+    /* hooks are best-effort */
+  }
+  reg.projects.push(project);
+  saveRegistry(reg);
+  saveMemory(project.id, emptyMemory());
+  const session = loadSession();
+  saveSession({ ...session, projectId: project.id });
+  return project;
+}
+
+async function cloneRepo(remoteUrl, dest) {
+  if (!remoteUrl) throw new Error("usage: relay clone <git-url> [directory]");
+  const target = path.resolve(dest || defaultCloneDir(remoteUrl));
+  if (!fs.existsSync(target)) {
+    fs.mkdirSync(path.dirname(target), { recursive: true });
+    await runGit(["clone", remoteUrl, target]);
+  } else if (!fs.existsSync(path.join(target, ".git"))) {
+    throw new Error(`${target} exists and is not a git repo`);
+  }
+  const project = registerProject({
+    name: path.basename(target),
+    workspacePath: target,
+    remoteUrl,
+    mode: "clone",
+  });
+  return { project, path: target };
+}
+
+function detectRemoteUrl(target) {
+  if (!fs.existsSync(path.join(target, ".git"))) return null;
+  try {
+    return execFileSync("git", ["config", "--get", "remote.origin.url"], {
+      cwd: target,
+      encoding: "utf8",
+      stdio: ["ignore", "pipe", "ignore"],
+      windowsHide: true,
+    }).trim() || null;
+  } catch {
+    return null;
+  }
+}
+
+function addLocal(workspacePath, name) {
+  const target = path.resolve(workspacePath);
+  if (!fs.existsSync(target)) throw new Error(`path not found: ${target}`);
+  return registerProject({
+    name: name || path.basename(target),
+    workspacePath: target,
+    // A folder added via "Add local repository" is very often already a git
+    // repo with a real GitHub remote (e.g. `test` had `origin` set up
+    // manually) — read it instead of always registering remoteUrl: null,
+    // otherwise features that key off the repo (like the Team tab's GitHub
+    // collaborator list) silently have nothing to work with.
+    remoteUrl: detectRemoteUrl(target),
+    mode: "local",
+  });
+}
+
+module.exports = { cloneRepo, addLocal, registerProject, defaultCloneDir, homeRelayDir, detectRemoteUrl };