relaybrain 0.0.0-stage → 0.2.1

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,150 @@
+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;
+}
+
+/** The stored row for a key, dismissed or not (raw, with payload). */
+function findNotice(key) {
+  if (!key) return null;
+  return prune(load()).find((n) => n.key === key) || null;
+}
+
+module.exports = {
+  findNotice,
+  listNotices,
+  unreadCount,
+  pushNotice,
+  markRead,
+  markAllRead,
+  dismissNotice,
+  dismissByKey,
+};

package/backend/lib/ot.js

@@ -0,0 +1,74 @@
+/**
+ * Ordered patch apply. Same-file overlapping hunks → manual merge (no busy-wait).
+ */
+function parseHunks(diff) {
+  const hunks = [];
+  let line = 0;
+  for (const raw of String(diff || "").split("\n")) {
+    const header = raw.match(/^@@ -(\d+)/);
+    if (header) {
+      line = Number(header[1]);
+      continue;
+    }
+    if (raw.startsWith("+") || raw.startsWith("-") || raw.startsWith(" ")) {
+      hunks.push({ line, kind: raw[0], text: raw.slice(1) });
+      if (raw[0] !== "+") line += 1;
+    }
+  }
+  return hunks;
+}
+
+function overlaps(a, b) {
+  const ha = parseHunks(a.diff);
+  const hb = parseHunks(b.diff);
+  if (!ha.length || !hb.length) return false;
+  const range = (hunks) => {
+    const lines = hunks.map((h) => h.line);
+    return [Math.min(...lines), Math.max(...lines)];
+  };
+  const [a0, a1] = range(ha);
+  const [b0, b1] = range(hb);
+  return a0 <= b1 && b0 <= a1;
+}
+
+function transformPair(first, second) {
+  if (first.file !== second.file) return { ok: true, patches: [first, second] };
+  if (first.sha256 && second.sha256 && first.binary) {
+    return first.lamport <= second.lamport
+      ? { ok: true, patches: [first, second] }
+      : { ok: true, patches: [second, first] };
+  }
+  if (overlaps(first, second)) {
+    return {
+      ok: false,
+      manual: true,
+      reason: `Conflicting patches on ${first.file} (Lamport ${first.lamport} vs ${second.lamport})`,
+    };
+  }
+  const ordered = first.lamport <= second.lamport ? [first, second] : [second, first];
+  return { ok: true, patches: ordered };
+}
+
+function insertOrdered(buffer, patch) {
+  const next = [...buffer, patch].sort((a, b) => a.lamport - b.lamport || a.file.localeCompare(b.file));
+  return next;
+}
+
+function drain(buffer, lastApplied) {
+  const ready = [];
+  const held = [];
+  let applied = lastApplied || 0;
+  const sorted = [...buffer].sort((a, b) => a.lamport - b.lamport);
+  for (const p of sorted) {
+    if (p.lamport <= applied) continue;
+    if (applied === 0 || p.lamport === applied + 1) {
+      ready.push(p);
+      applied = p.lamport;
+    } else {
+      held.push(p);
+    }
+  }
+  return { ready, held, lastApplied: applied };
+}
+
+module.exports = { parseHunks, overlaps, transformPair, insertOrdered, drain };

package/backend/lib/patches.js

