stim 1.19.0 → 1.20.0

package/dist/remote-BU9UyhCJ.mjs

@@ -0,0 +1,192 @@
+import { z as deviceSlotPlatforms } from "./config-D0LhTY3S.mjs";
+import { F as parseIosRemote, H as remoteIosSetting, L as publicUrlSetting, V as remoteEasFallbackSetting, tt as tunnelModeSetting } from "./settings-Bbztm4oV.mjs";
+import { l as phaseLine } from "./command-output-BjPN99ZB.mjs";
+import { n as devicePlacementRecord } from "./placement-log-reFbjqEr.mjs";
+import { c as devicePlacementLine } from "./build-plan-CP0tckNU.mjs";
+import "./device-remote-Bmg42063.mjs";
+import { b as resolveSimulatorAppFlag } from "./support-DCco5fut.mjs";
+import chalk from "chalk";
+//#region src/commands/ios/remote.ts
+function resolveIosRemote({ opts, settings, physical, recorded }) {
+	const target = opts.remote !== void 0 ? parseIosRemote(opts.remote) : remoteIosSetting(settings);
+	if (physical && target?.kind === "machine") return { failure: {
+		code: "STIM_BAD_ARG",
+		message: "--device builds for a phone connected to this machine, and --remote installs on a remote one.",
+		remedy: "Pass only one of --device and --remote; unset ios.remote for a local phone."
+	} };
+	const machine = target?.kind === "machine" ? target.machine : null;
+	if (recorded && recorded.machine !== machine && machine !== "auto") return { failure: {
+		code: "STIM_BAD_ARG",
+		message: `This workspace's iOS simulator runs on ${recorded.machine}; run stim stop first.`
+	} };
+	return {
+		machine,
+		backend: !physical && target?.kind === "backend" ? target.backend : null,
+		recorded
+	};
+}
+function selectIosTarget({ root, slot, opts, settings, physical, appMode, metroCheck, d }) {
+	let recorded;
+	try {
+		recorded = d.readHostedIos(root, slot)[slot];
+	} catch (error) {
+		return { failure: {
+			code: "STIM_HOSTING_REFUSED",
+			message: error.message,
+			...error instanceof Error && "remedy" in error && typeof error.remedy === "string" ? { remedy: error.remedy } : {}
+		} };
+	}
+	const selection = resolveIosRemote({
+		opts,
+		settings,
+		physical,
+		recorded
+	});
+	if ("failure" in selection) return selection;
+	const localIos = selection.machine ? deviceSlotPlatforms(d.getProject(root), slot)?.ios : void 0;
+	if (selection.machine !== "auto" && selection.machine && localIos?.owned && localIos.deviceUdid) {
+		let localRunning = true;
+		try {
+			localRunning = d.listAllIosSims({ timeoutMs: 5e3 }).some((sim) => sim.udid === localIos.deviceUdid && sim.state !== "Shutdown");
+		} catch {}
+		if (localRunning) return { failure: {
+			code: "STIM_BAD_ARG",
+			message: `This workspace's iOS simulator for slot ${slot} runs on this Mac; run stim stop first.`
+		} };
+	}
+	if (selection.machine !== "auto" && selection.machine && appMode === "development" && !metroCheck) return { failure: {
+		code: "STIM_BAD_ARG",
+		message: "Hosted Debug runs require the local Metro supervisor; --no-metro-check cannot be used.",
+		remedy: "Run stim stop; stim start, then retry without --no-metro-check."
+	} };
+	return selection;
+}
+async function selectIosPlacement(args) {
+	const selection = selectIosTarget(args);
+	if ("failure" in selection || selection.machine !== "auto") return selection;
+	const { root, slot, d, opts, deviceType, runtime, noWait, phase, log, release, appMode, metroCheck } = args;
+	const viewer = resolveSimulatorAppFlag(opts.simulatorApp, args.physical, null);
+	if ("refusal" in viewer) return { failure: viewer.refusal };
+	const refusal = args.validateSelectors();
+	if (refusal) return { failure: refusal };
+	const easFallback = args.supportsRemote && remoteEasFallbackSetting(args.settings);
+	try {
+		const placed = await d.automaticDevicePlacement({
+			root,
+			slot,
+			platform: "ios",
+			selectors: hostedIosSelectors(deviceType, runtime),
+			appMode,
+			buildMachine: opts.remoteBuild,
+			noWait,
+			...easFallback ? { eas: () => d.checkEasFallback({
+				root,
+				platform: "ios",
+				slot,
+				release,
+				isExpo: d.detectIsExpo(root),
+				tunnelMode: tunnelModeSetting(args.settings),
+				publicUrl: publicUrlSetting(args.settings),
+				deviceTypeFlag: opts.deviceType,
+				localOnlyFlags: typeof opts.runtime === "string" ? ["--runtime"] : []
+			}) } : {}
+		});
+		phase("placement:", devicePlacementLine(placed.placement, placed.skipped));
+		log?.(devicePlacementRecord({
+			platform: "ios",
+			fromFlag: opts.remote !== void 0,
+			easFallback,
+			placed
+		}));
+		if (placed.placement.decision === "eas") return {
+			...selection,
+			machine: null,
+			backend: "eas",
+			recorded: void 0,
+			auto: { target: null },
+			devicePlacement: placed.placement
+		};
+		if (placed.target && appMode === "development" && !metroCheck) return { failure: {
+			code: "STIM_BAD_ARG",
+			message: "Hosted Debug runs require the local Metro supervisor; --no-metro-check cannot be used.",
+			remedy: "Run stim stop; stim start, then retry without --no-metro-check."
+		} };
+		return {
+			...selection,
+			machine: placed.target?.host.machine ?? null,
+			recorded: void 0,
+			auto: { target: placed.target },
+			budget: placed.target ? {
+				reclaimed: [],
+				refusal: null
+			} : void 0,
+			devicePlacement: placed.placement
+		};
+	} catch (error) {
+		return { failure: {
+			code: error.code ?? "STIM_HOSTING_REFUSED",
+			message: error.message,
+			...error instanceof Error && "remedy" in error && typeof error.remedy === "string" ? { remedy: error.remedy } : {}
+		} };
+	}
+}
+function hostedIosSelectors(deviceType, runtime) {
+	return {
+		...deviceType ? { deviceType } : {},
+		...runtime ? { runtime } : {}
+	};
+}
+async function connectIosTarget(selection, selectors, d, appMode) {
+	if (selection.auto) return { target: selection.auto.target };
+	if (!selection.machine) return { target: null };
+	try {
+		return { target: await d.prepareHostedIos(selection.machine, selectors, selection.recorded, appMode) };
+	} catch (error) {
+		return { failure: {
+			code: error instanceof Error && "code" in error && typeof error.code === "string" ? error.code : "STIM_HOSTING_REFUSED",
+			message: error instanceof Error ? error.message : String(error),
+			...error instanceof Error && "remedy" in error && typeof error.remedy === "string" ? { remedy: error.remedy } : {}
+		} };
+	}
+}
+async function iosPlacementBudget(d, root, note, hosted, automatic, simSnapshot) {
+	if (automatic) return {
+		...automatic,
+		refusal: hosted ? null : automatic.refusal
+	};
+	return hosted ? {
+		reclaimed: [],
+		refusal: null
+	} : d.budgetGate({
+		root,
+		note,
+		simSnapshot
+	});
+}
+function hostedIosMetroNote(hosted, settings, note, simulatorApp) {
+	if (hosted && (settings.iosSimulatorApp !== void 0 || simulatorApp !== void 0)) note(chalk.dim(phaseLine("device", "iosSimulatorApp is ignored on a hosting Mac; the simulator boots headless.")));
+	if (hosted && (publicUrlSetting(settings) || tunnelModeSetting(settings))) note(chalk.dim(phaseLine("metro", "metro.publicUrl and metro.tunnel are ignored on a hosting Mac; Metro uses the private tailnet bridge.")));
+}
+async function connectIosBackend(root, backend, deviceType, d) {
+	if (!backend) return {
+		remote: null,
+		arch: null
+	};
+	const resolved = await d.resolveRemoteContext({
+		root,
+		backend,
+		easBin: d.resolveEasCliBin(root)?.file ?? null,
+		deviceType: deviceType?.trim() || null
+	});
+	if ("failed" in resolved) return { failure: {
+		code: resolved.code ?? "STIM_NO_REMOTE_SESSION",
+		message: resolved.failed,
+		remedy: resolved.remedy
+	} };
+	return {
+		remote: d.remoteIosDeps(resolved.ctx),
+		arch: await d.readRemoteSimulatorArch(resolved.ctx.existingDaemon)
+	};
+}
+//#endregion
+export { iosPlacementBudget as a, hostedIosSelectors as i, connectIosTarget as n, selectIosPlacement as o, hostedIosMetroNote as r, connectIosBackend as t };

