rdsh-gateway 0.6.0 → 0.8.0

package/dist/access-gate.d.ts

@@ -0,0 +1,13 @@
+/** 网关访问 cookie 名（hub 侧 relay 白名单同名硬编码，注释互指）。 */
+export declare const GATE_COOKIE = "rdsh_gate";
+/** 访问 cookie 有效期（对齐 host cookie 7 天）。 */
+export declare const GATE_COOKIE_TTL_MS: number;
+/** 签发访问 cookie；返回 value + 过期时间（毫秒）。 */
+export declare function signGateCookie(accessCode: string, now?: number): {
+    value: string;
+    expiresAt: number;
+};
+/** 验签访问 cookie：签名（恒定时间）+ 未过期。 */
+export declare function verifyGateCookie(accessCode: string, value: string, now?: number): boolean;
+/** code 恒定时间比对（对 sha256 摘要比较，避免长度侧信道）。 */
+export declare function verifyGateCode(input: string, accessCode: string): boolean;

package/dist/access-gate.js

@@ -0,0 +1,49 @@
+/**
+ * access-gate.ts — host 侧访问口令（feature 15）：访问 cookie 签发/验签 + code 恒定时间比对。
+ *
+ * - cookie 名 `rdsh_gate`（hub relay D12 白名单需同名透传，见 packages/hub/src/relay.ts）；
+ * - 无状态验签：HMAC-SHA256(payload, key=sha256(accessCode))，payload = `${exp}.${nonce}`；
+ * - 改 code → key 变 → 旧 cookie 全失效（无需版本/黑名单）。
+ */
+import { createHmac, createHash, randomBytes, timingSafeEqual } from "node:crypto";
+/** 网关访问 cookie 名（hub 侧 relay 白名单同名硬编码，注释互指）。 */
+export const GATE_COOKIE = "rdsh_gate";
+/** 访问 cookie 有效期（对齐 host cookie 7 天）。 */
+export const GATE_COOKIE_TTL_MS = 7 * 24 * 60 * 60 * 1000;
+/** 派生 HMAC 密钥：sha256(accessCode)（改 code 即吊销旧 cookie）。 */
+function keyFor(accessCode) {
+    return createHash("sha256").update(accessCode).digest();
+}
+function hmac(payload, accessCode) {
+    return createHmac("sha256", keyFor(accessCode)).update(payload).digest("base64url");
+}
+/** 签发访问 cookie；返回 value + 过期时间（毫秒）。 */
+export function signGateCookie(accessCode, now = Date.now()) {
+    const exp = now + GATE_COOKIE_TTL_MS;
+    const nonce = randomBytes(16).toString("base64url");
+    const payload = `${exp}.${nonce}`;
+    return { value: `${payload}.${hmac(payload, accessCode)}`, expiresAt: exp };
+}
+/** 验签访问 cookie：签名（恒定时间）+ 未过期。 */
+export function verifyGateCookie(accessCode, value, now = Date.now()) {
+    const parts = value.split(".");
+    if (parts.length !== 3)
+        return false;
+    const [expStr, nonce, sig] = parts;
+    if (expStr === "" || nonce === "" || sig === "")
+        return false;
+    const exp = Number(expStr);
+    if (!Number.isFinite(exp) || exp <= now)
+        return false;
+    const payload = `${expStr}.${nonce}`;
+    const expected = Buffer.from(hmac(payload, accessCode));
+    const actual = Buffer.from(sig);
+    return actual.length === expected.length && timingSafeEqual(actual, expected);
+}
+/** code 恒定时间比对（对 sha256 摘要比较，避免长度侧信道）。 */
+export function verifyGateCode(input, accessCode) {
+    const a = createHash("sha256").update(input).digest();
+    const b = createHash("sha256").update(accessCode).digest();
+    return timingSafeEqual(a, b);
+}
+//# sourceMappingURL=access-gate.js.map

package/dist/config.d.ts

