stim 1.12.0 → 1.13.0

package/dist/web-sWXd5iek.mjs

@@ -0,0 +1,394 @@
+import { T as upsertProject, p as getProject } from "./config-0jCcMM0E.mjs";
+import { t as getExecutor } from "./exec-DK8KaVHK.mjs";
+import { o as readNdjsonGenerations } from "./ndjson-CDY9IkVC.mjs";
+import { M as workspaceLogsDir, c as resolveProjectMetro, f as reserveMetroPort, g as recordWorkspaceUse, h as readWorkspaceState, k as workspaceDir } from "./metro-BPeY1YMh.mjs";
+import { s as gitCommonDir, y as repoRoot } from "./worktree-DeBQSVtR.mjs";
+import { i as findCommandWorkspace, r as detectIsExpo, s as isPackageResolvable } from "./project-DGeclhvO.mjs";
+import { n as windowsLauncherArgs } from "./detached-entry-DJHoca49.mjs";
+import { a as withWorkspaceProcessLock, i as reserveBrowserPort, n as getNamedPort } from "./named-ports-n7tnJsI8.mjs";
+import { f as refuseNoProject, l as phaseLine } from "./command-output-BIL7rlX7.mjs";
+import { P as settingShapeErrors, R as webSettings, a as SETTING_SHAPE_REMEDY, j as resolveSettings } from "./settings-xB0Frkg6.mjs";
+import { d as teardownBrowserHeld, t as resolveSupervisorTarget } from "./ownership-PUP4Dwai.mjs";
+import { a as readWebRecord, f as webSupervisorLogFile, o as updateWebRecord, r as cdpEndpoint, u as webLogFile } from "./state-l1pYwOre.mjs";
+import { i as findChrome, t as CHROME_INSTALL_REMEDY } from "./chrome-B5hWgQJS.mjs";
+import { c as readMetroRecords } from "./launch-verify-CuJaBpEa.mjs";
+import { f as spawnEntry } from "./start-BZhItkiL.mjs";
+import { a as sleep, n as ensureWorkspaceStorageSafely } from "./native-runtime-CiiFHt0e.mjs";
+import { n as sendToOwnedPage, t as liveWebRecord } from "./page-BTu7I60K.mjs";
+import { mkdirSync, openSync } from "node:fs";
+import { randomUUID } from "node:crypto";
+import chalk from "chalk";
+//#region src/web/launch.ts
+const VERIFY_WAIT_MS = 2e4;
+const LOADING_WAIT_MS = 6e4;
+const METRO_WEB_BUNDLE = /\bWeb\s+Bundl(?:ing|ed)\b/i;
+function after(record, since) {
+	const ts = Number(record.ts);
+	return Number.isFinite(ts) && ts >= since;
+}
+/**
+* Decides `launched` for a `stim web` navigation from the owned page's evidence since `since`: `true` needs the
+* page's load event after a successful document response and, for Metro, a web bundle response. A failed
+* document is decided at once. The check ends after 20 seconds, or 60 once a document not served by Metro has
+* answered; until then it returns null while the evidence is incomplete.
+*/
+function webLaunchVerdict({ records, metroRecords = [], since, expectBundle, elapsedMs }) {
+	const recent = records.filter((record) => after(record, since));
+	const failed = recent.find((record) => record.event === "web_document_failed");
+	if (failed) return {
+		launched: "unverified",
+		kind: "document-failed",
+		reason: String(failed.msg ?? "the page did not load")
+	};
+	const documentLoaded = recent.some((record) => record.event === "web_document_response" && Number(record.status) < 400);
+	const pageLoaded = recent.some((record) => record.event === "web_page_loaded");
+	const bundled = recent.some((record) => record.event === "web_bundle_response" && Number(record.status) < 400);
+	if (documentLoaded && pageLoaded && (!expectBundle || bundled)) return {
+		launched: true,
+		kind: "loaded",
+		reason: null
+	};
+	if (documentLoaded && pageLoaded) return {
+		launched: "unverified",
+		kind: "no-bundle",
+		reason: "the page loaded without requesting a web bundle from Metro"
+	};
+	const waitMs = documentLoaded && !expectBundle ? LOADING_WAIT_MS : VERIFY_WAIT_MS;
+	if (elapsedMs < waitMs) return null;
+	if (expectBundle && documentLoaded && metroRecords.some((record) => after(record, since) && METRO_WEB_BUNDLE.test(String(record.msg ?? "")))) return {
+		launched: "bundling",
+		kind: "bundling",
+		reason: "Metro was still building the web bundle"
+	};
+	return documentLoaded ? {
+		launched: "unverified",
+		kind: "loading",
+		reason: `the server answered, but the page did not fire its load event within ${waitMs / 1e3} seconds`
+	} : {
+		launched: "unverified",
+		kind: "no-response",
+		reason: "the page never received a response"
+	};
+}
+const EXPO_WEB_PACKAGES = [
+	"react-dom",
+	"react-native-web",
+	"@expo/metro-runtime"
+];
+const EXPO_WEB_DEPENDENCIES = `npx expo install ${EXPO_WEB_PACKAGES.join(" ")}`;
+const WEB_SERVER_EXAMPLE = "pnpm exec vite --port \"$(stim ports get web)\" --strictPort";
+function webServePlan({ usesMetro, metro, supervisorHeld, missingWebPackages }) {
+	if (!usesMetro) return {
+		serve: `Start the web dev server on that port, for example \`${WEB_SERVER_EXAMPLE}\``,
+		foreign: null
+	};
+	if (metro?.notOurs && (!supervisorHeld || metro.kind === "foreign-cwd")) return {
+		serve: null,
+		foreign: {
+			reason: `Another process holds this workspace's Metro port: ${metro.notOurs}`,
+			remedy: supervisorHeld ? "Run `stim stop` and follow its output, then `stim start`, then run `stim web` again." : "Run `stim start`, which reserves a free Metro port for this workspace, then run `stim web` again."
+		}
+	};
+	if (metro?.metro || supervisorHeld) return {
+		serve: null,
+		foreign: null
+	};
+	return {
+		serve: missingWebPackages.length ? `Run \`${EXPO_WEB_DEPENDENCIES}\` and \`stim start\`` : "Start this workspace's Metro with `stim start`",
+		foreign: null
+	};
+}
+const RETRY = "then run `stim web` again";
+const METRO_BUILD = (url) => `Run \`stim logs --errors\`; Metro may have failed to build the web bundle for ${url}.`;
+function webLaunchRemedy(verdict, { url, template, usesMetro, serve }) {
+	const nothingServed = serve ? `Nothing served ${url}. ${serve}, ${RETRY}.` : METRO_BUILD(url);
+	const https = url.startsWith("https:");
+	const reason = verdict.reason ?? "";
+	const withScheme = (scheme) => template ? `\`stim settings set web.url '${template.replace(/^https?:/, `${scheme}:`)}' --scope workspace\`` : `web.url with ${scheme}://`;
+	const status = Number(/failed: HTTP (\d+)/.exec(reason)?.[1]);
+	switch (verdict.kind) {
+		case "loaded": return null;
+		case "bundling": return "Metro is still building the web bundle. Run `stim logs --errors` in a moment to confirm the page rendered.";
+		case "loading":
+			if (usesMetro) break;
+			return `A cold dev server can take longer on its first load. Read \`stim logs --errors\`, ${RETRY}.`;
+		case "document-failed":
+			if (https && /net::ERR_CERT_/.test(reason)) return `The dev server's certificate is not trusted, as with a self-signed development certificate. Accept it in the owned profile only: \`stim settings set web.ignoreCertificateErrors true --scope workspace\`, ${RETRY}.`;
+			if (https && /net::ERR_SSL_PROTOCOL_ERROR/.test(reason)) return `The server on that port did not answer HTTPS. If it serves plain HTTP, set ${withScheme("http")}, ${RETRY}.`;
+			if (!https && /net::ERR_EMPTY_RESPONSE/.test(reason)) return `The server on that port closed the connection without an HTTP answer. If it serves HTTPS, set ${withScheme("https")}, ${RETRY}.`;
+			if (usesMetro) return Number.isNaN(status) ? nothingServed : METRO_BUILD(url);
+			if (status >= 400 && status < 500) return `The server has no page at ${url}. Check web.url's path, including the app's base path, ${RETRY}.`;
+			if (status >= 500) return `The dev server failed to serve ${url}. Read its output and \`stim logs --errors\`, ${RETRY}.`;
+			break;
+		case "no-response": return nothingServed;
+	}
+	return usesMetro ? METRO_BUILD(url) : nothingServed;
+}
+//#endregion
+//#region src/commands/web.ts
+const PORT_PLACEHOLDER = /\{port:([^}]*)\}/g;
+const REGISTER_WAIT_MS = 3e4;
+const POLL_MS = 250;
+const printNote = (line) => console.error(line);
+function failure(code, message, remedy) {
+	return {
+		ok: false,
+		error: {
+			code,
+			message,
+			remedy
+		}
+	};
+}
+/** Replaces each `{port:<label>}` in a `web.url` template; `metro` is the workspace's Metro port. */
+async function resolveWebUrl(template, { metroPort, namedPort }) {
+	let url = template;
+	for (const [placeholder, label] of template.matchAll(PORT_PLACEHOLDER)) {
+		const port = label === "metro" ? metroPort : await namedPort(label);
+		if (port === null) throw new Error(`${placeholder} needs a Metro port, and this workspace has none reserved.`);
+		url = url.replace(placeholder, String(port));
+	}
+	return url;
+}
+function sameLaunch(record, config) {
+	return record.chrome === config.chrome && record.headless === config.headless && record.viewport === config.viewport && record.ignoreCertificateErrors === config.ignoreCertificateErrors;
+}
+function startSupervisor(root, { url, port, config, launchId }) {
+	const entry = spawnEntry("web-run");
+	const args = [
+		"--root",
+		root,
+		"--chrome",
+		config.chrome,
+		"--url",
+		url,
+		"--port",
+		String(port),
+		"--launch-id",
+		launchId
+	];
+	if (!config.headless) args.push("--headed");
+	if (config.viewport !== "desktop") args.push("--viewport", config.viewport);
+	if (config.ignoreCertificateErrors) args.push("--ignore-certificate-errors");
+	mkdirSync(workspaceLogsDir(root), { recursive: true });
+	const logFile = webSupervisorLogFile(root);
+	if (process.platform === "win32") {
+		const launcher = windowsLauncherArgs({
+			entry,
+			args,
+			cwd: root,
+			logFile
+		});
+		return getExecutor().spawn(launcher.file, launcher.args, {
+			cwd: root,
+			stdio: "ignore",
+			env: {
+				...process.env,
+				...launcher.env
+			},
+			windowsHide: true
+		});
+	}
+	const fd = openSync(logFile, "a");
+	const child = getExecutor().spawn(process.execPath, [entry, ...args], {
+		cwd: root,
+		detached: true,
+		stdio: [
+			"ignore",
+			fd,
+			fd
+		],
+		env: process.env
+	});
+	child.unref?.();
+	return child;
+}
+async function waitForSupervisor(root, child, launchId) {
+	let exited = false;
+	if (process.platform !== "win32") child.once("exit", () => {
+		exited = true;
+	});
+	const deadline = Date.now() + REGISTER_WAIT_MS;
+	while (Date.now() < deadline) {
+		const record = readWebRecord(root);
+		if (record?.launchId === launchId && record.targetId) return record;
+		if (exited) return null;
+		await sleep(POLL_MS);
+	}
+	return null;
+}
+async function verifyLaunch(root, since, expectBundle) {
+	const startedAt = Date.now();
+	for (;;) {
+		const verdict = webLaunchVerdict({
+			records: readNdjsonGenerations(webLogFile(root)),
+			metroRecords: expectBundle ? readMetroRecords(workspaceLogsDir(root)) : [],
+			since,
+			expectBundle,
+			elapsedMs: Date.now() - startedAt
+		});
+		if (verdict) return verdict;
+		await sleep(POLL_MS);
+	}
+}
+async function runWeb({ root, headed, note }) {
+	const startedAt = Date.now();
+	await ensureWorkspaceStorageSafely(root, { note });
+	if (!getProject(root)) upsertProject(root, {});
+	const settings = resolveSettings({
+		projectPath: root,
+		gitCommonDir: gitCommonDir(root),
+		repoRoot: repoRoot(root)
+	});
+	const [shapeError] = settingShapeErrors(settings);
+	if (shapeError) return failure("STIM_BAD_ARG", shapeError, SETTING_SHAPE_REMEDY);
+	const web = webSettings(settings);
+	const chrome = findChrome();
+	if (!chrome) return failure("STIM_WEB_NO_CHROME", "Google Chrome or Chromium is not installed.", CHROME_INSTALL_REMEDY);
+	const usesMetro = web.url === null || web.url.includes("{port:metro}");
+	if (web.url === null && !detectIsExpo(root)) return failure("STIM_WEB_NO_URL", "This is not an Expo app, so Stim does not know which page to open.", "Start your web dev server on a named port, then set the page: `stim settings set web.url 'http://localhost:{port:web}/' --scope workspace`. See `stim guide web`.");
+	if (web.url === null && !isPackageResolvable(root, "react-native-web")) return failure("STIM_WEB_DEPS_MISSING", "This Expo app cannot render on the web: react-native-web is not installed.", `Run \`${EXPO_WEB_DEPENDENCIES}\` and \`stim start\`, then run \`stim web\` again.`);
+	let metroPort = getProject(root)?.metroPort ?? null;
+	if (usesMetro && metroPort === null) metroPort = await reserveMetroPort(root);
+	const metro = usesMetro && metroPort !== null ? await resolveProjectMetro(metroPort, root) : null;
+	const supervisor = resolveSupervisorTarget({
+		state: readWorkspaceState(root)?.supervisor,
+		record: getProject(root)?.supervisor,
+		reservedPort: metroPort
+	});
+	const { serve, foreign } = webServePlan({
+		usesMetro,
+		metro,
+		supervisorHeld: supervisor.status !== "none" && supervisor.status !== "stale",
+		missingWebPackages: usesMetro && detectIsExpo(root) ? EXPO_WEB_PACKAGES.filter((name) => !isPackageResolvable(root, name)) : []
+	});
+	let url;
+	try {
+		url = await resolveWebUrl(web.url ?? "http://localhost:{port:metro}/", {
+			metroPort,
+			namedPort: (label) => getNamedPort(root, label, { log: note })
+		});
+	} catch (error) {
+		return failure("STIM_BAD_ARG", `web.url: ${error.message}`, SETTING_SHAPE_REMEDY);
+	}
+	const config = {
+		chrome,
+		headless: !headed,
+		viewport: web.viewport,
+		ignoreCertificateErrors: web.ignoreCertificateErrors
+	};
+	const launch = await withWorkspaceProcessLock(workspaceDir(root), "web", async () => {
+		const live = liveWebRecord(readWebRecord(root));
+		if (live && sameLaunch(live, config)) {
+			const since = Date.now();
+			try {
+				await sendToOwnedPage(live, "Page.navigate", { url });
+				updateWebRecord(root, live, { url });
+				note(chalk.dim(phaseLine("device", `reusing the owned Chrome (pid ${live.chromeProcess?.pid})`)));
+				return {
+					ok: true,
+					record: {
+						...live,
+						url
+					},
+					since,
+					reused: true
+				};
+			} catch (error) {
+				note(chalk.dim(phaseLine("device", `restarting the owned Chrome: ${error.message}`)));
+			}
+		}
+		const stopped = await teardownBrowserHeld(root);
+		if (stopped.status === "failed" || stopped.status === "skipped") return failure("STIM_WEB_BROWSER_HELD", `The previous owned Chrome could not be stopped: ${stopped.reason ?? "unknown reason"}.`, "Run `stim status` and `stim guide errors teardown`.");
+		const port = await reserveBrowserPort(root, { log: note });
+		const since = Date.now();
+		note(chalk.dim(phaseLine("device", `starting ${config.headless ? "headless " : ""}Chrome on DevTools port ${port}`)));
+		const launchId = randomUUID();
+		const record = await waitForSupervisor(root, startSupervisor(root, {
+			url,
+			port,
+			config,
+			launchId
+		}), launchId);
+		if (!record) return failure("STIM_WEB_LAUNCH_FAILED", "The owned Chrome did not start.", `Read ${webSupervisorLogFile(root)} and \`stim logs --errors\`, then run \`stim web\` again.`);
+		return {
+			ok: true,
+			record,
+			since,
+			reused: false
+		};
+	}, {
+		external: true,
+		ownerPurpose: "stim web"
+	});
+	if (!launch.ok) return launch;
+	const measured = await verifyLaunch(root, launch.since, usesMetro);
+	const live = liveWebRecord(readWebRecord(root));
+	const record = live ?? launch.record;
+	const verdict = foreign ? {
+		launched: "unverified",
+		kind: "no-response",
+		reason: foreign.reason
+	} : measured;
+	const remedy = foreign ? foreign.remedy : webLaunchRemedy(verdict, {
+		url,
+		template: web.url,
+		usesMetro,
+		serve
+	});
+	return {
+		ok: true,
+		remedy: verdict.reason && remedy ? `${verdict.reason}. ${remedy}` : remedy,
+		facts: {
+			platform: "web",
+			browser: "chrome",
+			version: record.version ?? null,
+			running: live !== null,
+			pid: live?.chromeProcess?.pid ?? null,
+			supervisorPid: live?.pid ?? null,
+			url,
+			headless: record.headless,
+			viewport: record.viewport,
+			profile: record.profile,
+			cdpEndpoint: live ? cdpEndpoint(live.cdpPort) : null,
+			reused: launch.reused,
+			launched: verdict.launched,
+			metroPort: usesMetro ? metroPort : null,
+			logs: { dir: workspaceLogsDir(root) },
+			durationMs: Date.now() - startedAt
+		}
+	};
+}
+function webCommand(program) {
+	program.command("web").description("Open this workspace's page in a Stim-owned headless Chrome and capture its console, errors and failed requests in stim logs").option("--headed", "Show the Chrome window instead of running headless").option("--json", "Print the result as one JSON object; progress goes to stderr").action(async (opts) => {
+		const json = Boolean(opts.json);
+		const root = findCommandWorkspace(process.cwd());
+		if (!root) {
+			refuseNoProject({ json });
+			return;
+		}
+		recordWorkspaceUse(root);
+		const result = await runWeb({
+			root,
+			headed: Boolean(opts.headed),
+			note: printNote
+		});
+		if (!result.ok) {
+			printNote(chalk.red(phaseLine("error", `${result.error.code}: ${result.error.message}`)));
+			if (result.error.remedy) printNote(phaseLine("remedy", result.error.remedy));
+			if (json) console.log(JSON.stringify(result.error));
+			process.exitCode = 1;
+			return;
+		}
+		const { facts, remedy } = result;
+		if (remedy) printNote(chalk.yellow(phaseLine("launch", remedy)));
+		if (json) {
+			console.log(JSON.stringify(facts));
+			return;
+		}
+		const launched = facts.launched === true ? chalk.green("loaded") : chalk.yellow(facts.launched === "bundling" ? "bundling" : "unverified");
+		console.log(facts.running ? `${facts.url} ${launched} in ${facts.version ?? "Chrome"} (pid ${facts.pid}, ${facts.headless ? "headless" : "headed"}, ${facts.viewport}). DevTools: ${facts.cdpEndpoint}. Logs: stim logs --errors.` : `${facts.url} ${launched}, and the owned Chrome is no longer running. Run stim logs --errors, then stim web again.`);
+	});
+}
+//#endregion
+export { webCommand as default, resolveWebUrl, runWeb };

package/dist/{worktree-B5sTRskL.mjs → worktree-3cBa-bQt.mjs}

@@ -1,2 +1,2 @@
-import { a as reclaimKeys, c as removalBlockers, d as removeWorktreeTarget, f as worktreeCommand, i as porcelainPath, l as removalPath, n as excludePodChurn, o as registerRemove, r as matchWorktreeEntry, s as registerWarm, t as dependencyInstallCommand, u as removalRemedy } from "./worktree-ChDL5fO1.mjs";
+import { a as reclaimKeys, c as removalBlockers, d as removeWorktreeTarget, f as worktreeCommand, i as porcelainPath, l as removalPath, n as excludePodChurn, o as registerRemove, r as matchWorktreeEntry, s as registerWarm, t as dependencyInstallCommand, u as removalRemedy } from "./worktree-D4Do_XiQ.mjs";
 export { worktreeCommand as default, dependencyInstallCommand, excludePodChurn, matchWorktreeEntry, porcelainPath, reclaimKeys, registerRemove, registerWarm, removalBlockers, removalPath, removalRemedy, removeWorktreeTarget };