agent-relay 1.0.21 → 1.1.0

package/dist/cli/index.js

@@ -17,6 +17,8 @@ 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 { getShadowForAgent } from '../bridge/shadow-config.js';
+import { selectShadowCli } from '../bridge/shadow-cli.js';
 import { checkForUpdatesInBackground, checkForUpdates } from '../utils/update-checker.js';
 import fs from 'node:fs';
 import path from 'node:path';
@@ -53,6 +55,8 @@ program
     .option('-n, --name <name>', 'Agent name (auto-generated if not set)')
     .option('-q, --quiet', 'Disable debug output', false)
     .option('--prefix <pattern>', 'Relay prefix pattern (default: ->relay:)')
+    .option('--shadow <name>', 'Spawn a shadow agent with this name that monitors the primary')
+    .option('--shadow-role <role>', 'Shadow role: reviewer, auditor, or triggers (comma-separated: SESSION_END,CODE_WRITTEN,REVIEW_REQUEST,EXPLICIT_ASK,ALL_MESSAGES)')
     .argument('[command...]', 'Command to wrap (e.g., claude)')
     .action(async (commandParts, options) => {
     // If no command provided, show help
@@ -125,6 +129,76 @@ program
         process.exit(0);
     });
     await wrapper.start();
+    let shadowName;
+    let shadowRole;
+    let speakOn;
+    let shadowCli;
+    let shadowPrompt;
+    const rolePresets = {
+        reviewer: ['CODE_WRITTEN', 'REVIEW_REQUEST', 'EXPLICIT_ASK'],
+        auditor: ['SESSION_END', 'EXPLICIT_ASK'],
+        active: ['ALL_MESSAGES'],
+    };
+    if (options.shadow) {
+        // CLI flags provided
+        shadowName = options.shadow;
+        const role = options.shadowRole || 'EXPLICIT_ASK';
+        shadowRole = role;
+        if (rolePresets[role.toLowerCase()]) {
+            speakOn = rolePresets[role.toLowerCase()];
+        }
+        else {
+            speakOn = role.split(',').map((s) => s.trim().toUpperCase());
+        }
+    }
+    else {
+        // Check config file for shadow configuration
+        const shadowConfig = getShadowForAgent(paths.projectRoot, agentName);
+        if (shadowConfig) {
+            shadowName = shadowConfig.shadowName;
+            shadowRole = shadowConfig.roleName;
+            speakOn = shadowConfig.speakOn;
+            shadowCli = shadowConfig.cli;
+            shadowPrompt = shadowConfig.prompt;
+            console.error(`Shadow config: ${shadowName} (from .agent-relay.json)`);
+        }
+    }
+    // Spawn shadow if configured
+    if (shadowName && speakOn) {
+        // Decide how to run the shadow (subagent for Claude/OpenCode primaries)
+        let shadowSelection = null;
+        try {
+            shadowSelection = await selectShadowCli(mainCommand, { preferredShadowCli: shadowCli });
+            console.error(`[shadow] Mode: ${shadowSelection.mode} via ${shadowSelection.command || shadowSelection.cli} (primary: ${mainCommand})`);
+        }
+        catch (err) {
+            console.error(`[shadow] Shadow CLI selection failed: ${err.message}`);
+        }
+        // Subagent mode: do not spawn a separate shadow process
+        if (shadowSelection?.mode === 'subagent') {
+            console.error(`[shadow] ${shadowName} will run as ${shadowSelection.cli} subagent inside ${agentName}; no separate process spawned`);
+            return;
+        }
+        console.error(`Shadow: ${shadowName} (shadowing ${agentName}, speakOn: ${speakOn.join(',')})`);
+        // Wait for primary to register before spawning shadow
+        await new Promise(r => setTimeout(r, 3000));
+        // Build shadow task prompt
+        const defaultPrompt = `You are a shadow agent monitoring "${agentName}". You receive copies of their messages. Your role: ${shadowRole || 'observer'}. Stay passive unless your triggers activate.`;
+        const shadowTask = shadowPrompt || defaultPrompt;
+        const result = await spawner.spawn({
+            name: shadowName,
+            cli: shadowSelection?.command || shadowCli || mainCommand,
+            task: shadowTask,
+            shadowOf: agentName,
+            shadowSpeakOn: speakOn,
+        });
+        if (result.success) {
+            console.error(`Shadow ${shadowName} started [pid: ${result.pid}]`);
+        }
+        else {
+            console.error(`Failed to spawn shadow ${shadowName}: ${result.error}`);
+        }
+    }
 });
 // up - Start daemon + dashboard
 program
