dsh-jiuling-remote-mobile 0.0.0-stage → 1.0.1

package/lib/client.js

@@ -0,0 +1,636 @@
+/**
+ * dsh-remote-mobile —— 手机端（client half，跑在 WebView 的页面世界里）。
+ *
+ * ## 这个文件做两件事
+ *
+ * 1. **「电脑文件夹」入口** —— 注册进 `directoryFlow` slot，让选文件夹的对话框里
+ *    多出一个「电脑」页签：浏览电脑目录、在电脑上直接开一个会话。
+ * 2. **电脑实时消息流** —— 订阅宿主桥的全局 SSE，把电脑的流式帧转成
+ *    `assistant/live-chunk` transient 注入本地会话，于是手机上有逐字动画。
+ *
+ * ## ⚠️ 为什么是「取代」官方对话框，而不是「并列」
+ *
+ * `directoryFlow` 是 `kind: "single"` 的 slot，渲染时取 `entriesOfSlot(name)[0]`，
+ * 而 entries 按 priority **升序**排（见 dsh-client-ui-renderer L1148-1151）。
+ * 也就是说这个 slot 同时只能渲染**一个** occupant，无法「并排加一项」。
+ *
+ * 所以本插件用 **priority -1** 占据首位，自己实现一个双页签对话框：
+ * 「手机」页签复刻官方浏览行为（走 `uiWorkspace.listDirectory`，与官方 browse
+ * 后端是同一个 API），「电脑」页签走宿主桥。对用户的观感就是
+ * 「选文件夹的时候多了一个电脑入口」。
+ *
+ * ## ⚠️ 语法约束（旧内核）
+ *
+ * 本 App 有按 chrome73 降级编译的前端 bundle（`webview-compat.zip`），
+ * 所以这里**不用**可选链 `?.`、空值合并 `??`、`Object.fromEntries`、`Array.flat`
+ * 这些 chrome80+ 的语法。
+ *
+ * @module dsh-jiuling-remote-mobile/client
+ */
+
+window.__ModuleLoader__.load({
+	id: 'dsh-jiuling-remote-mobile',
+	factory: (require) => {
+		var module = { exports: {} };
+		var exports = module.exports;
+		Object.defineProperty(exports, Symbol.toStringTag, { value: 'Module' });
+
+		var react = require('react');
+		var h = react.createElement;
+
+		/** 宿主桥的路由（同源，直接相对路径）。 */
+		var ROUTE_RPC = '/api/dsh-remote/rpc';
+		var ROUTE_STREAM = '/api/dsh-remote/stream';
+
+		/** 配色取自官方设计令牌，拿不到时回退到中性值，避免与官方 UI 撞色。 */
+		var CSS = {
+			overlay:
+				'position:fixed;inset:0;z-index:60;display:flex;align-items:center;justify-content:center;' +
+				'background:rgba(0,0,0,.42);padding:16px;',
+			panel:
+				'width:100%;max-width:520px;max-height:82vh;display:flex;flex-direction:column;overflow:hidden;' +
+				'border-radius:14px;background:var(--dsw-alias-bg-primary,#1b1b1f);' +
+				'color:var(--dsw-alias-label-primary,#e8e8ea);' +
+				'box-shadow:0 18px 48px rgba(0,0,0,.38);' +
+				'border:1px solid var(--dsw-alias-border-secondary,rgba(255,255,255,.1));',
+			head: 'display:flex;align-items:center;gap:10px;padding:14px 16px 10px;flex:none;',
+			title: 'font-size:15px;font-weight:600;letter-spacing:.01em;flex:1;min-width:0;',
+			tabs: 'display:flex;gap:6px;padding:0 16px 10px;flex:none;',
+			tab:
+				'flex:1;height:32px;border-radius:8px;border:1px solid transparent;cursor:pointer;' +
+				'font-size:13px;background:transparent;color:var(--dsw-alias-label-secondary,#9a9aa2);',
+			tabOn:
+				'flex:1;height:32px;border-radius:8px;cursor:pointer;font-size:13px;font-weight:600;' +
+				'border:1px solid var(--dsw-alias-border-secondary,rgba(255,255,255,.14));' +
+				'background:var(--dsw-alias-interactive-bg-hover,rgba(255,255,255,.07));' +
+				'color:var(--dsw-alias-label-primary,#e8e8ea);',
+			path:
+				'display:flex;align-items:center;gap:8px;padding:8px 16px;flex:none;font-size:12px;' +
+				'color:var(--dsw-alias-label-tertiary,#7d7d85);' +
+				'border-top:1px solid var(--dsw-alias-border-secondary,rgba(255,255,255,.08));' +
+				'border-bottom:1px solid var(--dsw-alias-border-secondary,rgba(255,255,255,.08));',
+			pathText:
+				'flex:1;min-width:0;overflow:hidden;text-overflow:ellipsis;white-space:nowrap;',
+			list: 'flex:1;min-height:120px;overflow:auto;padding:6px 8px;',
+			row:
+				'display:flex;align-items:center;gap:10px;width:100%;text-align:left;padding:9px 10px;' +
+				'border-radius:8px;border:none;background:transparent;cursor:pointer;font-size:14px;' +
+				'color:var(--dsw-alias-label-primary,#e8e8ea);',
+			foot: 'display:flex;gap:8px;padding:12px 16px;flex:none;justify-content:flex-end;',
+			btn:
+				'height:34px;padding:0 16px;border-radius:8px;cursor:pointer;font-size:13px;' +
+				'border:1px solid var(--dsw-alias-border-secondary,rgba(255,255,255,.16));' +
+				'background:transparent;color:var(--dsw-alias-label-primary,#e8e8ea);',
+			btnPrimary:
+				'height:34px;padding:0 16px;border-radius:8px;cursor:pointer;font-size:13px;font-weight:600;' +
+				'border:none;background:var(--dsw-alias-state-business-primary,#4d6bfe);color:#fff;',
+			note: 'padding:10px 16px;font-size:12px;color:var(--dsw-alias-label-tertiary,#7d7d85);',
+			err: 'padding:10px 16px;font-size:12px;color:var(--dsw-alias-state-error-primary,#ff6b6b);word-break:break-all;',
+		};
+
+		/**
+		 * 调宿主桥的一条 RPC（令牌只在引擎进程里，浏览器侧不持有）。
+		 *
+		 * @param method - 方法名。
+		 * @param params - 参数。
+		 * @returns 结果的 Promise。
+		 */
+		function bridge(method, params) {
+			return fetch(ROUTE_RPC, {
+				method: 'POST',
+				headers: { 'content-type': 'application/json' },
+				body: JSON.stringify({ method: method, params: params || {} }),
+			}).then(
+				(res) => res.json(),
+				(error) => {
+					throw new Error('无法连接本地桥: ' + String((error && error.message) || error));
+				},
+			).then((payload) => {
+				if (!payload || payload.ok !== true) {
+					throw new Error((payload && payload.error) || '本地桥调用失败');
+				}
+				return payload.result;
+			});
+		}
+
+		/** 从任意形状的目录列表里取条目数组（宿主/官方后端的字段名略有差异）。 */
+		function entriesOf(listing) {
+			if (!listing || typeof listing !== 'object') return [];
+			if (Array.isArray(listing.entries)) return listing.entries;
+			if (Array.isArray(listing.items)) return listing.items;
+			return [];
+		}
+
+		/** 取条目的显示名。 */
+		function nameOf(entry) {
+			return entry.name || entry.title || entry.displayName || String(entry.path || '');
+		}
+
+		/** 取条目的完整路径。 */
+		function pathOf(entry) {
+			return entry.path || entry.fullPath || entry.name || '';
+		}
+
+		/** 是否是可进入的文件夹。 */
+		function isDir(entry) {
+			if (entry.enterable === false) return false;
+			if (entry.isDirectory === false) return false;
+			return true;
+		}
+
+		/** 取列表的当前路径与上级路径。 */
+		function locationOf(listing) {
+			var path = (listing && listing.path) || '';
+			var parent = (listing && listing.parent) || '';
+			// 后端明确给空 parent = 已经到顶了（Linux 的 `/`、Windows 的 `C:\`），
+			// 这时**不能**再自己兜底推算：切 `C:\` 会得到 `C:`，而它在前端眼里
+			// 也是绝对路径、按钮会被点亮，点下去后端直接报错。
+			var atRoot = path === '' || path === '/' || /^[a-zA-Z]:[\\/]?$/.test(path);
+			if (parent === '' && !atRoot) {
+				var trimmed = path.replace(/[\\/]+$/, '');
+				var slash = Math.max(trimmed.lastIndexOf('/'), trimmed.lastIndexOf('\\'));
+				if (slash > 0) parent = trimmed.slice(0, slash);
+			}
+			return { path: path, parent: parent, home: (listing && listing.home) || '' };
+		}
+
+		/**
+		 * 「选择工作区目录」对话框：手机 / 电脑 双页签。
+		 *
+		 * props 是 slot 契约的 `{open, busy, onPicked, onCancel, onError}`，
+		 * 外加 `inject` 送进来的浏览能力与宿主桥。
+		 */
+		function RemoteDirectoryFlow(props) {
+			var open = props.open;
+			var onPicked = props.onPicked;
+			var onCancel = props.onCancel;
+			var listDirectory = props.listDirectory;
+			var createDirectory = props.createDirectory;
+			var openSession = props.openSession;
+
+			var statePair = react.useState({
+				tab: 'local',
+				path: null,
+				listing: null,
+				loading: false,
+				error: null,
+				creating: false,
+			});
+			var state = statePair[0];
+			var setState = statePair[1];
+
+			var patch = react.useCallback(function (next) {
+				setState(function (prev) {
+					return Object.assign({}, prev, next);
+				});
+			}, []);
+
+			var aliveRef = react.useRef(true);
+			react.useEffect(function () {
+				aliveRef.current = true;
+				return function () {
+					aliveRef.current = false;
+				};
+			}, []);
+
+			// 每次打开都回到「手机」页签，避免上次停在电脑目录造成困惑。
+			react.useEffect(
+				function () {
+					if (open) patch({ tab: 'local', path: null, error: null });
+				},
+				[open, patch],
+			);
+
+			// 加载当前页签、当前路径的目录列表。
+			var tab = state.tab;
+			var path = state.path;
+			react.useEffect(
+				function () {
+					if (!open) return undefined;
+					patch({ loading: true, error: null });
+					var load =
+						tab === 'desktop'
+							? bridge('listDesktop', path === null ? {} : { path: path })
+							: Promise.resolve(listDirectory(path === null ? undefined : path));
+					load.then(
+						function (listing) {
+							if (!aliveRef.current) return;
+							patch({ loading: false, listing: listing });
+						},
+						function (reason) {
+							if (!aliveRef.current) return;
+							patch({
+								loading: false,
+								listing: null,
+								error: String((reason && reason.message) || reason),
+							});
+						},
+					);
+					return undefined;
+				},
+				[open, tab, path, listDirectory, patch],
+			);
+
+			if (!open) return null;
+
+			var loc = locationOf(state.listing);
+			var entries = entriesOf(state.listing).filter(isDir);
+
+			var switchTab = function (next) {
+				if (next === state.tab) return;
+				patch({ tab: next, path: null, listing: null, error: null });
+			};
+
+			/** 「手机」页签：采纳为本地工作区。 */
+			var pickLocal = function () {
+				if (loc.path === '') return;
+				onPicked(loc.path);
+			};
+
+			/** 「电脑」页签：在电脑的这个目录上开一个新会话，并跳到它。 */
+			var openDesktop = function () {
+				if (loc.path === '' || state.creating) return;
+				patch({ creating: true, error: null });
+				bridge('createSession', { path: loc.path }).then(
+					function (result) {
+						if (!aliveRef.current) return;
+						patch({ creating: false });
+						onCancel();
+						if (openSession !== undefined && result && result.sessionId) {
+							openSession(result.sessionId);
+						}
+					},
+					function (reason) {
+						if (!aliveRef.current) return;
+						patch({ creating: false, error: String((reason && reason.message) || reason) });
+					},
+				);
+			};
+
+			var makeFolder = function () {
+				if (loc.path === '' || createDirectory === undefined) return;
+				var name = window.prompt('文件夹名称', '新建文件夹');
+				if (name === null || name === '') return;
+				Promise.resolve(createDirectory(loc.path, name)).then(
+					function () {
+						if (aliveRef.current) patch({ path: loc.path });
+					},
+					function (reason) {
+						if (aliveRef.current) {
+							patch({ error: String((reason && reason.message) || reason) });
+						}
+					},
+				);
+			};
+
+			var rows = entries.map(function (entry) {
+				var full = pathOf(entry);
+				return h(
+					'button',
+					{
+						key: full,
+						type: 'button',
+						style: CSS.row,
+						onMouseEnter: function (event) {
+							event.currentTarget.style.background =
+								'var(--dsw-alias-interactive-bg-hover,rgba(255,255,255,.07))';
+						},
+						onMouseLeave: function (event) {
+							event.currentTarget.style.background = 'transparent';
+						},
+						onClick: function () {
+							patch({ path: full });
+						},
+					},
+					h('span', { style: { opacity: 0.55, flex: 'none' } }, '\u25B8'),
+					h(
+						'span',
+						{
+							style: {
+								flex: '1',
+								minWidth: 0,
+								overflow: 'hidden',
+								textOverflow: 'ellipsis',
+								whiteSpace: 'nowrap',
+							},
+						},
+						nameOf(entry),
+					),
+				);
+			});
+
+			return h(
+				'div',
+				{
+					style: CSS.overlay,
+					onClick: function (event) {
+						if (event.target === event.currentTarget) onCancel();
+					},
+				},
+				h(
+					'div',
+					{ style: CSS.panel, role: 'dialog', 'aria-label': '选择工作区目录' },
+					h(
+						'div',
+						{ style: CSS.head },
+						h('div', { style: CSS.title }, '选择工作区目录'),
+						h(
+							'button',
+							{ type: 'button', 'aria-label': '关闭', style: CSS.btn, onClick: onCancel },
+							'关闭',
+						),
+					),
+					h(
+						'div',
+						{ style: CSS.tabs },
+						h(
+							'button',
+							{
+								type: 'button',
+								style: state.tab === 'local' ? CSS.tabOn : CSS.tab,
+								onClick: function () {
+									switchTab('local');
+								},
+							},
+							'手机',
+						),
+						h(
+							'button',
+							{
+								type: 'button',
+								style: state.tab === 'desktop' ? CSS.tabOn : CSS.tab,
+								onClick: function () {
+									switchTab('desktop');
+								},
+							},
+							'电脑',
+						),
+					),
+					h(
+						'div',
+						{ style: CSS.path },
+						h(
+							'button',
+							{
+								type: 'button',
+								style: CSS.btn,
+								disabled: loc.parent === '',
+								onClick: function () {
+									patch({ path: loc.parent === '' ? null : loc.parent });
+								},
+							},
+							'上一级',
+						),
+						h('div', { style: CSS.pathText, title: loc.path }, loc.path || '（根）'),
+					),
+					state.error !== null ? h('div', { style: CSS.err, role: 'alert' }, state.error) : null,
+					state.loading
+						? h('div', { style: CSS.note }, '加载中…')
+						: h(
+								'div',
+								{ style: CSS.list },
+								rows.length > 0 ? rows : h('div', { style: CSS.note }, '这里没有子文件夹'),
+							),
+					state.tab === 'desktop'
+						? h(
+								'div',
+								{ style: CSS.note },
+								'在电脑的这个目录上开一个新对话，手机上会同步显示它的全部过程。',
+							)
+						: null,
+					h(
+						'div',
+						{ style: CSS.foot },
+						state.tab === 'local' && createDirectory !== undefined
+							? h('button', { type: 'button', style: CSS.btn, onClick: makeFolder }, '新建文件夹')
+							: null,
+						state.tab === 'local'
+							? h(
+									'button',
+									{
+										type: 'button',
+										style: CSS.btnPrimary,
+										disabled: loc.path === '' || props.busy,
+										onClick: pickLocal,
+									},
+									props.busy ? '处理中…' : '选择此文件夹',
+								)
+							: h(
+									'button',
+									{
+										type: 'button',
+										style: CSS.btnPrimary,
+										disabled: loc.path === '' || state.creating,
+										onClick: openDesktop,
+									},
+									state.creating ? '正在电脑上新建…' : '在此新建对话',
+								),
+					),
+				),
+			);
+		}
+
+		//#region 电脑流式帧 → 本地 transient
+		/**
+		 * 每个会话的流式折叠状态。
+		 *
+		 * 与官方 `ClientAssistantStream` 同构：`start` 建立 attempt、`chunk` 逐帧递增
+		 * `nextIndex`、`end` 收尾。**序号不连续时直接放弃这一轮流式动画**
+		 * （不抛错）——durable 事件随后会把完整内容补上，用户看到的是「没有逐字动画」
+		 * 而不是「内容缺失」。这与官方 `rebaseline` 的兜底方向一致。
+		 */
+		var attempts = new Map();
+
+		/** 取某会话的绑定（`eventSource` 就是浏览器侧的会话事件源）。 */
+		function bindingOf(ctx, sessionId) {
+			try {
+				return ctx.sessions.binding(sessionId);
+			} catch (error) {
+				return undefined;
+			}
+		}
+
+		/**
+		 * 退役某会话的逐字残片。
+		 *
+		 * ⚠️ **必须由我们来做**：官方的清理点是
+		 * `MutableSessionEventSource.settleAssistant(attemptId)`，它只被
+		 * `ClientAssistantStream.acceptEventChange` 调用 —— 而那条链服务于**远程
+		 * 事件流**。手机本地的 durable 事件是宿主直接 `session.append()` 进会话的，
+		 * 走不到它。不清理的话，逐字残片会永久留在窗口里，与随后到达的完整消息
+		 * 叠成两份。
+		 *
+		 * 不传 `entry`：durable 的完整消息会由会话事件流自己送进窗口，这里只负责
+		 * 把残片摘掉。
+		 *
+		 * @param ctx - client 根上下文。
+		 * @param sessionId - 会话 id。
+		 * @param attemptId - 要退役的 attempt。
+		 */
+		function retireTransient(ctx, sessionId, attemptId) {
+			if (typeof attemptId !== 'string') return;
+			var binding = bindingOf(ctx, sessionId);
+			if (binding === undefined || binding.eventSource === undefined) return;
+			try {
+				binding.eventSource.settleAssistant(attemptId);
+			} catch (error) {
+				/* 窗口已被替换：无需清理 */
+			}
+		}
+
+		/**
+		 * 把一帧电脑流式数据折进手机本地会话的 transient 行。
+		 *
+		 * @param ctx - client 根上下文。
+		 * @param sessionId - 两端同名的会话 id。
+		 * @param frame - 电脑端流式帧。
+		 */
+		function injectFrame(ctx, sessionId, frame) {
+			if (frame.type === 'start') {
+				// 上一轮若还挂着（start 帧没等到 end 帧），先把它退役，免得起重。
+				var stale = attempts.get(sessionId);
+				if (stale !== undefined) {
+					attempts.delete(sessionId);
+					retireTransient(ctx, sessionId, stale.attemptId);
+				}
+				attempts.set(sessionId, {
+					attemptId: frame.attemptId,
+					turn: frame.turn,
+					step: frame.step,
+					nextIndex: 0,
+					gap: 0,
+				});
+				return;
+			}
+			var attempt = attempts.get(sessionId);
+			if (attempt === undefined || attempt.attemptId !== frame.attemptId) return;
+			if (frame.type === 'end') {
+				attempts.delete(sessionId);
+				// `abandoned` 不会有 durable 结算，全靠这里把残片摘掉。
+				retireTransient(ctx, sessionId, attempt.attemptId);
+				return;
+			}
+			if (frame.type !== 'chunk') return;
+			if (frame.index !== attempt.nextIndex) {
+				// 序号跳了：这一轮流式不可信，交给 durable 通道兜底。
+				attempts.delete(sessionId);
+				retireTransient(ctx, sessionId, attempt.attemptId);
+				return;
+			}
+			attempt.nextIndex += 1;
+			attempt.gap += 1;
+
+			var binding = bindingOf(ctx, sessionId);
+			if (binding === undefined) return;
+
+			// transient 的 seq 要插在已提交事件之间：官方用 durableCursor + 1 - 1/(n+1)。
+			var cursor = -1;
+			var snapshot = binding.eventSource.getSnapshot();
+			var entries = (snapshot && snapshot.entries) || [];
+			for (var index = 0; index < entries.length; index += 1) {
+				var entry = entries[index];
+				if (entry.type !== 'transient' && entry.event && typeof entry.event.seq === 'number') {
+					if (entry.event.seq > cursor) cursor = entry.event.seq;
+				}
+			}
+			try {
+				binding.eventSource.append({
+					type: 'transient',
+					event: {
+						type: 'assistant/live-chunk',
+						seq: cursor + 1 - 1 / (attempt.gap + 1),
+						time: typeof frame.time === 'number' ? frame.time : Date.now(),
+						data: {
+							attemptId: attempt.attemptId,
+							turn: attempt.turn,
+							step: attempt.step,
+							chunk: frame.chunk,
+						},
+					},
+				});
+			} catch (error) {
+				attempts.delete(sessionId);
+			}
+		}
+
+		/**
+		 * 订阅宿主桥的全局 SSE。
+		 *
+		 * 全局一条：手机 WebView 对并发连接有上限，且一条连接就能服务所有会话。
+		 * EventSource 自带断线重连，所以这里不做退避。
+		 *
+		 * @param ctx - client 根上下文。
+		 */
+		function subscribe(ctx) {
+			var source = new EventSource(ROUTE_STREAM);
+			source.addEventListener('frame', function (message) {
+				var payload;
+				try {
+					payload = JSON.parse(message.data);
+				} catch (error) {
+					return;
+				}
+				if (!payload || typeof payload.sessionId !== 'string') return;
+				injectFrame(ctx, payload.sessionId, payload.frame);
+			});
+			// durable 结算兜底：万一 `end` 帧丢了，残片也要被摘掉。
+			source.addEventListener('settled', function (message) {
+				var payload;
+				try {
+					payload = JSON.parse(message.data);
+				} catch (error) {
+					return;
+				}
+				if (!payload || typeof payload.sessionId !== 'string') return;
+				var attempt = attempts.get(payload.sessionId);
+				if (attempt === undefined) return;
+				attempts.delete(payload.sessionId);
+				retireTransient(ctx, payload.sessionId, attempt.attemptId);
+			});
+			return function () {
+				source.close();
+			};
+		}
+		//#endregion
+
+		/** 需要宿主提供的服务：slot 注册表、工作区浏览与导航、会话数据。 */
+		const inject = ['slots', 'uiWorkspace', 'sessions'];
+
+		/**
+		 * Client 插件主体：注册「手机 / 电脑」双页签的目录选择对话框 + 订阅流式帧。
+		 *
+		 * @param ctx - client 根上下文。
+		 */
+		function apply(ctx) {
+			const injected = () => ({
+				listDirectory: (path, signal) => ctx.uiWorkspace.listDirectory(path, signal),
+				createDirectory: (path, name) => ctx.uiWorkspace.createDirectory(path, name),
+				openSession: (sessionId) => ctx.uiWorkspace.openSession(sessionId),
+			});
+
+			// 负 priority：single slot 取 entries[0]，entries 按 priority 升序 ⇒ 最先渲染。
+			const register = (name) =>
+				ctx.slots.register(
+					{
+						name: name,
+						priority: -1,
+						inject: injected,
+					},
+					RemoteDirectoryFlow,
+				);
+
+			ctx.slots.inject('conversation.hero.workspace.directoryFlow', () =>
+				ctx.slots.inject('sidebar.workspaces.directoryFlow', function* () {
+					yield register('conversation.hero.workspace.directoryFlow');
+					yield register('sidebar.workspaces.directoryFlow');
+				}),
+			);
+
+			ctx.effect(() => subscribe(ctx), 'dsh-remote-mobile: assistant stream bridge');
+		}
+
+		exports.apply = apply;
+		exports.inject = inject;
+		return module.exports;
+	},
+});

