relay-os 0.1.0

package/backend/lib/relayProjects.js

@@ -0,0 +1,225 @@
+const fs = require('fs');
+const path = require('path');
+const os = require('os');
+const crypto = require('crypto');
+
+const REGISTRY_DIR = path.join(os.homedir(), '.relay-os');
+const REGISTRY_PATH = path.join(REGISTRY_DIR, 'projects.json');
+
+function ensureRegistryDir() {
+  if (!fs.existsSync(REGISTRY_DIR)) fs.mkdirSync(REGISTRY_DIR, { recursive: true });
+}
+
+function loadRegistry() {
+  ensureRegistryDir();
+  if (!fs.existsSync(REGISTRY_PATH)) {
+    return { version: 1, projects: [] };
+  }
+  try {
+    return JSON.parse(fs.readFileSync(REGISTRY_PATH, 'utf-8'));
+  } catch (_) {
+    return { version: 1, projects: [] };
+  }
+}
+
+function saveRegistry(registry) {
+  ensureRegistryDir();
+  fs.writeFileSync(REGISTRY_PATH, JSON.stringify(registry, null, 2), 'utf-8');
+}
+
+function generateId() {
+  return crypto.randomBytes(8).toString('hex');
+}
+
+function generateApiKey() {
+  return `relay_${crypto.randomBytes(24).toString('hex')}`;
+}
+
+function defaultProjectName(workspacePath) {
+  return path.basename(path.resolve(workspacePath)) || 'Untitled project';
+}
+
+function writeProjectManifest(workspacePath, project) {
+  const relayDir = path.join(path.resolve(workspacePath), '.relay');
+  if (!fs.existsSync(relayDir)) fs.mkdirSync(relayDir, { recursive: true });
+
+  const uiPort = Number(process.env.RELAY_UI_PORT) || 6374;
+  const manifest = {
+    id: project.id,
+    name: project.name,
+    apiKey: project.apiKey,
+    workspacePath: path.resolve(workspacePath),
+    dashboardUrl: `http://localhost:${uiPort}/?project=${project.id}`,
+    setupUrl: `http://localhost:${uiPort}/?setup=${project.id}`,
+    updatedAt: new Date().toISOString(),
+  };
+
+  fs.writeFileSync(
+    path.join(relayDir, 'project.json'),
+    JSON.stringify(manifest, null, 2),
+    'utf-8'
+  );
+  return manifest;
+}
+
+function readProjectManifest(workspacePath) {
+  const manifestPath = path.join(path.resolve(workspacePath), '.relay', 'project.json');
+  if (!fs.existsSync(manifestPath)) return null;
+  try {
+    return JSON.parse(fs.readFileSync(manifestPath, 'utf-8'));
+  } catch (_) {
+    return null;
+  }
+}
+
+function getProjectStats(workspacePath) {
+  const memoryPath = path.join(path.resolve(workspacePath), '.relay', 'memory.json');
+  if (!fs.existsSync(memoryPath)) {
+    return { totalEvents: 0, lastSync: null, connectedAgents: 0 };
+  }
+  try {
+    const memory = JSON.parse(fs.readFileSync(memoryPath, 'utf-8'));
+    const timeline = Array.isArray(memory.timeline) ? memory.timeline : [];
+    const connectedAgents = Object.values(memory.agents || {}).filter(
+      (a) => a.status === 'connected'
+    ).length;
+    return {
+      totalEvents: timeline.length,
+      lastSync: memory.lastSync || null,
+      connectedAgents,
+    };
+  } catch (_) {
+    return { totalEvents: 0, lastSync: null, connectedAgents: 0 };
+  }
+}
+
+function enrichProject(project, { includeApiKey = false } = {}) {
+  const stats = getProjectStats(project.workspacePath);
+  const base = {
+    id: project.id,
+    name: project.name,
+    workspacePath: project.workspacePath,
+    createdAt: project.createdAt,
+    updatedAt: project.updatedAt,
+    stats,
+  };
+  if (includeApiKey) base.apiKey = project.apiKey;
+  return base;
+}
+
+function registerProject(workspacePath, options = {}) {
+  const resolved = path.resolve(workspacePath);
+  const registry = loadRegistry();
+  let project = registry.projects.find((p) => p.workspacePath === resolved);
+
+  if (project) {
+    if (options.name && options.name !== project.name) {
+      project.name = options.name.trim();
+      project.updatedAt = new Date().toISOString();
+    }
+  } else {
+    project = {
+      id: generateId(),
+      name: (options.name || defaultProjectName(resolved)).trim(),
+      workspacePath: resolved,
+      apiKey: generateApiKey(),
+      createdAt: new Date().toISOString(),
+      updatedAt: new Date().toISOString(),
+    };
+    registry.projects.push(project);
+  }
+
+  saveRegistry(registry);
+  const manifest = writeProjectManifest(resolved, project);
+  return { project: enrichProject(project, { includeApiKey: true }), manifest };
+}
+
+function listProjects(options = {}) {
+  const registry = loadRegistry();
+  return registry.projects
+    .map((p) => enrichProject(p, { includeApiKey: options.includeApiKey }))
+    .sort((a, b) => new Date(b.updatedAt) - new Date(a.updatedAt));
+}
+
+function getProject(projectId, options = {}) {
+  const registry = loadRegistry();
+  const project = registry.projects.find((p) => p.id === projectId);
+  if (!project) return null;
+  return enrichProject(project, { includeApiKey: options.includeApiKey });
+}
+
+function getProjectByWorkspace(workspacePath, options = {}) {
+  const resolved = path.resolve(workspacePath);
+  const registry = loadRegistry();
+  const project = registry.projects.find((p) => p.workspacePath === resolved);
+  if (!project) return null;
+  return enrichProject(project, { includeApiKey: options.includeApiKey });
+}
+
+function getProjectByApiKey(apiKey) {
+  if (!apiKey) return null;
+  const registry = loadRegistry();
+  const project = registry.projects.find((p) => p.apiKey === apiKey);
+  if (!project) return null;
+  return enrichProject(project, { includeApiKey: true });
+}
+
+function updateProjectName(projectId, name) {
+  const registry = loadRegistry();
+  const project = registry.projects.find((p) => p.id === projectId);
+  if (!project) throw new Error('Project not found');
+  project.name = String(name || '').trim() || defaultProjectName(project.workspacePath);
+  project.updatedAt = new Date().toISOString();
+  saveRegistry(registry);
+  writeProjectManifest(project.workspacePath, project);
+  return enrichProject(project, { includeApiKey: true });
+}
+
+function resolveProjectWorkspace(projectId) {
+  const project = getProject(projectId);
+  if (!project) throw new Error('Project not found');
+  return project.workspacePath;
+}
+
+function syncFromManifest(workspacePath) {
+  const manifest = readProjectManifest(workspacePath);
+  if (!manifest || !manifest.id || !manifest.apiKey) return null;
+
+  const registry = loadRegistry();
+  let project = registry.projects.find((p) => p.id === manifest.id);
+
+  if (!project) {
+    project = {
+      id: manifest.id,
+      name: manifest.name || defaultProjectName(workspacePath),
+      workspacePath: path.resolve(workspacePath),
+      apiKey: manifest.apiKey,
+      createdAt: manifest.updatedAt || new Date().toISOString(),
+      updatedAt: new Date().toISOString(),
+    };
+    registry.projects.push(project);
+  } else {
+    project.name = manifest.name || project.name;
+    project.apiKey = manifest.apiKey;
+    project.workspacePath = path.resolve(workspacePath);
+    project.updatedAt = new Date().toISOString();
+  }
+
+  saveRegistry(registry);
+  return enrichProject(project, { includeApiKey: true });
+}
+
+module.exports = {
+  REGISTRY_PATH,
+  registerProject,
+  listProjects,
+  getProject,
+  getProjectByWorkspace,
+  getProjectByApiKey,
+  updateProjectName,
+  resolveProjectWorkspace,
+  syncFromManifest,
+  writeProjectManifest,
+  readProjectManifest,
+  getProjectStats,
+};

