rollipop 1.0.0-alpha.21 → 1.0.0-alpha.23

package/dist/server/mcp/tools/index.js

@@ -0,0 +1,277 @@
+import { resetCache } from "../../../utils/reset-cache.js";
+import { getBaseBundleName } from "../../../utils/bundle.js";
+import { parseUrl } from "../../../utils/url.js";
+import { toSSEEvent } from "../../sse/adapter.js";
+import { symbolicate } from "../../symbolicate.js";
+import { getBuildInfo } from "./build-info.js";
+import { CallToolRequestSchema, ErrorCode, ListToolsRequestSchema, McpError } from "@modelcontextprotocol/sdk/types.js";
+import { type } from "arktype";
+//#region src/server/mcp/tools/index.ts
+const emptyArgs = type({});
+const durationArgs = type({ duration: "number >= 1000 & number <= 60000 = 10000" });
+const bundlerIdArgs = type({ bundlerId: "string" });
+const limitBundlerArgs = type({
+	limit: "number >= 1 & number <= 500 = 100",
+	"bundlerId?": "string"
+});
+const optionalBundlerIdArgs = type({ "bundlerId?": "string" });
+const symbolicateStackArgs = type({
+	stack: "unknown[]",
+	"bundleUrl?": "string",
+	"bundleName?": "string",
+	"platform?": "string",
+	"dev?": "boolean"
+});
+function registerTools(server, options) {
+	const { context, appLogDiagnostics, buildDiagnostics, deviceDiagnostics } = options;
+	const tools = [
+		defineTool({
+			name: "reset_cache",
+			title: "Reset Cache",
+			description: "Clear the build cache.",
+			inputSchema: emptyArgs,
+			async handler() {
+				resetCache(context.config.root);
+				context.eventBus.emit({ type: "cache_reset" });
+				return textResult("Cache cleared successfully.");
+			}
+		}),
+		defineTool({
+			name: "get_build_events",
+			title: "Get Build Events",
+			description: "Collect dev-server events for a duration.",
+			inputSchema: durationArgs,
+			async handler({ duration }) {
+				const events = [];
+				const unsubscribe = context.eventBus.subscribe((event) => {
+					const sseEvent = toSSEEvent(event);
+					if (sseEvent != null) events.push(sseEvent);
+				});
+				await new Promise((resolve) => setTimeout(resolve, duration));
+				unsubscribe();
+				if (events.length === 0) return textResult("No events received during the listening period.");
+				return jsonResult(events);
+			}
+		}),
+		defineTool({
+			name: "get_bundler_status",
+			title: "Get Bundler Status",
+			description: "Return a bundler status by id.",
+			inputSchema: bundlerIdArgs,
+			async handler({ bundlerId }) {
+				const bundler = context.bundlerPool.getInstanceById(bundlerId);
+				if (bundler == null) return jsonResult({ error: "not found" });
+				return jsonResult({
+					id: bundler.id,
+					status: bundler.status
+				});
+			}
+		}),
+		defineTool({
+			name: "build_logs",
+			title: "Build Logs",
+			description: "Return buffered Rolldown logs.",
+			inputSchema: limitBundlerArgs,
+			async handler({ limit, bundlerId }) {
+				return jsonResult(buildDiagnostics.getBuildLogs({
+					limit,
+					bundlerId
+				}));
+			}
+		}),
+		defineTool({
+			name: "build_errors",
+			title: "Build Errors",
+			description: "Return buffered Rolldown errors.",
+			inputSchema: limitBundlerArgs,
+			async handler({ limit, bundlerId }) {
+				return jsonResult(buildDiagnostics.getBuildErrors({
+					limit,
+					bundlerId
+				}));
+			}
+		}),
+		defineTool({
+			name: "clear_build_logs",
+			title: "Clear Build Logs",
+			description: "Clear buffered Rolldown logs.",
+			inputSchema: optionalBundlerIdArgs,
+			async handler({ bundlerId }) {
+				buildDiagnostics.clearBuildLogs({ bundlerId });
+				return jsonResult({ cleared: true });
+			}
+		}),
+		defineTool({
+			name: "clear_build_errors",
+			title: "Clear Build Errors",
+			description: "Clear buffered Rolldown errors.",
+			inputSchema: optionalBundlerIdArgs,
+			async handler({ bundlerId }) {
+				buildDiagnostics.clearBuildErrors({ bundlerId });
+				return jsonResult({ cleared: true });
+			}
+		}),
+		defineTool({
+			name: "clear_build_diagnostics",
+			title: "Clear Build Diagnostics",
+			description: "Clear buffered Rolldown diagnostics.",
+			inputSchema: optionalBundlerIdArgs,
+			async handler({ bundlerId }) {
+				buildDiagnostics.clearBuildDiagnostics({ bundlerId });
+				return jsonResult({ cleared: true });
+			}
+		}),
+		defineTool({
+			name: "get_console_logs",
+			title: "Get Console Logs",
+			description: "Return buffered app logs.",
+			inputSchema: limitBundlerArgs,
+			async handler({ limit, bundlerId }) {
+				return jsonResult(appLogDiagnostics.getConsoleLogs({
+					limit,
+					bundlerId
+				}));
+			}
+		}),
+		defineTool({
+			name: "clear_console_logs",
+			title: "Clear Console Logs",
+			description: "Clear buffered app logs.",
+			inputSchema: optionalBundlerIdArgs,
+			async handler({ bundlerId }) {
+				appLogDiagnostics.clearConsoleLogs({ bundlerId });
+				return jsonResult({ cleared: true });
+			}
+		}),
+		defineTool({
+			name: "list_devices",
+			title: "List Devices",
+			description: "Return known HMR clients.",
+			inputSchema: emptyArgs,
+			async handler() {
+				return jsonResult(deviceDiagnostics.getDevices());
+			}
+		}),
+		defineTool({
+			name: "reload",
+			title: "Reload App",
+			description: "Reload connected apps.",
+			inputSchema: emptyArgs,
+			async handler() {
+				context.message.broadcast("reload");
+				return jsonResult({
+					reloaded: true,
+					devices: deviceDiagnostics.getDevices()
+				});
+			}
+		}),
+		defineTool({
+			name: "get_build_info",
+			title: "Get Build Info",
+			description: "Return Rollipop build config.",
+			inputSchema: optionalBundlerIdArgs,
+			async handler({ bundlerId }) {
+				const bundler = bundlerId != null ? context.bundlerPool.getInstanceById(bundlerId) : void 0;
+				return jsonResult({
+					...getBuildInfo(context.config),
+					bundler: bundler != null ? {
+						id: bundler.id,
+						status: bundler.status
+					} : void 0
+				});
+			}
+		}),
+		defineTool({
+			name: "symbolicate_stack",
+			title: "Symbolicate Stack",
+			description: "Symbolicate React Native stack frames.",
+			inputSchema: symbolicateStackArgs,
+			async handler({ stack, bundleUrl, bundleName, platform, dev }) {
+				const buildOptions = resolveSymbolicateBuildOptions(stack, {
+					bundleUrl,
+					bundleName,
+					platform,
+					dev
+				});
+				return jsonResult(await symbolicate(await context.bundlerPool.get(buildOptions.bundleName, buildOptions).getBundle(), stack));
+			}
+		})
+	];
+	const toolsByName = new Map(tools.map((tool) => [tool.name, tool]));
+	server.server.registerCapabilities({ tools: { listChanged: true } });
+	server.server.setRequestHandler(ListToolsRequestSchema, () => ({ tools: tools.map((tool) => ({
+		name: tool.name,
+		title: tool.title,
+		description: tool.description,
+		inputSchema: toMcpInputSchema(tool.inputSchema)
+	})) }));
+	server.server.setRequestHandler(CallToolRequestSchema, async (request) => {
+		try {
+			const tool = toolsByName.get(request.params.name);
+			if (tool == null) throw new McpError(ErrorCode.InvalidParams, `Tool ${request.params.name} not found`);
+			const args = parseToolArgs(tool.inputSchema, request.params.arguments ?? {});
+			return await tool.handler(args);
+		} catch (error) {
+			return errorResult(error instanceof Error ? error.message : String(error));
+		}
+	});
+}
+function defineTool(definition) {
+	return definition;
+}
+function parseToolArgs(schema, args) {
+	const result = schema(args);
+	if (isArkErrors(result)) throw new McpError(ErrorCode.InvalidParams, result.summary);
+	return result;
+}
+function isArkErrors(value) {
+	return typeof value === "object" && value != null && " arkKind" in value && value[" arkKind"] === "errors";
+}
+function toMcpInputSchema(schema) {
+	const { $schema: _schema, type: _type, ...jsonSchema } = schema.toJsonSchema();
+	return {
+		type: "object",
+		...jsonSchema
+	};
+}
+function textResult(text) {
+	return { content: [{
+		type: "text",
+		text
+	}] };
+}
+function errorResult(text) {
+	return {
+		content: [{
+			type: "text",
+			text
+		}],
+		isError: true
+	};
+}
+function jsonResult(value) {
+	return { content: [{
+		type: "text",
+		text: JSON.stringify(value, null, 2)
+	}] };
+}
+function resolveSymbolicateBuildOptions(stack, options) {
+	const file = options.bundleUrl ?? stack.find((frame) => frame.file?.startsWith("http"))?.file;
+	if (file != null) {
+		const { pathname, query } = parseUrl(file);
+		if (pathname == null || query.platform == null || query.dev == null) throw new Error("Bundle URL must include pathname, platform, and dev query parameters");
+		return {
+			bundleName: getBaseBundleName(pathname),
+			platform: String(query.platform),
+			dev: query.dev === "true"
+		};
+	}
+	if (options.bundleName == null || options.platform == null || options.dev == null) throw new Error("bundleName, platform, and dev are required when stack frames do not include a bundle URL");
+	return {
+		bundleName: options.bundleName,
+		platform: options.platform,
+		dev: options.dev
+	};
+}
+//#endregion
+export { registerTools };