package/dist/{remote-cache-N3hAEaAL.mjs → remote-cache-Bsts6f6Y.mjs}

@@ -1,9 +1,9 @@
-import { t as getExecutor } from "./exec-i8GDPwq9.mjs";
+import { t as getExecutor } from "./exec-B81Qodjn.mjs";
+import { w as workspaceLogsDir } from "./workspace-state-CSIFuuDa.mjs";
 import { n as stripAnsi } from "./process-output-Fpl8PYi8.mjs";
-import { x as workspaceLogsDir } from "./workspace-state-CR9X86xJ.mjs";
-import { v as resolvePackageJson } from "./project-B5eQ1USs.mjs";
-import { r as createNdjsonWriter } from "./ndjson-LGZAMsqa.mjs";
-import { n as expoBinFromPackage, r as expoBinPath, s as findBinUpward } from "./server-expo-n3tUi3Em.mjs";
+import { S as resolvePackageJson } from "./project-B8_duAzW.mjs";
+import { r as createNdjsonWriter } from "./ndjson-GOnbyvso.mjs";
+import { n as expoBinFromPackage, r as expoBinPath, s as findBinUpward } from "./server-expo-CsYu2aKL.mjs";
 import { createRequire } from "node:module";
 import { existsSync, readFileSync } from "node:fs";
 import { join } from "node:path";