package/backend/lib/relayServe.js

@@ -0,0 +1,120 @@
+const http = require('http');
+const path = require('path');
+const { spawn } = require('child_process');
+
+const PACKAGE_ROOT = path.join(__dirname, '..', '..');
+const BACKEND = path.join(PACKAGE_ROOT, 'backend');
+
+function getApiPort() {
+  return Number(process.env.RELAY_PORT) || 3001;
+}
+
+function getUiPort() {
+  return Number(process.env.RELAY_UI_PORT) || 6374;
+}
+
+function pingHealth(port) {
+  return new Promise((resolve) => {
+    const req = http.get(`http://127.0.0.1:${port}/api/health`, (res) => {
+      res.resume();
+      resolve(res.statusCode === 200);
+    });
+    req.on('error', () => resolve(false));
+    req.setTimeout(1500, () => {
+      req.destroy();
+      resolve(false);
+    });
+  });
+}
+
+async function isRelayApiRunning(port = getApiPort()) {
+  return pingHealth(port);
+}
+
+function spawnDetached(args, env, cwd) {
+  const child = spawn(process.execPath, args, {
+    detached: true,
+    stdio: 'ignore',
+    env,
+    cwd,
+    windowsHide: true,
+  });
+  child.unref();
+  return child;
+}
+
+function startRelayServeForeground(options = {}) {
+  const port = options.port || getApiPort();
+  const uiPort = options.uiPort || getUiPort();
+  const apiOnly = Boolean(options.apiOnly);
+  const { startMissionControlUi } = require('./relayUi');
+  const serverPath = path.join(BACKEND, 'server.js');
+  const env = { ...process.env, RELAY_PORT: String(port), RELAY_UI_PORT: String(uiPort) };
+
+  let uiChild = null;
+  if (!apiOnly) {
+    try {
+      uiChild = startMissionControlUi({ apiPort: port, uiPort });
+    } catch (err) {
+      console.warn(`Mission Control UI failed to start: ${err.message || err}`);
+      console.warn('Continuing with API only.');
+    }
+  }
+
+  const apiChild = spawn(process.execPath, [serverPath], {
+    stdio: 'inherit',
+    env,
+    cwd: BACKEND,
+  });
+
+  function shutdown() {
+    if (uiChild && !uiChild.killed) uiChild.kill();
+    if (apiChild && !apiChild.killed) apiChild.kill();
+    process.exit(0);
+  }
+
+  process.on('SIGINT', shutdown);
+  process.on('SIGTERM', shutdown);
+
+  if (uiChild) {
+    uiChild.on('exit', (code) => {
+      if (code && code !== 0) console.warn(`Mission Control exited (${code})`);
+    });
+  }
+
+  return { apiChild, uiChild, port, uiPort };
+}
+
+async function startRelayServeBackground(options = {}) {
+  const port = options.port || getApiPort();
+  const uiPort = options.uiPort || getUiPort();
+
+  if (await isRelayApiRunning(port)) {
+    return { started: false, alreadyRunning: true, port, uiPort };
+  }
+
+  const relayBin = path.join(PACKAGE_ROOT, 'bin', 'relay.js');
+  const args = [relayBin, 'serve', '--port', String(port), '--ui-port', String(uiPort)];
+  if (options.apiOnly) args.push('--api-only');
+
+  const env = { ...process.env, RELAY_PORT: String(port), RELAY_UI_PORT: String(uiPort) };
+  spawnDetached(args, env, PACKAGE_ROOT);
+
+  for (let i = 0; i < 20; i += 1) {
+    await new Promise((r) => setTimeout(r, 500));
+    if (await isRelayApiRunning(port)) {
+      return { started: true, alreadyRunning: false, port, uiPort };
+    }
+  }
+
+  return { started: true, alreadyRunning: false, port, uiPort, warming: true };
+}
+
+module.exports = {
+  PACKAGE_ROOT,
+  getApiPort,
+  getUiPort,
+  isRelayApiRunning,
+  startRelayServeForeground,
+  startRelayServeBackground,
+};

