dsh-jiuling-remote-mobile 1.0.20 → 1.0.24

package/lib/client.js

@@ -305,6 +305,78 @@ window.__ModuleLoader__.load({
 		 */
 		var mirrorSlugs = {};
 
+		/**
+		 * 「用户刚刚在新建对话界面选中的那个工作区」的 cwd —— 只在**会话行还没带上
+		 * cwd** 的那一小段时间里当兜底判据用。
+		 *
+		 * ⚠️⚠️ **为什么需要它（用户报障，2026-10-17 真机复现）**：
+		 *
+		 * 在**新建对话界面**（还没有任何消息）切到电脑工作区时，`sessions.list`
+		 * 里那一行**还没有 cwd**（会话刚物化，宿主没回填），于是
+		 * `isRemoteSession()` 只能退回 `remoteSessionIds[sessionId]` —— 而新建的
+		 * 本地壳会话**不在里面**，结论是「本地」。后果：
+		 *
+		 * - 模型菜单只显示手机的模型（电脑的组被 `pickWorkspaceGroups` 筛掉）；
+		 * - 预设列表同理，仍是手机那份。
+		 *
+		 * 用户原话：「我在待选的工作区里面选择了默认工作区，也就是我手机的工作区，
+		 * 这个预设它没有改回来，模型列表也没有改回来」——反过来切到电脑时也一样。
+		 *
+		 * 兜底只影响**这一小段窗口**：一旦列表行带回 cwd，`cwdOf()` 优先，这个值
+		 * 自动失效（见 `isRemoteSession` 的判据顺序），不会长期歪掉。
+		 */
+		var pendingWorkspaceCwd = null;
+
+		/**
+		 * `pendingWorkspaceCwd` 的**过期时刻**（毫秒时间戳）。
+		 *
+		 * ⚠️ 为什么必须有这个：官方工作区下拉菜单走的是
+		 * `workspaceNavigation.openWorkspace()`（`ConversationContent` 的
+		 * `selectWorkspace`），**完全不经过本插件** —— 所以「用户切回默认工作区」
+		 * 这个动作我这边收不到通知，没法在那个时刻清掉 `pendingWorkspaceCwd`。
+		 *
+		 * 不设过期的话，一旦某次在电脑工作区设过它、而之后那个会话行的 cwd
+		 * 又一直读不到，兜底值就会**永久**把「本地会话」判成电脑会话，用户看到
+		 * 的正是「切回默认工作区，模型和预设都没改回来」。
+		 *
+		 * 取 30 秒：足够覆盖「建会话 → 列表行回填 cwd」这一段（真机是几百毫秒），
+		 * 又不至于让一个陈旧值活太久。
+		 */
+		var pendingWorkspaceExpiresAt = 0;
+
+		/** `pendingWorkspaceCwd` 的有效期（毫秒）。 */
+		var PENDING_WORKSPACE_TTL = 30000;
+
+		/**
+		 * 记下「刚选中的工作区」并开始计时。
+		 *
+		 * @param cwd - 工作区路径；传 `null`/空串表示**立刻作废**。
+		 */
+		function setPendingWorkspace(cwd) {
+			if (typeof cwd !== 'string' || cwd === '') {
+				pendingWorkspaceCwd = null;
+				pendingWorkspaceExpiresAt = 0;
+				return;
+			}
+			pendingWorkspaceCwd = cwd;
+			pendingWorkspaceExpiresAt = Date.now() + PENDING_WORKSPACE_TTL;
+		}
+
+		/**
+		 * 取当前有效的兜底 cwd（过期就当没有）。
+		 *
+		 * @returns 有效的 cwd 或 `null`。
+		 */
+		function currentPendingWorkspace() {
+			if (pendingWorkspaceCwd === null) return null;
+			if (Date.now() > pendingWorkspaceExpiresAt) {
+				pendingWorkspaceCwd = null;
+				pendingWorkspaceExpiresAt = 0;
+				return null;
+			}
+			return pendingWorkspaceCwd;
+		}
+
 		/**
 		 * 从 cwd 取出镜像工作区的 slug（与宿主 `desktopPathOfMirror` 同构）。
 		 *
@@ -331,7 +403,17 @@ window.__ModuleLoader__.load({
 		 * 工作区就是隔离条件本身。解绑后 `mirrorSlugs` 清空 ⇒ 全部回到本地，
 		 * 不需要再去清每个会话的旧标记。
 		 *
-		 * 只有列表行还没带 cwd 的那一两帧（会话刚建好）才退回 `remoteSessionIds`。
+		 * 只有列表行还没带 cwd 的那一两帧（会话刚建好）才退回
+		 * `pendingWorkspaceCwd` / `remoteSessionIds`。
+		 *
+		 * ⚠️ **判据顺序不能换**：
+		 * 1. `cwdOf(sessionId)` —— 会话自己的 cwd，最准；
+		 * 2. `pendingWorkspaceCwd` —— 用户在新建界面刚选的工作区（见它的注释，
+		 *    这是修「新建界面模型/预设不跟随工作区」的那一条）；
+		 * 3. `remoteSessionIds` —— 宿主显式标记过的会话。
+		 *
+		 * 第 2 条只在第 1 条读不到时才生效，所以一旦会话行带回 cwd，
+		 * 它就自动让位，不会跟真实 cwd 打架。
 		 *
 		 * @param sessionId - 会话 id。
 		 * @param cwdOf - `sessionId → cwd` 的同步读取函数。
@@ -343,6 +425,12 @@ window.__ModuleLoader__.load({
 				var slug = mirrorSlugOf(cwd);
 				return slug !== undefined && mirrorSlugs[slug] === true;
 			}
+			// 会话自己的 cwd 还没进列表行 —— 用「刚选中的工作区」兜底（会过期）。
+			var pending = currentPendingWorkspace();
+			if (pending !== null) {
+				var pendingSlug = mirrorSlugOf(pending);
+				return pendingSlug !== undefined && mirrorSlugs[pendingSlug] === true;
+			}
 			return remoteSessionIds[sessionId] === true;
 		}
 
@@ -717,22 +805,215 @@ window.__ModuleLoader__.load({
 		function makeCwdOf(ctx) {
 			return function (sessionId) {
 				if (typeof sessionId !== 'string' || sessionId === '') return undefined;
+				var row;
 				var sessions = ctx.sessions;
-				if (sessions === undefined || sessions === null) return undefined;
-				var list = sessions.list;
-				if (list === undefined || list === null) return undefined;
-				if (typeof list.getSnapshot !== 'function') return undefined;
-				var snapshot = list.getSnapshot();
-				if (snapshot === undefined || snapshot === null) return undefined;
-				var byId = snapshot.byId;
-				if (byId === undefined || byId === null) return undefined;
-				var row = byId[sessionId];
+				if (sessions !== undefined && sessions !== null) {
+					var list = sessions.list;
+					if (list !== undefined && list !== null && typeof list.getSnapshot === 'function') {
+						var snapshot = list.getSnapshot();
+						if (snapshot !== undefined && snapshot !== null) {
+							var byId = snapshot.byId;
+							if (byId !== undefined && byId !== null) row = byId[sessionId];
+						}
+					}
+				}
+				if (row !== undefined && row !== null) {
+					var cwd = row.cwd;
+					if (typeof cwd === 'string' && cwd !== '') return cwd;
+				}
+				// ⚠️ **会话行没有 cwd（甚至整行都还没出现）时，退回「它所属工作区的路径」。**
+				//
+				// 新建对话界面（还没有消息）那一行常常只有 `workspaceId`、没有 `cwd`：
+				// `cwd` 要等宿主把会话真正物化后才回填。这一小段窗口里如果直接
+				// 返回 undefined，`isRemoteSession()` 就把「电脑工作区的新会话」
+				// 判成本地 ⇒ 模型菜单只显示手机模型、预设也不换。
+				//
+				// 用户报障原话：「在待选的工作区里面选择了默认工作区…这个预设它没有
+				// 改回来，模型列表也没有改回来」——两个方向都是这个原因。
+				//
+				// 三条退路，先精确后宽松：
+				// 1. `pendingWorkspaceCwd` —— 用户刚在新建界面选中的工作区（见其注释）；
+				// 2. `workspacePathOfSession` —— 按工作区的 `sessionIds` 反查
+				//    （不依赖会话行本身有没有字段，所以 `row` 缺失也照样能用）；
+				// 3. `workspacePathOf` —— 按 `row.workspaceId` 直查。
+				//
+				// 工作区快照是**同步**可读的，所以仍然满足「模型菜单每帧同步读」。
+				if (typeof pendingWorkspaceCwd === 'string' && pendingWorkspaceCwd !== '') {
+					var pendingNow = currentPendingWorkspace();
+					if (pendingNow !== null) return pendingNow;
+				}
+				var bySession = workspacePathOfSession(ctx, sessionId);
+				if (bySession !== undefined) return bySession;
 				if (row === undefined || row === null) return undefined;
-				var cwd = row.cwd;
-				return typeof cwd === 'string' && cwd !== '' ? cwd : undefined;
+				return workspacePathOf(ctx, row.workspaceId);
 			};
 		}
 
+		/**
+		 * 收集所有可能挂着工作区快照的宿主对象。
+		 *
+		 * ⚠️ 用 `ctx.get('workspaces')` 而不是只靠 `ctx.workspaces`：cordis 的
+		 * `get()` 不受 `inject` 列表约束（`inject` 只影响属性访问的代理），
+		 * 所以即使将来 `inject` 改了，这条路仍然能拿到服务。
+		 *
+		 * @param ctx - client 根上下文。
+		 * @returns 候选宿主数组（可能为空）。
+		 */
+		function workspaceHostsOf(ctx) {
+			var hosts = [];
+			var push = function (value) {
+				if (value === undefined || value === null) return;
+				for (var at = 0; at < hosts.length; at += 1) {
+					if (hosts[at] === value) return;
+				}
+				hosts.push(value);
+			};
+			try {
+				if (typeof ctx.get === 'function') push(ctx.get('workspaces'));
+			} catch (error) {
+				/* 服务没起就跳过 */
+			}
+			push(ctx.workspaces);
+			push(ctx.sessions);
+			push(ctx.uiWorkspace);
+			return hosts;
+		}
+
+		/**
+		 * 按 `workspaceId` 查工作区的目录路径 —— **同步**，读不到就 `undefined`。
+		 *
+		 * 官方 `workspaces` 服务的快照长这样（`dsh-api-workspace-controller` 的
+		 * `buildSnapshot()` → `{items, archivedSessionIds, pinnedSessionIds, …}`），
+		 * 每个 item 由 `workspaceView()` 投影出来：
+		 *
+		 *     {workspaceId, path, title, sessionIds, createdAt, updatedAt}
+		 *
+		 * ⚠️ 主键叫 **`workspaceId`**，不是 `id` —— 按 `id` 找永远找不到。
+		 * ⚠️ 路径字段是 **`path`**（`workspace.path`）。
+		 *
+		 * @param ctx - client 根上下文。
+		 * @param workspaceId - 工作区 id。
+		 * @returns 工作区路径；查不到时 `undefined`。
+		 */
+		function workspacePathOf(ctx, workspaceId) {
+			if (typeof workspaceId !== 'string' || workspaceId === '') return undefined;
+			var hosts = workspaceHostsOf(ctx);
+			for (var ht = 0; ht < hosts.length; ht += 1) {
+				var host = hosts[ht];
+				var stores = [host.list, host.workspaces, host];
+				for (var st = 0; st < stores.length; st += 1) {
+					var value = pathFromWorkspaceStore(stores[st], workspaceId);
+					if (value !== undefined) return value;
+				}
+			}
+			return undefined;
+		}
+
+		/**
+		 * 从一个「工作区 store / 列表 / 数组」里取指定 id 的路径。
+		 *
+		 * 抽出来是为了让 `workspacePathOf` 能把多个来源串起来试，而不用把
+		 * 「快照怎么取」的细节重复四遍。
+		 *
+		 * 兼容三种主键写法（`workspaceId` / `id`）与四种路径字段写法，
+		 * 免得官方换个字段名就静默失效。
+		 *
+		 * @param store - 可能是 store、列表、数组或映射。
+		 * @param workspaceId - 工作区 id。
+		 * @returns 路径；没有就 `undefined`。
+		 */
+		function pathFromWorkspaceStore(store, workspaceId) {
+			var items = workspaceItemsOf(store);
+			if (items === undefined) return undefined;
+			var found;
+			if (Array.isArray(items)) {
+				for (var at = 0; at < items.length; at += 1) {
+					var row = items[at];
+					if (!row) continue;
+					if (row.workspaceId === workspaceId || row.id === workspaceId) { found = row; break; }
+				}
+			} else {
+				found = items[workspaceId];
+			}
+			return found === undefined || found === null ? undefined : pathOfWorkspaceRow(found);
+		}
+
+		/**
+		 * 从会话 id 反查它所属工作区的路径 —— **同步**，读不到就 `undefined`。
+		 *
+		 * 比「先拿 `row.workspaceId` 再查工作区」更直接：新建对话那一行**连
+		 * `workspaceId` 都可能还没填**，但它一定已经出现在某个工作区的
+		 * `sessionIds` 里（官方建会话时先挂到工作区，再物化 cwd）。
+		 *
+		 * ⚠️ 一个会话理论上只属于一个工作区，所以命中即返回，不用遍历完。
+		 *
+		 * @param ctx - client 根上下文。
+		 * @param sessionId - 会话 id。
+		 * @returns 所属工作区路径；查不到时 `undefined`。
+		 */
+		function workspacePathOfSession(ctx, sessionId) {
+			if (typeof sessionId !== 'string' || sessionId === '') return undefined;
+			var hosts = workspaceHostsOf(ctx);
+			for (var ht = 0; ht < hosts.length; ht += 1) {
+				var host = hosts[ht];
+				var stores = [host.list, host.workspaces, host];
+				for (var st = 0; st < stores.length; st += 1) {
+					var items = workspaceItemsOf(stores[st]);
+					if (items === undefined || !Array.isArray(items)) continue;
+					for (var at = 0; at < items.length; at += 1) {
+						var row = items[at];
+						if (!row || !Array.isArray(row.sessionIds)) continue;
+						if (row.sessionIds.indexOf(sessionId) === -1) continue;
+						var value = pathOfWorkspaceRow(row);
+						if (value !== undefined) return value;
+					}
+				}
+			}
+			return undefined;
+		}
+
+		/**
+		 * 从一个「工作区 store / 列表 / 数组」里取出 item 集合。
+		 *
+		 * @param store - 可能是 store、列表、数组或映射。
+		 * @returns 数组或 `{id: row}` 映射；取不到就 `undefined`。
+		 */
+		function workspaceItemsOf(store) {
+			if (store === undefined || store === null) return undefined;
+			var list;
+			if (typeof store.getSnapshot === 'function') {
+				try { list = store.getSnapshot(); } catch (error) { return undefined; }
+			} else if (typeof store.list === 'function') {
+				try { list = store.list(); } catch (error) { return undefined; }
+			} else if (Array.isArray(store)) {
+				list = store;
+			} else {
+				return undefined;
+			}
+			if (list === undefined || list === null) return undefined;
+			// 官方快照是 `{items, …}`；也兼容直接给数组或 `{byId}`。
+			if (Array.isArray(list)) return list;
+			if (Array.isArray(list.items)) return list.items;
+			if (list.byId !== undefined && list.byId !== null) return list.byId;
+			return undefined;
+		}
+
+		/**
+		 * 取一行工作区的路径（按几个候选字段名试）。
+		 *
+		 * @param row - 工作区行。
+		 * @returns 路径；没有就 `undefined`。
+		 */
+		function pathOfWorkspaceRow(row) {
+			if (row === undefined || row === null) return undefined;
+			var keys = ['path', 'cwd', 'root', 'directory'];
+			for (var kt = 0; kt < keys.length; kt += 1) {
+				var value = row[keys[kt]];
+				if (typeof value === 'string' && value !== '') return value;
+			}
+			return undefined;
+		}
+
 		/**
 		 * 调宿主桥的一条 RPC（令牌只在引擎进程里，浏览器侧不持有）。
 		 *
@@ -1021,6 +1302,10 @@ window.__ModuleLoader__.load({
 			/** 「手机」页签：采纳为本地工作区。 */
 			var pickLocal = function () {
 				if (loc.path === '') return;
+				// ⚠️ **必须清掉电脑那条兜底**（见 `pendingWorkspaceCwd`）：用户从
+				// 电脑工作区切回手机默认工作区时，若不清，模型/预设会继续按
+				// 「电脑」筛 —— 正是用户报的「切回默认工作区，预设和模型都没改回来」。
+				setPendingWorkspace(null);
 				onPicked(loc.path);
 			};
 
@@ -1308,6 +1593,13 @@ window.__ModuleLoader__.load({
 						// ⚠️ **先登记、再打开**，顺序反了就会静默失败（见 `registerLocal`）。
 						return settleLocal(result).then(function () {
 							if (!aliveRef.current) return;
+							// ⚠️ 会话行还没带上 cwd 之前，模型/预设菜单靠这个值判断
+							// 「这是电脑工作区」（见 `pendingWorkspaceCwd`）。不设的话，
+							// 新建出来的电脑会话在那一小段窗口里会被判成本地，
+							// 模型菜单显示手机模型 —— 用户报障就是这个。
+							if (result && typeof result.cwd === 'string' && result.cwd !== '') {
+								setPendingWorkspace(result.cwd);
+							}
 							patch({ creating: false });
 							onCancel();
 							if (openSession !== undefined && result && result.sessionId) {
@@ -1749,7 +2041,7 @@ window.__ModuleLoader__.load({
 		//#endregion
 
 		/** 需要宿主提供的服务：slot 注册表、工作区浏览与导航、会话数据。 */
-		const inject = ['slots', 'uiWorkspace', 'sessions'];
+		const inject = ['slots', 'uiWorkspace', 'sessions', 'workspaces'];
 
 		/**
 		 * Client 插件主体：注册「手机 / 电脑」双页签的目录选择对话框 + 订阅流式帧。

package/lib/index.js

@@ -75,6 +75,13 @@ const SESSIONS_PATH = join(STATE_DIR, 'sessions.json');
 /** 默认隧道地址。 */
 const DEFAULT_ENDPOINT = 'https://dsh-remote.jiulingssh.xyz';
 
+/**
+ * 凭据只允许发往这个 DNS 区（见 `assertTrustedHost`）。
+ *
+ * ⚠️ 与配对服务端的 `CF_ZONE_NAME` 是同一个常量，改一处必须改两处。
+ */
+const CF_ZONE_NAME = 'jiulingssh.xyz';
+
 /**
  * 配对服务地址。
  *
@@ -262,6 +269,16 @@ function saveRemoteSessions(set, logger) {
  * @returns 响应。
  */
 async function remoteFetch(url, init) {
+	// ⚠️⚠️ **禁止跟随重定向**（外部审计 M7）。实测：302 跨源会**带着
+	// `x-dsh-remote-token`** 打到攻击者的主机上，307 则会把整个请求体
+	//（含 `{"pairCode":…}`）原样重发过去。端点被攻陷、或上游插一个重定向，
+	// 令牌/配对码就送出去了。
+	//
+	// `redirect: 'manual'` 让 fetch 把 3xx 当普通响应返回（`res.ok === false`），
+	// 于是上层按 HTTP 错误处理 —— 这正是我们要的：**宁可不配，也不把凭据送去
+	// 一个不像我们服务器的地方。**
+	init = { redirect: 'manual', ...init };
+	assertTrustedHost(url);
 	const pool = await remotePool();
 	// ① 首选：undici 专用池（关掉 autoSelectFamily，Android 上最稳）。
 	// ② 备用：`node:https`（强制 IPv4，不依赖 undici 解析）。
@@ -271,9 +288,26 @@ async function remoteFetch(url, init) {
 	// （请求到了）又有界面上的 `fetch failed`（请求没到）—— 说明是**间歇性**
 	// 建连失败。只修「undici 没解析到」那一种情形，另一种照样挂。
 	//
-	// 重试是安全的：`fetch()` 抛错意味着**建连或响应头阶段**就失败了，
-	// 此时响应体一个字节都还没消费，重发不会产生重复副作用。
-	// （流中途断开不会走到这里 —— 那是 `for await` 里的事，不在本函数内。）
+	// ⚠️ 重试的**安全性由调用方的幂等键保证**，不能靠「fetch 抛错就一定没送到」
+	// 这个假设（外部审计 L6）。
+	//
+	// 原来这里的注释写的是「`fetch()` 抛错意味着建连或响应头阶段就失败了，
+	// 重发不会产生重复副作用」—— 这句话**不成立**：连接可能在服务器**已经处理完
+	// 请求**、响应头还没回来时断掉（隧道掐连接、手机切网、CF 边缘超时都会这样）。
+	// 那时重发就是**同一件事做两遍**。
+	//
+	// 对只读调用（`listDirectory` / `modelCatalog` / `presetList`）无所谓；
+	// 对写操作要靠幂等键：
+	//
+	// | 方法 | 幂等键 |
+	// |---|---|
+	// | `prompt` | **`requestId`** —— 手机端**总是**带上（见 `controller.prompt`），
+	// |          | 电脑端用它做 `hasPromptRequest` 去重 |
+	// | `createSession` | `sessionId`（同 id 重复创建是复用） |
+	// | `cancel` | 天然幂等 |
+	//
+	// ⚠️ 所以**新增写操作时必须一起想清楚它的幂等键**；没有幂等键的写操作
+	// **不能**走这条重试路径（否则一次建连抖动 = 一次重复副作用）。
 	const attempts = [];
 	if (pool !== null) {
 		try {
@@ -295,6 +329,43 @@ async function remoteFetch(url, init) {
 	}
 }
 
+/**
+ * 端点域名白名单：只往 `*.jiulingssh.xyz` 送凭据。
+ *
+ * ## 为什么需要（外部审计 M7）
+ *
+ * `payload.hostname` 是**网络对端**给的字段（配对服务器的响应、或 `mobile.json`
+ * 里被改过的值），而调用方会拿它拼 URL 去发请求 —— 请求里带着 `accessToken`。
+ * 审计实测的两种绕过：
+ * ① `https://a@evil.com` 这类 **userinfo 写法**，人眼看是 `a@`，实际 host 是
+ *    `evil.com`；
+ * ② 上游插一个 302/307 重定向（已由 `redirect:'manual'` 挡掉，但域名白名单是
+ *    第二道，且能挡住「直接写一个外域」这种更朴素的写法）。
+ *
+ * ⚠️ **用 `new URL(...).hostname` 判，不要用字符串 `includes`**：`includes` 对
+ * `evil.com/?x=jiulingssh.xyz` 和 `jiulingssh.xyz.evil.com` 都会误判为通过。
+ * ⚠️ 判的是**后缀且必须是子域边界**：`evil-jiulingssh.xyz` 不该通过，
+ * 所以比的是 `.jiulingssh.xyz` 结尾（或正好等于 `jiulingssh.xyz`）。
+ *
+ * @param url - 完整 URL。
+ * @throws 当目标域名不在白名单里时。
+ */
+function assertTrustedHost(url) {
+	let host;
+	try {
+		host = new URL(url).hostname.toLowerCase();
+	} catch {
+		throw new Error('目标地址不是合法 URL，已拒绝发送凭据');
+	}
+	const zone = CF_ZONE_NAME.toLowerCase();
+	if (host === zone || host.endsWith(`.${zone}`)) return;
+	// ⚠️ **放行 loopback**：本机调试 / 自建反代 / 测试用的就是 `127.0.0.1`，
+	// 而且往 loopback 送凭据**不构成外泄**（出不了这台机器）。少了这一条，
+	// 所有走本机端点的测试与自建部署都会直接报错。
+	if (host === '127.0.0.1' || host === 'localhost' || host === '[::1]' || host === '::1') return;
+	throw new Error(`拒绝对 ${host} 发送凭据（只允许 ${zone} 下的地址或本机）`);
+}
+
 /**
  * 是否是**主动中止**（不是网络故障）。
  *
@@ -589,6 +660,51 @@ async function claimPairing(code) {
 	return saveConfig(endpoint, token);
 }
 
+/**
+ * 目录缓存专用的**空对象**：没有原型，因此不可能被 `__proto__` 之类的键污染。
+ *
+ * ## 为什么（外部审计 5.2e）
+ *
+ * `desktopCache.dirs` 的键来自 `params.path`（前端传上来的电脑路径）。
+ * 用普通对象 `{}` 时，`dirs['__proto__'] = x` 走的是**原型设置**语义
+ * （而不是添一个属性）⇒ 改写这个对象的原型链。审计标为「自伤为主」——
+ * 确实不是远程接管，但那是因为这个对象的原型恰好没被别处依赖；
+ * 「恰好没被依赖」不是安全边界，是运气。
+ *
+ * `Object.create(null)` 让 `__proto__` 变回一个**普通字符串键**，
+ * 污染这条路从语义上就不存在了。同时把 `__proto__` 显式拒掉：
+ * 它本来也不是一个合法的电脑路径。
+ *
+ * @returns 无原型空对象。
+ */
+function emptyDirCache() {
+	return Object.create(null);
+}
+
+/**
+ * 这个键能不能当目录缓存的键。
+ *
+ * @param path - 前端传来的路径。
+ * @returns 是否可接受。
+ */
+function isSafeCacheKey(path) {
+	return typeof path === 'string' && path !== '' && path !== '__proto__' && path !== 'constructor';
+}
+
+/**
+ * 单个镜像事件的字节上限（4 MiB，外部审计 5.2b）。
+ *
+ * `mirrorEvent` 把**公网那台电脑**发来的事件原样 `append` 进手机本地会话。
+ * 没有上限时，对端只要发一条 `data` 巨大（或条数无限）的事件，就能把手机存储
+ * 写满 —— 而会话日志是**只增不减**的（`session.v4.jsonl`），写满之后 App
+ * 连自己的配置都写不进去。
+ *
+ * 4 MiB 的依据：正常事件里最大的是 `assistant/message` 的正文与工具输出，
+ * 实测都在几十 KB 量级；附件字节**不走这条路**（它们以 content part 的形式
+ * 在 RPC 里传，已经在 `RPC_BODY_LIMIT` 里限过）。所以 4 MiB 对合法事件极其宽松。
+ */
+const MIRROR_EVENT_LIMIT = 4 * 1024 * 1024;
+
 /**
  * 把一个电脑事件写进手机本地会话。
  *
@@ -617,14 +733,34 @@ async function claimPairing(code) {
  * @returns 是否写入了。
  */
 function mirrorEvent(session, event, state) {
+	// 同理：`type` 必须是字符串，否则 `session.append` 会拿到非字符串的键。
+	if (typeof event.type !== 'string' || event.type === '') {
+		throw new Error('事件流里的事件缺少 type，已拒收');
+	}
 	// ⚠️ `session/end-seed` 必须跳过：手机端没有对应的一条，写进去会让后续全部错位。
 	// 它只会出现在电脑日志的最开头，所以偏移量只认一次 —— 否则 SSE 重连补发
 	// 历史时会被反复累加，后续事件的折算 seq 越算越小。
+	//
+	// ⚠️ 这一条**排在最前面且不写入任何内容**，所以它不需要 `seq` 也安全：
+	// 唯一副作用是把 `skippedSeeds` 置 1（只置一次）。
 	if (event.type === 'session/end-seed') {
 		if (state.skippedSeeds === 0) state.skippedSeeds = 1;
 		return false;
 	}
-	if (typeof event.seq === 'number') {
+	// ⚠️ **`seq` 必须是数字，不是数字一律拒收**（外部审计 5.2c / L8）。
+	//
+	// 原来的写法是 `if (typeof event.seq === 'number') { ...对齐检查... }` ——
+	// 也就是说 `seq` 为 `undefined` / 字符串 / `null` 时**整段对齐检查被跳过**，
+	// 事件直接 `append` 进去。而这条流的对端是**公网上的那台电脑**：它（或链路
+	// 中间任何人）只要发一条没有 `seq` 的事件，就能往手机本地会话里插一条
+	// 不被对齐检查约束的记录 —— 后面所有事件的 seq 随之错位，搬运逻辑失效。
+	//
+	// 对齐检查是**正确性的地基**，它的前置条件不能是「攻击者给面子」。
+	// 所以这里倒过来写：先证明 `seq` 合法，再谈对齐；不合法就不认这条事件。
+	if (typeof event.seq !== 'number' || !Number.isInteger(event.seq) || event.seq < 0) {
+		throw new Error(`事件流里的 seq 不是非负整数（${JSON.stringify(event.seq)}），已拒收`);
+	}
+	{
 		const expected = event.seq - state.skippedSeeds;
 		if (expected < session.seq) return false; // 重连补发的历史，已写过
 		if (expected > session.seq) {
@@ -633,6 +769,24 @@ function mirrorEvent(session, event, state) {
 			);
 		}
 	}
+	// ⚠️ **大小上限**（外部审计 5.2b）：会话日志只增不减，一条巨型事件就能把
+	// 手机存储写满，之后 App 连自己的配置都写不进去。这里在 `append` **之前**判，
+	// 因为 `append` 一旦落盘就没法撤。
+	//
+	// 判据用 `JSON.stringify` 后的字节数（`Buffer.byteLength`）：`event.data`
+	// 的结构千变万化（正文、工具输出、patch 文本），逐个字段估不现实，
+	// 序列化长度才是真正会落盘的那份体积。
+	let serialized;
+	try {
+		serialized = JSON.stringify(event.data ?? null);
+	} catch (error) {
+		throw new Error(`事件 data 无法序列化（${String(error?.message ?? error)}），已拒收`);
+	}
+	if (Buffer.byteLength(serialized, 'utf8') > MIRROR_EVENT_LIMIT) {
+		throw new Error(
+			`事件 data 超过 ${Math.floor(MIRROR_EVENT_LIMIT / (1024 * 1024))} MiB（type=${event.type}），已拒收`,
+		);
+	}
 	const opts = {};
 	if (event.surfaceOp !== undefined) opts.surfaceOp = event.surfaceOp;
 	if (event.sourceEventSeqs !== undefined) opts.sourceEventSeqs = event.sourceEventSeqs;
@@ -640,6 +794,154 @@ function mirrorEvent(session, event, state) {
 	return true;
 }
 
+/** 降级（= 拿不到引擎判据）只告警一次，别刷屏。 */
+let bridgeDegradedWarned = false;
+
+/**
+ * `/api/dsh-remote/rpc` 请求体的上限（48 MiB）。
+ *
+ * ## 为什么必须有限制（外部审计 5.2a）
+ *
+ * 原来 handler 里是裸的 `req.on('data', c => chunks.push(c))`：
+ *
+ * - **没有上限**：手机上任一能打 loopback 的进程（或重载窗口内的任一页面）
+ *   只要 `POST` 一个无限长的 body，就能让引擎进程把内存吃干净
+ *   ⇒ OOM / 引擎重启（会话全中断）。这是**DoS**，不是「资源紧张」。
+ * - **没有 `content-type` 校验**：跨站表单可以直接 `POST` 一个
+ *   `text/plain` 的 body（那是**不会触发 CORS 预检**的三种 content-type 之一），
+ *   于是「body 必须是 JSON」这层防护可以绕过 —— 配合 `seq` 非数字等
+ *   （见 `mirrorEvent`）就能构造非预期的写入。
+ *
+ * ## 为什么是 48 MiB
+ *
+ * 图片附件是 **base64 内联**在 body 里的（见 `controller.prompt` 的注释），
+ * base64 会膨胀 4/3，再算上 JSON 转义 ⇒ 32 MiB 的原图约 43 MiB 的 body。
+ * 48 MiB 够放一张 32 MiB 的图，同时远小于「能把引擎搞死」的量级。
+ * 手机拍照一般 3–8 MiB，正常使用碰不到这个上限。
+ */
+const RPC_BODY_LIMIT = 48 * 1024 * 1024;
+
+/**
+ * 电脑 → 手机的 SSE 单条消息上限（8 MiB，外部审计 5.2b）。
+ *
+ * `follow()` 里用 `buffer` 累积到 `\n\n` 才切一条消息。对手（公网上的那台电脑，
+ * 或链路中间任何人）只要**一直不发空行**，`buffer` 就会无限增长 ⇒ 手机 OOM。
+ * 8 MiB 对正常的一帧（AI 正文分片，KB 量级）有巨大余量，
+ * 超过就说明对端不是在发 SSE，直接判为协议错误断开。
+ */
+const SSE_BUFFER_LIMIT = 8 * 1024 * 1024;
+
+/**
+ * 读一个请求体，**带上限和类型检查**（外部审计 5.2a）。
+ *
+ * @param req - HTTP 请求。
+ * @param limit - 上限字节数。
+ * @returns `{ ok:true, text }` 或 `{ ok:false, code, message }`。
+ */
+function readBodyLimited(req, limit) {
+	return new Promise((resolve) => {
+		const chunks = [];
+		let size = 0;
+		let settled = false;
+		const done = (value) => {
+			if (settled) return;
+			settled = true;
+			resolve(value);
+		};
+		req.on('data', (chunk) => {
+			if (settled) return;
+			size += chunk.length;
+			if (size > limit) {
+				// ⚠️ 超限就**立刻**停：不能继续 push 到内存里再判断，
+				// 那样上限形同虚设（攻击者还是把内存吃光了）。
+				done({
+					ok: false,
+					code: 413,
+					message: `请求体过大（上限 ${Math.floor(limit / (1024 * 1024))} MiB）`,
+				});
+				return;
+			}
+			chunks.push(chunk);
+		});
+		req.on('end', () => done({ ok: true, text: Buffer.concat(chunks).toString('utf8') }));
+		req.on('error', (error) =>
+			done({ ok: false, code: 400, message: `读取请求体失败: ${String(error?.message ?? error)}` }),
+		);
+	});
+}
+
+/**
+ * 桥路由的准入检查。
+ *
+ * ## ⚠️ 为什么必须自己加（外部审计 D5）
+ *
+ * 引擎的 `webserver` 只按 pathname 查表，**路由命中前不做任何鉴权**；
+ * 引擎自己的准入（Host / `sec-fetch-site` / Origin / 浏览器会话 cookie）加在
+ * **它自己那条 `/api` 前缀路由的 handler 里**。而 `match()` 是「**精确表先命中**」——
+ * 本插件的 `kind:'exact'` 路由 `/api/dsh-remote/rpc` 会比引擎的 `/api` 前缀
+ * **先**被选中，于是引擎那层门根本不会被调用。
+ *
+ * 后果（审计原文）：手机上任一其它 App（Android loopback 跨 App 可达）或任一
+ * 页面都能打 `/api/dsh-remote/rpc` —— `pair`（把手机改指到别人的电脑）、
+ * `unpair`、`listDesktop`、`createSession` 全都能打；`GET /api/dsh-remote/stream`
+ * 更是直接读走**全部远程会话的流式 AI 正文**。
+ *
+ * ## 做法：**复用引擎自己的判据**，不自己重写一套
+ *
+ * `connection` 服务暴露了 `requestRejection(request)` —— 它内部就是
+ * ①`isTrustedApiRequest`（Host 必须 loopback 或受信 + `sec-fetch-site !== 'cross-site'`
+ * + Origin 与 Host 同源）②`browserAuth.isAuthenticated`（**浏览器会话 cookie**）。
+ *
+ * ⚠️ **不自己照抄这两条的实现**：引擎升级判据时（比如加一条新的 fetch metadata
+ * 检查），复用它就自动跟上；照抄的副本会悄悄过期，那才是真正的隐患。
+ *
+ * ⚠️ **第二条（cookie）才是关键**：只判 Host 是 loopback 挡不住同机的其它 App ——
+ * 它们打 `127.0.0.1` 时 Host 也是 loopback。而 WebView 页面世界的请求天然带
+ * 引擎签发的会话 cookie，原生 App 拿不到。所以这道门对页面透明、对其它 App 关闭。
+ *
+ * ## ⚠️ 取不到 `connection` 一律 **fail-closed（503）**，绝不降级（外部审计 5.1）
+ *
+ * 第一版在这里回退到「Host + Origin + sec-fetch-site」的弱判据 —— 那是
+ * **fail-open**：弱判据里**没有 cookie 这一条**，而非浏览器客户端（本机任意
+ * 其它 App）天然不带 `sec-fetch-site`，于是全过。等于把上面刚关上的门又打开。
+ *
+ * 更糟的是它**有一个必然出现的窗口**：cordis 的 `ctx.get(name, strict)` 对
+ * 尚未 ACTIVE 的提供者返回 `undefined`（`cordis/lib/index.js:770`），而
+ * client-connection 的 `apply` 里 `await BrowserAuth.create(...)` 排在
+ * `provide('connection')` **之前** ⇒ 引擎启动 / 插件重载 / `cordis.patch.yml`
+ * HMR 期间，本插件同步注册的路由**已经在收请求**，而 `connection` 还没就绪。
+ * 审计已用手机 `engine.bin` 自带的那份 cordis 合成复现：窗口内探针全放行。
+ *
+ * 所以这里只有两种结局：**能拿到服务 → 用引擎的判据**；**拿不到 → 503**。
+ * 「服务缺失」是暂时不可用，「降级」是一直不安全 —— 后者严重得多，不能拿
+ * 可用性换。同理，`requestRejection` 自己抛错也一律 503：判据没跑成，
+ * 就等于没有判据，不能默认放行。
+ *
+ * @param ctx - Cordis 上下文。
+ * @param req - 请求。
+ * @returns 拒绝时的 HTTP 状态码，放行时 `undefined`。
+ */
+function bridgeRejection(ctx, req) {
+	const connection = ctx.get?.('connection');
+	if (connection === undefined || typeof connection.requestRejection !== 'function') {
+		if (!bridgeDegradedWarned) {
+			bridgeDegradedWarned = true;
+			ctx.logger?.warn?.(
+				'[dsh-remote-mobile] connection 服务尚未就绪，桥路由一律 503（fail-closed，不降级到弱判据）',
+			);
+		}
+		return 503;
+	}
+	try {
+		return connection.requestRejection(req);
+	} catch (error) {
+		ctx.logger?.warn?.(
+			`[dsh-remote-mobile] connection.requestRejection 抛错，桥路由一律 503（fail-closed）: ${String(error?.message ?? error)}`,
+		);
+		return 503;
+	}
+}
+
 /**
  * 插件入口。
  *
@@ -702,7 +1004,7 @@ export function apply(ctx) {
 	 * 会大面积显示过期内容。所以 `dirs` 只装「用户实际看过的那几层的下一层」，
 	 * 上限见 `DESKTOP_DIRS_MAX`。过期窗口由「刷新」按钮关闭。
 	 */
-	const desktopCache = { catalog: null, presets: null, directory: null, dirs: {}, at: 0 };
+	const desktopCache = { catalog: null, presets: null, directory: null, dirs: emptyDirCache(), at: 0 };
 
 	/** `desktopCache.dirs` 的容量上限（按插入顺序淘汰最旧的那些）。 */
 	const DESKTOP_DIRS_MAX = 200;
@@ -775,6 +1077,9 @@ export function apply(ctx) {
 	 * @param listing - 该层的列表结果。
 	 */
 	function rememberDir(path, listing) {
+		// ⚠️ 拒掉 `__proto__` / `constructor`（外部审计 5.2e）。配合
+		// `emptyDirCache()` 的无原型对象，这是双保险：前者防语义，后者防意外。
+		if (!isSafeCacheKey(path)) return;
 		desktopCache.dirs[path] = listing;
 		const keys = Object.keys(desktopCache.dirs);
 		for (let at = 0; at + DESKTOP_DIRS_MAX < keys.length; at += 1) {
@@ -933,9 +1238,24 @@ export function apply(ctx) {
 	/**
 	 * 跟随电脑的一个会话：durable 事件写手机本地，流式帧广播给浏览器。
 	 *
+	 * ⚠️ **未配对时直接不跟**（外部审计 I2）。
+	 *
+	 * `callRemote` 有「令牌为空 ⇒ 抛错」的守卫，但 `follow()` 原来没有：它会拿着
+	 * **空令牌**去连 `config.endpoint`，然后套着退避重连循环一直重试下去。两个后果：
+	 *
+	 * - 未配对的状态下（首次装、解绑之后、用户手改 `mobile.json` 清空令牌），
+	 *   后台持续打一个空令牌的请求 —— 那是**对着一台陌生服务器敲门**，
+	 *   日志里刷满失败，还白耗手机流量与电。
+	 * - 如果 `endpoint` 恰好指向某台仍在跑的电脑，那条空令牌请求会拿到 401，
+	 *   但重连退避会一直重试（永不放弃），这类循环在移动端是电量和流量杀手。
+	 *
+	 * 调用方（`handleBridge` 的 `createSession` / 恢复流程）在未配对时本来就
+	 * 不会走到这里 —— 这道守卫是**兜住所有调用路径**，不依赖调用方记得检查。
+	 *
 	 * @param sessionId - 两端同名的会话 id。
 	 */
 	const follow = (sessionId) => {
+		if (config.token === EMPTY_TOKEN) return;
 		if (follows.has(sessionId)) return;
 		const controller = new AbortController();
 		follows.set(sessionId, controller);
@@ -948,13 +1268,17 @@ export function apply(ctx) {
 		 * 折算把已写过的跳过，不会重复。
 		 */
 		const once = async () => {
-			const url =
-				`${config.endpoint}/api/dsh-remote/stream` +
-				`?session=${encodeURIComponent(sessionId)}&token=${encodeURIComponent(config.token)}`;
+			// ⚠️⚠️ **令牌走 header，不走 URL query**（外部审计 M3）。
+			// `?token=…` 会进 Cloudflare 隧道日志、任何反代/网关的 access log、
+			// 以及浏览器历史（如果哪天这条被页面直接打开）。桌面端本来就支持
+			// `x-dsh-remote-token` 头，所以这里换掉没有任何兼容代价 ——
+			// 而这条是 node 发起的请求，**本来就不需要** query 形式
+			//（query 形式只为浏览器 `EventSource` 保留，它设不了自定义头）。
+			const url = `${config.endpoint}/api/dsh-remote/stream?session=${encodeURIComponent(sessionId)}`;
 			// ⚠️ 必须走 `remoteFetch`（自带 dispatcher）：全局 fetch 的 dispatcher
 			// 在 Android 上连不通公网，见 `remoteFetch` 的注释。
 			const res = await remoteFetch(url, {
-				headers: { accept: 'text/event-stream' },
+				headers: { accept: 'text/event-stream', 'x-dsh-remote-token': config.token },
 				signal: controller.signal,
 			});
 			if (!res.ok || res.body === null) throw new Error(`HTTP ${res.status}`);
@@ -963,6 +1287,16 @@ export function apply(ctx) {
 			let buffer = '';
 			for await (const chunk of res.body) {
 				buffer += decoder.decode(chunk, { stream: true });
+				// ⚠️ **buffer 必须有上限**（外部审计 5.2b）：SSE 靠空行分隔消息，
+				// 若对端一直不发空行（恶意电脑 / 中间人 / 隧道注入），
+				// `buffer` 会无限增长直到手机 OOM。这是**输入侧**的 DoS，
+				// 而这条流的对端是「公网上的那台电脑」—— 正是不可信的那一侧。
+				//
+				// 上限取 8 MiB：正常一帧（AI 正文分片）是几百字节到几 KB 量级，
+				// 8 MiB 已经远超任何合法帧；超了说明对端不是在发 SSE。
+				if (buffer.length > SSE_BUFFER_LIMIT) {
+					throw new Error(`SSE 单条消息超过 ${Math.floor(SSE_BUFFER_LIMIT / (1024 * 1024))} MiB，已断开`);
+				}
 				// SSE 以空行分隔消息；末段可能不完整，留在 buffer 里。
 				let split;
 				while ((split = buffer.indexOf('\n\n')) >= 0) {
@@ -1141,12 +1475,26 @@ export function apply(ctx) {
 			//
 			// 把前端的 requestId 原样带过去：电脑端会把它写进
 			// `source.rpcId`，前端凭这个结算「提交中」状态并显示用户气泡。
+			//
+			// ⚠️⚠️ **`requestId` 是这条调用在跨通道重试下的幂等键，必须总是有**
+			// （外部审计 L6）。原来写的是
+			// `...(request.requestId === undefined ? {} : { requestId: request.requestId })`
+			// —— 前端偶尔不带（某些调用路径、旧缓存的前端包）时，这里就**没有幂等键**，
+			// 而 `remoteFetch` 在第一条通道失败后会**原样重发**这个 body。
+			// 后果是用户在电脑上**看到同一条消息发了两次**，AI 也就跑了两轮。
+			//
+			// 所以缺省时在这里补一个：用 `randomUUID()` 而不是「前端那个可能重复的
+			// 时间戳」，因为它必须每次都是新的（否则去重逻辑会把正常消息当成重复的）。
+			// 传了就用传的 —— 前端的 requestId 是它结算 UI 的依据，不能换。
 			await callRemote(config, 'prompt', {
 				sessionId: request.sessionId,
 				text,
 				// 附件形态一并带上（没有附件时给空数组，电脑端会退回纯文本）。
 				content,
-				...(request.requestId === undefined ? {} : { requestId: request.requestId }),
+				requestId:
+					typeof request.requestId === 'string' && request.requestId !== ''
+						? request.requestId
+						: randomUUID(),
 			});
 			// 确保事件流在线（断线时重连，补齐这段时间的事件）。
 			follow(request.sessionId);
@@ -1506,41 +1854,60 @@ export function apply(ctx) {
 						res.writeHead(code, { 'content-type': 'application/json; charset=utf-8' });
 						res.end(JSON.stringify(payload));
 					};
-					const chunks = [];
-					req.on('data', (c) => chunks.push(c));
-					req.on('end', async () => {
+					// ⚠️ 前置准入，必须在解析 body 之前（见 `bridgeRejection` 的 docstring）。
+					const rejected = bridgeRejection(ctx, req);
+					if (rejected !== undefined) {
+						res.writeHead(rejected);
+						res.end();
+						return;
+					}
+					// ⚠️ **必须校验 content-type**（外部审计 5.2a）：跨站表单能直接发
+					// `text/plain`，而那是不触发 CORS 预检的三种类型之一；本插件的门
+					// 是非浏览器的（原生 App / 重载窗口内的页面）也过得了。
+					// 这一条把「body 必须是 JSON」变成硬约束，而不是靠 JSON.parse 兜底。
+					const contentType = String(req.headers['content-type'] ?? '');
+					if (!contentType.toLowerCase().includes('application/json')) {
+						reply(415, { error: 'content-type 必须是 application/json' });
+						return;
+					}
+					readBodyLimited(req, RPC_BODY_LIMIT).then((read) => {
+						if (!read.ok) {
+							// ⚠️ 超限/读错时**断开连接**：不把剩下的字节继续收进来，
+							// 否则「限制」只是不发回应，内存照样被吃光。
+							reply(read.code, { error: read.message });
+							req.destroy();
+							return;
+						}
 						let body;
 						try {
-							body = JSON.parse(Buffer.concat(chunks).toString('utf8'));
+							body = JSON.parse(read.text);
 						} catch (error) {
 							reply(400, { error: `bad json: ${String(error?.message ?? error)}` });
 							return;
 						}
-						try {
-							const result = await handleBridge(ctx, config, {
-								remoteSessions,
-								follow,
-								// 解绑要能停掉全部旧连接、清掉全部搬运状态（见 `unpair`）。
-								follows,
-								mirrorStates,
-								// ⚠️ **必须显式传进来**：`handleBridge` 是模块级函数，作用域里
-								// 没有 `apply()` 的闭包变量；漏传就是 `workspaceMap is not defined`，
-								// 用户点「在此新建对话」时必然失败（1.0.16 的真实报障）。
-								workspaceMap,
-								persist: () => saveRemoteSessions(remoteSessions, ctx.logger),
-								// 模型/预设的静默缓存：配对后预拉、刷新按钮回写（见 desktopCache）。
-								desktopCache,
-								prefetch: prefetchDesktop,
-								// ⚠️ 同 `workspaceMap`：`handleBridge` 是模块级函数，闭包里的
-								// `prefetchDirs` / `rememberDir` 它看不见，必须显式传。
-								prefetchDirs,
-								rememberDir,
-								body,
-							});
-							reply(200, { ok: true, result });
-						} catch (error) {
-							reply(200, { ok: false, error: String(error?.message ?? error) });
-						}
+						handleBridge(ctx, config, {
+							remoteSessions,
+							follow,
+							// 解绑要能停掉全部旧连接、清掉全部搬运状态（见 `unpair`）。
+							follows,
+							mirrorStates,
+							// ⚠️ **必须显式传进来**：`handleBridge` 是模块级函数，作用域里
+							// 没有 `apply()` 的闭包变量；漏传就是 `workspaceMap is not defined`，
+							// 用户点「在此新建对话」时必然失败（1.0.16 的真实报障）。
+							workspaceMap,
+							persist: () => saveRemoteSessions(remoteSessions, ctx.logger),
+							// 模型/预设的静默缓存：配对后预拉、刷新按钮回写（见 desktopCache）。
+							desktopCache,
+							prefetch: prefetchDesktop,
+							// ⚠️ 同 `workspaceMap`：`handleBridge` 是模块级函数，闭包里的
+							// `prefetchDirs` / `rememberDir` 它看不见，必须显式传。
+							prefetchDirs,
+							rememberDir,
+							body,
+						}).then(
+							(result) => reply(200, { ok: true, result }),
+							(error) => reply(200, { ok: false, error: String(error?.message ?? error) }),
+						);
 					});
 				},
 			}),
@@ -1554,6 +1921,14 @@ export function apply(ctx) {
 				kind: 'exact',
 				path: ROUTE_STREAM,
 				handler: (req, res) => {
+					// ⚠️ 同上：`GET /api/dsh-remote/stream` 会把**全部远程会话的
+					// 流式 AI 正文**推给任何一个订阅者（外部审计 D5），必须有门。
+					const rejected = bridgeRejection(ctx, req);
+					if (rejected !== undefined) {
+						res.writeHead(rejected);
+						res.end();
+						return;
+					}
 					res.writeHead(200, {
 						'content-type': 'text/event-stream; charset=utf-8',
 						'cache-control': 'no-store, no-transform',
@@ -1736,7 +2111,14 @@ async function handleBridge(ctx, config, io) {
 		case 'listDesktop': {
 			const wantRoot = params.path === undefined || params.path === null || params.path === '';
 			const path = wantRoot ? '' : params.path;
-			const cached = wantRoot ? io.desktopCache?.directory : io.desktopCache?.dirs?.[path];
+			// ⚠️ 读缓存也要过 `isSafeCacheKey`（外部审计 5.2e）：`dirs['__proto__']`
+			// 在无原型对象上是 `undefined`，但在**普通对象**上会返回 `Object.prototype`
+			// ⇒ 缓存命中一个不是列表的东西。这里两个条件都要求。
+			const cached = wantRoot
+				? io.desktopCache?.directory
+				: isSafeCacheKey(path)
+					? io.desktopCache?.dirs?.[path]
+					: undefined;
 			if (cached != null) {
 				// 命中也要预取下一层：用户还没离开这一屏。
 				io.prefetchDirs?.(cached);
@@ -1807,7 +2189,7 @@ async function handleBridge(ctx, config, io) {
 				// ⚠️ **刷新要把子层缓存整棵作废**：用户点刷新就是要看电脑现状，
 				// 留着旧的子层，点进去看到的还是刷新前的内容（根层作废了、
 				// 子层没作废，比两处都不作废更难解释）。
-				io.desktopCache.dirs = {};
+				io.desktopCache.dirs = emptyDirCache();
 				if (
 					result.directory?.ok === true &&
 					io.desktopCache.directory?.path === result.directory.value?.path
@@ -2008,7 +2390,7 @@ async function handleBridge(ctx, config, io) {
 			// **累加**的（用户每浏览一层写一格），不清的话换一台电脑配对后，
 			// 旧电脑那些子目录还会命中缓存 —— 用户点进去看到的是上一台电脑的内容。
 			if (io.desktopCache !== undefined) {
-				io.desktopCache.dirs = {};
+				io.desktopCache.dirs = emptyDirCache();
 				io.desktopCache.directory = null;
 			}
 			io.persist();

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "dsh-jiuling-remote-mobile",
-  "version": "1.0.20",
+  "version": "1.0.24",
   "description": "DSH 远程目录（手机端）：在选文件夹流程里多出「电脑」页签，进入电脑目录、在电脑上发起对话，并把电脑的实时消息流同步到手机本地界面（只传文本，不映射桌面）。",
   "type": "module",
   "main": "./lib/index.js",