agent-relay 1.3.1 → 1.3.3

package/dist/cli/index.js

@@ -3,12 +3,14 @@
  * Agent Relay CLI
  *
  * Commands:
- *   relay <cmd>         - Wrap agent with real-time messaging (default)
- *   relay -n Name cmd   - Wrap with specific agent name
- *   relay up            - Start daemon + dashboard
- *   relay read <id>     - Read full message by ID
- *   relay agents        - List connected agents
- *   relay who           - Show currently active agents
+ *   relay claude                   - Start daemon + Dashboard coordinator with Claude
+ *   relay codex                    - Start daemon + Dasbboard coordinator with Codex
+ *   relay create-agent <cmd>       - Wrap agent with real-time messaging
+ *   relay create-agent -n Name cmd - Wrap with specific agent name
+ *   relay up                       - Start daemon + dashboard
+ *   relay read <id>                - Read full message by ID
+ *   relay agents                   - List connected agents
+ *   relay who                      - Show currently active agents
  */
 import { Command } from 'commander';
 import { config as dotenvConfig } from 'dotenv';
@@ -36,7 +38,7 @@ 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 interactiveCommands = ['up', 'down', 'status', 'agents', 'who', 'version', '--version', '-V', '--help', '-h', 'create-agent', 'claude', 'codex'];
 const shouldCheckUpdates = process.argv.length > 2 &&
     interactiveCommands.includes(process.argv[2]);
 if (shouldCheckUpdates) {
@@ -50,21 +52,19 @@ program
     .name('agent-relay')
     .description('Agent-to-agent messaging')
     .version(VERSION, '-V, --version', 'Output the version number');
-// Default action = wrap agent
+// create-agent - Wrap agent with real-time messaging
 program
+    .command('create-agent')
+    .description('Wrap an agent with real-time messaging')
     .option('-n, --name <name>', 'Agent name (auto-generated if not set)')
-    .option('-q, --quiet', 'Disable debug output', false)
+    .option('-d, --debug', 'Enable debug output')
     .option('--prefix <pattern>', 'Relay prefix pattern (default: ->relay:)')
     .option('--dashboard-port <port>', 'Dashboard port for spawn/release API (auto-detected if not set)')
     .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)')
+    .option('--skip-instructions', 'Skip initial instruction injection (use with --append-system-prompt)')
+    .argument('<command...>', 'Command to wrap (e.g., claude)')
     .action(async (commandParts, options) => {
-    // If no command provided, show help
-    if (!commandParts || commandParts.length === 0) {
-        program.help();
-        return;
-    }
     const { getProjectPaths } = await import('../utils/project-namespace.js');
     const { findAgentConfig, isClaudeCli, buildClaudeArgs } = await import('../utils/agent-config.js');
     const paths = getProjectPaths();
@@ -93,20 +93,29 @@ program
         dashboardPort = parseInt(options.dashboardPort, 10);
     }
     else {
-        // Try to detect if dashboard is running at default port
-        const defaultPort = parseInt(DEFAULT_DASHBOARD_PORT, 10);
-        try {
-            const response = await fetch(`http://localhost:${defaultPort}/api/status`, {
-                method: 'GET',
-                signal: AbortSignal.timeout(500), // Quick timeout for detection
-            });
-            if (response.ok) {
-                dashboardPort = defaultPort;
-                console.error(`Dashboard detected: http://localhost:${dashboardPort}`);
+        // Try to detect if dashboard is running at common ports
+        const portsToTry = [
+            parseInt(DEFAULT_DASHBOARD_PORT, 10),
+            3889, 3890, 3891, // Common fallback ports when default is in use
+        ];
+        for (const port of portsToTry) {
+            try {
+                const response = await fetch(`http://localhost:${port}/api/health`, {
+                    method: 'GET',
+                    signal: AbortSignal.timeout(300), // Quick timeout for detection
+                });
+                if (response.ok) {
+                    const health = await response.json();
+                    if (health.status === 'healthy') {
+                        dashboardPort = port;
+                        console.error(`Dashboard detected: http://localhost:${dashboardPort}`);
+                        break;
+                    }
+                }
+            }
+            catch {
+                // Try next port
             }
-        }
-        catch {
-            // Dashboard not running - spawn/release will use fallback callbacks
         }
     }
     // Create spawner as fallback for direct spawn (if dashboard API not available)
@@ -116,10 +125,11 @@ program
         command: mainCommand,
         args: finalArgs,
         socketPath: paths.socketPath,
-        debug: false, // Use -q to keep quiet (debug off by default)
+        debug: options.debug ?? false,
         relayPrefix: options.prefix,
         useInbox: true,
         inboxDir: paths.dataDir, // Use the project-specific data directory for the inbox
+        skipInstructions: options.skipInstructions,
         // Use dashboard API for spawn/release when available (preferred - works from any context)
         dashboardPort,
         // Wire up spawn/release callbacks as fallback (if no dashboardPort)
@@ -448,6 +458,162 @@ program
         console.log('Cleaned up stale pid');
     }
 });
