relaybrain 0.2.0 → 0.2.1

package/backend/lib/falkor/demo.js

@@ -0,0 +1,221 @@
+// Shared helper for seeding the isolated 5-agent demo sandbox (`demo_<projectId>`)
+// and rebuilding a real workspace graph (`<projectId>`) from real transcripts & history.
+const path = require("path");
+const schema = require("./schema");
+const cursor = require("./cursor");
+const { projectHistory, projectPeer } = require("./project");
+const { writeProjection } = require("./write");
+const { ingestHistory, ingestPeer } = require("./ingest");
+const coord = require("./coord");
+const central = require("./central");
+const analytics = require("./analytics");
+const intents = require("./intents");
+const { loadRegistry, loadMemory } = require("../store");
+
+const WS = process.platform === "win32" ? "C:\\demo\\relay-app" : "/workspace/relay-app";
+const wsFile = (...parts) => path.join(WS, ...parts);
+
+const S_CLAUDE = "52b29a54-d8fb-4091-ab60-463ac73c9d6c";
+const S_CURSOR = "3e62675d-9b0f-4d99-b17d-c1d875fe98dc";
+const S_CODEX = "019e1fdf-e54d-70e2-ae26-d0d7103a404f";
+const S_COPILOT = "fcc51653-804f-4e4f-9330-347a42abd57c";
+const S_ANTI = "46d9adf1-1b25-4cf7-bd41-da8309d19f08";
+
+function demoGraphId(projectId) {
+  const base = String(projectId || "sandbox").replace(/^demo_/, "");
+  return `demo_${base}`;
+}
+
+function buildDemoHistory(now = Date.now()) {
+  const m = (minsAgo) => now - minsAgo * 60_000;
+  return [
+    // Session 1: Claude Code (@alice) switching login flow to JWT tokens
+    { id: "d01", agent: "Claude Code", ownerLogin: "alice", sessionId: S_CLAUDE, ts: m(25), role: "user", kind: "message", text: "switch the login flow to short-lived JWT tokens with refresh rotation" },
+    { id: "d02", agent: "Claude Code", ownerLogin: "alice", sessionId: S_CLAUDE, ts: m(24.5), role: "assistant", kind: "message", text: "I'll update src/auth.ts to issue 15-minute access JWTs and rotate refresh tokens in src/session.ts." },
+    { id: "d03", agent: "Claude Code", ownerLogin: "alice", sessionId: S_CLAUDE, ts: m(24), role: "tool", kind: "code_edit", text: "Edit auth.ts", file: "auth.ts", path: wsFile("src", "auth.ts"), diff: "--- a/src/auth.ts\n+++ b/src/auth.ts\n@@ -10,4 +10,8 @@\n-export function loginWithCookie(user) {\n+export function issueJwtPair(user) {\n+  return signJwt(user, { expiresIn: '15m' });\n" },
+    { id: "d04", agent: "Claude Code", ownerLogin: "alice", sessionId: S_CLAUDE, ts: m(23), role: "tool", kind: "code_edit", text: "Edit session.ts", file: "session.ts", path: wsFile("src", "session.ts"), diff: "--- a/src/session.ts\n+++ b/src/session.ts\n@@ -1,3 +1,6 @@\n+export function rotateRefreshToken(token) {\n+  return revokeAndMint(token);\n+}\n" },
+    { id: "d05", agent: "Claude Code", ownerLogin: "alice", sessionId: S_CLAUDE, ts: m(22), role: "user", kind: "message", text: "continue" },
+    { id: "d06", agent: "Claude Code", ownerLogin: "alice", sessionId: S_CLAUDE, ts: m(21.5), role: "tool", kind: "code_edit", text: "Edit middleware.ts", file: "middleware.ts", path: wsFile("src", "middleware.ts"), diff: "--- a/src/middleware.ts\n+++ b/src/middleware.ts\n@@ -4,2 +4,5 @@\n+export function verifyBearerJwt(req, res, next) {\n+  req.user = verifyJwt(req.headers.authorization);\n+}\n" },
+
+    // Session 2: Codex (@alice) hardening rate limits on auth & api routes
+    { id: "d07", agent: "Codex", ownerLogin: "alice", sessionId: S_CODEX, ts: m(18), role: "user", kind: "message", text: "add sliding-window rate limiting to login and token refresh endpoints" },
+    { id: "d08", agent: "Codex", ownerLogin: "alice", sessionId: S_CODEX, ts: m(17.5), role: "assistant", kind: "message", text: "Applying rate limiter middleware to src/routes.ts and src/auth.ts." },
+    { id: "d09", agent: "Codex", ownerLogin: "alice", sessionId: S_CODEX, ts: m(17), role: "tool", kind: "code_edit", text: "apply_patch auth.ts", file: "auth.ts", path: wsFile("src", "auth.ts"), diff: "+import { rateLimit } from './rateLimit';\n+export const authLimiter = rateLimit({ windowMs: 60000, max: 10 });\n" },
+    { id: "d10", agent: "Codex", ownerLogin: "alice", sessionId: S_CODEX, ts: m(16.8), role: "tool", kind: "code_edit", text: "apply_patch routes.ts", file: "routes.ts", path: wsFile("src", "routes.ts"), diff: "+app.post('/api/token/refresh', authLimiter, rotateRefreshToken);\n" },
+
+    // Session 3: Antigravity (@alice) updating UI auth client
+    { id: "d11", agent: "Antigravity", ownerLogin: "alice", sessionId: S_ANTI, ts: m(12), role: "user", kind: "message", text: "wire automatic silent JWT refresh into the frontend API client" },
+    { id: "d12", agent: "Antigravity", ownerLogin: "alice", sessionId: S_ANTI, ts: m(11.5), role: "assistant", kind: "message", text: "Updating src/client.ts and src/auth.ts types to retry 401 responses after refreshing the access token." },
+    { id: "d13", agent: "Antigravity", ownerLogin: "alice", sessionId: S_ANTI, ts: m(11), role: "tool", kind: "code_edit", text: "replace_file_content client.ts", file: "client.ts", path: wsFile("src", "client.ts"), diff: "+if (res.status === 401) await refreshAccessToken();\n" },
+    { id: "d14", agent: "Antigravity", ownerLogin: "alice", sessionId: S_ANTI, ts: m(10.5), role: "tool", kind: "code_edit", text: "replace_file_content auth.ts", file: "auth.ts", path: wsFile("src", "auth.ts"), diff: "+export type TokenPair = { accessToken: string; refreshToken: string; expiresIn: number };\n" },
+  ];
+}
+
+function buildPeerSnapshot(now = Date.now()) {
+  const m = (minsAgo) => now - minsAgo * 60_000;
+  return {
+    login: "bob",
+    chats: [
+      {
+        id: `chat_cursor_${S_CURSOR}`,
+        agent: "Cursor",
+        ownerLogin: "bob",
+        sessionId: S_CURSOR,
+        messages: [
+          { role: "user", kind: "message", text: "add logout revocation endpoint and clear refresh token store", ts: m(20) },
+          { role: "assistant", kind: "message", text: "Adding token revocation in src/auth.ts and src/session.ts.", ts: m(19.5) },
+          { role: "tool", kind: "code_edit", text: "StrReplace auth.ts", file: "auth.ts", ts: m(19) },
+          { role: "tool", kind: "code_edit", text: "StrReplace session.ts", file: "session.ts", ts: m(18.5) },
+        ],
+      },
+      {
+        id: `chat_copilot_${S_COPILOT}`,
+        agent: "Copilot",
+        ownerLogin: "bob",
+        sessionId: S_COPILOT,
+        messages: [
+          { role: "user", kind: "message", text: "add integration tests for JWT expiry and refresh rotation", ts: m(8) },
+          { role: "assistant", kind: "message", text: "Creating tests/auth.test.ts and exporting verify helpers from src/auth.ts.", ts: m(7.5) },
+          { role: "tool", kind: "code_edit", text: "replace_string_in_file auth.ts", file: "auth.ts", ts: m(7) },
+          { role: "tool", kind: "code_edit", text: "create_file auth.test.ts", file: "auth.test.ts", ts: m(6.5) },
+        ],
+      },
+    ],
+    edits: [
+      { id: "e_bob01", agent: "Cursor", ownerLogin: "bob", file: "src/auth.ts", ts: m(19), diff: "+export async function revokeSession(jti: string) { await denylist.add(jti); }\n" },
+      { id: "e_bob02", agent: "Cursor", ownerLogin: "bob", file: "src/session.ts", ts: m(18.5), diff: "+export const denylist = new Set<string>();\n" },
+      { id: "e_bob03", agent: "Copilot", ownerLogin: "bob", file: "src/auth.ts", ts: m(7), diff: "+export { verifyJwt } from './jwt';\n" },
+      { id: "e_bob04", agent: "Copilot", ownerLogin: "bob", file: "tests/auth.test.ts", ts: m(6.5), diff: "+test('rotates refresh token and rejects replay', async () => {});\n" },
+    ],
+  };
+}
+
+/**
+ * Seeds the isolated demo graph (`demo_<projectId>`) without touching the real workspace graph.
+ * Note: does NOT pollute the live `intents` cache for real workspace sessions unless `updateIntents` is set.
+ */
+async function seedDemoGraph(falkor, projectId, opts = {}) {
+  const targetId = opts.rawTarget ? String(projectId || "demo_sandbox") : demoGraphId(projectId);
+  const { client } = falkor.state;
+  const now = Date.now();
+  await client.deleteGraph(targetId).catch(() => undefined);
+  schema.forget(targetId);
+  await falkor.ensureProject(targetId);
+
+  const localProj = projectHistory(buildDemoHistory(now), { workspacePath: WS, storeText: true });
+  await writeProjection(client, targetId, localProj);
+
+  const peerProj = projectPeer(buildPeerSnapshot(now), { login: "bob", trustRowOwners: false, storeText: true });
+  await writeProjection(client, targetId, peerProj);
+
+  if (opts.updateIntents) {
+    for (const i of localProj.intents.values()) intents.remember(i);
+    for (const i of peerProj.intents.values()) intents.remember(i);
+  }
+
+  coord.configure(falkor);
+  coord.recordHeld(targetId, `Claude Code:ALICE-DESK:${S_CLAUDE}`, "src/auth.ts", now - 2 * 60_000);
+  coord.recordContention(targetId, {
+    kind: "claim_blocked",
+    file: "src/auth.ts",
+    wanter: `Cursor:BOB-LAPTOP:${S_CURSOR}`,
+    holder: `Claude Code:ALICE-DESK:${S_CLAUDE}`,
+    reason: `File \`src/auth.ts\` is locked by Claude Code. They're working on: "switch the login flow to short-lived JWT tokens with refresh rotation" (2 min ago).`,
+    ts: now - 20 * 60_000,
+    holderIntentText: "switch the login flow to short-lived JWT tokens with refresh rotation",
+  });
+  await coord.flushAll();
+
+  central.configure(falkor);
+  const decisions = [
+    central.toRow({
+      event_id: 101,
+      kind: "decision",
+      decision_id: "jwt-refresh-rotation",
+      content: "Use 15-minute stateless JWT access tokens paired with single-use rotating refresh tokens in src/auth.ts and src/session.ts.",
+      status: "accepted",
+      user: "alice",
+      agent_label: "Claude Code",
+      files: ["src/auth.ts", "src/session.ts", "src/middleware.ts"],
+      ts: new Date(now - 21 * 60_000).toISOString(),
+    }),
+    central.toRow({
+      event_id: 102,
+      kind: "decision",
+      decision_id: "auth-rate-limit",
+      content: "Enforce 10 req/min sliding-window rate limit on /api/token/refresh and login routes.",
+      status: "accepted",
+      user: "alice",
+      agent_label: "Codex",
+      files: ["src/auth.ts", "src/routes.ts"],
+      ts: new Date(now - 16 * 60_000).toISOString(),
+    }),
+  ].filter(Boolean);
+  await central.writeRows(targetId, decisions);
+
+  analytics.configure(falkor);
+  const summary = await analytics.run(targetId, { full: true });
+  falkor.notify?.(projectId, { demo: true, summary });
+  return { targetId, summary };
+}
+
+/**
+ * Drops and rebuilds a real workspace graph from its local `memory.json` + roomPeers + central JSONL.
+ */
+async function rebuildProjectGraph(falkor, projectId, opts = {}) {
+  const projects = loadRegistry().projects || [];
+  const project = projects.find((p) => p.id === projectId || p.name === projectId);
+  if (!project) throw Object.assign(new Error(`Unknown project "${projectId}"`), { status: 404 });
+  const { client } = falkor.state;
+  if (!opts.keep) {
+    await client.deleteGraph(project.id);
+    schema.forget(project.id);
+    cursor.reset(project.id);
+  }
+  await falkor.ensureProject(project.id);
+  const memory = loadMemory(project.id);
+  const history = memory.history || [];
+  const t = Date.now();
+  const result = await ingestHistory(project.id, history, project.path, { full: true });
+  const peers = Object.entries(memory.roomPeers || {});
+  for (const [key, snapshot] of peers) {
+    await ingestPeer(project.id, { snapshot, login: snapshot.login || key, trustRowOwners: key === "host" });
+  }
+  // Re-ingest Central JSONL decisions/tasks if present
+  try {
+    central.configure(falkor);
+    const { eventsPath } = require("../centralStore");
+    const fs = require("fs");
+    const centralId = project.centralProjectId || project.id;
+    const file = eventsPath(centralId);
+    if (fs.existsSync(file)) {
+      const lines = fs.readFileSync(file, "utf8").split("\n").filter(Boolean);
+      const rows = lines
+        .map((l) => {
+          try {
+            return central.toRow(JSON.parse(l));
+          } catch {
+            return null;
+          }
+        })
+        .filter(Boolean);
+      if (rows.length) await central.writeRows(project.id, rows);
+    }
+  } catch {
+    /* optional central events */
+  }
+  analytics.configure(falkor);
+  const stats = await analytics.run(project.id, { full: true });
+  falkor.notify?.(project.id, { rebuilt: true, stats });
+  return {
+    projectId: project.id,
+    path: project.path,
+    events: history.length,
+    peers: peers.length,
+    ingest: result,
+    analytics: stats,
+    ms: Date.now() - t,
+  };
+}
+
+module.exports = { demoGraphId, buildDemoHistory, buildPeerSnapshot, seedDemoGraph, rebuildProjectGraph };

