relay-os 0.1.0

package/mission-control/src/components/WorkspaceRail.tsx

@@ -0,0 +1,56 @@
+'use client';
+
+import React, { useEffect, useState } from 'react';
+import { useRouter } from 'next/navigation';
+import { useRelay } from '@/lib/RelayContext';
+import styles from './WorkspaceRail.module.css';
+
+export default function WorkspaceRail() {
+  const [isExpanded, setIsExpanded] = useState(false);
+  const router = useRouter();
+  const { workspaces, selectWorkspace } = useRelay();
+
+  useEffect(() => {
+    setIsExpanded(localStorage.getItem('relay_rail_expanded') === '1');
+  }, []);
+
+  const toggle = () => {
+    setIsExpanded((prev) => {
+      const next = !prev;
+      localStorage.setItem('relay_rail_expanded', next ? '1' : '0');
+      return next;
+    });
+  };
+
+  return (
+    <nav className={`${styles.rail} ${isExpanded ? styles.expanded : ''}`}>
+      <div className={styles.topSection}>
+        <div className={styles.itemWrapper} onClick={toggle} title={isExpanded ? 'Collapse' : 'Expand'}>
+          <div className={styles.actionIcon}>{isExpanded ? '«' : '☰'}</div>
+          {isExpanded && <span className={styles.itemText}>Collapse</span>}
+        </div>
+
+        {isExpanded && <div className={styles.sectionTitle}>WORKSPACES</div>}
+
+        {workspaces.map((ws) => (
+          <div
+            key={ws.id}
+            className={`${styles.itemWrapper} ${ws.active ? styles.activeWrapper : ''}`}
+            onClick={() => selectWorkspace(ws.id)}
+            title={ws.localPath}
+          >
+            <div className={`${styles.workspaceIcon} ${ws.active ? styles.active : ''}`}>
+              {ws.name}
+            </div>
+            {isExpanded && <span className={styles.itemText}>{ws.full}</span>}
+          </div>
+        ))}
+
+        <div className={styles.itemWrapper} onClick={() => router.push('/onboarding')}>
+          <div className={styles.addWorkspace}>+</div>
+          {isExpanded && <span className={styles.itemText}>Add Workspace</span>}
+        </div>
+      </div>
+    </nav>
+  );
+}

package/mission-control/src/lib/RelayContext.tsx

