dsh-split-view 0.2.5 → 0.2.6

package/README.en.md

@@ -37,6 +37,8 @@ Install from source for local development: `dsh plugin --profile web add -w /pat
 
 Uninstall with `dsh plugin --profile web remove dsh-split-view`, restart, and the window is back to normal. If the plugin itself breaks, boot stops with an error instead of a silent blank page, so uninstalling is also the emergency recovery path.
 
+**Compatibility**: dsh `0.1.0-rc.6` through `0.2.x` — one build spans both host generations. dsh 0.2.0 added a peer-dependency gate, so on 0.2.5 or earlier the boot log shows `skipping profile bundle "dsh-split-view"` and no split buttons appear. Upgrade to 0.2.6 or later.
+
 ## Default shortcuts (customizable in Settings)
 
 | Key (⌘ on macOS, Ctrl on Windows/Linux) | Action |

package/README.md

@@ -37,6 +37,8 @@ dsh web   # 重启生效
 
 卸载用 `dsh plugin --profile web remove dsh-split-view`，重启恢复单窗口。插件本身如果出问题，boot 会停下来报错，不会静默白屏，所以卸载也就是紧急恢复的办法。
 
+**兼容范围**：dsh `0.1.0-rc.6` 起至 `0.2.x`，一份构建同时适配两代宿主。dsh 0.2.0 起有 peer 门禁，若装的是 0.2.5 及更早版本，启动日志会出现 `skipping profile bundle "dsh-split-view"`、界面上看不到分屏按钮——升级到 0.2.6 及以上即可。
+
 ## 默认快捷键（支持在设置中自定义）
 
 | 键（macOS ⌘，Windows/Linux Ctrl） | 动作 |

package/api.md

@@ -165,7 +165,7 @@ await sv.applyLayout(lay.tree)
 await sv.open('session-…', { pane: paneId })
 ```
 
-活面板**热切换**：顶层通过 postMessage 通知面板自己执行 `sessions.open`，不重载 iframe，面板内的客户端状态保留。休眠面板更新启动种子，下次唤醒时生效。会话不在列表里会抛错（列表基线未就绪时跳过校验，由面板侧兜底）。
+活面板**热切换**：顶层通过 postMessage 通知面板自己导航到目标会话（dsh 0.1.x 走 `sessions.open`，0.2.x 起走 `ctx.uiWorkspace.openSession`），不重载 iframe，面板内的客户端状态保留。休眠面板更新启动种子，下次唤醒时生效。会话不在列表里会抛错（列表基线未就绪时跳过校验，由面板侧兜底）。
 
 ### 新建会话
 

package/lib/client.js

@@ -11,9 +11,11 @@
 //   lowest renders) and draws a split container. Each cell is an iframe
 //   loading the full DSH client at /?dshPane=<id>[&dshSession=<sid>|&dshNew=1].
 // - Pane window (has ?dshPane): the pane agent pins the client to its assigned
-//   session via ctx.sessions.open() at boot (or ctx.sessions.clear() for a
-//   fresh pane), reports selection changes and focus to the parent, and
-//   forwards the split keyboard shortcuts as postMessage commands.
+//   session at boot (or drops it into the no-session state for a fresh pane),
+//   reports selection changes and focus to the parent, and forwards the split
+//   keyboard shortcuts as postMessage commands. Both the pinning and the
+//   read-back go through createSessionNav, which spans the dsh 0.2.0
+//   sessions-API break (open/clear/list.current replaced by mainView retention).
 // - Preferences (shortcuts, focus highlight color, title-bar visibility) are
 //   owned by the top window (it draws everything they control) and persisted
 //   in its localStorage; panes hold a mirror synced over postMessage and edit