package/dist/server/middlewares/request-logger.js

@@ -0,0 +1,15 @@
+import { isDebugEnabled } from "../../common/env.js";
+import { logger } from "../logger.js";
+import chalk from "chalk";
+//#region src/server/middlewares/request-logger.ts
+const requestLogger = (req, _res, next) => {
+	if (isDebugEnabled()) {
+		logger.trace(chalk.bgBlue(` ${req.method} `), chalk.gray(req.url));
+		Object.entries(req.headers).forEach(([key, value]) => {
+			logger.trace(`${chalk.bold(key)}: ${chalk.gray(value)}`);
+		});
+	}
+	next();
+};
+//#endregion
+export { requestLogger };

package/dist/server/middlewares/serve-assets.js

@@ -0,0 +1,49 @@
+import { DEV_SERVER_ASSET_PATH } from "../constants.js";
+import { resolveAssetPath } from "../../core/assets.js";
+import fs from "node:fs";
+import path from "node:path";
+import fp from "fastify-plugin";
+import { asConst } from "json-schema-to-ts";
+import mime from "mime";
+//#region src/server/middlewares/serve-assets.ts
+const queryParamSchema = asConst({
+	type: "object",
+	properties: {
+		platform: { type: "string" },
+		hash: { type: "string" }
+	},
+	required: ["platform"]
+});
+const plugin = fp((fastify, options) => {
+	const { context } = options;
+	const { host, port, https } = context.options;
+	const baseUrl = https ? `https://${host}:${port}` : `http://${host}:${port}`;
+	function resolveAsset(asset) {
+		return path.resolve(context.config.root, asset);
+	}
+	fastify.get(`/${DEV_SERVER_ASSET_PATH}/*`, {
+		schema: { querystring: queryParamSchema },
+		async handler(request, reply) {
+			const { url, query } = request;
+			const { pathname } = new URL(url, baseUrl);
+			const assetPath = resolveAsset(pathname.replace(new RegExp(`^/${DEV_SERVER_ASSET_PATH}/?`), ""));
+			let handle = null;
+			try {
+				handle = await fs.promises.open(resolveAssetPath(assetPath, {
+					platform: query.platform,
+					preferNativePlatform: context.config.resolver.preferNativePlatform
+				}, 1), "r");
+				const assetData = await handle.readFile();
+				const { size } = await handle.stat();
+				await reply.header("Content-Type", mime.getType(assetPath) ?? "").header("Content-Length", size).send(assetData);
+			} catch (error) {
+				fastify.log.error(error, "Failed to serve asset (scale assets resolving is not implemented yet)");
+				await reply.status(500).send();
+			} finally {
+				await handle?.close();
+			}
+		}
+	});
+}, { name: "serve-assets" });
+//#endregion
+export { plugin };

