dsh-jiuling-remote-mobile 1.0.26 → 1.0.28

package/lib/client.js

@@ -862,14 +862,68 @@ window.__ModuleLoader__.load({
 			if (presets === undefined || presets === null) return function () {};
 			if (typeof presets.list !== 'function') return function () {};
 
+			// ⚠️⚠️ **必须在「原始实例」上覆盖 `list`，不能在 `ctx.remote.agentPresets`
+			// 拿到的那个对象上覆盖 —— 这是 1.0.25 / 1.0.26 / 1.0.27 三次真机都
+			// 「改了却完全没效果」的根因。**
+			//
+			// 与 `patchModelDirectories` 同一个陷阱（见那里的长注释）：cordis 的
+			// `ctx.remote` 是 `createTraceable()` 造出来的 **Proxy**，它的 `get` trap
+			// 会把方法包成 `createShadowMethod(...)`，并把对象属性也裹一层。
+			// 往 Proxy 上赋一个新属性，写进的是 Proxy 的 shadow 层，
+			// **官方 `readRoster` 读的是它自己那份 `ctx.remote.agentPresets.list`** ——
+			// 两者不是同一个函数位，所以我那次赋值官方永远看不到。
+			//
+			// 真机症状（用户三次反馈）：
+			//   1.0.25「模型列表能够快速切换回来了，但是预设列表没有切换」
+			//   1.0.26/1.0.27「不管是应用的私有默认工作区，还是我自己选择的
+			//   手机目录工作区，都无法自动切换回手机的预设列表」
+			// —— 注意「模型能切、预设不能切」，正是因为模型走
+			// `patchModelDirectories`（**正确解包了**），而预设没有。
+			//
+			// 正解：用 `Symbol.for('cordis.original')` 取出 Proxy 背后的原始实例
+			// （`createTraceable` 的 get trap 第一条就是 `if (prop === symbols.original) return target`），
+			// 在**它**身上覆盖。这样官方经 Proxy 读到的就是这个被包过的 `list`。
+			var ORIGINAL = Symbol.for('cordis.original');
+			var raw = presets[ORIGINAL] === undefined ? presets : presets[ORIGINAL];
+			if (!raw || typeof raw.list !== 'function') return function () {};
+
 			/**
-			 * 「当前主视图会话」的 id —— 与官方 `installWorkspaceShortcuts` 的
-			 * `current()` 同一条判据（`dsh-client-ui-workspace/lib/client.js:106`）：
-			 * `retainedBy.mainView > 0`。
+			 * 「当前主视图会话」的 id。
+			 *
+			 * ⚠️⚠️ **必须优先读 `uiWorkspace.selection`，不能只靠 `retainedBy`。**
+			 *
+			 * 1.0.25 第一版用的是「遍历 `sessions.byId`，找 `retainedBy.mainView > 0`
+			 * 的第一行」—— 那是官方 `installWorkspaceShortcuts` 里给快捷键用的
+			 * `current()`（`dsh-client-ui-workspace/lib/client.js:106`），它只保证
+			 * 「**有一个**会话被主视图持有」，**不保证唯一、也不保证是最新的那个**。
+			 * 电脑工作区与手机工作区各有一个被持有的会话时，遍历顺序先命中谁就是谁，
+			 * 于是用户切回手机目录后，判定仍然可能落在电脑那个会话上。
+			 *
+			 * 真机症状（用户截图）：切回手机工作区，预设列表仍是电脑那份，
+			 * 选中后报 `Unknown agent preset: pojia` —— 手机宿主不认识电脑的预设 id。
+			 *
+			 * 正解是官方自己的权威来源：`uiWorkspace.selection`
+			 * （`createSnapshotStore({})`，见其 L761；`replaceMain()` 在切换主视图时
+			 * 用 `this.selection.set({sessionId: reference.sessionId})` 写入，
+			 * 见其 L982-985）。它就是「现在主视图上打开的是哪个会话」。
+			 *
+			 * `retainedBy` 只作为拿不到 `selection` 时的退路。
 			 *
 			 * @returns 会话 id；找不到时 `undefined`。
 			 */
 			var currentSessionId = function () {
+				// ① 权威来源：`uiWorkspace.selection`。
+				var uiWorkspace = ctx.uiWorkspace;
+				if (uiWorkspace !== undefined && uiWorkspace !== null) {
+					var selection = uiWorkspace.selection;
+					if (selection !== undefined && selection !== null && typeof selection.getSnapshot === 'function') {
+						var chosen = selection.getSnapshot();
+						if (chosen && typeof chosen.sessionId === 'string' && chosen.sessionId !== '') {
+							return chosen.sessionId;
+						}
+					}
+				}
+				// ② 退路：`retainedBy.mainView`（官方快捷键用的那条，不唯一）。
 				var sessions = ctx.sessions;
 				if (sessions === undefined || sessions === null) return undefined;
 				var list = sessions.list;
@@ -887,27 +941,111 @@ window.__ModuleLoader__.load({
 				return undefined;
 			};
 
-			var hadOwn = Object.prototype.hasOwnProperty.call(presets, 'list');
-			var previous = presets.list;
-			var call = previous.bind(presets);
-			presets.list = function () {
-				return call.apply(null, arguments).then(function (result) {
-					// ⚠️ 失败回执原样透传：`readRoster` 靠 `result.ok` 判断，
-					// 也靠 `error.code === 'gateway/invocation-unavailable'` 兜底，
-					// 动它会让预设菜单变成错误态。
-					if (!result || result.ok !== true || !result.value) return result;
-					var sessionId = currentSessionId();
-					var isRemote = sessionId === undefined
-						? false
-						: isRemoteSession(sessionId, cwdOf);
-					var picked = pickWorkspacePresets(result.value, isRemote);
-					if (picked === result.value) return result;
-					return Object.assign({}, result, { value: picked });
-				});
+			/**
+			 * 当前主视图所在的**工作区路径** —— 「选工作区就是开关」的那把开关本身。
+			 *
+			 * 用户原话：「就是选工作区的时候就作为一个开关……检测到是手机的，你就给我
+			 * 换回手机那一套呗，检测到是电脑的就换回电脑那一套呗」。
+			 *
+			 * 所以判据应当落在**工作区**上，而不是绕着会话去猜。官方自己在
+			 * `dsh-client-ui-workspace/lib/client.js:932` 就是这么定位当前工作区的：
+			 *
+			 * ```js
+			 * const workspace = workspaces.items.find(
+			 *   (item) => item.sessionIds.includes(sessionId));
+			 * ```
+			 *
+			 * `item.path` 即该工作区的目录 —— 电脑镜像工作区的路径里带
+			 * `.../workspaces/<slug>/...`，`mirrorSlugOf()` 能认出 slug。
+			 *
+			 * @param sessionId - 当前主视图会话 id。
+			 * @returns 工作区路径；查不到时 `undefined`。
+			 */
+			var workspacePathOfCurrent = function (sessionId) {
+				if (typeof sessionId !== 'string' || sessionId === '') return undefined;
+				var workspaceService = ctx.workspaces;
+				if (workspaceService === undefined || workspaceService === null) return undefined;
+				var list = workspaceService.list;
+				if (list === undefined || list === null || typeof list.getSnapshot !== 'function') return undefined;
+				var snapshot = list.getSnapshot();
+				if (snapshot === undefined || snapshot === null) return undefined;
+				var items = snapshot.items;
+				if (!Array.isArray(items)) return undefined;
+				for (var at = 0; at < items.length; at += 1) {
+					var item = items[at];
+					if (!item || !Array.isArray(item.sessionIds)) continue;
+					if (item.sessionIds.indexOf(sessionId) === -1) continue;
+					if (typeof item.path === 'string' && item.path !== '') return item.path;
+					return undefined;
+				}
+				return undefined;
+			};
+
+			/**
+			 * 这一屏该用电脑的预设还是手机的预设 —— **一个布尔开关**。
+			 *
+			 * 判据顺序（前面的赢）：
+			 *
+			 * 1. **当前工作区的路径**是不是电脑镜像目录 —— 用户要的那个开关；
+			 * 2. 当前会话自己的 `cwd` —— 与模型菜单完全同一条（`isRemoteSession`）；
+			 * 3. 都没有 ⇒ 当成手机（本地）。
+			 *
+			 * ⚠️ 第 1 条必须放最前：切工作区时 `selection` 与列表行可能晚一两帧才一致，
+			 * 而工作区行是**已经切过去**的那一个，它最能代表用户此刻的选择。
+			 *
+			 * @returns 是不是电脑工作区。
+			 */
+			var currentIsRemote = function () {
+				var sessionId = currentSessionId();
+				var path = workspacePathOfCurrent(sessionId);
+				if (typeof path === 'string' && path !== '') {
+					var slug = mirrorSlugOf(path);
+					if (slug !== undefined && mirrorSlugs[slug] === true) return true;
+					// 路径读到了、且不是镜像目录 ⇒ 就是手机本地工作区，直接定论。
+					return false;
+				}
+				if (sessionId === undefined) return false;
+				return isRemoteSession(sessionId, cwdOf);
+			};
+
+			/**
+			 * 覆盖一个对象上的 `list`，返回撤销函数。
+			 *
+			 * 抽出来是为了**同时覆盖 Proxy 与原始实例两个位置**：只要有一处没覆盖到，
+			 * 官方读到旧函数，整个筛选就是静默失效（1.0.25→1.0.27 三次都是这个形态）。
+			 * 两处都覆盖，无论官方经哪条路径读都命中。
+			 *
+			 * @param host - 要覆盖的对象（Proxy 或原始实例）。
+			 * @returns 撤销函数。
+			 */
+			var overrideList = function (host) {
+				if (!host || typeof host.list !== 'function') return function () {};
+				var hadOwn = Object.prototype.hasOwnProperty.call(host, 'list');
+				var previous = host.list;
+				var call = previous.bind(host);
+				host.list = function () {
+					return call.apply(null, arguments).then(function (result) {
+						// ⚠️ 失败回执原样透传：`readRoster` 靠 `result.ok` 判断，
+						// 也靠 `error.code === 'gateway/invocation-unavailable'` 兜底，
+						// 动它会让预设菜单变成错误态。
+						if (!result || result.ok !== true || !result.value) return result;
+						var picked = pickWorkspacePresets(result.value, currentIsRemote());
+						if (picked === result.value) return result;
+						return Object.assign({}, result, { value: picked });
+					});
+				};
+				return function () {
+					if (hadOwn) host.list = previous;
+					else delete host.list;
+				};
 			};
+
+			// 两处都覆盖：Proxy（`presets`）与原始实例（`raw`）。
+			var undoProxy = overrideList(presets);
+			var undoRaw = raw === presets ? function () {} : overrideList(raw);
 			return function () {
-				if (hadOwn) presets.list = previous;
-				else delete presets.list;
+				undoRaw();
+				undoProxy();
 			};
 		}
 

package/lib/index.js

@@ -48,7 +48,7 @@
  */
 
 import { createHash, randomUUID } from 'node:crypto';
-import { mkdirSync, readFileSync, renameSync, writeFileSync } from 'node:fs';
+import { existsSync, mkdirSync, readFileSync, renameSync, writeFileSync } from 'node:fs';
 import { request as httpRequest } from 'node:http';
 import { request as httpsRequest } from 'node:https';
 import { homedir } from 'node:os';
@@ -72,6 +72,80 @@ const CONFIG_PATH = join(STATE_DIR, 'mobile.json');
 /** 远程会话清单（持久化，重开 App 后能接着搬）。 */
 const SESSIONS_PATH = join(STATE_DIR, 'sessions.json');
 
+/**
+ * 电脑配置的本地快照 —— 模型目录、预设名单、根目录列表。
+ *
+ * ## 为什么要落盘（用户明确要求，2026-10-17）
+ *
+ * 用户原话：「我不想要你每次都往电脑上面拉取数据……用户匹配成功之后，他就加载
+ * 一次文件目录，还有预设以及模型列表就可以了，后续你就不用再拉取了。……电脑的
+ * 配置很少会有改变的，有改变的话，用户他自己在那个工作区那里点一下刷新来重新
+ * 拉取就行了。平时呢你就把上一次拉到的结果，直接给我存死在本地，后续就从本地
+ * 读取就行了，这样速度快体验优。」
+ *
+ * 对应两个真机症状：
+ *
+ * 1. **切模型转圈**：`modelCatalog` / `presetList` 这两个 RPC 原来是**每次都联网**
+ *    （见 `case 'modelCatalog'`），前端每展开一次模型菜单或切一个模型，就要等一趟
+ *    公网往返。本地已有数据时这完全是白等。
+ * 2. **电脑下线后预设还是旧的**：`desktopCache` 只在**成功**时写入、从不因失败清空，
+ *    所以电脑隧道断了以后，内存里那份旧预设仍被 `mergePresets` 并进去，
+ *    用户切回手机工作区也看到电脑的预设（`pojia`），选中就报
+ *    `Unknown agent preset: pojia`。
+ *
+ * 落盘之后，读路径**完全不碰网络**：有本地快照就直接给，没有才拉一次。
+ * 重新拉取只由两条路触发 —— 配对成功、以及用户自己点「刷新」。
+ */
+const DESKTOP_CACHE_PATH = join(STATE_DIR, 'desktop-cache.json');
+
+/**
+ * 读本地快照。
+ *
+ * ⚠️ 任何异常都只返回 `null`，绝不让它挡住插件启动 —— 这个文件是**加速用的**，
+ * 坏了最多退回「联网拉一次」，不该让整个远程功能起不来。
+ *
+ * @returns `{catalog, presets, directory, at}` 或 `null`。
+ */
+function loadDesktopCache() {
+	try {
+		if (!existsSync(DESKTOP_CACHE_PATH)) return null;
+		const raw = readFileSync(DESKTOP_CACHE_PATH, 'utf8');
+		if (typeof raw !== 'string' || raw === '') return null;
+		const parsed = JSON.parse(raw);
+		if (parsed === null || typeof parsed !== 'object') return null;
+		return {
+			catalog: parsed.catalog ?? null,
+			presets: parsed.presets ?? null,
+			directory: parsed.directory ?? null,
+			at: typeof parsed.at === 'number' ? parsed.at : 0,
+		};
+	} catch (error) {
+		return null;
+	}
+}
+
+/**
+ * 写本地快照（临时文件 + rename，与 `saveConfig` 同一个理由）。
+ *
+ * @param cache - `{catalog, presets, directory, at}`。
+ */
+function saveDesktopCache(cache) {
+	try {
+		mkdirSync(STATE_DIR, { recursive: true });
+		const record = {
+			catalog: cache.catalog ?? null,
+			presets: cache.presets ?? null,
+			directory: cache.directory ?? null,
+			at: cache.at ?? Date.now(),
+		};
+		const tmp = `${DESKTOP_CACHE_PATH}.${process.pid}.tmp`;
+		writeFileSync(tmp, JSON.stringify(record), { mode: 0o600 });
+		renameSync(tmp, DESKTOP_CACHE_PATH);
+	} catch (error) {
+		/* 写盘失败不影响本次会话的使用，下次成功时会再写 */
+	}
+}
+
 /** 默认隧道地址。 */
 const DEFAULT_ENDPOINT = 'https://dsh-remote.jiulingssh.xyz';
 
@@ -1003,9 +1077,33 @@ export function apply(ctx) {
 	 * **整棵目录树不进缓存**：电脑上几万个目录，全拉一遍既慢又没意义，而且
 	 * 会大面积显示过期内容。所以 `dirs` 只装「用户实际看过的那几层的下一层」，
 	 * 上限见 `DESKTOP_DIRS_MAX`。过期窗口由「刷新」按钮关闭。
+	 *
+	 * ⚠️ **`catalog` / `presets` / `directory` 三项同时落盘**（见
+	 * `DESKTOP_CACHE_PATH`）：重开 App、甚至电脑隧道断了，这三样也从本地读，
+	 * 读路径**完全不碰网络**。`dirs` **不落盘** —— 它是按层预取的临时加速，
+	 * 数量会膨胀到几百条，存下来既无必要也让文件变大。
 	 */
 	const desktopCache = { catalog: null, presets: null, directory: null, dirs: emptyDirCache(), at: 0 };
 
+	// 启动即从磁盘恢复上次拉到的电脑配置 —— 这是「配对后只拉一次」的落地点。
+	const restoredCache = loadDesktopCache();
+	if (restoredCache !== null) {
+		desktopCache.catalog = restoredCache.catalog;
+		desktopCache.presets = restoredCache.presets;
+		desktopCache.directory = restoredCache.directory;
+		desktopCache.at = restoredCache.at;
+	}
+
+	/** 把当前内存里的三项落盘（`dirs` 不存，见 `desktopCache` 的注释）。 */
+	const persistDesktopCache = () => {
+		saveDesktopCache({
+			catalog: desktopCache.catalog,
+			presets: desktopCache.presets,
+			directory: desktopCache.directory,
+			at: desktopCache.at,
+		});
+	};
+
 	/** `desktopCache.dirs` 的容量上限（按插入顺序淘汰最旧的那些）。 */
 	const DESKTOP_DIRS_MAX = 200;
 
@@ -1119,6 +1217,9 @@ export function apply(ctx) {
 		if (presets !== null) desktopCache.presets = presets;
 		if (directory !== null) desktopCache.directory = directory;
 		desktopCache.at = Date.now();
+		// ⚠️ 只有**真的拉到东西**才落盘。全失败时保留上次的本地快照，
+		// 而不是把缓存写成空 —— 用户要的是「上次拉到的结果存死在本地」。
+		if (catalog !== null || presets !== null || directory !== null) persistDesktopCache();
 		const models = catalog?.groups?.reduce((n, g) => n + (g.models?.length ?? 0), 0) ?? 0;
 		const dirs = directory?.entries?.length ?? directory?.items?.length ?? 0;
 		ctx.logger?.info?.(
@@ -1142,6 +1243,9 @@ export function apply(ctx) {
 		if (desktopCache.catalog !== null) return desktopCache.catalog;
 		try {
 			desktopCache.catalog = await callRemote(config, 'modelCatalog', {});
+			// 第一次拉到就落盘：此后重开 App / 电脑下线都从本地读，不再联网。
+			desktopCache.at = Date.now();
+			persistDesktopCache();
 			return desktopCache.catalog;
 		} catch (error) {
 			ctx.logger?.warn?.(
@@ -1918,6 +2022,9 @@ export function apply(ctx) {
 							persist: () => saveRemoteSessions(remoteSessions, ctx.logger),
 							// 模型/预设的静默缓存：配对后预拉、刷新按钮回写（见 desktopCache）。
 							desktopCache,
+							// ⚠️ 也要显式传：`refreshAll` 是模块级 `handleBridge` 里的
+							// case 分支，同样看不见 `apply()` 的闭包变量。
+							persistDesktopCache,
 							prefetch: prefetchDesktop,
 							// ⚠️ 同 `workspaceMap`：`handleBridge` 是模块级函数，闭包里的
 							// `prefetchDirs` / `rememberDir` 它看不见，必须显式传。
@@ -2154,18 +2261,51 @@ async function handleBridge(ctx, config, io) {
 		}
 
 		/**
-		 * 电脑上的模型目录。
+		 * 电脑上的模型目录 —— **只读本地缓存，不联网**。
 		 *
 		 * 用户要的是「选了电脑目录之后，输入框右下方的模型列表就刷新为电脑的」。
 		 * 手机本地那份模型列表来自手机自己的 LLM 配置，跟电脑上能跑什么没关系，
 		 * 拿它去发消息会选到一个电脑上不存在的模型。
+		 *
+		 * ⚠️⚠️ **这里从前是 `return callRemote(config, 'modelCatalog', {})`，
+		 * 每次前端读一次就过一趟公网隧道。** 用户原话：「我选择了电脑工作区之后，
+		 * 虽然说模型列表已经显示的是电脑的了，但是我如果展开列表，然后切换一个
+		 * 模型的话，此时会转圈圈的。如果是本地读取的话，完全没必要转圈圈」。
+		 *
+		 * 现在改为：**有缓存直接给，没有才拉一次并落盘**。电脑的模型配置极少变，
+		 * 要更新由用户自己点「刷新」（走 `refreshAll`，那条路仍然联网）。
 		 */
-		case 'modelCatalog':
-			return callRemote(config, 'modelCatalog', {});
+		case 'modelCatalog': {
+			if (desktopCache.catalog !== null) return desktopCache.catalog;
+			const fetched = await desktopCatalog();
+			if (fetched !== null) persistDesktopCache();
+			return fetched;
+		}
 
-		/** 电脑上的预设列表。 */
-		case 'presetList':
-			return callRemote(config, 'presetList', {});
+		/**
+		 * 电脑上的预设列表 —— **只读本地缓存，不联网**（理由同 `modelCatalog`）。
+		 *
+		 * 没有缓存的第一次仍会拉一次，之后一直用本地的。电脑下线后也不会再
+		 * 反复打失败的请求；用户切回手机工作区，读到的仍是这份本地快照，
+		 * 由前端按工作区筛选（见 `pickWorkspacePresets`）。
+		 */
+		case 'presetList': {
+			if (desktopCache.presets !== null) return desktopCache.presets;
+			try {
+				const fetched = await callRemote(config, 'presetList', {});
+				if (fetched !== null && fetched !== undefined) {
+					desktopCache.presets = fetched;
+					desktopCache.at = Date.now();
+					persistDesktopCache();
+				}
+				return fetched;
+			} catch (error) {
+				ctx.logger?.warn?.(
+					`[dsh-remote-mobile] 取电脑预设列表失败: ${String(error?.message ?? error)}`,
+				);
+				return null;
+			}
+		}
 
 		/**
 		 * 一键刷新：把「模型 / 预设 / 目录树」三样一起重新拉一遍。
@@ -2217,6 +2357,10 @@ async function handleBridge(ctx, config, io) {
 					io.desktopCache.directory = result.directory.value;
 				}
 				io.desktopCache.at = Date.now();
+				// ⚠️ 手动刷新是**唯一**会把新数据写进本地快照的路径 —— 平时读的都是
+				// 这份快照（见 `modelCatalog` / `presetList` 两个 case）。不落盘的话，
+				// 刷新只对本次运行有效，重开 App 又回到旧数据。
+				io.persistDesktopCache?.();
 				// 刷新完顺手把这一层的下一层预取回来，用户点进去就不用等了。
 				if (result.directory?.ok === true) io.prefetchDirs?.(result.directory.value);
 			}

package/package.json

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