@@ -72,7 +74,7 @@ window.__ModuleLoader__.load({
 		const params = new URLSearchParams(window.location.search);
 		/** Pane identity: present means this page load is a split pane, not the splitter. */
 		const PANE_ID = params.get("dshPane");
-		/** Session this pane must show (forced at boot through sessions.open). */
+		/** Session this pane must show (pinned at boot through the session nav). */
 		const SEED_SESSION = params.get("dshSession");
 		/** Fresh pane with an inherited workspace: create/connect its workspace session. */
 		const INHERIT_WORKSPACE = params.get("dshWorkspace");
@@ -449,7 +451,7 @@ function collectSyncedStorage() {
 		const SETTINGS_NS = "settings.splitView";
 		// Keep in sync with the "version" field in package.json — the client bundle
 		// has no runtime version source (boot manifest entries carry no version).
-		const PLUGIN_VERSION = "0.2.4";
+		const PLUGIN_VERSION = "0.2.6";
 		const ACTION_IDS = ["split-right", "split-down", "close", "maximize"];
 		const DEFAULT_SHORTCUTS = Object.freeze({
 			"split-right": "Mod+Shift+D",
@@ -687,6 +689,140 @@ function collectSyncedStorage() {
 		//#endregion
 
 		//#region pane agent (runs inside ?dshPane loads)
+		/** Pane session navigation across the dsh 0.2.0 sessions-API break.
+		 *
+		 * 0.1.x: `sessions.open(id)` selects the current session, `sessions.clear()`
+		 * drops back to the no-session view, and the selection reads back as
+		 * `list.getSnapshot().current`.
+		 *
+		 * 0.2.0 removed all three and moved navigation into `ctx.uiWorkspace`,
+		 * whose `replaceMain()` owns the single `mainView` retention reference.
+		 * That reference is the de-facto "current session" signal: a dozen call
+		 * sites across ui-workspace / ui-layout / ui-session / ui-cordis /
+		 * ui-open-in-app / ui-settings-general / ui-agent-preset derive it with
+		 * `Object.values(list.byId).find((row) => (row.retainedBy.mainView ?? 0) > 0)`.
+		 *
+		 * Retaining `mainView` ourselves — the obvious literal reading of the new
+		 * `sessions.retain(target, { source })` API — is wrong: the service does not
+		 * know about our reference and never releases it, so it outlives every
+		 * navigation and a second session accumulates a reference of its own. The
+		 * derivation above then resolves to whichever row comes first, and the pane
+		 * reports a session it is not showing (measured on 0.2.0-rc.2: our boot-seed
+		 * reference stayed on session A while the pane displayed B). Going through
+		 * `uiWorkspace` keeps the invariant and also updates `selection`, the
+		 * service's real source of truth.
+		 *
+		 * Access is through `ctx.get()`, which bypasses the cordis inject guard.
+		 * That is deliberate: declaring `"uiWorkspace"` in the fiber's inject list
+		 * would block the fiber forever on dsh 0.1.0-rc.6, where the service does
+		 * not exist yet, silently disabling the plugin for that whole range.
+		 *
+		 * The lookup is lazy and memoized. `applyPane` runs while the client tree
+		 * is still being mounted, and `ctx.get("uiWorkspace")` is undefined that
+		 * early — resolving it once at construction made every later navigation
+		 * throw "session navigation unavailable" while the service was in fact
+		 * reachable moments afterwards (measured on 0.2.0-rc.2).
+		 *
+		 * @param ctx - the pane client's cordis context.
+		 * @returns the pane's navigation handle; generation decided once, at construction. */
+		function createSessionNav(ctx) {
+			const sessions = ctx.sessions;
+			// 0.1.x has sessions.open/clear; 0.2.x has neither. `sessions` is a
+			// declared fiber inject, so it is settled by the time applyPane runs.
+			const legacy = typeof sessions.open === "function";
+			let workspace = void 0;
+			let warned = false;
+			const navigation = () => {
+				if (workspace === void 0 || workspace === null) {
+					try {
+						// Absent (not throwing) on hosts without the service.
+						if (typeof ctx.get === "function") workspace = ctx.get("uiWorkspace");
+					} catch {
+						workspace = void 0;
+					}
+				}
+				return workspace && typeof workspace.openSession === "function" ? workspace : void 0;
+			};
+			const unavailable = () => {
+				if (!warned) {
+					// Once, not per call: the pane agent retries on a bounded schedule.
+					warned = true;
+					console.warn("dsh-split-view: ctx.uiWorkspace is unavailable on this host; panes cannot pin a session");
+				}
+			};
+			return {
+				/** Whether this host's navigation entry point is reachable right now.
+				 * The service mounts after the client tree comes up, so a caller
+				 * gating a one-shot boot action asks first instead of discovering
+				 * by throwing — and can retry rather than latch a failure. */
+				ready() {
+					return legacy || navigation() !== void 0;
+				},
+				/** Point the pane at `id`; throws while the id is not listed yet. */
+				open(id) {
+					if (legacy) {
+						sessions.open(id);
+						return;
+					}
+					const ws = navigation();
+					if (ws === void 0) {
+						unavailable();
+						throw new Error("dsh-split-view: session navigation unavailable on this host");
+					}
+					// Same failure mode 0.1.x `open()` had — an id absent from the
+					// list baseline throws synchronously — so callers keep their
+					// retry-once-the-list-resolves logic unchanged.
+					ws.openSession(id);
+				},
+				/** Fresh-start the pane: no previously shown session.
+				 *
+				 * 0.1.x reaches the strict no-session view through `sessions.clear()`.
+				 * 0.2.x has no boot-time no-session state at all: `watchNavigation()`
+				 * treats a missing main reference as "restore the persisted
+				 * selection", so `clearMain()` during boot is provably overwritten by
+				 * the host's async `restoreSelection` (measured — the pane came back
+				 * up on the persisted session every time). `startSession()` is the
+				 * official fresh-start action instead: it reuses or creates the
+				 * workspace's blank session and sets the main reference, which makes
+				 * `watchNavigation` skip the restore. It degrades to `clearMain()`
+				 * itself when the host has no workspace, so the strict empty state is
+				 * still what a workspace-less pane gets. */
+				clear() {
+					if (legacy) {
+						sessions.clear();
+						return;
+					}
+					const ws = navigation();
+					if (ws === void 0) {
+						unavailable();
+						return;
+					}
+					if (typeof ws.startSession === "function") ws.startSession();
+					else if (typeof ws.clearMain === "function") ws.clearMain();
+				},
+				/** The session this pane shows, or undefined for the empty state.
+				 * `list.current` on 0.1.x; the `mainView` derivation the official UI
+				 * itself uses on 0.2.x, where `SessionListState` has no `current`
+				 * and the counts live on `SessionSummary.retainedBy` (absent in
+				 * 0.1.x, so the scan is a no-op there and the two paths cannot
+				 * disagree). Retention changes propagate through the list store —
+				 * `dsh-client-ui-cordis` reads this same shape as a reactive
+				 * `useSessions` selector — so the caller's list subscription is
+				 * sufficient; no separate retainInfo watch is needed.
+				 * @param snap - a `sessions.list` snapshot. */
+				currentOf(snap) {
+					if (snap.current !== void 0 && snap.current !== null) return snap.current;
+					const rows = Object.values(snap.byId);
+					for (let i = 0; i < rows.length; i++) {
+						const row = rows[i];
+						const retainedBy = row ? row.retainedBy : void 0;
+						if (retainedBy && (retainedBy.mainView ?? 0) > 0) return row.id;
+					}
+					return void 0;
+				}
+			};
+		}
+
 		function applyPane(ctx) {
 			// Prefs mirror of the top window (the source of truth — see the
 			// preferences region header). Same-origin panes share the top's
@@ -711,6 +847,9 @@ function collectSyncedStorage() {
 				}
 			};
 			applySettings(ctx, prefsChannel);
+			// Pane-scoped, shared by both effects below so every navigation in this
+			// pane goes through the same host-generation decision.
+			const nav = createSessionNav(ctx);
 			ctx.effect(() => {
 				const sessions = ctx.sessions;
 				// Session seeding is gated on the list baseline: SessionManager.select
@@ -724,7 +863,7 @@ function collectSyncedStorage() {
 					const opts = INHERIT_WORKSPACE ? { workspaceId: INHERIT_WORKSPACE } : { cwd: INHERIT_CWD };
 					const fallback = () => {
 						try {
-							sessions.clear();
+							nav.clear();
 						} catch {
 							// empty-state fallback is best-effort
 						}
@@ -741,7 +880,7 @@ function collectSyncedStorage() {
 							}
 							if (target !== void 0) {
 								try {
-									sessions.open(target);
+									nav.open(target);
 									return;
 								} catch {
 									// fall through to the empty state
@@ -756,32 +895,68 @@ function collectSyncedStorage() {
 				const trySeed = () => {
 					if (seeded) return;
 					if (sessions.list.getSnapshot().phase === "pending") return;
-					seeded = true;
+					// The host mounts the navigation service after the client tree
+					// comes up, and the list baseline can resolve first. Navigating
+					// that early fails against a service that becomes reachable
+					// moments later, so do not latch the attempt — the deferred
+					// passes below retry it (the same bounded idiom the theme
+					// presenter uses for events that race its listener).
+					if (!nav.ready()) return;
 					if (SEED_SESSION) {
 						try {
-							sessions.open(SEED_SESSION);
+							nav.open(SEED_SESSION);
 						} catch (error) {
+							// Genuinely gone (deleted/archived elsewhere) — give up
+							// gracefully and let the pane fall back.
+							seeded = true;
 							console.warn("dsh-split-view: pane session seed unavailable, pane falls back", error);
+							return;
 						}
+						// Latch only on the observed outcome. The host restores the
+						// persisted selection asynchronously (`restoreSelection`, which
+						// reuses a blank session in the same workspace) and can land
+						// after us, silently overwriting the seed; the passes below
+						// re-assert until the pane really shows it.
+						if (nav.currentOf(sessions.list.getSnapshot()) === SEED_SESSION) seeded = true;
 						return;
 					}
 					if (INHERIT_WORKSPACE || INHERIT_CWD) {
+						seeded = true;
 						seedInherited();
 						return;
 					}
 					if (WANT_NEW) {
 						try {
-							sessions.clear();
+							nav.clear();
 						} catch {
 							// empty-state fallback is best-effort
 						}
+						// Latch on the observed outcome rather than on having called:
+						// the host's async restore can still put the persisted session
+						// back, and a "fresh pane" showing someone's previous
+						// conversation is exactly the failure worth re-asserting. 0.1.x
+						// lands on no session, 0.2.x on the workspace's blank session —
+						// both are a fresh start, a restored non-blank one is not.
+						const freshSnap = sessions.list.getSnapshot();
+						const shown = nav.currentOf(freshSnap);
+						if (shown === void 0 || shown === null) seeded = true;
+						else {
+							const row = freshSnap.byId[shown];
+							if (row && row.blank) seeded = true;
+						}
 					}
 				};
 				trySeed();
 				const offSeed = seeded ? () => {} : sessions.list.subscribe(trySeed);
+				// Deferred passes: the list subscription only re-fires on list changes,
+				// which is not guaranteed once the baseline has resolved — so neither a
+				// late-mounting navigation service nor a host restore that overwrote us
+				// would ever be retried. Bounded, and every pass lands inside the pane's
+				// boot window, so re-asserting cannot fight a deliberate user navigation.
+				const seedTimers = seeded ? [] : [200, 500, 1000, 2000, 5000].map((delay) => setTimeout(trySeed, delay));
 				const report = () => {
 					const listSnap = sessions.list.getSnapshot();
-					const current = listSnap.current;
+					const current = nav.currentOf(listSnap);
 					const summary = current === null || current === void 0 ? void 0 : listSnap.byId[current];
 					postToParent({
 						kind: "session",
@@ -811,6 +986,7 @@ function collectSyncedStorage() {
 				document.addEventListener("keydown", onKey, true);
 				return () => {
 					offSeed();
+					for (const timer of seedTimers) clearTimeout(timer);
 					offList();
 					document.removeEventListener("mousedown", onActivity, true);
 					window.removeEventListener("focus", onActivity);
@@ -973,7 +1149,7 @@ function collectSyncedStorage() {
 						const target = data.sessionId;
 						const openNow = () => {
 							try {
-								ctx.sessions.open(target);
+								nav.open(target);
 								return true;
 							} catch {
 								return false;
@@ -988,7 +1164,7 @@ function collectSyncedStorage() {
 							if (ctx.sessions.list.getSnapshot().phase === "pending") return;
 							off();
 							try {
-								ctx.sessions.open(target);
+								nav.open(target);
 							} catch {
 								// genuinely gone (deleted elsewhere) — keep the current session
 							}

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "dsh-split-view",
-  "version": "0.2.5",
+  "version": "0.2.6",
   "description": "Multi-session split view for the DeepSeek Harness web GUI: the top window shadows the root slot with a resizable split container; each pane is an iframe running a full DSH client pinned to its own session, with per-pane title bars, LRU hibernation and a dual-loopback origin pool.",
   "license": "MIT",
   "type": "module",
@@ -65,10 +65,10 @@
   "peerDependencies": {
     "react": "^18.2.0",
     "@deepseek-ai/cordis": "^4.0.1",
-    "@deepseek-ai/dsh-client-runtime": "^0.1.0-rc.6",
-    "@deepseek-ai/dsh-client-locale": "^0.1.0-rc.6",
-    "@deepseek-ai/dsh-client-ui-theme": "^0.1.0-rc.6",
-    "@deepseek-ai/dsh-client-ui-settings": "^0.1.0-rc.6",
-    "@deepseek-ai/dsh-client-ui-settings-general": "^0.1.0-rc.6"
+    "@deepseek-ai/dsh-client-runtime": "^0.1.0-rc.6 || ^0.2.0-rc.2",
+    "@deepseek-ai/dsh-client-locale": "^0.1.0-rc.6 || ^0.2.0-rc.2",
+    "@deepseek-ai/dsh-client-ui-theme": "^0.1.0-rc.6 || ^0.2.0-rc.2",
+    "@deepseek-ai/dsh-client-ui-settings": "^0.1.0-rc.6 || ^0.2.0-rc.2",
+    "@deepseek-ai/dsh-client-ui-settings-general": "^0.1.0-rc.6 || ^0.2.0-rc.2"
   }
 }