dsh-jiuling-remote-mobile 1.0.15 → 1.0.17

package/lib/client.js

@@ -92,6 +92,11 @@ window.__ModuleLoader__.load({
 				'display:flex;align-items:flex-end;min-height:28px;margin:0;' +
 				'font-size:16px;font-weight:510;line-height:24px;color:var(--dsw-alias-label-primary);',
 			crumbBar: 'display:flex;align-items:center;gap:8px;min-height:24px;',
+			// 「显示隐藏文件夹」开关：与「上一级」同排，靠右。
+			crumbToggle:
+				'display:flex;flex:none;align-items:center;gap:4px;cursor:pointer;' +
+				'color:var(--dsw-alias-label-tertiary);font-size:12px;line-height:18px;white-space:nowrap;',
+			crumbToggleOn: 'color:var(--dsw-alias-label-secondary);',
 			pathText:
 				'flex:1 1 0;min-width:0;overflow:hidden;text-overflow:ellipsis;white-space:nowrap;' +
 				'color:var(--dsw-alias-label-tertiary);font-size:13px;line-height:20px;',
@@ -143,6 +148,11 @@ window.__ModuleLoader__.load({
 			pairConfirmText: 'flex:1 1 100%;',
 			pairMsg: 'padding:0 4px 8px;font-size:12px;line-height:18px;',
 			pairOk: 'color:var(--dsw-alias-state-success-primary);',
+			// 「刷新」那一行（模型 / 预设 / 目录树三样一起刷）的回执文字。
+			refreshNote:
+				'padding:0 4px 8px;font-size:12px;line-height:18px;' +
+				'color:var(--dsw-alias-label-tertiary);',
+			refreshOk: 'color:var(--dsw-alias-state-success-primary);',
 		};
 
 		/**
@@ -220,6 +230,37 @@ window.__ModuleLoader__.load({
 			document.head.appendChild(styleTag);
 		}
 
+		/**
+		 * 电脑目录的**访问缓存**：`电脑路径 → listing`（模块级，跨对话框开关存活）。
+		 *
+		 * ## 为什么必须有（用户报障原文）
+		 *
+		 * 「为什么我点击添加工作区的时候，每次点击电脑都要重新加载一遍目录，
+		 * 这就算了，我加载好之后，随便点击一个文件夹，文件夹里面的内容还要重新加载
+		 * 一遍」—— 同一个电脑目录，每次进「电脑」页签、每次点进同一个文件夹，
+		 * 都要重走一趟「手机 → Cloudflare 隧道 → 电脑」，一个来回 1～3 秒。
+		 * 用户要的是「加载一次，后续直接从本地读」。
+		 *
+		 * ## 为什么放模块级而不是组件内 ref
+		 *
+		 * 对话框每次打开都是**新挂载的组件**，组件内的 ref 一关就没了 —— 那样
+		 * 「关掉再打开又转一遍圈」，正是用户抱怨的第一个现象。放模块级则一次加载
+		 * 整条会话内都命中。
+		 *
+		 * ⚠️ 键是**电脑路径**原样（`C:\Users\...`），`''` 表示根目录 —— 与
+		 * `bridge('listDesktop')` 的入参完全一致，不做任何改写。
+		 *
+		 * ⚠️ **失效只有两条路**：用户点「刷新」（见 `refreshAll`），
+		 * 或者那一次加载失败（见下面的 catch）。不做 TTL 轮询 —— 用户明确要的是
+		 * 「加载一次就直接从本地读」。
+		 */
+		var desktopDirCache = {};
+
+		/** 清掉访问缓存（配对 / 解绑 / 切页签时调用，避免跨电脑串味）。 */
+		function clearDesktopDirCache() {
+			desktopDirCache = {};
+		}
+
 		/**
 		 * 调宿主桥的一条 RPC（令牌只在引擎进程里，浏览器侧不持有）。
 		 *
@@ -270,6 +311,21 @@ window.__ModuleLoader__.load({
 			return true;
 		}
 
+		/**
+		 * 是否是隐藏条目（名字以 `.` 开头）。
+		 *
+		 * ⚠️ **只按名字判断，不要去看属性位**：电脑端返回的条目只有
+		 * `{name, path, isDirectory, enterable}`，没有 Windows 的「隐藏」属性，
+		 * 而用户说的「前面带 `.` 的文件夹比如 `.dsh`」正是这一种。
+		 *
+		 * @param entry - 目录条目。
+		 * @returns 是否应归入「默认不显示」。
+		 */
+		function isHidden(entry) {
+			var name = nameOf(entry);
+			return name.length > 0 && name.charAt(0) === '.';
+		}
+
 		/** 取列表的当前路径与上级路径。 */
 		function locationOf(listing) {
 			var path = (listing && listing.path) || '';
@@ -311,6 +367,9 @@ window.__ModuleLoader__.load({
 				loading: false,
 				error: null,
 				creating: false,
+				// 是否显示 `.` 开头的隐藏文件夹。默认关 —— 电脑的项目根目录里
+				// `.dsh`、`.git`、`.vscode` 一堆，全列出来会把真正的项目目录淹掉。
+				showHidden: false,
 			});
 			var state = statePair[0];
 			var setState = statePair[1];
@@ -329,6 +388,9 @@ window.__ModuleLoader__.load({
 				// 「重新配对」的两步确认：`true` 时才显示「确定解绑 / 取消」。
 				confirming: false,
 				message: null,
+				// 一键刷新（模型 / 预设 / 目录树）的状态与回执。
+				refreshing: false,
+				refreshNote: null,
 			});
 			var pairState = pairPair[0];
 			var setPairState = pairPair[1];
@@ -393,6 +455,16 @@ window.__ModuleLoader__.load({
 						patch({ loading: false, listing: null, error: null });
 						return undefined;
 					}
+					// ⚠️ **电脑目录命中缓存就直接铺回去，不打桥**（用户报障：来回点文件夹
+					// 每次都重新加载）。缓存键用 `''` 表示根，与 `listDesktop` 的入参一致。
+					if (tab === 'desktop') {
+						var key = path === null ? '' : path;
+						var hit = desktopDirCache[key];
+						if (hit !== undefined) {
+							patch({ loading: false, listing: hit, error: null });
+							return undefined;
+						}
+					}
 					patch({ loading: true, error: null });
 					var load =
 						tab === 'desktop'
@@ -401,10 +473,16 @@ window.__ModuleLoader__.load({
 					load.then(
 						function (listing) {
 							if (!aliveRef.current) return;
+							if (tab === 'desktop') {
+								desktopDirCache[path === null ? '' : path] = listing;
+							}
 							patch({ loading: false, listing: listing });
 						},
 						function (reason) {
 							if (!aliveRef.current) return;
+							// ⚠️ 失败**要清掉这一格缓存**：留着的话用户再点进来会看到
+							// 上一次的旧内容，而以为自己看的是电脑现状。
+							if (tab === 'desktop') delete desktopDirCache[path === null ? '' : path];
 							patch({
 								loading: false,
 								listing: null,
@@ -420,7 +498,10 @@ window.__ModuleLoader__.load({
 			if (!open) return null;
 
 			var loc = locationOf(state.listing);
-			var entries = entriesOf(state.listing).filter(isDir);
+			// `.` 开头的默认不显示（见 `isHidden`）；开关在面包屑那一行。
+			var allDirs = entriesOf(state.listing).filter(isDir);
+			var hiddenCount = allDirs.filter(isHidden).length;
+			var entries = state.showHidden === true ? allDirs : allDirs.filter(function (e) { return !isHidden(e); });
 
 			var switchTab = function (next) {
 				if (next === state.tab) return;
@@ -454,6 +535,9 @@ window.__ModuleLoader__.load({
 							code: '',
 							message: { kind: 'ok', text: '配对成功，正在连接电脑…' },
 						});
+						// ⚠️ 换了一台电脑，旧缓存里的路径完全无效（甚至同名不同机）——
+						// 必须作废，否则用户会看到上一台电脑的目录。
+						clearDesktopDirCache();
 						patch({ path: null, listing: null });
 					},
 					function (reason) {
@@ -486,6 +570,8 @@ window.__ModuleLoader__.load({
 							code: '',
 							message: { kind: 'ok', text: '已解绑，请到电脑上生成新的配对码' },
 						});
+						// 解绑后旧凭据作废，缓存里的目录不该再露出来。
+						clearDesktopDirCache();
 						patch({ path: null, listing: null });
 					},
 					function (reason) {
@@ -555,6 +641,72 @@ window.__ModuleLoader__.load({
 				);
 			};
 
+			/**
+			 * 一键刷新：把「模型 / 预设 / 目录树」三样一起重新拉一遍。
+			 *
+			 * 用户需求原文：「你只需要添加一个手动刷新…这三个地方的数据都可以在
+			 * 选择工作区的时候，那个刷新按钮直接一键刷新这三个位置。」
+			 *
+			 * ⚠️ 光调桥拉数据**不够**：官方前端的模型目录是**带缓存**的
+			 * （`ModelCatalogDirectory.load()` 在 `status === 'ready'` 时直接返回旧值，
+			 * 见 `dsh-client-ui-model-selection/lib/client.js:100`）。所以拉完还要
+			 * 让它失效重载，否则用户看到的是「点了刷新，列表没变」。
+			 *
+			 * `modelDirectories` 是官方那个服务的名字（`super(ctx, "modelDirectories")`），
+			 * 它的 `.catalog.refresh()` 正是官方在 `llm/adapters-updated` 时走的那条路 ——
+			 * 走服务实例的公开方法，不碰前端 bundle 内部类。
+			 *
+			 * 预设名单没有等价的服务实例（官方预设前端不是 Service），它每次
+			 * 打开会话/设置面板都会重读，所以这里只更新宿主缓存即可。
+			 */
+			var refreshAll = function () {
+				if (pairState.refreshing) return;
+				patchPair({ refreshing: true, refreshNote: null });
+				var target = state.tab === 'desktop' ? loc.path : '';
+				// ⚠️ **「刷新」必须清掉访问缓存**，否则新列表铺回 `listing` 之后，
+				// 用户一离开再回来又命中旧的那一格，看起来就是「刷新没生效」。
+				// 连同整棵已缓存的树一起作废：电脑上的目录可能已经变了。
+				clearDesktopDirCache();
+				bridge('refreshAll', target === '' ? {} : { path: target }).then(
+					function (result) {
+						if (!aliveRef.current) return;
+						// 目录树：直接把新列表铺回去（正在看的这一层），并写回缓存。
+						if (result && result.directory && result.directory.ok) {
+							desktopDirCache[target === '' ? '' : target] = result.directory.value;
+							patch({ listing: result.directory.value });
+						}
+						// 模型：让官方目录失效重载，下一次打开菜单就是电脑的。
+						if (result && result.models && result.models.ok) {
+							try {
+								var models = props.modelDirectories;
+								if (models && models.catalog && typeof models.catalog.refresh === 'function') {
+									models.catalog.refresh();
+								}
+							} catch (error) {
+								/* 服务结构变了就只更新宿主缓存，不打扰用户 */
+							}
+						}
+						var failed = [];
+						if (result && result.models && !result.models.ok) failed.push('模型');
+						if (result && result.presets && !result.presets.ok) failed.push('预设');
+						if (result && result.directory && !result.directory.ok) failed.push('目录');
+						patchPair({
+							refreshing: false,
+							refreshNote: failed.length > 0
+								? { kind: 'error', text: failed.join('、') + '刷新失败，其余已更新' }
+								: { kind: 'ok', text: '模型、预设、目录已刷新' },
+						});
+					},
+					function (reason) {
+						if (!aliveRef.current) return;
+						patchPair({
+							refreshing: false,
+							refreshNote: { kind: 'error', text: String((reason && reason.message) || reason) },
+						});
+					},
+				);
+			};
+
 			/**
 			 * 「电脑」页签顶部的配对条。
 			 *
@@ -763,6 +915,41 @@ window.__ModuleLoader__.load({
 							'上一级',
 						),
 						h('span', { style: CSS.pathText, title: loc.path }, loc.path || '（根）'),
+						// 有隐藏文件夹时才显示开关 —— 一个目录里没有 `.` 开头的东西
+						// 却摆个开关，只会让人以为漏了什么。
+						hiddenCount > 0 || state.showHidden === true
+							? h(
+									'button',
+									{
+										type: 'button',
+										style: state.showHidden === true
+											? Object.assign({}, CSS.crumbToggle, CSS.crumbToggleOn)
+											: CSS.crumbToggle,
+										title: state.showHidden === true
+											? '隐藏以 . 开头的文件夹'
+											: '显示 ' + hiddenCount + ' 个以 . 开头的隐藏文件夹',
+										onClick: function () {
+											patch({ showHidden: state.showHidden !== true });
+										},
+									},
+									state.showHidden === true ? '隐藏 . 文件夹' : '显示 . 文件夹 (' + hiddenCount + ')',
+								)
+							: null,
+						// 一键刷新：模型 / 预设 / 目录树。只在「电脑」页签下有意义
+						//（手机页签的数据本来就来自本机，没什么可刷的）。
+						state.tab === 'desktop' && pairState.paired === true
+							? h(
+									'button',
+									{
+										type: 'button',
+										style: CSS.crumbToggle,
+										title: '重新拉取电脑的模型列表、预设列表与当前目录',
+										disabled: pairState.refreshing === true,
+										onClick: refreshAll,
+									},
+									pairState.refreshing === true ? '刷新中…' : '刷新',
+								)
+							: null,
 					),
 				),
 				// —— 主体：目录列表 ——
@@ -772,6 +959,18 @@ window.__ModuleLoader__.load({
 					// 配对条只在「电脑」页签下出现 —— 「手机」页签跟配对无关。
 					state.tab === 'desktop' ? pairBar : null,
 					state.tab === 'desktop' ? pairMsg : null,
+					state.tab === 'desktop' && pairState.refreshNote !== null
+						? h(
+								'div',
+								{
+									style: pairState.refreshNote.kind === 'ok'
+										? Object.assign({}, CSS.refreshNote, CSS.refreshOk)
+										: Object.assign({}, CSS.refreshNote, CSS.error),
+									role: pairState.refreshNote.kind === 'ok' ? undefined : 'alert',
+								},
+								pairState.refreshNote.text,
+							)
+						: null,
 					state.loading
 						? h('div', { style: CSS.status, role: 'status' }, '加载中…')
 						: h(
@@ -784,7 +983,9 @@ window.__ModuleLoader__.load({
 											{ style: CSS.status },
 											state.tab === 'desktop' && pairState.paired !== true
 												? '配对后这里会显示电脑上的文件夹'
-												: '这里没有子文件夹',
+												: hiddenCount > 0
+													? '这里只有 ' + hiddenCount + ' 个以 . 开头的隐藏文件夹'
+													: '这里没有子文件夹',
 										),
 							),
 					state.error !== null ? h('div', { style: CSS.error, role: 'alert' }, state.error) : null,
@@ -1058,6 +1259,14 @@ window.__ModuleLoader__.load({
 				},
 				/** 兜底：拉一次全量会话列表。 */
 				refreshSessions: () => ctx.sessions.refresh(),
+				/**
+				 * 官方的模型目录服务（`super(ctx, "modelDirectories")`）。
+				 *
+				 * 「刷新」按钮要让它失效重载 —— 官方目录**带缓存**，光把宿主那边的
+				 * 数据换掉，前端仍然显示旧值（见 `refreshAll` 的注释）。
+				 * `ctx.get` 拿不到就返回 `undefined`，组件里会跳过这一步。
+				 */
+				modelDirectories: ctx.get === undefined ? undefined : ctx.get('modelDirectories'),
 			});
 
 			// 负 priority：single slot 取 entries[0]，entries 按 priority 升序 ⇒ 最先渲染。

package/lib/index.js

@@ -164,6 +164,53 @@ function loadConfig() {
 	}
 }
 
+/**
+ * 镜像工作区登记表：`<slug> → <电脑路径>`。
+ *
+ * ## ⚠️ 为什么必须有这张表（否则「备选区选电脑目录」会静默退化成本地会话）
+ *
+ * 电脑目录在手机上的落点是**镜像目录** `STATE_DIR/workspaces/<slug>`，而 slug 是
+ * 电脑路径的**单向哈希**（`desktopSlug`，末 8 位是 sha256 摘要）——**推不回原路径**。
+ *
+ * 而用户第二次开对话时走的是**另一条路**：他不再进「电脑文件夹」对话框，而是直接在
+ * 新建对话首页的**备选区**里点上次那个工作区。那条路是官方前端自己
+ * `sessionController.create({workspaceId})`，**根本不经过本插件的 `createSession` 桥**
+ * ⇒ `remoteSessions` 里没有这个 sessionId ⇒ prompt 拦截不命中 ⇒ 消息走手机本地模型。
+ *
+ * 真机症状（用户原话）：「我问他你的工作目录是什么，他回答的就是我安卓的目录，
+ * 模型也没加载到电脑的」。第一次手动建时一切正常，**第二次起就变本地**。
+ *
+ * 所以要能从「镜像目录」反查出「电脑路径」，才能在那个路口把会话重新绑成远程。
+ */
+const WORKSPACES_PATH = join(STATE_DIR, 'workspaces.json');
+
+/** 读镜像工作区登记表。 */
+function loadWorkspaceMap() {
+	try {
+		const parsed = JSON.parse(readFileSync(WORKSPACES_PATH, 'utf8'));
+		const map = parsed?.workspaces;
+		if (map === null || typeof map !== 'object') return {};
+		/** @type {Record<string, string>} */
+		const out = {};
+		for (const key of Object.keys(map)) {
+			if (typeof map[key] === 'string' && map[key] !== '') out[key] = map[key];
+		}
+		return out;
+	} catch {
+		return {};
+	}
+}
+
+/** 写镜像工作区登记表（失败不致命，只影响重开后的自动绑定）。 */
+function saveWorkspaceMap(map, logger) {
+	try {
+		mkdirSync(STATE_DIR, { recursive: true });
+		writeFileSync(WORKSPACES_PATH, JSON.stringify({ workspaces: map }, null, 2), { mode: 0o600 });
+	} catch (error) {
+		logger?.warn?.(`[dsh-remote-mobile] 保存镜像工作区登记表失败: ${String(error?.message ?? error)}`);
+	}
+}
+
 /** 读远程会话清单。 */
 function loadRemoteSessions() {
 	try {
@@ -608,6 +655,9 @@ export function apply(ctx) {
 	/** 远程会话 id 集合：这些会话的 prompt 转发电脑，不在手机本地跑模型。 */
 	const remoteSessions = loadRemoteSessions();
 
+	/** 镜像工作区登记表：`<slug> → <电脑路径>`（见 `WORKSPACES_PATH` 的注释）。 */
+	const workspaceMap = loadWorkspaceMap();
+
 	/** 每个远程会话正在跟随的电脑事件流。 */
 	const follows = new Map();
 
@@ -627,6 +677,104 @@ export function apply(ctx) {
 	/** 浏览器侧全局 SSE 订阅者。 */
 	const watchers = new Set();
 
+	/**
+	 * 电脑侧的静默缓存：`{ catalog, presets, at }`。
+	 *
+	 * ## 为什么要缓存（用户需求原文）
+	 *
+	 * 「用户配对成功之后 就可以静默的拉取一些数据了，比如模型列表和预设列表，
+	 * 以及目录树这样体验会好很多……因为一般项目目录是不会变的，可以提前加载」。
+	 *
+	 * 配对后立刻拉一次，之后前端一打开模型菜单就有内容，不用等一轮往返。
+	 * 目录树**不进这个缓存** —— 它按路径变化，缓存了反而会显示过期内容，
+	 * 由前端每次进目录时实时拉。
+	 */
+	const desktopCache = { catalog: null, presets: null, at: 0 };
+
+	/**
+	 * 静默预拉电脑的模型目录与预设列表。
+	 *
+	 * ⚠️ **失败必须完全静默**：这是配对后的后台动作，用户没点任何东西。
+	 * 弹错误只会让人以为配对坏了 —— 而实际上配对是成功的，只是这台电脑的
+	 * 某个 provider 没配好（官方 `modelCatalog` 会把这种失败放进 `failures`，
+	 * 根本不会抛）。
+	 *
+	 * @param why - 日志里标明是谁触发的（配对 / 手动刷新）。
+	 */
+	const prefetchDesktop = async (why) => {
+		if (config.token === EMPTY_TOKEN) return;
+		const [catalog, presets] = await Promise.all([
+			callRemote(config, 'modelCatalog', {}).catch((error) => {
+				ctx.logger?.warn?.(`[dsh-remote-mobile] 预拉模型列表失败（${why}）: ${String(error?.message ?? error)}`);
+				return null;
+			}),
+			callRemote(config, 'presetList', {}).catch((error) => {
+				ctx.logger?.warn?.(`[dsh-remote-mobile] 预拉预设列表失败（${why}）: ${String(error?.message ?? error)}`);
+				return null;
+			}),
+		]);
+		if (catalog !== null) desktopCache.catalog = catalog;
+		if (presets !== null) desktopCache.presets = presets;
+		desktopCache.at = Date.now();
+		const models = catalog?.groups?.reduce((n, g) => n + (g.models?.length ?? 0), 0) ?? 0;
+		ctx.logger?.info?.(
+			`[dsh-remote-mobile] 已预拉电脑数据（${why}）：${models} 个模型、${presets?.presets?.length ?? 0} 个预设`,
+		);
+	};
+
+	/**
+	 * 把电脑的模型目录并进手机本地的目录。
+	 *
+	 * ## ⚠️ 为什么是「并」而不是「换」
+	 *
+	 * 官方前端的模型目录是**全局唯一一份**（`ModelCatalogDirectory` 由
+	 * `ModelDirectoryResolver` 持有，所有会话共享，见
+	 * `dsh-client-ui-model-selection/lib/client.js:340`），请求本身**不带 sessionId**。
+	 * 所以「远程会话看电脑的、本地会话看手机的」这种按会话切换，在官方结构里
+	 * **表达不出来** —— 硬要做得去改前端内部类，脆弱且升级即碎。
+	 *
+	 * 折中：**电脑的排前面**（用户要的就是「刷新为电脑的」，电脑模型一眼可见），
+	 * 手机自己那几组留在后面。这样远程会话能选到电脑的模型，本地会话也不会
+	 * 因为列表里只剩电脑模型而彻底没法用。
+	 *
+	 * 同 id 的 provider 以**电脑的为准**（电脑上那份才是干活用的）。
+	 *
+	 * @param local - 手机本地的模型目录。
+	 * @param desktop - 电脑的模型目录（`buildModelCatalog` 的产物）。
+	 * @returns 合并后的目录。
+	 */
+	function mergeCatalog(local, desktop) {
+		const groups = [...(desktop?.groups ?? [])];
+		const seen = new Set(groups.map((group) => group.id));
+		for (const group of local?.groups ?? []) {
+			if (!seen.has(group.id)) groups.push(group);
+		}
+		return {
+			...local,
+			groups,
+			failures: [...(desktop?.failures ?? []), ...(local?.failures ?? [])],
+			routableProviders: [
+				...new Set([...(local?.routableProviders ?? []), ...(desktop?.routableProviders ?? [])]),
+			],
+		};
+	}
+
+	/**
+	 * 把电脑的预设并进手机本地的预设名单（同 id 以电脑为准）。
+	 *
+	 * @param local - 手机本地的 `{presets}`。
+	 * @param desktop - 电脑的 `{presets}`。
+	 * @returns 合并后的名单。
+	 */
+	function mergePresets(local, desktop) {
+		const presets = [...(desktop?.presets ?? [])];
+		const seen = new Set(presets.map((preset) => preset.id));
+		for (const preset of local?.presets ?? []) {
+			if (!seen.has(preset.id)) presets.push(preset);
+		}
+		return { ...local, presets };
+	}
+
 	/** 往所有浏览器订阅者推一条 SSE。 */
 	const broadcast = (eventName, payload) => {
 		if (watchers.size === 0) return;
@@ -747,6 +895,69 @@ export function apply(ctx) {
 		});
 	};
 
+	// ---- 拦截官方 create：备选区选中「电脑目录」时自动绑成远程会话 ----
+	//
+	// ⚠️ **这是「第二次起就变本地」的根因修复，不是锦上添花。**
+	//
+	// 用户第一次是在「电脑文件夹」对话框里选的目录，走 `createSession` 桥 ——
+	// 那条路会把 sessionId 记进 `remoteSessions`，prompt 因此被转发电脑。
+	//
+	// 但第二次他是**在新建对话首页的备选区里**点上次那个工作区。官方前端此时
+	// 直接 `sessionController.create({workspaceId})`，**完全不经过本插件**，
+	// 于是 `remoteSessions` 里没有这个 sessionId ⇒ prompt 拦截不命中 ⇒
+	// 消息交给手机本地 agent（真跑手机模型、cwd 是手机路径）。
+	// 用户看到的就是「问他工作目录，答的是安卓目录」。
+	//
+	// 这里在同一个路口把它认出来并补上绑定：镜像目录 → 电脑路径 → 让电脑建同名会话。
+	ctx.effect(() => {
+		const controller = ctx.sessionController;
+		if (controller === undefined || typeof controller.create !== 'function') return;
+		const originalCreate = controller.create.bind(controller);
+		controller.create = async (request) => {
+			const result = await originalCreate(request);
+			const sessionId = result?.sessionId;
+			if (typeof sessionId !== 'string' || sessionId === '') return result;
+			// 已经绑过的（走对话框那条路）不用再绑。
+			if (remoteSessions.has(sessionId)) return result;
+			// 解析这个会话的 cwd：优先 `workspaceId`（备选区走的就是这条），
+			// 退回请求里的 `cwd`（直接给路径的情形）。
+			let dir = request?.cwd;
+			if (request?.workspaceId !== undefined) {
+				const workspace = ctx.get?.('workspaceRegistry')?.get?.(request.workspaceId);
+				if (workspace?.path !== undefined) dir = workspace.path;
+			}
+			const desktopPath = desktopPathOfMirror(workspaceMap, dir);
+			if (desktopPath === undefined) return result;
+			// 没配对时**不能**绑：绑了之后 prompt 会去打一个不存在的电脑，
+			// 用户看到的是「发消息就报错」，比退回本地会话更难理解。
+			if (config.token === EMPTY_TOKEN) {
+				ctx.logger?.warn?.(
+					`[dsh-remote-mobile] 会话 ${sessionId} 选的是电脑目录「${desktopPath}」，但还没配对，先当本地会话`,
+				);
+				return result;
+			}
+			try {
+				await callRemote(config, 'createSession', { sessionId, cwd: desktopPath });
+			} catch (error) {
+				// 电脑没建成功就别绑 —— 否则这个会话的每条消息都会失败。
+				ctx.logger?.warn?.(
+					`[dsh-remote-mobile] 电脑建会话失败，${sessionId} 退回本地会话: ${String(error?.message ?? error)}`,
+				);
+				return result;
+			}
+			remoteSessions.add(sessionId);
+			saveRemoteSessions(remoteSessions, ctx.logger);
+			follow(sessionId);
+			ctx.logger?.info?.(
+				`[dsh-remote-mobile] 备选区选中电脑目录「${desktopPath}」，会话 ${sessionId} 已绑为远程会话`,
+			);
+			return result;
+		};
+		return () => {
+			controller.create = originalCreate;
+		};
+	}, 'dsh-remote-mobile: create 拦截（备选区选电脑目录）');
+
 	// ---- 拦截官方 prompt：远程会话转发电脑，本地会话走原逻辑 ----
 	ctx.effect(() => {
 		const controller = ctx.sessionController;
@@ -763,7 +974,17 @@ export function apply(ctx) {
 		// 症状是**消息根本发不出去**，而报错文案完全看不出是参数漏传。
 		controller.prompt = async (request, signal) => {
 			if (!remoteSessions.has(request.sessionId)) return originalPrompt(request, signal);
-			const text = (request.content ?? [])
+			// ⚠️ **必须把附件一起转过去**，不能只挑 `text` part。
+			//
+			// 用户报的就是这个：「照片就会被吞了 AI 只能看到我的文字」。前端的
+			// `serializeAttachments()`（`dsh-client-ui-conversation/lib/client.js:3299`）
+			// 给图片发的是 `{type:'image', mediaType, data(base64)}` —— **字节是内联的**，
+			// 直接透传，电脑会用自己的 `attachments.admitPromptContent` 落盘。
+			//
+			// `{type:'file', receiptId}` 不转（receipt 属于手机的 `fileUploads`，
+			// 电脑解不开），由电脑端降级成一句说明（见其 `prompt` 分支的注释）。
+			const content = Array.isArray(request.content) ? request.content : [];
+			const text = content
 				.filter((part) => part.type === 'text')
 				.map((part) => part.text)
 				.join('\n');
@@ -781,6 +1002,8 @@ export function apply(ctx) {
 			await callRemote(config, 'prompt', {
 				sessionId: request.sessionId,
 				text,
+				// 附件形态一并带上（没有附件时给空数组，电脑端会退回纯文本）。
+				content,
 				...(request.requestId === undefined ? {} : { requestId: request.requestId }),
 			});
 			// 确保事件流在线（断线时重连，补齐这段时间的事件）。
@@ -900,6 +1123,234 @@ export function apply(ctx) {
 		};
 	}, 'dsh-remote-mobile: 屏蔽远程会话的本地标题生成');
 
+	// ---- 把电脑的模型目录与预设名单接进官方前端 ----
+	//
+	// ## 为什么拦在宿主侧，而不是改前端
+	//
+	// 官方前端的模型目录来自 `ctx.remote.session.modelCatalog()`（宿主 RPC），
+	// 预设来自 `ctx.remote.agentPresets.list()`（宿主 RPC）。两个 RPC 的**宿主实现**
+	// 就是 `sessionController.modelCatalog` 与 `agentPresets.remoteExportList`
+	// （装饰器 `Remote("modelCatalog")` / `Remote("list")`，见
+	// `dsh-api-session-controller/lib/index.js:2586`、
+	// `dsh-agent-preset-registry/lib/index.js:426`）。
+	//
+	// 这两处都是 `Remote(...)` 装饰的方法，**经实例动态派发**（与 `create`/`prompt`
+	// 同一机制），所以替换实例上的方法就能同时拦到直接调用与 RPC 调用 —— 不必碰
+	// 前端 bundle，升级也不会碎。
+	//
+	// 用户要的是「选了电脑目录之后，模型列表刷新为电脑的」。前端拿到的目录里
+	// **电脑的排前面**，手机自己那几组留在后面（原因见 `mergeCatalog` 的注释）。
+	ctx.effect(() => {
+		const undo = [];
+
+		/** 已配对才值得把电脑的东西并进来；没配对时保持手机本地原样。 */
+		const paired = () => config.token !== EMPTY_TOKEN;
+
+		// ① 模型目录
+		const controller = ctx.sessionController;
+		if (controller !== undefined && typeof controller.modelCatalog === 'function') {
+			const originalCatalog = controller.modelCatalog.bind(controller);
+			controller.modelCatalog = async (...args) => {
+				const local = await originalCatalog(...args);
+				if (!paired() || desktopCache.catalog === null) return local;
+				return mergeCatalog(local, desktopCache.catalog);
+			};
+			undo.push(() => {
+				controller.modelCatalog = originalCatalog;
+			});
+
+			// ② 选模型：远程会话的选择必须落到**电脑**上。
+			//
+			// ⚠️ 不转发的话，用户在前端选的模型只写进手机本地会话的投影，
+			// 电脑那边仍用它自己的默认模型 —— 表现是「选了也不生效」。
+			if (typeof controller.selectModel === 'function') {
+				const originalSelect = controller.selectModel.bind(controller);
+				controller.selectModel = async (request) => {
+					if (!remoteSessions.has(request?.sessionId)) return originalSelect(request);
+					const selected = await callRemote(config, 'selectModel', {
+						sessionId: request.sessionId,
+						provider: request.provider,
+						model: request.model,
+						...(request.reasoningEffort === undefined
+							? {}
+							: { reasoningEffort: request.reasoningEffort }),
+					});
+					return selected;
+				};
+				undo.push(() => {
+					controller.selectModel = originalSelect;
+				});
+			}
+		}
+
+		// ③ 预设名单
+		const patchPresets = (presets) => {
+			if (presets === undefined || typeof presets.remoteExportList !== 'function') return false;
+			const originalList = presets.remoteExportList.bind(presets);
+			presets.remoteExportList = async (...args) => {
+				const local = await originalList(...args);
+				if (!paired() || desktopCache.presets === null) return local;
+				return mergePresets(local, desktopCache.presets);
+			};
+			undo.push(() => {
+				presets.remoteExportList = originalList;
+			});
+			return true;
+		};
+
+		// 与标题守卫同构：先同步试一次，没就绪再交给依赖注入兜底。
+		// 两条路分开 try，否则 `ctx.get` 一抛错就把 `ctx.inject` 那条兜底也跳过了。
+		const warn = (error) =>
+			ctx.logger?.warn?.(
+				`[dsh-remote-mobile] 未能接上电脑的模型/预设列表: ${String(error?.message ?? error)}`,
+			);
+		let patched = false;
+		try {
+			patched = patchPresets(ctx.get('agentPresets'));
+		} catch (error) {
+			warn(error);
+		}
+		if (!patched) {
+			try {
+				ctx.inject(['agentPresets'], (scoped) => {
+					patchPresets(scoped.agentPresets);
+				});
+			} catch (error) {
+				warn(error);
+			}
+		}
+
+		return () => {
+			for (const fn of undo) fn();
+		};
+	}, 'dsh-remote-mobile: 电脑模型目录 / 预设名单接入');
+
+	// ---- 把远程会话的「文件树」接到电脑上（侧边栏 + 文件预览） ----
+	//
+	// 官方侧边栏的文件面板（`dsh-client-ui-sidebar-files`）以及内容预览
+	// （`dsh-client-ui-document-preview`）都只认 host 的 `workspaceFiles` 服务：
+	//
+	//   list(scope, path)              → 一层目录（含文件）
+	//   read(scope, path, {offset})    → 文本分页
+	//   stat(scope, path)              → 版本/大小
+	//   readBytes(scope, path, opts)   → 二进制分页
+	//
+	//   scope = {sessionId, workspaceRoot}，由官方按 sessionId 从会话 header 现算。
+	//
+	// ⚠️ **远程会话不能走本地的 `workspaceFiles`**：它的 `workspaceRoot` 是本插件
+	// 在手机上的**镜像空壳目录**（只为了让「备选区」里有个能点的项，见
+	// `ensureDesktopWorkspace`）。照本地那条路走，侧边栏里永远是**空的** ——
+	// 而用户要的是看到电脑上的目录树。所以这里把这几条调用转给电脑。
+	//
+	// ⚠️ **`changes`（自动刷新）刻意不转发**：官方那份是流式 RPC，本插件的中继
+	// 是一问一答，跨端桥一条长连的代价远大于收益。本地的 watcher 落在镜像空壳上，
+	// 会正常回 `ready`、只是永远不报变化 —— 侧边栏不会因此报错，用户用手动
+	// 「刷新」按钮看最新内容（产品上也是这么定的）。
+	ctx.effect(() => {
+		const undo = [];
+
+		/**
+		 * 判定会话是不是远程会话，并把路径换算成「相对于工作区」的一段。
+		 *
+		 * @returns 相对路径（根目录是空串）；不是远程会话时 `undefined`。
+		 */
+		const mapPath = (scope, path) => {
+			const desktopRoot = desktopPathOfMirror(workspaceMap, scope?.workspaceRoot);
+			if (desktopRoot === undefined) return undefined;
+			if (typeof path !== 'string' || path === '') return undefined;
+			// 侧边栏给的路径以会话 cwd 开头（官方 `childPath` 逐层拼出来），而
+			// `scope.workspaceRoot` 与它同源（都是会话 header 的 cwd）⇒ 前缀直接剥掉。
+			//
+			// ⚠️ **只传相对路径，绝不在这里拼电脑的绝对路径**：两端盘符/分隔符不同，
+			// 拼接是电脑那一端的事（见文件头「cwd 绝不跨端传」）。
+			const a = path.replace(/\\/g, '/');
+			const b = String(scope.workspaceRoot).replace(/\\/g, '/').replace(/\/+$/, '');
+			if (a === b) return { path: '' };
+			if (a.startsWith(`${b}/`)) return { path: a.slice(b.length + 1) };
+			// 不在工作区内的路径：原样交给电脑去解析（它自己会判越界）。
+			return { path: a };
+		};
+
+		/**
+		 * 只处理远程会话；本地会话原样交给官方。
+		 *
+		 * @param name - `workspaceFiles` 上的方法名。
+		 * @param original - 该方法**本来的**实现（可能没有）。
+		 */
+		const forward = (name, original) => async (scope, path, ...rest) => {
+			const mapped = remoteSessions.has(scope?.sessionId) ? mapPath(scope, path) : undefined;
+			if (mapped === undefined) {
+				if (original === undefined) throw new Error(`workspaceFiles.${name} 不可用`);
+				return await original(scope, path, ...rest);
+			}
+			if (name === 'list') {
+				return await callRemote(config, 'fileList', { sessionId: scope.sessionId, path: mapped.path });
+			}
+			if (name === 'read') {
+				const range = rest[0] ?? {};
+				return await callRemote(config, 'fileRead', {
+					sessionId: scope.sessionId,
+					path: mapped.path,
+					...(range.offset === undefined ? {} : { offset: range.offset }),
+				});
+			}
+			if (name === 'stat') {
+				return await callRemote(config, 'fileStat', { sessionId: scope.sessionId, path: mapped.path });
+			}
+			// readBytes：字节没法直接进 JSON，两端用 base64 过一道。
+			//
+			// ⚠️ **丢掉 `baseFile`**：官方那份是「相对 baseFile 所在目录」的语义，
+			// 而这里的路径已经换算成电脑上的绝对路径了，再带上一个手机路径的
+			// baseFile 只会让电脑去解析一个不存在的相对路径。
+			const result = await callRemote(config, 'fileReadBytes', {
+				sessionId: scope.sessionId,
+				path: mapped.path,
+				...(rest[0]?.range === undefined ? {} : { range: rest[0].range }),
+			});
+			const { data, ...meta } = result ?? {};
+			return { ...meta, data: new Uint8Array(Buffer.from(String(data ?? ''), 'base64')) };
+		};
+
+		const patch = (files) => {
+			if (files === undefined || typeof files.list !== 'function') return false;
+			let count = 0;
+			for (const name of ['list', 'read', 'stat', 'readBytes']) {
+				const fn = files[name];
+				if (typeof fn !== 'function') continue;
+				files[name] = forward(name, fn.bind(files));
+				undo.push(() => {
+					files[name] = fn;
+				});
+				count += 1;
+			}
+			return count > 0;
+		};
+
+		const warn = (error) =>
+			ctx.logger?.warn?.(
+				`[dsh-remote-mobile] 未能接上电脑的文件树: ${String(error?.message ?? error)}`,
+			);
+		let patched = false;
+		try {
+			patched = patch(ctx.get('workspaceFiles'));
+		} catch (error) {
+			warn(error);
+		}
+		if (!patched) {
+			try {
+				ctx.inject(['workspaceFiles'], (scoped) => {
+					patch(scoped.workspaceFiles);
+				});
+			} catch (error) {
+				warn(error);
+			}
+		}
+
+		return () => {
+			for (const fn of undo) fn();
+		};
+	}, 'dsh-remote-mobile: 电脑文件树接入（侧边栏 / 预览）');
+
 	// ---- 浏览器桥：目录浏览 / 建会话 ----
 	ctx.effect(
 		() =>
@@ -928,7 +1379,14 @@ export function apply(ctx) {
 								// 解绑要能停掉全部旧连接、清掉全部搬运状态（见 `unpair`）。
 								follows,
 								mirrorStates,
+								// ⚠️ **必须显式传进来**：`handleBridge` 是模块级函数，作用域里
+								// 没有 `apply()` 的闭包变量；漏传就是 `workspaceMap is not defined`，
+								// 用户点「在此新建对话」时必然失败（1.0.16 的真实报障）。
+								workspaceMap,
 								persist: () => saveRemoteSessions(remoteSessions, ctx.logger),
+								// 模型/预设的静默缓存：配对后预拉、刷新按钮回写（见 desktopCache）。
+								desktopCache,
+								prefetch: prefetchDesktop,
 								body,
 							});
 							reply(200, { ok: true, result });
@@ -980,6 +1438,11 @@ export function apply(ctx) {
 		if (remoteSessions.size > 0) {
 			ctx.logger?.info?.(`[dsh-remote-mobile] 已恢复 ${remoteSessions.size} 个远程会话的事件流`);
 		}
+		// 已配对的话，启动时也把电脑的模型/预设静默拉一次 —— 否则重启 App 后
+		// 用户直接打开模型菜单会看到空列表（缓存是内存态，重启即丢）。
+		// ⚠️ 不 await：这是后台动作，别拖慢引擎启动。`.catch` 兜住最后一道，
+		// 免得一个后台失败变成 unhandled rejection 打脏引擎日志。
+		prefetchDesktop('启动').catch(() => {});
 		return () => {
 			for (const controller of follows.values()) controller.abort();
 			follows.clear();
@@ -1052,22 +1515,52 @@ function desktopTitle(desktopPath) {
  * @param desktopPath - 电脑上的绝对路径（仅用于取名字，不会成为 cwd）。
  * @returns 工作区实体（含 `.id` / `.path` / `.title`）。
  */
-async function ensureDesktopWorkspace(ctx, desktopPath) {
+async function ensureDesktopWorkspace(ctx, desktopPath, workspaceMap) {
 	const registry = ctx.get?.('workspaceRegistry');
 	if (registry === undefined || typeof registry.create !== 'function') {
 		throw new Error('workspaceRegistry 不可用，无法为电脑目录建工作区');
 	}
-	const dir = join(STATE_DIR, 'workspaces', desktopSlug(desktopPath));
+	const slug = desktopSlug(desktopPath);
+	const dir = join(STATE_DIR, 'workspaces', slug);
 	mkdirSync(dir, { recursive: true });
+	// 登记 `slug → 电脑路径`，供「备选区直接选镜像工作区」那条路反查（见 WORKSPACES_PATH）。
+	if (workspaceMap !== undefined && workspaceMap[slug] !== desktopPath) {
+		workspaceMap[slug] = desktopPath;
+		saveWorkspaceMap(workspaceMap, ctx.logger);
+	}
 	return await registry.create(dir, desktopTitle(desktopPath));
 }
 
+/**
+ * 从镜像目录反查电脑路径。
+ *
+ * @param workspaceMap - `slug → 电脑路径`。
+ * @param dir - 会话的 cwd（应当落在 `STATE_DIR/workspaces/<slug>` 下）。
+ * @returns 电脑路径；不是镜像目录时 `undefined`。
+ */
+function desktopPathOfMirror(workspaceMap, dir) {
+	if (typeof dir !== 'string' || dir === '') return undefined;
+	// ⚠️ 用 `/workspaces/` 定位而不是拿 `join(STATE_DIR,'workspaces')` 做前缀比对：
+	// `workspace.path` 是 **realpath**（官方 `createOrAdopt` 会 realpath 解析），
+	// 在真机上可能多出/少掉一层符号链接（`/data/user/0` vs `/data/data`），
+	// 前缀一比就永远不命中 —— 症状是「修了但没生效」，极难查。
+	//
+	// 分隔符两种都认：真机是 posix（`join` 给 `/`），但把本插件装到 Windows 上
+	// 调试时 `join` 给的是 `\`，只认一种就会在那边静默失效。
+	const at = dir.search(/[\\/]workspaces[\\/]/);
+	if (at < 0) return undefined;
+	const slug = dir.slice(at).split(/[\\/]/)[2];
+	if (slug === undefined || slug === '') return undefined;
+	const path = workspaceMap[slug];
+	return typeof path === 'string' && path !== '' ? path : undefined;
+}
+
 /**
  * 处理浏览器桥来的一条 RPC。
  *
  * @param ctx - Cordis 上下文。
  * @param config - 远程配置。
- * @param io - `{ remoteSessions, follow, follows, mirrorStates, persist, body }`。
+ * @param io - `{ remoteSessions, follow, follows, mirrorStates, persist, workspaceMap, body }`。
  */
 async function handleBridge(ctx, config, io) {
 	const params = io.body?.params ?? {};
@@ -1080,6 +1573,56 @@ async function handleBridge(ctx, config, io) {
 		case 'listDesktop':
 			return callRemote(config, 'listDirectory', { path: params.path });
 
+		/**
+		 * 电脑上的模型目录。
+		 *
+		 * 用户要的是「选了电脑目录之后，输入框右下方的模型列表就刷新为电脑的」。
+		 * 手机本地那份模型列表来自手机自己的 LLM 配置，跟电脑上能跑什么没关系，
+		 * 拿它去发消息会选到一个电脑上不存在的模型。
+		 */
+		case 'modelCatalog':
+			return callRemote(config, 'modelCatalog', {});
+
+		/** 电脑上的预设列表。 */
+		case 'presetList':
+			return callRemote(config, 'presetList', {});
+
+		/**
+		 * 一键刷新：把「模型 / 预设 / 目录树」三样一起重新拉一遍。
+		 *
+		 * ⚠️ 三样**必须并发**且**互不牵连**：目录树拉不到（比如电脑上那个目录被删了）
+		 * 不该让模型列表也刷不出来。所以逐个 catch，谁失败谁自己带 `error`。
+		 *
+		 * @returns `{ models, presets, directory }`，每项是 `{ok, value|error}`。
+		 */
+		case 'refreshAll': {
+			const wantDirectory = typeof params.path === 'string' && params.path !== '';
+			const jobs = [
+				['models', () => callRemote(config, 'modelCatalog', {})],
+				['presets', () => callRemote(config, 'presetList', {})],
+				...(wantDirectory ? [['directory', () => callRemote(config, 'listDirectory', { path: params.path })]] : []),
+			];
+			const settled = await Promise.all(
+				jobs.map(async ([key, run]) => {
+					try {
+						return [key, { ok: true, value: await run() }];
+					} catch (error) {
+						return [key, { ok: false, error: String(error?.message ?? error) }];
+					}
+				}),
+			);
+			const result = Object.fromEntries(settled);
+			// ⚠️ 刷新到的模型/预设要**写回缓存**，否则「刷新按钮」只更新了它自己
+			// 那份响应，前端模型菜单读的是宿主拦截器里的缓存 —— 用户会看到
+			// 「点了刷新，模型列表没变」。
+			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.at = Date.now();
+			}
+			return result;
+		}
+
 		/**
 		 * 在电脑的某个目录下开一个新会话。
 		 *
@@ -1101,7 +1644,7 @@ async function handleBridge(ctx, config, io) {
 			// 这里给它一个**电脑目录专属的镜像工作区**（标题 = 电脑目录末段），
 			// 而不是手机的「默认工作区」—— 否则所有远程会话都堆在「默认工作区」
 			// 底下，看起来就像「建完又回到默认工作去了」（见 `ensureDesktopWorkspace`）。
-			const workspace = await ensureDesktopWorkspace(ctx, params.path);
+			const workspace = await ensureDesktopWorkspace(ctx, params.path, io.workspaceMap);
 			const cwd = workspace.path;
 			// ⚠️ **必须走 `sessionController.create`，不能走 `ctx.sessions.create`。**
 			//
@@ -1176,6 +1719,10 @@ async function handleBridge(ctx, config, io) {
 			}
 			const saved = await claimPairing(params.code.trim());
 			Object.assign(config, saved);
+			// 配对成功后**静默**预拉电脑的模型与预设（用户需求原文：
+			// 「用户配对成功之后 就可以静默的拉取一些数据了，比如模型列表和预设列表」）。
+			// ⚠️ 不 await：这是后台动作，配对请求要立刻回给前端，别让用户等一轮往返。
+			io.prefetch?.('配对成功')?.catch?.(() => {});
 			return { endpoint: saved.endpoint, tokenSet: saved.token !== '' };
 		}
 
@@ -1227,4 +1774,4 @@ async function handleBridge(ctx, config, io) {
 	}
 }
 
-export { callRemote, mirrorEvent, loadConfig, DEFAULT_ENDPOINT, CONFIG_PATH, PAIR_ENDPOINT, claimPairing };
+export { callRemote, mirrorEvent, loadConfig, DEFAULT_ENDPOINT, CONFIG_PATH, PAIR_ENDPOINT, claimPairing, handleBridge };

package/package.json

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