@@ -0,0 +1,192 @@
+const fs = require("fs");
+const path = require("path");
+const crypto = require("crypto");
+const { execFileSync } = require("child_process");
+const { tick } = require("./lamport");
+const { loadMemory, saveMemory, id } = require("./store");
+const { recordCollision } = require("./collisionMetrics");
+const { transformPair, insertOrdered, drain } = require("./ot");
+
+function isBinary(buf) {
+  return buf.includes(0);
+}
+
+function sha256(buf) {
+  return crypto.createHash("sha256").update(buf).digest("hex");
+}
+
+function gitDiff(workspacePath, file) {
+  try {
+    return execFileSync("git", ["-C", workspacePath, "diff", "--", file], {
+      encoding: "utf8",
+      timeout: 2000,
+      stdio: ["ignore", "pipe", "ignore"],
+      windowsHide: true,
+    });
+  } catch {
+    return "";
+  }
+}
+
+function computePatch({ workspacePath, file, agent, ownerLogin, workspaceId }) {
+  const abs = path.join(workspacePath, file);
+  if (!fs.existsSync(abs) || !fs.statSync(abs).isFile()) return null;
+  const buf = fs.readFileSync(abs);
+  const binary = isBinary(buf);
+  const lamport = tick(workspaceId || workspacePath);
+  const patch = {
+    id: id("patch"),
+    file: file.replace(/\\/g, "/"),
+    agent,
+    ownerLogin,
+    lamport,
+    ts: Date.now(),
+    binary,
+    sha256: sha256(buf),
+    diff: binary ? "" : gitDiff(workspacePath, file) || buf.toString("utf8").slice(0, 4000),
+    content: binary ? null : undefined,
+  };
+  if (binary) patch.replace = true;
+  else if (buf.length < 1_000_000) patch.content = buf.toString("utf8");
+  return patch;
+}
+
+/** True when the file already holds exactly this content. */
+function matchesDisk(abs, patch) {
+  try {
+    return sha256(fs.readFileSync(abs)) === patch.sha256;
+  } catch {
+    return false;
+  }
+}
+
+function applyPatchToDisk(workspacePath, patch) {
+  if (!workspacePath || !patch?.file) return { applied: false };
+  const abs = path.join(workspacePath, patch.file);
+  if (patch.binary) {
+    return { applied: false, reason: "binary_sha_replace", sha256: patch.sha256 };
+  }
+  if (typeof patch.content === "string") {
+    // Rewriting identical content still fires the filesystem watcher, which
+    // publishes a fresh patch (new id, so no dedupe catches it) straight back to
+    // the peer it came from — two machines in a room then trade the same file
+    // forever at full CPU. Content equality is the only thing that terminates
+    // that loop, because every hop legitimately looks like a new edit.
+    if (patch.sha256 && matchesDisk(abs, patch)) return { applied: false, reason: "identical" };
+    fs.mkdirSync(path.dirname(abs), { recursive: true });
+    fs.writeFileSync(abs, patch.content);
+    return { applied: true };
+  }
+  return { applied: false, reason: "no_content" };
+}
+
+function seenPatch(memory, patch) {
+  const id = patch?.id;
+  if (!id) return false;
+  return (memory.patches || []).some((p) => p.id === id) || (memory.patchBuffer || []).some((p) => p.id === id);
+}
+
+/** Peer fan-out: write this file on MY tree. Host is not the source of truth. */
+function applyPeerFile(projectId, patch, workspacePath) {
+  const memory = loadMemory(projectId);
+  if (seenPatch(memory, patch)) return { applied: false, duplicate: true };
+  memory.patches = insertOrdered(memory.patches || [], patch);
+  memory.edits = memory.edits || [];
+  memory.edits.unshift({
+    id: patch.id,
+    agent: patch.agent,
+    ownerLogin: patch.ownerLogin,
+    mine: false,
+    file: patch.file,
+    ts: patch.ts,
+    diff: patch.diff || `sha256:${patch.sha256}`,
+    lamport: patch.lamport,
+    binary: patch.binary,
+  });
+  let disk = { applied: false };
+  if (workspacePath) disk = applyPatchToDisk(workspacePath, patch);
+  saveMemory(projectId, memory);
+  require("./falkor/bus").emit("patch", { projectId, patch, mine: false });
+  return { ...disk, recorded: true };
+}
+
+function recordPatch(projectId, patch) {
+  const memory = loadMemory(projectId);
+  memory.patches = insertOrdered(memory.patches || [], patch);
+  memory.edits = memory.edits || [];
+  memory.edits.unshift({
+    id: patch.id,
+    agent: patch.agent,
+    ownerLogin: patch.ownerLogin,
+    mine: true,
+    file: patch.file,
+    ts: patch.ts,
+    diff: patch.diff || `sha256:${patch.sha256}`,
+    lamport: patch.lamport,
+    binary: patch.binary,
+  });
+  saveMemory(projectId, memory);
+  require("./falkor/bus").emit("patch", { projectId, patch, mine: true });
+  return memory;
+}
+
+function applyIncoming(projectId, patch, lastApplied, workspacePath) {
+  const memory = loadMemory(projectId);
+  memory.patchBuffer = insertOrdered(memory.patchBuffer || [], patch);
+  const { ready, held, lastApplied: next } = drain(
+    memory.patchBuffer,
+    lastApplied ?? memory.lastAppliedLamport ?? 0
+  );
+  memory.patchBuffer = held;
+  memory.lastAppliedLamport = next;
+  const conflicts = [];
+  for (let i = 1; i < ready.length; i++) {
+    const t = transformPair(ready[i - 1], ready[i]);
+    if (!t.ok) {
+      conflicts.push(t);
+      if (t.manual) {
+        recordCollision(projectId, "merge_flagged", {
+          file: ready[i].file,
+          reason: t.reason,
+          lamport: ready[i].lamport,
+        });
+      }
+    }
+  }
+  memory.patches = ready.reduce((acc, p) => insertOrdered(acc, p), memory.patches || []);
+  const applied = [];
+  if (workspacePath) {
+    for (const p of ready) {
+      if (conflicts.some((c) => c.manual && (c.reason || "").includes(p.file))) continue;
+      applied.push({ file: p.file, ...applyPatchToDisk(workspacePath, p) });
+    }
+  }
+  saveMemory(projectId, memory);
+  return { ready, conflicts, lastApplied: next, applied };
+}
+
+function replayUntil(projectId, lamport) {
+  const memory = loadMemory(projectId);
+  return (memory.patches || []).filter((p) => p.lamport <= lamport);
+}
+
+function rewindTo(projectId, workspacePath, lamport) {
+  const patches = replayUntil(projectId, lamport);
+  const latest = new Map();
+  for (const p of patches) latest.set(p.file, p);
+  const applied = [];
+  for (const p of latest.values()) applied.push({ file: p.file, ...applyPatchToDisk(workspacePath, p) });
+  return { lamport, files: [...latest.keys()], applied, patches };
+}
+
+module.exports = {
+  computePatch,
+  recordPatch,
+  applyIncoming,
+  applyPeerFile,
+  applyPatchToDisk,
+  replayUntil,
+  rewindTo,
+  isBinary,
+  sha256,
+};

