@agent-relay/dashboard-server 2.0.47 → 2.0.49

package/dist/server.js

@@ -549,6 +549,9 @@ export async function startDashboard(portOrOptions, dataDirArg, teamDirArg, dbPa
     });
     // Track log subscriptions: agentName -> Set of WebSocket clients
     const logSubscriptions = new Map();
+    // Track file watchers for externally-spawned worker logs (module scope to avoid duplicates)
+    const fileWatchers = new Map();
+    const fileLastSize = new Map();
     // Track alive status for ping/pong keepalive on main dashboard connections
     // This prevents TCP/proxy timeouts from killing idle workspace connections
     const mainClientAlive = new WeakMap();
@@ -1191,6 +1194,9 @@ export async function startDashboard(portOrOptions, dataDirArg, teamDirArg, dbPa
             }
             const hasMessageData = Object.keys(messageData).length > 0;
             // Send to all targets (single agent, team members, or broadcast)
+            // Note: We do NOT persist outgoing messages here because the relay daemon
+            // already persists them when delivered (in router.persistDeliverEnvelope).
+            // Persisting here would cause duplicate messages in storage.
             let allSent = true;
             for (const target of targets) {
                 const sent = relayClient.sendMessage(target, message, 'message', hasMessageData ? messageData : undefined, thread);
@@ -1198,25 +1204,6 @@ export async function startDashboard(portOrOptions, dataDirArg, teamDirArg, dbPa
                     allSent = false;
                     console.error(`[dashboard] Failed to send message to ${target}`);
                 }
-                else if (storage) {
-                    // Persist outgoing message to storage so it survives page refresh
-                    const messageId = `out-${crypto.randomUUID()}`;
-                    storage.saveMessage({
-                        id: messageId,
-                        ts: Date.now(),
-                        from: senderName || 'Dashboard',
-                        to: target,
-                        topic: thread,
-                        kind: 'message',
-                        body: message,
-                        data: hasMessageData ? messageData : undefined,
-                        status: 'read', // Outgoing messages are already "read" by sender
-                        is_urgent: false,
-                        is_broadcast: isBroadcast,
-                    }).catch((err) => {
-                        console.error('[dashboard] Failed to persist outgoing message', err);
-                    });
-                }
             }
             if (allSent) {
                 // Broadcast updated data to all connected clients so they see the sent message
@@ -1743,6 +1730,23 @@ export async function startDashboard(portOrOptions, dataDirArg, teamDirArg, dbPa
                 }
             }
         }
+        // Also check workers.json for externally-spawned workers (e.g., from agentswarm)
+        // These workers have log files but weren't spawned by the dashboard's spawner
+        const workersJsonPath = path.join(teamDir, 'workers.json');
+        if (fs.existsSync(workersJsonPath)) {
+            try {
+                const workersData = JSON.parse(fs.readFileSync(workersJsonPath, 'utf-8'));
+                for (const worker of workersData.workers || []) {
+                    const agent = agentsMap.get(worker.name);
+                    if (agent && !agent.isSpawned && worker.logFile && fs.existsSync(worker.logFile)) {
+                        agent.isSpawned = true; // Mark as spawned so log button appears
+                    }
+                }
+            }
+            catch (err) {
+                // Ignore errors reading workers.json
+            }
+        }
         // Set team from teams.json for agents that don't have a team yet
         // This ensures agents defined in teams.json are associated with their team
         // even if they weren't spawned via auto-spawn
@@ -2039,6 +2043,89 @@ export async function startDashboard(portOrOptions, dataDirArg, teamDirArg, dbPa
                 return false;
             }
         };
