dsh-pocket 2.10.2 → 2.10.4

package/README.en.md

@@ -133,7 +133,7 @@ Note: in named-tunnel mode the public PIN is **not auto-rotated** (the address i
 | Nothing changed after install/update | **You must restart `dsh web`**; the running process still loads the old code |
 | `listen EADDRINUSE ... :3081` | A stale dsh-pocket process holds the port: macOS/Linux `lsof -ti :3081 \| xargs kill -9`; Windows `netstat -ano \| findstr :3081` (find the LISTENING PID) → `taskkill /PID <PID> /F`, then retry |
 | Want a different port (issue #70) | Plugin mode: write `"proxyPort": 3082` into `$DSH_HOME/dsh-pocket/settings.json` and restart `dsh web`. CLI mode: `dsh-pocket --port 3082`. If the port is taken you'll get `EADDRINUSE` — kill the old process or pick another one |
-| Issue a temporary PIN to a guest (issue #69) | Settings → "Temporary access PINs" → pick public/LAN + duration (1h/24h/7d) + note → Create. Share the 8-char PIN + the access URL with the guest; it auto-expires and can be revoked manually. Temp PINs share the main PIN rate limit |
+| Issue a temporary PIN to a guest | Not available: the temporary access PIN feature (issue #69) was removed in 2.6.x (it crashed on revoke). To share access, send the main PIN or a `?token=<main PIN>` link, then hit "Refresh" in Settings once the guest is done |
 | cloudflared install fails on a remote Linux server (issue #45) | If all CDN sources (GitHub / ghproxy / gh.ddlc / gh-proxy) are unreachable on a remote Linux host, install `cloudflared` yourself (e.g. `apt install cloudflared`, `dnf install cloudflared`, or download the tgz and unpack it), then add `"cloudflaredPath": "/path/to/cloudflared"` into `$DSH_HOME/dsh-pocket/settings.json` and restart `dsh web`. The plugin will then use that binary directly and skip the auto-download |
 | Version stuck below 1.x | `^0.x` ranges never jump to 1.x: update with `--latest` (`dsh plugin --profile web update dsh-pocket --latest -w`) |
 | Public `error 1033` | See "Public tunnel troubleshooting" below — usually a local proxy/VPN (Clash etc. TUN mode) killing the tunnel |

package/README.md

@@ -118,6 +118,7 @@ npx @deepseek-ai/dsh web
 - **公网判定是 fail closed**（issue #66）：除本机（loopback）和局域网私网地址外，**一切陌生域名（包括你自建隧道/反向代理指向本机端口的固定域名）一律按公网处理、强制公网密码**——不存在「换域名绕过密码」的口子
 - 局域网模式不暴露公网，只有同一网络内的设备能访问
 - 适合个人自用；公网密码存本机 `$DSH_HOME/dsh-pocket/token`（默认每次开启公网自动换新，**自定义后不换**），局域网密码存 `$DSH_HOME/dsh-pocket/token-lan`（设置页手动刷新），开关/自定义标记存 `$DSH_HOME/dsh-pocket/settings.json`
+- **CLI 模式（命令行直跑 `dsh-pocket`）也有密码**（issue #90 修复前这条路是无认证的）：默认随机生成 8 位密码，打印在终端、并已内嵌进二维码（**扫码体验不变**），手动敲地址时需要填写，本机访问免密。`--pin <值>` 或 `DSH_POCKET_PIN=<值>` 自定义（至少 6 位）；`--no-auth` 可关闭，**不推荐**——那等于把能执行代码的 DSH 裸暴露给任何能连上该端口的人
 
 ## 💻 DSH Desktop（桌面版）
 
@@ -133,7 +134,7 @@ npx @deepseek-ai/dsh web
 | 装完/更新了但界面没变化 | **必须重启 `dsh web`** 才生效；运行中的进程仍加载旧代码 |
 | `listen EADDRINUSE ... :3081` | 旧 dsh-pocket 进程还占着端口：macOS/Linux `lsof -ti :3081 \| xargs kill -9`；Windows `netstat -ano \| findstr :3081`（找 LISTENING 的 PID）→ `taskkill /PID <PID> /F`，后重试 |
 | 想换端口（issue #70） | 插件模式：在 `$DSH_HOME/dsh-pocket/settings.json` 写 `"proxyPort": 3082` 后重启 `dsh web`。CLI 模式：`dsh-pocket --port 3082`。端口被占会报 `EADDRINUSE`，杀掉旧进程或换一个端口 |
-| 给访客一个临时 PIN（issue #69） | 设置页「临时访问 PIN」区块 → 选公网/局域网 + 时长（1h/24h/7d） + 备注 → 生成。把 8 位 PIN + 入口 URL 一起发给对方；过期自动作废，也能手动撤销。临时 PIN 与主 PIN 共用速率限制 |
+| 想给访客一个临时密码 | 暂不支持：issue #69 的「临时访问 PIN」功能已在 2.6.x 移除（撤销时会崩）。现在分享访问：把主密码或 `?token=<主密码>` 链接发给对方，用完在设置页点「刷新」换掉即可 |
 | Linux 服务器装不上 cloudflared（issue #45） | 远程 Linux 国内/企业网下所有 CDN 源（GitHub/ghproxy/gh.ddlc/gh-proxy）都连不上时：在服务器上手动装 `cloudflared`（如 `apt install cloudflared`、`dnf install cloudflared`、或下载 tgz 解压到任意目录），然后在 `$DSH_HOME/dsh-pocket/settings.json` 加 `"cloudflaredPath": "/path/to/cloudflared"`，重启 `dsh web` 后插件直接调用它，**不再走自动下载** |
 | 版本停在 0.x 升不上去 | `^0.x` 范围不允许升到 1.x：更新用 `--latest`（`dsh plugin --profile web update dsh-pocket --latest -w`） |
 | 公网 `error 1033` | 见下方「公网隧道常见问题」——多半是本机代理/VPN（Clash 等 TUN 模式）掐断了隧道 |

package/bin/dsh-pocket.mjs

@@ -10,24 +10,93 @@
 // 手机看到的界面 = 电脑上的界面，实时同步（WebSocket 流式透传）。
 
 import { networkInterfaces } from 'node:os';
+import { realpathSync } from 'node:fs';
+import { pathToFileURL } from 'node:url';
 import { createRequire } from 'node:module';
-import { createPocketProxy } from '../lib/proxy.mjs';
+import { randomBytes, randomInt } from 'node:crypto';
+import { createPocketProxy, classifyHost } from '../lib/proxy.mjs';
 import { startQuickTunnel } from '../lib/tunnel.mjs';
 
 const require = createRequire(import.meta.url);
 
-function parseArgs(argv) {
-  const args = { port: 3081, host: '0.0.0.0', public: false, upstream: { host: '127.0.0.1', port: 3080 } };
+/** 自定义密码的最短长度（issue #40：别让人设 `1234`）。 */
+export const MIN_PIN_LENGTH = 6;
+
+export function parseArgs(argv) {
+  const args = {
+    port: 3081,
+    host: '0.0.0.0',
+    public: false,
+    upstream: { host: '127.0.0.1', port: 3080 },
+    pin: null,
+    noAuth: false,
+  };
   for (let i = 0; i < argv.length; i++) {
     const a = argv[i];
     if (a === '--public') args.public = true;
     else if (a === '--port') args.port = Number(argv[++i]) || 3081;
     else if (a === '--host') args.host = argv[++i] ?? '0.0.0.0';
+    else if (a === '--pin') args.pin = String(argv[++i] ?? '');
+    else if (a === '--no-auth') args.noAuth = true;
     else if (a === '--help' || a === '-h') { printHelp(); process.exit(0); }
   }
   return args;
 }
 
+/**
+ * 决定本次运行用哪个访问密码（issue #90 第 8 条）。
+ *
+ * CLI 此前**完全不构造 auth**，且默认监听 `0.0.0.0`——任何能连到这个端口的人都能
+ * 直接操作 dsh web，而 dsh web 能在宿主机上执行任意代码。插件版一直有 PIN，
+ * 只有 CLI 这条路是裸的，属实是缺陷而非取舍。
+ *
+ * 修法上刻意**不改默认监听地址**：CLI 的主用法就是「手机连同一 WiFi 扫码」，
+ * 默认绑 loopback 等于把这个功能废掉。改成默认生成 PIN，并把它内嵌进二维码的
+ * `?token=` —— 扫码体验完全不变，手动敲地址的人才会看到登录页。
+ *
+ * 优先级：`--pin` > `DSH_POCKET_PIN` > CSPRNG 随机生成。
+ * @returns {{ pin: string|null, source: 'flag'|'env'|'generated'|'disabled', error?: string }}
+ */
+export function resolvePin({ pin = null, noAuth = false } = {}, env = {}) {
+  if (noAuth) return { pin: null, source: 'disabled' };
+  const explicit = pin != null && pin !== '' ? { value: String(pin), source: 'flag' }
+    : (env.DSH_POCKET_PIN ? { value: String(env.DSH_POCKET_PIN), source: 'env' } : null);
+  if (explicit) {
+    if (explicit.value.length < MIN_PIN_LENGTH) {
+      return {
+        pin: null,
+        source: explicit.source,
+        error: `访问密码至少 ${MIN_PIN_LENGTH} 位（当前 ${explicit.value.length} 位）。`
+          + `弱口令在公网上撑不过几分钟 | Access password must be at least ${MIN_PIN_LENGTH} characters.`,
+      };
+    }
+    return { pin: explicit.value, source: explicit.source };
+  }
+  return { pin: String(randomInt(10_000_000, 100_000_000)), source: 'generated' };
+}
+
+/**
+ * 构造给 createPocketProxy 的 auth（issue #90 第 8 条）。
+ * `isProtected` 与插件版语义保持一致：本机免密（能在本机直连本来就说明已经上了机器），
+ * 局域网与公网一律要密码。返回 null 表示不启用认证（`--no-auth`）。
+ */
+export function buildAuth(pin) {
+  if (!pin) return null;
+  return {
+    sessionKey: randomBytes(32).toString('hex'),
+    isProtected: (host) => classifyHost(host) !== 'loopback',
+    getToken: () => pin,
+  };
+}
+
+/** 把访问密码拼进入口 URL，让二维码扫了就能直达（与插件版一致）。 */
+export function entryUrl(base, pin) {
+  if (!pin) return base;
+  const u = new URL(base);
+  u.searchParams.set('token', pin);
+  return u.toString();
+}
+
 function printHelp() {
   console.log(`dsh-pocket — 手机访问电脑上的 DeepSeek Harness
 
@@ -35,11 +104,16 @@ function printHelp() {
   dsh-pocket             局域网模式（手机同一 WiFi）
   dsh-pocket --public    公网模式（cloudflared 隧道，人在外面）
   dsh-pocket --port 3081 自定义代理端口
+  dsh-pocket --host      自定义监听地址（默认 0.0.0.0）
+  dsh-pocket --pin <值>  自定义访问密码（至少 ${MIN_PIN_LENGTH} 位；也可用环境变量 DSH_POCKET_PIN）
+  dsh-pocket --no-auth   关闭访问密码（不推荐，见下）
   dsh-pocket --help      帮助
 
 前提：dsh web 已在 127.0.0.1:3080 运行（npx @deepseek-ai/dsh web）。
 
-安全提醒：dsh web 能执行代码。二维码/URL 就是钥匙，请勿发给别人。
+安全提醒：dsh web 能在这台机器上执行代码。默认会随机生成一个 8 位访问密码，
+二维码里已内嵌该密码（扫码直达），手动输入地址时需要填写。本机访问免密。
+--no-auth 会让任何能连到监听端口的人直接控制 dsh web，仅在完全可信的网络里用。
 `);
 }
 
@@ -63,12 +137,32 @@ function printQr(url, label) {
 async function main() {
   const args = parseArgs(process.argv.slice(2));
 
+  const resolved = resolvePin(args, process.env);
+  if (resolved.error) {
+    console.error(`❌ ${resolved.error}`);
+    process.exit(1);
+  }
+  const pin = resolved.pin;
+  const auth = buildAuth(pin);
+
   console.log('🚀 dsh-pocket 启动中…');
-  const { port, close } = await createPocketProxy(args);
+  const { port, close } = await createPocketProxy({ ...args, auth });
+
+  if (pin) {
+    console.log(`\n🔐 访问密码：${pin}${resolved.source === 'generated' ? '（本次随机生成）' : ''}`);
+    console.log('   二维码已内嵌密码，扫码直达；手动输入地址时需要填写。本机访问免密。');
+    if (resolved.source === 'generated') {
+      console.log(`   固定密码：--pin <值> 或 DSH_POCKET_PIN=<值>`);
+    }
+  } else {
+    console.log('\n⚠️  已用 --no-auth 关闭访问密码。');
+    console.log('   dsh web 能在这台机器上执行任意代码——现在任何能连到');
+    console.log(`   ${args.host}:${args.port} 的人都可以直接控制它。请仅在完全可信的网络里这样用。`);
+  }
 
   const lan = lanIPv4();
   if (lan) {
-    printQr(`http://${lan}:${port}`, '📶 局域网访问（手机连同一 WiFi）：');
+    printQr(entryUrl(`http://${lan}:${port}`, pin), '📶 局域网访问（手机连同一 WiFi）：');
   } else {
     console.log('⚠️  未检测到局域网 IP，跳过局域网二维码');
   }
@@ -90,7 +184,7 @@ async function main() {
     console.log('🌐 正在建立公网隧道（cloudflared）…');
     try {
       tunnel = await startQuickTunnel({ port, signal: controller.signal });
-      printQr(tunnel.url, '🌐 公网访问（人在外面也能用）：');
+      printQr(entryUrl(tunnel.url, pin), '🌐 公网访问（人在外面也能用）：');
       console.log('   隧道会持续运行；Ctrl+C 退出（下次启动会换新 URL）');
     } catch (err) {
       console.error(`❌ 公网隧道失败：${err.message}（局域网二维码仍可用）`);
@@ -103,7 +197,20 @@ async function main() {
   await new Promise(() => {});
 }
 
-main().catch((err) => {
-  console.error(`❌ dsh-pocket: ${err?.message ?? err}`);
-  process.exit(1);
-});
+// 只有被直接执行时才启动（测试里 import 本文件拿纯函数时不能把服务跑起来）。
+// npm 会把 bin 装成 symlink，argv[1] 是 symlink 路径而 import.meta.url 是真实路径，
+// 所以必须先 realpath 再比较，否则装完的 CLI 会变成什么都不做。
+const isDirectRun = (() => {
+  try {
+    return import.meta.url === pathToFileURL(realpathSync(process.argv[1] ?? '')).href;
+  } catch {
+    return false;
+  }
+})();
+
+if (isDirectRun) {
+  main().catch((err) => {
+    console.error(`❌ dsh-pocket: ${err?.message ?? err}`);
+    process.exit(1);
+  });
+}

package/client/client.js

@@ -1530,6 +1530,19 @@ var MOBILE_CSS = `
   }
 }
 
+/* ---------- mobile: stop iOS Safari forced zoom on input focus ----------
+ * Inputs are rendered with inline fontSize 13-14px, below the 16px threshold
+ * that makes iOS Safari zoom the whole page on focus (and never recover).
+ * Force the safe 16px minimum on narrow viewports only, so desktop keeps its
+ * tighter metrics. !important is required to beat the inline styles. */
+@media (max-width: 1024px) {
+  input,
+  textarea,
+  [contenteditable="true"] {
+    font-size: 16px !important;
+  }
+}
+
 /* ---------- desktop: the mobile controls must never appear ---------- */
 
 @media (min-width: 1024px) {

package/client/index.jsx

@@ -625,10 +625,10 @@ function PocketSettingsTab({ rpcCall, t }) {
 }
 
 export function apply(ctx) {
-  // 双保险：确保 connection.isLoopback 为 true（issue #58）。
-  // 主修复在代理注入的 loopback 补丁（proxy.mjs LOOPBACK_ENV_PATCH）——它在
-  // connection 模块 provide 时就改写句柄，早于 ui-settings 选择镜像模式；
-  // 这里兜底覆盖时序差异（若本插件 apply 晚于 ui-settings，则只能影响后续读者）。
+  // 兜底：确保 connection.isLoopback 为 true（issue #58）。
+  // 注：代理注入的 loopback 补丁（proxy.mjs LOOPBACK_ENV_PATCH）已在 #105 移除——
+  // 它与 DSH Desktop 2.0.4+ 客户端运行时不兼容，会令 BootHandoff 阶段白屏。
+  // #58「远程浏览器开设置页」需上游提供官方信任来源机制才能正经解决；此处仅保留兜底。
   if (ctx?.connection) {
     try {
       Object.defineProperty(ctx.connection, 'isLoopback', { value: true, writable: true, configurable: true });

package/client/mobile/mobile.css.ts

@@ -975,6 +975,19 @@ export const MOBILE_CSS = `
   }
 }
 
+/* ---------- mobile: stop iOS Safari forced zoom on input focus ----------
+ * Inputs are rendered with inline fontSize 13-14px, below the 16px threshold
+ * that makes iOS Safari zoom the whole page on focus (and never recover).
+ * Force the safe 16px minimum on narrow viewports only, so desktop keeps its
+ * tighter metrics. !important is required to beat the inline styles. */
+@media (max-width: 1024px) {
+  input,
+  textarea,
+  [contenteditable="true"] {
+    font-size: 16px !important;
+  }
+}
+
 /* ---------- desktop: the mobile controls must never appear ---------- */
 
 @media (min-width: 1024px) {

package/lib/index.js

@@ -210,7 +210,8 @@ async function consumeRestartNotice() {
 function pocketRestart(service) {
   const result = restartHost();
   if (!result || result.helperPid == null) return result; // helper 都没 spawn 出来 → 失败
-  try { service?.stopTunnel(); } catch { /* 忽略 */ }
+  // 停隧道是为了杀孤儿 cloudflared；保留自动恢复标记——重启后隧道要自动拉起（issue #11）
+  try { service?.stopTunnel({ keepAutoMarker: true }); } catch { /* 忽略 */ }
   writeRestartNotice().catch(() => {});
   return result;
 }

package/lib/proxy.mjs

@@ -35,6 +35,22 @@ export const RANDOM_UUID_POLYFILL = `<script data-dsh-pocket-polyfill="1">!funct
 导致会话列表不显示（实测 PAGEERROR: Identifier 'location' has already been declared）。
 已回退；该问题属 DSH 客户端限制（location.hostname 是 unforgeable 属性）无法安全绕过。*/</script>`;
 
+/**
+ * issue #96：dsh 0.1.1-rc.2 起，`@deepseek-ai/dsh-client-connection` 的连接层改成
+ *   const api = fixtureClient ?? transport?.createApiClient() ?? new WebApiClient()
+ * 其中 transport = globalThis.__DSH_TRANSPORT__（由 DSH 宿主 web shell 注入，本仓库
+ * 全程不创建、不引用这个全局）。桌面直连 127.0.0.1:3080 时宿主给的 transport 带
+ * createApiClient；经本代理（局域网 / 隧道域名）访问时宿主给的 transport 不带该方法
+ * → 手机上一执行就 TypeError: transport?.createApiClient is not a function，整页崩。
+ *
+ * 兜底策略：只在该方法缺失时补一个返回 null 的实现。null 会触发宿主自己那条
+ * `?? new WebApiClient()` 兜底分支，等于让连接层回到旧版本（0.1.1-rc.2 之前）的
+ * 行为。宿主自己有实现时一律不覆盖。
+ *
+ * 这是 stopgap 不是根治：真正的契约缺口在 DSH 宿主，需上游修复。
+ */
+export const TRANSPORT_API_CLIENT_SHIM = `<script data-dsh-pocket-transport-shim="1">!function(){try{var K='__DSH_TRANSPORT__',cur=globalThis[K];function patch(t){try{if(t&&typeof t==='object'&&typeof t.createApiClient!=='function'){try{Object.defineProperty(t,'createApiClient',{value:function(){return null;},writable:true,configurable:true});}catch(e){try{t.createApiClient=function(){return null;};}catch(e2){}}}}catch(e){}return t;}if(cur)patch(cur);Object.defineProperty(globalThis,K,{configurable:true,enumerable:true,get:function(){return cur;},set:function(t){cur=patch(t);}});}catch(e){}}();</script>`;
+
 const INJECT_MARK = 'data-dsh-pocket-polyfill="1"';
 
 /**
@@ -67,74 +83,10 @@ function isCompressed(headers) {
 }
 
 /**
- * DSH 客户端信任环境补丁（issue #58 的可行修法）：
- * 手机/局域网浏览器访问时 location.hostname 不是回环地址，dsh-client-connection 据此
- * 把 ctx.connection.isLoopback 判定为 false，dsh-client-ui-settings 便把 settings 镜像
- * 置为 memory 模式（不拉取 settings.describe），模型/通用设置页于是报
- * "settings are unavailable in this browser"（issue #58）。
- *
- * 与已回退的「全局 let location + Proxy」伪装方案不同，本补丁**不碰 location**——
- * 它包装 window.__ModuleLoader__，在 dsh-client-connection 模块向 Cordis 容器
- * provide('connection') 时把服务句柄的 isLoopback 强制为 true。经本代理（带 PIN 鉴权、
- * 请求头已回环化）的远程访问由此获得与本机一致的完整设置能力，会话列表回归不存在。
- *
- * 关键细节：HTML 只预加载 client-modules/client-runtime 两个 bundle（队列模式注册）；
- * connection 等插件 bundle 是 create() 启动后由加载器**动态**加载的，而 create() 会把
- * facade.load 整体替换为 live 注册函数。因此不能只包一次 load 函数——必须在 facade
- * 对象上把 load 装成访问器（getter/setter），每次赋值（队列→live 切换）都重新包装。
+ * 默认注入到经代理的 HTML 文档里：crypto.randomUUID / AbortSignal.any polyfill
+ * （非安全上下文必需）+ issue #96 的 transport.createApiClient 兜底。
  */
-const LOOPBACK_ENV_PATCH = `<script data-dsh-pocket-loopback-patch="1">!function(){try{
-var ml=window.__ModuleLoader__;
-function wrapFactory(h){
-  var of=h.factory;
-  h.factory=function(r){
-    var exp=of.apply(this,arguments);
-    if(exp&&typeof exp.apply==='function'){
-      var oa=exp.apply;
-      exp.apply=function(ctx){
-        var op=ctx&&ctx.provide;
-        if(typeof op==='function'){
-          ctx.provide=function(n,v){
-            if(n==='connection'&&v&&typeof v==='object'){
-              try{Object.defineProperty(v,'isLoopback',{value:true,writable:true,configurable:true});}catch(e){v.isLoopback=true;}
-            }
-            return op.apply(this,arguments);
-          };
-        }
-        return oa.apply(this,arguments);
-      };
-    }
-    return exp;
-  };
-}
-function wrapLoad(fn){
-  return function(h){
-    if(h&&h.id&&String(h.id).indexOf('connection')!==-1&&typeof h.factory==='function'){wrapFactory(h);}
-    return fn.call(this,h);
-  };
-}
-function wrapFacade(facade){
-  if(!facade||facade._dsh_p_w)return facade;
-  var current=wrapLoad(facade.load);
-  try{
-    Object.defineProperty(facade,'load',{
-      configurable:true,
-      get:function(){return current;},
-      set:function(fn){current=wrapLoad(fn);}
-    });
-  }catch(e){facade.load=current;}
-  facade._dsh_p_w=true;
-  return facade;
-}
-if(ml){wrapFacade(ml);}
-else{
-  var cur=undefined;
-  Object.defineProperty(window,'__ModuleLoader__',{configurable:true,enumerable:true,get:function(){return cur;},set:function(v){cur=wrapFacade(v);}});
-}
-}catch(e){}}();</script>`;
-
-/** 默认注入到经代理的 HTML 文档里：polyfill + loopback 信任环境补丁（issue #58）。 */
-export const DEFAULT_INJECT = RANDOM_UUID_POLYFILL + LOOPBACK_ENV_PATCH;
+export const DEFAULT_INJECT = RANDOM_UUID_POLYFILL + TRANSPORT_API_CLIENT_SHIM;
 
 /**
  * DSH Desktop advanced 模式不支持的提示覆盖层（issue #19）。
@@ -216,11 +168,22 @@ function createRateLimiter(cfg = {}) {
     },
   };
 }
-/** 客户端真实 IP：cf-connecting-ip（隧道，可信）优先，否则 socket 地址；不信 XFF。 */
-function clientIp(req) {
-  const cf = String(req.headers['cf-connecting-ip'] ?? '').trim();
-  if (cf) return cf;
-  return String(req.socket?.remoteAddress ?? 'unknown');
+/**
+ * 客户端真实 IP（限速与握手计数的身份键）：
+ *   - 来自本机（cloudflared 隧道回连，源地址 loopback）→ 认 cf-connecting-ip（Cloudflare 边缘写的真实客户端 IP）；
+ *   - 其余一律用 socket 源地址。
+ *
+ * 为什么不能无条件信任 cf-connecting-ip：那是**请求头**，能直连代理端口的人可以随手
+ * 伪造。隧道流量必经本机 cloudflared（源地址必为 loopback），所以把它限定在 loopback
+ * 来源既不影响隧道场景，又让「换头即换身份」的限速绕过失效。XFF 同理，始终不认。
+ */
+export function clientIp(req) {
+  const addr = String(req.socket?.remoteAddress ?? '');
+  if (classifySource(addr) === 'loopback') {
+    const cf = String(req.headers['cf-connecting-ip'] ?? '').trim();
+    if (cf) return cf;
+  }
+  return addr || 'unknown';
 }
 
 function parseCookies(header) {
@@ -795,13 +758,17 @@ export function createPocketProxy({ port = 3081, host = '0.0.0.0', upstream = DE
           req.on('data', (c) => { body += c; if (body.length > 1024) req.destroy(); });
           req.on('end', () => {
             const submitted = String(new URLSearchParams(body).get('token') ?? '');
-            if (submitted === token) {
+            // 与 cookie / ?token= 两条通道保持一致：常量时间比较 + 主 PIN 与替代令牌
+            // （临时 PIN，issue #69 钩子）任一命中即放行。原先这里是 `submitted === token`
+            // ——既会提前返回（计时侧信道可逐字节还原 PIN），又把替代令牌挡在门外。
+            const matched = acceptedTokens.find((candidate) => safeEqual(submitted, candidate));
+            if (matched !== undefined) {
               limiter?.clear(ip);
               res.writeHead(302, {
                 // 带上 dsh-pocket-auth=1：登录成功后强制重做一次浏览器会话握手，
                 // 换掉可能已过期/被撤销的 dsh web 会话 cookie（issue #77）
                 location: '/?dsh-pocket-auth=1',
-                'set-cookie': `${TOKEN_COOKIE}=${cookieFor(token, sessionKey)}; HttpOnly; SameSite=Lax; Path=/; Max-Age=${COOKIE_MAX_AGE}`,
+                'set-cookie': `${TOKEN_COOKIE}=${cookieFor(matched, sessionKey)}; HttpOnly; SameSite=Lax; Path=/; Max-Age=${COOKIE_MAX_AGE}`,
                 'cache-control': 'no-store',
               });
               res.end();

package/lib/service.mjs

@@ -187,7 +187,14 @@ export function createPocketService({
   getTunnelConfig,
   /** 隧道就绪回调（lib/index.js 用它轮换公网密码；参数为 'quick'|'named'） */
   onTunnelReady,
+  /** 日志（DSH 宿主 ctx.logger 有 info/warn/error；默认 console 无 info，自动退回 log）。
+   *  隧道自动恢复的成败必须走这里：console 输出在 DSH Desktop 里不进日志文件，
+   *  出问题时无法排查（2026-09-07 实测教训）。 */
+  log = console,
 } = {}) {
+  // ctx.logger 形状是 info/warn/error；console 只有 log/warn/error——info 做兜底兼容
+  const logInfo = (...args) => (log.info ?? log.log).call(log, ...args);
+  const logWarn = (...args) => log.warn(...args);
   const createProxy = internals.createProxy ?? createPocketProxy;
   const startTunnel = internals.startTunnel ?? startQuickTunnel;
   const startNamed = internals.startNamedTunnel ?? startNamedTunnel;
@@ -232,16 +239,25 @@ export function createPocketService({
   // 公网隧道自动恢复（issue #11）：DSH 重启后 cloudflared 子进程被杀、隧道消失，
   // 插件无从知晓。启动时检查持久化的「隧道开启中」标记，自动重新拉起。
   const autoStatePath = home ? join(home, 'dsh-pocket', 'tunnel-auto.json') : null;
-  async function persistAutoTunnel() {
+  // 写入与删除必须串行：隧道刚就绪就立即关闭时，异步写不能晚于删除重新落盘，
+  // 否则标记被晚到的写操作复活，下次启动误恢复（writeFile 与 rm 的完成顺序不保证）。
+  let autoStateQueue = Promise.resolve();
+  function persistAutoTunnel() {
     if (!autoStatePath) return;
-    try {
-      await mkdir(dirname(autoStatePath), { recursive: true });
-      await writeFile(autoStatePath, JSON.stringify({ at: Date.now() }), 'utf8');
-    } catch { /* 忽略 */ }
+    autoStateQueue = autoStateQueue.then(async () => {
+      try {
+        await mkdir(dirname(autoStatePath), { recursive: true });
+        await writeFile(autoStatePath, JSON.stringify({ at: Date.now() }), 'utf8');
+      } catch { /* 忽略 */ }
+    });
+    return autoStateQueue;
   }
-  async function clearAutoTunnel() {
+  function clearAutoTunnel() {
     if (!autoStatePath) return;
-    try { await rm(autoStatePath, { force: true }); } catch { /* 忽略 */ }
+    autoStateQueue = autoStateQueue.then(async () => {
+      try { await rm(autoStatePath, { force: true }); } catch { /* 忽略 */ }
+    });
+    return autoStateQueue;
   }
 
   return {
@@ -264,7 +280,7 @@ export function createPocketService({
             ...(launchToken ? { launchToken } : {}),
           });
           if (p !== port) {
-            console.log(`dsh-pocket: port ${port} busy, proxy on ${p} | 端口 ${port} 被占用，代理改用 ${p}`);
+            logInfo(`dsh-pocket: port ${port} busy, proxy on ${p} | 端口 ${port} 被占用，代理改用 ${p}`);
           }
           break;
         } catch (err) {
@@ -291,7 +307,12 @@ export function createPocketService({
         else if (phase === 'registering') tunnelState.detail = '连接 Cloudflare 边缘（通常 5-30 秒）| connecting to Cloudflare edge (usually 5-30s)';
         else if (phase === 'ready') tunnelState.detail = '隧道就绪 | ready';
       };
-      tunnelPromise = (async () => {
+      // 先 `await null` 让函数体从微任务开始执行：否则在 `p` 初始化之前（getTunnelConfig
+      // 之类的同步抛错）就会走到 finally，引用未初始化的 const 触发 TDZ 报错，
+      // tunnelPromise 会永久停在 rejected —— 此后 startTunnel 一直复用这个失败的
+      // promise，隧道再也起不来。
+      const p = (async () => {
+        await null;
         try {
           // 命名隧道（issue #66）：固定域名模式——URL 由设置里的域名拼出（cloudflared 不打印）
           const cfg = typeof getTunnelConfig === 'function' ? (getTunnelConfig() ?? {}) : {};
@@ -335,12 +356,18 @@ export function createPocketService({
           if (tunnelPromise === p) tunnelPromise = null;
         }
       })();
-      const p = tunnelPromise;
-      return tunnelPromise;
+      tunnelPromise = p;
+      return p;
     },
 
-    /** 停止公网隧道（代理保持）。 */
-    stopTunnel() {
+    /**
+     * 停止公网隧道（代理保持）。
+     * @param {{ keepAutoMarker?: boolean }} [opts] - keepAutoMarker=true 用于进程退出/
+     *   自重启（dispose / pocketRestart）：隧道是随进程被动消失的，不是用户主动关闭，
+     *   必须保留 tunnel-auto.json，下次启动才能自动恢复（issue #11 的本意）。
+     *   默认（设置页手动关闭、恢复出厂）删除标记。
+     */
+    stopTunnel({ keepAutoMarker = false } = {}) {
       tunnelAbort?.abort();
       tunnelAbort = null;
       tunnelPromise = null; // 丢弃已 abort 的 in-flight（其 finally 会再清一次，无害）
@@ -349,11 +376,12 @@ export function createPocketService({
       tunnelState.phase = 'idle';
       tunnelState.detail = '';
       tunnelState.startedAt = null;
-      void clearAutoTunnel(); // 手动关闭后不再自动恢复
+      if (!keepAutoMarker) void clearAutoTunnel(); // 手动关闭后不再自动恢复
     },
 
     /** 启动时自动恢复上次开启的公网隧道（DSH 重启后 cloudflared 子进程被杀，issue #11）。 */
     async restoreTunnelIfNeeded() {
+      logInfo('dsh-pocket: auto-restore check | 自动恢复检查：读取上次隧道状态');
       if (!autoStatePath || tunnel || tunnelPromise) return;
       let has = false;
       try {
@@ -361,12 +389,13 @@ export function createPocketService({
         has = /"at"\s*:/.test(raw);
       } catch { return; } // 无标记 → 不恢复
       if (!has) return;
+      logInfo('dsh-pocket: auto-restore: marker found, starting tunnel | 发现上次开启标记，尝试自动恢复');
       try {
         await this.startTunnel();
-        console.log('dsh-pocket: public tunnel auto-restored | 已自动恢复公网隧道');
+        logInfo('dsh-pocket: public tunnel auto-restored | 已自动恢复公网隧道');
       } catch (err) {
         // 恢复失败保留标记（下次启动再试）；网络问题见 README 排障
-        console.warn('dsh-pocket: tunnel auto-restore failed | 自动恢复隧道失败: %s', err?.message ?? err);
+        logWarn('dsh-pocket: tunnel auto-restore failed | 自动恢复隧道失败: %s', err?.message ?? err);
       }
     },
 
@@ -403,8 +432,9 @@ export function createPocketService({
     },
 
     /** 停止一切（插件卸载时）。 */
+    /** 停止一切（插件卸载时）。进程退出不是用户手动关闭：保留自动恢复标记。 */
     async dispose() {
-      this.stopTunnel();
+      this.stopTunnel({ keepAutoMarker: true });
       if (proxy) {
         const p = proxy;
         proxy = null;

package/lib/web-rpc.js

@@ -1,4 +1,10 @@
 // dsh-pocket Web RPC（loopback-only）：设置页 ⇄ Host 的手机访问通道
+//
+// 兼容两条路径：
+//   1. dsh v0.1.5-alpha.1+（client-connection inject 收缩为 ['credentials']，
+//      rpc.handle 内部访问 owner.webServer 必抛 "cannot get property without inject"）
+//      → 直接挂到本插件 inject 的 webServer 上，逐分支复刻 Connection /api 传输语义。
+//   2. 旧版 dsh / 无 webServer 服务（headless）→ 回退 ctx.connection.rpc.handle(...)。
 
 import { promises as fs } from 'node:fs';
 import path from 'node:path';
@@ -8,6 +14,224 @@ import { POCKET_RPC_CHANNEL, POCKET_ENDPOINTS, redactStatus } from '../client/ap
 /** 单次读取上限：4 MB，避免把大文件塞进剪贴板 / 内存。 */
 const FILE_READ_MAX = 4 * 1024 * 1024;
 
+/** RPC 请求体上限：8 MB。dsh-pocket 的所有 endpoint 都是小控制 JSON（status / 隧道开关 /
+ *  自定义密码等），不存在大载荷；413 直接拒绝避免无界缓冲。 */
+const POCKET_RPC_BODY_MAX = 8 * 1024 * 1024;
+
+/** endpoint 段字符（与 dsh-client-connection 的 ENDPOINT_SEGMENT_PATTERN 对齐）。 */
+const ENDPOINT_SEGMENT_PATTERN = /^[A-Za-z0-9_$.-]+$/;
+
+/** client-request 信封校验失败时使用的兜底 rpcId（与 dsh 内部 INVALID_REQUEST_RPC_ID 对齐）。 */
+const INVALID_REQUEST_RPC_ID = 'invalid-request';
+
+const LOOPBACK_HOSTNAMES = new Set(['127.0.0.1', 'localhost', '::1']);
+
+/**
+ * 从 `${channel}/<endpoint>` 路径里取出 endpoint，段非法时返回 undefined。
+ * 与 dsh-client-connection 的 endpointFromPath 字段对字段一致。
+ */
+function endpointFromPath(channel, pathname) {
+  if (!pathname.startsWith(`${channel}/`)) return undefined;
+  const endpoint = pathname.slice(channel.length + 1);
+  if (endpoint.split('/').some((seg) => seg === '' || seg === '.' || seg === '..' || !ENDPOINT_SEGMENT_PATTERN.test(seg))) {
+    return undefined;
+  }
+  return endpoint;
+}
+
+/** 构造 server-response JSON 串（与 dsh-client-connection 的 fullResponse 字段对齐）。 */
+function serverResponseJson(rpcId, result) {
+  return JSON.stringify({ type: 'server-response', rpcId, result });
+}
+
+/**
+ * 旧版 dsh / 无 connection.requestRejection 时的最小信任栅栏：仅放行 loopback Host，
+ * 拒 cross-site fetch 与 Origin 不匹配（与 isTrustedApiRequest 的 loopback 分支对齐）。
+ * 新版 dsh 走 ctx.connection.requestRejection(req)（401/403 都在那里），本函数只是兜底。
+ */
+function isTrustedLoopbackRequest(req) {
+  const host = req.headers?.host;
+  if (!host) return false;
+  const hostName = host.split(':')[0];
+  if (!LOOPBACK_HOSTNAMES.has(hostName)) return false;
+  if (req.headers['sec-fetch-site'] === 'cross-site') return false;
+  const origin = req.headers.origin;
+  if (origin === undefined) return true;
+  try { return new URL(origin).host === host; } catch { return false; }
+}
+
+/**
+ * 把 RPC handler 包装成 fetch-shaped handler，逐分支复刻 dsh-client-connection 的
+ * rpcFetchHandler：404（非 POST / 无 endpoint）、415（content-type）、400（非 JSON）、
+ * gateway/bad-request（信封非法 / method 与 endpoint 不匹配）、500（handler 抛错），
+ * 成功返回 server-response JSON（200）。wire 协议与原 /api 通道逐字节一致。
+ */
+function pocketFetchHandler(channel, handler, log) {
+  return {
+    async fetch(request) {
+      const endpoint = endpointFromPath(channel, new URL(request.url).pathname);
+      if (request.method !== 'POST' || endpoint === undefined) {
+        return new Response('not found', { status: 404 });
+      }
+      const mediaType = request.headers.get('content-type')?.split(';', 1)[0]?.trim().toLowerCase();
+      if (mediaType !== 'application/json') {
+        return new Response('content type must be application/json', { status: 415 });
+      }
+      let body;
+      try {
+        body = await request.json();
+      } catch {
+        return new Response('body is not JSON', { status: 400 });
+      }
+      // 最小信封校验（不依赖 @deepseek-ai/dsh-host-apiproxy 的 clientRequestSchema，
+      // 形状稳定：{ rpcId: string, method: string, payload?: any }）。
+      const rpcId = body && typeof body.rpcId === 'string' ? body.rpcId : INVALID_REQUEST_RPC_ID;
+      const method = body && typeof body.method === 'string' ? body.method : null;
+      if (rpcId === INVALID_REQUEST_RPC_ID || method === null) {
+        return new Response(
+          serverResponseJson(INVALID_REQUEST_RPC_ID, {
+            ok: false,
+            error: { code: 'bad-request', message: 'invalid client-request message', details: { issues: [] } },
+          }),
+          { status: 200, headers: { 'content-type': 'application/json' } },
+        );
+      }
+      if (method !== endpoint) {
+        return new Response(
+          serverResponseJson(rpcId, {
+            ok: false,
+            error: {
+              code: 'bad-request',
+              message: `method ${JSON.stringify(method)} does not match endpoint ${JSON.stringify(endpoint)}`,
+              details: { issues: [] },
+            },
+          }),
+          { status: 200, headers: { 'content-type': 'application/json' } },
+        );
+      }
+      try {
+        const result = await handler(endpoint, body.payload, request.signal);
+        return new Response(serverResponseJson(rpcId, result), {
+          status: 200,
+          headers: { 'content-type': 'application/json' },
+        });
+      } catch (err) {
+        log.error?.('dsh-pocket: rpc %s failed | RPC 失败: %s', endpoint, err?.message ?? err);
+        return new Response(`handler failure: ${String(err)}`, { status: 500 });
+      }
+    },
+  };
+}
+
+/**
+ * node:http 请求 → fetch-shaped handler → node:http 响应的桥接。
+ * 与 dsh-client-connection 的 bridge 行为一致：
+ *   - res.close 时若响应未结束 → abort（client 主动断开不再等 handler）；
+ *   - 声明 content-length 超 maxBodyBytes → 413 + 销毁 socket；
+ *   - 流式读取超 maxBodyBytes → 413 + 销毁 socket（防无界缓冲）；
+ *   - 把请求头里 string 值原样传给 fetch handler（数组头被丢弃，与原实现一致）；
+ *   - 响应 body 流式回写，遇背压等 drain / close。
+ */
+async function pocketHttpBridge(req, res, fetchHandler, maxBodyBytes) {
+  const abort = new AbortController();
+  res.on('close', () => { if (!res.writableEnded) abort.abort(); });
+
+  const declaredLen = req.headers['content-length'];
+  if (declaredLen !== undefined && Number(declaredLen) > maxBodyBytes) {
+    res.writeHead(413, { connection: 'close' });
+    res.end();
+    req.destroy();
+    return;
+  }
+  const chunks = [];
+  let received = 0;
+  let tooLarge = false;
+  for await (const chunk of req) {
+    received += chunk.length;
+    if (received > maxBodyBytes) { tooLarge = true; break; }
+    chunks.push(chunk);
+  }
+  if (tooLarge) {
+    res.writeHead(413, { connection: 'close' });
+    res.end();
+    req.destroy();
+    return;
+  }
+
+  const url = `http://${req.headers.host ?? '127.0.0.1'}${req.url}`;
+  const init = {
+    method: req.method ?? 'GET',
+    headers: Object.fromEntries(
+      Object.entries(req.headers).filter(([, v]) => typeof v === 'string'),
+    ),
+    signal: abort.signal,
+  };
+  if (chunks.length > 0) init.body = Buffer.concat(chunks);
+  const request = new Request(url, init);
+
+  const response = await fetchHandler.fetch(request);
+  const headers = Object.fromEntries(response.headers.entries());
+  // 不写 content-length（流式响应长度未知），交由 Node 自动分块。
+  res.writeHead(response.status, headers);
+  if (response.body === null) { res.end(); return; }
+  for await (const chunk of response.body) {
+    if (!res.write(chunk)) {
+      await new Promise((resolve) => {
+        const done = () => { res.off('drain', done); res.off('close', done); resolve(); };
+        res.once('drain', done);
+        res.once('close', done);
+      });
+    }
+    if (res.writableEnded) break;
+  }
+  res.end();
+}
+
+/**
+ * 直接把 /dsh-pocket 通道挂到插件自己 inject 的 webServer 上。
+ * 返回 disposer（同步或异步均可调用），返回 null 表示环境无 webServer（调用方应回退 rpc.handle）。
+ *
+ * 行为分支与 dsh-client-connection 的 register() /api 路由 1:1 对齐：
+ *   - connection.requestRejection(req) 可用时（dsh v0.1.5-alpha.1+）→ 走它，
+ *     401 unauthorized / 403 forbidden 都在那里判定（浏览器 cookie + Host/Origin 栅栏）；
+ *   - 不可用时（旧版 dsh）→ 用 isTrustedLoopbackRequest 兜底，仅做 loopback 信任栅栏，
+ *     浏览器 cookie 认证旧版本就没有，行为与原 rpc.handle({authority:'loopback'}) 一致；
+ *   - 之后交给 pocketHttpBridge + pocketFetchHandler，复刻 /api 的 4xx/5xx/200 分支。
+ */
+function mountPocketWebRoute(ctx, { channel, handler, log }) {
+  const webServer = ctx?.webServer;
+  if (!webServer || typeof webServer.register !== 'function') return null;
+  const requestRejection = ctx?.connection?.requestRejection;
+  const fetchHandler = pocketFetchHandler(channel, handler, log);
+  const route = {
+    kind: 'prefix',
+    path: channel,
+    handler: async (req, res) => {
+      let rejection;
+      if (typeof requestRejection === 'function') {
+        try { rejection = requestRejection(req); } catch { rejection = 403; }
+      } else if (!isTrustedLoopbackRequest(req)) {
+        rejection = 403;
+      }
+      if (rejection !== undefined) {
+        res.writeHead(rejection, { 'content-type': 'text/plain; charset=utf-8' });
+        res.end(rejection === 401 ? 'unauthorized' : 'forbidden');
+        return;
+      }
+      await pocketHttpBridge(req, res, fetchHandler, POCKET_RPC_BODY_MAX);
+    },
+  };
+  const registered = webServer.register(route);
+  // register 可能返回 disposer、Promise<disposer> 或 undefined（仅写入路由表）。
+  // 统一规整成「可幂等调用的清理函数」。
+  const cleanup = typeof registered === 'function'
+    ? () => { try { registered(); } catch { /* 已清理 */ } }
+    : (registered && typeof registered.then === 'function')
+      ? (() => { let done = false; return async () => { if (done) return; done = true; try { const d = await registered; if (typeof d === 'function') d(); } catch { /* 已清理 */ } }; })()
+      : () => {};
+  return cleanup;
+}
+
 function ok(value) {
   return { ok: true, value };
 }
@@ -30,13 +254,12 @@ export function killHint(port) {
   return `lsof -ti :${port} | xargs kill -9`;
 }
 
-/** 注册 /dsh-pocket 逻辑通道（仅本机 loopback 可调）。 */
+/** 注册 /dsh-pocket 逻辑通道（仅本机 loopback 可调）。
+ * 优先直接挂到本插件 inject 的 webServer 上（dsh v0.1.5-alpha.1+ 兼容路径），
+ * 不可用时回退 ctx.connection.rpc.handle（旧版 dsh 兼容路径）。
+ * wire 协议两条路径完全一致：client-request → handler → server-response。 */
 export function installPocketRpc(ctx, { service, log = console, desktop = false, runUpdate = null, restart = null, restartNotice = null, getToken = null, getLanToken = null, refreshLanToken = null, getLanAuthEnabled = null, setLanAuthEnabled = null, getLanEnabled = null, setLanEnabled = null, getLanIpOverride = null, setLanIpOverride = null, getPinCustom = null, setCustomPin = null, getTunnelConfig = null, setTunnelConfig = null, resetPocket = null }) {
-  if (!ctx?.connection?.rpc?.handle) {
-    log.warn?.('dsh-pocket: DSH Host Connection RPC unavailable — settings tab disabled | 无 Connection RPC，设置页不可用');
-    return () => {};
-  }
-  return ctx.connection.rpc.handle(POCKET_RPC_CHANNEL, async (endpoint, payload = {}, signal) => {
+  const pocketRpcHandler = async (endpoint, payload = {}, signal) => {
     if (signal?.aborted) return fail('cancelled', 'The request was cancelled.');
 
     // status 响应：服务状态 + 重启提示 + 停止命令 + 桌面端标志 + 公网/局域网访问密码 + 局域网密码开关
@@ -219,5 +442,19 @@ export function installPocketRpc(ctx, { service, log = console, desktop = false,
       log.error?.('dsh-pocket: rpc %s failed | RPC 失败: %s', endpoint, err?.message ?? err);
       return fail('bad-request', err?.message ?? String(err));
     }
-  }, { authority: 'loopback' });
+  };
+
+  // 优先路径：直接挂到本插件 inject 的 webServer 上（dsh v0.1.5-alpha.1+）。
+  // 该路径下 ctx.connection 仅用于 requestRejection（401/403 完整栅栏），即使
+  // client-connection 已不再 inject webServer，本插件自己 inject 的 webServer 也照常工作。
+  const directMount = mountPocketWebRoute(ctx, { channel: POCKET_RPC_CHANNEL, handler: pocketRpcHandler, log });
+  if (directMount) return directMount;
+
+  // 回退路径：旧版 dsh（无 webServer 服务，如 headless / 测试 fixture）走 rpc.handle。
+  // { authority: 'loopback' } 旧版用、新版 Connection 从未消费，保留向后兼容。
+  if (!ctx?.connection?.rpc?.handle) {
+    log.warn?.('dsh-pocket: DSH Host Connection RPC unavailable — settings tab disabled | 无 Connection RPC，设置页不可用');
+    return () => {};
+  }
+  return ctx.connection.rpc.handle(POCKET_RPC_CHANNEL, pocketRpcHandler, { authority: 'loopback' });
 }

package/package.json

@@ -80,5 +80,5 @@
     "access": "public",
     "registry": "https://registry.npmjs.org/"
   },
-  "version": "2.10.2"
+  "version": "2.10.4"
 }