stim 1.20.2 → 1.21.0

package/dist/web-run.mjs

@@ -1,19 +1,18 @@
-import { j as ownership_claim_exports, k as process_identity_exports } from "./config-BYDxlMY3.mjs";
-import { t as getExecutor } from "./exec-DqKo9GKJ.mjs";
-import { r as recordCreatedDevice } from "./created-devices-Dzd5C2LF.mjs";
-import { d as signalProcessTree } from "./metro-DnCEjCxs.mjs";
-import { t as cancellableSleep } from "./cancellation-C_22VQTH.mjs";
-import { r as createNdjsonWriter } from "./ndjson-GOnbyvso.mjs";
-import { t as relaunchWithLogFile } from "./detached-entry-B9C_zeQC.mjs";
-import { _ as removeSingletonFiles, c as webClaimRoot, d as webLogFile, f as webProfileDir, g as liveProfileHolder, h as chromeProcessState, i as clearWebRecord, l as webDir, m as writeWebRecord, n as browserLogFile, s as updateWebRecord } from "./state-D1Icyjlu.mjs";
-import { c as probeWebDrivers } from "./activity-BSV745Kz.mjs";
-import { t as connectOwnedBrowser } from "./cdp-Dq_ypAlJ.mjs";
-import { i as chromeArgs, n as DESKTOP_PAGE, r as PHONE_SCREEN } from "./chrome-BnzZMqsR.mjs";
+import { f as ownership_claim_exports, p as process_identity_exports, t as getExecutor } from "./exec-_UbtCQcG.mjs";
+import { Qt as cancellableSleep } from "./settings-CsJDEXgK.mjs";
+import { r as createNdjsonWriter } from "./ndjson-CgE_o3Dl.mjs";
+import { p as signalProcessTree } from "./metro-DEXpIhHC.mjs";
+import { c as webClaimRoot, f as webLogFile, g as chromeProcessState, h as writeWebRecord, i as clearWebRecord, l as webDir, n as browserLogFile, p as webProfileDir, s as updateWebRecord, v as liveProfileHolder, y as removeSingletonFiles } from "./state-C4ZtUisW.mjs";
+import { l as probeWebDrivers } from "./activity-BzVfHSrY.mjs";
+import { r as recordCreatedDevice } from "./created-devices-CqeBlrEn.mjs";
+import { t as connectOwnedBrowser } from "./cdp-CWmIUMbw.mjs";
+import { i as chromeArgs, n as DESKTOP_PAGE, r as PHONE_SCREEN } from "./chrome-B6tfCta1.mjs";
+import { t as relaunchWithLogFile } from "./detached-entry-DFRyG1_o.mjs";
 import { existsSync, mkdirSync, openSync, realpathSync } from "node:fs";
 import { isAbsolute, resolve } from "node:path";
+import { LOG_ROTATE_BYTES } from "@stim-cli/core";
 import { WEB_VIEWPORTS } from "@stim-cli/core/state";
 import { fileURLToPath } from "node:url";