package/lib/index.js

@@ -0,0 +1,566 @@
+/**
+ * dsh-remote-mobile —— 手机端（host half，跑在手机的 DSH 引擎里）。
+ *
+ * ## 职责
+ *
+ * 手机是这个方案的「瘦客户端 + 搬运工」：
+ * - 手机本地跑**完整官方前端**（零远程 UI 加载，这是本方案相对「映射桌面」的核心优势）；
+ * - 手机不跑 LLM。用户在「电脑文件夹」里发的消息，转成 RPC 打到电脑；
+ * - 电脑回的 durable 事件写进**手机本地**同名 sessionId 的会话日志。
+ *
+ * 于是会话列表、历史、工具卡片、流式渲染全部是官方现成组件在工作，
+ * 手机端不需要写任何聊天 UI（只写那个「电脑文件夹」入口对话框）。
+ *
+ * ## ⚠️ cwd 绝不跨端传（实测硬约束）
+ *
+ * Android 是 posix 语义，`path.posix.isAbsolute('C:/Users/...') === false`，
+ * 而 `validateSessionHeader` 要求 cwd 是绝对路径；更危险的是
+ * `SessionCommandController.createOrAdopt()` 里有 `await mkdir(cwd, {recursive:true})`。
+ * 所以**手机端会话用自己的本地 cwd**，电脑路径只作展示文字，两端靠 sessionId 映射。
+ *
+ * ## 为什么手机端不装 LLM 也能「发消息」
+ *
+ * 关键：手机端会话**不要有 live agent**。一旦 `ctx.agents.get(sessionId)` 有值，
+ * 官方 `sessionController.prompt` 就会把消息交给那个 agent（真跑手机本地模型）。
+ * 本插件**拦截 `sessionController.prompt`**：远程会话的消息转发电脑，
+ * 同时用 `Session.append()` 在手机本地落一条 user/message，前端立刻显示用户气泡。
+ *
+ * 注意 `follow` / `page` 这类历史 RPC 的第三个参数是 `false`（不激活 Agent），
+ * 所以手机端打开一个远程会话**不会**触发本地模型，这是本方案能成立的前提。
+ *
+ * ## 事件搬运（durable 通道）
+ *
+ * 电脑的 durable 事件按顺序写进手机本地会话：
+ * - 直接 `session.append(type, data, opts)`，与电脑端同构，前端零改动；
+ * - **跳过 `session/end-seed`** —— 手机端 `Session` 构造时已自动插过一条，
+ *   重放时再写会让 seq 错位一位（实测踩过这个坑）。
+ *
+ * ## 流式通道（best-effort，全局一条）
+ *
+ * 电脑的流式帧经**一条全局 SSE** 转给浏览器，浏览器侧注入 `assistant/live-chunk`
+ * transient（不落盘）。用全局而不是按会话开多条，是因为手机 WebView 对
+ * 并发连接有上限，且重开 App 后一条连接就能恢复所有会话的动画。
+ *
+ * 丢帧是安全的：电脑端帧来自进程内事件永不丢，重连后 durable settlement
+ * 会把完整内容补上（实测结论），最坏只是少了逐字动画。
+ *
+ * @module dsh-remote-mobile
+ */
+
+import { randomUUID } from 'node:crypto';
+import { mkdirSync, readFileSync, writeFileSync } from 'node:fs';
+import { homedir } from 'node:os';
+import { join } from 'node:path';
+
+export const name = 'dsh-jiuling-remote-mobile';
+
+/** `sessions` 建会话/追加事件，`webServer` 给浏览器挂桥，`sessionController` 拦截 prompt。 */
+export const inject = ['sessions', 'sessionController', 'webServer'];
+
+/** 浏览器访问桥的路由。 */
+const ROUTE_RPC = '/api/dsh-remote/rpc';
+const ROUTE_STREAM = '/api/dsh-remote/stream';
+
+/** 状态目录（手机端）。 */
+const STATE_DIR = join(process.env.DSH_HOME ?? join(homedir(), '.dsh'), 'dsh-remote');
+
+/** 连接配置：电脑隧道地址 + 访问令牌。 */
+const CONFIG_PATH = join(STATE_DIR, 'mobile.json');
+
+/** 远程会话清单（持久化，重开 App 后能接着搬）。 */
+const SESSIONS_PATH = join(STATE_DIR, 'sessions.json');
+
+/** 默认隧道地址。 */
+const DEFAULT_ENDPOINT = 'https://dsh-remote.jiulingssh.xyz';
+
+/**
+ * 内置访问令牌 —— **必须与 `dsh-jiuling-remote-desktop` 里的内置值逐字相同**。
+ *
+ * 两端同值 ⇒ 装完即可连通，用户不用手工同步任何东西。想隔离就改这个文件里的
+ * `token` 字段，并把电脑端 `<DSH_HOME>/dsh-remote/token.txt` 改成一样的值。
+ */
+const DEFAULT_TOKEN = 'f6721b0cf82414709df172056193c78a6c374e9a920e51145dd7883923cf16e7';
+
+/**
+ * 读配置。首次运行写一份模板，用户直接改文件即可。
+ *
+ * `token` 为空时退回内置值（与电脑端同值），所以**装完就能连**。
+ *
+ * @returns `{ endpoint, token }`。
+ */
+function loadConfig() {
+	try {
+		const parsed = JSON.parse(readFileSync(CONFIG_PATH, 'utf8'));
+		const token = typeof parsed.token === 'string' && parsed.token !== '' ? parsed.token : DEFAULT_TOKEN;
+		return {
+			endpoint:
+				typeof parsed.endpoint === 'string' && parsed.endpoint !== ''
+					? parsed.endpoint.replace(/\/+$/, '')
+					: DEFAULT_ENDPOINT,
+			token,
+		};
+	} catch {
+		try {
+			mkdirSync(STATE_DIR, { recursive: true });
+			writeFileSync(
+				CONFIG_PATH,
+				JSON.stringify({ endpoint: DEFAULT_ENDPOINT, token: DEFAULT_TOKEN }, null, 2),
+				{ mode: 0o600 },
+			);
+		} catch {
+			/* 只读环境：用默认值继续 */
+		}
+		return { endpoint: DEFAULT_ENDPOINT, token: DEFAULT_TOKEN };
+	}
+}
+
+/** 读远程会话清单。 */
+function loadRemoteSessions() {
+	try {
+		const parsed = JSON.parse(readFileSync(SESSIONS_PATH, 'utf8'));
+		return new Set(Array.isArray(parsed.sessions) ? parsed.sessions.filter((x) => typeof x === 'string') : []);
+	} catch {
+		return new Set();
+	}
+}
+
+/** 写远程会话清单（失败不致命，只影响重开后的自动恢复）。 */
+function saveRemoteSessions(set, logger) {
+	try {
+		mkdirSync(STATE_DIR, { recursive: true });
+		writeFileSync(SESSIONS_PATH, JSON.stringify({ sessions: [...set] }, null, 2), { mode: 0o600 });
+	} catch (error) {
+		logger?.warn?.(`[dsh-remote-mobile] 保存远程会话清单失败: ${String(error?.message ?? error)}`);
+	}
+}
+
+/**
+ * 调电脑端的一条 RPC。
+ *
+ * @param config - `{ endpoint, token }`。
+ * @param method - 方法名。
+ * @param params - 参数。
+ * @returns 电脑端的 `result`。
+ */
+async function callRemote(config, method, params = {}) {
+	if (config.token === '') {
+		throw new Error(`未配置访问令牌：请在 ${CONFIG_PATH} 里填 token（电脑端启动日志会打印它）`);
+	}
+	const res = await fetch(`${config.endpoint}/api/dsh-remote/rpc`, {
+		method: 'POST',
+		headers: {
+			'content-type': 'application/json',
+			'x-dsh-remote-token': config.token,
+		},
+		body: JSON.stringify({ id: randomUUID(), method, params }),
+	});
+	if (!res.ok) throw new Error(`远程请求失败: HTTP ${res.status}`);
+	const payload = await res.json();
+	if (payload.ok !== true) throw new Error(payload.error ?? '远程请求失败');
+	return payload.result;
+}
+
+/**
+ * 把一个电脑事件写进手机本地会话。
+ *
+ * ## seq 对齐规则（这是搬运正确性的核心）
+ *
+ * ⚠️ 两端的 seq **起点不一样**，这是实测确认的：
+ *
+ * - 电脑端走 `sessionController.create` → agent factory → `agents.create({seed: ...})`，
+ *   `seed !== undefined` ⇒ `Session` 构造时**自动插一条 `session/end-seed`**（seq=0），
+ *   真实事件从 seq=1 开始（`dsh-session` L1351-1352）。
+ * - 手机端走 `sessions.create(id, {meta})`，**不带 seed** ⇒ 那条自动插入不触发
+ *   （L1351-1352 的条件是 `seed !== void 0`），真实事件从 seq=0 开始。
+ *
+ * 所以映射关系是 `手机 seq = 电脑 seq - 已跳过的 end-seed 条数`。
+ * `end-seed` 只会出现在日志最前面，跳过它之后两端就逐条对齐了。
+ *
+ * 据此判断：
+ * - 折算后的 seq < 本地 seq ⇒ 已写过（SSE 重连时电脑会补发历史），**跳过**；
+ * - 折算后 === 本地 seq ⇒ 正是下一条，写入；
+ * - 折算后 > 本地 seq ⇒ 中间缺事件。此时**不能硬写** —— 官方 `Session` 的 seq
+ *   必须连续，硬写会造成空洞。抛错交给调用方记日志，等重连补齐。
+ *
+ * @param session - 手机本地会话。
+ * @param event - 电脑端事件（`{type, seq, time, data, surfaceOp?, sourceEventSeqs?}`）。
+ * @param state - 该会话的搬运状态 `{ skippedSeeds }`。
+ * @returns 是否写入了。
+ */
+function mirrorEvent(session, event, state) {
+	// ⚠️ `session/end-seed` 必须跳过：手机端没有对应的一条，写进去会让后续全部错位。
+	// 它只会出现在电脑日志的最开头，所以偏移量只认一次 —— 否则 SSE 重连补发
+	// 历史时会被反复累加，后续事件的折算 seq 越算越小。
+	if (event.type === 'session/end-seed') {
+		if (state.skippedSeeds === 0) state.skippedSeeds = 1;
+		return false;
+	}
+	if (typeof event.seq === 'number') {
+		const expected = event.seq - state.skippedSeeds;
+		if (expected < session.seq) return false; // 重连补发的历史，已写过
+		if (expected > session.seq) {
+			throw new Error(
+				`事件流有缺口：电脑 seq=${event.seq}（折算 ${expected}），手机本地 seq=${session.seq}（等重连补齐）`,
+			);
+		}
+	}
+	const opts = {};
+	if (event.surfaceOp !== undefined) opts.surfaceOp = event.surfaceOp;
+	if (event.sourceEventSeqs !== undefined) opts.sourceEventSeqs = event.sourceEventSeqs;
+	session.append(event.type, event.data, opts);
+	return true;
+}
+
+/**
+ * 插件入口。
+ *
+ * @param ctx - Cordis 上下文。
+ */
+export function apply(ctx) {
+	const config = loadConfig();
+	ctx.logger?.info?.(`[dsh-remote-mobile] 远端: ${config.endpoint}`);
+	if (config.token === '') {
+		ctx.logger?.warn?.(`[dsh-remote-mobile] 未配置令牌，请在 ${CONFIG_PATH} 里填 token`);
+	}
+
+	/** 远程会话 id 集合：这些会话的 prompt 转发电脑，不在手机本地跑模型。 */
+	const remoteSessions = loadRemoteSessions();
+
+	/** 每个远程会话正在跟随的电脑事件流。 */
+	const follows = new Map();
+
+	/** 每个远程会话的搬运状态（已跳过几条 `session/end-seed`）。 */
+	const mirrorStates = new Map();
+
+	/** 取（或建）某会话的搬运状态。 */
+	const mirrorStateOf = (sessionId) => {
+		let state = mirrorStates.get(sessionId);
+		if (state === undefined) {
+			state = { skippedSeeds: 0 };
+			mirrorStates.set(sessionId, state);
+		}
+		return state;
+	};
+
+	/** 浏览器侧全局 SSE 订阅者。 */
+	const watchers = new Set();
+
+	/** 往所有浏览器订阅者推一条 SSE。 */
+	const broadcast = (eventName, payload) => {
+		if (watchers.size === 0) return;
+		const chunk = `event: ${eventName}\ndata: ${JSON.stringify(payload)}\n\n`;
+		for (const res of watchers) {
+			try {
+				res.write(chunk);
+			} catch {
+				watchers.delete(res);
+			}
+		}
+	};
+
+	/**
+	 * 跟随电脑的一个会话：durable 事件写手机本地，流式帧广播给浏览器。
+	 *
+	 * @param sessionId - 两端同名的会话 id。
+	 */
+	const follow = (sessionId) => {
+		if (follows.has(sessionId)) return;
+		const controller = new AbortController();
+		follows.set(sessionId, controller);
+
+		/**
+		 * 连一次电脑的 SSE 并消费到断开。
+		 *
+		 * 断线是**常态**（Cloudflare 隧道会掐空闲连接、手机休眠会断网），所以
+		 * 外面套一层退避重连：重连后电脑会补发全部历史，`mirrorEvent` 靠 seq
+		 * 折算把已写过的跳过，不会重复。
+		 */
+		const once = async () => {
+			const url =
+				`${config.endpoint}/api/dsh-remote/stream` +
+				`?session=${encodeURIComponent(sessionId)}&token=${encodeURIComponent(config.token)}`;
+			const res = await fetch(url, {
+				headers: { accept: 'text/event-stream' },
+				signal: controller.signal,
+			});
+			if (!res.ok || res.body === null) throw new Error(`HTTP ${res.status}`);
+
+			const decoder = new TextDecoder();
+			let buffer = '';
+			for await (const chunk of res.body) {
+				buffer += decoder.decode(chunk, { stream: true });
+				// SSE 以空行分隔消息；末段可能不完整，留在 buffer 里。
+				let split;
+				while ((split = buffer.indexOf('\n\n')) >= 0) {
+					const raw = buffer.slice(0, split);
+					buffer = buffer.slice(split + 2);
+					let eventName = 'message';
+					let dataLine = '';
+					for (const line of raw.split('\n')) {
+						if (line.startsWith('event:')) eventName = line.slice(6).trim();
+						else if (line.startsWith('data:')) dataLine += line.slice(5).trim();
+					}
+					if (dataLine === '') continue; // 心跳/注释行
+					let payload;
+					try {
+						payload = JSON.parse(dataLine);
+					} catch {
+						continue;
+					}
+					if (eventName === 'event') {
+						const session = ctx.sessions.get(sessionId);
+						if (session === undefined) continue;
+						let wrote = false;
+						try {
+							wrote = mirrorEvent(session, payload, mirrorStateOf(sessionId));
+						} catch (error) {
+							ctx.logger?.warn?.(
+								`[dsh-remote-mobile] 写入事件失败 (${payload?.type}): ${String(error?.message ?? error)}`,
+							);
+						}
+						// ⚠️ 必须告诉浏览器「这一轮的 durable 结算到了」。
+						//
+						// 浏览器侧的逐字动画是我们自己注入的 transient 行，而官方的
+						// 清理点（`MutableSessionEventSource.settleAssistant`）只挂在
+						// `ClientAssistantStream.acceptEventChange` 上 —— 那条链是**远程
+						// 事件流**专用的，手机本地的 durable 是同步 append 进会话的，
+						// 走不到它。没人清的话，逐字残片会永久留在窗口里，和随后到达的
+						// 完整消息叠成两份。
+						if (wrote && (payload?.type === 'assistant/message' || payload?.type === 'assistant/attempt')) {
+							broadcast('settled', {
+								sessionId,
+								turn: payload?.data?.turn,
+								step: payload?.data?.step,
+							});
+						}
+					} else if (eventName === 'frame') {
+						// 带上 sessionId：浏览器侧一条连接服务所有会话。
+						broadcast('frame', { sessionId, frame: payload });
+					}
+				}
+			}
+		};
+
+		const run = async () => {
+			let wait = 1000;
+			while (!controller.signal.aborted) {
+				try {
+					await once();
+				} catch (error) {
+					if (controller.signal.aborted) return;
+					ctx.logger?.warn?.(
+						`[dsh-remote-mobile] 事件流中断(${wait}ms 后重连): ${String(error?.message ?? error)}`,
+					);
+				}
+				if (controller.signal.aborted) return;
+				await new Promise((resolve) => setTimeout(resolve, wait));
+				wait = Math.min(wait * 2, 15000); // 退避到 15s 为止，一直重试
+			}
+		};
+
+		run().finally(() => {
+			if (follows.get(sessionId) === controller) follows.delete(sessionId);
+		});
+	};
+
+	// ---- 拦截官方 prompt：远程会话转发电脑，本地会话走原逻辑 ----
+	ctx.effect(() => {
+		const controller = ctx.sessionController;
+		if (controller === undefined) return;
+		const originalPrompt = controller.prompt.bind(controller);
+		controller.prompt = async (request) => {
+			if (!remoteSessions.has(request.sessionId)) return originalPrompt(request);
+			const text = (request.content ?? [])
+				.filter((part) => part.type === 'text')
+				.map((part) => part.text)
+				.join('\n');
+			if (ctx.sessions.get(request.sessionId) === undefined) {
+				throw new Error(`远程会话 "${request.sessionId}" 不在手机本地`);
+			}
+			// ⚠️ 手机端**不**自己写 user/message。
+			//
+			// 手机本地日志是电脑日志的镜像，seq 必须逐条对齐；本地多写一条会让
+			// 后续所有事件的 seq 错位，事件搬运随即失效。而电脑端 prompt 后
+			// 本来就会 append 一条 user/message 并流回来 —— 那才是唯一真源。
+			//
+			// 把前端的 requestId 原样带过去：电脑端会把它写进
+			// `source.rpcId`，前端凭这个结算「提交中」状态并显示用户气泡。
+			await callRemote(config, 'prompt', {
+				sessionId: request.sessionId,
+				text,
+				...(request.requestId === undefined ? {} : { requestId: request.requestId }),
+			});
+			// 确保事件流在线（断线时重连，补齐这段时间的事件）。
+			follow(request.sessionId);
+			return { accepted: true };
+		};
+
+		// 「停止生成」同样要转发到电脑。
+		// ⚠️ 不拦的话，官方 `cancel` 会 `resolveAgent()` → 在手机上 resume 一个 agent，
+		// 那会真去建目录、真跑手机本地模型。
+		const originalCancel = controller.cancel.bind(controller);
+		controller.cancel = async (request) => {
+			if (!remoteSessions.has(request.sessionId)) return originalCancel(request);
+			await callRemote(config, 'cancel', { sessionId: request.sessionId });
+			return { accepted: true };
+		};
+
+		return () => {
+			controller.prompt = originalPrompt;
+			controller.cancel = originalCancel;
+		};
+	}, 'dsh-remote-mobile: prompt/cancel 拦截');
+
+	// ---- 浏览器桥：目录浏览 / 建会话 ----
+	ctx.effect(
+		() =>
+			ctx.webServer.register({
+				kind: 'exact',
+				path: ROUTE_RPC,
+				handler: (req, res) => {
+					const reply = (code, payload) => {
+						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 () => {
+						let body;
+						try {
+							body = JSON.parse(Buffer.concat(chunks).toString('utf8'));
+						} catch (error) {
+							reply(400, { error: `bad json: ${String(error?.message ?? error)}` });
+							return;
+						}
+						try {
+							const result = await handleBridge(ctx, config, {
+								remoteSessions,
+								follow,
+								persist: () => saveRemoteSessions(remoteSessions, ctx.logger),
+								body,
+							});
+							reply(200, { ok: true, result });
+						} catch (error) {
+							reply(200, { ok: false, error: String(error?.message ?? error) });
+						}
+					});
+				},
+			}),
+		'dsh-remote-mobile: browser rpc route',
+	);
+
+	// ---- 浏览器流式订阅（全局一条） ----
+	ctx.effect(
+		() =>
+			ctx.webServer.register({
+				kind: 'exact',
+				path: ROUTE_STREAM,
+				handler: (req, res) => {
+					res.writeHead(200, {
+						'content-type': 'text/event-stream; charset=utf-8',
+						'cache-control': 'no-store, no-transform',
+						connection: 'keep-alive',
+						'x-accel-buffering': 'no',
+					});
+					res.write(': connected\n\n');
+					watchers.add(res);
+					const heartbeat = setInterval(() => {
+						try {
+							res.write(': ping\n\n');
+						} catch {
+							clearInterval(heartbeat);
+						}
+					}, 15000);
+					const cleanup = () => {
+						clearInterval(heartbeat);
+						watchers.delete(res);
+					};
+					req.on('close', cleanup);
+					req.on('error', cleanup);
+				},
+			}),
+		'dsh-remote-mobile: browser stream route',
+	);
+
+	// ---- 启动时恢复：把持久化的远程会话重新接上电脑 ----
+	ctx.effect(() => {
+		for (const sessionId of remoteSessions) follow(sessionId);
+		if (remoteSessions.size > 0) {
+			ctx.logger?.info?.(`[dsh-remote-mobile] 已恢复 ${remoteSessions.size} 个远程会话的事件流`);
+		}
+		return () => {
+			for (const controller of follows.values()) controller.abort();
+			follows.clear();
+			for (const res of watchers) {
+				try {
+					res.end();
+				} catch {
+					/* 已断开 */
+				}
+			}
+			watchers.clear();
+		};
+	}, 'dsh-remote-mobile: restore + teardown');
+}
+
+/**
+ * 处理浏览器桥来的一条 RPC。
+ *
+ * @param ctx - Cordis 上下文。
+ * @param config - 远程配置。
+ * @param io - `{ remoteSessions, follow, persist, body }`。
+ */
+async function handleBridge(ctx, config, io) {
+	const params = io.body?.params ?? {};
+	switch (io.body?.method) {
+		/** 连接自检：手机 → 电脑。 */
+		case 'ping':
+			return callRemote(config, 'ping', {});
+
+		/** 列电脑上的目录。 */
+		case 'listDesktop':
+			return callRemote(config, 'listDirectory', { path: params.path });
+
+		/**
+		 * 在电脑的某个目录下开一个新会话。
+		 *
+		 * 两端用**同一个 sessionId**：手机本地建会话（用手机 cwd，见文件头），
+		 * 电脑端在它自己的 cwd 下建同名会话。之后事件就能直接互搬。
+		 */
+		case 'createSession': {
+			if (typeof params.path !== 'string' || params.path === '') {
+				throw new Error('请先在电脑页签里选一个目录');
+			}
+			if (config.token === '') {
+				throw new Error(`未配置访问令牌：请在 ${CONFIG_PATH} 里填 token`);
+			}
+			const sessionId = `session-${randomUUID()}`;
+			// ⚠️ 手机端 cwd 必须是**手机本地**的绝对路径，绝不把电脑路径传进来
+			// （Android 是 posix 语义，`path.posix.isAbsolute('C:/...') === false`，
+			// 且官方 createOrAdopt 会 `mkdir(cwd, {recursive:true})` 真去建目录）。
+			// `process.cwd()` 是引擎的工作目录，在手机上就是那个绝对路径。
+			const cwd = process.cwd();
+			ctx.sessions.create(sessionId, { meta: { cwd } });
+			try {
+				await callRemote(config, 'createSession', { sessionId, cwd: params.path });
+			} catch (error) {
+				// 电脑没建成功就别留在手机本地，免得出现一个永远发不出消息的会话。
+				io.remoteSessions.delete(sessionId);
+				throw error;
+			}
+			io.remoteSessions.add(sessionId);
+			io.persist();
+			io.follow(sessionId);
+			return { sessionId, cwd, desktopPath: params.path };
+		}
+
+		/** 手机本地会话（供前端判断某个会话是不是远程会话）。 */
+		case 'isRemote':
+			return { remote: io.remoteSessions.has(params.sessionId) };
+
+		default:
+			throw new Error(`unknown method "${String(io.body?.method)}"`);
+	}
+}
+
+export { callRemote, mirrorEvent, loadConfig, DEFAULT_ENDPOINT, CONFIG_PATH };