package/backend/lib/relayStore.js

@@ -0,0 +1,173 @@
+const fs = require('fs');
+const path = require('path');
+
+const IR_FILES = [
+  'relay_context.md',
+  'compile_brief.md',
+  'project.md',
+  'current_task.md',
+  'decisions.md',
+  'failures.md',
+  'architecture.md',
+  'AGENT_BOOTSTRAP.md',
+  'memory.json',
+  'config.json',
+];
+
+const SKIP_DIRS = new Set(['node_modules', '.git']);
+
+function getRelayDir(workspacePath) {
+  return path.join(path.resolve(workspacePath), '.relay');
+}
+
+function assertRelayPath(relayDir, relPath) {
+  const normalized = path.normalize(relPath).replace(/^(\.\.(\/|\\|$))+/, '');
+  const full = path.resolve(relayDir, normalized);
+  if (!full.startsWith(path.resolve(relayDir))) {
+    throw new Error('Path escapes .relay directory');
+  }
+  return { full, rel: normalized.replace(/\\/g, '/') };
+}
+
+function listRelayFiles(workspacePath, subPath = '') {
+  const relayDir = getRelayDir(workspacePath);
+  if (!fs.existsSync(relayDir)) {
+    throw new Error('Workspace not registered. Run relay init first.');
+  }
+
+  const { full, rel } = assertRelayPath(relayDir, subPath || '.');
+  if (!fs.existsSync(full)) return { path: rel === '.' ? '' : rel, entries: [] };
+
+  const stat = fs.statSync(full);
+  if (!stat.isDirectory()) {
+    return { path: rel === '.' ? '' : rel, entries: [] };
+  }
+
+  const entries = fs
+    .readdirSync(full, { withFileTypes: true })
+    .filter((e) => !e.name.startsWith('.') || e.name === '.relay-hook-continuing')
+    .filter((e) => !SKIP_DIRS.has(e.name))
+    .map((e) => {
+      const childRel = rel === '.' || !rel ? e.name : `${rel}/${e.name}`;
+      const childFull = path.join(full, e.name);
+      const childStat = fs.statSync(childFull);
+      return {
+        name: e.name,
+        path: childRel.replace(/\\/g, '/'),
+        type: childStat.isDirectory() ? 'dir' : 'file',
+        size: childStat.isFile() ? childStat.size : null,
+        updatedAt: childStat.mtime.toISOString(),
+      };
+    })
+    .sort((a, b) => {
+      if (a.type !== b.type) return a.type === 'dir' ? -1 : 1;
+      return a.name.localeCompare(b.name);
+    });
+
+  return { path: rel === '.' ? '' : rel, entries };
+}
+
+function readRelayFile(workspacePath, relPath) {
+  const relayDir = getRelayDir(workspacePath);
+  if (!fs.existsSync(relayDir)) {
+    throw new Error('Workspace not registered. Run relay init first.');
+  }
+
+  const { full, rel } = assertRelayPath(relayDir, relPath);
+  if (!fs.existsSync(full) || !fs.statSync(full).isFile()) {
+    throw new Error(`File not found: ${rel}`);
+  }
+
+  const stat = fs.statSync(full);
+  const content = fs.readFileSync(full, 'utf-8');
+  return {
+    path: rel,
+    content,
+    size: stat.size,
+    updatedAt: stat.mtime.toISOString(),
+  };
+}
+
+function writeRelayFile(workspacePath, relPath, content) {
+  const relayDir = getRelayDir(workspacePath);
+  if (!fs.existsSync(relayDir)) {
+    throw new Error('Workspace not registered. Run relay init first.');
+  }
+
+  const { full, rel } = assertRelayPath(relayDir, relPath);
+  fs.mkdirSync(path.dirname(full), { recursive: true });
+  fs.writeFileSync(full, content, 'utf-8');
+  const stat = fs.statSync(full);
+  return {
+    path: rel,
+    size: stat.size,
+    updatedAt: stat.mtime.toISOString(),
+  };
+}
+
+function buildRelayTree(workspacePath, maxDepth = 3) {
+  const relayDir = getRelayDir(workspacePath);
+  if (!fs.existsSync(relayDir)) return [];
+
+  function walk(dir, rel, depth) {
+    if (depth > maxDepth) return [];
+    let entries;
+    try {
+      entries = fs.readdirSync(dir, { withFileTypes: true });
+    } catch (_) {
+      return [];
+    }
+
+    return entries
+      .filter((e) => !SKIP_DIRS.has(e.name))
+      .filter((e) => !e.name.startsWith('.') || IR_FILES.includes(e.name))
+      .map((e) => {
+        const childRel = rel ? `${rel}/${e.name}` : e.name;
+        const childFull = path.join(dir, e.name);
+        if (e.isDirectory()) {
+          return {
+            name: e.name,
+            path: childRel.replace(/\\/g, '/'),
+            type: 'dir',
+            children: walk(childFull, childRel, depth + 1),
+          };
+        }
+        const stat = fs.statSync(childFull);
+        return {
+          name: e.name,
+          path: childRel.replace(/\\/g, '/'),
+          type: 'file',
+          size: stat.size,
+          updatedAt: stat.mtime.toISOString(),
+        };
+      })
+      .sort((a, b) => {
+        if (a.type !== b.type) return a.type === 'dir' ? -1 : 1;
+        return a.name.localeCompare(b.name);
+      });
+  }
+
+  return walk(relayDir, '', 0);
+}
+
+function readIrFiles(workspacePath) {
+  const relayDir = getRelayDir(workspacePath);
+  const out = {};
+  for (const name of IR_FILES) {
+    const full = path.join(relayDir, name);
+    if (fs.existsSync(full) && fs.statSync(full).isFile()) {
+      out[name] = fs.readFileSync(full, 'utf-8');
+    }
+  }
+  return out;
+}
+
+module.exports = {
+  IR_FILES,
+  getRelayDir,
+  listRelayFiles,
+  readRelayFile,
+  writeRelayFile,
+  buildRelayTree,
+  readIrFiles,
+};

