@yezack/dsh-remote-mobile 1.9.2 → 1.10.2

package/lib/bridge/compat.js

@@ -30,9 +30,13 @@
  *    - 判定基于 Cordis 公开运行时结构（服务占用 + fiber 运行态），不针对特定插件；
  *    - 保证与其他远程接入类插件共存时必定可以正常启动（不再触发整树回滚致命错误）。
  */
+import net from 'node:net';
 import { timingSafeEqual } from 'node:crypto';
-import { getClientIp, isTailscaleIp, isLanIp } from '../auth/tailscale.js';
-import { isLoopbackRequest } from '../auth/gate.js';
+import zlib from 'node:zlib';
+import { getPhysicalSocketIp, getClientIp, isTailscaleIp, isLanIp, getAllNetworkIps } from '../auth/tailscale.js';
+import { getGatewaySecret, safeCompareSecret } from '../gateway/secret.js';
+import { extractBareHostname, extractPortString, isLoopbackRequest, isTrustedHost, hasCrossSiteSignal, getRequestProtocol, } from '../auth/gate.js';
+export { extractBareHostname, extractPortString };
 import { isMobileUserAgent, applyDataMobileAttr, buildMobileStyleTag, } from '../styles/style-snippets.js';
 /**
  * 注入到 index.html <head> 最前列的 Polyfill 脚本代码片段
@@ -331,12 +335,53 @@ export const MOBILE_DISMISS_SNIPPET = `
   setInterval(ensure, 800);
 })();
 `;
+/**
+ * 向 HTML 文档的 <head> 顶部安全注入样式片段与 Polyfill 脚本（自带幂等防重守卫）
+ *
+ * @param html - 待注入的原始 HTML 字符串
+ * @param isMobile - 是否为移动端（用于追加 data-dsh-mobile 标记）
+ * @param mobileStyleCss - 动态收集的样式片段 CSS（支持按视口宽度生效）
+ */
+export function injectHtmlPayload(html, isMobile = false, mobileStyleCss = '') {
+    if (!html || !html.includes('<head>'))
+        return html;
+    let result = html;
+    if (isMobile) {
+        result = applyDataMobileAttr(result);
+    }
+    // 1. 样式片段覆写（按视口宽度生效，优先且幂等）
+    if (mobileStyleCss && !result.includes('id="dsh-remote-mobile-style-snippets"')) {
+        result = result.replace('<head>', `<head>${buildMobileStyleTag(mobileStyleCss)}`);
+    }
+    // 2. 悬浮把手拖拽脚本（全端注入，内部自带仅折叠时生效守卫）
+    if (!result.includes('id="dsh-draggable-nav"')) {
+        result = result.replace('<head>', `<head><script id="dsh-draggable-nav">${DRAGGABLE_NAV_SNIPPET}</script>`);
+    }
+    // 3. 移动端抽屉「点外部收起」脚本
+    if (!result.includes('id="dsh-mobile-dismiss"')) {
+        result = result.replace('<head>', `<head><script id="dsh-mobile-dismiss">${MOBILE_DISMISS_SNIPPET}</script>`);
+    }
+    // 4. 非安全上下文 Crypto Polyfill 脚本
+    if (!result.includes('id="dsh-crypto-polyfill"')) {
+        result = result.replace('<head>', `<head><script id="dsh-crypto-polyfill">${CRYPTO_POLYFILL_SNIPPET}</script>`);
+    }
+    // 5. 非安全上下文 Clipboard Polyfill 脚本
+    if (!result.includes('id="dsh-clipboard-polyfill"')) {
+        result = result.replace('<head>', `<head><script id="dsh-clipboard-polyfill">${CLIPBOARD_POLYFILL_SNIPPET}</script>`);
+    }
+    // 6. 桌面端全家桶冲突防护脚本
+    if (!result.includes('id="dsh-force-desktop-suppression"')) {
+        result = result.replace('<head>', `<head><script id="dsh-force-desktop-suppression">${FORCE_DESKTOP_SUPPRESSION_SNIPPET}</script>`);
+    }
+    return result;
+}
 /**
  * 挂载底层 http.Server 门禁劫持与回环上下文虚拟化代理
  *
  * @param server - 底层 Node.js http.Server 实例
  * @param gateMiddleware - 全局安全门禁拦截器函数
  * @param store - 会话与配置管理器实例
+ * @param styleStore - 样式片段管理器实例
  */
 export function patchHttpServerWithVirtualizer(server, gateMiddleware, _store, styleStore) {
     if (!server || server.__dsh_tailscale_gate_patched__)
@@ -357,7 +402,7 @@ export function patchHttpServerWithVirtualizer(server, gateMiddleware, _store, s
         if (req.socket && !req.socket.__dsh_real_remote_address__) {
             req.socket.__dsh_real_remote_address__ = req.socket.remoteAddress;
         }
-        // 1. 响应层拦截：在主文档 index.html 响应流中的 <head> 首行注入 Crypto Polyfill
+        // 1. 响应层拦截：在主文档 index.html 响应流中注入样式片段与 Polyfill 脚本
         const originalEnd = res.end;
         let isHtml = false;
         res.writeHead = ((origWriteHead) => {
@@ -373,100 +418,174 @@ export function patchHttpServerWithVirtualizer(server, gateMiddleware, _store, s
         res.end = function (chunk, ...args) {
             const currentCt = this.getHeader?.('content-type') || this.getHeader?.('Content-Type') || '';
             const shouldInject = isHtml || String(currentCt).includes('text/html');
+            const contentEncoding = String(this.getHeader?.('content-encoding') || this.getHeader?.('Content-Encoding') || '').toLowerCase();
             // 是否实际改写了响应体（注入会改变 body 字节长度）
             let injected = false;
             if (shouldInject && chunk) {
                 if (typeof chunk === 'string' && chunk.includes('<head>')) {
-                    let html = chunk;
-                    if (isMobile)
-                        html = applyDataMobileAttr(html);
-                    if (mobileStyleCss) {
-                        html = html.replace('<head>', `<head>${buildMobileStyleTag(mobileStyleCss)}`);
+                    const updated = injectHtmlPayload(chunk, isMobile, mobileStyleCss);
+                    if (updated !== chunk) {
+                        chunk = updated;
+                        injected = true;
                     }
-                    // 悬浮把手拖拽脚本全端注入：脚本自带“仅折叠时工作”守卫，
-                    // 预设按视口宽度生效后 PC 窄窗口同样需要可拖动的展开把手
-                    html = html.replace('<head>', `<head><script id="dsh-draggable-nav">${DRAGGABLE_NAV_SNIPPET}</script>`);
-                    // 移动端抽屉「点外部收起」全端注入：脚本自带 web-ui 让位守卫，
-                    // web-ui 在场时完全交给它处理，未装时复刻等价行为
-                    html = html.replace('<head>', `<head><script id="dsh-mobile-dismiss">${MOBILE_DISMISS_SNIPPET}</script>`);
-                    html = html.replace('<head>', `<head><script id="dsh-crypto-polyfill">${CRYPTO_POLYFILL_SNIPPET}</script>`);
-                    html = html.replace('<head>', `<head><script id="dsh-clipboard-polyfill">${CLIPBOARD_POLYFILL_SNIPPET}</script>`);
-                    // 冲突防护脚本后 replace → 位于 <head> 最前，优先写入 sessionStorage 避免小鲸鱼重复挂载
-                    html = html.replace('<head>', `<head><script id="dsh-force-desktop-suppression">${FORCE_DESKTOP_SUPPRESSION_SNIPPET}</script>`);
-                    chunk = html;
-                    injected = true;
                 }
                 else if (Buffer.isBuffer(chunk)) {
-                    let str = chunk.toString('utf8');
-                    if (str.includes('<head>')) {
-                        if (isMobile)
-                            str = applyDataMobileAttr(str);
-                        if (mobileStyleCss) {
-                            str = str.replace('<head>', `<head>${buildMobileStyleTag(mobileStyleCss)}`);
+                    // 判定是否经过压缩：Gzip (Magic Number 0x1f 0x8b) 或 Deflate
+                    const isGzip = contentEncoding.includes('gzip') || (chunk.length >= 2 && chunk[0] === 0x1f && chunk[1] === 0x8b);
+                    const isDeflate = contentEncoding.includes('deflate');
+                    if (isGzip) {
+                        try {
+                            const decompressed = zlib.gunzipSync(chunk).toString('utf8');
+                            if (decompressed.includes('<head>')) {
+                                const updated = injectHtmlPayload(decompressed, isMobile, mobileStyleCss);
+                                if (updated !== decompressed) {
+                                    chunk = zlib.gzipSync(Buffer.from(updated, 'utf8'));
+                                    injected = true;
+                                }
+                            }
+                        }
+                        catch { }
+                    }
+                    else if (isDeflate) {
+                        try {
+                            const decompressed = zlib.inflateSync(chunk).toString('utf8');
+                            if (decompressed.includes('<head>')) {
+                                const updated = injectHtmlPayload(decompressed, isMobile, mobileStyleCss);
+                                if (updated !== decompressed) {
+                                    chunk = zlib.deflateSync(Buffer.from(updated, 'utf8'));
+                                    injected = true;
+                                }
+                            }
+                        }
+                        catch { }
+                    }
+                    else {
+                        // 普通未压缩 Buffer
+                        const str = chunk.toString('utf8');
+                        if (str.includes('<head>')) {
+                            const updated = injectHtmlPayload(str, isMobile, mobileStyleCss);
+                            if (updated !== str) {
+                                chunk = Buffer.from(updated, 'utf8');
+                                injected = true;
+                            }
                         }
-                        str = str.replace('<head>', `<head><script id="dsh-draggable-nav">${DRAGGABLE_NAV_SNIPPET}</script>`);
-                        str = str.replace('<head>', `<head><script id="dsh-mobile-dismiss">${MOBILE_DISMISS_SNIPPET}</script>`);
-                        str = str.replace('<head>', `<head><script id="dsh-crypto-polyfill">${CRYPTO_POLYFILL_SNIPPET}</script>`);
-                        str = str.replace('<head>', `<head><script id="dsh-clipboard-polyfill">${CLIPBOARD_POLYFILL_SNIPPET}</script>`);
-                        str = str.replace('<head>', `<head><script id="dsh-force-desktop-suppression">${FORCE_DESKTOP_SUPPRESSION_SNIPPET}</script>`);
-                        chunk = Buffer.from(str, 'utf8');
-                        injected = true;
                     }
                 }
             }
-            // 防截断守卫：仅当头部尚未发出时移除显式的 Content-Length，
-            // 让 Node 按最终 body 重新计算长度（writeHead 已发出后 removeHeader 无效，属不可挽救场景）
+            // 长度防截断守卫：仅当头部尚未发出时移除显式的 Content-Length，
+            // 让 Node 按最终 body 重新计算长度或转为分块传输
             if (injected && !this.headersSent) {
                 try {
-                    if (typeof this.removeHeader === 'function')
+                    if (typeof this.removeHeader === 'function') {
                         this.removeHeader('content-length');
+                        this.removeHeader('Content-Length');
+                    }
                 }
                 catch { }
             }
             return originalEnd.apply(this, [chunk, ...args]);
         };
+        // 1.5 在门禁判定前校验受信网关 Secret。
+        // 网关转发请求同样来自物理回环，且带有 X-Forwarded-*，不能仅凭 Host/Forwarded
+        // 把它误判为同机反向代理；这里用 Secret 打上受信标记，供 isLoopbackRequest 识别。
+        try {
+            const trustSocketIp = getPhysicalSocketIp(req);
+            const trustIsLoopback = trustSocketIp === '127.0.0.1' || trustSocketIp === '::1';
+            const trustSecret = getGatewaySecret(server);
+            if (trustIsLoopback &&
+                trustSecret &&
+                safeCompareSecret(req.headers['x-dsh-gateway-secret'], trustSecret)) {
+                ;
+                req.__dsh_rm_trusted_gateway__ = true;
+            }
+        }
+        catch { }
         // 2. 请求层门禁判定与上下文虚拟化
         const allowed = gateMiddleware(req, res, () => {
-            // 记录真实客户端来源信息（内部专用头，无条件覆盖避免伪造）
-            const realIp = getClientIp(req);
-            req.headers['x-dsh-real-ip'] = realIp;
-            req.headers['x-real-ip'] = realIp;
+            // 物理 Socket 连接真实 IP（严格取底层物理连接，仅去除 ::ffff: 前缀，绝不受任何头篡改）
+            const physicalSocketIp = getPhysicalSocketIp(req);
+            const isLoopbackSocket = physicalSocketIp === '127.0.0.1' || physicalSocketIp === '::1' || physicalSocketIp === 'localhost';
+            // 网关受信密钥核验：仅当底层物理连接为本地回环且 Secret 比对一致时，才采纳网关上报的有效真实客户端 IP
+            const currentSecret = getGatewaySecret(server);
+            const candidateSecret = req.headers['x-dsh-gateway-secret'];
+            const candidateRealIp = req.headers['x-dsh-real-ip'];
+            const candidateIpStr = Array.isArray(candidateRealIp) ? candidateRealIp[0] : candidateRealIp;
+            const trustedGateway = isLoopbackSocket &&
+                Boolean(currentSecret) &&
+                safeCompareSecret(candidateSecret, currentSecret);
+            let effectiveClientIp = physicalSocketIp;
+            if (trustedGateway &&
+                typeof candidateIpStr === 'string' &&
+                candidateIpStr.trim() !== '' &&
+                net.isIP(candidateIpStr.replace(/^::ffff:/, '').trim()) !== 0) {
+                effectiveClientIp = candidateIpStr.replace(/^::ffff:/, '').trim();
+            }
+            else if (isLoopbackSocket && !isLoopbackRequest(req)) {
+                // 同机反向代理：物理来源是 127，但 Host/Forwarded 表明是外部流量；
+                // 采用代理透传的 X-Forwarded-For 首个合法 IP，恢复防暴破/审计真实来源。
+                const rawXff = req.headers['x-forwarded-for'];
+                const value = Array.isArray(rawXff) ? rawXff[0] : rawXff;
+                if (typeof value === 'string') {
+                    const first = value.split(',')[0].trim().replace(/^::ffff:/, '');
+                    if (net.isIP(first))
+                        effectiveClientIp = first;
+                }
+            }
+            else if (!isLoopbackSocket && req.headers['x-forwarded-for']) {
+                // 反向代理位于 LAN/Tailscale 网段：同样使用代理透传的真实 IP
+                const rawXff = req.headers['x-forwarded-for'];
+                const value = Array.isArray(rawXff) ? rawXff[0] : rawXff;
+                if (typeof value === 'string') {
+                    const first = value.split(',')[0].trim().replace(/^::ffff:/, '');
+                    if (net.isIP(first))
+                        effectiveClientIp = first;
+                }
+            }
+            // 同步有效客户端 IP 到三头（外部伪造的头在此被强制净化，下游生态插件与审计均可准确读取）
+            req.headers['x-dsh-real-ip'] = effectiveClientIp;
+            req.headers['x-real-ip'] = effectiveClientIp;
+            req.headers['x-forwarded-for'] = effectiveClientIp;
+            // 消费完毕后立即抹除内部私密密钥头，防止向下游泄露
+            delete req.headers['x-dsh-gateway-secret'];
             if (!req.headers['x-forwarded-host'] && req.headers.host) {
                 req.headers['x-forwarded-host'] = req.headers.host;
             }
-            // 回环 socket（本机浏览器 / 本机程序）不做 Host/Origin/sec-fetch-site 洗白：
-            // 保留浏览器原始同源信号，让下游自身的 CSRF 与 DNS-Rebinding 校验继续生效，
-            // 防御恶意网页借道本机发起的 drive-by 跨站写与 Rebinding 攻击；虚拟化仅服务于外部合法流量。
-            const isLoopbackSocket = realIp === '127.0.0.1' || realIp === '::1';
+            // 仅当底层物理 socket 为外部来源（Direct 模式直接对公网开放）时才由底座补丁进行外部虚拟化；
+            // 若底层物理 socket 为本地回环（包括本机直接访问或来自受信 Gateway 的回环转发），底座绝不无条件洗白 Origin，
+            // 保证下游生态插件的 CSRF / DNS-Rebinding 校验全额生效。
             if (!isLoopbackSocket) {
-                // 虚拟化 Host 与 Origin（解决外部合法流量的 DNS-Rebinding 400 阻断与同源 host === origin 严格检查）
+                // Direct 外部直连模式下的 Host/Origin 虚拟化
+                const externalProto = getRequestProtocol(req);
                 const hostHeader = req.headers.host || '';
-                const port = hostHeader.includes(':') ? hostHeader.split(':')[1] : '3080';
+                const port = extractPortString(hostHeader) || '3080';
                 req.headers.host = `127.0.0.1:${port}`;
                 if (req.headers.origin) {
-                    req.headers.origin = `http://127.0.0.1:${port}`;
+                    req.headers.origin = `${externalProto}://127.0.0.1:${port}`;
                 }
-                // 补齐浏览器同源探针标记（解决 task-board 等插件对 sec-fetch-site 的检查）
                 if (!req.headers['sec-fetch-site'] || req.headers['sec-fetch-site'] === 'cross-site') {
                     req.headers['sec-fetch-site'] = 'same-origin';
                 }
             }
             else {
-                // 仅归一化本地 Host 变体（localhost / [::1] → 127.0.0.1），其余原样保留供下游校验
+                // 本地回环连接：仅成对规范化本地 Host 变体（localhost / [::1] → 127.0.0.1）
+                // 关键安全原则：仅当 Origin 自身也是本地回环变体时才成对规范化；恶意的跨站 Origin（如 http://evil.com）必须 100% 原样保留！
                 const hostHeader = req.headers.host || '';
-                let bareHost = hostHeader;
-                if (bareHost.startsWith('[')) {
-                    bareHost = bareHost.slice(1).split(']')[0];
-                }
-                else {
-                    bareHost = bareHost.split(':')[0];
-                }
-                bareHost = bareHost.toLowerCase();
-                if (bareHost === 'localhost' || bareHost === '::1' || /^127\./.test(bareHost)) {
-                    const portMatch = hostHeader.match(/:(\d+)$/);
-                    req.headers.host = `127.0.0.1:${portMatch ? portMatch[1] : '3080'}`;
-                    if (req.headers.origin) {
-                        req.headers.origin = `http://${req.headers.host}`;
+                const bareHost = extractBareHostname(hostHeader);
+                const isLocalHostVariant = bareHost === 'localhost' || bareHost === '::1' || /^127\./.test(bareHost);
+                if (isLocalHostVariant) {
+                    const targetPort = extractPortString(hostHeader) || '3080';
+                    req.headers.host = `127.0.0.1:${targetPort}`;
+                    if (req.headers.origin && typeof req.headers.origin === 'string') {
+                        try {
+                            const origUrl = new URL(req.headers.origin);
+                            const origHostname = origUrl.hostname.toLowerCase();
+                            const isLocalOrigin = origHostname === 'localhost' || origHostname === '::1' || /^127\./.test(origHostname);
+                            if (isLocalOrigin) {
+                                req.headers.origin = `${origUrl.protocol}//127.0.0.1:${targetPort}`;
+                            }
+                            // 非本地 Origin（如 evil.com）原样保留，供下游 CSRF 检查
+                        }
+                        catch { }
                     }
                 }
             }
@@ -492,27 +611,54 @@ export function patchHttpServerWithVirtualizer(server, gateMiddleware, _store, s
             // 请求未通过安全门禁，已在门禁层执行重定向或返回 401 拦截
         }
     });
+    // WebSocket Upgrade 不经过上面的 request 监听器；同样需要在校验网关 Secret 后打受信标记，
+    // 否则网关转发的 WS 会因为 X-Forwarded-* 被误判为同机反代，从而在底座再次要求 token。
+    server.prependListener('upgrade', (req) => {
+        try {
+            const upgradeSocketIp = getPhysicalSocketIp(req);
+            const upgradeIsLoopback = upgradeSocketIp === '127.0.0.1' || upgradeSocketIp === '::1';
+            const upgradeSecret = getGatewaySecret(server);
+            if (upgradeIsLoopback &&
+                upgradeSecret &&
+                safeCompareSecret(req.headers['x-dsh-gateway-secret'], upgradeSecret)) {
+                ;
+                req.__dsh_rm_trusted_gateway__ = true;
+                delete req.headers['x-dsh-gateway-secret'];
+            }
+        }
+        catch { }
+    });
 }
 /**
- * 注册 WebServer HTML 模板层的 Polyfill 注入钩子
+ * 注册 WebServer HTML 模板层的样式与 Polyfill 注入钩子（在 Gzip 压缩前执行）
  *
  * @param ctx - Cordis 上下文对象
+ * @param styleStore - 样式片段管理器实例
  */
-export function mountIndexInjections(ctx) {
+export function mountIndexInjections(ctx, styleStore) {
+    if (!ctx || ctx.__dsh_rm_index_mounted__)
+        return;
+    ctx.__dsh_rm_index_mounted__ = true;
+    const injectFn = (html) => {
+        const mobileStyleCss = styleStore ? styleStore.collectCss() : '';
+        // tapIndex 阶段在服务端模板渲染期执行，尚未绑定单次请求的 UA，
+        // 因此 isMobile 设为 false，样式的 collectCss() 自带 @media 视口查询，
+        // PC 与移动端均能完美自适应生效。
+        return injectHtmlPayload(html, false, mobileStyleCss);
+    };
     if (ctx.webServer && typeof ctx.webServer.tapIndex === 'function') {
-        ctx.webServer.tapIndex((html) => {
-            if (html.includes('<head>')) {
-                return html
-                    .replace('<head>', `<head><script id="dsh-crypto-polyfill">${CRYPTO_POLYFILL_SNIPPET}</script>`)
-                    .replace('<head>', `<head><script id="dsh-clipboard-polyfill">${CLIPBOARD_POLYFILL_SNIPPET}</script>`)
-                    // 冲突防护脚本后 replace → 位于 <head> 最前，优先写入 sessionStorage 避免小鲸鱼重复挂载
-                    .replace('<head>', `<head><script id="dsh-force-desktop-suppression">${FORCE_DESKTOP_SUPPRESSION_SNIPPET}</script>`);
-            }
-            return html;
-        });
+        ctx.webServer.tapIndex(injectFn);
     }
     ctx.on?.('webserver/index-inject', (table) => {
         if (Array.isArray(table)) {
+            const mobileStyleCss = styleStore ? styleStore.collectCss() : '';
+            if (mobileStyleCss) {
+                table.push({
+                    kind: 'style',
+                    placement: 'head',
+                    text: mobileStyleCss,
+                });
+            }
             table.push({
                 kind: 'script',
                 placement: 'head',
@@ -528,6 +674,16 @@ export function mountIndexInjections(ctx) {
                 placement: 'head',
                 text: FORCE_DESKTOP_SUPPRESSION_SNIPPET,
             });
+            table.push({
+                kind: 'script',
+                placement: 'head',
+                text: DRAGGABLE_NAV_SNIPPET,
+            });
+            table.push({
+                kind: 'script',
+                placement: 'head',
+                text: MOBILE_DISMISS_SNIPPET,
+            });
         }
     });
 }
@@ -755,16 +911,30 @@ function safeStringEqual(a, b) {
 export function isRequestAuthorizedByGate(req, store) {
     if (!req)
         return false;
+    // 0. WebSocket Upgrade 直连（direct 模式）必须先通过 Host 白名单与 Origin 同源检查。
+    //    网关模式在 GatewayServer.handleUpgrade 中已完成同样的检查，并打上 __dsh_rm_host_allowed__，
+    //    此处避免重复校验，同时确保 direct 模式的核心 WS 不会被 DNS-Rebinding / CSWSH 绕过。
+    const isWebSocketUpgrade = String(req.headers?.upgrade || '').toLowerCase().includes('websocket');
+    if (isWebSocketUpgrade && !req.__dsh_rm_host_allowed__) {
+        if (!isTrustedHost(req.headers.host, store) || hasCrossSiteSignal(req)) {
+            return false;
+        }
+    }
     // 1. 本机 127.0.0.1 / ::1 回环无条件放行
     if (isLoopbackRequest(req))
         return true;
     const clientIp = getClientIp(req);
     const options = store.getOptions();
+    // 反向代理位于 LAN/Tailscale 网段时不能被当作真实客户端免密放行
+    const hasForwardedHeaders = Boolean(req.headers?.['x-forwarded-for'] ||
+        req.headers?.['x-forwarded-host'] ||
+        req.headers?.['x-forwarded-proto'] ||
+        req.headers?.['x-real-ip']);
     // 2. Tailscale 私网免密直连放行
-    if (options.allowTailscale && isTailscaleIp(clientIp))
+    if (!hasForwardedHeaders && options.allowTailscale && isTailscaleIp(clientIp))
         return true;
     // 3. 局域网 LAN 免密直连放行
-    if (options.allowLan && isLanIp(clientIp))
+    if (!hasForwardedHeaders && options.allowLan && isLanIp(clientIp))
         return true;
     // 4. 检查是否携带有效的授权会话 Token (Cookie / Header / URL Token)
     const token = store.extractTokenFromRequest(req);
@@ -834,4 +1004,77 @@ export function takeOverConnectionAuth(connection, store) {
             return origAuthorizeIndex(req, res);
         };
     }
+    // 4. 动态向 DSH 底座 connection.trustedHosts 注入当前本机所有可用 IP 与网关端口
+    // （适配 DSH 0.2.1+ 底层 Host/Origin 信任围栏，使外部网关合规直通，免去伪造 Host 头带来的副作用）
+    injectTrustedHosts(connection, [store.getActivePort(), 3080, 3081], store.getOptions().trustedHosts);
+}
+/**
+ * 向 DSH 运行时（webRuntime、connection、webStartup）的 trustedHosts 数组注入受信任的主机与端口
+ *
+ * @param target - Cordis 上下文对象或包含 trustedHosts 的服务对象
+ * @param ports - 允许访问的活跃端口（包含底座端口与网关实际绑定端口）
+ * @param staticTrustedHosts - 用户静态配置的白名单（如 Tailscale MagicDNS 域名等）
+ */
+export function injectTrustedHosts(target, ports = [3080, 3081], staticTrustedHosts = []) {
+    if (!target)
+        return;
+    const arraysToInject = [];
+    // 1. 如果 target 本身带有 trustedHosts 数组（如 connection 或 webRuntime）
+    if (Array.isArray(target.trustedHosts)) {
+        arraysToInject.push(target.trustedHosts);
+    }
+    // 2. 如果 target 是 Cordis 上下文 ctx，检查并提取各子服务的 trustedHosts
+    try {
+        const wr = (typeof target.get === 'function' ? target.get('webRuntime') : undefined) || target.webRuntime;
+        if (wr && Array.isArray(wr.trustedHosts) && !arraysToInject.includes(wr.trustedHosts)) {
+            arraysToInject.push(wr.trustedHosts);
+        }
+        const conn = (typeof target.get === 'function' ? target.get('connection') : undefined) || target.connection;
+        if (conn && Array.isArray(conn.trustedHosts) && !arraysToInject.includes(conn.trustedHosts)) {
+            arraysToInject.push(conn.trustedHosts);
+        }
+        const ws = (typeof target.get === 'function' ? target.get('webStartup') : undefined) || target.webStartup;
+        if (ws && Array.isArray(ws.trustedHosts) && !arraysToInject.includes(ws.trustedHosts)) {
+            arraysToInject.push(ws.trustedHosts);
+        }
+    }
+    catch { }
+    if (arraysToInject.length === 0)
+        return;
+    try {
+        const netIps = getAllNetworkIps().map((i) => i.ip);
+        // 规范化静态配置的主机名：去除端口、去除末尾点、过滤通配符
+        const cleanStatics = (staticTrustedHosts || [])
+            .map((h) => {
+            let raw = String(h).trim().toLowerCase().replace(/\.$/, '');
+            if (raw.startsWith('[')) {
+                const closeBracket = raw.indexOf(']');
+                if (closeBracket !== -1)
+                    raw = raw.slice(1, closeBracket);
+            }
+            else if (raw.includes(':')) {
+                raw = raw.split(':')[0];
+            }
+            return raw.trim();
+        })
+            .filter((h) => h && h !== '0.0.0.0' && h !== '::');
+        const candidates = ['127.0.0.1', 'localhost', '::1', ...netIps, ...cleanStatics];
+        for (const arr of arraysToInject) {
+            for (const hostItem of candidates) {
+                if (!arr.includes(hostItem)) {
+                    arr.push(hostItem);
+                }
+                for (const port of ports) {
+                    if (!port)
+                        continue;
+                    const isIpv6 = hostItem.includes(':') && !hostItem.startsWith('[');
+                    const withPort = isIpv6 ? `[${hostItem}]:${port}` : `${hostItem}:${port}`;
+                    if (!arr.includes(withPort)) {
+                        arr.push(withPort);
+                    }
+                }
+            }
+        }
+    }
+    catch { }
 }

package/lib/bridge/directory-picker.d.ts

@@ -0,0 +1,118 @@
+/**
+ * DSH 目录选择器（Directory Picker）配置检测与幂等补丁管理模块
+ *
+ * 【背景与问题】
+ * DSH 官方默认的 `id: directory-picker`（`@deepseek-ai/dsh-host-directory-picker-auto`）
+ * 仅在进程启动时根据 `webServer.host` 是否为 127.0.0.1 回环地址来判断“本机 / 远程”：
+ * - 本插件默认采用安全接入代理模式（DSH 核心保持 127.0.0.1:3080 回环，由 3081 代理对外）；
+ * - `auto` 因此将所有来自手机端 3081 的请求误判为“本机桌面操作”，直接调用 PC 的系统原生文件选择窗（native）；
+ * - 最终导致弹窗出现在 PC 屏幕上，手机浏览器一直转圈等待，无法在手机端选择文件夹或添加工作区。
+ *
+ * 【解决方案】
+ * 1. 运行时检测：结合 Cordis loader 激活树与 `~/.dsh/profiles/web/cordis.patch.yml` 配置文件，
+ *    精准判断当前是否已启用网页内目录选择器（`browse` 模式）；
+ * 2. 幂等补丁写入：支持在设置页一键开启/恢复，写入时对 `directory-picker`、`directory-picker-browse`、
+ *    `ui-directory-picker-browse` 三项分别执行严格结构化去重，绝不产生重复条目，且完整保留用户其它配置。
+ */
+export declare const AUTO_DIRECTORY_PICKER_ID = "directory-picker";
+export declare const AUTO_DIRECTORY_PICKER_PKG = "@deepseek-ai/dsh-host-directory-picker-auto";
+export declare const HOST_DIRECTORY_PICKER_BROWSE_ID = "directory-picker-browse";
+export declare const HOST_DIRECTORY_PICKER_BROWSE_PKG = "@deepseek-ai/dsh-host-directory-picker-browse";
+export declare const UI_DIRECTORY_PICKER_BROWSE_ID = "ui-directory-picker-browse";
+export declare const UI_DIRECTORY_PICKER_BROWSE_PKG = "@deepseek-ai/dsh-client-ui-directory-picker-browse";
+/** 标准可复制/可注入的 YAML 配置片段 */
+export declare const DIRECTORY_PICKER_YAML_SNIPPET: string;
+export interface DirectoryPickerPatchInspection {
+    /** `- id: directory-picker` 是否已设置 `disabled: true` */
+    autoDisabled: boolean;
+    /** 是否存在 `- id: directory-picker` 条目 */
+    hasAutoEntry: boolean;
+    /** `@deepseek-ai/dsh-host-directory-picker-browse` 是否已插入且未禁用 */
+    hostBrowseInserted: boolean;
+    /** `@deepseek-ai/dsh-client-ui-directory-picker-browse` 是否已插入且未禁用 */
+    uiBrowseInserted: boolean;
+    /** 三项配置是否已在 patch 文件中全部就绪 */
+    configured: boolean;
+    /** 是否仅配置了其中一部分（缺失其余项） */
+    partial: boolean;
+}
+export interface DirectoryPickerRuntimeInspection {
+    /** 是否能够从 Cordis loader 探测到目录选择器相关条目 */
+    detected: boolean;
+    /** 运行时中 `browse` 目录选择器（前后端）是否已激活生效 */
+    browseActive: boolean;
+    /** 运行时中 `auto` 目录选择器是否仍处于启用状态 */
+    autoActive: boolean;
+}
+export interface DirectoryPickerStatus {
+    /** 配置文件中是否已完整开启 browse 补丁 */
+    patchEnabled: boolean;
+    /** 配置文件中是否仅开启了部分项 */
+    patchPartial: boolean;
+    /** 当前运行时中网页目录选择器是否已生效 */
+    runtimeActive: boolean;
+    /** 配置已变更但当前进程尚未生效（需要重启 DSH 或等待 HMR 重载） */
+    restartRequired: boolean;
+    /** 当前是否需要向用户展示醒目提醒（回环核心且未开启 browse 时为 true） */
+    needsWarning: boolean;
+    /** 目标 cordis.patch.yml 的绝对路径 */
+    patchFilePath: string;
+    /** 标准可复制的 YAML 配置片段 */
+    yamlSnippet: string;
+}
+/**
+ * 绑定 Cordis 运行时上下文与回环核心判定函数（供 /status 路由实时查询）
+ */
+export declare function bindDirectoryPickerRuntime(ctx: any, isLoopbackCore?: () => boolean): void;
+/**
+ * 定位当前 DSH 的 web profile `cordis.patch.yml` 路径
+ *
+ * 优先使用 `~/.dsh/profiles/web/cordis.patch.yml`；若存在其他单 profile 则按优先级兜底。
+ */
+export declare function resolveDirectoryPickerPatchPath(customPath?: string): string;
+/**
+ * 解析 `cordis.patch.yml` 文本内容，检查目录选择器相关配置状态
+ */
+export declare function inspectDirectoryPickerPatchContent(content: string): DirectoryPickerPatchInspection;
+/**
+ * 检查 Cordis 运行时 loader 中的目录选择器插件激活状态
+ */
+export declare function inspectRuntimeDirectoryPicker(ctx?: any): DirectoryPickerRuntimeInspection;
+/**
+ * 幂等合并网页目录选择器配置到 `cordis.patch.yml` 内容中（严格去重）
+ *
+ * 去重规则：
+ * 1. 若已存在一个或多个 `- id: directory-picker`：就地将其设为 `disabled: true`，合并重复项；
+ * 2. 若已存在 `directory-picker-browse` 或 `ui-directory-picker-browse`（无论在哪个 `insert` 块下）：
+ *    不重复插入，仅补充缺失的那一项（若原项被设为 `disabled: true` 则移除禁用标记）；
+ * 3. 若三项均已就绪，原样返回，`changed: false`。
+ */
+export declare function applyDirectoryPickerBrowsePatch(rawContent: string): {
+    content: string;
+    changed: boolean;
+};
+/**
+ * 从 `cordis.patch.yml` 内容中安全移除网页目录选择器补丁（恢复 PC 原生目录选择器）
+ *
+ * 仅移除与 directory-picker 相关的禁用项与两个 browse 插入项，100% 保留用户其他配置。
+ */
+export declare function removeDirectoryPickerBrowsePatch(rawContent: string): {
+    content: string;
+    changed: boolean;
+};
+/**
+ * 获取目录选择器当前综合状态（供 `/api/remote-mobile/status` 与设置页消费）
+ */
+export declare function getDirectoryPickerStatus(customPatchPath?: string): DirectoryPickerStatus;
+/**
+ * 在目标 `cordis.patch.yml` 中一键开启网页目录选择器（幂等去重）
+ */
+export declare function enableDirectoryPickerBrowse(customPatchPath?: string): DirectoryPickerStatus & {
+    changed: boolean;
+};
+/**
+ * 从目标 `cordis.patch.yml` 中移除网页目录选择器配置（恢复 PC 原生目录选择器）
+ */
+export declare function disableDirectoryPickerBrowse(customPatchPath?: string): DirectoryPickerStatus & {
+    changed: boolean;
+};