@dev.fast/whiteboard 0.0.0-stage → 0.2.0

package/dist/desktop-discovery-DBO-PM2V.js

@@ -0,0 +1,164 @@
+import { a as jsonNumber, n as isJsonObject, s as jsonProperty, u as parseJsonText } from "./src-X9phtB2j.js";
+import { n as parseReviewDesktopDiscovery } from "./src-DnwdaQ2r.js";
+import { a as reviewInstancesDir, o as reviewLegacyDiscoveryPath, r as reviewDevInstanceKey, t as reviewDefaultInstancePath } from "./review-home-paths-6zZH-1c9.js";
+import { mkdir, readFile, readdir, rm, writeFile } from "node:fs/promises";
+import path from "node:path";
+//#region src/desktop-discovery.ts
+var ReviewDesktopProtocolMismatchError = class extends Error {
+	actualVersion;
+	expectedVersion;
+	name = "ReviewDesktopProtocolMismatchError";
+	constructor(actualVersion, expectedVersion = 3) {
+		super(`Whiteboard Desktop uses protocol ${actualVersion}, but this Whiteboard CLI needs protocol ${expectedVersion}. Update the Whiteboard CLI and Whiteboard Desktop to compatible versions, then try again.`);
+		this.actualVersion = actualVersion;
+		this.expectedVersion = expectedVersion;
+	}
+};
+var ReviewDesktopDiscoveryUnreadableError = class extends Error {
+	name = "ReviewDesktopDiscoveryUnreadableError";
+	constructor(filePath, detail) {
+		super(`Whiteboard Desktop discovery is unreadable at ${filePath}. Restart Whiteboard Desktop and try again.${detail ? ` ${detail}` : ""}`);
+	}
+};
+/** One record, or null when the file does not exist. */
+async function readReviewDesktopDiscoveryFile(filePath) {
+	let source;
+	try {
+		source = await readFile(filePath, "utf8");
+	} catch (error) {
+		if (error instanceof Error && "code" in error && error.code === "ENOENT") return null;
+		throw new ReviewDesktopDiscoveryUnreadableError(filePath, String(error));
+	}
+	let value;
+	try {
+		value = parseJsonText(source);
+	} catch (error) {
+		throw new ReviewDesktopDiscoveryUnreadableError(filePath, String(error));
+	}
+	try {
+		return parseReviewDesktopDiscovery(value);
+	} catch (error) {
+		const version = isJsonObject(value) ? jsonNumber(jsonProperty(value, "version")) : void 0;
+		if (version !== void 0 && Number.isInteger(version) && version !== 3) throw new ReviewDesktopProtocolMismatchError(version);
+		throw new ReviewDesktopDiscoveryUnreadableError(filePath, String(error));
+	}
+}
+async function isHealthyReviewDesktop(discovery, fetch = globalThis.fetch) {
+	try {
+		const response = await fetch(`${discovery.url}/health`, { signal: AbortSignal.timeout(1500) });
+		if (!response.ok) return false;
+		const health = await response.json();
+		return isJsonObject(health) && health.ok === true && health.instanceId === discovery.instanceId && health.desktopAttached === true;
+	} catch {
+		return false;
+	}
+}
+/** The selected Desktop's record while it is running, else null. */
+function healthyReviewInstance(selection) {
+	return selection.instance?.healthy ? selection.instance.discovery : null;
+}
+async function requireHealthyReviewDesktop(fetch = globalThis.fetch) {
+	const selection = await selectReviewInstance({ fetch });
+	const discovery = healthyReviewInstance(selection);
+	if (!discovery) throw reviewInstanceUnavailable(selection);
+	return discovery;
+}
+/** Shell-session override; agents inherit it through the bare shim. */
+const REVIEW_INSTANCE_ENV = "DEV_REVIEW_INSTANCE";
+function checkedInstanceKey(key, origin = "") {
+	if (/^(?:stable|preview|dev-[A-Za-z0-9_.-]+)$/.test(key)) return key;
+	throw new Error(`Unknown Whiteboard instance ${JSON.stringify(key)}${origin}. Use stable, preview, or a dev-… key from \`whiteboard instances\`.`);
+}
+/** Identity of the Desktop hosting this process, from the env electron-main passes. */
+function reviewInstanceIdentity(env) {
+	const checkout = env.DEV_FAST_REVIEW_CHECKOUT?.trim();
+	const channel = checkout ? "dev" : env.DEV_FAST_REVIEW_RELEASE_CHANNEL === "preview" ? "preview" : "stable";
+	const identity = {
+		key: checkout ? reviewDevInstanceKey(checkout) : channel,
+		channel
+	};
+	if (checkout) identity.checkout = path.resolve(checkout);
+	const appPath = env.DEV_FAST_REVIEW_APP_PATH?.trim();
+	if (appPath) identity.appPath = appPath;
+	const appVersion = env.DEV_FAST_REVIEW_APP_VERSION?.trim();
+	if (appVersion) identity.appVersion = appVersion;
+	return identity;
+}
+/** Records by key, plus the files that could not be read, by key. */
+async function readReviewInstances(dependencies) {
+	const env = dependencies.env ?? process.env;
+	const directory = reviewInstancesDir(env);
+	const names = await readdir(directory).catch(() => []);
+	const files = names.filter((name) => name.endsWith(".json")).map((name) => [path.basename(name, ".json"), path.join(directory, name)]);
+	if (!names.includes("stable.json")) files.push(["stable", reviewLegacyDiscoveryPath(env)]);
+	const records = [];
+	const broken = /* @__PURE__ */ new Map();
+	for (const [key, filePath] of files) try {
+		const discovery = await readReviewDesktopDiscoveryFile(filePath);
+		if (discovery) records.push({
+			key,
+			filePath,
+			discovery
+		});
+	} catch (error) {
+		const problem = error instanceof Error ? error : new Error(String(error));
+		broken.set(key, problem);
+		dependencies.warn?.(`Skipping ${filePath}: ${problem.message}`);
+	}
+	return {
+		instances: await Promise.all(records.map(async (record) => ({
+			...record,
+			healthy: await isHealthyReviewDesktop(record.discovery, dependencies.fetch)
+		}))),
+		broken
+	};
+}
+async function readDefaultReviewInstance(env = process.env) {
+	return await readFile(reviewDefaultInstancePath(env), "utf8").then((text) => text.trim()).catch(() => "") || void 0;
+}
+async function writeDefaultReviewInstance(key, env = process.env) {
+	const filePath = reviewDefaultInstancePath(env);
+	await mkdir(path.dirname(filePath), { recursive: true });
+	await writeFile(filePath, `${checkedInstanceKey(key)}\n`);
+}
+async function clearDefaultReviewInstance(env = process.env) {
+	await rm(reviewDefaultInstancePath(env), { force: true });
+}
+/** DEV_REVIEW_INSTANCE, then the machine default, then the only running Desktop, then stable. */
+async function selectReviewInstance(dependencies = {}) {
+	const env = dependencies.env ?? process.env;
+	const { instances, broken } = await readReviewInstances(dependencies);
+	const fromEnv = env[REVIEW_INSTANCE_ENV]?.trim();
+	const fromDefault = fromEnv ? void 0 : await readDefaultReviewInstance(env);
+	const running = instances.filter((instance) => instance.healthy);
+	const [key, source] = fromEnv ? [checkedInstanceKey(fromEnv, ` from ${REVIEW_INSTANCE_ENV}`), "env"] : fromDefault ? [checkedInstanceKey(fromDefault, " as the machine default (`whiteboard instances clear` removes it)"), "default"] : running.length === 1 ? [running[0].key, "only-running"] : ["stable", "fallback"];
+	const selection = {
+		key,
+		source,
+		instances
+	};
+	const instance = instances.find((instance) => instance.key === key);
+	const problem = instance ? void 0 : fromEnv || fromDefault ? broken.get(key) : broken.values().next().value;
+	if (instance) selection.instance = instance;
+	if (problem) selection.problem = problem;
+	return selection;
+}
+/** Never a redirect: names what is running and how to start or pick one. */
+function reviewInstanceUnavailable(selection) {
+	if (selection.problem) return selection.problem;
+	const running = selection.instances.filter((instance) => instance.healthy).map((instance) => instance.key);
+	const others = running.length ? ` Running: ${running.join(", ")}.` : " No Whiteboard is running.";
+	if (selection.source === "fallback" && running.length > 1) return new ReviewInstanceUnavailableError(`Several Whiteboard instances are running and none is selected.${others} Choose one with \`whiteboard instances use <key>\`, or \`export ${REVIEW_INSTANCE_ENV}=<key>\` for this shell.`);
+	return new ReviewInstanceUnavailableError(`Whiteboard \`${selection.key}\` is not running. ${reviewInstanceStartHint(selection)}, or pick another instance with \`whiteboard instances\`.${others}`);
+}
+/** A command could not reach the selected Desktop instance. */
+var ReviewInstanceUnavailableError = class extends Error {
+	name = "ReviewInstanceUnavailableError";
+};
+function reviewInstanceStartHint(selection) {
+	if (!selection.key.startsWith("dev-")) return "Start it with `whiteboard app launch`";
+	const checkout = selection.instance?.discovery.checkout;
+	return checkout ? `Start it with \`pnpm dev\` in ${checkout}` : "Start it with `pnpm dev` in its checkout";
+}
+//#endregion
+export { readDefaultReviewInstance as a, reviewInstanceIdentity as c, selectReviewInstance as d, writeDefaultReviewInstance as f, healthyReviewInstance as i, reviewInstanceStartHint as l, ReviewInstanceUnavailableError as n, readReviewInstances as o, clearDefaultReviewInstance as r, requireHealthyReviewDesktop as s, REVIEW_INSTANCE_ENV as t, reviewInstanceUnavailable as u };

