diff --git a/.env.example b/.env.example index ad9bde9..2aeb295 100644 --- a/.env.example +++ b/.env.example @@ -80,3 +80,8 @@ WORKSPACE_ISOLATION=isolated # ==================== Proxy (Optional) ==================== # http_proxy= + +# ==================== Mino (Optional) ==================== + +# MiMo openai-compatible proxy API key (used by opencode-acp runtime) +# MIMO_API_KEY= diff --git a/.gitignore b/.gitignore index fd35fe3..57f2539 100644 --- a/.gitignore +++ b/.gitignore @@ -89,4 +89,6 @@ skills-lock.json CodeBuddy Code_decompiled CodeBuddy Code_files decompiled -decompiled-ui \ No newline at end of file +decompiled-ui +# opencode project-level config (auto-generated tool overrides) +.opencode/tools/ diff --git a/.opencode/opencode.example.json b/.opencode/opencode.example.json new file mode 100644 index 0000000..baf4b85 --- /dev/null +++ b/.opencode/opencode.example.json @@ -0,0 +1,76 @@ +{ + "$schema": "https://opencode.ai/config.json", + "model": "mimo/mimo-v2.5-pro", + "provider": { + "mimo": { + "npm": "@ai-sdk/openai-compatible", + "name": "MiMo", + "options": { + "baseURL": "{env:OPENAI_API_ENDPOINT}", + "apiKey": "{env:MIMO_API_KEY}" + }, + "models": { + "mimo-v2.5-pro": { + "name": "MiMo V2.5 Pro", + "tool_call": true, + "limit": { + "context": 1048576, + "output": 131072 + }, + "modalities": { + "input": ["text", "image"], + "output": ["text"] + } + }, + "mimo-v2.5": { + "name": "MiMo V2.5", + "tool_call": true, + "limit": { + "context": 1048576, + "output": 131072 + }, + "modalities": { + "input": ["text"], + "output": ["text"] + } + }, + "mimo-v2.5-tts": { + "name": "MiMo V2.5 TTS", + "tool_call": false, + "limit": { + "context": 8192, + "output": 4096 + }, + "modalities": { + "input": ["text"], + "output": ["audio"] + } + }, + "mimo-v2.5-tts-voiceclone": { + "name": "MiMo V2.5 TTS VoiceClone", + "tool_call": false, + "limit": { + "context": 8192, + "output": 4096 + }, + "modalities": { + "input": ["text"], + "output": ["audio"] + } + }, + "mimo-v2.5-tts-voicedesign": { + "name": "MiMo V2.5 TTS VoiceDesign", + "tool_call": false, + "limit": { + "context": 8192, + "output": 4096 + }, + "modalities": { + "input": ["text"], + "output": ["audio"] + } + } + } + } + } +} diff --git a/.opencode/opencode.json b/.opencode/opencode.json new file mode 100644 index 0000000..be4ad4a --- /dev/null +++ b/.opencode/opencode.json @@ -0,0 +1,76 @@ +{ + "$schema": "https://opencode.ai/config.json", + "model": "mimo/mimo-v2.5-pro", + "provider": { + "mimo": { + "npm": "@ai-sdk/openai-compatible", + "name": "MiMo", + "options": { + "baseURL": "{env:OPENAI_API_ENDPOINT}", + "apiKey": "{env:OPENAI_API_KEY}" + }, + "models": { + "mimo-v2.5-pro": { + "name": "MiMo V2.5 Pro", + "tool_call": true, + "limit": { + "context": 1048576, + "output": 131072 + }, + "modalities": { + "input": ["text", "image"], + "output": ["text"] + } + }, + "mimo-v2.5": { + "name": "MiMo V2.5", + "tool_call": true, + "limit": { + "context": 1048576, + "output": 131072 + }, + "modalities": { + "input": ["text"], + "output": ["text"] + } + }, + "mimo-v2.5-tts": { + "name": "MiMo V2.5 TTS", + "tool_call": false, + "limit": { + "context": 8192, + "output": 4096 + }, + "modalities": { + "input": ["text"], + "output": ["audio"] + } + }, + "mimo-v2.5-tts-voiceclone": { + "name": "MiMo V2.5 TTS VoiceClone", + "tool_call": false, + "limit": { + "context": 8192, + "output": 4096 + }, + "modalities": { + "input": ["text"], + "output": ["audio"] + } + }, + "mimo-v2.5-tts-voicedesign": { + "name": "MiMo V2.5 TTS VoiceDesign", + "tool_call": false, + "limit": { + "context": 8192, + "output": 4096 + }, + "modalities": { + "input": ["text"], + "output": ["audio"] + } + } + } + } + } +} diff --git a/.opencode/tools/AskUserQuestion.ts b/.opencode/tools/AskUserQuestion.ts new file mode 100644 index 0000000..041c423 --- /dev/null +++ b/.opencode/tools/AskUserQuestion.ts @@ -0,0 +1,128 @@ +/** + * AskUserQuestion custom tool — 对齐 Tencent AskUserQuestion 契约 + * + * 这不是 opencode builtin tool 的 override，而是我们新增的 custom tool。 + * opencode 原生的 question tool 在 ACP 模式默认禁用且无 ACP 路由， + * 因此我们自行实现。工具名和 schema 对齐 Tencent SDK 的 AskUserQuestion。 + * + * 版本声明（用于 check:tool-schemas 脚本识别）： + * custom tool, not synced from opencode v1.14.33 src/tool/ + * + * Schema 来源：packages/web/src/types/task-chat.ts:AskUserQuestionData + * - 前端 `task-chat.tsx` 按 `part.toolName === 'AskUserQuestion'` 匹配渲染 + * AskUserForm；用其他名字前端识别不到 + * - 前端从 `part.input.questions` 取字段，结构必须是 + * `{ question, header, options:[{label, description}], multiSelect }` + * - askAnswers resume 契约也已存在： + * `{ [assistantMessageId]: { toolCallId, answers: { [header]: value } } }` + * + * OpenCode 文件名约定：文件名 = tool id（ACP tool_call.title） + * 所以文件名 `AskUserQuestion.ts` → opencode 注册的 tool id `AskUserQuestion` + * → 我们 runtime 把 ACP tool_call.title 透传为 AgentCallbackMessage.name + * → convertToSessionUpdate 把 name 放到 sessionUpdate.title + * → 前端 part.toolName = 'AskUserQuestion' ✓ + * + * 运行时行为： + * - execute 发 fetch 到 ASK_USER_URL 阻塞等答案 + * - 收到答案格式：{ ok: true, answers: { [header]: value } } + * - 格式化文本返回给 LLM + * + * env 契约（由 server spawn opencode 时注入）： + * ASK_USER_URL — server 本地回环 endpoint + * ASK_USER_TOKEN — shared secret，X-Internal-Token header + * ASK_USER_CONVERSATION_ID — 当前会话 id + */ +import { z } from 'zod' + +const OptionSchema = z.object({ + label: z.string().describe('Short display text (1-5 words)'), + description: z.string().describe('Explanation of what this option means or its implications'), +}) + +const QuestionSchema = z.object({ + question: z.string().describe('The complete question text (ends with ?)'), + header: z + .string() + .max(30) + .describe('Very short label for this question (max 30 chars, e.g. "Database", "Framework")'), + options: z.array(OptionSchema).min(2).max(4).describe('2-4 available choices'), + multiSelect: z.boolean().optional().describe('true = user may select multiple; false (default) = single selection'), +}) + +export default { + description: + 'Ask the user one or more multiple-choice questions during execution. Use this when you need a decision or clarification that can be expressed as choices. Each question has a `question` (full text), `header` (short label), `options` (2-4 choices, each with `label` and `description`), and `multiSelect` (default false). The user may also type a custom answer.', + args: { + questions: z.array(QuestionSchema).min(1).describe('Questions to ask'), + }, + async execute( + args: { questions: Array> }, + context: { sessionID?: string; callID?: string }, + ) { + const url = process.env.ASK_USER_URL + const token = process.env.ASK_USER_TOKEN + const conversationId = process.env.ASK_USER_CONVERSATION_ID + + if (!url || !token || !conversationId) { + return { + output: + 'Cannot ask questions: AskUser HTTP endpoint is not configured in this environment (ASK_USER_URL missing). Please ask the user directly in your next text response instead.', + } + } + + // 用 opencode 的 callID 作为 toolCallId，与 tool_call 事件的 toolCallId 对齐 + const toolCallId = context.callID || `ask-${context.sessionID ?? 'unknown'}-${Date.now()}` + + const timeoutMs = Number(process.env.ASK_USER_TIMEOUT_MS || 10 * 60 * 1000) + + try { + const res = await fetch(url, { + method: 'POST', + headers: { + 'Content-Type': 'application/json', + 'X-Internal-Token': token, + }, + body: JSON.stringify({ + conversationId, + toolCallId, + questions: args.questions, + }), + signal: AbortSignal.timeout(timeoutMs + 5_000), + }) + + const data = (await res.json().catch(() => ({}))) as { + ok?: boolean + answers?: Record + error?: string + } + + if (!res.ok || !data.ok || !data.answers) { + return { + output: `Failed to get user answer: ${data.error ?? 'unknown error'} (status=${res.status}). Consider asking via plain text.`, + } + } + + // 格式化答案给 LLM（answer key 是 question.header） + const formatted = args.questions + .map((q) => { + const a = data.answers![q.header] + return `"${q.question}" → ${a || '(unanswered)'}` + }) + .join('; ') + + return { + output: formatted, + hint: `You can continue with these answers in mind.`, + // output: `User answered: ${formatted}. You can continue with these answers in mind.`, + metadata: { + answers: data.answers, + }, + } + } catch (e) { + const msg = (e as Error).message + return { + output: `Error asking user (${msg}). You can try asking via plain text in your next response.`, + } + } + }, +} diff --git a/.opencode/tools/bash.ts b/.opencode/tools/bash.ts new file mode 100644 index 0000000..c3f7299 --- /dev/null +++ b/.opencode/tools/bash.ts @@ -0,0 +1,83 @@ +/** + * Global opencode tool override: bash + * 覆盖 opencode builtin bash tool，沙箱模式下通过 HTTP 路由到 SCF 沙箱。 + * + * Schema 与 opencode builtin 完全对齐（v1.14.33 src/tool/bash.ts）。 + * 如果 opencode 版本升级导致 builtin schema 变更，需同步更新本文件。 + * + * 运行时行为： + * SANDBOX_MODE=1 → fetch SANDBOX_BASE_URL/api/tools/bash（沙箱内执行，与宿主机完全隔离） + * 否则 → 本地 execSync + * + * 注意：sandbox 模式下 workdir 参数会被忽略（沙箱有自己的 cwd， + * 沙箱 API 暂不支持覆盖 cwd）。 + */ +import { z } from 'zod' +import { execSync } from 'node:child_process' + +export default { + description: + 'Executes a bash command. In sandbox mode, the command runs inside the SCF container (isolated from host).\n\n' + + 'Usage:\n' + + '- The command argument is required.\n' + + '- You can specify an optional timeout in milliseconds (default 120000ms).\n' + + '- It is very helpful to write a clear, concise description of what this command does in 5-10 words.\n' + + '- Use the workdir parameter to change the working directory instead of "cd ... && command".\n' + + '- AVOID using this tool for file operations (reading/writing/editing/searching); use the specialized tools instead.', + args: { + command: z.string().describe('The command to execute'), + timeout: z.number().int().positive().optional().describe('Optional timeout in milliseconds'), + description: z.string().optional().describe('A clear, concise description of what this command does in 5-10 words'), + workdir: z + .string() + .optional() + .describe( + 'The working directory to run the command in. Defaults to the current directory. Use this instead of "cd" commands.', + ), + }, + async execute( + args: { command: string; timeout?: number; description?: string; workdir?: string }, + context: { directory?: string }, + ) { + const timeoutMs = args.timeout ?? 120_000 + if (process.env.SANDBOX_MODE === '1') { + // workdir not forwarded to sandbox (sandbox manages its own cwd) + return await sandboxCall('bash', { command: args.command, timeout: timeoutMs }, timeoutMs) + } + try { + const out = execSync(args.command, { + timeout: timeoutMs, + cwd: args.workdir ?? context?.directory ?? undefined, + encoding: 'utf8', + maxBuffer: 1024 * 1024 * 4, + }) + return out + } catch (e) { + const err = e as { stdout?: Buffer | string; stderr?: Buffer | string; message: string } + const stdout = typeof err.stdout === 'string' ? err.stdout : (err.stdout?.toString() ?? '') + const stderr = typeof err.stderr === 'string' ? err.stderr : (err.stderr?.toString() ?? '') + throw new Error(`${err.message}\nstdout:\n${stdout}\nstderr:\n${stderr}`) + } + }, +} + +async function sandboxCall(tool: string, body: unknown, timeoutMs: number): Promise { + const baseUrl = process.env.SANDBOX_BASE_URL + if (!baseUrl) throw new Error('SANDBOX_BASE_URL not set') + const headers = JSON.parse(process.env.SANDBOX_AUTH_HEADERS_JSON || '{}') as Record + const res = await fetch(`${baseUrl}/api/tools/${tool}`, { + method: 'POST', + headers: { 'Content-Type': 'application/json', ...headers }, + body: JSON.stringify(body), + signal: AbortSignal.timeout(timeoutMs + 5_000), + }) + const data = (await res.json().catch(() => ({}))) as { success?: boolean; result?: unknown; error?: string } + if (!data.success) throw new Error(data.error ?? `sandbox ${tool} failed (${res.status})`) + const r = data.result as { output?: string; stdout?: string } | string | undefined + if (typeof r === 'string') return r + if (r && typeof r === 'object') { + if (typeof r.output === 'string') return r.output + if (typeof r.stdout === 'string') return r.stdout + } + return JSON.stringify(r ?? '') +} diff --git a/.opencode/tools/edit.ts b/.opencode/tools/edit.ts new file mode 100644 index 0000000..0546c42 --- /dev/null +++ b/.opencode/tools/edit.ts @@ -0,0 +1,74 @@ +/** + * Global opencode tool override: edit + * 覆盖 opencode builtin edit tool，沙箱模式下通过 HTTP 路由到 SCF 沙箱。 + * + * Schema 与 opencode builtin 完全对齐（v1.14.33 src/tool/edit.ts）。 + * 如果 opencode 版本升级导致 builtin schema 变更，需同步更新本文件。 + * + * 运行时行为： + * SANDBOX_MODE=1 → fetch SANDBOX_BASE_URL/api/tools/edit + * 否则 → 本地字符串替换 + */ +import { z } from 'zod' +import fs from 'node:fs' +import path from 'node:path' + +export default { + description: + 'Performs exact string replacements in files.\n\n' + + 'Usage:\n' + + '- You must use your Read tool at least once before editing. This tool will error if you attempt an edit without reading the file.\n' + + '- The edit will FAIL if oldString is not found in the file.\n' + + '- The edit will FAIL if oldString is found multiple times; use replaceAll or provide more context.\n' + + '- Use replaceAll for replacing and renaming strings across the file.\n' + + '- In sandbox mode, use relative paths (no leading /); they resolve against the session working directory.', + args: { + filePath: z.string().describe('The absolute path to the file to modify'), + oldString: z.string().describe('The text to replace'), + newString: z.string().describe('The text to replace it with (must be different from oldString)'), + replaceAll: z.boolean().optional().describe('Replace all occurrences of oldString (default false)'), + }, + async execute( + args: { filePath: string; oldString: string; newString: string; replaceAll?: boolean }, + context: { directory?: string }, + ) { + if (process.env.SANDBOX_MODE === '1') { + return await sandboxCall('edit', { + path: args.filePath, + oldString: args.oldString, + newString: args.newString, + replaceAll: args.replaceAll ?? false, + }) + } + const resolved = path.isAbsolute(args.filePath) + ? args.filePath + : path.resolve(context?.directory ?? process.cwd(), args.filePath) + const content = fs.readFileSync(resolved, 'utf8') + if (!content.includes(args.oldString)) { + throw new Error(`oldString not found in content of ${resolved}`) + } + const out = args.replaceAll + ? content.split(args.oldString).join(args.newString) + : content.replace(args.oldString, args.newString) + fs.writeFileSync(resolved, out) + return { output: `Edited ${resolved}` } + }, +} + +async function sandboxCall(tool: string, body: unknown): Promise { + const baseUrl = process.env.SANDBOX_BASE_URL + if (!baseUrl) throw new Error('SANDBOX_BASE_URL not set') + const headers = JSON.parse(process.env.SANDBOX_AUTH_HEADERS_JSON || '{}') as Record + const res = await fetch(`${baseUrl}/api/tools/${tool}`, { + method: 'POST', + headers: { 'Content-Type': 'application/json', ...headers }, + body: JSON.stringify(body), + signal: AbortSignal.timeout(60_000), + }) + const data = (await res.json().catch(() => ({}))) as { success?: boolean; result?: unknown; error?: string } + if (!data.success) throw new Error(data.error ?? `sandbox ${tool} failed (${res.status})`) + const r = data.result as { output?: string } | string | undefined + if (typeof r === 'string') return r + if (r && typeof r === 'object' && typeof r.output === 'string') return { output: r.output } + return JSON.stringify(r ?? 'ok') +} diff --git a/.opencode/tools/glob.ts b/.opencode/tools/glob.ts new file mode 100644 index 0000000..61dc615 --- /dev/null +++ b/.opencode/tools/glob.ts @@ -0,0 +1,62 @@ +/** + * Global opencode tool override: glob + * 覆盖 opencode builtin glob tool，沙箱模式下通过 HTTP 路由到 SCF 沙箱。 + * + * Schema 与 opencode builtin 完全对齐（v1.14.33 src/tool/glob.ts）。 + * 如果 opencode 版本升级导致 builtin schema 变更，需同步更新本文件。 + * + * 运行时行为： + * SANDBOX_MODE=1 → fetch SANDBOX_BASE_URL/api/tools/glob + * 否则 → find（本地文件系统） + */ +import { z } from 'zod' +import { execSync } from 'node:child_process' + +export default { + description: + 'Fast file pattern matching tool that works with any codebase size.\n' + + '- Supports glob patterns like "**/*.js" or "src/**/*.ts".\n' + + '- Returns matching file paths sorted by modification time.\n' + + '- Use this tool when you need to find files by name patterns.', + args: { + pattern: z.string().describe('The glob pattern to match files against'), + path: z + .string() + .optional() + .describe( + 'The directory to search in. If not specified, the current working directory will be used. ' + + 'IMPORTANT: Omit this field to use the default directory. DO NOT enter "undefined" or "null". ' + + 'Must be a valid directory path if provided.', + ), + }, + async execute(args: { pattern: string; path?: string }, context: { directory?: string }) { + if (process.env.SANDBOX_MODE === '1') { + return await sandboxCall('glob', { pattern: args.pattern, path: args.path }) + } + const base = args.path ?? context?.directory ?? '.' + try { + const out = execSync(`find ${JSON.stringify(base)} -name ${JSON.stringify(args.pattern)} -type f`, { + encoding: 'utf8', + maxBuffer: 1024 * 1024 * 4, + }) + return out + } catch { + return '' + } + }, +} + +async function sandboxCall(tool: string, body: unknown): Promise { + const baseUrl = process.env.SANDBOX_BASE_URL + if (!baseUrl) throw new Error('SANDBOX_BASE_URL not set') + const headers = JSON.parse(process.env.SANDBOX_AUTH_HEADERS_JSON || '{}') as Record + const res = await fetch(`${baseUrl}/api/tools/${tool}`, { + method: 'POST', + headers: { 'Content-Type': 'application/json', ...headers }, + body: JSON.stringify(body), + signal: AbortSignal.timeout(30_000), + }) + const data = (await res.json().catch(() => ({}))) as { success?: boolean; result?: unknown; error?: string } + if (!data.success) throw new Error(data.error ?? `sandbox ${tool} failed (${res.status})`) + return typeof data.result === 'string' ? data.result : JSON.stringify(data.result ?? '') +} diff --git a/.opencode/tools/grep.ts b/.opencode/tools/grep.ts new file mode 100644 index 0000000..04ca8ea --- /dev/null +++ b/.opencode/tools/grep.ts @@ -0,0 +1,64 @@ +/** + * Global opencode tool override: grep + * 覆盖 opencode builtin grep tool，沙箱模式下通过 HTTP 路由到 SCF 沙箱。 + * + * Schema 与 opencode builtin 完全对齐（v1.14.33 src/tool/grep.ts）。 + * 注意：builtin 参数名是 `include`（文件通配），不是 `glob`。 + * 如果 opencode 版本升级导致 builtin schema 变更，需同步更新本文件。 + * + * 运行时行为： + * SANDBOX_MODE=1 → fetch SANDBOX_BASE_URL/api/tools/grep + * 否则 → ripgrep（rg） + */ +import { z } from 'zod' +import { execSync } from 'node:child_process' + +export default { + description: + 'Fast content search tool that works with any codebase size.\n' + + '- Searches file contents using regular expressions.\n' + + '- Supports full regex syntax (e.g. "log.*Error", "function\\s+\\w+").\n' + + '- Filter files by pattern with the include parameter (e.g. "*.js", "*.{ts,tsx}").\n' + + '- Returns file paths and line numbers with at least one match sorted by modification time.', + args: { + pattern: z.string().describe('The regex pattern to search for in file contents'), + path: z.string().optional().describe('The directory to search in. Defaults to the current working directory.'), + include: z.string().optional().describe('File pattern to include in the search (e.g. "*.js", "*.{ts,tsx}")'), + }, + async execute(args: { pattern: string; path?: string; include?: string }, context: { directory?: string }) { + if (process.env.SANDBOX_MODE === '1') { + return await sandboxCall('grep', { + pattern: args.pattern, + path: args.path, + // 沙箱 API 参数名用 glob，与 builtin include 语义相同，做转换 + glob: args.include, + }) + } + const flags: string[] = ['-n', '--no-heading'] + if (args.include) flags.push('-g', args.include) + const searchPath = args.path ?? context?.directory ?? '.' + const cmd = `rg ${flags.map((f) => JSON.stringify(f)).join(' ')} ${JSON.stringify(args.pattern)} ${JSON.stringify(searchPath)}` + try { + return execSync(cmd, { encoding: 'utf8', maxBuffer: 1024 * 1024 * 4 }) + } catch (e) { + const err = e as { status?: number; stdout?: string } + if (err.status === 1) return '' // rg exit 1 = no matches + throw e + } + }, +} + +async function sandboxCall(tool: string, body: unknown): Promise { + const baseUrl = process.env.SANDBOX_BASE_URL + if (!baseUrl) throw new Error('SANDBOX_BASE_URL not set') + const headers = JSON.parse(process.env.SANDBOX_AUTH_HEADERS_JSON || '{}') as Record + const res = await fetch(`${baseUrl}/api/tools/${tool}`, { + method: 'POST', + headers: { 'Content-Type': 'application/json', ...headers }, + body: JSON.stringify(body), + signal: AbortSignal.timeout(30_000), + }) + const data = (await res.json().catch(() => ({}))) as { success?: boolean; result?: unknown; error?: string } + if (!data.success) throw new Error(data.error ?? `sandbox ${tool} failed (${res.status})`) + return typeof data.result === 'string' ? data.result : JSON.stringify(data.result ?? '') +} diff --git a/.opencode/tools/read.ts b/.opencode/tools/read.ts new file mode 100644 index 0000000..8b073a7 --- /dev/null +++ b/.opencode/tools/read.ts @@ -0,0 +1,70 @@ +/** + * Global opencode tool override: read + * 覆盖 opencode builtin read tool，沙箱模式下通过 HTTP 路由到 SCF 沙箱。 + * + * Schema 与 opencode builtin 完全对齐（v1.14.33 src/tool/read.ts）。 + * 如果 opencode 版本升级导致 builtin schema 变更，需同步更新本文件。 + * 检查命令：opencode --version + * + * 运行时行为： + * SANDBOX_MODE=1 → fetch SANDBOX_BASE_URL/api/tools/read + * 否则 → 读本地文件系统（使用 context.directory 解析相对路径） + */ +import { z } from 'zod' +import fs from 'node:fs' +import path from 'node:path' + +export default { + description: + 'Read a file or directory from the filesystem. Returns file contents with line numbers prefixed as `: `.\n\n' + + 'Usage:\n' + + '- The filePath parameter should be an absolute path.\n' + + '- By default, returns up to 2000 lines from the start of the file.\n' + + '- The offset parameter is the line number to start from (1-indexed).\n' + + '- In sandbox mode, use relative paths (no leading /); they resolve against the session working directory.', + args: { + filePath: z.string().describe('The absolute path to the file or directory to read'), + offset: z.number().int().nonnegative().optional().describe('The line number to start reading from (1-indexed)'), + limit: z.number().int().positive().optional().describe('The maximum number of lines to read (defaults to 2000)'), + }, + async execute(args: { filePath: string; offset?: number; limit?: number }, context: { directory?: string }) { + if (process.env.SANDBOX_MODE === '1') { + return await sandboxCall('read', { + path: args.filePath, + // builtin offset is 1-indexed; sandbox API expects 0-based offset + offset: args.offset !== undefined ? args.offset - 1 : undefined, + limit: args.limit, + }) + } + // Local fallback: resolve relative paths against opencode session directory + const resolved = path.isAbsolute(args.filePath) + ? args.filePath + : path.resolve(context?.directory ?? process.cwd(), args.filePath) + const content = fs.readFileSync(resolved, 'utf8') + const allLines = content.split('\n') + // offset is 1-indexed in the builtin interface + const startIdx = args.offset !== undefined ? args.offset - 1 : 0 + const count = args.limit ?? 2000 + const slice = allLines.slice(startIdx, startIdx + count) + // Prefix each line with its 1-indexed line number, matching builtin output format + return slice.map((line, i) => `${startIdx + i + 1}: ${line}`).join('\n') + }, +} + +async function sandboxCall(tool: string, body: unknown): Promise { + const baseUrl = process.env.SANDBOX_BASE_URL + if (!baseUrl) throw new Error('SANDBOX_BASE_URL not set') + const headers = JSON.parse(process.env.SANDBOX_AUTH_HEADERS_JSON || '{}') as Record + const res = await fetch(`${baseUrl}/api/tools/${tool}`, { + method: 'POST', + headers: { 'Content-Type': 'application/json', ...headers }, + body: JSON.stringify(body), + signal: AbortSignal.timeout(30_000), + }) + const data = (await res.json().catch(() => ({}))) as { success?: boolean; result?: unknown; error?: string } + if (!data.success) throw new Error(data.error ?? `sandbox ${tool} failed (${res.status})`) + const r = data.result as { content?: string } | string | undefined + if (typeof r === 'string') return r + if (r && typeof r === 'object' && typeof r.content === 'string') return r.content + return JSON.stringify(r ?? '') +} diff --git a/.opencode/tools/write.ts b/.opencode/tools/write.ts new file mode 100644 index 0000000..f733299 --- /dev/null +++ b/.opencode/tools/write.ts @@ -0,0 +1,57 @@ +/** + * Global opencode tool override: write + * 覆盖 opencode builtin write tool，沙箱模式下通过 HTTP 路由到 SCF 沙箱。 + * + * Schema 与 opencode builtin 完全对齐（v1.14.33 src/tool/write.ts）。 + * 如果 opencode 版本升级导致 builtin schema 变更，需同步更新本文件。 + * + * 运行时行为： + * SANDBOX_MODE=1 → fetch SANDBOX_BASE_URL/api/tools/write + * 否则 → 写本地文件系统 + */ +import { z } from 'zod' +import fs from 'node:fs' +import path from 'node:path' + +export default { + description: + 'Writes a file to the filesystem. Overwrites existing files.\n\n' + + 'Usage:\n' + + '- This tool will overwrite the existing file if there is one at the provided path.\n' + + "- If this is an existing file, you MUST use the Read tool first to read the file's contents.\n" + + '- ALWAYS prefer editing existing files in the codebase. NEVER write new files unless explicitly required.\n' + + '- In sandbox mode, use relative paths (no leading /); they resolve against the session working directory.', + args: { + filePath: z.string().describe('The absolute path to the file to write (must be absolute, not relative)'), + content: z.string().describe('The content to write to the file'), + }, + async execute(args: { filePath: string; content: string }, context: { directory?: string }) { + if (process.env.SANDBOX_MODE === '1') { + return await sandboxCall('write', { path: args.filePath, content: args.content }) + } + const resolved = path.isAbsolute(args.filePath) + ? args.filePath + : path.resolve(context?.directory ?? process.cwd(), args.filePath) + fs.mkdirSync(path.dirname(resolved), { recursive: true }) + fs.writeFileSync(resolved, args.content) + return { output: `Wrote ${args.content.length} bytes to ${resolved}` } + }, +} + +async function sandboxCall(tool: string, body: unknown): Promise { + const baseUrl = process.env.SANDBOX_BASE_URL + if (!baseUrl) throw new Error('SANDBOX_BASE_URL not set') + const headers = JSON.parse(process.env.SANDBOX_AUTH_HEADERS_JSON || '{}') as Record + const res = await fetch(`${baseUrl}/api/tools/${tool}`, { + method: 'POST', + headers: { 'Content-Type': 'application/json', ...headers }, + body: JSON.stringify(body), + signal: AbortSignal.timeout(60_000), + }) + const data = (await res.json().catch(() => ({}))) as { success?: boolean; result?: unknown; error?: string } + if (!data.success) throw new Error(data.error ?? `sandbox ${tool} failed (${res.status})`) + const r = data.result as { output?: string } | string | undefined + if (typeof r === 'string') return r + if (r && typeof r === 'object' && typeof r.output === 'string') return { output: r.output } + return JSON.stringify(r ?? 'ok') +} diff --git a/AGENT_SDK_QUICK_REFERENCE.md b/AGENT_SDK_QUICK_REFERENCE.md new file mode 100644 index 0000000..92028ee --- /dev/null +++ b/AGENT_SDK_QUICK_REFERENCE.md @@ -0,0 +1,244 @@ +# @tencent-ai/agent-sdk 快速参考表 + +## 核心 API 速查 + +### query() 参数详解 + +```typescript +query({ + prompt: string, // 用户输入 + options: { + model: string, // 'glm-5.1' | 'kimi-k2.6' | 'minimax-m2.7' 等 + permissionMode: string, // 'bypassPermissions' | 'plan' + cwd: string, // 本地工作目录 + maxTurns: number, // 默认 500 + resume?: string, // 会话 ID（恢复历史时使用） + persistSession?: boolean, // 新会话时为 true + sessionId: string, // 唯一会话标识 + includePartialMessages: boolean, // true 时流式输出 + systemPrompt: { + append?: string // 追加系统提示词 + }, + mcpServers?: { + [key: string]: McpServer // MCP 工具服务 + }, + canUseTool?: (name, input, options) => { + behavior: 'allow' | 'deny' | 'block' + interrupt?: boolean + message?: string + }, + hooks?: { + PreToolUse: Array<{ + matcher: string // 正则，如 '^mcp__' + hooks: Function[] + }> + }, + env?: Record, // 传给 CLI 的环境变量 + disallowedTools?: string[], // 禁用的工具 + } +}) +``` + +### 消息循环类型 + +```typescript +for await (const message of q) { + // message.type: + // - 'system' → { session_id: string } + // - 'stream_event' → { event: { type, content_block?, delta? } } + // - 'user' → { message: { content: ContentBlock[] } } + // - 'assistant' → { message: { content: ContentBlock[] } } + // - 'error' → { error: string } + // - 'result' → { subtype: string, duration_ms: number } +} +``` + +--- + +## 文件映射表 + +### SDK 调用 ↔ 项目文件 + +| 功能 | SDK 方法 | 项目文件 | 关键代码行 | +|-----|---------|--------|----------| +| **Agent 启动** | `query()` | cloudbase-agent.service.ts | L1429 | +| **消息转换** | callback → message | cloudbase-agent.service.ts | L420-522 | +| **权限检查** | `canUseTool()` | cloudbase-agent.service.ts | L1195-1321 | +| **MCP 集成** | `mcpServers` 参数 | cloudbase-agent.service.ts | L1155-1157 | +| **工具拦截** | patch: tool override | tool-override.ts | envVar 注入 | +| **会话恢复** | `resume` 参数 | persistence.service.ts | restoreMessages() | +| **事件缓冲** | 回调集聚 | event-buffer.ts | pushAndGetSeq() | +| **SSE 转换** | ExtendedSessionUpdate | acp.ts | L462-622 | + +--- + +## Patch 拦截点汇总 + +### 三个环境变量钩子 + +| 环境变量 | 目标类 | 拦截方法 | 用途 | +|---------|--------|---------|------| +| `CODEBUDDY_TOOL_OVERRIDE` | ToolManager | `overrideTools(toolMap)` | 工具重定向到沙箱 | +| `CODEBUDDY_SKILL_LOADER_OVERRIDE` | SkillLoader | `loadSkills() / scanSkillsDirectory() / parseSkillFile()` | 扫描项目/用户技能 | +| `CODEBUDDY_SESSION_STORE_OVERRIDE` | SessionStore | `overrideSessionStore(prototype)` | 自定义会话持久化 | + +### Patch 文件 +- 路径: `/patches/@tencent-ai__agent-sdk@0.3.68.patch` +- 大小: 85 行 +- 应用: pnpm install 时自动应用（via patch-package） + +--- + +## 消息类型对应表 + +### SDK 回调 → ACP sessionUpdate 映射 + +``` +AgentCallbackMessage (SDK) ExtendedSessionUpdate (ACP) +├─ { type: 'text' } → sessionUpdate: 'agent_message_chunk' +├─ { type: 'thinking' } → sessionUpdate: 'thinking' +├─ { type: 'tool_use' } → sessionUpdate: 'tool_call' +├─ { type: 'tool_input_update' } → sessionUpdate: 'tool_call_update' +├─ { type: 'tool_result' } → sessionUpdate: 'tool_call_update' +├─ { type: 'error' } → sessionUpdate: 'log' (level: error) +├─ { type: 'artifact' } → sessionUpdate: 'artifact' +├─ { type: 'ask_user' } → sessionUpdate: 'ask_user' +├─ { type: 'tool_confirm' } → sessionUpdate: 'tool_confirm' +└─ { type: 'agent_phase' } → sessionUpdate: 'agent_phase' +``` + +--- + +## 权限决策流程图 + +``` +Agent 调用工具 (toolName, input) + ↓ +① canUseTool() 同步检查 + ├─ 返回 allow → 继续执行 + ├─ 返回 deny/block + interrupt=true → 中断, emit tool_confirm + └─ 返回 deny/block + interrupt=false → 拒绝 + ↓ +② Resume 场景：用户确认后 + ├─ action='allow' → 执行 + ├─ action='allow_always' → 写白名单 + 执行 + ├─ action='deny' → 拒绝 + └─ action='reject_and_exit_plan' → 允许本次 + 退出 plan 模式 + ↓ +③ PreToolUse Hook (MCP 工具) + └─ 返回 {continue: true/false} → 最终决策 +``` + +--- + +## WRITE_TOOLS 清单 + +需要确认的写操作工具集合（8 个）: + +``` +writeNoSqlDatabaseStructure ← 修改 NoSQL 结构 +writeNoSqlDatabaseContent ← 修改 NoSQL 数据 +executeWriteSQL ← 执行 SQL 写入 +modifyDataModel ← 修改数据模型 +createFunction ← 创建云函数 +updateFunctionCode ← 更新函数代码 +updateFunctionConfig ← 更新函数配置 +invokeFunction ← 调用云函数 +``` + +--- + +## SDK 版本与兼容性 + +| 维度 | 值 | +|-----|-----| +| 当前版本 | 0.3.68 | +| package.json 位置 | packages/server/package.json L26 | +| 依赖列表 | `@tencent-ai/agent-sdk: 0.3.68` | +| Node 版本要求 | >= 18 (推荐 22) | + +--- + +## 故障排查速查表 + +| 问题 | 症状 | 检查点 | +|-----|------|--------| +| Agent 启动失败 | query() throw 异常 | 检查 model ID、cwd、permissions | +| 消息不同步 | SSE 流无响应 | 检查 eventBuffer.flush() 是否调用 | +| 工具执行超时 | tool 卡住 | 检查 ITERATION_TIMEOUT_MS (2min) | +| 会话 resume 失败 | "already running" | 检查 isAgentRunning() 状态 | +| 权限中断无反馈 | tool_confirm 未发出 | 检查 wrappedCallback 是否绑定 | +| MCP 工具不可用 | "Tool not found" | 检查 sandboxMcpClient 是否初始化 | +| Patch 未加载 | tool override 无效 | 运行 `pnpm install` 重新应用补丁 | + +--- + +## 关键常量 + +```typescript +// 模型 +DEFAULT_MODEL = 'glm-5.1' + +// 超时 +CONNECT_TIMEOUT_MS = 60_000 // 连接超时 +ITERATION_TIMEOUT_MS = 2 * 60 * 1000 // 迭代超时 +HEALTH_INTERVAL_MS = 2000 // 沙箱健康检查间隔 + +// 事件缓冲 +MAX_BUFFER_SIZE = 10 // 缓冲区大小 +FLUSH_INTERVAL_MS = 500 // 自动 flush 间隔 + +// 权限 +WRITE_TOOLS = Set(8) // 需确认的写工具 + +// Milestone 事件（触发立即 flush） +MILESTONE_SESSION_UPDATES = [ + 'tool_call', + 'tool_call_update', + 'ask_user', + 'tool_confirm', + 'artifact' +] +``` + +--- + +## 导入路径 + +```typescript +// ✓ 正确 +import { query, ExecutionError } from '@tencent-ai/agent-sdk' +import { CloudbaseAgentService } from '../agent/cloudbase-agent.service' +import { persistenceService } from '../agent/persistence.service' + +// ✗ 错误（不存在的 export） +import { Agent, createAgent } from '@tencent-ai/agent-sdk' // NOT exported +``` + +--- + +## 环境变量清单 + +项目传给 SDK CLI 的所有环境变量: + +```typescript +envVars = { + // 认证 + CODEBUDDY_API_KEY: string, // API Key 模式 + CODEBUDDY_AUTH_TOKEN: string, // OAuth token 模式 + CODEBUDDY_INTERNET_ENVIRONMENT?: string, // 网络环境 + + // 工具拦截 + CODEBUDDY_TOOL_OVERRIDE: string, // 工具 override 模块路径 + CODEBUDDY_TOOL_OVERRIDE_CONFIG: string, // 工具配置 (JSON) + + // 技能加载 + CODEBUDDY_SKILL_LOADER_OVERRIDE: string, // 技能加载 override 模块路径 + CODEBUDDY_SANDBOX_CWD?: string, // 沙箱工作目录 + // CODEBUDDY_BUNDLED_SKILLS_DIR: string, // 捆绑技能目录 (注释) + + // 会话存储 + CODEBUDDY_SESSION_STORE_OVERRIDE?: string, // 会话存储 override (未使用) +} +``` + diff --git a/AGENT_SDK_RESEARCH_REPORT.md b/AGENT_SDK_RESEARCH_REPORT.md new file mode 100644 index 0000000..9f8d394 --- /dev/null +++ b/AGENT_SDK_RESEARCH_REPORT.md @@ -0,0 +1,595 @@ +# @tencent-ai/agent-sdk 项目使用调研报告 + +**项目根目录**: `/Users/yang/git/coding-agent-template` +**生成日期**: 2026-05-01 + +--- + +## 1. SDK 核心使用方式 + +### 1.1 Import 位置与关键 API + +#### 主要导入文件 +- **文件**: `/packages/server/src/agent/cloudbase-agent.service.ts` (2200+ 行) +- **SDK 导入**: + ```typescript + import { query, ExecutionError } from '@tencent-ai/agent-sdk' + ``` + +#### 关键导出 API 及用法 + +| API | 用途 | 位置 | +|-----|------|------| +| `query()` | 创建 agent 查询迭代器，驱动整个 agent 执行流程 | L1429 | +| `ExecutionError` | SDK 内部中断异常（如 interrupt=true 时抛出） | L1556 | +| `supportedModels()` | 获取平台支持的模型列表 | L64 | + +#### 核心调用代码 + +```typescript +// ─── SDK 查询配置 (cloudbase-agent.service.ts, L1176-1426) +const queryArgs = { + prompt, // 用户提示词 + options: { + model: modelId, // 模型 ID（如 'glm-5.1'） + permissionMode: sdkPermissionMode, // 权限模式: 'bypassPermissions' | 'plan' + allowDangerouslySkipPermissions: true, // 跳过权限检查开关 + maxTurns: 500, // 最大对话轮数 + cwd: actualCwd, // 本地工作目录 + sessionId: conversationId, // 会话 ID（resume 时关键） + resume: hasHistory ? conversationId : undefined, // 恢复历史标志 + persistSession: !hasHistory, // 新会话持久化 + includePartialMessages: true, // 包含部分消息（流式） + systemPrompt: { append: '...' }, // 系统提示词（可追加） + mcpServers: { cloudbase: sdkServer }, // MCP 服务配置 + abortController, // 中止控制器 + canUseTool: async (toolName, input, _options) => { /* 工具权限回调 */ }, + hooks: { + PreToolUse: [/* 工具执行前 hook */] + }, + env: envVars, // 传入 CLI 的环境变量 + stderr: (data) => { /* 标准错误回调 */ }, + settingSources: ['project'], // 设置源 + disallowedTools: ['AskUserQuestion'], // 禁用工具列表 + } +} + +const q = query(queryArgs as any) + +// ─── 消息循环迭代 (L1451-1543) +for await (const message of q) { + switch (message.type) { + case 'system': // 系统消息（session_id） + case 'error': // 错误消息 + case 'stream_event': // SDK 内部流事件 + case 'user': // 工具执行结果 + case 'assistant': // 模型响应（含工具调用） + case 'result': // 本轮执行结果 + } +} +``` + +### 1.2 Model 支持 + +```typescript +// 静态模型列表（L49-58） +const STATIC_MODELS = [ + { id: 'minimax-m2.7', name: 'MiniMax-M2.7' }, + { id: 'glm-5.1', name: 'GLM-5.1' }, + { id: 'kimi-k2.6', name: 'Kimi-K2.6' }, + { id: 'deepseek-v3-2-volc', name: 'DeepSeek-V3.2' }, + // ... +] + +// 默认模型 +const DEFAULT_MODEL = 'glm-5.1' // L25 +``` + +--- + +## 2. SDK 改造点（Patch 机制） + +### 2.1 Patch 文件位置与内容 + +- **文件**: `/patches/@tencent-ai__agent-sdk@0.3.68.patch` (85 行) +- **配置**: `package.json` L52-54 注册了 pnpm 补丁 + +### 2.2 Patch 改造的三个拦截点 + +#### (1) **Skill 加载器拦截** (L11-30 of patch) +```javascript +// 注入环境变量: CODEBUDDY_SKILL_LOADER_OVERRIDE +// 目标: 覆盖 SDK 的 loadSkills / scanSkillsDirectory / parseSkillFile 方法 +(function(){ + var _m = process.env.CODEBUDDY_SKILL_LOADER_OVERRIDE; // override 模块路径 + if (!_m) return; + // 拦截三个方法： + // - loadSkills() + // - scanSkillsDirectory() + // - parseSkillFile() + // 注入自定义逻辑（e.g., 扫描项目/用户技能） +})(); +``` +**用途**: 支持项目级和用户级技能加载，不仅仅是 SDK 内置技能 + +**对应实现文件**: +- `packages/server/src/util/skill-loader-override.ts` (编译到 `dist/util/skill-loader-override.cjs`) +- 在 `launchAgent()` 中通过 `envVars.CODEBUDDY_SKILL_LOADER_OVERRIDE` 传入 + +#### (2) **会话存储拦截** (L41-51 of patch) +```javascript +// 注入环境变量: CODEBUDDY_SESSION_STORE_OVERRIDE +// 目标: 覆盖 SDK 的 SessionStore.prototype 行为 +(function(){ + var _ss = process.env.CODEBUDDY_SESSION_STORE_OVERRIDE; + if (!_ss) return; + var _mod = require(_ss); + if (typeof _mod.overrideSessionStore === "function") { + _mod.overrideSessionStore(tL.prototype); // 在 SessionStore 原型上拦截 + } +})(); +``` +**用途**: 自定义会话持久化（JSONL 格式转换、CloudBase 同步等） + +#### (3) **工具执行拦截** (L61-81 of patch) +```javascript +// 注入环境变量: CODEBUDDY_TOOL_OVERRIDE +// 目标: 在 SDK 工具管理器初始化后，覆盖工具集 +(function(){ + var _t = process.env.CODEBUDDY_TOOL_OVERRIDE; + if (!_t) return; + var _mod = require(_t); + if (typeof _mod.overrideTools === "function") { + // 在 ToolManager.init() 后注入，修改 this.toolMap + _mod.overrideTools(this.toolMap); + } +})(); +``` +**用途**: 重定向工具调用到沙箱（CloudBase SCF 函数） + +**对应实现文件**: +- `packages/server/src/sandbox/tool-override.ts` (编译到 `dist/sandbox/tool-override.cjs`) +- 通过 `envVars.CODEBUDDY_TOOL_OVERRIDE` 和 `envVars.CODEBUDDY_TOOL_OVERRIDE_CONFIG` 传入 + +### 2.3 Patch 版本与应用 + +```json +// package.json +"patchedDependencies": { + "@tencent-ai/agent-sdk@0.3.68": "patches/@tencent-ai__agent-sdk@0.3.68.patch" +} +``` +- **SDK 版本**: `0.3.68`（固定） +- **应用方式**: `pnpm install` 时自动应用（via `patch-package`） + +--- + +## 3. Agent 核心能力使用点 + +### 3.1 ACP (Agent Communication Protocol) 协议 + +#### 协议层面 +- **是否使用**: **是** ✓ +- **位置**: `/packages/server/src/routes/acp.ts` (全 ACP 路由实现) + +#### 关键 ACP 消息类型（来自 SDK） + +SDK 的 `message.type` 枚举（在消息循环中）: + +```typescript +// 系统级消息 +message.type === 'system' // session_id 初始化 +message.type === 'error' // 执行错误 + +// 核心业务消息 +message.type === 'stream_event' // SDK 流事件（含 thinking / tool_use / text_delta 等） +message.type === 'user' // 工具结果（tool_result 块） +message.type === 'assistant' // 模型响应（tool_use、text 块） +message.type === 'result' // 执行完成标志 +``` + +#### 消息转换管道 + +**Raw SDK Message → ExtendedSessionUpdate (DB 格式) → ACP SSE (前端格式)** + +```typescript +// CloudbaseAgentService.convertToSessionUpdate() [L420-522] +AgentCallbackMessage (SDK 内部) + ↓ +ExtendedSessionUpdate (适配 ACP 协议) + ↓ +SSE Stream (前端订阅) + +例: +{type: 'text', content: 'hello'} + → {sessionUpdate: 'agent_message_chunk', content: {type: 'text', text: 'hello'}} + → SSE: {'jsonrpc': '2.0', 'method': 'session/update', 'params': {...}} +``` + +### 3.2 SSE 流式输出处理 + +#### 流消息类型映射（L420-522） + +| SDK 回调类型 | sessionUpdate 值 | 说明 | +|-----------|-----------------|------| +| `text` | `agent_message_chunk` | 文本流片段 | +| `thinking` | `thinking` | 思考块内容 | +| `tool_use` | `tool_call` | 工具调用开始 | +| `tool_input_update` | `tool_call_update` | 工具参数更新 | +| `tool_result` | `tool_call_update` | 工具执行结果 | +| `error` | `log` (level=error) | 错误日志 | +| `artifact` | `artifact` | 部署 URL / 二维码等 | +| `ask_user` | `ask_user` | 用户问卷 | +| `tool_confirm` | `tool_confirm` | 工具确认请求 | +| `agent_phase` | `agent_phase` | 代理执行阶段 | + +#### 流处理管道 + +``` +SDK message loop + ↓ +wrappedCallback (L759-795) // 统一回调入口 + ↓ +convertToSessionUpdate() // 转换为 ACP 格式 + ↓ +eventBuffer.push() // 缓冲到内存 + ↓ +persistenceService.appendStreamEvents() // 异步刷到 DB + ↓ +liveCallback() → SSE stream // 同步发给前端 +``` + +### 3.3 工具调用处理与权限拦截 + +#### 权限框架（Permission Model） + +**三层权限检查**: + +1. **canUseTool 回调** (L1195-1321) + - 工具调用前的**异步权限决策** + - 返回 `{behavior: 'allow'|'deny'|'block', interrupt: true}` + +2. **PreToolUse Hook** (L1322-1417) + - MCP 工具（mcp__ 前缀）的前置拦截 + - 返回 `{continue: true/false, decision: 'block'|undefined}` + +3. **会话级白名单** (sessionPermissions) + - `sessionPermissions.isAllowed()` 检查 + - `sessionPermissions.allowAlways()` 记录许可 + +#### 写工具确认机制 + +**WRITE_TOOLS 集合** (L195-207): +```typescript +const WRITE_TOOLS = new Set([ + 'writeNoSqlDatabaseStructure', + 'writeNoSqlDatabaseContent', + 'executeWriteSQL', + 'modifyDataModel', + 'createFunction', + 'updateFunctionCode', + 'updateFunctionConfig', + 'invokeFunction', +]) +``` + +**确认流程**: +``` +Agent 调用写工具 (e.g., executeWriteSQL) + ↓ +canUseTool 判断: + - 白名单中 → {behavior: 'allow'} → 直接执行 + - Resume + toolConfirmation 中 → {behavior: 'allow'|'deny'} → 按用户决策 + - 首次调用 → wrappedCallback({type: 'tool_confirm'}) → 等待用户确认（Interrupt） + ↓ +前端展示 ToolConfirm 对话框 + ↓ +用户确认后 → cloudbaseAgentService.launchAgent() 再次启动 resume 流程 +``` + +### 3.4 MCP (Model Context Protocol) 集成 + +#### MCP 服务配置 + +**位置**: L1155-1157 +```typescript +const mcpServers: Record = {} +if (sandboxMcpClient) { + mcpServers.cloudbase = sandboxMcpClient.sdkServer // SDK-wrapped MCP server +} +``` + +#### MCP 服务来源 + +``` +sandboxMcpClient = await createSandboxMcpClient({ + sandbox: SandboxInstance, + getCredentials: () => ({ cloudbaseEnvId, secretId, secretKey, ... }), + workspaceFolderPaths: actualCwd, + ... +}) + ↓ +mcpClient 内部: + - 通过 HTTP API 与沙箱通信 + - 支持的工具: cloudbase_* (数据库、函数、存储、托管等) + - 工具结果经 tool-override 重定向 +``` + +#### MCP 工具规范化 + +```typescript +// normalizeToolName() [session-permissions.ts] +'mcp__cloudbase__executeWriteSQL' → 'executeWriteSQL' +// 用于权限检查和白名单匹配 +``` + +### 3.5 AskUserQuestion 中断机制 + +#### 工作流 (L1198-1211) + +```typescript +if (toolName === 'AskUserQuestion') { + wrappedCallback({ + type: 'ask_user', + id: toolUseId, + input: { questions: [...] }, + }) + return { + behavior: 'deny', + message: '等待用户回答问题', + interrupt: true, // 中断执行 + } +} +``` + +#### Resume 处理 (L668-738) + +``` +askAnswers 场景（用户填表后）: + ↓ +persistenceService.updateToolResult() // 写入用户回答 + ↓ +restoreMessages() // 从 DB 恢复含答案的历史 + ↓ +query() resume // 重新启动 agent + ↓ +SDK 看到 AskUserQuestion 的结果 → 继续执行（不再中断） +``` + +### 3.6 ExitPlanMode 工具与 Plan 模式 + +#### Plan 模式激活 + +```typescript +const sdkPermissionMode = requestedPermissionMode === 'plan' ? 'plan' : 'bypassPermissions' +// L1170：前端通过 permissionMode='plan' 切入 plan 模式 +``` + +#### ExitPlanMode 处理 (L1221-1256) + +```typescript +if (toolName === 'ExitPlanMode') { + // 首次调用 → wrappedCallback({type: 'tool_confirm', ...}) → PlanModeCard 展示 + // Resume 后 → 根据用户决策: + // · allow / allow_always → SDK 自动切出 plan 模式，继续执行 + // · deny → 继续停留 plan 模式 + // · reject_and_exit_plan → 允许本次，后续前端传 permissionMode=default +} +``` + +--- + +## 4. Agent 抽象层与耦合度分析 + +### 4.1 当前架构与接口 + +#### 核心服务架构 + +``` +CloudbaseAgentService (L416+) + │ + ├─ chatStream() ─────────→ 启动 agent (返回 turnId, alreadyRunning) + │ + ├─ launchAgent() ────────→ 后台执行（含沙箱管理、消息循环、持久化） + │ + ├─ convertToSessionUpdate() → SDK callback → ACP 格式转换 + │ + ├─ handleStreamEvent() ──→ stream_event 解析 + ├─ handleToolResults() ──→ tool_result 聚合 + └─ handleAssistantToolUseInputs() → tool_use 输入序列化 + +persistence.service.ts + ├─ restoreMessages() ────→ DB → JSONL（SDK resume） + ├─ syncMessages() ───────→ JSONL → DB（完成后同步） + └─ updateToolResult() ───→ 写入工具结果 + +EventBuffer (event-buffer.ts) + └─ pushAndGetSeq() → 缓冲 ACP 事件到 DB +``` + +#### 可抽象的接口 + +```typescript +// 建议的 Agent 接口（目前不存在） +interface AgentAdapter { + // 初始化 agent + initialize(config: AgentConfig): Promise + + // 执行 agent + execute(prompt: string, options: AgentOptions): AsyncIterable + + // 中止执行 + abort(conversationId: string): Promise + + // 恢复会话 + resume(conversationId: string, userInput: unknown): AsyncIterable +} + +type AgentMessage = + | {type: 'text', content: string} + | {type: 'tool_call', toolName: string, input: unknown} + | {type: 'tool_result', toolUseId: string, result: unknown} + | {type: 'ask_user', questions: Record} + | {type: 'done', result: unknown} +``` + +### 4.2 Session 与消息持久化耦合度 + +#### 耦合情形 + +| 组件 | 耦合点 | 是否易拆 | +|-----|-------|--------| +| `cloudbase-agent.service` | 直接调用 `query()` → 消息循环 | 😞 难（SDK 消息格式固定） | +| `persistence.service` | 依赖 JSONL → DB 映射 | 😐 中等（可通过 adapter 抽象） | +| `event-buffer` | 绑定 `ExtendedSessionUpdate` 格式 | 😐 中等（格式化层可独立） | +| `sandbox-mcp-proxy` | 实现 MCP server wrapping | 😐 中等（协议标准，可替换） | +| `tool-override.ts` | 工具重定向到沙箱 | 😞 难（与沙箱深度耦合） | + +#### 关键耦合链 + +``` +query() 消息类型 ← SDK 固定 + ↓ +convertToSessionUpdate() ← 适配层（相对独立） + ↓ +ExtendedSessionUpdate ← 项目定义 (shared/types) + ↓ +StreamEvent → DB 存储 ← persistence.service 依赖此格式 + ↓ +JSONL restore → 消息历史恢复 ← SDK resume 时读取 +``` + +### 4.3 替换方案评估 + +#### 选项 A: 保持 @tencent-ai/agent-sdk，替换上层（推荐） + +**可行性**: ✓ 高 +**工作量**: 🔴 中（主要改造 convertToSessionUpdate 和 persistence 层） + +```typescript +// 新增 adapter 层 +interface IAgentBackend { + convertMessage(sdkMessage: any): ExtendedSessionUpdate | null + persistMessage(sessionUpdate: ExtendedSessionUpdate): Promise + restoreHistory(conversationId: string): Promise +} + +class TencentAgentBackend implements IAgentBackend { + // 当前 cloudbase-agent.service 的逻辑 +} + +class AnthropicAgentBackend implements IAgentBackend { + // Claude agent SDK 的适配 +} +``` + +#### 选项 B: 替换为 Anthropic Claude Agent SDK + +**可行性**: ✓ 中 +**工作量**: 🟡 大（需要完全重写消息循环、工具拦截、权限系统） + +``` +@tencent-ai/agent-sdk @anthropic-ai/claude-agent-sdk + query() ←→ createAgent() / agent.run() + message loop ←→ eventStream / generator + canUseTool hook ←→ toolUseHandler callback +``` + +**已有支持**: `/packages/server/src/agent/cloudbase-agent.service.ts` 已 import `@anthropic-ai/claude-agent-sdk`，但仅用于 `tool()` 和 `createSdkMcpServer()`（未深度集成）。 + +#### 选项 C: 完全自建 Agent 引擎 + +**可行性**: 😞 低 +**工作量**: 🔴🔴 极大（需要 LLM 推理集成、工具调用框架、流式处理、会话管理等） + +--- + +## 5. 关键文件与代码路径 + +### 5.1 核心文件清单 + +| 文件 | 行数 | 主要职责 | +|-----|-----|---------| +| `/packages/server/src/agent/cloudbase-agent.service.ts` | 2200+ | **主入口**：Agent 调度、SDK 查询、消息循环、权限控制 | +| `/packages/server/src/agent/persistence.service.ts` | ? | 消息持久化、JSONL 转换、DB 同步 | +| `/packages/server/src/agent/event-buffer.ts` | 75 | 事件缓冲、自动 flush 机制 | +| `/packages/server/src/routes/acp.ts` | 500+ | ACP 协议路由（conversations、chat SSE） | +| `/packages/server/src/sandbox/sandbox-mcp-proxy.ts` | ? | MCP server wrapping、CloudBase 工具封装 | +| `/packages/server/src/sandbox/tool-override.ts` | ? | 工具重定向到沙箱 | +| `/packages/server/src/agent/session-permissions.ts` | ? | 权限检查、白名单管理 | +| `/patches/@tencent-ai__agent-sdk@0.3.68.patch` | 85 | SDK patch：工具/会话/技能拦截 | + +### 5.2 关键方法签名 + +```typescript +// ─── Agent 生命周期 ─────────────────────── +CloudbaseAgentService.chatStream( + prompt: string, + callback: AgentCallback | null, + options: AgentOptions +): Promise<{ turnId: string; alreadyRunning: boolean }> + +CloudbaseAgentService.launchAgent( + prompt: string, + liveCallback: AgentCallback | null, + options: AgentOptions, + assistantMessageId: string +): Promise + +// ─── 消息转换 ────────────────────────── +CloudbaseAgentService.convertToSessionUpdate( + msg: AgentCallbackMessage, + sessionId: string +): ExtendedSessionUpdate | null + +// ─── 权限检查 ────────────────────────── +canUseTool( + toolName: string, + input: unknown, + _options: unknown +): Promise<{ + behavior: 'allow' | 'deny' | 'block' + message?: string + interrupt?: boolean +}> +``` + +--- + +## 6. 快速集成要点 + +### 6.1 如何替换 SDK + +**最小改动方案**: +1. 在 `launchAgent()` 中替换 `query()` 调用 +2. 实现消息循环适配层（将新 SDK 的消息格式转换为 `AgentCallbackMessage`） +3. 保持 `convertToSessionUpdate()` 不变（这是核心格式适配） +4. 替换对应的 patch 文件（工具拦截等） + +**代码位置**: +```typescript +// L1429: const q = query(queryArgs as any) +// 替换为: +// const q = await newAgentSdk.query(queryArgs) +// 然后在消息循环中统一转换 +``` + +### 6.2 避免的陷阱 + +1. **会话 resume 数据格式**: SDK 期望特定的 JSONL 结构，replace 必须保持兼容 +2. **工具权限拦截**: `canUseTool` 返回值格式由 SDK 定义，需精确适配 +3. **Patch 加载顺序**: 工具/会话/技能拦截需要在 CLI 初始化**前**完成 +4. **MCP 服务生命周期**: `sdkServer` 需要与 query 迭代器同步释放 + +--- + +## 总结 + +| 维度 | 现状 | +|-----|-----| +| **SDK 使用深度** | 深度集成（消息循环、权限系统、工具拦截） | +| **抽象程度** | 低（SDK 紧密耦合，难以热替换） | +| **Patch 复杂度** | 中等（3 个拦截点，针对特定 SDK 版本） | +| **可替换性** | 中等（可通过适配层替换，但需改造权限、消息循环、沙箱工具层） | +| **推荐替换方案** | 保持 SDK，通过 adapter 模式支持多个后端 | + diff --git a/CHANGELOG.md b/CHANGELOG.md index 7a99163..fb6138a 100644 --- a/CHANGELOG.md +++ b/CHANGELOG.md @@ -1,171 +1,36 @@ # Changelog -本文件记录 `coding-agent-template` 面向用户/开发者的显著变更。格式参考 [Keep a Changelog](https://keepachangelog.com/zh-CN/1.1.0/)，版本遵循 [SemVer](https://semver.org/)。 +All notable changes to this project will be documented in this file. -## [2.1.0] — 2025-05-03 +## [Unreleased] ### Added -- **沙箱创建进度可见**: Coding 任务启动时，前端状态指示器现在会细分显示沙箱各阶段进度（镜像拉取 → 容器就绪 → 工作区初始化），不再全程显示"准备中..."。（`emitPhase('preparing', 'sandbox:xxx')` → `AgentStatusIndicator` 按阶段动态出文案） - -- **Dev server 启动失败快速报错**: Coding 模式下，vite 或 npm install 失败时错误原因会立即透传给前端（`viteFailureReason`），不再等待 120s 超时才报错。预览 URL 也改为等待 `viteReady === true` 再返回，避免拿到 URL 后立即 502。 - -- **Default 模式任务分类**: Default Agent 现在会先判断任务类型再行动——对话/创作类需求直接输出文本，编程/工程类才调用工具。（`buildAppendPrompt` 为 default 模式注入 `task-classification` guideline，coding 模式不受影响） - -- **子工作区隔离 (Scope API)**: 同一 session 内支持多个相互隔离的子工作区，通过 `X-Scope-Id` / `X-Scope-Template` 头控制；每个 scope 独立运行 vite dev server（端口 5173-5199 动态分配）；`GET /api/scope/info` 返回工作区路径和 vite 状态。 - -- **小程序部署进度轮询**: 小程序部署超过 60s 时接口异步返回 `{ async: true, jobId }`，客户端轮询 `GET /api/miniprogram/deploy/:jobId` 获取实时构建日志，不再因超时直接报错。 - -- **凭证安全加固**: - - session 云凭证（SecretId/SecretKey/SessionToken）从明文 `.session-env.json` 改为 AES-256-GCM 加密存储（`src/session-env.ts`） - - Git remote URL 不再嵌入 token，改用内存 credential helper 在 push/fetch 时动态注入，`git remote -v` 不再泄露凭证 - -- **ImageGen 图片生成**（Default 模式可用）: 生成的图片自动上传到 CloudBase 静态托管并返回 CDN 公开链接，Agent 在聊天中直接展示图片。前端 `ImageGen` / `ImageEdit` 工具卡片支持 Markdown 渲染，CDN 图片内联显示。（`GET /api/storage/presign?bucketType=static&key=xxx` 生成 COS 预签名 PUT URL，tool-override 直接 PUT 到 COS，不经过 server） - -- **文件浏览器下载**: 右键菜单新增文件下载（直接流式返回）和文件夹下载（沙箱内 `zip -r` 打包后流式返回）。临时 zip 存放在 `.tmp/`（已 gitignore），传输完成后删除。 - -- **管理员用户管理 — API Key 列**: 用户列表新增 API Key 一列，支持复制和重置；管理员可为任意用户生成新 key（`POST /api/admin/users/:id/api-key/reset`）。新注册用户自动生成 API key。 - -- **CloudBase 数据库集合权限加固**: 所有系统集合（users/tasks/keys 等）在首次访问时自动通过 `ModifySafeRule(AclTag=ADMINONLY)` 设为管理员专用，阻止前端 Web SDK 直接读写。 +- **Agent 统一选择器**：合并静态 CodeBuddy 标签和 runtime 选择器为统一 Agent `` 组件，采用静态列表（Method B）： + +- `CODING_AGENTS` 静态数组：`codebuddy`、`opencode`、`mimo`，每个带 `runtime` 字段 +- `RUNTIME_TO_AGENT` 映射：`tencent-sdk → codebuddy`，`opencode-acp → opencode` +- 多 agent 共享同一 runtime（`opencode` 和 `mimo` 都映射 `opencode-acp`） +- 后端 availability check 结果驱动 `unavailableAgents` Set，不可用时 disabled +- 每个 agent 独立模型列表，切换 agent 时自动校验 `selectedModel` 是否在新模型列表中，不存在则选第 0 个 +- `useEffect` 监听 `[selectedAgent, agentModels, selectedModel]` 防止竞态 + +**改动**：`task-form.tsx`（重构 agent/model 选择逻辑） + +--- + +### 4.2 MiMo 模型集成 + +新增 MiMo（小米）provider 到 OpenCode 配置： + +- **配置文件**：`.opencode/opencode.json`（项目级，checked in） + - Provider: `mimo`，使用 `@ai-sdk/openai-compatible` + - baseURL: `https://token-plan-sgp.xiaomimimo.com/v1` + - apiKey: `{env:MIMO_API_KEY}`（env var 替代，不硬编码） + - 默认模型：`mimo-v2.5-pro`（支持图片理解） + - TTS 模型：`mimo-v2.5-tts`、`mimo-v2.5-tts-voiceclone`、`mimo-v2.5-tts-voicedesign` +- **Logo**：`packages/web/public/logos/mimo.png` + `components/logos/mimo.tsx` + `ProviderLogos` 映射 +- **后端模型列表**：`opencode-acp-runtime.ts` 的 `getSupportedModels()` 返回 MiMo + Moonshot 模型 +- **环境变量**：`.env.example` 添加 `MIMO_API_KEY` 占位 + +**改动**：`.opencode/opencode.json`（新增）、`mimo.png`（新增）、`mimo.tsx`（新增）、`provider-logos.tsx`、`task-form.tsx`、`opencode-acp-runtime.ts`、`.env.example` + +--- + +### 4.3 配置隔离：项目级 tool override + +**问题**：opencode tool 安装在全局 `~/.config/opencode/tools/`，不同项目/用户互相干扰。 + +**方案**： + +- Tool 安装目录改为项目级 `.opencode/tools/`（`.gitignore` 排除生成物） +- 新增 `resolveProjectRoot()`：从 `__dirname` 向上查找含 `packages/server` 的目录 +- 新增 `getOpencodeConfigDir()`：返回 `OPENCODE_CONFIG_DIR ?? /.opencode` +- spawn opencode 时注入 `OPENCODE_CONFIG_DIR` 环境变量，与用户全局配置隔离 +- 支持 `OPENCODE_PROJECT_ROOT` env override（CI/部署场景） + +**改动**：`opencode-installer.ts`、`opencode-acp-runtime.ts`、`opencode-tool-templates/*.ts`、`.gitignore` + +--- + +### 4.4 修复：ACP 完成后发送按钮卡住 + +**问题**：ACP session 显示 `[DONE]` 后，对话框发送按钮一直不恢复为"发送"状态。 + +**根因**：`observeStreamWithLiveCallback` 在 SSE 流结束时未更新 `task.status`，前端 `isAgentBusy = task.status === 'processing' || task.status === 'pending'` 始终为 true。 + +**修复**：在 `[DONE]` SSE 消息之后，更新 `task.status` 为 `'done'`（或 `'error'`）： + +```typescript +const finalRun = getAgentRun(sessionId) +const finalStatus = finalRun?.status === 'error' ? 'error' : 'done' +await getDb().tasks.update(sessionId, { status: finalStatus, updatedAt: Date.now() }) +``` + +**改动**：`acp.ts` + +--- + +### 4.5 增量改动文件清单 + +| 路径 | 类型 | 说明 | +|---|---|---| +| `.opencode/opencode.json` | 新增 | MiMo provider 配置（checked in） | +| `.gitignore` | 修改 | +`.opencode/tools/` | +| `.env.example` | 修改 | +`MIMO_API_KEY` 占位 | +| `packages/web/public/logos/mimo.png` | 新增 | MiMo 品牌 PNG | +| `packages/web/src/components/logos/mimo.tsx` | 新增 | MiMo logo 组件 | +| `packages/web/src/components/logos/index.ts` | 修改 | +MiMo export | +| `packages/web/src/components/logos/provider-logos.tsx` | 修改 | +MiMoProvider | +| `packages/web/src/components/task-form.tsx` | 修改 | Agent 统一选择器 + per-agent 模型 | +| `packages/server/src/routes/acp.ts` | 修改 | task status done 修复 + runtimes 返回 models | +| `packages/server/src/agent/runtime/opencode-acp-runtime.ts` | 修改 | MiMo 模型列表 + OPENCODE_CONFIG_DIR | +| `packages/server/src/agent/runtime/opencode-installer.ts` | 修改 | 项目级安装 + resolveProjectRoot | +| `packages/server/src/agent/runtime/opencode-tool-templates/*.ts` | 修改 | 模板简化 | +| `packages/server/src/agent/cloudbase-agent.service.ts` | 修改 | 类型对齐 | diff --git a/docs/opencode-acp-integration-memo.md b/docs/opencode-acp-integration-memo.md new file mode 100644 index 0000000..8446b31 --- /dev/null +++ b/docs/opencode-acp-integration-memo.md @@ -0,0 +1,366 @@ +# OpenCode ACP Integration Memo + +> Source: `sst/opencode` @ branch `dev` (commit captured 2026-05-01). +> Inspection scope: `packages/opencode/src/acp/**`, `packages/opencode/src/cli/cmd/acp.ts`, supporting server / tool / permission modules. File and line citations below are against that branch. +> +> **TL;DR**: OpenCode's `acp` command is **not** a thin ACP agent that delegates I/O to the client. It boots the full OpenCode runtime (HTTP server + internal tool registry + filesystem + shell) inside the same process and exposes a JSON-RPC façade over stdio. Builtin tools (`read`, `write`, `edit`, `bash`, `grep`, `glob`, `webfetch`, …) execute locally against the *agent's* filesystem/shell. The ACP `connection.*` callbacks are used only for **presentation** (streaming `session/update` notifications, `session/request_permission`), and — in one narrow case — `fs/write_text_file` is called to push the post-approval edit back to the editor. `fs/read_text_file`, `terminal/*`, `fs/write_text_file` for arbitrary tool writes are **not** consumed. + +--- + +## 1. 启动与传输 + +| Item | Value | Source | +| --- | --- | --- | +| CLI entry | `opencode acp` (registered via yargs `cmd`) | `packages/opencode/src/cli/cmd/acp.ts:12-21` | +| Working directory flag | `--cwd` (defaults to `process.cwd()`) | `packages/opencode/src/cli/cmd/acp.ts:16-20` | +| Transport | NDJSON over stdio (`ndJsonStream` from `@agentclientprotocol/sdk`). **Not** LSP-style `Content-Length` framing. | `packages/opencode/src/cli/cmd/acp.ts:4, 55` | +| Stream wiring | `process.stdout` → `WritableStream`, `process.stdin` → `ReadableStream`, glued via `ndJsonStream`, then an `AgentSideConnection` is constructed | `packages/opencode/src/cli/cmd/acp.ts:32-60` | +| Lifecycle | Blocks on `process.stdin` `end`/`error`; no heartbeat/reconnect logic | `packages/opencode/src/cli/cmd/acp.ts:63-67` | +| Sidecar HTTP server | `Server.listen()` is started **inside the acp process** at `127.0.0.1:` (port 0) *before* stdio transport is wired; `createOpencodeClient` is then used by the ACP agent to talk to itself via localhost HTTP. | `packages/opencode/src/cli/cmd/acp.ts:24-30`, `packages/opencode/src/cli/network.ts:6-15, 44-62` | +| Server auth | HTTP Basic via `OPENCODE_SERVER_USERNAME` / `OPENCODE_SERVER_PASSWORD`. In ACP mode the env var isn't set so auth is effectively off (loopback only). | `packages/opencode/src/server/middleware.ts` (AuthMiddleware) | +| Env switch | `process.env.OPENCODE_CLIENT = "acp"` is set before bootstrap — gates feature flags elsewhere (e.g. `QuestionTool`, see §5.2). | `packages/opencode/src/cli/cmd/acp.ts:23` | + +**Error handling**: per-method `.catch()` logs errors via `@opencode-ai/core/util/log`; no protocol-level reconnect. `SIGTERM/SIGINT` graceful shutdown mentioned in the README (`packages/opencode/src/acp/README.md`) is **not present** in today's code (README references a `server.ts` that no longer exists — see §9). + +--- + +## 2. 依赖 SDK / 协议版本 + +| Item | Value | Source | +| --- | --- | --- | +| SDK | `@agentclientprotocol/sdk@0.16.1` | `packages/opencode/package.json` (dependencies) | +| Reported `protocolVersion` | `1` (advertised in `initialize` response) | `packages/opencode/src/acp/agent.ts:554-555` | +| OpenCode itself version | 1.14.31 (at current HEAD of `dev`) | `packages/opencode/package.json` (version) | +| ACP agent exported name | `{ name: "OpenCode", version: InstallationVersion }` | `packages/opencode/src/acp/agent.ts:573-576` | + +--- + +## 3. Agent-side 方法实现（OpenCode 作为 agent 响应） + +Implemented in `class Agent implements ACPAgent` — `packages/opencode/src/acp/agent.ts:140-1548`. + +| ACP method | Handler | File:line | Notes | +| --- | --- | --- | --- | +| `initialize` | `initialize()` | `packages/opencode/src/acp/agent.ts:534-578` | Returns `protocolVersion: 1`, advertises capabilities (below), one `authMethod` (`id: "opencode-login"`), `agentInfo: { name: "OpenCode", version }`. **Note**: `clientCapabilities` from the request is *not* stored on `this` — see §9 limitation. | +| `authenticate` | `authenticate()` | `packages/opencode/src/acp/agent.ts:580-582` | **Throws** `"Authentication not implemented"` — despite advertising `opencode-login`. See issue #24846. | +| `session/new` | `newSession()` | `packages/opencode/src/acp/agent.ts:584-617` | Calls `sdk.session.create` over the internal HTTP server; registers MCP servers; returns `sessionId`, `models`, `modes`, `configOptions`, `_meta` | +| `session/load` | `loadSession()` | `packages/opencode/src/acp/agent.ts:619-687` | Fetches stored messages and **replays full history** via `processMessage()` as `session/update` notifications; updates usage. | +| `session/list` | `listSessions()` | `packages/opencode/src/acp/agent.ts:689-732` | Cursor based (`time.updated`), page size 100. | +| `session/fork` (`unstable_forkSession`) | `unstable_forkSession()` | `packages/opencode/src/acp/agent.ts:734-797` | Forks upstream session; replays history. | +| `session/resume` (`unstable_resumeSession`) | `unstable_resumeSession()` | `packages/opencode/src/acp/agent.ts:799-828` | No replay — just re-registers session + sends usage. | +| `session/set_model` (`unstable_setSessionModel`) | `unstable_setSessionModel()` | `packages/opencode/src/acp/agent.ts:1286-1306` | Parses `provider/model[/variant]`. | +| `session/set_mode` | `setSessionMode()` | `packages/opencode/src/acp/agent.ts:1308-1315` | Backed by OpenCode "agents" (the TUI's agent *modes*, not sub-agents). | +| `session/set_config_option` | `setSessionConfigOption()` | `packages/opencode/src/acp/agent.ts:1317-1353` | Supports `configId ∈ {"model","mode"}`. | +| `session/prompt` | `prompt()` | `packages/opencode/src/acp/agent.ts:1355-1536` | Main entry point. Normalises ACP content blocks (`text`/`image`/`resource_link`/`resource`) → internal parts, intercepts slash commands (`/compact` handled natively; other `/` dispatched to `sdk.session.command`), else calls `sdk.session.prompt`. Returns `{ stopReason: "end_turn", usage, _meta }`. | +| `session/cancel` | `cancel()` | `packages/opencode/src/acp/agent.ts:1538-1547` | Calls `sdk.session.abort`. | + +### Advertised `agentCapabilities` + +```ts +{ + loadSession: true, + mcpCapabilities: { http: true, sse: true }, + promptCapabilities: { embeddedContext: true, image: true }, + sessionCapabilities: { fork: {}, list: {}, resume: {} }, +} +``` +Source: `packages/opencode/src/acp/agent.ts:556-571`. + +**Not advertised**: streaming audio, tool call authorisation (`toolCallAuth`), and the experimental per-message `configOptions` etc. Check the SDK version `0.16.1` for the authoritative Capability schema. + +--- + +## 4. Client-side 方法调用（OpenCode → client 请求）⭐ + +This is the **most important section for integration planning**. Searching `packages/opencode/src/acp/agent.ts` for every `this.connection.*` call: + +| ACP client method | How often / what triggers it | File:line | +| --- | --- | --- | +| `session/update` (notification) | High-volume stream. Used for `tool_call`, `tool_call_update`, `agent_message_chunk`, `agent_thought_chunk`, `user_message_chunk`, `plan`, `usage_update`, `available_commands_update`. Pushed from two sources: (a) real-time events from OpenCode's internal Bus (`message.part.updated`, `message.part.delta`) in `handleEvent()`; (b) replay in `processMessage()` during `session/load` / `session/fork`. | `agent.ts:117-129` (usage), `agent.ts:273-530` (live events), `agent.ts:830-1106` (replay), `agent.ts:1119-1134` (`tool_call` pending), `agent.ts:1256-1264` (commands update) | +| `session/request_permission` | When OpenCode's internal `Permission.ask()` is triggered by a tool (see §6) the bus fires `permission.asked`; the ACP handler forwards it. | `agent.ts:192-270` (especially `agent.ts:202-213`) | +| `fs/write_text_file` | **Only one call site.** After the user approves an `edit` permission, OpenCode applies the diff itself and pushes the resulting content to the client (so the editor can refresh open buffers). This is a cosmetic re-sync, **not the actual file write** — the file is already written via Node `fs` by the time this fires. | `agent.ts:239-253` | +| `fs/read_text_file` | **Not called anywhere.** `ReadTool` reads through `AppFileSystem.Service` → Node streams (`createReadStream`). Confirmed by reading `packages/opencode/src/tool/read.ts`. | — (absent) | +| `terminal/create`, `terminal/output`, `terminal/wait_for_exit`, `terminal/kill`, `terminal/release` | **Not called anywhere.** `BashTool` spawns a local child process via Effect's `ChildProcess.make` (shell, stdin ignored, stdout/stderr captured as streams). No PTY, no ACP terminal capability consumed. | — (absent; `packages/opencode/src/tool/bash.ts`) | + +> **Key implication for integrators**: If your goal is to let the ACP client enforce filesystem boundaries (the stated motivation for ACP's `fs/*` and `terminal/*` methods — "Client runs tools, agent only decides"), **OpenCode does not do that**. A sandbox around OpenCode must be imposed externally (container, worktree confinement at the filesystem layer, `--cwd`). + +Grep confirmation (from a local clone of the file): + +``` +$ grep -nE "connection\.(readTextFile|writeTextFile|createTerminal|terminal|requestPermission)" agent.ts +247: void this.connection.writeTextFile({ +``` + +(No hits for terminal or readTextFile.) + +--- + +## 5. 工具执行路径（内置工具 → ACP 回调 真实映射）⭐ + +### 5.1 How a tool call flows in ACP mode + +``` +ACP client ──(session/prompt)──► Agent.prompt() + │ + ▼ + sdk.session.prompt(...) [HTTP → loopback] + │ + ▼ + OpenCode server → internal session loop + │ + ▼ + Tool executed via ToolRegistry (read / write / bash / …) + │ (uses Node fs, child_process, ripgrep, …) + ▼ + Bus events: message.part.updated / delta / permission.asked + │ + ▼ + Agent.handleEvent() subscribes via sdk.global.event (SSE stream) + │ + ▼ + connection.sessionUpdate(...) / connection.requestPermission(...) + │ + ▼ + ACP client +``` + +Key source references: +- Event pump: `packages/opencode/src/acp/agent.ts:164-188` (`runEventSubscription()` calling `sdk.global.event({ signal })`). +- Session.prompt: `packages/opencode/src/acp/agent.ts:1471-1482`. +- Tool registry wiring: `packages/opencode/src/tool/registry.ts:98-200` (all builtins are instantiated and executed in-process). +- `ReadTool` uses `AppFileSystem.Service` + `createReadStream` locally — `packages/opencode/src/tool/read.ts` (confirmed: *no* ACP callback). +- `WriteTool` uses `fs.writeWithDirs` locally — `packages/opencode/src/tool/write.ts` (confirmed). +- `BashTool` uses `effect/unstable/process/ChildProcess.make` — `packages/opencode/src/tool/bash.ts` (confirmed: local `ChildProcess`, no PTY, no ACP terminal). + +### 5.2 Tool registry details + +All built-in tools are always enabled (modulo agent-mode filtering) — `packages/opencode/src/tool/registry.ts:184-200`: + +``` +invalid, bash, read, glob, grep, edit, write, task, fetch (webfetch), +todo, search (websearch), skill, patch (apply_patch), question, lsp, plan +``` + +**QuestionTool opt-in for ACP**: gated by +```ts +const questionEnabled = ["app","cli","desktop"].includes(Flag.OPENCODE_CLIENT) || Flag.OPENCODE_ENABLE_QUESTION_TOOL +``` +Source: `packages/opencode/src/tool/registry.ts:181-182`. Because `acp.ts` sets `OPENCODE_CLIENT=acp`, the tool is **disabled by default**. Set `OPENCODE_ENABLE_QUESTION_TOOL=1` to enable (confirmed by `packages/opencode/src/acp/README.md`). + +### 5.3 ACP-facing tool representation + +Tool calls are **reported** to the client via `session/update` events with `sessionUpdate: "tool_call" | "tool_call_update"`. Tool output → `ToolCallContent` blocks (`type: "content"` with text, `type: "diff"` for edits). Mapping from internal tool name → ACP `ToolKind`: + +| OpenCode tool | ACP kind | Location hint (`locations[]`) | +| --- | --- | --- | +| `bash` | `execute` | `[]` | +| `webfetch` | `fetch` | n/a | +| `edit`, `patch`, `write` | `edit` | `filePath` | +| `grep`, `glob`, `context7_*` | `search` | `path` | +| `read` | `read` | `filePath` | +| default | `other` | `[]` | + +Source: `packages/opencode/src/acp/agent.ts:1550-1592`. + +Special: `todowrite` tool output is additionally decoded and pushed as an ACP `plan` update — `packages/opencode/src/acp/agent.ts:375-400, 904-929`. + +--- + +## 6. 权限模型 + +### Event plumbing + +OpenCode has an internal `Permission` service (`packages/opencode/src/permission/index.ts`) that publishes two events on the in-process `Bus`: +- `permission.asked` — sent when a tool's `ctx.ask(...)` call cannot be resolved by the ruleset (no `allow` rule, no prior `always` approval). +- `permission.replied` — sent when `reply()` is called (including cascading `reject`/`always` replies within the same session). + +The ACP event subscription handles `permission.asked` at `agent.ts:190-270`: +1. Serialises per-session via `this.permissionQueues` (a `Map`) so users aren't prompted for two things at once. +2. Calls `this.connection.requestPermission({ sessionId, toolCall: { toolCallId, title: permission.permission, rawInput: permission.metadata, kind, locations }, options: this.permissionOptions })`. +3. Translates the outcome back to OpenCode's `sdk.permission.reply` (`"once" | "always" | "reject"`). + +### Which tools request permission + +Inside tool implementations, each call site calls `ctx.ask(...)` with a permission name. From reading tool files and `permission/index.ts`: + +- `edit`, `write`, `apply_patch` → permission name **`edit`** (grouped by `EDIT_TOOLS = ["edit","write","apply_patch"]` in permission/index). +- `bash` → permission name **`bash`** (request triggered from `tool/bash.ts`). +- `webfetch` → permission name **`webfetch`**. +- Other tools (`read`, `grep`, `glob`, `lsp`, `todo`, `task`, `plan`, `skill`, `question`, `websearch`) do **not** request permission in current code. +- MCP tools: permission name equals the tool id (generic fallback in `Permission.disabled()`). + +### Permission options advertised + +```ts +[ + { optionId: "once", kind: "allow_once", name: "Allow once" }, + { optionId: "always", kind: "allow_always", name: "Always allow" }, + { optionId: "reject", kind: "reject_once", name: "Reject" }, +] +``` +Source: `packages/opencode/src/acp/agent.ts:150-154`. + +### Configurable? + +Yes — OpenCode's own `opencode.json` / config supports a `permission` ruleset (`Schema.Array(Rule)` in `permission/index.ts`) that evaluates `{ permission, pattern, action: "allow"|"deny"|"ask" }` against the tool call, **before** the ACP round-trip. If a pattern `allow`s, the client is never asked. If it `deny`s, the tool fails with `DeniedError`. See `permission/evaluate.ts` and `permission/arity.ts` (not read in full, but referenced from `index.ts`). + +### Post-approval side effect (important) + +After the user approves an `edit`, the agent re-reads the original file, applies the stored unified diff via `diff.applyPatch`, and pushes the result to the client via `connection.writeTextFile`. Source: `packages/opencode/src/acp/agent.ts:239-253`. **If the client supports `fs/write_text_file` this shows up as a duplicate write**; the real write will also happen inside `WriteTool`/`EditTool` through `AppFileSystem.Service`. + +--- + +## 7. Session 管理 + +| Topic | Answer | +| --- | --- | +| ACP session registry | In-memory `Map` in `ACPSessionManager` (`packages/opencode/src/acp/session.ts:8-14`). One instance per `Agent`. | +| Backing store | `sdk.session.create` / `sdk.session.get` over the internal HTTP server (`packages/opencode/src/acp/session.ts:20-75`). The *actual* session persistence is OpenCode's own DB (SQLite / JSONL depending on build) — ACP just keeps a shallow in-mem map for CWD / MCP / model / variant / mode. | +| Multi-session per process | Yes — no `1:1` constraint. The ACP `Agent` instance holds all sessions. Event pump is a single loop shared by all sessions; events are dispatched by `part.sessionID`. | +| `session/load` | **Implemented** (`agent.ts:619-687`) — re-creates ACP state, replays the full message history as `session/update` notifications. README claims this is "basic support" / "doesn't restore actual conversation history", but the code does replay. | +| `session/list` | Implemented with cursor (`agent.ts:689-732`). | +| `session/fork` | Implemented as `unstable_forkSession` (`agent.ts:734-797`). Creates a divergent copy and replays history. | +| `session/resume` | Implemented as `unstable_resumeSession` (`agent.ts:799-828`). No replay. | +| `session/cancel` | Implemented (`agent.ts:1538-1547`) → `sdk.session.abort`. | +| Concurrent prompts in one session | `cancel` + permission queueing are the only concurrency controls; there's nothing preventing overlapping `prompt()` calls hitting `sdk.session.prompt` — OpenCode's server presumably serialises internally (not verified here). | + +--- + +## 8. 配置 / 认证 + +### Config resolution + +ACP mode **does** read OpenCode's configuration. `bootstrap(process.cwd(), ...)` in `acp.ts` initialises the full app runtime, which loads `opencode.json` / `.opencode/` config via `Config.Service`. Then `sdk.config.get({ directory })` is used at the per-request level so `--cwd` (or per-session `cwd`) picks up project-local config (`agent.ts:1601-1611`). + +### Default model selection + +`defaultModel()` at `packages/opencode/src/acp/agent.ts:1594-1654`: +1. If `ACPConfig.defaultModel` is set, use it. (It's never set — `ACP.init({ sdk })` at `acp.ts:56` passes no default.) +2. Read `config.model` from the resolved config. +3. Else enumerate `providers`, prefer `opencode` provider's `big-pickle`, else sort all models via `Provider.sort` and pick the first. +4. Fallback: `{ providerID: "opencode", modelID: "big-pickle" }`. + +### Dynamic model / variant / mode switching + +- Models: `session/set_model` (`setSessionModel`) — `agent.ts:1286-1306`. Accepts `"provider/model"` or `"provider/model/variant"`. +- Modes (OpenCode "agents"): `session/set_mode` — `agent.ts:1308-1315`. Validates against `AgentModule`'s list of non-hidden, non-subagent agents. +- `session/set_config_option` accepts `{ configId: "model" | "mode", value }` — `agent.ts:1317-1353`. +- Per-prompt `model` is **not** accepted as an ACP parameter; callers must call `session/set_model` before `session/prompt`. But `prompt()` does fall back to the session's current model (`agent.ts:1360-1364`). + +### Authentication + +- `initialize()` advertises one auth method `{ id: "opencode-login", ... }`, optionally with a `terminal-auth` `_meta` so clients can offer a CLI-launch button (`agent.ts:537-552`). +- `authenticate()` **throws `"Authentication not implemented"`** (`agent.ts:580-582`). This means ACP clients must either: + - Rely on pre-existing OpenCode auth (user already ran `opencode auth login` locally so credentials exist under `~/.config/opencode`), OR + - Ship API keys via env (`ANTHROPIC_API_KEY` etc.) at spawn time. +- Per-session `LoadAPIKeyError` is caught and converted to `RequestError.authRequired()` in `newSession`/`loadSession`/`forkSession`/`resumeSession` (`agent.ts:608-616`, `:678-686`, `:788-796`, `:819-827`). +- `OPENCODE_API_KEY` is **not referenced in the ACP code path** — it's an OpenCode Zen / "opencode" provider key, consumed by `Provider` modules. Standard AI-SDK env vars (`ANTHROPIC_API_KEY`, `OPENAI_API_KEY`, …) work as usual because tools instantiate the AI SDK providers in-process. + +### HTTP server auth (for the sidecar) + +`OPENCODE_SERVER_PASSWORD` / `OPENCODE_SERVER_USERNAME` via Basic Auth. Unset by default → loopback only. See `packages/opencode/src/server/middleware.ts`. + +--- + +## 9. 限制与已知问题 + +### From the in-repo README (`packages/opencode/src/acp/README.md`) + +> The README is **stale**. It references `client.ts` and `server.ts`, which don't exist in the current `src/acp/` directory (only `agent.ts`, `session.ts`, `types.ts`, `README.md`). Treat the README as aspirational; trust `agent.ts` as ground truth. + +Items the README lists as "Not Yet Implemented": +- Streaming responses → **Now implemented** (`message.part.delta` → `agent_message_chunk` / `agent_thought_chunk`). +- Tool call reporting → **Now implemented** (see §5.3). +- Session modes → **Now implemented** (`setSessionMode`). +- Terminal support → **Still not plumbed to ACP**; bash runs locally. +- Session persistence via `session/load` → **Implemented**, but tied to OpenCode's own storage. + +### From GitHub issues / PRs (as of 2026-05-01, ranked by recency) + +| # | Type | State | Summary | +| --- | --- | --- | --- | +| #24846 | Issue | open | `session/new` reported as "Method not found", `authenticate` returns "not implemented". Breaks Claudian (Obsidian) integration. The "not found" claim doesn't match current `dev` code — could be a release-lag issue. | +| #24815 / #24816 | Issue+PR | open | ACP `image` content with `https://` URIs silently dropped in `prompt()` around `agent.ts:1394` (only `http:` / `data:` handled). | +| #25127 / #25128 | Issue+PR | open | `tool_call_update` doesn't include image attachments. | +| #22674 | PR | open (older: #22606/#22609/#22290 closed) | Feature: **store `clientCapabilities` on initialize** and emit `fs/write_text_file` when a file is edited. Mostly what the current code already does for the edit-permission flow, but generalised. Indicates current code does *not* check `clientCapabilities.fs?.writeTextFile` before calling `connection.writeTextFile`. | +| #24008 | PR | open | ACP command argument parsing loses newlines. | +| #24340 | PR | closed | Variant config option exposure. | +| #23138 | PR | closed | Usage aggregation via SQL instead of message-list walk. Relevant if you expect `usage_update` events to be cheap. | +| #22192 / #22468 | PR | closed/merged | Duplicate user messages during ACP prompts — fixed. | +| #23948 | PR | open | Prefer semantic ACP tool title/input before completion. | +| #23294 | PR | closed | Structured output format via `_meta`. | + +Other observations: +- **No heartbeat / keepalive** — the ACP connection lives as long as stdin does. +- **Event subscription is per-Agent, not per-session**. If it crashes, all sessions lose updates; the while-loop auto-reconnects (`agent.ts:173-188`) unless aborted. +- **`_meta` protocol extension**: OpenCode embeds a namespace `_meta: { opencode: { modelId, variant, availableVariants } }` in responses — clients not understanding the namespace can ignore it (`agent.ts:1760-1772`). +- **Slash commands intercepted in `prompt()`**: any user message starting with `/` is parsed and routed either to `sdk.session.command` or (for `compact`) `sdk.session.summarize`. Be aware this subverts normal prompting (`agent.ts:1443-1528`). + +### Things I couldn't verify from source alone + +- Whether the `@agentclientprotocol/sdk@0.16.1` SDK implements any client→agent streaming backpressure. Not relevant for implementing a client, but matters for throughput tuning. +- Exact behaviour when multiple parallel `session/prompt` calls target the same `sessionId`. No explicit guard in ACP code; would have to read `packages/opencode/src/session/session.ts`. +- Whether `session/cancel` is idempotent across repeated calls (not verified). + +--- + +## 10. 集成建议（给想写 ACP client 的人） + +1. **Transport**: Speak NDJSON, not LSP-style. Line-delimited JSON frames. `stdin` writes → agent, `stdout` reads ← agent. Everything you emit must be `\n`-terminated single-line JSON. +2. **Capability negotiation**: Advertise `fs.readTextFile: false, fs.writeTextFile: true` (OpenCode only ever *writes* to you, for the post-approval edit refresh). You do **not** need terminal capabilities — OpenCode will never call them. Advertising them is harmless. +3. **Do not assume the client owns the filesystem**. OpenCode will mutate files under `--cwd` on its own. If you need sandboxing, do it at spawn time (container, chroot, dedicated worktree). `--cwd` is the only knob you control. +4. **Auth**: Don't rely on `authenticate`. Two workable paths: + - Spawn `opencode auth login` yourself (the `terminal-auth` `_meta` capability on `authMethods` is designed for this). + - Provide provider API keys via env (`ANTHROPIC_API_KEY`, `OPENAI_API_KEY`, …) or via a pre-populated config file. +5. **Model selection**: Call `session/set_model` after `session/new` if you want a specific model; don't put it in `session/prompt` (not a protocol field, and ignored by OpenCode). `variant` rides on the `modelId` as a third path segment (`provider/model/variant`). +6. **Session routing**: Single `opencode acp` process handles multiple sessions concurrently. Reuse the process; spin a new one only if you need a different auth/env surface. +7. **Streaming**: Subscribe to `session/update` for: + - `agent_message_chunk`, `agent_thought_chunk` — text stream + - `tool_call` + `tool_call_update` — tool timeline (rich enough to render: inputs, outputs, `content`/`diff` blocks, `rawInput`/`rawOutput`) + - `plan` — todowrite plans + - `usage_update` — token/cost meter + - `available_commands_update` — slash command palette (arrives shortly after `session/new`, via `setTimeout(0)` at `agent.ts:1256-1264`) + - `user_message_chunk` (replay only — live user parts are skipped at `agent.ts:459-464`) +8. **Permission UX**: Treat `session/request_permission` as user-facing and blocking. OpenCode serialises per-session, so one prompt at a time, but per-process you can get concurrent prompts across sessions. +9. **Image support**: Base64 data URLs and `http://` URIs work today; `https://` does **not** (issue #24815 open). Safest: pre-fetch and embed as `data:`. +10. **Slash commands**: If you implement your own `/foo` UI, remember OpenCode also interprets leading `/` in the text. Either strip the `/` before sending, or lean on OpenCode's command registry (`sdk.command.list` via `available_commands_update`). +11. **Error semantics**: Model/auth failures surface as JSON-RPC `RequestError.authRequired()`. Fatal tool errors arrive as `tool_call_update` with `status: "failed"` — they are *not* JSON-RPC errors and the `prompt()` call will still resolve with `stopReason: "end_turn"`. +12. **`OPENCODE_ENABLE_QUESTION_TOOL=1`**: Set this *only* if your client can respond to `QuestionTool` prompts (which currently also route through `permission.asked` / `session/request_permission` — verify in `packages/opencode/src/tool/question.ts` before shipping). + +--- + +## 11. 源码文件引用（汇总） + +- CLI entry: `packages/opencode/src/cli/cmd/acp.ts:12-70` +- Network defaults (sidecar HTTP): `packages/opencode/src/cli/network.ts:6-15, 44-62` +- Main ACP agent: `packages/opencode/src/acp/agent.ts:132-1548` +- Agent `initialize`: `packages/opencode/src/acp/agent.ts:534-578` +- Agent capabilities advertised: `packages/opencode/src/acp/agent.ts:556-571` +- Agent `authenticate` (not implemented): `packages/opencode/src/acp/agent.ts:580-582` +- Agent `newSession`: `packages/opencode/src/acp/agent.ts:584-617` +- Agent `loadSession` (with replay): `packages/opencode/src/acp/agent.ts:619-687` +- Agent `prompt` (command intercept + sdk.session.prompt): `packages/opencode/src/acp/agent.ts:1355-1536` +- Agent `cancel`: `packages/opencode/src/acp/agent.ts:1538-1547` +- Event subscription (bus → session/update): `packages/opencode/src/acp/agent.ts:164-188, 190-532` +- Permission handling (bus → request_permission → reply): `packages/opencode/src/acp/agent.ts:192-270` +- Post-approval `connection.writeTextFile` call (the ONLY fs callback): `packages/opencode/src/acp/agent.ts:239-253` +- Tool→ACP kind mapping: `packages/opencode/src/acp/agent.ts:1550-1592` +- Default model selection: `packages/opencode/src/acp/agent.ts:1594-1654` +- Session manager: `packages/opencode/src/acp/session.ts:1-115` +- ACP types: `packages/opencode/src/acp/types.ts:1-24` +- Stale internal README: `packages/opencode/src/acp/README.md` +- Tool registry (proves tools are local): `packages/opencode/src/tool/registry.ts:1-200` +- Local-fs read path: `packages/opencode/src/tool/read.ts` +- Local-fs write path: `packages/opencode/src/tool/write.ts` +- Local-process shell path: `packages/opencode/src/tool/bash.ts` +- Permission service (bus, rules, reply): `packages/opencode/src/permission/index.ts` +- HTTP auth middleware (Basic): `packages/opencode/src/server/middleware.ts` +- SDK version & deps: `packages/opencode/package.json` + +--- + +## Bottom-line recommendation + +If the value proposition you need is **"the client owns the filesystem and terminal; OpenCode only decides what to do"**, OpenCode ACP is **not** a good fit today. It is an ACP *presentation* layer — streaming, permission UX, and session metadata are protocol-grade, but the actual I/O happens inside the OpenCode process against the host it's running on. + +If instead your multi-agent backend can give OpenCode a pre-prepared worktree (container, chroot, or just an isolated directory) and you only need ACP for UX/streaming/permissioning, the integration is straightforward: one long-lived `opencode acp` child per workspace (or per user), pre-seeded auth, and wire `session/update` into your existing UI. Expect to carry workarounds for #24815 (https images), #25127 (tool image attachments), and possibly #24008 (newline parsing) until those PRs land. diff --git a/packages/server/package.json b/packages/server/package.json index b2493d5..05e7c06 100644 --- a/packages/server/package.json +++ b/packages/server/package.json @@ -11,9 +11,13 @@ "scripts": { "dev": "tsup src/sandbox/tool-override.ts --format cjs --outDir dist/sandbox --no-splitting --silent && tsup src/util/skill-loader-override.ts --format cjs --outDir dist/util --no-splitting --silent && DOTENVX_PATH=.env tsx watch --env-file=.env src/index.ts", "build": "tsup src/sandbox/tool-override.ts --format cjs --outDir dist/sandbox --no-splitting && tsup src/util/skill-loader-override.ts --format cjs --outDir dist/util --no-splitting && tsup src/index.ts --format esm --target node22", - "start": "node dist/index.js" + "start": "node dist/index.js", + "test": "vitest run", + "test:watch": "vitest", + "check:tool-schemas": "tsx scripts/check-tool-schemas.mts" }, "dependencies": { + "@agentclientprotocol/sdk": "^0.21.0", "@anthropic-ai/claude-agent-sdk": "^0.1.55", "@cloudbase/manager-node": "^4.10.6", "@cloudbase/node-sdk": "^3.18.1", @@ -46,6 +50,7 @@ "@types/uuid": "^11.0.0", "tsup": "^8.0.0", "tsx": "^4.21.0", - "typescript": "~5.7.0" + "typescript": "~5.7.0", + "vitest": "^3.2.0" } } \ No newline at end of file diff --git a/packages/server/scripts/check-tool-schemas.mts b/packages/server/scripts/check-tool-schemas.mts new file mode 100644 index 0000000..471e1f2 --- /dev/null +++ b/packages/server/scripts/check-tool-schemas.mts @@ -0,0 +1,79 @@ +#!/usr/bin/env tsx +/** + * 检查 opencode CLI 版本是否与 tool override 模板的同步版本一致。 + * + * tool override 模板（opencode-tool-templates/*.ts）是从 opencode 源码 + * 手动同步过来的。如果 opencode CLI 升级了，需要重新对比 builtin tool + * 的 schema / description 并更新模板。 + * + * 用法： + * npx tsx scripts/check-tool-schemas.mts + * 或在 CI 里定期跑，确保模板不过期。 + */ + +import { execSync } from 'node:child_process' +import path from 'node:path' +import fs from 'node:fs' +import { fileURLToPath } from 'node:url' + +const __dirname = path.dirname(fileURLToPath(import.meta.url)) +const TEMPLATE_DIR = path.resolve(__dirname, '../src/agent/runtime/opencode-tool-templates') +const SYNCED_VERSION = '1.14.31' + +// 从模板文件顶部注释提取已声明的同步版本 +function extractSyncedVersion(file: string): string | null { + const content = fs.readFileSync(file, 'utf8') + const m = content.match(/v([\d.]+)\s+src\/tool\//) + return m ? m[1] : null +} + +// 获取本地安装的 opencode 版本 +function getInstalledVersion(): string | null { + try { + const out = execSync('opencode --version', { encoding: 'utf8', timeout: 5000 }) + const m = out.trim().match(/([\d]+\.[\d]+\.[\d]+)/) + return m ? m[1] : out.trim().split('\n')[0] + } catch { + return null + } +} + +const installedVersion = getInstalledVersion() + +if (!installedVersion) { + console.log('[check-tool-schemas] opencode not installed, skipping version check.') + process.exit(0) +} + +console.log(`[check-tool-schemas] opencode installed: v${installedVersion}`) +console.log(`[check-tool-schemas] templates synced from: v${SYNCED_VERSION}`) + +const templates = fs.readdirSync(TEMPLATE_DIR).filter((f) => f.endsWith('.ts')) +let allMatch = true + +for (const f of templates) { + const filePath = path.join(TEMPLATE_DIR, f) + const ver = extractSyncedVersion(filePath) + if (!ver) { + console.warn(` ⚠ ${f}: no synced version comment found`) + allMatch = false + } else if (ver !== installedVersion) { + console.warn(` ⚠ ${f}: synced from v${ver}, installed v${installedVersion} — may need update`) + allMatch = false + } else { + console.log(` ✓ ${f}: v${ver}`) + } +} + +if (!allMatch) { + console.warn( + '\n[check-tool-schemas] Some templates may be out of sync with the installed opencode version.\n' + + 'Please compare the schemas in:\n' + + ' https://github.com/sst/opencode/tree/dev/packages/opencode/src/tool/\n' + + 'and update packages/server/src/agent/runtime/opencode-tool-templates/ if needed.\n', + ) + process.exit(1) +} + +console.log('\n[check-tool-schemas] All templates in sync with installed opencode version.') +process.exit(0) diff --git a/packages/server/scripts/test-acp-chat-http.mts b/packages/server/scripts/test-acp-chat-http.mts new file mode 100644 index 0000000..182753a --- /dev/null +++ b/packages/server/scripts/test-acp-chat-http.mts @@ -0,0 +1,188 @@ +#!/usr/bin/env tsx +/** + * HTTP 完整 chat e2e 测试： + * + * 跑一个迷你 Hono app，装上 /api/agent/runtimes 路由（从真实 routes/acp.ts） + * 与一个 /chat-test 路由（复制 routes/acp.ts 的 /chat 逻辑但 bypass auth）。 + * + * 走完整 SSE 流，验证 runtime=opencode-acp 时整条链路的 HTTP 行为。 + * + * 用法（packages/server 目录）： + * npx tsx --env-file=.env scripts/test-acp-chat-http.mts + */ + +import 'dotenv/config' +import { Hono } from 'hono' +import { serve } from '@hono/node-server' +import { streamSSE } from 'hono/streaming' +import fs from 'node:fs' +import { v4 as uuidv4 } from 'uuid' +import type { AgentCallback, AgentCallbackMessage } from '@coder/shared' +import { agentRuntimeRegistry } from '../src/agent/runtime/index.js' +import { CloudbaseAgentService } from '../src/agent/cloudbase-agent.service.js' + +const PORT = 38766 + +const app = new Hono() + +// --- /runtimes（公开） --- +app.get('/api/agent/runtimes', async (c) => { + const runtimes = agentRuntimeRegistry.list() + const def = agentRuntimeRegistry.resolve() + const items = await Promise.all( + runtimes.map(async (r) => ({ name: r.name, available: await r.isAvailable().catch(() => false) })), + ) + return c.json({ default: def.name, runtimes: items }) +}) + +// --- /chat-test（bypass auth，复刻 /chat 核心逻辑） --- +app.post('/api/agent/chat-test', async (c) => { + const body = await c.req.json<{ prompt: string; conversationId?: string; runtime?: string; model?: string }>() + const { prompt, conversationId, runtime: runtimeName, model } = body + + const actualConversationId = conversationId || uuidv4() + const runtime = agentRuntimeRegistry.resolve({ explicitRuntime: runtimeName, conversationId: actualConversationId }) + + return streamSSE(c, async (stream) => { + const { turnId } = await runtime.chatStream( + prompt, + async (msg: AgentCallbackMessage, seq?: number) => { + const acpEvent = CloudbaseAgentService.convertToSessionUpdate(msg, actualConversationId) + if (!acpEvent) return + await stream.writeSSE({ + data: JSON.stringify({ + jsonrpc: '2.0', + method: 'session/update', + params: { sessionId: actualConversationId, update: acpEvent }, + }), + }) + }, + { + conversationId: actualConversationId, + envId: '', + userId: 'test-user', + cwd: WORKDIR, + model, + } as never, + ) + + // 等 result / error + let waited = 0 + while (waited < 90000) { + await new Promise((r) => setTimeout(r, 500)) + waited += 500 + // 查 registry 状态 + const mod = await import('../src/agent/agent-registry.js') + const run = mod.getAgentRun(actualConversationId) + if (!run || run.status !== 'running') break + } + + await stream.writeSSE({ data: '[DONE]' }) + console.log(`[chat-test handler] turnId=${turnId} finished`) + }) +}) + +const WORKDIR = '/tmp/opencode-chat-http-e2e' +fs.rmSync(WORKDIR, { recursive: true, force: true }) +fs.mkdirSync(WORKDIR, { recursive: true }) + +const serverHandle = serve({ fetch: app.fetch, port: PORT }, () => { + console.log(`[chat-e2e] test server on :${PORT}`) +}) + +await new Promise((r) => setTimeout(r, 500)) + +// 1. GET /runtimes +const runtimes = await fetch(`http://127.0.0.1:${PORT}/api/agent/runtimes`).then((r) => r.json()) +console.log('[chat-e2e] /runtimes:', JSON.stringify(runtimes)) + +// 2. POST /chat-test with runtime=opencode-acp +console.log('[chat-e2e] calling /chat-test with runtime=opencode-acp ...') +const res = await fetch(`http://127.0.0.1:${PORT}/api/agent/chat-test`, { + method: 'POST', + headers: { 'Content-Type': 'application/json' }, + body: JSON.stringify({ + prompt: '请用一句话说明你是谁，不需要调任何工具', + conversationId: 'chat-e2e-' + Date.now(), + runtime: 'opencode-acp', + model: 'moonshot/kimi-k2-0905-preview', + }), +}) +console.log(`[chat-e2e] status=${res.status} content-type=${res.headers.get('content-type')}`) + +if (!res.ok || !res.body) { + console.error('[chat-e2e] FAIL: non-stream response') + process.exit(1) +} + +const events: Array<{ type: string; payload: unknown }> = [] +const decoder = new TextDecoder() +let buffer = '' +const reader = res.body.getReader() +const startTime = Date.now() + +while (true) { + const { done, value } = await reader.read() + if (done) break + buffer += decoder.decode(value, { stream: true }) + const lines = buffer.split('\n') + buffer = lines.pop() ?? '' + for (const line of lines) { + if (!line.startsWith('data:')) continue + const data = line.slice(5).trim() + if (data === '[DONE]') { + events.push({ type: 'DONE', payload: null }) + } else { + try { + events.push({ type: 'session/update', payload: JSON.parse(data) }) + } catch { + /* ignore */ + } + } + } + if (Date.now() - startTime > 120000) break +} + +console.log(`\n[chat-e2e] received ${events.length} SSE events`) + +const byTag: Record = {} +for (const e of events) { + if (e.type === 'session/update') { + const tag = (e.payload as { params?: { update?: { sessionUpdate?: string } } })?.params?.update?.sessionUpdate || '?' + const key = `update:${tag}` + byTag[key] = (byTag[key] ?? 0) + 1 + } else { + byTag[e.type] = (byTag[e.type] ?? 0) + 1 + } +} +console.log('[chat-e2e] event type distribution:', JSON.stringify(byTag, null, 2)) + +const textChunks = events + .filter((e) => e.type === 'session/update') + .map((e) => (e.payload as { params?: { update?: { sessionUpdate?: string; content?: { text?: string } } } }).params?.update) + .filter( + (u): u is { sessionUpdate: string; content: { text: string } } => + u?.sessionUpdate === 'agent_message_chunk' && !!u?.content?.text, + ) + .map((u) => u.content.text) + .join('') + +console.log('\n[chat-e2e] agent text:', textChunks || '(empty)') + +const hasDone = events.some((e) => e.type === 'DONE') +const hasText = textChunks.length > 0 + +console.log('\n[chat-e2e] assertions:') +console.log(` stream completed with [DONE]: ${hasDone ? 'PASS' : 'FAIL'}`) +console.log(` received agent text: ${hasText ? 'PASS' : 'FAIL'}`) + +const passed = hasDone && hasText +console.log(`\n[chat-e2e] OVERALL: ${passed ? 'PASS' : 'FAIL'}`) + +fs.writeFileSync( + '/tmp/acp-chat-http-e2e-report.json', + JSON.stringify({ timestamp: new Date().toISOString(), eventCounts: byTag, agentText: textChunks, passed }, null, 2), +) + +await serverHandle.close() +process.exit(passed ? 0 : 1) diff --git a/packages/server/scripts/test-acp-http-e2e.mts b/packages/server/scripts/test-acp-http-e2e.mts new file mode 100644 index 0000000..05c5850 --- /dev/null +++ b/packages/server/scripts/test-acp-http-e2e.mts @@ -0,0 +1,82 @@ +#!/usr/bin/env tsx +/** + * 完整 HTTP 端到端测试： + * 1. 启动 server（in-process Hono app，绑端口） + * 2. 用 ACP API key 走 /api/agent/runtimes 列出 runtime + * 3. 用 ACP API key 走 /api/agent/chat 发 prompt（runtime=opencode-acp） + * 4. 解析 SSE 流，确认收到完整事件 + * + * 用法（packages/server 目录下）： + * npx tsx scripts/test-acp-http-e2e.mts + * + * 前提： + * - .env 配置了 TCB_*、JWE_SECRET 等 + * - 已有有效 ACP API key（脚本会尝试用 admin 账号创建一个临时 key） + * - opencode CLI 已安装且 ~/.config/opencode 已配置 moonshot + */ + +import 'dotenv/config' +import fs from 'node:fs' + +// 启动 server (导入并 listen) +const PORT = 38765 +process.env.PORT = String(PORT) + +// 通过 dotenv 加载 .env +import { config } from 'dotenv' +config({ path: '.env' }) + +console.log('[e2e-http] booting server...') + +// 这一行起 server（监听端口）。注意 index.ts 顶部的 serve() 是 side-effect。 +// 但项目的 index.ts 是真正启服务的，import 会触发它。 +// @ts-ignore: side-effect import +await import('../src/index.js') + +await new Promise((r) => setTimeout(r, 1500)) + +console.log(`[e2e-http] server should be listening on :${PORT}`) + +const baseURL = `http://127.0.0.1:${PORT}` + +// 1. health check +const health = await fetch(`${baseURL}/api/agent/health`).then((r) => r.json()) +console.log('[e2e-http] /health =', health) + +// 2. 列出 runtimes +const runtimes = await fetch(`${baseURL}/api/agent/runtimes`).then((r) => r.json()) +console.log('[e2e-http] /runtimes =', JSON.stringify(runtimes, null, 2)) + +const hasOpencode = runtimes.runtimes?.some((r: { name: string; available: boolean }) => r.name === 'opencode-acp') +if (!hasOpencode) { + console.error('opencode-acp runtime not registered!') + process.exit(1) +} + +// 3. 创建 ACP API key（admin 通道） +// 这一步比较复杂，跳过 — 我们直接绕过 auth：通过设置请求头模拟 admin 用户 +// 实际项目里需要：先注册/登录用户，拿 session/cookie 或 API key +// +// 改用 ACP_API_KEY 环境变量（如果 server 支持）—— 实际上 routes/acp.ts 用 requireUserEnv +// 需要正常用户 session，所以这里只测试**不需要 auth 的 endpoint**。 +// +// 结论：完整 chat 流程的 e2e 已通过 test-opencode-runtime.mts 覆盖（直接调 runtime）。 +// 此 HTTP 测试主要验证 routes 层路由正确、registry 暴露正确。 + +console.log('\n[e2e-http] All public endpoints verified.') +console.log(` /health: ${health.status === 'ok' ? 'PASS' : 'FAIL'}`) +console.log(` /runtimes: ${hasOpencode ? 'PASS (opencode-acp registered)' : 'FAIL'}`) +console.log(` default runtime: ${runtimes.default}`) + +// 写出 e2e 报告 +const report = { + timestamp: new Date().toISOString(), + port: PORT, + health, + runtimes, + passed: health.status === 'ok' && hasOpencode, +} +fs.writeFileSync('/tmp/acp-http-e2e-report.json', JSON.stringify(report, null, 2)) +console.log('[e2e-http] report saved to /tmp/acp-http-e2e-report.json') + +process.exit(report.passed ? 0 : 1) diff --git a/packages/server/scripts/test-ask-user-e2e.mts b/packages/server/scripts/test-ask-user-e2e.mts new file mode 100644 index 0000000..7f3b85b --- /dev/null +++ b/packages/server/scripts/test-ask-user-e2e.mts @@ -0,0 +1,246 @@ +#!/usr/bin/env tsx +/** + * AskUserQuestion 端到端测试（OpenCode runtime） + * + * 验证链路： + * 1. 启动一个 Hono app，只挂载 acp 路由（含 /api/agent/internal/ask-user） + * 2. 设置 ASK_USER_BASE_URL = http://127.0.0.1: + * 3. 第一轮 chatStream： + * - LLM 调 question 工具 + * - custom question.ts execute → fetch ASK_USER_URL + * - server /internal/ask-user → emit ask_user（到 callback）+ 注册 pending + * - 观察：收到 ask_user 事件；一段时间内没 result（证明挂起） + * 4. 第二轮 chatStream 带 askAnswers + * - runtime resolvePendingQuestion → HTTP res.json(answers) + * - custom question.ts 拿到 answers → execute 返回 tool output + * - LLM 继续推理 + * - 最终 result + * 5. 断言：LLM 文本里包含用户答案的选项 label + * + * 用法： + * npx tsx scripts/test-ask-user-e2e.mts + */ + +import fs from 'node:fs' +import { serve } from '@hono/node-server' +import { Hono } from 'hono' + +// 在 import runtime 前设置 env（installer 和 emitter 都需要） +// 端口在 hono serve 起来后才知道，所以先占位，后面改写 +let assignedPort = 0 +process.env.OPENCODE_SKIP_TOOLS_INSTALL !== '1' // noop; 这个场景需要 tool 被装上 + +// 启动测试 server ────────────────────────────────────────────────────── +const app = new Hono() +// 只需要 acp 路由，但 acp.ts 的 middleware 会检查用户 env / token。 +// internal/* 走 token 认证（getAskUserToken），其他路径 requireUserEnv。 +// 因此我们直接 import acp 路由模块并挂载。 +import acpRoutes from '../src/routes/acp.js' +app.route('/api/agent', acpRoutes) + +// 赋值端口（让系统挑一个空闲端口） +const server = serve({ fetch: app.fetch, port: 0, hostname: '127.0.0.1' }, (info) => { + assignedPort = info.port + console.log(`[askuser-e2e] test server listening on 127.0.0.1:${assignedPort}`) +}) +await new Promise((r) => setTimeout(r, 200)) +process.env.ASK_USER_BASE_URL = `http://127.0.0.1:${assignedPort}` + +// 此时再 import runtime —— 它会读最新的 env +const { opencodeAcpRuntime } = await import('../src/agent/runtime/opencode-acp-runtime.js') +const { getAskUserToken } = await import('../src/agent/runtime/opencode-acp-runtime.js') +console.log('[askuser-e2e] ASK_USER_BASE_URL=', process.env.ASK_USER_BASE_URL) +console.log('[askuser-e2e] ASK_USER_TOKEN=', getAskUserToken().slice(0, 8) + '...') + +// ── 测试工作目录 ──────────────────────────────────────────────────────── +const WORKDIR = '/tmp/opencode-askuser-e2e-' + Date.now() +fs.mkdirSync(WORKDIR, { recursive: true }) + +// ── Event recorder ────────────────────────────────────────────────────── +import type { AgentCallbackMessage } from '@coder/shared' +const events: Array<{ ts: number; type: string; name?: string; id?: string; content?: string; input?: unknown }> = + [] +const startT0 = Date.now() + +function makeCb(label: string) { + return async (msg: AgentCallbackMessage) => { + events.push({ + ts: Date.now() - startT0, + type: msg.type, + name: msg.name, + id: msg.id, + content: typeof msg.content === 'string' ? msg.content.slice(0, 200) : undefined, + input: msg.input, + }) + const t = Date.now() - startT0 + if (msg.type === 'ask_user') { + console.log( + `\n[${label} +${t}ms] ★ ask_user id=${msg.id} questions=${JSON.stringify(msg.input).slice(0, 250)}`, + ) + } else if (msg.type === 'tool_use') { + console.log(`[${label} +${t}ms] tool_use id=${msg.id} name=${msg.name}`) + } else if (msg.type === 'tool_result') { + console.log(`[${label} +${t}ms] tool_result out=${(msg.content || '').slice(0, 200)}`) + } else if (msg.type === 'result') { + console.log(`[${label} +${t}ms] result: ${msg.content}`) + } else if (msg.type === 'error') { + console.log(`[${label} +${t}ms] error: ${msg.content}`) + } else if (msg.type === 'text' && msg.content) { + process.stdout.write(msg.content) + } + } +} + +// ── Round 1: 第一轮 prompt ────────────────────────────────────────────── +const conversationId = 'askuser-e2e-' + Date.now() +console.log(`\n[askuser-e2e] === Round 1 ===`) + +const r1 = await opencodeAcpRuntime.chatStream( + `我想搭建一个 web 应用后端。请使用 AskUserQuestion 工具问我以下问题（严格按 schema）：\n` + + ` question="Which database to use?"\n` + + ` header="Database"\n` + + ` options=[{label:"PostgreSQL", description:"powerful open-source"}, {label:"MySQL", description:"popular fast"}]\n` + + ` multiSelect=false\n` + + `等我回答后再给建议。不要自己下决定，必须用 AskUserQuestion 工具征询。`, + makeCb('r1'), + { + conversationId, + envId: '', + userId: 'e2e-user', + cwd: WORKDIR, + model: 'moonshot/kimi-k2-0905-preview', + }, +) +console.log(`[askuser-e2e] round1 returned: turnId=${r1.turnId}`) + +// 等 ask_user 事件 +console.log('[askuser-e2e] waiting for ask_user ...') +const askTimeout = Date.now() + 60_000 +let askEvent: (typeof events)[number] | undefined +while (Date.now() < askTimeout) { + askEvent = events.find((e) => e.type === 'ask_user') + if (askEvent) break + if (events.find((e) => e.type === 'result' || e.type === 'error')) { + console.error('[askuser-e2e] UNEXPECTED: round1 finished without ask_user') + console.log(JSON.stringify(events, null, 2)) + server.close() + process.exit(1) + } + await new Promise((r) => setTimeout(r, 200)) +} + +if (!askEvent) { + console.error('[askuser-e2e] FAIL: no ask_user within 60s') + server.close() + process.exit(1) +} +console.log(`\n[askuser-e2e] ✓ Received ask_user at +${askEvent.ts}ms (toolCallId=${askEvent.id})`) + +// 等 3 秒确认没 result（说明挂起） +await new Promise((r) => setTimeout(r, 3000)) +const earlyResult = events.find((e) => e.type === 'result' && e.ts > (askEvent!.ts ?? 0)) +if (earlyResult) { + console.error('[askuser-e2e] FAIL: got result too early after ask_user') + server.close() + process.exit(1) +} +console.log('[askuser-e2e] ✓ agent suspended after ask_user') + +// 取 questions 头（header）作为回答 key +const questions = (askEvent.input as { questions: Array<{ header: string; options: Array<{ label: string }> }> }) + .questions +const firstHeader = questions[0].header +const chosenLabel = questions[0].options.find((o) => /postgres/i.test(o.label))?.label ?? questions[0].options[0].label +console.log(`[askuser-e2e] simulated user answer: ${firstHeader}="${chosenLabel}"`) + +// ── Round 2: 发 askAnswers ────────────────────────────────────────────── +console.log(`\n[askuser-e2e] === Round 2 ===`) +const resumeT0 = Date.now() - startT0 +const r2 = await opencodeAcpRuntime.chatStream('', makeCb('r2'), { + conversationId, + envId: '', + userId: 'e2e-user', + cwd: WORKDIR, + model: 'moonshot/kimi-k2-0905-preview', + askAnswers: { + [askEvent.id!]: { + toolCallId: askEvent.id!, + answers: { [firstHeader]: chosenLabel }, + }, + }, +}) +console.log(`[askuser-e2e] round2 returned: alreadyRunning=${r2.alreadyRunning}`) + +if (!r2.alreadyRunning) { + console.error('[askuser-e2e] FAIL: round2 should have alreadyRunning=true') + server.close() + process.exit(1) +} + +// 等 result +console.log('[askuser-e2e] waiting for tool_result + result ...') +const finalTimeout = Date.now() + 120_000 +while (Date.now() < finalTimeout) { + if (events.find((e) => e.type === 'result' || e.type === 'error')) break + await new Promise((r) => setTimeout(r, 200)) +} + +// ── Validation ────────────────────────────────────────────────────────── +console.log('\n\n[askuser-e2e] === validation ===') +const counts: Record = {} +for (const e of events) counts[e.type] = (counts[e.type] ?? 0) + 1 +console.log('[askuser-e2e] event counts:', JSON.stringify(counts)) + +const toolResults = events.filter((e) => e.type === 'tool_result') +const questionResult = toolResults.find((e) => e.ts > resumeT0 && typeof e.content === 'string' && e.content.includes(chosenLabel)) +const finalResult = events.find((e) => e.type === 'result') +const errorEv = events.find((e) => e.type === 'error') + +// 检查 LLM 是否在最终文本里引用了用户答案（不强要求，但加分） +const allText = events + .filter((e) => e.type === 'text') + .map((e) => e.content) + .join('') +const textMentionsAnswer = allText.includes(chosenLabel) || allText.toLowerCase().includes(chosenLabel.toLowerCase()) + +console.log('\n[askuser-e2e] assertions:') + +// ★ Tencent 契约对齐断言 +const askUserToolUse = events.find((e) => e.type === 'tool_use' && e.name === 'AskUserQuestion') +const toolUseOk = !!askUserToolUse +console.log(` tool_use name='AskUserQuestion': ${toolUseOk ? 'PASS' : 'FAIL'}`) + +// ★ questions 字段 schema 对齐：multiSelect（不是 multiple），options[].description 必填 +const askQuestions = (askEvent.input as { questions?: Array> }).questions || [] +const schemaQ = askQuestions[0] +const hasHeader = typeof schemaQ?.header === 'string' +const hasQuestion = typeof schemaQ?.question === 'string' +const hasOptions = Array.isArray(schemaQ?.options) && (schemaQ.options as unknown[]).length >= 2 +// multiSelect 是可选（默认 false） +const optArr = (schemaQ?.options as Array>) || [] +const allOptsHaveDescription = optArr.every((o) => typeof o.label === 'string' && typeof o.description === 'string') +console.log(` questions[0].header/question: ${hasHeader && hasQuestion ? 'PASS' : 'FAIL'}`) +console.log(` options[].label+description: ${allOptsHaveDescription ? 'PASS' : 'FAIL'}`) +console.log(` options length >= 2: ${hasOptions ? 'PASS' : 'FAIL'}`) + +console.log(` ask_user received: PASS`) +console.log(` agent suspended after: PASS (no result 3s)`) +console.log(` round2 resume path: PASS (alreadyRunning=true)`) +console.log(` tool_result with user answer: ${questionResult ? 'PASS' : 'FAIL'}`) +console.log(` final result event: ${finalResult ? 'PASS' : 'FAIL'}`) +console.log(` no error event: ${errorEv ? 'FAIL (' + errorEv.content + ')' : 'PASS'}`) +console.log(` text mentions answer: ${textMentionsAnswer ? 'PASS (bonus)' : 'WARN (not required)'}`) + +const overall = + toolUseOk && + hasHeader && + hasQuestion && + hasOptions && + allOptsHaveDescription && + !!questionResult && + !!finalResult && + !errorEv +console.log(`\n[askuser-e2e] OVERALL: ${overall ? 'PASS' : 'FAIL'}`) + +server.close() +process.exit(overall ? 0 : 1) diff --git a/packages/server/scripts/test-memory-flow-e2e.mts b/packages/server/scripts/test-memory-flow-e2e.mts new file mode 100644 index 0000000..dd743ce --- /dev/null +++ b/packages/server/scripts/test-memory-flow-e2e.mts @@ -0,0 +1,316 @@ +#!/usr/bin/env tsx +/** + * 多轮会话连续性 + 中断恢复 + 记忆回溯 e2e + * + * 场景（用户真实使用模拟）： + * Turn 1: user → "hello 我叫王小明" + * assistant → 问候回复（必须明确提到"王小明"表明已认知） + * Turn 2: user → "我叫什么" + * assistant → 必须包含"王小明"（记忆能穿越不同 spawn 的 opencode 进程） + * Turn 3: user → "请使用 AskUserQuestion 工具问我 1+1=?，选项 2 / 3 / 4" + * assistant → 调 AskUserQuestion，挂起 + * [模拟用户答：2] + * assistant → tool_result 含 "2"，继续推理 + * Turn 4: user → "请总结一下我的名字以及我们的对话历史" + * assistant → 必须包含"王小明" + 提到 "1+1=2" + * + * 断言： + * - Turn 2 LLM 回答含"王小明"（上下文穿透） + * - Turn 3 产生 ask_user 事件 + * - Turn 3 Resume 后得到 tool_result + * - Turn 4 LLM 回答同时含"王小明"和"1+1"或"2"（完整历史回溯） + * - DB 里最终 4 条 user record + 4 条 assistant record 全部 status=done + * - Turn 3 assistant 的 parts 含 tool_call(completed) + tool_result(completed) + * + * 用法： + * npx tsx --env-file=.env scripts/test-memory-flow-e2e.mts + */ + +import 'dotenv/config' +import fs from 'node:fs' +import { serve } from '@hono/node-server' +import { Hono } from 'hono' + +const envId = process.env.TCB_ENV_ID +if (!envId) { + console.error('TCB_ENV_ID not set') + process.exit(1) +} + +// 启动 mini server 提供 /internal/ask-user +const app = new Hono() +const { default: acpRoutes } = await import('../src/routes/acp.js') +app.route('/api/agent', acpRoutes) + +let assignedPort = 0 +const server = serve({ fetch: app.fetch, port: 0, hostname: '127.0.0.1' }, (info) => { + assignedPort = info.port +}) +await new Promise((r) => setTimeout(r, 300)) +process.env.ASK_USER_BASE_URL = `http://127.0.0.1:${assignedPort}` +console.log(`[memflow-e2e] ASK_USER_BASE_URL=http://127.0.0.1:${assignedPort}`) + +const { opencodeAcpRuntime } = await import('../src/agent/runtime/opencode-acp-runtime.js') +const { persistenceService } = await import('../src/agent/persistence.service.js') +import type { AgentCallbackMessage, UnifiedMessagePart } from '@coder/shared' + +const userId = 'memflow-' + Date.now() +const conversationId = 'memflow-conv-' + Date.now() +const WORKDIR = '/tmp/opencode-memflow-' + Date.now() +fs.mkdirSync(WORKDIR, { recursive: true }) + +console.log(`[memflow-e2e] conv=${conversationId}`) +console.log(`[memflow-e2e] userId=${userId}\n`) + +// ── 通用帮助 ──────────────────────────────────────────────────────────── +interface RecordedEv { + ts: number + type: string + name?: string + id?: string + content?: string + input?: unknown +} +const startT = Date.now() + +/** + * 跑一轮 prompt，返回 { events, assistantText, finished } + * assistantText 是本轮 LLM 流式文本的拼接 + * finished = true 表示收到 result（无论是否 ask_user 中断） + */ +async function runTurn(label: string, prompt: string): Promise<{ events: RecordedEv[]; assistantText: string }> { + console.log(`\n[memflow-e2e] ▶ ${label} — prompt: ${prompt.slice(0, 80)}${prompt.length > 80 ? '...' : ''}`) + const evs: RecordedEv[] = [] + let assistantText = '' + + const cb = async (msg: AgentCallbackMessage) => { + evs.push({ + ts: Date.now() - startT, + type: msg.type, + name: msg.name, + id: msg.id, + content: typeof msg.content === 'string' ? msg.content.slice(0, 200) : undefined, + input: msg.input, + }) + if (msg.type === 'text' && msg.content) { + assistantText += msg.content + process.stdout.write(msg.content) + } else if (msg.type === 'tool_use') { + console.log(`\n [tool_use] ${msg.name}`) + } else if (msg.type === 'ask_user') { + console.log(`\n [ask_user] id=${msg.id}`) + } else if (msg.type === 'tool_result') { + console.log(`\n [tool_result] is_error=${msg.is_error}`) + } else if (msg.type === 'result') { + console.log(`\n [result]`) + } else if (msg.type === 'error') { + console.log(`\n [error] ${msg.content}`) + } + } + + await opencodeAcpRuntime.chatStream(prompt, cb, { + conversationId, + envId, + userId, + cwd: WORKDIR, + model: 'moonshot/kimi-k2-0905-preview', + }) + + // 等 result / error / ask_user + const deadline = Date.now() + 120_000 + while (Date.now() < deadline) { + if (evs.find((e) => e.type === 'result' || e.type === 'error' || e.type === 'ask_user')) break + await new Promise((r) => setTimeout(r, 200)) + } + + // result 之后再多等 500ms 吸收最后几个 text chunk + // (实测：opencode 的 SSE 推送顺序里，result 有时会先于最后一段 text chunk 到达) + if (evs.find((e) => e.type === 'result')) { + await new Promise((r) => setTimeout(r, 800)) + } + + return { events: evs, assistantText } +} + +async function resumeWithAnswers( + label: string, + toolCallId: string, + answers: Record, +): Promise<{ events: RecordedEv[]; assistantText: string }> { + console.log(`\n[memflow-e2e] ▶ ${label} — askAnswers: ${JSON.stringify(answers)}`) + const evs: RecordedEv[] = [] + let assistantText = '' + + const cb = async (msg: AgentCallbackMessage) => { + evs.push({ + ts: Date.now() - startT, + type: msg.type, + name: msg.name, + id: msg.id, + content: typeof msg.content === 'string' ? msg.content.slice(0, 200) : undefined, + }) + if (msg.type === 'text' && msg.content) { + assistantText += msg.content + process.stdout.write(msg.content) + } else if (msg.type === 'tool_result') { + console.log(`\n [tool_result] is_error=${msg.is_error} out=${(msg.content || '').slice(0, 100)}`) + } else if (msg.type === 'result') { + console.log(`\n [result]`) + } else if (msg.type === 'error') { + console.log(`\n [error] ${msg.content}`) + } + } + + await opencodeAcpRuntime.chatStream('', cb, { + conversationId, + envId, + userId, + cwd: WORKDIR, + model: 'moonshot/kimi-k2-0905-preview', + askAnswers: { + [toolCallId]: { toolCallId, answers }, + }, + }) + + const deadline = Date.now() + 120_000 + while (Date.now() < deadline) { + if (evs.find((e) => e.type === 'result' || e.type === 'error')) break + await new Promise((r) => setTimeout(r, 200)) + } + + return { events: evs, assistantText } +} + +// ── Turn 1: 自我介绍 ──────────────────────────────────────────────────── +const t1 = await runTurn('Turn 1 — 自我介绍', 'hello，我叫王小明') +console.log() +// 让 finalize 完成（messageBuilder 异步落库） +await new Promise((r) => setTimeout(r, 2000)) + +// ── Turn 2: 问名字（考察 cross-spawn 记忆）───────────────────────────────── +const t2 = await runTurn('Turn 2 — 问名字', '我叫什么') +console.log() +await new Promise((r) => setTimeout(r, 2000)) + +// ── Turn 3: 要求 AskUser ──────────────────────────────────────────────── +const t3 = await runTurn( + 'Turn 3 — 请 LLM 用 AskUserQuestion 工具', + '请使用 AskUserQuestion 工具问我：question="1+1=?" header="Math" options=[{label:"2",description:"正确答案"},{label:"3",description:"错的"},{label:"4",description:"也错"}] multiSelect=false', +) + +// 等 ask_user +const askEv = t3.events.find((e) => e.type === 'ask_user') +if (!askEv) { + console.error('\n[memflow-e2e] FAIL: Turn 3 没触发 ask_user') + console.log('events:', t3.events.slice(-10)) + server.close() + process.exit(1) +} +console.log(`\n[memflow-e2e] ✓ Turn 3 ask_user received id=${askEv.id}`) + +// 检查 input 结构（严格对齐） +const questions = (askEv.input as { questions: Array<{ header: string; options: Array<{ label: string }> }> }).questions +const header = questions[0].header +const chosenLabel = questions[0].options.find((o) => o.label === '2')?.label ?? questions[0].options[0].label +console.log(`[memflow-e2e] simulating user answer: ${header}="${chosenLabel}"`) + +// ── Turn 3 Resume: 用户答 2 ────────────────────────────────────────────── +const t3r = await resumeWithAnswers('Turn 3 resume — user answers "2"', askEv.id!, { [header]: chosenLabel }) +console.log() +await new Promise((r) => setTimeout(r, 3000)) + +// ── Turn 4: 总结 ────────────────────────────────────────────────────────── +const t4 = await runTurn( + 'Turn 4 — 总结', + '请总结一下我的名字，以及我们之前对话里发生了什么（我问了什么，你调了什么工具，我回答了什么）', +) +console.log() +await new Promise((r) => setTimeout(r, 2000)) + +// ── 验证 ────────────────────────────────────────────────────────────── +console.log('\n\n[memflow-e2e] === validation ===') + +// A. Turn 2 文本是否含 "王小明" +const t2MentionsName = /王小明/.test(t2.assistantText) + +// B. Turn 3 产生 ask_user +const t3HasAskUser = !!askEv + +// C. Turn 3 resume 后有 tool_result +const t3rHasToolResult = t3r.events.some((e) => e.type === 'tool_result') + +// D. Turn 4 同时含"王小明"和"1+1"或"2" +const t4MentionsName = /王小明/.test(t4.assistantText) +const t4MentionsMath = /1\+1|1\s*\+\s*1|问.*数学|数学.*问|算术|2\b/.test(t4.assistantText) + +// E. DB 状态检查 +const finalRecords = await persistenceService.loadDBMessages(conversationId, envId, userId, 50) +console.log(`\n[memflow-e2e] final DB records: ${finalRecords.length}`) +for (const r of finalRecords) { + const partsSig = r.parts + .map((p: UnifiedMessagePart) => { + if (p.contentType === 'text') return `text(${(p.content || '').slice(0, 30)}...)` + if (p.contentType === 'tool_call') return `tool_call(${p.metadata?.toolName}:${p.metadata?.status})` + if (p.contentType === 'tool_result') return `tool_result(${p.metadata?.status})` + return p.contentType + }) + .join(', ') + console.log(` - ${r.role} status=${r.status} parts=[${partsSig}]`) +} + +const userCount = finalRecords.filter((r) => r.role === 'user').length +const assistantCount = finalRecords.filter((r) => r.role === 'assistant').length +const allDone = finalRecords.every((r) => r.status === 'done') + +// F. Turn 3 的 assistant record 应含 tool_call + tool_result +const turn3Assistant = finalRecords.find( + (r) => + r.role === 'assistant' && + r.parts.some((p: UnifiedMessagePart) => p.contentType === 'tool_call' && p.metadata?.toolName === 'AskUserQuestion'), +) +const t3HasToolCallInDb = !!turn3Assistant +const t3HasToolResultInDb = turn3Assistant?.parts.some((p: UnifiedMessagePart) => p.contentType === 'tool_result') + +console.log('\n[memflow-e2e] assertions:') +console.log(` Turn 2 回答含"王小明"（记忆穿透）: ${t2MentionsName ? 'PASS' : 'FAIL'}`) +console.log(` Turn 3 触发 ask_user: ${t3HasAskUser ? 'PASS' : 'FAIL'}`) +console.log(` Turn 3 Resume 后 tool_result: ${t3rHasToolResult ? 'PASS' : 'FAIL'}`) +console.log(` Turn 4 回答含"王小明": ${t4MentionsName ? 'PASS' : 'FAIL'}`) +console.log(` Turn 4 回答含"1+1"或"2"（记得工具交互）: ${t4MentionsMath ? 'PASS' : 'FAIL'}`) +console.log(` DB user records == 4: ${userCount === 4 ? 'PASS' : 'FAIL'} (${userCount})`) +console.log(` DB assistant records == 4: ${assistantCount === 4 ? 'PASS' : 'FAIL'} (${assistantCount})`) +console.log(` DB 全部 status=done: ${allDone ? 'PASS' : 'FAIL'}`) +console.log(` Turn 3 assistant 含 AskUserQuestion tool_call: ${t3HasToolCallInDb ? 'PASS' : 'FAIL'}`) +console.log(` Turn 3 assistant 含 tool_result: ${t3HasToolResultInDb ? 'PASS' : 'FAIL'}`) + +// 清理 +try { + await persistenceService.deleteConversationMessages(conversationId, envId, userId) +} catch { + /* noop */ +} + +const overall = + t2MentionsName && + t3HasAskUser && + t3rHasToolResult && + t4MentionsName && + t4MentionsMath && + userCount === 4 && + assistantCount === 4 && + allDone && + t3HasToolCallInDb && + !!t3HasToolResultInDb + +console.log(`\n[memflow-e2e] OVERALL: ${overall ? 'PASS' : 'FAIL'}`) + +// 打印关键文本摘要供人工观察 +console.log('\n[memflow-e2e] assistant replies summary:') +console.log(` T1 text (${t1.assistantText.length} chars): ${t1.assistantText.slice(0, 120)}...`) +console.log(` T2 text (${t2.assistantText.length} chars): ${t2.assistantText.slice(0, 200)}`) +console.log(` T3 text (${t3.assistantText.length} chars): ${t3.assistantText.slice(0, 120)}`) +console.log(` T3r text (${t3r.assistantText.length} chars): ${t3r.assistantText.slice(0, 200)}`) +console.log(` T4 text (${t4.assistantText.length} chars): ${t4.assistantText.slice(0, 400)}`) + +server.close() +process.exit(overall ? 0 : 1) diff --git a/packages/server/scripts/test-opencode-coding-preview-e2e.mts b/packages/server/scripts/test-opencode-coding-preview-e2e.mts new file mode 100644 index 0000000..6be6922 --- /dev/null +++ b/packages/server/scripts/test-opencode-coding-preview-e2e.mts @@ -0,0 +1,313 @@ +#!/usr/bin/env tsx +/** + * E2E: OpenCode runtime + coding mode + preview + 第二轮修改 + * + * 验证目标： + * Round 1: hi 激活 → 沙箱初始化 + coding 模板 + Vite dev server 启动 + * → previewUrl 标记 ready，预览路径可访问 + * Round 2: 让 agent 修改 src/App.tsx 中某个文案 → 用 read+write 工具 + * → 重新拉预览，验证内容变更体现在 dev server 输出中 + * + * 用法： + * cd packages/server + * npx tsx --env-file=.env scripts/test-opencode-coding-preview-e2e.mts + */ + +import 'dotenv/config' +import { opencodeAcpRuntime } from '../src/agent/runtime/opencode-acp-runtime.js' +import { scfSandboxManager } from '../src/sandbox/scf-sandbox-manager.js' +import { getDb } from '../src/db/index.js' +import type { AgentCallbackMessage } from '@coder/shared' + +const envId = process.env.TCB_ENV_ID +if (!envId) { + console.error('TCB_ENV_ID not set') + process.exit(1) +} + +const conversationId = `opencode-coding-e2e-${Date.now()}` +const userId = 'e2e-coding-user' + +// 用一个有标记的 marker 字符串，便于在 round 2 中验证替换成功 +// 用普通可读词避免被模型内容审核误判 +const ROUND1_PROMPT = 'hi' +const TITLE_MARKER = `我的精彩应用` +const ROUND2_PROMPT = `请帮我把项目 index.html 的网页标题（title 标签）改成"${TITLE_MARKER}"。简单地说：用 read 工具读 index.html，然后用 edit 或 write 工具把 ... 之间的文字替换成"${TITLE_MARKER}"，做完告诉我即可。` + +console.log('=== OpenCode coding mode preview e2e ===') +console.log(`envId = ${envId}`) +console.log(`conversationId = ${conversationId}`) +console.log(`titleMarker = ${TITLE_MARKER}\n`) + +// ─── Helpers ──────────────────────────────────────────────────────────── + +interface Recorded { + type: string + name?: string + preview?: string +} + +function makeRecorder(label: string): { + cb: (msg: AgentCallbackMessage) => Promise + events: Recorded[] +} { + const events: Recorded[] = [] + const cb = async (msg: AgentCallbackMessage): Promise => { + events.push({ + type: msg.type, + name: msg.name, + preview: typeof msg.content === 'string' ? msg.content.slice(0, 200) : undefined, + }) + if (msg.type === 'text' && msg.content) process.stdout.write(msg.content) + else if (msg.type === 'tool_use') + console.log(`\n[${label} tool_use ▶] ${msg.name} input=${JSON.stringify(msg.input).slice(0, 200)}`) + else if (msg.type === 'tool_result') + console.log( + `[${label} tool_result ◯] tool_use_id=${msg.tool_use_id} is_error=${msg.is_error} out=${(msg.content || '').slice(0, 200)}`, + ) + else if (msg.type === 'agent_phase') console.log(`\n[${label} phase] ${msg.phase}`) + else if (msg.type === 'error') console.log(`\n[${label} error] ${msg.content}`) + else if (msg.type === 'result') console.log(`\n[${label} result] ${(msg.content || '').slice(0, 200)}`) + } + return { cb, events } +} + +async function waitForResultOrError(events: Recorded[], maxMs = 240_000): Promise { + const start = Date.now() + while (Date.now() - start < maxMs) { + if (events.some((e) => e.type === 'result' || e.type === 'error')) return + await new Promise((r) => setTimeout(r, 500)) + } + throw new Error(`timed out after ${maxMs}ms waiting for result/error`) +} + +// ─── Pre-flight: ensure DB ready, mark task as coding mode ────────────── + +async function ensureTaskCodingMode(): Promise { + const now = Date.now() + try { + await getDb().tasks.create({ + id: conversationId, + userId, + prompt: ROUND1_PROMPT, + title: null, + repoUrl: null, + selectedAgent: 'opencode' as any, + selectedModel: 'mimo/mimo-v2.5-pro', + selectedRuntime: 'opencode-acp', + mode: 'coding', + installDependencies: false, + maxDuration: 30, + keepAlive: false, + enableBrowser: false, + status: 'pending', + progress: 0, + logs: '[]', + error: null, + branchName: null, + sandboxId: null, + sandboxSessionId: envId, + sandboxCwd: `/tmp/workspace/${envId}/${conversationId}`, + sandboxMode: 'shared', + agentSessionId: null, + sandboxUrl: null, + previewUrl: null, + prUrl: null, + prNumber: null, + prStatus: null, + prMergeCommitSha: null, + mcpServerIds: null, + createdAt: now, + updatedAt: now, + } as any) + console.log(`[setup] task created (coding mode)`) + } catch (e) { + console.log(`[setup] task.create failed (may already exist): ${(e as Error).message}`) + } +} + +await ensureTaskCodingMode() + +// ─── Round 1: hi → expect sandbox + coding init + dev server up ───────── + +console.log('\n━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━') +console.log('Round 1: 激活 (hi) → 沙箱 + coding 项目 + dev server') +console.log('━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━\n') + +const r1 = makeRecorder('R1') +const r1Start = Date.now() +const r1Result = await opencodeAcpRuntime.chatStream(ROUND1_PROMPT, r1.cb, { + conversationId, + envId, + userId, + mode: 'coding', + model: 'mimo/mimo-v2.5-pro', +}) +console.log(`\n[R1] chatStream returned: turnId=${r1Result.turnId}`) + +await waitForResultOrError(r1.events, 240_000) +const r1Elapsed = ((Date.now() - r1Start) / 1000).toFixed(1) +console.log(`\n[R1] completed in ${r1Elapsed}s`) + +// ─── Round 1 sandbox & dev server validation ──────────────────────────── + +console.log('\n[R1] === sandbox + dev server validation ===') + +const sandbox = await scfSandboxManager.getOrCreate(conversationId, envId, { + mode: 'shared', + workspaceIsolation: 'shared', + isCodingMode: true, +}) + +let scopeInfo: any = null +try { + const headers = await sandbox.getAuthHeaders() + const res = await fetch(`${sandbox.baseUrl}/api/scope/info`, { headers }) + scopeInfo = await res.json().catch(() => null) + console.log(`[R1] scope/info: ${JSON.stringify(scopeInfo).slice(0, 400)}`) +} catch (e) { + console.log(`[R1] scope/info error: ${(e as Error).message}`) +} + +const workspace: string | undefined = scopeInfo?.workspace +const vitePort: number | undefined = scopeInfo?.vitePort +console.log(`[R1] workspace=${workspace} vitePort=${vitePort}`) + +// Check that index.html exists in workspace +let indexHtmlExists = false +let indexHtmlContent = '' +try { + const headers = await sandbox.getAuthHeaders() + const res = await fetch(`${sandbox.baseUrl}/api/tools/read`, { + method: 'POST', + headers: { 'Content-Type': 'application/json', ...headers }, + body: JSON.stringify({ path: 'index.html' }), + }) + const data = (await res.json().catch(() => ({}))) as any + if (data.success && typeof data.result?.content === 'string') { + indexHtmlContent = data.result.content + indexHtmlExists = true + console.log(`[R1] index.html exists, size=${indexHtmlContent.length}`) + const titleMatch = indexHtmlContent.match(/]*>([^<]*)<\/title>/i) + console.log(`[R1] current : ${titleMatch?.[1] ?? '(no title)'}`) + } else { + console.log(`[R1] index.html read failed: ${JSON.stringify(data).slice(0, 200)}`) + } +} catch (e) { + console.log(`[R1] read index.html error: ${(e as Error).message}`) +} + +// Check dev server preview path - 用 scope/info 返回的真实 previewUrl +const previewPath: string = scopeInfo?.previewUrl || (vitePort ? `/preview/${vitePort}/` : '/preview/') +let previewOk = false +let previewSnippet = '' +try { + const headers = await sandbox.getAuthHeaders() + const res = await fetch(`${sandbox.baseUrl}${previewPath}`, { headers, signal: AbortSignal.timeout(15000) }) + previewSnippet = (await res.text()).slice(0, 600) + previewOk = res.ok && previewSnippet.length > 0 + console.log( + `[R1] ${previewPath} status=${res.status} ok=${previewOk} snippet="${previewSnippet.slice(0, 200).replace(/\n/g, ' ')}"`, + ) +} catch (e) { + console.log(`[R1] ${previewPath} error: ${(e as Error).message}`) +} + +// Check task previewUrl in DB +const task1 = await getDb().tasks.findById(conversationId) +console.log(`[R1] task.previewUrl = ${task1?.previewUrl}`) + +// ─── Round 2: ask agent to modify title ──────────────────────────────── + +console.log('\n\n━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━') +console.log('Round 2: 修改 index.html title → 验证预览更新') +console.log('━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━\n') + +const r2 = makeRecorder('R2') +const r2Start = Date.now() +const r2Result = await opencodeAcpRuntime.chatStream(ROUND2_PROMPT, r2.cb, { + conversationId, + envId, + userId, + mode: 'coding', + model: 'mimo/mimo-v2.5-pro', +}) +console.log(`\n[R2] chatStream returned: turnId=${r2Result.turnId}`) + +await waitForResultOrError(r2.events, 300_000) +const r2Elapsed = ((Date.now() - r2Start) / 1000).toFixed(1) +console.log(`\n[R2] completed in ${r2Elapsed}s`) + +// ─── Round 2 validation: title changed in file & preview ─────────────── + +console.log('\n[R2] === modification validation ===') + +let r2IndexContent = '' +try { + const headers = await sandbox.getAuthHeaders() + const res = await fetch(`${sandbox.baseUrl}/api/tools/read`, { + method: 'POST', + headers: { 'Content-Type': 'application/json', ...headers }, + body: JSON.stringify({ path: 'index.html' }), + }) + const data = (await res.json().catch(() => ({}))) as any + if (data.success && typeof data.result?.content === 'string') { + r2IndexContent = data.result.content + const titleMatch = r2IndexContent.match(/<title[^>]*>([^<]*)<\/title>/i) + console.log(`[R2] new <title>: ${titleMatch?.[1] ?? '(no title)'}`) + } +} catch (e) { + console.log(`[R2] read index.html error: ${(e as Error).message}`) +} + +const fileHasMarker = r2IndexContent.includes(TITLE_MARKER) + +// Wait a moment for vite HMR to pick up change, then re-fetch preview +await new Promise((r) => setTimeout(r, 3000)) + +let r2PreviewSnippet = '' +let previewHasMarker = false +try { + const headers = await sandbox.getAuthHeaders() + const res = await fetch(`${sandbox.baseUrl}${previewPath}`, { headers, signal: AbortSignal.timeout(15000) }) + r2PreviewSnippet = await res.text() + previewHasMarker = r2PreviewSnippet.includes(TITLE_MARKER) + const titleMatch = r2PreviewSnippet.match(/<title[^>]*>([^<]*)<\/title>/i) + console.log(`[R2] preview <title>: ${titleMatch?.[1] ?? '(no title)'} (status=${res.status})`) +} catch (e) { + console.log(`[R2] ${previewPath} error: ${(e as Error).message}`) +} + +// ─── Summary & assertions ────────────────────────────────────────────── + +const r1Counts: Record<string, number> = {} +for (const e of r1.events) r1Counts[e.type] = (r1Counts[e.type] ?? 0) + 1 +const r2Counts: Record<string, number> = {} +for (const e of r2.events) r2Counts[e.type] = (r2Counts[e.type] ?? 0) + 1 + +console.log('\n\n=========================================================') +console.log('FINAL SUMMARY') +console.log('=========================================================') +console.log(`R1 events: ${JSON.stringify(r1Counts)}`) +console.log(`R2 events: ${JSON.stringify(r2Counts)}`) +console.log() +console.log('R1 (sandbox + coding init):') +console.log(` workspace path: ${workspace ? 'PASS' : 'FAIL'} (${workspace})`) +console.log(` index.html exists: ${indexHtmlExists ? 'PASS' : 'FAIL'}`) +console.log(` /preview/ accessible: ${previewOk ? 'PASS' : 'FAIL'}`) +console.log(` task.previewUrl set: ${task1?.previewUrl ? 'PASS' : 'FAIL'} (${task1?.previewUrl})`) +console.log(` R1 has result event: ${r1Counts.result ? 'PASS' : 'FAIL'}`) +console.log() +console.log('R2 (file modification + preview):') +console.log(` R2 has result event: ${r2Counts.result ? 'PASS' : 'FAIL'}`) +console.log(` R2 used tools: ${r2Counts.tool_use ? `PASS (${r2Counts.tool_use})` : 'FAIL'}`) +console.log(` index.html contains marker: ${fileHasMarker ? 'PASS' : 'FAIL'}`) +console.log(` /preview/ contains marker: ${previewHasMarker ? 'PASS' : 'FAIL'}`) + +const r1Ok = !!workspace && indexHtmlExists && previewOk && (r1Counts.result ?? 0) > 0 +const r2Ok = (r2Counts.result ?? 0) > 0 && (r2Counts.tool_use ?? 0) > 0 && fileHasMarker +const overall = r1Ok && r2Ok + +console.log('\nOVERALL:', overall ? 'PASS ✓' : 'FAIL ✗') + +process.exit(overall ? 0 : 1) diff --git a/packages/server/scripts/test-opencode-runtime.mts b/packages/server/scripts/test-opencode-runtime.mts new file mode 100644 index 0000000..cb7da26 --- /dev/null +++ b/packages/server/scripts/test-opencode-runtime.mts @@ -0,0 +1,119 @@ +#!/usr/bin/env tsx +/** + * 端到端测试 OpencodeAcpRuntime + * + * 用法（从 packages/server 目录）： + * npx tsx scripts/test-opencode-runtime.mts + * + * 验证目标： + * 1. runtime.chatStream() 能启动子进程并完成一轮对话 + * 2. callback 收到完整 AgentCallbackMessage 流（text / tool_use / tool_result / result） + * 3. 真实 LLM 响应（Moonshot Kimi） + * 4. 文件实际写入工作目录 + */ + +import fs from 'node:fs' +import { opencodeAcpRuntime } from '../src/agent/runtime/opencode-acp-runtime.js' +import type { AgentCallbackMessage } from '@coder/shared' + +const WORKDIR = '/tmp/opencode-runtime-e2e' +fs.rmSync(WORKDIR, { recursive: true, force: true }) +fs.mkdirSync(WORKDIR, { recursive: true }) + +console.log(`[e2e] workdir = ${WORKDIR}`) + +console.log('[e2e] checking opencode availability...') +const available = await opencodeAcpRuntime.isAvailable() +console.log(`[e2e] available = ${available}`) +if (!available) { + console.error('opencode CLI not available') + process.exit(1) +} + +interface RecordedEvent { + seq: number | undefined + type: string + name?: string + contentPreview?: string +} +const events: RecordedEvent[] = [] + +const cb = async (msg: AgentCallbackMessage, seq?: number): Promise<void> => { + events.push({ + seq, + type: msg.type, + name: msg.name, + contentPreview: typeof msg.content === 'string' ? msg.content.slice(0, 100) : undefined, + }) + if (msg.type === 'text' && msg.content) process.stdout.write(msg.content) + else if (msg.type === 'tool_use') + console.log(`\n[tool_use ▶] ${msg.name} id=${msg.id} input=${JSON.stringify(msg.input).slice(0, 200)}`) + else if (msg.type === 'tool_result') + console.log( + `[tool_result ◯] tool_use_id=${msg.tool_use_id} is_error=${msg.is_error} out=${(msg.content || '').slice(0, 200)}`, + ) + else if (msg.type === 'agent_phase') console.log(`\n[phase] ${msg.phase}`) + else if (msg.type === 'error') console.log(`\n[error] ${msg.content}`) + else if (msg.type === 'result') console.log(`\n[result] ${msg.content}`) + else if (msg.type === 'thinking') console.log(`\n[thinking] ${(msg.content || '').slice(0, 100)}`) +} + +console.log('\n[e2e] === starting chatStream ===') +const conversationId = 'e2e-test-' + Date.now() +const { turnId, alreadyRunning } = await opencodeAcpRuntime.chatStream( + '请在当前目录创建一个名为 hello.txt 的文件，内容是单行 "hello from runtime"。完成后简短告诉我已完成。', + cb, + { + conversationId, + // 不传 envId → 跳过持久化，纯内存模式（适合 e2e） + envId: '', + userId: 'e2e-user', + cwd: WORKDIR, + model: 'moonshot/kimi-k2-0905-preview', + }, +) +console.log(`\n[e2e] chatStream returned: turnId=${turnId} alreadyRunning=${alreadyRunning}`) + +console.log('[e2e] waiting for result event...') +const startTime = Date.now() +while (Date.now() - startTime < 120000) { + const done = events.find((e) => e.type === 'result' || e.type === 'error') + if (done) break + await new Promise((r) => setTimeout(r, 500)) +} + +console.log('\n\n[e2e] === completed ===') +const counts: Record<string, number> = {} +for (const e of events) counts[e.type] = (counts[e.type] ?? 0) + 1 +console.log('[e2e] event counts:', JSON.stringify(counts, null, 2)) + +console.log('\n[e2e] file system check:') +let fileOk = false +try { + const content = fs.readFileSync(`${WORKDIR}/hello.txt`, 'utf8') + console.log(`hello.txt content: ${JSON.stringify(content)}`) + if (content.includes('hello from runtime')) { + console.log('PASS: file created with correct content') + fileOk = true + } else { + console.log('WARN: file content unexpected') + } +} catch (e) { + console.log(`FAIL: hello.txt not created — ${(e as Error).message}`) +} + +const hasText = (counts.text ?? 0) > 0 +const hasToolUse = (counts.tool_use ?? 0) > 0 +const hasToolResult = (counts.tool_result ?? 0) > 0 +const hasResult = (counts.result ?? 0) > 0 + +console.log('\n[e2e] assertions:') +console.log(` text events: ${hasText ? 'PASS' : 'FAIL'} (${counts.text ?? 0})`) +console.log(` tool_use events: ${hasToolUse ? 'PASS' : 'FAIL'} (${counts.tool_use ?? 0})`) +console.log(` tool_result events: ${hasToolResult ? 'PASS' : 'FAIL'} (${counts.tool_result ?? 0})`) +console.log(` result events: ${hasResult ? 'PASS' : 'FAIL'} (${counts.result ?? 0})`) +console.log(` file created: ${fileOk ? 'PASS' : 'FAIL'}`) + +const ok = hasText && hasToolUse && hasToolResult && hasResult && fileOk +console.log(`\n[e2e] OVERALL: ${ok ? 'PASS' : 'FAIL'}`) +process.exit(ok ? 0 : 1) diff --git a/packages/server/scripts/test-opencode-sandbox-e2e.mts b/packages/server/scripts/test-opencode-sandbox-e2e.mts new file mode 100644 index 0000000..a9410f5 --- /dev/null +++ b/packages/server/scripts/test-opencode-sandbox-e2e.mts @@ -0,0 +1,150 @@ +#!/usr/bin/env tsx +/** + * 沙箱隔离 e2e 测试（新架构 - tool override + env 注入） + * + * 验证链路： + * LLM → 调 write 工具 (被 ~/.config/opencode/tools/write.ts 覆盖) + * → 读 process.env.SANDBOX_BASE_URL + SANDBOX_AUTH_HEADERS_JSON + * → fetch 沙箱 /api/tools/write + * → 沙箱容器里真实写文件 + * + * 断言： + * 1. LLM 使用了 write 工具（名字就是 write，非 sbx_* 前缀） + * 2. 直接调沙箱 /api/tools/read 能读到预期内容（独立验证） + * 3. 本地文件系统未被污染 + * + * 用法： + * npx tsx --env-file=.env scripts/test-opencode-sandbox-e2e.mts + */ + +import 'dotenv/config' +import fs from 'node:fs' +import { opencodeAcpRuntime } from '../src/agent/runtime/opencode-acp-runtime.js' +import { scfSandboxManager } from '../src/sandbox/scf-sandbox-manager.js' +import type { AgentCallbackMessage } from '@coder/shared' + +const envId = process.env.TCB_ENV_ID +if (!envId) { + console.error('TCB_ENV_ID not set in env — cannot run sandbox e2e') + process.exit(1) +} + +const conversationId = 'sandbox-e2e-v2-' + Date.now() +const testFilename = `hello-sandbox-v2-${Date.now()}.txt` +const expectedContent = `hello from v2 ${Math.random().toString(36).slice(2, 10)}` +const sandboxRelPath = testFilename + +console.log(`[sandbox-e2e-v2] envId=${envId}`) +console.log(`[sandbox-e2e-v2] conversationId=${conversationId}`) +console.log(`[sandbox-e2e-v2] testFile (relative)=${sandboxRelPath}`) +console.log(`[sandbox-e2e-v2] expectedContent=${JSON.stringify(expectedContent)}\n`) + +// 清理潜在的本地同名文件（e2e 将验证本地不被污染） +const localMirror = `/tmp/${testFilename}` +try { + fs.unlinkSync(localMirror) +} catch { + /* noop */ +} + +interface RecordedEvent { + type: string + name?: string + content?: string +} +const events: RecordedEvent[] = [] + +const cb = async (msg: AgentCallbackMessage): Promise<void> => { + events.push({ + type: msg.type, + name: msg.name, + content: typeof msg.content === 'string' ? msg.content.slice(0, 180) : undefined, + }) + if (msg.type === 'text' && msg.content) process.stdout.write(msg.content) + else if (msg.type === 'tool_use') + console.log(`\n[tool_use ▶] name=${msg.name} id=${msg.id} input=${JSON.stringify(msg.input).slice(0, 200)}`) + else if (msg.type === 'tool_result') + console.log( + `[tool_result ◯] tool_use_id=${msg.tool_use_id} is_error=${msg.is_error} out=${(msg.content || '').slice(0, 200)}`, + ) + else if (msg.type === 'agent_phase') console.log(`\n[phase] ${msg.phase}`) + else if (msg.type === 'error') console.log(`\n[error] ${msg.content}`) + else if (msg.type === 'result') console.log(`\n[result] ${msg.content}`) +} + +console.log('[sandbox-e2e-v2] === starting chatStream (sandbox mode) ===') +const { turnId } = await opencodeAcpRuntime.chatStream( + `请使用 write 工具创建文件 ${sandboxRelPath}（使用相对路径），内容**完全等于**这一个字符串：${expectedContent}\n不要加引号、不要加 markdown、不要多余换行、不要添加任何其他文字。完成后简短告诉我已完成。`, + cb, + { + conversationId, + envId, + userId: 'e2e-user', + model: 'moonshot/kimi-k2-0905-preview', + }, +) +console.log(`\n[sandbox-e2e-v2] chatStream returned: turnId=${turnId}`) + +const startTime = Date.now() +while (Date.now() - startTime < 180_000) { + if (events.find((e) => e.type === 'result' || e.type === 'error')) break + await new Promise((r) => setTimeout(r, 500)) +} + +console.log('\n\n[sandbox-e2e-v2] === validation ===') + +const counts: Record<string, number> = {} +for (const e of events) counts[e.type] = (counts[e.type] ?? 0) + 1 +console.log('[sandbox-e2e-v2] event counts:', JSON.stringify(counts)) + +// 1. 确认 LLM 用了 write 工具 +const writeToolUses = events.filter((e) => e.type === 'tool_use' && e.name === 'write') +console.log(`[sandbox-e2e-v2] 'write' tool_use count: ${writeToolUses.length}`) + +// 2. 独立验证沙箱里的文件 +console.log('\n[sandbox-e2e-v2] querying sandbox /api/tools/read to verify...') +let sandboxReadOk = false +let sandboxReadContent = '' +try { + const sandbox = await scfSandboxManager.getOrCreate(conversationId, envId, { + mode: 'shared', + workspaceIsolation: 'shared', + }) + const headers = await sandbox.getAuthHeaders() + const res = await fetch(`${sandbox.baseUrl}/api/tools/read`, { + method: 'POST', + headers: { 'Content-Type': 'application/json', ...headers }, + body: JSON.stringify({ path: sandboxRelPath }), + }) + const data = (await res.json().catch(() => ({}))) as { success?: boolean; result?: any; error?: string } + if (data.success && typeof data.result?.content === 'string') { + sandboxReadContent = data.result.content + sandboxReadOk = sandboxReadContent.includes(expectedContent) + console.log(`[sandbox-e2e-v2] sandbox file content = ${JSON.stringify(sandboxReadContent.slice(0, 200))}`) + } else { + console.log(`[sandbox-e2e-v2] sandbox read failed: ${data.error ?? JSON.stringify(data).slice(0, 200)}`) + } +} catch (e) { + console.log(`[sandbox-e2e-v2] sandbox read error: ${(e as Error).message}`) +} + +// 3. 本地文件系统干净 +const localExists = fs.existsSync(localMirror) +console.log(`[sandbox-e2e-v2] local ${localMirror} exists = ${localExists} (should be false)`) + +// ─── Assertions ───────────────────────────────────────────────────────────── +const hasText = (counts.text ?? 0) > 0 +const hasResult = (counts.result ?? 0) > 0 +const usedWrite = writeToolUses.length > 0 + +console.log('\n[sandbox-e2e-v2] assertions:') +console.log(` text events: ${hasText ? 'PASS' : 'FAIL'}`) +console.log(` result event: ${hasResult ? 'PASS' : 'FAIL'}`) +console.log(` LLM used 'write' tool: ${usedWrite ? 'PASS' : 'FAIL'} (count=${writeToolUses.length})`) +console.log(` sandbox file has content: ${sandboxReadOk ? 'PASS' : 'FAIL'}`) +console.log(` local NOT polluted: ${!localExists ? 'PASS' : 'FAIL'}`) + +const overall = hasText && hasResult && usedWrite && sandboxReadOk && !localExists +console.log(`\n[sandbox-e2e-v2] OVERALL: ${overall ? 'PASS' : 'FAIL'}`) + +process.exit(overall ? 0 : 1) diff --git a/packages/server/scripts/test-opencode-todowrite-e2e.mts b/packages/server/scripts/test-opencode-todowrite-e2e.mts new file mode 100644 index 0000000..322d465 --- /dev/null +++ b/packages/server/scripts/test-opencode-todowrite-e2e.mts @@ -0,0 +1,93 @@ +#!/usr/bin/env tsx +/** + * E2E: 验证 OpenCode 的 todoWrite 工具事件名称和格式 + * + * 目的：确认前端 TodoWrite renderer 能识别 opencode 发出的 tool_call name + */ + +import 'dotenv/config' +import { opencodeAcpRuntime } from '../src/agent/runtime/opencode-acp-runtime.js' +import type { AgentCallbackMessage } from '@coder/shared' + +const envId = process.env.TCB_ENV_ID +if (!envId) { + console.error('TCB_ENV_ID not set') + process.exit(1) +} + +const conversationId = `opencode-todo-e2e-${Date.now()}` +const userId = 'e2e-todo-user' + +console.log('=== OpenCode todoWrite e2e ===') +console.log(`envId=${envId}`) +console.log(`conversationId=${conversationId}\n`) + +interface ToolCall { + name: string + input: unknown +} + +const toolCalls: ToolCall[] = [] +const events: { type: string; name?: string; input?: unknown }[] = [] + +const cb = async (msg: AgentCallbackMessage): Promise<void> => { + events.push({ type: msg.type, name: msg.name, input: msg.input }) + if (msg.type === 'tool_use') { + toolCalls.push({ name: msg.name || '', input: msg.input }) + console.log(`\n[tool_use ▶] name="${msg.name}" input=${JSON.stringify(msg.input).slice(0, 400)}`) + } else if (msg.type === 'tool_input_update') { + console.log(`[tool_input_update] id=${msg.id} input=${JSON.stringify(msg.input).slice(0, 200)}`) + } else if (msg.type === 'text' && msg.content) { + process.stdout.write(msg.content) + } else if (msg.type === 'result') { + console.log(`\n[result] ${(msg.content || '').slice(0, 200)}`) + } else if (msg.type === 'error') { + console.log(`\n[error] ${msg.content}`) + } else if (msg.type === 'agent_phase') { + console.log(`\n[phase] ${msg.phase}`) + } +} + +const prompt = `请用 todoWrite 工具创建一个待办清单，至少 4 项，内容随意（比如"读取文件"、"分析代码"、"修改 bug"、"验证结果"）。创建完就结束。` + +console.log('[todowrite-e2e] Starting chatStream...') +const { turnId } = await opencodeAcpRuntime.chatStream(prompt, cb, { + conversationId, + envId, + userId, + mode: 'coding', + model: 'mimo/mimo-v2.5-pro', +}) +console.log(`[todowrite-e2e] chatStream returned: turnId=${turnId}`) + +const start = Date.now() +while (Date.now() - start < 180_000) { + if (events.some((e) => e.type === 'result' || e.type === 'error')) break + await new Promise((r) => setTimeout(r, 500)) +} + +console.log('\n\n=== SUMMARY ===') +console.log(`total events: ${events.length}`) +console.log(`tool_use events: ${toolCalls.length}`) +for (const tc of toolCalls) { + console.log(` - name="${tc.name}"`) +} + +const todoCall = toolCalls.find( + (t) => t.name.toLowerCase().includes('todo') || /todo/i.test(t.name), +) +if (todoCall) { + console.log(`\n[VERIFIED] Found todo-like tool call: name="${todoCall.name}"`) + console.log(`input: ${JSON.stringify(todoCall.input, null, 2)}`) + + // Verify input format matches what frontend TodoWrite renderer expects + const input = todoCall.input as { todos?: unknown[] } + if (Array.isArray(input.todos)) { + console.log(`\ntodos array length: ${input.todos.length}`) + console.log(`first item: ${JSON.stringify(input.todos[0])}`) + } +} else { + console.log('\n[NOT FOUND] No todo-like tool was called') +} + +process.exit(0) diff --git a/packages/server/scripts/test-persistence-e2e.mts b/packages/server/scripts/test-persistence-e2e.mts new file mode 100644 index 0000000..d602f58 --- /dev/null +++ b/packages/server/scripts/test-persistence-e2e.mts @@ -0,0 +1,186 @@ +#!/usr/bin/env tsx +/** + * 消息持久化端到端测试（OpenCode runtime） + * + * 验证链路： + * 1. chatStream(prompt, envId=真实 TCB 环境) + * 2. preSavePendingRecords → DB 有 user(done) + assistant(pending) + * 3. LLM 执行 → 若工具调用，tool_result 触发 flushToDb + * 4. finalize → status=done，最终 parts 写入 + * 5. loadDBMessages 读回 → 结构与预期一致 + * + * 断言： + * A. DB 里能找到 user + assistant 两条 record + * B. assistant record status = 'done' + * C. assistant parts 数组至少含 1 个 text part（LLM 的回答） + * D. 如果有工具调用，parts 包含 tool_call + tool_result 对 + * E. 前端 tasks.ts 转换逻辑能消化（模拟: 转成 TaskMessage 不报错） + * + * 用法： + * npx tsx --env-file=.env scripts/test-persistence-e2e.mts + */ + +import 'dotenv/config' +import fs from 'node:fs' +import { opencodeAcpRuntime } from '../src/agent/runtime/opencode-acp-runtime.js' +import { persistenceService } from '../src/agent/persistence.service.js' +import type { AgentCallbackMessage, UnifiedMessagePart } from '@coder/shared' + +const envId = process.env.TCB_ENV_ID +if (!envId) { + console.error('TCB_ENV_ID not set — cannot run persistence e2e') + process.exit(1) +} + +const userId = 'persist-e2e-user-' + Date.now() +const conversationId = 'persist-e2e-' + Date.now() + +console.log(`[persist-e2e] envId=${envId}`) +console.log(`[persist-e2e] userId=${userId}`) +console.log(`[persist-e2e] conversationId=${conversationId}\n`) + +// ── Test workdir（本地，避免沙箱路径问题）───────────────────────────────────── +const WORKDIR = '/tmp/opencode-persist-e2e-' + Date.now() +fs.mkdirSync(WORKDIR, { recursive: true }) + +// ── 收集事件，仅用于观察 ───────────────────────────────────────────────── +const events: AgentCallbackMessage[] = [] +const cb = async (msg: AgentCallbackMessage) => { + events.push(msg) + if (msg.type === 'text' && msg.content) process.stdout.write(msg.content) + else if (msg.type === 'tool_use') console.log(`\n[tool_use ▶] ${msg.name} id=${msg.id}`) + else if (msg.type === 'tool_result') console.log(`[tool_result ◯] is_error=${msg.is_error}`) + else if (msg.type === 'result') console.log(`\n[result] ${msg.content?.slice(0, 100)}`) + else if (msg.type === 'error') console.log(`[error] ${msg.content}`) +} + +// ── 让 LLM 写一个文件，触发工具调用（让 parts 里必然有 tool_call+tool_result）─ +// 不走沙箱（envId='' 会跳过），走本地 custom write tool +// 但 envId 必须传真实值才能落库，所以用 envId=真实、cwd=本地目录 +console.log('[persist-e2e] === chatStream (with envId + local workdir) ===') +const prompt = `请用 write 工具在当前目录创建文件 persist.txt，内容正好一行：persistence works\n完成后简短确认。` + +const { turnId } = await opencodeAcpRuntime.chatStream(prompt, cb, { + conversationId, + envId, + userId, + cwd: WORKDIR, + model: 'moonshot/kimi-k2-0905-preview', +}) +console.log(`[persist-e2e] chatStream turnId=${turnId}`) + +// 等 result / error +console.log('\n[persist-e2e] waiting for result ...') +const timeout = Date.now() + 120_000 +while (Date.now() < timeout) { + if (events.find((e) => e.type === 'result' || e.type === 'error')) break + await new Promise((r) => setTimeout(r, 300)) +} + +// 给 finalize 一点时间（它在 finally 里、异步写库） +await new Promise((r) => setTimeout(r, 2000)) + +// ── 从 DB 读回验证 ────────────────────────────────────────────────────── +console.log('\n\n[persist-e2e] === loadDBMessages ===') +const records = await persistenceService.loadDBMessages(conversationId, envId, userId, 20) +console.log(`[persist-e2e] records count: ${records.length}`) +for (const r of records) { + console.log( + ` - ${r.role} status=${r.status} recordId=${r.recordId.slice(0, 8)}... parts=${r.parts.length} ${r.parts.map((p: UnifiedMessagePart) => p.contentType).join(',')}`, + ) +} + +// ── Assertions ────────────────────────────────────────────────────────── +const userRecord = records.find((r) => r.role === 'user') +const assistantRecord = records.find((r) => r.role === 'assistant') + +const hasUser = !!userRecord +const hasAssistant = !!assistantRecord +const assistantDone = assistantRecord?.status === 'done' +const userHasTextPart = userRecord?.parts?.[0]?.contentType === 'text' +const userPromptMatches = userRecord?.parts?.[0]?.content?.includes('persist.txt') ?? false + +const assistantParts = assistantRecord?.parts ?? [] +const hasTextPart = assistantParts.some((p: UnifiedMessagePart) => p.contentType === 'text' && !!p.content) +const hasToolCallPart = assistantParts.some((p: UnifiedMessagePart) => p.contentType === 'tool_call') +const hasToolResultPart = assistantParts.some((p: UnifiedMessagePart) => p.contentType === 'tool_result') + +// 校验 replyTo 链 +const replyToOk = assistantRecord?.replyTo === userRecord?.recordId + +// ── 模拟前端转换（验证前端 tasks.ts 逻辑不会挂）───────────────────────── +let frontendConvertOk = true +try { + const frontMessages = records.map((record) => ({ + id: record.recordId, + taskId: conversationId, + role: record.role === 'user' ? 'user' : 'agent', + parts: (record.parts || []).map((p: UnifiedMessagePart) => { + if (p.contentType === 'text') return { type: 'text', text: p.content || '' } + if (p.contentType === 'reasoning') return { type: 'thinking', text: p.content || '' } + if (p.contentType === 'tool_call') + return { + type: 'tool_call', + toolCallId: p.toolCallId || p.partId, + toolName: (p.metadata?.toolCallName as string) || (p.metadata?.toolName as string) || 'tool', + input: p.content || p.metadata?.input, + status: p.metadata?.status, + } + if (p.contentType === 'tool_result') + return { + type: 'tool_result', + toolCallId: p.toolCallId || p.partId, + content: p.content || '', + isError: p.metadata?.isError, + } + return { type: 'text', text: p.content || '' } + }), + status: record.status, + createdAt: record.createTime, + })) + console.log(`\n[persist-e2e] frontend convert result: ${frontMessages.length} TaskMessage`) + const userMsg = frontMessages.find((m) => m.role === 'user') + const agentMsg = frontMessages.find((m) => m.role === 'agent') + console.log(` user parts: ${userMsg?.parts.map((p) => p.type).join(',')}`) + console.log(` agent parts: ${agentMsg?.parts.map((p) => p.type).join(',')}`) +} catch (e) { + console.error('[persist-e2e] frontend convert FAILED:', e) + frontendConvertOk = false +} + +console.log('\n[persist-e2e] assertions:') +console.log(` records >= 2: ${records.length >= 2 ? 'PASS' : 'FAIL'} (${records.length})`) +console.log(` user record exists: ${hasUser ? 'PASS' : 'FAIL'}`) +console.log(` user text part w/ prompt content: ${userHasTextPart && userPromptMatches ? 'PASS' : 'FAIL'}`) +console.log(` assistant record exists: ${hasAssistant ? 'PASS' : 'FAIL'}`) +console.log(` assistant status='done': ${assistantDone ? 'PASS' : 'FAIL'} (${assistantRecord?.status})`) +console.log(` assistant has text part: ${hasTextPart ? 'PASS' : 'FAIL'}`) +console.log(` assistant has tool_call part: ${hasToolCallPart ? 'PASS' : 'FAIL'}`) +console.log(` assistant has tool_result part: ${hasToolResultPart ? 'PASS' : 'FAIL'}`) +console.log(` assistant.replyTo == userRecordId: ${replyToOk ? 'PASS' : 'FAIL'}`) +console.log(` frontend convert works: ${frontendConvertOk ? 'PASS' : 'FAIL'}`) + +// 清理（不要留 e2e 垃圾在生产环境） +console.log('\n[persist-e2e] cleanup...') +try { + await persistenceService.deleteConversationMessages(conversationId, envId, userId) + console.log('[persist-e2e] cleanup done') +} catch (e) { + console.warn('[persist-e2e] cleanup failed:', (e as Error).message) +} + +const overall = + records.length >= 2 && + hasUser && + userHasTextPart && + userPromptMatches && + hasAssistant && + assistantDone && + hasTextPart && + hasToolCallPart && + hasToolResultPart && + replyToOk && + frontendConvertOk + +console.log(`\n[persist-e2e] OVERALL: ${overall ? 'PASS' : 'FAIL'}`) +process.exit(overall ? 0 : 1) diff --git a/packages/server/scripts/test-persistence-suspend-e2e.mts b/packages/server/scripts/test-persistence-suspend-e2e.mts new file mode 100644 index 0000000..46e1906 --- /dev/null +++ b/packages/server/scripts/test-persistence-suspend-e2e.mts @@ -0,0 +1,202 @@ +#!/usr/bin/env tsx +/** + * 持久化挂起态 e2e： + * + * 验证挂起场景（AskUserQuestion 等用户答）期间 DB 可见部分完整状态， + * 用户答复后 DB 继续补充剩余 parts 和 finalize status。 + * + * 场景： + * Round 1 发 prompt 让 LLM 调 AskUserQuestion + * 等到 ask_user 事件（挂起）→ **此时另一视角**调 loadDBMessages 读 DB + * 断言：assistant record 的 parts 里已有 tool_call（AskUserQuestion，status=in_progress） + * assistant.status 仍为 'pending' + * Round 2 发 askAnswers 恢复 + * 等到 result → 再读一次 DB + * 断言：parts 补齐了 tool_result（状态 completed）+ 后续 text + * assistant.status = 'done' + * + * 用法： + * npx tsx --env-file=.env scripts/test-persistence-suspend-e2e.mts + */ + +import 'dotenv/config' +import fs from 'node:fs' +import { serve } from '@hono/node-server' +import { Hono } from 'hono' + +const envId = process.env.TCB_ENV_ID +if (!envId) { + console.error('TCB_ENV_ID not set') + process.exit(1) +} + +// 启动 mini server 提供 /internal/ask-user +const app = new Hono() +const { default: acpRoutes } = await import('../src/routes/acp.js') +app.route('/api/agent', acpRoutes) + +let assignedPort = 0 +const server = serve({ fetch: app.fetch, port: 0, hostname: '127.0.0.1' }, (info) => { + assignedPort = info.port +}) +await new Promise((r) => setTimeout(r, 300)) +process.env.ASK_USER_BASE_URL = `http://127.0.0.1:${assignedPort}` +console.log(`[suspend-e2e] ASK_USER_BASE_URL=${process.env.ASK_USER_BASE_URL}`) + +const { opencodeAcpRuntime } = await import('../src/agent/runtime/opencode-acp-runtime.js') +const { persistenceService } = await import('../src/agent/persistence.service.js') +import type { AgentCallbackMessage, UnifiedMessagePart } from '@coder/shared' + +const userId = 'suspend-e2e-' + Date.now() +const conversationId = 'suspend-conv-' + Date.now() +console.log(`[suspend-e2e] conv=${conversationId}\n`) + +// e2e 专用目录（不会被真的用，AskUser 才是主线） +const WORKDIR = '/tmp/opencode-suspend-e2e-' + Date.now() +fs.mkdirSync(WORKDIR, { recursive: true }) + +const events: AgentCallbackMessage[] = [] +const cb = async (msg: AgentCallbackMessage) => { + events.push(msg) + if (msg.type === 'tool_use') console.log(`\n[tool_use] ${msg.name}`) + else if (msg.type === 'ask_user') console.log(`[ask_user]`) + else if (msg.type === 'text' && msg.content) process.stdout.write(msg.content) + else if (msg.type === 'tool_result') console.log(`[tool_result] is_error=${msg.is_error}`) + else if (msg.type === 'result') console.log(`\n[result]`) +} + +console.log('[suspend-e2e] === Round 1: LLM 调 AskUserQuestion ===') +const { turnId } = await opencodeAcpRuntime.chatStream( + `请使用 AskUserQuestion 工具问我：Framework，question="Which framework?"，options=[{label:"React", description:"..."},{label:"Vue", description:"..."}]，multiSelect=false。必须用这个工具。`, + cb, + { + conversationId, + envId, + userId, + cwd: WORKDIR, + model: 'moonshot/kimi-k2-0905-preview', + }, +) +console.log(`[suspend-e2e] turnId=${turnId}`) + +// 等 ask_user 事件 +console.log('[suspend-e2e] waiting for ask_user event ...') +let askEvent: AgentCallbackMessage | undefined +const askTimeout = Date.now() + 60_000 +while (Date.now() < askTimeout) { + askEvent = events.find((e) => e.type === 'ask_user') + if (askEvent) break + if (events.find((e) => e.type === 'result' || e.type === 'error')) { + console.error('[suspend-e2e] FAIL: got result/error before ask_user') + server.close() + process.exit(1) + } + await new Promise((r) => setTimeout(r, 200)) +} +if (!askEvent) { + console.error('[suspend-e2e] FAIL: no ask_user within 60s') + server.close() + process.exit(1) +} + +// 稍等让 flushToDb 完成 +await new Promise((r) => setTimeout(r, 2000)) + +// ── ★ 关键检查：挂起期间读 DB ── +console.log('\n[suspend-e2e] === 挂起期间读 DB ===') +const midRecords = await persistenceService.loadDBMessages(conversationId, envId, userId, 20) +console.log(`[suspend-e2e] mid records count: ${midRecords.length}`) +for (const r of midRecords) { + console.log( + ` - ${r.role} status=${r.status} parts=${r.parts.length} [${r.parts.map((p: UnifiedMessagePart) => `${p.contentType}(${(p.metadata?.status as string | undefined) ?? '-'})`).join(', ')}]`, + ) +} + +const midAssistant = midRecords.find((r) => r.role === 'assistant') +const midHasPendingStatus = midAssistant?.status === 'pending' +const midHasToolCall = midAssistant?.parts.some((p: UnifiedMessagePart) => p.contentType === 'tool_call') +const midHasToolResult = midAssistant?.parts.some((p: UnifiedMessagePart) => p.contentType === 'tool_result') +// 挂起时不应该有 tool_result +const midCorrect = midHasPendingStatus && midHasToolCall && !midHasToolResult + +console.log(`\n[suspend-e2e] 挂起期间断言：`) +console.log(` assistant.status == 'pending': ${midHasPendingStatus ? 'PASS' : 'FAIL'} (${midAssistant?.status})`) +console.log(` parts 含 tool_call: ${midHasToolCall ? 'PASS' : 'FAIL'}`) +console.log(` parts 尚无 tool_result: ${!midHasToolResult ? 'PASS' : 'FAIL'}`) +if (!midCorrect) { + console.error('\n[suspend-e2e] 挂起态不对，放弃') + server.close() + process.exit(1) +} + +// ── Round 2: 模拟用户答复 ── +console.log('\n[suspend-e2e] === Round 2: user answers ===') +const questions = (askEvent.input as { questions: Array<{ header: string; options: Array<{ label: string }> }> }).questions +const firstHeader = questions[0].header +const chosen = questions[0].options[0].label +console.log(`[suspend-e2e] answer: ${firstHeader}="${chosen}"`) + +await opencodeAcpRuntime.chatStream('', cb, { + conversationId, + envId, + userId, + cwd: WORKDIR, + model: 'moonshot/kimi-k2-0905-preview', + askAnswers: { + [askEvent.id!]: { + toolCallId: askEvent.id!, + answers: { [firstHeader]: chosen }, + }, + }, +}) + +// 等最终 result +const finalTimeout = Date.now() + 120_000 +while (Date.now() < finalTimeout) { + // 这里 events 已累积所有，但 result 可能还没到 + const r = events.filter((e) => e.type === 'result') + // 第一轮 ask_user 之前无 result；第二轮恢复后会有 result + if (r.length > 0) break + if (events.find((e) => e.type === 'error')) break + await new Promise((r) => setTimeout(r, 300)) +} + +// 让 finalize 落库 +await new Promise((r) => setTimeout(r, 3000)) + +// ── 最终读 DB ── +console.log('\n[suspend-e2e] === 最终读 DB ===') +const finalRecords = await persistenceService.loadDBMessages(conversationId, envId, userId, 20) +console.log(`[suspend-e2e] final records count: ${finalRecords.length}`) +for (const r of finalRecords) { + console.log( + ` - ${r.role} status=${r.status} parts=${r.parts.length} [${r.parts.map((p: UnifiedMessagePart) => `${p.contentType}(${(p.metadata?.status as string | undefined) ?? '-'})`).join(', ')}]`, + ) +} + +const finalAssistant = finalRecords.find((r) => r.role === 'assistant') +const finalDone = finalAssistant?.status === 'done' +const finalHasToolCall = finalAssistant?.parts.some((p: UnifiedMessagePart) => p.contentType === 'tool_call') +const finalHasToolResult = finalAssistant?.parts.some((p: UnifiedMessagePart) => p.contentType === 'tool_result') +const finalToolCompleted = finalAssistant?.parts.some( + (p: UnifiedMessagePart) => p.contentType === 'tool_call' && p.metadata?.status === 'completed', +) + +console.log(`\n[suspend-e2e] 最终断言：`) +console.log(` assistant.status == 'done': ${finalDone ? 'PASS' : 'FAIL'} (${finalAssistant?.status})`) +console.log(` parts 含 tool_call: ${finalHasToolCall ? 'PASS' : 'FAIL'}`) +console.log(` parts 含 tool_result: ${finalHasToolResult ? 'PASS' : 'FAIL'}`) +console.log(` tool_call.metadata.status=completed:${finalToolCompleted ? 'PASS' : 'FAIL'}`) + +// cleanup +try { + await persistenceService.deleteConversationMessages(conversationId, envId, userId) +} catch { + /* noop */ +} + +const overall = midCorrect && finalDone && finalHasToolCall && finalHasToolResult && finalToolCompleted +console.log(`\n[suspend-e2e] OVERALL: ${overall ? 'PASS' : 'FAIL'}`) + +server.close() +process.exit(overall ? 0 : 1) diff --git a/packages/server/scripts/test-runtime-selector.mts b/packages/server/scripts/test-runtime-selector.mts new file mode 100644 index 0000000..8fa087b --- /dev/null +++ b/packages/server/scripts/test-runtime-selector.mts @@ -0,0 +1,150 @@ +#!/usr/bin/env tsx +/** + * Runtime 选择器端到端测试 + * + * 验证： + * 1. GET /api/agent/runtimes 返回正确的 runtime 列表 + * 2. POST /api/tasks 能保存 selectedRuntime 字段 + * 3. 前端选 opencode-acp → session/prompt 真的路由给 OpencodeAcpRuntime + * 4. 前端选 tencent-sdk → session/prompt 路由给 TencentSdkRuntime（现状默认行为） + * + * 不依赖真实 LLM —— 只验证路由层，不等 agent 跑完。 + * + * 用法： + * npx tsx --env-file=.env scripts/test-runtime-selector.mts + */ + +import 'dotenv/config' +import { Hono } from 'hono' +import { serve } from '@hono/node-server' +import fs from 'node:fs' + +const app = new Hono() + +// 挂载 acp 路由和 tasks 路由 +const { default: acpRoutes } = await import('../src/routes/acp.js') +const { default: tasksRouter } = await import('../src/routes/tasks.js') +const { getDb } = await import('../src/db/index.js') +const { agentRuntimeRegistry } = await import('../src/agent/runtime/index.js') + +// 绑定 mock auth middleware（让 tasks + internal 路由可访问） +app.use('*', async (c, next) => { + c.set('session', { + created: Date.now(), + authProvider: 'api-key', + user: { id: 'selector-test-user', username: 'test', email: 'test@test.local', avatar: '' }, + }) + c.set('apiKeyScopes', ['acp']) + c.set('userEnv', { + envId: process.env.TCB_ENV_ID || '', + userId: 'selector-test-user', + credentials: { secretId: process.env.TCB_SECRET_ID || '', secretKey: process.env.TCB_SECRET_KEY || '' }, + }) + await next() +}) + +app.route('/api/agent', acpRoutes) +app.route('/api/tasks', tasksRouter) + +const server = serve({ fetch: app.fetch, port: 0, hostname: '127.0.0.1' }, (info) => { + process.env.ASK_USER_BASE_URL = `http://127.0.0.1:${info.port}` + console.log(`[selector-test] server on :${info.port}`) +}) +await new Promise((r) => setTimeout(r, 400)) + +const port = (server.address() as { port: number }).port +const BASE = `http://127.0.0.1:${port}` + +let passed = 0 +let failed = 0 +function assert(cond: unknown, label: string) { + if (cond) { + console.log(` ✓ ${label}`) + passed++ + } else { + console.error(` ✗ ${label}`) + failed++ + } +} + +// ── 1. GET /api/agent/runtimes ──────────────────────────────────────────────── +console.log('\n[selector-test] === 1. GET /api/agent/runtimes ===') +const runtimes = await fetch(`${BASE}/api/agent/runtimes`).then((r) => r.json()) as { + default: string + runtimes: Array<{ name: string; available: boolean }> +} +console.log(' response:', JSON.stringify(runtimes)) +assert(runtimes.default === 'tencent-sdk', 'default runtime = tencent-sdk') +assert(Array.isArray(runtimes.runtimes), 'runtimes is array') +assert(runtimes.runtimes.some((r) => r.name === 'tencent-sdk'), 'tencent-sdk listed') +assert(runtimes.runtimes.some((r) => r.name === 'opencode-acp'), 'opencode-acp listed') + +// ── 2. POST /api/tasks (不含 selectedRuntime) ───────────────────────────────── +console.log('\n[selector-test] === 2. POST /api/tasks without runtime ===') +const userId = 'selector-test-user' +const taskId1 = 'selector-task-' + Date.now() +const res1 = await fetch(`${BASE}/api/tasks`, { + method: 'POST', + headers: { 'Content-Type': 'application/json' }, + body: JSON.stringify({ + id: taskId1, + prompt: 'test task no runtime', + }), +}) +assert(res1.ok, `POST /api/tasks (no runtime) ok=${res1.status}`) +const task1 = await getDb().tasks.findById(taskId1) +assert(task1?.selectedRuntime === null, `task.selectedRuntime = null (no selection)`) + +// ── 3. POST /api/tasks with selectedRuntime = 'opencode-acp' ───────────────── +console.log('\n[selector-test] === 3. POST /api/tasks with runtime=opencode-acp ===') +const taskId2 = 'selector-task-oc-' + Date.now() +const res2 = await fetch(`${BASE}/api/tasks`, { + method: 'POST', + headers: { 'Content-Type': 'application/json' }, + body: JSON.stringify({ + id: taskId2, + prompt: 'test task opencode', + selectedRuntime: 'opencode-acp', + }), +}) +assert(res2.ok, `POST /api/tasks (opencode-acp) ok=${res2.status}`) +const task2 = await getDb().tasks.findById(taskId2) +assert(task2?.selectedRuntime === 'opencode-acp', `task.selectedRuntime = 'opencode-acp' saved`) + +// ── 4. registry.resolve() 按 task.selectedRuntime 选 runtime ───────────────── +console.log('\n[selector-test] === 4. registry.resolve with task.selectedRuntime ===') +// 模拟 handleSessionPrompt 的逻辑 +const taskRuntime1 = task1?.selectedRuntime || undefined +const resolved1 = agentRuntimeRegistry.resolve({ explicitRuntime: taskRuntime1, conversationId: taskId1 }) +assert(resolved1.name === 'tencent-sdk', `task1 (no runtime) resolves to tencent-sdk (got ${resolved1.name})`) + +const taskRuntime2 = task2?.selectedRuntime || undefined +const resolved2 = agentRuntimeRegistry.resolve({ explicitRuntime: taskRuntime2, conversationId: taskId2 }) +assert(resolved2.name === 'opencode-acp', `task2 (opencode-acp) resolves to opencode-acp (got ${resolved2.name})`) + +// ── 5. request params.runtime 优先级高于 task.selectedRuntime ────────────────── +console.log('\n[selector-test] === 5. params.runtime overrides task.selectedRuntime ===') +// task2 有 opencode-acp，但 params.runtime='tencent-sdk' 应覆盖 +const resolved3 = agentRuntimeRegistry.resolve({ + explicitRuntime: 'tencent-sdk', // request param 级别 + conversationId: taskId2, +}) +assert(resolved3.name === 'tencent-sdk', `params.runtime='tencent-sdk' overrides task's opencode-acp (got ${resolved3.name})`) + +// ── 清理 ───────────────────────────────────────────────────────────────────── +try { + const envId = process.env.TCB_ENV_ID || '' + if (envId && getDb().tasks.delete) { + await getDb().tasks.delete(taskId1) + await getDb().tasks.delete(taskId2) + } +} catch { + /* noop */ +} + +// ── 结果 ───────────────────────────────────────────────────────────────────── +console.log(`\n[selector-test] ${passed} passed, ${failed} failed`) +console.log(`[selector-test] OVERALL: ${failed === 0 ? 'PASS' : 'FAIL'}`) + +server.close() +process.exit(failed === 0 ? 0 : 1) diff --git a/packages/server/scripts/test-tool-confirm-e2e.mts b/packages/server/scripts/test-tool-confirm-e2e.mts new file mode 100644 index 0000000..2dc378c --- /dev/null +++ b/packages/server/scripts/test-tool-confirm-e2e.mts @@ -0,0 +1,267 @@ +#!/usr/bin/env tsx +/** + * ToolConfirm 端到端测试（OpenCode runtime） + * + * 验证路径： + * 1. 配置 `permission.edit: 'ask'` 让 write 工具触发 requestPermission + * 2. 第一次 chatStream（不带 toolConfirmation） + * → 收到 tool_confirm 事件（agent 挂起） + * 3. 第二次 chatStream（携带 toolConfirmation，模拟用户 allow） + * → pending 被 resolve + * → opencode 继续执行 write + * → 收到 tool_result 事件 + * → 收到 result 事件（整轮结束） + * + * 关键断言： + * A. 第一轮先收 tool_confirm，再（一段时间后还没）收到 result → 证实挂起 + * B. 第二轮发出后 1-2s 内收到 tool_result → 证实 pending 被唤醒 + * C. 最终文件真的被写入（证明 allow 走到底） + * + * 用法（不需要沙箱，纯本地即可）： + * npx tsx scripts/test-tool-confirm-e2e.mts + */ + +import fs from 'node:fs' +import path from 'node:path' +import os from 'node:os' + +// 在 runtime 导入前设置：防止 installer 自动安装 custom tools 覆盖 builtin。 +// 本 e2e 要测试 builtin write 的 permission 流程（custom tools 有独立代码路径不走 permission） +process.env.OPENCODE_SKIP_TOOLS_INSTALL = '1' + +import { opencodeAcpRuntime } from '../src/agent/runtime/opencode-acp-runtime.js' +import type { AgentCallbackMessage } from '@coder/shared' + +// ── Setup：临时改全局 opencode.json 加 permission，测试结束恢复 ─────────────── +const OC_CONFIG_PATH = path.join(os.homedir(), '.config', 'opencode', 'opencode.json') +const OC_CONFIG_BACKUP = OC_CONFIG_PATH + '.bak-tc-e2e-' + Date.now() +const OC_TOOLS_DIR = path.join(os.homedir(), '.config', 'opencode', 'tools') +const OC_TOOLS_BACKUP = OC_TOOLS_DIR + '.bak-tc-e2e-' + Date.now() + +let originalConfigExists = false +if (fs.existsSync(OC_CONFIG_PATH)) { + fs.copyFileSync(OC_CONFIG_PATH, OC_CONFIG_BACKUP) + originalConfigExists = true +} + +// 读原配置合并 permission +let baseConfig: Record<string, unknown> = {} +try { + baseConfig = JSON.parse(fs.readFileSync(OC_CONFIG_PATH, 'utf8')) as Record<string, unknown> +} catch { + /* noop */ +} + +const patchedConfig = { + ...baseConfig, + permission: { + ...(baseConfig.permission as Record<string, unknown> | undefined), + edit: 'ask', + }, +} +fs.writeFileSync(OC_CONFIG_PATH, JSON.stringify(patchedConfig, null, 2)) + +// 关键：暂时移除 custom tools 目录，让 builtin write 接受 permission 流程 +// 自定义 tools 有独立代码路径，不走 opencode 的 permission 系统 +let originalToolsExists = false +if (fs.existsSync(OC_TOOLS_DIR)) { + fs.renameSync(OC_TOOLS_DIR, OC_TOOLS_BACKUP) + originalToolsExists = true +} + +function restoreConfig() { + try { + if (originalConfigExists) { + fs.copyFileSync(OC_CONFIG_BACKUP, OC_CONFIG_PATH) + fs.unlinkSync(OC_CONFIG_BACKUP) + } else { + fs.unlinkSync(OC_CONFIG_PATH) + } + } catch (e) { + console.error('[tc-e2e] restore opencode.json error:', e) + } + try { + if (originalToolsExists) { + if (fs.existsSync(OC_TOOLS_DIR)) { + fs.rmSync(OC_TOOLS_DIR, { recursive: true, force: true }) + } + fs.renameSync(OC_TOOLS_BACKUP, OC_TOOLS_DIR) + } + } catch (e) { + console.error('[tc-e2e] restore tools dir error:', e) + } +} + +process.on('exit', restoreConfig) +process.on('SIGINT', () => { + restoreConfig() + process.exit(130) +}) + +// ── Test workdir ───────────────────────────────────────────────────────────── +const WORKDIR = '/tmp/opencode-toolconfirm-e2e' +fs.rmSync(WORKDIR, { recursive: true, force: true }) +fs.mkdirSync(WORKDIR, { recursive: true }) +const targetFile = path.join(WORKDIR, 'hello.txt') + +// ── Event recorder ─────────────────────────────────────────────────────────── +interface Evt { + ts: number + type: string + name?: string + id?: string + content?: string + input?: unknown +} +const events: Evt[] = [] + +const startT0 = Date.now() +function recordCb(msg: AgentCallbackMessage) { + events.push({ + ts: Date.now() - startT0, + type: msg.type, + name: msg.name, + id: msg.id, + content: typeof msg.content === 'string' ? msg.content.slice(0, 120) : undefined, + input: msg.input, + }) + if (msg.type === 'tool_confirm') { + console.log( + `\n[+${Date.now() - startT0}ms] tool_confirm id=${msg.id} name=${msg.name} input=${JSON.stringify(msg.input).slice(0, 150)}`, + ) + } else if (msg.type === 'tool_use') { + console.log(`[+${Date.now() - startT0}ms] tool_use id=${msg.id} name=${msg.name}`) + } else if (msg.type === 'tool_result') { + console.log( + `[+${Date.now() - startT0}ms] tool_result id=${msg.tool_use_id} is_error=${msg.is_error} out=${(msg.content || '').slice(0, 120)}`, + ) + } else if (msg.type === 'result') { + console.log(`[+${Date.now() - startT0}ms] result: ${msg.content}`) + } else if (msg.type === 'error') { + console.log(`[+${Date.now() - startT0}ms] error: ${msg.content}`) + } else if (msg.type === 'text' && msg.content) { + process.stdout.write(msg.content) + } +} + +// ── Round 1: initial prompt ────────────────────────────────────────────────── +const conversationId = 'tc-e2e-' + Date.now() +console.log(`[tc-e2e] conversationId=${conversationId}`) +console.log(`[tc-e2e] targetFile=${targetFile}`) + +console.log('\n[tc-e2e] === Round 1: initial chatStream ===') +const r1 = await opencodeAcpRuntime.chatStream( + `请用 write 工具在当前目录创建文件 hello.txt，内容正好是一行：hi from tc e2e\n不要加其他内容，写完后告诉我已完成。`, + recordCb, + { + conversationId, + envId: '', // 本地模式 + userId: 'tc-e2e-user', + cwd: WORKDIR, + model: 'moonshot/kimi-k2-0905-preview', + }, +) +console.log(`[tc-e2e] round1 returned: turnId=${r1.turnId} alreadyRunning=${r1.alreadyRunning}`) + +// 等 tool_confirm 事件出现（或超时） +console.log('[tc-e2e] waiting for tool_confirm ...') +const confirmTimeout = Date.now() + 60_000 +let confirmEvent: Evt | undefined +while (Date.now() < confirmTimeout) { + confirmEvent = events.find((e) => e.type === 'tool_confirm') + if (confirmEvent) break + // early exit：如果直接收到 result 或 error，说明没触发权限请求（可能配置没生效） + if (events.find((e) => e.type === 'result' || e.type === 'error')) { + console.error('[tc-e2e] UNEXPECTED: round1 finished without tool_confirm. Config might not take effect.') + console.log('[tc-e2e] events so far:', JSON.stringify(events, null, 2)) + process.exit(1) + } + await new Promise((r) => setTimeout(r, 200)) +} + +if (!confirmEvent) { + console.error('[tc-e2e] FAIL: no tool_confirm within 60s') + console.log(events.map((e) => `${e.ts}ms ${e.type}`).join('\n')) + process.exit(1) +} + +console.log( + `\n[tc-e2e] ✓ Received tool_confirm at +${confirmEvent.ts}ms (interruptId=${confirmEvent.id})`, +) + +// 确认收到 tool_confirm 后，一段时间（3s）不应该再收到 result（说明真挂起了） +const roundAT = confirmEvent.ts +await new Promise((r) => setTimeout(r, 3000)) +const resultAfterConfirm = events.find((e) => e.type === 'result' && e.ts > roundAT) +if (resultAfterConfirm) { + console.error('[tc-e2e] FAIL: got "result" within 3s after tool_confirm — agent did not suspend') + process.exit(1) +} +console.log('[tc-e2e] ✓ Agent appears suspended (no result in 3s after tool_confirm)') + +// ── Round 2: resume with toolConfirmation ───────────────────────────────────── +console.log('\n[tc-e2e] === Round 2: resume with toolConfirmation (allow) ===') +const resumeT0 = Date.now() - startT0 + +const r2 = await opencodeAcpRuntime.chatStream('', recordCb, { + conversationId, + envId: '', + userId: 'tc-e2e-user', + cwd: WORKDIR, + model: 'moonshot/kimi-k2-0905-preview', + toolConfirmation: { + interruptId: confirmEvent.id!, + payload: { action: 'allow' }, + }, +}) +console.log(`[tc-e2e] round2 returned: turnId=${r2.turnId} alreadyRunning=${r2.alreadyRunning}`) + +// 预期 alreadyRunning === true（同一个 agent） +if (!r2.alreadyRunning) { + console.error('[tc-e2e] FAIL: round2 alreadyRunning=false (expected true for resume path)') + process.exit(1) +} +console.log('[tc-e2e] ✓ round2 resume path (alreadyRunning=true)') + +// 等 tool_result + result 出现 +console.log('[tc-e2e] waiting for tool_result + result after resume ...') +const finalTimeout = Date.now() + 90_000 +while (Date.now() < finalTimeout) { + if (events.find((e) => e.type === 'result' || e.type === 'error')) break + await new Promise((r) => setTimeout(r, 200)) +} + +// ── Validation ──────────────────────────────────────────────────────────────── +console.log('\n\n[tc-e2e] === validation ===') +const counts: Record<string, number> = {} +for (const e of events) counts[e.type] = (counts[e.type] ?? 0) + 1 +console.log('[tc-e2e] event counts:', JSON.stringify(counts, null, 2)) + +const toolResults = events.filter((e) => e.type === 'tool_result') +const resumedToolResult = toolResults.find((e) => e.ts > resumeT0) +const finalResult = events.find((e) => e.type === 'result') +const errorEv = events.find((e) => e.type === 'error') + +// 文件检查 +let fileOk = false +try { + const content = fs.readFileSync(targetFile, 'utf8') + fileOk = content.includes('hi from tc e2e') + console.log(`[tc-e2e] file content = ${JSON.stringify(content)}`) +} catch (e) { + console.log(`[tc-e2e] file missing: ${(e as Error).message}`) +} + +console.log('\n[tc-e2e] assertions:') +console.log(` tool_confirm received: ${confirmEvent ? 'PASS' : 'FAIL'}`) +console.log(` agent suspended after it: PASS (no 'result' for 3s)`) +console.log(` round2 took resume path: PASS (alreadyRunning=true)`) +console.log(` tool_result after resume: ${resumedToolResult ? 'PASS' : 'FAIL'}`) +console.log(` final result event: ${finalResult ? 'PASS' : 'FAIL'}`) +console.log(` no error event: ${errorEv ? 'FAIL (err=' + errorEv.content + ')' : 'PASS'}`) +console.log(` file has expected content: ${fileOk ? 'PASS' : 'FAIL'}`) + +const overall = !!confirmEvent && !!resumedToolResult && !!finalResult && !errorEv && fileOk +console.log(`\n[tc-e2e] OVERALL: ${overall ? 'PASS' : 'FAIL'}`) + +process.exit(overall ? 0 : 1) diff --git a/packages/server/src/agent/cloudbase-agent.service.ts b/packages/server/src/agent/cloudbase-agent.service.ts index b719e42..6978746 100644 --- a/packages/server/src/agent/cloudbase-agent.service.ts +++ b/packages/server/src/agent/cloudbase-agent.service.ts @@ -17,7 +17,6 @@ import { archiveToGit } from '../sandbox/git-archive.js' import { getCodingSystemPrompt } from './coding-mode.js' import { getDb } from '../db/index.js' import { resolveSandboxConfig, backfillSandboxConfig } from '../lib/sandbox-config.js' -import { nanoid } from 'nanoid' import { decrypt } from '../lib/crypto.js' import { encryptJWE } from '../lib/session.js' import type { AgentCallbackMessage, AgentOptions, CodeBuddyMessage, ExtendedSessionUpdate } from '@coder/shared' @@ -31,8 +30,6 @@ const DEFAULT_MODEL = 'glm-5.1' const OAUTH_TOKEN_ENDPOINT = 'https://copilot.tencent.com/oauth2/token' const CONNECT_TIMEOUT_MS = 60_000 const ITERATION_TIMEOUT_MS = 2 * 60 * 1000 -const HEALTH_MAX_RETRIES = 20 -const HEALTH_INTERVAL_MS = 2000 // ─── Supported Models Cache ─────────────────────────────────────────────── @@ -52,13 +49,13 @@ let cachedModels: ModelInfo[] | null = null // Static model list (temporary, replace with dynamic fetch when ready) const STATIC_MODELS: ModelInfo[] = [ - { id: 'minimax-m2.7', name: 'MiniMax-M2.7' }, - { id: 'minimax-m2.5', name: 'MiniMax-M2.5' }, + { id: 'glm-5.1', name: 'GLM-5.1' }, + { id: 'glm-5.0', name: 'GLM-5.0' }, { id: 'kimi-k2.6', name: 'Kimi-K2.6' }, { id: 'kimi-k2.5', name: 'Kimi-K2.5' }, { id: 'kimi-k2-thinking', name: 'Kimi-K2-Thinking' }, - { id: 'glm-5.1', name: 'GLM-5.1' }, - { id: 'glm-5.0', name: 'GLM-5.0' }, + { id: 'minimax-m2.7', name: 'MiniMax-M2.7' }, + { id: 'minimax-m2.5', name: 'MiniMax-M2.5' }, { id: 'deepseek-v3-2-volc', name: 'DeepSeek-V3.2' }, ] @@ -89,133 +86,16 @@ export async function getSupportedModels(): Promise<ModelInfo[]> { return cachedModels } -// ─── Sandbox Helpers ────────────────────────────────────────────────────── - -/** - * 等待沙箱健康检查就绪（轮询 /health） - */ -async function waitForSandboxHealth( - sandbox: SandboxInstance, - _callback: AgentCallback, - onProgress?: SandboxProgressCallback, -): Promise<boolean> { - onProgress?.({ phase: 'wait_ready', message: '等待沙箱就绪...\n' }) - for (let i = 0; i < HEALTH_MAX_RETRIES; i++) { - try { - const res = await sandbox.request('/health', { - signal: AbortSignal.timeout(4000), - }) - if (res.ok) { - console.log('[Agent] Sandbox health check passed') - return true - } - } catch { - // 继续轮询 - } - await new Promise((r) => setTimeout(r, HEALTH_INTERVAL_MS)) - } - return false -} - -/** - * 初始化沙箱工作空间：POST /api/session/init 注入凭证和环境变量 - * 然后创建会话工作目录 - * 返回容器内的工作目录路径（可能为 undefined） - */ -async function initSandboxWorkspace( - sandbox: SandboxInstance, - secret: { envId: string; secretId: string; secretKey: string; token?: string }, - conversationId: string, - preferredCwd?: string, - onProgress?: SandboxProgressCallback, -): Promise<{ workspace: string; vitePort?: number }> { - const fallbackWorkspace = preferredCwd || `/tmp/workspace/${secret.envId}/${conversationId}` - - onProgress?.({ phase: 'init_mcp', message: '初始化工作空间...\n' }) - - // Fire session/init in background — injects credentials into the sandbox session. - // The actual workspace + vite initialisation is triggered lazily by /api/scope/info - // with X-Scope-Template: coding, but we still need credential injection first. - sandbox - .request('/api/session/init', { - method: 'POST', - headers: { 'Content-Type': 'application/json' }, - body: JSON.stringify({ - env: { - CLOUDBASE_ENV_ID: secret.envId, - TENCENTCLOUD_SECRETID: secret.secretId, - TENCENTCLOUD_SECRETKEY: secret.secretKey, - ...(secret.token ? { TENCENTCLOUD_SESSIONTOKEN: secret.token } : {}), - }, - }), - signal: AbortSignal.timeout(300_000), - }) - .then((res) => { - if (res.ok) { - console.log('[Agent] session/init completed successfully') - } else { - console.warn('[Agent] session/init returned status:', res.status) - } - }) - .catch((e) => { - console.warn('[Agent] session/init background error:', (e as Error).message) - }) - - // Poll /api/scope/info to get the workspace path (and vitePort if coding mode). - // Scope headers (X-Scope-Id, X-Scope-Template) are injected automatically by sandbox.request(). - // The first request with X-Scope-Template: coding triggers template init + vite dev server. - const maxWaitMs = 120_000 - const pollInterval = 2000 - const startTime = Date.now() - - while (Date.now() - startTime < maxWaitMs) { - try { - const res = await sandbox.request('/api/scope/info', { - signal: AbortSignal.timeout(10_000), - }) - if (res.ok) { - const data = (await res.json()) as { - success?: boolean - workspace?: string - vitePort?: number | null - } - if (data.success && data.workspace) { - console.log( - `[Agent] initSandboxWorkspace ready via scope/info, workspace: ${data.workspace}, vitePort: ${data.vitePort}`, - ) - onProgress?.({ phase: 'ready', message: '沙箱已就绪\n' }) - return { workspace: data.workspace, vitePort: data.vitePort ?? undefined } - } - } - } catch { - // scope/info not available yet, sandbox may still be starting - } - await new Promise((r) => setTimeout(r, pollInterval)) - } - - // Timeout fallback: return the computed workspace path so the agent can continue - console.warn(`[Agent] initSandboxWorkspace timeout after ${maxWaitMs / 1000}s, returning fallback workspace`) - return { workspace: fallbackWorkspace } -} - -/** - * 需要用户确认的写操作 MCP 工具集合。 - * canUseTool 中对这些工具发起 interrupt，等待客户端确认后再执行。 - * 可通过 bypassToolConfirmation=true 跳过确认。 - */ -const WRITE_TOOLS = new Set([ - // 数据库写操作（4 个） - 'writeNoSqlDatabaseStructure', // 修改 NoSQL 数据库结构 - 'writeNoSqlDatabaseContent', // 修改 NoSQL 数据库内容 - 'executeWriteSQL', // 执行写入 SQL - 'modifyDataModel', // 修改数据模型 - - // 云函数写操作（4 个） - 'createFunction', // 创建云函数 - 'updateFunctionCode', // 更新云函数代码 - 'updateFunctionConfig', // 更新云函数配置 - 'invokeFunction', // 调用云函数 -]) +// ─── Sandbox & Prompt Helpers (imported from base-runtime) ─────────────── +// 集中在 base-runtime.ts 维护，所有 runtime 共用。 +import { + waitForSandboxHealth, + initSandboxWorkspace, + WRITE_TOOLS, + buildAppendPrompt, + getPublishableKey, + persistDeploymentFromArtifact, +} from './runtime/base-runtime.js' // ─── Types ───────────────────────────────────────────────────────────────── @@ -330,145 +210,6 @@ function getBundledSkillsDir(): string { return existsSync(prodPath) ? prodPath : devPath } -// ─── System Prompt Builder ───────────────────────────────────────────────── - -/** - * 获取 CloudBase 前端 SDK 的 publishableKey（公开密钥） - * 使用系统大密钥（TCB_SECRET_ID/TCB_SECRET_KEY）调用 tcb:CreateApiKey 获取 - * KeyType=publish_key 会返回已存在的 key 或创建新的 - * 结果按 envId 缓存，避免重复调用 - */ -const publishableKeyCache = new Map<string, string>() - -async function getPublishableKey(envId: string): Promise<string> { - if (publishableKeyCache.has(envId)) return publishableKeyCache.get(envId)! - - const secretId = process.env.TCB_SECRET_ID - const secretKey = process.env.TCB_SECRET_KEY - if (!secretId || !secretKey || !envId) return '' - try { - const CloudBase = (await import('@cloudbase/manager-node')).default - const manager = new CloudBase({ - secretId, - secretKey, - envId, - proxy: process.env.http_proxy, - }) - const result = await manager.commonService('tcb', '2018-06-08').call({ - Action: 'CreateApiKey', - Param: { EnvId: envId, KeyType: 'publish_key' }, - }) - const apiKey = result?.ApiKey || result?.Response?.ApiKey || '' - if (apiKey) { - publishableKeyCache.set(envId, apiKey) - console.log('[Agent] Got publishableKey for env:', envId) - } - return apiKey - } catch (e) { - console.warn('[Agent] Failed to get publishableKey:', (e as Error).message) - return '' - } -} - -function buildAppendPrompt( - sandboxCwd?: string, - conversationId?: string, - envId?: string, - sandboxMode?: 'shared' | 'isolated', - isCodingMode?: boolean, -): string { - // Coding mode already has getCodingSystemPrompt() which strongly anchors the - // assistant as "a coder working in a React/Vite project". We should NOT - // inject the "task classification" guideline in that case — it would create - // ambiguity (user is in a code project, they want a page, not text). - // - // Default mode is the opposite: the assistant is generic and the user may - // want pure conversation (文案/翻译/聊天). Without the classification - // guideline, the assistant tends to escalate every request into - // "write files and deploy", which was the bug reported by the user. - const roleLine = isCodingMode - ? '你是一个通用 AI 编程助手，同时具备腾讯云开发（CloudBase）能力。' - : '你是一个通用 AI 助手，同时具备腾讯云开发（CloudBase）能力，可按需通过工具操作云函数、数据库、存储、云托管等资源。' - - const taskClassificationSection = isCodingMode - ? '' - : ` -<task-classification priority="highest"> -收到任务后，先判断类型再决定是否使用工具： - -1) **对话/创作/咨询类**（写文案、写文章、翻译、起名、解释概念、讨论观点、情绪陪伴、海报/帖子**文本**、小红书/朋友圈文案、社交媒体内容等） - → 直接在对话中以**文本/Markdown**形式输出，**不要**写文件、不要部署、不要调用开发相关工具。 - → 即使用户说"帮我做一个 XX 应援贴/海报/宣传文案"，默认先理解为"输出文案"，除非用户明确要求"做一个页面/网站/应用"。 - → **例外**：如果用户明确说"生成一张图""帮我画一张 XX 图片""做一张海报图片"，使用 ImageGen 工具生成图片。 - -2) **编程/工程类**（修改代码、调试、构建应用、部署服务、配置云资源、运维操作） - → 使用工具完成任务：读文件、写文件、执行命令、部署、调用云开发 MCP 等。 - -3) **自动化/定时类**（"每天…"、"每周…"、"定期…"） - → 使用 cronTask 工具管理定时任务（见下面 cron-task 章节）。 - -**不确定时优先问用户**："你希望我直接写文案给你，还是做一个可访问的网页？"，不要擅自升级为 2)。 -</task-classification> -` - - const base = `<role> -${roleLine} -默认使用中文与用户沟通；删除等破坏性操作需确认用户意图。 -</role> -${taskClassificationSection} -<cloudbase-guideline> -- 当前云开发环境为 ${envId || '(未指定)'}，必要时可通过 cloudbase MCP 工具操作。 -- **仅当用户明确要求部署、开发应用、操作数据库、上传文件等**，才使用云开发工具。纯文案/咨询不涉及此。 -- 部署云函数使用 manageFunctions 工具；上传文件到静态托管使用 cloudbase_uploadFiles 工具。 -</cloudbase-guideline> - -<bash-usage> -对于耗时较长的命令（如 npm install、yarn install、大型项目构建等），如果执行超时： -1. 改为后台执行, 添加 run_in_background，可以获取 pid -2. 定期检查进程状态：ps aux | grep '<关键词>' | grep -v grep -3. 通过 BashOutput 结合 pid 查看输出结果 -4. 也可以通过 KillShell 关闭后台执行的任务 -</bash-usage> - -<cron-task-usage> -当用户提到定时执行、定期运行、每天/每周/每小时执行某操作等需求时，必须使用 cronTask 工具来管理定时任务。 -- 创建：action="create"，需要 name、prompt、cronExpression -- 查询：action="list"，查看当前所有定时任务 -- 更新：action="update"，通过 id 修改已有任务（可改 prompt、cronExpression、enabled 等） -- 删除：action="delete"，通过 id 删除任务 -Cron 表达式格式：分 时 日 月 周，例如 "0 20 * * *" 表示每天 20:00。 -</cron-task-usage> - -<tools-extra-info> -- **ImageGen** — AI 图片生成。Usage: 用户明确要求生成/绘制图片时（"帮我画一张…""生成一张…的图""做一张海报图片"）。生成的图片会同时保存到工作区和静态托管，返回可公开访问的 CDN 链接。 -- **ImageEdit** — AI 图片编辑。Usage: 用户提供一张已有图片，要求修改风格、添加元素、局部重绘等。 -</tools-extra-info>` - - if (sandboxCwd) { - const homeDir = sandboxMode === 'isolated' ? sandboxCwd : sandboxCwd.substring(0, sandboxCwd.lastIndexOf('/')) - // In default mode, gate the sandbox section with a reminder so pure - // chat/creation tasks don't drift into file-writing behavior. In coding - // mode the getCodingSystemPrompt already establishes the context so no - // gating is needed. - const sandboxPreamble = isCodingMode - ? '' - : '（以下仅在你已判定任务属于"编程/工程类"、决定动手写文件或执行命令时适用；对话/创作类任务请忽略本节。）\n' - return `${base} - -<sandbox-context> -${sandboxPreamble}工具默认在 Home: ${homeDir} 下执行 -为项目开辟工作目录为: ${sandboxCwd} -使用的云开发环境为: ${envId} -请注意： -- 所有文件读写、终端命令都应在工作目录中执行，注意 cd 到工作目录操作。 -- 使用 cloudbase_uploadFiles 部署文件时，localPath 必须是容器内的**绝对路径**（即当前工作目录 ${sandboxCwd} 下的路径），例如 ${sandboxCwd}/index.html -- 如用户没有特别要求，cloudPath 需要为 ${conversationId}，即在当前会话路径下 -- 不要使用相对路径给 cloudbase_uploadFiles -</sandbox-context>` - } - return base -} - // ─── CloudbaseAgentService ───────────────────────────────────────────────── export class CloudbaseAgentService { @@ -652,6 +393,7 @@ export class CloudbaseAgentService { model, mode, permissionMode: requestedPermissionMode, + imageBlocks, } = options const modelId = model || DEFAULT_MODEL const isCodingMode = mode === 'coding' @@ -837,7 +579,7 @@ export class CloudbaseAgentService { // 2. Persist deployment records (side-effect, fire-and-forget) if (msg.type === 'artifact' && msg.artifact) { - this.persistDeploymentFromArtifact(conversationId, msg.artifact).catch((err) => { + persistDeploymentFromArtifact(conversationId, msg.artifact).catch((err) => { console.error('Failed to persist deployment:', err) }) } @@ -929,7 +671,7 @@ export class CloudbaseAgentService { } // ── 健康检查：等待沙箱就绪 ────────────────────────────────── - const sandboxReady = await waitForSandboxHealth(sandboxInstance, wrappedCallback, sandboxProgressBridge) + const sandboxReady = await waitForSandboxHealth(sandboxInstance, sandboxProgressBridge) if (!sandboxReady) { wrappedCallback({ type: 'text', content: '沙箱启动超时，将使用受限模式继续对话。\n\n' }) sandboxInstance = null @@ -1191,6 +933,7 @@ export class CloudbaseAgentService { prevRecordId: lastRecordId, assistantRecordId: assistantMessageId, lastAssistantRecordId, + imageBlocks: imageBlocks?.length ? imageBlocks : undefined, }) preSavedUserRecordId = preSaved.userRecordId } @@ -1275,8 +1018,38 @@ export class CloudbaseAgentService { // 构建 query 参数 - 和 tcb-headless-service buildQueryOptions 一致 // 注意: cwd 必须是本地路径, 即使沙箱启用. 沙箱只提供 MCP 工具, agent 进程在本地运行. + + // 多模态 prompt：有图片时构建 ContentBlock[] 作为 UserMessage，否则直接用字符串 + let queryPrompt: string | any + if (imageBlocks && imageBlocks.length > 0) { + // SDK ImageContentBlock 格式: { type:'image', source:{ type:'base64', media_type, data } } + const contentBlocks: any[] = imageBlocks.map((img) => ({ + type: 'image', + source: { + type: 'base64', + media_type: img.mimeType as 'image/jpeg' | 'image/png' | 'image/gif' | 'image/webp', + data: img.data, + }, + })) + if (prompt.trim()) { + contentBlocks.push({ type: 'text', text: prompt }) + } + // Wrap as AsyncIterable<UserMessage> + const userMsg = { + type: 'user' as const, + session_id: conversationId, + message: { role: 'user' as const, content: contentBlocks }, + parent_tool_use_id: null, + } + queryPrompt = (async function* () { + yield userMsg + })() + } else { + queryPrompt = prompt + } + const queryArgs = { - prompt, + prompt: queryPrompt, options: { model: modelId, permissionMode: sdkPermissionMode, @@ -1802,114 +1575,6 @@ export class CloudbaseAgentService { } } - // ─── Deployment Persistence ──────────────────────────────────────── - - private async persistDeploymentFromArtifact( - taskId: string, - artifact: NonNullable<AgentCallbackMessage['artifact']>, - ): Promise<void> { - const now = Date.now() - const meta = artifact.metadata || {} - const deploymentType = (meta.deploymentType as string) || (artifact.contentType === 'link' ? 'web' : 'miniprogram') - const metadataJson = Object.keys(meta).length > 0 ? JSON.stringify(meta) : null - - if (deploymentType === 'miniprogram') { - const qrCodeUrl = artifact.contentType === 'image' ? artifact.data : (meta.qrCodeUrl as string) || null - const pagePath = (meta.pagePath as string) || null - const appId = (meta.appId as string) || null - const label = artifact.title || null - - const existing = await getDb().deployments.findByTaskIdAndTypePath(taskId, 'miniprogram', null) - - if (existing) { - await getDb().deployments.update(existing.id, { - qrCodeUrl: qrCodeUrl || existing.qrCodeUrl, - pagePath: pagePath || existing.pagePath, - appId: appId || existing.appId, - label: label || existing.label, - metadata: metadataJson || existing.metadata, - updatedAt: now, - }) - } else { - await getDb().deployments.create({ - id: nanoid(12), - taskId, - type: 'miniprogram', - url: null, - path: null, - qrCodeUrl, - pagePath, - appId, - label, - metadata: metadataJson, - createdAt: now, - updatedAt: now, - }) - } - } else if (artifact.contentType === 'link' && artifact.data) { - const url = artifact.data - let urlPath: string | null = null - try { - const urlObj = new URL(url) - // Normalize path: strip trailing index.html and trailing slash for dedup - urlPath = urlObj.pathname.replace(/\/index\.html$/, '/').replace(/\/+$/, '') || '/' - } catch { - /* ignore */ - } - - if (urlPath) { - const existing = await getDb().deployments.findByTaskIdAndTypePath(taskId, 'web', urlPath) - - if (existing) { - await getDb().deployments.update(existing.id, { - url, - label: artifact.title || existing.label, - metadata: metadataJson || existing.metadata, - updatedAt: now, - }) - } else { - await getDb().deployments.create({ - id: nanoid(12), - taskId, - type: 'web', - url, - path: urlPath, - qrCodeUrl: null, - pagePath: null, - appId: null, - label: artifact.title || null, - metadata: metadataJson, - createdAt: now, - updatedAt: now, - }) - } - } - - // Also update legacy previewUrl for backward compatibility - try { - await getDb().tasks.update(taskId, { previewUrl: url }) - } catch { - // Non-critical - } - } else { - // Other artifact types (json, image without miniprogram context, etc.) - await getDb().deployments.create({ - id: nanoid(12), - taskId, - type: deploymentType as 'web' | 'miniprogram', - url: artifact.contentType === 'link' ? artifact.data : null, - path: null, - qrCodeUrl: artifact.contentType === 'image' ? artifact.data : null, - pagePath: null, - appId: null, - label: artifact.title || null, - metadata: metadataJson, - createdAt: now, - updatedAt: now, - }) - } - } - // ─── Stream Event Handlers ────────────────────────────────────────── private handleStreamEvent( @@ -2038,12 +1703,6 @@ export class CloudbaseAgentService { ? block.content : null - // 检测 uploadFiles 结果，提取 CloudBase 部署 URL - this.tryExtractDeployUrl(block.tool_use_id, rawText, tracker, callback) - - // 检测 publishMiniprogram 结果，提取预览二维码 - this.tryExtractQrcode(block.tool_use_id, rawText, tracker, callback) - let processedContent = block.content if (Array.isArray(block.content) && block.content.length > 0) { const firstBlock = block.content[0] @@ -2068,150 +1727,6 @@ export class CloudbaseAgentService { } } - /** - * 尝试从 uploadFiles 工具结果中提取 CloudBase 静态托管部署 URL - * 结果包含 accessUrl 或 staticDomain 则触发 artifact callback - */ - private tryExtractDeployUrl( - toolUseId: string, - rawText: string | null, - tracker: ToolCallTracker, - callback: AgentCallback, - ): void { - const toolInfo = tracker.pendingToolCalls.get(toolUseId) - const toolName = toolInfo?.name || '' - if (!toolName.includes('uploadFiles') && !toolName.includes('cloudbase_uploadFiles')) return - if (!rawText) return - - try { - let localPath: string | undefined - const inputJson = tracker.toolInputJsonBuffers.get(toolUseId) - if (inputJson) { - try { - localPath = JSON.parse(inputJson)?.localPath - } catch { - /* ignore */ - } - } - if (!localPath) localPath = (toolInfo?.input as Record<string, unknown>)?.localPath as string | undefined - - const isFile = localPath ? /\.[a-zA-Z0-9]+$/.test(localPath.replace(/\/+$/, '').split('/').pop() || '') : false - const deployUrl = CloudbaseAgentService.extractDeployUrl(rawText, isFile) - if (deployUrl) { - callback({ - type: 'artifact', - artifact: { - title: 'Web 应用已部署', - contentType: 'link', - data: deployUrl, - metadata: { deploymentType: 'web' }, - }, - }) - } - } catch { - // 提取失败不影响主流程 - } - } - - /** - * 从 uploadFiles 工具结果 JSON 中递归提取 CloudBase 部署 URL - * 支持 accessUrl / staticDomain 字段，最多递归 5 层 - */ - private static extractDeployUrl(rawText: string, isFile = false, depth = 0): string | null { - if (depth > 5) return null - try { - const parsed = JSON.parse(rawText) - - if (Array.isArray(parsed)) { - const firstText = parsed[0]?.text - if (typeof firstText === 'string') { - return CloudbaseAgentService.extractDeployUrl(firstText, isFile, depth + 1) - } - return null - } - - if (typeof parsed !== 'object' || parsed === null) return null - - if (parsed.accessUrl) { - const url = new URL(parsed.accessUrl) - if (!isFile && url.pathname !== '/' && !url.pathname.endsWith('/')) { - url.pathname += '/' - } - if (!url.searchParams.get('t')) { - url.searchParams.set('t', String(Date.now())) - } - return url.toString() - } - if (parsed.staticDomain) return `https://${parsed.staticDomain}/?t=${Date.now()}` - - const innerText = parsed?.res?.content?.[0]?.text || parsed?.content?.[0]?.text - if (typeof innerText === 'string') { - return CloudbaseAgentService.extractDeployUrl(innerText, isFile, depth + 1) - } - } catch { - // JSON parse 失败，忽略 - } - return null - } - - /** - * 尝试从 publishMiniprogram 工具结果中提取小程序预览二维码 - * 成功则触发 artifact callback - */ - private tryExtractQrcode( - toolUseId: string, - rawText: string | null, - tracker: ToolCallTracker, - callback: AgentCallback, - ): void { - const toolInfo = tracker.pendingToolCalls.get(toolUseId) - const toolName = toolInfo?.name || '' - if (!toolName.includes('publishMiniprogram') && !toolName.includes('Miniprogram')) return - if (!rawText) return - - try { - let parsedResult: any = null - try { - parsedResult = JSON.parse(rawText) - } catch { - return - } - - const action = parsedResult?.action || (toolInfo?.input as any)?.action - - // 小程序预览二维码 - if (parsedResult?.result?.qrcode) { - const qrcode = `data:${parsedResult?.result?.qrcode?.mimeType || 'image/png'};base64,${parsedResult?.result?.qrcode?.base64}` - callback({ - type: 'artifact', - artifact: { - title: '小程序预览二维码', - description: '使用微信扫码预览小程序', - contentType: 'image', - data: qrcode, - metadata: parsedResult, - }, - }) - return - } - - // 上传成功但无二维码 - if (parsedResult?.success && action === 'upload') { - callback({ - type: 'artifact', - artifact: { - title: '小程序上传成功', - description: '代码已上传到微信后台，可前往微信公众平台提交审核', - contentType: 'json', - data: JSON.stringify(parsedResult), - }, - }) - } - } catch { - // 提取失败不影响主流程 - } - } - private handleToolNotFoundErrors(msg: any, tracker: ToolCallTracker, callback: AgentCallback): void { if (!msg.message?.content) return for (const block of msg.message.content) { diff --git a/packages/server/src/agent/coding-mode.ts b/packages/server/src/agent/coding-mode.ts index d726854..e01a212 100644 --- a/packages/server/src/agent/coding-mode.ts +++ b/packages/server/src/agent/coding-mode.ts @@ -40,9 +40,11 @@ export function getCodingSystemPrompt(envId: string, publishableKey: string): st <IMPORTANT> IMPORTANT: 必须先读取 src/utils/cloudbase.ts，将其中的 ENV_ID 和 PUBLISHABLE_KEY 替换为当前环境的真实值。 -IMPORTANT: 直接修改代码而非创建 .env 文件。 +IMPORTANT: 直接修改代码而非创建 .env 文件。有关登录态判断时使用 auth-web-cloudbase skill 使用 supabase-like 的 api。 - ENV_ID：${envId} - PUBLISHABLE_KEY：${publishableKey} +IMPORTANT: 注意数据库权限，默认 PUBLISHABLE_KEY 时是匿名身份，刚开始数据库最好公有读写，方便调试，后续完善。 +IMPORTANT: 页面需要做好 error 处理，显示出具体的错误堆栈信息，而非直接 crash。需要 toast 等方式显示而非 console 打印。 </IMPORTANT> <tech-stack> diff --git a/packages/server/src/agent/persistence.service.ts b/packages/server/src/agent/persistence.service.ts index 651a3fc..07b3165 100644 --- a/packages/server/src/agent/persistence.service.ts +++ b/packages/server/src/agent/persistence.service.ts @@ -507,6 +507,14 @@ export class PersistenceService { await collection.where({ recordId: _.eq(recordId) }).update({ parts, updateTime: Date.now() }) } + /** + * Public: 完全替换指定 record 的 parts 数组（用于非 Claude SDK runtime， + * 它们不写 JSONL，需要直接在内存累积 parts 后一次性写入 DB）。 + */ + async setRecordParts(recordId: string, parts: UnifiedMessagePart[]): Promise<void> { + await this.replacePartsInRecord(recordId, parts) + } + // ========== Message Grouping ========== private groupMessages(messages: CodeBuddyMessage[]): CodeBuddyMessage[][] { @@ -842,26 +850,32 @@ export class PersistenceService { assistantRecordId?: string /** 上一条 assistant record 的 recordId，用于写入 user message metadata 的 parentId */ lastAssistantRecordId?: string | null + /** 图片附件 — 保存到 user record parts，用于历史恢复和消息展示 */ + imageBlocks?: Array<{ data: string; mimeType: string }> }): Promise<{ userRecordId: string; assistantRecordId: string }> { - const { conversationId, envId, userId, prompt, prevRecordId } = params + const { conversationId, envId, userId, prompt, prevRecordId, imageBlocks } = params const assistantRecordId = params.assistantRecordId || uuidv4() const userRecordId = uuidv4() + // Pre-save: only store the text prompt as a pending placeholder. + // If images are present, we intentionally skip them here — syncMessages() + // will call replacePartsInRecord() with the real SDK JSONL data (which + // includes proper image_blob_ref blocks) once the agent completes. + const baseMetadata: Record<string, unknown> = { + id: userRecordId, + type: 'message', + role: 'user', + sessionId: conversationId, + timestamp: Date.now(), + ...(params.lastAssistantRecordId ? { parentId: params.lastAssistantRecordId } : {}), + } + const userParts: UnifiedMessagePart[] = [ { partId: uuidv4(), contentType: 'text', content: prompt, - metadata: { - id: userRecordId, - type: 'message', - role: 'user', - sessionId: conversationId, - timestamp: Date.now(), - // parentId: 指向上一条 assistant 消息，确保 JSONL 树的连续性 - // 即使 cancel 导致 SDK 没写真正的 JSONL，树也不会断裂 - ...(params.lastAssistantRecordId ? { parentId: params.lastAssistantRecordId } : {}), - }, + metadata: baseMetadata, }, ] diff --git a/packages/server/src/agent/runtime/__tests__/baseline.test.ts b/packages/server/src/agent/runtime/__tests__/baseline.test.ts new file mode 100644 index 0000000..bbcba5f --- /dev/null +++ b/packages/server/src/agent/runtime/__tests__/baseline.test.ts @@ -0,0 +1,9 @@ +// placeholder — 这个文件仅用于验证 vitest 配置正确 +// 真正的测试在 buildHistoryContextPrompt.test.ts 和 resolveOnPath.test.ts +import { describe, it, expect } from 'vitest' + +describe('vitest baseline', () => { + it('works', () => { + expect(1 + 1).toBe(2) + }) +}) diff --git a/packages/server/src/agent/runtime/__tests__/buildHistoryContextPrompt.test.ts b/packages/server/src/agent/runtime/__tests__/buildHistoryContextPrompt.test.ts new file mode 100644 index 0000000..a93f1a9 --- /dev/null +++ b/packages/server/src/agent/runtime/__tests__/buildHistoryContextPrompt.test.ts @@ -0,0 +1,234 @@ +/** + * 单元测试：buildHistoryContextPrompt + * + * 全部 mock persistenceService，不依赖 LLM / CloudBase / TCB。 + * 测试粒度：精确 toContain，不用 snapshot（snapshot 对换行太脆）。 + */ +import { describe, it, expect, vi, beforeEach } from 'vitest' + +// ─── Mock persistence service ─────────────────────────────────────────────── +vi.mock('../../persistence.service.js', () => ({ + persistenceService: { + loadDBMessages: vi.fn(), + }, +})) + +// 延迟 import，确保 mock 先就绪 +const { buildHistoryContextPrompt } = await import('../opencode-message-builder.js') +const { persistenceService } = await import('../../persistence.service.js') + +// ─── Helper types (mirror UnifiedMessageRecord subset) ─────────────────────── +function makeRecord( + recordId: string, + role: 'user' | 'assistant', + status: 'done' | 'pending' | 'error' | 'cancel', + parts: Array<{ contentType: string; content?: string; metadata?: Record<string, unknown>; toolCallId?: string }>, +) { + return { recordId, role, status, parts } +} + +function textPart(content: string) { + return { contentType: 'text', content } +} + +function reasoningPart(content: string) { + return { contentType: 'reasoning', content } +} + +function toolCallPart(toolName: string, input: Record<string, unknown>, toolCallId = 'tc-1') { + return { + contentType: 'tool_call', + content: JSON.stringify(input), + toolCallId, + metadata: { toolName, toolCallName: toolName, input }, + } +} + +function toolResultPart(toolName: string, output: string, status = 'completed', toolCallId = 'tc-1') { + return { + contentType: 'tool_result', + content: output, + toolCallId, + metadata: { toolName, status }, + } +} + +const CONV = 'conv-1' +const ENV = 'env-1' +const USER = 'user-1' +const PROMPT = 'What should I do next?' + +// ─── Tests ───────────────────────────────────────────────────────────────── + +describe('buildHistoryContextPrompt', () => { + beforeEach(() => { + vi.mocked(persistenceService.loadDBMessages).mockReset() + }) + + // ── no-op cases ────────────────────────────────────────────────────────── + + it('returns raw prompt when envId is empty', async () => { + const result = await buildHistoryContextPrompt(CONV, '', USER, PROMPT) + expect(result).toBe(PROMPT) + expect(persistenceService.loadDBMessages).not.toHaveBeenCalled() + }) + + it('returns raw prompt when conversationId is empty', async () => { + const result = await buildHistoryContextPrompt('', ENV, USER, PROMPT) + expect(result).toBe(PROMPT) + }) + + it('returns raw prompt when loadDBMessages returns empty array', async () => { + vi.mocked(persistenceService.loadDBMessages).mockResolvedValueOnce([]) + const result = await buildHistoryContextPrompt(CONV, ENV, USER, PROMPT) + expect(result).toBe(PROMPT) + }) + + it('returns raw prompt when all records are excluded', async () => { + vi.mocked(persistenceService.loadDBMessages).mockResolvedValueOnce([ + makeRecord('r1', 'user', 'done', [textPart('hello')]), + ]) + const result = await buildHistoryContextPrompt(CONV, ENV, USER, PROMPT, { + excludeRecordIds: new Set(['r1']), + }) + expect(result).toBe(PROMPT) + }) + + it('returns raw prompt when loadDBMessages throws', async () => { + vi.mocked(persistenceService.loadDBMessages).mockRejectedValueOnce(new Error('db error')) + const result = await buildHistoryContextPrompt(CONV, ENV, USER, PROMPT) + expect(result).toBe(PROMPT) + }) + + // ── format checks ───────────────────────────────────────────────────────── + + it('single turn: contains Turn 1 heading', async () => { + vi.mocked(persistenceService.loadDBMessages).mockResolvedValueOnce([ + makeRecord('r1', 'user', 'done', [textPart('hello')]), + makeRecord('r2', 'assistant', 'done', [textPart('hi there')]), + ]) + const result = await buildHistoryContextPrompt(CONV, ENV, USER, PROMPT) + expect(result).toContain('## Turn 1') + }) + + it('single turn: user text prefixed with **User:**', async () => { + vi.mocked(persistenceService.loadDBMessages).mockResolvedValueOnce([ + makeRecord('r1', 'user', 'done', [textPart('hello world')]), + ]) + const result = await buildHistoryContextPrompt(CONV, ENV, USER, PROMPT) + expect(result).toContain('**User:** hello world') + }) + + it('single turn: assistant text prefixed with **Assistant:**', async () => { + vi.mocked(persistenceService.loadDBMessages).mockResolvedValueOnce([ + makeRecord('r2', 'assistant', 'done', [textPart('reply text')]), + ]) + const result = await buildHistoryContextPrompt(CONV, ENV, USER, PROMPT) + expect(result).toContain('**Assistant:** reply text') + }) + + it('multiple turns: contains Turn 1 and Turn 2', async () => { + vi.mocked(persistenceService.loadDBMessages).mockResolvedValueOnce([ + makeRecord('r1', 'user', 'done', [textPart('first')]), + makeRecord('r2', 'assistant', 'done', [textPart('ok1')]), + makeRecord('r3', 'user', 'done', [textPart('second')]), + makeRecord('r4', 'assistant', 'done', [textPart('ok2')]), + ]) + const result = await buildHistoryContextPrompt(CONV, ENV, USER, PROMPT) + expect(result).toContain('## Turn 1') + expect(result).toContain('## Turn 2') + }) + + it('multiple turns: --- separator between turns', async () => { + vi.mocked(persistenceService.loadDBMessages).mockResolvedValueOnce([ + makeRecord('r1', 'user', 'done', [textPart('first')]), + makeRecord('r2', 'assistant', 'done', [textPart('ok1')]), + makeRecord('r3', 'user', 'done', [textPart('second')]), + ]) + const result = await buildHistoryContextPrompt(CONV, ENV, USER, PROMPT) + // 应该有多个 --- 分隔（turn 之间 + current message 前） + const separators = result.match(/^---$/gm) + expect(separators?.length).toBeGreaterThanOrEqual(2) + }) + + it('contains "Current user message" section with new prompt', async () => { + vi.mocked(persistenceService.loadDBMessages).mockResolvedValueOnce([ + makeRecord('r1', 'user', 'done', [textPart('hello')]), + ]) + const result = await buildHistoryContextPrompt(CONV, ENV, USER, PROMPT) + expect(result).toContain('## Current user message') + expect(result).toContain(PROMPT) + }) + + // ── tool_call ───────────────────────────────────────────────────────────── + + it('tool_call: shows tool name and param keys, NOT param values', async () => { + vi.mocked(persistenceService.loadDBMessages).mockResolvedValueOnce([ + makeRecord('r1', 'assistant', 'done', [ + toolCallPart('write', { path: '/secret/file.txt', content: 'topsecret' }), + ]), + ]) + const result = await buildHistoryContextPrompt(CONV, ENV, USER, PROMPT) + // 工具名显示 + expect(result).toContain('[Tool call] write') + // 参数名显示 + expect(result).toContain('path') + expect(result).toContain('content') + // 参数值不显示 + expect(result).not.toContain('/secret/file.txt') + expect(result).not.toContain('topsecret') + }) + + // ── tool_result ─────────────────────────────────────────────────────────── + + it('tool_result: shows name, status and byte count, NOT raw content', async () => { + const longOutput = 'a'.repeat(500) + vi.mocked(persistenceService.loadDBMessages).mockResolvedValueOnce([ + makeRecord('r1', 'assistant', 'done', [ + toolCallPart('read', { path: 'x.txt' }), + toolResultPart('read', longOutput, 'completed'), + ]), + ]) + const result = await buildHistoryContextPrompt(CONV, ENV, USER, PROMPT) + expect(result).toContain('[Tool result] read') + expect(result).toContain('completed') + expect(result).toContain('500 bytes') + // 原始内容不应出现 + expect(result).not.toContain(longOutput.slice(0, 50)) + }) + + // ── filtering ───────────────────────────────────────────────────────────── + + it('reasoning part is NOT included in context', async () => { + vi.mocked(persistenceService.loadDBMessages).mockResolvedValueOnce([ + makeRecord('r1', 'assistant', 'done', [reasoningPart('my secret thinking process'), textPart('final answer')]), + ]) + const result = await buildHistoryContextPrompt(CONV, ENV, USER, PROMPT) + expect(result).not.toContain('my secret thinking process') + expect(result).toContain('final answer') + }) + + it('pending/error/cancel records are skipped', async () => { + vi.mocked(persistenceService.loadDBMessages).mockResolvedValueOnce([ + makeRecord('r1', 'user', 'done', [textPart('good')]), + makeRecord('r2', 'assistant', 'pending', [textPart('should not appear')]), + makeRecord('r3', 'assistant', 'error', [textPart('error msg')]), + ]) + const result = await buildHistoryContextPrompt(CONV, ENV, USER, PROMPT) + expect(result).toContain('good') + expect(result).not.toContain('should not appear') + expect(result).not.toContain('error msg') + }) + + it('excludeRecordIds skips specific records', async () => { + vi.mocked(persistenceService.loadDBMessages).mockResolvedValueOnce([ + makeRecord('r1', 'user', 'done', [textPart('old message')]), + makeRecord('r2', 'user', 'done', [textPart('new prompt - excluded')]), + ]) + const result = await buildHistoryContextPrompt(CONV, ENV, USER, PROMPT, { + excludeRecordIds: new Set(['r2']), + }) + expect(result).toContain('old message') + expect(result).not.toContain('new prompt - excluded') + }) +}) diff --git a/packages/server/src/agent/runtime/__tests__/resolveOnPath.test.ts b/packages/server/src/agent/runtime/__tests__/resolveOnPath.test.ts new file mode 100644 index 0000000..22dfaff --- /dev/null +++ b/packages/server/src/agent/runtime/__tests__/resolveOnPath.test.ts @@ -0,0 +1,122 @@ +/** + * 单元测试：resolveOnPath / tryBins / getResolvedBin + * + * 用 vi.mock + vi.mocked 控制 fs.existsSync，vi.stubEnv 控制 PATH / OPENCODE_BIN。 + * 全程无真实 PATH 扫描、无子进程。 + * + * 注意：vi.resetModules() 在每个 it 前清空 acp-transport 的模块缓存， + * 确保每次 import 都拿到新实例（新的 _resolvedBin 缓存）。 + */ +import { describe, it, expect, vi, beforeEach, afterEach } from 'vitest' + +// Mock node:fs 整体，这样 existsSync 可被控制 +vi.mock('node:fs', async (importOriginal) => { + const actual = await importOriginal<typeof import('node:fs')>() + return { + ...actual, + existsSync: vi.fn(), + } +}) + +import * as fs from 'node:fs' + +describe('resolveOnPath + getResolvedBin', () => { + beforeEach(() => { + vi.resetModules() + vi.unstubAllEnvs() + vi.mocked(fs.existsSync).mockReturnValue(false) + }) + + afterEach(() => { + vi.clearAllMocks() + }) + + // ── resolveOnPath ────────────────────────────────────────────────────────── + + it('resolveOnPath returns absolute path when bin found in PATH', async () => { + vi.stubEnv('PATH', '/usr/local/bin:/usr/bin') + vi.mocked(fs.existsSync).mockImplementation((p) => p === '/usr/local/bin/opencode') + const { resolveOnPath } = await import('../acp-transport.js') + expect(resolveOnPath('opencode')).toBe('/usr/local/bin/opencode') + }) + + it('resolveOnPath returns null when bin not found in any PATH dir', async () => { + vi.stubEnv('PATH', '/usr/local/bin:/usr/bin') + vi.mocked(fs.existsSync).mockReturnValue(false) + const { resolveOnPath } = await import('../acp-transport.js') + expect(resolveOnPath('opencode')).toBeNull() + }) + + it('resolveOnPath returns null when PATH is empty', async () => { + vi.stubEnv('PATH', '') + const { resolveOnPath } = await import('../acp-transport.js') + expect(resolveOnPath('opencode')).toBeNull() + }) + + // ── getResolvedBin: OPENCODE_BIN env override ────────────────────────────── + + it('getResolvedBin returns OPENCODE_BIN env if it exists on disk', async () => { + vi.stubEnv('OPENCODE_BIN', '/opt/custom/opencode') + vi.mocked(fs.existsSync).mockImplementation((p) => p === '/opt/custom/opencode') + const { getResolvedBin } = await import('../acp-transport.js') + expect(getResolvedBin()).toBe('/opt/custom/opencode') + }) + + it('getResolvedBin skips OPENCODE_BIN env if file does not exist, falls back to PATH', async () => { + vi.stubEnv('OPENCODE_BIN', '/opt/custom/opencode') + vi.stubEnv('PATH', '/usr/local/bin') + vi.mocked(fs.existsSync).mockImplementation((p) => p === '/usr/local/bin/opencode') + const { getResolvedBin } = await import('../acp-transport.js') + expect(getResolvedBin()).toBe('/usr/local/bin/opencode') + }) + + // ── getResolvedBin: fallback chain ───────────────────────────────────────── + + it('getResolvedBin finds "opencode" before fallback "opencode-ai"', async () => { + vi.stubEnv('PATH', '/usr/local/bin') + vi.mocked(fs.existsSync).mockImplementation((p) => p === '/usr/local/bin/opencode') + const { getResolvedBin } = await import('../acp-transport.js') + expect(getResolvedBin()).toBe('/usr/local/bin/opencode') + }) + + it('getResolvedBin falls back to "opencode-ai" when "opencode" is absent', async () => { + vi.stubEnv('PATH', '/usr/local/bin') + vi.mocked(fs.existsSync).mockImplementation((p) => p === '/usr/local/bin/opencode-ai') + const { getResolvedBin } = await import('../acp-transport.js') + expect(getResolvedBin()).toBe('/usr/local/bin/opencode-ai') + }) + + it('getResolvedBin returns null when all bins absent', async () => { + vi.stubEnv('PATH', '/usr/local/bin') + vi.mocked(fs.existsSync).mockReturnValue(false) + const { getResolvedBin } = await import('../acp-transport.js') + expect(getResolvedBin()).toBeNull() + }) +}) + +describe('isAvailable via getResolvedBin', () => { + beforeEach(() => { + vi.resetModules() + vi.unstubAllEnvs() + vi.mocked(fs.existsSync).mockReturnValue(false) + }) + afterEach(() => { + vi.clearAllMocks() + }) + + it('isAvailable returns true when getResolvedBin finds opencode', async () => { + vi.stubEnv('PATH', '/usr/local/bin') + vi.mocked(fs.existsSync).mockImplementation((p) => p === '/usr/local/bin/opencode') + const { OpencodeAcpRuntime } = await import('../opencode-acp-runtime.js') + const rt = new OpencodeAcpRuntime() + expect(await rt.isAvailable()).toBe(true) + }) + + it('isAvailable returns false when getResolvedBin cannot find any opencode bin', async () => { + vi.stubEnv('PATH', '/usr/local/bin') + vi.mocked(fs.existsSync).mockReturnValue(false) + const { OpencodeAcpRuntime } = await import('../opencode-acp-runtime.js') + const rt = new OpencodeAcpRuntime() + expect(await rt.isAvailable()).toBe(false) + }) +}) diff --git a/packages/server/src/agent/runtime/acp-transport.ts b/packages/server/src/agent/runtime/acp-transport.ts new file mode 100644 index 0000000..4bb770b --- /dev/null +++ b/packages/server/src/agent/runtime/acp-transport.ts @@ -0,0 +1,268 @@ +/** + * ACP Transport 抽象 + * + * 把"启动 opencode acp 进程 + 建立 NDJSON stdio 通道"的具体机制 + * 与 runtime 的事件翻译层解耦。 + * + * 当前只有一种 transport： + * + * LocalStdioTransport：spawn 本地 `opencode acp` 子进程，pipe stdin/stdout 为 NDJSON Stream + * + * 为什么不做"在沙箱里跑 opencode"的 transport？ + * - Agent 与 Sandbox 应严格分离（agent 负责决策、sandbox 负责执行） + * - 把 agent 塞进沙箱违反这一原则 + * - 正确的隔离方式：让 agent 在 server 本地跑，但把它的工具调用桥接到沙箱 + * （见 sandbox-mcp-bridge.ts + opencode-agent-config.ts） + */ + +import { spawn, type ChildProcessWithoutNullStreams } from 'node:child_process' +import { existsSync } from 'node:fs' +import { delimiter } from 'node:path' +import path from 'node:path' +import { ndJsonStream, type Stream } from '@agentclientprotocol/sdk' + +// ─── Bin resolution ───────────────────────────────────────────────────────── + +/** + * 在 PATH 各目录下查找指定 bin 名，返回第一个命中的**绝对路径**，找不到返回 null。 + * 纯同步 fs 检查，无子进程。 + */ +export function resolveOnPath(bin: string): string | null { + const dirs = (process.env.PATH ?? '').split(delimiter) + const exts = process.platform === 'win32' ? (process.env.PATHEXT ?? '.EXE;.CMD;.BAT').split(';') : [''] + for (const dir of dirs) { + if (!dir) continue + for (const ext of exts) { + const full = path.join(dir, bin + ext) + if (existsSync(full)) return full + } + } + return null +} + +/** + * Fallback 候选列表（按优先级排列）。 + * + * 1. OPENCODE_BIN env：允许完全覆盖（绝对路径或 bin 名均可） + * 2. 'opencode'：官方包名 + * 3. 'opencode-ai'：npm 包名（`npm i -g opencode-ai` 安装后 bin 叫 opencode-ai） + */ +const OPENCODE_BIN_CANDIDATES = ['opencode', 'opencode-ai'] as const + +/** + * 模块级缓存。undefined = 未初始化；null = 找不到；string = 解析到的绝对路径。 + * 第一次调用时扫 PATH，此后 O(1) 返回。 + */ +let _resolvedBin: string | null | undefined = undefined + +/** + * 解析可用的 opencode 可执行路径。 + * + * 优先级： + * 1. OPENCODE_BIN env（如果是绝对路径且存在，直接返回；否则当 bin 名走 resolveOnPath） + * 2. 按 OPENCODE_BIN_CANDIDATES 顺序在 PATH 里查找 + * + * 结果被模块级缓存，进程内只扫一次。测试时通过 vi.resetModules() 清除缓存。 + */ +export function getResolvedBin(): string | null { + if (_resolvedBin !== undefined) return _resolvedBin + + const envOverride = process.env.OPENCODE_BIN + if (envOverride) { + // 如果是绝对路径，直接检查；否则当 bin 名走 resolveOnPath + if (path.isAbsolute(envOverride)) { + if (existsSync(envOverride)) { + _resolvedBin = envOverride + return _resolvedBin + } + // env 里的绝对路径不存在 → 降到 fallback 继续找 + } else { + const resolved = resolveOnPath(envOverride) + if (resolved) { + _resolvedBin = resolved + return _resolvedBin + } + } + } + + // Fallback 候选 + for (const bin of OPENCODE_BIN_CANDIDATES) { + const resolved = resolveOnPath(bin) + if (resolved) { + _resolvedBin = resolved + return _resolvedBin + } + } + + _resolvedBin = null + return null +} + +// ─── Core Interfaces ──────────────────────────────────────────────────────── + +export interface AcpTransport { + /** ACP SDK 使用的双向 NDJSON 流 */ + readonly stream: Stream + /** + * 等待底层进程退出。transport 实现应在进程退出时 resolve 此 promise， + * 用于 runtime 检测异常退出并上报 error。 + */ + readonly exit: Promise<{ code: number | null; signal: NodeJS.Signals | null }> + /** + * 主动关闭 transport（杀进程 + 关闭流）。幂等。 + */ + close(): void +} + +export interface AcpTransportFactoryContext { + /** 工作目录（对应 opencode acp --cwd）。可以是一个临时目录，用来放自定义 agent 配置 */ + cwd: string + /** abort 信号；transport 实现必须监听并在 abort 时触发 close() */ + signal: AbortSignal + /** 调试开关：透传到 transport 的 stderr 打印行为 */ + debug?: boolean + /** 附加环境变量（如 OPENCODE_CONFIG 指向 per-session 配置文件） */ + env?: Record<string, string> +} + +export type AcpTransportFactory = (ctx: AcpTransportFactoryContext) => Promise<AcpTransport> + +// ─── Local stdio transport ────────────────────────────────────────────────── + +const LOCAL_SPAWN_TIMEOUT_MS = 15_000 + +export const createLocalStdioTransport: AcpTransportFactory = async (ctx) => { + const child = await spawnLocalOpencode(ctx.cwd, ctx.signal, ctx.debug ?? false, ctx.env) + + const stream = ndJsonStream( + new WritableStream<Uint8Array | string>({ + write(chunk) { + return new Promise((resolve, reject) => { + const data = typeof chunk === 'string' ? chunk : Buffer.from(chunk) + child.stdin.write(data, (err) => (err ? reject(err) : resolve())) + }) + }, + close() { + try { + child.stdin.end() + } catch { + /* noop */ + } + }, + }), + new ReadableStream<Uint8Array>({ + start(controller) { + child.stdout.on('data', (chunk: Buffer) => controller.enqueue(new Uint8Array(chunk))) + child.stdout.on('end', () => { + try { + controller.close() + } catch { + /* noop */ + } + }) + child.stdout.on('error', (err) => controller.error(err)) + }, + }), + ) + + const exit = new Promise<{ code: number | null; signal: NodeJS.Signals | null }>((resolve) => { + child.on('exit', (code, sig) => resolve({ code, signal: sig })) + }) + + return { + stream, + exit, + close() { + try { + child.kill('SIGTERM') + } catch { + /* noop */ + } + }, + } +} + +async function spawnLocalOpencode( + cwd: string, + signal: AbortSignal, + debug: boolean, + extraEnv?: Record<string, string>, +): Promise<ChildProcessWithoutNullStreams> { + // 用 getResolvedBin() 代替之前的硬编码常量，支持 fallback 候选 + const bin = getResolvedBin() + if (!bin) { + throw new Error( + `opencode CLI not found. Install via: npm i -g opencode-ai\n` + `Or set OPENCODE_BIN env to the absolute path.`, + ) + } + + return new Promise((resolve, reject) => { + const child = spawn(bin, ['acp', '--cwd', cwd], { + stdio: ['pipe', 'pipe', 'pipe'], + env: { ...process.env, ...(extraEnv ?? {}) }, + }) + + let settled = false + const onAbort = () => { + try { + child.kill('SIGTERM') + } catch { + /* noop */ + } + } + signal.addEventListener('abort', onAbort) + + const timer = setTimeout(() => { + if (!settled) { + settled = true + try { + child.kill('SIGKILL') + } catch { + /* noop */ + } + reject(new Error('opencode acp spawn timeout')) + } + }, LOCAL_SPAWN_TIMEOUT_MS) + + child.on('error', (err) => { + if (!settled) { + settled = true + clearTimeout(timer) + reject(err) + } + }) + + child.on('spawn', () => { + if (!settled) { + settled = true + clearTimeout(timer) + resolve(child) + } + }) + + child.stderr?.on('data', (chunk) => { + if (debug) { + process.stderr.write('[opencode stderr] ' + chunk.toString()) + } + }) + }) +} + +// ─── Transport Registry ───────────────────────────────────────────────────── + +export type AcpTransportKind = 'local-stdio' + +const FACTORIES: Record<AcpTransportKind, AcpTransportFactory> = { + 'local-stdio': createLocalStdioTransport, +} + +export function getAcpTransportFactory(kind: AcpTransportKind): AcpTransportFactory { + const f = FACTORIES[kind] + if (!f) throw new Error(`Unknown ACP transport kind: ${kind}`) + return f +} + +export function resolveAcpTransportKind(_opts: { kind?: AcpTransportKind } = {}): AcpTransportKind { + // 目前只有一种 transport，保留函数签名以便未来扩展（例如 WebSocket 转发给远端 agent 集群） + return 'local-stdio' +} diff --git a/packages/server/src/agent/runtime/base-runtime.ts b/packages/server/src/agent/runtime/base-runtime.ts new file mode 100644 index 0000000..45d13e7 --- /dev/null +++ b/packages/server/src/agent/runtime/base-runtime.ts @@ -0,0 +1,729 @@ +/** + * BaseAgentRuntime + * + * 抽象基类：提供所有 runtime 共享的基础设施： + * - 沙箱生命周期（SCF 创建 + 健康检查 + workspace init） + * - MCP Server（sandbox-mcp-proxy） + * - System Prompt（buildAppendPrompt + getCodingSystemPrompt） + * - PublishableKey 获取 + * + * 子类只需实现 `runAgent(ctx, prompt, options)` —— 具体 agent 驱动逻辑。 + * + * 使用模板方法模式：chatStream() 编排公共流程，调 runAgent() 做子类特定工作。 + * 但目前 CodeBuddyRuntime 因历史原因仍直接委托到 cloudbase-agent.service.ts， + * 仅 OpencodeAcpRuntime 使用基类提供的 sandbox/MCP/systemPrompt 设施。 + * 未来 CodeBuddyRuntime 迁移后可直接在 runAgent 中使用。 + */ + +import type { AgentCallback, AgentCallbackMessage, AgentOptions } from '@coder/shared' +import type { ChatStreamResult, IAgentRuntime } from './types.js' +import type { ModelInfo } from '../cloudbase-agent.service.js' +import { + scfSandboxManager, + type SandboxInstance, + type SandboxProgressCallback, +} from '../../sandbox/scf-sandbox-manager.js' +import { createSandboxMcpClient, type SandboxMcpDeps } from '../../sandbox/sandbox-mcp-proxy.js' +import { getDb } from '../../db/index.js' +import { resolveSandboxConfig, backfillSandboxConfig } from '../../lib/sandbox-config.js' +import { getCodingSystemPrompt } from '../coding-mode.js' +import { decrypt } from '../../lib/crypto.js' +import { encryptJWE } from '../../lib/session.js' +import { sessionPermissions } from '../session-permissions.js' + +// ─── Constants ───────────────────────────────────────────────────────────── + +const HEALTH_MAX_RETRIES = 20 +const HEALTH_INTERVAL_MS = 2000 + +/** + * 需要用户确认的写操作工具集合。 + * 所有 runtime 共享此白名单（TencentSdk 的 canUseTool + OpenCode 的 requestPermission）。 + */ +export const WRITE_TOOLS = new Set([ + 'writeNoSqlDatabaseStructure', + 'writeNoSqlDatabaseContent', + 'executeWriteSQL', + 'modifyDataModel', + 'createFunction', + 'updateFunctionCode', + 'updateFunctionConfig', + 'invokeFunction', +]) + +// ─── Shared Helpers ──────────────────────────────────────────────────────── + +/** + * 等待沙箱健康检查就绪（轮询 /health） + */ +export async function waitForSandboxHealth( + sandbox: SandboxInstance, + onProgress?: SandboxProgressCallback, +): Promise<boolean> { + onProgress?.({ phase: 'wait_ready', message: '等待沙箱就绪...\n' }) + for (let i = 0; i < HEALTH_MAX_RETRIES; i++) { + try { + const res = await sandbox.request('/health', { + signal: AbortSignal.timeout(4000), + }) + if (res.ok) { + return true + } + } catch { + // 继续轮询 + } + await new Promise((r) => setTimeout(r, HEALTH_INTERVAL_MS)) + } + return false +} + +/** + * 初始化沙箱工作空间：POST /api/session/init 注入凭证和环境变量 + * 然后 poll /api/scope/info 获取工作目录 + */ +export async function initSandboxWorkspace( + sandbox: SandboxInstance, + secret: { envId: string; secretId: string; secretKey: string; token?: string }, + conversationId: string, + preferredCwd?: string, + onProgress?: SandboxProgressCallback, +): Promise<{ workspace: string; vitePort?: number }> { + const fallbackWorkspace = preferredCwd || `/tmp/workspace/${secret.envId}/${conversationId}` + + onProgress?.({ phase: 'init_mcp', message: '初始化工作空间...\n' }) + + // Fire session/init in background — injects credentials into the sandbox session. + sandbox + .request('/api/session/init', { + method: 'POST', + headers: { 'Content-Type': 'application/json' }, + body: JSON.stringify({ + env: { + CLOUDBASE_ENV_ID: secret.envId, + TENCENTCLOUD_SECRETID: secret.secretId, + TENCENTCLOUD_SECRETKEY: secret.secretKey, + ...(secret.token ? { TENCENTCLOUD_SESSIONTOKEN: secret.token } : {}), + }, + }), + signal: AbortSignal.timeout(300_000), + }) + .then((res) => { + if (!res.ok) { + console.warn('[BaseRuntime] session/init returned status:', res.status) + } + }) + .catch((e) => { + console.warn('[BaseRuntime] session/init background error:', (e as Error).message) + }) + + // Poll /api/scope/info to get the workspace path + const maxWaitMs = 120_000 + const pollInterval = 2000 + const startTime = Date.now() + + while (Date.now() - startTime < maxWaitMs) { + try { + const res = await sandbox.request('/api/scope/info', { + signal: AbortSignal.timeout(10_000), + }) + if (res.ok) { + const data = (await res.json()) as { + success?: boolean + workspace?: string + vitePort?: number | null + } + if (data.success && data.workspace) { + onProgress?.({ phase: 'ready', message: '沙箱已就绪\n' }) + return { workspace: data.workspace, vitePort: data.vitePort ?? undefined } + } + } + } catch { + // scope/info not available yet + } + await new Promise((r) => setTimeout(r, pollInterval)) + } + + console.warn(`[BaseRuntime] initSandboxWorkspace timeout after ${maxWaitMs / 1000}s`) + return { workspace: fallbackWorkspace } +} + +// ─── System Prompt ───────────────────────────────────────────────────────── + +/** + * 获取 CloudBase 前端 SDK 的 publishableKey + */ +const publishableKeyCache = new Map<string, string>() + +export async function getPublishableKey(envId: string): Promise<string> { + if (publishableKeyCache.has(envId)) return publishableKeyCache.get(envId)! + + const secretId = process.env.TCB_SECRET_ID + const secretKey = process.env.TCB_SECRET_KEY + if (!secretId || !secretKey || !envId) return '' + try { + const CloudBase = (await import('@cloudbase/manager-node')).default + const manager = new CloudBase({ + secretId, + secretKey, + envId, + proxy: process.env.http_proxy, + }) + const result = await manager.commonService('tcb', '2018-06-08').call({ + Action: 'CreateApiKey', + Param: { EnvId: envId, KeyType: 'publish_key' }, + }) + const apiKey = result?.ApiKey || result?.Response?.ApiKey || '' + if (apiKey) { + publishableKeyCache.set(envId, apiKey) + } + return apiKey + } catch (e) { + console.warn('[BaseRuntime] Failed to get publishableKey:', (e as Error).message) + return '' + } +} + +/** + * 构建通用 system prompt（任务分类 + CloudBase 指引 + 沙箱上下文） + */ +export function buildAppendPrompt( + sandboxCwd?: string, + conversationId?: string, + envId?: string, + sandboxMode?: 'shared' | 'isolated', + isCodingMode?: boolean, +): string { + const roleLine = isCodingMode + ? '你是一个通用 AI 编程助手，同时具备腾讯云开发（CloudBase）能力。' + : '你是一个通用 AI 助手，同时具备腾讯云开发（CloudBase）能力，可按需通过工具操作云函数、数据库、存储、云托管等资源。' + + const taskClassificationSection = isCodingMode + ? '' + : ` +<task-classification priority="highest"> +收到任务后，先判断类型再决定是否使用工具： + +1) **对话/创作/咨询类**（写文案、写文章、翻译、起名、解释概念、讨论观点、情绪陪伴、海报/帖子**文本**、小红书/朋友圈文案、社交媒体内容等） + → 直接在对话中以**文本/Markdown**形式输出，**不要**写文件、不要部署、不要调用开发相关工具。 + → 即使用户说"帮我做一个 XX 应援贴/海报/宣传文案"，默认先理解为"输出文案"，除非用户明确要求"做一个页面/网站/应用"。 + → **例外**：如果用户明确说"生成一张图""帮我画一张 XX 图片""做一张海报图片"，使用 ImageGen 工具生成图片。 + +2) **编程/工程类**（修改代码、调试、构建应用、部署服务、配置云资源、运维操作） + → 使用工具完成任务：读文件、写文件、执行命令、部署、调用云开发 MCP 等。 + +3) **自动化/定时类**（"每天…"、"每周…"、"定期…"） + → 使用 cronTask 工具管理定时任务（见下面 cron-task 章节）。 + +**不确定时优先问用户**："你希望我直接写文案给你，还是做一个可访问的网页？"，不要擅自升级为 2)。 +</task-classification> +` + + const base = `<role> +${roleLine} +默认使用中文与用户沟通；删除等破坏性操作需确认用户意图。 +</role> +${taskClassificationSection} +<cloudbase-guideline> +- 当前云开发环境为 ${envId || '(未指定)'}，必要时可通过 cloudbase MCP 工具操作。 +- **仅当用户明确要求部署、开发应用、操作数据库、上传文件等**，才使用云开发工具。纯文案/咨询不涉及此。 +- 部署云函数使用 manageFunctions 工具；上传文件到静态托管使用 cloudbase_uploadFiles 工具。 +</cloudbase-guideline> + +<bash-usage> +对于耗时较长的命令（如 npm install、yarn install、大型项目构建等），如果执行超时： +1. 改为后台执行, 添加 run_in_background，可以获取 pid +2. 定期检查进程状态：ps aux | grep '<关键词>' | grep -v grep +3. 通过 BashOutput 结合 pid 查看输出结果 +4. 也可以通过 KillShell 关闭后台执行的任务 +</bash-usage> + +<cron-task-usage> +当用户提到定时执行、定期运行、每天/每周/每小时执行某操作等需求时，必须使用 cronTask 工具来管理定时任务。 +- 创建：action="create"，需要 name、prompt、cronExpression +- 查询：action="list"，查看当前所有定时任务 +- 更新：action="update"，通过 id 修改已有任务（可改 prompt、cronExpression、enabled 等） +- 删除：action="delete"，通过 id 删除任务 +Cron 表达式格式：分 时 日 月 周，例如 "0 20 * * *" 表示每天 20:00。 +</cron-task-usage> + +<tools-extra-info> +- **ImageGen** — AI 图片生成。Usage: 用户明确要求生成/绘制图片时（"帮我画一张…""生成一张…的图""做一张海报图片"）。生成的图片会同时保存到工作区和静态托管，返回可公开访问的 CDN 链接。 +- **ImageEdit** — AI 图片编辑。Usage: 用户提供一张已有图片，要求修改风格、添加元素、局部重绘等。 +</tools-extra-info>` + + if (sandboxCwd) { + const homeDir = sandboxMode === 'isolated' ? sandboxCwd : sandboxCwd.substring(0, sandboxCwd.lastIndexOf('/')) + const sandboxPreamble = isCodingMode + ? '' + : '（以下仅在你已判定任务属于"编程/工程类"、决定动手写文件或执行命令时适用；对话/创作类任务请忽略本节。）\n' + return `${base} + +<sandbox-context> +${sandboxPreamble}工具默认在 Home: ${homeDir} 下执行 +为项目开辟工作目录为: ${sandboxCwd} +使用的云开发环境为: ${envId} +请注意： +- 所有文件读写、终端命令都应在工作目录中执行，注意 cd 到工作目录操作。 +- 使用 cloudbase_uploadFiles 部署文件时，localPath 必须是容器内的**绝对路径**（即当前工作目录 ${sandboxCwd} 下的路径），例如 ${sandboxCwd}/index.html +- 如用户没有特别要求，cloudPath 需要为 ${conversationId}/xxx，即在当前会话路径下 +- 不要使用相对路径给 cloudbase_uploadFiles +</sandbox-context>` + } + return base +} + +// ─── RuntimeContext ──────────────────────────────────────────────────────── + +/** + * 由 BaseAgentRuntime 在 chatStream 中构建，传给子类 runAgent()。 + * 包含所有已初始化的公共资源。 + */ +export interface RuntimeContext { + conversationId: string + envId: string + userId: string + userCredentials?: { secretId: string; secretKey: string; sessionToken?: string } + model: string + mode: 'default' | 'coding' + isCodingMode: boolean + + /** SCF 沙箱实例（null 表示沙箱不可用或禁用） */ + sandbox: SandboxInstance | null + /** 沙箱内工作目录路径 */ + sandboxCwd: string | null + /** sandbox isolation mode */ + sandboxMode: 'shared' | 'isolated' + /** sandbox session id */ + sandboxSessionId: string + + /** MCP client (sandbox-mcp-proxy)，用于 CloudBase 工具调用 */ + mcpClient: Awaited<ReturnType<typeof createSandboxMcpClient>> | null + + /** 构建好的 system prompt（含沙箱上下文 + coding mode） */ + systemPrompt: string + /** CloudBase publishableKey */ + publishableKey: string + + /** tool override config（沙箱 → agent SDK 工具路由） */ + toolOverrideConfig: { url: string; headers: Record<string, string> } | null +} + +// ─── BaseAgentRuntime ────────────────────────────────────────────────────── + +export abstract class BaseAgentRuntime implements IAgentRuntime { + abstract readonly name: string + abstract isAvailable(): Promise<boolean> + abstract getSupportedModels(): Promise<ModelInfo[]> + abstract chatStream(prompt: string, callback: AgentCallback | null, options: AgentOptions): Promise<ChatStreamResult> + + // ─── 公共设施方法（子类可在 runAgent 中调用） ──────────────────── + + /** + * 初始化完整的沙箱环境：创建 SCF → 健康检查 → workspace init → MCP client。 + * + * @returns RuntimeContext 中与沙箱相关的字段 + */ + protected async setupSandbox(options: { + conversationId: string + envId: string + userId: string + userCredentials?: { secretId: string; secretKey: string; sessionToken?: string } + isCodingMode: boolean + callback?: AgentCallback | null + model?: string + }): Promise<{ + sandbox: SandboxInstance | null + sandboxCwd: string | null + sandboxMode: 'shared' | 'isolated' + sandboxSessionId: string + toolOverrideConfig: { url: string; headers: Record<string, string> } | null + mcpClient: Awaited<ReturnType<typeof createSandboxMcpClient>> | null + /** Short-lived JWE session cookie for authenticating localhost requests (e.g. /cloudbase-mcp) */ + sessionJwe: string | null + }> { + const { conversationId, envId, userId, userCredentials, isCodingMode, callback, model } = options + + const sandboxEnabled = !!(process.env.TCB_ENV_ID && process.env.SCF_SANDBOX_IMAGE_URI) + if (!sandboxEnabled || !envId) { + return { + sandbox: null, + sandboxCwd: null, + sandboxMode: 'shared', + sandboxSessionId: envId || conversationId, + toolOverrideConfig: null, + mcpClient: null, + sessionJwe: null, + } + } + + // Read sandbox config from task record + let sandboxConfig = resolveSandboxConfig({ envId, taskId: conversationId }) + try { + const taskRecord = await getDb().tasks.findById(conversationId) + await backfillSandboxConfig( + conversationId, + { + sandboxMode: taskRecord?.sandboxMode, + sandboxSessionId: taskRecord?.sandboxSessionId, + sandboxCwd: taskRecord?.sandboxCwd, + }, + envId, + getDb(), + ) + sandboxConfig = resolveSandboxConfig({ + sandboxMode: taskRecord?.sandboxMode, + sandboxSessionId: taskRecord?.sandboxSessionId, + sandboxCwd: taskRecord?.sandboxCwd, + envId, + taskId: conversationId, + }) + } catch { + // Non-critical + } + + const { sandboxMode, sandboxSessionId } = sandboxConfig + + // Progress bridge + const progressBridge: SandboxProgressCallback = ({ phase }) => { + if (callback) { + callback({ type: 'agent_phase', phase: 'preparing', phaseToolName: `sandbox:${phase}` }) + } + } + + let sandboxInstance: SandboxInstance | null = null + let toolOverrideConfig: { url: string; headers: Record<string, string> } | null = null + let mcpClient: Awaited<ReturnType<typeof createSandboxMcpClient>> | null = null + let detectedCwd: string | null = null + let capturedSessionJwe: string | null = null + + try { + sandboxInstance = await scfSandboxManager.getOrCreate( + conversationId, + envId, + { + mode: 'shared', + workspaceIsolation: sandboxMode, + sandboxSessionId, + isCodingMode, + }, + progressBridge, + ) + + toolOverrideConfig = await sandboxInstance.getToolOverrideConfig() + + // Inject hosting presign config for ImageGen, and capture sessionJwe for /cloudbase-mcp auth + try { + const user = await getDb().users.findById(userId) + if (user) { + const session = { + created: Date.now(), + authProvider: (user.provider || 'local') as 'github' | 'local' | 'cloudbase' | 'api-key', + user: { + id: user.id, + username: user.username, + email: user.email || undefined, + avatar: user.avatarUrl || '', + name: user.name || undefined, + }, + } + const sessionJwe = await encryptJWE(session, '2h') + capturedSessionJwe = sessionJwe + const serverPort = Number(process.env.PORT) || 3001 + ;(toolOverrideConfig as any).hosting = { + presignUrl: `http://localhost:${serverPort}/api/storage/presign?bucketType=static`, + sessionCookie: sessionJwe, + sessionId: conversationId, + } + } + } catch { + // hosting presign failure doesn't affect main flow + } + + // Health check + const sandboxReady = await waitForSandboxHealth(sandboxInstance, progressBridge) + if (!sandboxReady) { + if (callback) { + callback({ type: 'text', content: '沙箱启动超时，将使用受限模式继续对话。\n\n' }) + } + sandboxInstance = null + } else { + // Init workspace + const initResult = await initSandboxWorkspace( + sandboxInstance, + { + envId, + secretId: userCredentials?.secretId || '', + secretKey: userCredentials?.secretKey || '', + token: userCredentials?.sessionToken, + }, + conversationId, + sandboxConfig.sandboxCwd || undefined, + progressBridge, + ) + if (initResult.workspace) { + detectedCwd = initResult.workspace + } + + // Create MCP client + mcpClient = await createSandboxMcpClient({ + sandbox: sandboxInstance, + getCredentials: async () => ({ + cloudbaseEnvId: envId, + secretId: userCredentials?.secretId || '', + secretKey: userCredentials?.secretKey || '', + sessionToken: userCredentials?.sessionToken, + }), + workspaceFolderPaths: detectedCwd || sandboxConfig.sandboxCwd, + log: (msg) => console.log(msg), + onArtifact: (artifact) => { + if (callback) { + callback({ type: 'artifact', artifact }) + } + // 持久化部署记录（所有 runtime 共用） + persistDeploymentFromArtifact(conversationId, artifact).catch((err) => { + console.error('[BaseRuntime] Failed to persist deployment:', err) + }) + }, + getMpDeployCredentials: async (appId: string) => { + const app = await getDb().miniprogramApps.findByAppIdAndUserId(appId, userId) + if (!app) return null + return { appId: app.appId, privateKey: decrypt(app.privateKey) } + }, + userId, + currentModel: model, + }) + + // Persist sandboxId to task record + try { + await getDb().tasks.update(conversationId, { + sandboxId: sandboxInstance.functionName, + }) + } catch { + // Non-critical + } + } + } catch (err) { + console.error('[BaseRuntime] Sandbox creation failed:', (err as Error).message) + if (callback) { + callback({ + type: 'text', + content: `【沙箱环境创建失败】${(err as Error).message}。将使用受限模式继续对话。\n\n`, + }) + } + } + + return { + sandbox: sandboxInstance, + sandboxCwd: detectedCwd, + sandboxMode, + sandboxSessionId, + toolOverrideConfig, + mcpClient, + sessionJwe: capturedSessionJwe, + } + } + + /** + * 构建完整 system prompt（含 coding mode + 沙箱上下文）。 + */ + protected async buildSystemPrompt(options: { + envId: string + isCodingMode: boolean + sandboxCwd: string | null + sandboxMode: 'shared' | 'isolated' + conversationId: string + }): Promise<{ systemPrompt: string; publishableKey: string }> { + const { envId, isCodingMode, sandboxCwd, sandboxMode, conversationId } = options + const publishableKey = await getPublishableKey(envId) + + let systemPrompt: string + if (isCodingMode) { + systemPrompt = + getCodingSystemPrompt(envId, publishableKey) + + '\n\n' + + buildAppendPrompt(sandboxCwd || undefined, conversationId, envId, sandboxMode, true) + } else { + systemPrompt = buildAppendPrompt(sandboxCwd || undefined, conversationId, envId, sandboxMode, false) + } + + return { systemPrompt, publishableKey } + } + + /** + * Coding mode: 标记 preview ready。 + */ + protected async markCodingPreviewReady(conversationId: string, sandbox: SandboxInstance | null): Promise<void> { + if (!sandbox) return + try { + const taskRecord = await getDb().tasks.findById(conversationId) + if (!taskRecord?.previewUrl) { + await getDb().tasks.update(conversationId, { previewUrl: 'ready' }) + } + } catch { + // Non-critical + } + } + + /** + * Coding mode: 自动放行所有写工具。 + */ + protected allowAllWriteToolsForCodingMode(conversationId: string): void { + for (const tool of WRITE_TOOLS) { + sessionPermissions.allowAlways(conversationId, tool) + } + } +} + +// ─── Artifact Helpers（所有 runtime 共用） ───────────────────────────────── + +import { nanoid } from 'nanoid' + +/** + * 从 artifact 事件中持久化部署记录到 DB。 + * 所有 runtime 收到 type='artifact' 的回调时都应调用此函数。 + */ +export async function persistDeploymentFromArtifact( + taskId: string, + artifact: NonNullable<AgentCallbackMessage['artifact']>, +): Promise<void> { + const now = Date.now() + const meta = artifact.metadata || {} + const deploymentType = (meta.deploymentType as string) || (artifact.contentType === 'link' ? 'web' : 'miniprogram') + const metadataJson = Object.keys(meta).length > 0 ? JSON.stringify(meta) : null + + if (deploymentType === 'miniprogram') { + const qrCodeUrl = artifact.contentType === 'image' ? artifact.data : (meta.qrCodeUrl as string) || null + const pagePath = (meta.pagePath as string) || null + const appId = (meta.appId as string) || null + const label = artifact.title || null + + const existing = await getDb().deployments.findByTaskIdAndTypePath(taskId, 'miniprogram', null) + + if (existing) { + await getDb().deployments.update(existing.id, { + qrCodeUrl: qrCodeUrl || existing.qrCodeUrl, + pagePath: pagePath || existing.pagePath, + appId: appId || existing.appId, + label: label || existing.label, + metadata: metadataJson || existing.metadata, + updatedAt: now, + }) + } else { + await getDb().deployments.create({ + id: nanoid(12), + taskId, + type: 'miniprogram', + url: null, + path: null, + qrCodeUrl, + pagePath, + appId, + label, + metadata: metadataJson, + createdAt: now, + updatedAt: now, + }) + } + } else if (artifact.contentType === 'link' && artifact.data) { + const url = artifact.data + let urlPath: string | null = null + try { + const urlObj = new URL(url) + urlPath = urlObj.pathname.replace(/\/index\.html$/, '/').replace(/\/+$/, '') || '/' + } catch { + /* ignore */ + } + + if (urlPath) { + const existing = await getDb().deployments.findByTaskIdAndTypePath(taskId, 'web', urlPath) + + if (existing) { + await getDb().deployments.update(existing.id, { + url, + label: artifact.title || existing.label, + metadata: metadataJson || existing.metadata, + updatedAt: now, + }) + } else { + await getDb().deployments.create({ + id: nanoid(12), + taskId, + type: 'web', + url, + path: urlPath, + qrCodeUrl: null, + pagePath: null, + appId: null, + label: artifact.title || null, + metadata: metadataJson, + createdAt: now, + updatedAt: now, + }) + } + } + + // Also update legacy previewUrl for backward compatibility + try { + await getDb().tasks.update(taskId, { previewUrl: url }) + } catch { + // Non-critical + } + } else { + // Other artifact types (json, image without miniprogram context, etc.) + await getDb().deployments.create({ + id: nanoid(12), + taskId, + type: deploymentType as 'web' | 'miniprogram', + url: artifact.contentType === 'link' ? artifact.data : null, + path: null, + qrCodeUrl: artifact.contentType === 'image' ? artifact.data : null, + pagePath: null, + appId: null, + label: artifact.title || null, + metadata: metadataJson, + createdAt: now, + updatedAt: now, + }) + } +} + +/** + * 从 uploadFiles 工具结果 JSON 中递归提取 CloudBase 部署 URL。 + * 纯函数，支持 accessUrl / staticDomain 字段，最多递归 5 层。 + */ +export function extractDeployUrl(rawText: string, isFile = false, depth = 0): string | null { + if (depth > 5) return null + try { + const parsed = JSON.parse(rawText) + + if (Array.isArray(parsed)) { + const firstText = parsed[0]?.text + if (typeof firstText === 'string') { + return extractDeployUrl(firstText, isFile, depth + 1) + } + return null + } + + if (typeof parsed !== 'object' || parsed === null) return null + + if (parsed.accessUrl) { + const url = new URL(parsed.accessUrl) + if (!isFile && url.pathname !== '/' && !url.pathname.endsWith('/')) { + url.pathname += '/' + } + if (!url.searchParams.get('t')) { + url.searchParams.set('t', String(Date.now())) + } + return url.toString() + } + if (parsed.staticDomain) return `https://${parsed.staticDomain}/?t=${Date.now()}` + + const innerText = parsed?.res?.content?.[0]?.text || parsed?.content?.[0]?.text + if (typeof innerText === 'string') { + return extractDeployUrl(innerText, isFile, depth + 1) + } + } catch { + // JSON parse 失败，忽略 + } + return null +} diff --git a/packages/server/src/agent/runtime/codebuddy-runtime.ts b/packages/server/src/agent/runtime/codebuddy-runtime.ts new file mode 100644 index 0000000..72559a8 --- /dev/null +++ b/packages/server/src/agent/runtime/codebuddy-runtime.ts @@ -0,0 +1,39 @@ +/** + * CodeBuddyRuntime + * + * 把现有 `CloudbaseAgentService`（基于 @tencent-ai/agent-sdk）包装成 IAgentRuntime。 + * 继承 BaseAgentRuntime 获取沙箱/MCP/系统提示等公共设施（当前仍委托到 cloudbase-agent.service.ts， + * 其内部已包含完整的沙箱+MCP 逻辑，后续迁移到 runAgent 中复用基类设施）。 + * + * runtime name: 'codebuddy'（向后兼容：registry 同时注册 'tencent-sdk' 别名） + */ + +import type { AgentCallback, AgentOptions } from '@coder/shared' +import type { ChatStreamResult } from './types.js' +import { cloudbaseAgentService, getSupportedModels, type ModelInfo } from '../cloudbase-agent.service.js' +import { BaseAgentRuntime } from './base-runtime.js' + +export class CodeBuddyRuntime extends BaseAgentRuntime { + readonly name = 'codebuddy' + + async isAvailable(): Promise<boolean> { + // CodeBuddy SDK 是 monorepo 内部依赖，安装即可用 + return true + } + + async getSupportedModels(): Promise<ModelInfo[]> { + return getSupportedModels() + } + + async chatStream(prompt: string, callback: AgentCallback | null, options: AgentOptions): Promise<ChatStreamResult> { + return cloudbaseAgentService.chatStream(prompt, callback, options) + } +} + +export const codebuddyRuntime = new CodeBuddyRuntime() + +// ─── 向后兼容别名 ───────────────────────────────────────────────────────── +/** @deprecated Use CodeBuddyRuntime / codebuddyRuntime instead */ +export const tencentSdkRuntime = codebuddyRuntime +/** @deprecated Use CodeBuddyRuntime instead */ +export type TencentSdkRuntime = CodeBuddyRuntime diff --git a/packages/server/src/agent/runtime/index.ts b/packages/server/src/agent/runtime/index.ts new file mode 100644 index 0000000..caeb2c1 --- /dev/null +++ b/packages/server/src/agent/runtime/index.ts @@ -0,0 +1,23 @@ +/** + * Agent Runtime 抽象层 - 公共导出 + * + * 使用方式： + * import { agentRuntimeRegistry } from '../agent/runtime/index.js' + * const runtime = agentRuntimeRegistry.resolve({ explicitRuntime: req.body.runtime }) + * const { turnId, alreadyRunning } = await runtime.chatStream(prompt, callback, options) + */ + +export type { IAgentRuntime, ChatStreamResult, RuntimeSelectorOptions, EmitFn } from './types.js' +export { agentRuntimeRegistry } from './registry.js' +export { codebuddyRuntime, CodeBuddyRuntime, tencentSdkRuntime, type TencentSdkRuntime } from './codebuddy-runtime.js' +export { opencodeAcpRuntime, OpencodeAcpRuntime } from './opencode-acp-runtime.js' +export { BaseAgentRuntime, type RuntimeContext } from './base-runtime.js' +export { + WRITE_TOOLS, + waitForSandboxHealth, + initSandboxWorkspace, + buildAppendPrompt, + getPublishableKey, + persistDeploymentFromArtifact, + extractDeployUrl, +} from './base-runtime.js' diff --git a/packages/server/src/agent/runtime/opencode-acp-runtime.ts b/packages/server/src/agent/runtime/opencode-acp-runtime.ts new file mode 100644 index 0000000..85faaf5 --- /dev/null +++ b/packages/server/src/agent/runtime/opencode-acp-runtime.ts @@ -0,0 +1,804 @@ +/** + * OpencodeAcpRuntime + * + * 基于 ACP 协议的 OpenCode agent runtime。 + * 继承 BaseAgentRuntime 获取沙箱、MCP、系统提示等公共基础设施。 + * + * 架构（"项目级 tool override + env 注入 + 共享沙箱"）： + * + * 工具文件直接 checked in 到 .opencode/tools/（无需安装步骤）。 + * 同名 custom tool 覆盖 opencode builtin — read/write/bash/edit/grep/glob。 + * + * 每次 chatStream： + * 1. BaseAgentRuntime.setupSandbox() 创建/获取 SCF 沙箱（共享实例） + * 2. spawn opencode acp，通过 child env 注入： + * OPENCODE_CONFIG_DIR=<projectRoot>/.opencode （隔离用户全局配置） + * SANDBOX_MODE=1 + * SANDBOX_BASE_URL=<沙箱 HTTPS>（来自基类 sandbox） + * SANDBOX_AUTH_HEADERS_JSON=<凭证 JSON> + * 3. 基类构建的 MCP endpoint 传给 opencode newSession，opencode 可直接调用 + * CloudBase MCP 工具（数据库、云函数、存储等） + * 4. 基类 systemPrompt 拼到 history context 前面，确保任务分类 + 沙箱上下文生效 + * 5. ACP 握手 → newSession → prompt → 收 session/update 流 → 翻译为 AgentCallbackMessage + */ + +import { v4 as uuidv4 } from 'uuid' +import { ClientSideConnection } from '@agentclientprotocol/sdk' +import type { AgentCallback, AgentCallbackMessage, AgentOptions } from '@coder/shared' +import type { ChatStreamResult } from './types.js' +import type { ModelInfo } from '../cloudbase-agent.service.js' +import { + registerAgent, + isAgentRunning, + getAgentRun, + completeAgent, + removeAgent, + getNextSeq, +} from '../agent-registry.js' +import { persistenceService } from '../persistence.service.js' +import { CloudbaseAgentService } from '../cloudbase-agent.service.js' +import { getAcpTransportFactory, getResolvedBin, type AcpTransport } from './acp-transport.js' +import { getOpencodeConfigDir } from './opencode-installer.js' +import { registerPending, resolvePending, rejectPendingForConversation } from './pending-permission-registry.js' +import { resolvePendingQuestion, rejectPendingQuestionsForConversation } from './pending-question-registry.js' +import { OpencodeMessageBuilder, findLastRecordIds, buildHistoryContextPrompt } from './opencode-message-builder.js' +import { BaseAgentRuntime } from './base-runtime.js' +import type { SandboxInstance } from '../../sandbox/scf-sandbox-manager.js' +import { archiveToGit } from '../../sandbox/git-archive.js' +import os from 'node:os' +import path from 'node:path' +import fs from 'node:fs' + +// ─── Config ────────────────────────────────────────────────────────────── + +// OPENCODE_BIN 常量已删除——统一使用 acp-transport.ts 的 getResolvedBin() +// 好处：单一权威来源，isAvailable() 与 spawn 使用同一路径，支持 fallback 候选 +const DEFAULT_OPENCODE_MODEL = process.env.OPENCODE_DEFAULT_MODEL || 'custom/default' + +/** 沙箱内工作目录（agent 看到的"当前目录"概念）。相对路径工具都会以此为根。 */ +const SANDBOX_WORKSPACE_ROOT = process.env.SANDBOX_WORKSPACE_ROOT || '.' + +// ─── State ─────────────────────────────────────────────────────────────── + +/** + * 活跃 agent 的 liveCallback 注册表。 + * + * 为什么需要？—— Resume 场景：第一轮 chatStream 的 SSE 流已结束（前端看到 + * tool_confirm 后切 waiting_for_interaction），第二轮 chatStream 是**新的 + * HTTP 请求**，带新的 callback。pending 恢复后，后续的 session/update 必须 + * 用**新 callback** 推给新 SSE 流（而不是第一轮的 callback，那个 stream 已关）。 + * + * 所以每次 chatStream（包括 resume 入口）都要更新这个 map，launchAgent 内部的 + * emit 函数通过 getLiveCallback() 间接取最新值。 + */ +const liveCallbacks = new Map<string, AgentCallback | null>() + +function registerLiveCallback(conversationId: string, cb: AgentCallback | null): void { + liveCallbacks.set(conversationId, cb) +} + +function updateLiveCallback(conversationId: string, cb: AgentCallback | null): void { + liveCallbacks.set(conversationId, cb) +} + +function getLiveCallback(conversationId: string): AgentCallback | null { + return liveCallbacks.get(conversationId) ?? null +} + +function clearLiveCallback(conversationId: string): void { + liveCallbacks.delete(conversationId) +} + +/** + * Per-conversation emitter 注册表：launchAgent 里写入闭包 emit， + * 供 routes/acp.ts 的 /internal/ask-user handler 对 ask_user 消息广播。 + */ +const emitters = new Map<string, (msg: AgentCallbackMessage) => Promise<void>>() + +function registerEmitter(conversationId: string, emit: (m: AgentCallbackMessage) => Promise<void>): void { + emitters.set(conversationId, emit) +} + +function clearEmitter(conversationId: string): void { + emitters.delete(conversationId) +} + +/** + * 对外暴露：routes/acp.ts 调此方法给指定 conversation 发 AgentCallbackMessage。 + * 主要用于 /internal/ask-user endpoint：tool 请求问用户 → emit ask_user → SSE 推前端。 + */ +export async function emitForConversation(conversationId: string, msg: AgentCallbackMessage): Promise<void> { + const emit = emitters.get(conversationId) + if (!emit) throw new Error(`no emitter registered for conversation ${conversationId}`) + await emit(msg) +} + +/** + * Internal-endpoint 共享 token。 + * + * 在 server 启动时生成一次（惰性），通过 env 注入 opencode 子进程。 + * 子进程的 custom tool 通过 `X-Internal-Token` header 回调 server 时认证。 + */ +let askUserToken: string | null = null +export function getAskUserToken(): string { + if (!askUserToken) { + // 16 字节十六进制，足够强的临时 token + askUserToken = cryptoRandomToken() + } + return askUserToken +} + +function cryptoRandomToken(): string { + // 16 bytes hex, no external deps + const bytes = new Uint8Array(16) + // Node runtime 保证有 crypto.getRandomValues + ;(globalThis.crypto as Crypto).getRandomValues(bytes) + return Array.from(bytes, (b) => b.toString(16).padStart(2, '0')).join('') +} + +// ─── Runtime ───────────────────────────────────────────────────────────── + +export class OpencodeAcpRuntime extends BaseAgentRuntime { + readonly name = 'opencode-acp' + + async isAvailable(): Promise<boolean> { + // getResolvedBin() 是纯同步 existsSync，不需要子进程 --version + // 优点：更快（无 spawn 开销）、更可靠（不受 PATH 环境变量/shell 变更影响） + return getResolvedBin() !== null + } + + async getSupportedModels(): Promise<ModelInfo[]> { + // Read model list from .opencode/opencode.json (the authoritative config file) + try { + const configPath = path.join(getOpencodeConfigDir(), 'opencode.json') + const raw = fs.readFileSync(configPath, 'utf-8') + const config = JSON.parse(raw) as { + provider?: Record<string, { name?: string; models?: Record<string, { name?: string }> }> + } + const models: ModelInfo[] = [] + for (const [providerKey, providerDef] of Object.entries(config.provider ?? {})) { + const vendorName = + typeof providerDef.name === 'string' && !providerDef.name.startsWith('{env:') + ? providerDef.name + : process.env.OPENCODE_PROVIDER_NAME || providerKey + for (const [modelKey, modelDef] of Object.entries(providerDef.models ?? {})) { + models.push({ + id: `${providerKey}/${modelKey}`, + name: modelDef.name || modelKey, + vendor: vendorName, + }) + } + } + if (models.length > 0) return models + } catch { + // fall through to env-based fallback + } + // Fallback: single model from env + const defaultModel = DEFAULT_OPENCODE_MODEL + const vendor = process.env.OPENCODE_PROVIDER_NAME || 'Custom' + return [{ id: defaultModel, name: defaultModel.split('/').pop() || defaultModel, vendor }] + } + + async chatStream(prompt: string, callback: AgentCallback | null, options: AgentOptions): Promise<ChatStreamResult> { + const conversationId = options.conversationId || uuidv4() + + // Resume path：已有挂起的 agent + 携带 toolConfirmation / askAnswers + // → 不 spawn 新进程，直接 resolve 挂起的 permission Promise / question HTTP + // → opencode 收到 outcome/answers 后继续执行，session/update 流继续 + if (isAgentRunning(conversationId)) { + const run = getAgentRun(conversationId)! + + // 更新 liveCallback 到新 SSE 流（第一轮的 SSE 可能已关） + updateLiveCallback(conversationId, callback) + + if (options.toolConfirmation) { + const resolved = resolvePending( + conversationId, + options.toolConfirmation.interruptId, + options.toolConfirmation.payload.action, + ) + if (!resolved) { + console.warn( + `[OpencodeAcpRuntime] toolConfirmation arrived but no pending registration for interruptId=${options.toolConfirmation.interruptId}`, + ) + } + } + + if (options.askAnswers) { + // askAnswers 结构：{ [assistantMessageId|recordId]: { toolCallId, answers } } + // 我们只关心 value 里的 toolCallId + answers + for (const entry of Object.values(options.askAnswers)) { + const resolved = resolvePendingQuestion(conversationId, entry.toolCallId, entry.answers) + if (!resolved) { + console.warn( + `[OpencodeAcpRuntime] askAnswers arrived but no pending question for toolCallId=${entry.toolCallId}`, + ) + } + } + } + + if (!options.toolConfirmation && !options.askAnswers && process.env.OPENCODE_ACP_DEBUG) { + console.log( + `[OpencodeAcpRuntime] chatStream re-entered without resume payload (conv=${conversationId}); returning existing turn`, + ) + } + return { turnId: run.turnId, alreadyRunning: true } + } + + // 非 resume：preSave user + assistant(pending) 记录，取 assistantRecordId 作为 turnId + // (与 Tencent SDK runtime 一致：turnId == assistantMessageId) + let preSaved: { userRecordId: string; assistantRecordId: string } | null = null + if (options.envId) { + try { + // 找上一轮 record ids，维护 replyTo / parentId 链 + const { prevRecordId, lastAssistantRecordId } = await findLastRecordIds( + conversationId, + options.envId, + options.userId || 'anonymous', + ) + preSaved = await persistenceService.preSavePendingRecords({ + conversationId, + envId: options.envId, + userId: options.userId || 'anonymous', + prompt, + prevRecordId, + lastAssistantRecordId, + }) + } catch (e) { + console.warn( + '[OpencodeAcpRuntime] preSavePendingRecords failed (continuing without persistence):', + (e as Error).message, + ) + } + } + + const turnId = preSaved?.assistantRecordId ?? uuidv4() + const abortController = new AbortController() + + registerAgent({ + conversationId, + turnId, + envId: options.envId || '', + userId: options.userId || 'anonymous', + abortController, + }) + + // 记录本轮的 liveCallback（resume 时可替换，因为 SSE 流可能已更新） + registerLiveCallback(conversationId, callback) + + // 本轮预存的 user/assistant record ids（用于 buildHistoryContextPrompt 排除） + const currentRecordIds = preSaved ? new Set<string>([preSaved.userRecordId, preSaved.assistantRecordId]) : undefined + + this.launchAgent(prompt, callback, options, conversationId, turnId, abortController, currentRecordIds).catch( + (err) => { + console.error('[OpencodeAcpRuntime] background agent error:', err) + }, + ) + + return { turnId, alreadyRunning: false } + } + + private async launchAgent( + prompt: string, + _liveCallback: AgentCallback | null, + options: AgentOptions, + conversationId: string, + turnId: string, + abortController: AbortController, + excludeHistoryRecordIds?: ReadonlySet<string>, + ): Promise<void> { + const envId = options.envId || '' + const userId = options.userId || 'anonymous' + const modelId = options.model || DEFAULT_OPENCODE_MODEL + + // 消息持久化 builder：累积事件 → UnifiedMessagePart[] → 落 messages 集合 + // turnId 即是 preSave 返回的 assistantRecordId + const messageBuilder = envId + ? new OpencodeMessageBuilder({ + conversationId, + assistantRecordId: turnId, + envId, + userId, + }) + : null + + // emit 每次动态取 liveCallback（resume 时回调会被替换） + // 第一轮由 chatStream 调用 registerLiveCallback 写入；第二轮（resume）由 + // chatStream 的 resume 分支更新。 + // 同时把消息喂给 messageBuilder 做持久化 + const emit = makeEmitter({ envId, userId, conversationId, turnId, messageBuilder }) + registerEmitter(conversationId, emit) + + // 记录最终 record 状态；finally 里用它调 messageBuilder.finalize() + let finalRecordStatus: 'done' | 'error' | 'cancel' = 'error' + + let transport: AcpTransport | null = null + let sandbox: SandboxInstance | null = null + let sandboxMcpClient: { close: () => Promise<void> } | null = null + let sessionWorkingDir: string | null = null + + try { + // 0. 确保 opencode.json 已从 example 初始化（若不存在） + + // 1. 使用基类共享设施初始化沙箱 + MCP + 系统提示 + const isCodingMode = options.mode === 'coding' + let sandboxResult: Awaited<ReturnType<typeof this.setupSandbox>> | null = null + + if (envId) { + await emit({ type: 'agent_phase', phase: 'preparing' }) + sandboxResult = await this.setupSandbox({ + conversationId, + envId, + userId, + userCredentials: options.userCredentials, + isCodingMode, + callback: getLiveCallback(conversationId), + model: modelId, + }) + sandbox = sandboxResult.sandbox + sandboxMcpClient = sandboxResult.mcpClient + // Coding mode: auto-allow all write tools + mark preview ready + if (isCodingMode && conversationId) { + this.allowAllWriteToolsForCodingMode(conversationId) + await this.markCodingPreviewReady(conversationId, sandbox) + } + } + + // 构建系统提示 + let systemPrompt = '' + if (envId) { + const promptResult = await this.buildSystemPrompt({ + envId, + isCodingMode, + sandboxCwd: sandboxResult?.sandboxCwd || null, + sandboxMode: sandboxResult?.sandboxMode || 'shared', + conversationId, + }) + systemPrompt = promptResult.systemPrompt + } + + // 2. 工作目录 + // - 沙箱模式：opencode cwd 用临时占位目录（opencode 需要一个本地目录启动， + // 但真实读写由 tools 转发到沙箱，不依赖这个目录） + // - 本地模式：用 options.cwd 或临时目录 + sessionWorkingDir = options.cwd ?? path.join(os.tmpdir(), `opencode-session-${uuidv4()}`) + if (!fs.existsSync(sessionWorkingDir)) { + fs.mkdirSync(sessionWorkingDir, { recursive: true }) + } + + // 3. 构造 spawn env — 把沙箱凭证 + AskUser 回调 URL 通过 env 注入 opencode 子进程 + const childEnv: Record<string, string> = { + // 指向项目内 .opencode/，隔离用户全局配置 + OPENCODE_CONFIG_DIR: getOpencodeConfigDir(), + } + if (sandbox) { + const authHeaders = await sandbox.getAuthHeaders() + childEnv.SANDBOX_MODE = '1' + childEnv.SANDBOX_BASE_URL = sandbox.baseUrl + childEnv.SANDBOX_AUTH_HEADERS_JSON = JSON.stringify(authHeaders) + childEnv.SANDBOX_WORKSPACE_ROOT = SANDBOX_WORKSPACE_ROOT + } else { + childEnv.SANDBOX_MODE = '0' + } + + // AskUser 内部 HTTP 回调：question custom tool execute 时 fetch 此 URL + // URL 从 ASK_USER_BASE_URL env（server 启动时设置）+ path + 查询参数拼成 + const askUserBase = process.env.ASK_USER_BASE_URL || '' + if (askUserBase) { + childEnv.ASK_USER_URL = `${askUserBase.replace(/\/$/, '')}/api/agent/internal/ask-user` + childEnv.ASK_USER_TOKEN = getAskUserToken() + childEnv.ASK_USER_CONVERSATION_ID = conversationId + } + + // 4. spawn opencode acp + const factory = getAcpTransportFactory('local-stdio') + transport = await factory({ + cwd: sessionWorkingDir, + signal: abortController.signal, + debug: process.env.OPENCODE_ACP_DEBUG === '1', + env: childEnv, + }) + + // 5. 建立 ACP connection + const conn = new ClientSideConnection( + () => ({ + sessionUpdate: async (params) => { + await this.handleSessionUpdate(params.update, emit) + }, + requestPermission: async (params) => { + // ACP 权限请求 → 桥接到前端 ToolConfirm UI + // + // 流程： + // 1. 生成/取 interruptId（前端用来回传 toolConfirmation） + // 2. 发 AgentCallbackMessage(type='tool_confirm')：前端显示确认卡片 + // 3. registerPending 注册一个挂起 Promise + // 4. await pending：handler 卡住 → opencode 也卡住 + // 5. 前端用户选择 → 下一轮 chatStream 带 toolConfirmation + // 6. chatStream 调 resolvePending → 本 Promise resolve → handler 返回 + // 7. opencode 收到 outcome 后继续 + const interruptId = params.toolCall?.toolCallId || uuidv4() + const toolName = params.toolCall?.title || 'unknown' + const toolInput = (params.toolCall?.rawInput as Record<string, unknown>) || {} + + await emit({ + type: 'tool_confirm', + id: interruptId, + name: toolName, + input: toolInput, + }) + + try { + // 这里会长时间挂起 — 直到外部 resolvePending 或 rejectPendingForConversation + return await registerPending(conversationId, interruptId, params.options as any[]) + } catch (e) { + // abort/reject 时 fallback：让 opencode 收到拒绝（避免它卡死） + const reject = + params.options.find((o: { kind: string }) => o.kind === 'reject_once') ?? + params.options[params.options.length - 1] + console.warn( + `[OpencodeAcpRuntime] pending permission rejected (conv=${conversationId}, interrupt=${interruptId}):`, + (e as Error).message, + ) + return { outcome: { outcome: 'selected', optionId: reject!.optionId } } + } + }, + }), + transport.stream, + ) + + // 6. ACP 握手 + await conn.initialize({ + protocolVersion: 1, + clientCapabilities: { + fs: { readTextFile: true, writeTextFile: true }, + terminal: false, + }, + }) + + // 7. 创建 session — 注入 CloudBase MCP server（全局 /cloudbase-mcp 路由） + // 全局 HTTP MCP server 挂载在 server 进程的 /cloudbase-mcp 路径。 + // 认证：复用 base-runtime.setupSandbox() 已签发的 sessionJwe（同 nex_session cookie 格式）， + // 与 storage/presign 的 tool-override 机制完全一致。 + // sandboxAuth 来自 sandbox.getAuthHeaders()，包含所有沙箱需要的 headers。 + // X-Session-Id 仅用于本地工具 schema 缓存 key，不传给沙箱。 + const mcpServers: Array<{ + type: 'http' + name: string + url: string + headers: Array<{ name: string; value: string }> + }> = [] + if (sandbox && sandboxResult?.sessionJwe) { + const authHeaders = await sandbox.getAuthHeaders() + const serverPort = Number(process.env.PORT) || 3001 + mcpServers.push({ + type: 'http', + name: 'cloudbase', + url: `http://localhost:${serverPort}/cloudbase-mcp`, + headers: [ + { name: 'X-Sandbox-Url', value: sandbox.baseUrl }, + { name: 'X-Sandbox-Auth', value: JSON.stringify(authHeaders) }, + { name: 'X-Session-Id', value: conversationId }, + { name: 'Cookie', value: `nex_session=${sandboxResult.sessionJwe}` }, + ], + }) + } + const newRes = await conn.newSession({ + cwd: sessionWorkingDir, + mcpServers, + }) + const opencodeSessionId = newRes.sessionId + + // 8. 选择模型 + try { + await conn.unstable_setSessionModel({ + sessionId: opencodeSessionId, + modelId, + }) + } catch (e) { + console.warn('[OpencodeAcpRuntime] setSessionModel failed:', (e as Error).message) + } + + // 9. 发送 prompt（阻塞直到完成） + // + // OpenCode 每次新 session 是空白上下文，如果之前 conversation 有历史消息， + // 把它们作为 context prefix 拼到本轮 prompt 前面，让 LLM 能做多轮记忆。 + // 同时注入基类构建的 systemPrompt（任务分类 + 沙箱上下文 + CloudBase 指引）。 + // + // 注意：Resume 场景（toolConfirmation/askAnswers）不会走到这里（早 return 了）， + // 所以 resume 时用的是原 opencode session 自带的上下文，不需要重新注入。 + let contextPrompt: string + if (envId) { + const historyPrompt = await buildHistoryContextPrompt(conversationId, envId, userId, prompt, { + excludeRecordIds: excludeHistoryRecordIds, + }) + // Prepend system prompt before history+user prompt + contextPrompt = systemPrompt ? `${systemPrompt}\n\n${historyPrompt}` : historyPrompt + } else { + contextPrompt = prompt + } + const promptRes = await conn.prompt({ + sessionId: opencodeSessionId, + prompt: [{ type: 'text', text: contextPrompt }], + }) + + // 非正常停止原因：LLM provider 拒绝 (refusal) / 超出 token 上限 (max_tokens) / + // 超过最大 turn 请求数 (max_turn_requests) 时，assistant 可能没有产出任何 text， + // 只有截断的 reasoning。给用户显式提示，避免"空回复"的困惑。 + // + // 注意：'cancelled' 不在此处提示（abort 流程走 catch 分支处理），'end_turn' 是正常完成。 + const stopReason = promptRes.stopReason + if (stopReason === 'refusal' || stopReason === 'max_tokens' || stopReason === 'max_turn_requests') { + const hint = buildStopReasonHint(stopReason) + try { + await emit({ type: 'text', content: hint }) + } catch { + /* noop */ + } + } + + await emit({ type: 'agent_phase', phase: 'idle' }) + await emit({ + type: 'result', + content: JSON.stringify({ + stopReason: promptRes.stopReason, + usage: (promptRes as { _meta?: { usage?: unknown } })._meta?.usage ?? null, + sandbox: sandbox ? { baseUrl: sandbox.baseUrl, conversationId: sandbox.conversationId } : null, + workingDir: sessionWorkingDir, + }), + }) + + completeAgent(conversationId, 'completed') + finalRecordStatus = 'done' + } catch (error: any) { + const isAbort = abortController.signal.aborted || error?.name === 'AbortError' + console.error('[OpencodeAcpRuntime] launchAgent error:', error) + // 释放挂起的权限请求（否则 opencode 子进程卡住 + chatStream 永远不返回） + const rejectedCount = rejectPendingForConversation( + conversationId, + isAbort ? 'Aborted' : `runtime error: ${error?.message || error}`, + ) + const rejectedQ = rejectPendingQuestionsForConversation( + conversationId, + isAbort ? 'Aborted' : `runtime error: ${error?.message || error}`, + ) + if ((rejectedCount > 0 || rejectedQ > 0) && process.env.OPENCODE_ACP_DEBUG) { + console.log( + `[OpencodeAcpRuntime] rejected ${rejectedCount} pending permissions + ${rejectedQ} pending questions due to error`, + ) + } + try { + await emit({ + type: 'error', + content: isAbort ? 'Aborted' : `OpenCode runtime error: ${error?.message || String(error)}`, + }) + } catch { + /* noop */ + } + completeAgent(conversationId, isAbort ? 'cancelled' : 'error', String(error?.message || error)) + finalRecordStatus = isAbort ? 'cancel' : 'error' + } finally { + if (transport) { + try { + transport.close() + } catch { + /* noop */ + } + } + // Archive to git（含 error/cancel 场景，保留最终工作状态） + if (sandbox) { + archiveToGit(sandbox, conversationId, prompt).catch((err) => { + console.error('[OpencodeAcpRuntime] archiveToGit failed:', err) + }) + } + // Close sandbox MCP client（同 CodeBuddy runtime 对齐） + if (sandboxMcpClient) { + try { + await sandboxMcpClient.close() + } catch { + /* noop */ + } + } + // 清理临时工作目录（如果是我们自己建的） + if (sessionWorkingDir && !options.cwd && sessionWorkingDir.startsWith(os.tmpdir())) { + try { + fs.rmSync(sessionWorkingDir, { recursive: true, force: true }) + } catch { + /* noop */ + } + } + // 消息持久化 finalize：写入最终 parts + 更新 record status + if (messageBuilder) { + try { + await messageBuilder.finalize(finalRecordStatus) + } catch (e) { + console.error('[OpencodeAcpRuntime] messageBuilder.finalize error:', e) + } + } + // 清掉临时 SSE stream_events（turn 结束后已无用，持久化已在 messages 集合） + // 与 Tencent SDK runtime 的 finally 块对齐，避免 CloudBase 积累孤儿数据 + if (envId) { + persistenceService.cleanupStreamEvents(conversationId, turnId).catch(() => { + /* Non-critical */ + }) + } + // 清掉 liveCallback + emitter 注册，避免 map 泄漏 + clearLiveCallback(conversationId) + clearEmitter(conversationId) + setTimeout(() => removeAgent(conversationId, turnId), 5000) + } + } + + /** + * ACP session/update → 内部 AgentCallbackMessage。 + */ + private async handleSessionUpdate(update: any, emit: (msg: AgentCallbackMessage) => Promise<void>): Promise<void> { + const tag = update.sessionUpdate as string | undefined + if (!tag) return + + switch (tag) { + case 'agent_message_chunk': { + const text = update.content?.text + if (typeof text === 'string' && text.length > 0) { + await emit({ type: 'text', content: text }) + } + break + } + case 'agent_thought_chunk': { + const text = update.content?.text + if (typeof text === 'string' && text.length > 0) { + await emit({ type: 'thinking', content: text }) + } + break + } + case 'tool_call': { + await emit({ + type: 'tool_use', + id: update.toolCallId, + name: update.title || update.kind || 'tool', + input: update.rawInput ?? {}, + }) + break + } + case 'tool_call_update': { + const status = update.status + if (status === 'completed' || status === 'failed') { + await emit({ + type: 'tool_result', + tool_use_id: update.toolCallId, + content: typeof update.rawOutput === 'string' ? update.rawOutput : JSON.stringify(update.rawOutput ?? ''), + is_error: status === 'failed', + }) + } else { + await emit({ + type: 'tool_input_update', + id: update.toolCallId, + input: (update.rawInput ?? {}) as Record<string, unknown>, + }) + } + break + } + case 'plan': { + await emit({ + type: 'thinking', + content: `[plan] ${JSON.stringify(update.entries ?? [])}`, + }) + break + } + case 'available_commands_update': + case 'usage_update': + case 'current_mode_update': + break + default: + if (process.env.OPENCODE_ACP_DEBUG) { + console.log('[OpencodeAcpRuntime] unhandled session/update:', tag, JSON.stringify(update).slice(0, 200)) + } + } + } +} + +// ─── Helpers ───────────────────────────────────────────────────────────── + +function makeEmitter(ctx: { + envId: string + userId: string + conversationId: string + turnId: string + messageBuilder: OpencodeMessageBuilder | null +}): (msg: AgentCallbackMessage) => Promise<void> { + const { envId, userId, conversationId, turnId, messageBuilder } = ctx + return async (msg) => { + const enriched: AgentCallbackMessage = { + ...msg, + sessionId: conversationId, + assistantMessageId: turnId, + } + + // 1. 喂给消息 builder（持久化） + if (messageBuilder) { + messageBuilder.pushEvent(enriched) + // 里程碑 flushToDb： + // - tool_use：工具开始执行 → 立刻落库，让前端在挂起期间能看到"待回答/待确认"卡片 + // （尤其 AskUserQuestion / ToolConfirm 场景，会等很久才有 tool_result） + // - tool_result：工具执行完毕 → 反映最新状态 + if (msg.type === 'tool_use' || msg.type === 'tool_result') { + messageBuilder.flushToDb().catch((e) => { + console.error('[OpencodeAcpRuntime] flushToDb error:', e) + }) + } + } + + // 2. 动态取 liveCallback：resume 时第二轮 SSE 的 callback 会替换第一轮的 + const liveCallback = getLiveCallback(conversationId) + if (liveCallback) { + try { + const seq = getNextSeq(conversationId) + await liveCallback(enriched, seq) + } catch (e) { + console.error('[OpencodeAcpRuntime] liveCallback error:', e) + } + } + if (envId) { + const acpEvent = CloudbaseAgentService.convertToSessionUpdate(enriched, conversationId) + if (acpEvent) { + const seq = getAgentRun(conversationId)?.lastSeq ?? 0 + persistenceService + .appendStreamEvents([ + { + eventId: uuidv4(), + conversationId, + turnId, + envId, + userId, + event: acpEvent, + seq, + createTime: Date.now(), + }, + ]) + .catch((e) => console.error('[OpencodeAcpRuntime] appendStreamEvents error:', e)) + } + } + } +} + +// ─── Singleton ──────────────────────────────────────────────────────────── + +export const opencodeAcpRuntime = new OpencodeAcpRuntime() + +/** + * 为非正常 stopReason 生成面向用户的提示文本，塞到 assistant 消息尾部。 + * + * - refusal：LLM provider 内容审查拒绝生成（如腾讯 MiMo 的 high risk 拦截）。 + * LLM 通常在这种情况下直接中断流，没有产出 text，只剩截断的 reasoning。 + * - max_tokens：触发输出 token 上限，回复被截断。 + * - max_turn_requests：LLM 在单轮内调用工具次数过多（通常是死循环）。 + */ +function buildStopReasonHint(stopReason: 'refusal' | 'max_tokens' | 'max_turn_requests'): string { + switch (stopReason) { + case 'refusal': + return [ + '', + '---', + '⚠️ **模型拒绝回复**：当前提问被 LLM provider 的内容安全策略拦截了。', + '', + '可能的原因：', + '- 提问或上下文中包含被模型方风险模型判定为敏感的内容（人名、专有名词、政治/安全相关话题等）。', + '- 多轮对话累积的 history 中有 provider 敏感词。', + '', + '建议：换一种表述方式重试，或清空当前会话重新开始；必要时切换到其他模型。', + ].join('\n') + case 'max_tokens': + return [ + '', + '---', + '⚠️ **输出被截断**：回复达到了模型的最大 token 上限，内容可能不完整。你可以回复"继续"让模型接着写。', + ].join('\n') + case 'max_turn_requests': + return [ + '', + '---', + '⚠️ **单轮工具调用次数达到上限**：为避免死循环，本轮已停止。', + '', + '建议：拆分任务，或重新描述目标让模型更聚焦地执行。', + ].join('\n') + } +} diff --git a/packages/server/src/agent/runtime/opencode-installer.ts b/packages/server/src/agent/runtime/opencode-installer.ts new file mode 100644 index 0000000..fa208cb --- /dev/null +++ b/packages/server/src/agent/runtime/opencode-installer.ts @@ -0,0 +1,52 @@ +/** + * OpenCode 项目级配置路径解析 + * + * 背景：opencode 用 `OPENCODE_CONFIG_DIR` env 指向项目级配置目录，里面含： + * - `opencode.json`（model / provider / tools 声明） + * - `tools/*.ts`（checked-in 的 tool override 源文件，覆盖 builtin 同名工具） + * + * 我们的项目把 `.opencode/` 直接签入仓库（.opencode/tools/read.ts 等）， + * 生产镜像 Dockerfile Stage 2 会把 `.opencode/` 拷贝到 `/app/.opencode/`。 + * 本模块负责把 `__dirname` 映射回项目根，从而定位到 `.opencode/` 目录。 + * + * 历史：曾有一个 `ensureOpencodeToolsInstalled()` 从 `src/agent/runtime/opencode-tool-templates/` + * 拷贝模板到 `.opencode/tools/`，但 38114f1 后 tools 直接签入仓库，安装步骤已废弃。 + */ + +import fs from 'node:fs' +import path from 'node:path' +import { fileURLToPath } from 'node:url' + +const __filename = fileURLToPath(import.meta.url) +const __dirname = path.dirname(__filename) + +/** + * 解析项目根目录。 + * 优先级： + * 1. OPENCODE_PROJECT_ROOT env（测试 / 自定义部署时覆盖） + * 2. 从 __dirname 向上找包含 packages/server 的 monorepo 根 + * 3. process.cwd() 兜底 + */ +export function resolveProjectRoot(): string { + const fromEnv = process.env.OPENCODE_PROJECT_ROOT + if (fromEnv) return fromEnv + + // 向上最多 8 层查找 monorepo 根（含 packages/server 子目录） + let dir = __dirname + for (let i = 0; i < 8; i++) { + if (fs.existsSync(path.join(dir, 'packages', 'server'))) return dir + const parent = path.dirname(dir) + if (parent === dir) break + dir = parent + } + + return process.cwd() +} + +/** + * 返回项目级 `.opencode/` 目录路径（供 spawn 时注入 OPENCODE_CONFIG_DIR）。 + * 可通过 OPENCODE_CONFIG_DIR env 覆盖（若用户自行设置则尊重用户）。 + */ +export function getOpencodeConfigDir(): string { + return process.env.OPENCODE_CONFIG_DIR ?? path.join(resolveProjectRoot(), '.opencode') +} diff --git a/packages/server/src/agent/runtime/opencode-message-builder.ts b/packages/server/src/agent/runtime/opencode-message-builder.ts new file mode 100644 index 0000000..2df2dbd --- /dev/null +++ b/packages/server/src/agent/runtime/opencode-message-builder.ts @@ -0,0 +1,397 @@ +/** + * OpencodeMessageBuilder + * + * 把 AgentCallbackMessage 事件流累积成 UnifiedMessagePart[]，用于持久化到 + * vibe_agent_messages 集合（对齐 Tencent SDK runtime，前端零改动读取）。 + * + * ## 为什么用 Builder + * + * OpenCode runtime 的事件流是 chunk 级别： + * text chunk × N → tool_use → tool_result → text chunk × M → result + * + * 前端读 DB 期望的 parts 数组是**合并后的结构**： + * [text(合并后), tool_call, tool_result, text(合并后)] + * + * Builder 负责这个 chunk → part 的聚合，并在合适的时机落库。 + * + * ## 为什么不每个 chunk 都写 DB + * + * 1. DB 写入是网络 IO，text chunk 几十个一条 prompt 可能几百上千个 + * 2. Tencent SDK 的模式是 agent 结束后一次性 syncMessages + * 3. 中间态的实时展示由 stream_events + SSE 负责（两条独立的通道） + * + * 所以 Builder 采用"累积 + 里程碑落库"策略： + * - 每次 pushEvent 追加内存 parts 数组 + * - 工具调用完成 / 最终 finalize 时触发 DB 落库 + * - finalize 时调 updateRecordStatus(assistantRecordId, 'done'|'error'|'cancel') + * + * ## 什么是"里程碑" + * + * - 每次 tool_result 事件（一个工具调用完整结束）→ 落一次 + * - finalize 时 → 落一次 + 改 status + * 这样用户每次看到工具执行完毕，DB 已经反映最新状态；即使 server 崩溃， + * 最坏丢失的是最后一段 text（stream_events 里仍然有，重启后 replay 可补偿）。 + */ + +import { v4 as uuidv4 } from 'uuid' +import type { AgentCallbackMessage, UnifiedMessagePart, UnifiedMessageRecord } from '@coder/shared' +import { persistenceService } from '../persistence.service.js' + +export interface OpencodeMessageBuilderOptions { + conversationId: string + assistantRecordId: string + envId: string + userId: string +} + +export class OpencodeMessageBuilder { + private readonly parts: UnifiedMessagePart[] = [] + + /** 当前正在累积的文本 part（遇到 tool_use 时 flush） */ + private currentTextBuffer: string[] = [] + + /** 当前正在累积的 thinking part（与 text 分开 buffer） */ + private currentThinkingBuffer: string[] = [] + + /** toolCallId → parts 数组中的 tool_call part 索引，用来 tool_input_update 时定位 */ + private toolCallIndexById = new Map<string, number>() + + private finalized = false + + constructor(private readonly opts: OpencodeMessageBuilderOptions) {} + + /** + * 处理一条 AgentCallbackMessage。 + * 注意：不在这里写 DB（为了性能和事务简化）；DB 落库通过 flushToDb() 手动触发。 + */ + pushEvent(msg: AgentCallbackMessage): void { + if (this.finalized) return + + switch (msg.type) { + case 'text': { + // 遇到新 text 前如果还有 thinking buffer，先 flush thinking + if (this.currentThinkingBuffer.length > 0) { + this.flushThinkingBuffer() + } + if (typeof msg.content === 'string' && msg.content.length > 0) { + this.currentTextBuffer.push(msg.content) + } + break + } + case 'thinking': { + if (this.currentTextBuffer.length > 0) { + this.flushTextBuffer() + } + if (typeof msg.content === 'string' && msg.content.length > 0) { + this.currentThinkingBuffer.push(msg.content) + } + break + } + case 'tool_use': { + // 工具开始前先 flush 所有文本 / 思考 + this.flushTextBuffer() + this.flushThinkingBuffer() + + const toolCallId = msg.id || uuidv4() + const part: UnifiedMessagePart = { + partId: uuidv4(), + contentType: 'tool_call', + content: JSON.stringify(msg.input ?? {}), + toolCallId, + metadata: { + toolCallName: msg.name, + toolName: msg.name, + input: msg.input, + status: 'in_progress', + }, + } + this.toolCallIndexById.set(toolCallId, this.parts.length) + this.parts.push(part) + break + } + case 'tool_input_update': { + // 更新已有 tool_call part 的 input + const toolCallId = msg.id + if (!toolCallId) break + const idx = this.toolCallIndexById.get(toolCallId) + if (idx === undefined) break + const existing = this.parts[idx] + if (!existing || existing.contentType !== 'tool_call') break + existing.content = JSON.stringify(msg.input ?? {}) + existing.metadata = { + ...(existing.metadata ?? {}), + input: msg.input, + } + break + } + case 'tool_result': { + const toolCallId = msg.tool_use_id || msg.id + const part: UnifiedMessagePart = { + partId: uuidv4(), + contentType: 'tool_result', + content: typeof msg.content === 'string' ? msg.content : JSON.stringify(msg.content ?? ''), + toolCallId, + metadata: { + status: msg.is_error ? 'error' : 'completed', + isError: !!msg.is_error, + }, + } + this.parts.push(part) + + // 同步更新对应 tool_call 的 status + if (toolCallId) { + const idx = this.toolCallIndexById.get(toolCallId) + if (idx !== undefined) { + const callPart = this.parts[idx] + if (callPart && callPart.contentType === 'tool_call') { + callPart.metadata = { + ...(callPart.metadata ?? {}), + status: msg.is_error ? 'error' : 'completed', + } + } + } + } + break + } + case 'result': + case 'error': + case 'agent_phase': + case 'session': + case 'tool_confirm': + case 'ask_user': + case 'artifact': + // 这些不进 parts 数组（stream_events 已处理实时推送） + // ask_user/tool_confirm 的状态通过 stream_events + turn lifecycle 展示 + break + } + } + + /** + * 把当前累积的 parts 一次性写入 DB（replace）。 + * 触发点：tool_result 之后 + finalize 之前。 + */ + async flushToDb(): Promise<void> { + if (this.finalized) return + // 先把待定 buffer flush 到 parts 数组，然后写库 + const snapshot = this.snapshotParts() + if (this.opts.envId) { + try { + await persistenceService.setRecordParts(this.opts.assistantRecordId, snapshot) + } catch (e) { + console.error('[OpencodeMessageBuilder] setRecordParts failed:', e) + } + } + } + + /** + * 结束构建：flush buffer → 写 DB → 更新 record status。 + * status = 'done' | 'error' | 'cancel' + */ + async finalize(status: 'done' | 'error' | 'cancel'): Promise<void> { + if (this.finalized) return + this.finalized = true + + const snapshot = this.snapshotParts() + if (this.opts.envId) { + try { + await persistenceService.setRecordParts(this.opts.assistantRecordId, snapshot) + } catch (e) { + console.error('[OpencodeMessageBuilder] setRecordParts on finalize failed:', e) + } + try { + await persistenceService.finalizePendingRecords(this.opts.assistantRecordId, status) + } catch (e) { + console.error('[OpencodeMessageBuilder] finalizePendingRecords failed:', e) + } + } + } + + /** 当前已累积的 parts 快照（flush 临时 buffer 到数组里） */ + private snapshotParts(): UnifiedMessagePart[] { + // 为快照创建一个非破坏性 flush：临时合并 buffer + const extra: UnifiedMessagePart[] = [] + if (this.currentTextBuffer.length > 0) { + extra.push(this.buildTextPart(this.currentTextBuffer.join(''))) + } + if (this.currentThinkingBuffer.length > 0) { + extra.push(this.buildThinkingPart(this.currentThinkingBuffer.join(''))) + } + return [...this.parts, ...extra] + } + + private flushTextBuffer(): void { + if (this.currentTextBuffer.length === 0) return + this.parts.push(this.buildTextPart(this.currentTextBuffer.join(''))) + this.currentTextBuffer = [] + } + + private flushThinkingBuffer(): void { + if (this.currentThinkingBuffer.length === 0) return + this.parts.push(this.buildThinkingPart(this.currentThinkingBuffer.join(''))) + this.currentThinkingBuffer = [] + } + + private buildTextPart(text: string): UnifiedMessagePart { + return { + partId: uuidv4(), + contentType: 'text', + content: text, + metadata: { + id: this.opts.assistantRecordId, + type: 'message', + role: 'assistant', + }, + } + } + + private buildThinkingPart(text: string): UnifiedMessagePart { + return { + partId: uuidv4(), + contentType: 'reasoning', + content: text, + } + } +} + +// ─── Helpers ────────────────────────────────────────────────────────────── + +/** + * 根据 conversationId 查找上一轮 assistant recordId（用于新 user record 的 + * replyTo / parentId 建链）。没有历史时返回 null。 + */ +export async function findLastRecordIds( + conversationId: string, + envId: string, + userId: string, +): Promise<{ prevRecordId: string | null; lastAssistantRecordId: string | null }> { + if (!envId || !conversationId) return { prevRecordId: null, lastAssistantRecordId: null } + try { + const records = await persistenceService.loadDBMessages(conversationId, envId, userId, 2) + // loadDBMessages 返回按 createTime 升序的完整 records（最多 2 条，取最后 1 轮 QA） + let prevRecordId: string | null = null + let lastAssistantRecordId: string | null = null + for (const r of records) { + prevRecordId = r.recordId + if (r.role === 'assistant') lastAssistantRecordId = r.recordId + } + return { prevRecordId, lastAssistantRecordId } + } catch { + return { prevRecordId: null, lastAssistantRecordId: null } + } +} + +/** + * 从 DB 读最近 N 轮历史对话，构造一个 "context prompt prefix" 让新建的 opencode + * session 看到之前的上下文。 + * + * 为什么需要：OpenCode 每次 chatStream 都 newSession（空白上下文）。如果不注入 + * 历史，LLM 无法回答"上一轮我说过什么"。 + * + * 格式（Markdown 分层，模型自然理解）： + * Below is the prior conversation history. Use it as context when responding. + * + * --- + * + * ## Turn 1 + * + * **User:** 你好，我叫王小明 + * + * **Assistant:** 你好王小明，有什么我可以帮你的？ + * + * [Tool call] AskUserQuestion + * params: question, header, options, multiSelect + * + * [Tool result] AskUserQuestion — completed (28 bytes) + * + * --- + * + * ## Current user message + * + * <实际 prompt> + * + * 安全截断策略： + * - tool_call：只输出工具名 + 参数名列表，**不包含参数值**（避免 JSON 截断半截） + * - tool_result：输出工具名 + status + 字节数，**不输出原始内容**（避免 context 爆表） + * - reasoning：完全跳过（LLM 已消化，再放进去是噪声） + */ +export async function buildHistoryContextPrompt( + conversationId: string, + envId: string, + userId: string, + newPrompt: string, + opts: { maxHistoryRecords?: number; excludeRecordIds?: ReadonlySet<string> } = {}, +): Promise<string> { + const { maxHistoryRecords = 20, excludeRecordIds } = opts + if (!envId || !conversationId) return newPrompt + + try { + const records = await persistenceService.loadDBMessages(conversationId, envId, userId, maxHistoryRecords) + if (records.length === 0) return newPrompt + + // 过滤掉被排除的 record 和非 done 状态 + const usableRecords = records.filter((r) => { + if (excludeRecordIds?.has(r.recordId)) return false + if (r.status !== 'done') return false + return true + }) + + if (usableRecords.length === 0) return newPrompt + + // 把 records 按"user + 其后的 assistant"分组成 turns + // 策略：遇到 user record 就开启新 turn（turn number 随之递增） + const sections: string[] = [] + let turnNumber = 0 + let currentTurnLines: string[] = [] + + const flushTurn = () => { + if (currentTurnLines.length === 0) return + sections.push(`## Turn ${turnNumber}\n\n${currentTurnLines.join('\n\n')}`) + currentTurnLines = [] + } + + for (const r of usableRecords) { + if (r.role === 'user') { + // 开新 turn + flushTurn() + turnNumber += 1 + currentTurnLines = [] + } + + for (const p of r.parts || []) { + if (p.contentType === 'text' && p.content) { + const rolePrefix = r.role === 'user' ? '**User:**' : '**Assistant:**' + currentTurnLines.push(`${rolePrefix} ${p.content.trim()}`) + } else if (p.contentType === 'reasoning') { + // 不入 context + } else if (p.contentType === 'tool_call') { + const toolName = (p.metadata?.toolName as string) ?? (p.metadata?.toolCallName as string) ?? 'tool' + // 只输出参数名列表，不含参数值（安全截断，避免 JSON 断截） + const input = p.metadata?.input as Record<string, unknown> | undefined + const paramKeys = input ? Object.keys(input) : [] + const paramLine = paramKeys.length > 0 ? `\n params: ${paramKeys.join(', ')}` : '' + currentTurnLines.push(`[Tool call] ${toolName}${paramLine}`) + } else if (p.contentType === 'tool_result') { + const toolName = (p.metadata?.toolName as string) ?? 'tool' + const status = (p.metadata?.status as string) ?? 'unknown' + const byteCount = typeof p.content === 'string' ? p.content.length : 0 + currentTurnLines.push(`[Tool result] ${toolName} — ${status} (${byteCount} bytes)`) + } + } + } + flushTurn() + + if (sections.length === 0) return newPrompt + + const header = 'Below is the prior conversation history. Use it as context when responding.' + return `${header}\n\n---\n\n${sections.join('\n\n---\n\n')}\n\n---\n\n## Current user message\n\n${newPrompt}` + } catch (e) { + console.warn('[buildHistoryContextPrompt] failed, falling back to raw prompt:', (e as Error).message) + return newPrompt + } +} + +/** + * 避免 tsc 类型未引用警告 + */ +// eslint-disable-next-line @typescript-eslint/no-unused-vars +type _KeepUnifiedMessageRecord = UnifiedMessageRecord diff --git a/packages/server/src/agent/runtime/pending-permission-registry.ts b/packages/server/src/agent/runtime/pending-permission-registry.ts new file mode 100644 index 0000000..82cadf3 --- /dev/null +++ b/packages/server/src/agent/runtime/pending-permission-registry.ts @@ -0,0 +1,155 @@ +/** + * PendingPermissionRegistry + * + * 存放被挂起的 ACP `requestPermission` 调用，跨 chatStream 请求传递用户决策。 + * + * 场景（OpenCode ACP 下的 ToolConfirm 流程）： + * + * 1. opencode 子进程对工具调用发 `session/request_permission` + * 2. ClientSideConnection 的 `requestPermission` handler 被触发 + * 3. handler： + * a. 通过 emit 发 AgentCallbackMessage(type='tool_confirm') 给前端 SSE + * b. 调用 `registerPending(convId, interruptId, options)` 拿到 pending Promise + * c. `return await pending` → 本 handler 挂起（opencode 也挂起） + * 4. 前端用户点 "允许/拒绝" → 下一轮 session/prompt 带 params.toolConfirmation + * 5. routes/acp.ts 照常调 runtime.chatStream(options.toolConfirmation) + * 6. runtime 检测到： + * - isAgentRunning → 已有挂起的 agent + * - options.toolConfirmation 非空 + * → 调 `resolvePending(convId, interruptId, action)` 喂给挂起的 Promise + * 7. opencode 收到 outcome，继续执行，session/update 事件从卡住的地方恢复 + * + * 内存存储，进程重启清空（与 agent-registry 一致）。 + * 同一个 conversationId 同时只能有一个挂起的权限请求（opencode 本身保证序列化）。 + */ + +import type { RequestPermissionResponse } from '@agentclientprotocol/sdk' + +type AcpOption = { + optionId: string + kind: 'allow_once' | 'allow_always' | 'reject_once' | 'reject_always' | string + name?: string +} + +export interface PendingPermission { + conversationId: string + /** 对应 toolCallId（前端 resume 时传 interruptId） */ + interruptId: string + options: AcpOption[] + /** 创建时间（用于调试和超时清理） */ + createdAt: number + /** + * resolve opencode ACP `requestPermission` 返回值。 + * 这个函数被 runtime 外部（resolvePending）调用。 + */ + resolve: (outcome: RequestPermissionResponse) => void + /** reject 用于 abort 场景 */ + reject: (reason?: unknown) => void +} + +const pending = new Map<string, PendingPermission>() + +function key(conversationId: string, interruptId: string): string { + return `${conversationId}::${interruptId}` +} + +/** + * 注册一个挂起的权限请求，返回 Promise 给 ACP handler。 + * ACP handler 应该 `await` 这个 Promise，Promise resolve 时 handler 返回给 opencode。 + */ +export function registerPending( + conversationId: string, + interruptId: string, + options: AcpOption[], +): Promise<RequestPermissionResponse> { + return new Promise((resolve, reject) => { + const existing = pending.get(key(conversationId, interruptId)) + if (existing) { + // 边界：同一 interruptId 重复注册（理论上不应发生）—— 清理旧的 + existing.reject(new Error('Replaced by new pending permission')) + } + pending.set(key(conversationId, interruptId), { + conversationId, + interruptId, + options, + createdAt: Date.now(), + resolve, + reject, + }) + }) +} + +/** + * 由 runtime（下一轮 chatStream）调用：根据用户 action 查找对应 ACP 选项 id，喂给挂起的 handler。 + * + * @returns true 表示成功找到并 resolve；false 表示没有挂起的记录（可能 agent 已超时/被 cancel） + */ +export function resolvePending( + conversationId: string, + interruptId: string, + action: 'allow' | 'allow_always' | 'deny' | 'reject_and_exit_plan', +): boolean { + const entry = pending.get(key(conversationId, interruptId)) + if (!entry) return false + + const optionId = pickOptionId(entry.options, action) + pending.delete(key(conversationId, interruptId)) + entry.resolve({ + outcome: { outcome: 'selected', optionId }, + }) + return true +} + +/** + * 由 abort 逻辑调用：把所有该 conversation 的挂起权限请求 reject，让 opencode 收到错误退出。 + */ +export function rejectPendingForConversation(conversationId: string, reason = 'Aborted'): number { + let count = 0 + for (const [k, entry] of pending) { + if (entry.conversationId === conversationId) { + entry.reject(new Error(reason)) + pending.delete(k) + count++ + } + } + return count +} + +/** 是否有挂起的权限请求（调试/observability 用） */ +export function hasPending(conversationId: string): boolean { + for (const entry of pending.values()) { + if (entry.conversationId === conversationId) return true + } + return false +} + +/** + * 把 PermissionAction 映射到 ACP options 的 optionId。 + * + * ACP options 的 kind 可能包括： + * - allow_once: 本次允许 + * - allow_always: 永远允许 + * - reject_once: 本次拒绝 + * - reject_always: 永远拒绝（OpenCode 不一定提供） + * + * 前端 PermissionAction: + * - allow → allow_once + * - allow_always → allow_always（没有就 fallback 到 allow_once） + * - deny → reject_once + * - reject_and_exit_plan → reject_once（ExitPlanMode 特化，opencode 端视同拒绝） + */ +function pickOptionId(options: AcpOption[], action: string): string { + const findKind = (kind: string) => options.find((o) => o.kind === kind) + + switch (action) { + case 'allow': + return (findKind('allow_once') ?? findKind('allow_always') ?? options[0]).optionId + case 'allow_always': + return (findKind('allow_always') ?? findKind('allow_once') ?? options[0]).optionId + case 'deny': + case 'reject_and_exit_plan': + return (findKind('reject_once') ?? findKind('reject_always') ?? options[options.length - 1]).optionId + default: + return options[0].optionId + } +} diff --git a/packages/server/src/agent/runtime/pending-question-registry.ts b/packages/server/src/agent/runtime/pending-question-registry.ts new file mode 100644 index 0000000..ae0b135 --- /dev/null +++ b/packages/server/src/agent/runtime/pending-question-registry.ts @@ -0,0 +1,110 @@ +/** + * PendingQuestionRegistry + * + * 挂起"question tool"的 HTTP 回调，等用户通过下一轮 prompt.askAnswers 回答。 + * + * 对比 PendingPermissionRegistry（用于 ToolConfirm）： + * - PermissionRegistry 挂 ACP JSON-RPC Promise（opencode stdio ACP 协议里） + * - QuestionRegistry 挂 **HTTP 响应**（opencode 子进程里 custom tool 通过 fetch 调进来） + * + * 流程： + * 1. opencode 子进程的 custom tool `question` execute： + * fetch POST <server>/api/agent/internal/ask-user + * body { conversationId, toolCallId, questions } + * 2. server handler： + * registerPendingQuestion(convId, toolCallId, res) → res 挂起直到 resolve + * 同时 emit `ask_user` AgentCallbackMessage → 转为 SSE sessionUpdate 给前端 + * 3. 前端展示 AskUserForm，用户答完 → 下一轮 POST /api/agent/acp + * body.askAnswers = { toolCallId: { answers: {...} } } + * 4. routes/acp.ts 把 askAnswers 传给 runtime.chatStream + * 5. runtime 判断 isAgentRunning + options.askAnswers 非空： + * 对每个 toolCallId 调 resolvePendingQuestion → res.json({ answers }) → tool execute 返回 + * 6. opencode 收到 tool_result，LLM 继续推理 + */ + +import type { ServerResponse } from 'node:http' + +/** + * 存放的上下文。 + * + * - `response`: Hono/Node 返回的 HTTP response 对象的写入句柄。 + * 为什么不直接存 Hono Context？—— context 生命周期短，req 结束会销毁。 + * 用底层 ServerResponse（Node 原生）更可靠，或者 Hono 的 streaming primitive。 + * 这里存一个简单的 resolve 函数，由 route handler 关联到自身的 response。 + */ +export interface PendingQuestion { + conversationId: string + toolCallId: string + questions: unknown[] + createdAt: number + /** 由 route handler 提供：接收最终答案后写回 HTTP 响应 */ + resolve: (answers: Record<string, string>) => void + reject: (reason: string) => void +} + +const pending = new Map<string, PendingQuestion>() + +function key(conversationId: string, toolCallId: string): string { + return `${conversationId}::${toolCallId}` +} + +/** + * 由 HTTP handler 调用，记录一个挂起的 question 请求。 + */ +export function registerPendingQuestion(entry: PendingQuestion): void { + const k = key(entry.conversationId, entry.toolCallId) + const existing = pending.get(k) + if (existing) { + existing.reject('Replaced by new question request') + } + pending.set(k, entry) +} + +/** + * 由 runtime.chatStream 的 resume 分支调用：找到挂起的 question，写回答案。 + * + * @returns true 表示成功；false 表示没找到（可能已超时） + */ +export function resolvePendingQuestion( + conversationId: string, + toolCallId: string, + answers: Record<string, string>, +): boolean { + const k = key(conversationId, toolCallId) + const entry = pending.get(k) + if (!entry) return false + pending.delete(k) + entry.resolve(answers) + return true +} + +/** + * 错误/abort 时清理该 conversation 下所有挂起 question，让 HTTP 调用方拿到失败。 + */ +export function rejectPendingQuestionsForConversation(conversationId: string, reason = 'Aborted'): number { + let count = 0 + for (const [k, entry] of pending) { + if (entry.conversationId === conversationId) { + entry.reject(reason) + pending.delete(k) + count++ + } + } + return count +} + +export function hasPendingQuestion(conversationId: string): boolean { + for (const entry of pending.values()) { + if (entry.conversationId === conversationId) return true + } + return false +} + +/** Debug only */ +export function listPendingQuestions(): ReadonlyArray<PendingQuestion> { + return Array.from(pending.values()) +} + +// Explicit no-op import to keep ServerResponse referenced (avoids unused-type lint) +// eslint-disable-next-line @typescript-eslint/no-unused-vars +type _KeepServerResponseImportForDocs = ServerResponse diff --git a/packages/server/src/agent/runtime/registry.ts b/packages/server/src/agent/runtime/registry.ts new file mode 100644 index 0000000..09e7531 --- /dev/null +++ b/packages/server/src/agent/runtime/registry.ts @@ -0,0 +1,82 @@ +/** + * AgentRuntimeRegistry + * + * 集中管理所有 IAgentRuntime 实例 + 提供选择策略。 + * + * 选择优先级（高到低）： + * 1. 显式参数（如 routes/acp.ts 从请求 body / task 记录读取的 runtime 字段） + * 2. 环境变量 AGENT_RUNTIME（部署级 override） + * 3. registry 默认 runtime（本地开发期） + * + * 注册：默认包含 codebuddy + opencode-acp，可通过 register() 扩展。 + * 向后兼容：'tencent-sdk' 作为 'codebuddy' 的别名。 + */ + +import type { IAgentRuntime, RuntimeSelectorOptions } from './types.js' +import { codebuddyRuntime } from './codebuddy-runtime.js' +import { opencodeAcpRuntime } from './opencode-acp-runtime.js' + +const DEFAULT_RUNTIME = process.env.AGENT_RUNTIME_DEFAULT || 'codebuddy' + +class AgentRuntimeRegistry { + private runtimes = new Map<string, IAgentRuntime>() + + constructor() { + // 默认注册的 runtime + this.register(codebuddyRuntime) + this.register(opencodeAcpRuntime) + // 向后兼容别名：DB 中已存的 'tencent-sdk' 能正确 resolve + this.runtimes.set('tencent-sdk', codebuddyRuntime) + } + + register(runtime: IAgentRuntime): void { + this.runtimes.set(runtime.name, runtime) + } + + get(name: string): IAgentRuntime | undefined { + return this.runtimes.get(name) + } + + list(): IAgentRuntime[] { + // 去重：别名不重复列出 + const seen = new Set<IAgentRuntime>() + for (const r of this.runtimes.values()) { + seen.add(r) + } + return Array.from(seen) + } + + /** + * 根据选择策略返回应使用的 runtime。 + * 不做可用性检查（调用方自行检查或 runtime 在 chatStream 中报错）。 + */ + resolve(options: RuntimeSelectorOptions = {}): IAgentRuntime { + const candidates = [options.explicitRuntime, process.env.AGENT_RUNTIME, DEFAULT_RUNTIME].filter(Boolean) as string[] + + for (const name of candidates) { + const r = this.runtimes.get(name) + if (r) return r + } + + // 兜底：返回任何已注册的 runtime + const fallback = this.runtimes.get('codebuddy') ?? this.runtimes.values().next().value + if (!fallback) throw new Error('No agent runtime registered') + return fallback + } + + /** + * 如果调用方需要确认 runtime 真实可用（如启动时探测）。 + */ + async resolveWithAvailability(options: RuntimeSelectorOptions = {}): Promise<IAgentRuntime> { + const r = this.resolve(options) + const available = await r.isAvailable() + if (!available && r.name !== 'codebuddy') { + // 不可用 → 退回默认 codebuddy + const fallback = this.runtimes.get('codebuddy') + if (fallback) return fallback + } + return r + } +} + +export const agentRuntimeRegistry = new AgentRuntimeRegistry() diff --git a/packages/server/src/agent/runtime/types.ts b/packages/server/src/agent/runtime/types.ts new file mode 100644 index 0000000..1375b17 --- /dev/null +++ b/packages/server/src/agent/runtime/types.ts @@ -0,0 +1,96 @@ +/** + * Agent Runtime 抽象层 + * + * 设计目标：把"具体 agent 实现（Tencent SDK / OpenCode ACP / Claude Code ACP / ...）" + * 与"对外的会话/流式/持久化逻辑（routes/acp.ts、persistence.service.ts）"解耦。 + * + * 现状：原 `CloudbaseAgentService` 直接耦合 `@tencent-ai/agent-sdk`。 + * 重构后：`CloudbaseAgentService` 退化为 `CodeBuddyRuntime`（实现 IAgentRuntime）， + * 新增 `OpencodeAcpRuntime`，由 `AgentRuntimeRegistry` 调度。 + * + * 关键约束（来自 routes/acp.ts 现有调用面）： + * 1. `chatStream(prompt, callback, options)` 签名保持不变 + * 2. callback 收到 `AgentCallbackMessage`，由 `convertToSessionUpdate` 转 ACP `SessionUpdate` + * （所以 runtime 实现者需把自己的事件流"翻译"为 AgentCallbackMessage） + * 3. 返回 `{ turnId, alreadyRunning }`：turnId == assistantMessageId + * 4. 必须配合 `agent-registry`、`persistence.service`、`event-buffer` 三件套 + * （runtime 不直接 import 它们，由 BaseAgentRuntime 抽象类提供基础设施） + */ + +import type { AgentCallback, AgentCallbackMessage, AgentOptions } from '@coder/shared' +import type { ModelInfo } from '../cloudbase-agent.service.js' + +/** + * Runtime 启动 chatStream 后的返回。 + * + * - turnId: 本轮 assistant 消息在 DB 的 record id（用于 SSE observe / persistence） + * - alreadyRunning: 同一 conversation 已有 agent 在跑 → 调用方应直接 observe 已有 turn + */ +export interface ChatStreamResult { + turnId: string + alreadyRunning: boolean +} + +/** + * Agent Runtime 接口 + * + * 实现者必须： + * - 接收 `prompt + options`，启动一次"会话回合" + * - 通过 `callback` 实时推送 `AgentCallbackMessage`（type 列见 packages/shared/src/types/agent.ts） + * - 把自身事件流（如 ACP `session/update`、Tencent SDK 的 query iterator）转成 AgentCallbackMessage + * - 处理 abort / resume / askAnswers / toolConfirmation 等 options 字段 + * - 返回 `{ turnId, alreadyRunning }`，turnId 用于后续 SSE observe + */ +export interface IAgentRuntime { + /** + * Runtime 唯一标识（e.g. 'codebuddy', 'opencode-acp', 'claude-code-acp'） + */ + readonly name: string + + /** + * Runtime 是否可用（依赖检测，如 opencode CLI 是否安装、SDK 是否能 import）。 + * Registry 会在选择 runtime 前调用，避免选到不可用的 runtime。 + */ + isAvailable(): Promise<boolean> + + /** + * 列出此 runtime 支持的模型。 + * 用于前端模型选择器。不同 runtime 可暴露不同的模型集合。 + */ + getSupportedModels(): Promise<ModelInfo[]> + + /** + * 启动一次 chat 流。 + * + * 行为约定（必须严格遵守，否则 routes/acp.ts 的 SSE 流会卡住）： + * 1. 同步返回 `{ turnId, alreadyRunning }` + * 2. 后台 fire-and-forget 跑 agent，通过 callback 推送 message + * 3. 完成时推送 `type: 'result'` message（callback 触发后视为本轮结束） + * 4. 若 abort，推送 `type: 'error', content: 'Aborted'` + * 5. callback 调用顺序需保持单调时间序（不要并发 await） + * + * @param prompt 用户输入 + * @param callback 实时事件回调（可为 null，仅持久化不实时推） + * @param options 见 packages/shared/src/types/agent.ts AgentOptions + */ + chatStream(prompt: string, callback: AgentCallback | null, options: AgentOptions): Promise<ChatStreamResult> +} + +/** + * Runtime 选择策略。 + * + * 优先级： + * 1. 显式 `runtime` 字段（来自请求 body 或 task 记录） + * 2. 环境变量 `AGENT_RUNTIME` + * 3. registry 默认 runtime（构造时指定） + */ +export interface RuntimeSelectorOptions { + explicitRuntime?: string + conversationId?: string +} + +/** + * 把任意 runtime 内部事件桥接为 AgentCallbackMessage 时常用的辅助类型。 + * runtime 实现者可以用 EventBridge 的工具方法减少样板代码。 + */ +export type EmitFn = (msg: AgentCallbackMessage) => void diff --git a/packages/server/src/db/cloudbase/repositories.ts b/packages/server/src/db/cloudbase/repositories.ts index 80a6962..c82f155 100644 --- a/packages/server/src/db/cloudbase/repositories.ts +++ b/packages/server/src/db/cloudbase/repositories.ts @@ -211,6 +211,7 @@ function withTaskDefaults(task: Record<string, unknown>): Task { mode: doc.mode || 'default', status: doc.status || 'pending', selectedAgent: doc.selectedAgent ?? 'codebuddy', + selectedRuntime: doc.selectedRuntime ?? null, sandboxMode: doc.sandboxMode || 'isolated', installDependencies: doc.installDependencies ?? false, maxDuration: doc.maxDuration ?? 300, @@ -300,6 +301,7 @@ class CloudBaseTaskRepository implements TaskRepository { title: null, repoUrl: null, selectedModel: null, + selectedRuntime: null, logs: null, error: null, branchName: null, diff --git a/packages/server/src/db/schema.ts b/packages/server/src/db/schema.ts index df45410..0246983 100644 --- a/packages/server/src/db/schema.ts +++ b/packages/server/src/db/schema.ts @@ -64,6 +64,7 @@ export const tasks = sqliteTable( repoUrl: text('repo_url'), selectedAgent: text('selected_agent').default('claude'), selectedModel: text('selected_model'), + selectedRuntime: text('selected_runtime'), // 'tencent-sdk' | 'opencode-acp' | null (null = registry default) mode: text('mode').notNull().default('default'), // 'default' | 'coding' installDependencies: integer('install_dependencies', { mode: 'boolean' }).default(false), maxDuration: integer('max_duration').default(parseInt(process.env.MAX_SANDBOX_DURATION || '300', 10)), diff --git a/packages/server/src/db/types.ts b/packages/server/src/db/types.ts index 49528da..6068eef 100644 --- a/packages/server/src/db/types.ts +++ b/packages/server/src/db/types.ts @@ -37,6 +37,7 @@ export interface Task { repoUrl: string | null selectedAgent: string | null selectedModel: string | null + selectedRuntime: string | null mode: string installDependencies: boolean | null maxDuration: number | null @@ -216,6 +217,7 @@ type TaskNullableFields = | 'repoUrl' | 'selectedAgent' | 'selectedModel' + | 'selectedRuntime' | 'installDependencies' | 'maxDuration' | 'keepAlive' diff --git a/packages/server/src/index.ts b/packages/server/src/index.ts index 181cfa6..0135eba 100644 --- a/packages/server/src/index.ts +++ b/packages/server/src/index.ts @@ -50,6 +50,7 @@ import apiKeysRoutes from './routes/api-keys' import miscRoutes from './routes/misc' import reposRoutes from './routes/repos' import databaseRoutes from './routes/database.js' +import mcpCloudbaseRoutes from './routes/mcp-cloudbase.js' import storageRoutes from './routes/storage.js' import functionsRoutes from './routes/functions.js' import sqlRoutes from './routes/sql.js' @@ -70,6 +71,9 @@ app.use( // API routes (must be before static files) app.use('*', authMiddleware) +// CloudBase MCP HTTP server (for OpenCode ACP runtime — self-authenticates via X-Sandbox-Auth) +app.route('/cloudbase-mcp', mcpCloudbaseRoutes) + app.get('/health', (c) => c.json({ status: 'ok' })) app.route('/api/auth', authRoutes) app.route('/api/auth/github', githubAuthRoutes) @@ -146,6 +150,12 @@ async function backfillApiKeys() { const PORT = Number(process.env.PORT) || 3001 +// 让 OpencodeAcpRuntime 知道自己的 base URL（用于 spawn opencode 时注入 ASK_USER_URL）。 +// 仅 127.0.0.1 回环，opencode 子进程同机运行。 +if (!process.env.ASK_USER_BASE_URL) { + process.env.ASK_USER_BASE_URL = `http://127.0.0.1:${PORT}` +} + serve({ fetch: app.fetch, port: PORT }, () => { console.log(`Server running on http://localhost:${PORT}`) if (serveStaticFiles) { diff --git a/packages/server/src/routes/acp.ts b/packages/server/src/routes/acp.ts index 2d6560f..d9e20f3 100644 --- a/packages/server/src/routes/acp.ts +++ b/packages/server/src/routes/acp.ts @@ -13,9 +13,12 @@ import { type AgentCallback, type AgentCallbackMessage, } from '@coder/shared' -import { CloudbaseAgentService, cloudbaseAgentService, getSupportedModels } from '../agent/cloudbase-agent.service.js' +import { CloudbaseAgentService, getSupportedModels } from '../agent/cloudbase-agent.service.js' import { persistenceService } from '../agent/persistence.service.js' import { getAgentRun } from '../agent/agent-registry.js' +import { agentRuntimeRegistry } from '../agent/runtime/index.js' +import { emitForConversation, getAskUserToken } from '../agent/runtime/opencode-acp-runtime.js' +import { registerPendingQuestion } from '../agent/runtime/pending-question-registry.js' import { loadConfig } from '../config/store.js' import { getDb } from '../db/index.js' import { nanoid } from 'nanoid' @@ -23,9 +26,22 @@ import { requireUserEnv, type AppEnv } from '../middleware/auth.js' const acp = new Hono<AppEnv>() -// 除 /health 外，所有 ACP 路由都需要登录 + 用户环境校验 +// 除 /health 与 /runtimes 外，所有 ACP 路由都需要登录 + 用户环境校验 +// /internal/* 走独立 127.0.0.1 + shared token 认证（绕过用户会话） acp.use('/*', async (c, next) => { - if (c.req.path.endsWith('/health') || c.req.path.endsWith('/config')) { + const p = c.req.path + if (p.endsWith('/health') || p.endsWith('/config') || p.endsWith('/runtimes')) { + return next() + } + if (p.includes('/internal/')) { + // 仅接受 127.0.0.1 + 正确 token 的请求 + // 注意：Hono 不直接提供 remote addr 但可从 header X-Forwarded-For 判断； + // 这里更务实 — 用 token 作为主要防线（opencode 子进程是我们自己 spawn 的） + const expected = getAskUserToken() + const got = c.req.header('X-Internal-Token') + if (!expected || got !== expected) { + return c.json({ error: 'Unauthorized internal call' }, 401) + } return next() } // If using API key auth, verify it has 'acp' scope @@ -194,8 +210,15 @@ acp.delete('/conversation/:conversationId', async (c) => { * 简单的聊天端点，返回 SSE 流式响应 */ acp.post('/chat', async (c) => { - const body = await c.req.json<{ prompt: string; conversationId?: string; model?: string; mode?: string }>() - const { prompt, conversationId, model, mode } = body + const body = await c.req.json<{ + prompt: string + conversationId?: string + model?: string + mode?: string + /** Runtime override：tencent-sdk | opencode-acp | ... 默认 tencent-sdk */ + runtime?: string + }>() + const { prompt, conversationId, model, mode, runtime: runtimeName } = body const { envId, userId, credentials: userCredentials } = c.get('userEnv')! if (!envId) { @@ -214,8 +237,13 @@ acp.post('/chat', async (c) => { } } + const runtime = agentRuntimeRegistry.resolve({ + explicitRuntime: runtimeName, + conversationId: actualConversationId, + }) + return observeStreamWithLiveCallback(c, null, actualConversationId, envId, userId, async (callback) => { - return cloudbaseAgentService.chatStream(prompt, callback, { + return runtime.chatStream(prompt, callback, { conversationId: actualConversationId, envId, userId, @@ -285,7 +313,7 @@ async function handleInitialize(c: any, id: number | string) { agentCapabilities: { loadSession: true, promptCapabilities: { - image: false, + image: true, audio: false, embeddedContext: false, }, @@ -353,38 +381,53 @@ async function handleSessionPrompt(c: any, id: number | string, params: SessionP return c.json(rpcErr(id, JSON_RPC_ERRORS.INTERNAL, 'CloudBase environment not bound')) } - // Check if agent is already running via registry - const existingRun = getAgentRun(sessionId) - if (existingRun && existingRun.status === 'running') { - return observeStream(c, id, sessionId, existingRun.turnId, envId, userId) - } + // Resume payload (askAnswers / toolConfirmation) 必须路由到 runtime.chatStream 的 + // resume 分支来 resolve 挂起的 question/permission，而不是只 observe。 + // 这里优先检查 resume payload —— 有 resume 时跳过 observeStream early-return。 + const hasResumePayloadEarly = + (params?.askAnswers && Object.keys(params.askAnswers).length > 0) || !!params?.toolConfirmation - // Check DB status as fallback - const latestStatus = await persistenceService.getLatestRecordStatus(sessionId, userId, envId) - if (latestStatus && (latestStatus.status === 'pending' || latestStatus.status === 'streaming')) { - return c.json(rpcErr(id, JSON_RPC_ERRORS.INVALID_REQUEST, 'A prompt turn is already in progress')) + if (!hasResumePayloadEarly) { + // Check if agent is already running via registry + const existingRun = getAgentRun(sessionId) + if (existingRun && existingRun.status === 'running') { + return observeStream(c, id, sessionId, existingRun.turnId, envId, userId) + } + + // Check DB status as fallback + const latestStatus = await persistenceService.getLatestRecordStatus(sessionId, userId, envId) + if (latestStatus && (latestStatus.status === 'pending' || latestStatus.status === 'streaming')) { + return c.json(rpcErr(id, JSON_RPC_ERRORS.INVALID_REQUEST, 'A prompt turn is already in progress')) + } } - // Extract prompt text - const prompt: string = (params?.prompt ?? []) + // Extract prompt text and image blocks + const promptBlocks: any[] = params?.prompt ?? [] + const prompt: string = promptBlocks .filter((b) => b.type === 'text') .map((b) => b.text) .join('') + const imageBlocks = promptBlocks.filter((b) => b.type === 'image') const hasResumePayload = (params?.askAnswers && Object.keys(params.askAnswers).length > 0) || !!params?.toolConfirmation - if (!prompt.trim() && !hasResumePayload) { + if (!prompt.trim() && !hasResumePayload && imageBlocks.length === 0) { return c.json(rpcErr(id, JSON_RPC_ERRORS.INVALID_PARAMS, 'prompt must contain at least one text block')) } const effectivePrompt = prompt.trim() ? prompt : hasResumePayload ? '继续未完成的任务' : prompt - // Read task's selectedModel + // Read task metadata once: selectedModel + mode + selectedRuntime let selectedModel: string | undefined + let taskMode: 'default' | 'coding' | undefined + let taskRuntime: string | undefined try { const task = await getDb().tasks.findById(sessionId) selectedModel = task?.selectedModel || undefined + if (task?.mode === 'coding') taskMode = 'coding' + // task.selectedRuntime 是创建任务时用户选择的 runtime（如 'opencode-acp'） + taskRuntime = task?.selectedRuntime || undefined } catch { // read failure doesn't affect main flow } @@ -396,18 +439,15 @@ async function handleSessionPrompt(c: any, id: number | string, params: SessionP // write failure doesn't affect main flow } - // Resolve task mode - let taskMode: 'default' | 'coding' | undefined - try { - const task = await getDb().tasks.findById(sessionId) - if (task?.mode === 'coding') taskMode = 'coding' - } catch { - // ignore - } + // Resolve runtime: 优先级 request param > task's selectedRuntime > AGENT_RUNTIME env > default + const runtime = agentRuntimeRegistry.resolve({ + explicitRuntime: params.runtime || taskRuntime, + conversationId: sessionId, + }) // Launch agent with liveCallback for real-time SSE push return observeStreamWithLiveCallback(c, id, sessionId, envId, userId, async (callback) => { - return cloudbaseAgentService.chatStream(effectivePrompt, callback, { + return runtime.chatStream(effectivePrompt, callback, { conversationId: sessionId, envId, userId, @@ -415,10 +455,9 @@ async function handleSessionPrompt(c: any, id: number | string, params: SessionP model: selectedModel, askAnswers: params.askAnswers, toolConfirmation: params.toolConfirmation, - // P2: 透传 Plan 模式开关。当前端在开启 Plan 模式下发起 prompt 时传 'plan'， - // 或 ExitPlanMode 用户选择 reject_and_exit_plan 后下一轮传 'default' 恢复普通模式。 permissionMode: params.permissionMode, mode: taskMode, + imageBlocks: imageBlocks.length > 0 ? imageBlocks : undefined, }) }) } @@ -688,6 +727,16 @@ async function observeStreamWithLiveCallback( } await stream.writeSSE({ data: '[DONE]' }) + // Update task status: pending → done (or error). + // This allows the frontend to exit its "busy" state and show the send button. + try { + const finalRun = getAgentRun(sessionId) + const finalStatus = finalRun?.status === 'error' ? 'error' : 'done' + await getDb().tasks.update(sessionId, { status: finalStatus, updatedAt: Date.now() }) + } catch { + // Non-critical — frontend will eventually poll the task and reconcile + } + // Cleanup stream events — only if agent is no longer running. // If agent is still running (client disconnected mid-stream), // keep events in DB for reconnection via GET /observe/:sessionId. @@ -757,4 +806,94 @@ acp.get('/config', (c) => { }) }) +/** + * GET /api/agent/runtimes + * + * 列出所有已注册的 Agent Runtime 及其默认值。 + * 前端可用此构建 runtime 选择器。 + */ +acp.get('/runtimes', async (c) => { + const runtimes = agentRuntimeRegistry.list() + const defaultRuntime = agentRuntimeRegistry.resolve() + const items = await Promise.all( + runtimes.map(async (r) => { + const available = await r.isAvailable().catch(() => false) + const models = available ? await r.getSupportedModels().catch(() => []) : [] + return { name: r.name, available, models } + }), + ) + return c.json({ + default: defaultRuntime.name, + runtimes: items, + }) +}) + +/** + * POST /api/agent/internal/ask-user + * + * **只给 opencode 子进程的 question custom tool 调**。server 本地回环。 + * 认证：X-Internal-Token header（ASK_USER_TOKEN env，runtime 启动时生成，同 env 注入子进程） + * + * 行为： + * 1. 验证 conversationId 对应的 agent 还活着 + * 2. 通过 runtime.emit 发 ask_user AgentCallbackMessage → SSE 推给前端 + * 3. 注册 PendingQuestion，挂起当前 HTTP response 不返回 + * 4. 当用户答复（下一轮 prompt.askAnswers 到达）触发 resolvePendingQuestion + * → 本 handler 的 res.json(answers) 返回给 opencode 子进程 + * + * Timeout：默认 10 分钟（可由 ASK_USER_TIMEOUT_MS env 覆盖） + */ +acp.post('/internal/ask-user', async (c) => { + const body = await c.req.json<{ + conversationId: string + toolCallId: string + questions: unknown[] + }>() + const { conversationId, toolCallId, questions } = body + + if (!conversationId || !toolCallId || !Array.isArray(questions)) { + return c.json({ error: 'conversationId, toolCallId, questions required' }, 400) + } + + const run = getAgentRun(conversationId) + if (!run || run.status !== 'running') { + return c.json({ error: 'no active agent for conversation' }, 409) + } + + // emit ask_user 事件 → SSE 推给前端 + try { + await emitForConversation(conversationId, { + type: 'ask_user', + id: toolCallId, + input: { questions }, + }) + } catch (e) { + console.error('[internal/ask-user] emit failed:', e) + return c.json({ error: 'emit failed' }, 500) + } + + // 挂起：注册一个 pending question，等 runtime.chatStream(askAnswers) 来 resolve + const timeoutMs = Number(process.env.ASK_USER_TIMEOUT_MS || 10 * 60 * 1000) + return await new Promise<Response>((resolve) => { + const timer = setTimeout(() => { + resolve(c.json({ error: 'timeout waiting for user answer' }, 408)) + }, timeoutMs) + + registerPendingQuestion({ + conversationId, + toolCallId, + questions, + createdAt: Date.now(), + resolve: (answers) => { + clearTimeout(timer) + resolve(c.json({ ok: true, answers })) + }, + reject: (reason) => { + clearTimeout(timer) + resolve(c.json({ error: reason }, 500)) + }, + }) + }) +}) + export default acp diff --git a/packages/server/src/routes/mcp-cloudbase.ts b/packages/server/src/routes/mcp-cloudbase.ts new file mode 100644 index 0000000..70e98c2 --- /dev/null +++ b/packages/server/src/routes/mcp-cloudbase.ts @@ -0,0 +1,297 @@ +/** + * Global CloudBase MCP HTTP Route + * + * 全局单一 HTTP MCP 路由，供 OpenCode ACP runtime 连接 CloudBase 工具。 + * + * 设计： + * - 复用 Express server 的同一端口（/cloudbase-mcp 路径），零额外 TCP 端口 + * - 每次 HTTP 请求创建 per-request McpServer + StreamableHTTPServerTransport（stateless） + * 请求处理完毕后实例随 GC 回收 + * - Sandbox 信息（URL、认证 headers、scope ID）通过 request headers 传入 + * - 工具 schema 按 scopeId 缓存，避免每次重新调 mcporter list + * + * OpenCode 配置（McpServerHttp）： + * { + * type: 'http', + * name: 'cloudbase', + * url: 'http://localhost:3001/cloudbase-mcp', + * headers: [ + * { name: 'X-Sandbox-Url', value: sandbox.baseUrl }, + * { name: 'X-Sandbox-Auth', value: JSON.stringify(authHeaders) }, + * { name: 'Authorization', value: 'Bearer <MCP_API_KEY>' }, + * ] + * } + */ + +import { Hono } from 'hono' +import { McpServer } from '@modelcontextprotocol/sdk/server/mcp.js' +import { StreamableHTTPServerTransport } from '@modelcontextprotocol/sdk/server/streamableHttp.js' +import type { HttpBindings } from '@hono/node-server' +import { z } from 'zod' +import type { AppEnv } from '../middleware/auth.js' + +// ─── Types ──────────────────────────────────────────────────────────────── + +interface ToolSchema { + name: string + description?: string + inputSchema?: { + type?: string + properties?: Record<string, any> + required?: string[] + } +} + +// ─── Tools Schema Cache ──────────────────────────────────────────────────── +// key: scopeId（conversationId），value: discovered tool list +// TTL: 30 minutes（沙箱重启后工具列表不变，缓存避免重复调 mcporter list） + +interface CacheEntry { + tools: ToolSchema[] + expiresAt: number +} +const toolsSchemaCache = new Map<string, CacheEntry>() +const CACHE_TTL_MS = 30 * 60 * 1000 + +function getCachedTools(scopeId: string): ToolSchema[] | null { + const entry = toolsSchemaCache.get(scopeId) + if (!entry) return null + if (Date.now() > entry.expiresAt) { + toolsSchemaCache.delete(scopeId) + return null + } + return entry.tools +} + +function setCachedTools(scopeId: string, tools: ToolSchema[]): void { + toolsSchemaCache.set(scopeId, { tools, expiresAt: Date.now() + CACHE_TTL_MS }) +} + +// ─── Sandbox HTTP helpers ────────────────────────────────────────────────── +// 不依赖 SandboxInstance，直接通过 fetch 调沙箱 HTTP API +// sandboxAuth 已包含所有必要的认证和 scope headers（来自 sandbox.getAuthHeaders()），不额外注入 + +async function sandboxFetch( + sandboxUrl: string, + sandboxAuth: Record<string, string>, + path: string, + init: RequestInit = {}, +): Promise<Response> { + return fetch(`${sandboxUrl}${path}`, { + ...init, + headers: { + 'Content-Type': 'application/json', + ...sandboxAuth, + ...(init.headers as Record<string, string> | undefined), + }, + }) +} + +async function sandboxBash( + sandboxUrl: string, + sandboxAuth: Record<string, string>, + command: string, + timeoutMs = 60_000, +): Promise<string> { + const res = await sandboxFetch(sandboxUrl, sandboxAuth, '/api/tools/bash', { + method: 'POST', + body: JSON.stringify({ command, timeout: timeoutMs }), + signal: AbortSignal.timeout(timeoutMs + 5_000), + }) + const data = (await res.json().catch(() => ({ success: false, error: `HTTP ${res.status}` }))) as any + if (!data.success) throw new Error(data.error ?? `bash failed (${res.status})`) + const r = data.result + if (typeof r === 'string') return r + return r?.output ?? r?.stdout ?? JSON.stringify(r ?? '') +} + +// ─── Tool Schema Discovery ───────────────────────────────────────────────── + +async function discoverCloudbaseTools(sandboxUrl: string, sandboxAuth: Record<string, string>): Promise<ToolSchema[]> { + const tmpPath = `.cloudbase-mcp-schema-${Date.now()}.json` + try { + await sandboxBash( + sandboxUrl, + sandboxAuth, + `mcporter list cloudbase --schema --output json > ${tmpPath} 2>&1`, + 25_000, + ) + const res = await sandboxFetch(sandboxUrl, sandboxAuth, `/e2b-compatible/files?path=${encodeURIComponent(tmpPath)}`) + if (!res.ok) throw new Error(`Failed to read schema file: ${res.status}`) + const parsed = (await res.json()) as any + if (!Array.isArray(parsed.tools)) throw new Error('No tools array in schema response') + return parsed.tools as ToolSchema[] + } finally { + sandboxBash(sandboxUrl, sandboxAuth, `rm -f ${tmpPath}`, 5_000).catch(() => {}) + } +} + +// ─── mcporter call ───────────────────────────────────────────────────────── + +function serializeFnCall(toolName: string, args: Record<string, unknown>): string { + if (!args || Object.keys(args).length === 0) return `cloudbase.${toolName}()` + const parts = Object.entries(args) + .map(([k, v]) => { + if (v === undefined || v === null) return null + if (typeof v === 'string') return `${k}: ${JSON.stringify(v)}` + if (typeof v === 'boolean' || typeof v === 'number') return `${k}: ${v}` + return `${k}: ${JSON.stringify(v)}` + }) + .filter(Boolean) + .join(', ') + return `cloudbase.${toolName}(${parts})` +} + +async function mcporterCall( + sandboxUrl: string, + sandboxAuth: Record<string, string>, + toolName: string, + args: Record<string, unknown>, +): Promise<string> { + const expr = serializeFnCall(toolName, args) + const escaped = expr.replace(/'/g, "'\\''") + return sandboxBash(sandboxUrl, sandboxAuth, `mcporter call '${escaped}' 2>&1`, 60_000) +} + +// ─── JSON Schema to Zod ──────────────────────────────────────────────────── + +function jsonSchemaPropToZod(propSchema: any): z.ZodTypeAny { + if (!propSchema) return z.any() + const { type, description, enum: enumValues, items, properties, required } = propSchema + let zodType: z.ZodTypeAny + if (enumValues && Array.isArray(enumValues)) { + zodType = z.enum(enumValues as [string, ...string[]]) + } else if (type === 'string') { + zodType = z.string() + } else if (type === 'number' || type === 'integer') { + zodType = z.number() + } else if (type === 'boolean') { + zodType = z.boolean() + } else if (type === 'array') { + zodType = z.array(items ? jsonSchemaPropToZod(items) : z.any()) + } else if (type === 'object') { + if (properties) { + const shape: Record<string, z.ZodTypeAny> = {} + const reqSet = new Set(required || []) + for (const [k, v] of Object.entries(properties)) { + let t = jsonSchemaPropToZod(v as any) + if (!reqSet.has(k)) t = t.optional() as z.ZodTypeAny + shape[k] = t + } + zodType = z.object(shape) + } else { + zodType = z.record(z.string(), z.any()) + } + } else { + zodType = z.any() + } + return description ? zodType.describe(description) : zodType +} + +function jsonSchemaToZodShape(schema: any): Record<string, z.ZodTypeAny> { + if (!schema?.properties) return {} + const required = new Set<string>(schema.required ?? []) + const shape: Record<string, z.ZodTypeAny> = {} + for (const [key, prop] of Object.entries(schema.properties as Record<string, any>)) { + let t = jsonSchemaPropToZod(prop) + if (!required.has(key)) t = t.optional() as z.ZodTypeAny + shape[key] = t + } + return shape +} + +// ─── Per-request MCP Server builder ─────────────────────────────────────── + +const SKIP_TOOLS = new Set(['logout', 'interactiveDialog']) + +async function buildMcpServer( + sandboxUrl: string, + sandboxAuth: Record<string, string>, + /** 本地缓存 key（conversationId），不传给沙箱 */ + sessionId: string, +): Promise<McpServer> { + // Get or discover tool schema (cached by sessionId) + let tools = getCachedTools(sessionId) + if (!tools) { + try { + tools = await discoverCloudbaseTools(sandboxUrl, sandboxAuth) + setCachedTools(sessionId, tools) + } catch (e) { + console.warn('[cloudbase-mcp] Tool discovery failed:', (e as Error).message) + tools = [] + } + } + + const server = new McpServer({ name: 'cloudbase', version: '1.0.0' }) + + for (const tool of tools) { + if (SKIP_TOOLS.has(tool.name)) continue + const zodShape = jsonSchemaToZodShape(tool.inputSchema) + server.tool( + tool.name, + (tool.description ?? `CloudBase tool: ${tool.name}`) + + '\n\nNOTE: localPath refers to paths inside the container workspace.', + zodShape, + async (args: Record<string, unknown>) => { + try { + const output = await mcporterCall(sandboxUrl, sandboxAuth, tool.name, args) + return { + content: [{ type: 'text' as const, text: typeof output === 'string' ? output : JSON.stringify(output) }], + } + } catch (e: any) { + return { content: [{ type: 'text' as const, text: `Error: ${e.message}` }], isError: true } + } + }, + ) + } + + return server +} + +// ─── Hono Route ─────────────────────────────────────────────────────────── + +const app = new Hono<AppEnv & { Bindings: HttpBindings }>() + +// All methods: authenticate → parse sandbox headers → dispatch to MCP transport +app.all('*', async (c) => { + // 认证：要求已登录 session（cookie nex_session=<jwe> 由 base-runtime.setupSandbox 签发） + const session = c.get('session') + if (!session?.user?.id) { + return c.json({ error: 'Unauthorized' }, 401) + } + + const sandboxUrl = c.req.header('X-Sandbox-Url') + const sandboxAuthRaw = c.req.header('X-Sandbox-Auth') ?? '{}' + // sessionId 仅用于本地工具 schema 缓存 key，不传给沙箱 + const sessionId = c.req.header('X-Session-Id') ?? 'default' + + if (!sandboxUrl) { + return c.json({ error: 'X-Sandbox-Url header required' }, 400) + } + + let sandboxAuth: Record<string, string> + try { + sandboxAuth = JSON.parse(sandboxAuthRaw) + } catch { + return c.json({ error: 'Invalid X-Sandbox-Auth header (must be JSON)' }, 400) + } + + // Build per-request McpServer with tools registered + const mcpServer = await buildMcpServer(sandboxUrl, sandboxAuth, sessionId) + + // Create stateless transport and handle this single HTTP request. + // @hono/node-server exposes Node.js raw req/res via c.env (HttpBindings). + // transport.handleRequest writes directly to the Node.js ServerResponse, + // so we must tell Hono NOT to write its own response afterward. + // We use the @hono/node-server internal header 'x-hono-already-sent' = '1' + // which causes responseViaResponseObject to skip all header/body writing. + const transport = new StreamableHTTPServerTransport({ sessionIdGenerator: undefined }) + await mcpServer.connect(transport) + + const { incoming, outgoing } = c.env + await transport.handleRequest(incoming, outgoing) + + return new Response(null, { status: 200, headers: { 'x-hono-already-sent': '1' } }) +}) + +export default app diff --git a/packages/server/src/routes/tasks.ts b/packages/server/src/routes/tasks.ts index d5a24aa..cdb19ed 100644 --- a/packages/server/src/routes/tasks.ts +++ b/packages/server/src/routes/tasks.ts @@ -3,6 +3,7 @@ import { streamSSE } from 'hono/streaming' import { getDb } from '../db/index.js' import { nanoid } from 'nanoid' import { requireAuth, requireUserEnv, type AppEnv } from '../middleware/auth' +import { readFileSync } from 'node:fs' import { createTaskLogger } from '../lib/task-logger' import { resolveSandboxConfig, backfillSandboxConfig } from '../lib/sandbox-config' import { decrypt } from '../lib/crypto' @@ -303,6 +304,7 @@ tasksRouter.post('/', async (c) => { repoUrl, selectedAgent = 'claude', selectedModel, + selectedRuntime, mode = 'default', installDependencies = false, maxDuration = 300, @@ -333,6 +335,7 @@ tasksRouter.post('/', async (c) => { repoUrl: repoUrl || null, selectedAgent, selectedModel: selectedModel || null, + selectedRuntime: selectedRuntime || null, mode, installDependencies, maxDuration, @@ -422,6 +425,7 @@ tasksRouter.delete('/:taskId', requireUserEnv, async (c) => { const sandbox = await scfSandboxManager .getExisting(taskId, scfSessionId, { sandboxMode: existing.sandboxMode || undefined, + isCodingMode: existing.mode === 'code', }) .catch(() => null) if (sandbox) { @@ -447,28 +451,57 @@ tasksRouter.get('/:taskId/messages', requireUserEnv, async (c) => { try { const cloudbaseRecords = await persistenceService.loadDBMessages(taskId, envId, userId, 100) const messages = cloudbaseRecords.map((record) => { - const parts = (record.parts || []).map((p) => { - if (p.contentType === 'text') return { type: 'text' as const, text: p.content || '' } - else if (p.contentType === 'reasoning') return { type: 'thinking' as const, text: p.content || '' } - else if (p.contentType === 'tool_call') - return { - type: 'tool_call' as const, - toolCallId: p.toolCallId || p.partId, - toolName: (p.metadata?.toolCallName as string) || (p.metadata?.toolName as string) || 'tool', - input: p.content || p.metadata?.input, - status: (p.metadata?.status as string) || undefined, - } - else if (p.contentType === 'tool_result') - return { - type: 'tool_result' as const, - toolCallId: p.toolCallId || p.partId, - toolName: (p.metadata?.toolName as string) || undefined, - content: p.content || '', - isError: p.metadata?.isError as boolean | undefined, - status: (p.metadata?.status as string) || undefined, - } - return { type: 'text' as const, text: p.content || '' } - }) + const parts = (record.parts || []) + .map((p) => { + if (p.contentType === 'text') { + // contentBlocks may be in p.metadata (TypeScript model) or directly on p + // (when CloudBase flattens the nested metadata object on read-back) + const contentBlocks = ((p.metadata as any)?.contentBlocks ?? (p as any).contentBlocks) as any[] | undefined + if (contentBlocks) { + const imageParts: any[] = [] + for (const b of contentBlocks) { + if (b.type === 'image_blob_ref') { + // Post-syncMessages: read from local blob file + try { + const data = readFileSync(b.blob_path as string).toString('base64') + imageParts.push({ type: 'image' as const, data, mimeType: b.mime as string }) + } catch (e) { + console.error('[messages] blob read failed:', b.blob_path, (e as Error).message) + } + } + } + if (imageParts.length > 0) { + return [...imageParts, { type: 'text' as const, text: p.content || '' }] + } + } + return { type: 'text' as const, text: p.content || '' } + } else if (p.contentType === 'reasoning') return { type: 'thinking' as const, text: p.content || '' } + else if (p.contentType === 'tool_call') + return { + type: 'tool_call' as const, + toolCallId: p.toolCallId || p.partId, + toolName: (p.metadata?.toolCallName as string) || (p.metadata?.toolName as string) || 'tool', + input: p.content || p.metadata?.input, + status: (p.metadata?.status as string) || undefined, + } + else if (p.contentType === 'tool_result') + return { + type: 'tool_result' as const, + toolCallId: p.toolCallId || p.partId, + toolName: (p.metadata?.toolName as string) || undefined, + content: p.content || '', + isError: p.metadata?.isError as boolean | undefined, + status: (p.metadata?.status as string) || undefined, + } + else if (p.contentType === 'image') + return { + type: 'image' as const, + data: p.content || '', + mimeType: (p.metadata?.mimeType as string) || 'image/png', + } + return { type: 'text' as const, text: p.content || '' } + }) + .flat() const textContent = parts .filter((p) => p.type === 'text') .map((p) => (p as { type: 'text'; text: string }).text) diff --git a/packages/server/src/sandbox/sandbox-mcp-proxy.ts b/packages/server/src/sandbox/sandbox-mcp-proxy.ts index 9e1e5f6..7172b1c 100644 --- a/packages/server/src/sandbox/sandbox-mcp-proxy.ts +++ b/packages/server/src/sandbox/sandbox-mcp-proxy.ts @@ -17,6 +17,7 @@ import { nanoid } from 'nanoid' import cron from 'node-cron' import { getDb } from '../db/index.js' import { scheduleTask, unscheduleTask } from '../services/cron-scheduler.js' +import { extractDeployUrl } from '../agent/runtime/base-runtime.js' // ─── Types ─────────────────────────────────────────────────────── @@ -236,31 +237,6 @@ export async function createSandboxMcpClient(deps: SandboxMcpDeps): Promise<{ return /\.[a-zA-Z0-9]+$/.test(basename) } - function extractDeployUrl(rawText: string, isFile = false, depth = 0): string | null { - if (depth > 5) return null - try { - const parsed = JSON.parse(rawText) - if (Array.isArray(parsed)) { - const firstText = parsed[0]?.text - if (typeof firstText === 'string') return extractDeployUrl(firstText, isFile, depth + 1) - return null - } - if (typeof parsed !== 'object' || parsed === null) return null - if (parsed.accessUrl) { - const url = new URL(parsed.accessUrl) - if (!isFile && url.pathname !== '/' && !url.pathname.endsWith('/')) url.pathname += '/' - if (!url.searchParams.get('t')) url.searchParams.set('t', String(Date.now())) - return url.toString() - } - if (parsed.staticDomain) return `https://${parsed.staticDomain}/?t=${Date.now()}` - const innerText = parsed?.res?.content?.[0]?.text || parsed?.content?.[0]?.text - if (typeof innerText === 'string') return extractDeployUrl(innerText, isFile, depth + 1) - } catch { - // JSON parse 失败，忽略 - } - return null - } - function isCredentialError(output: string): boolean { return ( output.includes('AUTH_REQUIRED') || @@ -395,142 +371,164 @@ export async function createSandboxMcpClient(deps: SandboxMcpDeps): Promise<{ })) } - // ── publishMiniprogram tool ─────────────────────────────────── - server.tool( - 'publishMiniprogram', - '小程序发布/预览工具。支持预览（preview）和上传（upload）两种操作。预览会生成二维码供扫码体验，上传会将代码提交到微信后台。部署可能耗时较长，若超过 60s 未完成会返回 async=true 和 jobId，请使用 getDeployJobStatus 工具查询结果。', - { - action: z.enum(['preview', 'upload']).describe('操作类型：preview=预览, upload=上传'), - projectPath: z.string().describe('小程序项目路径（沙箱内的绝对路径）'), - appId: z.string().describe('微信小程序 AppId'), - version: z.string().optional().describe('版本号（upload 时建议提供，如 "1.0.0"）'), - description: z.string().optional().describe('版本描述'), - robot: z.number().optional().describe('CI 机器人编号（1-30），默认 1'), - }, - async (args: Record<string, unknown>) => { - try { - let privateKey: string | undefined - const appId = args.appId as string + // ── publishMiniprogram / getDeployJobStatus 共享 handler ───── + // 两个 tool 需要同时注册到标准 MCP Server 和 SDK-wrapped Server， + // 但 handler 逻辑只保留一份。 + + const PUBLISH_MP_DESC = + '小程序发布/预览工具。支持预览（preview）和上传（upload）两种操作。预览会生成二维码供扫码体验，上传会将代码提交到微信后台。部署可能耗时较长，若超过 60s 未完成会返回 async=true 和 jobId，请使用 getDeployJobStatus 工具查询结果。' + const PUBLISH_MP_SCHEMA = { + action: z.enum(['preview', 'upload']).describe('操作类型：preview=预览, upload=上传'), + projectPath: z.string().describe('小程序项目路径（沙箱内的绝对路径）'), + appId: z.string().describe('微信小程序 AppId'), + version: z.string().optional().describe('版本号（upload 时建议提供，如 "1.0.0"）'), + description: z.string().optional().describe('版本描述'), + robot: z.number().optional().describe('CI 机器人编号（1-30），默认 1'), + } - if (getMpDeployCredentials) { - const creds = await getMpDeployCredentials(appId) - if (creds) { - privateKey = creds.privateKey - } - } + async function handlePublishMiniprogram(args: Record<string, unknown>) { + try { + let privateKey: string | undefined + const appId = args.appId as string - if (!privateKey) { - return { - content: [ - { - type: 'text' as const, - text: JSON.stringify({ - error: true, - message: `未找到 appId ${appId} 的部署密钥，请先在小程序管理中关联该 appId`, - }), - }, - ], - isError: true, - } - } + if (getMpDeployCredentials) { + const creds = await getMpDeployCredentials(appId) + if (creds) privateKey = creds.privateKey + } - const res = await sandbox.request('/api/miniprogram/deploy', { - method: 'POST', - headers: { 'Content-Type': 'application/json' }, - body: JSON.stringify({ - appid: appId, - privateKey, - action: args.action, - projectPath: args.projectPath, - version: args.version, - description: args.description, - robot: args.robot, - }), - signal: AbortSignal.timeout(120_000), - }) - - const body = (await res.json().catch(() => null)) as any - - if (!res.ok || !body) { - return { - content: [ - { - type: 'text' as const, - text: JSON.stringify({ - error: true, - status: res.status, - message: body?.error || body?.message || `HTTP ${res.status}`, - }), - }, - ], - isError: true, - } + if (!privateKey) { + return { + content: [ + { + type: 'text' as const, + text: JSON.stringify({ + error: true, + message: `未找到 appId ${appId} 的部署密钥，请先在小程序管理中关联该 appId`, + }), + }, + ], + isError: true, } + } - if (body.async) { - return { - content: [ - { - type: 'text' as const, - text: JSON.stringify({ - async: true, - jobId: body.jobId, - message: '部署仍在进行中，请稍后使用 getDeployJobStatus 工具查询结果', - }), - }, - ], - } - } + const res = await sandbox.request('/api/miniprogram/deploy', { + method: 'POST', + headers: { 'Content-Type': 'application/json' }, + body: JSON.stringify({ + appid: appId, + privateKey, + action: args.action, + projectPath: args.projectPath, + version: args.version, + description: args.description, + robot: args.robot, + }), + signal: AbortSignal.timeout(120_000), + }) - if (!body.success) { - return { - content: [ - { - type: 'text' as const, - text: JSON.stringify({ - error: true, - message: body.error || body.result?.errMsg || 'Deploy failed', - result: body.result, - }), - }, - ], - isError: true, - } - } + const body = (await res.json().catch(() => null)) as any - return { content: [{ type: 'text' as const, text: JSON.stringify(body) }] } - } catch (e: any) { + if (!res.ok || !body) { return { - content: [{ type: 'text' as const, text: JSON.stringify({ error: true, message: e.message }) }], + content: [ + { + type: 'text' as const, + text: JSON.stringify({ + error: true, + status: res.status, + message: body?.error || body?.message || `HTTP ${res.status}`, + }), + }, + ], isError: true, } } - }, - ) - // ── getDeployJobStatus tool ─────────────────────────────────── - server.tool( - 'getDeployJobStatus', - '查询小程序发布/预览任务的状态。当 publishMiniprogram 返回 async=true 时使用此工具轮询结果。', - { jobId: z.string().describe('publishMiniprogram 返回的 jobId') }, - async (args: Record<string, unknown>) => { - try { - const res = await sandbox.request( - `/api/miniprogram/deploy/status?jobId=${encodeURIComponent(args.jobId as string)}`, - { signal: AbortSignal.timeout(30_000) }, - ) - const body = (await res.json().catch(() => null)) as any + if (body.async) { return { - content: [{ type: 'text' as const, text: JSON.stringify(body ?? { error: true, status: res.status }) }], + content: [ + { + type: 'text' as const, + text: JSON.stringify({ + async: true, + jobId: body.jobId, + message: '部署仍在进行中，请稍后使用 getDeployJobStatus 工具查询结果', + }), + }, + ], } - } catch (e: any) { + } + + if (!body.success) { return { - content: [{ type: 'text' as const, text: JSON.stringify({ error: true, message: e.message }) }], + content: [ + { + type: 'text' as const, + text: JSON.stringify({ + error: true, + message: body.error || body.result?.errMsg || 'Deploy failed', + result: body.result, + }), + }, + ], isError: true, } } - }, - ) + + // 触发 artifact：提取预览二维码或上传成功状态 + if (onArtifact && body) { + if (body.result?.qrcode) { + const qrcode = `data:${body.result.qrcode.mimeType || 'image/png'};base64,${body.result.qrcode.base64}` + onArtifact({ + title: '小程序预览二维码', + contentType: 'image', + data: qrcode, + metadata: { deploymentType: 'miniprogram', ...body }, + }) + } else if (body.success && args.action === 'upload') { + onArtifact({ + title: '小程序上传成功', + contentType: 'json', + data: JSON.stringify(body), + metadata: { deploymentType: 'miniprogram', appId: args.appId as string }, + }) + } + } + + return { content: [{ type: 'text' as const, text: JSON.stringify(body) }] } + } catch (e: any) { + return { + content: [{ type: 'text' as const, text: JSON.stringify({ error: true, message: e.message }) }], + isError: true, + } + } + } + + const DEPLOY_STATUS_DESC = + '查询小程序发布/预览任务的状态。当 publishMiniprogram 返回 async=true 时使用此工具轮询结果。' + const DEPLOY_STATUS_SCHEMA = { jobId: z.string().describe('publishMiniprogram 返回的 jobId') } + + async function handleGetDeployJobStatus(args: Record<string, unknown>) { + try { + const res = await sandbox.request( + `/api/miniprogram/deploy/status?jobId=${encodeURIComponent(args.jobId as string)}`, + { signal: AbortSignal.timeout(30_000) }, + ) + const body = (await res.json().catch(() => null)) as any + return { + content: [{ type: 'text' as const, text: JSON.stringify(body ?? { error: true, status: res.status }) }], + } + } catch (e: any) { + return { + content: [{ type: 'text' as const, text: JSON.stringify({ error: true, message: e.message }) }], + isError: true, + } + } + } + + // 注册到标准 MCP Server + server.tool('publishMiniprogram', PUBLISH_MP_DESC, PUBLISH_MP_SCHEMA, handlePublishMiniprogram) + server.tool('getDeployJobStatus', DEPLOY_STATUS_DESC, DEPLOY_STATUS_SCHEMA, handleGetDeployJobStatus) // ── Wire InMemoryTransport pair ─────────────────────────────── @@ -563,7 +561,6 @@ export async function createSandboxMcpClient(deps: SandboxMcpDeps): Promise<{ try { const deployUrl = extractDeployUrl(output, isFilePath(String(args.localPath || ''))) if (deployUrl) { - log(`[sandbox-mcp] deploy artifact detected\n`) onArtifact({ title: 'Web 应用已部署', contentType: 'link', @@ -584,92 +581,10 @@ export async function createSandboxMcpClient(deps: SandboxMcpDeps): Promise<{ ) }) - // SDK-wrapped publishMiniprogram tool + // SDK-wrapped publishMiniprogram + getDeployJobStatus（复用上面的 handler） + sdkTools.push(sdkTool('publishMiniprogram', PUBLISH_MP_DESC, PUBLISH_MP_SCHEMA as any, handlePublishMiniprogram)) sdkTools.push( - sdkTool( - 'publishMiniprogram', - '小程序发布/预览工具。支持预览（preview）和上传（upload）两种操作。', - { - action: z.enum(['preview', 'upload']).describe('操作类型'), - projectPath: z.string().describe('小程序项目路径'), - appId: z.string().describe('微信小程序 AppId'), - version: z.string().optional().describe('版本号'), - description: z.string().optional().describe('版本描述'), - robot: z.number().optional().describe('CI 机器人编号'), - }, - async (args: Record<string, unknown>) => { - try { - let privateKey: string | undefined - const appId = args.appId as string - - if (getMpDeployCredentials) { - const creds = await getMpDeployCredentials(appId) - if (creds) privateKey = creds.privateKey - } - - if (!privateKey) { - return { - content: [ - { - type: 'text' as const, - text: JSON.stringify({ error: true, message: `未找到 appId ${appId} 的部署密钥` }), - }, - ], - isError: true, - } - } - - const res = await sandbox.request('/api/miniprogram/deploy', { - method: 'POST', - headers: { 'Content-Type': 'application/json' }, - body: JSON.stringify({ - appid: appId, - privateKey, - action: args.action, - projectPath: args.projectPath, - version: args.version, - description: args.description, - robot: args.robot, - }), - signal: AbortSignal.timeout(120_000), - }) - - const body = (await res.json().catch(() => null)) as any - if (!res.ok || !body) { - return { - content: [{ type: 'text' as const, text: JSON.stringify({ error: true, status: res.status }) }], - isError: true, - } - } - return { content: [{ type: 'text' as const, text: JSON.stringify(body) }] } - } catch (e: any) { - return { content: [{ type: 'text' as const, text: `Error: ${e.message}` }], isError: true } - } - }, - ), - ) - - // SDK-wrapped getDeployJobStatus tool - sdkTools.push( - sdkTool( - 'getDeployJobStatus', - '查询小程序发布/预览任务的状态。', - { jobId: z.string().describe('publishMiniprogram 返回的 jobId') }, - async (args: Record<string, unknown>) => { - try { - const res = await sandbox.request( - `/api/miniprogram/deploy/status?jobId=${encodeURIComponent(args.jobId as string)}`, - { signal: AbortSignal.timeout(30_000) }, - ) - const body = (await res.json().catch(() => null)) as any - return { - content: [{ type: 'text' as const, text: JSON.stringify(body ?? { error: true, status: res.status }) }], - } - } catch (e: any) { - return { content: [{ type: 'text' as const, text: `Error: ${e.message}` }], isError: true } - } - }, - ), + sdkTool('getDeployJobStatus', DEPLOY_STATUS_DESC, DEPLOY_STATUS_SCHEMA as any, handleGetDeployJobStatus), ) // ── cronTask tool (CRUD) ────────────────────────────────────── @@ -873,7 +788,7 @@ export async function createSandboxMcpClient(deps: SandboxMcpDeps): Promise<{ }) log( - `[sandbox-mcp] Ready. sandbox=${sandbox.functionName} session=${sandbox.envId} scope=${sandbox.conversationId} mode=${sandbox.sandboxMode} coding=${sandbox.isCodingMode} tools=${cloudbaseTools.length}\n`, + `[sandbox-mcp] Ready. sandbox=${sandbox.functionName} session=${sandbox.scfSessionId} scope=${sandbox.conversationId} mode=${sandbox.sandboxMode} coding=${sandbox.isCodingMode} tools=${cloudbaseTools.length}\n`, ) return { diff --git a/packages/server/src/sandbox/scf-sandbox-manager.ts b/packages/server/src/sandbox/scf-sandbox-manager.ts index 699102c..b082983 100644 --- a/packages/server/src/sandbox/scf-sandbox-manager.ts +++ b/packages/server/src/sandbox/scf-sandbox-manager.ts @@ -32,7 +32,16 @@ interface ScfSandboxConfig { export class SandboxInstance { readonly functionName: string readonly conversationId: string - readonly envId: string + /** + * SCF session ID (used as `X-Cloudbase-Session-Id` header for sandbox auth). + * - In `shared` workspaceIsolation mode: equals the user's CloudBase envId + * - In `isolated` mode: equals conversationId + * - May be overridden via `options.sandboxSessionId` in `getOrCreate` + * + * 注意：这不是用户的 CloudBase 环境 ID（之前误命名为 envId 容易引起混淆）， + * 实际是沙箱 SCF function 的 session ID。 + */ + readonly scfSessionId: string readonly sandboxEnvId: string readonly baseUrl: string readonly status: 'creating' | 'ready' | 'error' @@ -62,7 +71,7 @@ export class SandboxInstance { ctx: { functionName: string conversationId: string - envId: string + scfSessionId: string status: 'creating' | 'ready' | 'error' mode: SandboxMode sandboxMode?: 'shared' | 'isolated' @@ -72,7 +81,7 @@ export class SandboxInstance { ) { this.functionName = ctx.functionName this.conversationId = ctx.conversationId - this.envId = ctx.envId + this.scfSessionId = ctx.scfSessionId this.sandboxEnvId = this.deps.sandboxEnvId this.baseUrl = `https://${this.deps.sandboxEnvId}.api.tcloudbasegateway.com/v1/functions/${ctx.functionName}` this.status = ctx.status @@ -86,10 +95,10 @@ export class SandboxInstance { return this.deps.getAccessToken() } - static buildAuthHeaders(accessToken: string, sessionId: string): Record<string, string> { + static buildAuthHeaders(accessToken: string, scfSessionId: string): Record<string, string> { return { Authorization: `Bearer ${accessToken}`, - 'X-Cloudbase-Session-Id': sessionId, + 'X-Cloudbase-Session-Id': scfSessionId, 'X-Tcb-Webfn': 'true', } } @@ -117,7 +126,7 @@ export class SandboxInstance { async getAuthHeaders(): Promise<Record<string, string>> { const accessToken = await this.getAccessToken() return { - ...SandboxInstance.buildAuthHeaders(accessToken, this.envId), + ...SandboxInstance.buildAuthHeaders(accessToken, this.scfSessionId), ...SandboxInstance.buildScopeHeaders(this.conversationId, this.sandboxMode, this.isCodingMode), } } @@ -313,7 +322,7 @@ export class ScfSandboxManager { return new SandboxInstance(instanceDeps, { functionName, conversationId, - envId: scfSessionId, + scfSessionId, status: 'ready', mode, sandboxMode: isolation, @@ -346,7 +355,7 @@ export class ScfSandboxManager { return new SandboxInstance(instanceDeps, { functionName, conversationId, - envId: scfSessionId, + scfSessionId, status: 'ready', mode: 'shared', sandboxMode: mode as any, @@ -357,7 +366,7 @@ export class ScfSandboxManager { private async createNewFunction( functionName: string, conversationId: string, - envId: string, + scfSessionId: string, mode: SandboxMode, options?: any, onProgress?: SandboxProgressCallback, @@ -387,7 +396,7 @@ export class ScfSandboxManager { const instanceDeps = await this.buildInstanceDeps() const mcpConfig = await this.buildSandboxMcpConfig( functionName, - envId, + scfSessionId, conversationId, instanceDeps.sandboxEnvId, isolation, @@ -397,7 +406,7 @@ export class ScfSandboxManager { return new SandboxInstance(instanceDeps, { functionName, conversationId, - envId, + scfSessionId, status: 'ready', mode, sandboxMode: isolation, diff --git a/packages/server/tsconfig.json b/packages/server/tsconfig.json index 760e881..fc3ad32 100644 --- a/packages/server/tsconfig.json +++ b/packages/server/tsconfig.json @@ -11,5 +11,6 @@ "@coder/shared": ["../shared/src/index.ts"] } }, - "include": ["src"] + "include": ["src"], + "exclude": ["src/**/__tests__/**"] } diff --git a/packages/server/vitest.config.ts b/packages/server/vitest.config.ts new file mode 100644 index 0000000..370664f --- /dev/null +++ b/packages/server/vitest.config.ts @@ -0,0 +1,15 @@ +import { defineConfig } from 'vitest/config' +import path from 'node:path' + +export default defineConfig({ + test: { + environment: 'node', + include: ['src/**/__tests__/**/*.test.ts'], + globals: false, + }, + resolve: { + alias: { + '@coder/shared': path.resolve(__dirname, '../shared/src/index.ts'), + }, + }, +}) diff --git a/packages/shared/src/types/agent.ts b/packages/shared/src/types/agent.ts index 762e767..1c33856 100644 --- a/packages/shared/src/types/agent.ts +++ b/packages/shared/src/types/agent.ts @@ -196,6 +196,17 @@ export interface SessionPromptParams { * - 用户主动开启 Plan 模式时传 `permissionMode: 'plan'` */ permissionMode?: AgentPermissionMode + /** + * Agent runtime 选择（多 runtime 抽象层新增） + * + * 取值由 server 注册的 runtime 名决定，目前内置： + * - `tencent-sdk` (默认): 基于 patch 过的 @tencent-ai/agent-sdk + * - `opencode-acp`: spawn `opencode acp` 子进程，走 ACP NDJSON + * + * 不传 → server 按 `agentRuntimeRegistry.resolve()` 默认策略选取 + * （AGENT_RUNTIME env 或 tencent-sdk） + */ + runtime?: string } /** @@ -519,4 +530,6 @@ export interface AgentOptions { * - `default` | undefined: 普通模式（沿用原行为） */ permissionMode?: AgentPermissionMode + /** 图片附件（多模态输入），转换后传给 SDK query() 的 ContentBlock[] */ + imageBlocks?: AcpImageBlock[] } diff --git a/packages/web/dist/index.html b/packages/web/dist/index.html index 2597054..68bb9ac 100644 --- a/packages/web/dist/index.html +++ b/packages/web/dist/index.html @@ -4,8 +4,8 @@ <meta charset="UTF-8" /> <meta name="viewport" content="width=device-width, initial-scale=1.0" /> <title>Coding Agent - - + +
diff --git a/packages/web/public/logos/mimo.png b/packages/web/public/logos/mimo.png new file mode 100644 index 0000000..f209e12 Binary files /dev/null and b/packages/web/public/logos/mimo.png differ diff --git a/packages/web/src/components/chat/task-list-panel.tsx b/packages/web/src/components/chat/task-list-panel.tsx index f9809b0..eba516c 100644 --- a/packages/web/src/components/chat/task-list-panel.tsx +++ b/packages/web/src/components/chat/task-list-panel.tsx @@ -32,16 +32,52 @@ function parseInput(raw: unknown): Record { } // --------------------------------------------------------------------------- -// deriveTasks — extract tasks from TaskCreate / TaskUpdate tool calls +// deriveTasks — extract tasks from multiple sources: +// 1. CodeBuddy SDK: TaskCreate + TaskUpdate 工具（task id 来自 result 里的 "Task #N"） +// 2. OpenCode: todowrite / TodoWrite 工具（一次性全量 todos 数组） // --------------------------------------------------------------------------- +/** 支持 CodeBuddy TaskCreate / OpenCode todowrite 两种工具名 */ +const TASK_CREATE_TOOLS = new Set(['TaskCreate']) +const TASK_UPDATE_TOOLS = new Set(['TaskUpdate']) +const TODO_WRITE_TOOLS = new Set(['todowrite', 'TodoWrite']) + +interface TodoItemInput { + content?: string + activeForm?: string + status?: 'pending' | 'in_progress' | 'completed' + priority?: string +} + export function deriveTasks(messages: TaskMessage[]): DerivedTask[] { const tasks: Record = {} + // 记录按时间顺序最近一次 todoWrite 调用的 message/partIndex， + // 用于判断哪个 todoWrite 是当前权威版本（后覆盖前）。 + let lastTodoWriteSnapshot: DerivedTask[] | null = null + for (const msg of messages) { if (!msg.parts) continue for (const part of msg.parts) { - if (part.type === 'tool_call' && part.toolName === 'TaskCreate') { + // ─── 1. OpenCode todowrite：一次性全量 todos 数组 ─────────── + if (part.type === 'tool_call' && TODO_WRITE_TOOLS.has(part.toolName)) { + const input = parseInput(part.input) + const todos = Array.isArray(input.todos) ? (input.todos as TodoItemInput[]) : [] + lastTodoWriteSnapshot = todos + .filter((t) => t && (t.content || t.activeForm)) + .map((t, idx) => ({ + id: `todo-${idx + 1}`, + subject: t.content ? String(t.content) : '', + status: (t.status === 'completed' || t.status === 'in_progress' + ? t.status + : 'pending') as DerivedTask['status'], + activeForm: t.activeForm ? String(t.activeForm) : undefined, + })) + continue + } + + // ─── 2. CodeBuddy TaskCreate / TaskUpdate ──────────────────── + if (part.type === 'tool_call' && TASK_CREATE_TOOLS.has(part.toolName)) { const input = parseInput(part.input) // Find matching tool_result to extract task ID @@ -60,7 +96,7 @@ export function deriveTasks(messages: TaskMessage[]): DerivedTask[] { activeForm: input.activeForm ? String(input.activeForm) : undefined, owner: input.owner ? String(input.owner) : undefined, } - } else if (part.type === 'tool_call' && part.toolName === 'TaskUpdate') { + } else if (part.type === 'tool_call' && TASK_UPDATE_TOOLS.has(part.toolName)) { const input = parseInput(part.input) const taskId = input.taskId ? String(input.taskId) : undefined if (!taskId || !tasks[taskId]) continue @@ -78,6 +114,12 @@ export function deriveTasks(messages: TaskMessage[]): DerivedTask[] { } } + // 如果存在 todoWrite 快照，它作为权威来源（覆盖 CodeBuddy 的 task 列表， + // 两者不会同时存在于同一会话）。若想都保留，可以 spread concat。 + if (lastTodoWriteSnapshot && lastTodoWriteSnapshot.length > 0) { + return lastTodoWriteSnapshot + } + return Object.values(tasks) } diff --git a/packages/web/src/components/chat/tool-renderers/index.ts b/packages/web/src/components/chat/tool-renderers/index.ts index 0bcd17b..b2a31e4 100644 --- a/packages/web/src/components/chat/tool-renderers/index.ts +++ b/packages/web/src/components/chat/tool-renderers/index.ts @@ -55,7 +55,7 @@ export interface ToolRenderer { * 所以这里只需注册核心短名即可。 */ export const TOOL_RENDERERS: Record = { - // Claude 内置工具 + // Claude 内置工具（CodeBuddy SDK，名字是 PascalCase） Bash: bashRenderer, Read: readRenderer, Write: writeRenderer, @@ -70,6 +70,19 @@ export const TOOL_RENDERERS: Record = { Agent: taskRenderer, // Anthropic SDK 的 Agent 工具等价 Task ImageGen: imageGenRenderer, ImageEdit: imageGenRenderer, // 复用 ImageGen 渲染器 + + // OpenCode builtin 工具（小写命名，复用同一套渲染器） + bash: bashRenderer, + read: readRenderer, + write: writeRenderer, + edit: editRenderer, + multiedit: editRenderer, + grep: grepRenderer, + glob: globRenderer, + webfetch: webFetchRenderer, + websearch: webSearchRenderer, + todowrite: todoWriteRenderer, + task: taskRenderer, } /** diff --git a/packages/web/src/components/home-page-content.tsx b/packages/web/src/components/home-page-content.tsx index 822884b..ec445c9 100644 --- a/packages/web/src/components/home-page-content.tsx +++ b/packages/web/src/components/home-page-content.tsx @@ -433,11 +433,13 @@ export function HomePageContent({ selectedAgent: string selectedModel: string selectedModels?: string[] + selectedRuntime?: string installDependencies: boolean maxDuration: number keepAlive: boolean enableBrowser: boolean mode: 'default' | 'coding' + imageBlocks?: Array<{ data: string; mimeType: string }> }) => { console.log( '[TaskSubmit] called, isSubmitting:', @@ -492,6 +494,7 @@ export function HomePageContent({ repoUrl: repo.clone_url, selectedAgent: data.selectedAgent, selectedModel: data.selectedModel, + selectedRuntime: data.selectedRuntime, installDependencies: data.installDependencies, maxDuration: data.maxDuration, keepAlive: data.keepAlive, @@ -566,6 +569,7 @@ export function HomePageContent({ repoUrl: data.repoUrl, selectedAgent: agent, selectedModel: model, + selectedRuntime: data.selectedRuntime, installDependencies: data.installDependencies, maxDuration: data.maxDuration, keepAlive: data.keepAlive, @@ -668,6 +672,10 @@ export function HomePageContent({ // 全部成功，重置状态后再跳转 console.log('[TaskSubmit] all success, navigating to /tasks/' + id) setIsSubmitting(false) + // Save image blocks to sessionStorage so task-page-client can pick them up + if (data.imageBlocks && data.imageBlocks.length > 0) { + sessionStorage.setItem(`task-images-${id}`, JSON.stringify(data.imageBlocks)) + } navigate(`/tasks/${id}?prompt=${encodeURIComponent(data.prompt)}`) await refreshTasks() } catch (error) { diff --git a/packages/web/src/components/logos/index.ts b/packages/web/src/components/logos/index.ts index bd6215b..c6274e2 100644 --- a/packages/web/src/components/logos/index.ts +++ b/packages/web/src/components/logos/index.ts @@ -4,5 +4,6 @@ export { default as Codex } from './codex' export { default as Copilot } from './copilot' export { default as Cursor } from './cursor' export { default as Gemini } from './gemini' +export { default as MiMo } from './mimo' export { default as OpenCode } from './opencode' export { ProviderLogos, type ProviderKey } from './provider-logos' diff --git a/packages/web/src/components/logos/mimo.tsx b/packages/web/src/components/logos/mimo.tsx new file mode 100644 index 0000000..00f24e8 --- /dev/null +++ b/packages/web/src/components/logos/mimo.tsx @@ -0,0 +1,26 @@ +import * as React from 'react' + +// MiMo logo — PNG asset from public/logos/mimo.png +// Accepts className/style like other logo components so it fits inline selectors +const MiMo = ({ + className, + style, + width, + height, +}: { + className?: string + style?: React.CSSProperties + width?: string | number + height?: string | number +}) => ( + MiMo +) + +export default MiMo diff --git a/packages/web/src/components/logos/provider-logos.tsx b/packages/web/src/components/logos/provider-logos.tsx index d0e01b2..9c2b6d7 100644 --- a/packages/web/src/components/logos/provider-logos.tsx +++ b/packages/web/src/components/logos/provider-logos.tsx @@ -59,6 +59,11 @@ const MiniMax = (props: SVGProps & React.ImgHTMLAttributes)} /> ) +// MiMo / Xiaomi MiMo (official brand PNG) +const MiMoProvider = (props: SVGProps & React.ImgHTMLAttributes) => ( + MiMo)} /> +) + // DeepSeek (from @lobehub/icons, official brand) const DeepSeek = (props: SVGProps) => ( @@ -159,6 +164,7 @@ export const ProviderLogos = { baidu: Baidu, generic: GenericLLM, minimax: MiniMax, + mimo: MiMoProvider, } as const export type ProviderKey = keyof typeof ProviderLogos diff --git a/packages/web/src/components/task-chat.tsx b/packages/web/src/components/task-chat.tsx index 310d1f0..2d7c8bc 100644 --- a/packages/web/src/components/task-chat.tsx +++ b/packages/web/src/components/task-chat.tsx @@ -35,6 +35,8 @@ import { MoreVertical, MessageSquare, Trash2, + X, + ImageIcon, } from 'lucide-react' import { toast } from 'sonner' import { Streamdown } from 'streamdown' @@ -43,7 +45,16 @@ import { taskChatInputAtomFamily } from '@/lib/atoms/task' import { DropdownMenu, DropdownMenuContent, DropdownMenuItem, DropdownMenuTrigger } from '@/components/ui/dropdown-menu' import { TaskListPanel } from '@/components/chat/task-list-panel' -const HIDDEN_TOOLS = new Set(['TaskCreate', 'TaskUpdate', 'TaskList', 'TaskGet']) +const HIDDEN_TOOLS = new Set([ + // CodeBuddy SDK task management 工具（由 TaskListPanel 独立展示） + 'TaskCreate', + 'TaskUpdate', + 'TaskList', + 'TaskGet', + // OpenCode 的 todowrite（同样交给 TaskListPanel 统一展示） + 'todowrite', + 'TodoWrite', +]) export function TaskChat({ taskId, @@ -62,6 +73,10 @@ export function TaskChat({ const [copiedMessageId, setCopiedMessageId] = useState(null) const [isStopping, setIsStopping] = useState(false) const [activeTab, setActiveTab] = useState('chat') + const [pendingImages, setPendingImages] = useState< + Array<{ id: string; url: string; data: string; mimeType: string }> + >([]) + const imageInputRef = useRef(null) // Tab data const [prComments, setPrComments] = useState([]) @@ -397,10 +412,12 @@ export function TaskChat({ const isAgentBusy = task.status === 'processing' || task.status === 'pending' const handleSendMessage = async () => { - if (!newMessage.trim() || isSending || isAgentBusy) return + if ((!newMessage.trim() && pendingImages.length === 0) || isSending || isAgentBusy) return const text = newMessage.trim() + const images = pendingImages.map(({ data, mimeType }) => ({ data, mimeType })) setNewMessage('') - await chatSendMessage(text, (draft) => setNewMessage(draft)) + setPendingImages([]) + await chatSendMessage(text, (draft) => setNewMessage(draft), images.length > 0 ? images : undefined) await fetchMessages(false) } @@ -412,6 +429,45 @@ export function TaskChat({ } } + const processImageFile = (file: File) => { + if (!file.type.startsWith('image/')) return + const reader = new FileReader() + reader.onload = (e) => { + const dataUrl = e.target?.result as string + // dataUrl = "data:image/png;base64," + const base64 = dataUrl.split(',')[1] + const url = URL.createObjectURL(file) + setPendingImages((prev) => [ + ...prev, + { id: `img-${Date.now()}-${Math.random()}`, url, data: base64, mimeType: file.type }, + ]) + } + reader.readAsDataURL(file) + } + + const handlePasteImage = (e: React.ClipboardEvent) => { + const items = Array.from(e.clipboardData.items) + items.forEach((item) => { + if (item.type.startsWith('image/')) { + const file = item.getAsFile() + if (file) processImageFile(file) + } + }) + } + + const handleImageFiles = (e: React.ChangeEvent) => { + Array.from(e.target.files ?? []).forEach(processImageFile) + e.target.value = '' + } + + const removeImage = (id: string) => { + setPendingImages((prev) => { + const img = prev.find((i) => i.id === id) + if (img) URL.revokeObjectURL(img.url) + return prev.filter((i) => i.id !== id) + }) + } + const handleCopyMessage = async (messageId: string, content: string) => { try { await navigator.clipboard.writeText(content) @@ -921,6 +977,23 @@ export function TaskChat({ className={`${groupIndex > 0 ? 'mt-4' : ''} sticky top-0 z-10 before:content-[""] before:absolute before:inset-0 before:bg-background before:-z-10`} > + {/* Render image parts outside height-limited container */} + {group.userMessage.parts?.some((p) => p.type === 'image') && ( +
+ {group.userMessage.parts + .filter((p) => p.type === 'image') + .map((p, i) => + p.type === 'image' ? ( + + ) : null, + )} +
+ )}
{ contentRefs.current[group.userMessage.id] = el @@ -1328,15 +1401,50 @@ export function TaskChat({ {/* Input Area */} {!readOnly && activeTab === 'chat' && (
+ {/* Pending images preview */} + {pendingImages.length > 0 && ( +
+ {pendingImages.map((img) => ( +
+ + +
+ ))} +
+ )}