stim 1.20.2 → 1.22.0

package/dist/{hosted-android-C3MHGld1.mjs → hosted-android-B-9f-jkd.mjs}

@@ -1,6 +1,7 @@
-import { c as connectHost, s as call } from "./hosted-client-ZEKpS9vw.mjs";
-import { i as requestHostedMetro } from "./metro-gateway-CX9Xlkq2.mjs";
-import { n as prepareHostedNative, r as stopHostedNative, t as placeHostedNative } from "./hosted-native-A4s1QPXe.mjs";
+import { f as throwIfCancelled } from "./operation-exec-BW0em61G.mjs";
+import { c as call, l as connectHost } from "./hosted-client-DZAPrcro.mjs";
+import { i as requestHostedMetro } from "./metro-gateway-CKZqKqx7.mjs";
+import { n as prepareHostedNative, r as stopHostedNative, t as placeHostedNative } from "./hosted-native-BdzE668-.mjs";
 //#region src/device-host/hosted-android.ts
 async function prepareHostedAndroid(machine, selectors, recorded, mode) {
 	return await prepareHostedNative(machine, selectors, recorded, "android", false, mode);
@@ -12,13 +13,14 @@ async function placeHostedAndroid(target, options) {
 		reserved: (placement) => options.reserved(placement)
 	});
 }
