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

package/dist/server/create-dev-server.js

@@ -0,0 +1,185 @@
+import { createPluginContext } from "../core/plugins/context.js";
+import { DevServerLogger, logger } from "./logger.js";
+import { assertDevServerStatus } from "../utils/dev-server.js";
+import { BundlerPool } from "./bundler-pool.js";
+import { DEFAULT_HOST, DEFAULT_PORT } from "./constants.js";
+import { errorHandler } from "./error.js";
+import { ServerEventBus } from "./events/event-bus.js";
+import { toSSEEvent } from "./sse/adapter.js";
+import { plugin } from "./mcp/server.js";
+import { requestLogger } from "./middlewares/request-logger.js";
+import { plugin as plugin$1 } from "./middlewares/serve-assets.js";
+import { plugin as plugin$2 } from "./middlewares/serve-bundle.js";
+import { SSEEventPublisher } from "./sse/event-bus.js";
+import { plugin as plugin$3 } from "./middlewares/sse.js";
+import { plugin as plugin$4 } from "./middlewares/symbolicate.js";
+import { getWebSocketUpgradeHandler } from "./wss/server.js";
+import { HMRServer } from "./wss/hmr-server.js";
+import url from "url";
+import { createDevServerMiddleware } from "@react-native-community/cli-server-api";
+import { createDevMiddleware } from "@react-native/dev-middleware";
+import Fastify from "fastify";
+import mitt from "mitt";
+//#region src/server/create-dev-server.ts
+async function createDevServer(config, options) {
+	const projectRoot = config.root;
+	const { port = DEFAULT_PORT, host = DEFAULT_HOST, https = false } = options ?? {};
+	if (https) throw new Error("HTTPS is not supported yet");
+	const serverBaseUrl = url.format({
+		protocol: https ? "https" : "http",
+		hostname: host,
+		port
+	});
+	await assertDevServerStatus({
+		devServerUrl: serverBaseUrl,
+		projectRoot,
+		port
+	});
+	const emitter = mitt();
+	const fastify = Fastify({
+		loggerInstance: new DevServerLogger(),
+		disableRequestLogging: true
+	});
+	const eventBus = new ServerEventBus();
+	const bundlerPool = new BundlerPool(config, {
+		host,
+		port
+	}, eventBus);
+	const ssePublisher = new SSEEventPublisher();
+	const reporter = config.reporter;
+	eventBus.subscribe((event) => {
+		const sseEvent = toSSEEvent(event);
+		if (sseEvent != null) ssePublisher.publish(sseEvent);
+	});
+	const { middleware: communityMiddleware, websocketEndpoints: communityWebsocketEndpoints, messageSocketEndpoint: { server: messageServer, broadcast }, eventsSocketEndpoint: { server: eventsServer, reportEvent } } = createDevServerMiddleware({
+		port,
+		host,
+		watchFolders: []
+	});
+	eventBus.subscribe((event) => {
+		switch (event.type) {
+			case "bundle_build_started":
+			case "bundle_build_done":
+			case "bundle_build_failed":
+			case "hmr_failed":
+			case "build_log":
+			case "build_error":
+			case "transform":
+			case "watch_change":
+				reporter?.update(event);
+				break;
+			case "client_log":
+				reportEvent?.(event);
+				reporter?.update(event);
+				break;
+			case "device_connected":
+				emitter.emit("device.connected", { client: event.client });
+				break;
+			case "device_message":
+				emitter.emit("device.message", {
+					client: event.client,
+					data: event.data
+				});
+				break;
+			case "device_error":
+				emitter.emit("device.error", {
+					client: event.client,
+					error: event.error
+				});
+				break;
+			case "device_disconnected":
+				emitter.emit("device.disconnected", { client: event.client });
+				break;
+		}
+	});
+	const { middleware: devMiddleware, websocketEndpoints } = createDevMiddleware({
+		serverBaseUrl,
+		logger: {
+			info(...args) {
+				if (args[0].includes("JavaScript logs have moved")) return;
+				logger.info(...args);
+			},
+			warn: logger.warn.bind(logger),
+			error: logger.error.bind(logger)
+		},
+		unstable_experiments: {
+			enableNetworkInspector: true,
+			enableStandaloneFuseboxShell: true
+		}
+	});
+	const hmrServer = new HMRServer({
+		bundlerPool,
+		eventBus
+	}).on("connection", (client) => eventBus.emit({
+		type: "device_connected",
+		client
+	})).on("message", (client, data) => eventBus.emit({
+		type: "device_message",
+		client,
+		data
+	})).on("error", (client, error) => eventBus.emit({
+		type: "device_error",
+		client,
+		error
+	})).on("close", (client) => eventBus.emit({
+		type: "device_disconnected",
+		client
+	}));
+	await fastify.register(import("@fastify/middie"));
+	const context = {
+		serverBaseUrl,
+		config: Object.freeze(config),
+		options: Object.freeze(options ?? {}),
+		bundlerPool,
+		eventBus,
+		message: Object.assign(messageServer, { broadcast }),
+		events: Object.assign(eventsServer, { reportEvent }),
+		hot: Object.assign(hmrServer.server, {
+			send: (client, eventName, payload) => {
+				hmrServer.send(client, JSON.stringify({
+					type: eventName,
+					payload
+				}));
+			},
+			sendAll: (eventName, payload) => {
+				hmrServer.sendAll(JSON.stringify({
+					type: eventName,
+					payload
+				}));
+			}
+		})
+	};
+	const devServer = {
+		...context,
+		...emitter,
+		instance: fastify,
+		middlewares: { use: fastify.use.bind(fastify) }
+	};
+	const { invokePostConfigureServer } = await invokeConfigureServer(devServer, config.plugins ?? []);
+	fastify.use(requestLogger).use(communityMiddleware).use(devMiddleware).register(plugin$4, { context }).register(plugin$2, { context }).register(plugin$1, { context }).register(plugin$3, { context }).register(plugin, { context }).setErrorHandler(errorHandler);
+	fastify.server.on("upgrade", getWebSocketUpgradeHandler({
+		...communityWebsocketEndpoints,
+		...websocketEndpoints,
+		"/hot": hmrServer.server
+	}));
+	await invokePostConfigureServer();
+	eventBus.emit({
+		type: "server_ready",
+		host,
+		port
+	});
+	return devServer;
+}
+async function invokeConfigureServer(server, plugins) {
+	const postConfigureServerHandlers = [];
+	for (const plugin of plugins) {
+		const context = createPluginContext(plugin.name);
+		const result = await plugin.configureServer?.call(context, server);
+		if (typeof result === "function") postConfigureServerHandlers.push(result);
+	}
+	return { invokePostConfigureServer: async () => {
+		for (const handler of postConfigureServerHandlers) await handler();
+	} };
+}
+//#endregion
+export { createDevServer };

