stim 1.14.0 → 1.16.0

package/dist/{guide-status-BZrFPIA_.mjs → guide-status-CjEZMAD4.mjs}

@@ -1,6 +1,6 @@
-import { T as upsertProject, d as getConfigDir, p as getProject } from "./config-lvc7d3C2.mjs";
-import { n as appProjectProblem } from "./project-CWlvEaeN.mjs";
-import { t as compareStimVersions } from "./stim-installations-CINXy_su.mjs";
+import { E as upsertProject, d as getConfigDir, p as getProject } from "./config-D0DbpZtM.mjs";
+import { n as appProjectProblem } from "./project-Du91Ilvc.mjs";
+import { t as compareStimVersions } from "./stim-installations-QMEI32v1.mjs";
 import { mkdirSync, readFileSync, renameSync, unlinkSync, writeFileSync } from "node:fs";
 import { join } from "node:path";
 //#region src/guide-status.ts

package/dist/hosted-client-a-WmqE2L.mjs

@@ -0,0 +1,197 @@
+import { t as BuildConnection, y as pinnedEndpoint$1 } from "./client-BTY686R6.mjs";
+import { t as configuredMachines } from "./machines-BIBUdhpj.mjs";
+import { createHash } from "node:crypto";
+import { lstatSync, readFileSync, readdirSync, readlinkSync } from "node:fs";
+import { join } from "node:path";
+import { HOSTED_APP_CHUNK_BYTES, hostedMacosAppSlot, isJsonObject, readDeviceHostMachines } from "@stim-cli/core/state";
+//#region src/device-host/hosted-client.ts
+const CONNECT_TIMEOUT_MS = 1e4;
+/** Covers 90s stop + 15s final logs + three 10s worker group-settle bounds, with 45s for polling and transport. */
+const SESSION_TIMEOUT_MS = 18e4;
+const INSTALL_TIMEOUT_MS = 3e5;
+const sleep = (ms) => new Promise((done) => setTimeout(done, ms));
+const sha256 = (content) => createHash("sha256").update(content).digest("hex");
+function credentialRefusal(message, remedy = "Run stim doctor.") {
+	return Object.assign(new Error(message), {
+		code: "STIM_HOSTING_REFUSED",
+		remedy
+	});
+}
+function hostingCredential(machine) {
+	const configured = configuredMachines();
+	if (configured === null) throw credentialRefusal("hosting.machines is invalid. Run stim guide settings and correct it.", "Run stim guide settings and correct hosting.machines.");
+	if (!configured.includes(machine)) throw Object.assign(/* @__PURE__ */ new Error(`${machine} is not in hosting.machines. Add it with stim settings set hosting.machines, then run stim doctor --fix to ask it for hosting access.`), { code: "STIM_BAD_ARG" });
+	let credentials;
+	try {
+		credentials = readDeviceHostMachines();
+	} catch {
+		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.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);
+	}
+	return credential;
+}
+/** Connects only to the pinned node of an approved hosting machine, and only when it grants `device-host`. */
+async function connectHost(machine, timeoutMs = CONNECT_TIMEOUT_MS, strict = false) {
+	const credential = hostingCredential(machine);
+	const target = pinnedEndpoint$1(credential);
+	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) => {
+		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}.`), {
+		code: strict ? "STIM_HOSTING_REFUSED" : opened.refused ? "STIM_HOSTING_REFUSED" : opened.code ?? "closed",
+		hostCode: opened.code
+	});
+	return {
+		machine,
+		credential,
+		connection: opened
+	};
+}
+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;
+}
+async function call(host, method, params, timeoutMs) {
+	if (method === "device-host.metro.open" && isJsonObject(params) && typeof params.secret === "string") gatewaySecrets.set(host, params.secret);
+	const reply = await host.connection.request(method, params, timeoutMs);
+	if ("error" in reply) throw Object.assign(/* @__PURE__ */ new Error(`${host.machine} refused ${method}: ${redactHostText(host, reply.error.message)}`), { code: reply.error.code });
+	if (!isJsonObject(reply.result)) throw new Error(`${host.machine} answered ${method} without a result.`);
+	return typeof reply.result.notice === "string" ? {
+		...reply.result,
+		notice: redactHostText(host, reply.result.notice)
+	} : reply.result;
+}
+function hostedSession(host, value, platform = "macos") {
+	if (typeof value.id !== "string" || typeof value.state !== "string" || value.platform !== platform) throw new Error(`${host.machine} answered with a session that is not a hosted ${platform} session.`);
+	return {
+		id: value.id,
+		state: value.state,
+		device: value.device,
+		...hostedMacosAppSlot(value.appSlot) ? { appSlot: value.appSlot } : {},
+		...typeof value.notice === "string" ? { notice: value.notice } : {}
+	};
+}
+const heldNoLonger = (error) => error instanceof Error && "code" in error && error.code === "unknown-session";
+async function attach(host, session, timeoutMs, platform = "macos") {
+	return hostedSession(host, await call(host, "device-host.attach", { session }, timeoutMs), platform);
+}
+const probeCache = /* @__PURE__ */ new Map();
+function probeHostedSession(placement, { timeoutMs = 3e3, ttlMs = 1e4 } = {}) {
+	const key = JSON.stringify([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);
+	if (ttlMs > 0) {
+		const entry = {
+			expiresAt: Infinity,
+			promise
+		};
+		probeCache.delete(key);
+		probeCache.set(key, entry);
+		if (probeCache.size > 64) probeCache.delete(probeCache.keys().next().value);
+		promise.then((result) => {
+			entry.expiresAt = Date.now() + ttlMs;
+			return result;
+		});
+	}
+	return promise;
+}
+async function probeSession(placement, timeoutMs) {
+	let host;
+	try {
+		host = await connectHost(placement.machine, timeoutMs);
+		const session = await attach(host, placement.session, timeoutMs, placement.device === void 0 ? "macos" : "ios");
+		if (session.state === "ready" || session.state === "stopped") return { state: session.state };
+		return {
+			state: "unknown",
+			notice: session.state === "unknown" ? session.notice : `The hosted session ${session.id} on ${host.machine} is ${session.state}.${session.notice ? ` ${session.notice}` : ""}`
+		};
+	} catch (error) {
+		if (heldNoLonger(error)) return { state: "stopped" };
+		return {
+			state: "unreachable",
+			reason: error instanceof Error ? error.message : String(error)
+		};
+	} finally {
+		host?.connection.close();
+	}
+}
+async function settle(host, session, passing, timeoutMs, platform = "macos") {
+	const deadline = Date.now() + timeoutMs;
+	while (passing.includes(session.state)) {
+		if (Date.now() > deadline) throw new Error(`The hosted session ${session.id} on ${host.machine} stayed ${session.state}.`);
+		await sleep(500);
+		session = await attach(host, session.id, void 0, platform);
+	}
+	return session;
+}
+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.`);
+}
+function bundleManifest(bundle) {
+	const files = [];
+	const content = /* @__PURE__ */ new Map();
+	const walk = (dir, prefix) => {
+		for (const name of readdirSync(dir)) {
+			const absolute = join(dir, name);
+			const path = prefix ? `${prefix}/${name}` : name;
+			const stat = lstatSync(absolute);
+			let read;
+			let kind;
+			if (stat.isDirectory()) {
+				walk(absolute, path);
+				continue;
+			} else if (stat.isSymbolicLink()) {
+				read = () => Buffer.from(readlinkSync(absolute));
+				kind = "link";
+			} else if (stat.isFile()) {
+				read = () => readFileSync(absolute);
+				kind = stat.mode & 73 ? "exec" : "file";
+			} else continue;
+			const bytes = read();
+			const digest = sha256(bytes);
+			files.push({
+				path,
+				kind,
+				size: bytes.length,
+				sha256: digest
+			});
+			content.set(digest, read);
+		}
+	};
+	walk(bundle, "");
+	files.sort((a, b) => a.path.localeCompare(b.path));
+	return {
+		files,
+		content
+	};
+}
+async function upload(host, ids, missing, content) {
+	if (!Array.isArray(missing)) throw new Error(`${host.machine} answered device-host.app.offer without missing content.`);
+	for (const entry of missing) {
+		const read = isJsonObject(entry) && typeof entry.sha256 === "string" ? content.get(entry.sha256) : void 0;
+		if (!read || !isJsonObject(entry) || typeof entry.offset !== "number") throw new Error(`${host.machine} asked for content this app does not have.`);
+		const bytes = read();
+		let offset = entry.offset;
+		do {
+			const data = bytes.subarray(offset, offset + HOSTED_APP_CHUNK_BYTES).toString("base64");
+			const next = (await call(host, "device-host.app.chunk", {
+				...ids,
+				sha256: entry.sha256,
+				offset,
+				data
+			})).offset;
+			if (typeof next !== "number" || next <= offset && next !== bytes.length) throw new Error(`${host.machine} did not accept app content at byte ${offset}.`);
+			offset = next;
+		} while (offset < bytes.length);
+	}
+}
+//#endregion
+export { call as a, hostedSession as c, sha256 as d, sleep as f, bundleManifest as i, probeHostedSession as l, upload as m, SESSION_TIMEOUT_MS as n, connectHost as o, unknownSession as p, attach as r, heldNoLonger as s, INSTALL_TIMEOUT_MS as t, settle as u };