@@ -0,0 +1,314 @@
+'use client';
+
+import React, {
+  createContext,
+  useCallback,
+  useContext,
+  useEffect,
+  useMemo,
+  useRef,
+  useState,
+} from 'react';
+import {
+  AGENTS,
+  AgentId,
+  RelayDashboard,
+  RelayDashboardIr,
+  RelayMemory,
+  RelayProject,
+  connectAgent as apiConnect,
+  getMemory,
+  getProject,
+  getProjectDashboard,
+  listProjects,
+  pingRelay,
+  registerWorkspace,
+  sendHandshake,
+  syncProject,
+  syncWorkspace,
+} from './relay';
+import {
+  Workspace,
+  WORKSPACES_CHANGED_EVENT,
+  badgeFromName,
+  getActiveWorkspace,
+  loadWorkspaces,
+  saveWorkspaces,
+} from './workspaces';
+
+export type AgentStatus = 'idle' | 'handshaking' | 'connected' | 'error';
+
+export interface AgentState {
+  id: AgentId;
+  status: AgentStatus;
+  eventCount: number;
+  error?: string;
+}
+
+interface RelayContextValue {
+  workspaces: Workspace[];
+  activeWorkspace: Workspace | null;
+  activeProject: RelayProject | null;
+  relayOnline: boolean;
+  memory: RelayMemory | null;
+  dashboard: RelayDashboard | null;
+  agentStates: AgentState[];
+  syncing: boolean;
+  addWorkspace: (ws: Omit<Workspace, 'active'>) => void;
+  selectWorkspace: (id: string) => void;
+  removeWorkspace: (id: string) => void;
+  registerAndAdd: (ws: Omit<Workspace, 'active'>) => Promise<void>;
+  connect: (agent: AgentId) => Promise<void>;
+  refresh: (opts?: { full?: boolean }) => Promise<void>;
+}
+
+const RelayContext = createContext<RelayContextValue | null>(null);
+
+const sleep = (ms: number) => new Promise((r) => setTimeout(r, ms));
+
+function memoryFingerprint(mem: RelayMemory | null): string {
+  if (!mem) return '';
+  return `${mem.lastSync || ''}:${mem.timeline?.length || 0}`;
+}
+
+function dashboardFingerprint(d: RelayDashboard | null): string {
+  if (!d) return '';
+  const ir = d.ir || ({} as RelayDashboardIr);
+  return [
+    d.lastSync || '',
+    d.handoff?.markdown?.length || 0,
+    ir.currentTask?.length || 0,
+    ir.decisions?.length || 0,
+    ir.failures?.length || 0,
+    ir.project?.length || 0,
+  ].join(':');
+}
+
+export function RelayProvider({ children }: { children: React.ReactNode }) {
+  const [workspaces, setWorkspaces] = useState<Workspace[]>([]);
+  const [relayOnline, setRelayOnline] = useState(false);
+  const [memory, setMemory] = useState<RelayMemory | null>(null);
+  const [dashboard, setDashboard] = useState<RelayDashboard | null>(null);
+  const [activeProject, setActiveProject] = useState<RelayProject | null>(null);
+  const [syncing, setSyncing] = useState(false);
+  const [pending, setPending] = useState<
+    Partial<Record<AgentId, { status: 'handshaking' | 'error'; error?: string }>>
+  >({});
+
+  const activeWorkspace = useMemo(() => getActiveWorkspace(workspaces), [workspaces]);
+  const activePath = activeWorkspace?.localPath || null;
+  const projectId = activeWorkspace?.relayProjectId || activeProject?.id || null;
+
+  const lastMemFp = useRef('');
+  const lastDashFp = useRef('');
+
+  useEffect(() => {
+    const loaded = loadWorkspaces();
+    setWorkspaces(loaded);
+    saveWorkspaces(loaded);
+    const reload = () => setWorkspaces(loadWorkspaces());
+    window.addEventListener('storage', reload);
+    window.addEventListener(WORKSPACES_CHANGED_EVENT, reload);
+    return () => {
+      window.removeEventListener('storage', reload);
+      window.removeEventListener(WORKSPACES_CHANGED_EVENT, reload);
+    };
+  }, []);
+
+  useEffect(() => {
+    let alive = true;
+    const check = async () => {
+      const ok = await pingRelay();
+      if (alive) setRelayOnline(ok);
+    };
+    check();
+    const t = setInterval(check, 10000);
+    return () => {
+      alive = false;
+      clearInterval(t);
+    };
+  }, []);
+
+  const resolveProject = useCallback(async (path: string) => {
+    try {
+      const { projects } = await listProjects();
+      return projects.find((p) => p.workspacePath === path) || null;
+    } catch {
+      return null;
+    }
+  }, []);
+
+  const refresh = useCallback(
+    async (opts: { full?: boolean } = {}) => {
+      if (!activePath) return;
+      setSyncing(true);
+      try {
+        let project = activeProject;
+        if (!project) {
+          project = await resolveProject(activePath);
+          if (project) setActiveProject(project);
+        }
+
+        if (opts.full) {
+          if (project?.id) await syncProject(project.id);
+          else await syncWorkspace(activePath);
+        }
+
+        if (project?.id) {
+          const { dashboard: d } = await getProjectDashboard(project.id, { limit: 200 });
+          const { project: fullProject } = await getProject(project.id);
+          setActiveProject(fullProject);
+          const fp = dashboardFingerprint(d);
+          if (fp !== lastDashFp.current) {
+            lastDashFp.current = fp;
+            setDashboard(d);
+          }
+        }
+
+        const mem = await getMemory(activePath);
+        const memFp = memoryFingerprint(mem);
+        if (memFp !== lastMemFp.current) {
+          lastMemFp.current = memFp;
+          setMemory(mem);
+        }
+      } catch {
+        /* keep last state — no flash to empty */
+      } finally {
+        setSyncing(false);
+      }
+    },
+    [activePath, activeProject, resolveProject],
+  );
+
+  const refreshRef = useRef(refresh);
+  refreshRef.current = refresh;
+
+  useEffect(() => {
+    setPending({});
+    if (!activePath) {
+      setMemory(null);
+      setDashboard(null);
+      setActiveProject(null);
+      lastMemFp.current = '';
+      lastDashFp.current = '';
+      return;
+    }
+
+    let cancelled = false;
+    (async () => {
+      const project = await resolveProject(activePath);
+      if (cancelled) return;
+      if (project) setActiveProject(project);
+      lastMemFp.current = '';
+      lastDashFp.current = '';
+      await refreshRef.current({ full: true });
+    })();
+
+    const t = setInterval(() => refreshRef.current({ full: false }), 12000);
+    return () => {
+      cancelled = true;
+      clearInterval(t);
+    };
+  }, [activePath, resolveProject]);
+
+  const addWorkspace = useCallback((ws: Omit<Workspace, 'active'>) => {
+    setWorkspaces((prev) => {
+      const others = prev.filter((w) => w.id !== ws.id).map((w) => ({ ...w, active: false }));
+      const next = [...others, { ...ws, active: true }];
+      saveWorkspaces(next);
+      return next;
+    });
+  }, []);
+
+  const registerAndAdd = useCallback(
+    async (ws: Omit<Workspace, 'active'>) => {
+      const { project } = await registerWorkspace(ws.localPath, ws.full);
+      addWorkspace({
+        ...ws,
+        relayProjectId: project.id,
+        name: badgeFromName(project.name || ws.full),
+        full: project.name || ws.full,
+      });
+    },
+    [addWorkspace],
+  );
+
+  const selectWorkspace = useCallback((id: string) => {
+    setWorkspaces((prev) => {
+      const next = prev.map((w) => ({ ...w, active: w.id === id }));
+      saveWorkspaces(next);
+      return next;
+    });
+  }, []);
+
+  const removeWorkspace = useCallback((id: string) => {
+    setWorkspaces((prev) => {
+      const remaining = prev.filter((w) => w.id !== id);
+      if (remaining.length && !remaining.some((w) => w.active)) remaining[0].active = true;
+      saveWorkspaces(remaining);
+      return remaining;
+    });
+  }, []);
+
+  const connect = useCallback(
+    async (agent: AgentId) => {
+      if (!activePath) throw new Error('Select a workspace first.');
+      setPending((p) => ({ ...p, [agent]: { status: 'handshaking' } }));
+      try {
+        await sendHandshake(activePath, agent, projectId || undefined);
+        await sleep(2000);
+        await apiConnect(activePath, agent, projectId || undefined);
+        setPending((p) => {
+          const next = { ...p };
+          delete next[agent];
+          return next;
+        });
+        await refresh({ full: true });
+      } catch (err) {
+        const message = err instanceof Error ? err.message : 'Connection failed';
+        setPending((p) => ({ ...p, [agent]: { status: 'error', error: message } }));
+        throw err;
+      }
+    },
+    [activePath, projectId, refresh],
+  );
+
+  const agentStates = useMemo<AgentState[]>(() => {
+    return AGENTS.map(({ id }) => {
+      const p = pending[id];
+      const mem = memory?.agents?.[id];
+      const dashAgent = dashboard?.agents?.find((a) => a.name === id);
+      const eventCount = mem?.eventCount ?? dashAgent?.eventCount ?? 0;
+      if (p) return { id, status: p.status, eventCount, error: p.error };
+      if (mem?.status === 'connected' || dashAgent?.status === 'connected') {
+        return { id, status: 'connected', eventCount };
+      }
+      return { id, status: 'idle', eventCount: 0 };
+    });
+  }, [pending, memory, dashboard]);
+
+  const value: RelayContextValue = {
+    workspaces,
+    activeWorkspace,
+    activeProject,
+    relayOnline,
+    memory,
+    dashboard,
+    agentStates,
+    syncing,
+    addWorkspace,
+    selectWorkspace,
+    removeWorkspace,
+    registerAndAdd,
+    connect,
+    refresh,
+  };
+
+  return <RelayContext.Provider value={value}>{children}</RelayContext.Provider>;
+}
+
+export function useRelay(): RelayContextValue {
+  const ctx = useContext(RelayContext);
+  if (!ctx) throw new Error('useRelay must be used within <RelayProvider>');
+  return ctx;
+}

