@zmainer/dsh-wx-bridge 1.0.9 → 1.0.11

package/README.md

@@ -147,6 +147,20 @@ dsh plugin --profile <profile> add @zmainer/dsh-wx-bridge
 
 ## 最近变更
 
+- **1.0.11**：三条体验/正确性修复（均来自用户反馈）——
+  ① **非文本消息不再静默丢弃**：图片/语音/表情/文件此前是 `if (!from || !text) return` 直接丢弃，
+  连回执都没有（用户只看到"发了没反应"）；现在会回一句「只认文字消息」并把条目类型记进日志
+  （同一个人 60 秒内只提醒一次，避免连发图片被刷屏）；
+  ② **会话自动归组修好**：宿主半原来在开机补登记时直接读 `ctx.workspaceRegistry`，而没声明 inject
+  → cordis 在**属性访问那一刻**就抛 `cannot get property "workspaceRegistry" without inject`，
+  "未注入就跳过"的兜底分支根本走不到 ⇒ 手机会话永远不进桌面 GUI 的工作区列表。
+  现在改用**注入进来的 webCtx**（并保留周期兜底扫描，10 分钟一次），失败只记日志、不影响其它功能；
+  ③ **宿主端口探测修正**：`dsh-host-webserver` 暴露的是**方法** `webServer.port()`，不是属性——
+  之前写出的 `host-address.json` 里 `port: 0`，桥只能去扒 `desktop.log` 猜端口（日志一换就瞎）。
+  另外桥**新建 ACP 会话后会主动上报宿主**（`POST /wxbridge/attach`），手机对话即刻出现在工作区里。
+- **1.0.10**：面板「运行时入口」一行区分「字段缺失」与「解析失败」——
+  升级了包但还没重启宿主时，宿主半仍是旧版、不上报该字段，此前会误显示成「未解析（手机对话会失败）」；
+  现在显示「—（宿主半未上报；重启宿主后显示）」。纯客户端修正。
 - **1.0.9**：修「手机发消息永远没答复 / 5 分钟后才报 ACP 超时」——
   根因是**运行时入口解析不到**（桌面端装在非标准目录时三级探测全部落空），ACP 子进程拿到空路径，
   而 `node "" --profile acp` 会进入「读 stdin」模式：**不回应协议、也不退出**，只能等满超时。

package/lib/client.js

