dsh-update-status 0.2.0 → 0.3.0

package/lib/index.js

@@ -28,6 +28,12 @@ const UPDATE_ENDPOINTS = {
 	getStatus: "dsh-update-status.get-status",
 	checkUpdate: "dsh-update-status.check-update"
 };
+/** Restart RPC remains on the same authenticated Connection `/api` channel. */
+const RESTART_ENDPOINTS = {
+	status: "dsh-update-status.restart-status",
+	check: "dsh-update-status.restart-check",
+	request: "dsh-update-status.restart"
+};
 //#endregion
 //#region src/host/installation.ts
 /**
@@ -176,6 +182,16 @@ function requestOf(value) {
 		...record.cacheTtlMinutes === void 0 ? {} : { cacheTtlMinutes: record.cacheTtlMinutes }
 	};
 }
+function restartRequestOf(value) {
+	if (value === null || typeof value !== "object" || Array.isArray(value)) return void 0;
+	const record = value;
+	if (record.force !== void 0 && typeof record.force !== "boolean") return void 0;
+	if (typeof record.expectedInstanceId !== "string" || record.expectedInstanceId === "") return void 0;
+	return {
+		force: record.force === true,
+		expectedInstanceId: record.expectedInstanceId
+	};
+}
 function jsonResponse(rpcId, result) {
 	return Response.json({
 		type: "server-response",
@@ -203,7 +219,7 @@ async function dispatchUpdateStatusFetch(endpoint, handler, request) {
 	}
 }
 /** Endpoint dispatcher, exported to allow exact JSON-shape tests without a Host. */
