@stim-cli/server 1.17.1 → 1.18.0

package/README.md

@@ -13,7 +13,8 @@ The design is in
 ## Commands
 
 ```bash
-stim-server [--port <n>]          # serve paired clients, port 7787 by default
+stim-server [--port <n>] [--loopback-only]
+                                  # serve paired clients, port 7787 by default
 stim-server pair [--port <n>] [--control]
                                   # print a single-use pairing payload
 stim-server devices [list]        # list pairings, approvals, requests and hosted sessions
@@ -28,6 +29,13 @@ stim-server service install|status|update|rollback|uninstall
                                   # run stim-server as a macOS LaunchAgent, see below
 ```
 
+`--loopback-only` makes the server listen on `127.0.0.1` only and refuse any request
+that names a remote peer (`X-Forwarded-For`, as `tailscale serve --https` adds), so
+phones and other Macs cannot connect; `/health` then reports `loopbackOnly: true`.
+Without it, the server also listens on this Mac's Tailscale addresses while Tailscale
+runs (see [Tailscale](#tailscale)). Stim Desktop starts its own server with the flag
+unless it serves phones.
+
 `--env KEY=VALUE` and `--path-prepend <dir>` (each repeatable) apply to the
 serving command: see [Run as a service](#run-as-a-service).
 
@@ -104,8 +112,9 @@ GUI login session.
 
 Running setup on the worker is the worker-side approval. It pre-approves at
 most one request per chosen capability, from this node, carrying this ticket,
-until this expiry. A terminal asks y/N for each grant (default No); use `--yes`
-to approve without those questions, including without a terminal. Without
+until this expiry. A terminal asks Y/n for each grant (default Yes: Enter, `y` and `yes` approve;
+`n`, `no` and any other answer decline); use `--yes` to approve without those
+questions, including without a terminal. Without
 a terminal or `--yes`, setup refuses before installing anything unless every
 chosen capability already has a matching approval. A person on
 the worker still approves; an SSH-driven run is not offered. Build and
@@ -147,7 +156,7 @@ nothing. Android and CocoaPods checks are not needed for hosting alone.
 In a terminal, setup prints a banner, then one line per step with a green check,
 a yellow arrow while a step runs, or a red cross; `NO_COLOR`, `TERM=dumb` and a
 non-terminal give plain `[ok]`, `[failed]` and `[pending]` marks, no colors and no
-in-place line. The y/N questions stay, one line each. The run ends with a
+in-place line. The Y/n questions stay, one line each. The run ends with a
 headline such as "janics-mac-mini is ready to build for Janic's MacBook Pro", one
 line per approved capability, a `Fix` line for each skipped permission or missing
 tool, and one `To undo` line. `--verbose` prints every step with its detail, the
@@ -208,8 +217,9 @@ same tailnet or with the Mac shared to the phone's user.
 addresses, never on every interface. It re-reads the Tailscale state in the
 background, so a server that started before Tailscale was up, or while it did
 not answer, starts listening on the Tailscale addresses once it runs, and stops
-when it goes away. In Stim Desktop, choose **Set up connection** in Settings >
-Phones to create and verify the private route without a terminal command. A
+when it goes away. In Stim Desktop, the Pair a Phone wizard (Settings > Phones) creates and
+verifies the private route without a terminal command; with the Phone app flag
+off, **Set up connection** on Settings > Server does. A
 missing or unreadable route keeps Desktop pairing unavailable; HTTPS setup may
 require Tailscale browser approval. Existing routes stay unchanged.
 
@@ -1153,7 +1163,11 @@ The server re-reads the build clients on every call, and revoking a client
 closes its connections and cancels its builds.
 
 - `build.offer` takes `repo` (the client's name for its repository: letters,
-  digits, `.`, `_` and `-`, at most 80) and an optional `lockfile` sha256. It
+  digits, `.`, `_` and `-`, at most 80), an optional `lockfile` sha256, and an
+  optional `rubyVersion` (the project's normalized `.ruby-version`, a nonempty
+  installation name without path separators, NUL or line breaks). The CocoaPods probe uses the
+  same Ruby selection and UTF-8 locale defaults as `pod install`; omitting
+  `rubyVersion` uses the worker's default Ruby. It
   returns `toolchain` (`stimBuild`, a digest of the bundled Stim's built code;
   `arch`; `xcode`; `simulatorSdk`; `macosSdk` (from
   `xcrun --sdk macosx --show-sdk-version`); `cocoapods`; `runtimes`, the simulator
@@ -1169,11 +1183,12 @@ closes its connections and cancels its builds.
   average per CPU), `builds` (this Mac's own Stim runs in prebuild, pods or
   compile that it did not offload, plus the offloaded builds it runs), `maxBuilds` (its
   `concurrency.maxBuilds`, 0 when unlimited), `maxLoadPerCore` (its
-  `server.maxLoadPerCore`, default 2), and `declined`: why it would refuse a
+  `server.maxLoadPerCore`, default 2), `memoryUsedBytes` (Activity Monitor's
+  Memory Used) and `memoryTotalBytes`, and `declined`: why it would refuse a
   build now, or null. It declines while it runs its limit of offloaded builds,
   while the worker root's volume has less than 10 GiB free, while `builds`
   reaches a non-zero `maxBuilds`, or while `loadPerCore` is at or above
-  `maxLoadPerCore`. The toolchain is read at most once a minute; capacity on
+  `maxLoadPerCore`. The toolchain is read at most once a minute per Ruby context; capacity on
   every offer.
 - `build.sync` takes `repo`, `files` and `done`. `files` is one page of the
   manifest, each `{ "path", "kind": "file"|"exec"|"link", "size", "sha256" }`,
@@ -1881,8 +1896,10 @@ after. With a `stim` whose status has no `activity.recent`, every app log
 record counts as activity, so an app that keeps logging never looks stuck or
 finished.
 
-Each workspace notifies once per episode: a stuck agent notifies again only
-after new activity and a new quiet stretch, a loop only after a success or a
+Each workspace notifies once per episode: an agent stop pushes `finished` once
+per run, which ends when the workspace goes idle, and a workspace pushes
+`attention` once per run, which starts over when the workspace stops being idle
+or has no item left; a stuck agent notifies again only after new activity and a new quiet stretch, a loop only after a success or a
 different failure. A push carries a collapse id for its workspace and
 category, so a later one replaces the earlier notification on the phone
 instead of stacking. What is already true when the server starts or a device

package/dist/{protocol-Btu-PwQS.mjs → protocol-qo5TTavl.mjs}

@@ -1,5 +1,5 @@
 import "node:module";
-import { ACTIONS, BUILD_REPO_PATTERN, CAPABILITIES, CONTROL_END_REASONS, DEVICE_POSTURES, ERROR_CODES, FEATURES, FRAME_EDGE, FRAME_FPS, INPUT_BUTTONS, INPUT_KEYS, KEY_MODIFIERS, LEGACY_PUSH_EVENTS, LOG_LEVELS, LOG_SOURCES, MAX_INPUT_TEXT, MAX_LOG_TAIL, NOTIFICATION_LEVELS, NOTIFICATION_SUPPRESSIONS, PLATFORMS, PROTOCOL_VERSION, PUSH_EVENTS, PUSH_TOKEN_PATTERN, RELOAD_PLATFORMS, REPLAY_MARKER_KINDS, REPLAY_RATES, ROTATE_DIRECTIONS, TOUCH_PHASES, VIDEO_CODECS } from "@stim-cli/core/protocol";
+import { ACTIONS, BUILD_REPO_PATTERN, BUILD_RUBY_VERSION_PATTERN, CAPABILITIES, CONTROL_END_REASONS, DEVICE_POSTURES, ERROR_CODES, FEATURES, FRAME_EDGE, FRAME_FPS, INPUT_BUTTONS, INPUT_KEYS, KEY_MODIFIERS, LEGACY_PUSH_EVENTS, LOG_LEVELS, LOG_SOURCES, MAX_INPUT_TEXT, MAX_LOG_TAIL, NOTIFICATION_LEVELS, NOTIFICATION_SUPPRESSIONS, PLATFORMS, PROTOCOL_VERSION, PUSH_EVENTS, PUSH_TOKEN_PATTERN, RELOAD_PLATFORMS, REPLAY_MARKER_KINDS, REPLAY_RATES, ROTATE_DIRECTIONS, TOUCH_PHASES, VIDEO_CODECS } from "@stim-cli/core/protocol";
 //#region \0rolldown/runtime.js
 var __defProp = Object.defineProperty;
 var __getOwnPropDesc = Object.getOwnPropertyDescriptor;
@@ -785,7 +785,11 @@ function protocolJsonSchema() {
 						required: ["name", "version"],
 						properties: {
 							name: { type: "string" },
-							version: { type: "string" }
+							version: { type: "string" },
+							runId: {
+								type: "string",
+								pattern: "^[A-Za-z0-9._-]{1,64}$"
+							}
 						}
 					},
 					auth: { oneOf: [
@@ -2209,7 +2213,11 @@ function protocolJsonSchema() {
 					additionalProperties: false,
 					properties: {
 						repo: buildRepo,
-						lockfile: sha256
+						lockfile: sha256,
+						rubyVersion: {
+							type: "string",
+							pattern: BUILD_RUBY_VERSION_PATTERN
+						}
 					}
 				}),
 				request("build.sync", {

package/dist/protocol.mjs

@@ -1,3 +1,3 @@
-import { t as protocolJsonSchema } from "./protocol-Btu-PwQS.mjs";
+import { t as protocolJsonSchema } from "./protocol-qo5TTavl.mjs";
 export * from "@stim-cli/core/protocol";
 export { protocolJsonSchema };

package/dist/protocol.schema.json

@@ -1145,6 +1145,10 @@
             },
             "version": {
               "type": "string"
+            },
+            "runId": {
+              "type": "string",
+              "pattern": "^[A-Za-z0-9._-]{1,64}$"
             }
           }
         },
@@ -1420,7 +1424,8 @@
               "device",
               "build",
               "agent",
-              "maintenance"
+              "maintenance",
+              "placement"
             ]
           }
         },
