dsh-remote-hub 0.0.0-stage → 0.1.0

package/LICENSE

@@ -0,0 +1,21 @@
+MIT License
+
+Copyright (c) 2026 liaoguogang-hub
+
+Permission is hereby granted, free of charge, to any person obtaining a copy
+of this software and associated documentation files (the "Software"), to deal
+in the Software without restriction, including without limitation the rights
+to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
+copies of the Software, and to permit persons to whom the Software is
+furnished to do so, subject to the following conditions:
+
+The above copyright notice and this permission notice shall be included in all
+copies or substantial portions of the Software.
+
+THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
+AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
+OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
+SOFTWARE.

package/README.md

@@ -1,3 +1,194 @@
-# Temporary Holding Version
+# DSH Remote — Android 远程控制器
 
-This version is a temporary placeholder for this package. An operational version to replace this has been submitted for review and is awaiting a staged release.
+手机原生 App，直接控制电脑上的 **DeepSeek Harness (DSH)**。不是 WebView 套壳：
+Kotlin/Compose 直连 DSH 自带的 HTTP API + WebSocket 网关。
+
+这是**公共版**，与作者自用版的唯一差别：
+
+| | 自用版 | 本仓库（公共版） |
+|---|---|---|
+| 连接方式 | 局域网 / 自建中继 / 自定义 | 局域网 / **ngrok 隧道** / 自定义 |
+| 内置服务器地址 | 有 | **无** |
+| 内置登录凭证 | 有（30 天 cookie） | **无** |
+| 包名 | `com.dsh.remote` | `com.dsh.remote.ngrok`（可与自用版共存） |
+| 应用名 / APK | `DSH` / `DSH-Remote-v*.apk` | `DSH Remote` / `DSH Remote-v*.apk` |
+
+功能与 UI 与自用版 4.12.2 完全一致。
+
+## 功能
+
+| 能力 | 状态 |
+|---|---|
+| 三种连接方式（局域网 / ngrok / 自定义），地址与凭证首次填写后本地保存 | ✅ |
+| 会话列表：搜索、排序（最近更新 / 手动）、归档筛选（隐藏 / 全部 / 仅归档） | ✅ |
+| 会话列表默认显示最近 10 条，「展开其余 N 个会话」每次 +5 | ✅ |
+| 长按会话：重命名 / 归档会话（或取消归档） | ✅ |
+| 发消息、逐字流式回复、随时中断 | ✅ |
+| 历史分页（「加载更早的消息」）与本地缓存（先显示上次内容再同步） | ✅ |
+| 模型选择（分组目录 + 切换） | ✅ |
+| 权限模式 | ⚠️ 只能读取当前值（DSH 未开放远程切换权限的接口） |
+| 自定义地址历史（点选填入 / 删除） | ✅ |
+
+## 三步连上（推荐：一键脚本）
+
+1. **电脑上双击 `connect.cmd`**（和 App 一起发布的文件）。
+   它会自动做四件事：起桥接 → 签发 30 天 Cookie → 尽量开公网隧道 → 打印结果。
+2. 等黑窗口打印出这两行：
+   - `DSH 地址: http://192.168.x.x:6300`（同一 WiFi，最快）
+   - `Cookie: dsh-auth-…`（已自动复制到剪贴板）
+   如果网络允许，还会多给一行公网地址 `https://xxx.trycloudflare.com`（人在外面时用）。
+3. **App 里选「自定义」档** → 把地址粘进「DSH 地址」框 → Cookie 粘进「Cookie」框 → 点连接。
+
+> 电脑端那个黑窗口要保持开着；关掉 = 断开手机。下次用重新双击一次，抄新的地址和 Cookie 即可。
+> 结果同时会写到同目录的 `connect-info.txt`。
+
+### 公网隧道说明
+
+脚本按这个顺序尝试，**局域网地址永远可用**，公网则尽力而为：
+
+| 情况 | 结果 |
+|---|---|
+| 装了 `ngrok` 且在 PATH 里 | 用 ngrok 开隧道 |
+| 有 `cloudflared`（脚本会自动找/下载）且 `api.trycloudflare.com` 可达 | 免费 trycloudflare 地址，免注册 |
+| 两者都不行（常见于受限网络） | 只给局域网地址，并提示需要自备内网穿透（cpolar / natapp / 花生壳 / 自建 frp） |
+
+### 用 ngrok 拿一个永久固定域名（可选，需注册）
+
+cloudflared 的免费 quick tunnel **每次重启地址都会变**；想要固定域名就用 ngrok 免费账号。
+
+
+![ngrok 注册要点：左栏三处](docs/ngrok-dashboard-annotated.png)
+
+上图红框就是全部要点：① Share Localhost ② Your Authtoken ③ Domains。
+
+**注册（约 2 分钟）**
+
+1. 打开 <https://dashboard.ngrok.com/get-started/setup>，在首页选 **Share Localhost**
+   （「Put your local app on a public URL」——它明确写着 *stable, auth-protected URL*）；
+2. 跟着 **Get started** 走完，进 dashboard 后取两样东西：
+   - **Authtoken**：左侧 `Getting Started` → `Your Authtoken`
+     <https://dashboard.ngrok.com/get-started/your-authtoken>
+   - **免费固定域名**：左侧 `Universal Gateway` → `Domains`，免费账号自带一个
+     `xxxx-yyyy.ngrok-free.app` <https://dashboard.ngrok.com/domains>
+3. 下载 ngrok 单文件（同样免安装、不需要管理员权限），放进 `tools\ngrok.exe`，或装到 PATH。
+
+**配置（只需一次）**
+
+```powershell
+tools\ngrok.exe config add-authtoken <你的 Authtoken>
+```
+
+然后双击 `connect.cmd`：它会自己发现 ngrok、问你一次固定域名（记在
+`%LOCALAPPDATA%\dsh-remote\ngrok-domain.txt`），之后每次都复用同一个地址。
+
+> - **Host 必须改写**：脚本用 `--host-header=127.0.0.1:1815`，否则 DSH 的信任栅栏会 403，
+>   而且 cookie 的 authority 对不上。
+> - **不要加 ngrok 的 Basic Auth**：App 是用 DSH 的签名 cookie 认证的，Basic Auth 会让每个
+>   API 调用先被 ngrok 拦下（401），App 连不上。安全性由 30 天签名的 cookie 保证。
+> - **免费额度**：约 40 连接/分钟、1 GB/月。App 是长连接 + 流式输出，日常够用；
+>   偶发断连多半是额度或连接数超限，可换付费或 cloudflared。
+
+### 自己下载 cloudflared（可选，单文件免安装、不需要管理员权限）
+
+脚本会优先在 `connect.cmd` 同目录、`tools\`、`%LOCALAPPDATA%\dsh-remote\` 等位置找
+`cloudflared.exe`；找不到才下载。想自己放一份，按下面来：
+
+```powershell
+# 1) 镜像优先：国内直连 GitHub 下 52 MB 基本必超时
+$url = "https://ghfast.top/https://github.com/cloudflare/cloudflared/releases/latest/download/cloudflared-windows-amd64.exe"
+# 官方直连（网络允许时）：
+# $url = "https://github.com/cloudflare/cloudflared/releases/latest/download/cloudflared-windows-amd64.exe"
+
+$dest = "tools\cloudflared.exe"
+New-Item -ItemType Directory -Force -Path (Split-Path $dest) | Out-Null
+Invoke-WebRequest -Uri $url -OutFile $dest -TimeoutSec 300 -UseBasicParsing
+
+# 2) 一定要验签：镜像可能给错文件，但签名伪造不了
+Get-AuthenticodeSignature $dest | Format-List Status, SignerCertificate
+```
+
+合格标准：`Status = Valid`，`Subject` 里含 `Cloudflare, Inc.`。
+参考值（2026.10.5 版）：`55,343,328` 字节，
+SHA256 `DB4E4C413612A0916F3E1679D3CAAF376F94911952D163028FB726FB2E0516A9`。
+
+> 脚本自己下载时也会做同样的验签（`Get-AuthenticodeSignature` + 主体含 Cloudflare），
+> 校验不过就丢弃并换下一个源 —— **不要用哈希对比代替验签**，镜像可以把哈希一起改掉。
+
+### 手工方式（想自己控制时）
+
+```bash
+node lan-proxy.mjs 6300 127.0.0.1:1815     # 桥接：把 Host 改写成 DSH 认可的 127.0.0.1:1815
+ngrok http 6300 --host-header=127.0.0.1:1815   # 或 cloudflared tunnel --url http://127.0.0.1:6300
+node mint.mjs "127.0.0.1:1815" 30              # 签发 30 天 Cookie
+```
+
+```text
+浏览器打开 DSH 页面 → F12 → Application → Cookies → 复制会话 cookie
+  （cookie 只对签发时的 authority 有效，所以桥接必须改写 Host 到同一个值）
+```
+
+## 安全说明
+
+- **本仓库不包含任何地址、Token 或 Cookie**：`DshDefaults.kt` 里全是空字符串，首次连接在 App 里填。
+- **Cookie 由你自己的电脑签发**：脚本用 `~/.dsh/.credentials.yaml` 里的密钥签一个 30 天有效的凭据，
+  只在你自己机器和手机之间流动，不要提交到任何仓库。
+- **局域网默认是明文 HTTP**：`lan-proxy.mjs` 监听 `0.0.0.0:6300`，同一 WiFi 内 Anyone 能访问它，
+  所以请只在可信网络里用局域网模式；要跨网请用 ngrok / cloudflared 这类带 TLS 的隧道。
+- **App 允许明文与用户证书**（`network_security_config.xml`）：DSH 通常跑在明文 HTTP 上，
+  自签 CA 的中转也要能信任；代价是它不会阻止你连明文地址，所以地址来源要自己把关。
+- **别把 ngrok 的 Basic Auth 和 DSH 的 Cookie 混用**：App 只带 DSH 的 Cookie，
+  Basic Auth 会让每个请求先被隧道 401 拦掉。
+
+## 构建
+
+```bash
+./gradlew assembleRelease      # 产物：dist/DSH Remote-v<version>.apk
+```
+
+需要 JDK 17 与 Android SDK（`local.properties` 指向本机 SDK）。
+
+## 版本
+
+当前 `4.12.2`（versionCode 58），与自用版 4.12.2 功能一致。
+
+## 作为 DSH 插件安装（推荐）
+
+本仓库根目录同时是一个 **DSH plugin**（Node 侧），装进 DSH 后由宿主负责起桥接、开隧道、签 Cookie，
+并把地址与 Cookie 写进 `~/.dsh/dsh-remote/`，手机 App 直接抄。
+
+```bash
+# 从 NPM 安装（发布后可用，会出现在 DSH 内的「插件中心」）
+dsh plugin --profile web add dsh-remote-hub
+
+# 或直接从本仓库源码安装（不需要 NPM 发布）
+dsh plugin --profile web add github:liaoguogang-hub/dsh-remote-public
+```
+
+装完重启 `dsh web`（或桌面端），插件会自动：
+
+1. 起桥接：`0.0.0.0:6300`，把 Host 改写成 `127.0.0.1:1815`（Cookie 因此不会因端口变化失效）；
+2. 自动发现 DSH 宿主端口（宿主每次重启都换端口，插件每次失败会重新扫一遍）；
+3. 开隧道：**有 ngrok 就用 ngrok**（固定域名），否则自动下载并验签 cloudflared 开免注册 quick tunnel；
+4. 签发 30 天 Cookie，写到 `~/.dsh/dsh-remote/status.json` 与 `connect.txt`。
+
+查看结果：
+
+```bash
+dsh-remote status     # 局域网地址、公网地址、Cookie、上游端口
+dsh-remote connect    # 直接打印要抄进手机的两行
+dsh-remote doctor     # 逐项自检：凭据、ngrok、cloudflared、宿主端口
+dsh-remote start      # 不开 DSH 也能单独前台跑（Ctrl+C 退出）
+```
+
+插件配置（profile 行里覆盖即可）：
+
+| 键 | 默认 | 作用 |
+|---|---|---|
+| `enabled` | `true` | 关掉插件但不卸载 |
+| `port` | `6300` | 桥接监听端口（手机连这个） |
+| `authority` | `127.0.0.1:1815` | 桥接呈现的 Host，Cookie 绑定它 |
+| `tunnel` | `auto` | `auto` / `off` / `ngrok` / `cloudflared` |
+| `upstreamPort` | `0` | 固定 DSH 宿主端口，`0` 表示自动发现 |
+
+> 公网隧道受网络影响：`api.trycloudflare.com` 不可达时插件会跳过公网、只给局域网地址，
+> 并在 `status.json` 里写明原因，不会假装成功。

package/bin/dsh-remote.mjs

@@ -0,0 +1,141 @@
+#!/usr/bin/env node
+/**
+ * dsh-remote CLI — inspect or drive the bridge/tunnel without the DSH UI.
+ *
+ *   dsh-remote status      show LAN URL, public URL, cookie and upstream port
+ *   dsh-remote connect     print the two lines to paste into the phone
+ *   dsh-remote cookie      print only the cookie
+ *   dsh-remote start       run the supervisor in the foreground (Ctrl+C stops it)
+ *   dsh-remote stop        ask a foreground `start` to stop (best effort, via status file)
+ *   dsh-remote doctor      check every prerequisite in one pass
+ *
+ * @module bin/dsh-remote
+ */
+
+import fs from 'node:fs'
+import os from 'node:os'
+import path from 'node:path'
+
+import { credentialsPath, mintCookie, readSigningSecret } from '../lib/cookie.js'
+import { listeningPorts, probePort } from '../lib/discover.js'
+import { findCloudflared, findNgrok } from '../lib/tunnel.js'
+import { CONNECT_FILE, STATUS_FILE, readStatus, start } from '../lib/supervisor.js'
+
+const args = process.argv.slice(2)
+const command = args[0] || 'status'
+
+function fmtTime(ms) {
+  if (!ms) return '?'
+  const d = new Date(ms)
+  return `${d.getFullYear()}-${String(d.getMonth() + 1).padStart(2, '0')}-${String(d.getDate()).padStart(2, '0')}`
+}
+
+function printStatus() {
+  const status = readStatus()
+  if (!status) {
+    console.log('还没有运行记录。先运行： dsh-remote start')
+    return
+  }
+  const remaining = status.cookieExpiresAt ? Math.round((status.cookieExpiresAt - Date.now()) / 86400000) : null
+  console.log('')
+  console.log('  DSH Remote 状态')
+  console.log('  ' + '-'.repeat(52))
+  console.log(`  局域网地址   ${status.lan?.url ?? '(未检测到局域网 IP)'}`)
+  console.log(`  公网地址     ${status.public?.url ?? `无（${status.public?.note ?? '未开启'}）`}`)
+  console.log(`  桥接端口     ${status.bridgePort}`)
+  console.log(`  DSH 上游     ${status.upstreamPort ? '127.0.0.1:' + status.upstreamPort : '未找到'}`)
+  console.log(`  更新时间     ${new Date(status.updatedAt).toLocaleString()}`)
+  if (status.cookie) {
+    console.log(`  Cookie 到期  ${fmtTime(status.cookieExpiresAt)}${remaining !== null ? `（还剩 ${remaining} 天）` : ''}`)
+    console.log('')
+    console.log('  把下面两样填进手机 App：')
+    console.log(`    地址   ${status.public?.url ?? status.lan?.url ?? ''}`)
+    console.log(`    Cookie ${status.cookie}`)
+  } else if (status.error) {
+    console.log(`  错误   ${status.error}`)
+  }
+  console.log('  ' + '-'.repeat(52))
+  console.log('')
+}
+
+async function doctor() {
+  console.log('')
+  console.log('  dsh-remote 自检')
+  console.log('  ' + '-'.repeat(52))
+  const cred = credentialsPath()
+  let secret = null
+  try {
+    secret = readSigningSecret(cred)
+    console.log(`  ✔ 凭据文件        ${cred}`)
+  } catch (err) {
+    console.log(`  ✘ 凭据文件        ${err.message}`)
+  }
+  const ngrok = findNgrok()
+  console.log(`  ${ngrok ? '✔' : '·'} ngrok          ${ngrok ?? '未安装（可选，有则优先用固定域名）'}`)
+  const cf = findCloudflared()
+  console.log(`  ${cf ? '✔' : '·'} cloudflared    ${cf ?? '未安装（首次运行会自动下载并验签）'}`)
+  if (secret) {
+    try {
+      const { cookie } = mintCookie('127.0.0.1:1815', { secret, days: 30 })
+      const bridgePort = Number(process.env.DSH_REMOTE_PORT || 6300)
+      const ports = (await listeningPorts()).filter((p) => p !== bridgePort)
+      let found = null
+      for (const p of ports) {
+        // eslint-disable-next-line no-await-in-loop
+        if (await probePort(p, { authority: '127.0.0.1:1815', cookie })) {
+          found = p
+          break
+        }
+      }
+      console.log(`  ${found ? '✔' : '✘'} DSH 宿主端口    ${found ? '127.0.0.1:' + found : '未找到（DSH 开着吗？）'}`)
+    } catch (err) {
+      console.log(`  ✘ 探测失败        ${err.message}`)
+    }
+  }
+  console.log('  ' + '-'.repeat(52))
+  console.log('')
+}
+
+async function main() {
+  switch (command) {
+    case 'status':
+      printStatus()
+      break
+    case 'connect':
+      if (fs.existsSync(CONNECT_FILE)) console.log(fs.readFileSync(CONNECT_FILE, 'utf8'))
+      else printStatus()
+      break
+    case 'cookie': {
+      const status = readStatus()
+      if (status?.cookie) console.log(status.cookie)
+      else {
+        const { cookie } = mintCookie('127.0.0.1:1815')
+        console.log(cookie)
+      }
+      break
+    }
+    case 'doctor':
+      await doctor()
+      break
+    case 'start': {
+      const handle = await start({ log: (m) => console.log(m) })
+      process.on('SIGINT', async () => {
+        await handle.close()
+        process.exit(0)
+      })
+      break
+    }
+    case 'stop':
+      console.log('前台运行的 dsh-remote 用 Ctrl+C 停止；插件模式下请在 profile 设置里关闭该插件。')
+      break
+    default:
+      console.log(`未知命令：${command}`)
+      console.log('可用：status | connect | cookie | doctor | start | stop')
+      process.exitCode = 1
+  }
+}
+
+main().catch((err) => {
+  console.error(err?.stack ?? String(err))
+  process.exitCode = 1
+})

package/cordis.patch.yml

@@ -0,0 +1,21 @@
+# Bundle patch layer for the dsh-remote plugin.
+#
+# One insert row mounts the Host half only: the plugin runs inside the DSH host process, starts
+# the Host-rewriting bridge and the tunnel from there, and writes the resulting URL + cookie to
+# ~/.dsh/dsh-remote/. There is no browser half — the phone talks to the bridge, not to the web UI.
+#
+# Every key below is overridable from a saved profile row:
+#   enabled        false disables the whole plugin without uninstalling it
+#   port           local bridge port the phone connects to on the LAN
+#   authority      Host header the bridge presents; the signed cookie is bound to it
+#   tunnel         "auto" (ngrok if found, else cloudflared), "off", "ngrok" or "cloudflared"
+#   upstreamPort   pin the DSH host port; 0 means discover it automatically
+- insert:
+    - id: dsh-remote
+      name: 'dsh-remote-hub'
+      config:
+        enabled: true
+        port: 6300
+        authority: '127.0.0.1:1815'
+        tunnel: 'auto'
+        upstreamPort: 0

package/lib/bridge.js

@@ -0,0 +1,200 @@
+/**
+ * Host-rewriting reverse proxy between the phone and the DSH host.
+ *
+ * Two invariants:
+ *
+ *  1. The cookie's audience is whatever Host DSH receives, so this proxy always presents a fixed
+ *     authority (`127.0.0.1:1815` by default). One signed cookie therefore keeps working across
+ *     host restarts and across every transport.
+ *  2. The upstream port moves, so forwarding never pins it: a failed request or a 5xx triggers a
+ *     re-resolve before the error reaches the phone (up to one retry).
+ *
+ * It also trims `/api/session/list`, which is the single heaviest payload the app pulls (every
+ * Session with its full projection set). The phone only renders title / permissions /
+ * modelSelection, so projecting it here cuts the wire body by roughly 8x.
+ *
+ * @module lib/bridge
+ */
+
+import http from 'node:http'
+import net from 'node:net'
+import zlib from 'node:zlib'
+
+const LIST_PATH = '/api/session/list'
+
+function rewriteHeaders(headers, authority) {
+  const next = { ...headers }
+  delete next.origin
+  delete next.referer
+  next.host = authority
+  return next
+}
+
+/** Keep only the fields the Android app reads, from a `session/list` response body. */
+function trimSessionList(body) {
+  const doc = JSON.parse(body.toString('utf8'))
+  const items = doc?.result?.value?.items
+  if (!Array.isArray(items)) return null
+  doc.result.value.items = items.map((row) => {
+    const v = row?.projections?.values ?? row?.projections ?? {}
+    return {
+      sessionId: row.sessionId,
+      updatedAt: row.updatedAt,
+      running: row.running,
+      blank: row.blank,
+      origin: row.origin,
+      cwd: row.cwd,
+      projections: {
+        values: {
+          title: v.title,
+          permissions: v.permissions,
+          modelSelection: v.modelSelection,
+        },
+      },
+    }
+  })
+  return Buffer.from(JSON.stringify(doc), 'utf8')
+}
+
+/**
+ * Start the bridge.
+ *
+ * @param {object} options
+ * @param {number} options.listenPort
+ * @param {string} options.authority
+ * @param {{resolve: (force?: boolean) => Promise<number>, invalidate: () => void}} options.upstream
+ * @param {(msg: string) => void} [options.log]
+ * @returns {Promise<{close: () => Promise<void>, port: number}>}
+ */
+export function startBridge({ listenPort, authority, upstream, log = () => {} }) {
+  const forward = (req, res, attempt = 0) =>
+    new Promise((resolve) => {
+      upstream.resolve(attempt > 0).then((port) => {
+        if (!port) {
+          res.writeHead(502)
+          res.end('dsh-remote: no upstream found (is the DSH host running?)')
+          return resolve()
+        }
+        const headers = rewriteHeaders(req.headers, authority)
+        // DSH gzips on its own when it sees Accept-Encoding; the list needs plain JSON so it can
+        // be trimmed and re-compressed here.
+        const isList = req.url === LIST_PATH
+        if (isList) delete headers['accept-encoding']
+
+        const up = http.request({ host: '127.0.0.1', port, path: req.url, method: req.method, headers }, (r) => {
+          if (r.statusCode >= 500 && attempt === 0) {
+            r.resume()
+            upstream.invalidate()
+            return forward(req, res, attempt + 1).then(resolve)
+          }
+          const contentType = String(r.headers['content-type'] || '')
+          const clientWantsGzip = /gzip/i.test(String(req.headers['accept-encoding'] || ''))
+          const canRewrite = isList && r.statusCode === 200 && !r.headers['content-encoding']
+          if (!canRewrite || !/json/i.test(contentType)) {
+            res.writeHead(r.statusCode, { ...r.headers, 'x-dsh-remote-bridge': '1' })
+            r.pipe(res)
+            r.on('end', resolve)
+            return
+          }
+          const chunks = []
+          r.on('data', (c) => chunks.push(c))
+          r.on('end', () => {
+            const headersOut = { ...r.headers }
+            let body = Buffer.concat(chunks)
+            try {
+              const trimmed = trimSessionList(body)
+              if (trimmed) {
+                body = trimmed
+                delete headersOut['content-length']
+              }
+            } catch {
+              /* unexpected shape: pass the original body through */
+            }
+            headersOut['x-dsh-remote-bridge'] = '1'
+            if (clientWantsGzip && body.length >= 2048) {
+              const gz = zlib.gzipSync(body, { level: 6 })
+              headersOut['content-encoding'] = 'gzip'
+              headersOut['content-length'] = String(gz.length)
+              delete headersOut['transfer-encoding']
+              res.writeHead(r.statusCode, headersOut)
+              res.end(gz)
+            } else {
+              res.writeHead(r.statusCode, headersOut)
+              res.end(body)
+            }
+            resolve()
+          })
+          r.on('error', () => {
+            try {
+              res.destroy()
+            } catch {}
+            resolve()
+          })
+        })
+        up.on('error', () => {
+          if (attempt === 0) {
+            upstream.invalidate()
+            return forward(req, res, attempt + 1).then(resolve)
+          }
+          try {
+            res.writeHead(502)
+            res.end('dsh-remote: upstream unavailable')
+          } catch {}
+          resolve()
+        })
+        req.pipe(up)
+      })
+    })
+
+  const server = http.createServer((req, res) => {
+    forward(req, res).catch(() => {
+      try {
+        res.writeHead(502)
+        res.end('dsh-remote: internal error')
+      } catch {}
+    })
+  })
+
+  // WebSocket upgrades (session/follow) need the same Host rewrite, done by hand: a raw socket
+  // tunnel cannot reuse `http.request`.
+  server.on('upgrade', (req, socket, head) => {
+    upstream.resolve().then((port) => {
+      if (!port) {
+        socket.destroy()
+        return
+      }
+      const up = net.connect(port, '127.0.0.1', () => {
+        const headers = rewriteHeaders({ ...req.headers, connection: 'Upgrade', upgrade: req.headers.upgrade }, authority)
+        const lines = [
+          `GET ${req.url} HTTP/1.1`,
+          ...Object.entries(headers).map(([k, v]) => `${k}: ${Array.isArray(v) ? v.join(', ') : v}`),
+          '',
+          '',
+        ]
+        up.write(lines.join('\r\n'))
+        if (head?.length) up.write(head)
+        up.pipe(socket)
+        socket.pipe(up)
+      })
+      up.on('error', () => socket.destroy())
+      socket.on('error', () => up.destroy())
+    })
+  })
+
+  return new Promise((resolve, reject) => {
+    server.once('error', reject)
+    server.listen(listenPort, '0.0.0.0', () => {
+      server.removeListener('error', reject)
+      log(`bridge listening on 0.0.0.0:${listenPort} (Host: ${authority})`)
+      resolve({
+        port: listenPort,
+        close: () =>
+          new Promise((done) => {
+            server.close(() => done())
+            // `close` waits for keep-alive sockets; drop them so shutdown is prompt.
+            server.closeAllConnections?.()
+          }),
+      })
+    })
+  })
+}

package/lib/cookie.js

@@ -0,0 +1,81 @@
+/**
+ * Cookie minting: sign a `dsh-auth-*` v1 cookie for an authority using the DSH install's own
+ * browser-session secret.
+ *
+ * Why this works without the launch token: DSH verifies the HMAC and `expiresAt`, and the
+ * authority is part of the signed body. Since the bridge always presents a fixed Host, one
+ * cookie keeps working across host restarts and across every transport (LAN / tunnel / proxy).
+ *
+ * @module lib/cookie
+ */
+
+import fs from 'node:fs'
+import os from 'node:os'
+import path from 'node:path'
+import { createHash, createHmac } from 'node:crypto'
+
+/** Path of the credentials file that holds the signing secret. */
+export function credentialsPath() {
+  return path.join(os.homedir(), '.dsh', '.credentials.yaml')
+}
+
+/**
+ * Read `client-connection/browser-session: secret` out of the credentials YAML.
+ *
+ * The file is small and machine-generated, so a targeted line scan beats pulling a YAML
+ * dependency into the plugin.
+ */
+export function readSigningSecret(file = credentialsPath()) {
+  let text
+  try {
+    text = fs.readFileSync(file, 'utf8')
+  } catch {
+    throw new Error(`cannot read DSH credentials at ${file}`)
+  }
+  const lines = text.split(/\r?\n/)
+  for (let i = 0; i < lines.length; i++) {
+    if (!/client-connection\/browser-session:/.test(lines[i])) continue
+    for (let j = i; j < Math.min(i + 8, lines.length); j++) {
+      const m = lines[j].match(/^\s*secret:\s*(\S+)\s*$/)
+      if (m) return m[1]
+    }
+  }
+  throw new Error(`no browser-session signing secret in ${file} (open DSH once, then retry)`)
+}
+
+const b64 = (buf) => Buffer.from(buf).toString('base64').replace(/\+/g, '-').replace(/\//g, '_').replace(/=+$/, '')
+
+/**
+ * Mint a signed cookie for `authority`.
+ *
+ * @param {string} authority  Host authority the bridge presents, e.g. `127.0.0.1:1815`
+ * @param {object} [options]
+ * @param {number} [options.days=30]  validity window
+ * @param {string} [options.secret]   pre-read secret (avoids re-reading the file)
+ * @returns {{cookie: string, issuedAt: number, expiresAt: number}}
+ */
+export function mintCookie(authority, options = {}) {
+  if (!authority) throw new Error('authority is required')
+  const days = Number(options.days ?? 30)
+  if (!Number.isFinite(days) || days <= 0) throw new Error('days must be a positive number')
+  const secret = options.secret ?? readSigningSecret()
+  const now = Date.now()
+  const expiresAt = now + days * 24 * 3600 * 1000
+  const body = b64(JSON.stringify({ version: 1, authority, issuedAt: now, expiresAt }))
+  const sig = b64(createHmac('sha256', Buffer.from(secret, 'base64url')).update(body).digest())
+  const name = 'dsh-auth-' + b64(createHash('sha256').update(authority).digest())
+  return { cookie: `${name}=v1.${body}.${sig}`, issuedAt: now, expiresAt }
+}
+
+/** Decode the `expiresAt` carried inside a minted cookie, for status reporting. */
+export function cookieExpiry(cookie) {
+  const m = /\.v1\.([^.]+)\./.exec(String(cookie))
+  if (!m) return null
+  try {
+    const json = Buffer.from(m[1].replace(/-/g, '+').replace(/_/g, '/'), 'base64').toString('utf8')
+    const parsed = JSON.parse(json)
+    return Number.isFinite(parsed?.expiresAt) ? parsed.expiresAt : null
+  } catch {
+    return null
+  }
+}

package/lib/discover.js

@@ -0,0 +1,166 @@
+/**
+ * Find the DSH host's HTTP port.
+ *
+ * The desktop host listens on a **different port every restart** (observed 1815, 5894, 14299,
+ * 8312, 12077), so the port cannot be configured once and forgotten. It also shares the machine
+ * with the inspector and other loopback services, so "the port is listening" is not enough —
+ * only the real web server answers our authenticated RPC.
+ *
+ * Strategy: enumerate local listening ports, then probe each with the signed cookie and the
+ * authority the bridge presents. First 200 wins. Results are cached with a TTL so a host restart
+ * is picked up on the next failure instead of pinning a dead port forever.
+ *
+ * @module lib/discover
+ */
+
+import http from 'node:http'
+import { execFile } from 'node:child_process'
+
+const PROBE_TIMEOUT_MS = 1500
+const PROBE_PATH = '/api/session/list'
+const PROBE_BODY = JSON.stringify({
+  type: 'client-request',
+  rpcId: 'probe',
+  method: 'session/list',
+  payload: { args: { _request: {} } },
+})
+
+function run(cmd, args, timeout = 8000) {
+  return new Promise((resolve) => {
+    execFile(cmd, args, { timeout, windowsHide: true }, (err, stdout) => {
+      resolve(err ? '' : String(stdout))
+    })
+  })
+}
+
+/** Local TCP ports currently in LISTEN state. */
+export async function listeningPorts() {
+  const ports = new Set()
+  if (process.platform === 'win32') {
+    const out = await run('netstat', ['-ano', '-p', 'tcp'])
+    for (const line of out.split(/\r?\n/)) {
+      const m = /^\s*TCP\s+(\S+):(\d+)\s+\S+\s+LISTENING\s+(\d+)/i.exec(line)
+      if (!m) continue
+      const addr = m[1]
+      const port = Number(m[2])
+      if (!Number.isInteger(port) || port <= 0) continue
+      if (addr !== '127.0.0.1' && addr !== '0.0.0.0' && addr !== '[::]' && addr !== '[::1]') continue
+      ports.add(port)
+    }
+    return [...ports]
+  }
+  // macOS / Linux
+  const ss = await run('ss', ['-ltn'])
+  if (ss) {
+    for (const line of ss.split(/\r?\n/)) {
+      const m = /\s(?:\S*):(\d+)\s/.exec(` ${line} `)
+      if (m) ports.add(Number(m[1]))
+    }
+  }
+  if (ports.size === 0) {
+    const lsof = await run('lsof', ['-nP', '-iTCP', '-sTCP:LISTEN'])
+    for (const line of lsof.split(/\r?\n/)) {
+      const m = /:(\d+)\s+\(LISTEN\)/.exec(line)
+      if (m) ports.add(Number(m[1]))
+    }
+  }
+  return [...ports].filter((p) => Number.isInteger(p) && p > 0)
+}
+
+/** Does `port` answer the authenticated DSH RPC? */
+export function probePort(port, { authority, cookie }) {
+  return new Promise((resolve) => {
+    const req = http.request(
+      {
+        host: '127.0.0.1',
+        port,
+        path: PROBE_PATH,
+        method: 'POST',
+        timeout: PROBE_TIMEOUT_MS,
+        headers: {
+          'content-type': 'application/json',
+          'content-length': Buffer.byteLength(PROBE_BODY),
+          host: authority,
+          cookie,
+        },
+      },
+      (res) => {
+        // Another dsh-remote bridge also answers our RPC (it forwards to the real host); treating
+        // it as upstream would chain bridges, so tagged responses are rejected.
+        const isBridge = res.headers['x-dsh-remote-bridge'] === '1'
+        res.resume()
+        resolve(res.statusCode === 200 && !isBridge)
+      },
+    )
+    req.on('error', () => resolve(false))
+    req.on('timeout', () => {
+      req.destroy()
+      resolve(false)
+    })
+    req.write(PROBE_BODY)
+    req.end()
+  })
+}
+
+/**
+ * A resolver that remembers the last known-good port.
+ *
+ * @param {object} options
+ * @param {string} options.authority
+ * @param {() => Promise<string>|string} options.cookie  current cookie (may be re-minted)
+ * @param {number} [options.pinned=0]                    skip discovery when > 0
+ * @param {number} [options.ttlMs=30000]
+ */
+export function createDiscovery({ authority, cookie, pinned = 0, ttlMs = 30_000, exclude = [] }) {
+  let port = pinned || 0
+  let resolvedAt = 0
+  let inFlight = null
+
+  async function resolveCookie() {
+    try {
+      return await cookie()
+    } catch {
+      return ''
+    }
+  }
+
+  async function resolve(force = false) {
+    if (pinned) return pinned
+    if (!force && port && Date.now() - resolvedAt < ttlMs) return port
+    if (inFlight) return inFlight
+    inFlight = (async () => {
+      const ck = await resolveCookie()
+      if (!ck) return port
+      const skip = new Set(exclude.filter((p) => Number.isInteger(p) && p > 0))
+      const ports = (await listeningPorts()).filter((p) => !skip.has(p))
+      // Probe the remembered port first: it is usually still right and saves a full sweep.
+      const ordered = port && ports.includes(port) ? [port, ...ports.filter((p) => p !== port)] : ports
+      for (const candidate of ordered) {
+        // eslint-disable-next-line no-await-in-loop
+        if (await probePort(candidate, { authority, cookie: ck })) {
+          port = candidate
+          resolvedAt = Date.now()
+          return port
+        }
+      }
+      return port
+    })()
+    try {
+      return await inFlight
+    } finally {
+      inFlight = null
+    }
+  }
+
+  return {
+    resolve,
+    get port() {
+      return port
+    },
+    /** Forget the cached port so the next `resolve()` sweeps again. */
+    invalidate() {
+      if (pinned) return
+      resolvedAt = 0
+    },
+  }
+}

package/lib/index.js

@@ -0,0 +1,62 @@
+/**
+ * dsh-remote — Host-side plugin that makes the DSH host reachable from the DSH Remote app.
+ *
+ * `apply()` starts three long-lived things inside the host process:
+ *   1. a bridge that rewrites Host to a fixed authority (so one signed cookie stays valid),
+ *   2. a tunnel (ngrok if present, otherwise an auto-downloaded cloudflared quick tunnel),
+ *   3. a status file with the LAN URL, public URL and a freshly minted 30-day cookie.
+ *
+ * Everything is torn down when the plugin is disposed, so disabling it in the profile leaves no
+ * orphan listeners or child processes behind.
+ *
+ * @module lib/index
+ */
+
+import { start } from './supervisor.js'
+
+export const name = 'dsh-remote-hub'
+
+export const version = '0.1.0'
+
+/** No host services are required: the plugin only needs Node builtins. */
+export const inject = []
+
+/**
+ * @param {object} ctx  cordis plugin context
+ * @param {object} [config]  see cordis.patch.yml
+ */
+export function apply(ctx, config = {}) {
+  const log = (msg) => {
+    try {
+      if (typeof ctx?.logger?.info === 'function') ctx.logger.info(msg)
+      else console.log(msg)
+    } catch {
+      /* logging must never break startup */
+    }
+  }
+
+  let closed = false
+  /** @type {{close: () => Promise<void>} | null} */
+  let handle = null
+
+  const dispose = async () => {
+    if (closed) return
+    closed = true
+    try {
+      await handle?.close()
+    } catch (err) {
+      log(`dsh-remote: shutdown failed: ${err?.message ?? err}`)
+    }
+  }
+
+  start({ ...config, log })
+    .then((started) => {
+      handle = started
+      if (closed) return handle.close()
+      return undefined
+    })
+    .catch((err) => log(`dsh-remote: startup failed: ${err?.message ?? err}`))
+
+  // cordis accepts a disposer as the return value of apply().
+  return dispose
+}

package/lib/supervisor.js

@@ -0,0 +1,206 @@
+/**
+ * Supervisor: cookie + discovery + bridge + tunnel, and the status file the app/CLI reads.
+ *
+ * Everything it produces lives under `~/.dsh/dsh-remote/`:
+ *   status.json  machine-readable (the CLI and the Android app's "pair" flow read this)
+ *   connect.txt  human-readable, the two lines you copy into the phone
+ *   dsh-remote.log  rolling log
+ *
+ * @module lib/supervisor
+ */
+
+import fs from 'node:fs'
+import os from 'node:os'
+import path from 'node:path'
+
+import { startBridge } from './bridge.js'
+import { cookieExpiry, mintCookie } from './cookie.js'
+import { createDiscovery } from './discover.js'
+import { startTunnel } from './tunnel.js'
+
+export const DATA_DIR = path.join(os.homedir(), '.dsh', 'dsh-remote')
+export const STATUS_FILE = path.join(DATA_DIR, 'status.json')
+export const CONNECT_FILE = path.join(DATA_DIR, 'connect.txt')
+export const LOG_FILE = path.join(DATA_DIR, 'dsh-remote.log')
+
+function ensureDir() {
+  fs.mkdirSync(DATA_DIR, { recursive: true })
+}
+
+function appendLog(line) {
+  try {
+    ensureDir()
+    fs.appendFileSync(LOG_FILE, `${new Date().toISOString()} ${line}\n`, 'utf8')
+  } catch {}
+}
+
+/**
+ * LAN address a phone on the same network can reach.
+ *
+ * VMs and container runtimes add private adapters (WSL/vEthernet 172.x, Docker, VMware, ...) that
+ * a phone on the Wi-Fi cannot route to, so real 192.168/10.x interfaces are ranked first and the
+ * virtual ones are penalised by name.
+ */
+export function lanAddress() {
+  const nets = os.networkInterfaces()
+  const VIRTUAL = /vEthernet|WSL|Docker|Hyper-V|VMware|VirtualBox|Loopback|Tunnel|Tailscale|ZeroTier/i
+  const scored = []
+  for (const [name, addrs] of Object.entries(nets)) {
+    for (const a of addrs || []) {
+      if (a.family !== 'IPv4' || a.internal) continue
+      const isPrivate = /^192\.168\.|^10\.|^172\.(1[6-9]|2\d|3[01])\./.test(a.address)
+      if (!isPrivate) continue
+      let score = 0
+      if (/^192\.168\./.test(a.address)) score += 40
+      else if (/^10\./.test(a.address)) score += 20
+      else score += 5 // 172.16/12 is dominated by virtual adapters in practice
+      if (/wi-?fi|wlan|WLAN|en0|Ethernet|以太网/i.test(name)) score += 10
+      if (VIRTUAL.test(name)) score -= 60
+      scored.push({ name, address: a.address, score })
+    }
+  }
+  scored.sort((a, b) => b.score - a.score)
+  const best = scored[0]
+  return best && best.score > 0 ? best.address : (best?.address ?? null)
+}
+
+/** Read the status file written by a previous run, or null. */
+export function readStatus() {
+  try {
+    return JSON.parse(fs.readFileSync(STATUS_FILE, 'utf8'))
+  } catch {
+    return null
+  }
+}
+
+function writeStatus(status) {
+  ensureDir()
+  fs.writeFileSync(STATUS_FILE, JSON.stringify(status, null, 2), 'utf8')
+  const lines = [
+    '',
+    '=======================  填进手机 App  =======================',
+    '',
+    '【同一 WiFi】DSH 地址:',
+    `    ${status.lan.url ?? '(未检测到局域网 IP)'}`,
+    '',
+  ]
+  if (status.public?.url) {
+    lines.push('【人在外面】DSH 地址:', `    ${status.public.url}`, '')
+  } else if (status.public?.note) {
+    lines.push('【人在外面】不可用：', `    ${status.public.note}`, '')
+  }
+  lines.push(
+    '【Cookie】粘到 App 的 Cookie 框（30 天有效）:',
+    `    ${status.cookie ?? '(未生成)'}`,
+    '',
+    '电脑端保持 DSH 运行；关闭 = 手机断开。',
+    '==============================================================',
+    '',
+  )
+  fs.writeFileSync(CONNECT_FILE, lines.join(os.EOL), 'utf8')
+}
+
+/**
+ * Start everything.
+ *
+ * @param {object} config
+ * @param {boolean} [config.enabled=true]
+ * @param {number} [config.port=6300]
+ * @param {string} [config.authority='127.0.0.1:1815']
+ * @param {'auto'|'off'|'ngrok'|'cloudflared'} [config.tunnel='auto']
+ * @param {number} [config.upstreamPort=0]
+ * @param {string} [config.domain='']
+ * @param {(msg: string) => void} [config.log]
+ */
+export async function start(config = {}) {
+  const {
+    enabled = true,
+    port = 6300,
+    authority = '127.0.0.1:1815',
+    tunnel: tunnelKind = 'auto',
+    upstreamPort = 0,
+    domain = '',
+    log = appendLog,
+  } = config
+
+  if (!enabled) {
+    log('dsh-remote: disabled by config, nothing started')
+    return { status: null, close: async () => {} }
+  }
+
+  let cookie
+  let expiresAt
+  try {
+    const minted = mintCookie(authority, { days: 30 })
+    cookie = minted.cookie
+    expiresAt = minted.expiresAt
+  } catch (err) {
+    log(`dsh-remote: cannot mint cookie: ${err.message}`)
+    const status = {
+      updatedAt: Date.now(),
+      error: `cookie: ${err.message}`,
+      lan: { url: null, ip: lanAddress() },
+      public: { url: null, kind: 'none', note: 'no cookie — open DSH once, then restart' },
+      cookie: null,
+    }
+    writeStatus(status)
+    return { status, close: async () => {} }
+  }
+
+  // The bridge listens on `port`; probing it would forward to itself, so it must be excluded
+  // from upstream discovery.
+  const discovery = createDiscovery({
+    authority,
+    cookie: () => cookie,
+    pinned: Number(upstreamPort) || 0,
+    exclude: [Number(port) || 6300],
+  })
+  const initialPort = await discovery.resolve(true)
+  if (initialPort) log(`dsh-remote: upstream host on 127.0.0.1:${initialPort}`)
+  else log('dsh-remote: no upstream host found yet; the bridge will keep retrying')
+
+  const bridge = await startBridge({
+    listenPort: Number(port) || 6300,
+    authority,
+    upstream: discovery,
+    log,
+  })
+
+  const tunnel = await startTunnel({
+    kind: tunnelKind,
+    bridgePort: bridge.port,
+    authority,
+    domain,
+    log,
+  })
+
+  const ip = lanAddress()
+  const status = {
+    updatedAt: Date.now(),
+    bridgePort: bridge.port,
+    authority,
+    upstreamPort: discovery.port || null,
+    lan: { ip, url: ip ? `http://${ip}:${bridge.port}` : null },
+    public: { url: tunnel.publicUrl, kind: tunnel.kind, ...(tunnel.note ? { note: tunnel.note } : {}) },
+    cookie,
+    cookieExpiresAt: expiresAt ?? cookieExpiry(cookie),
+  }
+  writeStatus(status)
+
+  log(`dsh-remote: LAN  ${status.lan.url ?? '(no private IPv4)'}`)
+  log(`dsh-remote: WAN  ${status.public.url ?? `(none — ${status.public.note ?? tunnelKind})`}`)
+  log(`dsh-remote: status written to ${STATUS_FILE}`)
+
+  return {
+    status,
+    close: async () => {
+      try {
+        tunnel.close()
+      } catch {}
+      try {
+        await bridge.close()
+      } catch {}
+      log('dsh-remote: stopped')
+    },
+  }
+}

