dsh-git-badge 0.10.1 → 0.11.0

package/CHANGELOG.md

@@ -10,6 +10,26 @@ npm. 0.6.0 is the first release recorded here.
 
 ## [Unreleased]
 
+## [0.11.0] - 2026-09-14
+
+### Added
+
+- **A one-click restart for the change the marketplace cannot see.** The
+  postinstall/apply patches DSH's own files, which is invisible to dshmarket's
+  restart bookkeeping — a market install could complete "restart-free" while
+  the running bundles no longer matched the disk. Now: the installer writes a
+  `restart-pending` marker (`seam/store.js`); the plugin's status response
+  carries it; and while it is pending the input chip shows a one-line
+  explanation — *the installer patched DSH, client bundles are composed at
+  boot* — plus a **Restart** button calling dshmarket's PUBLIC, documented v1
+  restart endpoint (`POST /dsh-market/api/v1/restart`, feature-detected via
+  `capabilities`; hosts that delegate restart — desktop/supervised — get the
+  manual instruction instead, never a hand-rolled process-control path). The
+  button polls until the host is serving again, then reloads into the
+  recomposed boot. The marker is cleared by the node half at the next boot, so
+  it self-expires exactly when the restart it asks for has happened. Applies
+  to `revert` too — removing the patch equally needs a restart to take effect.
+
 ## [0.10.1] - 2026-09-14
 
 ### Fixed

package/lib/client.js