@@ -5215,6 +5220,10 @@
                 "lockfile": {
                   "type": "string",
                   "pattern": "^[0-9a-f]{64}$"
+                },
+                "rubyVersion": {
+                  "type": "string",
+                  "pattern": "^(?!\\.{1,2}$)[^/\\\\\\u0000\\r\\n]+$"
                 }
               }
             }

package/dist/{stim-server-CGqz0EFG.mjs → stim-server-BR9FPA63.mjs}

@@ -1,8 +1,8 @@
-import { n as protocol_exports } from "./protocol-Btu-PwQS.mjs";
+import { n as protocol_exports } from "./protocol-qo5TTavl.mjs";
 import { createRequire } from "node:module";
 import { execFile, execFileSync, spawn, spawnSync } from "node:child_process";
 import { basename, delimiter, dirname, isAbsolute, join, relative, resolve, sep } from "node:path";
-import { HOSTED_APP_CHUNK_BYTES, HOSTED_MACOS_APP_SLOTS, RECORDING_CAP_BYTES, RECORDING_FOOTAGE_MS, RECORDING_PLATFORMS, archiveDir, assertHostedDeviceLedger, buildWorkerRoot, capDrops, closedSegmentName, compileGrep, createAgentActionReader, deviceHostArea, deviceHostRoot, deviceViewersDir, footageDrops, getConcurrencyLimits, getParkedMax, hostedAndroidPlacements, hostedAppArea, hostedAppAttempt, hostedAppBlobs, hostedDeviceId, hostedIosPlacements, hostedMacosBundleId, hostedMacosLogsDir, hostedNativeLogsDir, isJournalExpired, isJsonObject, isSetupJournalPrunable, listRecordedDevices, listSegments, loadConfig, machineCapacity, macosAppState, openSegmentName, parseHostedAppOffer, parseHostedLocalDeviceCount, parseHostedLogsCursor, parseHostedNativeOffer, parseHostedOfferRequest, parseHostedPlatformDevice, parseHostedRequest, parseNdjsonLine, pinnedEndpoint, queryJsonLogs, readArchive, readArchiveState, readBuildHistory, readBuildMachines, readDeviceHostMachines, readHostedApp, readHostedAppMetadata, readHostedDevice, readHostedDeviceLedger, readHostedMacosApp, readHostedNativeLogsCheckpoint, readHostedSessions, readJsonObject, readLogTimeline, readLogsSince, readMacosRecord, readSetupJournal, readWorkspaceState, recordingDeviceName, rememberHostedAppBlobRename, saturation, serverSetupDir, settingDefinition, settingValueError, setupJournalFile, sortByTs, stimBuildDigest, tryAcquireBuildSlotClaim, validHostedAppBlob, workspaceRecordingsDir } from "@stim-cli/core/state";
+import { HOSTED_APP_CHUNK_BYTES, HOSTED_MACOS_APP_SLOTS, RECORDING_CAP_BYTES, RECORDING_FOOTAGE_MS, RECORDING_PLATFORMS, archiveDir, assertHostedDeviceLedger, buildWorkerRoot, capDrops, closedSegmentName, compileGrep, createAgentActionReader, createDebugLog, deviceHostArea, deviceHostRoot, deviceViewersDir, footageDrops, getConcurrencyLimits, getParkedMax, hostedAndroidPlacements, hostedAppArea, hostedAppAttempt, hostedAppBlobs, hostedDeviceId, hostedIosPlacements, hostedMacosBundleId, hostedMacosLogsDir, hostedNativeLogsDir, isJournalExpired, isJsonObject, isSetupJournalPrunable, listRecordedDevices, listSegments, loadConfig, machineCapacity, macosAppState, openSegmentName, parseHostedAppOffer, parseHostedLocalDeviceCount, parseHostedLogsCursor, parseHostedNativeOffer, parseHostedOfferRequest, parseHostedPlatformDevice, parseHostedRequest, parseNdjsonLine, pinnedEndpoint, queryJsonLogs, readArchive, readArchiveState, readBuildHistory, readBuildMachines, readDeviceHostMachines, readHostedApp, readHostedAppMetadata, readHostedDevice, readHostedDeviceLedger, readHostedMacosApp, readHostedNativeLogsCheckpoint, readHostedSessions, readJsonObject, readLogTimeline, readLogsSince, readMacosRecord, readSetupJournal, readWorkspaceState, recordingDeviceName, rememberHostedAppBlobRename, saturation, serverSetupDir, settingDefinition, settingValueError, setupJournalFile, sortByTs, stimBuildDigest, tryAcquireBuildSlotClaim, validHostedAppBlob, validRunId, workspaceRecordingsDir } from "@stim-cli/core/state";
 import { accessSync, appendFileSync, chmodSync, closeSync, constants, copyFileSync, cpSync, createReadStream, existsSync, futimesSync, lstatSync, mkdirSync, mkdtempSync, openSync, readFileSync, readSync, readdirSync, readlinkSync, realpathSync, renameSync, rmSync, rmdirSync, statSync, statfsSync, watch, writeFileSync, writeSync } from "node:fs";
 import { availableParallelism, cpus, freemem, homedir, hostname, loadavg, tmpdir, totalmem } from "node:os";
 import { parseArgs } from "node:util";
