rdsh-gateway 0.5.0 → 0.7.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

@@ -30,6 +30,19 @@ export interface RdshConfig {
     hub?: string;
     name?: string;
     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 {
+    /** E2EE 激活（或宿主启用）时 patch JS；false = 保持 DSH 原样（共享 host/敏感场景） */
+    trustE2EEAsLoopback?: boolean;
 }
 export declare const DEFAULT_HOST_CONFIG_PATH: string;
 /** 解析配置文件路径（--config > $RDSH_CONFIG > 默认 host.json）。 */

package/dist/config.js

@@ -21,6 +21,8 @@ const DEFAULTS = {
     behindProxy: false,
     allowFrom: [],
     auth: DEFAULT_AUTH,
+    dshUiCompat: { trustE2EEAsLoopback: true },
+    gateway: { accessCode: null },
 };
 /** 解析配置文件路径（--config > $RDSH_CONFIG > 默认 host.json）。 */
 export function resolveConfigPath(cliPath, env = process.env) {
@@ -174,6 +176,33 @@ export function normalizeConfig(raw, source = "config") {
         assertString(cfg.dshPath, "dshPath", source);
         out.dshPath = cfg.dshPath;
     }
+    // ---- dshUiCompat（缺省 trustE2EEAsLoopback: true）----
+    if (cfg.dshUiCompat !== undefined) {
+        if (typeof cfg.dshUiCompat !== "object" || cfg.dshUiCompat === null) {
+            throw new Error(`${source}: "dshUiCompat" must be an object`);
+        }
+        const compat = cfg.dshUiCompat;
+        if (compat.trustE2EEAsLoopback !== undefined) {
+            if (typeof compat.trustE2EEAsLoopback !== "boolean") {
+                throw new Error(`${source}: "dshUiCompat.trustE2EEAsLoopback" must be boolean`);
+            }
+            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/join.d.ts

@@ -1,3 +1,4 @@
+import type { IncomingHttpHeaders } from "node:http";
 import type { ProxyTarget } from "./proxy.ts";
 import type { JoinLockRole } from "./lock.ts";
 export interface JoinOptions {
@@ -11,6 +12,14 @@ export interface JoinOptions {
     insecure?: boolean;
     /** 主机名（注册命名 / host.json） */
     name?: string;
+    /** DSH UI 兼容（透传 host.json dshUiCompat；缺省 true） */
+    dshUiCompat?: {
+        trustE2EEAsLoopback?: boolean;
+    };
+    /** 网关访问口令（feature 15；accessCode null = 关闭） */
+    gateway?: {
+        accessCode?: string | null;
+    };
 }
 /** 注册/接入结果：解析出的 host token + 是否需 insecure + 生效的主机名（缺省=机器 hostname）。 */
 export interface RegisterOutcome {
@@ -41,10 +50,24 @@ export interface StartJoinOptions {
     /** 锁文件路径（缺省 ~/.rdsh/join.lock；测试可注入临时路径） */
     lockPath?: string;
     hooks?: JoinHooks;
+    /** DSH UI 兼容（缺省 trustE2EEAsLoopback=true；false 关闭 JS patch） */
+    dshUiCompat?: {
+        trustE2EEAsLoopback?: boolean;
+    };
+    /** 网关访问口令（feature 15；accessCode null = 关闭） */
+    gateway?: {
+        accessCode?: string | null;
+    };
+    /** 主机名（challenge 页展示；缺省「本主机」） */
+    name?: string;
 }
 /** 可停止的 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>;
@@ -56,6 +79,14 @@ export declare function registerJoin(opts: JoinOptions): Promise<RegisterOutcome
  * 启动 join 隧道（no-spawn）：转发到外部 `opts.target`，不 spawn dsh、不 process.exit。
  * 获取 pid 锁（opts.role）；返回 `JoinHandle`，`stop()` 干净停止（关 WS/清 heartbeat/释放锁）。
  */
+/** JS 响应判定（content-type 含 javascript）。 */
+export declare function isJsContentType(headers: IncomingHttpHeaders): boolean;
+/**
+ * 最小 patch：把 DSH 客户端 bundle 里的前端 isLoopback 判定替换为 true
+ * （持久设置/API key 输入只对 loopback 开放；E2EE 流上信任基础等同 loopback）。
+ * fail-open：未命中目标串 → 返回 null，调用方原样透传（DSH 升级不炸）。
+ */
+export declare function patchLoopbackJs(body: Buffer): Buffer | null;
 export declare function startJoin(opts: StartJoinOptions): JoinHandle;
 /** `rdsh host serve`（join 模式）的 CLI 封装：spawn dsh + 信号退出 + startJoin(role:cli)。 */
 export declare function join(opts: JoinOptions): Promise<void>;

package/dist/join.js

@@ -20,6 +20,7 @@ import { clearPersistedToken, persistToken, readPersistedToken } from "./token-s
 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 ?? "";
@@ -128,9 +129,73 @@ async function register(hubUrl, joinToken, name, insecure, e2eePublicKey) {
  * 启动 join 隧道（no-spawn）：转发到外部 `opts.target`，不 spawn dsh、不 process.exit。
  * 获取 pid 锁（opts.role）；返回 `JoinHandle`，`stop()` 干净停止（关 WS/清 heartbeat/释放锁）。
  */
+/** JS 响应判定（content-type 含 javascript）。 */
+export function isJsContentType(headers) {
+    const ct = headers["content-type"];
+    const s = Array.isArray(ct) ? ct.join(";") : (ct ?? "");
+    return /javascript/i.test(s);
+}
+/**
+ * 最小 patch：把 DSH 客户端 bundle 里的前端 isLoopback 判定替换为 true
+ * （持久设置/API key 输入只对 loopback 开放；E2EE 流上信任基础等同 loopback）。
+ * fail-open：未命中目标串 → 返回 null，调用方原样透传（DSH 升级不炸）。
+ */
+export function patchLoopbackJs(body) {
+    const src = body.toString("utf8");
+    const target = "isLoopbackHostname(pageLocation.hostname)";
+    if (!src.includes(target))
+        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 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);
     };
@@ -153,9 +218,69 @@ export function startJoin(opts) {
         }
     }
     /** 内层帧分发器（plain 与 raw 共用）：OPEN http/ws + DATA → DSH 转发，响应帧经 `send` 回传。 */
-    function makeInnerDispatcher(send) {
+    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) {
@@ -219,6 +344,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;
@@ -241,6 +388,25 @@ export function startJoin(opts) {
                     reason: upRes.statusMessage,
                     headers: normalizeRespHeaders(upRes.headers),
                 })));
+                if (dio?.jsPatch?.() === true && isJsContentType(upRes.headers)) {
+                    // 最小 patch：E2EE 流上的 JS 响应，把前端 isLoopback 判定替换为 true
+                    // （fail-open：未命中 → 原样透传；DSH 升级不炸）
+                    const chunks = [];
+                    upRes.on("data", (chunk) => chunks.push(chunk));
+                    upRes.on("end", () => {
+                        const body = Buffer.concat(chunks);
+                        const patched = patchLoopbackJs(body);
+                        // fail-open：未命中也必须原样发 body（否则空响应白屏）
+                        send(encodeFrame(FRAME_TYPE.DATA, streamId, patched !== null ? patched : body));
+                        send(encodeFrame(FRAME_TYPE.CLOSE, streamId, jsonPayload({ code: 0 })));
+                        httpStreams.delete(streamId);
+                    });
+                    upRes.on("error", () => {
+                        send(encodeFrame(FRAME_TYPE.CLOSE, streamId, jsonPayload({ code: 502, message: "upstream error" })));
+                        httpStreams.delete(streamId);
+                    });
+                    return;
+                }
                 upRes.on("data", (chunk) => {
                     send(encodeFrame(FRAME_TYPE.DATA, streamId, chunk));
                 });
@@ -266,6 +432,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)
@@ -281,6 +457,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;
                 }
@@ -307,10 +490,11 @@ export function startJoin(opts) {
                 }
             }
             wsStreams.clear();