@@ -134,7 +208,67 @@ program
     .option('--port <port>', 'Dashboard port', DEFAULT_DASHBOARD_PORT)
     .option('--spawn', 'Force spawn all agents from teams.json')
     .option('--no-spawn', 'Do not auto-spawn agents (just start daemon)')
+    .option('--watch', 'Auto-restart daemon on crash (supervisor mode)')
+    .option('--max-restarts <n>', 'Max restarts in 60s before giving up (default: 5)', '5')
     .action(async (options) => {
+    // If --watch is specified, run in supervisor mode
+    if (options.watch) {
+        const { spawn } = await import('node:child_process');
+        const maxRestarts = parseInt(options.maxRestarts, 10) || 5;
+        const restartWindow = 60_000; // 60 seconds
+        const restartTimes = [];
+        let child = null;
+        let shuttingDown = false;
+        const startDaemon = () => {
+            // Build args without --watch to prevent infinite recursion
+            const args = ['up'];
+            if (options.dashboard === false)
+                args.push('--no-dashboard');
+            if (options.port)
+                args.push('--port', options.port);
+            if (options.spawn === true)
+                args.push('--spawn');
+            if (options.spawn === false)
+                args.push('--no-spawn');
+            console.log(`[supervisor] Starting daemon...`);
+            child = spawn(process.execPath, [process.argv[1], ...args], {
+                stdio: 'inherit',
+                env: { ...process.env, AGENT_RELAY_SUPERVISED: '1' },
+            });
+            child.on('exit', (code, signal) => {
+                if (shuttingDown) {
+                    process.exit(0);
+                    return;
+                }
+                const now = Date.now();
+                restartTimes.push(now);
+                // Remove restarts outside the window
+                while (restartTimes.length > 0 && restartTimes[0] < now - restartWindow) {
+                    restartTimes.shift();
+                }
+                if (restartTimes.length >= maxRestarts) {
+                    console.error(`[supervisor] Daemon crashed ${maxRestarts} times in ${restartWindow / 1000}s, giving up`);
+                    process.exit(1);
+                }
+                const exitReason = signal ? `signal ${signal}` : `code ${code}`;
+                console.log(`[supervisor] Daemon exited (${exitReason}), restarting in 2s... (${restartTimes.length}/${maxRestarts} restarts)`);
+                setTimeout(startDaemon, 2000);
+            });
+        };
+        process.on('SIGINT', () => {
+            console.log('\n[supervisor] Stopping...');
+            shuttingDown = true;
+            if (child)
+                child.kill('SIGINT');
+        });
+        process.on('SIGTERM', () => {
+            shuttingDown = true;
+            if (child)
+                child.kill('SIGTERM');
+        });
+        startDaemon();
+        return;
+    }
     const { ensureProjectDir } = await import('../utils/project-namespace.js');
     const { loadTeamsConfig } = await import('../bridge/teams-config.js');
     const { AgentSpawner } = await import('../bridge/spawner.js');
@@ -157,6 +291,34 @@ program
     });
     // Create spawner for auto-spawn (will be initialized after dashboard starts)
     let spawner = null;
+    // Track if we're already shutting down to prevent double-cleanup
+    let isShuttingDown = false;
+    const gracefulShutdown = async (reason) => {
+        if (isShuttingDown)
+            return;
+        isShuttingDown = true;
+        console.log(`\n[daemon] ${reason}, shutting down...`);
+        try {
+            if (spawner)
+                await spawner.releaseAll();
+            await daemon.stop();
+        }
+        catch (err) {
+            console.error('[daemon] Error during shutdown:', err);
+        }
+        process.exit(1);
+    };
+    // Handle uncaught exceptions - log and exit (supervisor will restart)
+    process.on('uncaughtException', (err) => {
+        console.error('[daemon] Uncaught exception:', err);
+        gracefulShutdown('Uncaught exception');
+    });
+    // Handle unhandled promise rejections
+    process.on('unhandledRejection', (reason, promise) => {
+        console.error('[daemon] Unhandled rejection at:', promise, 'reason:', reason);
+        // Don't exit on unhandled rejections - just log them
+        // Most are recoverable (e.g., failed message delivery)
+    });
     process.on('SIGINT', async () => {
         console.log('\nStopping...');
         if (spawner) {
@@ -189,6 +351,13 @@ program
                 projectRoot: paths.projectRoot,
             });
             console.log(`Dashboard: http://localhost:${dashboardPort}`);
+            // Hook daemon log output to dashboard WebSocket
+            daemon.onLogOutput = (agentName, data, _timestamp) => {
+                const broadcast = global.__broadcastLogOutput;
+                if (broadcast) {
+                    broadcast(agentName, data);
+                }
+            };
         }
         // Determine if we should auto-spawn agents
         // --spawn: force spawn
