@agimon-ai/po-runner 0.0.0-alpha.0

package/dist/runnerDependencies-DruByBGS.mjs

@@ -0,0 +1,647 @@
+import { t as BashRunService } from "./bashRunService-CJ02XaAq.mjs";
+import { g as noninteractiveEnvironment, s as getLogMaxBytes, u as getResultMaxBytes } from "./runnerConfig-BQBlVAXn.mjs";
+import { t as LogReader } from "./logReader-UfbDbwQl.mjs";
+import { t as SystemClock } from "./clock-Cv2pddgo.mjs";
+import { t as RmuxBackend } from "./rmuxBackend-DfyQwJrc.mjs";
+import { NO_TERMINAL_INPUT_ENV, cleanupSupervisorFiles, readExitMetadata, runtimeEntry, shellJoin, supervisorPaths, writeCommandSpec } from "./services/runnerSupervisor/index.mjs";
+import { t as RtkProcessor } from "./rtkProcessor-B9KPdyzr.mjs";
+import { t as Launcher } from "./launcher-BDm6-DiQ.mjs";
+import { t as NodeLifeline } from "./lifeline-BZaQA0rm.mjs";
+import { t as LogFile } from "./logFile-KKPbkC-a.mjs";
+import { t as NodeProcessControl } from "./processControl-DApTpV16.mjs";
+import { t as PtyHost } from "./ptyHost-DlQtTB8F.mjs";
+import { t as NodePtySpawner } from "./ptySpawner-DEi1KOnd.mjs";
+import { t as RunnerNamer } from "./runnerNamer-B8FH7n2v.mjs";
+import { t as RunnerPaths } from "./runnerPaths-B_dAAeco.mjs";
+import { n as createDefaultProcessRegistry, t as RunnerRegistry } from "./runnerRegistry-CeOHEjBv.mjs";
+import { t as NodeSpawner } from "./spawner-LoVsn55-.mjs";
+import { createHash } from "node:crypto";
+import fs from "node:fs";
+import path from "node:path";
+import { execFile } from "node:child_process";
+import { sharedExecutionBudget } from "@agimon-ai/po-core/packageApi";
+//#region src/constants/tmuxBackend.ts
+const LOG_DRAIN_TIMEOUT_MS = 2e3;
+const PANE_STATE_FORMAT = "#{pane_dead}:#{pane_dead_status}:#{session_name}";
+const SESSION_PREFIX = "doom-tmux-";
+const OWNED_TARGET_PATTERN = /^doom-tmux-[A-Za-z0-9_-]+$/;
+const SOCKET_PREFIX = "doom-tmux-";
+const NON_INTERACTIVE_ENV = {
+	NO_COLOR: "1",
+	CI: "1"
+};
+//#endregion
+//#region src/services/ptyBackendChain/index.ts
+/**
+* Presents the available PTY backends as one, preferring RMUX.
+*
+* A launch takes the first backend that accepts it, so a host without a
+* compatible RMUX binary still gets panes rather than falling through to the
+* plain subprocess launcher. Every later call routes on the target's prefix
+* instead of asking each backend in turn: a backend cannot tell "this session
+* is gone" from "this session was never mine", and guessing would let one
+* report success for the other's run.
+*/
+var PtyBackendChain = class {
+	rmux;
+	tmux;
+	constructor(rmux, tmux) {
+		this.rmux = rmux;
+		this.tmux = tmux;
+	}
+	async launch(request) {
+		return await this.rmux.launch(request) ?? await this.tmux.launch(request);
+	}
+	watch(id, target, sessionId) {
+		return this.owner(target).watch(id, target, sessionId);
+	}
+	stop(target, expectedPid) {
+		return this.owner(target).stop(target, expectedPid);
+	}
+	input(target, text) {
+		return this.owner(target).input(target, text);
+	}
+	capture(target) {
+		return this.owner(target).capture(target);
+	}
+	/** Both backends persist terminal evidence at the same path, so either answers. */
+	readOutcome(id, sessionId) {
+		return this.rmux.readOutcome(id, sessionId) ?? this.tmux.readOutcome(id, sessionId);
+	}
+	get(name) {
+		return this.rmux.get(name) ?? this.tmux.get(name);
+	}
+	owner(target) {
+		return target.startsWith("doom-tmux-") ? this.tmux : this.rmux;
+	}
+};
+//#endregion
+//#region src/services/tmuxBackend/TmuxClient.ts
+const TMUX_BINARY = "tmux";
+const SOCKET_OPTION = "-L";
+/** Long enough for a loaded server, short enough that a hung tmux is not fatal. */
+const COMMAND_TIMEOUT_MS = 1e4;
+const MAX_OUTPUT_BYTES = 4194304;
+var TmuxClient = class {
+	socket;
+	binary;
+	constructor(socket, binary = TMUX_BINARY) {
+		this.socket = socket;
+		this.binary = binary;
+	}
+	run(args) {
+		return new Promise((resolve, reject) => {
+			execFile(this.binary, [
+				SOCKET_OPTION,
+				this.socket,
+				...args
+			], {
+				timeout: COMMAND_TIMEOUT_MS,
+				maxBuffer: MAX_OUTPUT_BYTES,
+				encoding: "utf8"
+			}, (error, stdout, stderr) => {
+				const code = error?.code;
+				if (error && typeof code !== "number") {
+					reject(error);
+					return;
+				}
+				resolve({
+					returnCode: typeof code === "number" ? code : 0,
+					stdout,
+					stderr
+				});
+			});
+		});
+	}
+	async format(target, format) {
+		const result = await this.run([
+			"display-message",
+			"-p",
+			"-t",
+			target,
+			"-F",
+			format
+		]).catch(() => void 0);
+		if (!result || result.returnCode !== 0) return void 0;
+		return result.stdout.replace(/\n$/, "");
+	}
+	async sessionMissing(target) {
+		const result = await this.run([
+			"has-session",
+			"-t",
+			target
+		]).catch(() => void 0);
+		return !result || result.returnCode !== 0;
+	}
+};
+//#endregion
+//#region src/services/tmuxBackend/index.ts
+/** Pane liveness, its exit status, and whether the session still exists, in one read. */
+/** Distinct from the RMUX prefix so a target names the backend that owns it. */
+/**
+* Supervises runs in tmux panes, for hosts with no compatible RMUX binary.
+*
+* The pane runs the same runnerHost supervisor as the RMUX backend, so exit
+* metadata, log rotation, and lifeline handling are shared rather than
+* reimplemented: only the multiplexer differs. Kept beside the RMUX backend
+* rather than folded into it because that path has no unit coverage to
+* refactor against.
+*/
+var TmuxBackend = class {
+	paths;
+	createClient;
+	env;
+	settings;
+	clientPromise;
+	runs = /* @__PURE__ */ new Map();
+	completions = /* @__PURE__ */ new Map();
+	constructor(paths, createClient = (socket) => new TmuxClient(socket), env = process.env, settings) {
+		this.paths = paths;
+		this.createClient = createClient;
+		this.env = env;
+		this.settings = settings;
+	}
+	async launch(request) {
+		const tmux = await this.client();
+		if (!tmux) return void 0;
+		this.paths.ensureDirectories();
+		const target = `${SESSION_PREFIX}${request.id}`;
+		const logPath = this.paths.logPathFor(request.id);
+		const aux = this.auxPaths(request.id, request.sessionId);
+		let created = false;
+		let released = false;
+		try {
+			this.prepareFiles(request, logPath, aux);
+			const supervisor = shellJoin([
+				process.execPath,
+				runtimeEntry("runnerHost"),
+				aux.spec,
+				aux.gate,
+				aux.exit
+			]);
+			await this.checked(tmux, [
+				"new-session",
+				"-d",
+				"-s",
+				target,
+				"-c",
+				request.cwd,
+				supervisor
+			]);
+			created = true;
+			await this.checked(tmux, [
+				"set-option",
+				"-t",
+				target,
+				"remain-on-exit",
+				"on"
+			]);
+			await this.checked(tmux, [
+				"pipe-pane",
+				"-t",
+				target,
+				this.logPipeCommand(logPath, aux.logDone, request)
+			]);
+			const pid = await panePid(tmux, target);
+			fs.writeFileSync(aux.gate, "", { mode: 384 });
+			released = true;
+			let buffering = true;
+			const completion = this.monitor(tmux, target, aux);
+			this.trackCompletion(target, completion);
+			const handle = {
+				id: request.id,
+				name: request.name,
+				pid,
+				logPath,
+				backend: "tmux",
+				backendTarget: target,
+				output: () => buffering ? readTail(logPath, getResultMaxBytes(this.env, this.settings) * 2) : "",
+				completion: () => completion,
+				detach: () => {
+					buffering = false;
+				},
+				stop: () => this.stop(target, pid)
+			};
+			if (request.interactive) this.runs.set(request.name, this.interactiveRun(handle, tmux, target, completion));
+			completion.finally(() => this.runs.delete(request.name)).catch((error) => process.emitWarning(`tmux completion failed for ${target}: ${errorMessage(error)}`));
+			return handle;
+		} catch (error) {
+			if (released) throw error;
+			if (created) await killSession(tmux, target);
+			cleanupSupervisorFiles(aux);
+			process.emitWarning(request.interactive ? `tmux launch unavailable for interactive runner: ${errorMessage(error)}` : `tmux launch unavailable, using supervised subprocess: ${errorMessage(error)}`);
+			return;
+		}
+	}
+	async stop(target, expectedPid) {
+		if (!OWNED_TARGET_PATTERN.test(target) || !Number.isInteger(expectedPid) || expectedPid <= 0) return false;
+		const tmux = await this.client();
+		if (!tmux) return false;
+		try {
+			if (await tmux.sessionMissing(target)) return true;
+			const pid = await panePid(tmux, target);
+			if (pid !== expectedPid) return false;
+			const signalled = signalPane(pid, target);
+			if (signalled === "gone") return true;
+			if (signalled === "failed") return false;
+			if (await waitForPaneStop(tmux, target, 3e3)) return true;
+			if (await tmux.sessionMissing(target)) return true;
+			if (await panePid(tmux, target).catch(() => void 0) !== expectedPid) return false;
+			return killSession(tmux, target);
+		} catch (error) {
+			process.emitWarning(`Could not stop tmux target ${target}: ${errorMessage(error)}`);
+			return false;
+		}
+	}
+	async watch(id, target, sessionId) {
+		const tmux = await this.client();
+		if (!tmux) return void 0;
+		if (await tmux.sessionMissing(target)) return void 0;
+		const completion = this.monitor(tmux, target, this.auxPaths(id, sessionId));
+		this.trackCompletion(target, completion);
+		return completion;
+	}
+	async input(target, text) {
+		const tmux = await this.client();
+		if (!tmux) return false;
+		return (await tmux.run([
+			"send-keys",
+			"-t",
+			target,
+			"-l",
+			text
+		]).catch((error) => {
+			process.emitWarning(`Could not send input to tmux target ${target}: ${errorMessage(error)}`);
+		}))?.returnCode === 0;
+	}
+	async capture(target) {
+		const tmux = await this.client();
+		if (!tmux) return void 0;
+		const result = await tmux.run([
+			"capture-pane",
+			"-p",
+			"-t",
+			target
+		]).catch((error) => {
+			process.emitWarning(`Could not capture tmux target ${target}: ${errorMessage(error)}`);
+		});
+		return result?.returnCode === 0 ? result.stdout : void 0;
+	}
+	get(name) {
+		return this.runs.get(name);
+	}
+	readOutcome(id, sessionId) {
+		return readExitMetadata(this.auxPaths(id, sessionId).exit);
+	}
+	trackCompletion(target, completion) {
+		this.completions.set(target, completion);
+		completion.finally(() => this.completions.delete(target)).catch((error) => process.emitWarning(`tmux monitor failed for ${target}: ${errorMessage(error)}`));
+	}
+	client() {
+		this.clientPromise ??= this.resolveClient();
+		return this.clientPromise;
+	}
+	async resolveClient() {
+		const client = this.createClient(socketName(this.paths.repositoryPath()));
+		try {
+			const version = await client.run(["-V"]);
+			if (version.returnCode !== 0) throw new Error(version.stderr.trim() || "tmux reported no version");
+			return client;
+		} catch (error) {
+			process.emitWarning(`tmux is unavailable: ${errorMessage(error)}`);
+			return;
+		}
+	}
+	async checked(tmux, args) {
+		const result = await tmux.run(args);
+		if (result.returnCode !== 0) throw new Error(`tmux ${args[0] ?? ""} failed: ${result.stderr.trim() || `exit ${result.returnCode}`}`);
+	}
+	prepareFiles(request, logPath, aux) {
+		cleanupSupervisorFiles(aux);
+		fs.writeFileSync(logPath, "", { mode: 384 });
+		const env = environment(request.sessionId, request.interactive, this.env);
+		const spec = {
+			command: request.command,
+			cwd: request.cwd,
+			env
+		};
+		writeCommandSpec(aux.spec, spec);
+	}
+	auxPaths(id, sessionId) {
+		return supervisorPaths(this.paths.stateDirectory(sessionId), id);
+	}
+	/**
+	* The sink the pane pipes into.
+	*
+	* An interactive run also asks for a raw copy: the scrubbed log it writes
+	* beside it has had cursor movement taken out, which is what a terminal
+	* needs most. Only interactive runs pay for it, because only they can be
+	* attached to.
+	*/
+	logPipeCommand(logPath, donePath, request) {
+		const id = path.basename(logPath, ".log");
+		return shellJoin([
+			process.execPath,
+			runtimeEntry("logSink"),
+			logPath,
+			this.paths.rotatedLogPathFor(id),
+			String(getLogMaxBytes(this.env)),
+			donePath,
+			...request.interactive ? [this.paths.rawLogPathFor(id)] : []
+		]);
+	}
+	async monitor(tmux, target, aux) {
+		try {
+			const paneCode = await waitForRunEnd(tmux, target, aux.exit);
+			await waitForLogDrain(tmux, target, aux.logDone);
+			return readExitMetadata(aux.exit) ?? {
+				code: paneCode,
+				signal: null
+			};
+		} finally {
+			if (!await tmux.sessionMissing(target).catch(() => false)) await killSession(tmux, target);
+			cleanupSupervisorFiles(aux);
+		}
+	}
+	interactiveRun(handle, tmux, target, completion) {
+		let screen = "";
+		let active = true;
+		const handlers = /* @__PURE__ */ new Set();
+		const refresh = async () => {
+			while (active) {
+				const captured = await tmux.run([
+					"capture-pane",
+					"-p",
+					"-t",
+					target
+				]).catch((error) => {
+					process.emitWarning(`Could not capture tmux screen for ${handle.name}: ${errorMessage(error)}`);
+				});
+				const next = captured?.returnCode === 0 ? captured.stdout : screen;
+				if (next !== screen) {
+					screen = next;
+					for (const handler of handlers) handler(next);
+				}
+				await delay(100);
+			}
+		};
+		refresh();
+		completion.finally(() => {
+			active = false;
+		}).catch((error) => process.emitWarning(`tmux interactive completion failed for ${handle.name}: ${errorMessage(error)}`));
+		return {
+			...handle,
+			write: (text) => {
+				tmux.run([
+					"send-keys",
+					"-t",
+					target,
+					"-l",
+					text
+				]).catch((error) => process.emitWarning(errorMessage(error)));
+			},
+			screen: () => screen,
+			onData: (handler) => {
+				handlers.add(handler);
+				return () => handlers.delete(handler);
+			},
+			resize: (cols, rows) => {
+				tmux.run([
+					"resize-window",
+					"-t",
+					target,
+					"-x",
+					String(cols),
+					"-y",
+					String(rows)
+				]).catch((error) => process.emitWarning(errorMessage(error)));
+			}
+		};
+	}
+};
+function socketName(repositoryPath) {
+	const hash = createHash("sha256").update(repositoryPath).digest("hex").slice(0, 12);
+	return `${SOCKET_PREFIX}${hash}`;
+}
+function environment(sessionId, interactive, env) {
+	const values = {
+		...env,
+		...interactive ? {} : {
+			...NON_INTERACTIVE_ENV,
+			...noninteractiveEnvironment(env)
+		},
+		...NO_TERMINAL_INPUT_ENV,
+		PI_SESSION_ID: sessionId
+	};
+	if (!interactive) delete values["FORCE_COLOR"];
+	return Object.fromEntries(Object.entries(values).filter((entry) => entry[1] !== void 0));
+}
+async function killSession(tmux, target) {
+	return (await tmux.run([
+		"kill-session",
+		"-t",
+		target
+	]).catch((error) => {
+		process.emitWarning(`Could not close tmux target ${target}: ${errorMessage(error)}`);
+	}))?.returnCode === 0;
+}
+async function panePid(tmux, target) {
+	const message = await tmux.format(target, "#{pane_pid}");
+	const pid = Number(message);
+	if (!Number.isInteger(pid) || pid <= 0) throw new Error(`tmux did not report a pane pid for ${target}`);
+	return pid;
+}
+/**
+* Waits for the run to end, preferring the supervisor's own record of it.
+*
+* The sidecar is written before the pane can end and outlives the server the
+* pane's exit takes down, so asking tmux is the fallback for a supervisor that
+* died without recording anything.
+*/
+async function waitForRunEnd(tmux, target, exitPath) {
+	for (;;) {
+		if (fs.existsSync(exitPath)) return null;
+		const state = await readPaneExit(tmux, target);
+		if (state.exited) return state.code;
+		await delay(100);
+	}
+}
+async function waitForLogDrain(tmux, target, donePath) {
+	const deadline = Date.now() + LOG_DRAIN_TIMEOUT_MS;
+	while (Date.now() < deadline) {
+		if (fs.existsSync(donePath)) return;
+		if (await tmux.sessionMissing(target)) return;
+		await delay(25);
+	}
+}
+async function waitForPaneStop(tmux, target, timeoutMs) {
+	const deadline = Date.now() + timeoutMs;
+	while (Date.now() < deadline) {
+		if ((await readPaneExit(tmux, target)).exited) return true;
+		await delay(100);
+	}
+	return false;
+}
+/** One formatted read answers both questions this poll asks. */
+async function readPaneExit(tmux, target) {
+	const message = await tmux.format(target, PANE_STATE_FORMAT);
+	if (message === void 0) return {
+		exited: true,
+		code: null
+	};
+	const [dead, status, ...rest] = message.trim().split(":");
+	if (rest.join(":") === "") return {
+		exited: true,
+		code: null
+	};
+	if (dead === "1" || dead === "true") {
+		const code = Number(status);
+		return {
+			exited: true,
+			code: Number.isInteger(code) ? code : null
+		};
+	}
+	return {
+		exited: false,
+		code: null
+	};
+}
+function signalPane(pid, target) {
+	try {
+		process.kill(pid, "SIGTERM");
+		return "signalled";
+	} catch (error) {
+		if (error.code === "ESRCH") return "gone";
+		process.emitWarning(`Could not signal tmux target ${target}: ${errorMessage(error)}`);
+		return "failed";
+	}
+}
+function readTail(target, maxBytes) {
+	let handle;
+	try {
+		const size = fs.statSync(target).size;
+		const bytes = Math.min(size, maxBytes);
+		const buffer = Buffer.alloc(bytes);
+		handle = fs.openSync(target, "r");
+		fs.readSync(handle, buffer, 0, bytes, size - bytes);
+		return buffer.toString("utf8");
+	} catch (error) {
+		if (error.code !== "ENOENT") process.emitWarning(`Could not read tmux log ${target}: ${errorMessage(error)}`);
+		return "";
+	} finally {
+		if (handle !== void 0) fs.closeSync(handle);
+	}
+}
+function delay(ms) {
+	return new Promise((resolve) => {
+		setTimeout(resolve, ms).unref?.();
+	});
+}
+function errorMessage(error) {
+	return error instanceof Error ? error.message : String(error);
+}
+//#endregion
+//#region src/services/runnerDependencies/index.ts
+/** Build once on first access, then hand back the same instance. */
+function memoize(build) {
+	let value;
+	let built = false;
+	return () => {
+		if (!built) {
+			value = build();
+			built = true;
+		}
+		return value;
+	};
+}
+/**
+* Builds the extension's service graph.
+*
+* A factory rather than a module-level singleton: the extension owns one graph
+* per session, and tests get a fresh one they can substitute ports on through
+* `overrides` without leaking state between cases.
+*
+* Every slot resolves lazily and memoizes, which keeps the previous container's
+* behaviour: nothing is constructed until it is asked for, so opening the SQLite
+* process registry stays deferred until something actually needs a runner.
+*/
+function createRunnerDependencies(overrides) {
+	const settings = overrides.settings === void 0 ? void 0 : Object.freeze({
+		...overrides.settings,
+		...overrides.settings?.errorPatterns ? { errorPatterns: Object.freeze([...overrides.settings.errorPatterns]) } : {}
+	});
+	const environment = { ...overrides.environment };
+	const cwd = overrides.cwd ?? process.cwd();
+	const clock = memoize(() => overrides.clock ?? new SystemClock());
+	const spawner = memoize(() => overrides.spawner ?? new NodeSpawner());
+	const processControl = memoize(() => overrides.processControl ?? new NodeProcessControl());
+	const ptySpawner = memoize(() => overrides.ptySpawner ?? new NodePtySpawner());
+	const paths = memoize(() => overrides.paths ?? new RunnerPaths(cwd, environment));
+	const lifeline = memoize(() => overrides.lifeline ?? new NodeLifeline(paths()));
+	const processRegistry = memoize(() => overrides.processRegistry ?? createDefaultProcessRegistry(environment));
+	const runnerRegistry = memoize(() => overrides.runnerRegistry ?? new RunnerRegistry(paths(), processControl(), processRegistry(), environment));
+	const namer = memoize(() => overrides.namer ?? new RunnerNamer(runnerRegistry()));
+	const logFile = memoize(() => overrides.logFile ?? new LogFile(paths()));
+	const logReader = memoize(() => overrides.logReader ?? new LogReader());
+	const launcher = memoize(() => overrides.launcher ?? new Launcher(spawner(), processControl(), logFile(), clock(), paths(), lifeline(), environment, settings));
+	const rmuxBackend = memoize(() => overrides.rmuxBackend ?? new PtyBackendChain(new RmuxBackend(paths(), environment, settings), new TmuxBackend(paths(), void 0, environment, settings)));
+	const rtkProcessor = memoize(() => overrides.rtkProcessor ?? new RtkProcessor(void 0, void 0, environment, settings));
+	const ptyHost = memoize(() => overrides.ptyHost ?? new PtyHost(ptySpawner(), logFile(), processControl(), clock(), environment, settings));
+	const bashRunService = memoize(() => overrides.bashRunService ?? new BashRunService(launcher(), rmuxBackend(), namer(), runnerRegistry(), clock(), rtkProcessor(), cwd, environment, overrides.executionBudget ?? sharedExecutionBudget(environment)));
+	return {
+		settings,
+		environment,
+		get clock() {
+			return clock();
+		},
+		get spawner() {
+			return spawner();
+		},
+		get processControl() {
+			return processControl();
+		},
+		get ptySpawner() {
+			return ptySpawner();
+		},
+		get paths() {
+			return paths();
+		},
+		get lifeline() {
+			return lifeline();
+		},
+		get processRegistry() {
+			return processRegistry();
+		},
+		get runnerRegistry() {
+			return runnerRegistry();
+		},
+		get namer() {
+			return namer();
+		},
+		get logFile() {
+			return logFile();
+		},
+		get logReader() {
+			return logReader();
+		},
+		get launcher() {
+			return launcher();
+		},
+		get rmuxBackend() {
+			return rmuxBackend();
+		},
+		get rtkProcessor() {
+			return rtkProcessor();
+		},
+		get ptyHost() {
+			return ptyHost();
+		},
+		get bashRunService() {
+			return bashRunService();
+		}
+	};
+}
+//#endregion
+export { TmuxBackend as n, PtyBackendChain as r, createRunnerDependencies as t };
+
+//# sourceMappingURL=runnerDependencies-DruByBGS.mjs.map