evolclaw 2.2.0 → 2.3.0

package/dist/agents/gemini-runner.js

@@ -0,0 +1,425 @@
+/**
+ * Gemini Agent Runner
+ *
+ * Integrates Google Gemini CLI as a backend via subprocess.
+ * Each runQuery spawns `gemini -p` with --output-format stream-json,
+ * parsing the JSONL event stream into EvolClaw AgentEvent.
+ *
+ * Architecture:
+ *   GeminiRunner  →  spawn `gemini -p ...`  →  stdout JSONL stream
+ */
+import { spawn } from 'child_process';
+import { createInterface } from 'readline';
+import fs from 'fs';
+import path from 'path';
+import os from 'os';
+import { resolveGoogleConfig } from '../config.js';
+import { GeminiSessionFileAdapter } from '../core/session/adapters/gemini-session-file-adapter.js';
+import { logger } from '../utils/logger.js';
+// Strip ANSI escape codes from Gemini CLI text output.
+// Gemini embeds raw terminal colors from tool stdout (e.g. vitest, npm)
+// into its assistant text, unlike Claude SDK which strips them internally.
+// eslint-disable-next-line no-control-regex
+const ANSI_RE = /\x1b\[[0-9;]*[a-zA-Z]|\x1b\].*?(?:\x1b\\|\x07)/g;
+function stripAnsi(text) {
+    return text.replace(ANSI_RE, '');
+}
+// ── MIME → 扩展名映射 ──
+const MIME_EXT = {
+    'image/png': '.png',
+    'image/jpeg': '.jpg',
+    'image/gif': '.gif',
+    'image/webp': '.webp',
+};
+// ── Gemini 模型列表 ──
+const GEMINI_MODELS = [
+    'gemini-2.5-pro',
+    'gemini-2.5-flash',
+    'gemini-2.5-flash-lite',
+];
+// ── Gemini Runner ──
+export class GeminiRunner {
+    name = 'gemini';
+    capabilities = { clear: true, compact: false, fork: false };
+    resolved;
+    model;
+    activeProcesses = new Map();
+    activeStreams = new Map();
+    activeSessions = new Map(); // sessionId → geminiSessionId
+    onSessionIdUpdate;
+    currentMode = 'auto';
+    constructor(config, callbacks) {
+        this.resolved = resolveGoogleConfig(config);
+        this.model = this.resolved.model;
+        this.onSessionIdUpdate = callbacks.onSessionIdUpdate;
+    }
+    // ── ModelSwitcher ──
+    setModel(model) { this.model = model; }
+    getModel() { return this.model; }
+    listModels() { return GEMINI_MODELS; }
+    // ── Effort (not applicable) ──
+    setEffort(_effort) { }
+    getEffort() { return undefined; }
+    // ── Permission ──
+    setMode(mode) { this.currentMode = mode; }
+    getMode() { return this.currentMode; }
+    listModes() {
+        return [
+            { key: 'auto', nameZh: '自动', description: '全部自动（--yolo 模式）', available: true },
+            { key: 'bypass', nameZh: '放行', description: '全部自动（--yolo 模式）', available: true },
+            { key: 'edit', nameZh: '编辑', description: '仅 Claude 支持', available: false, unavailableReason: 'Gemini CLI 不支持此模式' },
+            { key: 'plan', nameZh: '规划', description: 'Gemini 规划模式', available: true },
+            { key: 'noask', nameZh: '静默', description: '仅 Claude 支持', available: false, unavailableReason: 'Gemini CLI 不支持此模式' },
+            { key: 'readonly', nameZh: '只读', description: '禁止修改项目文件，可在临时目录生成文件', available: true },
+        ];
+    }
+    setSendPrompt(_fn) { }
+    setPermissionGateway(_gw) { }
+    // ── Stream management ──
+    registerStream(key, stream) {
+        this.activeStreams.set(key, stream);
+    }
+    cleanupStream(key) {
+        this.activeStreams.delete(key);
+        this.activeProcesses.delete(key);
+    }
+    hasActiveStream(key) {
+        return this.activeStreams.has(key) || this.activeProcesses.has(key);
+    }
+    // ── Core: runQuery ──
+    async runQuery(sessionId, prompt, projectPath, initialAgentSessionId, images, systemPromptAppend, sessionManager) {
+        let geminiSessionId = initialAgentSessionId || this.activeSessions.get(sessionId);
+        // Safe mode: skip resume
+        if (geminiSessionId && sessionManager) {
+            const health = await sessionManager.getHealthStatus(sessionId);
+            if (health.safeMode) {
+                geminiSessionId = undefined;
+                logger.warn(`[GeminiRunner] Safe mode enabled for ${sessionId}, not resuming session`);
+            }
+        }
+        // Build CLI args
+        const args = [];
+        // Only inject system context on first turn (no resume).
+        // Resumed sessions already have the context from the first turn;
+        // repeating it pollutes the conversation history.
+        let fullPrompt = prompt;
+        if (systemPromptAppend && !geminiSessionId) {
+            fullPrompt = prompt + '\n\n--- [SYSTEM_PROMPT_END] ---\n' + systemPromptAppend;
+        }
+        // Handle images: write to temp files, prepend @file references
+        const tempFiles = [];
+        if (images?.length) {
+            const tmpDir = os.tmpdir();
+            const fileParts = [];
+            for (let i = 0; i < images.length; i++) {
+                const img = images[i];
+                const ext = MIME_EXT[img.mimeType || ''] || '.jpg';
+                const tmpPath = path.join(tmpDir, `evolclaw-gemini-img-${Date.now()}-${i}${ext}`);
+                fs.writeFileSync(tmpPath, Buffer.from(img.data, 'base64'));
+                tempFiles.push(tmpPath);
+                fileParts.push(`@${tmpPath}`);
+            }
+            fullPrompt = fileParts.join(' ') + ' ' + fullPrompt;
+            logger.info(`[GeminiRunner] Attached ${images.length} image(s) via @file reference`);
+        }
+        args.push('-p', fullPrompt);
+        args.push('--output-format', 'stream-json');
+        args.push('-m', this.model);
+        // Permission mode
+        if (this.currentMode === 'plan') {
+            args.push('--approval-mode=plan');
+        }
+        else {
+            args.push('--yolo');
+        }
+        // Resume session
+        if (geminiSessionId) {
+            args.push('-r', geminiSessionId);
+        }
+        // Spawn subprocess
+        const env = {
+            ...process.env,
+        };
+        if (this.resolved.apiKey) {
+            env.GOOGLE_API_KEY = this.resolved.apiKey;
+        }
+        const child = spawn(this.resolved.cliPath, args, {
+            cwd: projectPath,
+            stdio: ['pipe', 'pipe', 'pipe'],
+            env,
+        });
+        this.activeProcesses.set(sessionId, child);
+        // Log stderr
+        child.stderr?.on('data', (data) => {
+            const msg = data.toString().trim();
+            if (msg)
+                logger.debug(`[GeminiRunner:stderr] ${msg}`);
+        });
+        return this.transformStream(child, sessionId, tempFiles);
+    }
+    // ── Event stream transformation ──
+    async *transformStream(child, sessionId, tempFiles) {
+        const pendingToolNames = new Map(); // toolId → toolName
+        const startTime = Date.now();
+        const rl = createInterface({ input: child.stdout });
+        // Build async queue from readline
+        const queue = [];
+        let resolve = null;
+        let rlClosed = false;
+        let processExited = false;
+        let exitCode = null;
+        // We need both rl 'close' AND child 'exit' before considering stream done.
+        // rl 'close' guarantees all buffered lines are emitted.
+        // child 'exit' gives us the exit code.
+        const isStreamDone = () => rlClosed && processExited;
+        rl.on('line', (line) => {
+            queue.push(line);
+            resolve?.();
+        });
+        rl.on('close', () => {
+            rlClosed = true;
+            if (isStreamDone())
+                resolve?.();
+        });
+        child.on('exit', (code) => {
+            processExited = true;
+            exitCode = code;
+            if (isStreamDone())
+                resolve?.();
+        });
+        // Handle race: process may have already exited before we registered the listener.
+        // Real ChildProcess sets exitCode (number) on exit; null means still running.
+        if (!processExited && child.exitCode != null) {
+            processExited = true;
+            exitCode = child.exitCode;
+        }
+        child.on('error', (err) => {
+            logger.error(`[GeminiRunner] Process error: ${err.message}`);
+            rlClosed = true;
+            processExited = true;
+            resolve?.();
+        });
+        try {
+            let done = false;
+            let accumulatedText = '';
+            // TextBuffer: accumulate streaming text tokens, flush as a single
+            // text event on boundary signals (tool_use / result / error / exit).
+            // Prevents StreamFlusher from splitting a single reply into multiple messages.
+            let textBuffer = '';
+            const flushTextBuffer = function* () {
+                if (textBuffer) {
+                    yield { type: 'text', text: stripAnsi(textBuffer) };
+                    textBuffer = '';
+                }
+            };
+            while (!done) {
+                // Process queued lines
+                while (queue.length > 0) {
+                    const line = queue.shift();
+                    if (!line.trim())
+                        continue;
+                    let event;
+                    try {
+                        event = JSON.parse(line);
+                    }
+                    catch {
+                        logger.debug(`[GeminiRunner] Non-JSON line: ${line.substring(0, 200)}`);
+                        continue;
+                    }
+                    switch (event.type) {
+                        case 'init': {
+                            // Extract session_id from init event
+                            const geminiId = event.session_id;
+                            if (geminiId) {
+                                this.activeSessions.set(sessionId, geminiId);
+                                this.onSessionIdUpdate?.(sessionId, geminiId);
+                                yield { type: 'session_id', sessionId: geminiId };
+                            }
+                            break;
+                        }
+                        case 'message': {
+                            // Skip user message echo
+                            if (event.role === 'user')
+                                break;
+                            // Assistant message (delta=true → streaming)
+                            // Accumulate into textBuffer; will flush on boundary event
+                            if (event.role === 'assistant' && event.content) {
+                                accumulatedText += event.content;
+                                textBuffer += event.content;
+                            }
+                            break;
+                        }
+                        case 'tool_use': {
+                            // Boundary: flush accumulated text before tool call
+                            yield* flushTextBuffer();
+                            const toolName = event.tool_name || 'unknown';
+                            if (event.tool_id) {
+                                pendingToolNames.set(event.tool_id, toolName);
+                            }
+                            yield {
+                                type: 'tool_use',
+                                name: toolName,
+                                input: event.parameters || {},
+                            };
+                            break;
+                        }
+                        case 'tool_result': {
+                            const toolName = (event.tool_id && pendingToolNames.get(event.tool_id)) || 'unknown';
+                            if (event.tool_id)
+                                pendingToolNames.delete(event.tool_id);
+                            yield {
+                                type: 'tool_result',
+                                name: toolName,
+                                result: stripAnsi(event.output || ''),
+                                isError: event.status !== 'success',
+                            };
+                            break;
+                        }
+                        case 'result': {
+                            // Boundary: flush accumulated text before complete
+                            yield* flushTextBuffer();
+                            const durationMs = event.stats?.duration_ms || (Date.now() - startTime);
+                            const isError = event.status !== 'success';
+                            // Extract error message from event.error.message (Gemini CLI structure)
+                            const errorMessage = event.error?.message || event.message;
+                            yield {
+                                type: 'complete',
+                                result: accumulatedText || undefined,
+                                isError,
+                                errors: isError ? [errorMessage || event.status || '任务执行失败'] : undefined,
+                                durationMs,
+                                costUsd: undefined,
+                            };
+                            done = true;
+                            break;
+                        }
+                        case 'error': {
+                            // Boundary: flush accumulated text before error
+                            yield* flushTextBuffer();
+                            yield {
+                                type: 'error',
+                                error: event.message || 'Unknown Gemini error',
+                                errorType: 'unknown',
+                            };
+                            if (event.fatal) {
+                                yield { type: 'complete', result: '', isError: true, durationMs: Date.now() - startTime };
+                                done = true;
+                            }
+                            break;
+                        }
+                        default:
+                            logger.debug(`[GeminiRunner] Unknown event type: ${event.type}`);
+                    }
+                }
+                if (!done) {
+                    if (isStreamDone()) {
+                        // Boundary: flush accumulated text before exit
+                        yield* flushTextBuffer();
+                        // Process exited without result event
+                        if (exitCode !== 0) {
+                            yield { type: 'error', error: `Gemini CLI exited with code ${exitCode}`, errorType: 'unknown' };
+                        }
+                        yield { type: 'complete', result: '', isError: exitCode !== 0, durationMs: Date.now() - startTime };
+                        done = true;
+                    }
+                    else {
+                        // Wait for more data
+                        await new Promise((r) => { resolve = r; });
+                        resolve = null;
+                    }
+                }
+            }
+        }
+        finally {
+            rl.close();
+            this.activeProcesses.delete(sessionId);
+            // Kill process if still running
+            if (!child.killed && !processExited) {
+                child.kill('SIGTERM');
+            }
+            // Cleanup temp image files
+            if (tempFiles?.length) {
+                for (const f of tempFiles) {
+                    try {
+                        fs.unlinkSync(f);
+                    }
+                    catch { /* ignore */ }
+                }
+            }
+        }
+    }
+    // ── Interrupt ──
+    async interrupt(sessionKey) {
+        const child = this.activeProcesses.get(sessionKey);
+        if (child && !child.killed) {
+            child.kill('SIGINT');
+            setTimeout(() => {
+                if (!child.killed) {
+                    child.kill('SIGTERM');
+                    logger.info(`[GeminiRunner] SIGTERM fallback for: ${sessionKey}`);
+                }
+            }, 3000);
+            logger.info(`[GeminiRunner] Interrupted session: ${sessionKey} (SIGINT, SIGTERM fallback in 3s)`);
+        }
+        this.activeProcesses.delete(sessionKey);
+        this.activeStreams.delete(sessionKey);
+    }
+    // ── Session commands ──
+    updateSessionId(sessionId, agentSessionId) {
+        if (agentSessionId) {
+            this.activeSessions.set(sessionId, agentSessionId);
+        }
+        else {
+            this.activeSessions.delete(sessionId);
+        }
+        this.onSessionIdUpdate?.(sessionId, agentSessionId);
+    }
+    async closeSession(sessionId) {
+        this.activeSessions.delete(sessionId);
+        this.activeStreams.delete(sessionId);
+        this.activeProcesses.delete(sessionId);
+    }
+    resolveSessionFile(agentSessionId, projectPath) {
+        const adapter = new GeminiSessionFileAdapter();
+        return adapter.findSessionFile(projectPath, agentSessionId);
+    }
+    async clearSession(sessionId, _agentSessionId, _projectPath) {
+        // Clear = don't pass -r next time → fresh session
+        this.activeSessions.delete(sessionId);
+        return true;
+    }
+    async compactSession(_sessionId, _agentSessionId, _projectPath) {
+        logger.info('[GeminiRunner] Compact not supported, Gemini CLI handles context internally');
+        return false;
+    }
+    async compact(_sessionId, _agentSessionId, _projectPath) {
+        return this.compactSession(_sessionId, _agentSessionId, _projectPath);
+    }
+    setCompactStartCallback(_callback) { }
+    // ── Cleanup ──
+    async dispose() {
+        for (const [, child] of this.activeProcesses) {
+            if (!child.killed)
+                child.kill('SIGTERM');
+        }
+        this.activeProcesses.clear();
+        this.activeStreams.clear();
+        this.activeSessions.clear();
+    }
+}
+// ── Plugin ──
+export class GeminiAgentPlugin {
+    name = 'gemini';
+    isEnabled(config) {
+        try {
+            const resolved = resolveGoogleConfig(config);
+            return !!resolved.cliPath;
+        }
+        catch {
+            return false;
+        }
+    }
+    createAgent(config, callbacks) {
+        return { agent: new GeminiRunner(config, callbacks) };
+    }
+}