maestro-flow 0.1.4 → 0.2.1

package/dist/agents/cli-agent-runner.js

@@ -3,34 +3,54 @@
 // Orchestrates adapter selection, process spawning, stdout rendering, and
 // exit handling for the `maestro cli` command.
 // ---------------------------------------------------------------------------
-import { resolve } from 'node:path';
+import { resolve, join } from 'node:path';
 import { pathToFileURL } from 'node:url';
 import { randomBytes } from 'node:crypto';
-import { readFileSync } from 'node:fs';
+import { spawn } from 'node:child_process';
+import { readFileSync, appendFileSync, existsSync } from 'node:fs';
+import { tmpdir } from 'node:os';
 import { DashboardBridge } from './dashboard-bridge.js';
 import { CliHistoryStore } from './cli-history-store.js';
 import { loadTemplate, loadProtocol } from '../config/template-discovery.js';
+import { NOTIFY_PREFIX } from '../hooks/constants.js';
+import { DelegateBrokerClient } from '../async/index.js';
 // ---------------------------------------------------------------------------
 // Tool name -> AgentType mapping
 // ---------------------------------------------------------------------------
 const TOOL_TO_AGENT_TYPE = {
     gemini: 'gemini',
+    'gemini-a2a': 'gemini-a2a',
     qwen: 'qwen',
     codex: 'codex',
+    'codex-server': 'codex-server',
     claude: 'claude-code',
     opencode: 'opencode',
 };
 // ---------------------------------------------------------------------------
+// AgentType -> terminal CLI command mapping
+// ---------------------------------------------------------------------------
+const AGENT_TYPE_TO_TERMINAL_CMD = {
+    'gemini': 'gemini',
+    'gemini-a2a': 'gemini',
+    'qwen': 'qwen',
+    'codex': 'codex',
+    'codex-server': 'codex',
+    'claude-code': 'claude',
+    'opencode': 'opencode',
+};
+// ---------------------------------------------------------------------------
 // Execution ID generation
 // ---------------------------------------------------------------------------
 const TOOL_PREFIX = {
     gemini: 'gem',
+    'gemini-a2a': 'gma',
     qwen: 'qwn',
     codex: 'cdx',
+    'codex-server': 'cxs',
     claude: 'cld',
     opencode: 'opc',
 };
