opencode-bridge 2.9.0-beta

package/dist/opencode/client.js

@@ -0,0 +1,1126 @@
+import { createOpencodeClient } from '@opencode-ai/sdk';
+import { opencodeConfig, modelConfig } from '../config.js';
+import { EventEmitter } from 'events';
+function getPermissionLabel(props) {
+    if (typeof props.permission === 'string' && props.permission.trim()) {
+        return props.permission;
+    }
+    if (typeof props.tool === 'string' && props.tool.trim()) {
+        return props.tool;
+    }
+    if (props.tool && typeof props.tool === 'object') {
+        const toolObj = props.tool;
+        if (typeof toolObj.name === 'string' && toolObj.name.trim()) {
+            return toolObj.name;
+        }
+    }
+    return 'unknown';
+}
+function getFirstString(...values) {
+    for (const value of values) {
+        if (typeof value === 'string' && value.trim()) {
+            return value.trim();
+        }
+    }
+    return '';
+}
+function toRecord(value) {
+    if (!value || typeof value !== 'object' || Array.isArray(value)) {
+        return undefined;
+    }
+    return value;
+}
+function getFirstStringFromRecord(record, keys) {
+    if (!record) {
+        return '';
+    }
+    for (const key of keys) {
+        const value = record[key];
+        if (typeof value === 'string' && value.trim()) {
+            return value.trim();
+        }
+    }
+    return '';
+}
+function extractPermissionCorrelation(props) {
+    const propsRecord = props;
+    const toolRecord = toRecord(props.tool);
+    const metadataRecord = toRecord(props.metadata);
+    const parentSessionId = getFirstString(getFirstStringFromRecord(propsRecord, ['parentSessionID', 'parentSessionId', 'parent_session_id']), getFirstStringFromRecord(toolRecord, ['parentSessionID', 'parentSessionId', 'parent_session_id']), getFirstStringFromRecord(metadataRecord, ['parentSessionID', 'parentSessionId', 'parent_session_id']));
+    const relatedSessionId = getFirstString(getFirstStringFromRecord(propsRecord, [
+        'originSessionID',
+        'originSessionId',
+        'origin_session_id',
+        'rootSessionID',
+        'rootSessionId',
+        'root_session_id',
+        'sourceSessionID',
+        'sourceSessionId',
+        'source_session_id',
+    ]), getFirstStringFromRecord(toolRecord, [
+        'originSessionID',
+        'originSessionId',
+        'origin_session_id',
+        'rootSessionID',
+        'rootSessionId',
+        'root_session_id',
+        'sourceSessionID',
+        'sourceSessionId',
+        'source_session_id',
+    ]), getFirstStringFromRecord(metadataRecord, [
+        'originSessionID',
+        'originSessionId',
+        'origin_session_id',
+        'rootSessionID',
+        'rootSessionId',
+        'root_session_id',
+        'sourceSessionID',
+        'sourceSessionId',
+        'source_session_id',
+    ]));
+    const messageId = getFirstString(getFirstStringFromRecord(propsRecord, ['messageID', 'messageId', 'message_id']), getFirstStringFromRecord(toolRecord, ['messageID', 'messageId', 'message_id']), getFirstStringFromRecord(metadataRecord, ['messageID', 'messageId', 'message_id']));
+    const callId = getFirstString(getFirstStringFromRecord(propsRecord, ['callID', 'callId', 'call_id', 'toolCallID', 'toolCallId', 'tool_call_id']), getFirstStringFromRecord(toolRecord, ['callID', 'callId', 'call_id', 'toolCallID', 'toolCallId', 'tool_call_id']), getFirstStringFromRecord(metadataRecord, ['callID', 'callId', 'call_id', 'toolCallID', 'toolCallId', 'tool_call_id']));
+    return {
+        ...(parentSessionId ? { parentSessionId } : {}),
+        ...(relatedSessionId ? { relatedSessionId } : {}),
+        ...(messageId ? { messageId } : {}),
+        ...(callId ? { callId } : {}),
+    };
+}
+function isPermissionRequestEventType(eventType) {
+    const normalized = eventType.toLowerCase();
+    if (!normalized.includes('permission')) {
+        return false;
+    }
+    if (normalized.includes('replied') ||
+        normalized.includes('reply') ||
+        normalized.includes('granted') ||
+        normalized.includes('denied') ||
+        normalized.includes('resolved')) {
+        return false;
+    }
+    return (normalized.includes('request') ||
+        normalized.includes('asked') ||
+        normalized.includes('require') ||
+        normalized.includes('pending'));
+}
+function formatSdkError(error) {
+    if (!error)
+        return '未知错误';
+    if (typeof error === 'string') {
+        return error;
+    }
+    if (error instanceof Error) {
+        return error.message;
+    }
+    if (typeof error === 'object') {
+        const record = error;
+        if (typeof record.message === 'string' && record.message.trim()) {
+            return record.message;
+        }
+        try {
+            return JSON.stringify(record);
+        }
+        catch {
+            return String(error);
+        }
+    }
+    return String(error);
+}
+function parseBoolean(value) {
+    if (typeof value === 'boolean')
+        return value;
+    if (typeof value === 'number')
+        return value !== 0;
+    if (typeof value === 'string') {
+        const normalized = value.trim().toLowerCase();
+        if (normalized === 'true' || normalized === '1')
+            return true;
+        if (normalized === 'false' || normalized === '0')
+            return false;
+    }
+    return undefined;
+}
+function parseAgentMode(value) {
+    if (typeof value !== 'string')
+        return undefined;
+    const normalized = value.trim().toLowerCase();
+    if (normalized === 'primary' || normalized === 'subagent' || normalized === 'all') {
+        return normalized;
+    }
+    return undefined;
+}
+function buildOpencodeAuthorizationHeaderValue() {
+    const password = opencodeConfig.serverPassword;
+    if (!password) {
+        return undefined;
+    }
+    const username = opencodeConfig.serverUsername || 'opencode';
+    const encoded = Buffer.from(`${username}:${password}`).toString('base64');
+    return `Basic ${encoded}`;
+}
+function withOpencodeAuthorizationHeaders(headers) {
+    const merged = {
+        ...(headers || {}),
+    };
+    const authorization = buildOpencodeAuthorizationHeaderValue();
+    if (authorization) {
+        merged.Authorization = authorization;
+    }
+    return merged;
+}
+function isUnauthorizedStatusCode(statusCode) {
+    return statusCode === 401 || statusCode === 403;
+}
+function buildAuthEnvHint() {
+    return '请检查 OPENCODE_SERVER_USERNAME / OPENCODE_SERVER_PASSWORD 是否与 OpenCode 服务端一致';
+}
+function appendAuthHint(message, statusCode) {
+    if (!isUnauthorizedStatusCode(statusCode)) {
+        return message;
+    }
+    return `${message}；${buildAuthEnvHint()}`;
+}
+class OpencodeClientWrapper extends EventEmitter {
+    client = null;
+    eventAbortController = null;
+    eventReconnectTimer = null;
+    eventReconnectAttempt = 0;
+    eventListeningEnabled = false;
+    eventStreamActive = false;
+    directoryEventStreams = new Map();
+    // 防止并发调用 ensureDirectoryEventStream 对同一目录建立多条 SSE 连接
+    pendingDirectoryStreams = new Map();
+    constructor() {
+        super();
+    }
+    // 连接到OpenCode服务器
+    async connect() {
+        try {
+            console.log(`[OpenCode] 正在连接到 ${opencodeConfig.baseUrl}...`);
+            this.client = createOpencodeClient({
+                baseUrl: opencodeConfig.baseUrl,
+                headers: withOpencodeAuthorizationHeaders(),
+            });
+            // 通过获取会话列表来检查服务器状态
+            try {
+                const result = await this.client.session.list();
+                if (result.error) {
+                    const statusCode = result.response?.status;
+                    const reason = appendAuthHint(statusCode
+                        ? `OpenCode 连接失败（HTTP ${statusCode}）`
+                        : `OpenCode 连接失败: ${formatSdkError(result.error)}`, statusCode);
+                    console.error(`[OpenCode] ${reason}`);
+                    return false;
+                }
+                console.log('[OpenCode] 已连接');
+                this.eventListeningEnabled = true;
+                // 启动事件监听
+                void this.startEventListener();
+                return true;
+            }
+            catch (error) {
+                const errorMessage = error instanceof Error ? error.message : String(error);
+                const withHint = /\b(401|403)\b/.test(errorMessage)
+                    ? `${errorMessage}；${buildAuthEnvHint()}`
+                    : errorMessage;
+                console.error(`[OpenCode] 服务器状态异常: ${withHint}`);
+                return false;
+            }
+        }
+        catch (error) {
+            console.error('[OpenCode] 连接失败:', error);
+            return false;
+        }
+    }
+    clearEventReconnectTimer() {
+        if (this.eventReconnectTimer) {
+            clearTimeout(this.eventReconnectTimer);
+            this.eventReconnectTimer = null;
+        }
+    }
+    scheduleEventReconnect(reason) {
+        if (!this.eventListeningEnabled || !this.client) {
+            return;
+        }
+        if (this.eventReconnectTimer) {
+            return;
+        }
+        const maxBackoffMs = 15000;
+        const baseBackoffMs = 2000;
+        const step = Math.min(this.eventReconnectAttempt, 4);
+        const delay = Math.min(baseBackoffMs * Math.pow(2, step), maxBackoffMs);
+        this.eventReconnectAttempt += 1;
+        console.warn(`[OpenCode] ${reason}，将在 ${Math.round(delay / 1000)} 秒后重连事件流（第 ${this.eventReconnectAttempt} 次）`);
+        this.eventReconnectTimer = setTimeout(() => {
+            this.eventReconnectTimer = null;
+            void this.startEventListener();
+        }, delay);
+    }
+    clearDirectoryEventReconnectTimer(directory) {
+        const entry = this.directoryEventStreams.get(directory);
+        if (!entry || !entry.reconnectTimer) {
+            return;
+        }
+        clearTimeout(entry.reconnectTimer);
+        entry.reconnectTimer = null;
+    }
+    scheduleDirectoryEventReconnect(directory, reason) {
+        if (!this.eventListeningEnabled || !this.client) {
+            return;
+        }
+        const entry = this.directoryEventStreams.get(directory);
+        if (!entry || entry.reconnectTimer) {
+            return;
+        }
+        const delay = 3000;
+        console.warn(`[OpenCode] ${reason}，将在 ${Math.round(delay / 1000)} 秒后重连目录事件流: ${directory}`);
+        entry.reconnectTimer = setTimeout(() => {
+            entry.reconnectTimer = null;
+            void this.ensureDirectoryEventStream(directory);
+        }, delay);
+    }
+    async ensureDirectoryEventStream(directory) {
+        if (!this.client || !this.eventListeningEnabled) {
+            return;
+        }
+        const normalizedDirectory = directory.trim();
+        if (!normalizedDirectory) {
+            return;
+        }
+        // 防竞态：同一目录正在建立连接时，等待而非重复创建
+        const pending = this.pendingDirectoryStreams.get(normalizedDirectory);
+        if (pending) {
+            await pending;
+            return;
+        }
+        const promise = this._createDirectoryEventStream(normalizedDirectory);
+        this.pendingDirectoryStreams.set(normalizedDirectory, promise);
+        try {
+            await promise;
+        }
+        finally {
+            this.pendingDirectoryStreams.delete(normalizedDirectory);
+        }
+    }
+    async _createDirectoryEventStream(normalizedDirectory) {
+        const existing = this.directoryEventStreams.get(normalizedDirectory);
+        if (existing?.active) {
+            return;
+        }
+        if (existing) {
+            this.clearDirectoryEventReconnectTimer(normalizedDirectory);
+            existing.controller.abort();
+        }
+        const controller = new AbortController();
+        this.directoryEventStreams.set(normalizedDirectory, {
+            controller,
+            active: true,
+            reconnectTimer: null,
+        });
+        try {
+            const events = await this.client.event.subscribe({
+                query: { directory: normalizedDirectory },
+            });
+            console.log(`[OpenCode] 目录事件流订阅成功: ${normalizedDirectory}`);
+            (async () => {
+                try {
+                    for await (const event of events.stream) {
+                        if (controller.signal.aborted || !this.eventListeningEnabled) {
+                            break;
+                        }
+                        if (event.type.toLowerCase().includes('permission')) {
+                            console.log(`[OpenCode] 目录事件: ${event.type}`, JSON.stringify(event.properties || {}).slice(0, 1200));
+                        }
+                        this.handleEvent(event);
+                    }
+                    if (!controller.signal.aborted && this.eventListeningEnabled) {
+                        const entry = this.directoryEventStreams.get(normalizedDirectory);
+                        if (entry) {
+                            entry.active = false;
+                        }
+                        this.scheduleDirectoryEventReconnect(normalizedDirectory, '目录事件流已结束');
+                    }
+                }
+                catch (error) {
+                    if (!controller.signal.aborted && this.eventListeningEnabled) {
+                        console.error(`[OpenCode] 目录事件流中断: ${normalizedDirectory}`, error);
+                        const entry = this.directoryEventStreams.get(normalizedDirectory);
+                        if (entry) {
+                            entry.active = false;
+                        }
+                        this.scheduleDirectoryEventReconnect(normalizedDirectory, '目录事件流中断');
+                    }
+                }
+            })();
+        }
+        catch (error) {
+            console.error(`[OpenCode] 目录事件流订阅失败: ${normalizedDirectory}`, error);
+            // 先清理可能存在的重连定时器，再删除条目，防止僵尸 timer 继续触发
+            this.clearDirectoryEventReconnectTimer(normalizedDirectory);
+            this.directoryEventStreams.delete(normalizedDirectory);
+        }
+    }
+    // 启动SSE事件监听
+    async startEventListener() {
+        if (!this.client || !this.eventListeningEnabled)
+            return;
+        if (this.eventStreamActive)
+            return;
+        this.eventStreamActive = true;
+        this.clearEventReconnectTimer();
+        const controller = new AbortController();
+        if (this.eventAbortController) {
+            this.eventAbortController.abort();
+        }
+        this.eventAbortController = controller;
+        try {
+            const events = await this.client.event.subscribe();
+            console.log('[OpenCode] 事件流订阅成功');
+            this.eventReconnectAttempt = 0;
+            // 异步处理事件流
+            (async () => {
+                try {
+                    for await (const event of events.stream) {
+                        if (controller.signal.aborted || !this.eventListeningEnabled) {
+                            break;
+                        }
+                        // Debug log for permission requests to catch missing ones
+                        if (event.type.toLowerCase().includes('permission')) {
+                            console.log(`[OpenCode] 收到底层事件: ${event.type}`, JSON.stringify(event.properties || {}).slice(0, 1200));
+                        }
+                        this.handleEvent(event);
+                    }
+                    if (!controller.signal.aborted && this.eventListeningEnabled) {
+                        this.scheduleEventReconnect('事件流已结束');
+                    }
+                }
+                catch (error) {
+                    if (!controller.signal.aborted && this.eventListeningEnabled) {
+                        console.error('[OpenCode] 事件流中断:', error);
+                        this.scheduleEventReconnect('事件流中断');
+                    }
+                }
+                finally {
+                    if (this.eventAbortController === controller) {
+                        this.eventAbortController = null;
+                    }
+                    this.eventStreamActive = false;
+                }
+            })();
+        }
+        catch (error) {
+            console.error('[OpenCode] 无法订阅事件:', error);
+            this.eventStreamActive = false;
+            if (!controller.signal.aborted && this.eventListeningEnabled) {
+                this.scheduleEventReconnect('订阅失败');
+            }
+        }
+    }
+    // 处理SSE事件
+    handleEvent(event) {
+        const eventType = event.type.toLowerCase();
+        // 权限请求事件（兼容不同事件命名）
+        if (isPermissionRequestEventType(eventType) && event.properties) {
+            const props = event.properties;
+            const correlation = extractPermissionCorrelation(props);
+            const directSessionId = getFirstString(props.sessionID, props.sessionId, props.session_id);
+            const sessionId = getFirstString(directSessionId, correlation.relatedSessionId, correlation.parentSessionId);
+            const permissionEvent = {
+                sessionId,
+                permissionId: getFirstString(props.id, props.requestId, props.requestID, props.request_id, props.permissionId, props.permissionID, props.permission_id),
+                // permission.asked 的 tool 常为对象（messageID/callID），显示/判断应优先用 permission
+                tool: getPermissionLabel(props),
+                // If description is missing, try to construct one from metadata
+                description: props.description || (props.metadata ? JSON.stringify(props.metadata) : ''),
+                risk: props.risk,
+                ...(correlation.parentSessionId ? { parentSessionId: correlation.parentSessionId } : {}),
+                ...(correlation.relatedSessionId ? { relatedSessionId: correlation.relatedSessionId } : {}),
+                ...(correlation.messageId ? { messageId: correlation.messageId } : {}),
+                ...(correlation.callId ? { callId: correlation.callId } : {}),
+            };
+            if (!permissionEvent.sessionId || !permissionEvent.permissionId) {
+                console.warn('[OpenCode] 权限事件缺少关键字段:', event.type, JSON.stringify(event.properties || {}).slice(0, 1200));
+                return;
+            }
+            this.emit('permissionRequest', permissionEvent);
+        }
+        // 消息更新事件
+        if (event.type === 'message.updated' && event.properties) {
+            this.emit('messageUpdated', event.properties);
+        }
+        // 会话状态变化事件
+        if (event.type === 'session.status' && event.properties) {
+            this.emit('sessionStatus', event.properties);
+        }
+        // 会话空闲事件（处理完成）
+        if (event.type === 'session.idle' && event.properties) {
+            this.emit('sessionIdle', event.properties);
+        }
+        // 会话错误事件
+        if (event.type === 'session.error' && event.properties) {
+            this.emit('sessionError', event.properties);
+        }
+        // 消息部分更新事件（流式输出）
+        if (event.type === 'message.part.updated' && event.properties) {
+            this.emit('messagePartUpdated', event.properties);
+        }
+        // AI 提问事件
+        if (event.type === 'question.asked' && event.properties) {
+            this.emit('questionAsked', event.properties);
+        }
+    }
+    // 获取客户端实例
+    getClient() {
+        if (!this.client) {
+            throw new Error('OpenCode客户端未连接');
+        }
+        return this.client;
+    }
+    // 获取或创建会话
+    async getOrCreateSession(title) {
+        const client = this.getClient();
+        // 尝试获取现有会话列表
+        const sessions = await client.session.list();
+        // 如果有会话，返回最近的一个
+        if (sessions.data && sessions.data.length > 0) {
+            const latestSession = sessions.data[0];
+            return latestSession;
+        }
+        // 创建新会话
+        const newSession = await client.session.create({
+            body: { title: title || '飞书对话' },
+        });
+        return newSession.data;
+    }
+    resolveModelOption(options) {
+        const providerId = options?.providerId?.trim();
+        const modelId = options?.modelId?.trim();
+        if (providerId && modelId) {
+            return {
+                providerID: providerId,
+                modelID: modelId,
+            };
+        }
+        const defaultProvider = modelConfig.defaultProvider;
+        const defaultModel = modelConfig.defaultModel;
+        if (defaultProvider && defaultModel) {
+            return {
+                providerID: defaultProvider,
+                modelID: defaultModel,
+            };
+        }
+        return undefined;
+    }
+    normalizeDirectory(directory) {
+        if (typeof directory !== 'string') {
+            return undefined;
+        }
+        const normalized = directory.trim();
+        return normalized.length > 0 ? normalized : undefined;
+    }
+    buildPermissionDirectoryCandidates(options) {
+        const candidates = [];
+        const seen = new Set();
+        const pushDirectory = (directory) => {
+            const normalized = this.normalizeDirectory(directory);
+            if (!normalized) {
+                if (!seen.has('__default__')) {
+                    seen.add('__default__');
+                    candidates.push(undefined);
+                }
+                return;
+            }
+            const key = process.platform === 'win32' ? normalized.toLowerCase() : normalized;
+            if (seen.has(key)) {
+                return;
+            }
+            seen.add(key);
+            candidates.push(normalized);
+        };
+        pushDirectory(options?.directory);
+        if (Array.isArray(options?.fallbackDirectories)) {
+            for (const directory of options.fallbackDirectories) {
+                pushDirectory(directory);
+            }
+        }
+        pushDirectory(undefined);
+        return candidates;
+    }
+    // 发送消息并等待响应
+    async sendMessage(sessionId, text, options) {
+        const client = this.getClient();
+        const model = this.resolveModelOption(options);
+        if (options?.directory) {
+            void this.ensureDirectoryEventStream(options.directory);
+        }
+        const response = await client.session.prompt({
+            path: { id: sessionId },
+            body: {
+                parts: [{ type: 'text', text }],
+                ...(options?.agent ? { agent: options.agent } : {}),
+                ...(model ? { model } : {}),
+                ...(options?.variant ? { variant: options.variant } : {}),
+            },
+            ...(options?.directory ? { query: { directory: options.directory } } : {}),
+        });
+        return response.data;
+    }
+    // 发送带多类型 parts 的消息
+    async sendMessageParts(sessionId, parts, options, messageId) {
+        const client = this.getClient();
+        const model = this.resolveModelOption(options);
+        if (options?.directory) {
+            void this.ensureDirectoryEventStream(options.directory);
+        }
+        const response = await client.session.prompt({
+            path: { id: sessionId },
+            body: {
+                parts,
+                // ...(messageId ? { messageID: messageId } : {}), // 已注释：避免传递飞书 MessageID 导致 Opencode 无法处理
+                ...(options?.agent ? { agent: options.agent } : {}),
+                ...(model ? { model } : {}),
+                ...(options?.variant ? { variant: options.variant } : {}),
+            },
+            ...(options?.directory ? { query: { directory: options.directory } } : {}),
+        });
+        return response.data;
+    }
+    // 异步发送消息（不等待响应）
+    async sendMessageAsync(sessionId, text, options) {
+        this.getClient();
+        const model = this.resolveModelOption(options);
+        if (options?.directory) {
+            void this.ensureDirectoryEventStream(options.directory);
+        }
+        const dirQuery = options?.directory ? `?directory=${encodeURIComponent(options.directory)}` : '';
+        const response = await fetch(`${opencodeConfig.baseUrl}/session/${sessionId}/prompt_async${dirQuery}`, {
+            method: 'POST',
+            headers: withOpencodeAuthorizationHeaders({ 'Content-Type': 'application/json' }),
+            body: JSON.stringify({
+                parts: [{ type: 'text', text }],
+                ...(options?.agent ? { agent: options.agent } : {}),
+                ...(model ? { model } : {}),
+                ...(options?.variant ? { variant: options.variant } : {}),
+            }),
+        });
+        if (!response.ok) {
+            const detail = await response.text().catch(() => '');
+            const suffix = detail ? `: ${detail.slice(0, 300)}` : '';
+            const message = `prompt_async 请求失败 (${response.status} ${response.statusText})${suffix}`;
+            throw new Error(appendAuthHint(message, response.status));
+        }
+    }
+    // 异步发送多 parts 消息（立即返回，结果通过事件流推送）
+    async sendMessagePartsAsync(sessionId, parts, options) {
+        this.getClient();
+        const model = this.resolveModelOption(options);
+        if (options?.directory) {
+            void this.ensureDirectoryEventStream(options.directory);
+        }
+        const dirQuery = options?.directory ? `?directory=${encodeURIComponent(options.directory)}` : '';
+        const response = await fetch(`${opencodeConfig.baseUrl}/session/${sessionId}/prompt_async${dirQuery}`, {
+            method: 'POST',
+            headers: withOpencodeAuthorizationHeaders({ 'Content-Type': 'application/json' }),
+            body: JSON.stringify({
+                parts,
+                ...(options?.agent ? { agent: options.agent } : {}),
+                ...(model ? { model } : {}),
+                ...(options?.variant ? { variant: options.variant } : {}),
+            }),
+        });
+        if (!response.ok) {
+            const detail = await response.text().catch(() => '');
+            const suffix = detail ? `: ${detail.slice(0, 300)}` : '';
+            const message = `prompt_async 请求失败 (${response.status} ${response.statusText})${suffix}`;
+            throw new Error(appendAuthHint(message, response.status));
+        }
+    }
+    // 发送命令
+    async sendCommand(sessionId, command, args, options) {
+        const client = this.getClient();
+        if (options?.directory) {
+            void this.ensureDirectoryEventStream(options.directory);
+        }
+        const result = await client.session.command({
+            path: { id: sessionId },
+            body: {
+                command,
+                arguments: args,
+            },
+            ...(options?.directory ? { query: { directory: options.directory } } : {}),
+        });
+        if (result.error) {
+            const statusCode = result.response?.status;
+            const detail = formatSdkError(result.error);
+            const message = statusCode
+                ? `OpenCode 命令调用失败（HTTP ${statusCode}）: ${detail}`
+                : `OpenCode 命令调用失败: ${detail}`;
+            throw new Error(appendAuthHint(message, statusCode));
+        }
+        return result.data;
+    }
+    async sendShellCommand(sessionId, command, agent, options) {
+        this.getClient();
+        if (options?.directory) {
+            void this.ensureDirectoryEventStream(options.directory);
+        }
+        const model = options?.providerId && options?.modelId
+            ? {
+                providerID: options.providerId,
+                modelID: options.modelId,
+            }
+            : undefined;
+        const dirQuery = options?.directory ? `?directory=${encodeURIComponent(options.directory)}` : '';
+        const response = await fetch(`${opencodeConfig.baseUrl}/session/${sessionId}/shell${dirQuery}`, {
+            method: 'POST',
+            headers: withOpencodeAuthorizationHeaders({ 'Content-Type': 'application/json' }),
+            body: JSON.stringify({
+                agent,
+                command,
+                ...(model ? { model } : {}),
+            }),
+        });
+        if (!response.ok) {
+            const detail = await response.text().catch(() => '');
+            const suffix = detail ? `: ${detail.slice(0, 500)}` : '';
+            const message = `OpenCode Shell 调用失败（HTTP ${response.status} ${response.statusText}）${suffix}`;
+            throw new Error(appendAuthHint(message, response.status));
+        }
+        const payload = await response.json().catch(() => null);
+        if (!payload || typeof payload !== 'object') {
+            return { parts: [] };
+        }
+        const record = payload;
+        const parts = Array.isArray(record.parts) ? record.parts : [];
+        if (record.info && typeof record.info === 'object') {
+            return {
+                info: record.info,
+                parts,
+            };
+        }
+        if (typeof record.id === 'string' && typeof record.sessionID === 'string') {
+            return {
+                info: record,
+                parts,
+            };
+        }
+        return { parts };
+    }
+    async summarizeSession(sessionId, providerId, modelId) {
+        const client = this.getClient();
+        const result = await client.session.summarize({
+            path: { id: sessionId },
+            body: {
+                providerID: providerId,
+                modelID: modelId,
+            },
+        });
+        if (result.error) {
+            const statusCode = result.response?.status;
+            const detail = formatSdkError(result.error);
+            const message = statusCode
+                ? `会话压缩失败（HTTP ${statusCode}）: ${detail}`
+                : `会话压缩失败: ${detail}`;
+            throw new Error(appendAuthHint(message, statusCode));
+        }
+        return result.data === true;
+    }
+    // 撤回消息
+    async revertMessage(sessionId, messageId) {
+        const client = this.getClient();
+        try {
+            const result = await client.session.revert({
+                path: { id: sessionId },
+                body: { messageID: messageId },
+            });
+            return Boolean(result.data);
+        }
+        catch (error) {
+            console.error('[OpenCode] 撤回消息失败:', error);
+            return false;
+        }
+    }
+    // 中断会话执行
+    async abortSession(sessionId) {
+        const client = this.getClient();
+        try {
+            const result = await client.session.abort({
+                path: { id: sessionId },
+            });
+            return result.data === true;
+        }
+        catch (error) {
+            console.error('[OpenCode] 中断会话失败:', error);
+            return false;
+        }
+    }
+    // 响应权限请求
+    async respondToPermission(sessionId, permissionId, allow, remember = false, options) {
+        const responseType = allow ? (remember ? 'always' : 'once') : 'reject';
+        const directoryCandidates = this.buildPermissionDirectoryCandidates(options);
+        for (const directory of directoryCandidates) {
+            try {
+                const query = directory ? `?directory=${encodeURIComponent(directory)}` : '';
+                const response = await fetch(`${opencodeConfig.baseUrl}/session/${sessionId}/permissions/${permissionId}${query}`, {
+                    method: 'POST',
+                    headers: withOpencodeAuthorizationHeaders({ 'Content-Type': 'application/json' }),
+                    body: JSON.stringify({
+                        response: responseType,
+                    }),
+                });
+                if (response.ok) {
+                    return true;
+                }
+                const detail = await response.text().catch(() => '');
+                const suffix = detail ? `: ${detail.slice(0, 300)}` : '';
+                const message = appendAuthHint(`权限响应失败（HTTP ${response.status} ${response.statusText}）${suffix}`, response.status);
+                const directoryLabel = directory ? `directory=${directory}` : 'directory=<default>';
+                console.error(`[OpenCode] ${message} (${directoryLabel})`);
+            }
+            catch (error) {
+                const directoryLabel = directory ? `directory=${directory}` : 'directory=<default>';
+                console.error(`[OpenCode] 响应权限失败 (${directoryLabel}):`, error);
+            }
+        }
+        return false;
+    }
+    // 获取工作区列表
+    async listProjects(options) {
+        const client = this.getClient();
+        const directory = this.normalizeDirectory(options?.directory);
+        const result = await client.project.list(directory ? { query: { directory } } : undefined);
+        return Array.isArray(result.data) ? result.data : [];
+    }
+    // 获取会话列表（可按目录过滤）
+    async listSessions(options) {
+        const client = this.getClient();
+        const directory = this.normalizeDirectory(options?.directory);
+        const result = await client.session.list(directory ? { query: { directory } } : undefined);
+        return Array.isArray(result.data) ? result.data : [];
+    }
+    // 跨工作区聚合会话列表
+    async listSessionsAcrossProjects() {
+        const merged = new Map();
+        const upsertSessions = (sessions) => {
+            for (const session of sessions) {
+                const existing = merged.get(session.id);
+                if (!existing) {
+                    merged.set(session.id, session);
+                    continue;
+                }
+                const existingUpdated = existing.time?.updated ?? existing.time?.created ?? 0;
+                const nextUpdated = session.time?.updated ?? session.time?.created ?? 0;
+                if (nextUpdated >= existingUpdated) {
+                    merged.set(session.id, session);
+                }
+            }
+        };
+        try {
+            upsertSessions(await this.listSessions());
+        }
+        catch (error) {
+            console.warn('[OpenCode] 获取默认作用域会话列表失败:', error);
+        }
+        const projects = await this.listProjects();
+        const directories = [];
+        const seenDirectories = new Set();
+        for (const project of projects) {
+            const normalized = this.normalizeDirectory(project.worktree);
+            if (!normalized || seenDirectories.has(normalized)) {
+                continue;
+            }
+            seenDirectories.add(normalized);
+            directories.push(normalized);
+        }
+        const sessionGroups = await Promise.all(directories.map(async (directory) => {
+            try {
+                return await this.listSessions({ directory });
+            }
+            catch (error) {
+                console.warn(`[OpenCode] 获取目录会话列表失败: directory=${directory}`, error);
+                return [];
+            }
+        }));
+        for (const sessions of sessionGroups) {
+            upsertSessions(sessions);
+        }
+        return Array.from(merged.values());
+    }
+    // 聚合查询所有已知目录的 session（默认 Instance + 各自定义 directory Instance）
+    async listAllSessions(knownDirectories) {
+        const allSessions = [];
+        const seen = new Set();
+        // 1. 默认 Instance
+        try {
+            const defaultSessions = await this.listSessions();
+            for (const s of defaultSessions) {
+                if (!seen.has(s.id)) {
+                    seen.add(s.id);
+                    allSessions.push(s);
+                }
+            }
+        }
+        catch {
+            // 默认 Instance 查询失败不阻塞
+        }
+        // 2. 各自定义目录的 Instance
+        for (const dir of knownDirectories) {
+            try {
+                const sessions = await this.listSessions({ directory: dir });
+                for (const s of sessions) {
+                    if (!seen.has(s.id)) {
+                        seen.add(s.id);
+                        allSessions.push(s);
+                    }
+                }
+            }
+            catch {
+                // 单个目录查询失败不阻塞其他
+            }
+        }
+        return allSessions;
+    }
+    // 通过 ID 获取会话（可按目录限定）
+    async getSessionById(sessionId, options) {
+        const client = this.getClient();
+        const normalizedSessionId = sessionId.trim();
+        if (!normalizedSessionId) {
+            return null;
+        }
+        const directory = this.normalizeDirectory(options?.directory);
+        const result = await client.session.get({
+            path: { id: normalizedSessionId },
+            ...(directory ? { query: { directory } } : {}),
+        });
+        if (result.error) {
+            const statusCode = result.response?.status;
+            if (statusCode === 404) {
+                return null;
+            }
+            const detail = formatSdkError(result.error);
+            const message = statusCode
+                ? `获取会话失败（HTTP ${statusCode}）: ${detail}`
+                : `获取会话失败: ${detail}`;
+            throw new Error(appendAuthHint(message, statusCode));
+        }
+        return result.data || null;
+    }
+    // 跨工作区按 ID 查找会话
+    async findSessionAcrossProjects(sessionId) {
+        const normalizedSessionId = sessionId.trim();
+        if (!normalizedSessionId) {
+            return null;
+        }
+        const direct = await this.getSessionById(normalizedSessionId);
+        if (direct) {
+            return direct;
+        }
+        const projects = await this.listProjects();
+        const directories = [];
+        const seenDirectories = new Set();
+        for (const project of projects) {
+            const normalized = this.normalizeDirectory(project.worktree);
+            if (!normalized || seenDirectories.has(normalized)) {
+                continue;
+            }
+            seenDirectories.add(normalized);
+            directories.push(normalized);
+        }
+        for (const directory of directories) {
+            const found = await this.getSessionById(normalizedSessionId, { directory });
+            if (found) {
+                return found;
+            }
+        }
+        return null;
+    }
+    // 创建新会话
+    async createSession(title, directory) {
+        const client = this.getClient();
+        const normalizedDir = this.normalizeDirectory(directory);
+        if (normalizedDir) {
+            void this.ensureDirectoryEventStream(normalizedDir);
+        }
+        const result = await client.session.create({
+            body: { title: title || '新对话' },
+            ...(normalizedDir ? { query: { directory: normalizedDir } } : {}),
+        });
+        return result.data;
+    }
+    // 更新会话标题
+    async updateSession(sessionId, title) {
+        const client = this.getClient();
+        const trimmedTitle = title.trim();
+        if (!trimmedTitle) {
+            console.warn('[OpenCode] updateSession: 标题不能为空');
+            return false;
+        }
+        try {
+            const result = await client.session.update({
+                path: { id: sessionId },
+                body: { title: trimmedTitle },
+            });
+            if (result.error) {
+                const statusCode = result.response?.status;
+                const detail = formatSdkError(result.error);
+                const message = statusCode
+                    ? `会话重命名失败（HTTP ${statusCode}）: ${detail}`
+                    : `会话重命名失败: ${detail}`;
+                console.error(`[OpenCode] ${appendAuthHint(message, statusCode)}`);
+                return false;
+            }
+            return true;
+        }
+        catch (error) {
+            console.error(`[OpenCode] 更新会话标题失败: ${sessionId}`, error);
+            return false;
+        }
+    }
+    // 删除会话
+    async deleteSession(sessionId, options) {
+        const client = this.getClient();
+        try {
+            const directory = this.normalizeDirectory(options?.directory);
+            await client.session.delete({
+                path: { id: sessionId },
+                ...(directory ? { query: { directory } } : {}),
+            });
+            console.log(`[OpenCode] 已删除会话: ${sessionId}`);
+            return true;
+        }
+        catch (error) {
+            console.error(`[OpenCode] 删除会话失败: ${sessionId}`, error);
+            return false;
+        }
+    }
+    // 获取会话消息
+    async getSessionMessages(sessionId) {
+        const client = this.getClient();
+        const result = await client.session.messages({
+            path: { id: sessionId },
+        });
+        return result.data || [];
+    }
+    // 获取配置（含模型列表）
+    async getProviders() {
+        const client = this.getClient();
+        const result = await client.config.providers();
+        return result.data;
+    }
+    // 获取完整配置
+    async getConfig() {
+        const client = this.getClient();
+        const result = await client.config.get();
+        return (result.data || {});
+    }
+    // 更新完整配置
+    async updateConfig(config) {
+        const client = this.getClient();
+        try {
+            const result = await client.config.update({
+                body: config,
+            });
+            return (result.data || null);
+        }
+        catch (error) {
+            console.error('[OpenCode] 更新配置失败:', error);
+            return null;
+        }
+    }
+    // 获取可用 Agent 列表
+    async getAgents() {
+        const client = this.getClient();
+        const result = await client.app.agents();
+        const rawAgents = Array.isArray(result.data) ? result.data : [];
+        const agents = [];
+        for (const item of rawAgents) {
+            if (!item || typeof item !== 'object')
+                continue;
+            const record = item;
+            const name = typeof record.name === 'string' ? record.name.trim() : '';
+            if (!name)
+                continue;
+            const description = typeof record.description === 'string' && record.description.trim().length > 0
+                ? record.description.trim()
+                : undefined;
+            const mode = parseAgentMode(record.mode);
+            const hidden = parseBoolean(record.hidden);
+            const builtIn = parseBoolean(record.builtIn);
+            const native = parseBoolean(record.native);
+            agents.push({
+                name,
+                description,
+                mode,
+                ...(hidden !== undefined ? { hidden } : {}),
+                ...(builtIn !== undefined ? { builtIn } : {}),
+                ...(native !== undefined ? { native } : {}),
+            });
+        }
+        return agents;
+    }
+    // 回复问题 (question 工具)
+    // answers 是一个二维数组: [[第一个问题的答案们], [第二个问题的答案们], ...]
+    // 每个答案是选项的 label
+    async replyQuestion(requestId, answers) {
+        try {
+            const response = await fetch(`${opencodeConfig.baseUrl}/question/${requestId}/reply`, {
+                method: 'POST',
+                headers: withOpencodeAuthorizationHeaders({ 'Content-Type': 'application/json' }),
+                body: JSON.stringify({ answers }),
+            });
+            if (!response.ok) {
+                const detail = await response.text().catch(() => '');
+                const suffix = detail ? `: ${detail.slice(0, 300)}` : '';
+                const message = appendAuthHint(`回复问题失败（HTTP ${response.status} ${response.statusText}）${suffix}`, response.status);
+                console.error(`[OpenCode] ${message}`);
+            }
+            return response.ok;
+        }
+        catch (error) {
+            console.error('[OpenCode] 回复问题失败:', error);
+            return false;
+        }
+    }
+    // 拒绝/跳过问题
+    async rejectQuestion(requestId) {
+        try {
+            const response = await fetch(`${opencodeConfig.baseUrl}/question/${requestId}/reject`, {
+                method: 'POST',
+                headers: withOpencodeAuthorizationHeaders({ 'Content-Type': 'application/json' }),
+            });
+            if (!response.ok) {
+                const detail = await response.text().catch(() => '');
+                const suffix = detail ? `: ${detail.slice(0, 300)}` : '';
+                const message = appendAuthHint(`拒绝问题失败（HTTP ${response.status} ${response.statusText}）${suffix}`, response.status);
+                console.error(`[OpenCode] ${message}`);
+            }
+            return response.ok;
+        }
+        catch (error) {
+            console.error('[OpenCode] 拒绝问题失败:', error);
+            return false;
+        }
+    }
+    // 断开连接
+    disconnect() {
+        this.eventListeningEnabled = false;
+        this.eventStreamActive = false;
+        this.clearEventReconnectTimer();
+        this.eventReconnectAttempt = 0;
+        if (this.eventAbortController) {
+            this.eventAbortController.abort();
+            this.eventAbortController = null;
+        }
+        for (const [directory, entry] of this.directoryEventStreams) {
+            this.clearDirectoryEventReconnectTimer(directory);
+            entry.controller.abort();
+        }
+        this.directoryEventStreams.clear();
+        this.client = null;
+        console.log('[OpenCode] 已断开连接');
+    }
+}
+// 单例导出
+export const opencodeClient = new OpencodeClientWrapper();
+//# sourceMappingURL=client.js.map