+        const getExternalWorkerInfo = (agentName) => {
+            const workersPath = path.join(teamDir, 'workers.json');
+            if (!fs.existsSync(workersPath))
+                return null;
+            try {
+                const data = JSON.parse(fs.readFileSync(workersPath, 'utf-8'));
+                const worker = data.workers?.find((w) => w.name === agentName);
+                return worker ?? null;
+            }
+            catch {
+                return null;
+            }
+        };
+        // Helper to read logs from a log file (for externally-spawned workers)
+        const readLogsFromFile = (logFile, limit = 5000) => {
+            if (!fs.existsSync(logFile))
+                return [];
+            try {
+                const content = fs.readFileSync(logFile, 'utf-8');
+                const lines = content.split('\n');
+                // Return last `limit` lines
+                return lines.slice(-limit);
+            }
+            catch {
+                return [];
+            }
+        };
+        // Helper to start watching a log file for live updates
+        const watchLogFile = (agentName, logFile) => {
+            if (fileWatchers.has(agentName))
+                return; // Already watching
+            if (!fs.existsSync(logFile))
+                return;
+            try {
+                // Track current file size for incremental reads
+                const stats = fs.statSync(logFile);
+                fileLastSize.set(agentName, stats.size);
+                const watcher = fs.watch(logFile, (eventType) => {
+                    if (eventType !== 'change')
+                        return;
+                    const clients = logSubscriptions.get(agentName);
+                    if (!clients || clients.size === 0) {
+                        // No subscribers, stop watching
+                        watcher.close();
+                        fileWatchers.delete(agentName);
+                        fileLastSize.delete(agentName);
+                        return;
+                    }
+                    try {
+                        const newStats = fs.statSync(logFile);
+                        const lastSize = fileLastSize.get(agentName) || 0;
+                        if (newStats.size > lastSize) {
+                            // Read only the new content
+                            const fd = fs.openSync(logFile, 'r');
+                            const buffer = Buffer.alloc(newStats.size - lastSize);
+                            fs.readSync(fd, buffer, 0, buffer.length, lastSize);
+                            fs.closeSync(fd);
+                            const newContent = buffer.toString('utf-8');
+                            fileLastSize.set(agentName, newStats.size);
+                            // Broadcast to subscribed clients
+                            const payload = JSON.stringify({
+                                type: 'output',
+                                agent: agentName,
+                                data: newContent,
+                                timestamp: new Date().toISOString(),
+                            });
+                            for (const client of clients) {
+                                if (client.readyState === WebSocket.OPEN) {
+                                    client.send(payload);
+                                }
+                            }
+                        }
+                    }
+                    catch (err) {
+                        console.error(`[dashboard] Error reading log file updates for ${agentName}:`, err);
+                    }
+                });
+                fileWatchers.set(agentName, watcher);
+            }
+            catch (err) {
+                console.error(`[dashboard] Failed to watch log file for ${agentName}:`, err);
+            }
+        };
         // Helper to subscribe to an agent (async to handle spawn timing)
         const subscribeToAgent = async (agentName) => {
             let isSpawned = spawner?.hasWorker(agentName) ?? false;
@@ -2093,12 +2180,27 @@ export async function startDashboard(portOrOptions, dataDirArg, teamDirArg, dbPa
                 }));
             }
             else {
-                // For daemon-connected agents, explain that PTY output isn't available
-                ws.send(JSON.stringify({
-                    type: 'history',
-                    agent: agentName,
-                    lines: [`[${agentName} is a daemon-connected agent - PTY output not available. Showing relay messages only.]`],
-                }));
+                // Check if this is an externally-spawned worker with a log file
+                const externalWorker = getExternalWorkerInfo(agentName);
+                if (externalWorker?.logFile && fs.existsSync(externalWorker.logFile)) {
+                    // Read logs from the external worker's log file
+                    const lines = readLogsFromFile(externalWorker.logFile, 5000);
+                    ws.send(JSON.stringify({
+                        type: 'history',
+                        agent: agentName,
+                        lines,
+                    }));
+                    // Start watching the log file for live updates
+                    watchLogFile(agentName, externalWorker.logFile);
+                }
+                else {
+                    // For daemon-connected agents without log files, explain that PTY output isn't available
+                    ws.send(JSON.stringify({
+                        type: 'history',
+                        agent: agentName,
+                        lines: [`[${agentName} is a daemon-connected agent - PTY output not available. Showing relay messages only.]`],
+                    }));
+                }
             }
             ws.send(JSON.stringify({
                 type: 'subscribed',
@@ -2129,6 +2231,16 @@ export async function startDashboard(portOrOptions, dataDirArg, teamDirArg, dbPa
                     const agentName = msg.unsubscribe;
                     clientSubscriptions.delete(agentName);
                     logSubscriptions.get(agentName)?.delete(ws);
+                    // Clean up file watcher if no more subscribers
+                    const remainingClients = logSubscriptions.get(agentName);
+                    if (!remainingClients || remainingClients.size === 0) {
+                        const watcher = fileWatchers.get(agentName);
+                        if (watcher) {
+                            watcher.close();
+                            fileWatchers.delete(agentName);
+                            fileLastSize.delete(agentName);
+                        }
+                    }
                     console.log(`[dashboard] Client unsubscribed from logs for: ${agentName}`);
                     ws.send(JSON.stringify({
                         type: 'unsubscribed',
@@ -2174,6 +2286,17 @@ export async function startDashboard(portOrOptions, dataDirArg, teamDirArg, dbPa
             // Clean up subscriptions on disconnect
             for (const agentName of clientSubscriptions) {
                 logSubscriptions.get(agentName)?.delete(ws);
+                // Clean up file watchers if no more subscribers
+                const remainingClients = logSubscriptions.get(agentName);
+                if (!remainingClients || remainingClients.size === 0) {
+                    const watcher = fileWatchers.get(agentName);
+                    if (watcher) {
+                        watcher.close();
+                        fileWatchers.delete(agentName);
+                        fileLastSize.delete(agentName);
+                        console.log(`[dashboard] Stopped watching log file for: ${agentName}`);
+                    }
+                }
             }
             const reasonStr = reason?.toString() || 'no reason';
             console.log(`[dashboard] Logs WebSocket client disconnected (code: ${code}, reason: ${reasonStr})`);