package/dist/hosted-ios-CIWelIqf.mjs

@@ -0,0 +1,220 @@
+import { r as readWorkspaceState$1, v as workspaceDir } from "./workspace-state-B8-aJ1_5.mjs";
+import { a as call, c as hostedSession, d as sha256, f as sleep, i as bundleManifest, m as upload, n as SESSION_TIMEOUT_MS, o as connectHost, p as unknownSession, r as attach, s as heldNoLonger, t as INSTALL_TIMEOUT_MS, u as settle } from "./hosted-client-a-WmqE2L.mjs";
+import { i as requireHostedMetro, n as closeHostedMetro, r as requestHostedMetro } from "./metro-gateway-BJ-rxQAB.mjs";
+import { i as agentAccess, r as closeAgentConnection, t as pullHostedIosLogs } from "./hosted-logs-D5g041Q3.mjs";
+import { n as writeHostedIos } from "./ios-state-DS5UpYTH.mjs";
+import { randomUUID } from "node:crypto";
+import { rmSync } from "node:fs";
+import { join } from "node:path";
+import { hostedIosRecords, isJsonObject, parseHostedChoice, parseHostedDevice, parseHostedIosPlacement, unreadableHostedIos } from "@stim-cli/core/state";
+//#region src/device-host/hosted-ios.ts
+function hostingRefusal(machine, error) {
+	return Object.assign(/* @__PURE__ */ new Error(`${machine}: ${error instanceof Error ? error.message : String(error)}`), {
+		code: "STIM_HOSTING_REFUSED",
+		...error instanceof Error && "remedy" in error ? { remedy: error.remedy } : {}
+	});
+}
+const iosAgentRemoteConfig = (root, slot) => join(workspaceDir(root), "hosted-ios", slot, "agent-device-remote.json");
+async function prepareHostedIos(machine, selectors, recorded) {
+	let host;
+	try {
+		host = await connectHost(machine, void 0, true);
+		if (recorded) {
+			let session = null;
+			try {
+				session = await settle(host, await attach(host, recorded.session, void 0, "ios"), ["preparing", "stopping"], SESSION_TIMEOUT_MS, "ios");
+			} catch (error) {
+				if (!heldNoLonger(error)) throw error;
+			}
+			if (session && session.state !== "stopped") {
+				if (session.state !== "ready") throw unknownSession(host, session);
+				const device = parseHostedDevice(session.device);
+				if (!device) throw new Error("The ready session has no simulator identity.");
+				if (selectors.deviceType && selectors.deviceType !== device.deviceType || selectors.runtime && selectors.runtime.replace(/^iOS /, "") !== device.runtime.replace(/^iOS /, "")) throw new Error(`This session uses ${device.deviceType} (iOS ${device.runtime.replace(/^iOS /, "")}); run stim stop first to change it.`);
+				return {
+					host,
+					choice: device,
+					session
+				};
+			}
+		}
+		const offer = await call(host, "device-host.offer", {
+			platform: "ios",
+			...selectors
+		}, 3e3);
+		const choice = offer.platform === "ios" ? parseHostedChoice(offer.choice) : null;
+		if (typeof offer.declined === "string") throw new Error(offer.declined);
+		if (!choice) throw new Error("No compatible installed iOS simulator runtime was offered.");
+		if (!isJsonObject(offer.capacity) || offer.capacity.available === 0) throw new Error("No hosted device capacity is available.");
+		if (!isJsonObject(offer.resources) || offer.resources.memoryPressure !== "normal") throw new Error("Host memory pressure is unknown or elevated.");
+		return {
+			host,
+			choice,
+			session: null
+		};
+	} catch (error) {
+		if (error instanceof Error && "code" in error && error.code === "STIM_BAD_ARG") throw error;
+		throw hostingRefusal(machine, error);
+	} finally {
+		host?.connection.close();
+	}
+}
+async function placeHostedIos(target, { root, slot, bundle, handoff, bundleId, selectors, release, devClientScheme, reserved, note, metro = requestHostedMetro }) {
+	let host = target.host;
+	try {
+		if (!release && metro === requestHostedMetro) requireHostedMetro(root);
+		host = await connectHost(host.machine, void 0, true);
+		target.host = host;
+		let session = (target.session ? await attach(host, target.session.id, void 0, "ios") : null) ?? hostedSession(host, await call(host, "device-host.reserve", {
+			platform: "ios",
+			workspace: root,
+			slot,
+			attempt: randomUUID(),
+			...selectors
+		}), "ios");
+		let placement = {
+			machine: host.machine,
+			selected: host.machine,
+			session: session.id,
+			appAttempt: randomUUID(),
+			device: parseHostedDevice(session.device),
+			agent: {
+				driver: "none",
+				setting: "hosting.agentDriver"
+			}
+		};
+		reserved(placement);
+		session = await settle(host, session, ["preparing"], SESSION_TIMEOUT_MS, "ios");
+		if (session.state !== "ready") throw unknownSession(host, session);
+		const device = parseHostedDevice(session.device);
+		if (!device || device.architecture !== target.choice.architecture) throw new Error("The reserved simulator does not match the offered architecture.");
+		placement = {
+			...placement,
+			device
+		};
+		reserved(placement);
+		if (!release) {
+			const gateway = await metro(root, session.id, host.credential);
+			await call(host, "device-host.metro.open", {
+				session: session.id,
+				...gateway
+			});
+		} else {
+			await call(host, "device-host.metro.close", { session: session.id });
+			await closeHostedMetro(root, session.id);
+		}
+		const { files, content } = bundleManifest(bundle);
+		const manifest = Buffer.from(JSON.stringify(files));
+		content.set(sha256(manifest), () => manifest);
+		const ids = {
+			session: session.id,
+			attempt: placement.appAttempt
+		};
+		const offer = {
+			...ids,
+			bundleId,
+			mode: release ? "release" : "development",
+			...!release && devClientScheme ? { devClientScheme } : {},
+			manifest: {
+				sha256: sha256(manifest),
+				size: manifest.length
+			}
+		};
+		note(`Delivering ${files.length} files to ${host.machine} (${device.runtime}, ${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 (!host.connection.supports("hosted-ios-data")) note(`${host.machine} needs a newer stim-server for iOS build handoff; uploading the app instead`);
+			else try {
+				const taken = await call(host, "device-host.app.handoff", {
+					...ids,
+					build: {
+						handoff: handoff.token,
+						sha256: handoff.sha256
+					}
+				}, 6e4);
+				if (taken.files) note(`${host.machine} took ${String(taken.files)} files from the build it ran`);
+				missing = (await call(host, "device-host.app.offer", offer)).missing;
+			} catch (error) {
+				note(`${error instanceof Error ? error.message : String(error)}; uploading the app instead`);
+				const fallbackDeadline = Date.now() + 6e4;
+				for (;;) try {
+					missing = (await call(host, "device-host.app.offer", offer, Math.max(1, Math.min(2e4, fallbackDeadline - Date.now())))).missing;
+					break;
+				} catch (offerError) {
+					if (!String(offerError).includes("native operation in progress") || Date.now() >= fallbackDeadline) throw offerError;
+					await sleep(Math.min(500, Math.max(0, fallbackDeadline - Date.now())));
+				}
+			}
+		}
+		await upload(host, ids, missing, content);
+		note(`Launching on ${host.machine}`);
+		let delivery = await call(host, "device-host.app.launch", ids);
+		const deadline = Date.now() + INSTALL_TIMEOUT_MS;
+		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 sleep(500);
+			delivery = await call(host, "device-host.app.attach", ids);
+		}
+		if (typeof delivery.notice === "string") note(delivery.notice);
+		placement = {
+			...placement,
+			agent: agentAccess(iosAgentRemoteConfig(root, slot), host.credential, host.connection.supports("hosted-ios-agent") ? delivery.agent : void 0, note, "ios")
+		};
+		return {
+			placement,
+			launched: release && delivery.launched === true ? true : "unverified"
+		};
+	} catch (error) {
+		throw hostingRefusal(host.machine, error);
+	}
+}
+async function stopHostedIos(root, slot) {
+	const failures = [];
+	for (const [name, record] of Object.entries(hostedIosRecords(readWorkspaceState$1(root)))) {
+		if (slot !== void 0 && name !== slot) continue;
+		const placement = parseHostedIosPlacement(record);
+		if (!placement) {
+			failures.push(unreadableHostedIos(name));
+			continue;
+		}
+		if (placement.agent.driver === "agent-device") closeAgentConnection(placement.agent.remoteConfig);
+		let host;
+		try {
+			host = await connectHost(placement.machine);
+			try {
+				await pullHostedIosLogs(root, name, placement, host, true);
+			} catch (error) {
+				process.stderr.write(`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 }), "ios"), ["stopping"], SESSION_TIMEOUT_MS, "ios");
+			if (stopped.state !== "stopped") throw unknownSession(host, stopped);
+			try {
+				await pullHostedIosLogs(root, name, placement, host, true);
+			} catch (error) {
+				process.stderr.write(`Could not copy the host's final native logs from ${placement.machine}: ${error.message}\n`);
+			}
+		} catch (error) {
+			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") {
+				const remedy = code === "closed" || code === "timeout" ? "rerun stim stop when that machine answers." : code === "STIM_BAD_ARG" || code === "STIM_HOSTING_REFUSED" ? "run stim doctor, restore hosting access, then rerun stim stop." : "run stim stop to reconcile the session.";
+				failures.push(`Could not stop the iOS simulator on ${placement.machine}: ${(error instanceof Error ? error.message : String(error)).replace(/\.+$/, "")}. The placement is kept; ${remedy}`);
+				continue;
+			}
+		} finally {
+			host?.connection.close();
+		}
+		try {
+			await closeHostedMetro(root, placement.session);
+			rmSync(iosAgentRemoteConfig(root, name), { force: true });
+			writeHostedIos(root, name, null);
+		} catch (error) {
+			failures.push(`${placement.machine}: ${error.message}. The placement is kept; rerun stim stop.`);
+		}
+	}
+	if (failures.length) throw new Error(failures.join("\n"));
+}
+//#endregion
+export { prepareHostedIos as n, stopHostedIos as r, placeHostedIos as t };

