home-hosted 0.6.1 → 0.6.2

package/README.md

@@ -40,8 +40,9 @@ You run a handful of services at home. The usual choices are extremes — 🧟 `
 forget about, 📜 a hand-written systemd unit per service (times six), or 🐳 a whole docker/k8s
 stack??? - too extreme! — plus 😩 monitoring, rebooting and changing the host machine, yuck!
 
-🙂 home-hosted, well, joins in somewhere: a panel/supervisor that starts them, watches them, restarts what dies, and
-puts the whole stack on one page, with deep backup support.
+🙂✨ home-hosted enhances on top: a panel/supervisor that starts them, watches them, restarts what
+dies, and puts the whole stack on one page, with deep backup support — whether a server is a plain
+command or a `docker compose` stack.
 
 ```text
                    ┌──────────────────────────────────────┐
@@ -54,8 +55,13 @@ puts the whole stack on one page, with deep backup support.
    ┌─────────┐               ┌─────────┐                ┌─────────┐
    │ gateway │               │ files   │                │ bot     │
    │ :4000   │               │ :4010   │                │  ...    │
-   └─────────┘               └─────────┘                └─────────┘
-     health ✓                  health ✓                  restarts ↻
+   └────┬────┘               └─────────┘                └─────────┘
+        │ compose up -d
+        ▼
+   ┌────────────┬────────────┬────────────┐
+   │  gateway   │  postgres  │   redis    │          restarts ↻
+   └────────────┴────────────┴────────────┘
+     health ✓ (the published port is the probe)
 ```
 
 |  |  |
@@ -147,7 +153,7 @@ data/                         # per-server data directories, declared through da
 
 One clone, `pnpm install --frozen-lockfile`, `pnpm run up` — the setup is up on any machine with Node.
 Worked example, with per-server data inside the project:
-**[hhosted-9router-dsh](https://github.com/NamesMT/hhosted-9router-dsh)**.
+**[hhosted-ai-pack](https://github.com/NamesMT/hhosted-ai-pack)**.
 
 <sub>Call them as `pnpm run up` — `pnpm up` is pnpm's own update, not your script.</sub>
 
@@ -190,8 +196,8 @@ home-hosted set-token --generate
 #   hh_9uA2…                     (printed once; only its hash is kept, mode 0600)
 
 curl -H "Authorization: Bearer hh_9uA2…" http://127.0.0.1:3999/api/state
-curl -H "Authorization: Bearer hh_9uA2…" -X POST http://127.0.0.1:3999/api/servers/9router/restart
-curl -N -H "Authorization: Bearer hh_9uA2…" 'http://127.0.0.1:3999/api/events?serverId=9router'   # SSE
+curl -H "Authorization: Bearer hh_9uA2…" -X POST http://127.0.0.1:3999/api/servers/omniroute/restart
+curl -N -H "Authorization: Bearer hh_9uA2…" 'http://127.0.0.1:3999/api/events?serverId=omniroute'   # SSE
 home-hosted status --json        # machine-readable: pid, url, health, paths
 ```
 
@@ -396,7 +402,7 @@ archive and restore. Definitions come back, data lands where *this* machine's co
 `autostart` entries come up immediately.
 
 It works because an archive carries its own `servers.config.json` and paths are matched by the
-**declaration** (`9router:DATA_DIR`), not by an absolute path from the source machine. A restore never
+**declaration** (`omniroute:DATA_DIR`), not by an absolute path from the source machine. A restore never
 writes where no config declares.
 
 </details>

package/dist/cli.js

