@biomejs/backend-jsonrpc 0.1.0-nightly.54e85a2

package/package.json

@@ -0,0 +1 @@
+{"name":"@biomejs/backend-jsonrpc","version":"0.1.0-nightly.54e85a2","main":"dist/index.js","scripts":{"test":"vitest","test:ci":"pnpm build && vitest --run","tsc":"tsc --noEmit","build":"tsc"},"homepage":"https://biomejs.dev","repository":{"type":"git","url":"https://github.com/biomejs/biome.git","directory":"npm/backend-jsonrpc"},"author":"Rome Tools Developers and Contributors","bugs":"https://github.com/biomejs/biome/issues","description":"Bindings to the JSON-RPC Workspace API of the Rome daemon","keywords":["JavaScript","TypeScript","format","lint","toolchain"],"engines":{"node":">=14.*"},"license":"MIT","devDependencies":{"@types/node":"^18.7.2","typescript":"^4.8.2","vite":"^3.0.8","vitest":"^0.22.0"},"optionalDependencies":{"@biomsjs/cli-win32-x64":"0.1.0-nightly.54e85a2","@biomsjs/cli-win32-arm64":"0.1.0-nightly.54e85a2","@biomsjs/cli-darwin-x64":"0.1.0-nightly.54e85a2","@biomsjs/cli-darwin-arm64":"0.1.0-nightly.54e85a2","@biomsjs/cli-linux-x64":"0.1.0-nightly.54e85a2","@biomsjs/cli-linux-arm64":"0.1.0-nightly.54e85a2"}}

package/src/command.ts

@@ -0,0 +1,36 @@
+/**
+ * Gets the path of the Rome binary for the current platform
+ *
+ * @returns Filesystem path to the binary, or null if no prebuilt distribution exists for the current platform
+ */
+export function getCommand(): string | null {
+	const { platform, arch } = process;
+
+	type PlatformPaths = {
+		[P in NodeJS.Platform]?: {
+			[A in NodeJS.Architecture]?: string;
+		};
+	};
+
+	const PLATFORMS: PlatformPaths = {
+		win32: {
+			x64: "@rometools/cli-win32-x64/rome.exe",
+			arm64: "@rometools/cli-win32-arm64/rome.exe",
+		},
+		darwin: {
+			x64: "@rometools/cli-darwin-x64/rome",
+			arm64: "@rometools/cli-darwin-arm64/rome",
+		},
+		linux: {
+			x64: "@rometools/cli-linux-x64/rome",
+			arm64: "@rometools/cli-linux-arm64/rome",
+		},
+	};
+
+	const binPath = PLATFORMS?.[platform]?.[arch];
+	if (!binPath) {
+		return null;
+	}
+
+	return require.resolve(binPath);
+}

package/src/index.ts

@@ -0,0 +1,50 @@
+import { getCommand } from "./command";
+import { createSocket } from "./socket";
+import { Transport } from "./transport";
+import {
+	createWorkspace as wrapTransport,
+	type Workspace,
+	type RomePath,
+} from "./workspace";
+
+/**
+ * Create an instance of the Workspace client connected to a remote daemon
+ * instance through the JSON-RPC protocol
+ *
+ * @returns A Workspace client, or null if the underlying platform is not supported
+ */
+export async function createWorkspace(): Promise<Workspace | null> {
+	const command = getCommand();
+	if (!command) {
+		return null;
+	}
+
+	return createWorkspaceWithBinary(command);
+}
+
+/**
+ * Create an instance of the Workspace client connected to a remote daemon
+ * instance through the JSON-RPC protocol, using the provided command to spawn
+ * the daemon if necessary
+ *
+ * @param command Path to the Rome binary distribution
+ * @returns A Workspace client, or null if the underlying platform is not supported
+ */
+export async function createWorkspaceWithBinary(
+	command: string,
+): Promise<Workspace> {
+	const socket = await createSocket(command);
+	const transport = new Transport(socket);
+
+	await transport.request("initialize", {
+		capabilities: {},
+		client_info: {
+			name: "@biomejs/backend-jsonrpc",
+			version: "0.10.1-next",
+		},
+	});
+
+	return wrapTransport(transport);
+}
+
+export * from "./workspace";

package/src/socket.ts