package/dist/result-BDoRk1k3.mjs

@@ -0,0 +1,186 @@
+import { y as workspaceAgentDeviceDir } from "./workspace-state-CSIFuuDa.mjs";
+import { i as formatDuration, l as phaseLine } from "./command-output-BjPN99ZB.mjs";
+import { i as workspaceLinkLine } from "./stim-desktop-8GQX2OV8.mjs";
+import { Dt as recordFinishedBuild } from "./budget-BONq9vXY.mjs";
+import { a as easAuthNote, n as UPLOAD_TIMEOUT_MS, r as cacheLevel, s as isEasAuthFailureText } from "./remote-cache-Bsts6f6Y.mjs";
+import "./launch-verify-BzRdbuO1.mjs";
+import { n as CCACHE_UNAVAILABLE, r as ccacheActivityLine } from "./ccache-CjHQ5F8g.mjs";
+import { a as PLATFORM } from "./support-CnE_SIjt.mjs";
+import { buildDiagnostics } from "@stim-cli/core/state";
+import chalk from "chalk";
+//#region src/commands/android/result.ts
+function androidFacts({ root, slot, serial, avdName = null, deviceName = null, systemImage = null, deviceProfile = null, fingerprint, cacheKey = null, variant = null, metroPort = null, cacheHit, cacheSkipped = false, waitedForBuild = null, appPath, bundleId, installSkipped = false, launched, ccache = CCACHE_UNAVAILABLE, logs, debugHttpHost = null, debugHttpHostNote = null, devClientUrl = null, durationMs, lease, devServer = null, buildMachine = "auto", builtOn, offloadedTo = null, offloadFallback = null, host }) {
+	return {
+		platform: PLATFORM,
+		...host ? { host } : {},
+		...slot && slot !== "default" ? { slot } : {},
+		serial: serial ?? null,
+		avdName: avdName ?? null,
+		deviceName: deviceName ?? avdName ?? null,
+		systemImage: systemImage ?? null,
+		deviceProfile: deviceProfile ?? null,
+		fingerprint: fingerprint ?? null,
+		cacheKey: cacheKey ?? null,
+		variant: variant ?? null,
+		metroPort: metroPort ?? null,
+		cacheHit: cacheLevel(cacheHit),
+		cacheSkipped: Boolean(cacheSkipped),
+		buildMachine,
+		...builtOn ? { builtOn } : {},
+		...offloadedTo ? { offloadedTo } : {},
+		...offloadFallback ? { offloadFallback } : {},
+		waitedForBuild: waitedForBuild ? {
+			pid: waitedForBuild.pid ?? null,
+			ms: waitedForBuild.ms ?? 0
+		} : null,
+		appPath: appPath ?? null,
+		bundleId: bundleId ?? null,
+		installSkipped: Boolean(installSkipped),
+		launched: launched === "unverified" || launched === "bundling" ? launched : Boolean(launched),
+		ccache,
+		debugHttpHost: debugHttpHost ?? null,
+		debugHttpHostNote: debugHttpHostNote ?? null,
+		devClientUrl: devClientUrl ?? null,
+		logs: logs ?? null,
+		...root && !host ? { agentDevice: { stateDir: workspaceAgentDeviceDir(root) } } : {},
+		durationMs: typeof durationMs === "number" && Number.isFinite(durationMs) ? durationMs : null,
+		...lease === void 0 ? {} : { lease },
+		...devServer ? { devServer } : {}
+	};
+}
+function lastBuildRecord({ devicePlacement, fingerprint, cacheKey, cacheHit, cacheSkipped = false, durationMs, appPath, bundleId, startedAt, status, errorCode = null, avdName = null, deviceName = null, missReason = null, diagnostics = null, configuration = null, buildMachine = "auto", builtOn, offloadedTo = null, offloadFallback = null }) {
+	const record = {
+		platform: PLATFORM,
+		avdName: avdName ?? null,
+		deviceName: deviceName ?? avdName ?? null,
+		fingerprint: fingerprint ?? null,
+		cacheKey: cacheKey ?? null,
+		cacheHit: cacheLevel(cacheHit),
+		cacheSkipped: Boolean(cacheSkipped),
+		durationMs: Number.isFinite(durationMs) ? durationMs : null,
+		appPath: appPath ?? null,
+		bundleId: bundleId ?? null,
+		startedAt,
+		status,
+		configuration: configuration ?? null
+	};
+	if (errorCode) record.errorCode = errorCode;
+	if (devicePlacement) record.devicePlacement = devicePlacement;
+	record.buildMachine = buildMachine;
+	if (builtOn) record.builtOn = builtOn;
+	if (offloadedTo) record.offloadedTo = offloadedTo;
+	if (offloadFallback) record.offloadFallback = offloadFallback;
+	if (missReason && !cacheLevel(cacheHit)) record.missReason = missReason;
+	const recorded = status === "failed" ? buildDiagnostics(diagnostics) : [];
+	if (recorded.length) record.diagnostics = recorded;
+	return record;
+}
+async function finishAndroidUpload(uploadPending, remote, phase) {
+	if (!uploadPending) return false;
+	const upload = await uploadPending;
+	if (upload?.uploaded) phase("cache", `uploaded (${remote?.name})`);
+	else if (upload?.timedOut) {
+		phase("cache", chalk.yellow(`${remote?.name} upload still running after ${formatDuration(UPLOAD_TIMEOUT_MS)}; not waiting`));
+		return true;
+	} else if (upload?.failed) {
+		const authNote = remote?.name === "eas" && isEasAuthFailureText(upload.failed) ? easAuthNote({
+			code: "logged-out",
+			reason: upload.failed,
+			phase: "upload"
+		}) : null;
+		phase("cache", chalk.yellow(authNote || `${remote?.name} upload failed: ${upload.failed}`));
+	}
+	return false;
+}
+function reportAndroidResult({ host, root, slot, json, useBuildCache, variant, release, runtimeKind = release ? "embedded-js" : "metro", metroCheck, metroPort, logsDir, serial, apkPath, androidPackage, installSkipped, record, waitedForBuild, remote, providerName, launchState, launchWarning, launched, ccache, durationMs, writer, emit, lease, recordRun, reclaimed = [], devServer = null, links }) {
+	const offloadedTo = record.offloadedTo ?? null;
+	recordRun({
+		failed: false,
+		cacheHit: cacheLevel(record.cacheHit),
+		waited: waitedForBuild,
+		durationMs,
+		offloadedTo
+	});
+	const facts = androidFacts({
+		host,
+		root,
+		slot,
+		serial,
+		avdName: record.avdName,
+		deviceName: record.deviceName,
+		systemImage: record.systemImage,
+		deviceProfile: record.deviceProfile,
+		debugHttpHost: launched.debugHttpHost ?? null,
+		debugHttpHostNote: launched.debugHttpHostNote ?? null,
+		devClientUrl: launched.devClientUrl ?? null,
+		fingerprint: record.fingerprint,
+		cacheKey: record.cacheKey,
+		variant,
+		metroPort,
+		cacheHit: record.cacheHit,
+		cacheSkipped: record.cacheSkipped || !useBuildCache,
+		waitedForBuild,
+		appPath: apkPath,
+		bundleId: androidPackage,
+		installSkipped,
+		launched: launchState,
+		ccache,
+		logs: logsDir,
+		durationMs,
+		lease,
+		devServer,
+		buildMachine: record.buildMachine,
+		builtOn: record.builtOn ?? void 0,
+		offloadedTo,
+		offloadFallback: record.offloadFallback ?? null
+	});
+	writer.close();
+	if (record.devicePlacement) facts.devicePlacement = record.devicePlacement;
+	if (json) emit(JSON.stringify({
+		...facts,
+		...links ? { links } : {},
+		...reclaimed.length ? { reclaimed } : {}
+	}));
+	else {
+		const summary = `${launchWarning ? "WARNING" : "OK"}: ${androidPackage} launched on ${host ? `${host.device?.name ?? "Android emulator"} on ${host.machine}` : serial}, ${runtimeKind === "process" ? `${variant ?? "debug"} (native process, no Metro)` : runtimeKind === "embedded-js" ? `${variant} (embedded JS, no Metro)` : `Metro port ${metroPort}`} (${cacheOutcome(record.cacheHit, remote?.name ?? providerName, offloadedTo)})`;
+		const outcome = launchWarning ? chalk.yellow(`${summary} -- ${launchWarning}`) : launchState === "unverified" ? chalk.yellow(`${summary} -- launch UNVERIFIED`) : launchState === "bundling" ? chalk.green(`${summary} -- bundle requested, still building`) : chalk.green(summary);
+		const deviceName = record.avdName || record.deviceName || serial;
+		const cacheResult = useBuildCache ? cacheOutcome(record.cacheHit, remote?.name ?? providerName, offloadedTo) : `bypassed; ${cacheOutcome(false, null, offloadedTo)}`;
+		const metroResult = runtimeKind === "process" ? "native process (no Metro)" : runtimeKind === "embedded-js" ? `embedded (${variant})` : !metroCheck ? `check skipped on port ${metroPort}` : launchState === "unverified" ? `state unverified on port ${metroPort}` : `running on port ${metroPort}${devServer ? ` (started: ${devServer.reason})` : ""}`;
+		emit([
+			outcome,
+			phaseLine("device", host ? `${deviceName} on ${host.machine}` : `${deviceName} (${serial})`),
+			phaseLine("app", androidPackage),
+			phaseLine(runtimeKind === "process" ? "runtime" : "metro", metroResult),
+			phaseLine("cache", cacheResult),
+			...ccache.status === "not-run" ? [phaseLine("compilation cache", ccacheActivityLine(ccache))] : [],
+			phaseLine("logs", logsDir || "unavailable (remote device)"),
+			...!host ? [phaseLine("agent-device", `AGENT_DEVICE_STATE_DIR=${workspaceAgentDeviceDir(root)}`)] : []
+		].join("\n"));
+		if (links) console.error(chalk.dim(workspaceLinkLine(links)));
+	}
+	return facts;
+}
+function cacheOutcome(cacheHit, providerName = null, offloadedTo = null) {
+	if (cacheHit === "remote") return `cache hit from ${providerName || "the remote cache"}`;
+	if (cacheHit === "local") return "cache hit";
+	return offloadedTo ? `built on ${offloadedTo}` : "built";
+}
+function persistLastBuild({ recordBuild = recordFinishedBuild, root, record, startedAt, durationMs, status, errorCode = null, diagnostics = null, out }) {
+	const lastBuild = lastBuildRecord({
+		...record,
+		startedAt,
+		durationMs,
+		status,
+		errorCode,
+		diagnostics
+	});
+	try {
+		recordBuild(root, lastBuild);
+	} catch (err) {
+		out(phaseLine("state", chalk.yellow(`could not record lastBuild: ${err?.message || err}`)));
+	}
+	return lastBuild;
+}
+//#endregion
+export { reportAndroidResult as a, persistLastBuild as i, finishAndroidUpload as n, lastBuildRecord as r, androidFacts as t };