@@ -288,9 +457,11 @@ program
     .command('agents')
     .description('List connected agents and spawned workers')
     .option('--all', 'Include internal/CLI agents')
+    .option('--remote', 'Include agents from other linked machines (requires cloud link)')
     .option('--json', 'Output as JSON')
     .action(async (options) => {
     const { getProjectPaths } = await import('../utils/project-namespace.js');
+    const os = await import('node:os');
     const paths = getProjectPaths();
     const agentsPath = path.join(paths.teamDir, 'agents.json');
     // Load registered agents
@@ -311,6 +482,7 @@ program
             lastSeen: agent.lastSeen,
             team: worker?.team,
             pid: worker?.pid,
+            location: 'local',
         });
     });
     // Add workers not in registry (orphaned or not yet registered)
@@ -323,9 +495,51 @@ program
                 cli: worker.cli || '-',
                 team: worker.team,
                 pid: worker.pid,
+                location: 'local',
             });
         }
     });
+    // Include remote agents if --remote flag is set
+    if (options.remote) {
+        const dataDir = process.env.AGENT_RELAY_DATA_DIR ||
+            path.join(os.homedir(), '.local', 'share', 'agent-relay');
+        const configPath = path.join(dataDir, 'cloud-config.json');
+        if (fs.existsSync(configPath)) {
+            try {
+                const config = JSON.parse(fs.readFileSync(configPath, 'utf-8'));
+                const response = await fetch(`${config.cloudUrl}/api/daemons/agents`, {
+                    method: 'POST',
+                    headers: {
+                        'Authorization': `Bearer ${config.apiKey}`,
+                        'Content-Type': 'application/json',
+                    },
+                    body: JSON.stringify({ agents: [] }),
+                });
+                if (response.ok) {
+                    const data = await response.json();
+                    // Add remote agents (exclude local ones by name)
+                    const localNames = new Set(combined.map(a => a.name));
+                    for (const agent of data.allAgents) {
+                        if (!localNames.has(agent.name)) {
+                            combined.push({
+                                name: agent.name,
+                                status: agent.status.toUpperCase(),
+                                cli: '-',
+                                location: agent.daemonName,
+                                daemonId: agent.daemonId,
+                            });
+                        }
+                    }
+                }
+            }
+            catch (err) {
+                console.error('[warn] Failed to fetch remote agents:', err.message);
+            }
+        }
+        else {
+            console.error('[warn] Cloud not linked. Run `agent-relay cloud link` to see remote agents.');
+        }
+    }
     if (options.json) {
         console.log(JSON.stringify(combined, null, 2));
         return;
@@ -335,21 +549,39 @@ program
         console.log(`No agents found. Ensure the daemon is running and agents are connected${hint}.`);
         return;
     }
-    console.log('NAME            STATUS   CLI       TEAM');
-    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 team = agent.team ?? '-';
-        console.log(`${name} ${status} ${cli} ${team}`);
-    });
+    const hasRemote = combined.some(a => a.location !== 'local');
+    if (hasRemote) {
+        console.log('NAME            STATUS   CLI       LOCATION');
+        console.log('─'.repeat(55));
+        combined.forEach((agent) => {
+            const name = agent.name.padEnd(15);
+            const status = agent.status.padEnd(8);
+            const cli = agent.cli.padEnd(9);
+            const location = agent.location ?? 'local';
+            console.log(`${name} ${status} ${cli} ${location}`);
+        });
+    }
+    else {
+        console.log('NAME            STATUS   CLI       TEAM');
+        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 team = agent.team ?? '-';
+            console.log(`${name} ${status} ${cli} ${team}`);
+        });
+    }
     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');
     }
+    if (!options.remote) {
+        console.log('');
+        console.log('Tip: Use --remote to include agents from other linked machines.');
+    }
 });
 // who - Show currently active agents (online within last 30s)
 program
@@ -541,6 +773,7 @@ program
     .description('Bridge multiple projects as orchestrator')
     .argument('[projects...]', 'Project paths to bridge')
     .option('--cli <tool>', 'CLI tool override for all projects')
