@mostra/cli 0.0.0-stage → 0.1.0

package/dist/flush-BCuWs0Zh.js

@@ -0,0 +1,718 @@
+import { spawn } from "node:child_process";
+import { chmodSync, closeSync, fstatSync, linkSync, mkdirSync, openSync, readFileSync, renameSync, rmSync, writeFileSync } from "node:fs";
+import { dirname, join } from "node:path";
+import { DIAGNOSTIC_AREAS } from "@mostra/protocol";
+import { fileURLToPath } from "node:url";
+import * as z from "zod";
+import { request } from "node:http";
+import { request as request$1 } from "node:https";
+import { randomUUID } from "node:crypto";
+//#region src/version.ts
+/** The CLI's own package: its root directory and its release. */
+let found;
+function own() {
+	if (found) return found;
+	let dir = dirname(fileURLToPath(import.meta.url));
+	for (;;) {
+		try {
+			const manifest = JSON.parse(readFileSync(join(dir, "package.json"), "utf8"));
+			if (manifest.name === "@mostra/cli" && manifest.version) {
+				found = {
+					root: dir,
+					version: manifest.version
+				};
+				return found;
+			}
+		} catch {}
+		const parent = dirname(dir);
+		if (parent === dir) throw new Error("Couldn't find @mostra/cli's package.json.");
+		dir = parent;
+	}
+}
+/** This CLI's version (`mostra --version`, the client version it reports, telemetry's `version`). */
+function cliVersion() {
+	return own().version;
+}
+/** The CLI package's directory: its `dist/`, `src/` and bundled reference live under it. */
+function packageRoot() {
+	return own().root;
+}
+/** Whether this CLI runs from its TypeScript sources (tests), not its build. */
+function fromSource() {
+	return import.meta.url.endsWith(".ts");
+}
+//#endregion
+//#region src/telemetry/decision.ts
+/** The build's endpoint: empty in this package and in every development build. */
+function buildEndpoint() {
+	return "";
+}
+const OFF_VALUES = /* @__PURE__ */ new Set([
+	"0",
+	"false",
+	"off",
+	"no"
+]);
+const ON_VALUES = /* @__PURE__ */ new Set([
+	"1",
+	"true",
+	"on",
+	"yes"
+]);
+/** `DO_NOT_TRACK` and `MOSTRA_OFFLINE`'s parser: set to anything but empty, `0` or `false`. */
+function truthy(value) {
+	if (value === void 0) return false;
+	const normalized = value.trim().toLowerCase();
+	return normalized !== "" && normalized !== "0" && normalized !== "false";
+}
+/**
+* The endpoint in use: `MOSTRA_TELEMETRY_ENDPOINT` when it is `https:` or `http:` to a loopback
+* address, else the build's; `undefined` when there is none (D140 item 7).
+*/
+function endpointOf(env, build) {
+	const override = env["MOSTRA_TELEMETRY_ENDPOINT"];
+	const chosen = override !== void 0 && override !== "" ? override : build;
+	if (chosen === "") return void 0;
+	let url;
+	try {
+		url = new URL(chosen);
+	} catch {
+		return;
+	}
+	if (url.username !== "" || url.password !== "") return void 0;
+	if (url.protocol === "https:") return url.href;
+	const loopback = url.hostname === "127.0.0.1" || url.hostname === "[::1]" || url.hostname === "localhost";
+	return url.protocol === "http:" && loopback ? url.href : void 0;
+}
+/** Decides, in D140's order. */
+function decide(inputs) {
+	const { askFirst } = inputs;
+	const off = (reason) => ({
+		enabled: false,
+		reason,
+		askFirst
+	});
+	const endpoint = endpointOf(inputs.env, inputs.buildEndpoint);
+	if (endpoint === void 0) return off("no-collector");
+	const at = {
+		askFirst,
+		endpoint
+	};
+	if (inputs.embedded) return {
+		...at,
+		enabled: false,
+		reason: "embedded"
+	};
+	if (truthy(inputs.env["DO_NOT_TRACK"])) return {
+		...at,
+		enabled: false,
+		reason: "do-not-track"
+	};
+	const normalized = inputs.env["MOSTRA_TELEMETRY"]?.trim().toLowerCase();
+	if (normalized !== void 0 && OFF_VALUES.has(normalized)) return {
+		...at,
+		enabled: false,
+		reason: "variable"
+	};
+	if (!inputs.settings.ok) return {
+		...at,
+		enabled: false,
+		reason: "unreadable"
+	};
+	const choice = inputs.settings.settings.choice;
+	if (choice === "off") return {
+		...at,
+		enabled: false,
+		reason: "setting"
+	};
+	if (normalized !== void 0 && normalized !== "") return ON_VALUES.has(normalized) ? {
+		...at,
+		enabled: true,
+		reason: "variable",
+		consent: "explicit"
+	} : {
+		...at,
+		enabled: false,
+		reason: "variable-invalid"
+	};
+	if (choice === "on") return {
+		...at,
+		enabled: true,
+		reason: "setting",
+		consent: "explicit"
+	};
+	return askFirst ? {
+		...at,
+		enabled: false,
+		reason: "default"
+	} : {
+		...at,
+		enabled: true,
+		reason: "default",
+		consent: "default"
+	};
+}
+//#endregion
+//#region src/telemetry/harness.ts
+/** The agents Mostra recognizes, in the order their markers are checked. */
+const HARNESSES = [
+	"claude-code",
+	"codex",
+	"gemini-cli",
+	"opencode",
+	"cursor"
+];
+/** Each agent's own marker. */
+const MARKERS = {
+	"claude-code": "CLAUDECODE",
+	codex: "CODEX_THREAD_ID",
+	"gemini-cli": "GEMINI_CLI",
+	opencode: "OPENCODE",
+	cursor: "CURSOR_AGENT"
+};
+const set = (value) => value !== void 0 && value !== "";
+/**
+* The agent that ran this process: `AI_AGENT` when it starts with a known ID (the convention
+* `@vercel/detect-agent` reads), else the first agent whose own marker is set, else `other` when
+* `AI_AGENT` or `AGENT` names something else, else `none`. Cursor's editor terminal sets
+* `CURSOR_TRACE_ID` without `CURSOR_AGENT`: that is a person, so it isn't `cursor`.
+*/
+function detectHarness(env) {
+	const declared = env["AI_AGENT"];
+	if (set(declared)) {
+		const known = HARNESSES.find((id) => declared?.startsWith(id));
+		if (known) return known;
+	}
+	for (const id of HARNESSES) if (set(env[MARKERS[id]])) return id;
+	if (set(declared) || set(env["AGENT"])) return "other";
+	return "none";
+}
+/** The duration buckets of `cli.command`. */
+const DURATIONS = [
+	"<1s",
+	"1-5s",
+	"5-30s",
+	"30s-2m",
+	"2-10m",
+	">10m"
+];
+/** A command's duration bucket. */
+function durationBucket(ms) {
+	if (ms < 1e3) return "<1s";
+	if (ms < 5e3) return "1-5s";
+	if (ms < 3e4) return "5-30s";
+	if (ms < 12e4) return "30s-2m";
+	if (ms < 6e5) return "2-10m";
+	return ">10m";
+}
+/** A catalog-shaped diagnostic code: `MOSTRA_<AREA>_<NAME>`, never a message. */
+const code = z.string().regex(new RegExp(`^MOSTRA_(${DIAGNOSTIC_AREAS.join("|")})_[A-Z0-9_]{1,64}$`));
+/** A command path from the definitions: lowercase words. */
+const command = z.string().regex(/^[a-z]+( [a-z]+)?$/);
+const common = {
+	schema: z.literal(1),
+	at: z.string().regex(/^\d{4}-\d{2}-\d{2}T\d{2}:\d{2}:00Z$/),
+	installId: z.uuid(),
+	version: z.string().regex(/^\d+\.\d+\.\d+(-[0-9A-Za-z.-]+)?$/),
+	os: z.enum(["darwin", "linux"]),
+	arch: z.string().regex(/^[a-z0-9]{2,12}$/),
+	node: z.int().min(0).max(999),
+	harness: z.enum([
+		...HARNESSES,
+		"other",
+		"none"
+	]),
+	ci: z.boolean(),
+	consent: z.enum(["explicit", "default"])
+};
+/** Every event Mostra may send, as a strict union on `event`. */
+const TelemetryEvent = z.discriminatedUnion("event", [
+	z.strictObject({
+		...common,
+		event: z.literal("cli.first_run")
+	}),
+	z.strictObject({
+		...common,
+		event: z.literal("cli.command"),
+		command,
+		exit: z.int().min(0).max(255),
+		duration: z.enum(DURATIONS),
+		json: z.boolean(),
+		error: code.optional()
+	}),
+	z.strictObject({
+		...common,
+		event: z.literal("verify.result"),
+		status: z.enum(["pass", "fail"]),
+		codes: z.array(code).max(50),
+		codesTruncated: z.boolean()
+	}),
+	z.strictObject({
+		...common,
+		event: z.literal("publish.done"),
+		reused: z.boolean(),
+		forced: z.boolean()
+	}),
+	z.strictObject({
+		...common,
+		event: z.literal("share.done"),
+		kind: z.enum([
+			"tailnet",
+			"funnel",
+			"cloudflare",
+			"remote"
+		])
+	}),
+	z.strictObject({
+		...common,
+		event: z.literal("mcp.session"),
+		client: z.enum([...HARNESSES, "other"]),
+		clientVersion: z.string().regex(/^[0-9A-Za-z.+-]{1,32}$/).optional()
+	})
+]);
+/** `at`: now in UTC, rounded down to the minute. */
+function minute(now) {
+	return `${now.toISOString().slice(0, 16)}:00Z`;
+}
+/** The distinct catalog codes of `codes`, sorted, at most 50, and whether some were left out. */
+function catalogCodes(codes, known) {
+	const distinct = [...new Set(codes.filter((value) => known.has(value)))].sort();
+	return {
+		codes: distinct.slice(0, 50),
+		codesTruncated: distinct.length > 50
+	};
+}
+//#endregion
+//#region src/telemetry/store.ts
+/**
+* Telemetry's files in the CLI's config directory (D140 item 5): `telemetry.json` (the choice,
+* when the notice was shown, when a flush last started), `telemetry-id` (the random install ID)
+* and `telemetry-queue.ndjson` (events waiting to be sent). The directory is 0700 and the files
+* 0600; `telemetry.json` and the queue are written by rename. The install ID is made by an
+* exclusive create (a hard link that fails when the file exists), so processes on a first run
+* agree on one ID whatever happens to the lock. Every other change goes through one lock file,
+* owned by a token and taken over only when its holder has died, so a flusher never loses an
+* event appended while it sends.
+*/
+/** A lock older than this whose owner no longer runs is taken over as stale. */
+const STALE_LOCK_MS = 1e4;
+/**
+* A lock older than this is taken over whoever it names: a held section takes milliseconds, and
+* a PID can name an unrelated live process once the owner died (in a container, PID 1 always
+* runs), which would otherwise hold every later command up forever (Opus review finding 5).
+*/
+const DEAD_LOCK_MS = 6e4;
+/** The queue's bounds (D140 item 6). */
+const QUEUE_MAX_EVENTS = 1e3;
+const UUID = /^[0-9a-f]{8}-[0-9a-f]{4}-[0-9a-f]{4}-[0-9a-f]{4}-[0-9a-f]{12}$/;
+/** Telemetry's files in one config directory. */
+var TelemetryStore = class {
+	dir;
+	settingsFile;
+	queueFile;
+	idFile;
+	#lockFile;
+	constructor(dir) {
+		this.dir = dir;
+		this.settingsFile = join(dir, "telemetry.json");
+		this.queueFile = join(dir, "telemetry-queue.ndjson");
+		this.idFile = join(dir, "telemetry-id");
+		this.#lockFile = join(dir, "telemetry.lock");
+	}
+	/** The settings; a file that isn't telemetry settings is unreadable, never guessed at. */
+	read() {
+		const id = this.#readId();
+		if (id === null) return {
+			ok: false,
+			file: this.idFile
+		};
+		let text;
+		try {
+			text = readFileSync(this.settingsFile, "utf8");
+		} catch (error) {
+			if (error.code === "ENOENT") return {
+				ok: true,
+				settings: id !== void 0 ? { installId: id } : {}
+			};
+			return {
+				ok: false,
+				file: this.settingsFile
+			};
+		}
+		try {
+			const data = JSON.parse(text);
+			if (typeof data !== "object" || data === null || Array.isArray(data)) throw new Error();
+			const { choice, noticeShownAt, askFirstNoticeShownAt, lastFlushAt } = data;
+			const installId = id;
+			if (choice !== void 0 && choice !== "on" && choice !== "off") throw new Error();
+			if (data["installId"] !== void 0) throw new Error();
+			if (noticeShownAt !== void 0 && typeof noticeShownAt !== "string") throw new Error();
+			if (askFirstNoticeShownAt !== void 0 && typeof askFirstNoticeShownAt !== "string") throw new Error();
+			if (lastFlushAt !== void 0 && typeof lastFlushAt !== "string") throw new Error();
+			return {
+				ok: true,
+				settings: {
+					...choice !== void 0 ? { choice } : {},
+					...installId !== void 0 ? { installId } : {},
+					...noticeShownAt !== void 0 ? { noticeShownAt } : {},
+					...askFirstNoticeShownAt !== void 0 ? { askFirstNoticeShownAt } : {},
+					...lastFlushAt !== void 0 ? { lastFlushAt } : {}
+				}
+			};
+		} catch {
+			return {
+				ok: false,
+				file: this.settingsFile
+			};
+		}
+	}
+	/**
+	* Changes the settings under the lock and returns what they became; `undefined` when the file
+	* can't be read (nothing is written over it).
+	*/
+	update(change) {
+		return this.locked(() => {
+			const current = this.read();
+			if (!current.ok) return void 0;
+			const next = change(current.settings);
+			this.#write(next);
+			return next;
+		});
+	}
+	/**
+	* The install ID, made when there is none yet. A new ID is written to a file of this process's
+	* own, then hard-linked to `telemetry-id`, which fails when the file exists: of any processes
+	* making one at once exactly one wins, and the others read the winner's. `undefined` when the
+	* settings can't be read.
+	*/
+	installId() {
+		const current = this.read();
+		if (!current.ok) return void 0;
+		if (current.settings.installId !== void 0) return {
+			id: current.settings.installId,
+			created: false
+		};
+		const candidate = `${this.idFile}.${process.pid}.${randomUUID()}.tmp`;
+		const id = randomUUID();
+		try {
+			this.#prepareDir();
+			writeFileSync(candidate, `${id}\n`, { mode: 384 });
+			linkSync(candidate, this.idFile);
+			return {
+				id,
+				created: true
+			};
+		} catch (error) {
+			if (error.code !== "EEXIST") return void 0;
+			const winner = this.#readId();
+			return winner ? {
+				id: winner,
+				created: false
+			} : void 0;
+		} finally {
+			rmSync(candidate, { force: true });
+		}
+	}
+	/** The install ID in `telemetry-id`: `undefined` when there is none, `null` when it's damaged. */
+	#readId() {
+		let text;
+		try {
+			text = readFileSync(this.idFile, "utf8");
+		} catch (error) {
+			return error.code === "ENOENT" ? void 0 : null;
+		}
+		const id = text.trim();
+		return UUID.test(id) ? id : null;
+	}
+	/**
+	* Replaces a file that can't be read with these settings; only `telemetry on|off` do, as the
+	* person's explicit choice. Call it holding the lock.
+	*/
+	reset(settings) {
+		const { installId: _id, ...rest } = settings;
+		this.#write(rest);
+		rmSync(this.idFile, { force: true });
+		if (settings.choice === "off") rmSync(this.queueFile, { force: true });
+		return rest;
+	}
+	/** Turns telemetry off: the choice, and the install ID and the queue deleted at once. */
+	turnOff() {
+		return this.locked(() => {
+			const current = this.read();
+			if (!current.ok) return false;
+			const { installId: _id, ...rest } = current.settings;
+			this.#write({
+				...rest,
+				choice: "off"
+			});
+			rmSync(this.idFile, { force: true });
+			rmSync(this.queueFile, { force: true });
+			return true;
+		}) ?? false;
+	}
+	/** Appends events to the queue, keeping its bounds. */
+	append(lines, now) {
+		if (lines.length === 0) return;
+		this.locked(() => {
+			const kept = bounded([...this.#queued(), ...lines], now);
+			this.#writeQueue(kept);
+		});
+	}
+	/** The queued events, within their bounds. */
+	queued(now) {
+		return bounded(this.#queued(), now);
+	}
+	/**
+	* Removes the lines a flush sent from the head of the queue, after pruning what expired or
+	* fell outside the bounds, as {@link queued} did; how many sent lines were removed (0 when the
+	* lock can't be had). A flusher stops when this is 0, so it never sends a batch twice.
+	*/
+	drop(sent, now) {
+		return this.locked(() => {
+			const queued = bounded(this.#queued(), now);
+			let index = 0;
+			while (index < sent.length && queued[index] === sent[index]) index += 1;
+			this.#writeQueue(queued.slice(index));
+			return index;
+		}) ?? 0;
+	}
+	#queued() {
+		try {
+			return readFileSync(this.queueFile, "utf8").split("\n").filter((line) => line.length > 0);
+		} catch {
+			return [];
+		}
+	}
+	#writeQueue(lines) {
+		if (lines.length === 0) {
+			rmSync(this.queueFile, { force: true });
+			return;
+		}
+		const temporary = `${this.queueFile}.${process.pid}.tmp`;
+		writeFileSync(temporary, `${lines.join("\n")}\n`, { mode: 384 });
+		renameSync(temporary, this.queueFile);
+	}
+	#write(settings) {
+		const { installId: _id, ...stored } = settings;
+		const temporary = `${this.settingsFile}.${process.pid}.tmp`;
+		writeFileSync(temporary, `${JSON.stringify(stored, null, 2)}\n`, { mode: 384 });
+		renameSync(temporary, this.settingsFile);
+	}
+	#prepareDir() {
+		mkdirSync(this.dir, {
+			recursive: true,
+			mode: 448
+		});
+		try {
+			chmodSync(this.dir, 448);
+		} catch {}
+	}
+	/**
+	* Runs `fn` holding the lock file; `undefined` when the lock can't be had within 2 s, or the
+	* directory or a file in it can't be written (a full disk, a directory someone else owns):
+	* telemetry never stops a command (D140 item 5). The lock
+	* holds its owner's PID and a token of its own, is released only by its owner, and is taken
+	* over when it is older than 10 s and its owner is no longer running (a crash), or older than
+	* 60 s whoever it names.
+	*/
+	locked(fn) {
+		try {
+			this.#prepareDir();
+		} catch {
+			return;
+		}
+		const token = `${process.pid} ${randomUUID()}`;
+		const deadline = Date.now() + 2e3;
+		for (;;) try {
+			writeFileSync(this.#lockFile, token, {
+				flag: "wx",
+				mode: 384
+			});
+			break;
+		} catch (error) {
+			if (error.code !== "EEXIST") return void 0;
+			if (this.#breakStale()) continue;
+			if (Date.now() > deadline) return void 0;
+			Atomics.wait(new Int32Array(new SharedArrayBuffer(4)), 0, 0, 20);
+		}
+		try {
+			return fn();
+		} catch {
+			return;
+		} finally {
+			this.#release(token);
+		}
+	}
+	/** Removes the lock when it is still this owner's. */
+	#release(token) {
+		try {
+			if (readFileSync(this.#lockFile, "utf8") === token) rmSync(this.#lockFile, { force: true });
+		} catch {}
+	}
+	/**
+	* Takes a crashed owner's lock away; `true` when the caller should try again at once. The lock
+	* is moved aside under a name of this process's own (a rename is atomic, so of two processes
+	* breaking it one gets it), and a lock that turns out to be another, live owner's goes back.
+	*/
+	#breakStale() {
+		let seen;
+		let age;
+		let handle;
+		try {
+			handle = openSync(this.#lockFile, "r");
+			age = Date.now() - fstatSync(handle).mtimeMs;
+			if (age <= STALE_LOCK_MS) return false;
+			seen = readFileSync(handle, "utf8");
+		} catch {
+			return true;
+		} finally {
+			if (handle !== void 0) closeSync(handle);
+		}
+		if (age <= DEAD_LOCK_MS && ownerAlive(seen)) return false;
+		const aside = `${this.#lockFile}.${process.pid}.${randomUUID()}.stale`;
+		try {
+			renameSync(this.#lockFile, aside);
+		} catch {
+			return true;
+		}
+		try {
+			if (readFileSync(aside, "utf8") !== seen) linkSync(aside, this.#lockFile);
+		} catch {} finally {
+			rmSync(aside, { force: true });
+		}
+		return true;
+	}
+};
+/** Whether the process a lock names still runs; a lock whose owner can't be read counts as live. */
+function ownerAlive(lock) {
+	const pid = Number(lock.split(" ")[0]);
+	if (!Number.isSafeInteger(pid) || pid <= 0) return false;
+	try {
+		process.kill(pid, 0);
+		return true;
+	} catch (error) {
+		return error.code === "EPERM";
+	}
+}
+/** The newest events within 1,000, none older than 7 days; lines that aren't JSON go. */
+function bounded(lines, now) {
+	return lines.filter((line) => {
+		try {
+			const at = Date.parse(JSON.parse(line).at ?? "");
+			return Number.isFinite(at) && now - at <= 6048e5;
+		} catch {
+			return false;
+		}
+	}).slice(-1e3);
+}
+/** A flush starts at most this often. */
+const FLUSH_INTERVAL_MS = 6e4;
+/** The flush interval; `MOSTRA_TEST_FLUSH_INTERVAL_MS` shortens it, for tests only. */
+function flushInterval(env) {
+	const test = Number(env["MOSTRA_TEST_FLUSH_INTERVAL_MS"]);
+	return Number.isInteger(test) && test >= 0 && test < 6e4 ? test : FLUSH_INTERVAL_MS;
+}
+/** One request's limit. */
+const REQUEST_TIMEOUT_MS = 5e3;
+/** Posts one batch; resolves with whether the collector took it (any 2xx). */
+function post(endpoint, body) {
+	return new Promise((resolve) => {
+		const url = new URL(endpoint);
+		const req = (url.protocol === "https:" ? request$1 : request)(url, {
+			method: "POST",
+			headers: {
+				"Content-Type": "application/json",
+				"User-Agent": `mostra-cli/${cliVersion()}`,
+				"Content-Length": Buffer.byteLength(body)
+			},
+			timeout: REQUEST_TIMEOUT_MS
+		}, (response) => {
+			response.resume();
+			response.on("end", () => resolve((response.statusCode ?? 0) >= 200 && (response.statusCode ?? 0) < 300));
+			response.on("error", () => resolve(false));
+		});
+		req.on("timeout", () => req.destroy());
+		req.on("error", () => resolve(false));
+		req.end(body);
+	});
+}
+/**
+* Sends the queue: the decision again, then batches until one fails. Events the schema refuses
+* never leave the machine.
+*/
+async function flush(store, env, now) {
+	const settings = store.read();
+	const decision = decide({
+		env,
+		buildEndpoint: buildEndpoint(),
+		embedded: false,
+		settings,
+		askFirst: false
+	});
+	if (!decision.enabled || decision.endpoint === void 0) {
+		if (decision.reason !== "no-collector" && settings.ok) store.drop(store.queued(now()), now());
+		return;
+	}
+	for (let round = 0; round <= Math.ceil(QUEUE_MAX_EVENTS / 100); round += 1) {
+		const lines = store.queued(now()).slice(0, 100);
+		if (lines.length === 0) return;
+		const events = [];
+		for (const line of lines) try {
+			const parsed = TelemetryEvent.safeParse(JSON.parse(line));
+			if (parsed.success) events.push(parsed.data);
+		} catch {}
+		if (!(events.length === 0 || await post(decision.endpoint, JSON.stringify({ events })))) return;
+		if (store.drop(lines, now()) === 0) return;
+	}
+}
+/** The flusher's entry in the CLI's package. */
+function flusherEntry() {
+	const root = packageRoot();
+	return fromSource() ? {
+		entry: join(root, "src", "telemetry", "flush-main.ts"),
+		nodeArgs: ["--conditions=@mostra/source"]
+	} : {
+		entry: join(root, "dist", "telemetry", "flush-main.js"),
+		nodeArgs: []
+	};
+}
+/**
+* Starts a flusher when the queue has events and no flush started in the last minute, fully
+* detached: no stdio, its own process group, never waited for, so `mostra … | jq` and every
+* harness reading to end of file finish when the command does.
+*/
+function startFlusher(store, env, now) {
+	if (store.queued(now).length === 0) return;
+	let due = false;
+	store.update((current) => {
+		const last = current.lastFlushAt === void 0 ? 0 : Date.parse(current.lastFlushAt);
+		if (Number.isFinite(last) && now - last < flushInterval(env)) return current;
+		due = true;
+		return {
+			...current,
+			lastFlushAt: new Date(now).toISOString()
+		};
+	});
+	if (!due) return;
+	const { entry, nodeArgs } = flusherEntry();
+	try {
+		const child = spawn(process.execPath, [
+			...nodeArgs,
+			entry,
+			store.dir
+		], {
+			detached: true,
+			stdio: "ignore",
+			env: {
+				...process.env,
+				...env
+			}
+		});
+		child.on("error", () => {});
+		child.unref();
+	} catch {}
+}
+//#endregion
+export { catalogCodes as a, detectHarness as c, truthy as d, cliVersion as f, TelemetryEvent as i, buildEndpoint as l, packageRoot as m, startFlusher as n, durationBucket as o, fromSource as p, TelemetryStore as r, minute as s, flush as t, decide as u };
+
+//# sourceMappingURL=flush-BCuWs0Zh.js.map