dsh-update-status 0.4.0 → 0.4.2

package/lib/index.js

@@ -1,4 +1,4 @@
-import { c as parseSystemdMainPid, d as bootStampFile, f as countRecentRestarts, h as serviceLogDir, i as SYSTEMD_UNIT, m as recordBootStamp, p as dshHomeOf, r as LAUNCHD_LABEL, s as parseLaunchdTrackedPid, t as planFor, u as RESTART_STORM_WINDOW_MS } from "./plan-BornHBEZ.js";
+import { C as recordBootStamp, S as dshHomeOf, _ as parseSystemdMainPid, a as planFor, b as bootStampFile, f as LAUNCHD_LABEL, g as parseLaunchdTrackedPid, p as SYSTEMD_UNIT, w as serviceLogDir, x as countRecentRestarts, y as RESTART_STORM_WINDOW_MS } from "./plan-D9Ybaj-3.js";
 import { createRequire } from "node:module";
 import { existsSync, readFileSync, realpathSync, statSync } from "node:fs";
 import { basename, dirname, join, normalize, sep } from "node:path";
@@ -21,7 +21,8 @@ const VERIFIED_DSH_VERSIONS = [
 	"0.1.7-rc.2",
 	"0.2.0-rc.1",
 	"0.2.0-rc.2",
-	"0.2.1-alpha.1"
+	"0.2.1-alpha.1",
+	"0.2.1-alpha.3"
 ];
 function isCacheTtlMinutes(value) {
 	return typeof value === "number" && Number.isInteger(value) && value >= 30 && value <= 1440;

package/lib/{plan-BornHBEZ.js → plan-D9Ybaj-3.js}

@@ -1,6 +1,6 @@
 import { createRequire } from "node:module";
 import { appendFileSync, existsSync, mkdirSync, readFileSync, readdirSync, realpathSync, statSync, writeFileSync } from "node:fs";
-import { dirname, isAbsolute, join, resolve } from "node:path";
+import { dirname, isAbsolute, join, posix, resolve, win32 } from "node:path";
 import { homedir } from "node:os";
 //#region src/shared/restart-evidence.ts
 /**
@@ -165,15 +165,135 @@ function parseWindowsTaskRunning(output) {
 	return /(?:^|\W)running(?:\W|$)/i.test(output);
 }
 //#endregion
+//#region src/service/service-path.ts
+/** Resolve one audited PATH that preflight and the native service both consume. */
+/** A service definition must stay inspectable; never silently truncate it. */
+const MAX_SERVICE_PATH_LENGTH = 8192;
+const MINIMAL_POSIX = {
+	darwin: [
+		"/usr/local/bin",
+		"/usr/bin",
+		"/bin",
+		"/usr/sbin",
+		"/sbin"
+	],
+	linux: [
+		"/usr/local/bin",
+		"/usr/bin",
+		"/bin"
+	]
+};
+const DEFAULT_WINDOWS_PATHEXT = ".COM;.EXE;.BAT;.CMD";
+function normalizeServicePathExt(value) {
+	const raw = value?.trim() || DEFAULT_WINDOWS_PATHEXT;
+	validateText(raw);
+	const seen = /* @__PURE__ */ new Set();
+	const extensions = [];
+	for (const original of raw.split(";")) {
+		const extension = original.trim();
+		if (extension === "") continue;
+		if (!/^\.[A-Za-z0-9]+$/.test(extension)) throw new Error(`invalid PATHEXT entry: ${extension}`);
+		const key = extension.toUpperCase();
+		if (seen.has(key)) continue;
+		seen.add(key);
+		extensions.push(extension);
+	}
+	if (extensions.length === 0) throw new Error("PATHEXT has no usable extension");
+	return extensions.join(";");
+}
+function delimiter(platform) {
+	return platform === "win32" ? ";" : ":";
+}
+function nodeDirectory(platform, nodePath) {
+	return platform === "win32" ? win32.dirname(nodePath) : posix.dirname(nodePath);
+}
+function isAbsolute$1(platform, value) {
+	return platform === "win32" ? win32.isAbsolute(value) : posix.isAbsolute(value);
+}
+function minimalEntries(platform, nodePath, override) {
+	const node = nodeDirectory(platform, nodePath);
+	if (override !== void 0 && override.trim() !== "") return [node, ...override.split(delimiter(platform))];
+	if (platform === "win32") return [node];
+	return [node, ...MINIMAL_POSIX[platform]];
+}
+function sourceValue(options) {
+	if (options.source === "minimal") return minimalEntries(options.platform, options.nodePath, options.minimalPath).join(delimiter(options.platform));
+	if (options.source === "explicit") {
+		if (options.explicitPath === void 0 || options.explicitPath.trim() === "") throw new Error("`--service-path` is required when `--path-source explicit` is used");
+		return options.explicitPath;
+	}
+	if (options.currentPath === void 0 || options.currentPath.trim() === "") throw new Error("current PATH is empty; use `--path-source minimal` or `--service-path`");
+	return options.currentPath;
+}
+function validateText(value) {
+	if (/[\u0000-\u0008\u000A-\u001F\u007F]/.test(value)) throw new Error("service PATH must not contain control characters or line breaks");
+	if (value.length > 8192) throw new Error(`service PATH is too long (maximum ${String(MAX_SERVICE_PATH_LENGTH)} characters); use --service-path with a shorter value`);
+}
+/**
+* Resolve at install/plan time — no user rc file is executed. Missing absolute
+* directories are preserved (they may be mounted or created later) and reported.
+*/
+function resolveServicePath(options) {
+	const split = delimiter(options.platform);
+	const raw = sourceValue(options);
+	validateText(raw);
+	if (options.platform !== "win32" && /(?:^|;)[A-Za-z]:[\\/]/.test(raw)) throw new Error("Windows-style PATH cannot be used for Linux/WSL; provide a colon-separated PATH");
+	const exists = options.exists ?? existsSync;
+	const warnings = [];
+	const values = [nodeDirectory(options.platform, options.nodePath), ...raw.split(split)];
+	const seen = /* @__PURE__ */ new Set();
+	const entries = [];
+	let warnedEmpty = false;
+	for (const rawEntry of values) {
+		if (rawEntry === "") {
+			if (!warnedEmpty) warnings.push("ignored empty PATH entry (current-directory lookup)");
+			warnedEmpty = true;
+			continue;
+		}
+		const entry = options.platform === "win32" && rawEntry.length >= 2 && rawEntry.startsWith("\"") && rawEntry.endsWith("\"") ? rawEntry.slice(1, -1) : rawEntry;
+		if (!isAbsolute$1(options.platform, entry)) {
+			warnings.push(`ignored relative PATH entry: ${entry}`);
+			continue;
+		}
+		const key = options.platform === "win32" ? entry.toLowerCase() : entry;
+		if (seen.has(key)) continue;
+		seen.add(key);
+		entries.push(entry);
+		if (!exists(entry)) warnings.push(`PATH directory does not exist yet: ${entry}`);
+	}
+	const value = entries.join(split);
+	if (value === "") throw new Error("service PATH has no absolute directory");
+	validateText(value);
+	const pathExt = options.platform === "win32" ? normalizeServicePathExt(options.currentPathExt) : void 0;
+	return {
+		source: options.source,
+		value,
+		...pathExt === void 0 ? {} : { pathExt },
+		warnings
+	};
+}
+/** Old receipts had no PATH fields; keep their exact historical minimal shape. */
+function servicePathOf(spec) {
+	return spec.servicePath ?? minimalEntries(spec.platform, spec.nodePath).join(delimiter(spec.platform));
+}
+//#endregion
 //#region src/service/plan.ts
 /** Build transparent per-OS user-service definitions; do not install them here. */
 const SERVICE_LABEL = LAUNCHD_LABEL;
 const SUPERVISOR_MARKER = "dsh-update-status";
+function nativeServiceCommandCandidates(platform, systemRoot) {
+	if (platform === "darwin") return ["/bin/launchctl"];
+	if (platform === "linux") return ["/usr/bin/systemctl", "/bin/systemctl"];
+	return [`${systemRoot ?? "C:\\Windows"}\\System32\\schtasks.exe`];
+}
+function nativeServiceCommandOf(spec) {
+	return spec.nativeServiceCommand ?? nativeServiceCommandCandidates(spec.platform)[0];
+}
 function xml(value) {
 	return value.replace(/&/g, "&amp;").replace(/</g, "&lt;").replace(/>/g, "&gt;").replace(/"/g, "&quot;").replace(/'/g, "&apos;");
 }
 function systemd(value) {
-	return value.replace(/\\/g, "\\\\").replace(/"/g, "\\\"");
+	return value.replace(/%/g, "%%").replace(/\\/g, "\\\\").replace(/"/g, "\\\"");
 }
 function powerShell(value) {
 	return value.replace(/'/g, "''");
@@ -216,6 +336,24 @@ function servicePlatform(value) {
 	if (value === "darwin" || value === "linux" || value === "win32") return value;
 	throw new Error(`unsupported platform: ${value}; supported: macOS, Linux, Windows`);
 }
+function envValue(env, key, platform) {
+	if (platform !== "win32") return env[key];
+	return Object.entries(env).find(([name]) => name.toLowerCase() === key.toLowerCase())?.[1];
+}
+function pathSourceOf(args) {
+	const explicit = valueAfter(args, "--service-path");
+	const raw = valueAfter(args, "--path-source");
+	if (raw === void 0) return explicit === void 0 ? "current" : "explicit";
+	if (raw !== "current" && raw !== "minimal" && raw !== "explicit") throw new Error("`--path-source` must be current, minimal, or explicit");
+	if (explicit !== void 0 && raw !== "explicit") throw new Error("`--service-path` requires `--path-source explicit` (or omit --path-source)");
+	return raw;
+}
+function serviceStateFileFromArgs(args, env) {
+	const home = env.home || homedir();
+	const dshHome = valueAfter(args, "--dsh-home") ?? (env.env.DSH_HOME?.trim() || void 0);
+	if (dshHome !== void 0 && !isAbsolute(dshHome)) throw new Error("`--dsh-home` must be an absolute path");
+	return join(dshHome ?? join(home, ".dsh"), "dsh-update-status-service.json");
+}
 function specFromArgs(args, env) {
 	const platform = servicePlatform(env.platform);
 	const profile = valueAfter(args, "--profile") ?? env.env.DSH_PROFILE ?? "web";
@@ -233,6 +371,20 @@ function specFromArgs(args, env) {
 	if (!isAbsolute(dshPath)) throw new Error("`--dsh` must be an absolute executable path");
 	if (!isAbsolute(workspace)) throw new Error("`--workspace` must be an absolute path");
 	if (!isAbsolute(logDir)) throw new Error("`--log-dir` must be an absolute path");
+	const systemRoot = envValue(env.env, "SYSTEMROOT", platform);
+	const pathExtOverride = valueAfter(args, "--service-pathext");
+	if (pathExtOverride !== void 0 && platform !== "win32") throw new Error("`--service-pathext` is supported only on Windows");
+	const candidates = nativeServiceCommandCandidates(platform, systemRoot);
+	const nativeServiceCommand = platform === "linux" ? candidates.find((candidate) => existsSync(candidate)) ?? candidates[0] : candidates[0];
+	const servicePath = resolveServicePath({
+		platform,
+		nodePath,
+		source: pathSourceOf(args),
+		currentPath: env.path ?? envValue(env.env, "PATH", platform),
+		currentPathExt: pathExtOverride ?? envValue(env.env, "PATHEXT", platform),
+		explicitPath: valueAfter(args, "--service-path"),
+		minimalPath: platform === "win32" && systemRoot !== void 0 ? `${systemRoot}\\System32;${systemRoot}` : void 0
+	});
 	return {
 		schemaVersion: 1,
 		platform,
@@ -246,6 +398,12 @@ function specFromArgs(args, env) {
 		home,
 		...dshHome === void 0 ? {} : { dshHome },
 		logDir,
+		servicePath: servicePath.value,
+		servicePathSource: servicePath.source,
+		servicePathCapturedAt: (/* @__PURE__ */ new Date()).toISOString(),
+		...servicePath.pathExt === void 0 ? {} : { servicePathExt: servicePath.pathExt },
+		...servicePath.warnings.length === 0 ? {} : { servicePathWarnings: servicePath.warnings },
+		nativeServiceCommand,
 		supervisorMarker: SUPERVISOR_MARKER
 	};
 }
@@ -292,7 +450,7 @@ function webArguments(spec) {
 }
 function launchdWrapper(spec, paths, uid) {
 	const args = [spec.nodePath, ...webArguments(spec)].map(shQuote).join(" ");
-	const kickstart = `launchctl kickstart -k gui/${String(uid)}/${spec.label}`;
+	const kickstart = `${shQuote(nativeServiceCommandOf(spec))} kickstart -k gui/${String(uid)}/${spec.label}`;
 	return `#!/bin/sh
 # Managed by dsh-update-status. This wrapper, not launchd, owns the restart loop.
 #
@@ -349,7 +507,7 @@ function launchdDefinition(spec, paths) {
 	const args = ["/bin/sh", wrapper].map((value) => `    <string>${xml(value)}</string>`).join("\n");
 	const envXml = [
 		["HOME", spec.home],
-		["PATH", `${dirname(spec.nodePath)}:/usr/local/bin:/usr/bin:/bin:/usr/sbin:/sbin`],
+		["PATH", servicePathOf(spec)],
 		["DSH_WEB_SUPERVISOR", spec.supervisorMarker],
 		...spec.dshHome === void 0 ? [] : [["DSH_HOME", spec.dshHome]]
 	].map(([key, value]) => `    <key>${xml(key)}</key>\n    <string>${xml(value)}</string>`).join("\n");
@@ -383,7 +541,7 @@ function systemdDefinition(spec) {
 	const command = [spec.nodePath, ...webArguments(spec)].map((value) => `"${systemd(value)}"`).join(" ");
 	const env = [
 		`Environment="HOME=${systemd(spec.home)}"`,
-		`Environment="PATH=${systemd(`${dirname(spec.nodePath)}:/usr/local/bin:/usr/bin:/bin`)}"`,
+		`Environment="PATH=${systemd(servicePathOf(spec))}"`,
 		`Environment="DSH_WEB_SUPERVISOR=${spec.supervisorMarker}"`,
 		...spec.dshHome === void 0 ? [] : [`Environment="DSH_HOME=${systemd(spec.dshHome)}"`]
 	].join("\n");
@@ -418,7 +576,7 @@ function windowsWrapper(spec, paths) {
 	const dshHome = spec.dshHome === void 0 ? "" : `$env:DSH_HOME = '${powerShell(spec.dshHome)}'\n`;
 	return `$ErrorActionPreference = 'Stop'
 $env:HOME = '${home}'
-$env:DSH_WEB_SUPERVISOR = '${spec.supervisorMarker}'
+${spec.servicePath === void 0 ? "" : `$env:PATH = '${powerShell(spec.servicePath)}'\n$env:PATHEXT = '${powerShell(spec.servicePathExt ?? ".COM;.EXE;.BAT;.CMD")}'\n`}$env:DSH_WEB_SUPERVISOR = '${spec.supervisorMarker}'
 ${dshHome}Set-Location -LiteralPath '${workspace}'
 $rapidWindowSeconds = ${String(30)}
 $rapidLimit = ${String(5)}
@@ -463,6 +621,7 @@ function windowsDefinition(spec, paths) {
 /** Generate a service plan without writing, starting, or stopping anything. */
 function planFor(spec, uid = 0) {
 	const paths = pathsFor(spec);
+	const control = nativeServiceCommandOf(spec);
 	if (spec.platform === "darwin") {
 		const domain = `gui/${uid}`;
 		return {
@@ -471,30 +630,30 @@ function planFor(spec, uid = 0) {
 			definition: launchdDefinition(spec, paths),
 			wrapper: launchdWrapper(spec, paths, uid),
 			installCommand: [
-				"launchctl",
+				control,
 				"bootstrap",
 				domain,
 				paths.definitionFile
 			],
 			startCommand: [
-				"launchctl",
+				control,
 				"kickstart",
 				"-k",
 				`${domain}/${spec.label}`
 			],
-			recoverCommand: `launchctl kickstart -k ${domain}/${spec.label}`,
+			recoverCommand: `${shQuote(control)} kickstart -k ${domain}/${spec.label}`,
 			statusCommand: [
-				"launchctl",
+				control,
 				"print",
 				`${domain}/${spec.label}`
 			],
 			stopCommand: [
-				"launchctl",
+				control,
 				"bootout",
 				`${domain}/${spec.label}`
 			],
 			uninstallCommand: [
-				"launchctl",
+				control,
 				"bootout",
 				`${domain}/${spec.label}`
 			]
@@ -505,33 +664,33 @@ function planFor(spec, uid = 0) {
 		paths,
 		definition: systemdDefinition(spec),
 		installCommand: [
-			"systemctl",
+			control,
 			"--user",
 			"daemon-reload"
 		],
 		startCommand: [
-			"systemctl",
+			control,
 			"--user",
 			"enable",
 			"--now",
 			"dsh-update-status-web.service"
 		],
-		recoverCommand: `systemctl --user reset-failed ${SYSTEMD_UNIT} && systemctl --user enable --now ${SYSTEMD_UNIT}`,
+		recoverCommand: `${shQuote(control)} --user reset-failed ${SYSTEMD_UNIT} && ${shQuote(control)} --user enable --now ${SYSTEMD_UNIT}`,
 		statusCommand: [
-			"systemctl",
+			control,
 			"--user",
 			"status",
 			"dsh-update-status-web.service"
 		],
 		stopCommand: [
-			"systemctl",
+			control,
 			"--user",
 			"disable",
 			"--now",
 			"dsh-update-status-web.service"
 		],
 		uninstallCommand: [
-			"systemctl",
+			control,
 			"--user",
 			"disable",
 			"--now",
@@ -544,7 +703,7 @@ function planFor(spec, uid = 0) {
 		definition: windowsDefinition(spec, paths),
 		wrapper: windowsWrapper(spec, paths),
 		installCommand: [
-			"schtasks.exe",
+			control,
 			"/Create",
 			"/TN",
 			"DSH Update Status Web",
@@ -553,14 +712,14 @@ function planFor(spec, uid = 0) {
 			"/F"
 		],
 		startCommand: [
-			"schtasks.exe",
+			control,
 			"/Run",
 			"/TN",
 			"DSH Update Status Web"
 		],
-		recoverCommand: "schtasks.exe /Run /TN \"DSH Update Status Web\"",
+		recoverCommand: `"${control}" /Run /TN "DSH Update Status Web"`,
 		statusCommand: [
-			"schtasks.exe",
+			control,
 			"/Query",
 			"/TN",
 			"DSH Update Status Web",
@@ -569,13 +728,13 @@ function planFor(spec, uid = 0) {
 			"LIST"
 		],
 		stopCommand: [
-			"schtasks.exe",
+			control,
 			"/End",
 			"/TN",
 			"DSH Update Status Web"
 		],
 		uninstallCommand: [
-			"schtasks.exe",
+			control,
 			"/Delete",
 			"/TN",
 			"DSH Update Status Web",
@@ -584,4 +743,4 @@ function planFor(spec, uid = 0) {
 	};
 }
 //#endregion
-export { WINDOWS_TASK_NAME as a, parseSystemdMainPid as c, bootStampFile as d, countRecentRestarts as f, serviceLogDir as h, SYSTEMD_UNIT as i, parseWindowsTaskRunning as l, recordBootStamp as m, specFromArgs as n, WINDOWS_WRAPPER_BASENAME as o, dshHomeOf as p, LAUNCHD_LABEL as r, parseLaunchdTrackedPid as s, planFor as t, RESTART_STORM_WINDOW_MS as u };
+export { recordBootStamp as C, dshHomeOf as S, parseSystemdMainPid as _, planFor as a, bootStampFile as b, specFromArgs as c, servicePathOf as d, LAUNCHD_LABEL as f, parseLaunchdTrackedPid as g, WINDOWS_WRAPPER_BASENAME as h, pathsFor as i, MAX_SERVICE_PATH_LENGTH as l, WINDOWS_TASK_NAME as m, nativeServiceCommandCandidates as n, servicePlatform as o, SYSTEMD_UNIT as p, nativeServiceCommandOf as r, serviceStateFileFromArgs as s, SERVICE_LABEL as t, normalizeServicePathExt as u, parseWindowsTaskRunning as v, serviceLogDir as w, countRecentRestarts as x, RESTART_STORM_WINDOW_MS as y };

package/lib/service-cli.d.ts

@@ -16,9 +16,44 @@ interface ServiceSpec {
   readonly home: string;
   readonly dshHome?: string;
   readonly logDir: string;
+  /** Final audited PATH persisted by install and reused by every later action. */
+  readonly servicePath?: string;
+  readonly servicePathSource?: 'current' | 'minimal' | 'explicit';
+  readonly servicePathCapturedAt?: string;
+  /** Windows command extension lookup, persisted alongside PATH. */
+  readonly servicePathExt?: string;
+  /** Human-readable warnings retained in the receipt and dry-run output. */
+  readonly servicePathWarnings?: readonly string[];
+  /** Absolute launchctl/systemctl/schtasks path; later actions never search PATH. */
+  readonly nativeServiceCommand?: string;
   /** Written by the user-service definition, never inferred from a TTY. */
   readonly supervisorMarker: 'dsh-update-status';
 }
+interface ServicePaths {
+  readonly stateFile: string;
+  readonly definitionFile: string;
+  /** macOS and Windows: the wrapper that owns the restart loop. */
+  readonly wrapperFile?: string;
+  readonly stdoutFile: string;
+  readonly stderrFile: string;
+}
+interface ServicePlan {
+  readonly spec: ServiceSpec;
+  readonly paths: ServicePaths;
+  readonly definition: string;
+  readonly wrapper?: string;
+  readonly installCommand: readonly string[];
+  readonly startCommand: readonly string[];
+  /**
+   * One copy-only line that lets the service take over again after it stopped
+   * (a tripped start limit, a given-up wrapper). Displayed only — never run by
+   * the plugin.
+   */
+  readonly recoverCommand: string;
+  readonly statusCommand: readonly string[];
+  readonly stopCommand: readonly string[];
+  readonly uninstallCommand: readonly string[];
+}
 interface CliEnvironment {
   readonly platform: NodeJS.Platform;
   readonly home: string;
@@ -49,6 +84,7 @@ type ServiceVerification = {
 };
 //#endregion
 //#region src/service/cli.d.ts
+export declare function serialisePlan(plan: ServicePlan): string;
 export interface CliHooks {
   readonly preflight?: (spec: ServiceSpec) => void;
   /** Injected in tests; defaults to the real post-activation verification. */