stim 1.0.0 → 1.1.0

package/README.md

@@ -77,7 +77,7 @@ artifact caches and Xcode build directories; run `stim guide lifecycle builds`
 for provider behavior. This selects an Xcode scheme, not a URL scheme.
 
 Launch evidence does not prove that the UI is interactive. Apps can optionally
-[declare readiness with two debug log messages](https://appandflow.github.io/stim/docs/dev-server-and-logs#optional-app-declared-readiness),
+[declare readiness with two debug log messages](https://stim.appandflow.com/docs/dev-server-and-logs#optional-app-declared-readiness),
 without a package or SDK. A captured pending message extends the default
 three-second stability window after bundle delivery to a bounded wait for ready.
 Managed Metro response capture distinguishes a finished build from a finished
@@ -86,10 +86,12 @@ response; servers without capture use the build-complete marker. Run
 expected screen separately.
 
 `stim reload [ios|android]` requests a JavaScript reload in the live app on this
-workspace's owned local device. Use it after a failed first bundle load, when
-an error screen remains after a fix, or when you explicitly need an app
-restart. It is not part of the normal workflow and does not build, install,
-boot, or launch an app. The platform is optional when only one app is live.
+workspace's owned local device. Use it when an error screen remains after a fix,
+and on Android after a failed first bundle load. An iOS app whose first bundle
+failed never connects to Metro, so reload cannot reach it. It reloads
+JavaScript and never restarts the app. It is not part of the normal workflow
+and does not build, install, boot, or launch an app. The platform is optional
+when only one app is live.
 Success confirms that the request was sent; Stim does not observe completion.
 Verify the expected UI on the reported device and inspect `stim logs --errors`
 before claiming recovery.
@@ -103,9 +105,19 @@ stim worktree warm
 ```
 
 If a harness already created the linked worktree, run only `stim worktree warm`
-there. Warm copies missing ignored state from main, including eligible `.env`
-and local configuration files. Existing entries are preserved; existing
-ignored directories such as `node_modules` are skipped whole.
+there. Warm copies missing ignored state from the source checkout, including
+eligible `.env` and local configuration files. Existing entries are preserved;
+existing ignored directories such as `node_modules` are skipped whole.
+
+`stim worktree warm --refresh` brings the source checkout up to date first: it
+fetches, fast-forwards whatever branch is checked out there, and installs what
+the new commits moved before copying. It refuses a source checkout it cannot
+move (uncommitted tracked changes, a rebase or merge in progress, a detached
+HEAD, a diverged branch) and never switches branches. One lock per repository
+keeps a copy from reading a `node_modules` a refresh is rewriting; plain warms
+still run side by side. A plain warm also refuses (`STIM_DEPS_INCOMPLETE`) when the last
+install of the lockfile on disk did not finish, instead of copying a partial
+`node_modules`; `stim worktree warm --refresh` reinstalls it.
 
 Wait for warm to finish before editing, installing dependencies, starting
 Metro/builds, or running another warm in that worktree. Concurrent writes are
@@ -113,12 +125,12 @@ unsafe: entries created after the initial check can be overwritten or removed.
 
 After the work is preserved, `stim worktree remove` removes any linked
 worktree, warmed or not. Git-created branches stay. See the
-[worktree guide](https://appandflow.github.io/stim/docs/worktrees) for exclusions
+[worktree guide](https://stim.appandflow.com/docs/worktrees) for exclusions
 and cleanup rules.
 
 ## Reference
 
-The [documentation website](https://appandflow.github.io/stim/) explains the
+The [documentation website](https://stim.appandflow.com/) explains the
 human workflow and all commands.
 
 The installed CLI contains version-matched operational guidance:

package/dist/android-CC5bUer7.mjs

@@ -0,0 +1,204 @@
+import { t as getExecutor } from "./exec-bsN9MJXb.mjs";
+//#region src/collector/android.ts
+const LEVEL_BY_LETTER = {
+	V: "debug",
+	D: "debug",
+	I: "info",
+	W: "warn",
+	E: "error",
+	F: "fatal",
+	A: "fatal",
+	S: "debug"
+};
+function levelFromLogcatLetter(letter) {
+	return LEVEL_BY_LETTER[String(letter || "").toUpperCase()] ?? "info";
+}
+const NOISE_TAGS = /* @__PURE__ */ new Set([
+	"libEGL",
+	"EGL_emulation",
+	"eglCodecCommon",
+	"emuglGLESv2_enc",
+	"HostConnection",
+	"OpenGLRenderer",
+	"gralloc4",
+	"Gralloc4",
+	"vulkan",
+	"GraphicBufferAllocator",
+	"BufferQueueProducer",
+	"Surface",
+	"ziparchive",
+	"chatty"
+]);
+function levelForLogcat(letter, tag) {
+	const level = levelFromLogcatLetter(letter);
+	if (level !== "error") return level;
+	return NOISE_TAGS.has(String(tag || "").trim()) ? "info" : level;
+}
+const LOGCAT_TIME = /^(\d{2})-(\d{2}) (\d{2}):(\d{2}):(\d{2})\.(\d{3})\s+([A-Z])\/(.*?)\(\s*(\d+)\):\s?(.*)$/;
+const LOGCAT_EPOCH = /^\s*(\d+)\.(\d{3,6})\s+([A-Z])\/(.*?)\(\s*(\d+)\):\s?(.*)$/;
+function parseLogcatTimestamp({ month, day, hour, minute, second, millis }, now = Date.now()) {
+	const ref = new Date(now);
+	let ts = new Date(ref.getFullYear(), month - 1, day, hour, minute, second, millis).getTime();
+	if (ts - now > 864e5) ts = new Date(ref.getFullYear() - 1, month - 1, day, hour, minute, second, millis).getTime();
+	return ts;
+}
+function parseLogcatLine(line, { now = Date.now, clockOffsetMs = null } = {}) {
+	if (typeof line !== "string") return null;
+	const epoch = LOGCAT_EPOCH.exec(line.trimEnd());
+	if (epoch) {
+		const [, seconds, fraction, letter, tag, pid, msg] = epoch;
+		if (!letter || !tag || !msg?.trim()) return null;
+		const deviceTs = Number(seconds) * 1e3 + Number(fraction.slice(0, 3));
+		if (!Number.isSafeInteger(deviceTs)) return null;
+		return {
+			ts: deviceTs + (clockOffsetMs ?? 0),
+			deviceTs,
+			...clockOffsetMs === null ? {} : { clockOffsetMs },
+			src: "device",
+			level: levelForLogcat(letter, tag),
+			msg,
+			proc: `${tag.trim()}(${pid})`
+		};
+	}
+	const m = LOGCAT_TIME.exec(line.trimEnd());
+	if (!m) return null;
+	const [, month, day, hour, minute, second, millis, letter, tag, pid, msg] = m;
+	if (letter === void 0 || tag === void 0 || msg === void 0) return null;
+	if (!msg.trim()) return null;
+	return {
+		ts: parseLogcatTimestamp({
+			month: Number(month),
+			day: Number(day),
+			hour: Number(hour),
+			minute: Number(minute),
+			second: Number(second),
+			millis: Number(millis)
+		}, now()),
+		src: "device",
+		level: levelForLogcat(letter, tag),
+		msg,
+		proc: `${tag.trim()}(${pid})`
+	};
+}
+function logcatArgs(serial, pid) {
+	return [
+		"-s",
+		serial,
+		"logcat",
+		"--pid",
+		String(pid),
+		"-v",
+		"time,epoch"
+	];
+}
+function androidClockOffset(serial, { exec = getExecutor(), now = Date.now } = {}) {
+	const before = now();
+	try {
+		const output = exec.runFile("adb", [
+			"-s",
+			serial,
+			"shell",
+			"date",
+			"+%s%3N"
+		], { timeoutMs: 1e3 }).trim();
+		const after = now();
+		if (!/^\d{13}$/.test(output) || after < before || after - before > 1e3) return null;
+		return Math.round((before + after) / 2) - Number(output);
+	} catch {
+		return null;
+	}
+}
+function parsePidof(text) {
+	const first = String(text ?? "").trim().split(/\s+/)[0];
+	const pid = Number(first);
+	return Number.isInteger(pid) && pid > 0 ? pid : null;
+}
+function resolveAppPid(serial, packageName, { exec = null } = {}) {
+	const e = exec || getExecutor();
+	try {
+		return parsePidof(e.runFile("adb", [
+			"-s",
+			serial,
+			"shell",
+			"pidof",
+			"-s",
+			packageName
+		]));
+	} catch {
+		return null;
+	}
+}
+async function waitForAppPid({ serial, packageName, timeoutMs = 3e4, pollMs = 500, exec = null, now = Date.now, sleep = defaultSleep }) {
+	const deadline = now() + timeoutMs;
+	for (;;) {
+		const pid = resolveAppPid(serial, packageName, { exec });
+		if (pid) return {
+			ok: true,
+			pid
+		};
+		if (now() >= deadline) return {
+			failed: true,
+			reason: `No process for ${packageName} appeared on ${serial} within ${Math.round(timeoutMs / 1e3)}s.`
+		};
+		await sleep(pollMs);
+	}
+}
+function defaultSleep(ms) {
+	return new Promise((r) => setTimeout(r, ms));
+}
+function startAndroidLogcat({ serial, pid, spawnFn = null }) {
+	return (spawnFn || ((cmd, args, opts) => getExecutor().spawn(cmd, args, opts)))("adb", logcatArgs(serial, pid), {
+		stdio: [
+			"ignore",
+			"pipe",
+			"pipe"
+		],
+		detached: false
+	});
+}
+const PID_WATCH_MS = 3e3;
+function pidWatchInterval() {
+	const override = Number(process.env.STIM_PID_WATCH_MS);
+	return Number.isFinite(override) && override > 0 ? override : PID_WATCH_MS;
+}
+function watchAppPid({ serial, packageName, pid, intervalMs = null, exec = null, onChange, resolve = resolveAppPid, setTimer = setTimeout, clearTimer = clearTimeout }) {
+	const every = intervalMs ?? pidWatchInterval();
+	let current = pid;
+	let stopped = false;
+	let timer = null;
+	const tick = async () => {
+		timer = null;
+		if (stopped) return;
+		let next = null;
+		try {
+			next = resolve(serial, packageName, { exec });
+		} catch {}
+		if (next && next !== current) {
+			current = next;
+			try {
+				await onChange(next);
+			} catch {}
+		}
+		if (!stopped) timer = setTimer(tick, every);
+	};
+	timer = setTimer(tick, every);
+	return {
+		stop() {
+			stopped = true;
+			if (timer) clearTimer(timer);
+			timer = null;
+		},
+		probe() {
+			try {
+				return resolve(serial, packageName, { exec });
+			} catch {
+				return null;
+			}
+		},
+		get pid() {
+			return current;
+		}
+	};
+}
+//#endregion
+export { watchAppPid as a, waitForAppPid as i, parseLogcatLine as n, startAndroidLogcat as r, androidClockOffset as t };