package/dist/{run-lAkle1-c.mjs → run-qvff78hv.mjs}

@@ -1,7 +1,7 @@
 import { n as ownership_claim_exports, t as process_identity_exports } from "./process-identity-Biv3arCO.mjs";
-import { t as getExecutor } from "./exec-i8GDPwq9.mjs";
-import { a as macosRuntimeClaim, i as macosProcess, r as macosLogFile, s as updateMacosRecord } from "./state-Tp4uImDS.mjs";
-import { r as createNdjsonWriter } from "./ndjson-LGZAMsqa.mjs";
+import { t as getExecutor } from "./exec-B81Qodjn.mjs";
+import { r as createNdjsonWriter } from "./ndjson-GOnbyvso.mjs";
+import { a as macosRuntimeClaim, i as macosProcess, r as macosLogFile, s as updateMacosRecord } from "./state-Boo0IMJq.mjs";
 import { readMacosRecord } from "@stim-cli/core/state";
 import { LOG_ROTATE_BYTES } from "@stim-cli/core";
 import { StringDecoder } from "node:string_decoder";

package/dist/{server-bare-CkIjnegq.mjs → server-bare-dWjAarki.mjs}

@@ -1,7 +1,7 @@
 import { i as __require, r as __commonJSMin } from "./process-identity-Biv3arCO.mjs";
