dsh-builtin-browser 0.4.1 → 0.4.5

package/desktop-bridge/install.mjs

@@ -106,11 +106,31 @@ ${MARKER} pages.
 // Installed by apps/desktop/bridge/install.mjs — re-run it after a desktop upgrade.
 // A bridge failure is never fatal to the shell.
 app.whenReady().then(async () => {
+	const bridgeUrl = new URL("./plugin-browser-bridge.js", import.meta.url);
+	const loadBridge = async (why) => {
+		try {
+			// A plain import is cached for the process lifetime, so an edited bridge
+			// would need a shell restart. The stamp makes every load read the current
+			// bytes; start() itself stops the previous instance, so this reloads in place.
+			const bridge = await import(bridgeUrl.href + "?v=" + Date.now());
+			bridge.start();
+			console.log("[dsh-browser-bridge] started" + (why ? " (" + why + ")" : ""));
+		} catch (error) {
+			console.error("[dsh-browser-bridge] start failed:", error);
+		}
+	};
+	await loadBridge();
+	// Watch the module so an edit reloads it in place instead of forcing a shell
+	// restart. Debounced; a failure here is never fatal to the shell.
 	try {
-		const bridge = await import("./plugin-browser-bridge.js");
-		bridge.start();
+		const { watch } = await import("node:fs");
+		let timer = null;
+		watch(bridgeUrl, { persistent: false }, () => {
+			if (timer) clearTimeout(timer);
+			timer = setTimeout(() => void loadBridge("file changed"), 300);
+		});
 	} catch (error) {
-		console.error("[dsh-browser-bridge] start failed:", error);
+		console.error("[dsh-browser-bridge] watch failed:", error);
 	}
 });
 `
@@ -273,9 +293,49 @@ if (revert) {
     reverted = true
   }
   if (existsSync(backupPath)) {
-    copyFileSync(backupPath, mainPath)
-    console.log(`restored ${mainPath} from ${backupPath}`)
-    reverted = true
+    // Refuse when the backup no longer matches the tree it would overwrite.
+    //
+    // The backup is taken once and then kept, so after a desktop upgrade it holds the PREVIOUS
+    // build's main.js. Restoring it would silently roll the app back to that build's code — and
+    // it would also discard any patch another tool applied in the meantime, which is not a
+    // hypothetical here: `dsh-purge` patches this same file, so a blind revert erases its work
+    // while reporting success. A matching current file is the only case where the restore is
+    // unambiguously right; anything else needs a human to decide.
+    let backedUp
+    let current
+    try {
+      backedUp = readFileSync(backupPath)
+      current = readFileSync(mainPath)
+    } catch {
+      backedUp = undefined
+      current = undefined
+    }
+    const identical = backedUp !== undefined && current !== undefined && backedUp.equals(current)
+    const stillHasOurMarker = current !== undefined && current.includes(MARKER)
+    // A backup taken BEFORE the file was patched by anything else is not a clean restore
+    // point: reverting to it discards those patches. The marker test alone does not catch
+    // this, because the current file legitimately carries our marker — that is exactly what
+    // this script put there — while the backup predates a patch by another tool.
+    // `dsh-purge` patches this same file, so on this machine that is not hypothetical.
+    const backupHasOurMarker = backedUp !== undefined && backedUp.includes(MARKER)
+    if (!identical && stillHasOurMarker && !backupHasOurMarker) {
+      console.error(`WARNING: ${backupPath} predates the bridge patch, so it is not a clean`)
+      console.error(`  restore point for ${mainPath}. Reverting would also discard anything`)
+      console.error('  patched in between (dsh-purge patches this same file). Refreshing the')
+      console.error('  backup from the current file instead, so a later --revert is safe.')
+      writeFileSync(backupPath, current ?? Buffer.alloc(0))
+      reverted = true
+    } else if (!identical && !stillHasOurMarker) {
+      console.error(`WARNING: ${mainPath} has changed since the backup was taken, and it does`)
+      console.error('  not contain the bridge import either — something else has edited it')
+      console.error('  (a desktop upgrade, or another patch tool). Restoring the backup would')
+      console.error(`  discard that. The backup is at ${backupPath}; restore it by hand if that`)
+      console.error('  is what you want. Skipping this file.')
+    } else {
+      copyFileSync(backupPath, mainPath)
+      console.log(`restored ${mainPath} from ${backupPath}`)
+      reverted = true
+    }
   }
   if (existsSync(cliShimBackup)) {
     copyFileSync(cliShimBackup, cliShimPath)