deskbuddy 0.1.0 → 0.2.0-beta.0

package/dist/opencode.mjs

@@ -0,0 +1,329 @@
+// DeskBuddy 的 opencode 插件本体（二期 P9）。
+// `deskbuddy enable opencode` 在 opencode 的插件目录放一个入口文件 import 本文件；
+// 本文件随 hook.cjs / gate.cjs 一起同步到 ~/.deskbuddy/，CLI 升级即生效。
+//
+// 做的事只有翻译：把 opencode 的事件翻成 cc-hook 同构的输入，喂给同目录的 hook.cjs（状态上报）
+// 和 gate.cjs（授权关卡）。状态机、关卡、和设备打交道全在它们和 daemon 里，这里不重复。
+//
+// 实测依据（opencode 1.18.32；1.4.3 远程关卡与窗口确认同样实测通过，spec 2026-09-27-DeskBuddy二期 §P9 O1–O8）：
+// - 插件的 `permission.ask` 钩子不会被调用；授权只能从事件流的 permission.asked / permission.replied 拿
+// - `tool.execute.before` 在权限判断之前触发、可以 await 任意久、抛错 = 这次调用失败
+// - `opencode run` 遇到 ask 立即自动拒绝
+// - `config` 钩子原地改 permission 能生效（整对象替换不行）
+//
+// 🔴 远程任务（环境变量 DESKBUDDY_GATE_RUN）的安全模型，三层：
+//    ① daemon 起进程前确认插件装在 opencode 会读的位置（daemon/index.ts）；
+//    ② OPENCODE_CONFIG_CONTENT 把 OC_GATED_KEYS 逐项压成 deny（全局 + build agent 两级）。
+//       opencode 按"最后一条匹配的规则"生效且配置是深合并：只写 `*: deny` 挡不住用户配置里排在后面的
+//       `bash: allow`（评审 2026-09-28 实测），逐项写才会把同名键的值覆盖掉；
+//    ③ 本插件加载后才在 config 里放开、并在 tool.execute.before 里等设备。
+//    残余：用户给清单外的权限名写了 allow，且插件恰好加载失败 —— 那一项会放行。远程模式下本文件任何失败都必须走"拒绝"。
+// 🔴 窗口模式反过来：任何失败都不表态，授权框照常由人处理。
+
+import { spawn } from 'node:child_process'
+import { dirname, join } from 'node:path'
+import { fileURLToPath } from 'node:url'
+
+const HERE = dirname(fileURLToPath(import.meta.url))
+const HOOK = join(HERE, 'hook.cjs')
+const GATE = join(HERE, 'gate.cjs')
+const TOOL = 'opencode'
+
+/** 设备允许过的工具调用，后续同一调用的第二个授权框直接代答（O6：rm /tmp/x 会连问 external_directory 和 bash） */
+const APPROVED_CALL_TTL_MS = 60 * 1000
+/** 工具调用参数的缓存时长：tool.execute.before 记下，随后的授权框靠它显示真实命令 */
+const CALL_TTL_MS = 10 * 60 * 1000
+/** hook.cjs 自己有 2 秒上报超时，这里再兜一层：一次卡死不能堵住后面所有状态 */
+const HOOK_KILL_MS = 10 * 1000
+
+/**
+ * 远程模式要压成 deny、插件加载后再放开的权限名。与 src/daemon/executor.ts 的 OPENCODE_GATED_KEYS 必须一致（有测试）。
+ * 新版本 opencode 多出来的权限名不在这里时，只剩 `*` 兜，见顶部"残余"
+ */
+export const OC_GATED_KEYS = [
+  '*', 'bash', 'edit', 'write', 'read', 'glob', 'grep', 'list', 'task', 'webfetch', 'websearch', 'codesearch',
+  'external_directory', 'todowrite', 'todoread', 'lsp', 'skill', 'doom_loop', 'patch', 'apply_patch',
+]
+
+function runIdFromEnv() {
+  const v = process.env.DESKBUDDY_GATE_RUN || ''
+  return /^[0-9a-zA-Z_-]{1,64}$/.test(v) ? v : ''
+}
+
+/**
+ * `opencode run` 是非交互（O2），其余（TUI、`opencode <目录>`）当窗口。编译版 argv = [bun, 入口, 子命令…]。
+ * 子命令前可能有全局参数（`--print-logs run`），所以看 `--` 之前有没有 `run`；误判成非交互只是少一个确认渠道
+ */
+export function isHeadless(argv = process.argv) {
+  const args = argv.slice(2)
+  const end = args.indexOf('--')
+  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（用户原来在这些键上写的值已被覆盖，找不回来 —— 每一步都要过设备）
+ * - 其余键上的 ask 放成 allow（run 下 ask = 立即拒），用户显式的 deny 保留
+ * 全局与 build agent 两级都放（daemon 两级都压了）
+ */
+export function openPermissions(cfg) {
+  if (!cfg || typeof cfg !== 'object') return
+  const open = (perm) => {
+    const walk = (obj) => {
+      for (const k of Object.keys(obj)) {
+        const v = obj[k]
+        if (v === 'ask') obj[k] = 'allow'
+        else if (v && typeof v === 'object') walk(v)
+      }
+    }
+    walk(perm)
+    for (const k of OC_GATED_KEYS) perm[k] = 'allow'
+  }
+  if (!cfg.permission || typeof cfg.permission !== 'object') cfg.permission = {}
+  open(cfg.permission)
+  const build = cfg.agent && cfg.agent.build
+  if (build && build.permission && typeof build.permission === 'object') open(build.permission)
+}
+
+/** 活着的子进程；opencode 退出时一并结束，不留孤儿 gate 挂着设备卡片（评审） */
+const LIVE = new Set()
+process.on('exit', () => {
+  for (const c of LIVE) {
+    try {
+      c.kill('SIGTERM')
+    } catch (_) {
+      /* 已经退了 */
+    }
+  }
+})
+
+/** 起 node 子进程跑 hook.cjs / gate.cjs，stdin 喂 JSON。返回子进程句柄与结束结果（起不来 = code -1）。killMs > 0 时到点结束 */
+function startChild(node, script, args, input, killMs = 0) {
+  let child = null
+  const done = new Promise((resolve) => {
+    let out = ''
+    let err = ''
+    try {
+      child = spawn(node, [script, ...args], { stdio: ['pipe', 'pipe', 'pipe'] })
+    } catch (e) {
+      resolve({ code: -1, out, err: String(e) })
+      return
+    }
+    LIVE.add(child)
+    const timer = killMs > 0 ? setTimeout(() => child.kill('SIGKILL'), killMs) : null
+    const finish = (r) => {
+      LIVE.delete(child)
+      if (timer) clearTimeout(timer)
+      resolve(r)
+    }
+    child.stdout.on('data', (c) => (out += c))
+    child.stderr.on('data', (c) => (err += c))
+    child.on('error', (e) => finish({ code: -1, out, err: String(e) }))
+    child.on('close', (code) => finish({ code, out, err }))
+    child.stdin.on('error', () => {})
+    child.stdin.end(JSON.stringify(input))
+  })
+  return { child, done }
+}
+
+const runChild = (node, script, args, input, killMs) => startChild(node, script, args, input, killMs).done
+
+export function make(opts = {}) {
+  return async function DeskBuddy(ctx) {
+    const node = process.env.DESKBUDDY_NODE || opts.node || 'node'
+    const client = ctx && ctx.client
+    const cwd = (ctx && (ctx.directory || ctx.worktree)) || process.cwd()
+    const runId = runIdFromEnv()
+    const headless = isHeadless()
+
+    // ---- 状态上报：串行喂 hook.cjs，保证 PreToolUse / PostToolUse / Stop 的先后 ----
+    let queue = Promise.resolve()
+    const report = (event, sessionID, extra) => {
+      if (!sessionID) return
+      const input = { hook_event_name: event, session_id: sessionID, cwd, ...extra }
+      queue = queue.then(() => runChild(node, HOOK, [TOOL], input, HOOK_KILL_MS)).catch(() => {})
+    }
+
+    // ---- 窗口确认 ----
+    const pending = new Map() // requestID → gate 子进程
+    const approvedCalls = new Map() // callID → 允许时间
+    const calls = new Map() // callID → { cc, at }：这次工具调用的真实参数
+    const prune = () => {
+      const now = Date.now()
+      for (const [k, v] of calls) if (now - v.at > CALL_TTL_MS) calls.delete(k)
+      for (const [k, at] of approvedCalls) if (now - at > APPROVED_CALL_TTL_MS) approvedCalls.delete(k)
+    }
+
+    const reply = async (sessionID, id, response) => {
+      try {
+        await client.postSessionIdPermissionsPermissionId({ path: { id: sessionID, permissionID: id }, body: { response } })
+      } catch (_) {
+        /* 已被人答复过等，无所谓 */
+      }
+    }
+
+    const toast = async (message) => {
+      try {
+        await client.tui.showToast({ body: { message, variant: 'info' } })
+      } catch (_) {
+        /* 没有 TUI（web / acp）就不提示 */
+      }
+    }
+
+    const onAsked = async (p) => {
+      const { id, sessionID } = p || {}
+      if (!id || !sessionID) return
+      prune()
+      const callID = p.tool && p.tool.callID
+      // 🔴 卡片用这次工具调用的真实参数（tool.execute.before 先于授权触发，O3）。
+      //    external_directory 的 ask 自己不带命令，按它出卡片设备只看到"访问 /tmp/*"（评审）
+      const call = callID ? calls.get(callID) : null
+      const cc = call ? call.cc : askToCc(p)
+      report('PermissionRequest', sessionID, cc)
+      if (runId || headless || !client) return
+      // 同一调用的后续授权框直接代答：只在设备那张卡显示的就是真实参数时（approvedCalls 只在那时写入）
+      const at = callID && approvedCalls.get(callID)
+      if (at && Date.now() - at < APPROVED_CALL_TTL_MS) {
+        await reply(sessionID, id, 'once')
+        return
+      }
+      const input = { hook_event_name: 'PermissionRequest', session_id: sessionID, cwd, ...cc }
+      const { child, done } = startChild(node, GATE, ['--window', '--tool', TOOL], input)
+      if (child) pending.set(id, child)
+      const r = await done
+      pending.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')
+      } else if (d.behavior === 'deny') {
+        await reply(sessionID, id, 'reject')
+      } else return
+      if (typeof out.systemMessage === 'string' && out.systemMessage) await toast(out.systemMessage)
+    }
+
+    const onReplied = (p) => {
+      // 人先在窗口里答了：结束 gate 子进程，daemon 随之撤掉设备上的卡片
+      const child = p && pending.get(p.requestID)
+      if (child) {
+        pending.delete(p.requestID)
+        try {
+          child.kill('SIGTERM')
+        } catch (_) {
+          /* 已经退了 */
+        }
+      }
+    }
+
+    return {
+      config: async (cfg) => {
+        if (runId) openPermissions(cfg)
+      },
+
+      'chat.message': async (input) => {
+        report('UserPromptSubmit', input && input.sessionID)
+      },
+
+      '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() })
+        report('PreToolUse', input && input.sessionID, cc)
+        if (!runId) return
+        // 远程关卡：等设备。任何失败都拒（见顶部）
+        const r = await runChild(node, GATE, ['--run', runId], {
+          hook_event_name: 'PreToolUse',
+          session_id: (input && input.sessionID) || '',
+          cwd,
+          ...cc,
+        })
+        let decision = ''
+        try {
+          decision = JSON.parse(r.out).hookSpecificOutput.permissionDecision
+        } catch (_) {
+          decision = ''
+        }
+        if (r.code === 0 && decision === 'allow') return
+        throw new Error((r.err || '').trim() || '用户在设备上拒绝了这一步')
+      },
+
+      'tool.execute.after': async (input) => {
+        if (input && input.callID) calls.delete(input.callID)
+        approvedCalls.delete(input && input.callID)
+        const cc = toCcTool(input && input.tool, input && input.args)
+        report('PostToolUse', input && input.sessionID, cc)
+      },
+
+      event: async ({ event }) => {
+        const p = (event && event.properties) || {}
+        switch (event && event.type) {
+          case 'permission.asked':
+            onAsked(p).catch(() => {})
+            break
+          case 'permission.replied':
+            onReplied(p)
+            break
+          case 'session.idle':
+            report('Stop', p.sessionID)
+            break
+          case 'session.deleted':
+            report('SessionEnd', (p.info && p.info.id) || p.sessionID)
+            break
+          default:
+        }
+      },
+    }
+  }
+}

