@stim-cli/server 1.20.2 → 1.22.0

package/dist/stim-server.mjs

@@ -4,6 +4,6 @@ const encode = (version) => version.split(".", 3).reduce((sum, part) => sum * 1e
 if (encode(process.versions.node) < encode("22.12.0")) {
 	process.stderr.write(`STIM_NODE_UNSUPPORTED: stim-server needs Node 22.12.0 or later; this is Node ${process.versions.node} at ${process.execPath}. To run stim-server where a project pins an older Node, see https://stim.appandflow.com/docs/requirements#older-node-pins\n`);
 	process.exitCode = 1;
-} else import("./stim-server-FWcuNpW7.mjs");
+} else import("./stim-server-BKcEacbU.mjs");
 //#endregion
 export {};

package/dist/stim-service-runner.d.mts

@@ -0,0 +1,13 @@
+//#region src/service-runner.d.ts
+/**
+ * The Windows supervisor of `stim-server service`. It imports nothing but Node, so `install` can copy this one file
+ * beside the service and it keeps working whatever server version the service runs.
+ */
+interface SupervisorState {
+  supervisor: number;
+  server: number | null;
+  runs: number;
+  lastExitCode: string | null;
+}
+//#endregion
+export { SupervisorState };

package/dist/stim-service-runner.mjs