package/backend/lib/falkor/migrations.js

@@ -1,56 +1,56 @@
-// Versioned in-place graph migrations (#18): run at schema.ensure() and recorded on
-// Meta.migrations so schema/ingest version bumps preserve history older than memory.json's cap
-// instead of requiring a destructive drop-and-rebuild.
-
-const MIGRATIONS = [
-  {
-    id: "001_meta_versions_v6",
-    description: "Ensure Session.stub defaults and stamp Meta to schemaVersion=1, ingestVersion=6 in place",
-    async up(client, projectId, { schemaVersion, ingestVersion }) {
-      await client.write(
-        projectId,
-        `MATCH (s:Session) WHERE s.stub IS NULL SET s.stub = false RETURN count(s) AS n`
-      );
-      await client.write(
-        projectId,
-        `MATCH (m:Meta {key: 'meta'})
-         SET m.schemaVersion = $schema, m.ingestVersion = $ingest, m.migratedAt = $now
-         RETURN 1 AS ok`,
-        { schema: schemaVersion, ingest: ingestVersion, now: Date.now() }
-      );
-    },
-  },
-];
-
-async function runMigrations(client, projectId, { schemaVersion, ingestVersion }) {
-  const rows = await client.read(
-    projectId,
-    "MATCH (m:Meta {key: 'meta'}) RETURN coalesce(m.migrations, []) AS migrations, m.schemaVersion AS s, m.ingestVersion AS i"
-  );
-  const meta = rows[0] || {};
-  const applied = new Set(Array.isArray(meta.migrations) ? meta.migrations : []);
-  const ran = [];
-
-  for (const mig of MIGRATIONS) {
-    if (applied.has(mig.id)) continue;
-    await mig.up(client, projectId, { schemaVersion, ingestVersion });
-    applied.add(mig.id);
-    ran.push(mig.id);
-  }
-
-  // If the graph had an older schemaVersion or ingestVersion, migrate it forward in place
-  // so existing Turn/Edit/Session/Decision history is preserved without dropping the graph.
-  if (ran.length || meta.s !== schemaVersion || meta.i !== ingestVersion) {
-    await client.write(
-      projectId,
-      `MATCH (m:Meta {key: 'meta'})
-       SET m.migrations = $migrations, m.schemaVersion = $schema, m.ingestVersion = $ingest
-       RETURN 1 AS ok`,
-      { migrations: [...applied], schema: schemaVersion, ingest: ingestVersion }
-    );
-  }
-
-  return { applied: [...applied], ran };
-}
-
-module.exports = { MIGRATIONS, runMigrations };
+// Versioned in-place graph migrations (#18): run at schema.ensure() and recorded on
+// Meta.migrations so schema/ingest version bumps preserve history older than memory.json's cap
+// instead of requiring a destructive drop-and-rebuild.
+
+const MIGRATIONS = [
+  {
+    id: "001_meta_versions_v6",
+    description: "Ensure Session.stub defaults and stamp Meta to schemaVersion=1, ingestVersion=6 in place",
+    async up(client, projectId, { schemaVersion, ingestVersion }) {
+      await client.write(
+        projectId,
+        `MATCH (s:Session) WHERE s.stub IS NULL SET s.stub = false RETURN count(s) AS n`
+      );
+      await client.write(
+        projectId,
+        `MATCH (m:Meta {key: 'meta'})
+         SET m.schemaVersion = $schema, m.ingestVersion = $ingest, m.migratedAt = $now
+         RETURN 1 AS ok`,
+        { schema: schemaVersion, ingest: ingestVersion, now: Date.now() }
+      );
+    },
+  },
+];
+
+async function runMigrations(client, projectId, { schemaVersion, ingestVersion }) {
+  const rows = await client.read(
+    projectId,
+    "MATCH (m:Meta {key: 'meta'}) RETURN coalesce(m.migrations, []) AS migrations, m.schemaVersion AS s, m.ingestVersion AS i"
+  );
+  const meta = rows[0] || {};
+  const applied = new Set(Array.isArray(meta.migrations) ? meta.migrations : []);
+  const ran = [];
+
+  for (const mig of MIGRATIONS) {
+    if (applied.has(mig.id)) continue;
+    await mig.up(client, projectId, { schemaVersion, ingestVersion });
+    applied.add(mig.id);
+    ran.push(mig.id);
+  }
+
+  // If the graph had an older schemaVersion or ingestVersion, migrate it forward in place
+  // so existing Turn/Edit/Session/Decision history is preserved without dropping the graph.
+  if (ran.length || meta.s !== schemaVersion || meta.i !== ingestVersion) {
+    await client.write(
+      projectId,
+      `MATCH (m:Meta {key: 'meta'})
+       SET m.migrations = $migrations, m.schemaVersion = $schema, m.ingestVersion = $ingest
+       RETURN 1 AS ok`,
+      { migrations: [...applied], schema: schemaVersion, ingest: ingestVersion }
+    );
+  }
+
+  return { applied: [...applied], ran };
+}
+
+module.exports = { MIGRATIONS, runMigrations };

