deskbuddy 0.2.0-beta.2 → 0.2.0-beta.21

package/hook/opencode.mjs

@@ -21,8 +21,13 @@
 // 🔴 窗口模式反过来：任何失败都不表态，授权框照常由人处理。
 
 import { spawn } from 'node:child_process'
+import { appendFileSync } from 'node:fs'
 import { dirname, join } from 'node:path'
 import { fileURLToPath } from 'node:url'
+import { alwaysSuggestions, askToCc, isPlainQuestion, ocReplyOf, questionToCc, rememberTitle, supportsPermissionReply, toCcTool } from './ocTranslate.mjs'
+
+// 翻译函数搬到了 ocTranslate.mjs（与 DumateWatch 共用），这里转出去保持原来的导出
+export { alwaysSuggestions, askToCc, isPlainQuestion, ocReplyOf, questionToCc, rememberTitle, supportsPermissionReply, toCcTool }
 
 const HERE = dirname(fileURLToPath(import.meta.url))
 const HOOK = join(HERE, 'hook.cjs')
@@ -35,6 +40,8 @@ const APPROVED_CALL_TTL_MS = 60 * 1000
 const CALL_TTL_MS = 10 * 60 * 1000
 /** hook.cjs 自己有 2 秒上报超时，这里再兜一层：一次卡死不能堵住后面所有状态 */
 const HOOK_KILL_MS = 10 * 1000