-import { t as getExecutor } from "./exec-i8GDPwq9.mjs";
-import { O as projectMetroSharedCache } from "./settings-CxgngUZk.mjs";
-import { a as metroStoreRoot, c as supervisorError, o as registerMetroStore, t as appendCacheStore } from "./metro-store-BAHFcJm6.mjs";
+import { t as getExecutor } from "./exec-B81Qodjn.mjs";
+import { K as resolveProjectSettings } from "./settings-Bbztm4oV.mjs";
+import { c as registerMetroStore, f as resolveMetroSharedCache, n as supervisorError, r as appendCacheStore, s as metroStoreRoot } from "./errors-DzkMYh8Q.mjs";
 import { createRequire } from "node:module";
 import { isAbsolute, join, relative, sep } from "node:path";
 //#endregion
@@ -290,7 +290,7 @@ function closeHttpServer(httpServer, timeoutMs) {
 		}
 	});
 }
-async function startBareServer({ root, port, logsDir, writer = null, deps = null, reporterFactory = void 0, cacheStore = void 0, fileStore = void 0, closeTimeoutMs = 5e3, resetCache = false }) {
+async function startBareServer({ root, port, logsDir, writer = null, deps = null, reporterFactory = void 0, cacheStore = void 0, fileStore = void 0, closeTimeoutMs = 5e3, resetCache = false, settings }) {
 	const { metro, devMiddleware, serverApi } = deps || resolveBareDeps(root);
 	const makeReporter = reporterFactory === void 0 ? loadNdjsonReporter(root) : reporterFactory;
 	const config = await metro.loadConfig({
@@ -302,7 +302,7 @@ async function startBareServer({ root, port, logsDir, writer = null, deps = null
 		root,
 		config,
 		writer,
-		enabled: cacheStore === void 0 ? projectMetroSharedCache(root) : cacheStore,
+		enabled: cacheStore === void 0 ? resolveMetroSharedCache(settings ?? resolveProjectSettings(root).settings) : cacheStore,
 		FileStore: fileStore === void 0 ? loadFileStore(root) : fileStore
 	}) && normalizeMetroTransformerPaths(config, root)) writer?.write({
 		src: "metro",

package/dist/server-command-7XIKlWtO.mjs

@@ -0,0 +1,69 @@
+import { t as getExecutor } from "./exec-B81Qodjn.mjs";
+import { n as METRO_COMMAND_PORT } from "./settings-Bbztm4oV.mjs";
+import { w as MODE_COMMAND } from "./project-B8_duAzW.mjs";
+import { d as signalProcessTree } from "./metro-D_j9sN-B.mjs";
+import { r as createNdjsonWriter } from "./ndjson-GOnbyvso.mjs";
+import { f as recordFromLine, m as superviseChildServer } from "./server-expo-CsYu2aKL.mjs";
+import { join } from "node:path";
+import { LOG_ROTATE_BYTES } from "@stim-cli/core";
+//#region src/supervisor/server-command.ts
+function processGroupAlive(pgid) {
+	try {
+		process.kill(-pgid, 0);
+		return true;
+	} catch (err) {
+		return err.code === "EPERM";
+	}
+}
+function commandArgv(command, port) {
+	return command.map((arg) => arg.replaceAll(METRO_COMMAND_PORT, String(port)));
+}
+async function startCommandServer({ root, port, logsDir, command, writer = null, spawnFn = null, signalTree = signalProcessTree, groupAlive = processGroupAlive, killTimeoutMs = 5e3, platform = process.platform }) {
+	const log = writer || createNdjsonWriter(join(logsDir, "metro.ndjson"), { maxBytes: LOG_ROTATE_BYTES });
+	const spawn = spawnFn || ((cmd, args, opts) => getExecutor().spawn(cmd, args, opts));
+	const [program, ...args] = commandArgv(command, port);
+	log.write({
+		src: "metro",
+		level: "debug",
+		event: "cache_store_skipped",
+		msg: "metro.command starts the dev server, so Stim does not add its shared Metro transform store"
+	});
+	const group = platform !== "win32";
+	const child = spawn(program, args, {
+		cwd: root,
+		stdio: [
+			"ignore",
+			"pipe",
+			"pipe"
+		],
+		detached: group,
+		env: {
+			...process.env,
+			FORCE_COLOR: "0"
+		}
+	});
+	return superviseChildServer({
+		mode: MODE_COMMAND,
+		child,
+		log,
+		toRecord: (chunk, stream) => recordFromLine(chunk, {
+			stream,
+			source: "command"
+		}),
+		signal: (sig) => {
+			if (!child.pid) return false;
+			try {
+				return signalTree(child.pid, sig, {
+					group,
+					platform
+				});
+			} catch {
+				return false;
+			}
+		},
+		alive: group ? () => Boolean(child.pid) && groupAlive(child.pid) : null,
+		killTimeoutMs
+	});
+}
+//#endregion
+export { startCommandServer };