package/backend/lib/relayUi.js

@@ -0,0 +1,68 @@
+const fs = require('fs');
+const path = require('path');
+const { spawn, execSync } = require('child_process');
+
+const PACKAGE_ROOT = path.join(__dirname, '..', '..');
+const UI_DIR = path.join(PACKAGE_ROOT, 'mission-control');
+
+function getUiPort() {
+  return Number(process.env.RELAY_UI_PORT) || 6374;
+}
+
+function getApiPort() {
+  return Number(process.env.RELAY_PORT) || 3001;
+}
+
+function getDashboardBaseUrl() {
+  return `http://localhost:${getUiPort()}`;
+}
+
+function npmCommand() {
+  return process.platform === 'win32' ? 'npm.cmd' : 'npm';
+}
+
+function ensureMissionControlDeps(options = {}) {
+  if (!fs.existsSync(UI_DIR)) {
+    throw new Error('Mission Control UI not found in relay-os package');
+  }
+
+  const nodeModules = path.join(UI_DIR, 'node_modules');
+  if (fs.existsSync(nodeModules) && !options.force) return UI_DIR;
+
+  if (options.quiet) {
+    execSync(`${npmCommand()} install`, { cwd: UI_DIR, stdio: 'ignore', shell: process.platform === 'win32' });
+  } else {
+    console.log('[relay] Installing Mission Control UI dependencies (first run)…');
+    execSync(`${npmCommand()} install`, { cwd: UI_DIR, stdio: 'inherit', shell: process.platform === 'win32' });
+  }
+
+  return UI_DIR;
+}
+
+function startMissionControlUi(options = {}) {
+  ensureMissionControlDeps(options);
+  const uiPort = options.uiPort || getUiPort();
+  const apiPort = options.apiPort || getApiPort();
+
+  const env = {
+    ...process.env,
+    NEXT_PUBLIC_RELAY_URL: `http://localhost:${apiPort}`,
+    PORT: String(uiPort),
+  };
+
+  return spawn(npmCommand(), ['run', 'dev'], {
+    cwd: UI_DIR,
+    stdio: 'inherit',
+    env,
+    shell: process.platform === 'win32',
+  });
+}
+
+module.exports = {
+  UI_DIR,
+  getUiPort,
+  getApiPort,
+  getDashboardBaseUrl,
+  ensureMissionControlDeps,
+  startMissionControlUi,
+};