package/dist/server/middlewares/serve-bundle.js

@@ -0,0 +1,72 @@
+import { BundleResponse } from "../../utils/response.js";
+import { bundleRequestSchema } from "../common/schema.js";
+import { isBundlerEventForId } from "../events/types.js";
+import { invariant } from "es-toolkit";
+import fp from "fastify-plugin";
+import { asConst } from "json-schema-to-ts";
+//#region src/server/middlewares/serve-bundle.ts
+const routeParamSchema = asConst({
+	type: "object",
+	properties: { name: { type: "string" } }
+});
+function withGetBundleErrorHandler(reply, task) {
+	return task.catch((error) => {
+		return reply.status(500).send(error instanceof Error ? error.message : "Internal Server Error");
+	});
+}
+const plugin = fp((fastify, options) => {
+	const { context } = options;
+	const getBundleOptions = (buildOptions) => {
+		return {
+			platform: buildOptions.platform,
+			dev: buildOptions.dev,
+			minify: buildOptions.minify,
+			sourcemap: buildOptions.inlineSourceMap ? "inline" : true
+		};
+	};
+	fastify.get("/:name.bundle", {
+		schema: {
+			params: routeParamSchema,
+			querystring: bundleRequestSchema
+		},
+		async handler(request, reply) {
+			const { params, query, headers: { accept } } = request;
+			if (!params.name) {
+				await reply.status(400).send("invalid bundle name");
+				return;
+			}
+			const buildOptions = getBundleOptions(query);
+			const bundler = context.bundlerPool.get(params.name, buildOptions);
+			if (accept?.includes("multipart/mixed") ?? false) {
+				const bundleResponse = new BundleResponse(reply);
+				const unsubscribe = context.eventBus.subscribe((event) => {
+					if (isBundlerEventForId(event, bundler.id) && event.type === "transform") bundleResponse.writeBundleState(event.transformedModules, event.totalModules ?? 0);
+				});
+				await bundler.getBundle().then((bundle) => bundleResponse.endWithBundle(bundle.code)).catch((error) => bundleResponse.endWithError(error)).finally(unsubscribe);
+			} else {
+				this.log.debug(`client is not support multipart/mixed content: ${accept ?? "<empty>"}`);
+				const code = (await withGetBundleErrorHandler(reply, bundler.getBundle())).code;
+				await reply.header("Content-Type", "application/javascript").header("Content-Length", Buffer.byteLength(code)).status(200).send(code);
+			}
+		}
+	});
+	fastify.get("/:name.map", {
+		schema: {
+			params: routeParamSchema,
+			querystring: bundleRequestSchema
+		},
+		async handler(request, reply) {
+			const { params, query } = request;
+			if (!params.name) {
+				await reply.status(400).send("invalid bundle name");
+				return;
+			}
+			const buildOptions = getBundleOptions(query);
+			const sourceMap = (await withGetBundleErrorHandler(reply, context.bundlerPool.get(params.name, buildOptions).getBundle())).sourceMap;
+			invariant(sourceMap, "Source map is not available");
+			await reply.header("Access-Control-Allow-Origin", "devtools://devtools").header("Content-Type", "application/json").header("Content-Length", Buffer.byteLength(sourceMap)).status(200).send(sourceMap);
+		}
+	});
+}, { name: "serve-bundle" });
+//#endregion
+export { plugin };