package/backend/lib/paths.js

@@ -0,0 +1,85 @@
+const fs = require("fs");
+const os = require("os");
+const path = require("path");
+const crypto = require("crypto");
+
+function homeRelayDir() {
+  const dir = path.join(os.homedir(), ".relay");
+  fs.mkdirSync(dir, { recursive: true });
+  return dir;
+}
+
+function tryMkdir(dir) {
+  try {
+    fs.mkdirSync(dir, { recursive: true });
+    return true;
+  } catch {
+    // Missing drive (D:\ on a machine that only has C:), unplugged disk, or a
+    // host path from another OS. Callers fall back to ~/.relay instead of
+    // taking down relay serve.
+    return false;
+  }
+}
+
+function dataDir() {
+  const dir = path.join(homeRelayDir(), "data");
+  fs.mkdirSync(dir, { recursive: true });
+  return dir;
+}
+
+function registryPath() {
+  return path.join(dataDir(), "registry.json");
+}
+
+function sessionPath() {
+  return path.join(dataDir(), "session.json");
+}
+
+function nativeWorkspaceRoot(workspacePath) {
+  if (!workspacePath) return workspacePath;
+  let trimmed = String(workspacePath).trim().replace(/^file:\/+/i, "/");
+  const drive = trimmed.match(/^\/?([a-zA-Z]):([\\/].*)$/);
+  if (drive) trimmed = `${drive[1]}:${drive[2]}`;
+  const doubled = trimmed.match(/^([a-zA-Z]):[\\/]+\1:[\\/]+(.*)$/i);
+  if (doubled) trimmed = `${doubled[1]}:\\${doubled[2]}`;
+  return path.resolve(trimmed);
+}
+
+function coordinatorStatePath(workspacePath) {
+  if (workspacePath) {
+    const dir = path.join(nativeWorkspaceRoot(workspacePath), ".relay");
+    if (tryMkdir(dir)) return path.join(dir, "coordinator-state.json");
+  }
+  return path.join(homeRelayDir(), "coordinator-state.json");
+}
+
+function normKey(value) {
+  return String(value || "")
+    .replace(/\\/g, "/")
+    .replace(/\/+$/, "")
+    .toLowerCase();
+}
+
+function locksDirFor(workspacePath) {
+  const homeLocks = path.join(homeRelayDir(), "locks");
+  if (!workspacePath) {
+    tryMkdir(homeLocks);
+    return homeLocks;
+  }
+  const root = nativeWorkspaceRoot(workspacePath);
+  const dir = path.join(root, ".relay", "locks");
+  if (tryMkdir(dir)) return dir;
+  const slug = crypto.createHash("sha256").update(normKey(root)).digest("hex").slice(0, 16);
+  const fallback = path.join(homeLocks, slug);
+  tryMkdir(fallback);
+  return fallback;
+}
+
+module.exports = {
+  homeRelayDir,
+  dataDir,
+  registryPath,
+  sessionPath,
+  coordinatorStatePath,
+  locksDirFor,
+};