package/backend/lib/timeline.js

@@ -0,0 +1,101 @@
+function normalizeTs(value) {
+  if (value == null || value === '') return null;
+
+  if (typeof value === 'number' && Number.isFinite(value)) {
+    const date = new Date(value);
+    return Number.isNaN(date.getTime()) ? null : date.toISOString();
+  }
+
+  const str = String(value).trim();
+  if (!str) return null;
+
+  const parsed = Date.parse(str);
+  if (!Number.isNaN(parsed)) return new Date(parsed).toISOString();
+
+  return null;
+}
+
+const KIND_ORDER = {
+  message: 0,
+  code_edit: 1,
+  artifact: 2,
+  checkpoint: 3,
+};
+
+const REDACTED_RE = /\[REDACTED\]/i;
+
+function isRedactedContent(text) {
+  if (text == null) return false;
+  const s = String(text).trim();
+  if (!s) return false;
+  if (s === '[REDACTED]') return true;
+  if (/^\[REDACTED\]\s*$/.test(s)) return true;
+  const stripped = s.replace(/\[REDACTED\]/gi, '').trim();
+  if (!stripped && REDACTED_RE.test(s)) return true;
+  return false;
+}
+
+function shouldSkipEvent(event) {
+  if (!event) return true;
+  if (event.kind === 'message' && isRedactedContent(event.content)) return true;
+  if (event.kind === 'artifact' && isRedactedContent(event.content)) return true;
+  return false;
+}
+
+function compareEvents(a, b) {
+  const ta = Date.parse(a.ts || '') || 0;
+  const tb = Date.parse(b.ts || '') || 0;
+  if (ta !== tb) return ta - tb;
+
+  const ka = KIND_ORDER[a.kind] ?? 9;
+  const kb = KIND_ORDER[b.kind] ?? 9;
+  if (ka !== kb) return ka - kb;
+
+  if (a.role === 'user' && b.role !== 'user') return -1;
+  if (a.role !== 'user' && b.role === 'user') return 1;
+
+  return String(a.source || '').localeCompare(String(b.source || ''));
+}
+
+function buildGlobalTimeline(agentsMemory = {}) {
+  const merged = [];
+
+  for (const [agentName, agentData] of Object.entries(agentsMemory || {})) {
+    if (!agentData || agentData.status !== 'connected') continue;
+
+    for (const event of agentData.events || []) {
+      if (shouldSkipEvent(event)) continue;
+      merged.push({
+        ...event,
+        source: event.source || agentName,
+        ts: normalizeTs(event.ts) || event.ts || null,
+        kind: event.kind || (event.role ? 'message' : 'message'),
+      });
+    }
+  }
+
+  merged.sort(compareEvents);
+  return merged;
+}
+
+function makeUnifiedDiff(oldStr, newStr, filePath) {
+  const oldLines = String(oldStr ?? '').split('\n');
+  const newLines = String(newStr ?? '').split('\n');
+  const header = `--- a/${filePath || 'file'}\n+++ b/${filePath || 'file'}`;
+  const body = [
+    `@@ -1,${oldLines.length} +1,${newLines.length} @@`,
+    ...oldLines.map(line => `-${line}`),
+    ...newLines.map(line => `+${line}`),
+  ];
+  return `${header}\n${body.join('\n')}`;
+}
+
+module.exports = {
+  normalizeTs,
+  compareEvents,
+  buildGlobalTimeline,
+  makeUnifiedDiff,
+  isRedactedContent,
+  shouldSkipEvent,
+  KIND_ORDER,
+};