package/dist/server/middlewares/sse.js

@@ -0,0 +1,34 @@
+import { toSSEClientLogEvent, toSSEEvent } from "../sse/adapter.js";
+import { SSEEventPublisher } from "../sse/event-bus.js";
+import fp from "fastify-plugin";
+//#region src/server/middlewares/sse.ts
+const plugin = fp((fastify, options) => {
+	const { context } = options;
+	const publisher = new SSEEventPublisher();
+	const clientLogPublisher = new SSEEventPublisher();
+	context.eventBus.subscribe((event) => {
+		const sseEvent = toSSEEvent(event);
+		if (sseEvent != null) publisher.publish(sseEvent);
+		const clientLogEvent = toSSEClientLogEvent(event);
+		if (clientLogEvent != null) clientLogPublisher.publish(clientLogEvent);
+	});
+	const registerStream = (path, streamPublisher) => {
+		fastify.get(path, (request, reply) => {
+			const res = reply.raw;
+			res.writeHead(200, {
+				Connection: "keep-alive",
+				"Content-Type": "text/event-stream",
+				"Cache-Control": "no-cache",
+				"X-Accel-Buffering": "no"
+			});
+			request.raw.socket.setNoDelay(true);
+			res.write(":ok\n\n");
+			streamPublisher.addClient(res);
+			request.raw.on("close", () => streamPublisher.removeClient(res));
+		});
+	};
+	registerStream("/sse/events", publisher);
+	registerStream("/sse/client-logs", clientLogPublisher);
+}, { name: "sse" });
+//#endregion
+export { plugin };

