posipaki 0.35.0 → 0.35.2

package/dist/remote/node.js

@@ -1,13 +1,164 @@
-import { t as LIB_VERSION } from "../version-DDAdqTTr.js";
-import { c as isProto, i as json1Channel, t as VERSION } from "../json1-DS3xxg13.js";
-import { r as serveRemoteActor, t as remoteClient } from "../client-D23TlXPf.js";
-import { _ as FifoUtf8NlineTransport, a as HANDSHAKE_TIMEOUT_MS, c as StdioWireError, d as errorReason, f as fdStreams, g as stderrSink, h as serverChannel, i as runGateway, l as clientChannel, m as parseOutputFrame, n as gatewayArgs, o as LineTransport, p as outputFrame, r as gatewayBoot, s as OutputFilter, t as GATEWAY_FAILED, u as errorFrame } from "../gateway-Cj3HSrl3.js";
-import { readFile, unlink } from "node:fs/promises";
-import { execSync, spawn } from "node:child_process";
+import { t as LIB_VERSION } from "../version-0mlM8dbC.js";
+import { a as remoteClient, d as isProto, i as json1Channel, s as serveRemoteActor, t as VERSION } from "../json1-DzPx9oX3.js";
+import { mkdtemp, open, readFile, rm, unlink } from "node:fs/promises";
+import * as readline from "node:readline";
+import { execFile, execSync, spawn } from "node:child_process";
 import { createHash, randomUUID } from "node:crypto";
 import { tmpdir } from "node:os";
-import { join } from "node:path";
+import { basename, join } from "node:path";
 import { fileURLToPath } from "node:url";