package/lib/tunnel.js

@@ -0,0 +1,199 @@
+/**
+ * Tunnel management: put the local bridge on a public URL.
+ *
+ * Order of preference:
+ *   1. `ngrok` — a stable, account-backed domain. Detected on PATH and in the usual install dirs;
+ *      the authtoken must already be configured (`ngrok config add-authtoken`).
+ *   2. `cloudflared` — account-less quick tunnel. Auto-downloaded from a mirror chain when missing,
+ *      and every download is verified by Authenticode (`Cloudflare, Inc.`) before it is used:
+ *      a mirror can hand back anything, but it cannot forge Cloudflare's signature.
+ *   3. No tunnel — the LAN URL still works, so this is a warning, never a hard failure.
+ *
+ * @module lib/tunnel
+ */
+
+import fs from 'node:fs'
+import os from 'node:os'
+import path from 'node:path'
+import { spawn, execFile, execFileSync } from 'node:child_process'
+
+const DATA_DIR = path.join(os.homedir(), '.dsh', 'dsh-remote')
+const CLOUDFLARED_EXE = path.join(DATA_DIR, process.platform === 'win32' ? 'cloudflared.exe' : 'cloudflared')
+const URL_RE = /https:\/\/[a-z0-9][a-z0-9-]*\.(?:trycloudflare\.com|ngrok-free\.(?:dev|app)|ngrok\.(?:io|app))/i
+
+const CLOUDFLARED_URLS = [
+  'https://ghfast.top/https://github.com/cloudflare/cloudflared/releases/latest/download/cloudflared-windows-amd64.exe',
+  'https://github.com/cloudflare/cloudflared/releases/latest/download/cloudflared-windows-amd64.exe',
+  'https://gh-proxy.com/https://github.com/cloudflare/cloudflared/releases/latest/download/cloudflared-windows-amd64.exe',
+]
+
+function exists(p) {
+  try {
+    return fs.existsSync(p)
+  } catch {
+    return false
+  }
+}
+
+/** Resolve a command name to an absolute path, or null. */
+function which(cmd) {
+  try {
+    const out = execFileSync(process.platform === 'win32' ? 'where' : 'which', [cmd], {
+      timeout: 5000,
+      windowsHide: true,
+      encoding: 'utf8',
+      stdio: ['ignore', 'pipe', 'ignore'],
+    })
+    const first = String(out)
+      .split(String.fromCharCode(10))
+      .map((l) => l.trim())
+      .filter(Boolean)[0]
+    return first || null
+  } catch {
+    return null
+  }
+}
+
+/** Locate an installed tunel binary, or null. */
+export function findNgrok() {
+  const candidates = [
+    process.platform === 'win32' ? path.join(process.env.LOCALAPPDATA || '', 'ngrok', 'ngrok.exe') : null,
+    path.join(DATA_DIR, process.platform === 'win32' ? 'ngrok.exe' : 'ngrok'),
+    process.platform === 'win32' ? 'ngrok.exe' : 'ngrok',
+  ].filter(Boolean)
+  for (const c of candidates) {
+    if (exists(c)) return c
+  }
+  const onPath = which('ngrok')
+  return onPath && exists(onPath) ? onPath : null
+}
+
+export function findCloudflared() {
+  const candidates = [CLOUDFLARED_EXE, path.join(DATA_DIR, 'cloudflared.exe')]
+  for (const c of candidates) {
+    if (exists(c)) return c
+  }
+  const onPath = which('cloudflared')
+  return onPath && exists(onPath) ? onPath : null
+}
+
+/** Does the binary carry a valid Authenticode signature from Cloudflare, Inc.? */
+export async function verifyCloudflaredSignature(exePath) {
+  if (process.platform !== 'win32') return true // signed differently (or not at all) off Windows
+  const script =
+    `$s = Get-AuthenticodeSignature -FilePath '${exePath.replace(/'/g, "''")}';` +
+    `if ($s.Status -ne 'Valid') { 'INVALID' } else { $s.SignerCertificate.Subject }`
+  const out = await new Promise((resolve) => {
+    execFile('powershell', ['-NoProfile', '-NonInteractive', '-Command', script], { timeout: 30_000, windowsHide: true }, (err, stdout) => {
+      resolve(err ? '' : String(stdout).trim())
+    })
+  })
+  if (!out || out === 'INVALID') return false
+  return /Cloudflare/i.test(out) && /Inc/i.test(out)
+}
+
+async function downloadFile(url, dest) {
+  const res = await fetch(url, { redirect: 'follow' })
+  if (!res.ok) throw new Error(`HTTP ${res.status}`)
+  const buf = Buffer.from(await res.arrayBuffer())
+  if (buf.length < 20 * 1024 * 1024) throw new Error(`suspiciously small (${buf.length} bytes)`)
+  fs.writeFileSync(dest, buf)
+  return buf.length
+}
+
+/** Download cloudflared (mirror chain) and verify its signature. Returns the path or null. */
+export async function ensureCloudflared({ log = () => {} } = {}) {
+  const existing = findCloudflared()
+  if (existing) return existing
+  fs.mkdirSync(DATA_DIR, { recursive: true })
+  for (const url of CLOUDFLARED_URLS) {
+    log(`downloading cloudflared from ${url}`)
+    try {
+      // eslint-disable-next-line no-await-in-loop
+      await downloadFile(url, CLOUDFLARED_EXE)
+      // eslint-disable-next-line no-await-in-loop
+      if (await verifyCloudflaredSignature(CLOUDFLARED_EXE)) {
+        log('cloudflared downloaded and signature verified (Cloudflare, Inc.)')
+        return CLOUDFLARED_EXE
+      }
+      log('cloudflared signature check failed, discarding and trying the next source')
+      fs.rmSync(CLOUDFLARED_EXE, { force: true })
+    } catch (err) {
+      log(`cloudflared download failed: ${err.message}`)
+      fs.rmSync(CLOUDFLARED_EXE, { force: true })
+    }
+  }
+  return null
+}
+
+/**
+ * Spawn a tunnel and resolve its public URL.
+ *
+ * @param {object} options
+ * @param {'auto'|'off'|'ngrok'|'cloudflared'} [options.kind='auto']
+ * @param {number} options.bridgePort
+ * @param {string} options.authority
+ * @param {string} [options.domain]   pinned ngrok domain (e.g. xxxx.ngrok-free.app)
+ * @param {(msg: string) => void} [options.log]
+ * @returns {Promise<{publicUrl: string|null, kind: string, close: () => void, note?: string}>}
+ */
+export async function startTunnel({ kind = 'auto', bridgePort, authority, domain = '', log = () => {} }) {
+  if (kind === 'off') return { publicUrl: null, kind: 'none', close: () => {}, note: 'tunnel disabled by config' }
+
+  const wantNgrok = kind === 'auto' || kind === 'ngrok'
+  const wantCloudflared = kind === 'auto' || kind === 'cloudflared'
+
+  if (wantNgrok) {
+    const ngrok = findNgrok()
+    if (ngrok) {
+      const args = ['http', String(bridgePort), '--host-header', authority, '--log', 'stdout', '--log-format', 'json']
+      if (domain) args.push('--url', domain)
+      const child = spawn(ngrok, args, { windowsHide: true, stdio: ['ignore', 'pipe', 'pipe'] })
+      const url = await waitForUrl(child, 45_000)
+      if (url) return { publicUrl: url, kind: 'ngrok', close: () => child.kill() }
+      child.kill()
+      log('ngrok started but produced no URL (authtoken configured?)')
+      if (kind === 'ngrok') return { publicUrl: null, kind: 'none', close: () => {}, note: 'ngrok produced no URL' }
+    } else if (kind === 'ngrok') {
+      return { publicUrl: null, kind: 'none', close: () => {}, note: 'ngrok not installed' }
+    }
+  }
+
+  if (wantCloudflared) {
+    const cf = await ensureCloudflared({ log })
+    if (cf) {
+      const child = spawn(cf, ['tunnel', '--url', `http://127.0.0.1:${bridgePort}`, '--no-autoupdate'], {
+        windowsHide: true,
+        stdio: ['ignore', 'pipe', 'pipe'],
+      })
+      const url = await waitForUrl(child, 60_000)
+      if (url) return { publicUrl: url, kind: 'cloudflared', close: () => child.kill() }
+      child.kill()
+      log('cloudflared started but produced no URL (api.trycloudflare.com reachable?)')
+      return { publicUrl: null, kind: 'none', close: () => {}, note: 'cloudflared produced no URL (network may block it)' }
+    }
+    return { publicUrl: null, kind: 'none', close: () => {}, note: 'could not obtain cloudflared' }
+  }
+
+  return { publicUrl: null, kind: 'none', close: () => {} }
+}
+
+function waitForUrl(child, timeoutMs) {
+  return new Promise((resolve) => {
+    let done = false
+    const finish = (url) => {
+      if (done) return
+      done = true
+      clearTimeout(timer)
+      resolve(url)
+    }
+    const scan = (buf) => {
+      const m = URL_RE.exec(String(buf))
+      if (m) finish(m[0])
+    }
+    child.stdout?.on('data', scan)
+    child.stderr?.on('data', scan)
+    child.on('exit', () => finish(null))
+    const timer = setTimeout(() => finish(null), timeoutMs)
+  })
+}

