feat: ipc server

packages/orchestrator/src/ipc/server.ts

@@ -0,0 +1,107 @@
+import { existsSync, unlinkSync } from "node:fs";
+import { createConnection, createServer, type Server } from "node:net";
+import { getSocketPath } from "../config.ts";
+import {
+	type ErrorResponse,
+	encodeMessage,
+	type OrchestratorRequest,
+	parseRequestLine,
+	type ResponseFor,
+} from "./protocol.ts";
+
+export type IpcRequestHandler = <T extends OrchestratorRequest>(request: T) => Promise<ResponseFor<T>> | ResponseFor<T>;
+
+export async function startIpcServer(handler: IpcRequestHandler): Promise<Server> {
+	const socketPath = getSocketPath();
+	await removeStaleSocketIfNeeded(socketPath);
+
+	const server = createServer((socket) => {
+		let buffer = "";
+
+		socket.on("data", async (chunk: Buffer | string) => {
+			buffer += chunk.toString();
+			const newlineIndex = buffer.indexOf("\n");
+			if (newlineIndex === -1) {
+				return;
+			}
+
+			const line = buffer.slice(0, newlineIndex).trim();
+			buffer = buffer.slice(newlineIndex + 1);
+			if (!line) {
+				return;
+			}
+
+			try {
+				const request = parseRequestLine(line);
+				const response = await handler(request);
+				socket.end(encodeMessage(response));
+			} catch (error) {
+				const response: ErrorResponse = {
+					type: "error",
+					ok: false,
+					error: error instanceof Error ? error.message : String(error),
+				};
+				socket.end(encodeMessage(response));
+			}
+		});
+	});
+
+	await new Promise<void>((resolve, reject) => {
+		server.once("error", reject);
+		server.listen(socketPath, () => {
+			server.off("error", reject);
+			resolve();
+		});
+	});
+
+	return server;
+}
+
+async function removeStaleSocketIfNeeded(socketPath: string): Promise<void> {
+	if (!existsSync(socketPath)) {
+		return;
+	}
+
+	const isLive = await isSocketLive(socketPath);
+	if (isLive) {
+		throw new Error(`orchestrator is already running: ${socketPath}`);
+	}
+
+	unlinkSync(socketPath);
+}
+
+async function isSocketLive(socketPath: string): Promise<boolean> {
+	return new Promise<boolean>((resolve, reject) => {
+		const socket = createConnection(socketPath);
+		let settled = false;
+
+		const finish = (result: boolean) => {
+			if (settled) {
+				return;
+			}
+			settled = true;
+			socket.removeAllListeners();
+			socket.destroy();
+			resolve(result);
+		};
+
+		socket.on("connect", () => finish(true));
+		socket.on("error", (error: NodeJS.ErrnoException) => {
+			if (error.code === "ECONNREFUSED" || error.code === "ENOENT") {
+				finish(false);
+				return;
+			}
+			if (error.code === "EPIPE" || error.code === "ECONNRESET") {
+				finish(false);
+				return;
+			}
+			if (settled) {
+				return;
+			}
+			settled = true;
+			socket.removeAllListeners();
+			socket.destroy();
+			reject(error);
+		});
+	});
+}