+/** chat.message 里同步取「窗口外追加」的上限：它卡着用户这句话发出去 */
+const APPENDED_KILL_MS = 3 * 1000
 
 /**
  * 远程模式要压成 deny、插件加载后再放开的权限名。与 src/daemon/executor.ts 的 OPENCODE_GATED_KEYS 必须一致（有测试）。
@@ -60,51 +67,6 @@ export function isHeadless(argv = process.argv) {
   return (end >= 0 ? args.slice(0, end) : args).includes('run')
 }
 
-/** opencode 工具 → cc-hook 同构的 tool_name / tool_input（daemon 的 classify 按 Claude Code 的工具名判断） */
-export function toCcTool(tool, args) {
-  const a = args && typeof args === 'object' ? args : {}
-  const s = (v) => (typeof v === 'string' ? v : '')
-  switch (tool) {
-    case 'bash':
-      return { tool_name: 'Bash', tool_input: { command: s(a.command) } }
-    case 'read':
-      return { tool_name: 'Read', tool_input: { file_path: s(a.filePath) } }
-    case 'edit':
-      return { tool_name: 'Edit', tool_input: { file_path: s(a.filePath) } }
-    case 'write':
-      return { tool_name: 'Write', tool_input: { file_path: s(a.filePath) } }
-    case 'glob':
-      return { tool_name: 'Glob', tool_input: { pattern: s(a.pattern), path: s(a.path) } }
-    case 'grep':
-      return { tool_name: 'Grep', tool_input: { pattern: s(a.pattern), path: s(a.path) } }
-    case 'list':
-      return { tool_name: 'LS', tool_input: { path: s(a.path) } }
-    case 'webfetch':
-      return { tool_name: 'WebFetch', tool_input: { url: s(a.url) } }
-    case 'task':
-      return { tool_name: 'Task', tool_input: {} }
-    case 'todowrite':
-    case 'todoread':
-      return { tool_name: 'TodoWrite', tool_input: {} }
-    case 'patch':
-    case 'apply_patch':
-      return { tool_name: 'apply_patch', tool_input: { patch: s(a.patchText) || s(a.patch) || s(a.input) } }
-    default:
-      // 不认识的工具（MCP 等）原名原参数交出去：classify 对不认识的一律推设备
-      return { tool_name: String(tool || ''), tool_input: a }
-  }
-}
-
-/** permission.asked → PermissionRequest 的 tool_name / tool_input，给设备卡片生成摘要 */
-export function askToCc(props) {
-  const md = (props && props.metadata) || {}
-  if (typeof md.command === 'string' && md.command) return { tool_name: 'Bash', tool_input: { command: md.command } }
-  const file = md.filepath || md.filePath
-  if (typeof file === 'string' && file) return { tool_name: 'Edit', tool_input: { file_path: file } }
-  const patterns = Array.isArray(props && props.patterns) ? props.patterns.join(' ') : ''
-  return { tool_name: String((props && props.permission) || 'permission'), tool_input: { path: patterns } }
-}
-
 /**
  * 远程模式：关卡改由 tool.execute.before 把，放开权限。🔴 必须原地改（整对象替换不生效，O8）。
  * - OC_GATED_KEYS 是 daemon 压成 deny 的，放成 allow（用户原来在这些键上写的值已被覆盖，找不回来 —— 每一步都要过设备）
@@ -130,6 +92,46 @@ export function openPermissions(cfg) {
   if (build && build.permission && typeof build.permission === 'object') open(build.permission)
 }
 
+/** chat.message 的 output（{ message, parts }）里用户自己打的字：text 类 part，跳过 synthetic（插件 / 系统补的） */
+export function userText(output) {
+  const parts = output && Array.isArray(output.parts) ? output.parts : []
+  return parts
+    .filter((p) => p && p.type === 'text' && !p.synthetic && typeof p.text === 'string')
+    .map((p) => p.text)
+    .join('\n')
+}
+
+/** opencode 风格的 part id（prt_ + 时间 + 随机），只要求唯一且大致递增 */
+function partId() {
+  return 'prt_' + Date.now().toString(16).padStart(12, '0') + Math.random().toString(16).slice(2, 16).padEnd(14, '0')
+}
+
+/**
+ * 切片 C：把 hook.cjs `--appended` 快速路径的输出补进这条用户消息：additionalContext 作为一条 synthetic 文本 part
+ * （模型看得到、userText 不会把它当成用户打的字）。返回要 toast 的 systemMessage。任何异常吞掉、不影响发消息
+ */
+export function injectAppended(output, raw) {
+  let o
+  try {
+    o = JSON.parse(raw)
+  } catch (_) {
+    return ''
+  }
+  const ctx = o && o.hookSpecificOutput && o.hookSpecificOutput.additionalContext
+  const msg = output && output.message
+  if (typeof ctx === 'string' && ctx && output && Array.isArray(output.parts)) {
+    output.parts.push({
+      id: partId(),
+      sessionID: (msg && msg.sessionID) || '',
+      messageID: (msg && msg.id) || '',
+      type: 'text',
+      text: ctx,
+      synthetic: true,
+    })
+  }
+  return o && typeof o.systemMessage === 'string' ? o.systemMessage : ''
+}
+
 /** 活着的子进程；opencode 退出时一并结束，不留孤儿 gate 挂着设备卡片（评审） */
 const LIVE = new Set()
 process.on('exit', () => {
@@ -173,7 +175,18 @@ function startChild(node, script, args, input, killMs = 0) {
 
 const runChild = (node, script, args, input, killMs) => startChild(node, script, args, input, killMs).done
 
+/**
+ * 跑在百度搭子（DuMate，内核是改名的 opencode：dumate-opencode）里。那边的会话由 daemon 的 DumateWatch 直连 HTTP 上报和推卡，
+ * 插件再报一遍就是 tool=opencode 的第二份会话 + 双卡（spec 2026-10-03 §3.2「防双卡」）
+ */
+export function isDumateHost(env = process.env, execPath = process.execPath) {
+  return !!(env && env.DUMATE_INAPP_KEY) || /dumate-opencode/i.test(String(execPath || ''))
+}
+
 export function make(opts = {}) {
+  if (isDumateHost(opts.env, opts.execPath)) return async function DeskBuddyOff() {
+    return {}
+  }
   return async function DeskBuddy(ctx) {
     const node = process.env.DESKBUDDY_NODE || opts.node || 'node'
     const client = ctx && ctx.client
@@ -183,9 +196,13 @@ export function make(opts = {}) {
 
     // ---- 状态上报：串行喂 hook.cjs，保证 PreToolUse / PostToolUse / Stop 的先后 ----
     let queue = Promise.resolve()
+    const titles = new Map() // sessionID → opencode 自动生成的标题（session.updated 里来）
+    const children = new Set() // 子会话（subagent，带 parentID）：它们的 Reject 在电脑上会弹输入框
     const report = (event, sessionID, extra) => {
       if (!sessionID) return
       const input = { hook_event_name: event, session_id: sessionID, cwd, ...extra }
+      const title = titles.get(sessionID)
+      if (title) input.oc_session_title = title
       queue = queue.then(() => runChild(node, HOOK, [TOOL], input, HOOK_KILL_MS)).catch(() => {})
     }
 
@@ -232,7 +249,18 @@ export function make(opts = {}) {
         await reply(sessionID, id, 'once')
         return
       }
-      const input = { hook_event_name: 'PermissionRequest', session_id: sessionID, cwd, ...cc }
+      const sugg = alwaysSuggestions(p)
+      const input = {
+        hook_event_name: 'PermissionRequest',
+        session_id: sessionID,
+        cwd,
+        ...cc,
+        ...(sugg ? { permission_suggestions: sugg } : {}),
+        // 授权选项透传：设备上照 TUI 出 Allow once / Allow always / Reject（daemon 按这几项生成）
+        oc_permission: typeof p.permission === 'string' ? p.permission : '',
+        oc_always: Array.isArray(p.always) ? p.always.filter((x) => typeof x === 'string') : [],
+        oc_child: children.has(sessionID),
+      }
       const { child, done } = startChild(node, GATE, ['--window', '--tool', TOOL], input)
       if (child) pending.set(id, child)
       const r = await done
@@ -244,16 +272,113 @@ export function make(opts = {}) {
       } catch (_) {
         return
       }
+      const r2 = ocReplyOf(out)
+      if (!r2) return
+      if (r2.reply !== 'reject' && callID && call) approvedCalls.set(callID, Date.now())
+      if (r2.message && (await canReplyWithMessage())) {
+        // 拒绝并说明：只有新路由收 message（旧路由 200 但会把 message 吃掉，notes §1.3）；新路由失败退回不带说明的拒绝
+        const ok = await postRaw('/permission/{requestID}/reply', { requestID: id }, { reply: 'reject', message: r2.message })
+        if (!ok) await reply(sessionID, id, 'reject')
+      } else {
+        // 版本判断不了 / 不支持：不碰新路由（未知路由可能被转发出去），退回旧路由拒绝，反馈丢弃
+        if (r2.message) debugLog('opencode 版本不确定支持带说明的拒绝，设备上的反馈没有带给模型')
+        await reply(sessionID, id, r2.reply)
+      }
+      if (typeof out.systemMessage === 'string' && out.systemMessage) await toast(out.systemMessage)
+    }
+
+    // ---- 选择题（question.asked）：推设备作答，答案经 /question/{id}/reply 回填；设备跳过 → reject ----
+    const pendingQ = new Map() // requestID → gate 子进程
+    const debugLog = (line) => {
+      try {
+        appendFileSync(join(HERE, 'hook-debug.log'), `${new Date().toISOString()} [opencode] ${line}\n`, 'utf8')
+      } catch (_) {
+        /* 记不下不影响 */
+      }
+    }
+    /** 返回是否成功（hey-api 客户端不抛错，失败在返回值的 error / response.status 里） */
+    const postRaw = async (url, path, body) => {
+      // 插件拿到的是 v1 SDK 客户端，没有 question 的方法：用它底下的 HTTP 客户端直接打（路径参数由客户端填）
+      const http = client && (client._client || client.client)
+      if (!http || typeof http.post !== 'function') {
+        debugLog(`回填选择题失败：客户端没有 post（${url}）`)
+        return false
+      }
+      try {
+        const r = await http.post({ url, path, ...(body ? { body, headers: { 'Content-Type': 'application/json' } } : {}) })
+        const status = r && r.response && typeof r.response.status === 'number' ? r.response.status : 0
+        if ((r && r.error) || status >= 400) {
+          debugLog(`回填选择题失败：${url} status=${status || '?'}`)
+          return false
+        }
+        return true
+      } catch (e) {
+        debugLog(`回填选择题出错：${url} ${(e && e.message) || e}`)
+        return false
+      }
+    }
+    /** opencode 版本（GET /global/health 的 version，进程内只问一次）是否支持 /permission/{id}/reply 带 message */
+    let replyMsgOk = null
+    const canReplyWithMessage = async () => {
+      if (replyMsgOk !== null) return replyMsgOk
+      let version = ''
+      try {
+        const http = client && (client._client || client.client)
+        const r = http && typeof http.get === 'function' ? await http.get({ url: '/global/health' }) : null
+        const data = r && (r.data !== undefined ? r.data : null)
+        version = data && typeof data.version === 'string' ? data.version : ''
+      } catch (_) {
+        version = ''
+      }
+      replyMsgOk = supportsPermissionReply(version)
+      if (!replyMsgOk) debugLog(`opencode 版本 ${version || '读不出'}：带说明的拒绝不走新路由`)
+      return replyMsgOk
+    }
+    const onQuestion = async (p) => {
+      const { id, sessionID } = p || {}
+      if (!id || !sessionID || runId || headless || !client) return
+      const call = p.tool && p.tool.callID ? calls.get(p.tool.callID) : null
+      if (!isPlainQuestion(p, call && call.tool)) return
+      const cc = questionToCc(p)
+      if (!cc) return
+      const input = { hook_event_name: 'PermissionRequest', session_id: sessionID, cwd, ...cc }
+      const { child, done } = startChild(node, GATE, ['--window', '--tool', TOOL], input)
+      if (child) pendingQ.set(id, child)
+      const r = await done
+      pendingQ.delete(id)
+      if (r.code !== 0 || !r.out) return
+      let out
+      try {
+        out = JSON.parse(r.out)
+      } catch (_) {
+        return
+      }
       const d = out && out.hookSpecificOutput && out.hookSpecificOutput.decision
       if (!d) return
-      if (d.behavior === 'allow') {
-        if (callID && call) approvedCalls.set(callID, Date.now())
-        await reply(sessionID, id, 'once')
+      let ok
+      if (d.behavior === 'allow' && Array.isArray(out.deskbuddyAnswers)) {
+        ok = await postRaw('/question/{requestID}/reply', { requestID: id }, { answers: out.deskbuddyAnswers })
       } else if (d.behavior === 'deny') {
-        await reply(sessionID, id, 'reject')
+        ok = await postRaw('/question/{requestID}/reject', { requestID: id })
       } else return
+      if (!ok) {
+        await toast('设备答案未能回填，请在窗口作答')
+        return
+      }
       if (typeof out.systemMessage === 'string' && out.systemMessage) await toast(out.systemMessage)
     }
+    const onQuestionDone = (p) => {
+      // 人先在窗口里答了 / 拒了：结束 gate 子进程，daemon 随之撤掉设备上的卡片
+      const child = p && pendingQ.get(p.requestID)
+      if (child) {
+        pendingQ.delete(p.requestID)
+        try {
+          child.kill('SIGTERM')
+        } catch (_) {
+          /* 已经退了 */
+        }
+      }
+    }
 
     const onReplied = (p) => {
       // 人先在窗口里答了：结束 gate 子进程，daemon 随之撤掉设备上的卡片
@@ -273,13 +398,26 @@ export function make(opts = {}) {
         if (runId) openPermissions(cfg)
       },
 
-      'chat.message': async (input) => {
-        report('UserPromptSubmit', input && input.sessionID)
+      'chat.message': async (input, output) => {
+        // prompt 给 hook 的 first-prompt 标题来源用（只记首条，见 hook.cjs）
+        report('UserPromptSubmit', input && input.sessionID, { prompt: userText(output) })
+        // 切片 C：设备在这个窗口之外追加、daemon 后台跑完的轮次，同步取出补进这条消息（常规 report 是异步的，输出不读）
+        // daemon 起的远程 run（runId）不取：那是留给用户窗口的（hook 侧还有 DESKBUDDY_HEADLESS 兜一层）
+        if (runId || !(input && input.sessionID)) return
+        try {
+          const r = await runChild(node, HOOK, [TOOL, '--appended'], { hook_event_name: 'UserPromptSubmit', session_id: input.sessionID, cwd }, APPENDED_KILL_MS)
+          if (r.code === 0 && r.out) {
+            const note = injectAppended(output, r.out)
+            if (note) await toast(note)
+          }
+        } catch (_) {
+          /* 补不了就算了 */
+        }
       },
 
       'tool.execute.before': async (input, output) => {
         const cc = toCcTool(input && input.tool, output && output.args)
-        if (input && input.callID) calls.set(input.callID, { cc, at: Date.now() })
+        if (input && input.callID) calls.set(input.callID, { cc, tool: input && input.tool, at: Date.now() })
         report('PreToolUse', input && input.sessionID, cc)
         if (!runId) return
         // 远程关卡：等设备。任何失败都拒（见顶部）
@@ -315,10 +453,23 @@ export function make(opts = {}) {
           case 'permission.replied':
             onReplied(p)
             break
+          case 'question.asked':
+            onQuestion(p).catch(() => {})
+            break
+          case 'question.replied':
+          case 'question.rejected':
+            onQuestionDone(p)
+            break
           case 'session.idle':
             report('Stop', p.sessionID)
             break
+          case 'session.created':
+          case 'session.updated':
+            if (event.type === 'session.updated') rememberTitle(titles, p.info)
+            if (p.info && typeof p.info.id === 'string' && p.info.parentID) children.add(p.info.id)
+            break
           case 'session.deleted':
+            children.delete((p.info && p.info.id) || p.sessionID)
             report('SessionEnd', (p.info && p.info.id) || p.sessionID)
             break
           default: