@zmainer/dsh-wx-bridge 1.1.6 → 1.1.7

package/lib/kernel/acp.mjs

@@ -128,6 +128,11 @@ export class AcpHost {
       const p = this.pending.get(f.id)
       if (!p) return
       this.pending.delete(f.id)
+      if (p.late) {
+        // 迟到帧：调用方早已按超时返回，但这一轮其实跑完了 → 交回给它补发结果
+        try { p.late(f.error ? null : f.result, f.error ? new Error(String(f.error.message || 'rpc error')) : null) } catch (e) { this.log('acp-late-handler-failed', { error: String(e?.message ?? e) }) }
+        return
+      }
       if (f.error) p.reject(Object.assign(new Error(String(f.error.message || 'rpc error')), { rpc: f.error }))
       else p.resolve(f.result)
       return
@@ -181,10 +186,23 @@ export class AcpHost {
     try { this.child.stdin.write(JSON.stringify(frame) + NL) } catch (e) { this.log('acp-write-failed', { error: String(e?.message ?? e) }) }
   }
 
-  _request(method, params, timeoutMs) {
+  _request(method, params, timeoutMs, opts) {
+    const o = opts || {}
     return new Promise((resolve, reject) => {
       const id = this.nextId++
-      const t = setTimeout(() => { this.pending.delete(id); reject(new Error('ACP 超时：' + method)) }, Number(timeoutMs || this.promptTimeoutMs))
+      const t = setTimeout(() => {
+        const err = Object.assign(new Error('ACP 超时：' + method), { code: 'ACP_TIMEOUT', method })
+        // 超时 ≠ 失败：`session/prompt` 的一方仍在跑，服务端最后一定会回这一帧。
+        // keepAliveOnTimeout 时**保留 pending 条目**，让它落地时走 onLate（避免"以为失败了"→ 兜底重跑一遍）。
+        if (o.keepAliveOnTimeout) {
+          const p = this.pending.get(id)
+          if (p) { p.late = o.onLate || null; p.timedOutAt = Date.now() }
+          this.log('acp-request-timeout-kept-alive', { id, method, timeoutMs: Number(timeoutMs || this.promptTimeoutMs) })
+        } else {
+          this.pending.delete(id)
+        }
+        reject(err)
+      }, Number(timeoutMs || this.promptTimeoutMs))
       this.pending.set(id, { resolve: (v) => { clearTimeout(t); resolve(v) }, reject: (e) => { clearTimeout(t); reject(e) } })
       this._raw({ jsonrpc: '2.0', id, method, params })
     })
@@ -230,10 +248,16 @@ export class AcpHost {
 
   /**
    * 发一轮提示词，收集助手正文（思考块与工具生命周期走 onUpdate，便于回传进度）。
+   *
+   * @param {object} [opts]
+   * @param {number} [opts.timeoutMs]            本轮等待上限（默认 promptTimeoutMs）
+   * @param {boolean} [opts.keepAliveOnTimeout]  超时后**不要丢弃**这一轮：迟到帧交给 onLate
+   * @param {(r:{text:string,stopReason:string|null,toolCalls:number,error:Error|null})=>void} [opts.onLate]
    * @returns {Promise<{text:string, stopReason:string, toolCalls:number}>}
    */
-  async ask(sessionId, text, onUpdate) {
+  async ask(sessionId, text, onUpdate, opts) {
     await this.ensure()
+    const o = opts || {}
     let out = ''
     let tools = 0
     const sink = (u) => {
@@ -241,12 +265,24 @@ export class AcpHost {
       else if (u.sessionUpdate === 'tool_call') tools++
       if (onUpdate) { try { onUpdate(u) } catch {} }
     }
+    const dropSink = () => { if (this.inflight.get(sessionId) === sink) this.inflight.delete(sessionId) }
     this.inflight.set(sessionId, sink)
+    const late = o.onLate
+      ? (result, error) => {
+        dropSink()
+        try { o.onLate({ text: out.trim(), stopReason: result?.stopReason ?? null, toolCalls: tools, error: error || null }) }
+        catch (e) { this.log('acp-late-callback-failed', { error: String(e?.message ?? e) }) }
+      }
+      : null
     try {
-      const r = await this._request('session/prompt', { sessionId, prompt: [{ type: 'text', text: String(text) }] })
+      const r = await this._request('session/prompt', { sessionId, prompt: [{ type: 'text', text: String(text) }] },
+        o.timeoutMs, { keepAliveOnTimeout: !!o.keepAliveOnTimeout, onLate: late })
+      dropSink()
       return { text: out.trim(), stopReason: r?.stopReason ?? null, toolCalls: tools }
-    } finally {
-      this.inflight.delete(sessionId)
+    } catch (e) {
+      // 超时且已保留：**留着 sink**——这一轮还在跑，正文要靠后续 session/update 累积
+      if (!(o.keepAliveOnTimeout && isAcpTimeout(e))) dropSink()
+      throw e
     }
   }
 
@@ -272,3 +308,13 @@ export class AcpHost {
     this.ready = null
   }
 }
+
+/**
+ * 这个错误是不是"本轮超时"（而不是"通道不可用"）？
+ * 超时意味着 **ACP 那一轮还在跑**，调用方不该把它当失败去走兜底（会重复执行同一件事）。
+ */
+export function isAcpTimeout(err) {
+  if (!err) return false
+  if (err.code === 'ACP_TIMEOUT') return true
+  return /ACP 超时|ACP_TIMEOUT/.test(String(err.message || ''))
+}

package/lib/kernel/bridge.mjs

@@ -13,7 +13,7 @@
  */
 import { readFileSync, writeFileSync, appendFileSync, existsSync, mkdirSync, renameSync, statSync, readdirSync, copyFileSync, rmSync } from 'node:fs'
 import { spawn, execFileSync } from 'node:child_process'
-import { AcpHost } from './acp.mjs'
+import { AcpHost, isAcpTimeout } from './acp.mjs'
 import { ensureAcpPresetSupport, acpPresetSupported, acpPackageFile, acpPackageCandidates } from './acp-preset-shim.mjs'
 import { parseApprovalReply, pickOptionByDecision, formatApprovalCard, decisionAck, DECISION_ALLOW, DECISION_REJECT } from './approval-reply.mjs'
 import { parsePushEntry, pickRecipient } from './outbox.mjs'
@@ -183,7 +183,7 @@ function ensureDshBin() {
 
 const API_BASE = process.env.ILINK_BASE || 'https://ilinkai.weixin.qq.com'
 const PROTOCOL_VERSION = '2.4.6'
-const BRIDGE_VERSION = '0.5.0'
+const BRIDGE_VERSION = '0.5.1'
 const BOOT_ID = process.pid
 const MESSAGE_TYPE_BOT = 2
 const ITEM_TYPE_TEXT = 1
@@ -236,6 +236,10 @@ const PERM_MODES = ['ask', 'allow', 'reject']
 function normPermMode(v, d = 'ask') { const s = String(v ?? '').toLowerCase(); return PERM_MODES.includes(s) ? s : d }
 let ACP_PERM = normPermMode(ACP_CFG.permPolicy, 'ask')
 const APPROVAL_TIMEOUT_MS = Number(process.env.WXBRIDGE_APPROVAL_TIMEOUT_MS || ACP_CFG.approvalTimeoutMs || 120000)
+// 一轮 ACP 提示词的等待上限（与"任务超时"分开）：
+//   任务超时（TASK_TIMEOUT_MS，5 分钟）用在**兜底路径**上——那里超时是真杀子进程；
+//   而 ACP 超时只意味着"我们不再等"，那一轮**还在跑**，所以给足 15 分钟，且超时不回落（见 runViaAcp）。
+const PROMPT_TIMEOUT_MS = Number(process.env.BRIDGE_PROMPT_TIMEOUT_MS || ACP_CFG.promptTimeoutMs || 900000)
 // 手机通道的权限预设（ACP 叠层里 permission.defaultPreset）。默认 workspace-write：
 // 越界（工作区之外）的写与提权会变成审批卡推到微信，回「批准 / 拒绝」即可 —— 手机可应答后，
 // 不必再用"最宽权限"绕开审批。要回到旧行为：config.json 的 acp.permPreset 设 danger-full-access；
@@ -822,7 +826,7 @@ function presetKey(peer) {
   if (peer.acpMode === 'chat') return 'chat'
   return ACP_DEFAULT_PRESET
 }
-function overlayFor(key) {
+function overlayFor(key) {
   if (key === 'chat') return ensureChatOverlay()
   if (!overlayCache.has(key)) overlayCache.set(key, ensurePresetOverlay(key) || '')
   return overlayCache.get(key) || ACP_PATCH
@@ -881,7 +885,7 @@ export function buildChatOverlayText(text, permPreset, hintLines) {
  * 必须重启桥才会重写，否则老生成文件会把新预设**静默顶掉**（2026-09-24 实测踩过）。
  * 这里**每次都重写**（一次几毫秒）：宁可多写一次，也不要让"磁盘上的旧生成物"成为隐形真源。
  */
-function ensureChatOverlay() {
+function ensureChatOverlay() {
   const src = join(HERE, 'acp-overlay-chat.yml')
   let text = ''
   try { text = readFileSync(src, 'utf8') } catch { return src }
@@ -994,7 +998,7 @@ function getAcpHost(key) {
   if (!acpHosts.has(k)) acpHosts.set(k, new AcpHost({
     bin: resolveAcpBin(), node: NODE_BIN, home: ACP_HOME, cwd: CWD, patch: overlayFor(k),
     permPolicy: ACP_PERM, permFallback: 'reject', onPermission: (req) => handlePermissionRequest(req),
-    promptTimeoutMs: TASK_TIMEOUT_MS, log,
+    promptTimeoutMs: PROMPT_TIMEOUT_MS, log,
   }))
   // 策略是热切换的：已有宿主每次取用都同步一次（改 /审批 后不必重启桥）
   const host = acpHosts.get(k)
@@ -1356,12 +1360,14 @@ async function applyPeerConfig(peer, sessionId) {
 
 /**
  * 一轮任务走 ACP：把用户原话交给 DSH 会话（**不拼接历史**），上下文由 DSH 维护。
- * 失败返回 null，由调用方回落宿主/headless 路径。
+ * 返回 null 才意味着"ACP 不可用"，由调用方回落宿主/headless 路径；
+ * **超时不算不可用**（那一轮还在跑）→ 返回 `{pending:true}` 并等 onLate 补发结果。
  */
-async function runViaAcp(text, peer, taskId) {
+async function runViaAcp(text, peer, taskId, peerKey) {
   if (!ACP_ENABLED) return null
+  let sessionId = ''
   try {
-    const sessionId = await ensurePeerSession(peer)
+    sessionId = await ensurePeerSession(peer)
     if (!sessionId) return null
     const rec = state.tasks[taskId]
     if (rec) { rec.session = sessionId; rec.mode = 'acp' }
@@ -1371,17 +1377,47 @@ async function runViaAcp(text, peer, taskId) {
         const rec = state.tasks[taskId]
         if (rec) { rec.lastTool = String(u.title || 'tool'); rec.lastToolAt = Date.now() }   // /task 能看到"最近在干什么"
       }
+    }, {
+      timeoutMs: PROMPT_TIMEOUT_MS,
+      keepAliveOnTimeout: true,
+      onLate: (late) => deliverLateAcpResult(peer, peerKey, taskId, late),
     })
     log('task-done-acp', { id: taskId, session: sessionId, outLen: (r.text || '').length, tools: r.toolCalls, stop: r.stopReason })
     const notice = peer.acpNotice || ''
     if (notice) peer.acpNotice = ''
     return { ok: true, text: r.text, sessionId, viaAcp: true, stopReason: r.stopReason, notice }
   } catch (e) {
+    if (isAcpTimeout(e)) {
+      // **超时 ≠ 失败**：这一轮还在 ACP 侧跑，服务端最后一定会回帧（onLate 负责补发）。
+      // 这里绝不能返回 null —— 那会让 processTask 去走兜底路径，把同一件事**再干一遍**（而且是拼接提示词的旧形态）。
+      log('task-acp-still-running', { id: taskId, session: sessionId, waitedMs: PROMPT_TIMEOUT_MS, error: String(e?.message ?? e) })
+      return { ok: false, pending: true, sessionId, error: '这一轮超过 ' + Math.round(PROMPT_TIMEOUT_MS / 60000) + ' 分钟仍在跑' }
+    }
+    // 真·通道不可用：回落之前先取消这一轮，避免"兜底路径与 ACP 同时跑"重复执行
+    if (sessionId) {
+      try { await getAcpHost(peerMode(peer)).cancel(sessionId); log('acp-fallback-cancel', { id: taskId, session: sessionId }) } catch {}
+    }
     log('task-acp-failed', { id: taskId, error: String(e?.message ?? e) })
     return null
   }
 }
 
+/** 迟到的那一轮跑完了：把结果补发给用户（手机侧不必重发原话）。 */
+function deliverLateAcpResult(peer, peerKey, taskId, late) {
+  const t = state.tasks[taskId] || {}
+  const audited = auditOutput('⏳（这一轮跑完了）' + NL + (late.error ? '执行失败：' + late.error.message : late.text))
+  if (audited.hits.length) log('output-audit', { id: taskId, hits: audited.hits })
+  t.status = late.error ? 'failed' : 'done'
+  t.endedAt = new Date().toISOString()
+  t.lateDelivered = true
+  peer.history = ((peer.history || []).concat([{ u: t.u || '', a: late.text || String(late.error?.message || '失败'), ok: !late.error, at: t.endedAt, late: true }])).slice(-50)
+  log('task-late-done', { id: taskId, ok: !late.error, outLen: (late.text || '').length, tools: late.toolCalls })
+  saveState(state).catch(() => {})
+  const key = peerKey || Object.keys(state.peers).find((k) => state.peers[k] === peer) || ''
+  if (!key) return
+  reply(wechatToken, key, audited.text, peer.lastContextToken).catch((e) => log('late-reply-failed', { error: String(e?.message ?? e) }))
+}
+
 function killTree(pid) { try { spawn('taskkill', ['/PID', String(pid), '/T', '/F'], { windowsHide: true, stdio: 'ignore' }) } catch {} }
 function runDsh(task, cwd, taskId) {
   return new Promise((resolve) => {
@@ -1471,7 +1507,7 @@ const runningCount = () => Object.values(state.tasks).filter((t) => t.status ===
 async function processTask(token, peerKey, from, taskId, text, contextToken) {
   const peer = state.peers[peerKey]
   const t = state.tasks[taskId]
-  t.status = 'running'; t.startedAt = new Date().toISOString(); activeTasks = runningCount()
+  t.status = 'running'; t.u = text; t.startedAt = new Date().toISOString(); activeTasks = runningCount()
   await saveState(state)
   const history = (peer.history || []).filter((h) => h.ok !== false).slice(-6)
   const prompt = PROMPT_PREFIX + sanitize(history.length
@@ -1479,16 +1515,28 @@ async function processTask(token, peerKey, from, taskId, text, contextToken) {
     : text)
   let r = null
   // ① 首选 ACP：DSH 原生会话 + 原生上下文（桥不拼接历史）
-  r = await runViaAcp(text, peer, taskId)
+  r = await runViaAcp(text, peer, taskId, peerKey)
+  // ①-b 超时 ≠ 失败：这一轮还在 ACP 侧跑，结果由 onLate 补发；**不走兜底**（否则同一件事被重跑一遍）
+  if (r && r.pending) {
+    t.pendingSince = new Date().toISOString(); activeTasks = runningCount()
+    await saveState(state)
+    return reply(token, from, '⏳ 这一轮已跑 ' + Math.round(PROMPT_TIMEOUT_MS / 60000) + ' 分钟仍在继续（会话 '
+      + String(r.sessionId || '').slice(0, 12) + '…）。' + NL
+      + '我**不会重复执行**它；跑完直接把结果发到这里（/task 看进度，/cancel 可中止）。', contextToken)
+  }
+  let viaFallback = ''
   // ② 其次宿主内执行（历史行为；不产生 turn 时返回空 → 继续回落）
-  if (!r) { const viaHost = await runViaHost(text, peer, taskId); if (viaHost && String(viaHost.text || '').trim()) r = viaHost }
+  if (!r) { const viaHost = await runViaHost(text, peer, taskId); if (viaHost && String(viaHost.text || '').trim()) { r = viaHost; viaFallback = 'host' } }
   // ③ 最后回落：一次性 headless（沿用拼接提示词，仅作兜底）
-  if (!r) r = await runDsh(prompt, peer.cwd, taskId)
+  if (!r) { r = await runDsh(prompt, peer.cwd, taskId); viaFallback = 'headless' }
   t.status = r.timedOut ? 'timeout' : (r.ok ? 'done' : 'failed')
   t.endedAt = new Date().toISOString(); t.log = r.log; activeTasks = runningCount()
   peer.history = ((peer.history || []).concat([{ u: text, a: r.ok ? r.text : (r.error || '失败'), ok: !!r.ok, at: t.endedAt }])).slice(-50)
-  log('task-done', { id: taskId, ok: r.ok, timeout: !!r.timedOut, outLen: r.text?.length ?? 0 })
-  const audited = auditOutput((r.notice ? r.notice + NL : '') + (r.ok ? r.text : '执行失败：' + (r.error ?? '未知错误')))
+  log('task-done', { id: taskId, ok: r.ok, timeout: !!r.timedOut, viaFallback: viaFallback || 'acp', outLen: r.text?.length ?? 0 })
+  const fallbackNotice = viaFallback
+    ? '⚠️ 本轮 ACP 路径不可用，走了兜底（' + viaFallback + '）；兜底路径会把历史拼接进提示词（不是上下文回退）。' + NL
+    : ''
+  const audited = auditOutput((r.notice ? r.notice + NL : '') + fallbackNotice + (r.ok ? r.text : '执行失败：' + (r.error ?? '未知错误')))
   if (audited.hits.length) log('output-audit', { id: taskId, hits: audited.hits })
   await reply(token, from, audited.text, contextToken)
   await saveState(state)
@@ -2215,13 +2263,60 @@ async function main() {
       hostHome: HOST_HOME || '(未指定)', acpHome: ACP_HOME, childHome: CHILD_HOME,
       vault: VAULT_PATH || '(未指定)', contract: CONTRACT_FILE,
       acp: { enabled: ACP_ENABLED, preset: ACP_CFG.preset || '(跟随宿主默认)', permPolicy: ACP_PERM,
-             permPreset: ACP_PERM_PRESET, approvalTimeoutMs: APPROVAL_TIMEOUT_MS, patchAcp: ACP_CFG.patchAcp !== false },
+             permPreset: ACP_PERM_PRESET, approvalTimeoutMs: APPROVAL_TIMEOUT_MS, promptTimeoutMs: PROMPT_TIMEOUT_MS,
+             taskTimeoutMs: TASK_TIMEOUT_MS, patchAcp: ACP_CFG.patchAcp !== false },
       overlays: { presetOverlay: overlayFor(ACP_DEFAULT_PRESET), chatOverlay: ensureChatOverlay() },
       push: { cli: PUSH_CLI, outbox: OUTBOX_DIR },
     }, null, 1))
     process.exit(0)
   }
 
+  if (args.includes('--selftest-acp-timeout')) {
+    // 离线自测：**超时 ≠ 失败** 这条规则的三段行为（不连模型、不起子进程）
+    const rows = []
+    const mk = (timeoutMs) => {
+      const h = new AcpHost({ promptTimeoutMs: timeoutMs, permPolicy: 'ask', log: () => {} })
+      h.ready = Promise.resolve({})                       // 跳过真实握手
+      h.child = { stdin: { write: () => {} }, exitCode: null }
+      return h
+    }
+    const frame = (id, text, stop) => JSON.stringify({ jsonrpc: '2.0', id, result: { stopReason: stop, _text: text } }) + NL
+    // ① 分类：超时 vs 其它
+    const timeoutErr = Object.assign(new Error('ACP 超时：session/prompt'), { code: 'ACP_TIMEOUT' })
+    rows.push({ name: 'isAcpTimeout(tagged)', ok: isAcpTimeout(timeoutErr) === true })
+    rows.push({ name: 'isAcpTimeout(plain message)', ok: isAcpTimeout(new Error('ACP 超时：session/prompt')) === true })
+    rows.push({ name: 'isAcpTimeout(其它错误)', ok: isAcpTimeout(new Error('ACP 进程已退出(code=1)')) === false })
+    // ② keepAlive：超时后迟到帧交给 onLate（正文靠 session/update 累积）
+    {
+      const h = mk(120)
+      let late = null
+      const id = h.nextId
+      let code = ''
+      try { await h.ask('s-late', 'hi', null, { timeoutMs: 120, keepAliveOnTimeout: true, onLate: (r) => { late = r } }) } catch (e) { code = e.code || '' }
+      const keptAfterTimeout = h.pending.has(id)
+      h._onData(Buffer.from(JSON.stringify({ jsonrpc: '2.0', method: 'session/update', params: { sessionId: 's-late', update: { sessionUpdate: 'agent_message_chunk', content: { type: 'text', text: '迟到正文' } } } }) + NL))
+      h._onData(Buffer.from(frame(id, '', 'end_turn')))
+      rows.push({ name: '超时错误带 code=ACP_TIMEOUT', ok: code === 'ACP_TIMEOUT' })
+      rows.push({ name: '超时后 pending 条目被保留', ok: keptAfterTimeout === true })
+      rows.push({ name: '迟到帧触发 onLate 且正文完整', ok: !!late && late.text === '迟到正文' && late.stopReason === 'end_turn' })
+      rows.push({ name: '迟到后 pending 清空 + sink 摘除', ok: !h.pending.has(id) && !h.inflight.has('s-late') })
+    }
+    // ③ 对照：不 keepAlive 时超时即丢弃，迟到帧不会触发任何回调（旧行为）
+    {
+      const h = mk(120)
+      let late = null
+      const id = h.nextId
+      let code = ''
+      try { await h.ask('s-drop', 'hi', null, { timeoutMs: 120, onLate: (r) => { late = r } }) } catch (e) { code = e.code || '' }
+      h._onData(Buffer.from(frame(id, '', 'end_turn')))
+      rows.push({ name: '未开 keepAlive：超时即丢弃且无回调', ok: code === 'ACP_TIMEOUT' && late === null && !h.pending.has(id) && !h.inflight.has('s-drop') })
+    }
+    console.log('[selftest-acp-timeout] ' + JSON.stringify({
+      rows, failed: rows.filter((r) => !r.ok).map((r) => r.name),
+      promptTimeoutMs: PROMPT_TIMEOUT_MS, taskTimeoutMs: TASK_TIMEOUT_MS,
+    }, null, 1))
+    process.exit(rows.every((r) => r.ok) ? 0 : 1)
+  }
   acquireLock()
   // 上次进程遗留的运行态任务：本轮一启动就标成 interrupted。
   // 否则 runningCount() 永远虚高，`while (runningCount() >= MAX_CONCURRENT_TASKS)` 会把新任务永久挡住。

package/package.json

@@ -1,52 +1,52 @@
-{
-  "name": "@zmainer/dsh-wx-bridge",
-  "version": "1.1.6",
-  "type": "module",
-  "main": "./lib/index.js",
-  "dsh": {
-    "bundle": {
-      "patch": "./cordis.patch.yml"
-    },
-    "client": {
-      "platform": "web"
-    }
-  },
-  "exports": {
-    ".": "./lib/index.js",
-    "./client": "./lib/client.js",
-    "./package.json": "./package.json"
-  },
-  "scripts": {
-    "build": "node scripts/build-client.mjs"
-  },
-  "files": [
-    "lib",
-    "src",
-    "scripts",
-    "cordis.patch.yml",
-    "README.md",
-    "package.json"
-  ],
-  "description": "DSH plugin: connect WeChat (official iLink/ClawBot) to DeepSeek Harness — settings page with live bridge status, QR device pairing, in-WeChat tool approvals, proactive push, and the bundled bridge + keeper kernel.",
-  "license": "MIT",
-  "keywords": [
-    "deepseek-harness",
-    "dsh-plugin",
-    "wechat",
-    "weixin",
-    "ilink",
-    "clawbot"
-  ],
-  "repository": {
-    "type": "git",
-    "url": "git+https://github.com/zhy5/dsh-wx-bridge.git"
-  },
-  "homepage": "https://github.com/zhy5/dsh-wx-bridge#readme",
-  "bugs": {
-    "url": "https://github.com/zhy5/dsh-wx-bridge/issues"
-  },
-  "author": "zmainer",
-  "engines": {
-    "node": ">=22.19.0"
-  }
-}
+{
+  "name": "@zmainer/dsh-wx-bridge",
+  "version": "1.1.7",
+  "type": "module",
+  "main": "./lib/index.js",
+  "dsh": {
+    "bundle": {
+      "patch": "./cordis.patch.yml"
+    },
+    "client": {
+      "platform": "web"
+    }
+  },
+  "exports": {
+    ".": "./lib/index.js",
+    "./client": "./lib/client.js",
+    "./package.json": "./package.json"
+  },
+  "scripts": {
+    "build": "node scripts/build-client.mjs"
+  },
+  "files": [
+    "lib",
+    "src",
+    "scripts",
+    "cordis.patch.yml",
+    "README.md",
+    "package.json"
+  ],
+  "description": "DSH plugin: connect WeChat (official iLink/ClawBot) to DeepSeek Harness — settings page with live bridge status, QR device pairing, in-WeChat tool approvals, proactive push, and the bundled bridge + keeper kernel.",
+  "license": "MIT",
+  "keywords": [
+    "deepseek-harness",
+    "dsh-plugin",
+    "wechat",
+    "weixin",
+    "ilink",
+    "clawbot"
+  ],
+  "repository": {
+    "type": "git",
+    "url": "git+https://github.com/zhy5/dsh-wx-bridge.git"
+  },
+  "homepage": "https://github.com/zhy5/dsh-wx-bridge#readme",
+  "bugs": {
+    "url": "https://github.com/zhy5/dsh-wx-bridge/issues"
+  },
+  "author": "zmainer",
+  "engines": {
+    "node": ">=22.19.0"
+  }
+}