package/package.json

@@ -1,6 +1,34 @@
 {
   "name": "dsh-jiuling-remote-mobile",
-  "version": "0.0.0-stage",
-  "stub": true,
-  "description": "Temporary package placeholder for staged publishing"
-}
+  "version": "1.0.1",
+  "description": "DSH 远程目录（手机端）：在选文件夹流程里多出「电脑」页签，进入电脑目录、在电脑上发起对话，并把电脑的实时消息流同步到手机本地界面（只传文本，不映射桌面）。",
+  "type": "module",
+  "main": "./lib/index.js",
+  "exports": {
+    ".": "./lib/index.js",
+    "./client": "./lib/client.js",
+    "./package.json": "./package.json"
+  },
+  "keywords": [
+    "dshapp-plugin",
+    "dsh",
+    "dsh-plugin",
+    "deepseek-harness",
+    "remote",
+    "android",
+    "cloudflare-tunnel"
+  ],
+  "files": [
+    "lib"
+  ],
+  "dsh": {
+    "client": {
+      "inject": [],
+      "platform": "web"
+    }
+  },
+  "engines": {
+    "node": ">=20"
+  },
+  "license": "MIT"
+}

package/README.md

@@ -1,3 +0,0 @@
-# Temporary Holding Version
-
-This version is a temporary placeholder for this package. An operational version to replace this has been submitted for review and is awaiting a staged release.