package/dist/error-message-OtiDonty.js

@@ -0,0 +1,6 @@
+//#region ../trace-core/src/error-message.ts
+function errorMessage(cause) {
+	return cause instanceof Error ? cause.message : String(cause);
+}
+//#endregion
+export { errorMessage as t };

package/dist/fs-utils-BMPLt0cr.js

@@ -0,0 +1,22 @@
+import { stat } from "node:fs/promises";
+//#region src/fs-utils.ts
+/** Whether a thrown filesystem error reports a missing file (ENOENT). */
+function isMissingFileError(cause) {
+	return cause instanceof Error && "code" in cause && cause.code === "ENOENT";
+}
+async function isDirectory(target) {
+	try {
+		return (await stat(target)).isDirectory();
+	} catch {
+		return false;
+	}
+}
+async function isFile(target) {
+	try {
+		return (await stat(target)).isFile();
+	} catch {
+		return false;
+	}
+}
+//#endregion
+export { isFile as n, isMissingFileError as r, isDirectory as t };

package/dist/fuzzy-match-BoAmcyak.js

@@ -0,0 +1,30 @@
+import fuzzysort from "fuzzysort";
+//#region src/fuzzy-match.ts
+const SCORE_THRESHOLD = .5;
+/**
+* The single fuzzy matcher for this package. Each label is scored on its own,
+* never joined: a match across a join could pair a letter from one label with
+* a letter from the next and keep an item that shows neither word.
+*/
+function bestScore(needle, labels) {
+	let best = 0;
+	for (const label of labels) {
+		const score = fuzzysort.single(needle, label)?.score ?? 0;
+		if (score > best) best = score;
+	}
+	return best;
+}
+/**
+* The items whose labels hit the query, best match first. An empty query keeps
+* every item in its original order.
+*/
+function fuzzyRank(query, items, labelsOf) {
+	const needle = query.trim();
+	if (!needle) return [...items];
+	return items.values().map((item) => ({
+		item,
+		score: bestScore(needle, labelsOf(item))
+	})).filter((hit) => hit.score >= SCORE_THRESHOLD).toArray().sort((left, right) => right.score - left.score).map((hit) => hit.item);
+}
+//#endregion
+export { fuzzyRank as t };