@@ -848,15 +848,27 @@ function answersAs(health, expected) {
 	return !health.stimBuild || !expected.stimBuild || health.stimBuild === expected.stimBuild;
 }
 const packageNames = (entries) => entries.map((entry) => isJsonObject(entry) ? `${String(entry.name)}@${String(entry.version)}` : "?").join(", ");
-/** Why `npm audit signatures --json` output does not vouch for every installed package, or null when it does. */
-function signatureProblem(output) {
+const lastLines = (text) => text.trim().split("\n").slice(-8).join("\n");
+/**
+* Why `npm audit signatures --json` output does not vouch for every installed package, or null when it does. When npm
+* fails it prints `{"error":{"summary","detail"}}` on stdout, or only text on stderr; the message carries that error.
+*/
+function signatureProblem(output, stderr = "") {
 	let report;
 	try {
 		report = JSON.parse(output);
 	} catch {
-		return "npm audit signatures did not print a JSON report";
+		report = null;
+	}
+	if (isJsonObject(report) && isJsonObject(report.error)) {
+		const { summary, detail } = report.error;
+		const text = [summary, detail].filter((part) => typeof part === "string" && part.trim() !== "");
+		if (text.length) return `npm audit signatures failed: ${text.map((part) => part.trim()).join(" ")}`;
+	}
+	if (!isJsonObject(report) || !Array.isArray(report.invalid) || !Array.isArray(report.missing)) {
+		const error = lastLines(stderr);
+		return `npm audit signatures did not print a JSON report${error ? `:\n${error}` : ""}`;
 	}
-	if (!isJsonObject(report) || !Array.isArray(report.invalid) || !Array.isArray(report.missing)) return "npm audit signatures did not print a JSON report";
 	if (report.invalid.length) return `npm found invalid registry signatures or attestations: ${packageNames(report.invalid)}`;
 	if (report.missing.length) return `npm found packages without registry signatures: ${packageNames(report.missing)}`;
 	return null;
@@ -1107,6 +1119,10 @@ function findTailscale(env) {
 	for (const dir of (env.PATH ?? "").split(delimiter)) if (dir && executable(join(dir, "tailscale"))) return join(dir, "tailscale");
 	return executable(MAC_APP_BINARY) ? MAC_APP_BINARY : null;
 }
+function tailscaleInstall(env, isExecutable = executable) {
+	if (isExecutable(MAC_APP_BINARY)) return "app";
+	return (env.PATH ?? "").split(delimiter).some((dir) => dir && isExecutable(join(dir, "tailscale"))) ? "cli" : "none";
+}
 function parseTailscaleStatus(value) {
 	if (!isJsonObject(value) || typeof value.BackendState !== "string") return {
 		state: "unavailable",
@@ -1170,30 +1186,6 @@ function readTailscaleStatus(binary, env, timeoutMs = TIMEOUT_MS$1) {
 		});
 	});
 }
