dsh-jiuling-remote-mobile 1.0.18 → 1.0.20

package/lib/client.js

@@ -261,6 +261,478 @@ window.__ModuleLoader__.load({
 			desktopDirCache = {};
 		}
 
+		/**
+		 * 哪些会话是「跑在电脑上的」—— 宿主 `remoteSessions` 的本地镜像。
+		 *
+		 * ## 为什么需要（用户需求原文）
+		 *
+		 * 「用户如果当前选择的是 **app 本地文件夹**，那么**就不要出现电脑的模型**，
+		 * 以这个文件夹为隔离条件，**互不干预**」。
+		 *
+		 * 宿主把电脑的模型目录与手机本地那份**并**在一起交给前端（原因见宿主
+		 * `mergeCatalog` 的注释：官方 `modelCatalog` 是全局唯一一份、不带 sessionId）。
+		 * 所以要按工作区隔离，只能在**前端按会话**再筛一次 —— 而筛之前必须先知道
+		 * 「这个会话是不是电脑的」。
+		 *
+		 * ⚠️ **判据必须与宿主 `prompt` 拦截同源**（宿主读的也是 `remoteSessions`）。
+		 * 用 cwd 猜镜像目录是另一套判据，一旦两者不一致，就会出现「菜单里显示的是
+		 * 电脑模型、消息却发到手机本地」这种最坏情况。
+		 *
+		 * ⚠️ **不能每次渲染打一次桥**：模型菜单每帧都读目录快照，那是同步 API。
+		 * 所以 `apply` 时拉一次全量，之后建会话 / 解绑时自己增量维护，
+		 * `getSnapshot` 纯查内存（见宿主 `case 'remoteSessions'` 的注释）。
+		 */
+		var remoteSessionIds = {};
+
+		/**
+		 * 电脑镜像工作区的 slug 集合 —— 隔离的**真正判据**。
+		 *
+		 * ⚠️⚠️ **为什么不用 `remoteSessionIds`（那是第一代，已被用户报障推翻）。**
+		 *
+		 * 第一代按 **sessionId** 判定，只在「用户从电脑文件夹对话框里建会话」
+		 * 或「宿主拦截器绑过」时才知道。而用户在**侧边栏点「新建会话」**时，
+		 * 官方前端直接 `sessionController.create({workspaceId})`，**不经过本插件**；
+		 * 宿主的 create 拦截器认得出镜像目录（消息发得对），但前端不知道
+		 * ⇒ 模型菜单仍按「本地」筛，显示手机模型。
+		 *
+		 * 用户原话：「只有我手动添加工作区的时候，才会触发模型和预设的刷新」——
+		 * 说的就是判据挂在了「走了哪条路」上，而不是「会话的工作区在哪」。
+		 *
+		 * 正解：**按 cwd 判定**，与宿主 `desktopPathOfMirror` 同一个轴。
+		 * 前端从 `sessions.list` 里同步读到会话的 `cwd`，看它是不是
+		 * `…/workspaces/<slug>` 且 slug 属于电脑镜像。这条路与「谁建的会话」
+		 * 完全无关，所以**任何入口进来都一致，不需要任何刷新触发**。
+		 */
+		var mirrorSlugs = {};
+
+		/**
+		 * 从 cwd 取出镜像工作区的 slug（与宿主 `desktopPathOfMirror` 同构）。
+		 *
+		 * ⚠️ 用 `/workspaces/` 定位而不是前缀比对：`workspace.path` 是 realpath，
+		 * 真机上 `/data/user/0` 与 `/data/data` 会差一层，前缀一比就永远不命中
+		 * （宿主那边踩过这个坑，注释见 `desktopPathOfMirror`）。
+		 * 两种分隔符都认：手机是 posix，但在 Windows 上调试时是 `\`。
+		 *
+		 * @param cwd - 会话的 cwd。
+		 * @returns 镜像工作区的 slug；不是镜像目录时 `undefined`。
+		 */
+		function mirrorSlugOf(cwd) {
+			if (typeof cwd !== 'string' || cwd === '') return undefined;
+			var at = cwd.search(/[\\/]workspaces[\\/]/);
+			if (at < 0) return undefined;
+			var slug = cwd.slice(at).split(/[\\/]/)[2];
+			return slug === undefined || slug === '' ? undefined : slug;
+		}
+
+		/**
+		 * 这个会话是不是跑在电脑上 —— **同步**判定，任何入口都用同一条。
+		 *
+		 * ⚠️ **cwd 读得到时，它以 cwd 为唯一判据**（不看 `remoteSessionIds`）：
+		 * 工作区就是隔离条件本身。解绑后 `mirrorSlugs` 清空 ⇒ 全部回到本地，
+		 * 不需要再去清每个会话的旧标记。
+		 *
+		 * 只有列表行还没带 cwd 的那一两帧（会话刚建好）才退回 `remoteSessionIds`。
+		 *
+		 * @param sessionId - 会话 id。
+		 * @param cwdOf - `sessionId → cwd` 的同步读取函数。
+		 * @returns 是不是电脑工作区的会话。
+		 */
+		function isRemoteSession(sessionId, cwdOf) {
+			var cwd = cwdOf === undefined ? undefined : cwdOf(sessionId);
+			if (typeof cwd === 'string' && cwd !== '') {
+				var slug = mirrorSlugOf(cwd);
+				return slug !== undefined && mirrorSlugs[slug] === true;
+			}
+			return remoteSessionIds[sessionId] === true;
+		}
+
+		/** 从宿主拉一次全量远程会话清单（失败就按「全是本地」处理）。 */
+		function loadRemoteSessionIds() {
+			return bridge('remoteSessions', {}).then(
+				function (result) {
+					var ids = result && result.ids;
+					if (!Array.isArray(ids)) return;
+					var next = {};
+					for (var at = 0; at < ids.length; at += 1) next[ids[at]] = true;
+					remoteSessionIds = next;
+				},
+				function () {
+					/* 拉不到就保持原样：最坏是本地工作区多看到电脑模型，不会误发 */
+				},
+			);
+		}
+
+		/**
+		 * 从宿主拉一次「电脑镜像工作区的 slug 集合」（隔离的真正判据）。
+		 *
+		 * 拉不到就保持原样（空集合 = 全部按本地处理）：最坏是本地工作区多看到
+		 * 电脑模型，**不会误发** —— 消息该发给谁由宿主 `prompt` 拦截器按
+		 * `remoteSessions` 决定，与这里无关。
+		 */
+		function loadMirrorSlugs() {
+			return bridge('mirrorSlugs', {}).then(
+				function (result) {
+					var slugs = result && result.slugs;
+					if (!Array.isArray(slugs)) return;
+					var next = {};
+					for (var at = 0; at < slugs.length; at += 1) next[slugs[at]] = true;
+					mirrorSlugs = next;
+				},
+				function () {
+					/* 同上：最坏是多显示几项，不会误发 */
+				},
+			);
+		}
+
+		/**
+		 * 按「这个会话是不是电脑的」筛出该显示的组与失败项。
+		 *
+		 * ## 双向隔离
+		 *
+		 * - **本地工作区**：只留手机自己的组，并把被电脑同 id provider 覆盖掉的那组
+		 *   **还原**回来（`localGroups`，宿主 `mergeCatalog` 额外带上的）。
+		 * - **电脑工作区**：只留电脑的组。这不是「顺手加活」—— 电脑会话的 prompt 会
+		 *   转发到电脑，选一个手机本地才有的模型（比如 `agnes-3.0-flash`）发过去，
+		 *   电脑上根本不存在，必然报错。用户说的「互不干预」正是这个意思。
+		 *
+		 * ⚠️ 没配对时目录里根本没有 `desktop` 标记，两个分支都会原样返回。
+		 *
+		 * ⚠️ **`extraLocal` 是必需的**：官方的 `syncInputs` 往 `directory.store`
+		 * 里只拷了 `groups` / `failures`（见
+		 * `dsh-client-ui-model-selection/lib/client.js:325`），**`localGroups` 不在
+		 * 那一层**。所以筛 `directory.store` 时得由调用方把 `localGroups`
+		 * 从 catalog 原值里递进来，否则本地工作区永远还原不出被覆盖的那组。
+		 *
+		 * @param value - 目录值（`{groups, failures, localGroups?, localFailures?}`）。
+		 * @param isRemote - 这个会话是不是跑在电脑上。
+		 * @param extraLocal - 备用本地组（`value.localGroups` 缺失时用）。
+		 * @returns `{groups, failures}`（`value` 不合法时原样返回空数组）。
+		 */
+		function pickWorkspaceGroups(value, isRemote, extraLocal) {
+			if (!value || !Array.isArray(value.groups)) {
+				return { groups: [], failures: [] };
+			}
+			const groups = value.groups;
+			const failures = Array.isArray(value.failures) ? value.failures : [];
+			if (isRemote === true) {
+				return {
+					groups: groups.filter(function (group) { return group.desktop === true; }),
+					failures: failures.filter(function (failure) { return failure.desktop === true; }),
+				};
+			}
+			const kept = groups.filter(function (group) { return group.desktop !== true; });
+			// 还原被电脑同 id 覆盖掉的本地组（见宿主 `mergeCatalog`）。
+			const local = Array.isArray(value.localGroups)
+				? value.localGroups
+				: (Array.isArray(extraLocal) ? extraLocal : []);
+			if (local.length > 0) {
+				const have = {};
+				for (let at = 0; at < kept.length; at += 1) have[kept[at].id] = true;
+				for (let lt = 0; lt < local.length; lt += 1) {
+					if (have[local[lt].id] !== true) kept.push(local[lt]);
+				}
+			}
+			return {
+				groups: kept,
+				failures: failures.filter(function (failure) { return failure.desktop !== true; }),
+			};
+		}
+
+		/**
+		 * 从共享的 catalog 原值里取「手机本地的组」（宿主 `mergeCatalog` 带的）。
+		 *
+		 * @param directory - 官方的 `ModelDirectory`（含 `.catalog`）。
+		 * @returns 本地组数组；拿不到就空数组。
+		 */
+		function localGroupsOf(directory) {
+			try {
+				// ⚠️ 不用可选链：本文件受 chrome73 语法约束（见文件头）。
+				if (!directory || !directory.catalog || !directory.catalog.store) return [];
+				const store = directory.catalog.store;
+				if (typeof store.getSnapshot !== 'function') return [];
+				const value = store.getSnapshot().value;
+				return value && Array.isArray(value.localGroups) ? value.localGroups : [];
+			} catch (error) {
+				return [];
+			}
+		}
+
+		/** 某个 `provider/model` 在给定的组里存不存在。 */
+		function isSelectable(groups, selection) {			if (!selection) return false;
+			for (let at = 0; at < groups.length; at += 1) {
+				if (groups[at].id !== selection.provider) continue;
+				const models = Array.isArray(groups[at].models) ? groups[at].models : [];
+				for (let mt = 0; mt < models.length; mt += 1) {
+					if (models[mt].id === selection.model) return true;
+				}
+			}
+			return false;
+		}
+
+		/**
+		 * 筛**目录值**（`catalog.store` 里 `{value}` 那一份）。
+		 *
+		 * ⚠️ **`default` 必须跟着换**：官方的 `syncInputs` 用
+		 * `projected.next ?? catalog.value.default` 定 `current`，如果 `default`
+		 * 指向一个已被筛掉的 provider，界面就会显示一个不在列表里的模型名。
+		 * 所以筛完若 `default` 不在剩下的组里，就退到第一个组的第一个模型。
+		 *
+		 * ⚠️ **一组都没剩时原样返回**（例如电脑那边所有 provider 都挂了）：
+		 * 宁可多显示几个，也别把菜单变成空的 —— 空菜单用户连「刷新」都点不到。
+		 *
+		 * @param value - 目录值。
+		 * @param isRemote - 这个会话是不是跑在电脑上。
+		 * @returns 筛过的目录值。
+		 */
+		function filterCatalogValue(value, isRemote) {
+			if (!value || !Array.isArray(value.groups)) return value;
+			const picked = pickWorkspaceGroups(value, isRemote);
+			if (picked.groups.length === 0) return value;
+			const next = Object.assign({}, value, {
+				groups: picked.groups,
+				failures: picked.failures,
+			});
+			if (!isSelectable(picked.groups, value.default)) {
+				const first = picked.groups[0];
+				const firstModel = Array.isArray(first.models) ? first.models[0] : undefined;
+				if (firstModel !== undefined) next.default = { provider: first.id, model: firstModel.id };
+			}
+			return next;
+		}
+
+		/**
+		 * 给官方那个**每会话共享**的 `ModelDirectory` 套一层「按工作区筛」的读路径。
+		 *
+		 * ## 为什么包装 `directoryFor` 而不是改前端 bundle
+		 *
+		 * `conversation.input.model` 这个 slot 的 `inject(sessionId)` 会调
+		 * `modelDirectories.directoryFor(sessionId)`（见
+		 * `dsh-client-ui-model-selection/lib/client.js:1189`），菜单和 `/model`
+		 * 命令都从它拿数据。`directoryFor` 是**服务实例上的普通方法**，包它
+		 * 就等于包住了这两个入口 —— 不用碰前端内部类，升级也不会碎。
+		 *
+		 * ## 为什么两层的 store 都要包
+		 *
+		 * 官方有两级快照，形状**不一样**，两个都要筛：
+		 *
+		 * | 来源 | 形状 | 谁读它 |
+		 * |---|---|---|
+		 * | `catalog.store` | `{value:{groups,default,…}, status}` | `syncInputs()` 算 `current`/`routable` |
+		 * | `directory.store` | `{groups, failures, current, status, …}` | `ModelSelect` 直接渲染 |
+		 *
+		 * 只筛 `directory.store` 的话，`syncInputs` 仍会用**没筛过**的 `default`
+		 * 把 `current` 算成被筛掉的那个模型 —— 菜单里没有它、触发按钮却显示它，
+		 * 而且 `routable` 会被算成 `false`，官方界面会提示「该 provider 的目录加载失败」。
+		 *
+		 * ## 为什么要「稳定」而不是每次新建
+		 *
+		 * `inject` 每渲染一帧都调一次 `directoryFor`，返回值里的 `store` 直接喂给
+		 * `useSyncExternalStore` 的 `subscribe`。每次返回新对象会让 React 每帧
+		 * 重订阅。所以包装缓存在原 `directory.__dshRemoteScoped` 上，生命周期跟着
+		 * 官方的会话 scope 一起走 —— 官方在 scope dispose 时删掉原实例，
+		 * 包装随之被 GC，不会累积。
+		 *
+		 * ⚠️ 用 `Object.create(原型) + Object.assign` 而不是 `{...directory}`：
+		 * `ModelDirectory` 的方法（`select` / `reasoningFor` / `syncInputs`）
+		 * 在**原型**上，展开运算符只复制自有属性、会把方法全丢掉 —— 症状是
+		 * 「点模型没反应」。
+		 *
+		 * ⚠️ `select` 走原型链、以 `this = wrapper` 调用，于是它读到的
+		 * `this.store.getSnapshot()` 是**筛过**的（`current` 正确），写回
+		 * `this.store.update()` 仍转发给原 store。读写都落在正确的那一层。
+		 *
+		 * @param directory - 官方的 `ModelDirectory` 实例。
+		 * @param sessionId - 它归属的会话。
+		 * @param cwdOf - `sessionId → cwd` 的**同步**读取函数（隔离判据要用它）。
+		 * @returns 读路径被筛过的同构对象。
+		 */
+		function scopeDirectoryToWorkspace(directory, sessionId, cwdOf) {
+			if (!directory || !directory.store || typeof directory.store.getSnapshot !== 'function') {
+				return directory;
+			}
+			// ⚠️ 判据是**每次读时现算**的（不是建包装时算一次）：会话的 cwd 可能
+			// 在列表行到达后才出现，而且解绑/换工作区都会改结论。
+			// `isRemoteSession` 见其注释 —— 它看的 cwd，跟宿主 `desktopPathOfMirror` 同一个轴。
+			const isRemote = function () { return isRemoteSession(sessionId, cwdOf); };
+			const wrapper = Object.create(Object.getPrototypeOf(directory));
+			Object.assign(wrapper, directory);
+
+			/**
+			 * 包一层 store：读时筛，通知与写回照旧转发。
+			 *
+			 * ⚠️⚠️ **`getSnapshot()` 必须身份稳定**，否则 React 直接炸。这条是
+			 * 1.0.19 第二次真机启动实测到的（第一次是上面的 `remote.session`）：
+			 *
+			 *     [web] slot entry crashed in 'conversation.input.model':
+			 *           Error: Minified React error #185
+			 *
+			 * #185 就是「Maximum update depth exceeded」（无限重渲染）。原因：
+			 * 官方把这个 store 的 `getSnapshot` 直接喂给 `useSyncExternalStore`，
+			 * 而 React 在渲染期用 **`Object.is`** 比较前后两次快照，不同就再渲染一次。
+			 * 而 `pickWorkspaceGroups` 每次都 `filter` 出新数组、外面又 `Object.assign`
+			 * 出新对象 —— **同一个源快照也每次返回新对象** ⇒ 每一帧都"变了" ⇒ 死循环。
+			 *
+			 * 所以按「源快照身份 + 影响筛选结果的外部开关」缓存上一次的投影结果。
+			 */
+			const wrapStore = function (store, project, volatileToken) {
+				let cachedSource;
+				let cachedToken;
+				let cachedProjected;
+				return {
+					getSnapshot: function () {
+						const source = store.getSnapshot();
+						const token = volatileToken === undefined ? '' : volatileToken();
+						// 源快照换了、或开关变了才重算；否则复用同一个对象（身份稳定）。
+						if (source === cachedSource && token === cachedToken) return cachedProjected;
+						cachedSource = source;
+						cachedToken = token;
+						cachedProjected = project(source);
+						return cachedProjected;
+					},
+					subscribe: function (fn) { return store.subscribe(fn); },
+					update: function (mutator) { return store.update(mutator); },
+					set: function (value) { return store.set(value); },
+				};
+			};
+
+			const store = directory.store;
+			wrapper.store = wrapStore(store, function (snapshot) {
+				// ⚠️ `directory.store` 那一层没有 `localGroups`（官方 `syncInputs`
+				// 只拷了 groups/failures），所以从 catalog 的原值里现取一份递进去。
+				const picked = pickWorkspaceGroups(snapshot, isRemote(), localGroupsOf(directory));
+				if (picked.groups.length === 0) return snapshot;
+				const next = Object.assign({}, snapshot, picked);
+				// `current` 指向被筛掉的模型时置空 —— 官方界面会显示「选择模型」，
+				// 比显示一个列表里根本没有的名字好。
+				if (!isSelectable(picked.groups, snapshot.current)) next.current = null;
+				return next;
+			// ⚠️ 缓存键必须带上「这个会话算不算远程」：同一个源快照在「切成远程会话」
+			// 前后要投影出**不同**结果，只看源快照身份会永远返回旧的那一份。
+			}, function () { return isRemote() === true ? 'remote:1' : 'remote:0'; });
+
+			// `load()` 返回的就是快照，`/model` 命令直接拿它渲染，所以也要筛。
+			wrapper.load = function () {
+				return Promise.resolve(directory.load()).then(function () {
+					return wrapper.store.getSnapshot();
+				});
+			};
+
+			const catalog = directory.catalog;
+			if (catalog && catalog.store && typeof catalog.store.getSnapshot === 'function') {
+				const catalogStore = catalog.store;
+				const catalogWrapper = Object.create(Object.getPrototypeOf(catalog));
+				Object.assign(catalogWrapper, catalog);
+				catalogWrapper.store = wrapStore(catalogStore, function (snapshot) {
+					return Object.assign({}, snapshot, {
+						value: filterCatalogValue(snapshot.value, isRemote()),
+					});
+				}, function () { return isRemote() === true ? 'remote:1' : 'remote:0'; });
+				wrapper.catalog = catalogWrapper;
+			}
+			return wrapper;
+		}
+
+		/**
+		 * 把「按工作区筛模型目录」接到官方服务上。
+		 *
+		 * `ctx.get` 拿不到服务就静默跳过（最坏是回到「两个工作区看到同一份列表」的
+		 * 旧行为，不会报错）。返回一个撤销函数。
+		 *
+		 * @param ctx - client 根上下文。
+		 * @param cwdOf - `sessionId → cwd` 的**同步**读取函数（隔离判据要用它）。
+		 * @returns 撤销函数。
+		 */
+		function patchModelDirectories(ctx, cwdOf) {
+			var models = ctx.get === undefined ? undefined : ctx.get('modelDirectories');
+			if (!models || typeof models.directoryFor !== 'function') return function () {};
+
+			// ⚠️⚠️ **必须在「原始实例」上覆盖，不能在 `ctx.get()` 拿到的那个对象上覆盖。**
+			//
+			// `modelDirectories` 是 cordis 的 Service，`ctx.get()` 返回的是
+			// `createTraceable()` 造出来的 **Proxy**（见 cordis `lib/index.js` 的
+			// `getTraceable`/`createTraceable`）。那个 Proxy 的 `get` 会把方法包成
+			// `createShadowMethod(ctx, fn, receiver, shadow)`，其 apply 里有一句：
+			//
+			//     if (thisArg === outer) thisArg = shadow;
+			//
+			// `outer` 就是取方法时的那个 receiver，而 `shadow` 是
+			// `withProp(receiver, property, ctx.extend({[shadow]: origin}))` ——
+			// 这个 `ctx` 是**谁调 `ctx.get()` 就用谁的上下文**。
+			//
+			// 于是 `models.directoryFor.bind(models)` 把 this 钉在了 Proxy 上，
+			// 每次调用都命中 `thisArg === outer` ⇒ this 被换成**我的插件上下文**
+			// 扩展出来的 shadow。而官方 `ModelDirectoryResolver.directoryFor` 内部要读
+			// `this.ctx.remote.session`（`dsh-client-ui-model-selection/lib/client.js:388`），
+			// 我的插件没有 inject 过 `remote.session` ⇒ 抛
+			//
+			//     cannot get property "remote.session" without inject
+			//
+			// 真机症状：`conversation.input.model` 这个 slot 整体 crash，
+			// **输入框上的模型按钮直接消失**。1.0.19 首次真机启动实测到的。
+			//
+			// 正解是用 `Symbol.for('cordis.original')` 取出 Proxy 背后的原始实例
+			// （`createTraceable` 的 get trap 里第一条就是 `if (prop === symbols.original) return target`），
+			// 在**它**身上覆盖。这样 `this.ctx` 始终是 `ModelDirectoryResolver`
+			// 构造时 `super(ctx, …)` 存下的那个 ctx，服务解析照旧。
+			var ORIGINAL = Symbol.for('cordis.original');
+			var raw = models[ORIGINAL] === undefined ? models : models[ORIGINAL];
+			if (!raw || typeof raw.directoryFor !== 'function') return function () {};
+
+			var hadOwn = Object.prototype.hasOwnProperty.call(raw, 'directoryFor');
+			var previous = raw.directoryFor;
+			var call = previous.bind(raw);
+			raw.directoryFor = function (sessionId) {
+				var directory = call(sessionId);
+				if (directory.__dshRemoteScoped !== undefined) return directory.__dshRemoteScoped;
+				var scoped = scopeDirectoryToWorkspace(directory, sessionId, cwdOf);
+				try {
+					directory.__dshRemoteScoped = scoped;
+				} catch (error) {
+					/* 冻结就退回「每次新建」，功能不受影响 */
+				}
+				return scoped;
+			};
+			return function () {
+				if (hadOwn) raw.directoryFor = previous;
+				else delete raw.directoryFor;
+			};
+		}
+
+		/**
+		 * 造一个 `sessionId → cwd` 的**同步**读取函数。
+		 *
+		 * 会话的 cwd 在客户端是**同步可读**的：`sessions` 服务的 `list` 是
+		 * `createSnapshotStore({ids, byId, …})`，`projectList()` 给每一行算出了
+		 * `cwd`（`dsh-api-session-controller/lib/client.js` 的 `byId[id] = {id,
+		 * displayTitle, running, …, cwd?, …}`）。
+		 *
+		 * ⚠️ 之所以要「同步」：模型菜单每渲染一帧都会读一次目录快照
+		 * （`getSnapshot`），那里**不能**是异步的。
+		 *
+		 * 全用显式 `if` 判空 —— chrome73 语法约束，不能用 `?.`。
+		 *
+		 * @param ctx - client 根上下文。
+		 * @returns 读取函数；读不到时返回 `undefined`。
+		 */
+		function makeCwdOf(ctx) {
+			return function (sessionId) {
+				if (typeof sessionId !== 'string' || sessionId === '') return undefined;
+				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 (row === undefined || row === null) return undefined;
+				var cwd = row.cwd;
+				return typeof cwd === 'string' && cwd !== '' ? cwd : undefined;
+			};
+		}
+
 		/**
 		 * 调宿主桥的一条 RPC（令牌只在引擎进程里，浏览器侧不持有）。
 		 *
@@ -359,6 +831,12 @@ window.__ModuleLoader__.load({
 			var registerLocal = props.registerLocal;
 			/** 兜底：拉一次全量会话列表（登记失败时用）。 */
 			var refreshSessions = props.refreshSessions;
+			/** 把会话标记成「电脑的」（cwd 还没进列表行时兜底，见 `isRemoteSession`）。 */
+			var markRemote = props.markRemote;
+			/** 重拉一次镜像工作区 slug 集合（新建镜像工作区之后必须调）。 */
+			var refreshMirrorSlugs = props.refreshMirrorSlugs;
+			/** 解绑后把所有会话退回「本地」。 */
+			var clearRemote = props.clearRemote;
 
 			var statePair = react.useState({
 				tab: 'local',
@@ -575,6 +1053,10 @@ window.__ModuleLoader__.load({
 						// 不作废的话用户接下来看到的仍然是配对前那份手机模型列表 ——
 						// 就是用户报的「模型列表还是没同步」。
 						reloadModelCatalog();
+						// ⚠️ **镜像工作区 slug 集合也要重拉**：换一台电脑后 `workspaceMap`
+						// 是另一份（slug 由电脑路径哈希得来，同名不同机 slug 不同）。
+						// 不重拉的话，新电脑的镜像工作区会被判成「本地」—— 又是那个 bug。
+						if (refreshMirrorSlugs !== undefined) refreshMirrorSlugs();
 					},
 					function (reason) {
 						if (!aliveRef.current) return;
@@ -608,6 +1090,11 @@ window.__ModuleLoader__.load({
 						});
 						// 解绑后旧凭据作废，缓存里的目录不该再露出来。
 						clearDesktopDirCache();
+						// ⚠️ **同时清掉「电脑会话」标记**：解绑后电脑已经不在了，
+						// 那些会话退回普通本地会话（宿主 `unpair` 也清了
+						// `remoteSessions`）。留着标记的话，模型菜单会一直显示
+						// 电脑的模型，而消息其实发给了手机本地。
+						if (clearRemote !== undefined) clearRemote();
 						patch({ path: null, listing: null });
 					},
 					function (reason) {
@@ -872,6 +1359,13 @@ window.__ModuleLoader__.load({
 			 */
 			var settleLocal = function (result) {
 				if (!result || typeof result.sessionId !== 'string') return Promise.resolve();
+				// ⚠️ **先标记「这是电脑的」再登记**：列表行的 `cwd` 要等宿主那一行
+				// 回来才带上，之前那几帧判据读不到 cwd，靠这个标记兜住。
+				if (markRemote !== undefined) markRemote(result.sessionId);
+				// ⚠️ **重拉镜像工作区 slug 集合**：宿主刚为这个电脑目录建好（或复用）
+				// 镜像工作区，`workspaceMap` 可能**刚多出一条**。前端那份集合是快照，
+				// 不重拉的话这个工作区在侧边栏里点进去仍被判成「本地」。
+				if (refreshMirrorSlugs !== undefined) refreshMirrorSlugs();
 				var local = registerLocal === undefined
 					? Promise.resolve()
 					: Promise.resolve(registerLocal(result.sessionId, result.cwd)).then(null, function () {
@@ -1303,8 +1797,44 @@ window.__ModuleLoader__.load({
 				 * `ctx.get` 拿不到就返回 `undefined`，组件里会跳过这一步。
 				 */
 				modelDirectories: ctx.get === undefined ? undefined : ctx.get('modelDirectories'),
+				/**
+				 * 把一个会话标记成「跑在电脑上」。
+				 *
+				 * 建完远程会话**当场**登记，用户不必等下一次全量拉取就能看到
+				 * 正确的模型列表（见 `remoteSessionIds` 的注释）。
+				 *
+				 * @param sessionId - 会话 id。
+				 */
+				markRemote: (sessionId) => {
+					if (typeof sessionId === 'string' && sessionId !== '') remoteSessionIds[sessionId] = true;
+				},
+				/**
+				 * 重拉一次「电脑镜像工作区 slug 集合」。
+				 *
+				 * ⚠️ **必须在「刚给某个电脑目录建好工作区」之后调**：宿主
+				 * `ensureDesktopWorkspace()` 每碰到一个新的电脑目录就往 `workspaceMap`
+				 * 里加一条 slug，而前端这份集合是**快照**。不重拉的话，新加的镜像工作区
+				 * 在侧边栏里点进去仍会被判成「本地」—— 正是用户报的那个 bug。
+				 */
+				refreshMirrorSlugs: () => loadMirrorSlugs(),
+				/** 解绑后把所有会话退回「本地」（电脑已经不在了）。 */
+				clearRemote: () => {
+					remoteSessionIds = {};
+					mirrorSlugs = {};
+				},
 			});
 
+			// 拉一次全量远程会话清单（重启 App 后已有会话也要能正确识别）。
+			loadRemoteSessionIds();
+			// 拉一次镜像工作区 slug 集合（隔离的**真正判据**，见 `mirrorSlugs`）。
+			loadMirrorSlugs();
+
+			// 把「按工作区筛模型目录」接到官方服务上。
+			ctx.effect(
+				() => patchModelDirectories(ctx, makeCwdOf(ctx)),
+				'dsh-remote-mobile: workspace-scoped model catalog',
+			);
+
 			// 负 priority：single slot 取 entries[0]，entries 按 priority 升序 ⇒ 最先渲染。
 			const register = (name) =>
 				ctx.slots.register(

package/lib/index.js

@@ -687,16 +687,100 @@ export function apply(ctx) {
 	 *
 	 * 配对后立刻拉一次，之后前端一打开模型菜单就有内容，不用等一轮往返。
 	 *
-	 * ⚠️ **`directory` 只缓存「根」那一层**（`listDirectory` 不给 path 时返回的
+	 * ⚠️ **`directory` 缓存「根」那一层**（`listDirectory` 不给 path 时返回的
 	 * home），因为「点开电脑页签」是每次都逃不掉的第一步，而它现在必然要过一轮
 	 * 隧道往返 —— 用户看到的就是那个转圈（原话：「还是有一个加载过程，
 	 * 不能预加载吗」）。
 	 *
+	 * ⚠️ **`dirs` 是「用户正在看的那一层」的下一层**（`电脑路径 → listing`）。
+	 * 只缓存根层还不够：用户报障原文「你现在好像只缓存了顶级目录，打开某个
+	 * 文件夹还是要加载」—— 点进任何一个子目录仍要过一次隧道往返（实测
+	 * 700～1200ms）。而用户看到列表到点击之间的那一两秒，完全够把这一层的
+	 * 子目录拉回来（见 `prefetchDirs`）。
+	 *
 	 * **整棵目录树不进缓存**：电脑上几万个目录，全拉一遍既慢又没意义，而且
-	 * 会大面积显示过期内容。点进子目录仍然实时拉（前端另有 `desktopDirCache`
-	 * 兜住「同一层来回点」）。根目录的过期窗口由「刷新」按钮关闭。
+	 * 会大面积显示过期内容。所以 `dirs` 只装「用户实际看过的那几层的下一层」，
+	 * 上限见 `DESKTOP_DIRS_MAX`。过期窗口由「刷新」按钮关闭。
+	 */
+	const desktopCache = { catalog: null, presets: null, directory: null, dirs: {}, at: 0 };
+
+	/** `desktopCache.dirs` 的容量上限（按插入顺序淘汰最旧的那些）。 */
+	const DESKTOP_DIRS_MAX = 200;
+
+	/**
+	 * 把用户**正在看的这一层**的子目录拉回手机本地。
+	 *
+	 * ## 为什么要有这个（用户报障原文）
+	 *
+	 * 「你现在好像只缓存了顶级目录，打开某个文件夹还是要加载」—— 根层命中缓存后
+	 * 不再打隧道了，可点进任何一层子目录仍然要过一趟 Cloudflare，实测
+	 * 700～1200ms，用户看到的就是那个转圈。
+	 *
+	 * 而**用户看列表、再决定点哪个文件夹，中间至少有一两秒**。这段时间完全够
+	 * 把这一层的子目录并发拉回来 —— 用户点下去时就已经在本地了。
+	 *
+	 * ## 只预取「一层」而不是整棵树
+	 *
+	 * 电脑上一个项目根目录动辄几十上百个子目录，整棵树递归下去是几千次往返，
+	 * 既慢又会大面积显示过期内容。**只拉下一层**：用户真正会点的就是这一层里
+	 * 的那几个，而下下一层等他进了这一层再预取（`listDesktop` 每次都会触发）。
+	 *
+	 * ## 并发上限
+	 *
+	 * 隧道是单个 Cloudflare 连接，一次打几十个并发没有意义还会互相挤。所以
+	 * 分批（每批 `DESKTOP_PREFETCH_BATCH` 个）顺序推，**不 await**：这是后台
+	 * 动作，调用方（`listDesktop`）要立刻把当前层回给前端。
+	 *
+	 * @param listing - 用户当前看到的那一层（`listDirectory` 的产物）。
 	 */
-	const desktopCache = { catalog: null, presets: null, directory: null, at: 0 };
+	const prefetchDirs = (listing) => {
+		if (config.token === EMPTY_TOKEN) return;
+		const dirs = listing?.entries?.filter?.((entry) => entry?.isDirectory === true) ?? [];
+		if (dirs.length === 0) return;
+		// ⚠️ **已经缓存过的不再拉**：来回翻页时不能把同一批目录重复请求一遍。
+		const todo = dirs
+			.map((entry) => entry.path)
+			.filter((path) => typeof path === 'string' && path !== '' && desktopCache.dirs[path] === undefined);
+		if (todo.length === 0) return;
+		void (async () => {
+			for (let at = 0; at < todo.length; at += DESKTOP_PREFETCH_BATCH) {
+				const batch = todo.slice(at, at + DESKTOP_PREFETCH_BATCH);
+				await Promise.all(
+					batch.map(async (path) => {
+						// 期间用户可能已经点「刷新」清过缓存，那就别再写回去了。
+						if (desktopCache.dirs[path] !== undefined) return;
+						try {
+							const child = await callRemote(config, 'listDirectory', { path });
+							rememberDir(path, child);
+						} catch {
+							/* 单个目录拉不到（被删 / 无权限）不影响其它目录，静默跳过 */
+						}
+					}),
+				);
+			}
+		})();
+	};
+
+	/** 每批并发数（见 `prefetchDirs` 的注释）。 */
+	const DESKTOP_PREFETCH_BATCH = 6;
+
+	/**
+	 * 写一格目录缓存，超出上限就按插入顺序淘汰最旧的。
+	 *
+	 * ⚠️ 淘汰必须用 `Object.keys` 的**插入顺序**：JS 对象的字符串键就是这个顺序，
+	 * 而 `desktopCache.dirs` 正好是按用户浏览顺序写进去的 —— 最旧的键就是最早
+	 * 看过的那些层，淘汰它们对用户体感最没影响。
+	 *
+	 * @param path - 电脑上的绝对路径。
+	 * @param listing - 该层的列表结果。
+	 */
+	function rememberDir(path, listing) {
+		desktopCache.dirs[path] = listing;
+		const keys = Object.keys(desktopCache.dirs);
+		for (let at = 0; at + DESKTOP_DIRS_MAX < keys.length; at += 1) {
+			delete desktopCache.dirs[keys[at]];
+		}
+	}
 
 	/**
 	 * 静默预拉电脑的模型目录与预设列表。
@@ -770,21 +854,32 @@ export function apply(ctx) {
 	 * 官方前端的模型目录是**全局唯一一份**（`ModelCatalogDirectory` 由
 	 * `ModelDirectoryResolver` 持有，所有会话共享，见
 	 * `dsh-client-ui-model-selection/lib/client.js:340`），请求本身**不带 sessionId**。
-	 * 所以「远程会话看电脑的、本地会话看手机的」这种按会话切换，在官方结构里
-	 * **表达不出来** —— 硬要做得去改前端内部类，脆弱且升级即碎。
+	 * 所以「远程会话看电脑的、本地会话看手机的」这种按会话切换，在**这一层**
+	 * 表达不出来。
 	 *
-	 * 折中：**电脑的排前面**（用户要的就是「刷新为电脑的」，电脑模型一眼可见），
-	 * 手机自己那几组留在后面。这样远程会话能选到电脑的模型，本地会话也不会
-	 * 因为列表里只剩电脑模型而彻底没法用。
+	 * 折中：这里把两份**并起来**（电脑的排前面，同 id 的 provider 以电脑为准），
+	 * 由前端按「当前会话的工作区是不是电脑镜像目录」再筛一次
+	 * （见 client.js 的 `filterCatalogForWorkspace`）。合并时必须给电脑那几组
+	 * 打上 `desktop: true`，否则前端分不出哪些是电脑的 —— 用户需求原文：
+	 * 「用户如果当前选择的是 app 本地文件夹，那么就不要出现电脑的模型，
+	 * 以这个文件夹为隔离条件，互不干预」。
 	 *
-	 * 同 id 的 provider 以**电脑的为准**（电脑上那份才是干活用的）。
+	 * ⚠️ **`localGroups` / `localFailures` 必须一起带上**。因为同 id 的 provider
+	 * 以电脑为准 ⇒ 本地那一组被**丢掉**了；而本地会话的 `current` 很可能正指向
+	 * 它（手机本地的 `deepseek-official` 与电脑的同名）。前端要「本地工作区只显示
+	 * 本地模型」，就得能把被覆盖的那组**还原**回来 —— 只靠 `groups` 做不到，
+	 * 那组已经不在里面了。这两个字段是**本插件加的**，官方 `syncInputs` 只读
+	 * `groups` / `failures` / `default`，多带两个不会影响渲染。
+	 *
+	 * ⚠️ `desktop` 同理是**我们加的非官方字段**。前端渲染只读 `id` / `name` /
+	 * `models`（见 `optionsOf`），多一个字段无害。
 	 *
 	 * @param local - 手机本地的模型目录。
 	 * @param desktop - 电脑的模型目录（`buildModelCatalog` 的产物）。
-	 * @returns 合并后的目录。
+	 * @returns 合并后的目录（额外带 `localGroups` / `localFailures`）。
 	 */
 	function mergeCatalog(local, desktop) {
-		const groups = [...(desktop?.groups ?? [])];
+		const groups = (desktop?.groups ?? []).map((group) => ({ ...group, desktop: true }));
 		const seen = new Set(groups.map((group) => group.id));
 		for (const group of local?.groups ?? []) {
 			if (!seen.has(group.id)) groups.push(group);
@@ -792,7 +887,14 @@ export function apply(ctx) {
 		return {
 			...local,
 			groups,
-			failures: [...(desktop?.failures ?? []), ...(local?.failures ?? [])],
+			// failures 同样打标记：本地工作区里不该看到电脑 provider 的加载失败。
+			failures: [
+				...(desktop?.failures ?? []).map((failure) => ({ ...failure, desktop: true })),
+				...(local?.failures ?? []),
+			],
+			// ⚠️ 前端「本地工作区只显示本地模型」的还原依据（见上面注释）。
+			localGroups: local?.groups ?? [],
+			localFailures: local?.failures ?? [],
 			routableProviders: [
 				...new Set([...(local?.routableProviders ?? []), ...(desktop?.routableProviders ?? [])]),
 			],
@@ -1429,6 +1531,10 @@ export function apply(ctx) {
 								// 模型/预设的静默缓存：配对后预拉、刷新按钮回写（见 desktopCache）。
 								desktopCache,
 								prefetch: prefetchDesktop,
+								// ⚠️ 同 `workspaceMap`：`handleBridge` 是模块级函数，闭包里的
+								// `prefetchDirs` / `rememberDir` 它看不见，必须显式传。
+								prefetchDirs,
+								rememberDir,
 								body,
 							});
 							reply(200, { ok: true, result });
@@ -1614,19 +1720,34 @@ async function handleBridge(ctx, config, io) {
 		/**
 		 * 列电脑上的目录。
 		 *
-		 * ⚠️ **根那层命中预拉缓存就直接回，不打隧道**：用户点开「电脑」页签时
-		 * 看的正是这一层，而它每一轮往返都要穿过 Cloudflare 隧道 ——
-		 * 那就是用户抱怨的那个「还是有一个加载过程」（原话：「目录树都提前存档
-		 * 手机本地了，为什么还是还加载呢，不能预加载吗」）。
+		 * ⚠️ **命中缓存就直接回，不打隧道**。两级缓存：
+		 *
+		 * ① 根层（`desktopCache.directory`）—— 用户点开「电脑」页签时看的正是
+		 *    这一层，每一轮往返都要穿过 Cloudflare 隧道，那就是用户抱怨的
+		 *    「还是有一个加载过程」（原话：「目录树都提前存档手机本地了，
+		 *    为什么还是还加载呢，不能预加载吗」）。
+		 * ② 子层（`desktopCache.dirs`）—— 用户报障原文「你现在好像只缓存了
+		 *    顶级目录，打开某个文件夹还是要加载」。
 		 *
-		 * 只在**没给 path**（= 要 home）且预拉成功过时才走缓存。子目录照旧实时拉，
-		 * 前端 `desktopDirCache` 负责「同一层来回点」，两边分工见各自的注释。
+		 * 两级都只在**拉成功之后**写回，并且**每次返回前都顺手预取「下一层」**
+		 * （见 `prefetchDirs`）：用户看列表、决定点哪个，这一两秒足够把下一层
+		 * 拉回来，点下去时就已经在本地了。
 		 */
 		case 'listDesktop': {
 			const wantRoot = params.path === undefined || params.path === null || params.path === '';
-			if (wantRoot && io.desktopCache?.directory != null) return io.desktopCache.directory;
+			const path = wantRoot ? '' : params.path;
+			const cached = wantRoot ? io.desktopCache?.directory : io.desktopCache?.dirs?.[path];
+			if (cached != null) {
+				// 命中也要预取下一层：用户还没离开这一屏。
+				io.prefetchDirs?.(cached);
+				return cached;
+			}
 			const listing = await callRemote(config, 'listDirectory', { path: params.path });
-			if (wantRoot && io.desktopCache !== undefined) io.desktopCache.directory = listing;
+			if (io.desktopCache !== undefined) {
+				if (wantRoot) io.desktopCache.directory = listing;
+				else if (typeof path === 'string' && path !== '') io.rememberDir?.(path, listing);
+			}
+			io.prefetchDirs?.(listing);
 			return listing;
 		}
 
@@ -1683,6 +1804,10 @@ async function handleBridge(ctx, config, io) {
 			if (io.desktopCache !== undefined) {
 				if (result.models?.ok === true) io.desktopCache.catalog = result.models.value;
 				if (result.presets?.ok === true) io.desktopCache.presets = result.presets.value;
+				// ⚠️ **刷新要把子层缓存整棵作废**：用户点刷新就是要看电脑现状，
+				// 留着旧的子层，点进去看到的还是刷新前的内容（根层作废了、
+				// 子层没作废，比两处都不作废更难解释）。
+				io.desktopCache.dirs = {};
 				if (
 					result.directory?.ok === true &&
 					io.desktopCache.directory?.path === result.directory.value?.path
@@ -1690,6 +1815,8 @@ async function handleBridge(ctx, config, io) {
 					io.desktopCache.directory = result.directory.value;
 				}
 				io.desktopCache.at = Date.now();
+				// 刷新完顺手把这一层的下一层预取回来，用户点进去就不用等了。
+				if (result.directory?.ok === true) io.prefetchDirs?.(result.directory.value);
 			}
 			return result;
 		}
@@ -1775,6 +1902,47 @@ async function handleBridge(ctx, config, io) {
 		case 'isRemote':
 			return { remote: io.remoteSessions.has(params.sessionId) };
 
+		/**
+		 * 全量远程会话清单（一次性给前端，前端拿它在**本地**做同步判定）。
+		 *
+		 * ⚠️ **为什么需要一个「全量」的桥**：前端要把模型菜单按「当前会话是不是
+		 * 电脑镜像工作区」隔离（用户需求原文：「用户如果当前选择的是 app 本地
+		 * 文件夹，那么就不要出现电脑的模型，以这个文件夹为隔离条件，互不干预」）。
+		 * 而模型菜单每渲染一帧都会读一次目录快照，**不可能每帧打一次桥** ——
+		 * 那是同步 API。所以前端在 `apply` 时拉一次全量，之后建会话/解绑时
+		 * 自己增量维护，`getSnapshot` 就纯查内存。
+		 *
+		 * 重启 App 后已有会话也能正确识别，正是靠这一条：宿主从
+		 * `sessions.json` 恢复出 `remoteSessions`，前端一次性拿走。
+		 */
+		case 'remoteSessions':
+			return { ids: [...io.remoteSessions] };
+
+		/**
+		 * 电脑镜像工作区的 slug 集合（`workspaceMap` 的 keys）。
+		 *
+		 * ⚠️⚠️ **这是「模型列表按工作区隔离」的第二代判据，用户 1.0.19 报障后的正解。**
+		 *
+		 * 上一代用 `remoteSessions`（按 **sessionId**）当判据，漏掉了这条真实路径：
+		 * 用户在侧边栏点「新建会话」时，官方前端直接
+		 * `sessionController.create({workspaceId})` —— **不经过本插件的桥**。
+		 * 宿主的 create 拦截器认得出镜像目录（所以消息发得对），但**前端不知道**，
+		 * 于是模型菜单仍按「本地」筛，显示手机模型。
+		 *
+		 * 用户原话：「只有我手动添加工作区的时候，才会触发模型和预设的刷新」——
+		 * 一针见血：判据挂在了「走了哪条路」上，而不是「会话的工作区在哪」。
+		 *
+		 * 正解是**按 cwd 判定**，与宿主 `desktopPathOfMirror` 同一个轴：
+		 * 前端从 `sessions.list` 的会话行里**同步**读到 cwd，看它是不是
+		 * `<STATE_DIR>/workspaces/<slug>` 且 `slug` 在这里面。这条路
+		 * **与「谁建的会话」完全无关**，所以任何入口进来都一致。
+		 *
+		 * 只回 slug 列表而不是整张 `workspaceMap`：前端不需要电脑路径，
+		 * 少传一份数据也少一处可能不一致的地方。
+		 */
+		case 'mirrorSlugs':
+			return { slugs: Object.keys(io.workspaceMap ?? {}) };
+
 		/**
 		 * 配对：用电脑上生成的 6 位码换回这台电脑的隧道地址与令牌。
 		 *
@@ -1835,6 +2003,14 @@ async function handleBridge(ctx, config, io) {
 			io.follows.clear();
 			io.mirrorStates.clear();
 			io.remoteSessions.clear();
+			// ⚠️ **子层目录缓存必须一起清**：`catalog` / `presets` / 根层目录在下次
+			// 配对成功时会被 `prefetchDesktop` **覆盖**，不会串味；而 `dirs` 是
+			// **累加**的（用户每浏览一层写一格），不清的话换一台电脑配对后，
+			// 旧电脑那些子目录还会命中缓存 —— 用户点进去看到的是上一台电脑的内容。
+			if (io.desktopCache !== undefined) {
+				io.desktopCache.dirs = {};
+				io.desktopCache.directory = null;
+			}
 			io.persist();
 			ctx.logger?.info?.('[dsh-remote-mobile] 已解除配对，本地凭据与远程会话清单已清空');
 			return { endpoint: config.endpoint, paired: false };

package/package.json

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