dsh-mini-remote 0.1.0

package/lib/cloudflared.js

@@ -0,0 +1,165 @@
+/**
+ * 找到（或下载）cloudflared 可执行文件。
+ *
+ * cloudflared 是 Cloudflare 的隧道客户端。它从你的电脑主动连出去，Cloudflare
+ * 那头给你一个公网网址，转发回本机的手机服务。好处是电脑不用有公网 IP、不用
+ * 在路由器上开端口；代价是那个网址任何人都访问得到——密码和限速是唯一的门。
+ *
+ * 找的顺序是「能用现成的就不下载」：配置里指定的 → 系统 PATH 里的 → dsh-pocket
+ * 已经下过的那份 → 自己下（下过一次就缓存下来）。
+ */
+import { chmod, mkdir, rename, rm, stat, access } from 'node:fs/promises'
+import { createWriteStream } from 'node:fs'
+import { spawn } from 'node:child_process'
+import { join, dirname } from 'node:path'
+import { Readable } from 'node:stream'
+import { pipeline } from 'node:stream/promises'
+
+const BIN_NAME = process.platform === 'win32' ? 'cloudflared.exe' : 'cloudflared'
+
+/**
+ * 各系统对应的发布产物名。
+ * 注意 linux 是**裸二进制**（没有 .tgz）——dsh-pocket 的注释里记着，早期给
+ * linux 拼 `cloudflared-linux-amd64.tgz` 是错的，那个文件根本不存在。这里把
+ * .tgz 留在候选里只作回退，万一上游改回打包方式也不会直接躺平。
+ */
+function assetNames() {
+  const arch = process.arch === 'arm64' ? 'arm64' : 'amd64'
+  if (process.platform === 'win32') return ['cloudflared-windows-amd64.exe']
+  if (process.platform === 'darwin') return [`cloudflared-darwin-${arch}.tgz`]
+  return [`cloudflared-linux-${arch}`, `cloudflared-linux-${arch}.tgz`]
+}
+
+/**
+ * 下载源，按顺序试。前三个是 GitHub 加速代理——国内直连 GitHub 的 release
+ * 经常超时。（npmmirror 没有 cloudflared 镜像，实测 404，所以不在列表里。）
+ *
+ * 这三个加速源和 dsh-pocket（shaobeichen，GPL-2.0）用的是同一批。这类镜像地址是
+ * 国内开发者的公共常识，不是谁的独创；这里记一笔，是为了不假装没见过它。
+ * 代码本身（这个数组的形状、下载与校验流程）是我们自己写的。
+ */
+const MIRRORS = [
+  (asset) => `https://github.com/cloudflare/cloudflared/releases/latest/download/${asset}`,
+  (asset) => `https://ghproxy.net/https://github.com/cloudflare/cloudflared/releases/latest/download/${asset}`,
+  (asset) => `https://gh.ddlc.top/https://github.com/cloudflare/cloudflared/releases/latest/download/${asset}`,
+  (asset) => `https://gh-proxy.com/https://github.com/cloudflare/cloudflared/releases/latest/download/${asset}`,
+]
+
+async function exists(file) {
+  try {
+    await access(file)
+    return true
+  } catch {
+    return false
+  }
+}
+
+/**
+ * 跑一次 `cloudflared --version` 看能不能用。
+ * 比自己在 PATH 里拼路径可靠——PATH 之外还有别名、软链、包管理器装的 shim。
+ */
+function probe(command) {
+  return new Promise((resolve) => {
+    let child
+    try {
+      child = spawn(command, ['--version'], { stdio: ['ignore', 'pipe', 'pipe'] })
+    } catch {
+      resolve(false)
+      return
+    }
+    let out = ''
+    const finish = (ok) => {
+      clearTimeout(timer)
+      try { child.kill() } catch { /* 已经退了 */ }
+      resolve(ok)
+    }
+    const timer = setTimeout(() => finish(false), 5000)
+    timer.unref?.()
+    child.stdout?.on('data', (chunk) => { out += chunk })
+    child.stderr?.on('data', (chunk) => { out += chunk })
+    child.on('error', () => finish(false))
+    child.on('close', (code) => finish(code === 0 && /cloudflared/i.test(out)))
+  })
+}
+
+async function fetchTo(url, file) {
+  const res = await fetch(url, { redirect: 'follow', signal: AbortSignal.timeout(180_000) })
+  if (!res.ok) throw new Error(`HTTP ${res.status}`)
+  if (!res.body) throw new Error('响应没有正文')
+  await pipeline(Readable.fromWeb(res.body), createWriteStream(file))
+  const { size } = await stat(file)
+  // 代理挂掉时经常返回一个 HTML 错误页而不是报错，用体积把它挡掉
+  if (size < 1_000_000) throw new Error(`文件只有 ${size} 字节，多半下到的是错误页`)
+}
+
+function extractTgz(archive, dir) {
+  return new Promise((resolve, reject) => {
+    const child = spawn('tar', ['-xzf', archive, '-C', dir], { stdio: 'ignore' })
+    child.on('error', reject)
+    child.on('close', (code) => (code === 0 ? resolve() : reject(new Error(`tar 退出码 ${code}`))))
+  })
+}
+
+async function download(dataDir, log) {
+  const dir = join(dataDir, 'bin')
+  await mkdir(dir, { recursive: true })
+  const target = join(dir, BIN_NAME)
+  const tmp = `${target}.part`
+  const failures = []
+
+  for (const asset of assetNames()) {
+    for (const mirror of MIRRORS) {
+      const url = mirror(asset)
+      try {
+        log?.info?.('正在下载 cloudflared（约 50MB，国内可能比较慢，只需一次）…')
+        await fetchTo(url, tmp)
+        if (asset.endsWith('.tgz')) {
+          await extractTgz(tmp, dir)
+          await rm(tmp, { force: true })
+        } else {
+          await rename(tmp, target)
+        }
+        if (process.platform !== 'win32') await chmod(target, 0o755)
+        log?.info?.(`cloudflared 已下载到 ${target}`)
+        return target
+      } catch (err) {
+        failures.push(`${new URL(url).host} — ${err?.message ?? err}`)
+        await rm(tmp, { force: true })
+      }
+    }
+  }
+
+  throw new Error(`所有下载源都没成功：\n  ${failures.join('\n  ')}`)
+}
+
+/**
+ * @param {object} opts
+ * @param {string} [opts.configuredPath] settings.json 里的 cloudflaredPath
+ * @param {string} opts.dataDir 插件数据目录（下载物落在它的 bin/ 下）
+ * @returns {Promise<{path: string|null, source?: string, error?: string}>}
+ */
+export async function ensureCloudflared({ configuredPath, dataDir, log }) {
+  if (configuredPath) {
+    if (await exists(configuredPath)) return { path: configuredPath, source: 'configured' }
+    return { path: null, error: `settings.json 里的 cloudflaredPath 指向的文件不存在：${configuredPath}` }
+  }
+
+  if (await probe('cloudflared')) return { path: 'cloudflared', source: 'path' }
+
+  // dsh-pocket 很可能已经下过一份，直接复用，省掉 50MB 下载
+  const shared = join(dirname(dataDir), 'dsh-pocket', 'bin', BIN_NAME)
+  if (await exists(shared)) return { path: shared, source: 'dsh-pocket' }
+
+  const cached = join(dataDir, 'bin', BIN_NAME)
+  if (await exists(cached)) return { path: cached, source: 'cached' }
+
+  try {
+    return { path: await download(dataDir, log), source: 'downloaded' }
+  } catch (err) {
+    return {
+      path: null,
+      error: `${err?.message ?? err}\n也可以自己装一个（apt/dnf install cloudflared），`
+        + '或者在 settings.json 里用 cloudflaredPath 直接指向它。',
+    }
+  }
+}