package/dist/server/middlewares/symbolicate.js

@@ -0,0 +1,71 @@
+import { isDebugEnabled } from "../../common/env.js";
+import { getBaseBundleName } from "../../utils/bundle.js";
+import { parseUrl } from "../../utils/url.js";
+import { symbolicate } from "../symbolicate.js";
+import { invariant } from "es-toolkit";
+import chalk from "chalk";
+import fp from "fastify-plugin";
+import { asConst } from "json-schema-to-ts";
+//#region src/server/middlewares/symbolicate.ts
+const bodySchema = asConst({
+	type: "object",
+	properties: {
+		stack: {
+			type: "array",
+			items: {}
+		},
+		extraData: {}
+	},
+	required: ["stack"]
+});
+const plugin = fp((fastify, options) => {
+	const { context } = options;
+	fastify.post("/symbolicate", {
+		schema: { body: bodySchema },
+		async handler(request, reply) {
+			const { stack } = request.body;
+			const bundleUrl = stack.find((frame) => frame.file?.startsWith("http"));
+			invariant(bundleUrl?.file, "No bundle URL found in stack frames");
+			const { pathname, query } = parseUrl(bundleUrl.file);
+			invariant(pathname, "No pathname found in bundle URL");
+			invariant(query.platform, "No platform found in query");
+			invariant(query.dev, "No dev found in query");
+			const platform = query.platform;
+			const dev = query.dev === "true";
+			const bundleName = getBaseBundleName(pathname);
+			const symbolicateResult = await symbolicate(await context.bundlerPool.get(bundleName, {
+				platform,
+				dev
+			}).getBundle(), stack);
+			if (isDebugEnabled()) printSymbolicateResult(stack, symbolicateResult);
+			await reply.header("Content-Type", "application/json").send(symbolicateResult);
+		}
+	});
+}, { name: "symbolicate" });
+function printSymbolicateResult(rawStackFrame, symbolicateResult) {
+	console.log();
+	console.log("Symbolicate result:");
+	console.log();
+	if (symbolicateResult.codeFrame != null) {
+		console.log(symbolicateResult.codeFrame.content);
+		console.log();
+	}
+	console.log("Stack trace:");
+	symbolicateResult.stack.forEach((stackFrame) => {
+		const symbol = stackFrame.methodName ?? "<anonymous>";
+		const file = stackFrame.file ?? "unknown";
+		const location = stackFrame.lineNumber != null && stackFrame.column != null ? `(${chalk.gray.underline(`${file}:${stackFrame.lineNumber}:${stackFrame.column}`)})` : "";
+		console.log(`  at ${symbol} ${location}`);
+	});
+	console.log();
+	console.log("Raw stack trace:");
+	rawStackFrame.filter((stackFrame) => stackFrame.file?.startsWith("http")).forEach((stackFrame) => {
+		const bundleName = new URL(stackFrame.file).pathname.slice(1);
+		const symbol = stackFrame.methodName ?? "<anonymous>";
+		const location = stackFrame.lineNumber != null && stackFrame.column != null ? `(${chalk.gray.underline(`${bundleName}:${stackFrame.lineNumber}:${stackFrame.column}`)})` : "";
+		console.log(`  at ${symbol} ${location}`);
+	});
+	console.log();
+}
+//#endregion
+export { plugin };