package/dist/headless-host-BJxf4dUU.js

@@ -0,0 +1,94 @@
+import { p as isObjectValue } from "./src-X9phtB2j.js";
+import { O as withFileLock, P as writePrivateJsonAtomic } from "./s3-config-CAxhO9u_.js";
+import "./review-home-paths-6zZH-1c9.js";
+import { t as openReviewProfile } from "./profile-4ry2f3AM.js";
+import { i as createWhiteboardCore, l as createNodeRequestListener, n as installProcessErrorTelemetry, p as GlobalReviewDesktopVerbRelay, t as drainServerCrashReport } from "./process-error-telemetry-v9e5h6D7.js";
+import { i as reviewServerDiscoveryPath, t as headlessServerLockPath } from "./server-discovery-Dbzn3w6Z.js";
+import { randomBytes, randomUUID } from "node:crypto";
+import { mkdir, realpath, rm } from "node:fs/promises";
+import { createServer } from "node:http";
+import { once } from "node:events";
+//#region src/server/headless-host.ts
+/** One foreground headless endpoint per profile; Desktop shares its database. */
+async function runHeadlessServer(input) {
+	await mkdir(input.stateDir, {
+		recursive: true,
+		mode: 448
+	});
+	const stateDir = await realpath(input.stateDir);
+	const stopErrorTelemetry = input.telemetry && installProcessErrorTelemetry(input.telemetry);
+	if (!(await withHeadlessServerLock(stateDir, () => serve({
+		...input,
+		stateDir
+	})).finally(() => stopErrorTelemetry?.())).acquired) throw new Error(`A Whiteboard server already owns ${stateDir}. Stop it first, or choose another --state-dir.`);
+}
+/** Held by a running server, so also by anything that must not run beside one. */
+function withHeadlessServerLock(stateDir, operation) {
+	return withFileLock(headlessServerLockPath(stateDir), {
+		timeoutMs: 0,
+		retryMs: 20,
+		staleMs: Infinity,
+		unownedGraceMs: 1e3,
+		identifyOwner: true
+	}, operation);
+}
+async function serve(input) {
+	if (input.signal.aborted) return;
+	if (input.telemetry) await drainServerCrashReport(input.telemetry);
+	const local = await openReviewProfile(input.stateDir, { manageWorkspaces: false });
+	const discovery = {
+		version: 1,
+		instanceId: randomUUID(),
+		url: "http://127.0.0.1:0",
+		serverPid: process.pid,
+		token: randomBytes(32).toString("base64url")
+	};
+	const relay = new GlobalReviewDesktopVerbRelay();
+	const { app, api } = createWhiteboardCore({
+		profile: local,
+		relay,
+		token: discovery.token,
+		instanceId: discovery.instanceId,
+		softwareMapEnabled: input.softwareMapEnabled,
+		scratchpad: () => false,
+		status: () => ({
+			key: "headless",
+			home: input.stateDir
+		})
+	});
+	app.route("/reviews-api", api);
+	const server = createServer(createNodeRequestListener(app));
+	let published = false;
+	try {
+		const listening = once(server, "listening");
+		server.listen(input.port ?? 0, "127.0.0.1");
+		await listening;
+		const address = server.address();
+		if (!isObjectValue(address)) throw new Error("Whiteboard server did not bind a TCP port.");
+		discovery.url = `http://127.0.0.1:${address.port}`;
+		await writePrivateJsonAtomic(reviewServerDiscoveryPath(input.stateDir), discovery);
+		published = true;
+		input.onReady(discovery);
+		await new Promise((resolve) => {
+			if (input.signal.aborted) resolve();
+			else input.signal.addEventListener("abort", () => resolve(), { once: true });
+		});
+	} finally {
+		const forceClose = setTimeout(() => server.closeAllConnections(), 5e3);
+		forceClose.unref();
+		try {
+			if (published) await rm(reviewServerDiscoveryPath(input.stateDir), { force: true });
+		} finally {
+			relay.close();
+			await new Promise((resolve) => server.close(() => resolve()));
+			clearTimeout(forceClose);
+			try {
+				await local.data.close();
+			} finally {
+				await local.store.close();
+			}
+		}
+	}
+}
+//#endregion
+export { runHeadlessServer, withHeadlessServerLock };

package/dist/input-error-OLgB_h31.js

@@ -0,0 +1,11 @@
+//#region src/review-api/input-error.ts
+/** Deliberately safe to show to API clients, unlike filesystem/provider errors. */
+var ReviewInputError = class extends Error {
+	status;
+	constructor(message, status = 400) {
+		super(message);
+		this.status = status;
+	}
+};
+//#endregion
+export { ReviewInputError as t };