package/lib/events.js

@@ -0,0 +1,165 @@
+/**
+ * 从 DSH 会话事件流里，只捞出两样东西：
+ *   1. 用户真正发出的指令（不是插件注入的合成上下文）
+ *   2. Agent 一轮任务的最终回复（不是中间的工具调用和思考）
+ *
+ * 依据 DSH 0.1.5-rc.2 实测的事件契约：
+ *   SessionEvent = { type, seq, time, data }
+ *   - turn/start      data: { turn }
+ *   - user/message    data: UserMessage          （data.source.kind === 'user' 才是人发的）
+ *   - assistant/message data: { turn, step, message: AssistantMessage, stream, usage? }
+ *   - turn/end        data: { turn, reason: { kind } }
+ *   reason.kind ∈ completed | aborted | blocked | error | max-tokens | interrupted
+ */
+
+/** 只取真正面向用户可见的 text 块，丢掉 reasoning / tool-call / image。 */
+export function visibleText(content) {
+  if (!Array.isArray(content)) return ''
+  const parts = []
+  for (const block of content) {
+    if (block && block.type === 'text' && typeof block.text === 'string' && block.text.trim() !== '') {
+      parts.push(block.text)
+    }
+  }
+  return parts.join('\n\n').trim()
+}
+
+/**
+ * 这条助手消息是不是「中间步骤」。
+ *
+ * 判据：内容里有没有工具调用块。**有就是中间步骤**——模型先写一句「我先看看…」，
+ * 再发起工具调用，那句话说到底只是它自己的旁白，不是给你的回答。
+ *
+ * 依据 dsh-llm 的类型定义（lib/types/types.d.ts）：
+ *   TextBlock      { type: 'text',      text }              面向用户的可见文字
+ *   ReasoningBlock { type: 'reasoning', text }              思考内容，与可见文字明确区分
+ *   ToolCallBlock  { type: 'tool-call', id, name, arguments }
+ *
+ * 用户 2026-09-21 实机报的「手机端我看回答过来的是思考过程」，就是这里漏了：
+ * 原来只要一条消息有文字就记下来，于是一轮里最后那条旁白被当成了回答。
+ */
+export function isIntermediateStep(content) {
+  if (!Array.isArray(content)) return false
+  return content.some((block) => block && block.type === 'tool-call')
+}
+
+/**
+ * 这段文字里是不是夹着工具调用的原始标记。
+ *
+ * 实机见过：一条助手消息的 text 块里既有旁白，又有没被解析掉的
+ * `<parameter name="edit">…`。那属于协议，不是给人读的话——
+ * 用户在手机上看到的就是这个（2026-09-21 反馈里贴出来的原文）。
+ *
+ * 判据故意写窄：只认工具调用那几种标记的开头，不碰别的尖括号内容。
+ * 写宽了会误伤——用户完全可能正当地跟你讨论一段 XML 或 HTML。
+ */
+const TOOL_MARKUP = /<parameter\s+name\s*=|<\s*function_calls\s*>|<invoke\s+name\s*=/
+
+export function looksLikeToolMarkup(text) {
+  return typeof text === 'string' && TOOL_MARKUP.test(text)
+}
+
+/**
+ * 一轮任务的累计器。
+ *
+ * 一个 turn 可能包含多个 step（模型多次调用工具），每个 step 都会落一条
+ * assistant/message。
+ *
+ * **只有「不含工具调用」的那一条才是最终回答。** 带工具调用的那些是中间步骤，
+ * 里面的文字是模型的旁白（「编辑没生效，我重做一下」这种），不是给你的回答——
+ * 原来把它们也记下来，于是用户看到的是「思考过程」。
+ *
+ * 一轮跑完却始终没出现这样一条（被中断、或卡在工具里出不来），那就**没有回答可推**，
+ * 推空。宁可什么都不显示，也不能把旁白冒充成回答。
+ */
+export function createTurnTracker() {
+  /** @type {Map<string, { turn: number|null, lastText: string, userText: string, interrupted: boolean }>} */
+  const bySession = new Map()
+
+  function slot(sessionId) {
+    let s = bySession.get(sessionId)
+    if (!s) {
+      s = { turn: null, lastText: '', userText: '', interrupted: false }
+      bySession.set(sessionId, s)
+    }
+    return s
+  }
+
+  return {
+    /**
+     * 喂入一条会话事件。
+     * @returns {{kind:'user', text:string}|{kind:'reply', text:string, reason:string}|null}
+     *          需要推送到手机时返回动作，否则返回 null。
+     */
+    feed(sessionId, event) {
+      if (!event || typeof event.type !== 'string') return null
+      const s = slot(sessionId)
+
+      switch (event.type) {
+        case 'turn/start':
+          s.turn = event.data?.turn ?? s.turn
+          s.lastText = ''
+          s.interrupted = false
+          return null
+
+        case 'user/message': {
+          // 只认人发的；agent.inject() 的合成上下文（文件变更通知、skill 内容等）
+          // 的 source.kind 是 'plugin'，必须排除，否则手机里会冒出莫名其妙的消息。
+          if (event.data?.source?.kind !== 'user') return null
+          const text = visibleText(event.data.content)
+          if (!text) return null
+          s.userText = text
+          // 带上 id：手机自己发出去的指令，注入后也会以这条事件回来，
+          // 调用方要靠 id 把它认出来、不要记第二笔（见 index.js 的 injectedIds）。
+          return { kind: 'user', text, id: event.data?.id }
+        }
+
+        case 'assistant/message': {
+          const content = event.data?.message?.content
+          // 中间步骤的文字是旁白，不是回答——跳过。见上面 isIntermediateStep 的说明。
+          if (isIntermediateStep(content)) return null
+          const text = visibleText(content)
+          if (!text) return null
+          // 夹着工具调用原始标记的文字不是给人读的，同样不能推。
+          if (looksLikeToolMarkup(text)) return null
+          s.lastText = text
+          /**
+           * 被中止的那一轮，会把「已经吐出来的那一段」作为一个 assistant/message
+           * 落下来，带 interrupted: true（见 dsh-session 的类型注释：
+           * "A turn cancelled mid-stream finalizes its delivered text/reasoning
+           * prefix as this event with `interrupted: true`; undispatched tool calls
+           * are absent."）。
+           *
+           * **那个「没派发的工具调用不在里面」是这里的关键**：中止的那条消息通常
+           * 一个 tool-call 块都没有，于是 isIntermediateStep 放它过去、被当成最终
+           * 回答。手机上就会莫名其妙出现半句话——看着像模型答崩了。
+           * 所以必须单独认这个标记，让手机知道「这是你按停的那半句」。
+           */
+          s.interrupted = event.data?.interrupted === true
+          return null
+        }
+
+        case 'turn/end': {
+          const reason = event.data?.reason?.kind ?? 'completed'
+          const text = s.lastText
+          const userText = s.userText
+          const interrupted = s.interrupted
+          s.lastText = ''
+          s.userText = ''
+          s.interrupted = false
+          // 被取消/出错的轮次，以及卡在工具里没跑出回答的轮次，都没有什么可推的。
+          if (!text) return null
+          return { kind: 'reply', text, reason, userText, interrupted }
+        }
+
+        default:
+          return null
+      }
+    },
+
+    /** 会话销毁时清掉累计器，避免长期运行下 Map 无限增长。 */
+    forget(sessionId) {
+      bySession.delete(sessionId)
+    },
+  }
+}