-import { LOG_ROTATE_BYTES } from "@stim-cli/core";
 //#region src/web/events.ts
 const MAX_FRAMES = 20;
 const CONSOLE_LEVELS = {

package/dist/windows-report.d.mts

@@ -0,0 +1 @@
+export {}

package/dist/windows-report.mjs

@@ -0,0 +1,18 @@
+import { t as getExecutor } from "./exec-_UbtCQcG.mjs";
+//#region bin/windows-report.ts
+const request = JSON.parse(process.env.STIM_REPORT_CHILD ?? "");
+const env = { ...process.env };
+delete env.STIM_REPORT_CHILD;
+const child = getExecutor().spawn(request.file, request.args, {
+	stdio: "inherit",
+	env
+});
+child.once("error", (error) => {
+	console.error(error.message);
+	process.exitCode = 1;
+});
+child.once("close", (status) => {
+	process.exitCode = status ?? 1;
+});
+//#endregion
+export {};

package/dist/windows-report.ps1

@@ -0,0 +1,43 @@
+$ErrorActionPreference = 'Stop'
+$assembly = [AppDomain]::CurrentDomain.DefineDynamicAssembly(
+    [Reflection.AssemblyName]::new('StimReportJob'), [Reflection.Emit.AssemblyBuilderAccess]::Run)
+$module = $assembly.DefineDynamicModule('StimReportJob')
+$builder = $module.DefineType('StimReportNative', [Reflection.TypeAttributes]'Public, Sealed, Abstract')
+function Define-Native([string]$name, [type]$returns, [type[]]$parameters) {
+    $method = $builder.DefinePInvokeMethod($name, 'kernel32.dll',
+        [Reflection.MethodAttributes]'Public, Static, PinvokeImpl',
+        [Reflection.CallingConventions]::Standard, $returns, $parameters,
+        [Runtime.InteropServices.CallingConvention]::Winapi, [Runtime.InteropServices.CharSet]::Unicode)
+    $method.SetImplementationFlags([Reflection.MethodImplAttributes]::PreserveSig)
+}
+Define-Native 'CreateJobObjectW' ([IntPtr]) ([type[]]@([IntPtr], [string]))
+Define-Native 'SetInformationJobObject' ([bool]) ([type[]]@([IntPtr], [int], [IntPtr], [uint32]))
+Define-Native 'AssignProcessToJobObject' ([bool]) ([type[]]@([IntPtr], [IntPtr]))
+$native = $builder.CreateType()
+$job = $native::CreateJobObjectW([IntPtr]::Zero, $null)
+if ($job -eq [IntPtr]::Zero) { throw 'Could not create the report process job.' }
+# Win32 JOBOBJECT_EXTENDED_LIMIT_INFORMATION is 144 bytes on 64-bit and 112 on 32-bit;
+# its BasicLimitInformation.LimitFlags field is at offset 16 on both.
+# https://learn.microsoft.com/windows/win32/api/winnt/ns-winnt-jobobject_extended_limit_information
+$size = if ([IntPtr]::Size -eq 8) { 144 } else { 112 }
+$limits = [Runtime.InteropServices.Marshal]::AllocHGlobal($size)
+try {
+    [Runtime.InteropServices.Marshal]::Copy([byte[]]::new($size), 0, $limits, $size)
+    [Runtime.InteropServices.Marshal]::WriteInt32($limits, 16, 0x2000)
+    if (!$native::SetInformationJobObject($job, 9, $limits, $size) -or
+        !$native::AssignProcessToJobObject($job, [IntPtr](-1))) {
+        throw 'Could not contain the report process job.'
+    }
+} finally {
+    [Runtime.InteropServices.Marshal]::FreeHGlobal($limits)
+}
+# Child jobs inherit containment; closing the helper's sole job handle kills descendants.
+# https://learn.microsoft.com/windows/win32/procthread/job-objects
+$request = $env:STIM_REPORT_CHILD | ConvertFrom-Json
+$start = [System.Diagnostics.ProcessStartInfo]::new()
+$start.FileName = $request.node
+$start.Arguments = '"' + $request.entry + '"'
+$start.UseShellExecute = $false
+$child = [System.Diagnostics.Process]::Start($start)
+$child.WaitForExit()
+[System.Environment]::Exit($child.ExitCode)

package/dist/workspace-process-lock-1_1OoVW5.mjs

@@ -0,0 +1,57 @@
+import { c as stopDeclaringSpawnsOn, f as ownership_claim_exports, i as declareSpawnsOn } from "./exec-_UbtCQcG.mjs";
+import { join } from "node:path";
+import { setTimeout } from "node:timers/promises";
+//#region src/engine/workspace-process-lock.ts
+const DEFAULT_WAIT_MS = 6e4;
+const POLL_MS = 25;
+function workspaceProcessLockError(err) {
+	const code = err?.code;
+	if (code === "STIM_LOCK_REFUSED") return "refused";
+	if (code === "STIM_LOCK_TIMEOUT") return "timeout";
+	return null;
+}
+function workspaceProcessLockPath(root, name, external) {
+	return external ? join(root, `${name}.lock`) : join(root, ".stim", `${name}.lock`);
+}
+async function withWorkspaceProcessLock(root, name, fn, { now = Date.now, signal, sleep = (ms) => setTimeout(ms, void 0, { signal }), waitMs = DEFAULT_WAIT_MS, ownerPurpose, details = {}, onHeld, rejectOwnerPurposes = [], external = false, declareSpawnsFor } = {}) {
+	const path = workspaceProcessLockPath(root, name, external);
+	const deadline = now() + waitMs;
+	for (;;) {
+		signal?.throwIfAborted();
+		const attempt = (0, ownership_claim_exports.tryAcquireClaim)({
+			root: path,
+			mode: "exclusive",
+			label: `${name} lock`,
+			details: ownerPurpose ? {
+				...details,
+				purpose: ownerPurpose
+			} : details
+		});
+		if (attempt.pending) (0, ownership_claim_exports.releaseClaim)(attempt.pending);
+		if (attempt.acquired) {
+			if (declareSpawnsFor) declareSpawnsOn(declareSpawnsFor, attempt.acquired);
+			try {
+				return await fn(attempt.acquired);
+			} finally {
+				if (declareSpawnsFor) stopDeclaringSpawnsOn(declareSpawnsFor, attempt.acquired);
+				(0, ownership_claim_exports.releaseClaim)(attempt.acquired);
+			}
+		}
+		const holder = attempt.held ?? attempt.waitingFor?.[0];
+		const purpose = holder?.details.purpose;
+		if (typeof purpose === "string" && rejectOwnerPurposes.includes(purpose)) {
+			const error = /* @__PURE__ */ new Error(`The ${name} lock at ${path} is held for ${purpose}.`);
+			error.code = "STIM_LOCK_REFUSED";
+			throw error;
+		}
+		if (holder && onHeld) await onHeld(holder);
+		if (now() >= deadline) {
+			const error = /* @__PURE__ */ new Error(`Timed out waiting for the ${name} lock at ${path}.`);
+			error.code = "STIM_LOCK_TIMEOUT";
+			throw error;
+		}
+		await sleep(POLL_MS);
+	}
+}
+//#endregion
+export { workspaceProcessLockError as n, workspaceProcessLockPath as r, withWorkspaceProcessLock as t };

package/dist/{workspace-state-DJt_MMvf.mjs → workspace-state-Cjuigeeu.mjs}

@@ -1,43 +1,12 @@
-import { O as writeConfigSetting, k as process_identity_exports, m as getProjectSettings } from "./config-BYDxlMY3.mjs";
-import { t as getExecutor } from "./exec-DqKo9GKJ.mjs";
-import { it as workspaceHiddenSetting } from "./settings-B717odTD.mjs";
+import { p as process_identity_exports, t as getExecutor } from "./exec-_UbtCQcG.mjs";
+import { _ as workspaceStateLock, g as workspaceStateFile$1, n as ensureWorkspaceStorage, r as ensureWorkspaceStorageAsync, v as withDirLock, y as withDirLockAsync } from "./paths-DQtTgsBf.mjs";
+import { A as writeConfigSettingAsync, k as writeConfigSetting, m as getProjectSettings } from "./config-CYcBF478.mjs";
+import { ot as workspaceHiddenSetting } from "./settings-CsJDEXgK.mjs";
 import { existsSync, mkdirSync, readFileSync, realpathSync, renameSync, rmSync, writeFileSync } from "node:fs";
-import { dirname, isAbsolute, join, relative } from "node:path";
-import { join as join$1, resolve as resolve$1 } from "path";
-import { WORKSPACE_AGENT_KEY, emulatorLogFile, isJsonObject, readJsonObject, readWorkspaceState, readWorkspaceState as readWorkspaceState$1, sharedCcache as sharedCcache$1, sharedCompilationCache as sharedCompilationCache$1, supervisorLogFile, supervisorPidFile, workspaceAgentDeviceDir, workspaceDerivedData, workspaceLastUsed, workspaceLogErrorIndex, workspaceLogsDir as workspaceLogsDir$1, workspaceMetadataFile, workspaceStateFile, workspaceStateLock } from "@stim-cli/core/state";
-import { buildCacheRoot as sharedBuildCache, ensurePrivateDir, withDirLock as withDirLock$1, workspaceId as workspaceId$1, workspaceName as workspaceName$1, workspaceStateDir as workspaceDir } from "@stim-cli/core";
 import { homedir } from "node:os";
+import { dirname, isAbsolute, join, relative } from "node:path";
+import { WORKSPACE_AGENT_KEY, isJsonObject, readWorkspaceState, readWorkspaceState as readWorkspaceState$1, workspaceLastUsed } from "@stim-cli/core/state";
 import { readFile, readdir } from "node:fs/promises";
-//#region src/workspace/paths.ts
-function ensureWorkspaceStorage(projectRoot) {
-	const canonicalRoot = resolve$1(projectRoot);
-	const dir = workspaceDir(canonicalRoot);
-	const file = workspaceMetadataFile(canonicalRoot);
-	ensurePrivateDir(dir);
-	return withDirLock$1(join$1(dir, "metadata.lock"), () => {
-		if (!existsSync(file)) {
-			const metadata = {
-				projectRoot: canonicalRoot,
-				workspace: workspaceName$1(canonicalRoot),
-				version: 1
-			};
-			const tmp = `${file}.${process.pid}.${Math.random().toString(36).slice(2)}.tmp`;
-			writeFileSync(tmp, `${JSON.stringify(metadata, null, 2)}\n`);
-			try {
-				renameSync(tmp, file);
-			} catch (error) {
-				rmSync(tmp, { force: true });
-				throw error;
-			}
-			return dir;
-		}
-		if (readJsonObject(file)?.projectRoot === canonicalRoot) return dir;
-		const error = /* @__PURE__ */ new Error(`Stim workspace collision at ${dir}: its workspace.json does not belong to ${canonicalRoot}.`);
-		error.code = "STIM_WORKSPACE_COLLISION";
-		throw error;
-	});
-}
-//#endregion
 //#region src/agent-sessions.ts
 const TITLE_MAX_LENGTH = 120;
 const SESSION_ID = /^[A-Za-z0-9._:-]{1,128}$/;
@@ -285,12 +254,21 @@ function attributeAgentSessions(workspaces, sessions, now) {
 //#endregion
 //#region src/workspace/workspace-state.ts
 function withWorkspaceStateLock(root, fn) {
-	const file = workspaceStateFile(root);
-	return withDirLock$1(workspaceStateLock(root), fn, { ensureParent: () => {
+	const file = workspaceStateFile$1(root);
+	return withDirLock(workspaceStateLock(root), fn, { ensureParent: () => {
 		ensureWorkspaceStorage(root);
 		mkdirSync(dirname(file), { recursive: true });
 	} });
 }
+/** Waits for the workspace state lock asynchronously; the transaction remains synchronous and reentrant. */
+async function withWorkspaceStateLockAsync(root, fn, signal) {
+	await ensureWorkspaceStorageAsync(root, signal);
+	const file = workspaceStateFile$1(root);
+	return withDirLockAsync(workspaceStateLock(root), fn, {
+		ensureParent: () => mkdirSync(dirname(file), { recursive: true }),
+		signal
+	});
+}
 function writeWorkspaceState(root, patch) {
 	return updateWorkspaceState(root, (state) => ({
 		...state,
@@ -300,8 +278,12 @@ function writeWorkspaceState(root, patch) {
 function updateWorkspaceState(root, update) {
 	return withWorkspaceStateLock(root, () => replaceWorkspaceState(root, update(readWorkspaceState(root) ?? {})));
 }
+/** Updates workspace state atomically after asynchronously acquiring its lock. */
+function updateWorkspaceStateAsync(root, update, signal) {
+	return withWorkspaceStateLockAsync(root, () => replaceWorkspaceState(root, update(readWorkspaceState(root) ?? {})), signal);
+}
 function replaceWorkspaceState(root, state) {
-	const file = workspaceStateFile(root);
+	const file = workspaceStateFile$1(root);
 	mkdirSync(dirname(file), { recursive: true });
 	const tmp = `${file}.tmp-${process.pid}`;
 	writeFileSync(tmp, `${JSON.stringify(state, null, 2)}\n`, { mode: 384 });
@@ -309,10 +291,10 @@ function replaceWorkspaceState(root, state) {
 	return state;
 }
 function clearWorkspaceStateKeys(root, keys) {
-	if (!existsSync(workspaceStateFile(root))) return;
+	if (!existsSync(workspaceStateFile$1(root))) return;
 	withWorkspaceStateLock(root, () => {
 		const state = readWorkspaceState(root);
-		const file = workspaceStateFile(root);
+		const file = workspaceStateFile$1(root);
 		if (!state) {
 			try {
 				rmSync(file, { force: true });
@@ -339,7 +321,7 @@ function clearWorkspaceStateKey(root, key, shouldClear) {
 		if (!state || !(key in state)) return true;
 		if (!shouldClear(state[key])) return false;
 		delete state[key];
-		const file = workspaceStateFile(root);
+		const file = workspaceStateFile$1(root);
 		if (Object.keys(state).length === 0) {
 			try {
 				rmSync(file, { force: true });
@@ -354,21 +336,9 @@ function clearWorkspaceStateKey(root, key, shouldClear) {
 * Records a command's use of the workspace, and the agent session whose shell ran it when there is one, and
 * clears `workspace.hidden`.
 */
-function recordWorkspaceUse(root, now = /* @__PURE__ */ new Date(), env = process.env) {
-	const agent = agentFromEnv(env);
-	let cwd = process.cwd();
+function recordWorkspaceUse(root, now = /* @__PURE__ */ new Date(), env = process.env, commandCwd = process.cwd()) {
 	try {
-		cwd = realpathSync(cwd);
-	} catch {}
-	try {
-		writeWorkspaceState(root, {
-			lastUsedAt: now.toISOString(),
-			...agent ? { [WORKSPACE_AGENT_KEY]: {
-				...agent,
-				cwd,
-				lastActiveAt: now.toISOString()
-			} } : {}
-		});
+		writeWorkspaceState(root, workspaceUsePatch(now, env, commandCwd));
 	} catch {}
 	try {
 		if (workspaceHiddenSetting(getProjectSettings(root))) writeConfigSetting({
@@ -377,5 +347,39 @@ function recordWorkspaceUse(root, now = /* @__PURE__ */ new Date(), env = proces
 		}, "workspace.hidden", void 0);
 	} catch {}
 }
+/** Records workspace use and clears workspace.hidden after asynchronously acquiring the state and config locks. */
+async function recordWorkspaceUseAsync(root, now = /* @__PURE__ */ new Date(), env = process.env, commandCwd = process.cwd(), signal) {
+	signal?.throwIfAborted();
+	try {
+		const patch = workspaceUsePatch(now, env, commandCwd);
+		await updateWorkspaceStateAsync(root, (state) => ({
+			...state,
+			...patch
+		}), signal);
+	} catch {}
+	signal?.throwIfAborted();
+	try {
+		if (workspaceHiddenSetting(getProjectSettings(root))) await writeConfigSettingAsync({
+			scope: "workspace",
+			projectPath: root
+		}, "workspace.hidden", void 0, signal);
+	} catch {}
+	signal?.throwIfAborted();
+}
+function workspaceUsePatch(now, env, commandCwd) {
+	const agent = agentFromEnv(env);
+	let cwd = commandCwd;
+	try {
+		cwd = realpathSync(cwd);
+	} catch {}
+	return {
+		lastUsedAt: now.toISOString(),
+		...agent ? { [WORKSPACE_AGENT_KEY]: {
+			...agent,
+			cwd,
+			lastActiveAt: now.toISOString()
+		} } : {}
+	};
+}
 //#endregion
-export { workspaceLogErrorIndex as C, withDirLock$1 as D, workspaceStateFile as E, workspaceId$1 as S, workspaceName$1 as T, supervisorLogFile as _, updateWorkspaceState as a, workspaceDerivedData as b, writeWorkspaceState as c, discoverAgentSessions as d, emulatorLogFile as f, sharedCompilationCache$1 as g, sharedCcache$1 as h, recordWorkspaceUse as i, agentKey as l, sharedBuildCache as m, clearWorkspaceStateKeys as n, withWorkspaceStateLock as o, ensureWorkspaceStorage as p, readWorkspaceState$1 as r, workspaceLastUsed as s, clearWorkspaceStateKey as t, attributeAgentSessions as u, supervisorPidFile as v, workspaceLogsDir$1 as w, workspaceDir as x, workspaceAgentDeviceDir as y };
+export { recordWorkspaceUseAsync as a, withWorkspaceStateLock as c, writeWorkspaceState as d, agentKey as f, recordWorkspaceUse as i, withWorkspaceStateLockAsync as l, discoverAgentSessions as m, clearWorkspaceStateKeys as n, updateWorkspaceState as o, attributeAgentSessions as p, readWorkspaceState$1 as r, updateWorkspaceStateAsync as s, clearWorkspaceStateKey as t, workspaceLastUsed as u };