relaybrain 0.0.0-stage → 0.2.1

package/backend/lib/seed.js

@@ -0,0 +1,107 @@
+const fs = require("fs");
+const path = require("path");
+const crypto = require("crypto");
+const { loadRegistry, saveRegistry, saveMemory, loadMemory, id } = require("./store");
+
+function avatar(seed, size = 80) {
+  const hash = crypto.createHash("md5").update(seed).digest("hex");
+  return `https://www.gravatar.com/avatar/${hash}?d=identicon&s=${size}`;
+}
+
+function initials(name) {
+  const parts = String(name).replace(/[./]/g, " ").trim().split(/\s+/);
+  if (parts.length === 1) return parts[0].slice(0, 2).toUpperCase();
+  return (parts[0][0] + parts[1][0]).toUpperCase();
+}
+
+function agent(label, status, extra = {}) {
+  return {
+    id: label.toLowerCase().replace(/\s+/g, "-"),
+    label,
+    status,
+    lastActiveAt: Date.now() - (extra.agoMs || 0),
+    sessionId: extra.sessionId,
+    ownerId: extra.ownerId,
+    ownerLogin: extra.ownerLogin,
+    ...extra,
+  };
+}
+
+function emptyMemory() {
+  return {
+    stats: { events: 0, agents: 0, patches: 0 },
+    agents: [
+      agent("Claude Code", "idle"),
+      agent("Cursor", "idle"),
+      agent("Codex", "idle"),
+      agent("Copilot", "idle"),
+      agent("Antigravity", "idle"),
+    ],
+    collaborators: [],
+    activity: [],
+    history: [],
+    timeline: [],
+    chats: [],
+    edits: [],
+  };
+}
+
+function looksLikeDemo(mem) {
+  if (!mem) return false;
+  if (mem.stats?.events === 186 || mem.stats?.events === 64) return true;
+  const ids = (mem.activity || []).map((a) => a.id);
+  return ids.includes("a1") || ids.includes("u1");
+}
+
+// Demo accounts used to be seeded here with `user_<login>` ids. Real accounts
+// come from GitHub and are `gh_<id>`, so anything still carrying the old id
+// scheme is a placeholder — drop it, unless it is the signed-in session.
+function dropDemoUsers() {
+  const reg = loadRegistry();
+  const users = reg.users || [];
+  let activeId = null;
+  try {
+    activeId = require("./store").loadSession?.().userId || null;
+  } catch {
+    /* no session helper: keep every account */
+  }
+  const kept = users.filter((u) => !String(u.id || "").startsWith("user_") || u.id === activeId);
+  if (kept.length !== users.length) {
+    reg.users = kept;
+    saveRegistry(reg);
+  }
+}
+
+function seedIfEmpty() {
+  dropDemoUsers();
+  const current = loadRegistry();
+  if (current.projects?.length) {
+    for (const p of current.projects) {
+      const mem = loadMemory(p.id);
+      if (looksLikeDemo(mem) || mem.ir) saveMemory(p.id, emptyMemory());
+    }
+    return loadRegistry();
+  }
+  const cwd = process.cwd();
+  const project = {
+    id: "proj_relay",
+    name: path.basename(cwd),
+    initials: initials(cwd),
+    color: "#f59e0b",
+    path: cwd,
+    remoteUrl: null,
+    apiKey: "rl_" + crypto.randomBytes(12).toString("hex"),
+    createdAt: Date.now(),
+    lastSyncAt: Date.now(),
+  };
+  try {
+    fs.mkdirSync(path.join(cwd, ".relay"), { recursive: true });
+  } catch {
+    /* ignore */
+  }
+  saveMemory(project.id, emptyMemory());
+  saveRegistry({ users: loadRegistry().users, projects: [project] });
+  return loadRegistry();
+}
+
+module.exports = { seedIfEmpty, avatar, initials, emptyMemory, id };

package/backend/lib/sseHub.js