package/dist/server/error.js

@@ -0,0 +1,9 @@
+import { logger } from "./logger.js";
+//#region src/server/error.ts
+function errorHandler(error, request, reply) {
+	logger.error(`An error occurred while processing the request (${request.method} ${request.url}):`, error.message);
+	logger.debug(error);
+	reply.status(500).send("Internal Server Error");
+}
+//#endregion
+export { errorHandler };

package/dist/server/events/event-bus.d.ts

@@ -0,0 +1,12 @@
+import { ServerEvent } from "./types.js";
+
+//#region src/server/events/event-bus.d.ts
+type EventListener<Event> = (event: Event) => void;
+declare class EventBus<Event> {
+  private listeners;
+  emit(event: Event): void;
+  subscribe(listener: EventListener<Event>): () => void;
+}
+declare class ServerEventBus extends EventBus<ServerEvent> {}
+//#endregion
+export { ServerEventBus };

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

@@ -0,0 +1,16 @@
+//#region src/server/events/event-bus.ts
+var EventBus = class {
+	listeners = /* @__PURE__ */ new Set();
+	emit(event) {
+		for (const listener of this.listeners) listener(event);
+	}
+	subscribe(listener) {
+		this.listeners.add(listener);
+		return () => {
+			this.listeners.delete(listener);
+		};
+	}
+};
+var ServerEventBus = class extends EventBus {};
+//#endregion
+export { ServerEventBus };