+import { createReadStream, createWriteStream } from "node:fs";
+import { promisify } from "node:util";
+//#region src/remote/transports/fifo.ts
+var FifoUtf8NlineTransport = class FifoUtf8NlineTransport {
+	constructor(opts) {
+		this.pvtOnMessage = null;
+		this.pvtOnClose = null;
+		this.closed = false;
+		this.closingPromise = null;
+		this.pvtError = null;
+		this.readFd = opts.readFd ?? null;
+		this.writeFd = opts.writeFd ?? null;
+		if (this.readFd) {
+			this.rs = this.readFd.createReadStream({ encoding: "utf-8" });
+			this.rl = readline.createInterface({ input: this.rs });
+			this.rl.on("line", (line) => {
+				if (this.pvtOnMessage && !this.closed) this.pvtOnMessage(line);
+			});
+			this.rl.on("close", () => {
+				this.pvtOnClose?.();
+				this.close();
+			});
+			this.rs.on("error", (err) => {
+				this.pvtError = err;
+				this.close();
+			});
+		} else {
+			this.rs = null;
+			this.rl = null;
+		}
+		if (this.writeFd) {
+			this.ws = this.writeFd.createWriteStream({ encoding: "utf-8" });
+			this.ws.on("error", (err) => {
+				this.pvtError = err;
+				this.close();
+			});
+		} else this.ws = null;
+	}
+	static openReaderFd(readFd) {
+		return new FifoUtf8NlineTransport({ readFd });
+	}
+	static openWriterFd(writeFd) {
+		return new FifoUtf8NlineTransport({ writeFd });
+	}
+	static fromFds(readFd, writeFd) {
+		return new FifoUtf8NlineTransport({
+			readFd,
+			writeFd
+		});
+	}
+	/**
+	* Start opening a bidirectional connection.  Opens readPath for reading
+	* in the background, returns a promise.  The caller should do whatever
+	* setup is needed to unblock the read (e.g. spawn a process that opens
+	* readPath for writing), then await the returned transport.
+	*
+	* The transport itself is built only once both directions are open.  A read
+	* stream created while no writer exists on its fifo is handed an immediate
+	* end-of-stream by some runtimes (bun), which closes a channel that has not
+	* carried a byte yet — so the writes side is opened before the reader exists.
+	*/
+	static beginConnect(readPath, writePath) {
+		return { transport: open(readPath, "r").then(async (readFd) => {
+			const writeFd = await open(writePath, "w");
+			return FifoUtf8NlineTransport.fromFds(readFd, writeFd);
+		}) };
+	}
+	/**
+	* Open a bidirectional connection.  Opens writePath for writing first
+	* (unblocking the peer's read), starts reading readPath in the
+	* background, then awaits both.
+	*
+	* Use this when you are the side that responds to the peer's beginConnect
+	* (i.e. you don't need to interleave any setup between the read and write
+	* opens).  Built like `beginConnect`: the transport exists only after both
+	* directions do.
+	*/
+	static async connect(readPath, writePath) {
+		const readFdPromise = open(readPath, "r");
+		const writeFd = await open(writePath, "w");
+		const readFd = await readFdPromise;
+		return FifoUtf8NlineTransport.fromFds(readFd, writeFd);
+	}
+	get canSend() {
+		return this.writeFd !== null && !this.closed;
+	}
+	onMessage(handler) {
+		if (this.closed) throw new Error("FifoUtf8NlineTransport: closed");
+		if (this.readFd === null) throw new Error("FifoUtf8NlineTransport: not a reader");
+		if (this.pvtOnMessage !== null) throw new Error("FifoUtf8NlineTransport: handler already set — call removeHandler() first");
+		this.pvtOnMessage = handler;
+	}
+	removeHandler() {
+		const prev = this.pvtOnMessage;
+		this.pvtOnMessage = null;
+		return prev;
+	}
+	onClose(handler) {
+		this.pvtOnClose = handler;
+	}
+	get hasHandler() {
+		return this.pvtOnMessage !== null;
+	}
+	get lastError() {
+		return this.pvtError;
+	}
+	async send(line) {
+		if (this.closed) throw new Error("FifoUtf8NlineTransport: closed");
+		if (this.writeFd === null) throw new Error("FifoUtf8NlineTransport: not a writer");
+		if (!line.endsWith("\n")) line += "\n";
+		await this.ws?.write(line);
+	}
+	async close() {
+		this.closingPromise = this.closingPromise || this.pvtClose();
+		await this.closingPromise;
+		this.closed = true;
+	}
+	async pvtClose() {
+		await Promise.resolve();
+		if (this.rl) {
+			this.rl.close();
+			this.rl = null;
+		}
+		if (this.rs) {
+			this.rs.destroy();
+			this.rs = null;
+		}
+		if (this.ws) {
+			await new Promise((resolve) => {
+				try {
+					this.ws?.end("", resolve);
+				} catch {
+					resolve();
+				}
+			});
+			this.ws = null;
+		}
+		if (this.readFd) {
+			try {
+				await this.readFd.close();
+			} catch {}
+			this.readFd = null;
+		}
+		if (this.writeFd) {
+			try {
+				await this.writeFd.close();
+			} catch {}
+			this.writeFd = null;
+		}
+	}
+};
+//#endregion
 //#region src/remote/spawners/fifo-command.ts
 function commandSpawner(command) {
 	return async () => {
@@ -333,6 +484,382 @@ function defineSubprocessActor(actor, url, opts = {}) {
 	};
 }
 //#endregion
+//#region src/remote/stdio.ts
+/** How long to wait for the far end's first protocol frame. */
+const HANDSHAKE_TIMEOUT_MS = 15e3;
+const OUTPUT_KEY = "$fd";
+const ERROR_KEY = "$error";
+/** Raised when the wire itself fails: no frame, the wrong protocol, a peer that went away. */
+var StdioWireError = class extends Error {
+	constructor(message) {
+		super(message);
+		this.name = "StdioWireError";
+	}
+};
+function outputFrame(fd, data) {
+	return JSON.stringify({
+		[OUTPUT_KEY]: fd,
+		data
+	});
+}
+/** The output frame a line carries, or null when it carries something else. */
+function parseOutputFrame(line) {
+	if (!line.startsWith("{\"$fd\"")) return null;
+	let parsed;
+	try {
+		parsed = JSON.parse(line);
+	} catch {
+		return null;
+	}
+	if (typeof parsed !== "object" || parsed === null) return null;
+	const frame = parsed;
+	const fd = frame[OUTPUT_KEY];
+	const data = frame.data;
+	if (fd !== 1 && fd !== 2) return null;
+	return {
+		fd,
+		data: typeof data === "string" ? data : JSON.stringify(data)
+	};
+}
+function errorFrame(reason) {
+	return JSON.stringify({ [ERROR_KEY]: reason });
+}
+/** The reason an `$error` frame carries, or null when it is not one. */
+function errorReason(frame) {
+	const reason = frame[ERROR_KEY];
+	return typeof reason === "string" ? reason : null;
+}
+/** Is this write error just a peer that already left? */
+function peerGone(code) {
+	return code === "EPIPE" || code === "ERR_STREAM_DESTROYED" || code === "ERR_STREAM_WRITE_AFTER_END" || code === "ERR_STREAM_ALREADY_FINISHED";
+}
+function errorText$2(err) {
+	return err instanceof Error ? err.message : String(err);
+}
+/**
+* A `StringTransport` over a read/write stream pair, one JSON frame per line.
+*
+* `close()` is idempotent and never throws: teardown races are normal here —
+* the peer exits, the read side ends, and a write arrives a moment later.
+*/
+var LineTransport = class {
+	constructor(streams) {
+		this.pvtOnMessage = null;
+		this.pvtOnClose = null;
+		this.pvtClosed = false;
+		this.pvtClosing = null;
+		this.streams = streams;
+		const lines = readline.createInterface({ input: streams.read });
+		lines.on("line", (line) => {
+			if (this.pvtOnMessage && !this.pvtClosed) this.pvtOnMessage(line);
+		});
+		lines.on("close", () => {
+			this.pvtOnClose?.();
+			this.close();
+		});
+		streams.read.on("error", () => {
+			this.close();
+		});
+		streams.write.on("error", () => {
+			this.close();
+		});
+	}
+	get closed() {
+		return this.pvtClosed;
+	}
+	get hasHandler() {
+		return this.pvtOnMessage !== null;
+	}
+	onMessage(handler) {
+		if (this.pvtClosed) throw new StdioWireError("stdio transport: closed");
+		if (this.pvtOnMessage !== null) throw new StdioWireError("stdio transport: handler already set — call removeHandler()");
+		this.pvtOnMessage = handler;
+	}
+	removeHandler() {
+		const previous = this.pvtOnMessage;
+		this.pvtOnMessage = null;
+		return previous;
+	}
+	onClose(handler) {
+		this.pvtOnClose = handler;
+	}
+	send(frame) {
+		if (this.pvtClosed) return Promise.resolve();
+		const line = frame.endsWith("\n") ? frame : `${frame}\n`;
+		return new Promise((resolve, reject) => {
+			try {
+				this.streams.write.write(line, (err) => {
+					if (!err) return resolve();
+					const code = err.code;
+					if (peerGone(code)) return resolve();
+					reject(new StdioWireError(`stdio transport: ${err.message}`));
+				});
+			} catch (err) {
+				reject(new StdioWireError(`stdio transport: ${errorText$2(err)}`));
+			}
+		});
+	}
+	async close() {
+		this.pvtClosing ??= this.pvtClose();
+		await this.pvtClosing;
+	}
+	async pvtClose() {
+		await Promise.resolve();
+		this.pvtClosed = true;
+		try {
+			this.streams.read.destroy?.();
+		} catch {}
+		try {
+			if (!this.streams.write.writableEnded) this.streams.write.end();
+		} catch {}
+	}
+};
+/** Streams over two fds of *our own* process — the child side of an fd wire. */
+function fdStreams(readFd, writeFd) {
+	return {
+		read: createReadStream("", {
+			fd: readFd,
+			encoding: "utf-8",
+			autoClose: false
+		}),
+		write: createWriteStream("", {
+			fd: writeFd,
+			encoding: "utf-8",
+			autoClose: false
+		})
+	};
+}
+/**
+* A transport that lifts output frames out of the stream: everything else is
+* passed through untouched, so the protocol sees frames and only frames.
+*/
+var OutputFilter = class {
+	constructor(inner, sink) {
+		this.inner = inner;
+		this.sink = sink;
+	}
+	send(frame) {
+		return this.inner.send(frame);
+	}
+	onMessage(handler) {
+		this.inner.onMessage((line) => {
+			const output = parseOutputFrame(line);
+			if (output) this.sink(output.fd, output.data);
+			else handler(line);
+		});
+	}
+	removeHandler() {
+		this.inner.removeHandler();
+	}
+	onClose(handler) {
+		this.inner.onClose(handler);
+	}
+	close() {
+		return this.inner.close();
+	}
+};
+/** Write the far end's output to our stderr, tagged with its name. */
+function stderrSink(name = "") {
+	const tag = name ? `[${name}] ` : "";
+	return (fd, data) => {
+		const lead = fd === 1 ? tag : `${tag}err: `;
+		for (const line of data.split("\n")) if (line.length > 0) process.stderr.write(`${lead}${line}\n`);
+	};
+}
+/** The next frame that arrives, or a timeout. */
+async function nextFrame(channel, timeoutMs) {
+	return await new Promise((resolve, reject) => {
+		const timer = setTimeout(() => reject(new StdioWireError(`no protocol frame within ${timeoutMs}ms`)), timeoutMs);
+		timer.unref?.();
+		channel.onMessage((frame) => {
+			clearTimeout(timer);
+			resolve(frame);
+		});
+	});
+}
+/**
+* The client end of the wire: hand the streams to the seam (minus output
+* frames) and wait for the peer's `$proto`.  A first stage reports a failed
+* start as an `$error` frame instead.
+*/
+async function clientChannel(streams, opts = {}) {
+	const transport = new LineTransport(streams);
+	const channel = json1Channel(new OutputFilter(transport, opts.onOutput ?? stderrSink()));
+	const frame = await nextFrame(channel, opts.timeoutMs ?? 15e3);
+	channel.removeHandler();
+	const reason = errorReason(frame);
+	if (reason) throw new StdioWireError(reason);
+	if (!isProto(frame)) throw new StdioWireError(`unexpected first frame: ${JSON.stringify(frame).slice(0, 120)}`);
+	if (frame.$proto !== "json.v1") throw new StdioWireError(`unsupported protocol ${String(frame.$proto)}, expected ${VERSION}`);
+	return channel;
+}
+/** The server end of the wire — a payload speaking stdio itself. */
+async function serverChannel(streams) {
+	const channel = json1Channel(new LineTransport(streams));
+	await channel.send({ $proto: VERSION });
+	return channel;
+}
+//#endregion
+//#region src/remote/gateway.ts
+const run = promisify(execFile);
+/** Exit code for "this environment could not be set up". */
+const GATEWAY_FAILED = 1;
+function errorText$1(err) {
+	return err instanceof Error ? err.message : String(err);
+}
+/**
+* A label for the gateway's own temp directory: the program this environment was made for.
+* It is the gateway's business alone — the payload is not told which label it is.
+*/
+function label(worker) {
+	const name = basename(worker).replace(/[^A-Za-z0-9.+@_-]/g, "-").slice(0, 60);
+	return name === "" ? "payload" : name;
+}
+/**
+* The argv that boots this gateway — built by the client, read by
+* {@link gatewayBoot}, so the two halves cannot drift apart.
+*
+* The payload comes first and its arguments after it, so a positional argument of the
+* payload's own can never be mistaken for the payload.
+*/
+function gatewayArgs(boot) {
+	return [boot.worker, ...boot.passthrough];
+}
+/** The boot a gateway was started with, or the reason it cannot start. */
+function gatewayBoot(argv) {
+	const [worker, ...passthrough] = argv;
+	if (worker === void 0 || worker.startsWith("--")) throw new Error("no <payload>: the gateway relays to a payload, named as its first argument");
+	return {
+		passthrough,
+		worker
+	};
+}
+/**
+* End a start that failed.  The reason has already gone out on the wire, and
+* returning is not enough: the `open()` on a fifo no payload will ever write sits
+* in the threadpool forever, so the loop never drains and the gateway would linger
+* with a dead payload on its books.
+*/
+function abandon() {
+	process.exit(1);
+}
+/** Carry a failed start to the client, then let the caller exit non-zero. */
+async function fail(wire, reason) {
+	process.stderr.write(`gateway: ${reason}\n`);
+	try {
+		await wire.send(errorFrame(reason));
+	} catch {}
+}
+/** Copy everything the payload prints onto the wire as output frames. */
+function forwardOutput(stream, wire, fd) {
+	stream.setEncoding("utf-8");
+	stream.on("data", (chunk) => {
+		wire.send(outputFrame(fd, chunk)).catch(() => {});
+	});
+}
+/**
+* Serve one environment over stdin/stdout.  Returns the exit code; the caller
+* turns it into `process.exitCode`.
+*/
+async function runGateway(argv = process.argv.slice(2)) {
+	const wire = new LineTransport({
+		read: process.stdin,
+		write: process.stdout
+	});
+	let booted;
+	try {
+		booted = gatewayBoot(argv);
+	} catch (err) {
+		await fail(wire, errorText$1(err));
+		abandon();
+	}
+	const { passthrough, worker } = booted;
+	const dir = await mkdtemp(join(tmpdir(), `posipaki-${label(worker)}-`));
+	const fifoIn = join(dir, "in");
+	const fifoOut = join(dir, "out");
+	let child = null;
+	let fifo = null;
+	/**
+	* Everything this gateway owns, undone.  All of it is idempotent, because the
+	* exit path and the signal path can both arrive.
+	*/
+	const teardown = async () => {
+		child?.kill();
+		await fifo?.close().catch(() => {});
+		await rm(dir, {
+			recursive: true,
+			force: true
+		}).catch(() => {});
+	};
+	/**
+	* A client that gives up stops us with a signal, and a gateway that died on the
+	* spot would leave its payload behind in the environment — a process holding a
+	* fifo nobody will ever write, which is a leak the environment cannot clean up
+	* for us.  So the signals do what the exit path does.
+	*/
+	const onTerminate = () => {
+		teardown().catch(() => {}).then(() => process.exit(1));
+	};
+	for (const signal of [
+		"SIGTERM",
+		"SIGINT",
+		"SIGHUP"
+	]) process.on(signal, onTerminate);
+	try {
+		await run("mkfifo", [
+			"-m",
+			"600",
+			fifoIn,
+			fifoOut
+		]);
+	} catch (err) {
+		await fail(wire, `cannot create the environment's fifos: ${errorText$1(err)}`);
+		await teardown();
+		abandon();
+	}
+	const connection = FifoUtf8NlineTransport.beginConnect(fifoIn, fifoOut);
+	const workerArgs = [
+		worker,
+		...passthrough,
+		`--fifo-in=${fifoIn}`,
+		`--fifo-out=${fifoOut}`
+	];
+	const workerProc = spawn(workerArgs[0], workerArgs.slice(1), { stdio: [
+		"ignore",
+		"pipe",
+		"pipe"
+	] });
+	child = workerProc;
+	forwardOutput(workerProc.stdout, wire, 1);
+	forwardOutput(workerProc.stderr, wire, 2);
+	const exited = new Promise((settle) => {
+		workerProc.once("exit", (code) => settle(code ?? 0));
+	});
+	try {
+		fifo = await Promise.race([connection.transport, exited.then((code) => {
+			throw new Error(`the payload exited with code ${code} before it opened its channel`);
+		})]);
+	} catch (err) {
+		await fail(wire, errorText$1(err));
+		await teardown();
+		abandon();
+	}
+	const relay = fifo;
+	relay.onMessage((line) => {
+		wire.send(line).catch(() => {});
+	});
+	wire.onMessage((line) => {
+		relay.send(line).catch(() => {});
+	});
+	wire.onClose(() => {
+		child?.kill();
+	});
+	const code = await exited;
+	await teardown();
+	await wire.close();
+	return code;
+}
+//#endregion
 //#region src/remote/host.ts
 /** The real thing: spawn it, feed it, collect it. */
 const runHost = (command, stdin) => new Promise((settle, fail) => {