+// System prompt for Dashboard agent - plain text to avoid shell escaping issues
+const MEGA_SYSTEM_PROMPT = [
+    'You are Dashboard, a lead coordinator in agent-relay.',
+    'Your PRIMARY job is to delegate - you should almost NEVER do implementation work yourself.',
+    'ALWAYS SPAWN AGENTS: For any non-trivial task, spawn specialized workers.',
+].join(' ');
+// Helper function for starting Dashboard coordinator with a specific provider
+async function startDashboardCoordinator(operator) {
+    const { spawn } = await import('node:child_process');
+    const { getProjectPaths } = await import('../utils/project-namespace.js');
+    const { resolveTmux, TmuxNotFoundError } = await import('../utils/tmux-resolver.js');
+    // Check for tmux first
+    const tmuxInfo = resolveTmux();
+    if (!tmuxInfo) {
+        const error = new TmuxNotFoundError();
+        console.error(`Error: ${error.message}`);
+        process.exit(1);
+    }
+    const paths = getProjectPaths();
+    console.log(`Starting Dashboard with ${operator}...`);
+    console.log(`Project: ${paths.projectRoot}`);
+    console.log(`Tmux: ${tmuxInfo.path} (v${tmuxInfo.version})`);
+    // Step 1: Check if daemon is already running, start if needed
+    console.log('\n[1/3] Checking daemon...');
+    // Check if socket exists (daemon running)
+    const socketExists = fs.existsSync(paths.socketPath);
+    // Ports to try for dashboard detection
+    const portsToTry = [
+        parseInt(DEFAULT_DASHBOARD_PORT, 10),
+        3889, 3890, 3891,
+    ];
+    // Check if dashboard is responding for THIS project
+    let dashboardReady = false;
+    let detectedPort;
+    // Helper to check health at a port
+    const checkPort = async (port) => {
+        try {
+            const response = await fetch(`http://localhost:${port}/api/health`, {
+                signal: AbortSignal.timeout(500),
+            });
+            if (response.ok) {
+                const health = await response.json();
+                return health.status === 'healthy';
+            }
+        }
+        catch {
+            // Port not responding
+        }
+        return false;
+    };
+    if (socketExists) {
+        for (const port of portsToTry) {
+            if (await checkPort(port)) {
+                dashboardReady = true;
+                detectedPort = port;
+                break;
+            }
+        }
+    }
+    if (dashboardReady && detectedPort) {
+        console.log(`Daemon already running at port ${detectedPort}, reusing...`);
+    }
+    else {
+        console.log('Starting daemon...');
+        const daemonProc = spawn(process.execPath, [process.argv[1], 'up'], {
+            stdio: 'ignore',
+            detached: true,
+        });
+        daemonProc.unref();
+        // Wait for dashboard to be ready (up to 10 seconds)
+        const maxWait = 10000;
+        const startTime = Date.now();
+        while (Date.now() - startTime < maxWait) {
+            await new Promise((resolve) => setTimeout(resolve, 500));
+            for (const port of portsToTry) {
+                if (await checkPort(port)) {
+                    dashboardReady = true;
+                    detectedPort = port;
+                    break;
+                }
+            }
+            if (dashboardReady)
+                break;
+        }
+        if (!dashboardReady) {
+            console.error('Warning: Dashboard may not be fully ready. Spawn might not work.');
+            detectedPort = parseInt(DEFAULT_DASHBOARD_PORT, 10); // Fallback
+        }
+    }
+    const dashboardPort = detectedPort || parseInt(DEFAULT_DASHBOARD_PORT, 10);
+    // Step 2: Install prpm snippet via npx
+    console.log('[2/3] Installing agent-relay snippet...');
+    const prpmArgs = operator.toLowerCase() === 'claude'
+        ? ['prpm', 'install', '@agent-relay/agent-relay-snippet', '--location', 'CLAUDE.md']
+        : ['prpm', 'install', '@agent-relay/agent-relay-snippet'];
+    try {
+        await new Promise((resolve, reject) => {
+            const prpmProc = spawn('npx', prpmArgs, {
+                stdio: 'inherit',
+            });
+            prpmProc.on('close', (code) => {
+                if (code === 0)
+                    resolve();
+                else
+                    reject(new Error(`npx prpm exited with code ${code}`));
+            });
+            prpmProc.on('error', reject);
+        });
+    }
+    catch (err) {
+        console.warn(`Warning: prpm install failed: ${err.message}`);
+        console.warn('Continuing without snippet installation...');
+    }
+    // Step 3: Start Dashboard agent with system prompt
+    console.log(`[3/3] Starting Dashboard agent with ${operator}...`);
+    console.log('');
+    const op = operator.toLowerCase();
+    // Build CLI-specific arguments for system prompt
+    // These args go AFTER the operator command, passed through to the CLI
+    let cliArgs = [];
+    if (op === 'claude') {
+        // Claude: --append-system-prompt <content> (takes content directly, not file)
+        cliArgs = ['--append-system-prompt', MEGA_SYSTEM_PROMPT];
+    }
+    else if (op === 'codex') {
+        // Codex: --config developer_instructions="<content>"
+        cliArgs = ['--config', `developer_instructions=${MEGA_SYSTEM_PROMPT}`];
+    }
+    // Use '--' to separate agent-relay options from the command + its args
+    // Format: agent-relay create-agent -n Dashboard --skip-instructions --dashboard-port <port> -- claude --append-system-prompt "..."
+    const agentProc = spawn(process.execPath, [process.argv[1], 'create-agent', '-n', 'Dashboard', '--skip-instructions', '--dashboard-port', String(dashboardPort), '--', operator, ...cliArgs], { stdio: 'inherit' });
+    // Forward signals to agent process
+    process.on('SIGINT', () => {
+        agentProc.kill('SIGINT');
+    });
+    process.on('SIGTERM', () => {
+        agentProc.kill('SIGTERM');
+    });
+    agentProc.on('close', (code) => {
+        process.exit(code ?? 0);
+    });
+}
+// claude - Start daemon and spawn Dashboard coordinator with Claude
+program
+    .command('claude')
+    .description('Start daemon and Dashboard coordinator with Claude')
+    .action(async () => {
+    await startDashboardCoordinator('claude');
+});
+// codex - Start daemon and spawn Dashboard coordinator with Codex
+program
+    .command('codex')
+    .description('Start daemon and Dashboard coordinator with Codex')
+    .action(async () => {
+    await startDashboardCoordinator('codex');
+});
 // status - Check daemon status
 program
     .command('status')
