dsh-update-status 0.1.1 → 0.1.4

package/lib/client.js

@@ -12,8 +12,16 @@ window.__ModuleLoader__.load({
 		};
 		/**
 		* Reduce raw dist-tags to user-meaningful choices without losing Host facts.
-		* The selected channel and stable return path are mandatory; other rows must
-		* represent a version that differs from both the running DSH and earlier rows.
+		* The selected channel and stable return path are always present; every other
+		* row must carry a version no earlier row already shows.
+		*
+		* A channel is deliberately NOT hidden just because it currently points at the
+		* release that is running. Following a channel is a statement about future
+		* releases, and `currentVersion` still rides the input for the caller's own
+		* rendering, but filtering on it created a deadlock: while running the version
+		* published on `alpha`, the `alpha` row disappeared, so the one channel a user
+		* on that line would want to follow could never be selected — the only way to
+		* see it was to already follow it.
 		*/
 		function visibleChannelReleases(status) {
 			const ordered = [...status.channels].sort((left, right) => CHANNEL_ORDER[left.channel] - CHANNEL_ORDER[right.channel]);
@@ -21,7 +29,7 @@ window.__ModuleLoader__.load({
 			const visible = ordered.filter((release) => mandatory.has(release.channel));
 			const seenVersions = new Set(visible.map((release) => release.version).filter((version) => version !== null));
 			for (const release of ordered) {
-				if (mandatory.has(release.channel) || release.version === null || release.version === status.currentVersion) continue;
+				if (mandatory.has(release.channel) || release.version === null) continue;
 				if (seenVersions.has(release.version)) continue;
 				visible.push(release);
 				seenVersions.add(release.version);
@@ -42,13 +50,6 @@ window.__ModuleLoader__.load({
 		const PACKAGE_NAME = "@deepseek-ai/dsh";
 		/** Shared Connection RPC channel. Custom prefixes 405 on the SPA fallback. */
 		const UPDATE_STATUS_CHANNEL = "/api";
-		/** Exact DSH release this bundle declares compatible in package.json. */
-		const STATIC_COMPATIBLE_VERSION = "0.1.5-rc.1";
-		const RELEASE_CHANNELS = [
-			"latest",
-			"next",
-			"alpha"
-		];
 		const MAX_CACHE_TTL_MINUTES = 1440;
 		function isCacheTtlMinutes(value) {
 			return typeof value === "number" && Number.isInteger(value) && value >= 30 && value <= 1440;
@@ -439,7 +440,7 @@ window.__ModuleLoader__.load({
 				event.stopPropagation();
 				const target = event.currentTarget;
 				if (target instanceof HTMLElement) target.blur();
-				if (ui.canManage) ui.panel.toggle("brand");
+				ui.panel.toggle("brand");
 			};
 			const onKeyDown = (event) => {
 				if (event.key !== "Enter" && event.key !== " ") return;
@@ -454,13 +455,12 @@ window.__ModuleLoader__.load({
 					className: "dus-badge",
 					"data-update": snapshot.status?.hasUpdate === true || void 0,
 					"data-error": state === "problem" || void 0,
-					role: ui.canManage ? "button" : void 0,
-					tabIndex: ui.canManage ? 0 : void 0,
+					role: "button",
+					tabIndex: 0,
 					"aria-label": badgeLabel(snapshot.status, snapshot.loading, snapshot.error),
-					"aria-disabled": ui.canManage ? void 0 : true,
 					title: badgeLabel(snapshot.status, snapshot.loading, snapshot.error),
-					onClick: ui.canManage ? activate : void 0,
-					onKeyDown: ui.canManage ? onKeyDown : void 0,
+					onClick: activate,
+					onKeyDown,
 					children: [/* @__PURE__ */ (0, react_jsx_runtime.jsx)("span", {
 						className: "dus-badge-version",
 						children: shortVersion(version)
@@ -485,7 +485,6 @@ window.__ModuleLoader__.load({
 				type: "button",
 				"aria-label": t("footer.status"),
 				title: label,
-				disabled: !ui.canManage,
 				onClick: () => {
 					ui.panel.toggle("rail");
 				},
@@ -534,7 +533,7 @@ window.__ModuleLoader__.load({
 				element.focus();
 			} catch {}
 		}
-		/** Full detail is only opened from a loopback/local DSH UI surface. */
+		/** Full detail from whichever page the operator is on (the transport is authenticated). */
 		function UpdatePanel({ ui }) {
 			const panel = useObservable(ui.panel);
 			const preferences = useObservable(ui.preferences);
@@ -542,7 +541,7 @@ window.__ModuleLoader__.load({
 			const commandRef = React.useRef(null);
 			const dialogRef = React.useRef(null);
 			const [copyMessage, setCopyMessage] = React.useState(null);
-			const visible = panel.open && preferences.sidebarEnabled && ui.canManage;
+			const visible = panel.open && preferences.sidebarEnabled;
 			React.useLayoutEffect(() => {
 				if (!visible) return void 0;
 				const dialog = dialogRef.current;
@@ -861,7 +860,7 @@ window.__ModuleLoader__.load({
 								className: "dus-settings-hint",
 								children: t("preview.follow")
 							}),
-							ui.canManage && /* @__PURE__ */ (0, react_jsx_runtime.jsx)("button", {
+							/* @__PURE__ */ (0, react_jsx_runtime.jsx)("button", {
 								className: "dus-action",
 								type: "button",
 								"aria-expanded": showGuidance,
@@ -870,7 +869,7 @@ window.__ModuleLoader__.load({
 								},
 								children: t(showGuidance ? "preview.close" : "preview.open")
 							}),
-							ui.canManage && showGuidance && /* @__PURE__ */ (0, react_jsx_runtime.jsxs)("section", {
+							showGuidance && /* @__PURE__ */ (0, react_jsx_runtime.jsxs)("section", {
 								"aria-label": t("preview.open"),
 								children: [
 									/* @__PURE__ */ (0, react_jsx_runtime.jsx)("p", {
@@ -986,40 +985,12 @@ window.__ModuleLoader__.load({
 		};
 		var StatusStore = class {
 			connection;
-			snapshot;
-			allowRequests;
+			snapshot = INITIAL_STATUS;
 			listeners = /* @__PURE__ */ new Set();
 			inFlight;
 			stopped = false;
-			constructor(connection, staticVersion = null) {
+			constructor(connection) {
 				this.connection = connection;
-				this.allowRequests = staticVersion === null;
-				this.snapshot = staticVersion === null ? INITIAL_STATUS : {
-					status: {
-						currentVersion: staticVersion,
-						latestVersion: null,
-						hasUpdate: false,
-						cached: true,
-						checkedAt: null,
-						warning: null,
-						installKind: "unknown",
-						upgradeCommand: "",
-						releaseUrl: "",
-						changelogUrl: "",
-						publishedAt: null,
-						packageName: "@deepseek-ai/dsh",
-						channel: "latest",
-						channels: RELEASE_CHANNELS.map((channel) => ({
-							channel,
-							version: null,
-							publishedAt: null,
-							compatibility: "unverified"
-						})),
-						canApplyInPlace: false
-					},
-					loading: false,
-					error: null
-				};
 			}
 			getSnapshot = () => this.snapshot;
 			subscribe = (listener) => {
@@ -1030,15 +1001,14 @@ window.__ModuleLoader__.load({
 			};
 			/** First mount reads the Host's cached status; it never starts a browser timer. */
 			async load(cacheTtlMinutes = 360) {
-				if (this.allowRequests) await this.request(false, this.snapshot.status?.channel ?? "latest", cacheTtlMinutes);
+				await this.request(false, this.snapshot.status?.channel ?? "latest", cacheTtlMinutes);
 			}
 			/** User gesture only: force the Host to bypass TTL (while retaining single-flight). */
 			async refresh(channel = this.snapshot.status?.channel ?? "latest", cacheTtlMinutes = 360) {
-				if (this.allowRequests) await this.request(true, channel, cacheTtlMinutes);
+				await this.request(true, channel, cacheTtlMinutes);
 			}
 			/** Channel selection re-projects the Host cache; it is not a forced refresh. */
 			async selectChannel(channel, cacheTtlMinutes = 360) {
-				if (!this.allowRequests) return;
 				for (let attempts = 0; attempts < 3 && !this.stopped && this.snapshot.status?.channel !== channel; attempts += 1) {
 					const pending = this.inFlight;
 					if (pending !== void 0 && !await pending) return;
@@ -1237,6 +1207,355 @@ window.__ModuleLoader__.load({
 		/** The one namespace name used by Host registration and browser binding. */
 		const SETTINGS_NAMESPACE = PLUGIN_ID$1;
 		//#endregion
+		//#region src/client/settings/scopeFaces.ts
+		/** Guard: does an object look like a binder with bind()? */
+		function binderOf(raw) {
+			if (raw === null || typeof raw !== "object") return void 0;
+			const binder = raw.settingsScope;
+			if (binder === null || typeof binder !== "object") return void 0;
+			if (typeof binder.bind !== "function") return void 0;
+			return binder;
+		}
+		/** Guard: does an object look like a bound scope? */
+		function scopeOf(value) {
+			if (value === null || typeof value !== "object") return void 0;
+			const scope = value;
+			if (typeof scope.getSnapshot !== "function") return void 0;
+			if (typeof scope.subscribe !== "function") return void 0;
+			if (typeof scope.set !== "function") return void 0;
+			return scope;
+		}
+		//#endregion
+		//#region src/client/settings/hostDirectScope.ts
+		/** A refused namespace write; `code` keeps the Host's own diagnosis. */
+		var SettingsWriteFailure = class extends Error {
+			code;
+			constructor(code, message) {
+				super(message === void 0 || message === "" ? code : message);
+				this.name = "SettingsWriteFailure";
+				this.code = code;
+			}
+		};
+		function isRecord(value) {
+			return typeof value === "object" && value !== null;
+		}
+		/**
+		* Guard: does this value look like the `remote.settings` namespace face?
+		* Applied to a bare service object (`ctx.get('remote.settings')` or a payload
+		* member), and it never calls anything.
+		*/
+		function settingsRemoteFace(value) {
+			if (!isRecord(value)) return void 0;
+			if (typeof value.describe !== "function" || typeof value.mutate !== "function") return void 0;
+			return value;
+		}
+		/**
+		* Guard: read the `remote.settings` face off an injection payload.
+		*
+		* The payload a `ctx.inject(['remote.settings'], …)` callback receives exposes
+		* the LITERAL service key. Reading the dotted PARENT off that injected context
+		* (`payload.remote`) throws `cannot get property "remote" without inject` — a
+		* throw that used to abort a whole wiring callback on a LAN page. So the literal
+		* key is read FIRST and every read is contained; the nested
+		* (`payload.remote.settings`) shape is only a fallback for a plain object
+		* payload. Both absence and refusal answer `undefined`.
+		*/
+		function settingsRemoteOf(raw) {
+			if (!isRecord(raw)) return void 0;
+			try {
+				const direct = settingsRemoteFace(raw["remote.settings"]);
+				if (direct !== void 0) return direct;
+			} catch {}
+			try {
+				const remote = raw.remote;
+				if (isRecord(remote)) return settingsRemoteFace(remote.settings);
+			} catch {}
+		}
+		/**
+		* Guard: subscribe to the Host's settings-document invalidation on the Remote
+		* service object (`remote.$on`). Returns undefined when the service exposes no
+		* event seam — the preferences then refresh on reconnect only.
+		*/
+		function settingsInvalidationsOf(service) {
+			if (!isRecord(service)) return void 0;
+			const on = service.$on;
+			if (typeof on !== "function") return void 0;
+			return (listener) => {
+				const dispose = on.call(service, "settings/document-updated", listener);
+				return typeof dispose === "function" ? dispose : () => {};
+			};
+		}
+		function cloneOps(ops) {
+			try {
+				return structuredClone(ops);
+			} catch {
+				return ops.map((op) => op.op === "set" ? {
+					op: "set",
+					path: [...op.path],
+					value: op.value
+				} : {
+					op: "unset",
+					path: [...op.path]
+				});
+			}
+		}
+		function messageOf(error) {
+			return error instanceof Error ? error.message : String(error);
+		}
+		function sameSnapshot$1(a, b) {
+			return a.status === b.status && a.revision === b.revision && a.writable === b.writable && a.mode === b.mode && a.value === b.value && a.base === b.base && a.user === b.user;
+		}
+		function readySnapshot(row, writable) {
+			return {
+				status: "ready",
+				value: row.value,
+				base: row.base,
+				user: row.user,
+				revision: row.revision,
+				writable,
+				mode: "host"
+			};
+		}
+		function unavailableSnapshot(writable) {
+			return {
+				status: "unavailable",
+				value: void 0,
+				base: void 0,
+				user: void 0,
+				revision: void 0,
+				writable,
+				mode: "host"
+			};
+		}
+		/**
+		* Build the direct Host settings scope for one namespace.
+		*
+		* Snapshot semantics mirror the official per-namespace derivation: a namespace
+		* row answers `ready` with the resolved section, its `base`/`user` layers and its
+		* revision fence, and the document's `writable` decides editability. A row the
+		* Host does not serve answers `unavailable`; a refused read keeps the last
+		* confirmed document and reports `unavailable` only while it has never held one.
+		*
+		* Writes are serialized in issue order, fenced by the latest known revision and
+		* REJECT with {@link SettingsWriteFailure} on a Host refusal — that rejection is
+		* what makes the settings page surface a conflict instead of pretending the edit
+		* landed (the official scope resolves on `!ok` after its recovery read).
+		*
+		* @param remote - the `remote.settings` face of the page's Remote service.
+		* @param namespace - the settings namespace this scope derives from.
+		* @returns the scope plus its load/dispose seams.
+		*/
+		function createHostDirectScope(remote, namespace) {
+			let snapshot = {
+				status: "loading",
+				value: void 0,
+				base: void 0,
+				user: void 0,
+				revision: void 0,
+				writable: false,
+				mode: "host"
+			};
+			let held;
+			let error;
+			let disposed = false;
+			let tail = Promise.resolve();
+			const listeners = /* @__PURE__ */ new Set();
+			const publish = (next) => {
+				if (disposed || sameSnapshot$1(next, snapshot)) return;
+				snapshot = next;
+				for (const listener of [...listeners]) try {
+					listener();
+				} catch {}
+			};
+			const adopt = (next) => {
+				if (next.status === "ready") held = next;
+				publish(next);
+			};
+			async function load() {
+				if (disposed) return;
+				let outcome;
+				try {
+					outcome = await remote.describe();
+				} catch (caught) {
+					outcome = {
+						ok: false,
+						error: { message: messageOf(caught) }
+					};
+				}
+				if (disposed) return;
+				if (!outcome.ok) {
+					error = outcome.error?.message ?? outcome.error?.code ?? "settings/describe-failed";
+					publish(held ?? unavailableSnapshot(snapshot.writable));
+					return;
+				}
+				error = void 0;
+				const view = outcome.value;
+				const writable = view.writable === true;
+				const row = Array.isArray(view.namespaces) ? view.namespaces.find((candidate) => candidate.ns === namespace) : void 0;
+				if (row === void 0 || typeof row.revision !== "number") {
+					publish(unavailableSnapshot(writable));
+					return;
+				}
+				adopt(readySnapshot(row, writable));
+			}
+			/** Fold one write answer's namespace row in without a second wire read. */
+			function fold(row, writable) {
+				if (typeof row.revision !== "number") return;
+				adopt(readySnapshot(row, writable));
+			}
+			function mutate(ops, expectedRevision) {
+				const owned = cloneOps(ops);
+				const run = tail.then(async () => {
+					if (disposed) throw new SettingsWriteFailure("settings/unavailable");
+					const revision = expectedRevision ?? snapshot.revision;
+					let outcome;
+					try {
+						outcome = revision === void 0 ? await remote.mutate(namespace, owned) : await remote.mutate(namespace, owned, revision);
+					} catch (caught) {
+						await load();
+						throw new SettingsWriteFailure("settings/unreachable", messageOf(caught));
+					}
+					if (outcome.ok) {
+						fold(outcome.value, true);
+						return;
+					}
+					await load();
+					throw new SettingsWriteFailure(outcome.error?.code ?? "settings/unknown", outcome.error?.message);
+				});
+				tail = run.then(() => void 0, () => void 0);
+				return run;
+			}
+			return {
+				getSnapshot: () => snapshot,
+				subscribe(listener) {
+					listeners.add(listener);
+					return () => {
+						listeners.delete(listener);
+					};
+				},
+				set: (field, value) => mutate([{
+					op: "set",
+					path: [field],
+					value
+				}]),
+				load,
+				dispose() {
+					disposed = true;
+					listeners.clear();
+				},
+				lastError: () => error
+			};
+		}
+		//#endregion
+		//#region src/client/settings/settingsChannel.ts
+		/** Snapshot used while no channel has answered yet. */
+		const LOADING_SNAPSHOT = Object.freeze({
+			status: "loading",
+			value: void 0,
+			base: void 0,
+			user: void 0,
+			revision: void 0,
+			writable: false,
+			mode: "host"
+		});
+		function sameSnapshot(a, b) {
+			return a.status === b.status && a.revision === b.revision && a.writable === b.writable && a.mode === b.mode && a.value === b.value && a.base === b.base && a.user === b.user;
+		}
+		/** Ask a channel for its first/next read; a refusal surfaces as a snapshot, never a throw. */
+		function loadSource(source) {
+			const loadable = source;
+			if (loadable === void 0 || typeof loadable.load !== "function") return Promise.resolve();
+			return Promise.resolve(loadable.load()).then(() => void 0, () => void 0);
+		}
+		function createSettingsChannel(options) {
+			let official;
+			let direct;
+			let active;
+			let snapshot = LOADING_SNAPSHOT;
+			let disposed = false;
+			const disposers = [];
+			const listeners = /* @__PURE__ */ new Set();
+			const notify = () => {
+				for (const listener of [...listeners]) try {
+					listener();
+				} catch {}
+			};
+			const publish = (next) => {
+				if (disposed || sameSnapshot(next, snapshot)) return;
+				snapshot = next;
+				notify();
+			};
+			const select = () => {
+				if (official !== void 0 && official.getSnapshot().status !== "unavailable") return official;
+				if (direct === void 0) {
+					try {
+						direct = options.openDirect();
+					} catch {
+						direct = void 0;
+					}
+					if (direct !== void 0) {
+						try {
+							disposers.push(direct.subscribe(() => {
+								if (active === direct) publish(direct.getSnapshot());
+							}));
+						} catch {}
+						loadSource(direct);
+					}
+				}
+				return direct ?? official;
+			};
+			const reselect = () => {
+				if (disposed) return;
+				const next = select();
+				if (next !== active) {
+					active = next;
+					publish(next?.getSnapshot() ?? LOADING_SNAPSHOT);
+					return;
+				}
+				publish(next?.getSnapshot() ?? LOADING_SNAPSHOT);
+			};
+			return {
+				getSnapshot: () => snapshot,
+				subscribe(listener) {
+					listeners.add(listener);
+					return () => {
+						listeners.delete(listener);
+					};
+				},
+				set(field, value) {
+					const source = active;
+					if (source === void 0) return Promise.reject(/* @__PURE__ */ new Error("dsh-update-status: settings channel is unavailable"));
+					return source.set(field, value);
+				},
+				setOfficial(scope) {
+					if (disposed) return;
+					official = scope;
+					if (scope !== void 0) try {
+						disposers.push(scope.subscribe(() => {
+							reselect();
+						}));
+					} catch {}
+					reselect();
+				},
+				refresh: reselect,
+				reload() {
+					if (active === void 0 || active === official) return;
+					loadSource(active);
+				},
+				dispose() {
+					disposed = true;
+					listeners.clear();
+					for (const dispose of disposers.splice(0)) try {
+						dispose();
+					} catch {}
+					const disposable = active;
+					if (disposable !== void 0 && typeof disposable.dispose === "function") try {
+						disposable.dispose();
+					} catch {}
+				}
+			};
+		}
+		//#endregion
 		//#region src/client/styles.ts
 		/** Plugin-owned CSS only; no shell DOM selection or official SVG manipulation. */
 		const UPDATE_STATUS_CSS = `
@@ -1338,48 +1657,87 @@ window.__ModuleLoader__.load({
 			}
 		}
 		function apply(ctx) {
-			const connection = connectionOf(ctx);
-			const canManage = connection.isLoopback === true;
-			const status = new StatusStore(connection, canManage ? null : STATIC_COMPATIBLE_VERSION);
+			const status = new StatusStore(connectionOf(ctx));
 			const preferences = new PreferencesStore();
 			const ui = {
 				status,
 				preferences,
-				panel: new PanelStore(),
-				canManage
+				panel: new PanelStore()
 			};
+			const disposers = [];
+			let stopped = false;
+			/** Own a subscription raised from an injection callback; release after teardown at once. */
+			const own = (dispose) => {
+				if (typeof dispose !== "function") return;
+				if (stopped) {
+					try {
+						dispose();
+					} catch {}
+					return;
+				}
+				disposers.push(dispose);
+			};
+			let remoteSettings;
+			/** Resolve the direct channel's Remote face; `ctx.get` covers a payload we could not read. */
+			const directRemote = () => {
+				if (remoteSettings !== void 0) return remoteSettings;
+				try {
+					remoteSettings = settingsRemoteFace(ctx.get("remote.settings"));
+				} catch {}
+				return remoteSettings;
+			};
+			const channel = createSettingsChannel({ openDirect: () => {
+				const remote = directRemote();
+				return remote === void 0 ? void 0 : createHostDirectScope(remote, SETTINGS_NAMESPACE);
+			} });
 			ctx.effect(() => {
 				const disposeStyles = installStyles();
-				if (canManage) status.load(preferences.getSnapshot().cacheTtlMinutes);
+				const detach = preferences.attach(channel);
+				let selected = status.getSnapshot().status?.channel ?? "latest";
+				const syncPreferences = () => {
+					const next = preferences.getSnapshot();
+					if (next.channel !== selected) {
+						selected = next.channel;
+						status.selectChannel(selected, next.cacheTtlMinutes);
+					}
+				};
+				syncPreferences();
+				const unsubscribe = preferences.subscribe(syncPreferences);
+				status.load(preferences.getSnapshot().cacheTtlMinutes);
 				return () => {
+					stopped = true;
+					unsubscribe();
+					detach();
+					for (const dispose of disposers.splice(0)) try {
+						dispose();
+					} catch {}
+					channel.dispose();
 					status.stop();
 					disposeStyles();
 				};
-			}, "dsh-update-status: style and first status read");
-			ctx.inject(["settingsScope"], (raw) => {
-				const binder = raw.settingsScope;
-				if (binder === null || typeof binder !== "object" || typeof binder.bind !== "function") return;
-				try {
-					const scope = binder.bind({ namespace: SETTINGS_NAMESPACE });
-					ctx.effect(() => {
-						const detach = preferences.attach(scope);
-						let selected = status.getSnapshot().status?.channel ?? "latest";
-						const syncPreferences = () => {
-							const next = preferences.getSnapshot();
-							if (next.channel !== selected) {
-								selected = next.channel;
-								status.selectChannel(selected, next.cacheTtlMinutes);
-							}
-						};
-						syncPreferences();
-						const unsubscribe = preferences.subscribe(syncPreferences);
-						return () => {
-							unsubscribe();
-							detach();
-						};
-					}, "dsh-update-status: sidebar and channel preferences");
-				} catch {}
-			});
+			}, "dsh-update-status: styles, settings channel and first status read");
+			try {
+				ctx.inject(["settingsScope"], (raw) => {
+					try {
+						const binder = binderOf(raw);
+						if (binder === void 0) return;
+						channel.setOfficial(scopeOf(binder.bind({ namespace: SETTINGS_NAMESPACE })));
+					} catch {}
+				});
+			} catch {}
+			try {
+				ctx.inject(["remote.settings"], (raw) => {
+					try {
+						remoteSettings = settingsRemoteOf(raw) ?? remoteSettings;
+						channel.refresh();
+						const invalidations = settingsInvalidationsOf(ctx.get("remote"));
+						if (invalidations !== void 0) own(invalidations(() => channel.reload()));
+					} catch {}
+				});
+			} catch {}
+			if (typeof ctx.on === "function") try {
+				own(ctx.on("connection/reset", () => channel.reload()));
+			} catch {}
 			ctx.slots.inject("sidebar.brand.name", () => ctx.slots.register({
 				name: "sidebar.brand.name",
 				priority: -10