package/hook/gate.cjs

@@ -0,0 +1,249 @@
+#!/usr/bin/env node
+'use strict'
+// 远程执行的「授权关卡」。daemon 起智能体时把它挂成 PreToolUse hook：
+//   node gate.cjs --run <runId>
+// 智能体每次要调工具都会先跑一次它。它只做一件事：把 hook 输入转给 daemon，
+// 把 daemon 的决定翻译成 hook 输出。分类、等待、和设备打交道全在 daemon 里。
+//
+// 🔴 铁律：**任何失败都 exit 2**。
+//    实测（2026-09-23，Qoder CN 1.1.61）：hook 崩溃、HTTP hook 连不上，智能体【照常执行】。
+//    Qoder 必须开 bypass_permissions 才能用，这时本脚本就是唯一的关卡 ——
+//    一个没接住的异常、一次 exit 0 的兜底，就等于把设备授权整个绕过去。
+//    exit 2 是四家公认的「阻止这次工具调用」，实测能拦住。
+//
+// 🔴 与 hook.cjs 相反，这里【不设超时】：用户可能过很久才在设备上按下允许，
+//    等待就是它的本职。超时由智能体那边的 hook timeout 兜（daemon 配 7 天）。
+//
+// 🔴 `--window` 模式（S10）的兜底方向**相反**：任何失败都 exit 0 且不输出。
+//    那是用户自己窗口里的 PermissionRequest hook，设备只是多一个答复的地方；不表态 = 授权框照常由人处理。
+//    PermissionRequest 下 exit 2 = 拒绝 —— 沿用上面的铁律，daemon 一挂，用户窗口里每个授权都会被自动拒掉。
+//
+// 只 require Node 内置模块，理由同 hook.cjs 顶部 ①。
+const fs = require('node:fs')
+const os = require('node:os')
+const path = require('node:path')
+const http = require('node:http')
+const { execFileSync } = require('node:child_process')
+
+const DECISIONS = new Set(['allow', 'deny', 'defer'])
+const WINDOW = process.argv.includes('--window')
+
+function fail(why) {
+  // 窗口模式：不表态，见顶部
+  if (WINDOW) process.exit(0)
+  try {
+    process.stderr.write(`DeskBuddy 授权关卡：${why}，已阻止这次操作\n`)
+  } catch (_) {
+    /* stderr 都写不了也必须继续走到 exit 2 */
+  }
+  process.exit(2)
+}
+
+function deskbuddyHome() {
+  return process.env.DESKBUDDY_HOME || path.join(os.homedir(), '.deskbuddy')
+}
+
+function argRun(argv) {
+  const i = argv.indexOf('--run')
+  const v = i >= 0 ? argv[i + 1] : ''
+  return typeof v === 'string' && /^[0-9a-zA-Z_-]{1,64}$/.test(v) ? v : ''
+}
+
+function readStdin() {
+  return new Promise((resolve, reject) => {
+    let buf = ''
+    process.stdin.setEncoding('utf8')
+    process.stdin.on('data', (c) => (buf += c))
+    process.stdin.on('end', () => resolve(buf))
+    process.stdin.on('error', reject)
+  })
+}
+
+function post(port, token, body) {
+  return new Promise((resolve, reject) => {
+    const req = http.request(
+      {
+        host: '127.0.0.1',
+        port,
+        method: 'POST',
+        path: '/gate',
+        headers: {
+          'content-type': 'application/json',
+          'content-length': Buffer.byteLength(body),
+          'x-gate-token': token,
+        },
+      },
+      (res) => {
+        let data = ''
+        res.setEncoding('utf8')
+        res.on('data', (c) => (data += c))
+        res.on('end', () => resolve({ status: res.statusCode, data }))
+        res.on('error', reject)
+      }
+    )
+    req.on('error', reject)
+    req.end(body)
+  })
+}
+
+/**
+ * 这个 hook 是不是由【交互窗口】里的 Claude Code 触发的。
+ * 🔴 实测（2026-09-24，2.1.259）：`claude -p` 碰到要授权的工具**也会**触发 PermissionRequest，
+ * 而 hook 输入里没有区分字段。不拦的话，用户脚本 / IDE 插件 / SDK 里的 claude 会被推到设备上一直挂着。
+ * 做法：沿父进程找到 claude，启动参数里有 -p / --print / stream-json 的一律当非交互。找不到也当非交互
+ */
+/** `--tool <name>`（二期 P8：窗口模式不只 Claude Code）。缺省 claude_code，兼容已装出去的 hook 命令 */
+function argTool(argv) {
+  const i = argv.indexOf('--tool')
+  const v = i >= 0 ? argv[i + 1] : ''
+  return typeof v === 'string' && /^[a-z_]{1,32}$/.test(v) ? v : 'claude_code'
+}
+
+/**
+ * 按智能体判断是不是交互窗口。
+ * - Qoder CN（2026-09-27 实测）：桌面端弹授权框时 hook 的父进程就是 `Qoder CN.app` 主进程；
+ *   daemon 起的远程任务走 worker（node），父进程链上没有它
+ * - Claude Code：见 isInteractiveClaude
+ */
+function isInteractiveAgent(tool) {
+  if (tool === 'qoder') return hasAncestor((comm) => comm.includes('/Qoder CN.app/'))
+  if (tool === 'claude_code') return isInteractiveClaude()
+  // opencode 的窗口确认由插件发起，插件已排除 `opencode run`（hook/opencode.mjs isHeadless）
+  if (tool === 'opencode') return true
+  return false
+}
+
+function hasAncestor(match) {
+  let pid = process.ppid
+  for (let i = 0; i < 8 && pid > 1; i++) {
+    let line
+    try {
+      line = execFileSync('ps', ['-o', 'ppid=,comm=', '-p', String(pid)], { encoding: 'utf8', stdio: ['ignore', 'pipe', 'ignore'] }).trim()
+    } catch (_) {
+      return false
+    }
+    const m = line.match(/^(\d+)\s+(.*)$/)
+    if (!m) return false
+    if (match(m[2])) return true
+    pid = Number(m[1])
+  }
+  return false
+}
+
+function isInteractiveClaude() {
+  let pid = process.ppid
+  for (let i = 0; i < 8 && pid > 1; i++) {
+    let line
+    try {
+      line = execFileSync('ps', ['-o', 'ppid=,comm=', '-p', String(pid)], { encoding: 'utf8', stdio: ['ignore', 'pipe', 'ignore'] }).trim()
+    } catch (_) {
+      return false
+    }
+    const m = line.match(/^(\d+)\s+(.*)$/)
+    if (!m) return false
+    if (path.basename(m[2]) === 'claude') {
+      let args = ''
+      try {
+        args = execFileSync('ps', ['-ww', '-o', 'args=', '-p', String(pid)], { encoding: 'utf8', stdio: ['ignore', 'pipe', 'ignore'] })
+      } catch (_) {
+        return false
+      }
+      const tokens = args.trim().split(/\s+/)
+      // 短参数可能合写（`-cp`）；args 里 argv[0] 之后才算参数
+      return !tokens.slice(1).some(
+        (t) => t === '--print' || /^-[a-zA-Z]*p[a-zA-Z]*$/.test(t) || t === 'stream-json' || t.startsWith('--output-format=stream')
+      )
+    }
+    pid = Number(m[1])
+  }
+  return false
+}
+
+/** 窗口模式：daemon 回 allow / deny 才表态，其余一律不输出、exit 0 */
+async function windowMain() {
+  // DESKBUDDY_GATE_ASSUME_INTERACTIVE 只给测试用：1 当交互、0 当非交互，其余真去查进程
+  const tool = argTool(process.argv)
+  const forced = process.env.DESKBUDDY_GATE_ASSUME_INTERACTIVE
+  if (forced === '0' || (forced !== '1' && !isInteractiveAgent(tool))) return fail()
+  const conf = JSON.parse(fs.readFileSync(path.join(deskbuddyHome(), 'gate.json'), 'utf8'))
+  if (!conf || !Number.isInteger(conf.port) || typeof conf.token !== 'string' || !conf.token) return fail()
+  const hook = JSON.parse(await readStdin())
+  const res = await post(conf.port, conf.token, JSON.stringify({ mode: 'window', tool, hook }))
+  if (res.status !== 200) return fail()
+  const out = JSON.parse(res.data)
+  if (!out || (out.decision !== 'allow' && out.decision !== 'deny')) return fail()
+  const decision =
+    out.decision === 'allow'
+      ? Array.isArray(out.updatedPermissions) && out.updatedPermissions.length > 0
+        ? { behavior: 'allow', updatedPermissions: out.updatedPermissions }
+        : { behavior: 'allow' }
+      : { behavior: 'deny', message: (typeof out.reason === 'string' && out.reason) || '用户在设备上拒绝了这一步' }
+  const body = { hookSpecificOutput: { hookEventName: 'PermissionRequest', decision } }
+  // 窗口里告诉人是在哪台设备上处理的
+  if (typeof out.notice === 'string' && out.notice) body.systemMessage = out.notice.slice(0, 300)
+  process.stdout.write(JSON.stringify(body), () => process.exit(0))
+}
+
+async function main() {
+  if (WINDOW) return windowMain()
+  const runId = argRun(process.argv)
+  if (!runId) return fail('缺少 --run')
+
+  let conf
+  try {
+    conf = JSON.parse(fs.readFileSync(path.join(deskbuddyHome(), 'gate.json'), 'utf8'))
+  } catch (_) {
+    return fail('找不到守护进程（gate.json 读不到）')
+  }
+  if (!conf || !Number.isInteger(conf.port) || typeof conf.token !== 'string' || !conf.token) {
+    return fail('gate.json 内容不对')
+  }
+
+  let hook
+  try {
+    hook = JSON.parse(await readStdin())
+  } catch (_) {
+    return fail('读不懂 hook 输入')
+  }
+
+  let res
+  try {
+    res = await post(conf.port, conf.token, JSON.stringify({ runId, hook }))
+  } catch (e) {
+    return fail(`连不上守护进程（${(e && e.code) || 'error'}）`)
+  }
+  if (res.status !== 200) return fail(`守护进程返回 ${res.status}`)
+
+  let out
+  try {
+    out = JSON.parse(res.data)
+  } catch (_) {
+    return fail('守护进程的回复读不懂')
+  }
+  if (!out || !DECISIONS.has(out.decision)) return fail('守护进程给了不认识的决定')
+
+  const reason = typeof out.reason === 'string' ? out.reason : ''
+
+  // 🔴 拒绝一律走 stderr + exit 2，不走 JSON（评审 S5）：exit 2 是四家公认的"拦下"，
+  //    而 JSON 那条路要是 stdout 没写完进程就退了，智能体拿到的是"exit 0 + 没有决定"，
+  //    Qoder 在 bypass 下会当成放行。拒绝的方向必须不依赖任何一次写入成功
+  if (out.decision === 'deny') {
+    process.stderr.write(`${reason || '用户在设备上拒绝了这一步'}\n`, () => process.exit(2))
+    return
+  }
+
+  const payload = JSON.stringify({
+    hookSpecificOutput: {
+      hookEventName: 'PreToolUse',
+      permissionDecision: out.decision,
+      permissionDecisionReason: reason,
+    },
+  })
+  // 等写完再退：管道写入是异步的，写一半就 exit 的话 allow / defer 会丢
+  process.stdout.write(payload, (err) => (err ? fail('写 hook 输出失败') : process.exit(0)))
+}
+
+// 兜住一切没想到的异常 —— 见顶部铁律
+process.on('uncaughtException', (e) => fail(`内部错误 ${(e && e.message) || e}`))
+process.on('unhandledRejection', (e) => fail(`内部错误 ${(e && e.message) || e}`))
+main().catch((e) => fail(`内部错误 ${(e && e.message) || e}`))