package/dist/server/sse/adapter.js

@@ -0,0 +1,74 @@
+import stripAnsi from "strip-ansi";
+//#region src/server/sse/adapter.ts
+function toSSEEvent(event) {
+	switch (event.type) {
+		case "client_log": return null;
+		case "device_connected": return {
+			type: "device_connected",
+			clientId: event.client.id
+		};
+		case "device_disconnected": return {
+			type: "device_disconnected",
+			clientId: event.client.id
+		};
+		case "server_ready":
+		case "cache_reset": return event;
+		case "bundle_build_started":
+		case "bundle_build_done":
+		case "bundle_build_failed":
+		case "hmr_failed":
+		case "watch_change": return reporterEventToSSEEvent(event);
+		case "hmr_updates":
+		case "device_message":
+		case "device_error":
+		case "transform":
+		case "build_log":
+		case "build_error": return null;
+	}
+}
+function toSSEClientLogEvent(event) {
+	if (event.type !== "client_log") return null;
+	return {
+		type: "client_log",
+		...event.bundlerId != null ? { bundlerId: event.bundlerId } : {},
+		data: event.data
+	};
+}
+function reporterEventToSSEEvent(event) {
+	switch (event.type) {
+		case "bundle_build_started": return {
+			type: "bundle_build_started",
+			bundlerId: event.bundlerId
+		};
+		case "bundle_build_done": return {
+			type: "bundle_build_done",
+			bundlerId: event.bundlerId,
+			totalModules: event.totalModules,
+			transformedModules: event.transformedModules,
+			cacheHitModules: event.cacheHitModules,
+			duration: event.duration,
+			...event.bundleFilePath != null ? { bundleFilePath: event.bundleFilePath } : {}
+		};
+		case "bundle_build_failed": return {
+			type: "bundle_build_failed",
+			bundlerId: event.bundlerId,
+			error: stripAnsi(event.error.message)
+		};
+		case "hmr_failed": return {
+			type: "hmr_failed",
+			bundlerId: event.bundlerId,
+			error: stripAnsi(event.error.message)
+		};
+		case "watch_change": return {
+			type: "watch_change",
+			bundlerId: event.bundlerId,
+			file: event.id
+		};
+		case "client_log":
+		case "transform":
+		case "build_log":
+		case "build_error": return null;
+	}
+}
+//#endregion
+export { toSSEClientLogEvent, toSSEEvent };

package/dist/server/sse/event-bus.js

@@ -0,0 +1,26 @@
+//#region src/server/sse/event-bus.ts
+var SSEEventPublisher = class {
+	clients = /* @__PURE__ */ new Set();
+	publish(event) {
+		const data = JSON.stringify(event);
+		const message = `event: ${event.type}\ndata: ${data}\n\n`;
+		for (const client of this.clients) if (!client.closed) client.write(message);
+	}
+	/**
+	* Subscribe an SSE HTTP response client.
+	*/
+	addClient(res) {
+		this.clients.add(res);
+	}
+	/**
+	* Unsubscribe an SSE HTTP response client.
+	*/
+	removeClient(res) {
+		this.clients.delete(res);
+	}
+	get clientCount() {
+		return this.clients.size;
+	}
+};
+//#endregion
+export { SSEEventPublisher };