+    .option('--architect [cli]', 'Spawn an architect agent to coordinate all projects (default: claude)')
     .action(async (projectPaths, options) => {
     const { resolveProjects, validateDaemons } = await import('../bridge/config.js');
     const { MultiProjectClient } = await import('../bridge/multi-project-client.js');
@@ -646,9 +879,106 @@ program
     console.log('Connected to all projects.');
     console.log('');
     console.log('Cross-project messaging:');
-    console.log('  @relay:projectId:agent Message');
-    console.log('  @relay:*:lead Broadcast to all leads');
+    console.log('  ->relay:projectId:agent Message');
+    console.log('  ->relay:*:lead Broadcast to all leads');
     console.log('');
+    // Spawn architect agent if --architect flag is set
+    let architectWrapper = null;
+    if (options.architect !== undefined) {
+        const { TmuxWrapper } = await import('../wrapper/tmux-wrapper.js');
+        // Determine CLI to use (default to claude)
+        const architectCli = typeof options.architect === 'string' ? options.architect : 'claude';
+        // Use first project as the base for the architect
+        const baseProject = valid[0];
+        const basePaths = getProjectPaths(baseProject.path);
+        // Build project context for the architect
+        const projectContext = valid.map(p => `- ${p.id}: ${p.path} (Lead: ${p.leadName})`).join('\n');
+        // Create architect system prompt
+        const architectPrompt = `You are the Architect, a cross-project coordinator overseeing multiple codebases.
+
+## Connected Projects
+${projectContext}
+
+## Your Role
+- Coordinate high-level work across all projects
+- Assign tasks to project leads
+- Ensure consistency and resolve cross-project dependencies
+- Review overall architecture decisions
+
+## Cross-Project Messaging
+
+Use this syntax to message agents in specific projects:
+
+\`\`\`
+->relay:${valid[0].id}:${valid[0].leadName} <<<
+Your message to this project's lead>>>
+
+->relay:${valid.length > 1 ? valid[1].id : valid[0].id}:* <<<
+Broadcast to all agents in a project>>>
+
+->relay:*:* <<<
+Broadcast to ALL agents in ALL projects>>>
+\`\`\`
+
+Format: \`->relay:project-id:agent-name\`
+
+## Getting Started
+1. Check in with each project lead to understand current status
+2. Identify cross-project dependencies
+3. Coordinate work across teams
+
+Start by greeting the project leads and asking for status updates.`;
+        console.log('Spawning Architect agent...');
+        console.log(`  CLI: ${architectCli}`);
+        console.log(`  Base project: ${baseProject.path}`);
+        console.log('');
+        // Determine command and args based on CLI
+        let command;
+        let args = [];
+        if (architectCli === 'claude' || architectCli.startsWith('claude:')) {
+            command = 'claude';
+            args = ['--dangerously-skip-permissions'];
+            // Add model if specified (e.g., claude:opus)
+            if (architectCli.includes(':')) {
+                const model = architectCli.split(':')[1];
+                args.push('--model', model);
+            }
+        }
+        else if (architectCli === 'codex') {
+            command = 'codex';
+            args = ['--dangerously-skip-permissions'];
+        }
+        else {
+            command = architectCli;
+        }
+        try {
+            architectWrapper = new TmuxWrapper({
+                name: 'Architect',
+                command,
+                args,
+                socketPath: basePaths.socketPath,
+                debug: false,
+                useInbox: true,
+                inboxDir: basePaths.dataDir,
+            });
+            await architectWrapper.start();
+            // Wait for agent to be ready, then inject the prompt
+            setTimeout(async () => {
+                try {
+                    await architectWrapper.injectMessage(architectPrompt);
+                    console.log('Architect agent started and initialized.');
+                    console.log('Attach to session: tmux attach -t relay-Architect');
+                    console.log('');
+                }
+                catch (err) {
+                    console.error('Failed to inject architect prompt:', err);
+                }
+            }, 3000);
+        }
+        catch (err) {
+            console.error('Failed to spawn Architect agent:', err);
+        }
+    }
     // Handle messages from projects
     client.onMessage = (projectId, from, payload, messageId) => {
         console.log(`[${projectId}] ${from}: ${payload.body.substring(0, 80)}...`);
@@ -985,6 +1315,40 @@ program
         }
     }
 });
