stim 1.14.0 → 1.16.0

package/dist/hosted-macos-BSZyIb3y.mjs

@@ -0,0 +1,135 @@
+import { l as phaseLine } from "./command-output-DnJMdEY-.mjs";
+import { t as macosDir } from "./state-3DwSQIBK.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 agentAccess, n as pullHostedMacosLogs, r as closeAgentConnection } from "./hosted-logs-D5g041Q3.mjs";
+import { randomUUID } from "node:crypto";
+import { rmSync } from "node:fs";
+import { join } from "node:path";
+import { hostedMacosBundleId, parseHostedMacosDevice, validHostedAppArguments } from "@stim-cli/core/state";
+//#region src/device-host/hosted-macos.ts
+const HANDOFF_TIMEOUT_MS = 3e5;
+const agentRemoteConfig = (root) => join(macosDir(root), "agent-device-remote.json");
+/**
+* Places a staged `.app` on `host`: reuses the recorded session when the host still holds it ready, else reserves one,
+* then delivers the bundle as a new app attempt, launches it and waits for the host to report it installed. `reserved`
+* records the placement as soon as a session exists, so `stim stop` can find it even if delivery fails.
+*/
+async function placeHostedMacos(host, { root, bundle, bundleId, handoff, arguments: requestedArguments, recorded, reserved, note }) {
+	let session = null;
+	if (recorded) {
+		try {
+			session = await settle(host, await attach(host, recorded.session), ["preparing", "stopping"], SESSION_TIMEOUT_MS);
+		} catch (error) {
+			if (!heldNoLonger(error)) throw error;
+		}
+		if (session?.state === "unknown") throw unknownSession(host, session);
+		if (session?.state === "stopped") session = null;
+	}
+	if (!session) {
+		note(`Reserving a macOS session on ${host.machine}`);
+		session = hostedSession(host, await call(host, "device-host.reserve", {
+			workspace: root,
+			slot: "default",
+			attempt: randomUUID(),
+			platform: "macos"
+		}));
+	}
+	const appSlot = session.appSlot;
+	if (appSlot === void 0) throw new Error(`${host.machine} reserved a session without a macOS app slot.`);
+	const appAttempt = randomUUID();
+	const placement = {
+		machine: host.machine,
+		session: session.id,
+		appSlot,
+		appAttempt,
+		bundleId: hostedMacosBundleId(bundleId, appSlot),
+		agent: {
+			driver: "none",
+			setting: "hosting.agentDriver"
+		}
+	};
+	reserved(placement);
+	session = await settle(host, session, ["preparing"], SESSION_TIMEOUT_MS);
+	if (session.state === "unknown") throw unknownSession(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.`);
+	const { files, content } = bundleManifest(bundle);
+	const manifest = Buffer.from(JSON.stringify(files));
+	content.set(sha256(manifest), () => manifest);
+	const ids = {
+		session: session.id,
+		attempt: appAttempt
+	};
+	const offer = {
+		...ids,
+		bundleId,
+		mode: "release",
+		...requestedArguments.length ? { arguments: requestedArguments } : {},
+		manifest: {
+			sha256: sha256(manifest),
+			size: manifest.length
+		}
+	};
+	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) {
+		try {
+			const taken = await call(host, "device-host.app.handoff", {
+				...ids,
+				build: {
+					handoff: handoff.token,
+					sha256: handoff.sha256
+				}
+			}, HANDOFF_TIMEOUT_MS);
+			if (taken.files) note(`${host.machine} took ${String(taken.files)} files from the build it ran`);
+		} catch (error) {
+			note(`${error instanceof Error ? error.message : String(error)}; uploading the app instead`);
+		}
+		missing = (await call(host, "device-host.app.offer", offer)).missing;
+	}
+	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(`${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 sleep(500);
+		delivery = await call(host, "device-host.app.attach", ids);
+	}
+	const appliedArguments = validHostedAppArguments(delivery.arguments) ? delivery.arguments : [];
+	if (JSON.stringify(appliedArguments) !== JSON.stringify(requestedArguments)) note(`${host.machine} did not apply macos.arguments. Update stim-server on that host.`);
+	if (typeof delivery.notice === "string") note(delivery.notice);
+	return {
+		placement: {
+			...placement,
+			agent: 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) {
+	if (placement.agent.driver === "agent-device") closeAgentConnection(placement.agent.remoteConfig);
+	const host = await connectHost(placement.machine);
+	try {
+		try {
+			let session = hostedSession(host, await call(host, "device-host.stop", { session: placement.session }));
+			session = await settle(host, session, ["stopping"], SESSION_TIMEOUT_MS);
+			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`);
+			});
+		} catch (error) {
+			if (!heldNoLonger(error)) throw error;
+		}
+	} finally {
+		host.connection.close();
+	}
+	rmSync(agentRemoteConfig(root), { force: true });
+}
+//#endregion
+export { stopHostedMacos as n, placeHostedMacos as t };