package/dist/server/events/types.d.ts

@@ -0,0 +1,37 @@
+import { MetroCompatibleClientLogEvent, ReportableEvent } from "../../types.js";
+import { WebSocketClient } from "../wss/server.js";
+import * as rolldownExperimental from "@rollipop/rolldown/experimental";
+import * as ws from "ws";
+
+//#region src/server/events/types.d.ts
+type IdentifiedReportableEvent = ReportableEvent & {
+  bundlerId: string;
+};
+type BundlerEvent = IdentifiedReportableEvent | {
+  type: 'hmr_updates';
+  bundlerId: string;
+  updates: rolldownExperimental.BindingClientHmrUpdate[];
+};
+type ServerEvent = BundlerEvent | MetroCompatibleClientLogEvent | {
+  type: 'device_connected';
+  client: WebSocketClient;
+} | {
+  type: 'device_message';
+  client: WebSocketClient;
+  data: ws.RawData;
+} | {
+  type: 'device_error';
+  client: WebSocketClient;
+  error: Error;
+} | {
+  type: 'device_disconnected';
+  client: WebSocketClient;
+} | {
+  type: 'server_ready';
+  host: string;
+  port: number;
+} | {
+  type: 'cache_reset';
+};
+//#endregion
+export { ServerEvent };

package/dist/server/events/types.js

@@ -0,0 +1,6 @@
+//#region src/server/events/types.ts
+function isBundlerEventForId(event, bundlerId) {
+	return "bundlerId" in event && event.bundlerId === bundlerId;
+}
+//#endregion
+export { isBundlerEventForId };

package/dist/server/index.d.ts

@@ -0,0 +1,3 @@
+import { BundleDetails, DevServer, DevServerContext, DevServerEvents, FastifyInstance, FormattedError, Middlewares, ServerOptions } from "./types.js";
+import { createDevServer } from "./create-dev-server.js";
+import { DEFAULT_HOST, DEFAULT_PORT, DEV_SERVER_ASSET_PATH } from "./constants.js";

package/dist/server/index.js

@@ -0,0 +1,3 @@
+import "./constants.js";
+import "./create-dev-server.js";
+export {};

package/dist/server/logger.js

@@ -0,0 +1,33 @@
+import { Logger } from "../common/logger.js";
+import chalk from "chalk";
+//#region src/server/logger.ts
+const logger = new Logger("dev-server");
+var DevServerLogger = class {
+	level = "trace";
+	trace(...args) {
+		logger.trace(...args);
+	}
+	debug(...args) {
+		logger.debug(...args);
+	}
+	info(...args) {
+		logger.info(...args);
+	}
+	warn(...args) {
+		logger.warn(...args);
+	}
+	error(...args) {
+		logger.error(...args);
+	}
+	silent(...args) {
+		logger.trace(chalk.gray("(silent)"), ...args);
+	}
+	fatal(...args) {
+		logger.error(chalk.magenta("(fatal)"), ...args);
+	}
+	child(_bindings) {
+		return this;
+	}
+};
+//#endregion
+export { DevServerLogger, logger };

package/dist/server/mcp/context.js

@@ -0,0 +1,14 @@
+import { AppLogDiagnostics } from "./tools/app-log-diagnostics.js";
+import { BuildDiagnostics } from "./tools/build-diagnostics.js";
+import { DeviceDiagnostics } from "./tools/device-diagnostics.js";
+//#region src/server/mcp/context.ts
+function createMcpToolContext(context) {
+	return {
+		context,
+		appLogDiagnostics: new AppLogDiagnostics(context),
+		buildDiagnostics: new BuildDiagnostics(context),
+		deviceDiagnostics: new DeviceDiagnostics(context)
+	};
+}
+//#endregion
+export { createMcpToolContext };