@@ -269,9 +269,12 @@ window.__ModuleLoader__.load({
       const rows = [
         ['桥状态', state + '（' + (b.phase || 'n/a') + '）'],
         ['进程', b.pid ? ('pid ' + b.pid + '｜心跳 ' + (b.ageSec === null ? 'n/a' : b.ageSec + 's 前')) : '无'],
-        ['运行时入口', b.runtimeBin
-          ? (b.runtimeBin + (b.runtimeBinOk ? '' : '（⚠️ 文件不存在）'))
-          : '⚠️ 未解析（手机对话会失败，请设置 dshBin）'],
+        // 字段缺失 ≠ 解析失败：升级了包但还没重启宿主时，宿主半仍是旧版、不上报这个字段。
+        ['运行时入口', b.runtimeBin === undefined
+          ? '—（宿主半未上报；重启宿主后显示）'
+          : (b.runtimeBin
+            ? (b.runtimeBin + (b.runtimeBinOk ? '' : '（⚠️ 文件不存在）'))
+            : '⚠️ 未解析（手机对话会失败，请设置 dshBin）')],
         ['数据目录', b.dataDir || 'n/a'],
         ['默认工作区', b.cwd || 'n/a'],
       ]

package/lib/index.js

@@ -85,6 +85,7 @@ export function apply(ctx, config) {
   let timer = null
   let pairing = null
   let runtimeInfo = { bin: '', ok: false, source: '' }
+  let injectedWebCtx = null
 
   /** 按钮操作日志（环形缓冲）：面板要能看到"我点了什么、结果如何"。 */
   const actions = []
@@ -98,6 +99,83 @@ export function apply(ctx, config) {
     try { return JSON.parse(readFileSync(f, 'utf8')) || {} } catch { return {} }
   }
 
+  /**
+   * 从宿主的 webServer 服务里取本进程真正监听的端口。
+   * `dsh-host-webserver` 暴露的是**方法** `port()` / `host()`（config.port=0 时 port() 返回系统
+   * 分配的真值），不是属性——原来只试属性/底层 server，永远拿不到。
+   */
+  const portFromWebCtx = (webCtx) => {
+    let port = 0
+    try {
+      const ws = (webCtx && webCtx.webServer) || {}
+      try { if (typeof ws.port === 'function') port = Number(ws.port() || 0) } catch {}
+      if (!port) {
+        for (const srv of [ws.server, ws.httpServer, ws.instance, ws.listener, ws.app]) {
+          try {
+            const a = srv && typeof srv.address === 'function' ? srv.address() : null
+            if (a && typeof a === 'object' && a.port) { port = Number(a.port); break }
+          } catch {}
+        }
+      }
+      if (!port) for (const k of ['port', 'portNumber', 'listenPort']) if (ws[k]) { port = Number(ws[k]); break }
+    } catch (e) { ctx.logger?.warn?.('wxbridge: 读宿主端口失败 ' + String(e?.message ?? e)) }
+    if (!port) port = Number(process.env.WXBRIDGE_HOST_PORT || 0)
+    return port
+  }
+  /** 数据目录（boot 完成后以 keeper 为准）。 */
+  const hostDataDir = () => (keeper && keeper.dataDir) || cfg.dataDir || readConfigFile().dataDir || ''
+  /**
+   * 写 host-address.json。**不许用较差的值覆盖本进程已知的好值**：
+   * 注入回调与 boot 有先后竞态，若晚到的 0 覆盖了真实端口，桥就只能回去扒日志（脆弱）。
+   */
+  const writeHostAddress = (dataDir, port) => {
+    if (!dataDir) return
+    const f = join(dataDir, 'host-address.json')
+    try {
+      if (!port) {
+        try { const cur = JSON.parse(readFileSync(f, 'utf8')); if (cur && cur.port && cur.pid === process.pid) return } catch {}
+      }
+      writeFileSync(f, JSON.stringify({ pid: process.pid, port, at: new Date().toISOString() }, null, 2))
+      if (port) ctx.logger?.info?.('wxbridge: 宿主地址已写出（port=' + port + '）')
+    } catch (e) { ctx.logger?.warn?.('wxbridge: 写 host-address.json 失败 ' + String(e?.message ?? e)) }
+  }
+
+  /**
+   * 把「外部（桥/ACP/headless）写出来的会话」补登记进宿主工作区（按 cwd 匹配工作区 path）。
+   * **必须用注入进来的 webCtx**：直接读 `ctx.workspaceRegistry` 会在属性访问那一刻抛
+   * `cannot get property "workspaceRegistry" without inject`——连"未注入就跳过"的兜底分支都走不到
+   *（2026-09-22 实况：宿主每次开机都报同一条 warn，手机会话永远不进 GUI）。
+   * 失败一律降级为一条日志，绝不影响插件其它功能。
+   */
+  const autoGroupSessions = async (webCtx, reason) => {
+    try {
+      const reg = webCtx && webCtx.workspaceRegistry
+      if (!reg) { ctx.logger?.info?.('wxbridge: 跳过自动归组（宿主未提供 workspaceRegistry）'); return { skipped: true } }
+      const raw = await reg.list()
+      const workspaces = Array.isArray(raw) ? raw : ((raw && raw.items) || [])
+      const norm = (v) => String(v || '').replace(/[\/]+$/, '').toLowerCase()
+      const known = new Set()
+      for (const w of workspaces) for (const id of (w.sessionIds || [])) known.add(id)
+      const persistence = webCtx.sessionPersistence
+      if (!persistence || typeof persistence.list !== 'function') return { skipped: true, note: '宿主未提供 sessionPersistence' }
+      const records = await persistence.list()
+      let n = 0
+      for (const rec of (records || [])) {
+        const header = (rec && (rec.header || rec)) || {}
+        const id = String(header.id || '')
+        if (!id.startsWith('session-') || known.has(id)) continue
+        const ws = workspaces.find((w) => norm(w.path) === norm(header.cwd))
+        if (!ws) continue
+        try { await ws.attachSession(id); known.add(id); n++ } catch {}
+      }
+      if (n) ctx.logger?.info?.('wxbridge: 自动归组 ' + n + ' 条会话到对应工作区' + (reason ? '（' + reason + '）' : ''))
+      return { grouped: n, scanned: (records || []).length, workspaces: workspaces.length }
+    } catch (e) {
+      ctx.logger?.warn?.('wxbridge: 自动归组失败（已降级，不影响其它功能） ' + String(e?.message ?? e))
+      return { error: String(e?.message ?? e) }
+    }
+  }
+
   /**
    * 宿主自己的运行时入口：**宿主进程就是 `<runtime>/lib/bin.js`**（argv[1]），
    * 这是唯一无需猜测的权威答案（2026-09-22：其他用户装在非标准目录，三级探测全落空
@@ -169,34 +247,6 @@ export function apply(ctx, config) {
     if (ownership !== 'host' && cfg.autoStart && process.env.WXBRIDGE_NO_AUTOSTART !== '1' && !st.pidOk) {
       try { ctx.logger?.info?.('wxbridge: spawned bridge pid=' + keeper.startBridge()) } catch (e) { ctx.logger?.warn?.('wxbridge: spawn failed ' + String(e?.message ?? e)) }
     }
-    // 开机自动归组：把外部（桥/headless）写出的、尚未登记到工作区的会话补登记
-    setTimeout(async () => {
-      try {
-        const fsMod = await import('node:fs')
-        const hostHome = process.env.DSH_HOME || ''
-        if (!hostHome) return
-        // 复用路由里的 attachOne/scanAndAttach 需要 webCtx；这里用等价的独立实现
-        const reg = ctx.workspaceRegistry
-        if (!reg) { ctx.logger?.info?.('wxbridge: 跳过自动归组（workspaceRegistry 未注入）'); return }
-        const workspaces = await reg.list()
-        const norm = (v) => String(v || '').replace(/[\/]+$/, '').toLowerCase()
-        const known = new Set()
-        for (const w of workspaces) for (const id of (w.sessionIds || [])) known.add(id)
-        const persistence = ctx.sessionPersistence
-        if (!persistence || typeof persistence.list !== 'function') return
-        const records = await persistence.list()
-        let n = 0
-        for (const rec of (records || [])) {
-          const header = (rec && (rec.header || rec)) || {}
-          const id = String(header.id || '')
-          if (!id.startsWith('session-') || known.has(id)) continue
-          const ws = workspaces.find((w) => norm(w.path) === norm(header.cwd))
-          if (!ws) continue
-          try { await ws.attachSession(id); known.add(id); n++ } catch {}
-        }
-        if (n) ctx.logger?.info?.('wxbridge: 自动归组 ' + n + ' 条会话到对应工作区')
-      } catch (e) { ctx.logger?.warn?.('wxbridge: 自动归组失败 ' + String(e?.message ?? e)) }
-    }, 15000)
     if (cfg.autoSupervise && process.env.WXBRIDGE_NO_SUPERVISE !== '1') {
       timer = setInterval(() => { try { keeper.tick() } catch (e) { ctx.logger?.warn?.('wxbridge tick: ' + String(e?.message ?? e)) } }, cfg.intervalMs || file.intervalMs || 300000)
       if (timer.unref) timer.unref()
@@ -209,27 +259,12 @@ export function apply(ctx, config) {
       log: (m) => ctx.logger?.info?.('wxbridge: ' + m),
     })
     pushAction({ action: 'host-boot', ok: true, detail: 'dataDir=' + st.dataDir + ' pidOk=' + st.pidOk + ' qr=' + (loadQrRenderer() ? 'qrcode' : 'text-only') })
-    // 把宿主自身的 HTTP 地址写给桥：桥据此把新生成的会话上报回来登记进工作区
-    try {
-      let port = 0
-      try {
-        // 依次尝试：webServer 的底层 server → 常见宿主属性 → 配置/环境变量
-        const ws = webCtx.webServer || {}
-        const cands = [ws.server, ws.httpServer, ws.instance, ws.listener, ws.app]
-        for (const srv of cands) {
-          if (srv && typeof srv.address === 'function') {
-            const addr = srv.address()
-            if (addr && typeof addr === 'object' && addr.port) { port = addr.port; break }
-          }
-        }
-        if (!port) {
-          for (const k of ['port', 'portNumber', 'listenPort']) if (ws[k]) { port = Number(ws[k]); break }
-        }
-        if (!port) port = Number(process.env.WXBRIDGE_HOST_PORT || 0)
-      } catch {}
-      const addrFile = join(st.dataDir, 'host-address.json')
-      writeFileSync(addrFile, JSON.stringify({ pid: process.pid, port, at: new Date().toISOString() }, null, 2))
-    } catch {}
+    // 把宿主自身的 HTTP 地址写给桥：桥据此把新生成的会话上报回来登记进工作区。
+    // 注意：此刻注入回调可能还没跑（webCtx 是回调参数、boot 里看不见它——原来这里直接写
+    // `webCtx.webServer` 是自由变量 → ReferenceError 被空 catch 吞掉 → port 恒为 0）。
+    // 所以先用"当前已有的信息"写一份，真正的端口由注入回调重写（见 writeHostAddress 的防覆盖规则）。
+    writeHostAddress(st.dataDir, portFromWebCtx(injectedWebCtx))
+    setTimeout(() => { try { writeHostAddress(hostDataDir(), portFromWebCtx(injectedWebCtx)) } catch {} }, 3000)
     ctx.logger?.info?.('wxbridge: pairing ready (qr renderer=' + (loadQrRenderer() ? 'qrcode' : 'text-only') + ')')
   }
 
@@ -243,6 +278,15 @@ export function apply(ctx, config) {
   })
 
   ctx.inject?.(['webServer', 'workspaceRegistry', 'sessions', 'agents', 'sessionPersistence', 'agentDefaultModel', 'sessionController'], (webCtx) => {
+    // 只有在这里 webCtx（含 webServer）才真实存在：把端口写进 host-address.json 供桥发现宿主。
+    injectedWebCtx = webCtx
+    setTimeout(() => { try { writeHostAddress(hostDataDir(), portFromWebCtx(webCtx)) } catch {} }, 1500)
+    // 开机补登记（等宿主把工作区/会话仓库读起来）+ 周期性兜底：
+    // 桥在新建 ACP 会话时会主动 /attach，这里负责"宿主不在时写下的会话"和其它来源的会话。
+    setTimeout(() => { void autoGroupSessions(webCtx, 'boot') }, 12000)
+    const groupTimer = setInterval(() => { void autoGroupSessions(webCtx, 'periodic') }, 10 * 60 * 1000)
+    if (groupTimer.unref) groupTimer.unref()
+    ctx.on?.('dispose', () => clearInterval(groupTimer))
     const send = (res, o, code = 200) => { res.writeHead(code, { 'content-type': 'application/json', 'cache-control': 'no-store' }); res.end(JSON.stringify(o)) }
     let lastError = null
 

package/lib/kernel/bridge.mjs

@@ -481,6 +481,23 @@ const sendText = (token, to, text, contextToken) => ilink('ilink/bot/sendmessage
 })
 
 function inboundText(msg) { for (const it of msg?.item_list ?? []) if (it?.type === ITEM_TYPE_TEXT && typeof it.text_item?.text === 'string') return it.text_item.text; return '' }
+/** 入站消息里出现过的条目类型（排障 + 「只认文字」提示用）。 */
+function inboundItemTypes(msg) {
+  const out = new Set()
+  for (const it of msg?.item_list ?? []) if (it && it.type !== undefined) out.add(Number(it.type))
+  return [...out]
+}
+/** 「只认文字」的提示：同一个人 60 秒内只提醒一次，避免连发图片被刷屏。 */
+const NOTEXT_NOTICE_AT = new Map()
+const NOTEXT_NOTICE = '只认文字消息：图片 / 语音 / 表情 / 文件我都收不到（微信侧也不会自动转文字）。'
+  + NL + '把内容打成文字发我就好。'
+/** 该不该给他回「只认文字」：同一个人 60 秒内只回一次。返回要发的文本，'' = 这次不回。 */
+function nonTextNoticeFor(from, now = Date.now()) {
+  const last = NOTEXT_NOTICE_AT.get(from) || 0
+  if (now - last <= 60000) return ''
+  NOTEXT_NOTICE_AT.set(from, now)
+  return NOTEXT_NOTICE
+}
 const msgKey = (m) => 'id:' + (m?.msg_id ?? m?.message_id ?? m?.client_id ?? JSON.stringify(m).slice(0, 80))
 
 const SECRET_PATTERNS = [/sk-[A-Za-z0-9]{16,}/g, /ghp_[A-Za-z0-9]{20,}/g, /AKIA[0-9A-Z]{16}/g, /-----BEGIN [A-Z ]*PRIVATE KEY-----[\s\S]{0,4000}?-----END [A-Z ]*PRIVATE KEY-----/g]
@@ -780,6 +797,8 @@ async function ensurePeerSession(peer) {
   const r = await host.newSession(cwd)
   slot.id = r?.sessionId || ''
   slot.cwd = cwd
+  // 卖点落地：桥写出的会话要立刻出现在桌面 GUI 的工作区列表里（不靠人手动 /attach）。
+  void reportSessionToHost(slot.id, cwd)
   flattenConfigOptions(r?.configOptions)
   if (Array.isArray(r?.configOptions)) peer.acpConfig = r.configOptions.map((o) => o.id).join(',')
   await applyPeerConfig(peer, slot.id)
@@ -788,6 +807,26 @@ async function ensurePeerSession(peer) {
   return slot.id
 }
 
+/**
+ * 把桥创建的会话上报给宿主，登记进对应工作区（幂等；失败只影响"归组"，不影响本轮任务）。
+ * 宿主路由 /wxbridge/attach 就是干这个的，且只有宿主进程内的插件能调 workspaceRegistry。
+ */
+async function reportSessionToHost(sessionId, cwd, isRetry) {
+  if (!sessionId || EXECUTION === 'headless') return
+  try {
+    const port = await discoverHost()
+    if (!port) { log('attach-report-skip', { session: sessionId, note: '宿主未发现（端口未探到）' }); return }
+    const r = await fetch('http://127.0.0.1:' + port + '/wxbridge/attach', {
+      method: 'POST', headers: { 'content-type': 'application/json' },
+      body: JSON.stringify({ sessionId, cwd }), signal: AbortSignal.timeout(8000),
+    })
+    const j = await r.json().catch(() => null)
+    log('attach-report', { session: sessionId, ok: !!(j && j.ok), workspace: (j && j.workspacePath) || null, error: (j && j.error) || null })
+    // 会话文件刚落盘时宿主可能还读不到 → 4 秒后补一次（仍幂等；再不行还有宿主侧 10 分钟的兜底扫描）
+    if (!(j && j.ok)) setTimeout(() => { void reportSessionToHost(sessionId, cwd, true) }, 4000)
+  } catch (e) { log('attach-report-failed', { session: sessionId, error: String(e?.message ?? e) }) }
+}
+
 /**
  * 把 peer 选的模型/推理强度施加到当前会话。
  * **必须每次 new/resume 后都做**：实测 resume 后会话会掉回 acp profile 的默认模型
@@ -1086,7 +1125,18 @@ async function handleMessage(token, msg) {
   const from = String(msg?.from_user_id ?? '')
   const text = inboundText(msg)
   const ctx = msg?.context_token
-  if (!from || !text) return
+  if (!from) return
+  if (!text) {
+    // 原来这里是一句 `if (!from || !text) return` —— 图片/语音/表情**连回执都没有**，
+    // 用户只看到"发了没反应"。现在至少回一句"只认文字"（2026-09-22 其他用户反馈）。
+    const types = inboundItemTypes(msg)
+    log('inbound-nontext', { types, note: types.length ? '非文本，已回提示' : '空消息' })
+    const notice = nonTextNoticeFor(from)
+    if (notice) {
+      try { await reply(token, from, notice, ctx) } catch (e) { log('send-failed', { error: String(e?.message ?? e) }) }
+    }
+    return
+  }
   const trimmed = text.trim()
   const firstToken = trimmed.split(/\s+/)[0] || ''
   const authed = firstToken === AUTH_TOKEN
@@ -1318,6 +1368,23 @@ async function main() {
     }, null, 1))
     process.exit(0)
   }
+  if (args.includes('--selftest-inbound')) {
+    const mk = (items) => ({ from_user_id: 'u-test', item_list: items })
+    const textMsg = mk([{ type: 1, text_item: { text: '你好' } }])
+    const imgMsg = mk([{ type: 2, image_item: { url: 'x' } }])
+    const bothMsg = mk([{ type: 2, image_item: { url: 'x' } }, { type: 1, text_item: { text: '这是什么' } }])
+    const first = nonTextNoticeFor('u-cooldown', 1000000000000)
+    const second = nonTextNoticeFor('u-cooldown', 1000000000000 + 30 * 1000)
+    const third = nonTextNoticeFor('u-cooldown', 1000000000000 + 61 * 1000)
+    console.log('[selftest-inbound] ' + JSON.stringify({
+      text: { text: inboundText(textMsg), types: inboundItemTypes(textMsg) },
+      image: { text: inboundText(imgMsg), types: inboundItemTypes(imgMsg), notice: first.slice(0, 24) + '…' },
+      imagePlusText: { text: inboundText(bothMsg), types: inboundItemTypes(bothMsg) },
+      cooldown: { at0: !!first, at30s: !!second, at61s: !!third },
+      noticeText: NOTEXT_NOTICE,
+    }, null, 1))
+    process.exit(0)
+  }
   if (args.includes('--selftest-preset-check')) {
     const peer = { cwd: CWD }
     const sp = argOf('--selftest-preset-check', '')
@@ -1441,7 +1508,7 @@ async function main() {
         const key = msgKey(msg)
         if (seen.has(key)) continue
         seen.add(key); state.processed.push(key)
-        log('inbound', { text: inboundText(msg).slice(0, 80) })
+        log('inbound', { text: inboundText(msg).slice(0, 80), types: inboundItemTypes(msg) })
         try { await handleMessage(wechatToken, msg) } catch (e) { log('handle-error', { error: String(e?.message ?? e) }) }
       }
       await saveState(state)

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@zmainer/dsh-wx-bridge",
-  "version": "1.0.9",
+  "version": "1.0.11",
   "type": "module",
   "main": "./lib/index.js",
   "dsh": {

package/src/client.js

@@ -263,9 +263,12 @@ function Panel() {
   const rows = [
     ['桥状态', state + '（' + (b.phase || 'n/a') + '）'],
     ['进程', b.pid ? ('pid ' + b.pid + '｜心跳 ' + (b.ageSec === null ? 'n/a' : b.ageSec + 's 前')) : '无'],
-    ['运行时入口', b.runtimeBin
-      ? (b.runtimeBin + (b.runtimeBinOk ? '' : '（⚠️ 文件不存在）'))
-      : '⚠️ 未解析（手机对话会失败，请设置 dshBin）'],
+    // 字段缺失 ≠ 解析失败：升级了包但还没重启宿主时，宿主半仍是旧版、不上报这个字段。
+    ['运行时入口', b.runtimeBin === undefined
+      ? '—（宿主半未上报；重启宿主后显示）'
+      : (b.runtimeBin
+        ? (b.runtimeBin + (b.runtimeBinOk ? '' : '（⚠️ 文件不存在）'))
+        : '⚠️ 未解析（手机对话会失败，请设置 dshBin）')],
     ['数据目录', b.dataDir || 'n/a'],
     ['默认工作区', b.cwd || 'n/a'],
   ]