auto-mode 1.0.1 → 2.0.0

package/dist/start-judge-server-Drj5c8js.js

@@ -0,0 +1,169 @@
+import { d as string, s as number, u as strictObject } from "./schemas-Dc2424NY.js";
+import { t as startJudgeSession } from "./start-judge-session-9R_bGhxY.js";
+import { randomBytes } from "node:crypto";
+import { chmod, mkdir, rename, rm, stat } from "node:fs/promises";
+import { dirname, join } from "node:path";
+import { connect, createServer } from "node:net";
+//#region src/judge/judge-server-request-schema.ts
+const judgeServerRequestSchema = strictObject({
+	model: string().min(1),
+	timeoutMs: number().int().positive(),
+	system: string(),
+	user: string()
+});
+//#endregion
+//#region src/judge/start-judge-server.ts
+async function startJudgeServer(options) {
+	await mkdir(dirname(options.socketPath), {
+		recursive: true,
+		mode: 448
+	});
+	if (await isAnswering(options.socketPath)) return null;
+	const server = createServer();
+	const session = startJudgeSession(options.env);
+	const closed = Promise.withResolvers();
+	let ownIno = null;
+	let idleTimer = null;
+	let active = 0;
+	let stopped = false;
+	const stop = () => {
+		if (stopped) return;
+		stopped = true;
+		if (idleTimer !== null) clearTimeout(idleTimer);
+		session.stop();
+		server.close(() => {
+			removeOwnSocket(options.socketPath, ownIno, closed.resolve);
+		});
+	};
+	const waitIdle = () => {
+		idleTimer = setTimeout(stop, options.idleMs);
+		idleTimer.unref();
+	};
+	const runConnection = async (socket) => {
+		active += 1;
+		if (idleTimer !== null) {
+			clearTimeout(idleTimer);
+			idleTimer = null;
+		}
+		await runReview(socket, session);
+		active -= 1;
+		if (active === 0) waitIdle();
+	};
+	server.on("connection", (socket) => {
+		runConnection(socket);
+	});
+	const listenPath = join(dirname(options.socketPath), `j-${randomBytes(4).toString("hex")}`);
+	await startListening(server, listenPath);
+	await chmod(listenPath, 384);
+	const own = await stat(listenPath);
+	ownIno = own.ino;
+	await rename(listenPath, options.socketPath);
+	if ((await stat(options.socketPath).catch(() => null))?.ino !== own.ino) {
+		stop();
+		return null;
+	}
+	waitIdle();
+	return {
+		closed: closed.promise,
+		stop
+	};
+}
+async function removeOwnSocket(socketPath, ino, onRemoved) {
+	const current = await stat(socketPath).catch(() => null);
+	if (ino !== null && current?.ino === ino) await rm(socketPath, { force: true });
+	onRemoved();
+}
+function startListening(server, socketPath) {
+	return new Promise((resolve, reject) => {
+		server.once("error", reject);
+		server.listen(socketPath, () => {
+			server.off("error", reject);
+			resolve();
+		});
+	});
+}
+function isAnswering(socketPath) {
+	return new Promise((resolve) => {
+		const probe = connect(socketPath);
+		probe.once("connect", () => {
+			probe.destroy();
+			resolve(true);
+		});
+		probe.once("error", () => {
+			resolve(false);
+		});
+	});
+}
+const MAX_REQUEST_BYTES = 4194304;
+async function runReview(socket, session) {
+	const controller = new AbortController();
+	let answered = false;
+	const stopUnanswered = () => {
+		if (!answered) controller.abort();
+	};
+	socket.on("end", stopUnanswered);
+	socket.on("close", stopUnanswered);
+	socket.on("error", () => {});
+	const line = await readLine(socket, MAX_REQUEST_BYTES);
+	const request = judgeServerRequestSchema.safeParse(parseJSON(line));
+	if (!request.success) {
+		answered = true;
+		writeResponse(socket, {
+			kind: "failure",
+			aborted: false,
+			message: "malformed request"
+		});
+		return;
+	}
+	const signal = AbortSignal.any([controller.signal, AbortSignal.timeout(request.data.timeoutMs)]);
+	let response;
+	try {
+		response = {
+			kind: "reply",
+			...await session.review(request.data.model, {
+				system: request.data.system,
+				user: request.data.user
+			}, signal)
+		};
+	} catch (error) {
+		response = {
+			kind: "failure",
+			aborted: signal.aborted,
+			message: error instanceof Error ? error.message : String(error)
+		};
+	}
+	answered = true;
+	writeResponse(socket, response);
+}
+function readLine(socket, maxBytes) {
+	return new Promise((resolve) => {
+		const chunks = [];
+		let size = 0;
+		const stopReading = () => {
+			socket.off("data", onData);
+			socket.off("end", stopReading);
+			socket.off("close", stopReading);
+			resolve(Buffer.concat(chunks).toString("utf8").split("\n")[0] ?? "");
+		};
+		const onData = (chunk) => {
+			chunks.push(chunk);
+			size += chunk.length;
+			if (size > maxBytes || chunk.includes(10)) stopReading();
+		};
+		socket.on("data", onData);
+		socket.once("end", stopReading);
+		socket.once("close", stopReading);
+	});
+}
+function writeResponse(socket, response) {
+	if (!socket.destroyed) socket.end(`${JSON.stringify(response)}\n`);
+}
+function parseJSON(text) {
+	try {
+		return JSON.parse(text);
+	} catch {
+		return null;
+	}
+}
+//#endregion
+export { startJudgeServer };