@agent-relay/dashboard-server 2.0.83-beta.0 → 2.0.85

package/dist/proxy-server.js

@@ -1,63 +1,113 @@
 /**
  * Relay Dashboard Server
  *
- * A flexible server that can operate in two modes:
- * 1. Proxy mode (default): Proxies API/WebSocket requests to a relay daemon
- * 2. Mock mode: Returns fixture data for standalone testing/demos
- *
- * This allows the dashboard to run independently without any external dependencies.
+ * A flexible server that can operate in three modes:
+ * 1. Proxy mode (default): static files + Relaycast data + broker proxy
+ * 2. Standalone mode: static files + Relaycast data (no broker proxy)
+ * 3. Mock mode: fixture-backed standalone mode for demos/tests
  */
 import express from 'express';
 import { createServer as createHttpServer } from 'http';
-import { createProxyMiddleware } from 'http-proxy-middleware';
-import { WebSocketServer, WebSocket } from 'ws';
+import { WebSocketServer } from 'ws';
+import fs from 'fs';
 import path from 'path';
 import { fileURLToPath } from 'url';
 import { registerMockRoutes } from './mocks/routes.js';
-import { mockAgents, mockMessages, mockSessions, } from './mocks/fixtures.js';
+import { fetchAgents, fetchChannels, loadRelaycastConfig, } from './relaycast-provider.js';
+import { createSendStrategy } from './lib/send-strategy.js';
+import { DASHBOARD_DISPLAY_NAME } from './relaycast-provider-types.js';
+import { resolveIdentity } from './lib/identity.js';
+import { EMPTY_DASHBOARD_SNAPSHOT } from './lib/types.js';
+import { normalizeRelayUrl, normalizeName, isDirectRecipient, sendHtmlFileOrFallback, getBindHost, mapChannelForDashboard, } from './lib/utils.js';
+import { filterPhantomAgents, mergeBrokerSpawnedAgents, createSpawnedAgentsCaches, } from './lib/spawned-agents.js';
+import { handleMockWebSocket } from './websocket/mock.js';
+import { handleStandaloneWebSocket, handleHybridWebSocket } from './websocket/standalone.js';
+import { handleStandaloneLogWebSocket } from './websocket/logs.js';
+import { registerHealthRoutes } from './routes/health.js';
+import { registerDataRoutes } from './routes/data.js';
+import { registerAgentRoutes } from './routes/agents.js';
+import { registerChannelRoutes } from './routes/channels.js';
+import { registerBrokerProxyRoutes } from './routes/broker-proxy.js';
+import { registerMetricsRoutes } from './routes/metrics.js';
+import { registerReactionRoutes } from './routes/reactions.js';
+import { registerThreadReplyRoutes } from './routes/thread-replies.js';
+import { registerRelayConfigRoutes } from './routes/relay-config.js';
+import { registerRelaycastHistoryRoutes } from './routes/history-relaycast.js';
 const __filename = fileURLToPath(import.meta.url);
 const __dirname = path.dirname(__filename);