package/dist/server/mcp/server.js

@@ -0,0 +1,86 @@
+import { createMcpToolContext } from "./context.js";
+import { registerTools } from "./tools/index.js";
+import { randomUUID } from "node:crypto";
+import { McpServer } from "@modelcontextprotocol/sdk/server/mcp.js";
+import { StreamableHTTPServerTransport } from "@modelcontextprotocol/sdk/server/streamableHttp.js";
+import { isInitializeRequest } from "@modelcontextprotocol/sdk/types.js";
+import fp from "fastify-plugin";
+//#region src/server/mcp/server.ts
+function createMcpServer(options) {
+	const server = new McpServer({
+		name: "rollipop",
+		version: "1.0.0-alpha.23"
+	}, { capabilities: { logging: {} } });
+	registerTools(server, options);
+	return server;
+}
+const plugin = fp((fastify, options) => {
+	const { context } = options;
+	if (context.options.mcp !== true) {
+		fastify.all("/mcp", async (_request, reply) => {
+			return reply.status(503).send({ error: {
+				code: "MCP_DISABLED",
+				message: "MCP server is disabled. Start Rollipop with --mcp to enable it."
+			} });
+		});
+		return;
+	}
+	const toolContext = createMcpToolContext(context);
+	const sessions = /* @__PURE__ */ new Map();
+	fastify.addContentTypeParser("application/json", { parseAs: "string" }, (_req, body, done) => {
+		try {
+			done(null, JSON.parse(body));
+		} catch (error) {
+			done(error, void 0);
+		}
+	});
+	fastify.post("/mcp", async (request, reply) => {
+		const sessionId = request.headers["mcp-session-id"];
+		if (sessionId && sessions.has(sessionId)) {
+			const { transport } = sessions.get(sessionId);
+			await transport.handleRequest(request.raw, reply.raw, request.body);
+			return reply;
+		}
+		if (!sessionId && isInitializeRequest(request.body)) {
+			const transport = new StreamableHTTPServerTransport({
+				sessionIdGenerator: () => randomUUID(),
+				onsessioninitialized: (sid) => {
+					sessions.set(sid, {
+						transport,
+						server
+					});
+				}
+			});
+			transport.onclose = () => {
+				const sid = transport.sessionId;
+				if (sid) sessions.delete(sid);
+			};
+			const server = createMcpServer(toolContext);
+			await server.connect(transport);
+			await transport.handleRequest(request.raw, reply.raw, request.body);
+			return reply;
+		}
+		return reply.status(400).send({
+			jsonrpc: "2.0",
+			error: {
+				code: -32e3,
+				message: "Bad Request: invalid or missing session"
+			},
+			id: null
+		});
+	});
+	fastify.get("/mcp", async (request, reply) => {
+		const sessionId = request.headers["mcp-session-id"];
+		if (!sessionId || !sessions.has(sessionId)) return reply.status(400).send("Missing or invalid session ID");
+		await sessions.get(sessionId).transport.handleRequest(request.raw, reply.raw);
+		return reply;
+	});
+	fastify.delete("/mcp", async (request, reply) => {
+		const sessionId = request.headers["mcp-session-id"];
+		if (!sessionId || !sessions.has(sessionId)) return reply.status(404).send("Session not found");
+		await sessions.get(sessionId).transport.handleRequest(request.raw, reply.raw);
+		return reply;
+	});
+}, { name: "mcp" });
+//#endregion
+export { plugin };

package/dist/server/mcp/tools/app-log-diagnostics.js