+// release - Release a spawned agent via API (works from any context, no terminal required)
+program
+    .command('release')
+    .description('Release a spawned agent via API (no terminal required)')
+    .argument('<name>', 'Agent name to release')
+    .option('--port <port>', 'Dashboard port', DEFAULT_DASHBOARD_PORT)
+    .action(async (name, options) => {
+    const port = options.port || DEFAULT_DASHBOARD_PORT;
+    try {
+        const response = await fetch(`http://localhost:${port}/api/spawned/${encodeURIComponent(name)}`, {
+            method: 'DELETE',
+        });
+        const result = await response.json();
+        if (result.success) {
+            console.log(`Released agent: ${name}`);
+            process.exit(0);
+        }
+        else {
+            console.error(`Failed to release ${name}: ${result.error || 'Unknown error'}`);
+            process.exit(1);
+        }
+    }
+    catch (err) {
+        // If API call fails, try to provide helpful error message
+        if (err.code === 'ECONNREFUSED') {
+            console.error(`Cannot connect to dashboard at port ${port}. Is the daemon running?`);
+            console.log(`Run 'agent-relay up' to start the daemon.`);
+        }
+        else {
+            console.error(`Failed to release ${name}: ${err.message}`);
+        }
+        process.exit(1);
+    }
+});
 // agents:kill - Kill a spawned agent by PID
 program
     .command('agents:kill')
@@ -1039,5 +1403,426 @@ program
         }
     }
 });