@@ -703,6 +703,48 @@ window.__ModuleLoader__.load({
 		 */
 		let seamHint = null;
 
+		/**
+		 * The restart affordance for a seam change made while the host was
+		 * running. dshmarket cannot see host-file mutations (its restart banner
+		 * tracks only its own package bookkeeping), so the flag this reads is
+		 * written by our own postinstall/apply — see seam/store.js. The Restart
+		 * button calls dshmarket's PUBLIC, documented v1 restart endpoint
+		 * (UPDATE-API-V1.md): feature-detected via capabilities, same-origin, and
+		 * rendered as text-only on hosts that delegate restart (desktop /
+		 * supervised), never a hand-rolled process-control path.
+		 */
+		async function marketRestartSupported() {
+			try {
+				const cap = await fetch("/dsh-market/api/v1/capabilities", { headers: { accept: "application/json" } }).then((r) => r.json());
+				return cap !== null && typeof cap === "object" && cap.restart !== void 0 && cap.restart.supported === true;
+			} catch {
+				return false;
+			}
+		}
+
+		async function marketRestart() {
+			await fetch("/dsh-market/api/v1/restart", {
+				method: "POST",
+				headers: { accept: "application/json", "content-type": "application/json" },
+				body: "{}",
+			}).catch(() => void 0); // the host drops the socket mid-restart — expected
+			// Poll until the origin is serving again, then reload into the
+			// recomposed boot. Bounded so a failed relaunch cannot spin forever.
+			for (let waited = 0; waited < 30000; waited += 500) {
+				await new Promise((r) => setTimeout(r, 500));
+				try {
+					const cap = await fetch("/dsh-market/api/v1/capabilities", { headers: { accept: "application/json" } });
+					if (cap.ok) {
+						location.reload();
+						return;
+					}
+				} catch {
+					// host down mid-restart — expected; keep polling
+				}
+			}
+			location.reload();
+		}
+
 		function ComposerGitChip({ sessionId }) {
 			const target = sessionId === void 0 ? void 0 : { kind: "session", id: sessionId };
 			// the PR/CI token is always on the chip, so its fetch is not gated
@@ -715,7 +757,29 @@ window.__ModuleLoader__.load({
 			// the PR token's own hover/focus state: it underlines on hover (and on
 			// focus) rather than at rest, and that underline is applied inline below
 			const [linkHover, setLinkHover] = react.useState(false);
+			// The restart affordance: idle → checking (capabilities) → restarting.
+			// One status refresh carries seamRestartPending at a time; when the
+			// restart lands, the marker is cleared at the new boot and this reverts.
+			const [restarting, setRestarting] = react.useState(false);
+			const [canRestart, setCanRestart] = react.useState(null); // null = not yet checked
 			const detail = useGitStatus(target, { pr: true, detail: true, enabled: hovered });
+			const restartPending = info !== void 0 && info.git === true && info.seamRestartPending !== void 0;
+			react.useEffect(() => {
+				if (!restartPending || canRestart !== null) return;
+				let cancelled = false;
+				marketRestartSupported().then((v) => {
+					if (!cancelled) setCanRestart(v);
+				});
+				return () => {
+					cancelled = true;
+				};
+			}, [restartPending, canRestart]);
+			async function restartNow() {
+				setRestarting(true);
+				if (await marketRestartSupported()) await marketRestart();
+				// Unsupported host: the text stays and says restart dsh web manually.
+				else setRestarting(false);
+			}
 			if (info === void 0 || info.git !== true) return null;
 			// the mark is an element now rather than a leading glyph in the string, so
 			// the SAME StatusMark the sidebar row draws carries the status here too;
@@ -723,6 +787,63 @@ window.__ModuleLoader__.load({
 			const text = info.branch + formatOperationToken(info) + formatGitSuffix(info);
 			const prToken = formatPrToken(info);
 			const prUrl = prLinkUrl(info);
+			// One-line explanation + one-click restart, ONLY while a restart is
+			// actually pending. The button exists because dshmarket's own banner
+			// cannot see the host-file change our installer made; the endpoint is
+			// its documented public API. On hosts that delegate restart (desktop,
+			// supervisors) canRestart is false and the text names the manual step.
+			const restartNotice =
+				!restartPending || restarting
+					? null
+					: react_jsx_runtime.jsxs(
+							"span",
+							{
+								style: {
+									display: "inline-flex",
+									alignItems: "center",
+									gap: "6px",
+									paddingLeft: "6px",
+									borderLeft: "1px solid var(--dsw-alias-border-secondary, #d0d7de)",
+									whiteSpace: "normal",
+									maxWidth: "320px"
+								},
+								children: [
+									react_jsx_runtime.jsx(
+										"span",
+										{
+											title: "The installer applied dsh-git-badge's sidebar patch to DSH's own files; client bundles are composed at boot, so a restart is needed for it to take effect. Revert anytime with `npx dsh-git-badge revert`.",
+											children:
+												canRestart === false
+													? "restart dsh web to activate the sidebar badges (one-click restart is unavailable on this host)"
+													: "installer patched DSH — restart to activate the sidebar badges"
+										},
+										"explain"
+									),
+									canRestart === true
+										? react_jsx_runtime.jsx(
+												"button",
+												{
+													onClick: () => void restartNow(),
+													style: {
+														cursor: "pointer",
+														color: "inherit",
+														background: "none",
+														border: "1px solid var(--dsw-alias-border-secondary, #d0d7de)",
+														borderRadius: "4px",
+														fontSize: "11px",
+														lineHeight: "18px",
+														padding: "0 6px",
+														flex: "none"
+													},
+													children: "Restart"
+												},
+												"btn"
+											)
+										: null
+								]
+							},
+							"restart"
+						);
 			const chip = react_jsx_runtime.jsxs("span", {
 				style: {
 					display: "inline-flex",
@@ -785,7 +906,8 @@ window.__ModuleLoader__.load({
 									onFocus: () => setLinkHover(true),
 									onBlur: () => setLinkHover(false),
 									children: prToken
-								})
+								}),
+					restartNotice
 				]
 			});
 			// No Tooltip primitive (a shell that does not seed it): render the chip

package/lib/index.js

@@ -69,6 +69,7 @@
 import { execFile } from "node:child_process";
 import { watch, existsSync, readFileSync } from "node:fs";
 import { basename, isAbsolute, join, resolve } from "node:path";
+import { clearRestartMarker, readRestartMarker } from "../seam/store.js";
 
 const inject = ["webServer", "workspaceRegistry"];
 const name = "dsh-git-badge";
@@ -1218,6 +1219,11 @@ async function effectiveTarget(target, bySession, wantPr, notify) {
 
 /** Host plugin body — register the status route and the SSE change feed. */
 function apply(ctx) {
+	// A fresh boot composed the files on disk into the new bundles — any
+	// restart-pending marker was written by an install/apply against the PREVIOUS
+	// boot and its change is now live. Clearing here is what makes the marker
+	// self-expiring: it survives exactly until the restart it asks for happens.
+	clearRestartMarker();
 	ctx.effect(() => ctx.webServer.register({
 		kind: "exact",
 		path: "/api/git-badge",
@@ -1230,6 +1236,7 @@ function apply(ctx) {
 					res.end(JSON.stringify({ git: false, error: target.error }));
 					return;
 				}
+				const pending = readRestartMarker();
 				const detail = url.searchParams.get("detail") === "1";
 				const pr = url.searchParams.get("pr") === "1";
 				// WHO asked decides whether a linked worktree may stand in for the
@@ -1268,6 +1275,12 @@ function apply(ctx) {
 				// tell whether an event belongs to it — without this the input chip
 				// only ever refreshed on remount or the 60s poll.
 				res.writeHead(200, { "content-type": "application/json" });
+				if (pending !== null) {
+					// dshmarket cannot see postinstall/apply host-file changes; this
+					// flag is how the running UI learns a restart is pending and
+					// offers its own Restart button (dshmarket v1 restart endpoint).
+					body.seamRestartPending = { by: pending.by, at: pending.at };
+				}
 				res.end(JSON.stringify(body));
 			} catch (error) {
 				res.writeHead(400, { "content-type": "application/json" });

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "dsh-git-badge",
-  "version": "0.10.1",
+  "version": "0.11.0",
   "description": "Git status badges for DeepSeek Harness: an input-row chip on every install, plus sidebar session-row badges (git status, PR/CI action tokens) after one manual step: `npx dsh-git-badge apply`, then restart dsh web. Event-driven freshness over SSE.",
   "type": "module",
   "main": "lib/index.js",
@@ -52,6 +52,7 @@
     "seam/apply.js",
     "seam/anchors.js",
     "seam/postinstall.js",
+    "seam/store.js",
     "seam/stub-index.js",
     "cordis.patch.yml",
     "package.json",

package/seam/apply.js

@@ -55,18 +55,16 @@ import {
 	seamPresent,
 } from "./anchors.js";
 
+import { dataDir, writeRestartMarker } from "./store.js";
+
 const HERE = dirname(fileURLToPath(import.meta.url));
 /**
- * Where revert backups live. A STABLE, user-level directory by default — NOT
- * this script's own directory. For an npx run that directory is a cache entry
- * keyed by package version: a backup written by one `npx dsh-git-badge apply`
- * was invisible to the next `npx dsh-git-badge revert`, which then had to
- * refuse ("patched but no backup exists") even though the bytes were on disk
- * somewhere. Sharing one store across npx runs, the profile bin and the repo
- * wrapper makes the apply→revert round trip reliable for everyone. Override
- * with SEAM_DATA_DIR (the test suite does, to stay hermetic).
+ * The stable backup store — shared with the postinstall hook and any future
+ * invocation path, so an apply→revert round trip works across npx cache
+ * entries. SEAM_DATA_DIR overrides (the test suite does, to stay hermetic).
+ * See seam/store.js for the full rationale and the restart marker.
  */
-const DATA_DIR = process.env.SEAM_DATA_DIR || join(process.env.DSH_HOME || join(process.env.HOME || "", ".dsh"), "git-badge-seam");
+const DATA_DIR = dataDir();
 
 // sha256 of the upstream build the anchors were last verified against. ADVISORY:
 // status prints it for orientation; apply does NOT require it.
@@ -156,6 +154,9 @@ function doPatch() {
 	writeText(CLIENT, patched);
 	copyFileSync(STUB_INDEX, INDEX);
 	console.log("patched lib/client.js in place (anchors applied); host half stubbed.");
+	// dshmarket cannot see this host-file change; the plugin surfaces the
+	// restart itself (marker → status response → chip button).
+	writeRestartMarker("apply");
 }
 
 function writeText(path, text) {
@@ -291,6 +292,8 @@ if (verb === "apply") {
 			writeText(CLIENT, readText(BACKUP_CLIENT));
 			copyFileSync(BACKUP_INDEX, INDEX);
 			console.log("reverted client.js/index.js to the bytes as found before patching.");
+			// A revert also changes bytes the running bundles were composed from.
+			writeRestartMarker("revert");
 		} else {
 			// Installed file is not ours => upstream replaced it since patching.
 			console.error("REFUSING to revert: the installed client.js is not this repo's");

package/seam/postinstall.js

@@ -26,15 +26,10 @@ import { copyFileSync, existsSync, mkdirSync, readFileSync, writeFileSync } from
 import { dirname, join } from "node:path";
 import { fileURLToPath } from "node:url";
 import { applyPatch, firstFailure, isOurs, seamPresent } from "./anchors.js";
+import { dataDir, writeRestartMarker } from "./store.js";
 
 const HERE = dirname(fileURLToPath(import.meta.url));
 const HINT = "Sidebar session-row badges need one manual step: `npx dsh-git-badge apply`, then restart dsh web.";
-/**
- * Same stable backup store apply.js defaults to — the backup this hook takes
- * must be findable by a LATER `npx dsh-git-badge revert` running from a
- * different cache entry. SEAM_DATA_DIR overrides (test suite).
- */
-const DATA_DIR = process.env.SEAM_DATA_DIR || join(process.env.DSH_HOME || join(process.env.HOME || "", ".dsh"), "git-badge-seam");
 
 function dshClientPath() {
 	try {
@@ -74,12 +69,16 @@ function main() {
 		return;
 	}
 	// The one state we act on: pristine upstream, anchors resolve.
-	mkdirSync(DATA_DIR, { recursive: true });
-	copyFileSync(client, join(DATA_DIR, "backup-client.js"));
-	copyFileSync(index, join(DATA_DIR, "backup-index.js"));
+	mkdirSync(dataDir(), { recursive: true });
+	copyFileSync(client, join(dataDir(), "backup-client.js"));
+	copyFileSync(index, join(dataDir(), "backup-index.js"));
 	writeFileSync(client, applyPatch(text));
 	copyFileSync(join(HERE, "stub-index.js"), index);
 	console.log("[dsh-git-badge] seam applied — RESTART dsh web to get sidebar session-row badges.");
+	// Tell the running UI: dshmarket cannot see this host-file change, so the
+	// plugin offers the Restart button itself (marker → status response → chip).
+	// Read/cleared by the plugin halves — see seam/store.js.
+	writeRestartMarker("postinstall");
 }
 
 try {

package/seam/store.js

@@ -0,0 +1,71 @@
+/**
+ * The restart-pending marker — the bridge from install-time (node side) to the
+ * running UI.
+ *
+ * WHY IT EXISTS: dshmarket's pending-restart banner tracks its own package
+ * bookkeeping. A postinstall that patches the DSH HOST package
+ * (dsh-client-ui-workspace) mutates files outside that bookkeeping, so the
+ * market can complete "restart-free" while the host's composed client bundles
+ * no longer match the files on disk. The marker is the out-of-band signal:
+ *
+ *   postinstall / apply / revert  → write the marker (seam changed on disk)
+ *   plugin node half, at boot     → clear the marker (fresh boot composed the
+ *                                   new bytes; the change is live)
+ *   plugin client half            → while the marker is served on the status
+ *                                   response, offer a Restart button calling
+ *                                   dshmarket's public v1 restart endpoint
+ *
+ * The hot-mount path is what makes this work on a FIRST market install: the
+ * freshly installed plugin's client half mounts into the running shell, reads
+ * the marker through the status response, and can restart the host — even
+ * though the process that installed the patch is gone.
+ */
+
+import { existsSync, mkdirSync, readFileSync, rmSync, writeFileSync } from "node:fs";
+import { join } from "node:path";
+
+/** The stable backup store — same default apply.js uses; SEAM_DATA_DIR overrides. */
+export function dataDir() {
+	if (process.env.SEAM_DATA_DIR) return process.env.SEAM_DATA_DIR;
+	return join(process.env.DSH_HOME || join(process.env.HOME || "", ".dsh"), "git-badge-seam");
+}
+
+function markerPath() {
+	return join(dataDir(), "restart-pending.json");
+}
+
+/**
+ * Record that DSH files were changed on disk and a restart is needed to
+ * compose them. `reason` is a one-word actor (postinstall | apply | revert).
+ */
+export function writeRestartMarker(reason) {
+	try {
+		mkdirSync(dataDir(), { recursive: true });
+		writeFileSync(
+			markerPath(),
+			JSON.stringify({ schema: "dsh-git-badge/restart-pending/v1", by: reason, at: new Date().toISOString() }),
+			"utf8",
+		);
+	} catch {
+		// The marker is a UX nicety; never fail the operation that earned it.
+	}
+}
+
+/** The pending marker, or null. Never throws. */
+export function readRestartMarker() {
+	try {
+		if (!existsSync(markerPath())) return null;
+		return JSON.parse(readFileSync(markerPath(), "utf8"));
+	} catch {
+		return null;
+	}
+}
+
+/** The change is live — a new boot composed it. Clear the pending state. */
+export function clearRestartMarker() {
+	try {
+		rmSync(markerPath(), { force: true });
+	} catch {
+		// Absent is the goal; any error leaves the marker to be cleared later.
+	}
+}