package/mission-control/src/lib/relay.ts

@@ -0,0 +1,280 @@
+// Typed client for the Relay companion backend (backend/server.js).
+
+export const RELAY_URL =
+  process.env.NEXT_PUBLIC_RELAY_URL || 'http://localhost:3001';
+
+export type AgentId =
+  | 'Antigravity'
+  | 'Codex'
+  | 'Claude Code'
+  | 'GitHub Copilot'
+  | 'Cursor';
+
+export interface AgentMeta {
+  id: AgentId;
+  label: string;
+  logo: string;
+  desc: string;
+  accent: string;
+}
+
+export const AGENTS: AgentMeta[] = [
+  { id: 'Claude Code', label: 'Claude', logo: '/logos/Claude.png', desc: 'Anthropic Claude Code CLI', accent: '#fcd34d' },
+  { id: 'Codex', label: 'Codex', logo: '/logos/Codex.png', desc: 'OpenAI Codex CLI', accent: '#6ee7b7' },
+  { id: 'GitHub Copilot', label: 'Copilot', logo: '/logos/github-copilot.png', desc: 'GitHub Copilot sessions', accent: '#93c5fd' },
+  { id: 'Cursor', label: 'Cursor', logo: '/logos/cursor.png', desc: 'Cursor agent transcripts', accent: '#f9a8d4' },
+  { id: 'Antigravity', label: 'Antigravity', logo: '/logos/antigravity.png', desc: 'Antigravity IDE agent', accent: '#a5b4fc' },
+];
+
+export const AGENT_BY_ID = Object.fromEntries(AGENTS.map((a) => [a.id, a])) as Record<AgentId, AgentMeta>;
+
+export type EventKind = 'message' | 'code_edit' | 'artifact';
+
+export interface RelayEvent {
+  source?: string;
+  role?: 'user' | 'assistant' | string;
+  kind?: EventKind;
+  content?: string;
+  file?: string;
+  path?: string;
+  summary?: string;
+  diff?: string;
+  ts?: string;
+}
+
+export interface RelayArtifact {
+  name: string;
+  content: string;
+  metadata?: string;
+  source?: string;
+}
+
+export interface RelayTask {
+  id: string;
+  preview: string;
+  source?: string;
+}
+
+export interface RelayMessage {
+  type?: string;
+  payload?: unknown;
+  source?: string;
+}
+
+export interface RelayAgentMemory {
+  status: 'connected' | 'handshaking' | 'idle' | 'error';
+  transcriptPath?: string;
+  eventCount?: number;
+  events?: RelayEvent[];
+  artifacts?: RelayArtifact[];
+  tasks?: RelayTask[];
+  messages?: RelayMessage[];
+}
+
+export interface RelayMemory {
+  workspace: string;
+  lastSync: string | null;
+  agents: Partial<Record<AgentId, RelayAgentMemory>>;
+  timeline: RelayEvent[];
+}
+
+export interface RelayProjectStats {
+  totalEvents: number;
+  lastSync: string | null;
+  connectedAgents: number;
+}
+
+export interface RelayProject {
+  id: string;
+  name: string;
+  workspacePath: string;
+  apiKey?: string;
+  createdAt?: string;
+  updatedAt?: string;
+  stats?: RelayProjectStats;
+}
+
+export interface RelayDashboardIr {
+  project: string;
+  currentTask: string;
+  decisions: string;
+  failures: string;
+  architecture: string;
+  compileBrief: string;
+}
+
+export interface RelayDashboard {
+  workspace: string;
+  lastSync: string | null;
+  stats: {
+    totalEvents: number;
+    byKind: Record<string, number>;
+    bySource: Record<string, number>;
+    connectedAgents: number;
+  };
+  agents: { name: string; status: string; eventCount: number; transcriptPath?: string | null }[];
+  handoff: { markdown: string; updatedAt?: string | null };
+  ir: RelayDashboardIr;
+  recentEdits: RelayEvent[];
+  activity: { total: number; offset: number; limit: number; events: RelayEvent[] };
+}
+
+export interface MissionChatMessage {
+  id: string;
+  author: string;
+  agent?: AgentId | null;
+  mentions?: AgentId[];
+  role: 'user' | 'system';
+  text: string;
+  ts: string;
+}
+
+export interface MissionMeta {
+  version: number;
+  collaborators: string[];
+  chat: MissionChatMessage[];
+  updatedAt?: string;
+}
+
+async function relayFetch<T>(path: string, init?: RequestInit): Promise<T> {
+  let res: Response;
+  try {
+    res = await fetch(`${RELAY_URL}${path}`, {
+      ...init,
+      headers: { 'Content-Type': 'application/json', ...(init?.headers || {}) },
+    });
+  } catch {
+    throw new Error(`Relay backend offline at ${RELAY_URL}. Start it with: relay serve`);
+  }
+  let data: Record<string, unknown> = {};
+  try {
+    data = await res.json();
+  } catch {
+    /* non-JSON */
+  }
+  if (!res.ok || data.ok === false) {
+    throw new Error((data.error as string) || `Relay request failed (${res.status})`);
+  }
+  return data as T;
+}
+
+export function listProjects() {
+  return relayFetch<{ ok: true; projects: RelayProject[] }>('/api/projects');
+}
+
+export function createProject(workspacePath: string, name?: string) {
+  return relayFetch<{ ok: true; project: RelayProject }>('/api/projects', {
+    method: 'POST',
+    body: JSON.stringify({ workspacePath, name }),
+  });
+}
+
+export function getProject(projectId: string) {
+  return relayFetch<{ ok: true; project: RelayProject }>(`/api/projects/${projectId}`);
+}
+
+export function updateProjectName(projectId: string, name: string) {
+  return relayFetch<{ ok: true; project: RelayProject }>(`/api/projects/${projectId}`, {
+    method: 'PATCH',
+    body: JSON.stringify({ name }),
+  });
+}
+
+export function registerWorkspace(workspacePath: string, name?: string) {
+  return relayFetch<{ ok: true; project: RelayProject }>('/api/register', {
+    method: 'POST',
+    body: JSON.stringify({ workspacePath, name }),
+  });
+}
+
+export function sendHandshake(workspacePath: string, agent: AgentId, projectId?: string) {
+  return relayFetch<{ ok: true; token: string; message: string }>('/api/handshake', {
+    method: 'POST',
+    body: JSON.stringify({ workspacePath, agent, projectId }),
+  });
+}
+
+export function connectAgent(workspacePath: string, agent: AgentId, projectId?: string) {
+  return relayFetch<{ ok: true; transcriptPath: string; eventCount: number; events: RelayEvent[] }>(
+    '/api/connect',
+    { method: 'POST', body: JSON.stringify({ workspacePath, agent, projectId }) },
+  );
+}
+
+export function syncProject(projectId: string) {
+  return relayFetch<{ ok: true; totalEvents: number; timelineCount: number; lastSync: string }>(
+    `/api/projects/${projectId}/sync`,
+    { method: 'POST' },
+  );
+}
+
+export function syncWorkspace(workspacePath: string) {
+  return relayFetch<{ ok: true; totalEvents: number; timelineCount: number; lastSync: string }>(
+    '/api/sync',
+    { method: 'POST', body: JSON.stringify({ workspacePath }) },
+  );
+}
+
+export async function getMemory(workspacePath: string): Promise<RelayMemory> {
+  const data = await relayFetch<{ ok: true; memory: RelayMemory }>(
+    `/api/memory?workspacePath=${encodeURIComponent(workspacePath)}`,
+  );
+  return data.memory;
+}
+
+export async function getProjectDashboard(
+  projectId: string,
+  params: { limit?: number; offset?: number; kind?: string; source?: string; role?: string } = {},
+): Promise<{ project: RelayProject; dashboard: RelayDashboard }> {
+  const q = new URLSearchParams();
+  if (params.limit != null) q.set('limit', String(params.limit));
+  if (params.offset != null) q.set('offset', String(params.offset));
+  if (params.kind) q.set('kind', params.kind);
+  if (params.source) q.set('source', params.source);
+  if (params.role) q.set('role', params.role);
+  const data = await relayFetch<{ ok: true; project: RelayProject; dashboard: RelayDashboard }>(
+    `/api/projects/${projectId}/dashboard?${q}`,
+  );
+  return { project: data.project, dashboard: data.dashboard };
+}
+
+export async function pingRelay(): Promise<boolean> {
+  try {
+    const res = await fetch(`${RELAY_URL}/api/health`);
+    const data = await res.json();
+    return res.ok && data.ok === true;
+  } catch {
+    return false;
+  }
+}
+
+export function getMissionMeta(workspacePath: string) {
+  return relayFetch<{ ok: true; meta: MissionMeta }>(
+    `/api/mission-meta?workspacePath=${encodeURIComponent(workspacePath)}`,
+  );
+}
+
+export function saveMissionMeta(workspacePath: string, meta: Partial<MissionMeta>) {
+  return relayFetch<{ ok: true; meta: MissionMeta }>(
+    `/api/mission-meta?workspacePath=${encodeURIComponent(workspacePath)}`,
+    { method: 'PUT', body: JSON.stringify(meta) },
+  );
+}
+
+export function isRedactedContent(text?: string | null): boolean {
+  if (!text) return false;
+  const s = text.trim();
+  if (s === '[REDACTED]') return true;
+  if (/^\[REDACTED\]\s*$/i.test(s)) return true;
+  const stripped = s.replace(/\[REDACTED\]/gi, '').trim();
+  return !stripped && /\[REDACTED\]/i.test(s);
+}
+
+export function filterTimeline(events: RelayEvent[]): RelayEvent[] {
+  return events.filter((e) => {
+    if (e.kind === 'message' || e.kind === 'artifact') {
+      return !isRedactedContent(e.content);
+    }
+    return true;
+  });
+}