@@ -0,0 +1,37 @@
+//#region src/server/mcp/tools/app-log-diagnostics.ts
+const MAX_DIAGNOSTIC_ENTRIES = 500;
+var AppLogDiagnostics = class {
+	logs = [];
+	nextLogId = 0;
+	constructor(context) {
+		context.eventBus.subscribe((event) => {
+			if (event.type !== "client_log") return;
+			this.logs.push({
+				id: ++this.nextLogId,
+				timestamp: (/* @__PURE__ */ new Date()).toISOString(),
+				source: "client_log",
+				level: event.level,
+				args: event.data,
+				...event.bundlerId != null ? { bundlerId: event.bundlerId } : {}
+			});
+			trimArray(this.logs, MAX_DIAGNOSTIC_ENTRIES);
+		});
+	}
+	getConsoleLogs(options) {
+		return filterByBundlerId(this.logs, options?.bundlerId).slice(-(options?.limit ?? 100));
+	}
+	clearConsoleLogs(options) {
+		this.logs = filterOutBundlerId(this.logs, options?.bundlerId);
+	}
+};
+function trimArray(entries, maxEntries) {
+	if (entries.length > maxEntries) entries.splice(0, entries.length - maxEntries);
+}
+function filterByBundlerId(entries, bundlerId) {
+	return bundlerId == null ? entries : entries.filter((entry) => entry.bundlerId === bundlerId);
+}
+function filterOutBundlerId(entries, bundlerId) {
+	return bundlerId == null ? [] : entries.filter((entry) => entry.bundlerId !== bundlerId);
+}
+//#endregion
+export { AppLogDiagnostics };

package/dist/server/mcp/tools/build-diagnostics.js

@@ -0,0 +1,97 @@
+//#region src/server/mcp/tools/build-diagnostics.ts
+const MAX_DIAGNOSTIC_ENTRIES = 500;
+var BuildDiagnostics = class {
+	buildLogs = [];
+	buildErrors = [];
+	nextBuildLogId = 0;
+	nextBuildErrorId = 0;
+	constructor(context) {
+		context.eventBus.subscribe((event) => {
+			switch (event.type) {
+				case "build_log":
+					this.pushBuildLog({
+						source: "rolldown",
+						level: event.level,
+						bundlerId: event.bundlerId,
+						log: event.log
+					});
+					break;
+				case "build_error":
+					this.pushBuildError({
+						source: "rolldown",
+						level: event.level,
+						bundlerId: event.bundlerId,
+						log: event.log
+					});
+					break;
+				case "bundle_build_failed":
+					this.pushBuildError({
+						source: "build",
+						level: "error",
+						bundlerId: event.bundlerId,
+						error: serializeError(event.error)
+					});
+					break;
+				case "hmr_failed":
+					this.pushBuildError({
+						source: "hmr",
+						level: "error",
+						bundlerId: event.bundlerId,
+						error: serializeError(event.error)
+					});
+					break;
+			}
+		});
+	}
+	getBuildLogs(options) {
+		return filterByBundlerId(this.buildLogs, options?.bundlerId).slice(-(options?.limit ?? 100));
+	}
+	getBuildErrors(options) {
+		return filterByBundlerId(this.buildErrors, options?.bundlerId).slice(-(options?.limit ?? 100));
+	}
+	clearBuildLogs(options) {
+		this.buildLogs = filterOutBundlerId(this.buildLogs, options?.bundlerId);
+	}
+	clearBuildErrors(options) {
+		this.buildErrors = filterOutBundlerId(this.buildErrors, options?.bundlerId);
+	}
+	clearBuildDiagnostics(options) {
+		this.clearBuildLogs(options);
+		this.clearBuildErrors(options);
+	}
+	pushBuildLog(log) {
+		this.buildLogs.push({
+			id: ++this.nextBuildLogId,
+			timestamp: (/* @__PURE__ */ new Date()).toISOString(),
+			...log
+		});
+		trimArray(this.buildLogs, MAX_DIAGNOSTIC_ENTRIES);
+	}
+	pushBuildError(error) {
+		this.buildErrors.push({
+			id: ++this.nextBuildErrorId,
+			timestamp: (/* @__PURE__ */ new Date()).toISOString(),
+			...error
+		});
+		trimArray(this.buildErrors, MAX_DIAGNOSTIC_ENTRIES);
+	}
+};
+function serializeError(error) {
+	if (error instanceof Error) return {
+		name: error.name,
+		message: error.message,
+		stack: error.stack
+	};
+	return { message: String(error) };
+}
+function trimArray(entries, maxEntries) {
+	if (entries.length > maxEntries) entries.splice(0, entries.length - maxEntries);
+}
+function filterByBundlerId(entries, bundlerId) {
+	return bundlerId == null ? entries : entries.filter((entry) => entry.bundlerId === bundlerId);
+}
+function filterOutBundlerId(entries, bundlerId) {
+	return bundlerId == null ? [] : entries.filter((entry) => entry.bundlerId !== bundlerId);
+}
+//#endregion
+export { BuildDiagnostics };

