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

package/dist/mcp-QeF8vkdf.js

@@ -0,0 +1,140 @@
+import { a as toolResultText, s as ReviewApiError } from "./agent-client-CPQo7iTI.js";
+import { t as ReviewInputError } from "./input-error-OLgB_h31.js";
+import { n as REVIEW_STATUS_TOOL, t as authoringTools } from "./authoring-tools-Cr6Kpjsx.js";
+import { i as publicTool, n as RECOVERY, r as callPublicTool, t as toolFailure } from "./tool-failure-C8zB73HV.js";
+import { Server } from "@modelcontextprotocol/sdk/server/index.js";
+import { StdioServerTransport } from "@modelcontextprotocol/sdk/server/stdio.js";
+import { CallToolRequestSchema, ListToolsRequestSchema } from "@modelcontextprotocol/sdk/types.js";
+//#region src/review-api/mcp-client-agent.ts
+/**
+* The agent behind an MCP client, from the name it sends in `initialize`.
+* Names seen on 2026-10-02: Claude Code `claude-code`, Codex
+* `codex-mcp-client`, the Cursor CLI `Cursor`, OpenCode `opencode`, Pi `pi`
+* and Oh My Pi `omp-coding-agent`. Undefined for
+* a client this does not recognize, so the caller can fall back to the
+* session environment. Codex strips its `CODEX_*` variables from the MCP
+* server's environment, so for Codex the handshake is the only signal.
+*/
+function mcpClientAgent(name) {
+	const normalized = name?.trim().toLowerCase();
+	if (!normalized) return void 0;
+	if (normalized.startsWith("codex")) return "codex";
+	if (normalized.startsWith("claude")) return "claude";
+	if (normalized.startsWith("cursor")) return "cursor";
+	if (normalized.startsWith("opencode")) return "opencode";
+	if (/^omp(?:$|[-_ ])/.test(normalized)) return "omp";
+	if (/^pi(?:$|[-_ ])/.test(normalized)) return "pi";
+}
+//#endregion
+//#region src/review-api/mcp.ts
+const RELOAD_TOOLS = "Whiteboard is running now, but this session listed Whiteboard's tools before it started, so you may see only session_get_instructions. Before authoring, reload the `whiteboard` MCP server's tools (reconnect it in your agent, or start a new agent session). If you can already see tools such as session_create, carry on.";
+function mcpAuthoringGuidance(context) {
+	return [
+		"Whiteboard explains code in documents the user reads in Whiteboard Desktop. Call session_get_instructions before creating or editing a Whiteboard and follow it. Read session_capabilities before authoring; session_create opens the new review in Desktop when it is available, so call session_open only for an existing review, and generate software maps only when softwareMapEnabled is true. When the user asks for a Whiteboard or to use Whiteboard (for example to review a branch, a change or a pull request, or to explain a system in Whiteboard), author a Whiteboard with the default topic.",
+		...context.scratchpadAvailable ? ["When the user asks in conversation to be shown how code works or wants a diagram, without asking for a Whiteboard, call session_capabilities; if it reports scratchpadEnabled and desktopAvailable, draw on the Whiteboard scratchpad rather than answering only in chat, starting with session_get_instructions({topic:\"scratchpad\"})."] : [],
+		...context.traceEnabled ? ["For why code exists, what an agent was thinking, or whether an agent solved something before, call session_get_instructions({topic:\"trace-archaeology\"})."] : [],
+		"Never read or write Whiteboard files or SQL."
+	].join(" ");
+}
+async function serveReviewMcp(connect, stdin, stdout, stderr = process.stderr, traceEnabled = false, offlineStatus, onToolCall, environmentAgent) {
+	const instructionsTool = {
+		...authoringTools(false, traceEnabled).find((tool) => tool.name === "review_get_instructions"),
+		name: "session_get_instructions"
+	};
+	const server = new Server({
+		name: "whiteboard",
+		version: "1.0.0"
+	}, { capabilities: { tools: { listChanged: true } } });
+	let catalog = [];
+	let announceCatalog = false;
+	let listedWhileDown = false;
+	let latched;
+	const agentKind = () => mcpClientAgent(server.getClientVersion()?.name) ?? environmentAgent;
+	const load = async (signal) => {
+		const { client, instance } = await connect(latched, agentKind());
+		latched ??= instance?.key;
+		catalog = (await client.read("/authoring", signal)).map(publicTool);
+		if (announceCatalog) {
+			announceCatalog = false;
+			server.sendToolListChanged().catch(() => {});
+		}
+		return {
+			client,
+			tools: catalog
+		};
+	};
+	server.setRequestHandler(ListToolsRequestSchema, async (_request, extra) => {
+		let tools = catalog;
+		try {
+			({tools} = await load(extra.signal));
+			listedWhileDown = false;
+		} catch (error) {
+			announceCatalog = true;
+			listedWhileDown = true;
+			stderr.write(`whiteboard mcp: ${error instanceof Error ? error.message : String(error)}\n`);
+		}
+		const always = [instructionsTool, REVIEW_STATUS_TOOL].map((fallback) => tools.find((tool) => tool.name === fallback.name) ?? fallback);
+		return { tools: [...always, ...tools.filter((tool) => !always.includes(tool))].map(({ name, description, inputSchema }) => ({
+			name,
+			description: name === instructionsTool.name ? `${mcpAuthoringGuidance({
+				scratchpadAvailable: true,
+				traceEnabled
+			})}\n\n${description}` : description,
+			inputSchema
+		})) };
+	});
+	server.setRequestHandler(CallToolRequestSchema, async (request, extra) => {
+		const startedAt = Date.now();
+		let tool;
+		let phase = "connect";
+		const report = (failure) => void onToolCall?.({
+			tool: tool?.name ?? "other",
+			via: "mcp",
+			ok: !failure,
+			durationMs: Date.now() - startedAt,
+			agentKind: agentKind(),
+			...failure
+		});
+		try {
+			let client;
+			let tools;
+			try {
+				({client, tools} = await load(extra.signal));
+			} catch (error) {
+				announceCatalog = true;
+				if (request.params.name === instructionsTool.name && !(error instanceof ReviewApiError)) return { content: [{
+					type: "text",
+					text: RECOVERY
+				}] };
+				if (request.params.name === REVIEW_STATUS_TOOL.name && offlineStatus) return { content: [{
+					type: "text",
+					text: JSON.stringify(await offlineStatus(error instanceof Error ? error.message : String(error)))
+				}] };
+				throw error;
+			}
+			phase = "call";
+			tool = tools.find((tool) => tool.name === request.params.name);
+			if (!tool) throw new ReviewInputError(`Unknown Whiteboard tool: ${request.params.name}`);
+			const result = await callPublicTool(client, tool, request.params.arguments ?? {}, extra.signal);
+			const text = toolResultText(tool, result);
+			report();
+			return { content: [{
+				type: "text",
+				text: listedWhileDown && tool.name === instructionsTool.name ? `${RELOAD_TOOLS}\n\n${text}` : text
+			}] };
+		} catch (error) {
+			report(toolFailure(error, phase));
+			return {
+				isError: true,
+				content: [{
+					type: "text",
+					text: error instanceof Error ? error.message : String(error)
+				}]
+			};
+		}
+	});
+	await server.connect(new StdioServerTransport(stdin, stdout));
+	return server;
+}
+//#endregion
+export { serveReviewMcp };