package/dist/hosted-logs-D5g041Q3.mjs

@@ -0,0 +1,187 @@
+import { t as getExecutor } from "./exec-CaErVv7t.mjs";
+import { L as deviceSlotFileKey, W as validateDeviceSlot } from "./config-D0DbpZtM.mjs";
+import { l as phaseLine } from "./command-output-DnJMdEY-.mjs";
+import { v as workspaceDir, x as workspaceLogsDir$1 } from "./workspace-state-B8-aJ1_5.mjs";
+import { t as macosDir } from "./state-3DwSQIBK.mjs";
+import { r as createNdjsonWriter } from "./ndjson-PclOIwVY.mjs";
+import { v as parseMachine$1 } from "./client-BTY686R6.mjs";
+import { a as call } from "./hosted-client-a-WmqE2L.mjs";
+import { mkdirSync, readFileSync, realpathSync, renameSync, rmSync, writeFileSync } from "node:fs";
+import { dirname, join } from "node:path";
+import { LOG_ROTATE_BYTES, withDirLock } from "@stim-cli/core";
+import { isJsonObject, parseHostedAgentGrant, parseHostedLogsCursor } from "@stim-cli/core/state";
+//#region src/device-host/hosted-agent.ts
+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 === "ios-instance" !== (platform === "ios")) {
+		rmSync(file, { force: true });
+		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 === "ios" ? "ios-instance" : "macos-app",
+		leaseProvider: "proxy",
+		clientId: parsed.lease.clientId,
+		deviceKey: parsed.lease.deviceKey,
+		platform
+	};
+	mkdirSync(dirname(file), { recursive: true });
+	const tmp = `${file}.${process.pid}.tmp`;
+	try {
+		writeFileSync(tmp, `${JSON.stringify(config, null, 2)}\n`, { mode: 384 });
+		renameSync(tmp, file);
+	} finally {
+		rmSync(tmp, { force: true });
+	}
+	return {
+		driver: "agent-device",
+		remoteConfig: file,
+		command: `agent-device <command> --remote-config ${file}`
+	};
+}
+//#endregion
+//#region src/device-host/agent-connection.ts
+function canonical(path) {
+	try {
+		return realpathSync(path);
+	} catch {
+		return null;
+	}
+}
+function report(message) {
+	process.stderr.write(`${phaseLine("device", message.replace(/\s+/g, " "))}\n`);
+}
+function closeAgentConnection(remoteConfig) {
+	const exec = getExecutor();
+	const deadline = Date.now() + 3e4;
+	const run = (args) => {
+		const remaining = deadline - Date.now();
+		if (remaining <= 0) throw new Error("agent-device cleanup timed out");
+		const result = JSON.parse(exec.runFile("agent-device", [...args, "--json"], {
+			timeoutMs: Math.min(1e4, remaining),
+			killSignal: "SIGKILL"
+		}));
+		if (result?.success !== true) throw new Error("agent-device did not confirm the command");
+		return result.data;
+	};
+	try {
+		if (!exec.findExecutable("agent-device")) return;
+		const status = run(["connection", "status"]);
+		if (status?.connected !== true || typeof status.session !== "string" || typeof status.remoteConfig !== "string") return;
+		const config = canonical(remoteConfig);
+		if (config === null || canonical(status.remoteConfig) !== config) return;
+		const failures = [];
+		for (const args of [[
+			"close",
+			"--remote-config",
+			remoteConfig,
+			"--session",
+			status.session
+		], [
+			"disconnect",
+			"--session",
+			status.session
+		]]) try {
+			run(args);
+		} catch (error) {
+			failures.push(error.message);
+		}
+		report(failures.length ? `could not clean up agent-device connection for ${status.session}: ${failures.join("; ")}` : `closed agent-device connection for ${status.session}`);
+	} catch (error) {
+		report(`could not clean up agent-device connection: ${error.message}`);
+	}
+}
+//#endregion
+//#region src/device-host/hosted-logs.ts
+const MAX_PAGES = 64;
+const MACOS = {
+	platform: "macos",
+	slot: "default"
+};
+const logsStateDir = (root, target) => target.platform === "macos" ? macosDir(root) : join(workspaceDir(root), "ios", validateDeviceSlot(target.slot));
+const cursorFile = (root, target) => join(logsStateDir(root, target), "host-logs-cursor.json");
+const hostLogFile = (root, target) => join(workspaceLogsDir$1(root), `${target.platform === "macos" ? "macos" : deviceSlotFileKey("ios", target.slot)}-host.ndjson`);
+function readCursor(root, session, target) {
+	try {
+		const stored = JSON.parse(readFileSync(cursorFile(root, target), "utf8"));
+		if (isJsonObject(stored) && stored.session === session) return parseHostedLogsCursor(stored.cursor) ?? void 0;
+	} 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) {
+	if (!records.length && sameCursor(before, cursor)) return;
+	const directory = logsStateDir(root, target);
+	withDirLock(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 });
+			try {
+				for (const record of records) writer.write(target.platform === "ios" ? {
+					...record,
+					src: "device",
+					platform: "ios",
+					slot: target.slot,
+					event: "hosted_native_log"
+				} : record);
+			} finally {
+				writer.close();
+			}
+		}
+		const temporary = `${cursorFile(root, target)}.${process.pid}.tmp`;
+		try {
+			writeFileSync(temporary, JSON.stringify({
+				session,
+				cursor
+			}), { mode: 384 });
+			renameSync(temporary, cursorFile(root, target));
+		} finally {
+			rmSync(temporary, { force: true });
+		}
+	}, { ensureParent: () => mkdirSync(directory, { recursive: true }) });
+}
+async function pullHostedMacosLogs(root, placement, host, target = MACOS, maxPages = MAX_PAGES, final = false) {
+	const deadline = Date.now() + (final ? 3e4 : 12e4);
+	let checkpoint;
+	let progressAt = 0;
+	for (let page = 0; page < maxPages && Date.now() < deadline; page++) {
+		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`);
+			progressAt = Date.now() + 5e3;
+		}
+		const result = await call(host, "device-host.logs.query", {
+			session: placement.session,
+			...before ? { cursor: before } : {}
+		}, 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);
+		if (!result.more) return;
+		const nextCheckpoint = typeof result.checkpoint === "number" ? result.checkpoint : void 0;
+		if (sameCursor(cursor, before) && nextCheckpoint === checkpoint) {
+			if (target.platform === "macos" && !final) return;
+			throw new Error("Hosted native logs made no progress; keeping the logs already copied here.");
+		}
+		checkpoint = nextCheckpoint;
+	}
+	if (target.platform === "ios") 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 pullHostedIosLogs(root, slot, placement, host, final = false) {
+	if (!host.connection.supports("hosted-ios-data")) throw new Error(`${host.machine} needs a newer stim-server to collect hosted iOS native logs.`);
+	await pullHostedMacosLogs(root, placement, host, {
+		platform: "ios",
+		slot
+	}, final ? 1024 : MAX_PAGES, final);
+}
+//#endregion
+export { agentAccess as i, pullHostedMacosLogs as n, closeAgentConnection as r, pullHostedIosLogs as t };