package/backend/lib/peerClash.js

@@ -0,0 +1,64 @@
+const os = require("os");
+const { sameOwner } = require("../coordinator/lockTable");
+
+function localHost() {
+  return String(os.hostname() || "").toLowerCase();
+}
+
+function holderHost(held) {
+  if (!held) return "";
+  if (held.holder?.host) return String(held.holder.host).toLowerCase();
+  const parts = String(held.agentId || "").split(":");
+  return (parts[1] || "").toLowerCase();
+}
+
+function holderIsLocal(held) {
+  const host = holderHost(held);
+  return Boolean(host) && host === localHost();
+}
+
+function aliveLock(lockTable, file, workspacePath) {
+  if (!lockTable || typeof lockTable.getLock !== "function") return null;
+  const held = lockTable.getLock(file, workspacePath);
+  if (!held) return null;
+  if (held.mode && held.mode !== "write") return null;
+  const ttl = held.ttlMs || 15_000;
+  if (Date.now() >= (held.lastHeartbeat || held.claimedAt) + ttl) return null;
+  return held;
+}
+
+/**
+ * skip — remote holder (their apply landed here).
+ * defer — local agent still writing; wait for PostToolUse.
+ * publish — no live write lock.
+ */
+function skipPublish(lockTable, workspacePath, file) {
+  const held = aliveLock(lockTable, file, workspacePath);
+  if (!held) return { skip: false, defer: false, held: null };
+  if (!holderIsLocal(held)) {
+    return {
+      skip: true,
+      defer: false,
+      held,
+      reason: `${file} is locked by ${held.holder?.label || held.agentId}`,
+    };
+  }
+  return { skip: false, defer: true, held };
+}
+
+/**
+ * Do not write a peer file onto a tree where a local agent is mid-edit,
+ * or where a different remote agent holds the lock.
+ */
+function applyClash(lockTable, workspacePath, file, patch) {
+  const held = aliveLock(lockTable, file, workspacePath);
+  if (!held) return null;
+  const label = held.holder?.label || held.agentId;
+  if (holderIsLocal(held)) {
+    return { clash: true, holder: held.agentId, reason: `${file} is locked locally by ${label}` };
+  }
+  if (patch?.originAgentId && sameOwner(held.agentId, patch.originAgentId)) return null;
+  return { clash: true, holder: held.agentId, reason: `${file} is locked by ${label}` };
+}
+
+module.exports = { skipPublish, applyClash, holderIsLocal, aliveLock };

package/backend/lib/presence.js

@@ -0,0 +1,35 @@
+const { EventEmitter } = require("events");
+
+class Presence extends EventEmitter {
+  constructor() {
+    super();
+    this.workspaces = new Map();
+  }
+
+  join(workspaceId, userId) {
+    if (!workspaceId || !userId) return { count: 0, escalated: false };
+    if (!this.workspaces.has(workspaceId)) this.workspaces.set(workspaceId, new Set());
+    const set = this.workspaces.get(workspaceId);
+    const before = set.size;
+    set.add(userId);
+    const escalated = before < 2 && set.size >= 2;
+    this.emit("change", { workspaceId, userId, count: set.size, type: "join", escalated });
+    if (escalated) this.emit("escalate", { workspaceId, users: [...set] });
+    return { count: set.size, escalated };
+  }
+
+  leave(workspaceId, userId) {
+    const set = this.workspaces.get(workspaceId);
+    if (!set) return { count: 0 };
+    set.delete(userId);
+    const deescalated = set.size < 2;
+    this.emit("change", { workspaceId, userId, count: set.size, type: "leave", deescalated });
+    return { count: set.size, deescalated };
+  }
+
+  count(workspaceId) {
+    return this.workspaces.get(workspaceId)?.size || 0;
+  }
+}
+
+module.exports = { Presence };