+            gatedHttp.clear();
         }
         return { handleFrame, cleanup };
     }
-    const plainDispatcher = makeInnerDispatcher(sendTunnelFrame);
+    const plainDispatcher = makeInnerDispatcher(sendTunnelFrame, { jsPatch: () => uiCompat.trustE2EEAsLoopback, gate: true });
     // host 端 E2EE 静态密钥对（持久化 ~/.rdsh/e2ee-key.json；join 注册时上送指纹）
     const hostE2eeKeypair = loadOrCreateE2eeKeyPair();
     const rawStreams = new Map();
@@ -321,7 +505,7 @@ export function startJoin(opts) {
                 const ct = raw.encryptor.encrypt(frame, Buffer.alloc(0));
                 sendTunnelFrame(encodeFrame(FRAME_TYPE.DATA, streamId, ct, FLAG_E2E));
             }
-        });
+        }, { jsPatch: () => uiCompat.trustE2EEAsLoopback });
         rawStreams.set(streamId, {
             handshakeBuf: Buffer.alloc(0),
             keys: null,
@@ -419,8 +603,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，
@@ -498,6 +683,16 @@ export function startJoin(opts) {
     }
     connect();
     return {
+        setUiCompat(trustE2EEAsLoopback) {
+            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;
@@ -525,7 +720,7 @@ export async function join(opts) {
     const dsh = await spawnDsh(foundDsh);
     const target = { host: "127.0.0.1", port: dsh.port };
     // 解析 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({
@@ -534,6 +729,9 @@ export async function join(opts) {
         insecure,
         target,
         role: "cli",
+        dshUiCompat: opts.dshUiCompat,
+        gateway: opts.gateway,
+        name,
         hooks: {
             onLog: (level, message) => {
                 (level === "error" ? console.error : console.log)(`rdsh join: ${message}`);

package/package.json

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