@dev.fast/whiteboard 0.0.0-stage → 0.2.1-preview.20261005.98

package/dist/s3-config-CAxhO9u_.js

@@ -0,0 +1,676 @@
+import { a as jsonNumber, c as jsonString, o as jsonObject, u as parseJsonText } from "./src-X9phtB2j.js";
+import { createHash, randomBytes } from "node:crypto";
+import { z } from "zod";
+import { chmodSync, chownSync, closeSync, existsSync, fsyncSync, lstatSync, mkdirSync, openSync, readFileSync, realpathSync, renameSync, rmSync, statSync, writeSync } from "node:fs";
+import { chmod, chown, lstat, mkdir, open, readFile, realpath, rename, rm, stat, utimes, writeFile } from "node:fs/promises";
+import path from "node:path";
+import os from "node:os";
+import { spawnSync } from "node:child_process";
+import { setTimeout } from "node:timers/promises";
+//#region ../trace-core/src/atomic-write.ts
+const inFlight = /* @__PURE__ */ new Map();
+function temporaryPath(filePath) {
+	return `${filePath}.${process.pid}.${randomBytes(12).toString("hex")}.tmp`;
+}
+function snapshotContents(contents) {
+	return contents instanceof Uint8Array ? Buffer.from(contents) : contents;
+}
+function toBuffer(contents, encoding) {
+	return contents instanceof Uint8Array ? contents : Buffer.from(contents, encoding ?? "utf8");
+}
+function canIgnoreMetadataError(error) {
+	if (!("code" in error)) return false;
+	return error.code === "ENOSYS" || (!process.getuid || process.getuid() !== 0) && (error.code === "EINVAL" || error.code === "EPERM");
+}
+/**
+* Replace a file through a flushed sibling, preserving an existing symlink's
+* target and metadata. Exceptions clean up temporary files; process termination may leave them.
+*/
+function writeFileAtomic(filePath, contents, encoding, options = {}) {
+	const snapshot = snapshotContents(contents);
+	mkdirSync(path.dirname(filePath), { recursive: true });
+	let target = filePath;
+	if (!options.replaceSymlink) try {
+		target = realpathSync(filePath);
+	} catch {}
+	let metadata;
+	try {
+		const candidate = options.replaceSymlink ? lstatSync(target) : statSync(target);
+		if (!candidate.isSymbolicLink()) metadata = candidate;
+	} catch {}
+	const mode = options.mode || metadata?.mode;
+	const tmp = temporaryPath(target);
+	let fd;
+	let created = false;
+	try {
+		fd = openSync(tmp, "wx", mode ?? 438);
+		created = true;
+		options.tmpfileCreated?.(tmp);
+		const buffer = toBuffer(snapshot, encoding);
+		let offset = 0;
+		while (offset < buffer.length) {
+			const written = writeSync(fd, buffer, offset, buffer.length - offset);
+			if (written === 0) throw new Error("Atomic write made no progress");
+			offset += written;
+		}
+		fsyncSync(fd);
+		closeSync(fd);
+		fd = void 0;
+		if (metadata && process.getuid) try {
+			chownSync(tmp, metadata.uid, metadata.gid);
+		} catch (error) {
+			if (!(error instanceof Error) || !canIgnoreMetadataError(error)) throw error;
+		}
+		if (mode) try {
+			chmodSync(tmp, mode);
+		} catch (error) {
+			if (!(error instanceof Error) || !canIgnoreMetadataError(error)) throw error;
+		}
+		renameSync(tmp, target);
+	} catch (error) {
+		if (fd !== void 0) try {
+			closeSync(fd);
+		} catch {}
+		if (created) try {
+			rmSync(tmp, { force: true });
+		} catch {}
+		throw error;
+	}
+}
+async function replaceFile(filePath, contents, options) {
+	await mkdir(path.dirname(filePath), { recursive: true });
+	const target = options.replaceSymlink ? filePath : await realpath(filePath).catch(() => filePath);
+	const candidate = options.replaceSymlink ? await lstat(target).catch(() => void 0) : await stat(target).catch(() => void 0);
+	const metadata = candidate?.isSymbolicLink() ? void 0 : candidate;
+	const mode = options.mode ?? metadata?.mode;
+	const tmp = temporaryPath(target);
+	let handle;
+	let created = false;
+	try {
+		handle = await open(tmp, "wx", mode ?? 438);
+		created = true;
+		await options.tmpfileCreated?.(tmp);
+		const buffer = toBuffer(contents, options.encoding);
+		let offset = 0;
+		while (offset < buffer.length) {
+			const { bytesWritten } = await handle.write(buffer, offset, buffer.length - offset);
+			if (bytesWritten === 0) throw new Error("Atomic write made no progress");
+			offset += bytesWritten;
+		}
+		await handle.sync();
+		await handle.close();
+		handle = void 0;
+		if (metadata && process.getuid) await chown(tmp, metadata.uid, metadata.gid).catch((error) => {
+			if (!(error instanceof Error) || !canIgnoreMetadataError(error)) throw error;
+		});
+		if (mode) await chmod(tmp, mode).catch((error) => {
+			if (!(error instanceof Error) || !canIgnoreMetadataError(error)) throw error;
+		});
+		await rename(tmp, target);
+	} catch (error) {
+		await handle?.close().catch(() => void 0);
+		if (created) await rm(tmp, { force: true }).catch(() => void 0);
+		throw error;
+	}
+}
+/** Replace a file atomically, awaiting its callback and earlier writes to the same path. */
+async function writeFileAtomicAsync(filePath, contents, options = {}) {
+	const snapshot = snapshotContents(contents);
+	const key = path.resolve(filePath);
+	const pending = (inFlight.get(key) ?? Promise.resolve()).catch(() => void 0).then(() => replaceFile(filePath, snapshot, options));
+	inFlight.set(key, pending);
+	try {
+		await pending;
+	} finally {
+		if (inFlight.get(key) === pending) inFlight.delete(key);
+	}
+}
+/**
+* Write JSON with owner-only permissions on the file and on a directory
+* this call creates. Login tokens and consent files use it.
+*/
+async function writePrivateJsonAtomic(filePath, value) {
+	await mkdir(path.dirname(filePath), {
+		recursive: true,
+		mode: 448
+	});
+	await writeFileAtomicAsync(filePath, `${JSON.stringify(value, null, 2)}\n`, {
+		encoding: "utf8",
+		mode: 384
+	});
+}
+//#endregion
+//#region ../trace-core/src/store-origin.ts
+const LOCAL_HOSTS = /* @__PURE__ */ new Set([
+	"localhost",
+	"127.0.0.1",
+	"[::1]"
+]);
+/**
+* The canonical form of one store origin: `https://host[:port]`, or
+* `http://` for a local development store. Any other URL is an error.
+*/
+function normalizeStoreOrigin(value) {
+	let url;
+	try {
+		url = new URL(value.trim());
+	} catch {
+		throw new Error(`The trace store origin is not a URL: ${value}`);
+	}
+	const local = LOCAL_HOSTS.has(url.hostname);
+	if (!(url.protocol === "https:") && !(local && url.protocol === "http:")) throw new Error(`The trace store origin must use https (http is allowed for localhost): ${value}`);
+	if (url.username || url.password || url.search || url.hash || url.pathname !== "/") throw new Error(`The trace store origin must be a bare origin without a path, query, or login: ${value}`);
+	return url.origin;
+}
+//#endregion
+//#region ../trace-core/src/trace-home.ts
+const DEV_REVIEW_HOME_ENV = "DEV_REVIEW_HOME";
+/**
+* The one resolver for the Review home directory. Every reader of
+* DEV_REVIEW_HOME calls this, so an untrimmed or empty value cannot make two
+* modules disagree about the directory. An empty value means "use the
+* default".
+*/
+function devReviewHome(env = process.env, homeDir = os.homedir()) {
+	const override = env[DEV_REVIEW_HOME_ENV]?.trim();
+	return override ? path.resolve(override) : path.join(homeDir, ".dev");
+}
+//#endregion
+//#region ../trace-core/src/with-file-lock.ts
+const LOCK_OWNER_FILE = "owner.json";
+const DEFAULT_HEARTBEAT_MS = 3e4;
+async function withFileLock(lockPath, options, operation) {
+	await mkdir(path.dirname(lockPath), { recursive: true });
+	const deadline = Date.now() + options.timeoutMs;
+	while (true) try {
+		await mkdir(lockPath);
+		try {
+			await writeFile(path.join(lockPath, LOCK_OWNER_FILE), JSON.stringify({
+				pid: process.pid,
+				...options.identifyOwner && { started: processStartIdentity(process.pid) }
+			}), "utf8");
+		} catch (error) {
+			await rm(lockPath, {
+				recursive: true,
+				force: true
+			});
+			throw error;
+		}
+		break;
+	} catch (error) {
+		if (!(error instanceof Error && "code" in error && error.code === "EEXIST")) throw error;
+		const lockAge = await stat(lockPath).then((metadata) => Date.now() - metadata.mtimeMs).catch(() => 0);
+		const owner = await readLockOwner(lockPath);
+		const ownerPid = owner?.pid ?? null;
+		const ownerDead = ownerPid !== null && (!processIsAlive(ownerPid) || pidReused(ownerPid, owner?.started));
+		const neverOwned = ownerPid === null && lockAge > options.unownedGraceMs;
+		const heartbeatSilent = lockAge > options.staleMs;
+		if (ownerDead || neverOwned || heartbeatSilent) {
+			await rm(lockPath, {
+				recursive: true,
+				force: true
+			});
+			continue;
+		}
+		if (Date.now() >= deadline) return { acquired: false };
+		await setTimeout(options.retryMs);
+	}
+	const heartbeat = startHeartbeat(lockPath, options.heartbeatMs ?? DEFAULT_HEARTBEAT_MS);
+	try {
+		return {
+			acquired: true,
+			result: await operation()
+		};
+	} finally {
+		clearInterval(heartbeat);
+		await rm(lockPath, {
+			recursive: true,
+			force: true
+		});
+	}
+}
+function processIsAlive(pid) {
+	try {
+		process.kill(pid, 0);
+		return true;
+	} catch (error) {
+		return error instanceof Error && "code" in error && error.code === "EPERM";
+	}
+}
+function startHeartbeat(lockPath, intervalMs) {
+	const timer = setInterval(() => {
+		const now = /* @__PURE__ */ new Date();
+		utimes(lockPath, now, now).catch(() => {});
+	}, intervalMs);
+	timer.unref?.();
+	return timer;
+}
+async function readLockOwner(lockPath) {
+	return readFile(path.join(lockPath, LOCK_OWNER_FILE), "utf8").then((contents) => {
+		const owner = jsonObject(parseJsonText(contents));
+		const pid = jsonNumber(owner?.pid);
+		return pid === void 0 ? null : {
+			pid,
+			started: jsonString(owner?.started)
+		};
+	}).catch(() => null);
+}
+/** Only a recorded start that differs proves reuse; unknown is the same process. */
+function pidReused(pid, started) {
+	if (!started) return false;
+	const current = processStartIdentity(pid);
+	return current !== null && current !== started;
+}
+/**
+* Fixed for a process's life and unaffected by clock changes: the boot id and
+* start ticks on Linux, the kernel's recorded start elsewhere. Null if unknown.
+*/
+function processStartIdentity(pid) {
+	try {
+		if (process.platform === "linux") {
+			const stat = readFileSync(`/proc/${pid}/stat`, "utf8");
+			const ticks = stat.slice(stat.lastIndexOf(")") + 2).split(" ")[19];
+			const boot = readFileSync("/proc/sys/kernel/random/boot_id", "utf8");
+			return ticks ? `${boot.trim()}:${ticks}` : null;
+		}
+		const ps = spawnSync("ps", [
+			"-o",
+			"lstart=",
+			"-p",
+			String(pid)
+		], {
+			encoding: "utf8",
+			env: {
+				...process.env,
+				LC_ALL: "C",
+				TZ: "UTC"
+			}
+		});
+		return ps.status === 0 && ps.stdout.trim() || null;
+	} catch {
+		return null;
+	}
+}
+/** The two stores a machine can name. */
+const traceStoreNameSchema = z.enum(["s3", "hosted"]);
+/** The hosted origin used when a file names none. */
+const DEFAULT_HOSTED_ORIGIN = "https://app.dev.fast";
+const s3CaptureSchema = z.object({
+	enabled: z.boolean(),
+	autoActivateRepositories: z.boolean(),
+	verifiedAt: z.string().optional(),
+	error: z.string().optional()
+});
+/** Your own S3-compatible bucket. Complete or rejected; never patched from legacy files. */
+const s3ProfileSchema = z.object({
+	endpoint: z.string().min(1),
+	bucket: z.string().min(1),
+	accessKeyId: z.string().min(1),
+	secretAccessKey: z.string().min(1),
+	region: z.string().min(1).optional(),
+	capture: s3CaptureSchema.optional()
+});
+/** The hosted store in use. The login token lives in the auth file. */
+const hostedStoreSchema = z.object({
+	origin: z.string().min(1).optional(),
+	/** Machine-level capture switch for the hosted store; consent stays. */
+	capture: z.object({ enabled: z.boolean() }).optional()
+});
+/**
+* Hosted-only consent: one repository the user allowed to publish complete
+* session transcripts, and the hosted origins it may publish to. Bucket
+* uploads never read this list.
+*/
+const traceRepositoryEntrySchema = z.object({
+	repositoryId: z.number().int().positive(),
+	name: z.string().min(1),
+	enabledOrigins: z.array(z.string().min(1)).optional(),
+	allowedAt: z.string().optional()
+});
+const traceConfigSchema = z.object({
+	version: z.literal(2),
+	"current-store": traceStoreNameSchema.optional(),
+	stores: z.object({
+		s3: s3ProfileSchema.optional(),
+		hosted: hostedStoreSchema.optional()
+	}).optional(),
+	repositories: z.array(traceRepositoryEntrySchema).optional()
+});
+/** The empty configuration every writer starts from. */
+function emptyTraceConfig() {
+	return { version: 2 };
+}
+function currentStore(config) {
+	return config?.["current-store"];
+}
+function s3Store(config) {
+	return config?.stores?.s3 ?? null;
+}
+/** The hosted origin in effect: the store entry's, or the default. */
+function hostedOrigin(config) {
+	const origin = config?.stores?.hosted?.origin;
+	if (!origin) return DEFAULT_HOSTED_ORIGIN;
+	try {
+		return normalizeStoreOrigin(origin);
+	} catch {
+		return origin;
+	}
+}
+/** Whether hosted capture is switched on; consent alone leaves it on. */
+function hostedCaptureEnabled(config) {
+	return config?.stores?.hosted?.capture?.enabled ?? true;
+}
+/** Whether the file names a hosted store at all, explicitly or through consent. */
+function hasHostedStore(config) {
+	return config?.stores?.hosted !== void 0 || (config?.repositories?.length ?? 0) > 0;
+}
+/** The origins one consent entry allows; absent means the default origin. */
+function enabledOriginsOf(entry) {
+	return entry.enabledOrigins ?? ["https://app.dev.fast"];
+}
+const traceConfigV1Schema = z.object({
+	version: z.literal(1),
+	repositories: z.array(z.unknown()).optional()
+});
+const v1RepositorySchema = z.object({
+	repositoryId: z.number().int().positive(),
+	name: z.string().min(1),
+	store: z.string().min(1),
+	allowedAt: z.string().optional()
+});
+var TraceConfigurationError = class extends Error {
+	constructor(message) {
+		super(message);
+		this.name = "TraceConfigurationError";
+	}
+};
+function traceConfigPath(scope = {}) {
+	const devHome = scope.devHome ?? devReviewHome(scope.env ?? process.env, scope.homeDir ?? os.homedir());
+	return path.join(devHome, "trace", "config.json");
+}
+function readTraceConfigFile(scope = {}) {
+	const filePath = traceConfigPath(scope);
+	let text;
+	let fingerprint;
+	try {
+		const stats = statSync(filePath);
+		fingerprint = `${stats.size}:${stats.mtimeMs}`;
+		text = readFileSync(filePath, "utf8");
+	} catch {
+		return {
+			path: filePath,
+			source: "absent",
+			config: null,
+			extra: {},
+			fingerprint: null
+		};
+	}
+	const malformed = (reason) => ({
+		path: filePath,
+		source: "absent",
+		config: null,
+		extra: {},
+		fingerprint,
+		error: `Trace configuration at ${filePath} is invalid: ${reason}`
+	});
+	let raw;
+	try {
+		raw = jsonObject(parseJsonText(text));
+	} catch {
+		return malformed("not valid JSON.");
+	}
+	if (!raw) return malformed("expected a JSON object.");
+	const v2 = traceConfigSchema.safeParse(raw);
+	if (v2.success) {
+		if (v2.data.stores?.s3 !== void 0 && v2.data.stores?.hosted !== void 0 && v2.data["current-store"] === void 0) return malformed("both stores are configured; set \"current-store\" to \"s3\" or \"hosted\".");
+		return {
+			path: filePath,
+			source: "v2",
+			config: v2.data,
+			extra: unknownFields(raw, [
+				"version",
+				"current-store",
+				"stores",
+				"repositories"
+			]),
+			fingerprint
+		};
+	}
+	const v1 = traceConfigV1Schema.safeParse(raw);
+	if (v1.success) return {
+		path: filePath,
+		source: "v1",
+		config: {
+			version: 2,
+			repositories: (v1.data.repositories ?? []).flatMap((entry) => {
+				const parsed = v1RepositorySchema.safeParse(entry);
+				if (!parsed.success) return [];
+				const { store, ...rest } = parsed.data;
+				return [{
+					...rest,
+					enabledOrigins: [store]
+				}];
+			})
+		},
+		extra: unknownFields(raw, ["version", "repositories"]),
+		fingerprint
+	};
+	const issue = v2.error.issues[0];
+	const where = issue?.path.length ? ` at ${issue.path.join(".")}` : "";
+	return malformed(`${issue?.message ?? "unsupported contents"}${where}.`);
+}
+/**
+* Replaces the configuration atomically with private permissions. The
+* write is refused when the file changed since it was read, so two
+* concurrent editors cannot silently drop each other's changes.
+*/
+async function writeTraceConfigFile(file, config) {
+	if (file.error) throw new TraceConfigurationError(file.error);
+	await mkdir(path.dirname(file.path), {
+		recursive: true,
+		mode: 448
+	});
+	if (!(await withFileLock(`${path.resolve(file.path)}.lock`, {
+		retryMs: 20,
+		timeoutMs: 1e4,
+		staleMs: 12e4,
+		heartbeatMs: 5e3,
+		unownedGraceMs: 1e3
+	}, async () => {
+		if (currentFingerprint(file.path) !== file.fingerprint) throw new TraceConfigurationError(`Trace configuration at ${file.path} changed while it was being updated. Re-run the command.`);
+		const document = {
+			...file.extra,
+			version: 2,
+			"current-store": config["current-store"],
+			stores: config.stores,
+			repositories: config.repositories
+		};
+		await writePrivateJsonAtomic(file.path, document);
+	})).acquired) throw new TraceConfigurationError(`Trace configuration at ${file.path} is busy. Re-run the command after the current update finishes.`);
+}
+function currentFingerprint(filePath) {
+	try {
+		const stats = statSync(filePath);
+		return `${stats.size}:${stats.mtimeMs}`;
+	} catch {
+		return null;
+	}
+}
+function unknownFields(raw, known) {
+	return Object.fromEntries(Object.entries(raw).filter(([key]) => !known.includes(key)));
+}
+/** Direct profiles compare on destination, credentials, and capture settings. */
+function sameS3Profile(a, b) {
+	return a.endpoint === b.endpoint && a.bucket === b.bucket && a.accessKeyId === b.accessKeyId && a.secretAccessKey === b.secretAccessKey && (a.region ?? "auto") === (b.region ?? "auto") && (a.capture?.enabled ?? false) === (b.capture?.enabled ?? false) && (a.capture?.autoActivateRepositories ?? false) === (b.capture?.autoActivateRepositories ?? false);
+}
+//#endregion
+//#region ../trace-core/src/trace-storage/s3-config.ts
+const S3_DEFAULT_REGION = "auto";
+function traceEnvPath(homeDir = os.homedir(), env = process.env) {
+	return env.TRACE_ENV_FILE ?? path.join(homeDir, ".config", "dev-trace", "env");
+}
+function traceSettingsPath(homeDir = os.homedir(), env = process.env) {
+	return env.TRACE_SETTINGS_FILE ?? path.join(homeDir, ".config", "dev-trace", "settings.json");
+}
+const envFileCache = /* @__PURE__ */ new Map();
+function clearTraceEnvCache() {
+	envFileCache.clear();
+}
+/** Parses one `export NAME=value` file; a missing file reads as empty. */
+function readTraceEnvFile(envPath) {
+	const cached = envFileCache.get(envPath);
+	if (cached) return cached;
+	const values = /* @__PURE__ */ new Map();
+	try {
+		for (const line of readFileSync(envPath, "utf8").split("\n")) {
+			const match = /^\s*(?:export\s+)?([A-Z0-9_]+)=(.*)$/.exec(line);
+			if (!match) continue;
+			values.set(match[1], unquoteEnvValue(match[2]));
+		}
+	} catch {}
+	envFileCache.set(envPath, values);
+	return values;
+}
+function unquoteEnvValue(raw) {
+	const trimmed = raw.trim();
+	try {
+		const decoded = jsonString(parseJsonText(trimmed));
+		if (decoded !== void 0) return decoded;
+	} catch {}
+	return trimmed.replace(/^["']|["']$/g, "").trim();
+}
+function traceEnvValue(name, scope = {}) {
+	const env = scope.env ?? process.env;
+	return env[name] ?? readTraceEnvFile(traceEnvPath(scope.homeDir, env)).get(name);
+}
+const S3_FIELDS = [
+	"endpoint",
+	"bucket",
+	"accessKeyId",
+	"secretAccessKey",
+	"region"
+];
+/** The variables that supply each field, in precedence order. */
+const S3_FIELD_VARIABLES = {
+	endpoint: ["TRACE_R2_ENDPOINT"],
+	bucket: ["TRACE_R2_BUCKET"],
+	accessKeyId: ["TRACE_R2_ACCESS_KEY_ID", "AWS_ACCESS_KEY_ID"],
+	secretAccessKey: ["TRACE_R2_SECRET_ACCESS_KEY", "AWS_SECRET_ACCESS_KEY"],
+	region: ["TRACE_R2_REGION"]
+};
+/**
+* Resolves the direct bucket setup. A complete version-2 profile is the
+* base; otherwise the legacy env file is. Process environment variables
+* override either. An incomplete profile is a configuration error, never
+* patched from the legacy file. `ignoreProfile` reads the legacy inputs
+* only, which migration needs to describe what it would persist.
+*/
+function resolveS3Setup(scope = {}) {
+	const env = scope.env ?? process.env;
+	const envPath = traceEnvPath(scope.homeDir, env);
+	const configFile = readTraceConfigFile(scope);
+	if (configFile.error) throw new TraceConfigurationError(configFile.error);
+	const configPath = configFile.path;
+	const profile = scope.ignoreProfile ? null : s3Store(configFile.config);
+	const legacy = readTraceEnvFile(envPath);
+	const overrides = [];
+	const resolved = {
+		endpoint: void 0,
+		bucket: void 0,
+		accessKeyId: void 0,
+		secretAccessKey: void 0,
+		region: void 0
+	};
+	let source = profile ? "profile" : "none";
+	for (const field of S3_FIELDS) for (const name of S3_FIELD_VARIABLES[field]) {
+		if (env[name] !== void 0) {
+			overrides.push(name);
+			resolved[field] = env[name];
+			break;
+		}
+		if (profile && profile[field] !== void 0) {
+			resolved[field] = profile[field];
+			break;
+		}
+		if (legacy.has(name)) {
+			resolved[field] = legacy.get(name);
+			if (source === "none") source = "legacy-file";
+			break;
+		}
+	}
+	if (source === "none" && overrides.length > 0) source = "process-env";
+	const { endpoint, bucket, accessKeyId, secretAccessKey } = resolved;
+	const credentials = endpoint && bucket && accessKeyId && secretAccessKey ? {
+		endpoint,
+		bucket,
+		accessKeyId,
+		secretAccessKey,
+		region: resolved.region ?? "auto"
+	} : null;
+	return {
+		credentials,
+		source: credentials ? source : "none",
+		overrides,
+		envPath,
+		configPath,
+		profile
+	};
+}
+function resolveS3Credentials(scope = {}) {
+	return resolveS3Setup(scope).credentials;
+}
+/** The message a machine with no trace configuration reads, in either CLI. */
+function noTraceConfigurationMessage() {
+	return `No trace configuration found. Run \`whiteboard trace allow .\` to configure trace capture.`;
+}
+/** Describes the resolved direct-bucket setup without testing the network. */
+function describeS3Setup(env = process.env) {
+	const setup = resolveS3Setup({ env });
+	const envPath = setup.source === "profile" ? setup.configPath : setup.envPath;
+	if (isS3MockMode(env)) return {
+		envPath,
+		config: {
+			endpoint: "mock://endpoint",
+			bucket: "mock-bucket",
+			accessKeyId: "mock-key"
+		}
+	};
+	const config = setup.credentials;
+	if (!config) return {
+		envPath,
+		error: setup.profile !== null || existsSync(setup.envPath) || Boolean(env.TRACE_R2_BUCKET) ? "Configuration is missing one or more required S3/R2 values." : noTraceConfigurationMessage()
+	};
+	return {
+		envPath,
+		config: {
+			endpoint: config.endpoint,
+			bucket: config.bucket,
+			accessKeyId: config.accessKeyId
+		}
+	};
+}
+/** The bucket test double: object keys become files under this directory. */
+function s3MockRoot(env = process.env) {
+	if (env.TRACE_R2_MODE !== "mock") return null;
+	return env.TRACE_R2_MOCK_DIR || null;
+}
+function isS3MockMode(env = process.env) {
+	return env.TRACE_R2_MODE === "mock";
+}
+/** Secret-free identity of the destination; the same bucket keys the same cache. */
+function s3CacheIdentity(config, mockRoot) {
+	if (!config) return `s3:mock:${mockRoot ?? ""}`;
+	return `s3:${createHash("sha256").update(`${normalizeS3Endpoint(config.endpoint)}\n${config.bucket}`).digest("hex").slice(0, 16)}`;
+}
+function normalizeS3Endpoint(endpoint) {
+	try {
+		const url = new URL(endpoint);
+		url.hash = "";
+		url.search = "";
+		return url.toString().replace(/\/+$/, "").toLowerCase();
+	} catch {
+		return endpoint.trim().replace(/\/+$/, "").toLowerCase();
+	}
+}
+//#endregion
+export { devReviewHome as A, s3ProfileSchema as C, processIsAlive as D, writeTraceConfigFile as E, writeFileAtomic as M, writeFileAtomicAsync as N, withFileLock as O, writePrivateJsonAtomic as P, readTraceConfigFile as S, sameS3Profile as T, emptyTraceConfig as _, noTraceConfigurationMessage as a, hostedCaptureEnabled as b, resolveS3Setup as c, traceEnvPath as d, traceEnvValue as f, currentStore as g, TraceConfigurationError as h, isS3MockMode as i, normalizeStoreOrigin as j, DEV_REVIEW_HOME_ENV as k, s3CacheIdentity as l, DEFAULT_HOSTED_ORIGIN as m, clearTraceEnvCache as n, readTraceEnvFile as o, traceSettingsPath as p, describeS3Setup as r, resolveS3Credentials as s, S3_DEFAULT_REGION as t, s3MockRoot as u, enabledOriginsOf as v, s3Store as w, hostedOrigin as x, hasHostedStore as y };

package/dist/server/desktop-host.d.ts

@@ -0,0 +1,4 @@
+//#region src/server/desktop-host.d.ts
+declare function runDesktopHost(env?: NodeJS.ProcessEnv): Promise<void>;
+//#endregion
+export { runDesktopHost };