dsh-git-badge 0.10.1 → 0.12.0

package/CHANGELOG.md

@@ -10,6 +10,38 @@ npm. 0.6.0 is the first release recorded here.
 
 ## [Unreleased]
 
+## [0.12.0] - 2026-09-15
+
+### Removed
+
+- **The restart notice and one-click Restart button are gone from the input
+  chip.** The inline text — *restart dsh web to activate the sidebar badges* —
+  and its Restart button (`POST /dsh-market/api/v1/restart`) could outlive the
+  restart it asked for when the marker survived a boot, and the nag outweighed
+  the convenience. The restart-pending marker pipeline is intact server-side
+  (`seam/store.js`, `seamRestartPending` on the status response) for a future
+  marketplace-surface notification; the chip simply no longer renders it.
+
+## [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

@@ -785,7 +785,7 @@ window.__ModuleLoader__.load({
 									onFocus: () => setLinkHover(true),
 									onBlur: () => setLinkHover(false),
 									children: prToken
-								})
+								}),
 				]
 			});
 			// 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.12.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.
+	}
+}