-async function stopHostedAndroid(root, slot) {
-	await stopHostedNative(root, slot, "android");
+async function stopHostedAndroid(root, slot, signal) {
+	await stopHostedNative(root, slot, signal, "android");
 }
-async function reopenHostedAndroidMetro(root, placement, clientMetroPort) {
-	const host = await connectHost(placement.machine, void 0, true);
+async function reopenHostedAndroidMetro(root, placement, clientMetroPort, signal) {
+	const host = await connectHost(placement.machine, void 0, true, signal);
 	try {
-		const gateway = await requestHostedMetro(root, placement.session, host.credential);
+		const gateway = await requestHostedMetro(root, placement.session, host.credential, signal);
+		throwIfCancelled(signal, "reload");
 		await call(host, "device-host.metro.open", {
 			session: placement.session,
 			clientMetroPort,

package/dist/{hosted-client-ZEKpS9vw.mjs → hosted-client-DZAPrcro.mjs}

@@ -1,19 +1,22 @@
-import { c as pinnedEndpoint$1 } from "./tailnet-Dh-qiYzG.mjs";
-import { r as throwIfCancelled, t as cancellableSleep } from "./cancellation-C_22VQTH.mjs";
-import { t as BuildConnection, x as configuredMachines } from "./client-qQAaXSUs.mjs";
+import { rt as resolveEndpoint } from "./config-DlrsduwG.mjs";
+import { f as throwIfCancelled, u as cancellableSleep } from "./operation-exec-BW0em61G.mjs";
+import { t as BuildConnection } from "./client-OyRoEuSr.mjs";
+import { u as configuredMachines } from "./selection-DSMbWEX2.mjs";
+import { createHash } from "node:crypto";
 import { lstatSync, readFileSync, readdirSync, readlinkSync } from "node:fs";
 import { join } from "node:path";
-import { DEVICE_HOST_LIMITS, HOSTED_APP_CHUNK_BYTES, hostedMacosAppSlot, hostedWorkerSettleMs, isJsonObject, readDeviceHostMachines } from "@stim-cli/core/state";
-import { createHash } from "node:crypto";
+import { configDir } from "@stim-cli/core";
+import { DEVICE_HOST_LIMITS, HOSTED_APP_CHUNK_BYTES, HOSTED_PARKED_CANDIDATES, hostedMacosAppSlot, hostedWorkerSettleMs, isJsonObject, readDeviceHostMachines } from "@stim-cli/core/state";
 //#region src/device-host/hosted-client.ts
 const CONNECT_TIMEOUT_MS = 1e4;
 const HOSTED_POLL_MARGIN_MS = 45e3;
 const HOSTED_REQUEST_MARGIN_MS = 5e3;
 const workerBoundMs = (deadlineMs) => deadlineMs + hostedWorkerSettleMs();
-const SESSION_TIMEOUT_MS = hostedWorkerSettleMs() + workerBoundMs(DEVICE_HOST_LIMITS.logsMs) + workerBoundMs(DEVICE_HOST_LIMITS.stopMs) + HOSTED_POLL_MARGIN_MS;
+const SESSION_TIMEOUT_MS = hostedWorkerSettleMs() + workerBoundMs(DEVICE_HOST_LIMITS.logsMs) + 2 * workerBoundMs(DEVICE_HOST_LIMITS.stopMs) + HOSTED_POLL_MARGIN_MS;
 const PREPARE_TIMEOUT_MS = workerBoundMs(DEVICE_HOST_LIMITS.prepareMs) + HOSTED_POLL_MARGIN_MS;
 const INSTALL_TIMEOUT_MS = workerBoundMs(DEVICE_HOST_LIMITS.prepareMs) + HOSTED_POLL_MARGIN_MS;
 const OFFER_TIMEOUT_MS = workerBoundMs(DEVICE_HOST_LIMITS.offerMs) + HOSTED_REQUEST_MARGIN_MS;
+const RESERVE_TIMEOUT_MS = HOSTED_PARKED_CANDIDATES * (workerBoundMs(DEVICE_HOST_LIMITS.offerMs) + workerBoundMs(DEVICE_HOST_LIMITS.stopMs)) + workerBoundMs(DEVICE_HOST_LIMITS.offerMs) + HOSTED_REQUEST_MARGIN_MS;
 const sha256 = (content) => createHash("sha256").update(content).digest("hex");
 function credentialRefusal(message, remedy = "Run stim doctor.") {
 	return Object.assign(new Error(message), {
@@ -32,22 +35,26 @@ function hostingCredential(machine) {
 		throw credentialRefusal("The hosting credentials are unreadable. Run stim doctor.");
 	}
 	const credential = credentials.find((each) => each.machine === machine);
-	if (!credential) throw credentialRefusal(`This Mac has not asked ${machine} for hosting access. Run stim doctor --fix.`, "Run stim doctor --fix.");
+	if (!credential) throw credentialRefusal(`This machine has not asked ${machine} for hosting access. Run stim doctor --fix.`, "Run stim doctor --fix.");
 	if (credential.state !== "approved") {
-		const remedy = `A person on ${machine} approves it with stim-server devices grant ${credential.deviceId} --device-host; then run stim doctor.`;
-		throw credentialRefusal(`${machine} has not confirmed hosting access for this Mac. ${remedy}`, remedy);
+		const remedy = `A person on ${machine} runs the stim-server setup command stim doctor --fix printed; then run stim doctor.`;
+		throw credentialRefusal(`${machine} has not confirmed hosting access for this machine. ${remedy}`, remedy);
 	}
 	return credential;
 }
-/** Connects only to the pinned node of an approved remote Mac, and only when it grants `device-host`. */
-async function connectHost(machine, timeoutMs = CONNECT_TIMEOUT_MS, strict = false) {
+/** Connects only to the stim-server that proves it holds the approved machine's pinned key, and only for `device-host`. */
+async function connectHost(machine, timeoutMs = CONNECT_TIMEOUT_MS, strict = false, signal) {
+	signal?.throwIfAborted();
 	const credential = hostingCredential(machine);
-	const target = await pinnedEndpoint$1(credential);
+	const target = await resolveEndpoint(credential, void 0, signal);
+	signal?.throwIfAborted();
 	if (typeof target === "string") throw Object.assign(/* @__PURE__ */ new Error(`Stim does not connect to ${machine}: ${target}.`), { code: "STIM_HOSTING_REFUSED" });
-	const opened = await BuildConnection.open(target, credential.deviceToken, timeoutMs, "device-host").catch((error) => {
+	const opened = await BuildConnection.open(target, credential.serverKey, timeoutMs, "device-host", signal).catch((error) => {
 		throw Object.assign(new Error(`${machine} is unreachable. Check stim-server and its tailnet serve route on ${machine}.`, { cause: error }), { code: strict ? "STIM_HOSTING_REFUSED" : "closed" });
 	});
-	if (!(opened instanceof BuildConnection)) throw Object.assign(/* @__PURE__ */ new Error(opened.refused ? `${machine} refused this Mac: ${opened.failure.replaceAll(credential.deviceToken, "[redacted]").replace(/\.+$/, "")}. Run stim doctor.` : `${machine} is unreachable: ${opened.failure.replaceAll(credential.deviceToken, "[redacted]")}. Check stim-server and its tailnet serve route on ${machine}.`), {
+	if (signal?.aborted && opened instanceof BuildConnection) opened.close();
+	signal?.throwIfAborted();
+	if (!(opened instanceof BuildConnection)) throw Object.assign(/* @__PURE__ */ new Error(opened.code === "server-outdated" ? `${machine} runs a stim-server that speaks an older protocol than this Stim. Run stim doctor for the command that updates it there, then retry.` : opened.refused ? `${machine} refused this machine: ${opened.failure.replace(/\.+$/, "")}. Run stim doctor.` : `${machine} is unreachable: ${opened.failure}. Check stim-server and its tailnet serve route on ${machine}.`), {
 		code: strict ? "STIM_HOSTING_REFUSED" : opened.refused ? "STIM_HOSTING_REFUSED" : opened.code ?? "closed",
 		hostCode: opened.code
 	});
@@ -63,8 +70,8 @@ function requireHostedAppMode(host, platform, mode) {
 }
 const gatewaySecrets = /* @__PURE__ */ new WeakMap();
 function redactHostText(host, message) {
-	for (const secret of [host.credential.deviceToken, gatewaySecrets.get(host)]) if (secret) message = message.replaceAll(secret, "[redacted]");
-	return message;
+	const secret = gatewaySecrets.get(host);
+	return secret ? message.replaceAll(secret, "[redacted]") : message;
 }
 async function call(host, method, params, timeoutMs) {
 	if (method === "device-host.metro.open" && isJsonObject(params) && typeof params.secret === "string") gatewaySecrets.set(host, params.secret);
@@ -92,7 +99,11 @@ async function attach(host, session, timeoutMs, platform = "macos") {
 }
 const probeCache = /* @__PURE__ */ new Map();
 function probeHostedSession(placement, { timeoutMs = 3e3, ttlMs = 1e4 } = {}) {
-	const key = JSON.stringify([placement.machine, placement.session]);
+	const key = JSON.stringify([
+		configDir(),
+		placement.machine,
+		placement.session
+	]);
 	const cached = probeCache.get(key);
 	if (ttlMs > 0 && cached && cached.expiresAt > Date.now()) return cached.promise;
 	const promise = probeSession(placement, timeoutMs);
@@ -145,8 +156,12 @@ async function settle(host, session, passing, timeoutMs, platform = "macos", sig
 	}
 	return session;
 }
+const reason = (session) => session.notice ? `: ${session.notice.replace(/\.+$/, "")}` : "";
 function unknownSession(host, session) {
-	return /* @__PURE__ */ new Error(`The hosted session ${session.id} on ${host.machine} is in an unknown state${session.notice ? `: ${session.notice}` : ""}. Run stim stop to reconcile it.`);
+	return /* @__PURE__ */ new Error(`The hosted session ${session.id} on ${host.machine} is in an unknown state${reason(session)}. Run stim stop to reconcile it.`);
+}
+function stoppedSession(host, session) {
+	return /* @__PURE__ */ new Error(`The hosted session ${session.id} on ${host.machine} stopped before it was ready${reason(session)}. Retry when the host can take it; it needs no stim stop.`);
 }
 function bundleManifest(bundle) {
 	const files = [];
@@ -207,4 +222,4 @@ async function upload(host, ids, missing, content) {
 	}
 }
 //#endregion
-export { attach as a, connectHost as c, probeHostedSession as d, requireHostedAppMode as f, upload as g, unknownSession as h, SESSION_TIMEOUT_MS as i, heldNoLonger as l, sha256 as m, OFFER_TIMEOUT_MS as n, bundleManifest as o, settle as p, PREPARE_TIMEOUT_MS as r, call as s, INSTALL_TIMEOUT_MS as t, hostedSession as u };
+export { unknownSession as _, SESSION_TIMEOUT_MS as a, call as c, hostedSession as d, probeHostedSession as f, stoppedSession as g, sha256 as h, RESERVE_TIMEOUT_MS as i, connectHost as l, settle as m, OFFER_TIMEOUT_MS as n, attach as o, requireHostedAppMode as p, PREPARE_TIMEOUT_MS as r, bundleManifest as s, INSTALL_TIMEOUT_MS as t, heldNoLonger as u, upload as v };

package/dist/{hosted-ios-l-o3iM9J.mjs → hosted-ios-CsCS21hn.mjs}

@@ -1,4 +1,4 @@
-import { n as prepareHostedNative, r as stopHostedNative, t as placeHostedNative } from "./hosted-native-A4s1QPXe.mjs";
+import { n as prepareHostedNative, r as stopHostedNative, t as placeHostedNative } from "./hosted-native-BdzE668-.mjs";
 //#region src/device-host/hosted-ios.ts
 async function prepareHostedIos(machine, selectors, recorded, mode) {
 	return await prepareHostedNative(machine, selectors, recorded, "ios", false, mode);

package/dist/{hosted-logs-EzQM7-3Z.mjs → hosted-logs-FIRx9X2f.mjs}

@@ -1,52 +1,84 @@
-import { K as validateDeviceSlot, z as deviceSlotFileKey } from "./config-BYDxlMY3.mjs";
-import { t as getExecutor } from "./exec-DqKo9GKJ.mjs";
-import { w as workspaceLogsDir$1, x as workspaceDir } from "./workspace-state-DJt_MMvf.mjs";
-import { l as phaseLine } from "./command-output-BTy8hZ0F.mjs";
-import { o as parseMachine$1 } from "./tailnet-Dh-qiYzG.mjs";
-import { r as createNdjsonWriter } from "./ndjson-GOnbyvso.mjs";
-import { n as macosDir } from "./state-CG_OFoaA.mjs";
-import { s as call } from "./hosted-client-ZEKpS9vw.mjs";
+import { t as getExecutor } from "./exec-DEoAhcze.mjs";
+import { d as workspaceDir, m as workspaceLogsDir$1 } from "./paths-DQtTgsBf.mjs";
+import { B as deviceSlotFileKey, et as parseMachine$1, q as validateDeviceSlot } from "./config-DlrsduwG.mjs";
+import { l as phaseLine } from "./command-output-gwpm28fu.mjs";
+import { n as macosDir } from "./state-08I3hw3_.mjs";
+import { r as createNdjsonWriter } from "./ndjson-CgE_o3Dl.mjs";
+import { c as call } from "./hosted-client-DZAPrcro.mjs";
 import { mkdirSync, readFileSync, realpathSync, renameSync, rmSync, writeFileSync } from "node:fs";
 import { dirname, join } from "node:path";
+import { LOG_ROTATE_BYTES, ambientWrite, withDirLockAsync } from "@stim-cli/core";
 import { isJsonObject, parseHostedAgentGrant, parseHostedLogsCursor } from "@stim-cli/core/state";
-import { LOG_ROTATE_BYTES, withDirLock } from "@stim-cli/core";
+import { loadAgentDriverModule } from "@stim-cli/agent-driver";
+//#region src/device-host/agent-drivers.ts
+const DRIVERS = { "agent-device": {
+	load: () => import("@stim-cli/agent-driver-agent-device"),
+	configFile: "agent-device-remote.json"
+} };
+function registered(name) {
+	return Object.hasOwn(DRIVERS, name);
+}
+/** The client side of a first-party driver, or a reason it is unavailable to this Stim. */
+async function agentDriverClient(name) {
+	if (!registered(name)) return { unavailable: `this Stim has no ${name} driver` };
+	const { load, configFile } = DRIVERS[name];
+	const loaded = await loadAgentDriverModule(name, load);
+	if ("unavailable" in loaded) return loaded;
+	const { client } = loaded.module;
+	if (!client) return { unavailable: `the ${name} driver has no client` };
+	if (client.configFile !== configFile) return { unavailable: `the ${name} driver writes ${client.configFile}, not ${configFile}` };
+	return { client };
+}
+/**
+* The config file names every first-party driver's client writes beside a placement. They are listed here rather
+* than read from the drivers, so access is removed even when a driver package does not load.
+*/
+function agentClientFiles() {
+	return Object.values(DRIVERS).map((driver) => driver.configFile);
+}
+//#endregion
 //#region src/device-host/hosted-agent.ts
-function agentAccess(file, credential, grant, note, platform = "macos") {
+/** Removes every driver's client file beside `file`, the placement's agent-device config path. */
+async function removeAgentAccess(file, keep) {
+	for (const name of agentClientFiles()) {
+		const path = join(dirname(file), name);
+		if (path !== keep) rmSync(path, { force: true });
+	}
+}
+async function agentAccess(file, credential, grant, note, platform = "macos") {
 	const parsed = grant === void 0 ? null : parseHostedAgentGrant(grant);
-	if (grant !== void 0 && !parsed) note(`${credential.machine} offered agent control this Stim does not support.`);
-	if (!parsed || parsed.driver === "none" || parsed.lease.backend !== (platform === "macos" ? void 0 : `${platform}-instance`)) {
-		rmSync(file, { force: true });
+	const issued = parsed && "token" in parsed ? parsed : null;
+	const loaded = issued ? await agentDriverClient(issued.driver) : null;
+	if (grant !== void 0 && !parsed || loaded && "unavailable" in loaded) note(`${credential.machine} offered agent control this Stim does not support.`);
+	const port = parseMachine$1(credential.machine)?.port ?? 443;
+	const client = loaded && "client" in loaded ? loaded.client : null;
+	const target = client ? join(dirname(file), client.configFile) : file;
+	const access = client && issued ? client.access({
+		grant: issued,
+		baseUrl: `https://${credential.address}${port === 443 ? "" : `:${port}`}${issued.path}`,
+		file: target,
+		platform
+	}) : null;
+	if (!issued || !access) {
+		await removeAgentAccess(file);
 		return {
 			driver: "none",
 			setting: "hosting.agentDriver"
 		};
 	}
-	const port = parseMachine$1(credential.machine)?.port ?? 443;
-	const config = {
-		daemonBaseUrl: `https://${credential.dnsName}${port === 443 ? "" : `:${port}`}${parsed.path}`,
-		daemonAuthToken: parsed.token,
-		tenant: parsed.lease.tenant,
-		sessionIsolation: "tenant",
-		runId: parsed.lease.runId,
-		...platform === "macos" ? { leaseId: parsed.scope } : {},
-		leaseBackend: platform === "macos" ? "macos-app" : `${platform}-instance`,
-		leaseProvider: "proxy",
-		clientId: parsed.lease.clientId,
-		deviceKey: parsed.lease.deviceKey,
-		platform
-	};
-	mkdirSync(dirname(file), { recursive: true });
-	const tmp = `${file}.${process.pid}.tmp`;
+	await removeAgentAccess(file, target);
+	mkdirSync(dirname(target), { recursive: true });
+	const tmp = `${target}.${process.pid}.tmp`;
 	try {
-		writeFileSync(tmp, `${JSON.stringify(config, null, 2)}\n`, { mode: 384 });
-		renameSync(tmp, file);
+		writeFileSync(tmp, access.config, { mode: 384 });
+		renameSync(tmp, target);
 	} finally {
 		rmSync(tmp, { force: true });
 	}
 	return {
-		driver: "agent-device",
-		remoteConfig: file,
-		command: `agent-device <command> --remote-config ${file}`
+		driver: issued.driver,
+		remoteConfig: target,
+		command: access.command
 	};
 }
 //#endregion
@@ -59,7 +91,7 @@ function canonical(path) {
 	}
 }
 function report(message) {
-	process.stderr.write(`${phaseLine("device", message.replace(/\s+/g, " "))}\n`);
+	ambientWrite("stderr", `${phaseLine("device", message.replace(/\s+/g, " "))}\n`);
 }
 function closeAgentConnection(remoteConfig) {
 	const exec = getExecutor();
@@ -118,10 +150,10 @@ function readCursor(root, session, target) {
 	} catch {}
 }
 const sameCursor = (a, b) => JSON.stringify(Object.entries(a ?? {}).toSorted()) === JSON.stringify(Object.entries(b ?? {}).toSorted());
-function commitPage(root, session, before, records, cursor, target) {
+async function commitPage(root, session, before, records, cursor, target) {
 	if (!records.length && sameCursor(before, cursor)) return;
 	const directory = logsStateDir(root, target);
-	withDirLock(join(directory, "host-logs.lock"), () => {
+	await withDirLockAsync(join(directory, "host-logs.lock"), () => {
 		if (!sameCursor(readCursor(root, session, target), before)) return;
 		if (records.length) {
 			const writer = createNdjsonWriter(hostLogFile(root, target), { maxBytes: LOG_ROTATE_BYTES });
@@ -149,14 +181,15 @@ function commitPage(root, session, before, records, cursor, target) {
 		}
 	}, { ensureParent: () => mkdirSync(directory, { recursive: true }) });
 }
-async function pullHostedMacosLogs(root, placement, host, target = MACOS, maxPages = MAX_PAGES, final = false) {
+async function pullHostedMacosLogs(root, placement, host, target = MACOS, maxPages = MAX_PAGES, final = false, signal) {
 	const deadline = Date.now() + (final ? 3e4 : 12e4);
 	let checkpoint;
 	let progressAt = 0;
 	for (let page = 0; page < maxPages && Date.now() < deadline; page++) {
+		signal?.throwIfAborted();
 		const before = readCursor(root, placement.session, target);
 		if (final && Date.now() >= progressAt) {
-			process.stderr.write(`Copying final native logs from ${host.machine} (page ${page + 1})\n`);
+			ambientWrite("stderr", `Copying final native logs from ${host.machine} (page ${page + 1})\n`);
 			progressAt = Date.now() + 5e3;
 		}
 		const result = await call(host, "device-host.logs.query", {
@@ -165,7 +198,8 @@ async function pullHostedMacosLogs(root, placement, host, target = MACOS, maxPag
 		}, Math.max(1, Math.min(2e4, deadline - Date.now())));
 		const cursor = isJsonObject(result) ? parseHostedLogsCursor(result.cursor) : null;
 		if (!isJsonObject(result) || !cursor || !Array.isArray(result.records) || !result.records.every(isJsonObject) || typeof result.more !== "boolean") throw new Error(`${host.machine} answered device-host.logs.query with an unexpected result.`);
-		commitPage(root, placement.session, before, result.records, cursor, target);
+		signal?.throwIfAborted();
+		await commitPage(root, placement.session, before, result.records, cursor, target);
 		if (!result.more) return;
 		const nextCheckpoint = typeof result.checkpoint === "number" ? result.checkpoint : void 0;
 		if (sameCursor(cursor, before) && nextCheckpoint === checkpoint) {
@@ -176,12 +210,12 @@ async function pullHostedMacosLogs(root, placement, host, target = MACOS, maxPag
 	}
 	if (target.platform !== "macos") throw new Error(final ? "Final native log copy reached its time or page bound; the host keeps collected logs after stop." : "Hosted native logs still have unread pages; run stim logs again.");
 }
-async function pullHostedNativeLogs(root, slot, placement, host, final = false, platform = "ios") {
+async function pullHostedNativeLogs(root, slot, placement, host, final = false, platform = "ios", signal) {
 	if (!host.connection.supports(platform === "ios" ? "hosted-ios-data" : "hosted-android-data")) throw new Error(`${host.machine} needs a newer stim-server to collect hosted ${platform === "ios" ? "iOS" : "Android"} native logs.`);
 	await pullHostedMacosLogs(root, placement, host, {
 		platform,
 		slot
-	}, final ? 1024 : MAX_PAGES, final);
+	}, final ? 1024 : MAX_PAGES, final, signal);
 }
 //#endregion
-export { agentAccess as i, pullHostedNativeLogs as n, closeAgentConnection as r, pullHostedMacosLogs as t };
+export { removeAgentAccess as a, agentAccess as i, pullHostedNativeLogs as n, closeAgentConnection as r, pullHostedMacosLogs as t };

package/dist/{hosted-macos-BACVAVqE.mjs → hosted-macos-_awYSpfv.mjs}

@@ -1,13 +1,13 @@
-import { l as phaseLine } from "./command-output-BTy8hZ0F.mjs";
-import { x as runCancellationSignal } from "./tailnet-Dh-qiYzG.mjs";
-import { t as cancellableSleep } from "./cancellation-C_22VQTH.mjs";
-import { n as macosDir } from "./state-CG_OFoaA.mjs";
-import { a as attach, c as connectHost, g as upload, h as unknownSession, i as SESSION_TIMEOUT_MS, l as heldNoLonger, m as sha256, o as bundleManifest, p as settle, r as PREPARE_TIMEOUT_MS, s as call, t as INSTALL_TIMEOUT_MS, u as hostedSession } from "./hosted-client-ZEKpS9vw.mjs";
-import { i as agentAccess, r as closeAgentConnection, t as pullHostedMacosLogs } from "./hosted-logs-EzQM7-3Z.mjs";
-import { rmSync } from "node:fs";
+import { a as removeAgentAccess, i as agentAccess, r as closeAgentConnection, t as pullHostedMacosLogs } from "./hosted-logs-FIRx9X2f.mjs";
+import { l as phaseLine } from "./command-output-gwpm28fu.mjs";
+import { u as cancellableSleep } from "./operation-exec-BW0em61G.mjs";
+import { n as macosDir } from "./state-08I3hw3_.mjs";
+import { d as runCancellationSignal } from "./native-run-NwUuxbkg.mjs";
+import { _ as unknownSession, a as SESSION_TIMEOUT_MS, c as call, d as hostedSession, g as stoppedSession, h as sha256, i as RESERVE_TIMEOUT_MS, l as connectHost, m as settle, o as attach, r as PREPARE_TIMEOUT_MS, s as bundleManifest, t as INSTALL_TIMEOUT_MS, u as heldNoLonger, v as upload } from "./hosted-client-DZAPrcro.mjs";
+import { randomUUID } from "node:crypto";
 import { join } from "node:path";
+import { ambientContext, ambientWrite } from "@stim-cli/core";
 import { hostedMacosBundleId, parseHostedMacosDevice, validHostedAppArguments } from "@stim-cli/core/state";
-import { randomUUID } from "node:crypto";
 //#region src/device-host/hosted-macos.ts
 const HANDOFF_TIMEOUT_MS = 3e5;
 const agentRemoteConfig = (root) => join(macosDir(root), "agent-device-remote.json");
@@ -20,8 +20,8 @@ async function placeHostedMacos(host, { root, bundle, bundleId, handoff, argumen
 	let session = null;
 	if (recorded) {
 		try {
-			session = await settle(host, await attach(host, recorded.session), ["preparing"], PREPARE_TIMEOUT_MS, "macos", runCancellationSignal());
-			session = await settle(host, session, ["stopping"], SESSION_TIMEOUT_MS, "macos", runCancellationSignal());
+			session = await settle(host, await attach(host, recorded.session), ["preparing"], PREPARE_TIMEOUT_MS, "macos", runCancellationSignal(ambientContext()));
+			session = await settle(host, session, ["stopping"], SESSION_TIMEOUT_MS, "macos", runCancellationSignal(ambientContext()));
 		} catch (error) {
 			if (!heldNoLonger(error)) throw error;
 		}
@@ -35,7 +35,7 @@ async function placeHostedMacos(host, { root, bundle, bundleId, handoff, argumen
 			slot: "default",
 			attempt: randomUUID(),
 			platform: "macos"
-		}));
+		}, RESERVE_TIMEOUT_MS));
 	}
 	const appSlot = session.appSlot;
 	if (appSlot === void 0) throw new Error(`${host.machine} reserved a session without a macOS app slot.`);
@@ -52,8 +52,9 @@ async function placeHostedMacos(host, { root, bundle, bundleId, handoff, argumen
 		}
 	};
 	reserved(placement);
-	session = await settle(host, session, ["preparing"], PREPARE_TIMEOUT_MS, "macos", runCancellationSignal());
+	session = await settle(host, session, ["preparing"], PREPARE_TIMEOUT_MS, "macos", runCancellationSignal(ambientContext()));
 	if (session.state === "unknown") throw unknownSession(host, session);
+	if (session.state === "stopped") throw stoppedSession(host, session);
 	if (session.state !== "ready") throw new Error(`The hosted session ${session.id} on ${host.machine} is ${session.state}.`);
 	const device = parseHostedMacosDevice(session.device);
 	if (!device || device.appSlot !== appSlot) throw new Error(`${host.machine} reported a ready session without its reserved macOS app slot.`);
@@ -77,7 +78,7 @@ async function placeHostedMacos(host, { root, bundle, bundleId, handoff, argumen
 	note(`Delivering ${files.length} files to ${host.machine} (macOS ${device.macosVersion}, ${device.architecture})`);
 	await upload(host, ids, (await call(host, "device-host.app.offer", offer)).missing, content);
 	let missing = (await call(host, "device-host.app.offer", offer)).missing;
-	if (handoff && handoff.nodeId === host.credential.nodeId && Array.isArray(missing) && missing.length) {
+	if (handoff && handoff.serverKey === host.credential.serverKey && Array.isArray(missing) && missing.length) {
 		try {
 			const taken = await call(host, "device-host.app.handoff", {
 				...ids,
@@ -99,7 +100,10 @@ async function placeHostedMacos(host, { root, bundle, bundleId, handoff, argumen
 	while (delivery.state !== "installed") {
 		if (delivery.state === "unknown") throw new Error(`${host.machine} could not install or launch the app${typeof delivery.notice === "string" ? `: ${delivery.notice}` : ""}.`);
 		if (Date.now() > deadline) throw new Error(`${host.machine} did not finish installing the app.`);
-		await cancellableSleep(500);
+		await cancellableSleep(500, {
+			signal: runCancellationSignal(ambientContext()),
+			what: "hosted app installation"
+		});
 		delivery = await call(host, "device-host.app.attach", ids);
 	}
 	const appliedArguments = validHostedAppArguments(delivery.arguments) ? delivery.arguments : [];
@@ -108,31 +112,40 @@ async function placeHostedMacos(host, { root, bundle, bundleId, handoff, argumen
 	return {
 		placement: {
 			...placement,
-			agent: agentAccess(agentRemoteConfig(root), host.credential, delivery.agent, note)
+			agent: await agentAccess(agentRemoteConfig(root), host.credential, delivery.agent, note)
 		},
 		launched: delivery.launched === true ? true : "unverified",
 		arguments: appliedArguments
 	};
 }
 /** Stops a recorded hosted session and waits until the host confirms it stopped; anything else is a failure. */
-async function stopHostedMacos(root, placement) {
+async function stopHostedMacos(root, placement, signal) {
+	signal?.throwIfAborted();
 	if (placement.agent.driver === "agent-device") closeAgentConnection(placement.agent.remoteConfig);
-	const host = await connectHost(placement.machine);
+	let host;
+	const cancel = () => host?.connection.close();
+	signal?.addEventListener("abort", cancel, { once: true });
 	try {
+		host = await connectHost(placement.machine, void 0, false, signal);
 		try {
 			let session = hostedSession(host, await call(host, "device-host.stop", { session: placement.session }));
-			session = await settle(host, session, ["stopping"], SESSION_TIMEOUT_MS);
+			session = await settle(host, session, ["stopping"], SESSION_TIMEOUT_MS, "macos", signal);
+			signal?.throwIfAborted();
 			if (session.state !== "stopped") throw unknownSession(host, session);
-			await pullHostedMacosLogs(root, placement, host).catch((error) => {
-				process.stderr.write(`${phaseLine("device", `Could not copy the final logs from ${host.machine}: ${error.message}`)}\n`);
+			await pullHostedMacosLogs(root, placement, host, void 0, void 0, false, signal).catch((error) => {
+				signal?.throwIfAborted();
+				ambientWrite("stderr", `${phaseLine("device", `Could not copy the final logs from ${placement.machine}: ${error.message}`)}\n`);
 			});
 		} catch (error) {
+			signal?.throwIfAborted();
 			if (!heldNoLonger(error)) throw error;
 		}
 	} finally {
-		host.connection.close();
+		signal?.removeEventListener("abort", cancel);
+		host?.connection.close();
 	}
-	rmSync(agentRemoteConfig(root), { force: true });
+	signal?.throwIfAborted();
+	await removeAgentAccess(agentRemoteConfig(root));
 }
 //#endregion
 export { stopHostedMacos as n, placeHostedMacos as t };

package/dist/{hosted-native-A4s1QPXe.mjs → hosted-native-BdzE668-.mjs}

@@ -1,14 +1,16 @@
-import { r as readWorkspaceState$1, x as workspaceDir } from "./workspace-state-DJt_MMvf.mjs";
-import { x as runCancellationSignal } from "./tailnet-Dh-qiYzG.mjs";
-import { t as cancellableSleep } from "./cancellation-C_22VQTH.mjs";
-import { a as attach, c as connectHost, f as requireHostedAppMode, g as upload, h as unknownSession, i as SESSION_TIMEOUT_MS, l as heldNoLonger, m as sha256, n as OFFER_TIMEOUT_MS, o as bundleManifest, p as settle, r as PREPARE_TIMEOUT_MS, s as call, t as INSTALL_TIMEOUT_MS, u as hostedSession } from "./hosted-client-ZEKpS9vw.mjs";
-import { i as agentAccess, n as pullHostedNativeLogs, r as closeAgentConnection } from "./hosted-logs-EzQM7-3Z.mjs";
-import { a as requireHostedMetro, i as requestHostedMetro, n as closeHostedMetro } from "./metro-gateway-CX9Xlkq2.mjs";
-import { s as writeHostedNative } from "./ios-state-CBLe1xYw.mjs";
-import { readFileSync, rmSync } from "node:fs";
+import { d as workspaceDir } from "./paths-DQtTgsBf.mjs";
+import { a as removeAgentAccess, i as agentAccess, n as pullHostedNativeLogs, r as closeAgentConnection } from "./hosted-logs-FIRx9X2f.mjs";
+import { u as cancellableSleep } from "./operation-exec-BW0em61G.mjs";
+import { l as withWorkspaceStateLockAsync, r as readWorkspaceState$1 } from "./workspace-state-U08dEzhG.mjs";
+import { d as runCancellationSignal } from "./native-run-NwUuxbkg.mjs";
+import { _ as unknownSession, a as SESSION_TIMEOUT_MS, c as call, d as hostedSession, g as stoppedSession, h as sha256, i as RESERVE_TIMEOUT_MS, l as connectHost, m as settle, n as OFFER_TIMEOUT_MS, o as attach, p as requireHostedAppMode, r as PREPARE_TIMEOUT_MS, s as bundleManifest, t as INSTALL_TIMEOUT_MS, u as heldNoLonger, v as upload } from "./hosted-client-DZAPrcro.mjs";
+import { a as requireHostedMetro, i as requestHostedMetro, n as closeHostedMetro } from "./metro-gateway-CKZqKqx7.mjs";
+import { s as writeHostedNative } from "./ios-state-Dtw5K2aI.mjs";
+import { randomUUID } from "node:crypto";
+import { readFileSync } from "node:fs";
 import { join } from "node:path";
+import { ambientContext, ambientWrite } from "@stim-cli/core";
 import { hostedNativeRecords, isJsonObject, parseHostedAndroidDevice, parseHostedChoice, parseHostedDevice, parseHostedNativeOffer, parseHostedNativePlacement, requireAutomaticMachine, unreadableHostedNative } from "@stim-cli/core/state";
-import { randomUUID } from "node:crypto";
 //#region src/device-host/hosted-native.ts
 function hostingRefusal(machine, error) {
 	return Object.assign(/* @__PURE__ */ new Error(`${machine}: ${error instanceof Error ? error.message : String(error)}`), {
@@ -26,8 +28,8 @@ async function prepareHostedNative(machine, selectors, recorded, platform = "ios
 		if (recorded) {
 			let session = null;
 			try {
-				session = await settle(host, await attach(host, recorded.session, void 0, platform), ["preparing"], PREPARE_TIMEOUT_MS, platform, runCancellationSignal());
-				session = await settle(host, session, ["stopping"], SESSION_TIMEOUT_MS, platform, runCancellationSignal());
+				session = await settle(host, await attach(host, recorded.session, void 0, platform), ["preparing"], PREPARE_TIMEOUT_MS, platform, runCancellationSignal(ambientContext()));
+				session = await settle(host, session, ["stopping"], SESSION_TIMEOUT_MS, platform, runCancellationSignal(ambientContext()));
 			} catch (error) {
 				if (!heldNoLonger(error)) throw error;
 			}
@@ -73,7 +75,7 @@ async function prepareHostedNative(machine, selectors, recorded, platform = "ios
 async function reserveHostedNative(host, target, params, platform) {
 	try {
 		if (target.selection?.selected === "auto") requireAutomaticMachine("device", host.machine);
-		return hostedSession(host, await call(host, "device-host.reserve", params), platform);
+		return hostedSession(host, await call(host, "device-host.reserve", params, RESERVE_TIMEOUT_MS), platform);
 	} catch (error) {
 		if (target.selection?.selected !== "auto") throw error;
 		throw Object.assign(/* @__PURE__ */ new Error(`${error instanceof Error ? error.message : String(error)} Retry stim ${platform} --remote auto; the build already targets ${host.machine}'s architecture.`), { remedy: `Retry stim ${platform} --remote auto.` });
@@ -111,7 +113,8 @@ async function placeHostedNative(target, { root, slot, bundle, handoff, bundleId
 			}
 		};
 		reserved(placement);
-		session = await settle(host, session, ["preparing"], PREPARE_TIMEOUT_MS, platform, runCancellationSignal());
+		session = await settle(host, session, ["preparing"], PREPARE_TIMEOUT_MS, platform, runCancellationSignal(ambientContext()));
+		if (session.state === "stopped") throw stoppedSession(host, session);
 		if (session.state !== "ready") throw unknownSession(host, session);
 		const device = platform === "ios" ? parseHostedDevice(session.device) : parseHostedAndroidDevice(session.device);
 		if (!device || device.architecture !== target.choice.architecture || "avdName" in device && "systemImage" in target.choice && (device.systemImage !== target.choice.systemImage || device.deviceProfile !== target.choice.deviceProfile)) throw new Error(platform === "ios" ? "The reserved simulator does not match the offered architecture." : "The reserved emulator does not match the offered architecture or selectors.");
@@ -164,7 +167,7 @@ async function placeHostedNative(target, { root, slot, bundle, handoff, bundleId
 		note(`Delivering ${files.length} files to ${host.machine} (${"runtime" in device ? device.runtime : device.systemImage}, ${device.architecture})`);
 		await upload(host, ids, (await call(host, "device-host.app.offer", offer)).missing, content);
 		let missing = (await call(host, "device-host.app.offer", offer)).missing;
-		if (handoff && handoff.nodeId === host.credential.nodeId && Array.isArray(missing) && missing.length) {
+		if (handoff && handoff.serverKey === host.credential.serverKey && Array.isArray(missing) && missing.length) {
 			if (!host.connection.supports(platform === "android" ? "hosted-android-data" : "hosted-ios-data")) note(`${host.machine} needs a newer stim-server for ${platform === "ios" ? "iOS" : "Android"} build handoff; uploading the app instead`);
 			else try {
 				const taken = await call(host, "device-host.app.handoff", {
@@ -184,7 +187,10 @@ async function placeHostedNative(target, { root, slot, bundle, handoff, bundleId
 					break;
 				} catch (offerError) {
 					if (!String(offerError).includes("native operation in progress") || Date.now() >= fallbackDeadline) throw offerError;
-					await cancellableSleep(Math.min(500, Math.max(0, fallbackDeadline - Date.now())));
+					await cancellableSleep(Math.min(500, Math.max(0, fallbackDeadline - Date.now())), {
+						signal: runCancellationSignal(ambientContext()),
+						what: "hosted app offer"
+					});
 				}
 			}
 		}
@@ -196,13 +202,16 @@ async function placeHostedNative(target, { root, slot, bundle, handoff, bundleId
 		while (delivery.state !== "installed") {
 			if (delivery.state === "unknown") throw new Error(typeof delivery.notice === "string" ? delivery.notice : "App installation or launch is unknown.");
 			if (Date.now() > deadline) throw new Error("App installation did not finish.");
-			await cancellableSleep(500);
+			await cancellableSleep(500, {
+				signal: runCancellationSignal(ambientContext()),
+				what: "hosted app installation"
+			});
 			delivery = await call(host, "device-host.app.attach", ids);
 		}
 		if (typeof delivery.notice === "string") note(delivery.notice);
 		placement = {
 			...placement,
-			agent: agentAccess(platform === "ios" ? iosAgentRemoteConfig(root, slot) : androidAgentRemoteConfig(root, slot), host.credential, host.connection.supports(platform === "ios" ? "hosted-ios-agent" : "hosted-android-agent") ? delivery.agent : void 0, note, platform)
+			agent: await agentAccess(platform === "ios" ? iosAgentRemoteConfig(root, slot) : androidAgentRemoteConfig(root, slot), host.credential, host.connection.supports(platform === "ios" ? "hosted-ios-agent" : "hosted-android-agent") ? delivery.agent : void 0, note, platform)
 		};
 		return {
 			placement,
@@ -214,9 +223,11 @@ async function placeHostedNative(target, { root, slot, bundle, handoff, bundleId
 		if (platform === "android") host.connection.close();
 	}
 }
-async function stopHostedNative(root, slot, platform = "ios") {
+async function stopHostedNative(root, slot, signal, platform = "ios") {
+	signal?.throwIfAborted();
 	const failures = [];
 	for (const [name, record] of Object.entries(hostedNativeRecords(readWorkspaceState$1(root), platform))) {
+		signal?.throwIfAborted();
 		if (slot !== void 0 && name !== slot) continue;
 		const placement = parseHostedNativePlacement(record, platform);
 		if (!placement) {
@@ -225,21 +236,28 @@ async function stopHostedNative(root, slot, platform = "ios") {
 		}
 		if (placement.agent.driver === "agent-device") closeAgentConnection(placement.agent.remoteConfig);
 		let host;
+		const cancel = () => host?.connection.close();
+		signal?.addEventListener("abort", cancel, { once: true });
 		try {
-			host = await connectHost(placement.machine);
+			host = await connectHost(placement.machine, void 0, false, signal);
 			try {
-				await pullHostedNativeLogs(root, name, placement, host, true, platform);
+				await pullHostedNativeLogs(root, name, placement, host, true, platform, signal);
 			} catch (error) {
-				process.stderr.write(`Could not copy final native logs from ${placement.machine}: ${error.message}\n`);
+				signal?.throwIfAborted();
+				ambientWrite("stderr", `Could not copy final native logs from ${placement.machine}: ${error.message}\n`);
 			}
-			const stopped = await settle(host, hostedSession(host, await call(host, "device-host.stop", { session: placement.session }), platform), ["stopping"], SESSION_TIMEOUT_MS, platform);
+			signal?.throwIfAborted();
+			const stopped = await settle(host, hostedSession(host, await call(host, "device-host.stop", { session: placement.session }), platform), ["stopping"], SESSION_TIMEOUT_MS, platform, signal);
+			signal?.throwIfAborted();
 			if (stopped.state !== "stopped") throw unknownSession(host, stopped);
 			try {
-				await pullHostedNativeLogs(root, name, placement, host, true, platform);
+				await pullHostedNativeLogs(root, name, placement, host, true, platform, signal);
 			} catch (error) {
-				process.stderr.write(`Could not copy the host's final native logs from ${placement.machine}: ${error.message}\n`);
+				signal?.throwIfAborted();
+				ambientWrite("stderr", `Could not copy the host's final native logs from ${placement.machine}: ${error.message}\n`);
 			}
 		} catch (error) {
+			signal?.throwIfAborted();
 			const code = error instanceof Error && "code" in error ? error.code : void 0;
 			const hostCode = error instanceof Error && "hostCode" in error ? error.hostCode : code;
 			if (hostCode !== "unknown-session" && hostCode !== "forbidden") {
@@ -248,13 +266,17 @@ async function stopHostedNative(root, slot, platform = "ios") {
 				continue;
 			}
 		} finally {
+			signal?.removeEventListener("abort", cancel);
 			host?.connection.close();
 		}
+		signal?.throwIfAborted();
 		try {
-			await closeHostedMetro(root, placement.session);
-			rmSync(platform === "ios" ? iosAgentRemoteConfig(root, name) : androidAgentRemoteConfig(root, name), { force: true });
-			writeHostedNative(root, name, null, platform);
+			await closeHostedMetro(root, placement.session, signal);
+			signal?.throwIfAborted();
+			await removeAgentAccess(platform === "ios" ? iosAgentRemoteConfig(root, name) : androidAgentRemoteConfig(root, name));
+			await withWorkspaceStateLockAsync(root, () => writeHostedNative(root, name, null, platform), signal);
 		} catch (error) {
+			signal?.throwIfAborted();
 			failures.push(`${placement.machine}: ${error.message}. The placement is kept; rerun stim stop.`);
 		}
 	}