-function createUpdateStatusRpcHandler(service) {
+function createUpdateStatusRpcHandler(service, restart, restartContext) {
 	return async (endpoint, payload) => {
 		try {
 			if (endpoint === UPDATE_ENDPOINTS.getStatus) {
@@ -222,6 +238,29 @@ function createUpdateStatusRpcHandler(service) {
 					value: await service.check(request.force === true, request.cacheTtlMinutes)
 				};
 			}
+			if (endpoint === RESTART_ENDPOINTS.status) {
+				if (restart === void 0) return failure("dsh-update-status/restart-unavailable", "restart support is not configured");
+				return {
+					ok: true,
+					value: restart.status()
+				};
+			}
+			if (endpoint === RESTART_ENDPOINTS.check) {
+				if (restart === void 0 || restartContext === void 0) return failure("dsh-update-status/restart-unavailable", "restart support is not configured");
+				return {
+					ok: true,
+					value: restart.check(restartContext)
+				};
+			}
+			if (endpoint === RESTART_ENDPOINTS.request) {
+				const request = restartRequestOf(payload);
+				if (request === void 0) return failure("dsh-update-status/bad-request", "`force` must be boolean");
+				if (restart === void 0 || restartContext === void 0) return failure("dsh-update-status/restart-unavailable", "restart support is not configured");
+				return {
+					ok: true,
+					value: restart.request(restartContext, request.force, request.expectedInstanceId)
+				};
+			}
 			return failure("dsh-update-status/unknown-endpoint", `unknown endpoint: ${endpoint}`);
 		} catch (error) {
 			return failure("dsh-update-status/internal", (error instanceof Error ? error.message : String(error)).slice(0, 220));
@@ -230,19 +269,18 @@ function createUpdateStatusRpcHandler(service) {
 }
 /**
 * Static packages do not receive dynamic Cordis's `harness.handle` closure.
-* DSH 0.1.5 serves browser unary RPC only on the shared `/api` channel; a
-* private prefix such as `/dsh-update-status` is answered by the SPA fallback
-* with HTTP 405. Exact Fetch routes on `/api/<endpoint>` are dispatched by
-* Connection before the Typert interceptor and do not need a new HTTP prefix.
+* Exact Fetch routes on `/api/<endpoint>` are dispatched by Connection after
+* its Host/Origin and cookie admission. Every destructive restart request is
+* therefore authenticated before it reaches this plugin.
 */
-function installUpdateStatusRpc(ctx, service) {
-	const handler = createUpdateStatusRpcHandler(service);
+function installUpdateStatusRpc(ctx, service, restart) {
+	const handler = createUpdateStatusRpcHandler(service, restart, ctx);
 	ctx.inject(["connection"], (owned) => {
 		const connection = owned.connection;
 		const register = typeof connection.fetch?.register === "function" ? connection.fetch.register.bind(connection.fetch) : void 0;
 		if (register === void 0) return;
 		try {
-			for (const endpoint of Object.values(UPDATE_ENDPOINTS)) register({
+			for (const endpoint of [...Object.values(UPDATE_ENDPOINTS), ...Object.values(RESTART_ENDPOINTS)]) register({
 				path: `${UPDATE_STATUS_CHANNEL}/${endpoint}`,
 				methods: ["POST"],
 				requestBody: "buffered",
@@ -253,6 +291,261 @@ function installUpdateStatusRpc(ctx, service) {
 		}
 	});
 }
+const INSTANCE_KEY = Symbol.for("dsh-update-status/process-instance-id");
+/**
+* This must outlive plugin HMR/recomposition inside one Node process. A module
+* local random value would make a Host reload look like a successful restart.
+*/
+function processInstanceId() {
+	const carrier = globalThis;
+	const existing = carrier[INSTANCE_KEY];
+	if (existing !== void 0) return existing;
+	const created = `${Date.now().toString(36)}-${Math.random().toString(36).slice(2, 10)}`;
+	carrier[INSTANCE_KEY] = created;
+	return created;
+}
+/**
+* Strict supervisor recognition: the marker is written only by this package's
+* user-service installer. Platform-specific signals defend against a user
+* copying that environment variable into an arbitrary terminal by accident.
+*/
+function restartStatusOf(options = {}) {
+	const env = options.env ?? process.env;
+	const platform = options.platform ?? process.platform;
+	const versions = options.versions ?? process.versions;
+	const instanceId = options.instanceId ?? processInstanceId();
+	if (versions.electron !== void 0 && versions.electron !== "") return {
+		instanceId,
+		available: false,
+		supervisor: null,
+		unavailableReason: "desktop"
+	};
+	if (env.DSH_WEB_SUPERVISOR !== "dsh-update-status") return {
+		instanceId,
+		available: false,
+		supervisor: null,
+		unavailableReason: "not-supervised"
+	};
+	if (platform === "darwin") {
+		if (env.XPC_SERVICE_NAME !== "com.idoall.dsh-update-status.web") return {
+			instanceId,
+			available: false,
+			supervisor: "launchd",
+			unavailableReason: "supervisor-mismatch"
+		};
+		return {
+			instanceId,
+			available: true,
+			supervisor: "launchd",
+			unavailableReason: null
+		};
+	}
+	if (platform === "linux") {
+		if (typeof env.INVOCATION_ID !== "string" || env.INVOCATION_ID === "") return {
+			instanceId,
+			available: false,
+			supervisor: "systemd",
+			unavailableReason: "supervisor-mismatch"
+		};
+		return {
+			instanceId,
+			available: true,
+			supervisor: "systemd",
+			unavailableReason: null
+		};
+	}
+	if (platform === "win32") return {
+		instanceId,
+		available: true,
+		supervisor: "task-scheduler",
+		unavailableReason: null
+	};
+	return {
+		instanceId,
+		available: false,
+		supervisor: "unknown",
+		unavailableReason: "supervisor-mismatch"
+	};
+}
+/** Same facts dsh-service lists before allowing its force-restart control. */
+function collectActiveWork(ctx) {
+	const unavailable = () => ({
+		available: false,
+		hasActive: false,
+		items: []
+	});
+	const getter = typeof ctx.get === "function" ? ctx.get.bind(ctx) : void 0;
+	if (getter === void 0) return unavailable();
+	let agentsFace;
+	let jobsFace;
+	try {
+		agentsFace = getter("agents");
+		jobsFace = getter("jobs");
+	} catch {
+		return unavailable();
+	}
+	if (typeof agentsFace?.list !== "function") return unavailable();
+	let agents;
+	try {
+		agents = agentsFace.list();
+	} catch {
+		return unavailable();
+	}
+	const items = [];
+	for (const agent of agents) {
+		if (agent.status !== "running") continue;
+		const id = String(agent.id);
+		items.push({
+			type: "agent",
+			id,
+			label: id,
+			status: "running"
+		});
+	}
+	if (jobsFace !== void 0) {
+		if (typeof jobsFace.list !== "function") return unavailable();
+		const byId = /* @__PURE__ */ new Map();
+		for (const caller of [void 0, ...agents.map((agent) => agent.id)]) try {
+			for (const job of jobsFace.list(caller)) {
+				if (job.status !== "running" && job.status !== "stopping") continue;
+				byId.set(String(job.id), job);
+			}
+		} catch {
+			return unavailable();
+		}
+		for (const job of byId.values()) items.push({
+			type: "job",
+			id: String(job.id),
+			label: typeof job.label === "string" && job.label !== "" ? job.label : String(job.id),
+			status: typeof job.status === "string" ? job.status : "running",
+			...job.owner === void 0 ? {} : { ownerSession: String(job.owner) }
+		});
+	}
+	const terminals = /* @__PURE__ */ new Map();
+	for (const owner of agents) {
+		const ownerCtx = owner.ctx;
+		if (ownerCtx === void 0 || typeof ownerCtx.get !== "function") return unavailable();
+		let face;
+		try {
+			face = ownerCtx.get("terminals");
+		} catch {
+			return unavailable();
+		}
+		if (face === void 0) continue;
+		if (typeof face.list !== "function") return unavailable();
+		try {
+			for (const terminal of face.list(owner)) {
+				if (terminal.status?.kind !== "running") continue;
+				terminals.set(String(terminal.sessionId), terminal);
+			}
+		} catch {
+			return unavailable();
+		}
+	}
+	for (const terminal of terminals.values()) {
+		const id = String(terminal.sessionId);
+		items.push({
+			type: "terminal",
+			id,
+			label: typeof terminal.name === "string" && terminal.name !== "" ? terminal.name : `${typeof terminal.type === "string" ? terminal.type : "terminal"} terminal`,
+			status: "running"
+		});
+	}
+	return {
+		available: true,
+		hasActive: items.length > 0,
+		items
+	};
+}
+var RestartController = class {
+	instanceId;
+	options;
+	scheduled = false;
+	constructor(options = {}) {
+		this.options = options;
+		this.instanceId = options.instanceId ?? processInstanceId();
+	}
+	status() {
+		return restartStatusOf({
+			...this.options,
+			instanceId: this.instanceId
+		});
+	}
+	check(ctx) {
+		const status = this.status();
+		if (!status.available) return {
+			kind: "unavailable",
+			status
+		};
+		const activity = collectActiveWork(ctx);
+		if (!activity.available) return {
+			kind: "unavailable",
+			status: {
+				...status,
+				available: false,
+				unavailableReason: "activity-unavailable"
+			}
+		};
+		if (activity.hasActive) return {
+			kind: "active-work",
+			status,
+			activity
+		};
+		return {
+			kind: "ready",
+			status
+		};
+	}
+	request(ctx, force, expectedInstanceId) {
+		if (expectedInstanceId !== this.instanceId) return {
+			kind: "unavailable",
+			status: {
+				...this.status(),
+				available: false,
+				unavailableReason: "stale-instance"
+			}
+		};
+		const checked = this.check(ctx);
+		if (checked.kind === "unavailable") return checked;
+		if (checked.kind === "active-work" && !force) return checked;
+		if (this.scheduled) return {
+			kind: "in-progress",
+			instanceId: this.instanceId
+		};
+		let timer;
+		try {
+			timer = ctx.get?.("timer");
+		} catch {
+			timer = void 0;
+		}
+		const schedule = typeof timer?.timeout === "function" ? (callback) => {
+			timer.timeout(callback, 500);
+		} : this.options.schedule === void 0 ? void 0 : (callback) => {
+			this.options.schedule(callback, 500);
+		};
+		if (schedule === void 0) return {
+			kind: "unavailable",
+			status: {
+				...this.status(),
+				available: false,
+				unavailableReason: "timer-unavailable"
+			}
+		};
+		this.scheduled = true;
+		const exit = this.options.exit ?? ((code) => process.exit(code));
+		schedule(() => {
+			exit(42);
+		});
+		return {
+			kind: "scheduled",
+			instanceId: this.instanceId
+		};
+	}
+};
+/** Creates the process-scoped controller once per DSH Host generation. */
+function createRestartController() {
+	return new RestartController();
+}
 //#endregion
 //#region src/host/schemastery.ts
 /**
@@ -885,7 +1178,7 @@ function apply(ctx, config = {}) {
 		runtimeWarnings: schema.warning === null ? [] : [schema.warning]
 	});
 	installSettings(ctx);
-	installUpdateStatusRpc(ctx, service);
+	installUpdateStatusRpc(ctx, service, createRestartController());
 	if (config.autoCheckOnMount !== false) service.getStatus();
 }
 //#endregion