package/mission-control/src/lib/workspaces.ts

@@ -0,0 +1,53 @@
+// Workspace registry in localStorage (single-user, local machine).
+
+export interface Workspace {
+  id: string;
+  name: string;
+  full: string;
+  source: 'local';
+  localPath: string;
+  relayProjectId?: string;
+  active: boolean;
+}
+
+const STORAGE_KEY = 'relay_workspaces';
+export const WORKSPACES_CHANGED_EVENT = 'relay:workspaces-changed';
+
+function isRealWorkspace(w: unknown): w is Workspace {
+  return (
+    !!w &&
+    typeof w === 'object' &&
+    typeof (w as Workspace).localPath === 'string' &&
+    (w as Workspace).localPath.length > 0
+  );
+}
+
+export function loadWorkspaces(): Workspace[] {
+  if (typeof window === 'undefined') return [];
+  try {
+    const raw = localStorage.getItem(STORAGE_KEY);
+    if (!raw) return [];
+    const parsed = JSON.parse(raw);
+    if (!Array.isArray(parsed)) return [];
+    const real = parsed.filter(isRealWorkspace);
+    if (real.length && !real.some((w) => w.active)) real[0].active = true;
+    return real;
+  } catch {
+    return [];
+  }
+}
+
+export function saveWorkspaces(workspaces: Workspace[]) {
+  if (typeof window === 'undefined') return;
+  localStorage.setItem(STORAGE_KEY, JSON.stringify(workspaces));
+  window.dispatchEvent(new CustomEvent(WORKSPACES_CHANGED_EVENT));
+}
+
+export function badgeFromName(full: string): string {
+  const leaf = full.split(/[/\\]/).filter(Boolean).pop() || full;
+  return leaf.slice(0, 2).toUpperCase();
+}
+
+export function getActiveWorkspace(workspaces: Workspace[]): Workspace | null {
+  return workspaces.find((w) => w.active) || null;
+}