-function tailscaleStatus(binary, env) {
-	if (!binary) return {
-		state: "unavailable",
-		reason: "the tailscale command was not found"
-	};
-	try {
-		const output = execFileSync(binary, ["status", "--json"], {
-			env,
-			timeout: TIMEOUT_MS$1,
-			encoding: "utf8",
-			stdio: [
-				"ignore",
-				"pipe",
-				"ignore"
-			]
-		});
-		return parseTailscaleStatus(JSON.parse(output));
-	} catch (error) {
-		return {
-			state: "unavailable",
-			reason: `\`tailscale status --json\` failed: ${error.message}`
-		};
-	}
-}
 function reaches(address, target, hosts) {
 	if (typeof address !== "string") return null;
 	let url;
@@ -1540,7 +1532,7 @@ async function waitForHealth(port, label) {
 }
 async function prepareRoute(port, previous) {
 	const binary = findTailscale(process.env);
-	const status = tailscaleStatus(binary, process.env);
+	const status = await readTailscaleStatus(binary, process.env);
 	if (!binary || status.state !== "running") throw new ServiceError("--serve needs Tailscale running on this Mac, and the tailscale command on PATH.");
 	const plan = planServe(await serveRoute(binary, process.env, port, status.ips), port, previous?.serve ?? null);
 	if ("refusal" in plan) throw new ServiceError(plan.refusal);
@@ -1818,7 +1810,7 @@ async function uninstallJob(label) {
 	let routeOff = null;
 	const tailscale = findTailscale(process.env);
 	if (installed.serve?.created && installed.port !== null) {
-		const status = tailscaleStatus(tailscale, process.env);
+		const status = await readTailscaleStatus(tailscale, process.env);
 		if (!tailscale || status.state !== "running") throw new ServiceError(`${label} created the tailscale serve route on https port ${installed.serve.port}, and Tailscale is not answering, so uninstall cannot check it. Start Tailscale and run this again.`);
 		const route = await serveRoute(tailscale, process.env, installed.port, status.ips);
 		if (route.state === "routed" && route.port === installed.serve.port) routeOff = installed.serve.port;
@@ -1900,7 +1892,6 @@ function serverBuild(script) {
 	}
 }
 const describeBuild = (build) => `stim-server ${build.version}${build.stimBuild ? ` (Stim build ${build.stimBuild})` : ""}`;
-const lastLines = (text) => text.trim().split("\n").slice(-8).join("\n");
 function sameFile(a, b) {
 	try {
 		return realpathSync(a) === realpathSync(b);
@@ -1931,6 +1922,32 @@ function installedIntegrity(staging) {
 		return null;
 	}
 }
+/**
+* The uploaded package files by package name, as `file:` specs. npm `audit signatures` skips a node only when its
+* dependent's spec is a file spec (npm lib/utils/verify-signatures.js), so the staging project lists every uploaded
+* package as a direct dependency and overrides every edge to it with `$name`.
+*/
+async function localPackageSpecs(dir, names) {
+	const specs = {};
+	for (const file of names) {
+		const path = join(dir, file);
+		const manifest = await run$2("/usr/bin/tar", [
+			"-xzOf",
+			path,
+			"package/package.json"
+		], process.env, 6e4);
+		let name;
+		try {
+			name = JSON.parse(manifest.stdout).name;
+		} catch {
+			name = null;
+		}
+		if (!manifest.ok || typeof name !== "string" || !name) throw new ServiceError(`${path} is not an npm package file.${manifest.ok ? "" : `\n${lastLines(manifest.stderr)}`}`);
+		if (specs[name]) throw new ServiceError(`${dir} has more than one package file for ${name}.`);
+		specs[name] = `file:${path}`;
+	}
+	return specs;
+}
 async function installServer(versions, source, node, log) {
 	mkdirSync(versions, { recursive: true });
 	for (const entry of readdirSync(versions)) if (entry.startsWith(".install-")) rmSync(join(versions, entry), {
@@ -1944,6 +1961,7 @@ async function installServer(versions, source, node, log) {
 		const registry = [`--registry=${REGISTRY}`, `--@stim-cli:registry=${REGISTRY}`];
 		let files = [];
 		let specs;
+		let localPackages = null;
 		if ("release" in source) specs = [`${SERVER_PACKAGE}@${source.release}`];
 		else {
 			const names = readdirSync(source.from).filter((name) => name.endsWith(".tgz"));
@@ -1952,9 +1970,16 @@ async function installServer(versions, source, node, log) {
 				name,
 				sha256: createHash("sha256").update(readFileSync(join(source.from, name))).digest("hex")
 			}));
-			specs = names.map((name) => join(source.from, name));
-		}
-		writeFileSync(join(staging, "package.json"), "{ \"private\": true }\n");
+			specs = [];
+			localPackages = await localPackageSpecs(source.from, names);
+		}
+		const overrides = localPackages && Object.fromEntries(Object.keys(localPackages).map((name) => [name, `$${name}`]));
+		const project = localPackages ? {
+			private: true,
+			dependencies: localPackages,
+			overrides
+		} : { private: true };
+		writeFileSync(join(staging, "package.json"), `${JSON.stringify(project, null, 2)}\n`);
 		log(`Installing ${"release" in source ? `${SERVER_PACKAGE}@${source.release} from ${REGISTRY}` : `${files.length} package file(s) from ${source.from}`}.`);
 		const installed = await run$2(npm, [
 			"install",
@@ -1969,14 +1994,15 @@ async function installServer(versions, source, node, log) {
 			...specs
 		], env, NPM_TIMEOUT_MS);
 		if (!installed.ok) throw new ServiceError(`npm install failed:\n${lastLines(installed.stderr)}`);
-		const problem = signatureProblem((await run$2(npm, [
+		const audit = await run$2(npm, [
 			"audit",
 			"signatures",
 			"--json",
 			"--prefix",
 			staging,
 			...registry
-		], env, NPM_TIMEOUT_MS)).stdout);
+		], env, NPM_TIMEOUT_MS);
+		const problem = signatureProblem(audit.stdout, audit.stderr);
 		if (problem) throw new ServiceError(`${problem}. Not switching to it.`);
 		const script = join(staging, ...SERVER_SCRIPT);
 		const build = existsSync(script) ? serverBuild(script) : null;
@@ -2569,8 +2595,7 @@ var BuildHost = class {
 	retained = /* @__PURE__ */ new Map();
 	closed = false;
 	draining = null;
-	toolchainAt = 0;
-	toolchainValue = null;
+	toolchains = /* @__PURE__ */ new Map();
 	options;
 	sweeping = Promise.resolve();
 	queued = null;
@@ -2624,11 +2649,17 @@ var BuildHost = class {
 	clientDir(client) {
 		return join(this.root(), client);
 	}
-	toolchain() {
-		if (this.toolchainValue && Date.now() - this.toolchainAt < this.limits.toolchainTtlMs) return this.toolchainValue;
-		this.toolchainAt = Date.now();
-		this.toolchainValue = new Promise((resolve) => {
-			const child = spawn(process.execPath, [this.options.worker, "offer"], {
+	toolchain(rubyVersion = null) {
+		const now = Date.now();
+		for (const [context, entry] of this.toolchains) if (now - entry.at >= this.limits.toolchainTtlMs) this.toolchains.delete(context);
+		const cached = this.toolchains.get(rubyVersion);
+		if (cached) return cached.value;
+		const value = new Promise((resolve) => {
+			const child = spawn(process.execPath, [
+				this.options.worker,
+				"offer",
+				...rubyVersion ? [rubyVersion] : []
+			], {
 				env: this.options.env,
 				stdio: [
 					"ignore",
@@ -2644,21 +2675,26 @@ var BuildHost = class {
 			child.on("close", () => {
 				clearTimeout(timer);
 				try {
-					const value = JSON.parse(out);
-					resolve(isJsonObject(value) ? value : null);
+					const report = JSON.parse(out);
+					resolve(isJsonObject(report) ? report : null);
 				} catch {
 					resolve(null);
 				}
 			});
 		});
-		this.toolchainValue.then((value) => {
-			if (!value) this.toolchainValue = null;
+		this.toolchains.set(rubyVersion, {
+			at: now,
+			value
+		});
+		value.then((result) => {
+			if (!result && this.toolchains.get(rubyVersion)?.value === value) this.toolchains.delete(rubyVersion);
 		});
-		return this.toolchainValue;
+		return value;
 	}
 	async offer(client, params) {
 		if (!isJsonObject(params) || !validRepo(params.repo)) return refusal("bad-request", "build.offer needs params.repo.");
-		const toolchain = await this.toolchain();
+		if (params.rubyVersion !== void 0 && (typeof params.rubyVersion !== "string" || !new RegExp(protocol_exports.BUILD_RUBY_VERSION_PATTERN).test(params.rubyVersion))) return refusal("bad-request", "build.offer needs a Ruby installation name without path separators.");
+		const toolchain = await this.toolchain(params.rubyVersion ?? null);
 		if (!toolchain) return refusal("build-refused", "This Mac could not read its build toolchain.");
 		const root = this.root();
 		mkdirSync(root, {
@@ -2670,9 +2706,18 @@ var BuildHost = class {
 		try {
 			lockfile = readFileSync(join(area, "lockfile"), "utf8");
 		} catch {}
+		const available = await readAvailableMemory();
+		const total = totalmem();
+		const memory = available === null ? {} : {
+			memoryTotalBytes: total,
+			memoryUsedBytes: total - available
+		};
 		return { result: {
 			toolchain,
-			capacity: this.capacity(),
+			capacity: {
+				...this.capacity(),
+				...memory
+			},
 			warm: {
 				checkout: existsSync(join(area, "src")),
 				dependencies: typeof params.lockfile === "string" && lockfile === params.lockfile,
@@ -3499,6 +3544,11 @@ function setupVersionDecision(current, desired, managed) {
 	if (managed && compareVersions(current, desired) < 0) return "update";
 	return compareVersions(current.replace(/-.*/, ""), SETUP_MIN_VERSION) < 0 ? "too-old" : "reuse";
 }
+function tailscaleRefusal(install) {
+	if (install === "none") return "Install Tailscale on this Mac and sign in to the same tailnet: https://tailscale.com/download/mac";
+	if (install === "app") return "Turn on Tailscale from its menu bar icon on this Mac, then run this again.";
+	return "Run tailscale up on this Mac, then run this again.";
+}
 function setupExitCode(journal) {
 	if (journal.steps.some((s) => s.state === "failed")) return 1;
 	if (journal.granted.length === 0) return 2;
@@ -3544,7 +3594,7 @@ async function confirmSetup(input, question, timeoutMs) {
 	input.on("SIGINT", interrupt);
 	input.on("close", interrupt);
 	try {
-		return /^(y|yes)$/i.test((await input.question(question, { signal: controller.signal })).trim());
+		return /^(|y|yes)$/i.test((await input.question(question, { signal: controller.signal })).trim());
 	} catch (error) {
 		if (controller.signal.reason instanceof SetupRefusal) throw controller.signal.reason;
 		if (error.name === "AbortError") return false;
@@ -3556,6 +3606,15 @@ async function confirmSetup(input, question, timeoutMs) {
 		input.close();
 	}
 }
+const discardInput = () => void 0;
+async function discardTypedAhead(stream) {
+	if (!stream.isTTY) return;
+	stream.on("data", discardInput);
+	stream.resume();
+	await sleep(300);
+	stream.off("data", discardInput);
+	stream.pause();
+}
 function defaultSetupDeps() {
 	return {
 		now: Date.now,
@@ -3564,10 +3623,13 @@ function defaultSetupDeps() {
 		display: setupDisplayFor(process.stdout.isTTY === true, process.env, (text) => void process.stdout.write(text)),
 		stdout: (line) => console.log(line),
 		stderr: (line) => console.error(line),
-		confirm: (question, timeoutMs) => confirmSetup(createInterface({
-			input: process.stdin,
-			output: process.stderr
-		}), question, timeoutMs),
+		confirm: async (question, timeoutMs) => {
+			await discardTypedAhead(process.stdin);
+			return confirmSetup(createInterface({
+				input: process.stdin,
+				output: process.stderr
+			}), question, timeoutMs);
+		},
 		permissionWait(ms) {
 			if (!process.stdin.isTTY) return sleep(ms).then(() => false);
 			return new Promise((resolve, reject) => {
@@ -3594,7 +3656,7 @@ function defaultSetupDeps() {
 			if (process.platform !== "darwin") throw new SetupRefusal("setup runs only on macOS.");
 			if (compareVersions(process.versions.node, "22.12.0") < 0) throw new SetupRefusal("setup needs Node 22.12 or later.");
 			const status = await readRawTailscaleStatus(binary(), process.env);
-			if (!isJsonObject(status) || !isJsonObject(status.Self) || typeof status.Self.DNSName !== "string" || !status.Self.DNSName) throw new SetupRefusal("Start Tailscale on this Mac: tailscale up.");
+			if (!isJsonObject(status) || !isJsonObject(status.Self) || typeof status.Self.DNSName !== "string" || !status.Self.DNSName) throw new SetupRefusal(tailscaleRefusal(tailscaleInstall(process.env)));
 			if (!isJsonObject(status.Peer) || !Object.values(status.Peer).some((p) => isJsonObject(p) && p.ID === options.nodeId)) throw new SetupRefusal("That Mac is not on this tailnet");
 			if (!(await run$2("launchctl", ["print", `gui/${process.getuid?.()}`])).ok) throw new SetupRefusal("Log in to a GUI session on this Mac before running setup.");
 			return { dnsName: status.Self.DNSName.replace(/\.$/, "") };
@@ -3743,9 +3805,9 @@ const capabilityNoun = (capability) => capability === "build" ? "builds" : "host
 function approvalQuestion(concise, name, capability, nodeId) {
 	if (!concise) {
 		const verb = capability === "build" ? "build on this Mac" : "host simulators on this Mac";
-		return `${name} (node ${nodeId.slice(0, 4)}...) asks to ${verb}. Approve? [y/N] `;
+		return `${name} (node ${nodeId.slice(0, 4)}...) asks to ${verb}. Approve? [Y/n] `;
 	}
-	return `Approve ${name} to ${capability === "build" ? "build here (runs its project code" : "host simulators here (runs its app code"} on this Mac)? [y/N] `;
+	return `Approve ${name} to ${capability === "build" ? "build here (runs its project code" : "host simulators here (runs its app code"} on this Mac)? [Y/n] `;
 }
 function serverText(desktop, decision, version) {
 	if (desktop) return `using the app's stim-server ${version}`;
@@ -4125,6 +4187,93 @@ async function runSetup(args, version, deps) {
 	return journal.exit;
 }
 //#endregion
+//#region src/request-log.ts
+const SLOW_MS = 1e3;
+const METHOD = /^[a-z][a-z0-9.-]{0,47}$/;
+const ERROR_REPEAT_MS = 6e4;
+const MAX_REMEMBERED = 256;
+/** One token of a service-log line: no whitespace or control characters, so a client cannot forge another field or line. */
+const printable = (value) => String(value).replace(/[^\x21-\x7e]+/g, "_").slice(0, 80);
+const text = (fields) => Object.entries(fields).filter(([, value]) => value !== void 0 && value !== null).map(([key, value]) => `${key}=${printable(value)}`).join(" ");
+/**
+* Request timing for stim-server. An error reply always goes to the service log (stderr), once a minute per
+* client, method and code. With debug logging on, every request goes to the service log and to
+* `logs/debug/server.ndjson` with its duration and the slow steps. Lines carry the method, the client's device id,
+* the CLI run id, durations and the error code: never params, messages, tokens or tickets.
+*/
+function createRequestLog({ service = (line) => console.error(line), debug = createDebugLog("server"), now = Date.now } = {}) {
+	const lastError = /* @__PURE__ */ new Map();
+	const errorDue = (key) => {
+		const at = now();
+		const last = lastError.get(key);
+		if (last !== void 0 && at - last < ERROR_REPEAT_MS) return false;
+		lastError.delete(key);
+		lastError.set(key, at);
+		if (lastError.size > MAX_REMEMBERED) lastError.delete(lastError.keys().next().value);
+		return true;
+	};
+	return {
+		track() {
+			let client = {
+				id: null,
+				runId: null
+			};
+			const inflight = /* @__PURE__ */ new Map();
+			return {
+				identify(next) {
+					client = next;
+				},
+				begin(id, method) {
+					if (id === null) return;
+					if (inflight.size >= MAX_REMEMBERED) inflight.delete(inflight.keys().next().value);
+					inflight.set(id, {
+						method: METHOD.test(method) ? method : "unknown",
+						start: now(),
+						steps: {}
+					});
+				},
+				step(id, name, ms) {
+					const entry = inflight.get(id);
+					if (entry) entry.steps[name] = Math.round(ms);
+				},
+				reply(message) {
+					if (!message || typeof message !== "object" || !("id" in message)) return;
+					const { id, error } = message;
+					const entry = inflight.get(id);
+					if (entry) inflight.delete(id);
+					if (!entry && !error) return;
+					const code = error ? String(error.code ?? "error").slice(0, 64) : void 0;
+					const method = entry?.method ?? "unknown";
+					const ms = entry ? now() - entry.start : void 0;
+					const fields = {
+						method,
+						client: client.id ?? void 0,
+						run: client.runId ?? void 0,
+						ms,
+						...ms !== void 0 && ms >= SLOW_MS ? { slow: true } : {},
+						...entry?.steps,
+						error: code
+					};
+					if (debug.enabled()) {
+						service(`stim-server: debug request ${text(fields)}`);
+						const { run, ...rest } = fields;
+						debug.log("request", {
+							...rest,
+							runId: run
+						});
+					} else if (code !== void 0 && errorDue(`${client.id}|${method}|${code}`)) service(`stim-server: request failed ${text(fields)}`);
+				}
+			};
+		},
+		host(event, fields, failed = false) {
+			if (debug.enabled()) {
+				service(`stim-server: debug ${event} ${text(fields)}`);
+				debug.log(event, fields);
+			} else if (failed && errorDue(`host|${event}|${String(fields.host)}`)) service(`stim-server: ${event} ${text(fields)}`);
+		}
+	};
+}
+//#endregion
 //#region src/agent-driver.ts
 /** The driver cannot run or cannot scope an app; the message is safe to show a client. */
 var AgentDriverUnavailable = class extends Error {};
@@ -8780,6 +8929,7 @@ var LatestFrames = class {
 //#endregion
 //#region src/hosted-relay.ts
 const TIMEOUT_MS = 1e4;
+const REQUEST_TIMEOUT_MS = 2e4;
 const KEYFRAME_RETRY_MS = 1e3;
 const CONGESTION_NOTICE_MS = 250;
 function routeOf(message) {
@@ -8802,6 +8952,8 @@ var Upstream = class {
 	users = 0;
 	features = [];
 	onClose = null;
+	connectMs = 0;
+	helloMs = 0;
 	token;
 	constructor(endpoint, token) {
 		this.token = token;
@@ -8868,6 +9020,7 @@ var Upstream = class {
 	}
 	/** Connects and says hello with the token; the host must grant `capability` to this Mac. */
 	async open(version, capability = "device-host") {
+		const started = Date.now();
 		await new Promise((resolve, reject) => {
 			const done = (error) => {
 				clearTimeout(timer);
@@ -8888,6 +9041,7 @@ var Upstream = class {
 			this.socket.once("close", closed);
 			this.socket.once("error", failed);
 		});
+		this.connectMs = Date.now() - started;
 		const reply = await this.request("hello", {
 			protocol: 1,
 			client: {
@@ -8896,6 +9050,7 @@ var Upstream = class {
 			},
 			auth: { deviceToken: this.token }
 		});
+		this.helloMs = Date.now() - started - this.connectMs;
 		if ("error" in reply) throw new Error(reply.error.message);
 		if (!isJsonObject(reply.result) || !Array.isArray(reply.result.capabilities) || !reply.result.capabilities.includes(capability)) throw new Error(`the host did not grant ${capability} access`);
 		if (Array.isArray(reply.result.features)) this.features = reply.result.features.filter((feature) => typeof feature === "string");
@@ -8904,7 +9059,7 @@ var Upstream = class {
 		if (this.ended) return Promise.reject(this.ended);
 		return new Promise((resolve, reject) => {
 			const id = this.nextId++;
-			const timer = setTimeout(() => this.fail(`the host did not answer ${method} in time`), TIMEOUT_MS);
+			const timer = setTimeout(() => this.fail(`the host was busy or slow: it did not answer ${method} within ${REQUEST_TIMEOUT_MS / 1e3} seconds`), REQUEST_TIMEOUT_MS);
 			this.pending.set(id, {
 				resolve: (reply) => {
 					clearTimeout(timer);
@@ -8977,6 +9132,7 @@ var HostConnections = class {
 	/** Checks the credential and pinned node on every call, then joins or opens the connection to that endpoint. */
 	async acquire(host) {
 		let token = "";
+		const started = Date.now();
 		try {
 			const credential = readDeviceHostMachines().find((entry) => entry.machine === host.machine);
 			if (!credential || credential.state !== "approved") throw new Error("no approved device-host credential");
@@ -8992,6 +9148,7 @@ var HostConnections = class {
 				endpoint.host
 			]);
 			let entry = this.open.get(key);
+			const created = !entry;
 			if (!entry) {
 				const connection = new Upstream(endpoint, token);
 				const opened = {
@@ -9012,10 +9169,24 @@ var HostConnections = class {
 				lease.release();
 				throw cause;
 			}
+			this.options.log?.("host_connect", {
+				host: host.machine,
+				ms: Date.now() - started,
+				...created ? {
+					connectMs: entry.connection.connectMs,
+					helloMs: entry.connection.helloMs
+				} : { reused: true }
+			});
 			return lease;
 		} catch (cause) {
 			const reason = cause.message;
-			throw new Error(token ? reason.replaceAll(token, "[redacted]") : reason, { cause });
+			const safe = token ? reason.replaceAll(token, "[redacted]") : reason;
+			this.options.log?.("host_connect", {
+				host: host.machine,
+				ms: Date.now() - started,
+				error: safe.slice(0, 200)
+			}, true);
+			throw new Error(safe, { cause });
 		}
 	}
 	close() {
@@ -13009,7 +13180,9 @@ function take(bucket, cost, perSecond, capacity) {
 	bucket.tokens -= cost;
 	return true;
 }
+const trackers = /* @__PURE__ */ new WeakMap();
 function send(socket, message) {
+	if (typeof message !== "string") trackers.get(socket)?.reply(message);
 	if (socket.readyState === socket.OPEN) socket.send(typeof message === "string" ? message : JSON.stringify(message));
 }
 function buildAllowed(session) {
@@ -13111,6 +13284,7 @@ async function startServer(options) {
 		}
 		return hostProbe;
 	};
+	const requestLog = options.requestLog ?? createRequestLog();
 	const limiter = new FailureLimiter(options.maxAuthFailures ?? 5, options.failureWindowMs ?? 6e4);
 	const authTimeoutMs = options.authTimeoutMs ?? 5e3;
 	const feeds = new FeedPool(options.stimCli, options.env);
@@ -13425,7 +13599,10 @@ async function startServer(options) {
 		limits: options.pushLimits
 	});
 	const relays = /* @__PURE__ */ new Map();
-	const hostConnections = new HostConnections(options.hostedRelay ?? { status: () => readRawTailscaleStatus(tailscaleNow().binary, options.env) }, options.serverVersion);
+	const hostConnections = new HostConnections({
+		...options.hostedRelay ?? { status: () => readRawTailscaleStatus(tailscaleNow().binary, options.env) },
+		log: requestLog.host
+	}, options.serverVersion);
 	let revocationCheck = null;
 	let checkedRegistry = null;
 	const checkRevocations = () => {
@@ -13489,6 +13666,9 @@ async function startServer(options) {
 		const commands = /* @__PURE__ */ new Set();
 		let nextSubscription = 1;
 		let device = null;
+		const tracker = requestLog.track();
+		trackers.set(socket, tracker);
+		let runId = null;
 		let buildSession = null;
 		let queue = Promise.resolve();
 		let archiveReads = Promise.resolve();
@@ -13529,7 +13709,15 @@ async function startServer(options) {
 			if (!isJsonObject(params) || !auth || !isJsonObject(params.client)) return refuse(id, "bad-request", "hello needs params.client and params.auth.", CLOSE_BAD_REQUEST);
 			if (params.protocol !== protocol_exports.PROTOCOL_VERSION) return refuse(id, "protocol-unsupported", `This server speaks protocol ${protocol_exports.PROTOCOL_VERSION}.`, CLOSE_BAD_REQUEST);
 			clearTimeout(timer);
+			runId = validRunId(params.client.runId);
+			tracker.identify({
+				id: null,
+				runId
+			});
+			const probing = hostHealth();
+			const whoisStarted = Date.now();
 			const identity = await identify();
+			tracker.step(id, "whois", Date.now() - whoisStarted);
 			if (socket.readyState !== socket.OPEN) return;
 			if (!identity) return refuse(id, "identity-unavailable", `tailscale whois did not identify ${peer}.`, CLOSE_UNAUTHORIZED);
 			let outcome;
@@ -13583,8 +13771,15 @@ async function startServer(options) {
 				return;
 			}
 			device = outcome.device;
+			tracker.identify({
+				id: device.id,
+				runId
+			});
 			sessions.set(socket, device);
 			sampler.start();
+			const probeWaited = Date.now();
+			const host = options.host ? await probing : void 0;
+			if (options.host) tracker.step(id, "probe", Date.now() - probeWaited);
 			send(socket, {
 				id,
 				result: {
@@ -13595,7 +13790,7 @@ async function startServer(options) {
 						stim: options.stimVersion,
 						home: homedir()
 					},
-					...options.host ? { host: await hostHealth() } : {},
+					...options.host ? { host } : {},
 					capabilities: device.capabilities,
 					features: [...protocol_exports.FEATURES],
 					actions: device.capabilities.includes("control") ? [...protocol_exports.ACTIONS] : [],
@@ -14743,6 +14938,7 @@ async function startServer(options) {
 				});
 				return refuse(id, "bad-request", "Expected {id, method, params}.", CLOSE_BAD_REQUEST);
 			}
+			tracker.begin(id, message.method);
 			if (message.method === "hello") return hello(id, message.params);
 			if (!device) return refuse(id, "unauthorized", "Send hello first.", CLOSE_UNAUTHORIZED);
 			if (protocol_exports.DEVICE_HOST_METHODS.includes(message.method)) {
@@ -14939,6 +15135,10 @@ async function startServer(options) {
 			return;
 		}
 		const peer = peerAddress(request);
+		if (options.loopbackOnly && peer !== null) {
+			socket.end("HTTP/1.1 403 Forbidden\r\nConnection: close\r\nContent-Length: 0\r\n\r\n");
+			return;
+		}
 		if (limiter.blocked(peer ?? "local")) {
 			socket.end("HTTP/1.1 429 Too Many Requests\r\nConnection: close\r\nContent-Length: 0\r\n\r\n");
 			return;
@@ -14980,7 +15180,8 @@ async function startServer(options) {
 			},
 			tailscale: healthTailscale(tailscale),
 			route,
-			nativeViewerOpened
+			nativeViewerOpened,
+			...options.loopbackOnly ? { loopbackOnly: true } : {}
 		};
 		response.writeHead(startup.state === "ready" ? 200 : 503, { "content-type": "application/json" }).end(JSON.stringify(body));
 	};
@@ -15027,6 +15228,10 @@ async function startServer(options) {
 	};
 	async function listenOn(host) {
 		const server = createServer$1((request, response) => {
+			if (options.loopbackOnly && peerAddress(request) !== null) {
+				response.writeHead(403, { "content-type": "text/plain" }).end("This stim-server serves this Mac only.\n");
+				return;
+			}
 			if (localHealthRequest(request)) {
 				answerHealth(response);
 				return;
@@ -15095,7 +15300,7 @@ async function startServer(options) {
 	const monitor = options.tailscaleMonitor;
 	const listenFailures = /* @__PURE__ */ new Set();
 	const reconcile = async (snapshot) => {
-		const tailnet = snapshot.state.state === "running" ? snapshot.state.ips : [];
+		const tailnet = snapshot.state.state === "running" && !options.loopbackOnly ? snapshot.state.ips : [];
 		const wanted = /* @__PURE__ */ new Set([...options.hosts, ...tailnet]);
 		for (const [host, listener] of servers) {
 			if (wanted.has(host)) continue;
@@ -15247,8 +15452,9 @@ function watchTailscale(options) {
 //#endregion
 //#region bin/stim-server.ts
 const USAGE = `Usage:
-  stim-server [--port <n>] [--env KEY=VALUE]... [--path-prepend <dir>]...
+  stim-server [--port <n>] [--loopback-only] [--env KEY=VALUE]... [--path-prepend <dir>]...
                                     serve paired clients (default port ${DEFAULT_PORT});
+                                    --loopback-only serves this Mac only (127.0.0.1, no remote peers);
                                     --env and --path-prepend apply after the login shell's environment
   stim-server setup --client <node-id> --ticket <t> --expires <iso>
                     [--build] [--device-host] [--port <n>] [--label <name>]
@@ -15298,7 +15504,7 @@ function routeNote(route, port) {
 function macName(tailscale) {
 	return tailscale.state === "running" && tailscale.hostName || hostname();
 }
-async function serve(port, extraEnv, pathPrepend) {
+async function serve(port, extraEnv, pathPrepend, loopbackOnly) {
 	const captureHost = hostFromExecutable(process.env.STIM_HOST_EXECUTABLE);
 	const login = loginShellEnvironment();
 	if (!login) console.error("stim-server: could not read the login shell environment; using this process environment.");
@@ -15309,7 +15515,7 @@ async function serve(port, extraEnv, pathPrepend) {
 	if (process.env.STIM_HOME) env.STIM_HOME = process.env.STIM_HOME;
 	const launchdLabel = process.env.XPC_SERVICE_NAME;
 	const tailscaleBinary = findTailscale(env);
-	const tailscale = tailscaleStatus(tailscaleBinary, env);
+	const tailscale = await readTailscaleStatus(tailscaleBinary, env);
 	const stim = bundledStim();
 	const monitor = watchTailscale({
 		env,
@@ -15324,6 +15530,7 @@ async function serve(port, extraEnv, pathPrepend) {
 			name: macName(tailscale),
 			host: captureHost,
 			hosts: ["127.0.0.1"],
+			...loopbackOnly ? { loopbackOnly: true } : {},
 			port,
 			stimCli: stim.cli,
 			stimVersion: stim.version,
@@ -15354,13 +15561,13 @@ async function serve(port, extraEnv, pathPrepend) {
 		}
 		if (note) console.error(note);
 	};
-	await announce(tailscaleBinary, tailscale);
-	monitor.onChange((snapshot, previous) => {
+	if (!loopbackOnly) monitor.onChange((snapshot, previous) => {
 		const { state } = snapshot;
 		if (state.state === "running") console.log("Tailscale is running.");
 		else if (previous.state.state === "running") console.error("Tailscale stopped.");
 		if (state.state === "running" || previous.state.state === "running") announce(snapshot.binary, state);
 	});
+	if (!loopbackOnly) await announce(tailscaleBinary, tailscale);
 	const shutdown = () => {
 		monitor.stop();
 		server.close().catch((error) => {
@@ -15384,7 +15591,7 @@ const SCOPE_TEXT = {
 };
 async function pair(port, json, control) {
 	const binary = findTailscale(process.env);
-	const tailscale = tailscaleStatus(binary, process.env);
+	const tailscale = await readTailscaleStatus(binary, process.env);
 	let endpoint = `ws://127.0.0.1:${port}`;
 	let note = tailscaleNote(tailscale);
 	if (note) note = `${note} The endpoint above only works on this Mac.`;
@@ -15491,6 +15698,7 @@ async function main() {
 		allowPositionals: true,
 		options: {
 			port: { type: "string" },
+			"loopback-only": { type: "boolean" },
 			json: { type: "boolean" },
 			control: { type: "boolean" },
 			read: { type: "boolean" },
@@ -15533,7 +15741,8 @@ async function main() {
 	}
 	if ((values.label !== void 0 || values.serve) && !service) fail(`--label and --serve apply only to \`service\`.\n${USAGE}`);
 	if ((values.release !== void 0 || values.from !== void 0) && !service) fail(`--release and --from apply only to \`service update\`.\n${USAGE}`);
-	if (command === void 0) return serve(port, extraEnv, pathPrepend);
+	if (values["loopback-only"] && command !== void 0) fail(`--loopback-only applies only to serving.\n${USAGE}`);
+	if (command === void 0) return serve(port, extraEnv, pathPrepend, values["loopback-only"] === true);
 	const grant = command === "devices" && sub === "grant";
 	if (values.read && !grant) fail(`--read applies only to \`devices grant\`.\n${USAGE}`);
 	if (values.build && !grant) fail(`--build applies only to \`devices grant\`.\n${USAGE}`);

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-CGqz0EFG.mjs");
+} else import("./stim-server-BR9FPA63.mjs");
 //#endregion
 export {};

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@stim-cli/server",
-  "version": "1.17.1",
+  "version": "1.18.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,8 @@
     "./protocol.schema.json": "./dist/protocol.schema.json"
   },
   "dependencies": {
-    "@stim-cli/core": "^1.17.1",
-    "stim": "1.17.1",
+    "@stim-cli/core": "^1.18.0",
+    "stim": "1.18.0",
     "ws": "^8.21.3"
   },
   "devDependencies": {