sudocode 1.1.18-dev.0 → 1.1.18

package/node_modules/@sudocode-ai/local-server/dist/execution/executors/agent-executor-wrapper.js

@@ -1,725 +0,0 @@
-/**
- * AgentExecutorWrapper - Generic wrapper for any agent adapter
- *
- * Provides a unified execution interface that works with any IAgentAdapter.
- * Supports Claude Code, Codex, Cursor, Copilot, and any future agents.
- *
- * @module execution/executors/agent-executor-wrapper
- */
-import { ClaudeCodeExecutor, CodexExecutor, CursorExecutor, CopilotExecutor, } from "agent-execution-engine/agents";
-import { NormalizedEntryToAgUiAdapter } from "../output/normalized-to-ag-ui-adapter.js";
-import { AgUiEventAdapter } from "../output/ag-ui-adapter.js";
-import { updateExecution, getExecution } from "../../services/executions.js";
-import { broadcastExecutionUpdate } from "../../services/websocket.js";
-import { execSync } from "child_process";
-import { ExecutionChangesService } from "../../services/execution-changes-service.js";
-import { notifyExecutionEvent } from "../../services/execution-event-callbacks.js";
-/**
- * Merge agent config with overrides, filtering undefined values.
- *
- * Enables functional composition of configs where undefined values
- * are treated as "not present" rather than explicit values.
- *
- * @param base - Base agent configuration
- * @param overrides - Partial overrides to apply (undefined values ignored)
- * @returns Merged configuration with undefined values filtered out
- */
-function mergeAgentConfig(base, overrides) {
-    return {
-        ...base,
-        ...Object.fromEntries(Object.entries(overrides).filter(([_, v]) => v !== undefined)),
-    };
-}
-/**
- * Generic wrapper for any agent adapter
- *
- * Provides basic execution lifecycle management for any agent that implements
- * IAgentAdapter. This is a simplified version compared to ClaudeExecutorWrapper,
- * which has specialized logic for Claude Code's protocol peer.
- *
- * @example
- * ```typescript
- * const wrapper = new AgentExecutorWrapper({
- *   adapter: codexAdapter,
- *   agentConfig: {
- *     workDir: '/path/to/repo',
- *     apiKey: 'sk-...',
- *     model: 'code-davinci-002',
- *   },
- *   lifecycleService,
- *   logsStore,
- *   projectId: 'my-project',
- *   db,
- *   transportManager,
- * });
- *
- * await wrapper.executeWithLifecycle(executionId, task, workDir);
- * ```
- */
-export class AgentExecutorWrapper {
-    adapter;
-    executor;
-    /** Agent type used for executor selection and logging */
-    agentType;
-    _agentConfig;
-    logsStore;
-    transportManager;
-    projectId;
-    db;
-    /** MOSTLY DEPRECATED. just used for the workdir today */
-    processConfig;
-    activeExecutions;
-    /** Track completion state for Claude Code executions (from protocol peer) */
-    completionState;
-    constructor(config) {
-        this.adapter = config.adapter;
-        this.agentType = config.agentType;
-        this._agentConfig = config.agentConfig;
-        this.logsStore = config.logsStore;
-        this.transportManager = config.transportManager;
-        this.projectId = config.projectId;
-        this.db = config.db;
-        this.activeExecutions = new Map();
-        this.completionState = new Map();
-        // Build process configuration from agent-specific config
-        this.processConfig = this.adapter.buildProcessConfig(this._agentConfig);
-        // Create executor instance based on agent type
-        this.executor = this.createExecutor(config.agentType, this._agentConfig);
-        console.log("[AgentExecutorWrapper] Initialized", {
-            agentType: this.agentType,
-            adapterName: this.adapter.metadata.name,
-            projectId: this.projectId,
-            workDir: this.processConfig.workDir,
-            hasTransport: !!this.transportManager,
-            hasLogsStore: !!this.logsStore,
-        });
-    }
-    /**
-     * Create the appropriate executor for the given agent type
-     *
-     * @param agentType - Type of agent
-     * @param agentConfig - Agent configuration
-     * @returns Executor instance
-     */
-    createExecutor(agentType, agentConfig) {
-        switch (agentType) {
-            case "claude-code":
-                return new ClaudeCodeExecutor({
-                    workDir: agentConfig.workDir,
-                    executablePath: agentConfig.claudePath,
-                    print: agentConfig.print ?? true,
-                    outputFormat: agentConfig.outputFormat ?? "stream-json",
-                    verbose: agentConfig.verbose ?? true,
-                    dangerouslySkipPermissions: agentConfig.dangerouslySkipPermissions ?? false,
-                    restrictToWorkDir: agentConfig.restrictToWorkDir ?? true,
-                    directoryGuardHookPath: agentConfig.directoryGuardHookPath,
-                    mcpServers: agentConfig.mcpServers,
-                    appendSystemPrompt: agentConfig.appendSystemPrompt,
-                    disallowedTools: agentConfig.disallowedTools,
-                });
-            case "codex":
-                return new CodexExecutor(agentConfig);
-            case "cursor":
-                return new CursorExecutor(agentConfig);
-            case "copilot":
-                return new CopilotExecutor(agentConfig);
-            default:
-                throw new Error(`Unknown agent type: ${agentType}`);
-        }
-    }
-    /**
-     * Execute a task with full lifecycle management
-     *
-     * @param executionId - Unique execution identifier
-     * @param task - Task to execute
-     * @param workDir - Working directory for execution
-     */
-    async executeWithLifecycle(executionId, task, workDir) {
-        console.log(`[AgentExecutorWrapper] Starting execution ${executionId}`, {
-            agentType: this.adapter.metadata.name,
-            taskId: task.id,
-            workDir,
-        });
-        // 1. Setup AG-UI system
-        const { agUiAdapter, normalizedAdapter } = this.setupAgUiSystem(executionId);
-        // 2. Connect to transport
-        if (this.transportManager) {
-            this.transportManager.connectAdapter(agUiAdapter, executionId);
-            console.log(`[AgentExecutorWrapper] Connected AG-UI adapter to transport for ${executionId}`);
-        }
-        try {
-            // 3. Emit run started event
-            agUiAdapter.emitRunStarted({
-                model: task.config?.model || this.adapter.metadata.name,
-                timestamp: new Date().toISOString(),
-            });
-            // 4. Update execution status to running
-            updateExecution(this.db, executionId, { status: "running" });
-            const execution = getExecution(this.db, executionId);
-            if (execution) {
-                broadcastExecutionUpdate(this.projectId, executionId, "status_changed", execution, execution.issue_id || undefined);
-            }
-            // 5. Execute task with agent executor
-            // Check if task has MCP servers or other runtime config that requires a fresh executor
-            let executor = this.executor;
-            const taskMcpServers = task.metadata?.mcpServers;
-            const taskAppendSystemPrompt = task.metadata?.appendSystemPrompt;
-            const taskDangerouslySkipPermissions = task.metadata
-                ?.dangerouslySkipPermissions;
-            const taskResume = task.metadata?.resume;
-            // Debug: Log what we received in task metadata
-            console.log(`[AgentExecutorWrapper] Task metadata for ${executionId}:`, {
-                agentType: this.agentType,
-                hasMcpServers: !!taskMcpServers,
-                mcpServerNames: taskMcpServers
-                    ? Object.keys(taskMcpServers)
-                    : "none",
-                hasAppendSystemPrompt: !!taskAppendSystemPrompt,
-                dangerouslySkipPermissions: taskDangerouslySkipPermissions,
-                resume: taskResume,
-            });
-            if (this.agentType === "claude-code" &&
-                (taskMcpServers ||
-                    taskAppendSystemPrompt ||
-                    taskDangerouslySkipPermissions !== undefined || // false is a valid override
-                    taskResume)) {
-                // Create a task-specific executor with merged config
-                console.log(`[AgentExecutorWrapper] Creating task-specific executor for ${executionId}`, {
-                    mcpServers: taskMcpServers ? Object.keys(taskMcpServers) : "none",
-                    dangerouslySkipPermissions: taskDangerouslySkipPermissions,
-                    resume: taskResume,
-                });
-                const taskSpecificConfig = mergeAgentConfig(this._agentConfig, {
-                    mcpServers: taskMcpServers,
-                    appendSystemPrompt: taskAppendSystemPrompt,
-                    dangerouslySkipPermissions: taskDangerouslySkipPermissions,
-                    resume: taskResume,
-                });
-                executor = this.createExecutor(this.agentType, taskSpecificConfig);
-            }
-            console.log(`[AgentExecutorWrapper] Spawning ${this.adapter.metadata.name} process for ${executionId}`, {
-                taskId: task.id,
-                workDir,
-                promptLength: task.prompt.length,
-            });
-            const spawned = await executor.executeTask(task);
-            console.log(`[AgentExecutorWrapper] ${this.adapter.metadata.name} process spawned for ${executionId}`, {
-                pid: spawned.process.process?.pid,
-                spawnfile: spawned.process.process?.spawnfile,
-            });
-            // 6. Store cancellation handle
-            this.activeExecutions.set(executionId, {
-                cancel: () => {
-                    if (spawned.process.process) {
-                        spawned.process.process.kill("SIGTERM");
-                    }
-                },
-            });
-            // 7. Initialize completion state for Claude Code
-            if (this.agentType === "claude-code") {
-                this.completionState.set(executionId, {
-                    completed: false,
-                    exitCode: 0,
-                });
-            }
-            // 8. Create output stream from process stdout/stderr
-            const outputStream = this.createOutputChunks(spawned.process, executionId);
-            const normalized = this.executor.normalizeOutput(outputStream, workDir);
-            // 9. Process normalized output (runs concurrently with process)
-            const processOutputPromise = this.processNormalizedOutput(executionId, normalized, normalizedAdapter);
-            // 10. Capture stderr for debugging
-            const childProcess = spawned.process.process;
-            if (childProcess && childProcess.stderr) {
-                let stderrOutput = "";
-                childProcess.stderr.on("data", (data) => {
-                    const chunk = data.toString();
-                    stderrOutput += chunk;
-                    console.error(`[AgentExecutorWrapper] ${this.adapter.metadata.name} stderr for ${executionId}:`, chunk);
-                });
-            }
-            // 11. Wait for output processing to complete
-            await processOutputPromise;
-            console.log(`[AgentExecutorWrapper] Output processing completed for ${executionId}`);
-            // 12. Close stdin to signal the process to exit (for Claude Code with peer)
-            if (this.agentType === "claude-code" &&
-                childProcess &&
-                childProcess.stdin) {
-                try {
-                    childProcess.stdin.end();
-                    console.log(`[AgentExecutorWrapper] Closed stdin for Claude Code process ${executionId}`);
-                }
-                catch (error) {
-                    console.error(`[AgentExecutorWrapper] Error closing stdin for ${executionId}:`, error);
-                }
-            }
-            // 13. Wait for process to exit (with timeout for Claude Code)
-            const exitCode = await Promise.race([
-                new Promise((resolve) => {
-                    if (!childProcess) {
-                        // Use completion state for Claude Code if available
-                        if (this.agentType === "claude-code") {
-                            const state = this.completionState.get(executionId);
-                            resolve(state?.exitCode ?? 0);
-                        }
-                        else {
-                            resolve(0);
-                        }
-                        return;
-                    }
-                    childProcess.on("exit", (code) => {
-                        console.log(`[AgentExecutorWrapper] Process exited with code ${code} for ${executionId}`);
-                        // For Claude Code, use completion state exit code if available (more reliable)
-                        if (this.agentType === "claude-code") {
-                            const state = this.completionState.get(executionId);
-                            if (state?.completed) {
-                                console.log(`[AgentExecutorWrapper] Using completion state exit code ${state.exitCode} for ${executionId}`);
-                                resolve(state.exitCode);
-                                return;
-                            }
-                        }
-                        resolve(code ?? 0);
-                    });
-                    childProcess.on("error", (error) => {
-                        console.error(`[AgentExecutorWrapper] Process error for ${executionId}:`, error);
-                        resolve(1);
-                    });
-                }),
-                // Timeout for Claude Code processes that may not exit cleanly
-                this.agentType === "claude-code"
-                    ? new Promise((resolve) => {
-                        setTimeout(() => {
-                            console.log(`[AgentExecutorWrapper] Process exit timeout for ${executionId}, using completion state`);
-                            if (childProcess && !childProcess.killed) {
-                                childProcess.kill("SIGTERM");
-                            }
-                            // Use completion state exit code
-                            const state = this.completionState.get(executionId);
-                            resolve(state?.exitCode ?? 0);
-                        }, 5000);
-                    })
-                    : new Promise(() => { }), // Never resolves for non-Claude agents
-            ]);
-            // 14. Handle completion
-            if (exitCode === 0) {
-                await this.handleSuccess(executionId);
-                agUiAdapter.emitRunFinished({ exitCode });
-            }
-            else {
-                throw new Error(`Process exited with code ${exitCode}`);
-            }
-        }
-        catch (error) {
-            console.error(`[AgentExecutorWrapper] Execution failed for ${executionId}:`, error);
-            await this.handleError(executionId, error);
-            agUiAdapter.emitRunError(error instanceof Error ? error.message : String(error));
-            throw error;
-        }
-        finally {
-            // Cleanup
-            this.activeExecutions.delete(executionId);
-            this.completionState.delete(executionId);
-            if (this.transportManager) {
-                this.transportManager.disconnectAdapter(agUiAdapter);
-                console.log(`[AgentExecutorWrapper] Disconnected AG-UI adapter for ${executionId}`);
-            }
-        }
-    }
-    /**
-     * Resume a task from a previous session
-     *
-     * @param executionId - Unique execution identifier
-     * @param sessionId - Session ID to resume from
-     * @param task - Task to resume
-     * @param workDir - Working directory for execution
-     */
-    async resumeWithLifecycle(executionId, sessionId, task, workDir) {
-        // Check if executor supports resume
-        const capabilities = this.executor.getCapabilities?.();
-        if (!capabilities?.supportsSessionResume || !this.executor.resumeTask) {
-            console.log(`[AgentExecutorWrapper] Resume not supported for agent '${this.adapter.metadata.name}'`);
-            throw new Error(`Resume functionality not supported for agent '${this.adapter.metadata.name}'`);
-        }
-        console.log(`[AgentExecutorWrapper] Resuming session ${sessionId} for ${executionId}`);
-        // Setup AG-UI system
-        const { agUiAdapter, normalizedAdapter } = this.setupAgUiSystem(executionId);
-        if (this.transportManager) {
-            this.transportManager.connectAdapter(agUiAdapter, executionId);
-        }
-        try {
-            agUiAdapter.emitRunStarted({
-                model: task.config?.model || this.adapter.metadata.name,
-                sessionId,
-                resumed: true,
-            });
-            // Update status and session_id (sessionId is the path used for resumption)
-            updateExecution(this.db, executionId, {
-                status: "running",
-                session_id: sessionId,
-            });
-            const execution = getExecution(this.db, executionId);
-            if (execution) {
-                broadcastExecutionUpdate(this.projectId, executionId, "status_changed", execution, execution.issue_id || undefined);
-            }
-            // Use resumeTask instead of executeTask
-            const spawned = await this.executor.resumeTask(task, sessionId);
-            this.activeExecutions.set(executionId, {
-                cancel: () => {
-                    if (spawned.process.process) {
-                        spawned.process.process.kill("SIGTERM");
-                    }
-                },
-            });
-            // Initialize completion state for Claude Code
-            if (this.agentType === "claude-code") {
-                this.completionState.set(executionId, {
-                    completed: false,
-                    exitCode: 0,
-                });
-            }
-            // Create output streams
-            const outputChunks = this.createOutputChunks(spawned.process, executionId);
-            const normalized = this.executor.normalizeOutput(outputChunks, workDir);
-            const processOutputPromise = this.processNormalizedOutput(executionId, normalized, normalizedAdapter);
-            await processOutputPromise;
-            // For Claude Code, use completion state; for others, wait for process exit
-            let exitCode = 0;
-            if (this.agentType === "claude-code") {
-                const state = this.completionState.get(executionId);
-                exitCode = state?.exitCode ?? 0;
-                console.log(`[AgentExecutorWrapper] Using completion state exit code ${exitCode} for resumed ${executionId}`);
-            }
-            else {
-                exitCode = await new Promise((resolve, reject) => {
-                    const childProcess = spawned.process.process;
-                    if (!childProcess) {
-                        reject(new Error("No child process available"));
-                        return;
-                    }
-                    childProcess.on("exit", (code) => resolve(code || 0));
-                    childProcess.on("error", (error) => reject(error));
-                });
-            }
-            if (exitCode === 0) {
-                await this.handleSuccess(executionId);
-                agUiAdapter.emitRunFinished({ exitCode });
-            }
-            else {
-                throw new Error(`Process exited with code ${exitCode}`);
-            }
-        }
-        catch (error) {
-            await this.handleError(executionId, error);
-            agUiAdapter.emitRunError(error instanceof Error ? error.message : String(error));
-            throw error;
-        }
-        finally {
-            this.activeExecutions.delete(executionId);
-            this.completionState.delete(executionId);
-            if (this.transportManager) {
-                this.transportManager.disconnectAdapter(agUiAdapter);
-            }
-        }
-    }
-    /**
-     * Cancel a running execution
-     *
-     * @param executionId - Execution ID to cancel
-     */
-    async cancel(executionId) {
-        console.log(`[AgentExecutorWrapper] Cancel execution ${executionId}`);
-        // Kill the process if active
-        const execution = this.activeExecutions.get(executionId);
-        if (execution) {
-            execution.cancel();
-            this.activeExecutions.delete(executionId);
-        }
-        else {
-            console.warn(`[AgentExecutorWrapper] No active execution found for ${executionId}`);
-        }
-        // Capture final commit before marking stopped
-        const dbExecution = getExecution(this.db, executionId);
-        const repoPath = dbExecution?.worktree_path || this.processConfig.workDir;
-        let afterCommit;
-        try {
-            afterCommit = execSync("git rev-parse HEAD", {
-                cwd: repoPath,
-                encoding: "utf-8",
-            }).trim();
-        }
-        catch (error) {
-            console.warn(`[AgentExecutorWrapper] Failed to capture after_commit for cancelled execution ${executionId}:`, error instanceof Error ? error.message : String(error));
-            // Continue - this is supplementary data
-        }
-        // Update database status
-        updateExecution(this.db, executionId, {
-            after_commit: afterCommit,
-            status: "stopped",
-            completed_at: new Date().toISOString(),
-        });
-        const updatedExecution = getExecution(this.db, executionId);
-        if (updatedExecution) {
-            broadcastExecutionUpdate(this.projectId, executionId, "status_changed", updatedExecution, updatedExecution.issue_id || undefined);
-        }
-    }
-    /**
-     * Setup AG-UI system for execution
-     *
-     * @private
-     */
-    setupAgUiSystem(executionId) {
-        const agUiAdapter = new AgUiEventAdapter(executionId);
-        const normalizedAdapter = new NormalizedEntryToAgUiAdapter(agUiAdapter);
-        console.log(`[AgentExecutorWrapper] Setup AG-UI system for ${executionId}`);
-        return { agUiAdapter, normalizedAdapter };
-    }
-    /**
-     * Process normalized output from agent
-     *
-     * For Claude Code: Also captures session ID from metadata for session resumption
-     *
-     * @private
-     */
-    async processNormalizedOutput(executionId, normalized, normalizedAdapter) {
-        console.log(`[AgentExecutorWrapper] Processing normalized output for ${executionId}`);
-        let entryCount = 0;
-        let sessionIdCaptured = false;
-        for await (const entry of normalized) {
-            entryCount++;
-            // Log first 10 entries and every 100th entry for debugging
-            if (entryCount <= 10 || entryCount % 100 === 0) {
-                console.log(`[AgentExecutorWrapper] Entry ${entryCount} for ${executionId}:`, {
-                    index: entry.index,
-                    kind: entry.type.kind,
-                    timestamp: entry.timestamp,
-                    hasMetadata: !!entry.metadata,
-                    sessionId: entry.metadata?.sessionId,
-                });
-            }
-            try {
-                // Capture session ID from metadata for Claude Code (populated by normalizer from SystemMessage)
-                if (this.agentType === "claude-code" &&
-                    !sessionIdCaptured &&
-                    entry.metadata?.sessionId) {
-                    const sessionId = entry.metadata.sessionId;
-                    updateExecution(this.db, executionId, { session_id: sessionId });
-                    console.log(`[AgentExecutorWrapper] Captured session ID from metadata: ${sessionId} for ${executionId}`);
-                    sessionIdCaptured = true;
-                }
-                // 1. Store normalized entry for historical replay
-                this.logsStore.appendNormalizedEntry(executionId, entry);
-                // 2. Convert to AG-UI and broadcast for real-time streaming
-                await normalizedAdapter.processEntry(entry);
-            }
-            catch (error) {
-                console.error(`[AgentExecutorWrapper] Error processing entry for ${executionId}:`, {
-                    entryIndex: entry.index,
-                    entryType: entry.type.kind,
-                    error: error instanceof Error ? error.message : String(error),
-                });
-                // Continue processing (don't fail entire execution for one entry)
-            }
-        }
-        console.log(`[AgentExecutorWrapper] Finished processing ${entryCount} entries for ${executionId}`);
-    }
-    /**
-     * Handle successful execution
-     *
-     * @private
-     */
-    async handleSuccess(executionId) {
-        console.log(`[AgentExecutorWrapper] Execution ${executionId} completed successfully`);
-        // Capture final commit before marking complete
-        const execution = getExecution(this.db, executionId);
-        const repoPath = execution?.worktree_path || this.processConfig.workDir;
-        let afterCommit;
-        try {
-            afterCommit = execSync("git rev-parse HEAD", {
-                cwd: repoPath,
-                encoding: "utf-8",
-            }).trim();
-        }
-        catch (error) {
-            console.warn(`[AgentExecutorWrapper] Failed to capture after_commit for execution ${executionId}:`, error instanceof Error ? error.message : String(error));
-            // Continue - this is supplementary data
-        }
-        // Calculate file changes using ExecutionChangesService
-        let filesChangedJson = null;
-        try {
-            // Import and instantiate ExecutionChangesService
-            const changesService = new ExecutionChangesService(this.db, this.processConfig.workDir);
-            // Get changes for this execution
-            const changesResult = await changesService.getChanges(executionId);
-            if (changesResult.available && changesResult.captured) {
-                // Extract just the file paths from the changes
-                const filePaths = changesResult.captured.files.map((f) => f.path);
-                filesChangedJson = JSON.stringify(filePaths);
-                console.log(`[AgentExecutorWrapper] Captured ${filePaths.length} file changes for execution ${executionId}`);
-            }
-            else {
-                console.log(`[AgentExecutorWrapper] No file changes detected for execution ${executionId}:`, changesResult.reason);
-            }
-        }
-        catch (error) {
-            console.warn(`[AgentExecutorWrapper] Failed to calculate files_changed for execution ${executionId}:`, error instanceof Error ? error.message : String(error));
-            // Continue - this is supplementary data
-        }
-        updateExecution(this.db, executionId, {
-            after_commit: afterCommit,
-            files_changed: filesChangedJson,
-            status: "completed",
-            completed_at: new Date().toISOString(),
-            exit_code: 0,
-        });
-        const updatedExecution = getExecution(this.db, executionId);
-        if (updatedExecution) {
-            broadcastExecutionUpdate(this.projectId, executionId, "status_changed", updatedExecution, updatedExecution.issue_id || undefined);
-            // Notify callbacks for workflow integration
-            await notifyExecutionEvent("completed", {
-                executionId,
-                workflowId: updatedExecution.workflow_execution_id ?? undefined,
-                issueId: updatedExecution.issue_id ?? undefined,
-            });
-        }
-    }
-    /**
-     * Handle execution error
-     *
-     * @private
-     */
-    async handleError(executionId, error) {
-        console.error(`[AgentExecutorWrapper] Execution ${executionId} failed:`, error);
-        // Calculate file changes even for failed executions
-        // (user may want to commit partial work)
-        let filesChangedJson = null;
-        try {
-            const changesService = new ExecutionChangesService(this.db, this.processConfig.workDir);
-            const changesResult = await changesService.getChanges(executionId);
-            if (changesResult.available && changesResult.captured) {
-                const filePaths = changesResult.captured.files.map((f) => f.path);
-                filesChangedJson = JSON.stringify(filePaths);
-                console.log(`[AgentExecutorWrapper] Captured ${filePaths.length} file changes for failed execution ${executionId}`);
-            }
-        }
-        catch (calcError) {
-            console.warn(`[AgentExecutorWrapper] Failed to calculate files_changed for failed execution ${executionId}:`, calcError instanceof Error ? calcError.message : String(calcError));
-        }
-        updateExecution(this.db, executionId, {
-            status: "failed",
-            completed_at: new Date().toISOString(),
-            error_message: error.message,
-            files_changed: filesChangedJson,
-        });
-        const execution = getExecution(this.db, executionId);
-        if (execution) {
-            broadcastExecutionUpdate(this.projectId, executionId, "status_changed", execution, execution.issue_id || undefined);
-            // Notify callbacks for workflow integration
-            await notifyExecutionEvent("failed", {
-                executionId,
-                workflowId: execution.workflow_execution_id ?? undefined,
-                issueId: execution.issue_id ?? undefined,
-                error: error.message,
-            });
-        }
-    }
-    /**
-     * Create output chunk stream from ManagedProcess
-     *
-     * For Claude Code: Uses protocol peer to receive messages
-     * For other agents: Reads directly from stdout/stderr streams
-     *
-     * @private
-     */
-    async *createOutputChunks(process, executionId) {
-        // Check if this is a Claude Code process with a protocol peer
-        const peer = process.peer;
-        if (this.agentType === "claude-code") {
-            // Claude Code REQUIRES a protocol peer
-            if (!peer) {
-                throw new Error("No peer attached to Claude Code process - cannot read output");
-            }
-            // Claude Code: Use protocol peer messages
-            console.log("[AgentExecutorWrapper] Using protocol peer for Claude Code output");
-            yield* this.peerMessagesToOutputChunks(peer, executionId);
-            return;
-        }
-        // Other agents: Use stdout/stderr streams
-        if (!process.streams) {
-            throw new Error("Process does not have streams available");
-        }
-        const { stdout, stderr } = process.streams;
-        // Merge stdout and stderr
-        const streams = [];
-        if (stdout) {
-            streams.push(this.streamToChunks(stdout, "stdout"));
-        }
-        if (stderr) {
-            streams.push(this.streamToChunks(stderr, "stderr"));
-        }
-        // Yield chunks from all streams
-        for (const stream of streams) {
-            for await (const chunk of stream) {
-                yield chunk;
-            }
-        }
-    }
-    /**
-     * Convert protocol peer messages to output chunks
-     *
-     * Used for Claude Code which uses a protocol peer that consumes stdout
-     * Updates completion state when result message is received
-     *
-     * @private
-     */
-    async *peerMessagesToOutputChunks(peer, executionId) {
-        const messageQueue = [];
-        let streamEnded = false;
-        let exitDetected = false;
-        // Register message handler
-        peer.onMessage((message) => {
-            messageQueue.push(message);
-            // Detect completion and update completion state
-            if (message.type === "result" &&
-                (message.subtype === "success" || message.subtype === "failure")) {
-                exitDetected = true;
-                const exitCode = message.subtype === "success" ? 0 : 1;
-                this.completionState.set(executionId, { completed: true, exitCode });
-                console.log(`[AgentExecutorWrapper] Detected completion from peer for ${executionId}:`, { subtype: message.subtype, exitCode });
-            }
-        });
-        // Process messages until completion
-        while (!streamEnded || messageQueue.length > 0) {
-            if (messageQueue.length === 0) {
-                if (exitDetected) {
-                    streamEnded = true;
-                    break;
-                }
-                // Wait for more messages
-                await new Promise((resolve) => setTimeout(resolve, 10));
-                continue;
-            }
-            // Convert message to stream-json line format
-            const message = messageQueue.shift();
-            const line = JSON.stringify(message) + "\n";
-            yield {
-                type: "stdout",
-                data: Buffer.from(line, "utf-8"),
-                timestamp: new Date(),
-            };
-        }
-    }
-    /**
-     * Convert a readable stream to output chunks
-     *
-     * @private
-     */
-    async *streamToChunks(stream, type) {
-        for await (const chunk of stream) {
-            yield {
-                type,
-                data: Buffer.isBuffer(chunk) ? chunk : Buffer.from(chunk),
-                timestamp: new Date(),
-            };
-        }
-    }
-}
-//# sourceMappingURL=agent-executor-wrapper.js.map