package/backend/lib/falkor/routes.js

@@ -1,5 +1,6 @@
 const { runNamed, names } = require("./query");
 const { projectIdFor } = require("./coord");
+const { demoGraphId, seedDemoGraph, rebuildProjectGraph } = require("./demo");
 const { loadRoom } = require("../room");
 const { loadRegistry, loadSession } = require("../store");
 
@@ -11,6 +12,10 @@ function argsFrom(req) {
   return q;
 }
 
+function isDemoMode(args) {
+  return args?.demo === "1" || args?.demo === 1 || args?.demo === true || args?.mode === "demo";
+}
+
 function resolveProjectId(args) {
   if (args.projectId) return String(args.projectId);
   const byPath = projectIdFor(args.workspace);
@@ -41,9 +46,11 @@ async function askHost(room, name, args) {
 
 /** Local graph first unless this machine is a room guest, in which case the host's graph is the room brain. */
 async function query(name, args) {
-  const projectId = resolveProjectId(args);
-  const room = loadRoom(args.workspace || projectPath(projectId) || undefined);
-  if (room?.role === "guest" && room.url && api.state.deps.fetchHost && !args.local) {
+  const baseProjectId = resolveProjectId(args);
+  const demo = isDemoMode(args);
+  const targetGraphId = demo ? demoGraphId(baseProjectId) : baseProjectId;
+  const room = loadRoom(args.workspace || projectPath(baseProjectId) || undefined);
+  if (!demo && room?.role === "guest" && room.url && api.state.deps.fetchHost && !args.local) {
     try {
       return await askHost(room, name, args);
     } catch (err) {
@@ -57,14 +64,24 @@ async function query(name, args) {
   }
   if (!api.state.started) return { ok: false, reason: "falkor_disabled", hint: "set RELAY_FALKOR_URL and restart relay serve" };
   if (!api.client.available()) return { ok: false, reason: "falkor_unavailable", breaker: api.client.status() };
-  await api.ensureProject(projectId);
-  return { ok: true, projectId, source: "local", ...(await runNamed(api.client, projectId, name, args)) };
+  await api.ensureProject(targetGraphId);
+  return {
+    ok: true,
+    projectId: baseProjectId,
+    graphId: targetGraphId,
+    mode: demo ? "demo" : "live",
+    source: "local",
+    ...(await runNamed(api.client, targetGraphId, name, args)),
+  };
 }
 
 function register(app, falkor) {
-  api = { ...falkor, get client() {
-    return falkor.state.client;
-  } };
+  api = {
+    ...falkor,
+    get client() {
+      return falkor.state.client;
+    },
+  };
   const guard = falkor.state.deps.requireRoomMember || ((_req, _res, next) => next());
   const handler = async (req, res) => {
     try {
@@ -76,6 +93,33 @@ function register(app, falkor) {
   app.get("/api/graph/queries", (_req, res) => res.json({ queries: names() }));
   app.get("/api/graph/query/:name", guard, handler);
   app.post("/api/graph/query/:name", guard, handler);
+
+  // Local-only actions: seed the isolated demo sandbox or rebuild a real project graph from live transcripts.
+  app.post("/api/graph/seed-demo", async (req, res) => {
+    if (require("../roomAuth").isRemoteRequest(req)) return res.status(403).json({ ok: false, reason: "local requests only" });
+    if (!api.state.started) return res.status(409).json({ ok: false, reason: "falkor_disabled" });
+    try {
+      const pid = resolveProjectId(argsFrom(req)) || "sandbox";
+      const out = await seedDemoGraph(falkor, pid);
+      res.json({ ok: true, projectId: pid, ...out });
+    } catch (err) {
+      res.status(err.status || 500).json({ ok: false, reason: String(err.message || err) });
+    }
+  });
+
+  app.post("/api/graph/rebuild", async (req, res) => {
+    if (require("../roomAuth").isRemoteRequest(req)) return res.status(403).json({ ok: false, reason: "local requests only" });
+    if (!api.state.started) return res.status(409).json({ ok: false, reason: "falkor_disabled" });
+    try {
+      const q = argsFrom(req);
+      const pid = resolveProjectId(q);
+      if (!pid) return res.status(404).json({ ok: false, reason: "no project selected" });
+      const out = await rebuildProjectGraph(falkor, pid, { keep: Boolean(q.keep) });
+      res.json({ ok: true, ...out });
+    } catch (err) {
+      res.status(err.status || 500).json({ ok: false, reason: String(err.message || err) });
+    }
+  });
 }
 
 module.exports = { register, query };

package/backend/lib/localBrowse.js

@@ -1,109 +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 };
+// 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 };