agent-relay 1.3.1 → 1.3.3

package/dist/dashboard-server/server.js

@@ -19,6 +19,7 @@ import { loadTeamsConfig } from '../bridge/teams-config.js';
 import { getMemoryMonitor } from '../resiliency/memory-monitor.js';
 import { detectWorkspacePath } from '../utils/project-namespace.js';
 import { startCLIAuth, getAuthSession, cancelAuthSession, submitAuthCode, completeAuthSession, getSupportedProviders, } from '../daemon/cli-auth.js';
+import { HealthWorkerManager, getHealthPort } from '../health-worker-manager.js';
 /**
  * Initialize cloud persistence for session tracking.
  *
@@ -597,7 +598,8 @@ export async function startDashboard(portOrOptions, dataDirArg, teamDirArg, dbPa
         return connectionPromise;
     };
     // Start default relay client connection (non-blocking)
-    getRelayClient('Dashboard').catch(() => { });
+    // Use '_DashboardUI' to avoid conflicts with agents named 'Dashboard'
+    getRelayClient('_DashboardUI').catch(() => { });
     // User bridge for human-to-human and human-to-agent messaging
     const userBridge = new UserBridge({
         socketPath,
@@ -693,6 +695,12 @@ export async function startDashboard(portOrOptions, dataDirArg, teamDirArg, dbPa
             return false;
         }
     };
+    const isUserOnline = (username) => {
+        if (username === '*')
+            return true;
+        return onlineUsers.has(username) || userBridge.isUserRegistered(username);
+    };
+    const isRecipientOnline = (name) => (isAgentOnline(name) || isUserOnline(name));
     // Helper to get team members from teams.json, agents.json, and spawner's active workers
     const getTeamMembers = (teamName) => {
         const members = new Set();
@@ -752,13 +760,15 @@ export async function startDashboard(portOrOptions, dataDirArg, teamDirArg, dbPa
         }
         else {
             // Fail fast if target agent is offline (except broadcasts)
-            if (to !== '*' && !isAgentOnline(to)) {
-                return res.status(404).json({ error: `Agent "${to}" is not online` });
+            if (to !== '*' && !isRecipientOnline(to)) {
+                return res.status(404).json({ error: `Recipient "${to}" is not online` });
             }
             targets = [to];
         }
-        // Get or create relay client for this sender (defaults to 'Dashboard' for non-cloud mode)
-        const relayClient = await getRelayClient(senderName || 'Dashboard');
+        // Always use '_DashboardUI' client to avoid name conflicts with user agents
+        // (underscore prefix indicates system client, prevents collision if user names an agent "Dashboard")
+        // The sender name is preserved in message history/logs but not used for the relay connection
+        const relayClient = await getRelayClient('_DashboardUI');
         if (!relayClient || relayClient.state !== 'READY') {
             return res.status(503).json({ error: 'Relay daemon not connected' });
         }
@@ -1103,6 +1113,25 @@ export async function startDashboard(portOrOptions, dataDirArg, teamDirArg, dbPa
                 team: a.team,
             });
         });
+        // Inject online human users (connected via dashboard WebSocket) into agentsMap
+        // These users are tracked in onlineUsers for presence but need to appear in the agents list
+        // with cli: 'dashboard' so they show up in the sidebar for DM conversations
+        for (const [username, state] of onlineUsers) {
+            // Don't overwrite existing entries (e.g., if user is also in team.json)
+            if (!agentsMap.has(username)) {
+                agentsMap.set(username, {
+                    name: username,
+                    role: 'User',
+                    cli: 'dashboard',
+                    messageCount: 0,
+                    status: 'online',
+                    lastSeen: state.info.lastSeen,
+                    lastActive: state.info.lastSeen,
+                    needsAttention: false,
+                    avatarUrl: state.info.avatarUrl,
+                });
+            }
+        }
         // Update inbox counts if fallback mode; if storage, count messages addressed to agent
         if (storage) {
             for (const msg of allMessages) {
@@ -2067,16 +2096,49 @@ export async function startDashboard(portOrOptions, dataDirArg, teamDirArg, dbPa
             websocketClients: wss.clients.size,
         });
     });
+    /**
+     * GET /keep-alive - Keep-alive endpoint for Fly.io idle prevention
+     * Called by cloud server when workspace has active agents running.
+     * This inbound request counts as activity for Fly.io's request-based
+     * concurrency tracking, preventing the machine from being idled.
+     */
+    app.get('/keep-alive', (req, res) => {
+        // Count online agents (seen within last 30 seconds)
+        let activeAgents = 0;
+        const agentsPath = path.join(teamDir, 'agents.json');
+        if (fs.existsSync(agentsPath)) {
+            try {
+                const data = JSON.parse(fs.readFileSync(agentsPath, 'utf-8'));
+                const thirtySecondsAgo = Date.now() - 30 * 1000;
+                activeAgents = (data.agents || []).filter((a) => {
+                    if (!a.lastSeen)
+                        return false;
+                    return new Date(a.lastSeen).getTime() > thirtySecondsAgo;
+                }).length;
+            }
+            catch {
+                // Ignore parse errors
+            }
+        }
+        res.json({
+            ok: true,
+            activeAgents,
+            timestamp: Date.now(),
+        });
+    });
     // ===== CLI Auth API (for workspace-based provider authentication) =====
     /**
      * POST /auth/cli/:provider/start - Start CLI auth flow
-     * Body: { useDeviceFlow?: boolean }
+     * Body: { useDeviceFlow?: boolean, userId?: string }
+     *
+     * When userId is provided, credentials are stored per-user at /data/users/{userId}/.{provider}/
+     * This allows multiple users to share a workspace with their own CLI credentials.
      */
     app.post('/auth/cli/:provider/start', async (req, res) => {
         const { provider } = req.params;
-        const { useDeviceFlow } = req.body || {};
+        const { useDeviceFlow, userId } = req.body || {};
         try {
-            const session = await startCLIAuth(provider, { useDeviceFlow });
+            const session = await startCLIAuth(provider, { useDeviceFlow, userId });
             res.json({
                 sessionId: session.id,
                 status: session.status,
@@ -2239,18 +2301,35 @@ export async function startDashboard(portOrOptions, dataDirArg, teamDirArg, dbPa
      */
     app.get('/auth/cli/openai/check', async (req, res) => {
         try {
-            // Codex stores credentials at ~/.codex/auth.json
-            const homedir = process.env.HOME || '/home/workspace';
-            const credPath = path.join(homedir, '.codex', 'auth.json');
+            // Get userId from query params for per-user credential checking
+            // Multiple users can share a workspace, each with their own CLI credentials
+            const userId = req.query.userId;
+            let credPath;
+            if (userId) {
+                // Per-user credential path: /data/users/{userId}/.codex/auth.json
+                const dataDir = process.env.AGENT_RELAY_DATA_DIR || '/data';
+                credPath = path.join(dataDir, 'users', userId, '.codex', 'auth.json');
+            }
+            else {
+                // Fallback to workspace-wide path for backwards compatibility
+                const homedir = process.env.HOME || '/home/workspace';
+                credPath = path.join(homedir, '.codex', 'auth.json');
+            }
             if (!fs.existsSync(credPath)) {
                 return res.json({ authenticated: false });
             }
             const creds = JSON.parse(fs.readFileSync(credPath, 'utf-8'));
             // Check if we have a valid access token or API key
-            const hasToken = !!(creds.access_token || creds.token || creds.api_key || creds.OPENAI_API_KEY);
+            // Codex stores tokens in a nested 'tokens' object: { tokens: { access_token, refresh_token } }
+            const hasToken = !!(creds.access_token ||
+                creds.token ||
+                creds.api_key ||
+                creds.OPENAI_API_KEY ||
+                creds.tokens?.access_token ||
+                creds.tokens?.refresh_token);
             res.json({ authenticated: hasToken });
         }
-        catch (error) {
+        catch (_error) {
             // File doesn't exist or is invalid
             res.json({ authenticated: false });
         }
@@ -2858,10 +2937,20 @@ export async function startDashboard(portOrOptions, dataDirArg, teamDirArg, dbPa
             res.status(500).json({ error: 'Failed to list agents' });
         }
     });
+    // ===== Agent Status API =====
+    /**
+     * GET /api/agents/:name/online - Check if an agent is online
+     * Used by wrappers to wait for spawned agents before sending tasks.
+     */
+    app.get('/api/agents/:name/online', (req, res) => {
+        const { name } = req.params;
+        const online = isAgentOnline(name);
+        res.json({ name, online });
+    });
     // ===== Agent Spawn API =====
     /**
      * POST /api/spawn - Spawn a new agent
-     * Body: { name: string, cli?: string, task?: string, team?: string, shadowMode?, shadowAgent?, shadowOf?, shadowTriggers?, shadowSpeakOn? }
+     * Body: { name: string, cli?: string, task?: string, team?: string, spawnerName?, cwd?, interactive?, shadowMode?, shadowAgent?, shadowOf?, shadowTriggers?, shadowSpeakOn? }
      */
     app.post('/api/spawn', async (req, res) => {
         if (!spawner) {
@@ -2870,7 +2959,7 @@ export async function startDashboard(portOrOptions, dataDirArg, teamDirArg, dbPa
                 error: 'Spawner not enabled. Start dashboard with enableSpawner: true',
             });
         }
-        const { name, cli = 'claude', task = '', team, interactive, shadowMode, shadowAgent, shadowOf, shadowTriggers, shadowSpeakOn, } = req.body;
+        const { name, cli = 'claude', task = '', team, spawnerName, cwd, interactive, shadowMode, shadowAgent, shadowOf, shadowTriggers, shadowSpeakOn, userId, } = req.body;
         if (!name || typeof name !== 'string') {
             return res.status(400).json({
                 success: false,
@@ -2883,12 +2972,15 @@ export async function startDashboard(portOrOptions, dataDirArg, teamDirArg, dbPa
                 cli,
                 task,
                 team: team || undefined, // Optional team name
+                spawnerName: spawnerName || undefined, // For policy enforcement
+                cwd: cwd || undefined, // Working directory
                 interactive, // Disables auto-accept for auth setup flows
                 shadowMode,
                 shadowAgent,
                 shadowOf,
                 shadowTriggers,
                 shadowSpeakOn,
+                userId: typeof userId === 'string' ? userId : undefined,
             };
             const result = await spawner.spawn(request);
             if (result.success) {
@@ -2997,19 +3089,70 @@ Start by greeting the project leads and asking for status updates.`;
     });
     /**
      * GET /api/spawned - List active spawned agents
+     *
+     * Returns agents from two sources:
+     * 1. Spawner's active workers (in-memory tracking)
+     * 2. Daemon's agents.json registry (persisted, survives restarts)
+     *
+     * This fallback ensures docker deployments show agents even after
+     * container restarts when spawner's in-memory state is lost but
+     * agents have reconnected to the daemon.
      */
     app.get('/api/spawned', (req, res) => {
-        if (!spawner) {
-            return res.status(503).json({
-                success: false,
-                error: 'Spawner not enabled',
-                agents: [],
-            });
+        // Collect agents from all available sources
+        const agentsByName = new Map();
+        // Source 1: Spawner's active workers (authoritative for spawned agents)
+        if (spawner) {
+            for (const worker of spawner.getActiveWorkers()) {
+                agentsByName.set(worker.name, {
+                    name: worker.name,
+                    cli: worker.cli,
+                    pid: worker.pid,
+                    spawnedAt: worker.spawnedAt,
+                    task: worker.task,
+                    team: worker.team,
+                    source: 'spawner',
+                });
+            }
         }
-        const agents = spawner.getActiveWorkers();
+        // Source 2: Daemon's agents.json registry (fallback for docker restarts)
+        // Only include agents not already tracked by spawner
+        const agentsPath = path.join(teamDir, 'agents.json');
+        if (fs.existsSync(agentsPath)) {
+            try {
+                const data = JSON.parse(fs.readFileSync(agentsPath, 'utf-8'));
+                const registeredAgents = data.agents || [];
+                const thirtySecondsAgo = Date.now() - 30 * 1000;
+                for (const agent of registeredAgents) {
+                    // Skip if already tracked by spawner
+                    if (agentsByName.has(agent.name))
+                        continue;
+                    // Only include recently active agents (within 30s heartbeat window)
+                    const lastSeen = agent.lastSeen ? new Date(agent.lastSeen).getTime() : 0;
+                    if (lastSeen < thirtySecondsAgo)
+                        continue;
+                    agentsByName.set(agent.name, {
+                        name: agent.name,
+                        cli: agent.cli || 'unknown',
+                        spawnedAt: agent.connectedAt ? new Date(agent.connectedAt).getTime() : undefined,
+                        team: agent.team,
+                        source: 'daemon',
+                    });
+                }
+            }
+            catch (err) {
+                console.error('[api/spawned] Failed to read agents.json:', err);
+            }
+        }
+        const agents = Array.from(agentsByName.values());
         res.json({
             success: true,
             agents,
+            // Include source info for debugging
+            sources: {
+                spawnerEnabled: !!spawner,
+                daemonAgentsFile: fs.existsSync(agentsPath),
+            },
         });
     });
     /**
@@ -3043,6 +3186,53 @@ Start by greeting the project leads and asking for status updates.`;
             });
         }
     });
+    /**
+     * POST /api/agents/by-name/:name/interrupt - Send ESC sequence to interrupt an agent
+     *
+     * Sends ESC ESC (0x1b 0x1b) to the agent's PTY to interrupt the current operation.
+     * This is useful for breaking agents out of stuck loops without terminating them.
+     */
+    app.post('/api/agents/by-name/:name/interrupt', (req, res) => {
+        if (!spawner) {
+            return res.status(503).json({
+                success: false,
+                error: 'Spawner not enabled',
+            });
+        }
+        const { name } = req.params;
+        // Check if agent exists
+        if (!spawner.hasWorker(name)) {
+            return res.status(404).json({
+                success: false,
+                error: `Agent ${name} not found or not spawned`,
+            });
+        }
+        try {
+            // Send ESC ESC sequence to interrupt the agent
+            // ESC = 0x1b in hexadecimal
+            const success = spawner.sendWorkerInput(name, '\x1b\x1b');
+            if (success) {
+                console.log(`[api] Sent interrupt (ESC ESC) to agent ${name}`);
+                res.json({
+                    success: true,
+                    message: `Interrupt signal sent to ${name}`,
+                });
+            }
+            else {
+                res.status(500).json({
+                    success: false,
+                    error: `Failed to send interrupt to ${name}`,
+                });
+            }
+        }
+        catch (err) {
+            console.error('[api] Interrupt error:', err);
+            res.status(500).json({
+                success: false,
+                error: err.message,
+            });
+        }
+    });
     /**
      * GET /api/trajectory - Get current trajectory status
      */
@@ -3311,7 +3501,7 @@ Start by greeting the project leads and asking for status updates.`;
         }
         // Try to send message to agent
         try {
-            const client = await getRelayClient('Dashboard');
+            const client = await getRelayClient('_DashboardUI');
             if (client) {
                 await client.sendMessage(agentName, responseMessage, 'message');
             }
@@ -3341,7 +3531,7 @@ Start by greeting the project leads and asking for status updates.`;
             responseMessage += `\nReason: ${reason}`;
         }
         try {
-            const client = await getRelayClient('Dashboard');
+            const client = await getRelayClient('_DashboardUI');
             if (client) {
                 await client.sendMessage(agentName, responseMessage, 'message');
             }
@@ -3529,7 +3719,7 @@ Start by greeting the project leads and asking for status updates.`;
         tasks.set(task.id, task);
         // Send task to agent via relay
         try {
-            const client = await getRelayClient('Dashboard');
+            const client = await getRelayClient('_DashboardUI');
             if (client) {
                 const taskMessage = `TASK ASSIGNED [${priority.toUpperCase()}]: ${title}\n\n${description || 'No additional details.'}`;
                 await client.sendMessage(agentName, taskMessage, 'message');
@@ -3577,7 +3767,7 @@ Start by greeting the project leads and asking for status updates.`;
         // Notify agent of cancellation if task is still active
         if (task.status === 'pending' || task.status === 'assigned' || task.status === 'in_progress') {
             try {
-                const client = await getRelayClient('Dashboard');
+                const client = await getRelayClient('_DashboardUI');
                 if (client) {
                     await client.sendMessage(task.agentName, `TASK CANCELLED: ${task.title}`, 'message');
                 }
@@ -3651,7 +3841,7 @@ Start by greeting the project leads and asking for status updates.`;
             return res.status(400).json({ success: false, error: 'Message content is required' });
         }
         try {
-            const client = await getRelayClient('Dashboard');
+            const client = await getRelayClient('_DashboardUI');
             if (!client) {
                 return res.status(503).json({
                     success: false,
@@ -3758,13 +3948,39 @@ Start by greeting the project leads and asking for status updates.`;
         console.log(`Requested dashboard port ${port} is busy; switching to ${availablePort}.`);
     }
     return new Promise((resolve, reject) => {
-        server.listen(availablePort, () => {
+        server.listen(availablePort, async () => {
             console.log(`Dashboard running at http://localhost:${availablePort}`);
             console.log(`Monitoring: ${dataDir}`);
             // Set the dashboard port on spawner so spawned agents can use the API for nested spawns
             if (spawner) {
                 spawner.setDashboardPort(availablePort);
             }
+            // Start health worker on separate thread for reliable health checks
+            // This ensures health checks respond even when main event loop is blocked
+            const healthPort = getHealthPort(availablePort);
+            const healthWorker = new HealthWorkerManager({ port: healthPort }, {
+                getUptime: () => process.uptime(),
+                getMemoryMB: () => Math.round(process.memoryUsage().heapUsed / 1024 / 1024),
+                getRelayConnected: () => {
+                    const defaultClient = relayClients.get('Dashboard');
+                    return defaultClient?.state === 'READY';
+                },
+                getAgentCount: () => relayClients.size,
+                getStatus: () => {
+                    const socketExists = fs.existsSync(socketPath);
+                    if (!socketExists)
+                        return 'degraded';
+                    const defaultClient = relayClients.get('Dashboard');
+                    return defaultClient?.state === 'READY' ? 'healthy' : 'busy';
+                },
+            });
+            try {
+                await healthWorker.start();
+                console.log(`Health check worker running at http://localhost:${healthPort}/health`);
+            }
+            catch (err) {
+                console.warn('[dashboard] Failed to start health worker, using main thread health check:', err);
+            }
             resolve(availablePort);
         });
         server.on('error', (err) => {

package/dist/health-worker-manager.d.ts

@@ -0,0 +1,62 @@
+/**
+ * Health Worker Manager
+ *
+ * Manages the health check worker thread, sending periodic stats updates
+ * and handling worker lifecycle.
+ */
+export interface HealthWorkerConfig {
+    /** Port for health check server (default: main port + 1) */
+    port: number;
+    /** Interval for sending stats updates (default: 5000ms) */
+    statsInterval?: number;
+}
+export interface HealthStatsProvider {
+    getUptime: () => number;
+    getMemoryMB: () => number;
+    getRelayConnected: () => boolean;
+    getAgentCount: () => number;
+    getStatus: () => 'healthy' | 'busy' | 'degraded';
+}
+export declare class HealthWorkerManager {
+    private worker;
+    private statsInterval;
+    private config;
+    private statsProvider;
+    private ready;
+    constructor(config: HealthWorkerConfig, statsProvider: HealthStatsProvider);
+    /**
+     * Start the health worker thread
+     */
+    start(): Promise<void>;
+    /**
+     * Stop the health worker thread
+     */
+    stop(): Promise<void>;
+    /**
+     * Check if worker is ready
+     */
+    isReady(): boolean;
+    /**
+     * Get the port the health worker is listening on
+     */
+    getPort(): number;
+    /**
+     * Start periodic stats updates to worker
+     */
+    private startStatsUpdates;
+    /**
+     * Stop stats updates
+     */
+    private stopStatsUpdates;
+    /**
+     * Send current stats to worker
+     */
+    private sendStats;
+}
+/** Default health port offset from main port */
+export declare const HEALTH_PORT_OFFSET = 1;
+/**
+ * Calculate health port from main port
+ */
+export declare function getHealthPort(mainPort: number): number;
+//# sourceMappingURL=health-worker-manager.d.ts.map

package/dist/health-worker-manager.js

@@ -0,0 +1,144 @@
+/**
+ * Health Worker Manager
+ *
+ * Manages the health check worker thread, sending periodic stats updates
+ * and handling worker lifecycle.
+ */
+import { Worker } from 'node:worker_threads';
+import path from 'node:path';
+import { fileURLToPath } from 'node:url';
+const __filename = fileURLToPath(import.meta.url);
+const __dirname = path.dirname(__filename);
+export class HealthWorkerManager {
+    worker = null;
+    statsInterval = null;
+    config;
+    statsProvider;
+    ready = false;
+    constructor(config, statsProvider) {
+        this.config = {
+            statsInterval: 5000,
+            ...config,
+        };
+        this.statsProvider = statsProvider;
+    }
+    /**
+     * Start the health worker thread
+     */
+    async start() {
+        if (this.worker) {
+            console.warn('[health-manager] Worker already running');
+            return;
+        }
+        return new Promise((resolve, reject) => {
+            // Worker script path - handle both dev (src) and prod (dist)
+            const workerPath = path.join(__dirname, 'health-worker.js');
+            this.worker = new Worker(workerPath, {
+                workerData: { port: this.config.port },
+            });
+            this.worker.on('message', (msg) => {
+                if (msg.type === 'ready') {
+                    this.ready = true;
+                    console.log(`[health-manager] Worker ready on port ${msg.port}`);
+                    this.startStatsUpdates();
+                    resolve();
+                }
+                else if (msg.type === 'error') {
+                    console.error('[health-manager] Worker error:', msg.error);
+                }
+            });
+            this.worker.on('error', (err) => {
+                console.error('[health-manager] Worker thread error:', err);
+                if (!this.ready) {
+                    reject(err);
+                }
+            });
+            this.worker.on('exit', (code) => {
+                console.log(`[health-manager] Worker exited with code ${code}`);
+                this.ready = false;
+                this.worker = null;
+                this.stopStatsUpdates();
+            });
+            // Timeout for worker startup
+            setTimeout(() => {
+                if (!this.ready) {
+                    reject(new Error('Health worker startup timeout'));
+                }
+            }, 10000);
+        });
+    }
+    /**
+     * Stop the health worker thread
+     */
+    async stop() {
+        this.stopStatsUpdates();
+        if (this.worker) {
+            await this.worker.terminate();
+            this.worker = null;
+            this.ready = false;
+        }
+    }
+    /**
+     * Check if worker is ready
+     */
+    isReady() {
+        return this.ready;
+    }
+    /**
+     * Get the port the health worker is listening on
+     */
+    getPort() {
+        return this.config.port;
+    }
+    /**
+     * Start periodic stats updates to worker
+     */
+    startStatsUpdates() {
+        if (this.statsInterval)
+            return;
+        // Send initial stats
+        this.sendStats();
+        // Send periodic updates
+        this.statsInterval = setInterval(() => {
+            this.sendStats();
+        }, this.config.statsInterval);
+    }
+    /**
+     * Stop stats updates
+     */
+    stopStatsUpdates() {
+        if (this.statsInterval) {
+            clearInterval(this.statsInterval);
+            this.statsInterval = null;
+        }
+    }
+    /**
+     * Send current stats to worker
+     */
+    sendStats() {
+        if (!this.worker || !this.ready)
+            return;
+        try {
+            const stats = {
+                uptime: this.statsProvider.getUptime(),
+                memoryMB: this.statsProvider.getMemoryMB(),
+                relayConnected: this.statsProvider.getRelayConnected(),
+                agentCount: this.statsProvider.getAgentCount(),
+                status: this.statsProvider.getStatus(),
+            };
+            this.worker.postMessage(stats);
+        }
+        catch (err) {
+            console.error('[health-manager] Failed to send stats:', err);
+        }
+    }
+}
+/** Default health port offset from main port */
+export const HEALTH_PORT_OFFSET = 1;
+/**
+ * Calculate health port from main port
+ */
+export function getHealthPort(mainPort) {
+    return mainPort + HEALTH_PORT_OFFSET;
+}
+//# sourceMappingURL=health-worker-manager.js.map

package/dist/health-worker.d.ts

@@ -0,0 +1,9 @@
+/**
+ * Health Check Worker Thread
+ *
+ * Runs a minimal HTTP server on a separate thread to handle health checks.
+ * This ensures health checks respond even when the main event loop is blocked
+ * by heavy compute tasks (builds, large file operations, etc.).
+ */
+export {};
+//# sourceMappingURL=health-worker.d.ts.map