@@ -6821,7 +6821,7 @@ var init_config_watch = __esmMin((() => {
 			if (this.disposed || this.watcher !== null) return;
 			try {
 				this.watcher = fs.watch(path.dirname(this.options.file), (_event, filename) => {
-					if (filename !== null && filename !== path.basename(this.options.file)) return;
+					if (filename !== null && path.basename(filename) !== path.basename(this.options.file)) return;
 					this.schedule();
 				});
 				this.watcher.on("error", (error) => {
@@ -7785,6 +7785,104 @@ function isSafeUiEntry(entry) {
 	if (cleaned.length === 0) return false;
 	return cleaned.split("/").every((segment) => segment !== "" && segment !== "." && segment !== ".." && !segment.includes(":"));
 }
+function withInstallLock(dataRoot, run) {
+	const key = path.resolve(dataRoot);
+	const next = (installLocks.get(key) ?? Promise.resolve()).then(run, run);
+	installLocks.set(key, next.catch(() => {}));
+	return next;
+}
+/** Renames the staged tree into place, keeping the old one until that has certainly worked. */
+function commitSwap(dataRoot, resting, staged, meta) {
+	return withInstallLock(dataRoot, async () => {
+		try {
+			fs.renameSync(staged, resting);
+		} catch {
+			const previous = `${resting}.previous-${process.pid}-${Date.now()}`;
+			const hadPrevious = fs.existsSync(resting);
+			if (hadPrevious) fs.renameSync(resting, previous);
+			try {
+				fs.renameSync(staged, resting);
+			} catch (error) {
+				try {
+					fs.rmSync(resting, {
+						recursive: true,
+						force: true
+					});
+					if (hadPrevious && fs.existsSync(previous)) fs.renameSync(previous, resting);
+					fs.rmSync(previous, {
+						recursive: true,
+						force: true
+					});
+				} catch {
+					return {
+						ok: false,
+						error: `${describeError$1(error)} — the previous UI is kept at ${previous}`
+					};
+				}
+				return {
+					ok: false,
+					error: describeError$1(error)
+				};
+			}
+			fs.rmSync(previous, {
+				recursive: true,
+				force: true
+			});
+		}
+		sweepBackups(dataRoot, resting);
+		return {
+			ok: true,
+			meta
+		};
+	});
+}
+function sweepBackups(dataRoot, resting) {
+	const prefix = `${path.basename(resting)}.previous-`;
+	for (const entry of readDataRoot(dataRoot)) if (entry.startsWith(prefix)) fs.rmSync(path.join(dataRoot, entry), {
+		recursive: true,
+		force: true
+	});
+}
+/** The most recently abandoned UI tree, or null when there is not one. */
+function newestBackup(dataRoot, resting) {
+	const prefix = `${path.basename(resting)}.previous-`;
+	let best = null;
+	let bestStamp = -1;
+	for (const entry of readDataRoot(dataRoot)) {
+		if (!entry.startsWith(prefix)) continue;
+		const full = path.join(dataRoot, entry);
+		if (!fs.existsSync(path.join(full, "index.html"))) continue;
+		const stamp = Number(entry.slice(prefix.length).split("-").pop() ?? "");
+		if (Number.isFinite(stamp) && stamp > bestStamp) {
+			bestStamp = stamp;
+			best = full;
+		}
+	}
+	return best;
+}
+/** Dropped staging trees and superseded backups, once the live UI is whole. */
+function sweepJunk(dataRoot) {
+	let swept = 0;
+	for (const entry of readDataRoot(dataRoot)) {
+		if (!entry.startsWith(".ui-staging-") && !entry.startsWith(`.ui.previous-`)) continue;
+		fs.rmSync(path.join(dataRoot, entry), {
+			recursive: true,
+			force: true
+		});
+		swept += 1;
+	}
+	return swept;
+}
+function readDataRoot(dataRoot) {
+	try {
+		return fs.readdirSync(dataRoot);
+	} catch {
+		return [];
+	}
+}
+function describeError$1(error) {
+	return error instanceof Error ? error.message : String(error);
+}
 /**
 * Where the site actually starts: the archive root, or a single wrapper directory
 * (`zip -r ui.zip dist` is a common way to build one).
@@ -7812,7 +7910,7 @@ function countFiles(root) {
 	})) if (entry.isFile() && entry.name !== META) total += 1;
 	return Math.max(1, total);
 }
-var META, MAX_ENTRIES, MAX_BYTES, MAX_NAME, manifestSchema, UiService;
+var META, MAX_ENTRIES, MAX_BYTES, MAX_NAME, manifestSchema, UiService, installLocks;
 var init_ui = __esmMin((() => {
 	init_atomic();
 	init_archive();
@@ -7872,7 +7970,7 @@ var init_ui = __esmMin((() => {
 				ok: false,
 				error: "the upload is not a zip archive"
 			};
-			const staging = path.join(this.options.dataRoot, `.ui-staging-${Date.now()}`);
+			const staging = path.join(this.options.dataRoot, `.ui-staging-${process.pid}-${Date.now()}-${Math.random().toString(36).slice(2, 8)}`);
 			try {
 				return await this.stage(archivePath, staging, fallbackName, installedTag);
 			} catch (error) {
@@ -7941,43 +8039,38 @@ var init_ui = __esmMin((() => {
 				...manifest?.asset === void 0 ? {} : { asset: manifest.asset },
 				...manifest?.unix === void 0 ? {} : { unix: manifest.unix }
 			};
-			const previous = `${this.directory}.previous-${process.pid}-${Date.now()}`;
-			if (fs.existsSync(this.directory)) fs.renameSync(this.directory, previous);
-			try {
-				fs.renameSync(root, this.directory);
-				writeFileAtomic(path.join(this.directory, META), `${JSON.stringify(meta, null, 2)}\n`);
-			} catch (error) {
-				try {
-					fs.rmSync(this.directory, {
-						recursive: true,
-						force: true
-					});
-					if (fs.existsSync(previous)) fs.renameSync(previous, this.directory);
-					fs.rmSync(previous, {
+			writeFileAtomic(path.join(root, META), `${JSON.stringify(meta, null, 2)}\n`);
+			return commitSwap(this.options.dataRoot, this.directory, root, meta);
+		}
+		/**
+		* Puts a half-finished install back together, and is safe to call on every boot.
+		*
+		* An install that was interrupted between its two renames — a kill, a power cut, a
+		* crash — leaves `.ui` missing with the user's only copy sitting in a `.previous-*`
+		* sibling. Without this the panel would quietly serve the stock UI forever, because
+		* `custom` is false and nothing ever looked at the backup.
+		*/
+		recover() {
+			const resting = this.directory;
+			let restored = null;
+			if (!fs.existsSync(path.join(resting, "index.html"))) {
+				const backup = newestBackup(this.options.dataRoot, resting);
+				if (backup !== null) {
+					fs.rmSync(resting, {
 						recursive: true,
 						force: true
 					});
-				} catch {
-					return {
-						ok: false,
-						error: `${error instanceof Error ? error.message : String(error)} — the previous UI is kept at ${previous}`
-					};
+					fs.renameSync(backup, resting);
+					restored = path.basename(backup);
 				}
-				return {
-					ok: false,
-					error: error instanceof Error ? error.message : String(error)
-				};
 			}
-			fs.rmSync(previous, {
-				recursive: true,
-				force: true
-			});
 			return {
-				ok: true,
-				meta
+				restored,
+				swept: sweepJunk(this.options.dataRoot)
 			};
 		}
 	};
+	installLocks = /* @__PURE__ */ new Map();
 }));
 //#endregion
 //#region src/providers/ui-release.ts
@@ -8481,6 +8574,8 @@ async function runControlPlane(options) {
 		dataRoot,
 		stockDir: path.join(packageRoot, "uis", "stock", "dist")
 	});
+	const uiRecovery = ui.recover();
+	if (uiRecovery.restored !== null) logger.warn(`ui:      restored the installed UI from ${uiRecovery.restored} — an earlier update was interrupted`);
 	const hub = new EventHub();
 	let app;
 	const token = newToken();