@@ -0,0 +1,96 @@
+import { spawn } from "node:child_process";
+import { appendFileSync, closeSync, mkdirSync, openSync, readFileSync, renameSync, writeFileSync } from "node:fs";
+import { dirname, join } from "node:path";
+import { setTimeout } from "node:timers/promises";
+//#region src/service-runner.ts
+function program(file) {
+	const parsed = JSON.parse(readFileSync(file, "utf8"));
+	const value = parsed && typeof parsed === "object" ? { ...parsed } : {};
+	const argv = Array.isArray(value.programArguments) ? value.programArguments.filter((entry) => typeof entry === "string") : [];
+	if (value.managed !== true || !argv.length || typeof value.logPath !== "string") throw new Error(`${file} is not a service file install wrote.`);
+	const environment = {};
+	if (value.environment && typeof value.environment === "object") {
+		for (const [name, entry] of Object.entries(value.environment)) if (typeof entry === "string") environment[name] = entry;
+	}
+	return {
+		argv,
+		environment,
+		workingDirectory: typeof value.workingDirectory === "string" ? value.workingDirectory : "",
+		logPath: value.logPath
+	};
+}
+async function supervise(file, statePath, throttleMs) {
+	let runs = 0;
+	let lastExitCode = null;
+	const log = (line) => {
+		try {
+			appendFileSync(join(dirname(statePath), "supervisor.log"), `${(/* @__PURE__ */ new Date()).toISOString()} ${line}\n`);
+		} catch {}
+	};
+	const record = (server) => {
+		const state = {
+			supervisor: process.pid,
+			server,
+			runs,
+			lastExitCode
+		};
+		try {
+			mkdirSync(dirname(statePath), { recursive: true });
+			const partial = `${statePath}.${process.pid}.tmp`;
+			writeFileSync(partial, `${JSON.stringify(state)}\n`);
+			renameSync(partial, statePath);
+		} catch (error) {
+			log(`could not record ${statePath}: ${error instanceof Error ? error.message : String(error)}`);
+		}
+	};
+	record(null);
+	for (;;) {
+		try {
+			lastExitCode = await runOnce(file, (server) => {
+				runs += 1;
+				record(server);
+			});
+		} catch (error) {
+			lastExitCode = `supervisor: ${error instanceof Error ? error.message : String(error)}`;
+			log(lastExitCode);
+		}
+		record(null);
+		await setTimeout(throttleMs);
+	}
+}
+/** Starts the server once from the service file and resolves with how it ended. */
+async function runOnce(file, started) {
+	const { argv, environment, workingDirectory, logPath } = program(file);
+	const [node = "", ...args] = argv;
+	mkdirSync(dirname(logPath), { recursive: true });
+	const out = openSync(logPath, "a");
+	const child = spawn(node, args, {
+		cwd: workingDirectory || void 0,
+		env: {
+			...process.env,
+			...environment
+		},
+		stdio: [
+			"ignore",
+			out,
+			out
+		],
+		windowsHide: true
+	});
+	closeSync(out);
+	started(child.pid ?? null);
+	return new Promise((resolve) => {
+		child.once("error", (error) => resolve(error.message));
+		child.once("exit", (code, signal) => resolve(code === null ? `signal ${signal}` : String(code)));
+	});
+}
+const [file, statePath, throttle] = process.argv.slice(2);
+if (!file || !statePath || !/^\d+$/.test(throttle ?? "")) {
+	process.stderr.write("usage: stim-service-runner <service file> <state file> <restart delay seconds>\n");
+	process.exitCode = 2;
+} else supervise(file, statePath, Number(throttle) * 1e3).catch((error) => {
+	process.stderr.write(`stim-service-runner: ${error instanceof Error ? error.message : String(error)}\n`);
+	process.exitCode = 1;
+});
+//#endregion
+export {};

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@stim-cli/server",
-  "version": "1.20.2",
+  "version": "1.22.0",
   "description": "Serves Stim status to paired clients over Tailscale, and runs reload and stop for clients granted control.",
   "license": "MIT",
   "repository": {
@@ -28,8 +28,13 @@
     "./protocol.schema.json": "./dist/protocol.schema.json"
   },
   "dependencies": {
-    "@stim-cli/core": "^1.20.2",
-    "stim": "1.20.2",
+    "@stim-cli/agent-driver": "^1.22.0",
+    "@stim-cli/agent-driver-agent-device": "^1.22.0",
+    "@stim-cli/cache": "^1.22.0",
+    "@stim-cli/core": "^1.22.0",
+    "@stim-cli/transport": "^1.22.0",
+    "@stim-cli/transport-tailscale": "^1.22.0",
+    "stim": "1.22.0",
     "ws": "^8.21.3"
   },
   "devDependencies": {

package/dist/stats-read.d.mts

@@ -1 +0,0 @@
-export {}

package/dist/stats-read.mjs

@@ -1,46 +0,0 @@
-import { execFile } from "node:child_process";
-import { sep } from "node:path";
-import { findProjectRoot, readStatsReport, statsProjectKey } from "@stim-cli/core/state";
-//#region src/stats-read.ts
-let git = null;
-let cancelled = false;
-const cancel = () => {
-	cancelled = true;
-	git?.kill("SIGKILL");
-};
-process.on("SIGTERM", cancel);
-process.on("message", (message) => {
-	if (message === "cancel") cancel();
-});
-function gitPath(root, args) {
-	return new Promise((resolve) => {
-		git = execFile("git", [
-			"-C",
-			root,
-			"rev-parse",
-			...args
-		], { encoding: "utf8" }, (error, stdout) => {
-			git = null;
-			const path = error ? "" : stdout.trim();
-			resolve(path ? sep === "/" ? path : path.replaceAll("/", sep) : null);
-		});
-	});
-}
-try {
-	const root = findProjectRoot(process.cwd());
-	const commonDir = root ? await gitPath(root, ["--path-format=absolute", "--git-common-dir"]) : null;
-	const repoRoot = root && !cancelled ? await gitPath(root, ["--show-toplevel"]) : null;
-	if (!cancelled) {
-		const key = root ? statsProjectKey({
-			root,
-			commonDir,
-			repoRoot
-		}) : null;
-		const { report } = readStatsReport(key, Date.now());
-		process.stdout.write(`${JSON.stringify(report)}\n`);
-	}
-} finally {
-	if (process.connected) process.disconnect();
-}
-//#endregion
-export {};