@accomplish_ai/agent-core 0.0.0-pr-353-20260205225158

package/dist/internal/classes/OpenCodeAdapter.js

@@ -0,0 +1,653 @@
+import * as pty from 'node-pty';
+import { EventEmitter } from 'events';
+import fs from 'fs';
+import path from 'path';
+import { StreamParser } from './StreamParser.js';
+import { OpenCodeLogWatcher, createLogWatcher } from './OpenCodeLogWatcher.js';
+import { CompletionEnforcer } from '../../opencode/completion/index.js';
+export class OpenCodeCliNotFoundError extends Error {
+    constructor() {
+        super('OpenCode CLI is not available. The bundled CLI may be missing or corrupted. Please reinstall the application.');
+        this.name = 'OpenCodeCliNotFoundError';
+    }
+}
+export class OpenCodeAdapter extends EventEmitter {
+    ptyProcess = null;
+    streamParser;
+    logWatcher = null;
+    currentSessionId = null;
+    currentTaskId = null;
+    messages = [];
+    hasCompleted = false;
+    isDisposed = false;
+    wasInterrupted = false;
+    completionEnforcer;
+    lastWorkingDirectory;
+    currentModelId = null;
+    waitingTransitionTimer = null;
+    hasReceivedFirstTool = false;
+    startTaskCalled = false;
+    options;
+    constructor(options, taskId) {
+        super();
+        this.options = options;
+        this.currentTaskId = taskId || null;
+        this.streamParser = new StreamParser();
+        this.completionEnforcer = this.createCompletionEnforcer();
+        this.setupStreamParsing();
+        this.setupLogWatcher();
+    }
+    createCompletionEnforcer() {
+        const callbacks = {
+            onStartContinuation: async (prompt) => {
+                await this.spawnSessionResumption(prompt);
+            },
+            onComplete: () => {
+                this.hasCompleted = true;
+                this.emit('complete', {
+                    status: 'success',
+                    sessionId: this.currentSessionId || undefined,
+                });
+            },
+            onDebug: (type, message, data) => {
+                this.emit('debug', { type, message, data });
+            },
+        };
+        return new CompletionEnforcer(callbacks);
+    }
+    setupLogWatcher() {
+        this.logWatcher = createLogWatcher();
+        this.logWatcher.on('error', (error) => {
+            if (!this.hasCompleted && this.ptyProcess) {
+                console.log('[OpenCode Adapter] Log watcher detected error:', error.errorName);
+                const errorMessage = OpenCodeLogWatcher.getErrorMessage(error);
+                this.emit('debug', {
+                    type: 'error',
+                    message: `[${error.errorName}] ${errorMessage}`,
+                    data: {
+                        errorName: error.errorName,
+                        statusCode: error.statusCode,
+                        providerID: error.providerID,
+                        modelID: error.modelID,
+                        message: error.message,
+                    },
+                });
+                if (error.isAuthError && error.providerID) {
+                    console.log('[OpenCode Adapter] Emitting auth-error for provider:', error.providerID);
+                    this.emit('auth-error', {
+                        providerId: error.providerID,
+                        message: errorMessage,
+                    });
+                }
+                this.hasCompleted = true;
+                this.emit('complete', {
+                    status: 'error',
+                    sessionId: this.currentSessionId || undefined,
+                    error: errorMessage,
+                });
+                if (this.ptyProcess) {
+                    try {
+                        this.ptyProcess.kill();
+                    }
+                    catch (err) {
+                        console.warn('[OpenCode Adapter] Error killing PTY after log error:', err);
+                    }
+                    this.ptyProcess = null;
+                }
+            }
+        });
+    }
+    async startTask(config) {
+        if (this.isDisposed) {
+            throw new Error('Adapter has been disposed and cannot start new tasks');
+        }
+        const taskId = config.taskId || this.generateTaskId();
+        this.currentTaskId = taskId;
+        this.currentSessionId = null;
+        this.currentModelId = config.modelId || null;
+        this.messages = [];
+        this.streamParser.reset();
+        this.hasCompleted = false;
+        this.wasInterrupted = false;
+        this.completionEnforcer.reset();
+        this.lastWorkingDirectory = config.workingDirectory;
+        this.hasReceivedFirstTool = false;
+        this.startTaskCalled = false;
+        if (this.waitingTransitionTimer) {
+            clearTimeout(this.waitingTransitionTimer);
+            this.waitingTransitionTimer = null;
+        }
+        if (this.logWatcher) {
+            await this.logWatcher.start();
+        }
+        if (this.options.onBeforeStart) {
+            await this.options.onBeforeStart();
+        }
+        const cliArgs = await this.options.buildCliArgs(config);
+        const { command, args: baseArgs } = this.options.getCliCommand();
+        const startMsg = `Starting: ${command} ${[...baseArgs, ...cliArgs].join(' ')}`;
+        console.log('[OpenCode CLI]', startMsg);
+        this.emit('debug', { type: 'info', message: startMsg });
+        const env = await this.options.buildEnvironment(taskId);
+        const allArgs = [...baseArgs, ...cliArgs];
+        const cmdMsg = `Command: ${command}`;
+        const argsMsg = `Args: ${allArgs.join(' ')}`;
+        const safeCwd = config.workingDirectory || this.options.tempPath;
+        const cwdMsg = `Working directory: ${safeCwd}`;
+        if (this.options.isPackaged && this.options.platform === 'win32') {
+            const dummyPackageJson = path.join(safeCwd, 'package.json');
+            if (!fs.existsSync(dummyPackageJson)) {
+                try {
+                    fs.writeFileSync(dummyPackageJson, JSON.stringify({ name: 'opencode-workspace', private: true }, null, 2));
+                    console.log('[OpenCode CLI] Created workspace package.json at:', dummyPackageJson);
+                }
+                catch (err) {
+                    console.warn('[OpenCode CLI] Could not create workspace package.json:', err);
+                }
+            }
+        }
+        console.log('[OpenCode CLI]', cmdMsg);
+        console.log('[OpenCode CLI]', argsMsg);
+        console.log('[OpenCode CLI]', cwdMsg);
+        this.emit('debug', { type: 'info', message: cmdMsg });
+        this.emit('debug', { type: 'info', message: argsMsg, data: { args: allArgs } });
+        this.emit('debug', { type: 'info', message: cwdMsg });
+        {
+            const fullCommand = this.buildShellCommand(command, allArgs);
+            const shellCmdMsg = `Full shell command: ${fullCommand}`;
+            console.log('[OpenCode CLI]', shellCmdMsg);
+            this.emit('debug', { type: 'info', message: shellCmdMsg });
+            const shellCmd = this.getPlatformShell();
+            const shellArgs = this.getShellArgs(fullCommand);
+            const shellMsg = `Using shell: ${shellCmd} ${shellArgs.join(' ')}`;
+            console.log('[OpenCode CLI]', shellMsg);
+            this.emit('debug', { type: 'info', message: shellMsg });
+            this.ptyProcess = pty.spawn(shellCmd, shellArgs, {
+                name: 'xterm-256color',
+                cols: 32000,
+                rows: 30,
+                cwd: safeCwd,
+                env: env,
+            });
+            const pidMsg = `PTY Process PID: ${this.ptyProcess.pid}`;
+            console.log('[OpenCode CLI]', pidMsg);
+            this.emit('debug', { type: 'info', message: pidMsg });
+            this.emit('progress', { stage: 'loading', message: 'Loading agent...' });
+            this.ptyProcess.onData((data) => {
+                const cleanData = data
+                    .replace(/\x1B\[[0-9;?]*[a-zA-Z]/g, '')
+                    .replace(/\x1B\][^\x07]*\x07/g, '')
+                    .replace(/\x1B\][^\x1B]*\x1B\\/g, '');
+                if (cleanData.trim()) {
+                    const truncated = cleanData.substring(0, 500) + (cleanData.length > 500 ? '...' : '');
+                    console.log('[OpenCode CLI stdout]:', truncated);
+                    this.emit('debug', { type: 'stdout', message: cleanData });
+                    this.streamParser.feed(cleanData);
+                }
+            });
+            this.ptyProcess.onExit(({ exitCode, signal }) => {
+                const exitMsg = `PTY Process exited with code: ${exitCode}, signal: ${signal}`;
+                console.log('[OpenCode CLI]', exitMsg);
+                this.emit('debug', { type: 'exit', message: exitMsg, data: { exitCode, signal } });
+                this.handleProcessExit(exitCode);
+            });
+        }
+        return {
+            id: taskId,
+            prompt: config.prompt,
+            status: 'running',
+            messages: [],
+            createdAt: new Date().toISOString(),
+            startedAt: new Date().toISOString(),
+        };
+    }
+    async resumeSession(sessionId, prompt) {
+        return this.startTask({
+            prompt,
+            sessionId,
+        });
+    }
+    async sendResponse(response) {
+        if (!this.ptyProcess) {
+            throw new Error('No active process');
+        }
+        this.ptyProcess.write(response + '\n');
+        console.log('[OpenCode CLI] Response sent via PTY');
+    }
+    async cancelTask() {
+        if (this.ptyProcess) {
+            this.ptyProcess.kill();
+            this.ptyProcess = null;
+        }
+    }
+    async interruptTask() {
+        if (!this.ptyProcess) {
+            console.log('[OpenCode CLI] No active process to interrupt');
+            return;
+        }
+        this.wasInterrupted = true;
+        this.ptyProcess.write('\x03');
+        console.log('[OpenCode CLI] Sent Ctrl+C interrupt signal');
+        if (this.options.platform === 'win32') {
+            setTimeout(() => {
+                if (this.ptyProcess) {
+                    this.ptyProcess.write('Y\n');
+                    console.log('[OpenCode CLI] Sent Y to confirm batch termination');
+                }
+            }, 100);
+        }
+    }
+    getSessionId() {
+        return this.currentSessionId;
+    }
+    getTaskId() {
+        return this.currentTaskId;
+    }
+    get running() {
+        return this.ptyProcess !== null && !this.hasCompleted;
+    }
+    isAdapterDisposed() {
+        return this.isDisposed;
+    }
+    dispose() {
+        if (this.isDisposed) {
+            return;
+        }
+        console.log(`[OpenCode Adapter] Disposing adapter for task ${this.currentTaskId}`);
+        this.isDisposed = true;
+        if (this.logWatcher) {
+            this.logWatcher.stop().catch((err) => {
+                console.warn('[OpenCode Adapter] Error stopping log watcher:', err);
+            });
+        }
+        if (this.ptyProcess) {
+            try {
+                this.ptyProcess.kill();
+            }
+            catch (error) {
+                console.error('[OpenCode Adapter] Error killing PTY process:', error);
+            }
+            this.ptyProcess = null;
+        }
+        this.currentSessionId = null;
+        this.currentTaskId = null;
+        this.messages = [];
+        this.hasCompleted = true;
+        this.currentModelId = null;
+        this.hasReceivedFirstTool = false;
+        this.startTaskCalled = false;
+        if (this.waitingTransitionTimer) {
+            clearTimeout(this.waitingTransitionTimer);
+            this.waitingTransitionTimer = null;
+        }
+        this.streamParser.reset();
+        this.removeAllListeners();
+        console.log('[OpenCode Adapter] Adapter disposed');
+    }
+    escapeShellArg(arg) {
+        if (this.options.platform === 'win32') {
+            if (arg.includes(' ') || arg.includes('"')) {
+                return `"${arg.replace(/"/g, '""')}"`;
+            }
+            return arg;
+        }
+        else {
+            const needsEscaping = ["'", ' ', '$', '`', '\\', '"', '\n'].some(c => arg.includes(c));
+            if (needsEscaping) {
+                return `'${arg.replace(/'/g, "'\\''")}'`;
+            }
+            return arg;
+        }
+    }
+    buildShellCommand(command, args) {
+        const escapedCommand = this.escapeShellArg(command);
+        const escapedArgs = args.map(arg => this.escapeShellArg(arg));
+        return [escapedCommand, ...escapedArgs].join(' ');
+    }
+    setupStreamParsing() {
+        this.streamParser.on('message', (message) => {
+            this.handleMessage(message);
+        });
+        this.streamParser.on('error', (error) => {
+            console.warn('[OpenCode Adapter] Stream parse warning:', error.message);
+            this.emit('debug', { type: 'parse-warning', message: error.message });
+        });
+    }
+    handleMessage(message) {
+        console.log('[OpenCode Adapter] Handling message type:', message.type);
+        switch (message.type) {
+            case 'step_start':
+                this.currentSessionId = message.part.sessionID;
+                const modelDisplayName = this.currentModelId && this.options.getModelDisplayName
+                    ? this.options.getModelDisplayName(this.currentModelId)
+                    : 'AI';
+                this.emit('progress', {
+                    stage: 'connecting',
+                    message: `Connecting to ${modelDisplayName}...`,
+                    modelName: modelDisplayName,
+                });
+                if (this.waitingTransitionTimer) {
+                    clearTimeout(this.waitingTransitionTimer);
+                }
+                this.waitingTransitionTimer = setTimeout(() => {
+                    if (!this.hasReceivedFirstTool && !this.hasCompleted) {
+                        this.emit('progress', { stage: 'waiting', message: 'Waiting for response...' });
+                    }
+                }, 500);
+                break;
+            case 'text':
+                if (!this.currentSessionId && message.part.sessionID) {
+                    this.currentSessionId = message.part.sessionID;
+                }
+                this.emit('message', message);
+                if (message.part.text) {
+                    const taskMessage = {
+                        id: this.generateMessageId(),
+                        type: 'assistant',
+                        content: message.part.text,
+                        timestamp: new Date().toISOString(),
+                    };
+                    this.messages.push(taskMessage);
+                }
+                break;
+            case 'tool_call':
+                this.handleToolCall(message.part.tool || 'unknown', message.part.input, message.part.sessionID);
+                break;
+            case 'tool_use':
+                const toolUseMessage = message;
+                const toolUseName = toolUseMessage.part.tool || 'unknown';
+                const toolUseInput = toolUseMessage.part.state?.input;
+                const toolUseOutput = toolUseMessage.part.state?.output || '';
+                this.handleToolCall(toolUseName, toolUseInput, toolUseMessage.part.sessionID);
+                const toolDescription = toolUseInput?.description;
+                if (toolDescription) {
+                    const syntheticTextMessage = {
+                        type: 'text',
+                        timestamp: message.timestamp,
+                        sessionID: message.sessionID,
+                        part: {
+                            id: this.generateMessageId(),
+                            sessionID: toolUseMessage.part.sessionID,
+                            messageID: toolUseMessage.part.messageID,
+                            type: 'text',
+                            text: toolDescription,
+                        },
+                    };
+                    this.emit('message', syntheticTextMessage);
+                }
+                this.emit('message', message);
+                const toolUseStatus = toolUseMessage.part.state?.status;
+                console.log('[OpenCode Adapter] Tool use:', toolUseName, 'status:', toolUseStatus);
+                if (toolUseStatus === 'completed' || toolUseStatus === 'error') {
+                    this.emit('tool-result', toolUseOutput);
+                }
+                if (toolUseName === 'AskUserQuestion') {
+                    this.handleAskUserQuestion(toolUseInput);
+                }
+                break;
+            case 'tool_result':
+                const toolOutput = message.part.output || '';
+                console.log('[OpenCode Adapter] Tool result received, length:', toolOutput.length);
+                this.emit('tool-result', toolOutput);
+                break;
+            case 'step_finish':
+                if (message.part.reason === 'error') {
+                    if (!this.hasCompleted) {
+                        this.hasCompleted = true;
+                        this.emit('complete', {
+                            status: 'error',
+                            sessionId: this.currentSessionId || undefined,
+                            error: 'Task failed',
+                        });
+                    }
+                    break;
+                }
+                const action = this.completionEnforcer.handleStepFinish(message.part.reason);
+                console.log(`[OpenCode Adapter] step_finish action: ${action}`);
+                if (action === 'complete' && !this.hasCompleted) {
+                    this.hasCompleted = true;
+                    this.emit('complete', {
+                        status: 'success',
+                        sessionId: this.currentSessionId || undefined,
+                    });
+                }
+                break;
+            case 'error':
+                this.hasCompleted = true;
+                this.emit('complete', {
+                    status: 'error',
+                    sessionId: this.currentSessionId || undefined,
+                    error: message.error,
+                });
+                break;
+            default:
+                const unknownMessage = message;
+                console.log('[OpenCode Adapter] Unknown message type:', unknownMessage.type);
+        }
+    }
+    handleToolCall(toolName, toolInput, sessionID) {
+        console.log('[OpenCode Adapter] Tool call:', toolName);
+        if (this.isStartTaskTool(toolName)) {
+            this.startTaskCalled = true;
+            const startInput = toolInput;
+            if (startInput?.goal && startInput?.steps) {
+                this.emitPlanMessage(startInput, sessionID || this.currentSessionId || '');
+                const todos = startInput.steps.map((step, i) => ({
+                    id: String(i + 1),
+                    content: step,
+                    status: i === 0 ? 'in_progress' : 'pending',
+                    priority: 'medium',
+                }));
+                if (todos.length > 0) {
+                    this.emit('todo:update', todos);
+                    this.completionEnforcer.updateTodos(todos);
+                    console.log('[OpenCode Adapter] Created todos from start_task steps');
+                }
+            }
+        }
+        if (!this.startTaskCalled && !this.isExemptTool(toolName)) {
+            console.warn(`[OpenCode Adapter] Tool "${toolName}" called before start_task`);
+            this.emit('debug', {
+                type: 'warning',
+                message: `Tool "${toolName}" called before start_task - plan may not be captured`,
+            });
+        }
+        if (!this.hasReceivedFirstTool) {
+            this.hasReceivedFirstTool = true;
+            if (this.waitingTransitionTimer) {
+                clearTimeout(this.waitingTransitionTimer);
+                this.waitingTransitionTimer = null;
+            }
+        }
+        this.completionEnforcer.markToolsUsed();
+        if (toolName === 'complete_task' || toolName.endsWith('_complete_task')) {
+            this.completionEnforcer.handleCompleteTaskDetection(toolInput);
+        }
+        if (toolName === 'todowrite' || toolName.endsWith('_todowrite')) {
+            const input = toolInput;
+            if (input?.todos && Array.isArray(input.todos) && input.todos.length > 0) {
+                this.emit('todo:update', input.todos);
+                this.completionEnforcer.updateTodos(input.todos);
+            }
+        }
+        this.emit('tool-use', toolName, toolInput);
+        this.emit('progress', {
+            stage: 'tool-use',
+            message: `Using ${toolName}`,
+        });
+        if (toolName === 'AskUserQuestion') {
+            this.handleAskUserQuestion(toolInput);
+        }
+    }
+    handleAskUserQuestion(input) {
+        const question = input.questions?.[0];
+        if (!question)
+            return;
+        const permissionRequest = {
+            id: this.generateRequestId(),
+            taskId: this.currentTaskId || '',
+            type: 'question',
+            question: question.question,
+            options: question.options?.map((o) => ({
+                label: o.label,
+                description: o.description,
+            })),
+            multiSelect: question.multiSelect,
+            createdAt: new Date().toISOString(),
+        };
+        this.emit('permission-request', permissionRequest);
+    }
+    handleProcessExit(code) {
+        this.ptyProcess = null;
+        if (this.wasInterrupted && code === 0 && !this.hasCompleted) {
+            console.log('[OpenCode CLI] Task was interrupted by user');
+            this.hasCompleted = true;
+            this.emit('complete', {
+                status: 'interrupted',
+                sessionId: this.currentSessionId || undefined,
+            });
+            this.currentTaskId = null;
+            return;
+        }
+        if (code === 0 && !this.hasCompleted) {
+            this.completionEnforcer.handleProcessExit(code).catch((error) => {
+                console.error('[OpenCode Adapter] Completion enforcer error:', error);
+                this.hasCompleted = true;
+                this.emit('complete', {
+                    status: 'error',
+                    sessionId: this.currentSessionId || undefined,
+                    error: `Failed to complete: ${error.message}`,
+                });
+            });
+            return;
+        }
+        if (!this.hasCompleted) {
+            if (code !== null && code !== 0) {
+                this.emit('error', new Error(`OpenCode CLI exited with code ${code}`));
+            }
+        }
+        this.currentTaskId = null;
+    }
+    async spawnSessionResumption(prompt) {
+        const sessionId = this.currentSessionId;
+        if (!sessionId) {
+            throw new Error('No session ID available for session resumption');
+        }
+        console.log(`[OpenCode Adapter] Starting session resumption with session ${sessionId}`);
+        this.streamParser.reset();
+        const config = {
+            prompt,
+            sessionId: sessionId,
+            workingDirectory: this.lastWorkingDirectory,
+        };
+        const cliArgs = await this.options.buildCliArgs(config);
+        const { command, args: baseArgs } = this.options.getCliCommand();
+        console.log('[OpenCode Adapter] Session resumption command:', command, [...baseArgs, ...cliArgs].join(' '));
+        const env = await this.options.buildEnvironment(this.currentTaskId || 'default');
+        const allArgs = [...baseArgs, ...cliArgs];
+        const safeCwd = config.workingDirectory || this.options.tempPath;
+        const fullCommand = this.buildShellCommand(command, allArgs);
+        const shellCmd = this.getPlatformShell();
+        const shellArgs = this.getShellArgs(fullCommand);
+        this.ptyProcess = pty.spawn(shellCmd, shellArgs, {
+            name: 'xterm-256color',
+            cols: 32000,
+            rows: 30,
+            cwd: safeCwd,
+            env: env,
+        });
+        this.ptyProcess.onData((data) => {
+            const cleanData = data
+                .replace(/\x1B\[[0-9;?]*[a-zA-Z]/g, '')
+                .replace(/\x1B\][^\x07]*\x07/g, '')
+                .replace(/\x1B\][^\x1B]*\x1B\\/g, '');
+            if (cleanData.trim()) {
+                const truncated = cleanData.substring(0, 500) + (cleanData.length > 500 ? '...' : '');
+                console.log('[OpenCode CLI stdout]:', truncated);
+                this.emit('debug', { type: 'stdout', message: cleanData });
+                this.streamParser.feed(cleanData);
+            }
+        });
+        this.ptyProcess.onExit(({ exitCode }) => {
+            this.handleProcessExit(exitCode);
+        });
+    }
+    generateId(prefix) {
+        return `${prefix}_${Date.now()}_${Math.random().toString(36).substring(2, 11)}`;
+    }
+    generateTaskId() {
+        return this.generateId('task');
+    }
+    generateMessageId() {
+        return this.generateId('msg');
+    }
+    generateRequestId() {
+        return this.generateId('req');
+    }
+    isStartTaskTool(toolName) {
+        return toolName === 'start_task' || toolName.endsWith('_start_task');
+    }
+    isExemptTool(toolName) {
+        if (toolName === 'todowrite' || toolName.endsWith('_todowrite')) {
+            return true;
+        }
+        if (this.isStartTaskTool(toolName)) {
+            return true;
+        }
+        return false;
+    }
+    emitPlanMessage(input, sessionId) {
+        const verificationSection = input.verification?.length
+            ? `\n\n**Verification:**\n${input.verification.map((v, i) => `${i + 1}. ${v}`).join('\n')}`
+            : '';
+        const skillsSection = input.skills?.length
+            ? `\n\n**Skills:** ${input.skills.join(', ')}`
+            : '';
+        const planText = `**Plan:**\n\n**Goal:** ${input.goal}\n\n**Steps:**\n${input.steps.map((s, i) => `${i + 1}. ${s}`).join('\n')}${verificationSection}${skillsSection}`;
+        const syntheticMessage = {
+            type: 'text',
+            timestamp: Date.now(),
+            sessionID: sessionId,
+            part: {
+                id: this.generateMessageId(),
+                sessionID: sessionId,
+                messageID: this.generateMessageId(),
+                type: 'text',
+                text: planText,
+            },
+        };
+        this.emit('message', syntheticMessage);
+        console.log('[OpenCode Adapter] Emitted synthetic plan message');
+    }
+    getPlatformShell() {
+        if (this.options.platform === 'win32') {
+            return 'cmd.exe';
+        }
+        else if (this.options.isPackaged && this.options.platform === 'darwin') {
+            return '/bin/sh';
+        }
+        else {
+            const userShell = process.env.SHELL;
+            if (userShell) {
+                return userShell;
+            }
+            if (fs.existsSync('/bin/bash'))
+                return '/bin/bash';
+            if (fs.existsSync('/bin/zsh'))
+                return '/bin/zsh';
+            return '/bin/sh';
+        }
+    }
+    getShellArgs(command) {
+        if (this.options.platform === 'win32') {
+            return ['/s', '/c', command];
+        }
+        else {
+            return ['-c', command];
+        }
+    }
+}
+export function createAdapter(options, taskId) {
+    return new OpenCodeAdapter(options, taskId);
+}
+//# sourceMappingURL=OpenCodeAdapter.js.map