@@ -0,0 +1,40 @@
+class SseHub {
+  constructor() {
+    this.clients = new Set();
+  }
+
+  subscribe(res, filter = {}) {
+    res.setHeader("Content-Type", "text/event-stream");
+    res.setHeader("Cache-Control", "no-cache, no-transform");
+    res.setHeader("Connection", "keep-alive");
+    res.setHeader("X-Accel-Buffering", "no");
+    res.flushHeaders?.();
+    const client = { res, filter };
+    this.clients.add(client);
+    res.write(`event: hello\ndata: ${JSON.stringify({ ok: true, ts: Date.now() })}\n\n`);
+    res.on("close", () => this.clients.delete(client));
+    return client;
+  }
+
+  emit(event, payload) {
+    const data = `event: ${event}\ndata: ${JSON.stringify(payload)}\n\n`;
+    for (const client of this.clients) {
+      const { workspaceId } = client.filter;
+      if (
+        event !== "notice" &&
+        workspaceId &&
+        payload.workspaceId &&
+        payload.workspaceId !== workspaceId
+      ) {
+        continue;
+      }
+      try {
+        client.res.write(data);
+      } catch {
+        this.clients.delete(client);
+      }
+    }
+  }
+}
+
+module.exports = { SseHub };

package/backend/lib/store.js

@@ -0,0 +1,79 @@
+const fs = require("fs");
+const path = require("path");
+const crypto = require("crypto");
+const { dataDir, registryPath, sessionPath } = require("./paths");
+
+function readJson(file, fallback) {
+  try {
+    return JSON.parse(fs.readFileSync(file, "utf8"));
+  } catch {
+    return fallback;
+  }
+}
+
+function writeJson(file, value) {
+  fs.mkdirSync(path.dirname(file), { recursive: true });
+  fs.writeFileSync(file, JSON.stringify(value, null, 2));
+}
+
+function id(prefix = "id") {
+  return `${prefix}_${crypto.randomBytes(6).toString("hex")}`;
+}
+
+function loadRegistry() {
+  return readJson(registryPath(), { projects: [], users: [] });
+}
+
+function saveRegistry(reg) {
+  writeJson(registryPath(), reg);
+}
+
+function loadSession() {
+  return readJson(sessionPath(), { userId: null });
+}
+
+function saveSession(session) {
+  writeJson(sessionPath(), session);
+}
+
+function projectDir(projectId) {
+  const dir = path.join(dataDir(), "projects", projectId);
+  fs.mkdirSync(dir, { recursive: true });
+  return dir;
+}
+
+function memoryPath(projectId) {
+  return path.join(projectDir(projectId), "memory.json");
+}
+
+function loadMemory(projectId) {
+  return readJson(memoryPath(projectId), {
+    history: [],
+    timeline: [],
+    chats: [],
+    edits: [],
+    ir: {},
+    agents: [],
+    collaborators: [],
+    activity: [],
+  });
+}
+
+function saveMemory(projectId, memory) {
+  writeJson(memoryPath(projectId), memory);
+}
+
+module.exports = {
+  readJson,
+  writeJson,
+  id,
+  loadRegistry,
+  saveRegistry,
+  loadSession,
+  saveSession,
+  projectDir,
+  memoryPath,
+  loadMemory,
+  saveMemory,
+  dataDir,
+};

package/backend/lib/supergraph.js

@@ -0,0 +1,46 @@
+const graphs = new Map();
+
+function unionKey(workspaceId) {
+  return workspaceId || "default";
+}
+
+function ingest(workspaceId, { userId, edges }) {
+  const key = unionKey(workspaceId);
+  let g = graphs.get(key);
+  if (!g) {
+    g = { users: new Map(), edges: new Map() };
+    graphs.set(key, g);
+  }
+  g.users.set(userId || "anon", edges || []);
+  g.edges = new Map();
+  for (const list of g.users.values()) {
+    for (const e of list) {
+      const from = e.from || e[0];
+      const to = e.to || e[1];
+      if (!from || !to) continue;
+      if (!g.edges.has(from)) g.edges.set(from, new Set());
+      g.edges.get(from).add(to);
+    }
+  }
+  return snapshot(workspaceId);
+}
+
+function dependents(workspaceId, file) {
+  const g = graphs.get(unionKey(workspaceId));
+  if (!g) return [];
+  const out = [];
+  for (const [from, tos] of g.edges) {
+    if (tos.has(file)) out.push(from);
+  }
+  return out;
+}
+
+function snapshot(workspaceId) {
+  const g = graphs.get(unionKey(workspaceId));
+  if (!g) return { users: 0, edges: [] };
+  const edges = [];
+  for (const [from, tos] of g.edges) for (const to of tos) edges.push({ from, to });
+  return { users: g.users.size, edges };
+}
+
+module.exports = { ingest, dependents, snapshot };