-/**
- * Get the host to bind to.
- * In cloud environments, bind to '::' (IPv6 any) which also accepts IPv4 on dual-stack.
- * This is required for Fly.io's internal IPv6 network (6PN) connectivity.
- * Locally, let Node.js use its default behavior.
- */
-function getBindHost() {
-    // Explicit override via env var
-    if (process.env.BIND_HOST) {
-        return process.env.BIND_HOST;
+function resolveMetricsPagePath(staticDir) {
+    const candidates = [
+        path.join(staticDir, 'metrics.html'),
+        path.join(staticDir, 'metrics', 'index.html'),
+        path.join(staticDir, 'app.html'),
+        path.join(staticDir, 'index.html'),
+    ];
+    for (const candidate of candidates) {
+        if (fs.existsSync(candidate)) {
+            return candidate;
+        }
     }
-    // Cloud environment detection - bind to :: for IPv6 + IPv4 dual-stack
-    // Fly.io internal network uses IPv6 (fdaa:...), so 0.0.0.0 won't work
-    const isCloudEnvironment = process.env.FLY_APP_NAME || // Fly.io
-        process.env.WORKSPACE_ID || // Agent Relay workspace
-        process.env.RELAY_WORKSPACE_ID || // Alternative workspace ID
-        process.env.RUNNING_IN_DOCKER === 'true'; // Docker container
-    return isCloudEnvironment ? '::' : undefined;
+    return candidates[0];
 }
+const asString = (value) => {
+    if (typeof value === 'string' && value.length > 0)
+        return value;
+    if (Array.isArray(value)) {
+        for (const item of value) {
+            if (typeof item === 'string' && item.length > 0)
+                return item;
+        }
+    }
+    return undefined;
+};
+const getWorkspaceHeader = (headers) => {
+    if (!headers)
+        return undefined;
+    const direct = headers['x-workspace-id'];
+    if (typeof direct === 'string' && direct.length > 0)
+        return direct;
+    for (const [key, value] of Object.entries(headers)) {
+        if (key.toLowerCase() === 'x-workspace-id' && typeof value === 'string' && value.length > 0) {
+            return value;
+        }
+    }
+    return undefined;
+};
 /**
  * Create the dashboard server without starting it
  */
 export function createServer(options = {}) {
-    const { port = parseInt(process.env.PORT || '3888', 10), relayUrl = process.env.RELAY_URL || 'http://localhost:3889', staticDir = process.env.STATIC_DIR || path.join(__dirname, '..', 'out'), verbose = process.env.VERBOSE === 'true', mock = process.env.MOCK === 'true', corsOrigins = process.env.CORS_ORIGINS || '', requestTimeout = parseInt(process.env.REQUEST_TIMEOUT || '30000', 10), } = options;
+    const { relayUrl: relayUrlOption, staticDir = process.env.STATIC_DIR || path.join(__dirname, '..', 'out'), dataDir = process.env.DATA_DIR || path.join(process.cwd(), '.agent-relay'), verbose = process.env.VERBOSE === 'true', mock = process.env.MOCK === 'true', corsOrigins = process.env.CORS_ORIGINS || '', requestTimeout = parseInt(process.env.REQUEST_TIMEOUT || '60000', 10), relayApiKey: relayApiKeyOption, } = options;
+    // In-memory API key — highest priority, avoids any file I/O.
+    // Seeded from the option or RELAY_API_KEY env var, then updated dynamically
+    // via setRelayApiKey() when a workflow creates a new Relaycast workspace.
+    let inMemoryRelayApiKey = relayApiKeyOption?.trim() || process.env.RELAY_API_KEY?.trim() || undefined;
+    const resolvedDataDir = path.resolve(dataDir);
+    if (!process.env.AGENT_RELAY_PROJECT) {
+        process.env.AGENT_RELAY_PROJECT = path.dirname(resolvedDataDir);
+    }
+    const relayUrl = normalizeRelayUrl(relayUrlOption ?? process.env.RELAY_URL);
+    const mode = mock ? 'mock' : (relayUrl ? 'proxy' : 'standalone');
+    const brokerProxyEnabled = mode === 'proxy' && Boolean(relayUrl);
+    const defaultWorkspaceId = process.env.RELAY_WORKSPACE_ID ?? process.env.AGENT_RELAY_WORKSPACE_ID;
+    const resolveWorkspaceId = (req) => {
+        const fromQuery = asString(req.query?.workspaceId);
+        const fromBody = asString(req.body?.workspaceId);
+        const fromHeader = getWorkspaceHeader(req.headers);
+        return fromQuery || fromBody || fromHeader || defaultWorkspaceId;
+    };
     const app = express();
     const server = createHttpServer(app);
-    const mode = mock ? 'mock' : 'proxy';
-    // Set request timeout
     server.timeout = requestTimeout;
-    // Parse JSON bodies
     app.use(express.json({ limit: '10mb' }));
-    // CORS middleware - configurable for cross-origin deployments
     if (corsOrigins) {
         app.use((req, res, next) => {
             const origin = req.headers.origin;
-            // Check if origin is allowed
             if (corsOrigins === '*') {
                 res.header('Access-Control-Allow-Origin', '*');
             }
             else if (origin) {
-                const allowedOrigins = corsOrigins.split(',').map(o => o.trim());
+                const allowedOrigins = corsOrigins.split(',').map((value) => value.trim());
                 if (allowedOrigins.includes(origin)) {
                     res.header('Access-Control-Allow-Origin', origin);
                 }
@@ -66,7 +116,6 @@ export function createServer(options = {}) {
             res.header('Access-Control-Allow-Headers', 'Content-Type, Authorization, X-CSRF-Token');
             res.header('Access-Control-Allow-Credentials', 'true');
             res.header('Access-Control-Expose-Headers', 'X-CSRF-Token');
-            // Handle preflight requests
             if (req.method === 'OPTIONS') {
                 res.sendStatus(204);
                 return;
@@ -74,99 +123,268 @@ export function createServer(options = {}) {
             next();
         });
     }
-    // Logging middleware
     if (verbose) {
         app.use((req, _res, next) => {
             console.log(`[dashboard] ${req.method} ${req.url}`);
             next();
         });
     }
-    // Health check endpoint (always local)
-    app.get('/health', (_req, res) => {
-        res.json({
-            status: 'ok',
-            service: 'relay-dashboard',
-            mode,
-            uptime: process.uptime(),
-        });
-    });
-    // Keep-alive endpoint
-    app.get('/keep-alive', (_req, res) => {
-        res.json({ ok: true });
+    // --- Build shared context ---
+    const resolveRelaycastConfig = () => {
+        // In-memory key (from option, env var, or dynamic update) takes priority over the file.
+        if (inMemoryRelayApiKey) {
+            const baseUrl = process.env.RELAYCAST_API_URL || 'https://api.relaycast.dev';
+            const projectDir = path.basename(path.resolve(dataDir, '..'));
+            return { apiKey: inMemoryRelayApiKey, baseUrl, projectIdentity: projectDir };
+        }
+        return loadRelaycastConfig(dataDir);
+    };
+    const setRelayApiKey = (apiKey) => {
+        inMemoryRelayApiKey = apiKey.trim();
+    };
+    const { getSpawnedAgents, getLocalAgentNames } = createSpawnedAgentsCaches({
+        brokerProxyEnabled,
+        relayUrl,
+        dataDir,
+        verbose,
     });
+    const getRelaycastSnapshot = async () => {
+        const config = resolveRelaycastConfig();
+        if (!config) {
+            return { ...EMPTY_DASHBOARD_SNAPSHOT };
+        }
+        const [agents, spawnedAgents, localAgentNames] = await Promise.all([
+            fetchAgents(config),
+            brokerProxyEnabled ? getSpawnedAgents() : Promise.resolve({ names: null, agents: null }),
+            brokerProxyEnabled ? Promise.resolve(null) : Promise.resolve(getLocalAgentNames()),
+        ]);
+        const filteredAgents = filterPhantomAgents(agents, spawnedAgents.names, localAgentNames);
+        const mergedAgents = mergeBrokerSpawnedAgents(filteredAgents, spawnedAgents.agents);
+        return {
+            agents: mergedAgents,
+            users: [],
+            messages: [],
+            activity: [],
+            sessions: [],
+            summaries: [],
+        };
+    };
+    const getRelaycastChannels = async () => {
+        const config = resolveRelaycastConfig();
+        if (!config) {
+            return { channels: [], archivedChannels: [] };
+        }
+        const channels = await fetchChannels(config);
+        const activeChannels = [];
+        const archivedChannels = [];
+        for (const channel of channels) {
+            const mapped = mapChannelForDashboard({ ...channel, is_archived: channel.is_archived ?? false });
+            if (mapped.status === 'archived') {
+                archivedChannels.push(mapped);
+            }
+            else {
+                activeChannels.push(mapped);
+            }
+        }
+        activeChannels.sort((a, b) => a.name.localeCompare(b.name));
+        archivedChannels.sort((a, b) => a.name.localeCompare(b.name));
+        return { channels: activeChannels, archivedChannels };
+    };
+    const sendRelaycastMessage = async (params) => {
+        const sendTimeout = Math.max(requestTimeout - 5000, 10000);
+        const sendStart = Date.now();
+        const timeoutPromise = new Promise((_, reject) => setTimeout(() => reject(new Error('Send timed out')), sendTimeout));
+        try {
+            return await Promise.race([
+                (async () => {
+                    const config = resolveRelaycastConfig();
+                    const rawTarget = params.to.trim();
+                    const message = params.message.trim();
+                    let resolvedTarget = rawTarget;
+                    if (isDirectRecipient(rawTarget) && config) {
+                        const relayAgents = await fetchAgents(config);
+                        const relayMatch = relayAgents.find((agent) => normalizeName(agent.name) === normalizeName(rawTarget));
+                        if (relayMatch) {
+                            resolvedTarget = relayMatch.name;
+                        }
+                    }
+                    const projectIdentity = config?.agentName?.trim()
+                        || path.basename(path.resolve(dataDir, '..'))
+                        || DASHBOARD_DISPLAY_NAME;
+                    const senderInput = params.from?.trim() ?? '';
+                    const senderName = mode === 'proxy'
+                        ? resolveIdentity(senderInput || projectIdentity, {
+                            projectIdentity: projectIdentity.trim(),
+                            relayAgentName: config?.agentName?.trim(),
+                        })
+                        : (senderInput || projectIdentity);
+                    const strategy = createSendStrategy({
+                        brokerProxyEnabled,
+                        brokerUrl: relayUrl,
+                        relaycastConfig: config,
+                        dataDir,
+                    });
+                    if (!strategy) {
+                        return {
+                            success: false,
+                            status: 503,
+                            error: `Relaycast credentials not found in ${path.join(dataDir, 'relaycast.json')}`,
+                        };
+                    }
+                    console.log(`[dashboard] /api/send request: to=${resolvedTarget}, from=${senderName}, relayUrl=${relayUrl}, timeoutMs=${sendTimeout}`);
+                    const outcome = await strategy.send({
+                        to: resolvedTarget,
+                        message,
+                        from: senderName,
+                        thread: params.thread,
+                    });
+                    console.log(`[dashboard] /api/send completed in ${Date.now() - sendStart}ms with status=${outcome.success ? 200 : outcome.status}`);
+                    // Enrich "agent not found" errors with available agent names
+                    if (!outcome.success && isDirectRecipient(params.to) && config) {
+                        if (/agent\s+\".+\"\s+not\s+found/i.test(outcome.error)) {
+                            const relayAgents = await fetchAgents(config);
+                            const available = relayAgents.map((agent) => agent.name).sort();
+                            const suffix = available.length > 0
+                                ? ` Available relay agents: ${available.join(', ')}.`
+                                : ' No relay agents are currently online.';
+                            return {
+                                success: false,
+                                status: 404,
+                                error: `${outcome.error}.${suffix}`,
+                            };
+                        }
+                    }
+                    return outcome;
+                })(),
+                timeoutPromise,
+            ]);
+        }
+        catch (err) {
+            console.error(`[dashboard] /api/send failed after ${Date.now() - sendStart}ms: ${err.message}`);
+            return {
+                success: false,
+                status: 504,
+                error: err.message || 'Send request timed out',
+            };
+        }
+    };
+    const ctx = {
+        mode,
+        dataDir,
+        staticDir,
+        verbose,
+        relayUrl,
+        brokerProxyEnabled,
+        resolveRelaycastConfig,
+        setRelayApiKey,
+        getRelaycastSnapshot,
+        getRelaycastChannels,
+        sendRelaycastMessage,
+        getSpawnedAgents,
+        getLocalAgentNames,
+        filterPhantomAgents,
+    };
+    // --- Register routes ---
+    registerHealthRoutes(app, ctx);
     if (mock) {
-        // ===== MOCK MODE =====
-        // Register mock API routes for standalone operation
-        console.log('[dashboard] Running in MOCK mode - no relay daemon required');
+        console.log('[dashboard] Running in MOCK mode - no relay broker required');
         registerMockRoutes(app, verbose);
     }
     else {
-        // ===== PROXY MODE =====
-        // Proxy all API requests to the relay daemon
-        console.log(`[dashboard] Running in PROXY mode - forwarding to ${relayUrl}`);
-        const apiProxyOptions = {
-            target: relayUrl,
-            changeOrigin: true,
-            ws: false, // WebSocket handled separately
-            logger: verbose ? console : undefined,
-            on: {
-                error: (err, _req, res) => {
-                    console.error('[dashboard] API proxy error:', err.message);
-                    if (res && 'writeHead' in res && typeof res.writeHead === 'function') {
-                        res.writeHead(502, { 'Content-Type': 'application/json' });
-                        res.end(JSON.stringify({
-                            error: 'Relay daemon unavailable',
-                            message: err.message,
-                        }));
-                    }
-                },
-            },
-        };
-        app.use('/api', createProxyMiddleware(apiProxyOptions));
-        app.use('/auth', createProxyMiddleware(apiProxyOptions));
-        app.use('/metrics', createProxyMiddleware(apiProxyOptions));
+        if (mode === 'proxy' && relayUrl) {
+            console.log(`[dashboard] Running in PROXY mode - relaycast + broker proxy (${relayUrl})`);
+        }
+        else {
+            console.log('[dashboard] Running in STANDALONE mode - relaycast only (read-only broker surface)');
+        }
+        registerAgentRoutes(app, ctx);
+        registerDataRoutes(app, ctx);
+        registerRelayConfigRoutes(app, ctx);
+        registerChannelRoutes(app, ctx);
+        registerReactionRoutes(app, ctx);
+        registerThreadReplyRoutes(app, ctx);
+        registerMetricsRoutes(app, {
+            teamDir: path.join(dataDir, 'team'),
+            resolveWorkspaceId,
+        });
+        registerRelaycastHistoryRoutes(app, ctx);
+        registerBrokerProxyRoutes(app, ctx);
     }
-    // Serve static files
+    // --- Static files and SPA fallback ---
+    const fallbackHtml = `<!doctype html>
+<html lang="en">
+<head>
+  <meta charset="utf-8" />
+  <meta name="viewport" content="width=device-width, initial-scale=1" />
+  <title>Relay Dashboard</title>
+</head>
+<body>
+  <h1>Relay Dashboard</h1>
+  <p>Dashboard static build not found.</p>
+</body>
+</html>`;
+    app.get('/metrics', (_req, res) => {
+        const metricsPath = resolveMetricsPagePath(staticDir);
+        sendHtmlFileOrFallback(res, metricsPath, fallbackHtml, 200);
+    });
+    app.get('/app', (_req, res) => {
+        const appHtmlPath = path.join(staticDir, 'app.html');
+        sendHtmlFileOrFallback(res, appHtmlPath, fallbackHtml, 200);
+    });
+    app.get('/app/{*path}', (_req, res) => {
+        const appHtmlPath = path.join(staticDir, 'app.html');
+        sendHtmlFileOrFallback(res, appHtmlPath, fallbackHtml, 200);
+    });
     app.use(express.static(staticDir, {
         extensions: ['html'],
     }));
-    // SPA fallback - serve appropriate HTML file for unmatched routes
-    // Express 5 requires named parameter instead of bare *
+    app.get('/', (_req, res) => {
+        const indexPath = path.join(staticDir, 'index.html');
+        sendHtmlFileOrFallback(res, indexPath, fallbackHtml, 200);
+    });
     app.get('/{*path}', (req, res) => {
-        // Don't serve HTML for API routes or static assets
+        // WebSocket endpoints require upgrade - return 426 for regular HTTP requests
+        if (req.path === '/ws' || req.path.startsWith('/ws/')) {
+            res.status(426).json({ error: 'Upgrade Required', message: 'WebSocket upgrade required' });
+            return;
+        }
         if (req.path.startsWith('/api') || req.path.startsWith('/auth') || req.path.includes('.')) {
             res.status(404).json({ error: 'Not found' });
             return;
         }
-        // For /app/* routes (including /app/channel/*, /app/agent/*, /app/dm/*, /app/settings/*),
-        // serve the app.html which handles client-side routing
         if (req.path.startsWith('/app')) {
-            res.sendFile(path.join(staticDir, 'app.html'));
+            const appHtmlPath = path.join(staticDir, 'app.html');
+            sendHtmlFileOrFallback(res, appHtmlPath, fallbackHtml, 200);
             return;
         }
-        // For other routes, serve index.html
-        res.sendFile(path.join(staticDir, 'index.html'));
+        const indexPath = path.join(staticDir, 'index.html');
+        sendHtmlFileOrFallback(res, indexPath, fallbackHtml, 200);
     });
-    // WebSocket server
+    // --- WebSocket ---
     const wss = new WebSocketServer({ noServer: true });
-    // Handle WebSocket upgrade
     server.on('upgrade', (request, socket, head) => {
         const pathname = request.url ? new URL(request.url, `http://${request.headers.host}`).pathname : '';
         if (pathname === '/ws') {
             wss.handleUpgrade(request, socket, head, (ws) => {
-                if (mock) {
-                    // Mock WebSocket - send periodic updates with fixture data
+                if (mode === 'mock') {
                     handleMockWebSocket(ws, verbose);
                 }
+                else if (mode === 'proxy' && relayUrl) {
+                    handleHybridWebSocket(ws, getRelaycastSnapshot, relayUrl, verbose);
+                }
                 else {
-                    // Proxy WebSocket to relay daemon
-                    handleProxyWebSocket(ws, relayUrl, verbose);
+                    handleStandaloneWebSocket(ws, getRelaycastSnapshot, verbose);
                 }
             });
+            return;
         }
-        else {
-            socket.destroy();
+        if (mode !== 'mock' && (pathname === '/ws/logs' || pathname.startsWith('/ws/logs/'))) {
+            wss.handleUpgrade(request, socket, head, (ws) => {
+                handleStandaloneLogWebSocket(ws, pathname, dataDir, getLocalAgentNames, verbose);
+            });
+            return;
         }
+        socket.destroy();
     });
     const close = () => {
         return new Promise((resolve) => {
@@ -177,113 +395,10 @@ export function createServer(options = {}) {
             });
         });
     };
-    return { app, server, wss, close, mode };
-}
-/**
- * Handle mock WebSocket connections
- * Sends periodic updates with fixture data
- */
-function handleMockWebSocket(ws, verbose) {
-    if (verbose) {
-        console.log('[dashboard] Mock WebSocket client connected');
-    }
-    // Send initial data
-    const sendData = () => {
-        if (ws.readyState === WebSocket.OPEN) {
-            ws.send(JSON.stringify({
-                agents: mockAgents,
-                messages: mockMessages,
-                sessions: mockSessions,
-            }));
-        }
-    };
-    // Send initial data immediately
-    sendData();
-    // Send updates every 5 seconds
-    const interval = setInterval(sendData, 5000);
-    // Handle messages from client
-    ws.on('message', (data) => {
-        try {
-            const msg = JSON.parse(data.toString());
-            if (verbose) {
-                console.log('[dashboard] Mock WS received:', msg);
-            }
-            // Echo back acknowledgment for certain message types
-            if (msg.type === 'ping') {
-                ws.send(JSON.stringify({ type: 'pong' }));
-            }
-            else if (msg.type === 'subscribe') {
-                // Send current data when client subscribes
-                sendData();
-            }
-        }
-        catch {
-            // Ignore parse errors
-        }
-    });
-    ws.on('close', () => {
-        if (verbose) {
-            console.log('[dashboard] Mock WebSocket client disconnected');
-        }
-        clearInterval(interval);
-    });
-    ws.on('error', (err) => {
-        console.error('[dashboard] Mock WebSocket error:', err.message);
-        clearInterval(interval);
-    });
+    return { app, server, wss, close, mode, setRelayApiKey };
 }
 /**
- * Handle proxy WebSocket connections
- * Forwards messages bidirectionally to relay daemon
- */
-function handleProxyWebSocket(ws, relayUrl, verbose) {
-    const relayUrlObj = new URL(relayUrl);
-    const wsRelayUrl = `ws://${relayUrlObj.host}`;
-    // Create connection to relay daemon
-    const relayWs = new WebSocket(`${wsRelayUrl}/ws`);
-    relayWs.on('open', () => {
-        if (verbose) {
-            console.log('[dashboard] WebSocket connected to relay daemon');
-        }
-    });
-    // Forward messages from client to relay
-    ws.on('message', (data) => {
-        if (relayWs.readyState === WebSocket.OPEN) {
-            relayWs.send(data);
-        }
-    });
-    // Forward messages from relay to client
-    relayWs.on('message', (data) => {
-        if (ws.readyState === WebSocket.OPEN) {
-            ws.send(data);
-        }
-    });
-    // Handle client disconnect
-    ws.on('close', () => {
-        if (verbose) {
-            console.log('[dashboard] Client WebSocket closed');
-        }
-        relayWs.close();
-    });
-    // Handle relay disconnect
-    relayWs.on('close', () => {
-        if (verbose) {
-            console.log('[dashboard] Relay WebSocket closed');
-        }
-        ws.close();
-    });
-    // Handle errors
-    ws.on('error', (err) => {
-        console.error('[dashboard] Client WebSocket error:', err.message);
-        relayWs.close();
-    });
-    relayWs.on('error', (err) => {
-        console.error('[dashboard] Relay WebSocket error:', err.message);
-        ws.close();
-    });
-}
-/**
- * Try to listen on a port, returns the port if successful or null if in use
+ * Try to listen on a port, returns the port if successful or null if in use.
  */
 function tryListen(server, port) {
     return new Promise((resolve) => {
@@ -310,7 +425,7 @@ function tryListen(server, port) {
     });
 }
 /**
- * Find an available port starting from the preferred port
+ * Find an available port starting from the preferred port.
  */
 async function findAvailablePort(server, preferredPort, maxAttempts = 10) {
     for (let i = 0; i < maxAttempts; i++) {
@@ -319,19 +434,47 @@ async function findAvailablePort(server, preferredPort, maxAttempts = 10) {
         if (result !== null) {
             return result;
         }
-        // Close and recreate listener for next attempt
         server.close();
     }
     throw new Error(`Could not find available port after ${maxAttempts} attempts starting from ${preferredPort}`);
 }
 /**
- * Start the dashboard server
- * Automatically finds an available port if the preferred port is in use
+ * Bootstrap Relaycast credentials from the broker's authenticated /api/config
+ * endpoint.  The workspace key is on an authenticated route (not /health) so it
+ * is not exposed to unauthenticated callers.
+ */
+async function bootstrapRelayApiKeyFromBroker(relayUrl, setRelayApiKey) {
+    const brokerApiKey = process.env.RELAY_BROKER_API_KEY?.trim();
+    const headers = {};
+    if (brokerApiKey) {
+        headers['x-api-key'] = brokerApiKey;
+    }
+    // Retry a few times to allow the broker to fully start up.
+    for (let attempt = 0; attempt < 5; attempt++) {
+        try {
+            const res = await fetch(`${relayUrl}/api/config`, { headers });
+            if (!res.ok)
+                break;
+            const json = await res.json();
+            const key = typeof json.workspaceKey === 'string' ? json.workspaceKey.trim() : '';
+            if (key) {
+                setRelayApiKey(key);
+                console.log('[dashboard] Relaycast workspace key bootstrapped from broker');
+                return;
+            }
+        }
+        catch {
+            // Broker not yet ready — wait and retry.
+        }
+        await new Promise((r) => setTimeout(r, 500));
+    }
+}
+/**
+ * Start the dashboard server.
  */
 export async function startServer(options = {}) {
     const preferredPort = options.port || parseInt(process.env.PORT || '3888', 10);
     const dashboard = createServer(options);
-    // Try preferred port first, then search for available port
     const actualPort = await findAvailablePort(dashboard.server, preferredPort);
     if (actualPort !== preferredPort) {
         console.log(`[dashboard] Port ${preferredPort} in use, using port ${actualPort}`);
@@ -340,8 +483,17 @@ export async function startServer(options = {}) {
     if (dashboard.mode === 'mock') {
         console.log('[dashboard] Using mock data - ready for standalone testing');
     }
+    else if (dashboard.mode === 'proxy') {
+        console.log(`[dashboard] Proxy mode enabled - broker URL ${normalizeRelayUrl(options.relayUrl ?? process.env.RELAY_URL)}`);
+    }
     else {
-        console.log(`[dashboard] Proxying to relay daemon at ${options.relayUrl || process.env.RELAY_URL || 'http://localhost:3889'}`);
+        console.log('[dashboard] Standalone mode enabled - relaycast data only');
+    }
+    // Best-effort: fetch workspace key from the broker health endpoint so the
+    // dashboard uses the same Relaycast workspace as the broker (no relaycast.json needed).
+    const resolvedRelayUrl = normalizeRelayUrl(options.relayUrl ?? process.env.RELAY_URL);
+    if (resolvedRelayUrl && !options.mock) {
+        bootstrapRelayApiKeyFromBroker(resolvedRelayUrl, dashboard.setRelayApiKey).catch(() => { });
     }
     return dashboard;
 }