@@ -1341,6 +1507,105 @@ program
         }
     }
 });
+// spawn - Spawn an agent via API (works from any context, no tmux required)
+program
+    .command('spawn', { hidden: true })
+    .description('Spawn an agent via dashboard API (no tmux required, works in containers)')
+    .argument('<name>', 'Agent name')
+    .argument('<cli>', 'CLI to use (claude, codex, gemini, etc.)')
+    .argument('[task]', 'Task description (can also be piped via stdin)')
+    .option('--port <port>', 'Dashboard port', DEFAULT_DASHBOARD_PORT)
+    .option('--team <team>', 'Team name for the agent')
+    .option('--spawner <name>', 'Name of the agent requesting the spawn (for policy enforcement)')
+    .option('--interactive', 'Disable auto-accept of permission prompts (for auth setup flows)')
+    .option('--cwd <path>', 'Working directory for the agent')
+    .option('--shadow-mode <mode>', 'Shadow execution mode: subagent or process')
+    .option('--shadow-of <name>', 'Primary agent to shadow (if this agent is a shadow)')
+    .option('--shadow-agent <profile>', 'Shadow agent profile to use')
+    .option('--shadow-triggers <triggers>', 'When to trigger shadow (comma-separated: SESSION_END,CODE_WRITTEN,REVIEW_REQUEST,EXPLICIT_ASK,ALL_MESSAGES)')
+    .option('--shadow-speak-on <triggers>', 'When shadow should speak (comma-separated, same values as --shadow-triggers)')
+    .action(async (name, cli, task, options) => {
+    const port = options.port || DEFAULT_DASHBOARD_PORT;
+    // Read task from stdin if not provided as argument
+    let finalTask = task;
+    if (!finalTask && !process.stdin.isTTY) {
+        const chunks = [];
+        for await (const chunk of process.stdin) {
+            chunks.push(chunk);
+        }
+        finalTask = Buffer.concat(chunks).toString('utf-8').trim();
+    }
+    if (!finalTask) {
+        console.error('Error: Task description required (as argument or via stdin)');
+        process.exit(1);
+    }
+    // Validate shadow mode if provided
+    if (options.shadowMode && !['subagent', 'process'].includes(options.shadowMode)) {
+        console.error('Error: --shadow-mode must be "subagent" or "process"');
+        process.exit(1);
+    }
+    // Parse comma-separated trigger lists
+    const parseTriggers = (value) => {
+        if (!value)
+            return undefined;
+        const validTriggers = ['SESSION_END', 'CODE_WRITTEN', 'REVIEW_REQUEST', 'EXPLICIT_ASK', 'ALL_MESSAGES'];
+        const triggers = value.split(',').map(t => t.trim().toUpperCase());
+        const invalid = triggers.filter(t => !validTriggers.includes(t));
+        if (invalid.length > 0) {
+            console.error(`Error: Invalid triggers: ${invalid.join(', ')}`);
+            console.error(`Valid triggers: ${validTriggers.join(', ')}`);
+            process.exit(1);
+        }
+        return triggers;
+    };
+    try {
+        // Build spawn request using the SpawnRequest type for consistency
+        const spawnRequest = {
+            name,
+            cli,
+            task: finalTask,
+            team: options.team,
+            spawnerName: options.spawner,
+            interactive: options.interactive,
+            cwd: options.cwd,
+            shadowMode: options.shadowMode,
+            shadowOf: options.shadowOf,
+            shadowAgent: options.shadowAgent,
+            shadowTriggers: parseTriggers(options.shadowTriggers),
+            shadowSpeakOn: parseTriggers(options.shadowSpeakOn),
+        };
+        const response = await fetch(`http://localhost:${port}/api/spawn`, {
+            method: 'POST',
+            headers: { 'Content-Type': 'application/json' },
+            body: JSON.stringify(spawnRequest),
+        });
+        const result = await response.json();
+        if (result.success) {
+            console.log(`Spawned agent: ${name} (pid: ${result.pid})`);
+            process.exit(0);
+        }
+        else {
+            if (result.policyDecision) {
+                console.error(`Policy denied spawn: ${result.policyDecision.reason}`);
+                console.error(`Policy source: ${result.policyDecision.policySource}`);
+            }
+            else {
+                console.error(`Failed to spawn ${name}: ${result.error || 'Unknown error'}`);
+            }
+            process.exit(1);
+        }
+    }
+    catch (err) {
+        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 spawn ${name}: ${err.message}`);
+        }
+        process.exit(1);
+    }
+});
 // release - Release a spawned agent via API (works from any context, no terminal required)
 program
     .command('release')
@@ -1439,7 +1704,7 @@ 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')
+    .option('--cloud-url <url>', 'Cloud API URL', process.env.AGENT_RELAY_CLOUD_URL || 'https://agent-relay.com')
     .action(async (options) => {
     const os = await import('node:os');
     const crypto = await import('node:crypto');
@@ -1720,6 +1985,8 @@ program
         stdio: 'inherit',
         env: {
             ...process.env,
+            // Trajectory env vars override parent shell settings
+            // This ensures config-based TRAJECTORIES_DATA_DIR takes precedence
             TRAJECTORIES_PROJECT: paths.projectId,
             TRAJECTORIES_DATA_DIR: trajectoriesDir,
         },

package/dist/cloud/api/admin.js

@@ -43,7 +43,7 @@ adminRouter.use(requireAdminAuth);
  * - batchSize?: Number of concurrent updates (default: 5)
  *
  * Response:
- * - summary: { total, updated, pendingRestart, skippedActiveAgents, skippedNotRunning, errors }
+ * - summary: { total, updated, pendingRestart, skippedActiveAgents, skippedVerificationFailed, skippedNotRunning, errors }
  * - results: Array of per-workspace results
  */
 adminRouter.post('/workspaces/update-image', async (req, res) => {
@@ -159,7 +159,9 @@ adminRouter.get('/workspaces/:id/agents', async (req, res) => {
             return;
         }
         try {
-            const response = await fetch(`${baseUrl}/api/agents`, {
+            // Use /api/data endpoint which returns { agents: [...], ... }
+            // Note: /api/agents doesn't exist on the workspace dashboard-server
+            const response = await fetch(`${baseUrl}/api/data`, {
                 method: 'GET',
                 headers: { 'Accept': 'application/json' },
                 signal: AbortSignal.timeout(10_000),
@@ -170,7 +172,18 @@ adminRouter.get('/workspaces/:id/agents', async (req, res) => {
             }
             const data = await response.json();
             const agents = data.agents || [];
-            const activeAgents = agents.filter(a => a.status === 'running' || a.activityState === 'active' || a.activityState === 'idle');
+            const activeAgents = agents.filter(a => {
+                const status = (a.status ?? '').toLowerCase();
+                const activityState = (a.activityState ?? '').toLowerCase();
+                const isProcessing = a.isProcessing === true;
+                if (activityState === 'active' || activityState === 'idle')
+                    return true;
+                if (status && status !== 'disconnected' && status !== 'offline')
+                    return true;
+                if (isProcessing)
+                    return true;
+                return false;
+            });
             res.json({
                 hasActiveAgents: activeAgents.length > 0,
                 agentCount: activeAgents.length,

package/dist/cloud/api/codex-auth-helper.js

@@ -19,6 +19,7 @@ import { requireAuth } from './auth.js';
 import { db } from '../db/index.js';
 import { deriveSshPassword } from '../services/ssh-security.js';
 export const codexAuthHelperRouter = Router();
+const WORKSPACE_SSH_PORT = 3022;
 const pendingAuthSessions = new Map();
 const pendingCliTokens = new Map();
 // Clean up old sessions every minute
@@ -201,18 +202,18 @@ codexAuthHelperRouter.get('/tunnel-info/:workspaceId', async (req, res) => {
         const host = url.hostname;
         const apiPort = parseInt(url.port, 10) || 80;
         // SSH connection info varies by environment:
-        // - Fly.io: Use public fly.dev hostname with port 2222 (exposed via TCP service)
+        // - Fly.io: Use public fly.dev hostname with port 3022 (exposed via TCP service)
         // - Local Docker: Use localhost with derived SSH port (22000 + apiPort - 3000)
         const isOnFly = !!process.env.FLY_APP_NAME;
         const isLocalDocker = (host === 'localhost' || host === '127.0.0.1') && apiPort >= 3000;
         let sshHost;
         let sshPort;
         if (isOnFly) {
-            // Fly.io public hostname - SSH is exposed as a public TCP service on port 2222
-            // Users can SSH directly from their machine to {app}.fly.dev:2222
+            // Fly.io public hostname - SSH is exposed as a public TCP service on port 3022
+            // Users can SSH directly from their machine to {app}.fly.dev:3022
             const appName = `ar-${workspace.id.substring(0, 8)}`;
             sshHost = `${appName}.fly.dev`;
-            sshPort = 2222;
+            sshPort = WORKSPACE_SSH_PORT;
         }
         else if (isLocalDocker) {
             // Local Docker: SSH port is derived from API port
@@ -223,7 +224,7 @@ codexAuthHelperRouter.get('/tunnel-info/:workspaceId', async (req, res) => {
         else {
             // Default fallback
             sshHost = host;
-            sshPort = 2222;
+            sshPort = WORKSPACE_SSH_PORT;
         }
         // SSH password is derived per-workspace for security
         // Each workspace gets a unique password based on its ID + secret salt
@@ -288,18 +289,37 @@ codexAuthHelperRouter.get('/auth-status/:workspaceId', async (req, res) => {
         if (!workspace.publicUrl) {
             return res.status(400).json({ error: 'Workspace URL not available' });
         }
-        // Check with workspace daemon if Codex is authenticated
-        const response = await fetch(`${workspace.publicUrl}/auth/cli/openai/check`, {
+        // Check with workspace daemon if Codex is authenticated for this specific user
+        // Pass userId to enable per-user credential checking (multiple users can share a workspace)
+        const checkUrl = new URL(`${workspace.publicUrl}/auth/cli/openai/check`);
+        checkUrl.searchParams.set('userId', userId);
+        const response = await fetch(checkUrl.toString(), {
             method: 'GET',
             signal: AbortSignal.timeout(5000),
         });
         if (response.ok) {
             const data = await response.json();
+            // When authentication is detected, mark the provider as connected in the database
+            // This ensures the dashboard shows correct per-user connection status
+            if (data.authenticated && userId) {
+                try {
+                    await db.credentials.upsert({
+                        userId,
+                        provider: 'codex', // Codex provider for OpenAI
+                        scopes: [],
+                    });
+                    console.log(`[codex-helper] Marked codex as connected for user ${userId}`);
+                }
+                catch (dbError) {
+                    console.error('[codex-helper] Failed to mark provider as connected:', dbError);
+                    // Don't fail the request if DB update fails
+                }
+            }
             return res.json({ authenticated: data.authenticated });
         }
         res.json({ authenticated: false });
     }
-    catch (error) {
+    catch (_error) {
         // Workspace might not be reachable, return false
         res.json({ authenticated: false });
     }

package/dist/cloud/api/consensus.d.ts

@@ -0,0 +1,13 @@
+/**
+ * Consensus API Routes (Read-Only)
+ *
+ * Provides API endpoints for observing multi-agent consensus decisions.
+ * The dashboard is read-only - agents handle all consensus activity via relay messages.
+ *
+ * Architecture:
+ * - Agents create proposals and vote via ->relay:_consensus messages
+ * - The daemon processes these and syncs state to cloud via /sync endpoint
+ * - Dashboard reads consensus state for display only
+ */
+export declare const consensusRouter: import("express-serve-static-core").Router;
+//# sourceMappingURL=consensus.d.ts.map