-function generateExecId(tool) {
+export function generateCliExecId(tool) {
     const prefix = TOOL_PREFIX[tool] ?? 'run';
     const now = new Date();
     const hh = String(now.getHours()).padStart(2, '0');
@@ -67,42 +87,31 @@ async function assemblePrompt(userPrompt, mode, rule) {
 // Adapter factory — dynamic import avoids rootDir cross-boundary issues
 // ---------------------------------------------------------------------------
 async function loadAdapterModule(adapterFile) {
-    const dashboardAgents = resolve(import.meta.dirname ?? __dirname, '..', '..', 'dashboard', 'dist-server', 'server', 'agents');
-    const fullPath = resolve(dashboardAgents, adapterFile);
+    const baseDir = import.meta.dirname ?? __dirname;
+    // Prefer tsc-compiled output; fall back to legacy vite bundle path
+    const tscAgents = resolve(baseDir, '..', '..', 'dashboard', 'dist-server', 'dashboard', 'src', 'server', 'agents');
+    const legacyAgents = resolve(baseDir, '..', '..', 'dashboard', 'dist-server', 'server', 'agents');
+    const tscPath = resolve(tscAgents, adapterFile);
+    const legacyPath = resolve(legacyAgents, adapterFile);
+    const fullPath = existsSync(tscPath) ? tscPath : legacyPath;
     // Convert to file:// URL for Windows compatibility with dynamic import()
     const fileUrl = pathToFileURL(fullPath).href;
     return await import(fileUrl);
 }
-async function createAdapter(agentType) {
-    switch (agentType) {
-        case 'gemini': {
-            const mod = await loadAdapterModule('stream-json-adapter.js');
-            const Cls = mod.StreamJsonAdapter;
-            return new Cls('npx -y @google/gemini-cli', 'gemini');
-        }
-        case 'qwen': {
-            const mod = await loadAdapterModule('stream-json-adapter.js');
-            const Cls = mod.StreamJsonAdapter;
-            return new Cls('qwen', 'qwen');
-        }
-        case 'codex': {
-            const mod = await loadAdapterModule('codex-cli-adapter.js');
-            const Cls = mod.CodexCliAdapter;
-            return new Cls();
-        }
-        case 'opencode': {
-            const mod = await loadAdapterModule('opencode-adapter.js');
-            const Cls = mod.OpenCodeAdapter;
-            return new Cls();
+async function createAdapter(agentType, backend) {
+    if (backend === 'terminal') {
+        const { detectBackend } = await import('./terminal-backend.js');
+        const { TerminalAdapter } = await import('./terminal-adapter.js');
+        const termBackend = detectBackend();
+        if (!termBackend) {
+            throw new Error('No terminal multiplexer detected (need TMUX or WEZTERM_PANE env)');
         }
-        case 'claude-code': {
-            const mod = await loadAdapterModule('claude-code-adapter.js');
-            const Cls = mod.ClaudeCodeAdapter;
-            return new Cls();
-        }
-        default:
-            throw new Error(`Unsupported agent type: ${agentType}`);
+        const cmd = AGENT_TYPE_TO_TERMINAL_CMD[agentType] ?? agentType;
+        return new TerminalAdapter(termBackend, cmd);
     }
+    const mod = await loadAdapterModule('adapter-factory.js');
+    const factory = mod.createAdapterForType;
+    return await factory(agentType);
 }
 // ---------------------------------------------------------------------------
 // Entry renderer — writes normalized entries to stdout/stderr
@@ -141,10 +150,145 @@ function renderEntry(entry) {
             break;
     }
 }
+function buildJobMetadata(options) {
+    const metadata = {
+        tool: options.tool,
+        mode: options.mode,
+        workDir: options.workDir,
+        prompt: options.prompt.substring(0, 200),
+        cancelRequestedAt: null,
+        cancelRequestedBy: null,
+        cancelReason: null,
+    };
+    if (options.model) {
+        metadata.model = options.model;
+    }
+    if (options.rule) {
+        metadata.rule = options.rule;
+    }
+    if (options.backend) {
+        metadata.backend = options.backend;
+    }
+    if (options.sessionId) {
+        metadata.sessionId = options.sessionId;
+    }
+    if (options.includeDirs && options.includeDirs.length > 0) {
+        metadata.includeDirs = options.includeDirs;
+    }
+    return metadata;
+}
+function mergeJsonObjects(base, patch) {
+    return patch ? { ...base, ...patch } : { ...base };
+}
+function spawnQueuedDelegateWorker(options, execId, prompt) {
+    const entryScript = process.argv[1];
+    if (!entryScript) {
+        return false;
+    }
+    const args = [
+        entryScript,
+        'delegate',
+        prompt,
+        '--worker',
+        '--to',
+        options.tool,
+        '--mode',
+        options.mode,
+        '--cd',
+        options.workDir,
+        '--id',
+        execId,
+        '--backend',
+        options.backend ?? 'direct',
+        '--resume',
+        execId,
+    ];
+    if (options.model) {
+        args.push('--model', options.model);
+    }
+    if (options.rule) {
+        args.push('--rule', options.rule);
+    }
+    if (options.includeDirs && options.includeDirs.length > 0) {
+        args.push('--includeDirs', options.includeDirs.join(','));
+    }
+    if (options.sessionId) {
+        args.push('--session', options.sessionId);
+    }
+    const child = spawn(process.execPath, args, {
+        cwd: options.workDir,
+        detached: true,
+        stdio: 'ignore',
+        env: {
+            ...process.env,
+            MAESTRO_DISABLE_DASHBOARD_BRIDGE: '1',
+        },
+    });
+    child.unref();
+    return true;
+}
+function isTerminalStatus(status) {
+    return status === 'completed' || status === 'failed' || status === 'cancelled';
+}
+function summarizeEntry(entry) {
+    switch (entry.type) {
+        case 'assistant_message':
+            return entry.content.replace(/\s+/g, ' ').trim().slice(0, 200) || 'Assistant response updated';
+        case 'tool_use':
+            return `Tool ${entry.name} ${entry.status}`;
+        case 'file_change':
+            return `File ${entry.action}: ${entry.path}`;
+        case 'command_exec':
+            return `Command: ${entry.command}`;
+        case 'error':
+            return entry.message;
+        case 'status_change':
+            return `Status changed to ${entry.status}`;
+        default:
+            return `Event: ${entry.type}`;
+    }
+}
+function shouldPublishSnapshot(entry) {
+    switch (entry.type) {
+        case 'assistant_message':
+            return entry.partial !== true;
+        case 'tool_use':
+            return entry.status === 'completed' || entry.status === 'failed';
+        case 'file_change':
+        case 'command_exec':
+        case 'error':
+            return true;
+        default:
+            return false;
+    }
+}
+function createNoopBridge() {
+    return {
+        async tryConnect() {
+            return false;
+        },
+        forwardSpawn() {
+            return;
+        },
+        forwardEntry() {
+            return;
+        },
+        forwardStopped() {
+            return;
+        },
+        close() {
+            return;
+        },
+    };
+}
 // ---------------------------------------------------------------------------
 // CliAgentRunner
 // ---------------------------------------------------------------------------
 export class CliAgentRunner {
+    dependencies;
+    constructor(dependencies = {}) {
+        this.dependencies = dependencies;
+    }
     /** Resolve dashboard WS URL from env → config → default port 3001 */
     static getDashboardWsUrl() {
         const envPort = process.env.MAESTRO_DASHBOARD_PORT;
@@ -167,6 +311,43 @@ export class CliAgentRunner {
         }
         return 'ws://127.0.0.1:3001/ws';
     }
+    /**
+     * Send MCP channel notification (primary path).
+     * If maestro MCP server is running in this process, push a
+     * notifications/claude/channel message directly.
+     */
+    static sendChannelNotification(_sessionId, execId, tool, mode, status, exitCode) {
+        try {
+            // Dynamic import to avoid circular dependency — getMcpServer is exported
+            // from mcp/server.ts which may not be loaded in CLI-only mode.
+            const { getMcpServer } = require('../mcp/server.js');
+            const server = getMcpServer();
+            if (!server)
+                return;
+            const label = status === 'completed'
+                ? 'DELEGATE COMPLETED'
+                : status === 'cancelled'
+                    ? 'DELEGATE CANCELLED'
+                    : 'DELEGATE FAILED';
+            const result = status === 'completed'
+                ? 'done'
+                : status === 'cancelled'
+                    ? 'cancelled'
+                    : `exit:${exitCode}`;
+            const content = `[${label}] ${execId} (${tool}/${mode}) ${result}\nUse \`maestro delegate output ${execId}\` for full result.`;
+            // Fire-and-forget notification via MCP protocol
+            server.notification({
+                method: 'notifications/claude/channel',
+                params: {
+                    content,
+                    meta: { exec_id: execId, job_id: execId, tool, mode, exit_code: String(exitCode), event_type: status, status },
+                },
+            }).catch((err) => { console.error(`[${execId}] MCP notification send failed: ${err instanceof Error ? err.message : err}`); });
+        }
+        catch (err) {
+            console.error(`[${execId}] MCP server not available for channel notification: ${err instanceof Error ? err.message : err}`);
+        }
+    }
     /**
      * Run a CLI agent to completion and return its exit code (0 = success).
      */
@@ -177,10 +358,13 @@ export class CliAgentRunner {
             return 1;
         }
         // Generate or use provided execution ID
-        const execId = options.execId ?? generateExecId(options.tool);
+        const execId = options.execId ?? generateCliExecId(options.tool);
         process.stderr.write(`[MAESTRO_EXEC_ID=${execId}]\n`);
         // History store for persistence and resume
         const store = new CliHistoryStore();
+        const broker = this.dependencies.brokerClient ?? new DelegateBrokerClient();
+        const now = this.dependencies.now ?? (() => new Date().toISOString());
+        const jobMetadata = buildJobMetadata(options);
         // Handle --resume: prepend previous session context to user prompt
         let userPrompt = options.prompt;
         if (options.resume) {
@@ -198,10 +382,16 @@ export class CliAgentRunner {
         }
         // Assemble final prompt: protocol + user prompt + template
         const finalPrompt = await assemblePrompt(userPrompt, options.mode, options.rule);
-        const adapter = await createAdapter(agentType);
+        const adapterFactory = this.dependencies.createAdapter ?? createAdapter;
+        const adapter = await adapterFactory(agentType, options.backend);
         // Optional Dashboard bridge — connect silently, don't block startup
-        const bridge = new DashboardBridge();
-        const bridgeConnected = await bridge.tryConnect(CliAgentRunner.getDashboardWsUrl(), 1000);
+        const bridgeEnabled = process.env.MAESTRO_DISABLE_DASHBOARD_BRIDGE !== '1';
+        const bridge = bridgeEnabled
+            ? (this.dependencies.createBridge?.() ?? new DashboardBridge())
+            : createNoopBridge();
+        const bridgeConnected = bridgeEnabled
+            ? await bridge.tryConnect(CliAgentRunner.getDashboardWsUrl(), 1000)
+            : false;
         if (!bridgeConnected) {
             process.stderr.write('[Dashboard not connected — real-time view unavailable]\n');
         }
@@ -211,17 +401,62 @@ export class CliAgentRunner {
             workDir: options.workDir,
             model: options.model,
             approvalMode: options.mode === 'write' ? 'auto' : 'suggest',
+            interactive: adapter.supportsInteractive?.() === true,
         };
         const agentProcess = await adapter.spawn(config);
         bridge.forwardSpawn(agentProcess);
+        const agentJobMetadata = {
+            ...jobMetadata,
+            agentProcessId: agentProcess.id,
+        };
+        store.saveMeta(execId, {
+            execId,
+            tool: options.tool,
+            model: options.model,
+            mode: options.mode,
+            prompt: options.prompt.substring(0, 500),
+            workDir: options.workDir,
+            startedAt: agentProcess.startedAt,
+        });
+        const publishEvent = (type, status, summary, extraPayload = {}, extraJobMetadata) => {
+            try {
+                const snapshot = store.buildSnapshot(execId);
+                broker.publishEvent({
+                    jobId: execId,
+                    type,
+                    status,
+                    snapshot: snapshot,
+                    payload: {
+                        execId,
+                        summary,
+                        ...extraPayload,
+                    },
+                    jobMetadata: mergeJsonObjects(agentJobMetadata, extraJobMetadata),
+                });
+            }
+            catch {
+                // Broker publication is best-effort and must not break CLI execution
+            }
+        };
+        publishEvent('status_update', 'running', `Delegate started for ${options.tool}/${options.mode}`);
         // Safety net: if the process exits without a stopped event (e.g. Windows
         // shell process tree doesn't fire exit/close reliably), write meta.json
         // from the synchronous process.on('exit') handler as a last resort.
         let metaWritten = false;
-        const saveMeta = (exitCode) => {
+        let cancellationRequested = Boolean(broker.getJob(execId)?.metadata?.cancelRequestedAt);
+        let cancellationInitiated = false;
+        let cancellationPoller = null;
+        const clearCancellationPoller = () => {
+            if (cancellationPoller) {
+                clearInterval(cancellationPoller);
+                cancellationPoller = null;
+            }
+        };
+        const saveMeta = (status, exitCode) => {
             if (metaWritten)
                 return;
             metaWritten = true;
+            const completedAt = now();
             store.saveMeta(execId, {
                 execId,
                 tool: options.tool,
@@ -230,37 +465,221 @@ export class CliAgentRunner {
                 prompt: options.prompt.substring(0, 500),
                 workDir: options.workDir,
                 startedAt: agentProcess.startedAt,
-                completedAt: new Date().toISOString(),
+                completedAt,
                 exitCode,
+                ...(status === 'cancelled' ? { cancelledAt: completedAt } : {}),
             });
+            publishEvent(status, status, status === 'completed'
+                ? `Delegate completed: ${execId}`
+                : status === 'cancelled'
+                    ? `Delegate cancelled: ${execId}`
+                    : `Delegate failed: ${execId}`, {
+                exitCode,
+                completedAt,
+                status,
+            });
+            // Write delegate completion notification (for hook fallback)
+            const sessionId = options.sessionId;
+            if (sessionId) {
+                // JSONL file write (for hook fallback)
+                try {
+                    const notifyPath = join(tmpdir(), `${NOTIFY_PREFIX}${sessionId}.jsonl`);
+                    const entry = JSON.stringify({
+                        execId,
+                        tool: options.tool,
+                        mode: options.mode,
+                        prompt: options.prompt.substring(0, 200),
+                        exitCode,
+                        completedAt,
+                        status,
+                    });
+                    appendFileSync(notifyPath, entry + '\n', 'utf-8');
+                }
+                catch (err) {
+                    console.error(`[${execId}] Failed to write JSONL notification: ${err instanceof Error ? err.message : err}`);
+                }
+                // MCP channel notification (primary path)
+                try {
+                    CliAgentRunner.sendChannelNotification(sessionId, execId, options.tool, options.mode, status, exitCode);
+                }
+                catch (err) {
+                    console.error(`[${execId}] Failed to send channel notification: ${err instanceof Error ? err.message : err}`);
+                }
+            }
         };
         const processExitHandler = () => {
-            saveMeta(0);
+            saveMeta(cancellationRequested ? 'cancelled' : 'completed', cancellationRequested ? 130 : 0);
         };
         process.on('exit', processExitHandler);
+        const requestCancellation = async () => {
+            cancellationRequested = true;
+            if (cancellationInitiated) {
+                return;
+            }
+            cancellationInitiated = true;
+            publishEvent('status_update', 'running', `Cancellation requested for ${execId}`, {
+                cancelRequested: true,
+            });
+            try {
+                await adapter.stop(agentProcess.id);
+            }
+            catch {
+                // Adapter stop failures are surfaced by subsequent process status events.
+            }
+        };
+        const dispatchQueuedFollowup = (finalStatus) => {
+            let queuedMessage;
+            try {
+                queuedMessage = broker.listMessages(execId).find((message) => (message.status === 'queued'
+                    && ((message.delivery === 'inject'
+                        && (finalStatus === 'cancelled' || finalStatus === 'completed' || finalStatus === 'failed'))
+                        || (message.delivery === 'after_complete' && finalStatus === 'completed'))));
+            }
+            catch {
+                return;
+            }
+            if (!queuedMessage) {
+                return;
+            }
+            const dispatchedAt = now();
+            let launched = false;
+            try {
+                launched = (this.dependencies.spawnDetachedDelegate ?? spawnQueuedDelegateWorker)(options, execId, queuedMessage.message);
+            }
+            catch {
+                launched = false;
+            }
+            if (!launched) {
+                broker.updateMessage({
+                    jobId: execId,
+                    messageId: queuedMessage.messageId,
+                    status: 'dropped',
+                    dispatchReason: 'missing-entry-script',
+                    now: dispatchedAt,
+                });
+                return;
+            }
+            broker.updateMessage({
+                jobId: execId,
+                messageId: queuedMessage.messageId,
+                status: 'dispatched',
+                dispatchReason: finalStatus,
+                now: dispatchedAt,
+            });
+            publishEvent('status_update', finalStatus, `Queued follow-up dispatched via ${queuedMessage.delivery}`, {
+                delivery: queuedMessage.delivery,
+                messageId: queuedMessage.messageId,
+            }, {
+                cancelRequestedAt: null,
+                cancelRequestedBy: null,
+                cancelReason: null,
+            });
+        };
+        const inFlightMessageIds = new Set();
+        if (!isTerminalStatus(broker.getJob(execId)?.status)) {
+            cancellationPoller = setInterval(() => {
+                try {
+                    const job = broker.getJob(execId);
+                    if (job?.metadata?.cancelRequestedAt && !cancellationInitiated) {
+                        void requestCancellation();
+                    }
+                }
+                catch {
+                    // Best-effort polling only.
+                }
+                // Poll for inject messages and auto-route based on adapter capabilities
+                try {
+                    const injectMessages = broker.listMessages(execId)
+                        .filter((msg) => msg.status === 'queued' && msg.delivery === 'inject' && !inFlightMessageIds.has(msg.messageId))
+                        .sort((a, b) => a.createdAt.localeCompare(b.createdAt));
+                    for (const msg of injectMessages) {
+                        const polledNow = now();
+                        if (adapter.sendMessage && (adapter.supportsInteractive?.() !== false)) {
+                            // Interactive adapter: inject via stdin without interruption
+                            inFlightMessageIds.add(msg.messageId);
+                            void adapter.sendMessage(agentProcess.id, msg.message).then(() => {
+                                broker.updateMessage({
+                                    jobId: execId,
+                                    messageId: msg.messageId,
+                                    status: 'injected',
+                                    dispatchReason: 'inject-streaming',
+                                    now: polledNow,
+                                });
+                            }).catch(() => {
+                                broker.updateMessage({
+                                    jobId: execId,
+                                    messageId: msg.messageId,
+                                    status: 'dropped',
+                                    dispatchReason: 'send-failed',
+                                    now: polledNow,
+                                });
+                            }).finally(() => {
+                                inFlightMessageIds.delete(msg.messageId);
+                            });
+                        }
+                        else {
+                            // Non-interactive adapter: fall back to cancel + resume
+                            if (!cancellationInitiated) {
+                                void requestCancellation();
+                            }
+                            break; // Messages stay queued for dispatchQueuedFollowup after restart
+                        }
+                    }
+                }
+                catch {
+                    // Best-effort inject message polling.
+                }
+            }, 750);
+        }
+        if (cancellationRequested) {
+            void requestCancellation();
+        }
         return new Promise((resolvePromise) => {
             const unsubscribe = adapter.onEntry(agentProcess.id, (entry) => {
                 // Persist entry to JSONL history before rendering
                 store.appendEntry(execId, entry);
-                renderEntry(entry);
+                (this.dependencies.renderEntry ?? renderEntry)(entry);
                 bridge.forwardEntry(entry);
+                if (shouldPublishSnapshot(entry)) {
+                    publishEvent('snapshot', 'running', summarizeEntry(entry), {
+                        entryType: entry.type,
+                    });
+                }
+                // Interactive mode: when Claude emits token_usage (end of turn) and no
+                // more inject messages are queued, close stdin to let the process exit.
+                if (config.interactive && entry.type === 'token_usage' && broker) {
+                    try {
+                        const pending = broker.listMessages(execId)
+                            .filter((m) => m.status === 'queued' && m.delivery === 'inject');
+                        if (pending.length === 0 && !cancellationRequested) {
+                            adapter.endInput?.(agentProcess.id);
+                        }
+                    }
+                    catch { /* best-effort */ }
+                }
                 // Resolve when the agent process stops
                 if (entry.type === 'status_change' && entry.status === 'stopped') {
-                    saveMeta(0);
+                    clearCancellationPoller();
+                    const finalStatus = cancellationRequested ? 'cancelled' : 'completed';
+                    saveMeta(finalStatus, cancellationRequested ? 130 : 0);
+                    dispatchQueuedFollowup(finalStatus);
                     process.removeListener('exit', processExitHandler);
                     bridge.forwardStopped(agentProcess.id);
                     bridge.close();
                     unsubscribe();
-                    resolvePromise(0);
+                    resolvePromise(cancellationRequested ? 130 : 0);
                 }
                 // Resolve with error code on error status
                 if (entry.type === 'status_change' && entry.status === 'error') {
-                    saveMeta(1);
+                    clearCancellationPoller();
+                    const finalStatus = cancellationRequested ? 'cancelled' : 'failed';
+                    saveMeta(finalStatus, cancellationRequested ? 130 : 1);
+                    dispatchQueuedFollowup(finalStatus);
                     process.removeListener('exit', processExitHandler);
                     bridge.forwardStopped(agentProcess.id);
                     bridge.close();
                     unsubscribe();
-                    resolvePromise(1);
+                    resolvePromise(cancellationRequested ? 130 : 1);
                 }
             });
         });