@@ -0,0 +1,47 @@
+import { spawn } from "child_process";
+import { connect, type Socket } from "net";
+
+function getSocket(command: string): Promise<string> {
+	return new Promise((resolve, reject) => {
+		const process = spawn(command, ["__print_socket"], {
+			stdio: "pipe",
+		});
+
+		process.on("error", reject);
+
+		let pipeName = "";
+		process.stdout.on("data", (data) => {
+			pipeName += data.toString("utf-8");
+		});
+
+		process.on("exit", (code) => {
+			if (code === 0) {
+				resolve(pipeName.trimEnd());
+			} else {
+				reject(
+					new Error(
+						`Command '${command} __print_socket' exited with code ${code}`,
+					),
+				);
+			}
+		});
+	});
+}
+
+/**
+ * Ensure the Rome daemon server is running and create a Socket connected to the RPC channel
+ *
+ * @param command Path to the Rome daemon binary
+ * @returns Socket instance connected to the daemon
+ */
+export async function createSocket(command: string): Promise<Socket> {
+	const path = await getSocket(command);
+	const socket = connect(path);
+
+	await new Promise((resolve, reject) => {
+		socket.once("error", reject);
+		socket.once("ready", resolve);
+	});
+
+	return socket;
+}

package/src/transport.ts