+// ============================================================================
+// Cloud commands
+// ============================================================================
+const cloudCommand = program
+    .command('cloud')
+    .description('Cloud account and sync commands');
+cloudCommand
+    .command('link')
+    .description('Link this machine to your Agent Relay Cloud account')
+    .option('--name <name>', 'Name for this machine')
+    .option('--cloud-url <url>', 'Cloud API URL', process.env.AGENT_RELAY_CLOUD_URL || 'https://api.agent-relay.com')
+    .action(async (options) => {
+    const os = await import('node:os');
+    const crypto = await import('node:crypto');
+    const readline = await import('node:readline');
+    const cloudUrl = options.cloudUrl;
+    const machineName = options.name || os.hostname();
+    // Generate machine ID
+    const dataDir = process.env.AGENT_RELAY_DATA_DIR ||
+        path.join(os.homedir(), '.local', 'share', 'agent-relay');
+    const machineIdPath = path.join(dataDir, 'machine-id');
+    const configPath = path.join(dataDir, 'cloud-config.json');
+    let machineId;
+    if (fs.existsSync(machineIdPath)) {
+        machineId = fs.readFileSync(machineIdPath, 'utf-8').trim();
+    }
+    else {
+        machineId = `${os.hostname()}-${crypto.randomBytes(8).toString('hex')}`;
+        fs.mkdirSync(dataDir, { recursive: true });
+        fs.writeFileSync(machineIdPath, machineId);
+    }
+    console.log('');
+    console.log('🔗 Agent Relay Cloud - Link Machine');
+    console.log('');
+    console.log(`Machine: ${machineName}`);
+    console.log(`ID: ${machineId}`);
+    console.log('');
+    // Generate a temporary code for the browser auth flow
+    const tempCode = crypto.randomBytes(16).toString('hex');
+    // Store temp code for callback
+    const tempCodePath = path.join(dataDir, '.link-code');
+    fs.writeFileSync(tempCodePath, tempCode);
+    const authUrl = `${cloudUrl.replace('/api', '')}/cloud/link?code=${tempCode}&machine=${encodeURIComponent(machineId)}&name=${encodeURIComponent(machineName)}`;
+    console.log('Open this URL in your browser to authenticate:');
+    console.log('');
+    console.log(`  ${authUrl}`);
+    console.log('');
+    // Try to open browser automatically
+    try {
+        const openCommand = process.platform === 'darwin' ? 'open' :
+            process.platform === 'win32' ? 'start' : 'xdg-open';
+        await execAsync(`${openCommand} "${authUrl}"`);
+        console.log('(Browser opened automatically)');
+    }
+    catch {
+        console.log('(Copy the URL above and paste it in your browser)');
+    }
+    console.log('');
+    console.log('After authenticating, paste your API key here:');
+    const rl = readline.createInterface({
+        input: process.stdin,
+        output: process.stdout,
+    });
+    const apiKey = await new Promise((resolve) => {
+        rl.question('API Key: ', (answer) => {
+            rl.close();
+            resolve(answer.trim());
+        });
+    });
+    if (!apiKey || !apiKey.startsWith('ar_live_')) {
+        console.error('');
+        console.error('Invalid API key format. Expected ar_live_...');
+        process.exit(1);
+    }
+    // Verify the API key works
+    console.log('');
+    console.log('Verifying API key...');
+    try {
+        const response = await fetch(`${cloudUrl}/api/daemons/heartbeat`, {
+            method: 'POST',
+            headers: {
+                'Authorization': `Bearer ${apiKey}`,
+                'Content-Type': 'application/json',
+            },
+            body: JSON.stringify({
+                agents: [],
+                metrics: { linkedAt: new Date().toISOString() },
+            }),
+        });
+        if (!response.ok) {
+            const error = await response.text();
+            console.error(`Failed to verify API key: ${error}`);
+            process.exit(1);
+        }
+        // Save config
+        const config = {
+            apiKey,
+            cloudUrl,
+            machineId,
+            machineName,
+            linkedAt: new Date().toISOString(),
+        };
+        fs.writeFileSync(configPath, JSON.stringify(config, null, 2));
+        fs.chmodSync(configPath, 0o600); // Secure the file
+        // Clean up temp code
+        if (fs.existsSync(tempCodePath)) {
+            fs.unlinkSync(tempCodePath);
+        }
+        console.log('');
+        console.log('✓ Machine linked successfully!');
+        console.log('');
+        console.log('Your daemon will now sync with Agent Relay Cloud.');
+        console.log('Run `agent-relay up` to start with cloud sync enabled.');
+        console.log('');
+    }
+    catch (err) {
+        console.error(`Failed to connect to cloud: ${err.message}`);
+        process.exit(1);
+    }
+});
+cloudCommand
+    .command('unlink')
+    .description('Unlink this machine from Agent Relay Cloud')
+    .action(async () => {
+    const os = await import('node:os');
+    const dataDir = process.env.AGENT_RELAY_DATA_DIR ||
+        path.join(os.homedir(), '.local', 'share', 'agent-relay');
+    const configPath = path.join(dataDir, 'cloud-config.json');
+    if (!fs.existsSync(configPath)) {
+        console.log('This machine is not linked to Agent Relay Cloud.');
+        return;
+    }
+    // Read current config
+    const config = JSON.parse(fs.readFileSync(configPath, 'utf-8'));
+    // Delete config file
+    fs.unlinkSync(configPath);
+    console.log('');
+    console.log('✓ Machine unlinked from Agent Relay Cloud');
+    console.log('');
+    console.log(`Machine ID: ${config.machineId}`);
+    console.log(`Was linked since: ${config.linkedAt}`);
+    console.log('');
+    console.log('Note: The API key has been removed locally. To fully revoke access,');
+    console.log('visit your Agent Relay Cloud dashboard and remove this machine.');
+    console.log('');
+});
+cloudCommand
+    .command('status')
+    .description('Show cloud sync status')
+    .action(async () => {
+    const os = await import('node:os');
+    const dataDir = process.env.AGENT_RELAY_DATA_DIR ||
+        path.join(os.homedir(), '.local', 'share', 'agent-relay');
+    const configPath = path.join(dataDir, 'cloud-config.json');
+    if (!fs.existsSync(configPath)) {
+        console.log('');
+        console.log('Cloud sync: Not configured');
+        console.log('');
+        console.log('Run `agent-relay cloud link` to connect to Agent Relay Cloud.');
+        console.log('');
+        return;
+    }
+    const config = JSON.parse(fs.readFileSync(configPath, 'utf-8'));
+    console.log('');
+    console.log('Cloud sync: Enabled');
+    console.log('');
+    console.log(`  Machine: ${config.machineName}`);
+    console.log(`  ID: ${config.machineId}`);
+    console.log(`  Cloud URL: ${config.cloudUrl}`);
+    console.log(`  Linked: ${new Date(config.linkedAt).toLocaleString()}`);
+    console.log('');
+    // Check if daemon is running and connected
+    const { getProjectPaths } = await import('../utils/project-namespace.js');
+    const paths = getProjectPaths();
+    if (fs.existsSync(paths.socketPath)) {
+        console.log('  Daemon: Running');
+        // Try to get cloud sync status from daemon
+        try {
+            const response = await fetch(`${config.cloudUrl}/api/daemons/heartbeat`, {
+                method: 'POST',
+                headers: {
+                    'Authorization': `Bearer ${config.apiKey}`,
+                    'Content-Type': 'application/json',
+                },
+                body: JSON.stringify({ agents: [], metrics: {} }),
+            });
+            if (response.ok) {
+                console.log('  Cloud connection: Online');
+            }
+            else {
+                console.log('  Cloud connection: Error (API key may be invalid)');
+            }
+        }
+        catch (err) {
+            console.log(`  Cloud connection: Offline (${err.message})`);
+        }
+    }
+    else {
+        console.log('  Daemon: Not running');
+        console.log('  Cloud connection: Offline (daemon not started)');
+    }
+    console.log('');
+});
+cloudCommand
+    .command('sync')
+    .description('Manually sync credentials from cloud')
+    .action(async () => {
+    const os = await import('node:os');
+    const dataDir = process.env.AGENT_RELAY_DATA_DIR ||
+        path.join(os.homedir(), '.local', 'share', 'agent-relay');
+    const configPath = path.join(dataDir, 'cloud-config.json');
+    if (!fs.existsSync(configPath)) {
+        console.error('Not linked to cloud. Run `agent-relay cloud link` first.');
+        process.exit(1);
+    }
+    const config = JSON.parse(fs.readFileSync(configPath, 'utf-8'));
+    console.log('Syncing credentials from cloud...');
+    try {
+        const response = await fetch(`${config.cloudUrl}/api/daemons/credentials`, {
+            headers: {
+                'Authorization': `Bearer ${config.apiKey}`,
+            },
+        });
+        if (!response.ok) {
+            const error = await response.text();
+            console.error(`Failed to sync: ${error}`);
+            process.exit(1);
+        }
+        const data = await response.json();
+        console.log('');
+        console.log(`Synced ${data.credentials.length} provider credentials:`);
+        for (const cred of data.credentials) {
+            console.log(`  - ${cred.provider}`);
+        }
+        // Save credentials locally for daemon to use
+        const credentialsPath = path.join(dataDir, 'cloud-credentials.json');
+        fs.writeFileSync(credentialsPath, JSON.stringify(data.credentials, null, 2));
+        fs.chmodSync(credentialsPath, 0o600);
+        console.log('');
+        console.log('✓ Credentials synced successfully');
+        console.log('');
+    }
+    catch (err) {
+        console.error(`Failed to sync: ${err.message}`);
+        process.exit(1);
+    }
+});
+cloudCommand
+    .command('agents')
+    .description('List agents across all linked machines')
+    .option('--json', 'Output as JSON')
+    .action(async (options) => {
+    const os = await import('node:os');
+    const dataDir = process.env.AGENT_RELAY_DATA_DIR ||
+        path.join(os.homedir(), '.local', 'share', 'agent-relay');
+    const configPath = path.join(dataDir, 'cloud-config.json');
+    if (!fs.existsSync(configPath)) {
+        console.error('Not linked to cloud. Run `agent-relay cloud link` first.');
+        process.exit(1);
+    }
+    const config = JSON.parse(fs.readFileSync(configPath, 'utf-8'));
+    try {
+        // Get agents from cloud
+        const response = await fetch(`${config.cloudUrl}/api/daemons/agents`, {
+            method: 'POST',
+            headers: {
+                'Authorization': `Bearer ${config.apiKey}`,
+                'Content-Type': 'application/json',
+            },
+            body: JSON.stringify({ agents: [] }), // Report no agents, just fetch list
+        });
+        if (!response.ok) {
+            const error = await response.text();
+            console.error(`Failed to fetch agents: ${error}`);
+            process.exit(1);
+        }
+        const data = await response.json();
+        if (options.json) {
+            console.log(JSON.stringify(data.allAgents, null, 2));
+            return;
+        }
+        if (!data.allAgents.length) {
+            console.log('No agents found across linked machines.');
+            console.log('Make sure daemons are running on linked machines.');
+            return;
+        }
+        console.log('');
+        console.log('Agents across all linked machines:');
+        console.log('');
+        console.log('NAME            STATUS   DAEMON              MACHINE');
+        console.log('─'.repeat(65));
+        // Group by daemon
+        const byDaemon = new Map();
+        for (const agent of data.allAgents) {
+            const existing = byDaemon.get(agent.daemonName) || [];
+            existing.push(agent);
+            byDaemon.set(agent.daemonName, existing);
+        }
+        for (const [daemonName, agents] of byDaemon.entries()) {
+            for (const agent of agents) {
+                const name = agent.name.padEnd(15);
+                const status = agent.status.padEnd(8);
+                const daemon = daemonName.padEnd(18);
+                const machine = agent.machineId.substring(0, 20);
+                console.log(`${name} ${status} ${daemon} ${machine}`);
+            }
+        }
+        console.log('');
+        console.log(`Total: ${data.allAgents.length} agents on ${byDaemon.size} machines`);
+        console.log('');
+    }
+    catch (err) {
+        console.error(`Failed to fetch agents: ${err.message}`);
+        process.exit(1);
+    }
+});
+cloudCommand
+    .command('send')
+    .description('Send a message to an agent on any linked machine')
+    .argument('<agent>', 'Target agent name')
+    .argument('<message>', 'Message to send')
+    .option('--from <name>', 'Sender name', 'cli')
+    .action(async (agent, message, options) => {
+    const os = await import('node:os');
+    const dataDir = process.env.AGENT_RELAY_DATA_DIR ||
+        path.join(os.homedir(), '.local', 'share', 'agent-relay');
+    const configPath = path.join(dataDir, 'cloud-config.json');
+    if (!fs.existsSync(configPath)) {
+        console.error('Not linked to cloud. Run `agent-relay cloud link` first.');
+        process.exit(1);
+    }
+    const config = JSON.parse(fs.readFileSync(configPath, 'utf-8'));
+    console.log(`Sending message to ${agent}...`);
+    try {
+        // First, find which daemon the agent is on
+        const agentsResponse = await fetch(`${config.cloudUrl}/api/daemons/agents`, {
+            method: 'POST',
+            headers: {
+                'Authorization': `Bearer ${config.apiKey}`,
+                'Content-Type': 'application/json',
+            },
+            body: JSON.stringify({ agents: [] }),
+        });
+        if (!agentsResponse.ok) {
+            const error = await agentsResponse.text();
+            console.error(`Failed to find agent: ${error}`);
+            process.exit(1);
+        }
+        const agentsData = await agentsResponse.json();
+        const targetAgent = agentsData.allAgents.find(a => a.name === agent);
+        if (!targetAgent) {
+            console.error(`Agent "${agent}" not found.`);
+            console.log('Available agents:');
+            for (const a of agentsData.allAgents) {
+                console.log(`  - ${a.name} (on ${a.daemonName})`);
+            }
+            process.exit(1);
+        }
+        // Send the message
+        const sendResponse = await fetch(`${config.cloudUrl}/api/daemons/message`, {
+            method: 'POST',
+            headers: {
+                'Authorization': `Bearer ${config.apiKey}`,
+                'Content-Type': 'application/json',
+            },
+            body: JSON.stringify({
+                targetDaemonId: targetAgent.daemonId,
+                targetAgent: agent,
+                message: {
+                    from: options.from,
+                    content: message,
+                },
+            }),
+        });
+        if (!sendResponse.ok) {
+            const error = await sendResponse.text();
+            console.error(`Failed to send message: ${error}`);
+            process.exit(1);
+        }
+        console.log('');
+        console.log(`✓ Message sent to ${agent} on ${targetAgent.daemonName}`);
+        console.log('');
+    }
+    catch (err) {
+        console.error(`Failed to send message: ${err.message}`);
+        process.exit(1);
+    }
+});
+cloudCommand
+    .command('daemons')
+    .description('List all linked daemon instances')
+    .option('--json', 'Output as JSON')
+    .action(async (options) => {
+    const os = await import('node:os');
+    const dataDir = process.env.AGENT_RELAY_DATA_DIR ||
+        path.join(os.homedir(), '.local', 'share', 'agent-relay');
+    const configPath = path.join(dataDir, 'cloud-config.json');
+    if (!fs.existsSync(configPath)) {
+        console.error('Not linked to cloud. Run `agent-relay cloud link` first.');
+        process.exit(1);
+    }
+    const config = JSON.parse(fs.readFileSync(configPath, 'utf-8'));
+    try {
+        // Get daemons list (requires browser auth, so we use a workaround)
+        // For now, just show what we know about our own daemon
+        console.log('');
+        console.log('Linked Daemon:');
+        console.log('');
+        console.log(`  Machine: ${config.machineName}`);
+        console.log(`  ID: ${config.machineId}`);
+        console.log(`  Cloud: ${config.cloudUrl}`);
+        console.log(`  Linked: ${new Date(config.linkedAt).toLocaleString()}`);
+        console.log('');
+        console.log('Note: To see all linked daemons, visit your cloud dashboard.');
+        console.log('');
+    }
+    catch (err) {
+        console.error(`Failed: ${err.message}`);
+        process.exit(1);
+    }
+});
 program.parse();
 //# sourceMappingURL=index.js.map