package/dist/server/mcp/tools/build-info.js

@@ -0,0 +1,33 @@
+import { loadEnv } from "../../../core/env.js";
+//#region src/server/mcp/tools/build-info.ts
+function getBuildInfo(config) {
+	return toJsonSafe({
+		...config,
+		env: loadEnv(config)
+	});
+}
+function toJsonSafe(value, seen = /* @__PURE__ */ new WeakSet()) {
+	if (value == null) return value;
+	switch (typeof value) {
+		case "string":
+		case "number":
+		case "boolean": return value;
+		case "bigint":
+		case "symbol": return String(value);
+		case "function": return `[Function ${value.name || "anonymous"}]`;
+	}
+	if (value instanceof Date) return value.toISOString();
+	if (value instanceof Error) return {
+		name: value.name,
+		message: value.message,
+		stack: value.stack
+	};
+	if (seen.has(value)) return "[Circular]";
+	seen.add(value);
+	if (Array.isArray(value)) return value.map((item) => toJsonSafe(item, seen));
+	if (value instanceof Map) return Object.fromEntries(Array.from(value.entries()).map(([key, item]) => [String(key), toJsonSafe(item, seen)]));
+	if (value instanceof Set) return Array.from(value.values()).map((item) => toJsonSafe(item, seen));
+	return Object.fromEntries(Object.entries(value).map(([key, item]) => [key, toJsonSafe(item, seen)]));
+}
+//#endregion
+export { getBuildInfo };

package/dist/server/mcp/tools/device-diagnostics.js

@@ -0,0 +1,52 @@
+//#region src/server/mcp/tools/device-diagnostics.ts
+var DeviceDiagnostics = class {
+	devices = /* @__PURE__ */ new Map();
+	constructor(context) {
+		context.eventBus.subscribe((event) => {
+			switch (event.type) {
+				case "device_connected":
+					this.devices.set(event.client.id, {
+						id: event.client.id,
+						connected: true,
+						connectedAt: (/* @__PURE__ */ new Date()).toISOString()
+					});
+					break;
+				case "device_message":
+					this.updateDeviceFromMessage(event.client.id, event.data);
+					break;
+				case "device_disconnected": {
+					const device = this.devices.get(event.client.id);
+					if (device != null) this.devices.set(event.client.id, {
+						...device,
+						connected: false,
+						disconnectedAt: (/* @__PURE__ */ new Date()).toISOString()
+					});
+					break;
+				}
+			}
+		});
+	}
+	getDevices() {
+		return Array.from(this.devices.values());
+	}
+	updateDeviceFromMessage(clientId, data) {
+		const device = this.devices.get(clientId);
+		if (device == null) return;
+		try {
+			const message = JSON.parse(rawDataToString(data));
+			if (message.type !== "hmr:connected") return;
+			this.devices.set(clientId, {
+				...device,
+				platform: message.platform,
+				bundleEntry: message.bundleEntry
+			});
+		} catch {}
+	}
+};
+function rawDataToString(data) {
+	if (Buffer.isBuffer(data)) return data.toString("utf8");
+	if (Array.isArray(data)) return Buffer.concat(data).toString("utf8");
+	return Buffer.from(data).toString("utf8");
+}
+//#endregion
+export { DeviceDiagnostics };