@@ -0,0 +1,291 @@
+interface Socket {
+	on(event: "data", fn: (data: Buffer) => void): void;
+	write(data: Buffer): void;
+	destroy(): void;
+}
+
+enum ReaderStateKind {
+	Header,
+	Body,
+}
+
+interface ReaderStateHeader {
+	readonly kind: ReaderStateKind.Header;
+	contentLength?: number;
+	contentType?: string;
+}
+
+interface ReaderStateBody {
+	readonly kind: ReaderStateKind.Body;
+	readonly contentLength: number;
+	readonly contentType?: string;
+}
+
+type ReaderState = ReaderStateHeader | ReaderStateBody;
+
+interface JsonRpcRequest {
+	jsonrpc: "2.0";
+	id: number;
+	method: string;
+	params: any;
+}
+
+function isJsonRpcRequest(message: JsonRpcMessage): message is JsonRpcRequest {
+	return (
+		"id" in message &&
+		typeof message.id === "number" &&
+		"method" in message &&
+		typeof message.method === "string" &&
+		"params" in message
+	);
+}
+
+interface JsonRpcNotification {
+	jsonrpc: "2.0";
+	method: string;
+	params: any;
+}
+
+function isJsonRpcNotification(
+	message: JsonRpcMessage,
+): message is JsonRpcNotification {
+	return (
+		!("id" in message) &&
+		"method" in message &&
+		typeof message.method === "string" &&
+		"params" in message
+	);
+}
+
+type JsonRpcResponse =
+	| {
+			jsonrpc: "2.0";
+			id: number;
+			result: any;
+	  }
+	| {
+			jsonrpc: "2.0";
+			id: number;
+			error: any;
+	  };
+
+function isJsonRpcResponse(
+	message: JsonRpcMessage,
+): message is JsonRpcResponse {
+	return (
+		"id" in message &&
+		typeof message.id === "number" &&
+		!("method" in message) &&
+		("result" in message || "error" in message)
+	);
+}
+
+type JsonRpcMessage = JsonRpcRequest | JsonRpcNotification | JsonRpcResponse;
+
+function isJsonRpcMessage(message: any): message is JsonRpcMessage {
+	return (
+		typeof message === "object" && message !== null && message.jsonrpc === "2.0"
+	);
+}
+
+interface PendingRequest {
+	resolve(result: any): void;
+	reject(error: any): void;
+}
+
+const MIME_JSONRPC = "application/vscode-jsonrpc";
+
+/**
+ * Implements the Rome daemon server JSON-RPC protocol over a Socket instance
+ */
+export class Transport {
+	/**
+	 * Counter incremented for each outgoing request to generate a unique ID
+	 */
+	private nextRequestId = 0;
+
+	/**
+	 * Storage for the promise resolver functions of pending requests,
+	 * keyed by ID of the request
+	 */
+	private pendingRequests: Map<number, PendingRequest> = new Map();
+
+	constructor(private socket: Socket) {
+		socket.on("data", (data) => {
+			this.processIncoming(data);
+		});
+	}
+
+	/**
+	 * Send a request to the remote server
+	 *
+	 * @param method Name of the remote method to call
+	 * @param params Parameters object the remote method should be called with
+	 * @return Promise resolving with the value returned by the remote method, or rejecting with an RPC error if the remote call failed
+	 */
+	request(method: string, params: any): Promise<any> {
+		return new Promise((resolve, reject) => {
+			const id = this.nextRequestId++;
+			this.pendingRequests.set(id, { resolve, reject });
+			this.sendMessage({
+				jsonrpc: "2.0",
+				id,
+				method,
+				params,
+			});
+		});
+	}
+
+	/**
+	 * Send a notification message to the remote server
+	 *
+	 * @param method Name of the remote method to call
+	 * @param params Parameters object the remote method should be called with
+	 */
+	notify(method: string, params: any) {
+		this.sendMessage({
+			jsonrpc: "2.0",
+			method,
+			params,
+		});
+	}
+
+	/**
+	 * Destroy the internal socket instance for this Transport
+	 */
+	destroy() {
+		this.socket.destroy();
+	}
+
+	private sendMessage(message: JsonRpcMessage) {
+		const body = Buffer.from(JSON.stringify(message));
+		const headers = Buffer.from(
+			`Content-Length: ${body.length}\r\n` +
+				`Content-Type: ${MIME_JSONRPC};charset=utf-8\r\n` +
+				`\r\n`,
+		);
+		this.socket.write(Buffer.concat([headers, body]));
+	}
+
+	private pendingData = Buffer.from("");
+	private readerState: ReaderState = {
+		kind: ReaderStateKind.Header,
+	};
+
+	private processIncoming(data: Buffer) {
+		this.pendingData = Buffer.concat([this.pendingData, data]);
+
+		while (this.pendingData.length > 0) {
+			if (this.readerState.kind === ReaderStateKind.Header) {
+				const lineBreakIndex = this.pendingData.indexOf("\n");
+				if (lineBreakIndex < 0) {
+					break;
+				}
+
+				const header = this.pendingData.subarray(0, lineBreakIndex + 1);
+				this.pendingData = this.pendingData.subarray(lineBreakIndex + 1);
+				this.processIncomingHeader(this.readerState, header.toString("utf-8"));
+			} else if (this.pendingData.length >= this.readerState.contentLength) {
+				const body = this.pendingData.subarray(
+					0,
+					this.readerState.contentLength,
+				);
+				this.pendingData = this.pendingData.subarray(
+					this.readerState.contentLength,
+				);
+				this.processIncomingBody(body);
+
+				this.readerState = {
+					kind: ReaderStateKind.Header,
+				};
+			} else {
+				break;
+			}
+		}
+	}
+
+	private processIncomingHeader(readerState: ReaderStateHeader, line: string) {
+		if (line === "\r\n") {
+			const { contentLength, contentType } = readerState;
+			if (typeof contentLength !== "number") {
+				throw new Error(
+					`incoming message from the remote workspace is missing the Content-Length header`,
+				);
+			}
+
+			this.readerState = {
+				kind: ReaderStateKind.Body,
+				contentLength,
+				contentType,
+			};
+			return;
+		}
+
+		const colonIndex = line.indexOf(":");
+		if (colonIndex < 0) {
+			throw new Error(`could not find colon token in "${line}"`);
+		}
+
+		const headerName = line.substring(0, colonIndex);
+		const headerValue = line.substring(colonIndex + 1).trim();
+
+		switch (headerName) {
+			case "Content-Length": {
+				const value = parseInt(headerValue);
+				readerState.contentLength = value;
+				break;
+			}
+			case "Content-Type": {
+				if (!headerValue.startsWith(MIME_JSONRPC)) {
+					throw new Error(
+						`invalid value for Content-Type expected "${MIME_JSONRPC}", got "${headerValue}"`,
+					);
+				}
+
+				readerState.contentType = headerValue;
+				break;
+			}
+			default:
+				console.warn(`ignoring unknown header "${headerName}"`);
+		}
+	}
+
+	private processIncomingBody(buffer: Buffer) {
+		const data = buffer.toString("utf-8");
+		const body = JSON.parse(data);
+
+		if (isJsonRpcMessage(body)) {
+			if (isJsonRpcRequest(body)) {
+				// TODO: Not implemented at the moment
+				return;
+			}
+
+			if (isJsonRpcNotification(body)) {
+				// TODO: Not implemented at the moment
+				return;
+			}
+
+			if (isJsonRpcResponse(body)) {
+				const pendingRequest = this.pendingRequests.get(body.id);
+				if (pendingRequest) {
+					this.pendingRequests.delete(body.id);
+					const { resolve, reject } = pendingRequest;
+					if ("result" in body) {
+						resolve(body.result);
+					} else {
+						reject(body.error);
+					}
+				} else {
+					throw new Error(
+						`could not find any pending request matching RPC response ID ${body.id}`,
+					);
+				}
+				return;
+			}
+		}
+
+		throw new Error(
+			`failed to deserialize incoming message from remote workspace, "${data}" is not a valid JSON-RPC message body`,
+		);
+	}
+}