@@ -32,6 +32,12 @@ export interface RdshConfig {
     insecure?: boolean;
     /** DSH UI 兼容开关（跟随 E2EE；trustE2EEAsLoopback 默认 true） */
     dshUiCompat?: DshUiCompat;
+    /** 网关访问口令（host 侧独立于 hub 的访问保护） */
+    gateway?: GatewayConfig;
+}
+/** 网关访问口令：accessCode 缺失/null/"" → null（gate off）；非空 ≥4 位（gate on）。 */
+export interface GatewayConfig {
+    accessCode: string | null;
 }
 /** DSH UI 兼容：把经隧道访问的前端 isLoopback 判定视为 loopback，使 Models/设置持久化可用。 */
 export interface DshUiCompat {

package/dist/config.js

@@ -22,6 +22,7 @@ const DEFAULTS = {
     allowFrom: [],
     auth: DEFAULT_AUTH,
     dshUiCompat: { trustE2EEAsLoopback: true },
+    gateway: { accessCode: null },
 };
 /** 解析配置文件路径（--config > $RDSH_CONFIG > 默认 host.json）。 */
 export function resolveConfigPath(cliPath, env = process.env) {
@@ -188,6 +189,20 @@ export function normalizeConfig(raw, source = "config") {
             out.dshUiCompat = { trustE2EEAsLoopback: compat.trustE2EEAsLoopback };
         }
     }
+    // ---- gateway（访问口令；缺省 accessCode null = gate off）----
+    if (cfg.gateway !== undefined) {
+        if (typeof cfg.gateway !== "object" || cfg.gateway === null)
+            throw new Error(`${source}: "gateway" must be an object`);
+        const g = cfg.gateway;
+        // 折叠语义：缺失 / null / "" → null（gate off）；非空字符串 → ≥4 位（gate on）
+        if (g.accessCode !== undefined && g.accessCode !== null && g.accessCode !== "") {
+            if (typeof g.accessCode !== "string")
+                throw new Error(`${source}: "gateway.accessCode" must be a string`);
+            if (g.accessCode.length < 4)
+                throw new Error(`${source}: "gateway.accessCode" must be at least 4 chars`);
+            out.gateway = { accessCode: g.accessCode };
+        }
+    }
     return out;
 }
 function assertString(v, field, source) {

package/dist/index.d.ts

@@ -10,7 +10,7 @@ export type { SessionPayload } from "./session.ts";
 export { PairManager } from "./pair.ts";
 export { startGateway } from "./server.ts";
 export type { GatewayOptions, RunningGateway } from "./server.ts";
-export { findDsh, spawnDsh } from "./spawn-dsh.ts";
+export { findDsh, spawnDsh, exchangeDshSessionCookie, detectDshVersion, compareDshVersions, dshVersionWarning, DSH_COMPAT_MIN, DSH_COMPAT_MAX } from "./spawn-dsh.ts";
 export type { SpawnedDsh } from "./spawn-dsh.ts";
 export { forwardHttp, createUpgradeProxy, rewriteHeadersForDsh } from "./proxy.ts";
 export type { ProxyTarget } from "./proxy.ts";
@@ -24,7 +24,7 @@ export { loginPageHtml } from "./login-page.ts";
 export { installService, uninstallService, serviceStatus, systemdUnit, launchdPlist, SERVICE_NAME, JOIN_SERVICE_NAME, HOST_SERVICE_NAME, HUB_SERVICE_NAME } from "./service.ts";
 export type { ServiceSpec } from "./service.ts";
 export declare const NAME = "rdsh-gateway";
-export { join, startJoin, registerJoin, detectInsecure, selfRevoke } from "./join.ts";
+export { join, startJoin, registerJoin, detectInsecure, selfRevoke, patchLoopbackJs } from "./join.ts";
 export type { JoinOptions, RegisterOutcome, JoinState, JoinHooks, StartJoinOptions, JoinHandle } from "./join.ts";
 export { readPersistedToken, clearPersistedToken } from "./token-store.ts";
 export { acquireJoinLock, releaseJoinLock, readJoinLock, JOIN_LOCK_PATH } from "./lock.ts";

package/dist/index.js

@@ -7,7 +7,7 @@ export { serve } from "./serve.js";
 export { SessionManager, SESSION_COOKIE, sessionTokenFromCookie } from "./session.js";
 export { PairManager } from "./pair.js";
 export { startGateway } from "./server.js";
-export { findDsh, spawnDsh } from "./spawn-dsh.js";
+export { findDsh, spawnDsh, exchangeDshSessionCookie, detectDshVersion, compareDshVersions, dshVersionWarning, DSH_COMPAT_MIN, DSH_COMPAT_MAX } from "./spawn-dsh.js";
 export { forwardHttp, createUpgradeProxy, rewriteHeadersForDsh } from "./proxy.js";
 export { loadConfig, normalizeConfig, resolveConfigPath, saveConfig, DEFAULT_HOST_CONFIG_PATH } from "./config.js";
 export { hashPassword, verifyPassword, UserManager } from "./auth.js";
@@ -16,7 +16,7 @@ export { loadTls } from "./tls.js";
 export { loginPageHtml } from "./login-page.js";
 export { installService, uninstallService, serviceStatus, systemdUnit, launchdPlist, SERVICE_NAME, JOIN_SERVICE_NAME, HOST_SERVICE_NAME, HUB_SERVICE_NAME } from "./service.js";
 export const NAME = "rdsh-gateway";
-export { join, startJoin, registerJoin, detectInsecure, selfRevoke } from "./join.js";
+export { join, startJoin, registerJoin, detectInsecure, selfRevoke, patchLoopbackJs } from "./join.js";
 export { readPersistedToken, clearPersistedToken } from "./token-store.js";
 export { acquireJoinLock, releaseJoinLock, readJoinLock, JOIN_LOCK_PATH } from "./lock.js";
 //# sourceMappingURL=index.js.map

package/dist/join.d.ts

@@ -16,6 +16,10 @@ export interface JoinOptions {
     dshUiCompat?: {
         trustE2EEAsLoopback?: boolean;
     };
+    /** 网关访问口令（feature 15；accessCode null = 关闭） */
+    gateway?: {
+        accessCode?: string | null;
+    };
 }
 /** 注册/接入结果：解析出的 host token + 是否需 insecure + 生效的主机名（缺省=机器 hostname）。 */
 export interface RegisterOutcome {
@@ -50,12 +54,22 @@ export interface StartJoinOptions {
     dshUiCompat?: {
         trustE2EEAsLoopback?: boolean;
     };
+    /** 网关访问口令（feature 15；accessCode null = 关闭） */
+    gateway?: {
+        accessCode?: string | null;
+    };
+    /** 主机名（challenge 页展示；缺省「本主机」） */
+    name?: string;
+    /** 宿主代持的 dsh 浏览器会话 cookie（`dsh-auth-*`，0.1.2+）；有值时注入隧道→本地转发 */
+    dshAuthCookieHeader?: string | null;
 }
 /** 可停止的 join 隧道句柄。 */
 export interface JoinHandle {
     stop(): Promise<void>;
     /** 运行中切换 DSH UI 兼容（trustE2EEAsLoopback）；下一个请求即生效。 */
     setUiCompat(trustE2EEAsLoopback: boolean): void;
+    /** 运行中设置/清除访问口令（null = 关闭 gate）；下一个请求即生效。 */
+    setAccessCode(code: string | null): void;
 }
 /** 探测 hub 是否需 insecure：以严格校验握手一次；证书错误 → true（需 insecure）。 */
 export declare function detectInsecure(hubUrl: string): Promise<boolean>;

package/dist/join.js

@@ -14,12 +14,13 @@ import { request as httpsRequest } from "node:https";
 import { hostname as osHostname } from "node:os";
 import { WebSocket } from "ws";
 import { FrameParser, FRAME_TYPE, encodeFrame, jsonPayload, parseJsonPayload, FLAG_E2E } from "rdsh-tunnel";
-import { findDsh, spawnDsh } from "./spawn-dsh.js";
+import { findDsh, spawnDsh, exchangeDshSessionCookie, detectDshVersion, dshVersionWarning } from "./spawn-dsh.js";
 import { rewriteHeadersForDsh } from "./proxy.js";
 import { clearPersistedToken, persistToken, readPersistedToken } from "./token-store.js";
 import { acquireJoinLock, releaseJoinLock } from "./lock.js";
 import { responderHandshake, Aead } from "./e2ee.js";
 import { loadOrCreateE2eeKeyPair } from "./e2ee-key-store.js";
+import { GATE_COOKIE, signGateCookie, verifyGateCookie, verifyGateCode } from "./access-gate.js";
 /** 判断错误是否为 TLS 证书类错误（自签/过期/域名不匹配）。 */
 function isCertError(err) {
     const code = err?.code ?? "";
@@ -146,11 +147,57 @@ export function patchLoopbackJs(body) {
         return null;
     return Buffer.from(src.split(target).join("true"), "utf8");
 }
+/** 从转发头里取 Accept-Language（数组取首个，缺失 undefined）。 */
+function headerAcceptLanguage(headers) {
+    const al = headers["accept-language"];
+    return Array.isArray(al) ? al.join(",") : typeof al === "string" ? al : undefined;
+}
+/** HTML 转义（challenge 页内插 hostName/actionPath 防注入；actionPath 经 hub URL 解析已 percent-encoded，此处为纵深防御）。 */
+function escapeHtml(s) {
+    return s
+        .replaceAll("&", "&")
+        .replaceAll("<", "&lt;")
+        .replaceAll(">", "&gt;")
+        .replaceAll('"', "&quot;")
+        .replaceAll("'", "&#39;");
+}
+/** 访问口令 challenge 页（内联，零外部依赖；经隧道在 hub 域名下展示；Accept-Language 含 zh → 中文，否则英文兜底）。 */
+function gateChallengeHtml(hostName, actionPath, error, acceptLanguage) {
+    const safeHost = escapeHtml(hostName);
+    const safePath = escapeHtml(actionPath);
+    const zh = typeof acceptLanguage === "string" && /zh/i.test(acceptLanguage);
+    const t = zh
+        ? { title: "访问密码", heading: `主机「${safeHost}」受访问密码保护`, note: "此密码由主机所有者设置，hub 无法绕过。", placeholder: "请输入访问密码", submit: "进入", wrong: "访问密码错误", locked: "尝试次数过多，请稍后再试" }
+        : { title: "Access code", heading: `Host "${safeHost}" is protected by an access code`, note: "This code is set by the host owner; the hub cannot bypass it.", placeholder: "Enter access code", submit: "Enter", wrong: "Incorrect access code", locked: "Too many attempts — please try again later" };
+    const errHtml = error === null ? "" : `<p style="color:#dc2626;font-size:13px;margin:10px 0 0">${error === "wrong" ? t.wrong : t.locked}</p>`;
+    return (`<!doctype html><html lang="${zh ? "zh-CN" : "en"}"><meta charset="utf-8"><meta name="viewport" content="width=device-width,initial-scale=1">` +
+        `<title>${t.title}</title>` +
+        `<body style="font-family:system-ui,sans-serif;background:#f6f7f9;margin:0">` +
+        `<div style="max-width:360px;margin:64px auto;background:#fff;border:1px solid #e5e7eb;border-radius:12px;padding:24px">` +
+        `<h1 style="font-size:18px;margin:0 0 8px">${t.heading}</h1>` +
+        `<p style="font-size:13px;color:#6b7280;margin:0 0 16px">${t.note}</p>` +
+        `<form method="POST" action="${safePath}">` +
+        `<input name="gate_code" type="password" autocomplete="off" autofocus placeholder="${t.placeholder}" style="width:100%;box-sizing:border-box;height:38px;border:1px solid #d1d5db;border-radius:8px;padding:0 12px;font-size:14px">` +
+        `<button type="submit" style="width:100%;margin-top:12px;height:38px;border:none;border-radius:8px;background:#2563eb;color:#fff;font-size:14px;cursor:pointer">${t.submit}</button>` +
+        `</form>${errHtml}</div></body></html>`);
+}
+/** 发送合成的 HTTP 响应帧（gateway 不触达 dsh）。 */
+function sendSyntheticHttp(send, streamId, status, headers, body) {
+    send(encodeFrame(FRAME_TYPE.OPEN, streamId, jsonPayload({ kind: "http", status, reason: undefined, headers })));
+    send(encodeFrame(FRAME_TYPE.DATA, streamId, body));
+    send(encodeFrame(FRAME_TYPE.CLOSE, streamId, jsonPayload({ code: 0 })));
+}
 export function startJoin(opts) {
     const hubWsBase = opts.hubUrl.replace(/^https/, "wss").replace(/^http/, "ws");
     const hooks = opts.hooks ?? {};
+    // 宿主代持的 dsh 会话 cookie（0.1.2+）；null = 无认证（0.1.1）或换发失败
+    const dshAuthCookie = opts.dshAuthCookieHeader ?? null;
     // DSH UI 兼容开关：缺省 true（跟随 E2EE）；可变引用 → 运行中可切换（插件面板即时生效）
     const uiCompat = { trustE2EEAsLoopback: opts.dshUiCompat?.trustE2EEAsLoopback !== false };
+    // 访问口令（feature 15）：可变引用 → setAccessCode 运行中切换；null = gate off
+    const gate = { accessCode: opts.gateway?.accessCode ?? null };
+    const hostName = opts.name ?? "本主机";
+    const gateFailures = { count: 0, lockedUntil: 0 };
     const log = (level, message) => {
         hooks.onLog?.(level, message);
     };
@@ -176,6 +223,66 @@ export function startJoin(opts) {
     function makeInnerDispatcher(send, dio) {
         const httpStreams = new Map();
         const wsStreams = new Map();
+        // gate 未过、等待 code 提交的 http 流（OPEN 后缓冲 DATA，CLOSE 时校验）
+        const gatedHttp = new Map();
+        /** 从转发头里取 rdsh_gate cookie（hub D12 白名单透传）。 */
+        function gateCookie(headers) {
+            const ck = headers["cookie"];
+            const s = Array.isArray(ck) ? ck.join(";") : typeof ck === "string" ? ck : "";
+            for (const part of s.split(";")) {
+                const idx = part.indexOf("=");
+                if (idx <= 0)
+                    continue;
+                if (part.slice(0, idx).trim() === GATE_COOKIE)
+                    return part.slice(idx + 1).trim();
+            }
+            return null;
+        }
+        /** gate 开启时的失败计数：全局封顶，达限短时锁定（隧道流量无真实客户端 IP）。 */
+        function gateBlocked() {
+            if (gateFailures.lockedUntil > Date.now())
+                return true;
+            if (gateFailures.lockedUntil !== 0)
+                gateFailures.lockedUntil = 0;
+            return false;
+        }
+        /** 发送 challenge 页（或带错误）响应。 */
+        function sendChallenge(streamId, path, error, acceptLanguage) {
+            const html = gateChallengeHtml(hostName, path, error, acceptLanguage);
+            sendSyntheticHttp(send, streamId, 200, { "content-type": "text/html; charset=utf-8" }, Buffer.from(html));
+        }
+        /** 校验 code 提交（POST gate_code）→ 302 回跳 + 发 cookie，或回 challenge 错误。 */
+        function handleGateSubmit(streamId, state) {
+            const code = gate.accessCode;
+            if (code === null) {
+                sendSyntheticHttp(send, streamId, 302, { location: state.path }, Buffer.alloc(0));
+                return;
+            }
+            if (gateBlocked()) {
+                sendChallenge(streamId, state.path, "locked", state.acceptLanguage);
+                return;
+            }
+            const raw = Buffer.concat(state.body).toString("utf8");
+            let input = null;
+            try {
+                const params = new URLSearchParams(raw);
+                input = params.get("gate_code");
+            }
+            catch {
+                input = null;
+            }
+            if (input !== null && verifyGateCode(input, code)) {
+                gateFailures.count = 0;
+                const { value } = signGateCookie(code);
+                sendSyntheticHttp(send, streamId, 302, { location: state.path, "set-cookie": `${GATE_COOKIE}=${value}; HttpOnly; SameSite=Lax; Path=/; Max-Age=${7 * 24 * 3600}` }, Buffer.alloc(0));
+            }
+            else {
+                gateFailures.count += 1;
+                if (gateFailures.count >= 10)
+                    gateFailures.lockedUntil = Date.now() + 60_000;
+                sendChallenge(streamId, state.path, "wrong", state.acceptLanguage);
+            }
+        }
         function closeStream(streamId) {
             const ws = wsStreams.get(streamId);
             if (ws !== undefined) {
@@ -196,7 +303,7 @@ export function startJoin(opts) {
         }
         function openWsStream(streamId, path, headers) {
             const upstream = new WebSocket(`ws://${opts.target.host}:${opts.target.port}${path}`, {
-                headers: rewriteHeadersForDsh(headers, opts.target),
+                headers: rewriteHeadersForDsh(headers, opts.target, dshAuthCookie),
             });
             const queue = [];
             wsStreams.set(streamId, { upstream, queue });
@@ -239,6 +346,28 @@ export function startJoin(opts) {
                 send(encodeFrame(FRAME_TYPE.ERROR, frame.streamId, jsonPayload({ code: "BAD_OPEN", message: "malformed open" })));
                 return;
             }
+            // ---- 访问口令 gate（仅 plain dispatcher：dio.gate=true 且已设 accessCode）----
+            if (dio?.gate === true && gate.accessCode !== null) {
+                const code = gate.accessCode;
+                const authed = verifyGateCookie(code, gateCookie(headers) ?? "");
+                if (kind === "ws") {
+                    if (!authed) {
+                        send(encodeFrame(FRAME_TYPE.CLOSE, frame.streamId, jsonPayload({ code: 403, message: "access code required" })));
+                        return;
+                    }
+                    openWsStream(frame.streamId, path, headers);
+                    return;
+                }
+                if (!authed) {
+                    if (method === "POST") {
+                        // 可能是 code 提交：缓冲 body，CLOSE 时校验（见 handleFrame）
+                        gatedHttp.set(frame.streamId, { method, path, body: [], size: 0, acceptLanguage: headerAcceptLanguage(headers) });
+                        return;
+                    }
+                    sendChallenge(frame.streamId, path, null, headerAcceptLanguage(headers));
+                    return;
+                }
+            }
             if (kind === "ws") {
                 openWsStream(frame.streamId, path, headers);
                 return;
@@ -253,7 +382,7 @@ export function startJoin(opts) {
                 port: opts.target.port,
                 path,
                 method,
-                headers: rewriteHeadersForDsh(headers, opts.target),
+                headers: rewriteHeadersForDsh(headers, opts.target, dshAuthCookie),
             }, (upRes) => {
                 send(encodeFrame(FRAME_TYPE.OPEN, streamId, jsonPayload({
                     kind: "http",
@@ -305,6 +434,16 @@ export function startJoin(opts) {
                     return;
                 }
                 case FRAME_TYPE.DATA: {
+                    const gated = gatedHttp.get(frame.streamId);
+                    if (gated !== undefined) {
+                        gated.body.push(frame.payload);
+                        gated.size += frame.payload.length;
+                        if (gated.size > 64 * 1024) {
+                            gatedHttp.delete(frame.streamId);
+                            send(encodeFrame(FRAME_TYPE.CLOSE, frame.streamId, jsonPayload({ code: 413, message: "body too large" })));
+                        }
+                        return;
+                    }
                     const ws = wsStreams.get(frame.streamId);
                     if (ws !== undefined) {
                         if (ws.upstream.readyState === ws.upstream.OPEN)
@@ -320,6 +459,13 @@ export function startJoin(opts) {
                 }
                 case FRAME_TYPE.CLOSE:
                 case FRAME_TYPE.ERROR: {
+                    const gated = gatedHttp.get(frame.streamId);
+                    if (gated !== undefined) {
+                        gatedHttp.delete(frame.streamId);
+                        if (frame.type === FRAME_TYPE.CLOSE)
+                            handleGateSubmit(frame.streamId, gated);
+                        return;
+                    }
                     closeStream(frame.streamId);
                     return;
                 }
@@ -346,10 +492,11 @@ export function startJoin(opts) {
                 }
             }
             wsStreams.clear();
+            gatedHttp.clear();
         }
         return { handleFrame, cleanup };
     }
-    const plainDispatcher = makeInnerDispatcher(sendTunnelFrame, { jsPatch: () => uiCompat.trustE2EEAsLoopback });
+    const plainDispatcher = makeInnerDispatcher(sendTunnelFrame, { jsPatch: () => uiCompat.trustE2EEAsLoopback, gate: true });
     // host 端 E2EE 静态密钥对（持久化 ~/.rdsh/e2ee-key.json；join 注册时上送指纹）
     const hostE2eeKeypair = loadOrCreateE2eeKeyPair();
     const rawStreams = new Map();
@@ -458,8 +605,9 @@ export function startJoin(opts) {
     function connect() {
         if (shuttingDown)
             return;
-        const url = `${hubWsBase}/tunnel?token=${encodeURIComponent(opts.token)}`;
-        const client = new WebSocket(url, { rejectUnauthorized: !opts.insecure });
+        // 认证走 Authorization 头（不入 URL，避免 token 进日志）
+        const url = `${hubWsBase}/tunnel`;
+        const client = new WebSocket(url, { headers: { authorization: `Bearer ${opts.token}` }, rejectUnauthorized: !opts.insecure });
         currentClient = client;
         setState("connecting", { message: `connecting to ${opts.hubUrl}` });
         // 401/403 = token 被拒（吊销/不存在）。监听此事件后 ws 不再自动 abort，
@@ -541,6 +689,12 @@ export function startJoin(opts) {
             uiCompat.trustE2EEAsLoopback = trustE2EEAsLoopback;
             console.log(`rdsh join: dshUiCompat.trustE2EEAsLoopback = ${trustE2EEAsLoopback}（运行中生效）`);
         },
+        setAccessCode(code) {
+            gate.accessCode = code;
+            gateFailures.count = 0;
+            gateFailures.lockedUntil = 0;
+            console.log(`rdsh join: accessCode = ${code === null ? "(off)" : "***"}（运行中生效）`);
+        },
         async stop() {
             if (shuttingDown)
                 return;
@@ -565,10 +719,23 @@ export async function join(opts) {
     if (foundDsh === null) {
         throw new Error("cannot find 'dsh' in PATH. Install DeepSeek Harness first, or pass --dsh <path>.");
     }
+    // 版本窗口外 → warn（不硬拒）
+    const dshVersion = await detectDshVersion(foundDsh);
+    const versionWarn = dshVersionWarning(dshVersion);
+    if (versionWarn !== null)
+        console.warn(`\n⚠  ${versionWarn}\n`);
     const dsh = await spawnDsh(foundDsh);
     const target = { host: "127.0.0.1", port: dsh.port };
+    // 0.1.2+：换发浏览器会话 cookie 并代持注入隧道→本地转发
+    let dshAuthCookieHeader = null;
+    if (dsh.authToken !== undefined) {
+        dshAuthCookieHeader = await exchangeDshSessionCookie(dsh.port, dsh.authToken);
+        if (dshAuthCookieHeader === null) {
+            console.warn("rdsh join: dsh 0.1.2+ 会话 cookie 换发失败——远程访问将返回 401。");
+        }
+    }
     // 解析 host token（含证书自动检测 + 持久化）；进程重启后复用，避免重复配对。
-    const { token, insecure } = await registerJoin(opts);
+    const { token, insecure, name } = await registerJoin(opts);
     console.log(`rdsh join: dsh web on 127.0.0.1:${dsh.port}`);
     console.log(`rdsh join: connecting to ${opts.hubUrl}...`);
     const handle = startJoin({
@@ -578,6 +745,9 @@ export async function join(opts) {
         target,
         role: "cli",
         dshUiCompat: opts.dshUiCompat,
+        gateway: opts.gateway,
+        dshAuthCookieHeader,
+        name,
         hooks: {
             onLog: (level, message) => {
                 (level === "error" ? console.error : console.log)(`rdsh join: ${message}`);

package/dist/proxy.d.ts

@@ -11,14 +11,23 @@ export interface ForwardOptions {
      * （DSH 浏览器侧 RPC 依赖它），用非 secure context 也可用的 getRandomValues polyfill。
      */
     htmlInject?: string;
+    /**
+     * 宿主代持的 dsh 浏览器会话 cookie（`dsh-auth-<sha256(authority)>`，0.1.2+）。
+     * 提供时合并进每个转发/升级请求的 cookie 头，穿透 dsh 0.1.2 认证层。
+     */
+    authCookie?: string | null;
 }
 /**
  * 重写转发头以通过 DSH 围栏（isTrustedApiRequest 要求 Host/Origin 一致且为 loopback）。
  * - Host → 127.0.0.1:<port>（M1 事实：DSH 只信任 loopback/trusted Host）
  * - Origin 同步改写为 http://127.0.0.1:<port>（浏览器视角仍同源，不影响 CORS）
+ * - 文档导航请求剥离 accept-encoding：0.1.2 起 dsh 对 HTML 默认 gzip，会使下游
+ *   HTML 注入（hub 返回条/E2EE shim、serve polyfill）因 content-encoding 跳过；
+ *   剥离后 dsh 返回明文 HTML，压缩交给 hub 的 TLS + E2EE 层。静态 JS/CSS 仍 gzip。
+ * - 可选注入宿主 dsh 会话 cookie（合并进既有 cookie 头，保留 rdsh_gate 等，不覆盖）
  * 供 forwardHttp / createUpgradeProxy / join.ts（隧道→本地转发）复用。
  */
-export declare function rewriteHeadersForDsh(headers: Record<string, string | string[] | undefined>, target: ProxyTarget): Record<string, string | string[] | undefined>;
+export declare function rewriteHeadersForDsh(headers: Record<string, string | string[] | undefined>, target: ProxyTarget, dshAuthCookie?: string | null): Record<string, string | string[] | undefined>;
 /** 转发一个 HTTP 请求（含 SSE：响应流式写回，零缓冲）。 */
 export declare function forwardHttp(req: IncomingMessage, res: ServerResponse, target: ProxyTarget, opts?: ForwardOptions): void;
 /**
@@ -27,7 +36,7 @@ export declare function forwardHttp(req: IncomingMessage, res: ServerResponse, t
  * - handleUpgrade 成功后 ws 库会自动 emit 'connection'，这里不再手动 emit；
  * - 客户端消息立即入队，upstream open 后按序发送（避免握手竞态丢消息）。
  */
-export declare function createUpgradeProxy(target: ProxyTarget): {
+export declare function createUpgradeProxy(target: ProxyTarget, opts?: ForwardOptions): {
     /** 完成客户端 upgrade 握手并桥接（转发前必须已通过认证）。 */
     handleUpgrade(req: IncomingMessage, socket: Duplex, head: Buffer): void;
 };

package/dist/proxy.js

@@ -10,19 +10,37 @@ import { WebSocket, WebSocketServer } from "ws";
  * 重写转发头以通过 DSH 围栏（isTrustedApiRequest 要求 Host/Origin 一致且为 loopback）。
  * - Host → 127.0.0.1:<port>（M1 事实：DSH 只信任 loopback/trusted Host）
  * - Origin 同步改写为 http://127.0.0.1:<port>（浏览器视角仍同源，不影响 CORS）
+ * - 文档导航请求剥离 accept-encoding：0.1.2 起 dsh 对 HTML 默认 gzip，会使下游
+ *   HTML 注入（hub 返回条/E2EE shim、serve polyfill）因 content-encoding 跳过；
+ *   剥离后 dsh 返回明文 HTML，压缩交给 hub 的 TLS + E2EE 层。静态 JS/CSS 仍 gzip。
+ * - 可选注入宿主 dsh 会话 cookie（合并进既有 cookie 头，保留 rdsh_gate 等，不覆盖）
  * 供 forwardHttp / createUpgradeProxy / join.ts（隧道→本地转发）复用。
  */
-export function rewriteHeadersForDsh(headers, target) {
+export function rewriteHeadersForDsh(headers, target, dshAuthCookie) {
     const out = { ...headers };
     out.host = `${target.host}:${target.port}`;
     if (out.origin !== undefined) {
         out.origin = `http://${target.host}:${target.port}`;
     }
+    if (acceptsHtml(headers)) {
+        delete out["accept-encoding"];
+    }
+    if (dshAuthCookie !== undefined && dshAuthCookie !== null && dshAuthCookie !== "") {
+        const existing = out.cookie;
+        const current = Array.isArray(existing) ? existing.join("; ") : typeof existing === "string" ? existing : "";
+        out.cookie = current === "" ? dshAuthCookie : `${current}; ${dshAuthCookie}`;
+    }
     return out;
 }
+/** 请求是否期望 text/html（文档导航：地址栏/链接）；浏览器 fetch/script 的 Accept 不含它。 */
+function acceptsHtml(headers) {
+    const accept = headers["accept"];
+    const s = Array.isArray(accept) ? accept.join(",") : typeof accept === "string" ? accept : "";
+    return s.toLowerCase().includes("text/html");
+}
 /** 转发一个 HTTP 请求（含 SSE：响应流式写回，零缓冲）。 */
 export function forwardHttp(req, res, target, opts) {
-    const headers = rewriteHeadersForDsh(req.headers, target);
+    const headers = rewriteHeadersForDsh(req.headers, target, opts?.authCookie);
     const upstream = request({
         host: target.host,
         port: target.port,
@@ -80,10 +98,10 @@ export function forwardHttp(req, res, target, opts) {
  * - handleUpgrade 成功后 ws 库会自动 emit 'connection'，这里不再手动 emit；
  * - 客户端消息立即入队，upstream open 后按序发送（避免握手竞态丢消息）。
  */
-export function createUpgradeProxy(target) {
+export function createUpgradeProxy(target, opts) {
     const wss = new WebSocketServer({ noServer: true });
     wss.on("connection", (clientWs, req) => {
-        const headers = rewriteHeadersForDsh(req.headers, target);
+        const headers = rewriteHeadersForDsh(req.headers, target, opts?.authCookie);
         const upstreamUrl = `ws://${target.host}:${target.port}${req.url ?? "/"}`;
         const upstream = new WebSocket(upstreamUrl, { headers });
         const queue = [];

package/dist/serve.js

@@ -3,7 +3,7 @@
  */
 import { networkInterfaces } from "node:os";
 import { startGateway } from "./server.js";
-import { findDsh, spawnDsh } from "./spawn-dsh.js";
+import { findDsh, spawnDsh, exchangeDshSessionCookie, detectDshVersion, dshVersionWarning } from "./spawn-dsh.js";
 import { loadConfig, resolveConfigPath } from "./config.js";
 import { UserManager } from "./auth.js";
 import { loadTls } from "./tls.js";
@@ -25,7 +25,20 @@ export async function serve(opts) {
     if (foundDsh === null) {
         throw new Error("cannot find 'dsh' in PATH. Install DeepSeek Harness first, or set dshPath in config / pass --dsh <path>.");
     }
+    // 版本窗口外 → warn（不硬拒）：dsh 太新建议升 rdsh / 太旧建议升 dsh
+    const dshVersion = await detectDshVersion(foundDsh);
+    const versionWarn = dshVersionWarning(dshVersion);
+    if (versionWarn !== null)
+        console.warn(`\n⚠  ${versionWarn}\n`);
     const dsh = await spawnDsh(foundDsh);
+    // 0.1.2+：就绪行带 launch token → 换发浏览器会话 cookie 并代持注入转发
+    let dshAuthCookieHeader = null;
+    if (dsh.authToken !== undefined) {
+        dshAuthCookieHeader = await exchangeDshSessionCookie(dsh.port, dsh.authToken);
+        if (dshAuthCookieHeader === null) {
+            console.warn("rdsh: dsh 0.1.2+ 会话 cookie 换发失败——远程访问将返回 401（请确认 dsh web 已就绪或暂用 dsh@0.1.1-rc.2）。");
+        }
+    }
     // TLS 决策：有 tls.cert/key → https；无 → http（behindProxy 或 pair/none）。
     // password + http + 非反代 → server.ts 安全约束拒绝启动（需自行提供证书）。
     const tlsMaterial = await loadTls(config.tls, config.behindProxy);
@@ -42,6 +55,7 @@ export async function serve(opts) {
             pairCode,
             sessionTtlSeconds,
             dshPort: dsh.port,
+            dshAuthCookieHeader,
             reset: opts.reset,
             noCode: opts.noCode,
             authMode,

package/dist/server.d.ts

@@ -24,6 +24,8 @@ export interface GatewayOptions {
     pairCode?: string;
     sessionTtlSeconds: number;
     dshPort: number;
+    /** 宿主代持的 dsh 浏览器会话 cookie（`dsh-auth-*`，0.1.2+）；有值时注入转发 */
+    dshAuthCookieHeader?: string | null;
     /** true = 启动时重置会话密钥（全部会话失效） */
     reset?: boolean;
     /** 会话密钥目录（默认 ~/.rdsh；测试可注入临时目录） */

package/dist/server.js

@@ -69,6 +69,7 @@ export async function startGateway(opts) {
         sessionTtlSeconds: opts.sessionTtlSeconds,
         authMode,
         behindProxy,
+        dshAuthCookieHeader: opts.dshAuthCookieHeader ?? null,
         getVersion: () => currentVersion,
         isAllowed: (ip) => currentAllowFrom.length === 0 || ipInCidrs(ip, currentAllowFrom),
         userManager: opts.userManager,
@@ -98,7 +99,7 @@ export async function startGateway(opts) {
     });
     const address = server.address();
     const actualPort = typeof address === "object" && address !== null ? address.port : opts.port;
-    const upgradeProxy = createUpgradeProxy(target);
+    const upgradeProxy = createUpgradeProxy(target, { authCookie: ctx.dshAuthCookieHeader });
     return {
         server,
         sessions,
@@ -155,7 +156,7 @@ async function handleHttp(req, res, ctx, loginLimiter) {
         return;
     }
     if (ctx.authMode === "none") {
-        forwardHttp(req, res, ctx.target, { htmlInject: SECURE_CONTEXT_POLYFILL });
+        forwardHttp(req, res, ctx.target, { htmlInject: SECURE_CONTEXT_POLYFILL, authCookie: ctx.dshAuthCookieHeader });
         return;
     }
     if (!hasValidSession(req, ctx)) {
@@ -163,7 +164,7 @@ async function handleHttp(req, res, ctx, loginLimiter) {
         res.end();
         return;
     }
-    forwardHttp(req, res, ctx.target, { htmlInject: SECURE_CONTEXT_POLYFILL });
+    forwardHttp(req, res, ctx.target, { htmlInject: SECURE_CONTEXT_POLYFILL, authCookie: ctx.dshAuthCookieHeader });
 }
 async function handlePairPost(req, res, ctx) {
     const ip = req.socket.remoteAddress ?? "unknown";

package/dist/spawn-dsh.d.ts

@@ -2,6 +2,11 @@ import type { ChildProcess } from "node:child_process";
 export interface SpawnedDsh {
     /** dsh 实际监听端口（OS 分配） */
     port: number;
+    /**
+     * 0.1.2+ 就绪行携带的 launch token（`/?token=` 后）；0.1.1 及更早为 undefined。
+     * 有值才需要换发浏览器会话 cookie。
+     */
+    authToken?: string;
     child: ChildProcess;
     /** 终止 dsh（SIGTERM，超时 SIGKILL），返回退出码 */
     stop(): Promise<number>;
@@ -17,3 +22,31 @@ export declare function findDsh(override?: string): string | null;
  * dsh 启动失败/超时 → reject。
  */
 export declare function spawnDsh(dshPath: string): Promise<SpawnedDsh>;
+/**
+ * 用 launch token 向 dsh web 换发浏览器会话 cookie（0.1.2+ 认证）。
+ * `GET /?token=<t>` → 303 + `Set-Cookie: dsh-auth-<sha256(authority)>=v1...`。
+ * 用 node:http 而非 fetch：fetch 的 opaque-redirect 响应读不到 Set-Cookie。
+ * 返回 cookie 的 `name=value` 段（不含属性）；换发失败/超时/无 cookie → null（调用方降级）。
+ */
+export declare function exchangeDshSessionCookie(port: number, token: string, timeoutMs?: number): Promise<string | null>;
+/** 探测 dsh 版本号（`dsh --version` 输出如 `0.1.2-rc.1`）；失败/不可解析 → null。 */
+export declare function detectDshVersion(dshPath: string, timeoutMs?: number): Promise<string | null>;
+/**
+ * 比较两个 dsh 版本串（如 `0.1.1-rc.2` / `0.1.2-rc.1`），支持 `-rc.N`/`-beta.N` 后缀：
+ * 返回负/0/正；同 core 时 release 大于任何 prerelease；不可解析排序为「更旧」。
+ * 语义对齐 dsh4vscode 的 compareVersions（跨仓库同一 dsh 版本约定）。
+ */
+export declare function compareDshVersions(a: string, b: string): number;
+/**
+ * remote-dsh 已实测兼容的 dsh 版本窗口（registry 实存版本定界）。
+ * ⚠️ 适配新的 dsh 版本并真机实测后，须同步扩展此窗口（见 doc/fix/20260907-dsh-0.1.2-rc1-auth/）。
+ */
+export declare const DSH_COMPAT_MIN = "0.1.1-rc.2";
+export declare const DSH_COMPAT_MAX = "0.1.2-rc.1";
+/**
+ * 版本落在实测窗口外时的提示文案（零文档导向：直接给动作指令，用户不查表）。
+ * - 比 max 新 → 升级 remote-dsh 或暂用旧 dsh；
+ * - 比 min 旧 → 升级 dsh；
+ * - 在窗口内 / 探测失败（version=null）→ null（不提示）。
+ */
+export declare function dshVersionWarning(version: string | null): string | null;

package/dist/spawn-dsh.js

@@ -4,13 +4,20 @@
  * 事实依据（discussion.md §2）：`dsh web --port 0 --no-open` 由 OS 分配端口，
  * 启动时打印 `dsh web: http://127.0.0.1:<port>`（dsh-web-app/lib/index.js）。
  */
-import { spawn } from "node:child_process";
+import { execFile, spawn } from "node:child_process";
 import { accessSync } from "node:fs";
+import { get } from "node:http";
 import { createInterface } from "node:readline";
-/** dsh 的 URL 行格式（`dsh web: http://127.0.0.1:<port> (LAN: ...)`）。 */
-const URL_LINE_RE = /dsh web:\s*http:\/\/127\.0\.0\.1:(\d+)/;
+/**
+ * dsh 的 URL 行格式。0.1.1：`dsh web: http://127.0.0.1:<port>`；
+ * 0.1.2+：`dsh web: http://127.0.0.1:<port>/?token=<launchToken> (LAN: ...)`。
+ * 就绪行不锚定行尾（LAN 提示可随行出现）；token 为 base64url（[A-Za-z0-9_-]）。
+ */
+const URL_LINE_RE = /dsh web:\s*http:\/\/127\.0\.0\.1:(\d+)(?:\/\?token=([A-Za-z0-9_-]+))?/;
 const READY_TIMEOUT_MS = 30_000;
 const STOP_TIMEOUT_MS = 5_000;
+const VERSION_TIMEOUT_MS = 5_000;
+const EXCHANGE_TIMEOUT_MS = 5_000;
 /**
  * 在 PATH 中查找 dsh 可执行文件；`override` 直接使用。
  * 找不到返回 null。
@@ -58,7 +65,7 @@ export function spawnDsh(dshPath) {
                 // 就绪：后续 dsh 输出全部透传
                 child.stdout?.pipe(process.stdout);
                 child.stderr?.pipe(process.stderr);
-                resolve({ port: Number(m[1]), child, stop: () => stopDsh(child) });
+                resolve({ port: Number(m[1]), authToken: m[2], child, stop: () => stopDsh(child) });
             }
             else {
                 process.stdout.write(`${line}\n`);
@@ -88,4 +95,127 @@ function stopDsh(child) {
         setTimeout(() => child.kill("SIGKILL"), STOP_TIMEOUT_MS).unref();
     });
 }
+/**
+ * 用 launch token 向 dsh web 换发浏览器会话 cookie（0.1.2+ 认证）。
+ * `GET /?token=<t>` → 303 + `Set-Cookie: dsh-auth-<sha256(authority)>=v1...`。
+ * 用 node:http 而非 fetch：fetch 的 opaque-redirect 响应读不到 Set-Cookie。
+ * 返回 cookie 的 `name=value` 段（不含属性）；换发失败/超时/无 cookie → null（调用方降级）。
+ */
+export function exchangeDshSessionCookie(port, token, timeoutMs = EXCHANGE_TIMEOUT_MS) {
+    return new Promise((resolve) => {
+        const req = get({ host: "127.0.0.1", port, path: `/?token=${encodeURIComponent(token)}` }, (res) => {
+            const raw = res.headers["set-cookie"];
+            const list = Array.isArray(raw) ? raw : raw !== undefined ? [raw] : [];
+            let found = null;
+            for (const c of list) {
+                const segment = c.split(";", 1)[0]?.trim() ?? "";
+                if (segment.startsWith("dsh-auth-")) {
+                    found = segment;
+                    break;
+                }
+            }
+            res.resume();
+            resolve(found);
+        });
+        req.on("error", () => resolve(null));
+        req.setTimeout(timeoutMs, () => {
+            req.destroy();
+            resolve(null);
+        });
+    });
+}
+/** 探测 dsh 版本号（`dsh --version` 输出如 `0.1.2-rc.1`）；失败/不可解析 → null。 */
+export function detectDshVersion(dshPath, timeoutMs = VERSION_TIMEOUT_MS) {
+    return new Promise((resolve) => {
+        execFile(dshPath, ["--version"], { timeout: timeoutMs }, (err, stdout) => {
+            if (err) {
+                resolve(null);
+                return;
+            }
+            const first = stdout.trim().split(/\r?\n/)[0] ?? "";
+            const m = first.match(/^\d+\.\d+\.\d+(?:-[0-9A-Za-z.-]+)?$/);
+            resolve(m !== null ? m[0] : null);
+        });
+    });
+}
+function parseVersion(v) {
+    const m = v.trim().match(/^(\d+)\.(\d+)\.(\d+)(?:-([0-9A-Za-z.-]+))?$/);
+    if (m === null)
+        return null;
+    const core = [Number(m[1]), Number(m[2]), Number(m[3])];
+    const pre = m[4] !== undefined ? m[4].split(".").map((s) => (/^\d+$/.test(s) ? Number(s) : s)) : null;
+    return { core, pre };
+}
+/**
+ * 比较两个 dsh 版本串（如 `0.1.1-rc.2` / `0.1.2-rc.1`），支持 `-rc.N`/`-beta.N` 后缀：
+ * 返回负/0/正；同 core 时 release 大于任何 prerelease；不可解析排序为「更旧」。
+ * 语义对齐 dsh4vscode 的 compareVersions（跨仓库同一 dsh 版本约定）。
+ */
+export function compareDshVersions(a, b) {
+    const pa = parseVersion(a);
+    const pb = parseVersion(b);
+    if (pa === null && pb === null)
+        return 0;
+    if (pa === null)
+        return -1;
+    if (pb === null)
+        return 1;
+    for (let i = 0; i < 3; i++) {
+        const x = pa.core[i];
+        const y = pb.core[i];
+        if (x !== y)
+            return x - y;
+    }
+    if (pa.pre === null && pb.pre === null)
+        return 0;
+    if (pa.pre === null)
+        return 1;
+    if (pb.pre === null)
+        return -1;
+    const len = Math.max(pa.pre.length, pb.pre.length);
+    for (let i = 0; i < len; i++) {
+        const x = pa.pre[i];
+        const y = pb.pre[i];
+        if (x === undefined)
+            return -1;
+        if (y === undefined)
+            return 1;
+        if (typeof x === "number" && typeof y === "number") {
+            if (x !== y)
+                return x - y;
+        }
+        else if (typeof x === "string" && typeof y === "string") {
+            if (x !== y)
+                return x < y ? -1 : 1;
+        }
+        else {
+            return typeof x === "number" ? -1 : 1;
+        }
+    }
+    return 0;
+}
+/**
+ * remote-dsh 已实测兼容的 dsh 版本窗口（registry 实存版本定界）。
+ * ⚠️ 适配新的 dsh 版本并真机实测后，须同步扩展此窗口（见 doc/fix/20260907-dsh-0.1.2-rc1-auth/）。
+ */
+export const DSH_COMPAT_MIN = "0.1.1-rc.2";
+export const DSH_COMPAT_MAX = "0.1.2-rc.1";
+/**
+ * 版本落在实测窗口外时的提示文案（零文档导向：直接给动作指令，用户不查表）。
+ * - 比 max 新 → 升级 remote-dsh 或暂用旧 dsh；
+ * - 比 min 旧 → 升级 dsh；
+ * - 在窗口内 / 探测失败（version=null）→ null（不提示）。
+ */
+export function dshVersionWarning(version) {
+    if (version === null)
+        return null;
+    if (compareDshVersions(version, DSH_COMPAT_MAX) > 0) {
+        return (`检测到 dsh ${version}：该版本超出 remote-dsh 已实测范围（≤${DSH_COMPAT_MAX}），远程访问可能不可用。` +
+            `升级 remote-dsh：npm i -g remote-dsh@latest；或暂用 dsh@${DSH_COMPAT_MIN}。`);
+    }
+    if (compareDshVersions(version, DSH_COMPAT_MIN) < 0) {
+        return `检测到 dsh ${version}：版本过旧，请升级 dsh：npm i -g @deepseek-ai/dsh@latest。`;
+    }
+    return null;
+}
 //# sourceMappingURL=spawn-dsh.js.map

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "rdsh-gateway",
-  "version": "0.6.0",
+  "version": "0.8.0",
   "description": "rdsh host-side component: LAN auth gateway + outbound tunnel endpoint (spawns dsh web)",
   "license": "MIT",
   "type": "module",