agent-relay 1.0.9 → 1.0.12

package/dist/cli/index.js

@@ -15,6 +15,9 @@ import { config as dotenvConfig } from 'dotenv';
 import { Daemon } from '../daemon/server.js';
 import { RelayClient } from '../wrapper/client.js';
 import { generateAgentName } from '../utils/name-generator.js';
+import { getTmuxPath } from '../utils/tmux-resolver.js';
+import { readWorkersMetadata, getWorkerLogsDir } from '../bridge/spawner.js';
+import { checkForUpdatesInBackground, checkForUpdates } from '../utils/update-checker.js';
 import fs from 'node:fs';
 import path from 'node:path';
 import { promisify } from 'node:util';
@@ -29,6 +32,14 @@ const packageJsonPath = path.resolve(__dirname, '../../package.json');
 const packageJson = JSON.parse(fs.readFileSync(packageJsonPath, 'utf-8'));
 const VERSION = packageJson.version;
 const execAsync = promisify(exec);
+// Check for updates in background (non-blocking)
+// Only show notification for interactive commands, not when wrapping agents or running update
+const interactiveCommands = ['up', 'down', 'status', 'agents', 'who', 'version', '--version', '-V', '--help', '-h'];
+const shouldCheckUpdates = process.argv.length > 2 &&
+    interactiveCommands.includes(process.argv[2]);
+if (shouldCheckUpdates) {
+    checkForUpdatesInBackground(VERSION);
+}
 const program = new Command();
 function pidFilePathForSocket(socketPath) {
     return `${socketPath}.pid`;
@@ -91,7 +102,7 @@ program
                 requestedBy: agentName,
             });
             if (result.success) {
-                console.error(`[${agentName}] ✓ Spawned ${workerName} in ${result.window}`);
+                console.error(`[${agentName}] ✓ Spawned ${workerName} [pid: ${result.pid}]`);
             }
             else {
                 console.error(`[${agentName}] ✗ Failed to spawn ${workerName}: ${result.error}`);
@@ -115,93 +126,6 @@ program
     });
     await wrapper.start();
 });
-// Load teams.json from project root or .agent-relay/
-function loadTeamConfig(projectRoot) {
-    const locations = [
-        path.join(projectRoot, 'teams.json'),
-        path.join(projectRoot, '.agent-relay', 'teams.json'),
-    ];
-    for (const configPath of locations) {
-        if (fs.existsSync(configPath)) {
-            try {
-                const content = fs.readFileSync(configPath, 'utf-8');
-                return JSON.parse(content);
-            }
-            catch (err) {
-                console.error(`Failed to parse ${configPath}:`, err);
-            }
-        }
-    }
-    return null;
-}
-// Spawn agents from team config using tmux
-async function spawnTeamAgents(agents, socketPath, dataDir, projectRoot, relayPrefix) {
-    const { TmuxWrapper } = await import('../wrapper/tmux-wrapper.js');
-    const { findAgentConfig, isClaudeCli, buildClaudeArgs } = await import('../utils/agent-config.js');
-    const { AgentSpawner } = await import('../bridge/spawner.js');
-    // Create spawner so all team agents can spawn workers
-    const spawner = new AgentSpawner(projectRoot);
-    for (const agent of agents) {
-        console.log(`Spawning agent: ${agent.name} (${agent.cli})`);
-        // Parse CLI - handle "claude:opus" format
-        const [mainCommand, ...cliArgs] = agent.cli.split(/\s+/);
-        // Auto-detect agent config and inject --model/--agent for Claude CLI
-        let finalArgs = cliArgs;
-        if (isClaudeCli(mainCommand)) {
-            const config = findAgentConfig(agent.name, projectRoot);
-            if (config) {
-                console.log(`  Agent config: ${config.configPath}`);
-                if (config.model) {
-                    console.log(`  Model: ${config.model}`);
-                }
-                finalArgs = buildClaudeArgs(agent.name, cliArgs, projectRoot);
-            }
-        }
-        const wrapper = new TmuxWrapper({
-            name: agent.name,
-            command: mainCommand,
-            args: finalArgs,
-            socketPath,
-            debug: false,
-            relayPrefix,
-            useInbox: true,
-            inboxDir: dataDir,
-            // Wire up spawn/release callbacks so any agent can spawn workers
-            onSpawn: async (workerName, workerCli, task) => {
-                console.log(`[${agent.name}] Spawning ${workerName} (${workerCli})...`);
-                const result = await spawner.spawn({
-                    name: workerName,
-                    cli: workerCli,
-                    task,
-                    requestedBy: agent.name,
-                });
-                if (result.success) {
-                    console.log(`[${agent.name}] ✓ Spawned ${workerName} in ${result.window}`);
-                }
-                else {
-                    console.error(`[${agent.name}] ✗ Failed to spawn ${workerName}: ${result.error}`);
-                }
-            },
-            onRelease: async (workerName) => {
-                console.log(`[${agent.name}] Releasing ${workerName}...`);
-                const released = await spawner.release(workerName);
-                if (released) {
-                    console.log(`[${agent.name}] ✓ Released ${workerName}`);
-                }
-                else {
-                    console.error(`[${agent.name}] ✗ Worker ${workerName} not found`);
-                }
-            },
-        });
-        try {
-            await wrapper.start();
-            console.log(`  Started: ${agent.name}`);
-        }
-        catch (err) {
-            console.error(`  Failed to start ${agent.name}:`, err);
-        }
-    }
-}
 // up - Start daemon + dashboard
 program
     .command('up')