package/dist/package-paths-B6-zxvIO.js

@@ -0,0 +1,47 @@
+import { c as jsonString, o as jsonObject, u as parseJsonText } from "./src-X9phtB2j.js";
+import "./review-home-paths-6zZH-1c9.js";
+import { readFileSync } from "node:fs";
+import path from "node:path";
+import { fileURLToPath } from "node:url";
+//#region ../trace-core/src/package-root.ts
+/** Finds the package containing a source or bundled module URL. */
+function findPackageRoot(moduleUrl) {
+	const currentDir = path.dirname(fileURLToPath(moduleUrl));
+	let candidate = currentDir;
+	while (true) {
+		const directoryName = path.basename(candidate);
+		if (directoryName === "src" || directoryName === "dist") return path.dirname(candidate);
+		const parent = path.dirname(candidate);
+		if (parent === candidate) return currentDir;
+		candidate = parent;
+	}
+}
+//#endregion
+//#region src/package-paths.ts
+function findReviewPackageRoot(moduleUrl = import.meta.url) {
+	return findPackageRoot(moduleUrl);
+}
+function readReviewPackageVersion(moduleUrl = import.meta.url) {
+	try {
+		const packageJson = jsonObject(parseJsonText(readFileSync(path.join(findReviewPackageRoot(moduleUrl), "package.json"), "utf8")));
+		return jsonString(packageJson?.version) ?? "unknown";
+	} catch {
+		return "unknown";
+	}
+}
+/** `build-info.json` in a built package's `dist`, when present. */
+function readBuildInfo(distDirectory) {
+	try {
+		return jsonObject(parseJsonText(readFileSync(path.join(distDirectory, "build-info.json"), "utf8")));
+	} catch {
+		return;
+	}
+}
+/** The build's commit; null from source, where an old `dist` may linger. */
+function readBuildCommit(moduleUrl) {
+	const dist = path.join(findReviewPackageRoot(moduleUrl), "dist");
+	if (!fileURLToPath(moduleUrl).startsWith(`${dist}${path.sep}`)) return null;
+	return jsonString(readBuildInfo(dist)?.commit) ?? null;
+}
+//#endregion
+export { readReviewPackageVersion as i, readBuildCommit as n, readBuildInfo as r, findReviewPackageRoot as t };