package/package.json

@@ -1,6 +1,54 @@
 {
   "name": "dsh-remote-hub",
-  "version": "0.0.0-stage",
-  "stub": true,
-  "description": "Temporary package placeholder for staged publishing"
-}
+  "version": "0.1.0",
+  "description": "DSH 插件：把电脑上的 DeepSeek Harness 变成手机可访问的服务——起桥接、自动开隧道（ngrok / cloudflared）、签发 30 天 Cookie，并输出地址与凭据，配合 DSH Remote Android App 使用。",
+  "type": "module",
+  "main": "lib/index.js",
+  "bin": {
+    "dsh-remote": "bin/dsh-remote.mjs"
+  },
+  "exports": {
+    ".": "./lib/index.js",
+    "./package.json": "./package.json"
+  },
+  "files": [
+    "lib",
+    "bin",
+    "cordis.patch.yml",
+    "README.md",
+    "LICENSE"
+  ],
+  "keywords": [
+    "deepseek-harness",
+    "dsh",
+    "dsh-plugin",
+    "mobile",
+    "remote",
+    "tunnel",
+    "ngrok",
+    "cloudflared",
+    "android"
+  ],
+  "engines": {
+    "node": "^22.19.0 || >=24.0.0"
+  },
+  "license": "MIT",
+  "author": "liaoguogang-hub",
+  "repository": {
+    "type": "git",
+    "url": "git+https://github.com/liaoguogang-hub/dsh-remote-public.git"
+  },
+  "homepage": "https://github.com/liaoguogang-hub/dsh-remote-public",
+  "bugs": {
+    "url": "https://github.com/liaoguogang-hub/dsh-remote-public/issues"
+  },
+  "dsh": {
+    "bundle": {
+      "patch": "./cordis.patch.yml"
+    }
+  },
+  "publishConfig": {
+    "registry": "https://registry.npmjs.org",
+    "access": "public"
+  }
+}