@@ -209,7 +133,7 @@ program
     .option('--no-dashboard', 'Disable web dashboard')
     .option('--port <port>', 'Dashboard port', DEFAULT_DASHBOARD_PORT)
     .action(async (options) => {
-    const { getProjectPaths, ensureProjectDir } = await import('../utils/project-namespace.js');
+    const { ensureProjectDir } = await import('../utils/project-namespace.js');
     const paths = ensureProjectDir();
     const socketPath = paths.socketPath;
     const dbPath = paths.dbPath;
@@ -237,7 +161,7 @@ program
         // Dashboard starts by default (use --no-dashboard to disable)
         if (options.dashboard !== false) {
             const port = parseInt(options.port, 10);
-            const { startDashboard } = await import('../dashboard/server.js');
+            const { startDashboard } = await import('../dashboard-server/server.js');
             const actualPort = await startDashboard({
                 port,
                 dataDir: paths.dataDir,
@@ -308,38 +232,73 @@ program
         logRelaySessions(relaySessions);
     }
 });
-// agents - List connected agents (from registry file)
+// agents - List connected agents (from registry file) and spawned workers
 program
     .command('agents')
-    .description('List connected agents')
+    .description('List connected agents and spawned workers')
     .option('--all', 'Include internal/CLI agents')
     .option('--json', 'Output as JSON')
     .action(async (options) => {
     const { getProjectPaths } = await import('../utils/project-namespace.js');
     const paths = getProjectPaths();
     const agentsPath = path.join(paths.teamDir, 'agents.json');
+    // Load registered agents
     const allAgents = loadAgents(agentsPath);
     const agents = options.all
         ? allAgents
         : allAgents.filter(isVisibleAgent);
+    // Load spawned workers
+    const workers = readWorkersMetadata(paths.projectRoot);
+    const combined = [];
+    // Add registered agents
+    agents.forEach((agent) => {
+        const worker = workers.find(w => w.name === agent.name);
+        combined.push({
+            name: agent.name ?? 'unknown',
+            status: getAgentStatus(agent),
+            cli: agent.cli ?? '-',
+            lastSeen: agent.lastSeen,
+            spawnedBy: worker?.spawnedBy,
+            pid: worker?.pid,
+        });
+    });
+    // Add workers not in registry (orphaned or not yet registered)
+    workers.forEach((worker) => {
+        const existsInAgents = agents.some(a => a.name === worker.name);
+        if (!existsInAgents) {
+            combined.push({
+                name: worker.name || 'unknown',
+                status: 'ONLINE',
+                cli: worker.cli || '-',
+                spawnedBy: worker.spawnedBy,
+                pid: worker.pid,
+            });
+        }
+    });
     if (options.json) {
-        console.log(JSON.stringify(agents.map(a => ({ ...a, status: getAgentStatus(a) })), null, 2));
+        console.log(JSON.stringify(combined, null, 2));
         return;
     }
-    if (!agents.length) {
+    if (!combined.length) {
         const hint = options.all ? '' : ' (use --all to include internal/cli agents)';
         console.log(`No agents found. Ensure the daemon is running and agents are connected${hint}.`);
         return;
     }
-    console.log('NAME            STATUS   CLI       LAST SEEN');
-    console.log('---------------------------------------------');
-    agents.forEach((agent) => {
-        const name = (agent.name ?? 'unknown').padEnd(15);
-        const status = getAgentStatus(agent).padEnd(8);
-        const cli = (agent.cli ?? '-').padEnd(8);
-        const lastSeen = formatRelativeTime(agent.lastSeen);
-        console.log(`${name} ${status} ${cli} ${lastSeen}`);
+    console.log('NAME            STATUS   CLI       PARENT');
+    console.log('─'.repeat(50));
+    combined.forEach((agent) => {
+        const name = agent.name.padEnd(15);
+        const status = agent.status.padEnd(8);
+        const cli = agent.cli.padEnd(9);
+        const parent = agent.spawnedBy ?? '-';
+        console.log(`${name} ${status} ${cli} ${parent}`);
     });
+    if (workers.length > 0) {
+        console.log('');
+        console.log('Commands:');
+        console.log('  agent-relay agents:logs <name>   - View spawned agent output');
+        console.log('  agent-relay agents:kill <name>   - Kill a spawned agent');
+    }
 });
 // who - Show currently active agents (online within last 30s)
 program
@@ -464,6 +423,67 @@ program
     .action(() => {
     console.log(`agent-relay v${VERSION}`);
 });
+// update - Check for updates and optionally install
+program
+    .command('update')
+    .description('Check for updates and install if available')
+    .option('--check', 'Only check for updates, do not install')
+    .action(async (options) => {
+    console.log(`Current version: ${VERSION}`);
+    console.log('Checking for updates...');
+    const info = await checkForUpdates(VERSION);
+    if (info.error) {
+        console.error(`Failed to check for updates: ${info.error}`);
+        process.exit(1);
+    }
+    if (!info.updateAvailable) {
+        console.log('You are running the latest version.');
+        return;
+    }
+    console.log(`New version available: ${info.latestVersion}`);
+    if (options.check) {
+        console.log('Run `agent-relay update` to install.');
+        return;
+    }
+    console.log('Installing update...');
+    try {
+        const { stdout, stderr } = await execAsync('npm install -g agent-relay@latest');
+        if (stdout)
+            console.log(stdout);
+        if (stderr)
+            console.error(stderr);
+        console.log(`Successfully updated to ${info.latestVersion}`);
+    }
+    catch (err) {
+        console.error('Failed to install update:', err.message);
+        console.log('Try running manually: npm install -g agent-relay@latest');
+        process.exit(1);
+    }
+});
+// check-tmux - Check tmux availability (hidden - for diagnostics)
+program
+    .command('check-tmux', { hidden: true })
+    .description('Check tmux availability and version')
+    .action(async () => {
+    const { resolveTmux, checkTmuxVersion } = await import('../utils/tmux-resolver.js');
+    const info = resolveTmux();
+    if (!info) {
+        console.log('tmux: NOT FOUND');
+        console.log('');
+        console.log('Install tmux, then reinstall agent-relay:');
+        console.log('  brew install tmux          # macOS');
+        console.log('  apt install tmux           # Ubuntu/Debian');
+        console.log('  npm install agent-relay    # Reinstall to bundle tmux');
+        process.exit(1);
+    }
+    console.log(`tmux: ${info.path}`);
+    console.log(`Version: ${info.version}`);
+    console.log(`Source: ${info.isBundled ? 'bundled' : 'system'}`);
+    const versionCheck = checkTmuxVersion();
+    if (!versionCheck.ok) {
+        console.log(`Warning: tmux ${versionCheck.minimum}+ recommended`);
+    }
+});
 // bridge - Multi-project orchestration
 program
     .command('bridge')
@@ -565,7 +585,7 @@ program
     try {
         await client.connect();
     }
-    catch (err) {
+    catch (_err) {
         console.error('Failed to connect to all projects');
         writeBridgeState(); // Write final state before exit
         process.exit(1);
@@ -704,9 +724,10 @@ program
     }
     // Kill orphaned sessions
     let killed = 0;
+    const tmuxPath = getTmuxPath();
     for (const session of orphaned) {
         try {
-            await execAsync(`tmux kill-session -t ${session.sessionName}`);
+            await execAsync(`"${tmuxPath}" kill-session -t ${session.sessionName}`);
             killed++;
             console.log(`Killed: ${session.sessionName}`);
         }
@@ -718,7 +739,8 @@ program
 });
 async function discoverRelaySessions() {
     try {
-        const { stdout } = await execAsync('tmux list-sessions -F "#{session_name}"');
+        const tmuxPath = getTmuxPath();
+        const { stdout } = await execAsync(`"${tmuxPath}" list-sessions -F "#{session_name}"`);
         const sessionNames = stdout
             .split('\n')
             .map(s => s.trim())
@@ -734,7 +756,7 @@ async function discoverRelaySessions() {
         return await Promise.all(relaySessions.map(async (session) => {
             let cwd;
             try {
-                const { stdout: cwdOut } = await execAsync(`tmux display-message -t ${session.sessionName} -p '#{pane_current_path}'`);
+                const { stdout: cwdOut } = await execAsync(`"${tmuxPath}" display-message -t ${session.sessionName} -p '#{pane_current_path}'`);
                 cwd = cwdOut.trim() || undefined;
             }
             catch {
@@ -862,233 +884,108 @@ function parseSince(input) {
     return parsed;
 }
 // ============================================
-// Spawn/Worker debugging commands
+// Spawned agent debugging commands
 // ============================================
-const WORKER_SESSION = 'relay-workers';
-// workers - List spawned workers
-program
-    .command('workers')
-    .description('List spawned worker agents (from tmux)')
-    .option('--json', 'Output as JSON')
-    .action(async (options) => {
-    try {
-        // Check if worker session exists
-        try {
-            await execAsync(`tmux has-session -t ${WORKER_SESSION} 2>/dev/null`);
-        }
-        catch {
-            if (options.json) {
-                console.log(JSON.stringify({ workers: [], session: null }));
-            }
-            else {
-                console.log('No spawned workers (session does not exist)');
-            }
-            return;
-        }
-        // List windows in the worker session
-        const { stdout } = await execAsync(`tmux list-windows -t ${WORKER_SESSION} -F "#{window_index}|#{window_name}|#{pane_current_command}|#{window_activity}"`);
-        const workers = stdout
-            .split('\n')
-            .filter(Boolean)
-            .map(line => {
-            const [index, name, command, activity] = line.split('|');
-            const activityTs = parseInt(activity, 10) * 1000;
-            const lastActive = isNaN(activityTs) ? undefined : new Date(activityTs).toISOString();
-            return {
-                index: parseInt(index, 10),
-                name,
-                command,
-                lastActive,
-                window: `${WORKER_SESSION}:${name}`,
-            };
-        })
-            // Filter out the default zsh window
-            .filter(w => w.name !== 'zsh' && w.command !== 'zsh');
-        if (options.json) {
-            console.log(JSON.stringify({ workers, session: WORKER_SESSION }, null, 2));
-            return;
-        }
-        if (!workers.length) {
-            console.log('No spawned workers');
-            return;
-        }
-        console.log('SPAWNED WORKERS');
-        console.log('─'.repeat(50));
-        console.log('NAME            COMMAND       WINDOW');
-        console.log('─'.repeat(50));
-        workers.forEach(w => {
-            const name = w.name.padEnd(15);
-            const cmd = (w.command || '-').padEnd(12);
-            console.log(`${name} ${cmd}  ${w.window}`);
-        });
-        console.log('');
-        console.log('Commands:');
-        console.log('  agent-relay workers:logs <name>   - View worker output');
-        console.log('  agent-relay workers:attach <name> - Attach to worker tmux');
-        console.log('  agent-relay workers:kill <name>   - Kill a worker');
-    }
-    catch (err) {
-        console.error('Failed to list workers:', err.message);
-    }
-});
-// workers:logs - Show tmux pane output for a worker
+// agents:logs - Show log file output for a spawned agent
 program
-    .command('workers:logs')
-    .description('Show recent output from a spawned worker')
-    .argument('<name>', 'Worker name')
+    .command('agents:logs')
+    .description('Show recent output from a spawned agent')
+    .argument('<name>', 'Agent name')
     .option('-n, --lines <n>', 'Number of lines to show', '50')
     .option('-f, --follow', 'Follow output (like tail -f)')
     .action(async (name, options) => {
-    const window = `${WORKER_SESSION}:${name}`;
-    try {
-        // Check if window exists
-        await execAsync(`tmux has-session -t ${window} 2>/dev/null`);
-    }
-    catch {
-        console.error(`Worker "${name}" not found`);
-        console.log(`Run 'agent-relay workers' to see available workers`);
+    const { getProjectPaths } = await import('../utils/project-namespace.js');
+    const paths = getProjectPaths();
+    const logsDir = getWorkerLogsDir(paths.projectRoot);
+    const logFile = path.join(logsDir, `${name}.log`);
+    if (!fs.existsSync(logFile)) {
+        console.error(`No logs found for agent "${name}"`);
+        console.log(`Log file not found: ${logFile}`);
+        console.log(`Run 'agent-relay agents' to see available agents`);
         process.exit(1);
     }
     if (options.follow) {
-        console.log(`Following output from ${window} (Ctrl+C to stop)...`);
+        console.log(`Following logs for ${name} (Ctrl+C to stop)...`);
         console.log('─'.repeat(50));
-        // Use a polling approach to follow
-        let lastContent = '';
-        const poll = async () => {
-            try {
-                const { stdout } = await execAsync(`tmux capture-pane -t ${window} -p -S -100`);
-                if (stdout !== lastContent) {
-                    // Print only new lines
-                    const newContent = stdout.replace(lastContent, '');
-                    if (newContent.trim()) {
-                        process.stdout.write(newContent);
-                    }
-                    lastContent = stdout;
-                }
-            }
-            catch {
-                console.error('\nWorker disconnected');
-                process.exit(1);
-            }
-        };
-        const interval = setInterval(poll, 500);
+        // Use tail -f approach
+        const { spawn } = await import('child_process');
+        const child = spawn('tail', ['-f', logFile], {
+            stdio: ['ignore', 'inherit', 'inherit'],
+        });
         process.on('SIGINT', () => {
-            clearInterval(interval);
+            child.kill();
             console.log('\nStopped following');
             process.exit(0);
         });
-        await poll(); // Initial fetch
-        await new Promise(() => { }); // Keep running
+        child.on('exit', () => {
+            process.exit(0);
+        });
     }
     else {
         try {
             const lines = parseInt(options.lines || '50', 10);
-            const { stdout } = await execAsync(`tmux capture-pane -t ${window} -p -S -${lines}`);
-            console.log(`Output from ${window} (last ${lines} lines):`);
+            const { stdout } = await execAsync(`tail -n ${lines} "${logFile}"`);
+            console.log(`Logs for ${name} (last ${lines} lines):`);
             console.log('─'.repeat(50));
             console.log(stdout || '(empty)');
         }
         catch (err) {
-            console.error('Failed to capture output:', err.message);
+            console.error('Failed to read logs:', err.message);
         }
     }
 });
-// workers:attach - Attach to a worker's tmux window
-program
-    .command('workers:attach')
-    .description('Attach to a spawned worker tmux window')
-    .argument('<name>', 'Worker name')
-    .action(async (name) => {
-    const window = `${WORKER_SESSION}:${name}`;
-    try {
-        // Check if window exists
-        await execAsync(`tmux has-session -t ${window} 2>/dev/null`);
-    }
-    catch {
-        console.error(`Worker "${name}" not found`);
-        console.log(`Run 'agent-relay workers' to see available workers`);
-        process.exit(1);
-    }
-    console.log(`Attaching to ${window}...`);
-    console.log('(Use Ctrl+B D to detach)');
-    // Spawn tmux attach as a child process with stdio inherited
-    const { spawn } = await import('child_process');
-    const child = spawn('tmux', ['attach-session', '-t', window], {
-        stdio: 'inherit',
-    });
-    child.on('exit', (code) => {
-        process.exit(code || 0);
-    });
-});
-// workers:kill - Kill a spawned worker
+// agents:kill - Kill a spawned agent by PID
 program
-    .command('workers:kill')
-    .description('Kill a spawned worker')
-    .argument('<name>', 'Worker name')
+    .command('agents:kill')
+    .description('Kill a spawned agent')
+    .argument('<name>', 'Agent name')
     .option('--force', 'Skip graceful shutdown, kill immediately')
     .action(async (name, options) => {
-    const window = `${WORKER_SESSION}:${name}`;
-    try {
-        // Check if window exists
-        await execAsync(`tmux has-session -t ${window} 2>/dev/null`);
+    const { getProjectPaths } = await import('../utils/project-namespace.js');
+    const paths = getProjectPaths();
+    const workers = readWorkersMetadata(paths.projectRoot);
+    const worker = workers.find(w => w.name === name);
+    if (!worker) {
+        console.error(`Spawned agent "${name}" not found`);
+        console.log(`Run 'agent-relay agents' to see available agents`);
+        process.exit(1);
     }
-    catch {
-        console.error(`Worker "${name}" not found`);
-        console.log(`Run 'agent-relay workers' to see available workers`);
+    if (!worker.pid) {
+        console.error(`Agent "${name}" has no PID recorded`);
         process.exit(1);
     }
-    if (!options.force) {
-        // Try graceful shutdown first
-        console.log(`Sending /exit to ${name}...`);
-        try {
-            await execAsync(`tmux send-keys -t ${window} '/exit' Enter`);
+    try {
+        if (!options.force) {
+            // Try graceful shutdown first (SIGTERM)
+            console.log(`Sending SIGTERM to ${name} (pid: ${worker.pid})...`);
+            process.kill(worker.pid, 'SIGTERM');
             // Wait for graceful shutdown
             await new Promise(r => setTimeout(r, 2000));
+            // Check if still running
+            try {
+                process.kill(worker.pid, 0); // Check if process exists
+                console.log(`Agent still running, sending SIGKILL...`);
+                process.kill(worker.pid, 'SIGKILL');
+            }
+            catch {
+                // Process no longer exists, graceful shutdown worked
+            }
         }
-        catch {
-            // Ignore errors, will force kill below
+        else {
+            // Force kill immediately
+            console.log(`Force killing ${name} (pid: ${worker.pid})...`);
+            process.kill(worker.pid, 'SIGKILL');
         }
-    }
-    // Kill the window
-    try {
-        await execAsync(`tmux kill-window -t ${window}`);
-        console.log(`Killed worker: ${name}`);
+        console.log(`Killed agent: ${name}`);
     }
     catch (err) {
-        console.error(`Failed to kill ${name}:`, err.message);
-        process.exit(1);
-    }
-});
-// workers:session - Show tmux session info
-program
-    .command('workers:session')
-    .description('Show worker tmux session details')
-    .action(async () => {
-    try {
-        // Check if session exists
-        try {
-            await execAsync(`tmux has-session -t ${WORKER_SESSION} 2>/dev/null`);
+        if (err.code === 'ESRCH') {
+            console.log(`Agent ${name} is no longer running (pid: ${worker.pid})`);
         }
-        catch {
-            console.log(`Session "${WORKER_SESSION}" does not exist`);
-            console.log('Spawn a worker to create it.');
-            return;
+        else {
+            console.error(`Failed to kill ${name}:`, err.message);
+            process.exit(1);
         }
-        console.log(`Session: ${WORKER_SESSION}`);
-        console.log('─'.repeat(50));
-        // Get session info
-        const { stdout: sessionInfo } = await execAsync(`tmux display-message -t ${WORKER_SESSION} -p "Created: #{session_created_string}\\nWindows: #{session_windows}\\nAttached: #{?session_attached,yes,no}"`);
-        console.log(sessionInfo);
-        // List windows
-        console.log('\nWindows:');
-        const { stdout: windows } = await execAsync(`tmux list-windows -t ${WORKER_SESSION} -F "  #{window_index}: #{window_name} (#{pane_current_command})"`);
-        console.log(windows || '  (none)');
-        console.log('\nQuick commands:');
-        console.log(`  tmux attach -t ${WORKER_SESSION}     # Attach to session`);
-        console.log(`  tmux kill-session -t ${WORKER_SESSION}  # Kill entire session`);
-    }
-    catch (err) {
-        console.error('Failed:', err.message);
     }
 });
 program.parse();