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

package/dist/reconcile.d.mts

@@ -0,0 +1,36 @@
+import { t as ILauncher } from "./launcher-BG5t9nvG.mjs";
+import { t as IRmuxBackend } from "./rmuxBackend-CaEWooWn.mjs";
+import { a as RunnerTerminationIntent, i as RunnerRecord, n as IRunnerRegistry } from "./runnerRegistry-CtJiD02R.mjs";
+import { t as IProcessControl } from "./processControl-BAOa3oo_.mjs";
+import { t as IRunnerPaths } from "./type-BXM03qSw.mjs";
+//#region src/services/reconcile/index.d.ts
+interface ReconcileDependencies {
+  registry: IRunnerRegistry;
+  launcher: ILauncher;
+  rmuxBackend: IRmuxBackend;
+  processControl: IProcessControl;
+  currentHostPid: number;
+  startup: boolean;
+  /** Same-host restart cleanup belongs only to this session. */
+  startupSessionId?: string;
+  active?: readonly RunnerRecord[];
+}
+export interface RunnerReconcileResult {
+  reclaimed: string[];
+  errors: string[];
+}
+export declare function stopRunnerProcess(record: RunnerRecord, launcher: ILauncher, rmuxBackend: IRmuxBackend, termination?: {
+  registry: IRunnerRegistry;
+  intent: RunnerTerminationIntent;
+}): Promise<boolean>;
+/** Repairs active registry entries that lost their original completion observer. */
+export declare function reconcileActiveRunners(dependencies: ReconcileDependencies): Promise<RunnerReconcileResult>;
+interface LegacyCleanupDependencies extends Omit<ReconcileDependencies, 'startup'> {
+  paths: IRunnerPaths;
+}
+/** Deletes the legacy Git store only after no live foreign runner uses it. */
+export declare function cleanupLegacyRunnerStore(dependencies: LegacyCleanupDependencies): Promise<RunnerReconcileResult & {
+  removed?: string;
+}>;
+//#endregion
+//# sourceMappingURL=reconcile.d.mts.map

package/dist/reconcile.d.mts.map

@@ -0,0 +1 @@
+{"version":3,"file":"reconcile.d.mts","names":[],"sources":["../src/services/reconcile/index.ts"],"mappings":";;;;;;UAWU;EACR,UAAU;EACV,UAAU;EACV,aAAa;EACb,gBAAgB;EAChB;EACA;;EAEA;EACA,kBAAkB;;iBAGH;EACf;EACA;;wBAGoB,kBACpB,QAAQ,cACR,UAAU,WACV,aAAa,cACb;EAAgB,UAAU;EAAiB,QAAQ;IAClD;;wBAWmB,uBAAuB,cAAc,wBAAwB,QAAQ;UAqFjF,kCAAkC,KAAK;EAC/C,OAAO;;;wBAIa,yBACpB,cAAc,4BACb,QAAQ;EAA0B"}

package/dist/reconcile.mjs

@@ -0,0 +1,2 @@
+import { n as reconcileActiveRunners, r as stopRunnerProcess, t as cleanupLegacyRunnerStore } from "./reconcile-DMeNSxwn.mjs";
+export { cleanupLegacyRunnerStore, reconcileActiveRunners, stopRunnerProcess };

package/dist/responseEnvelope.cjs

@@ -0,0 +1,19 @@
+Object.defineProperty(exports, Symbol.toStringTag, { value: "Module" });
+const require_bashResult = require("./bashResult-DNgtahGR.cjs");
+const require_logReader = require("./logReader-B6J7L7Ua.cjs");
+exports.boundExcerpt = require_bashResult.boundExcerpt;
+exports.boundResultText = require_bashResult.boundResultText;
+exports.collectErrorLines = require_bashResult.collectErrorLines;
+exports.composeExcerpt = require_bashResult.composeExcerpt;
+exports.countLines = require_bashResult.countLines;
+exports.createErrorScanner = require_bashResult.createErrorScanner;
+exports.errorResult = require_bashResult.errorResult;
+exports.formatRunResult = require_bashResult.formatRunResult;
+exports.formatRunnerLine = require_bashResult.formatRunnerLine;
+exports.formatSize = require_bashResult.formatSize;
+exports.formatUptime = require_bashResult.formatUptime;
+exports.parseResultPragma = require_bashResult.parseResultPragma;
+exports.summarizeLog = require_logReader.summarizeLog;
+exports.summarizeText = require_bashResult.summarizeText;
+exports.textResult = require_bashResult.textResult;
+exports.truncateForResult = require_logReader.truncateForResult;

package/dist/responseEnvelope.d.mts

@@ -0,0 +1,50 @@
+import { n as BashRunResult } from "./bashRunService-Ci0cGdYO.mjs";
+import { i as RunnerRecord } from "./runnerRegistry-CtJiD02R.mjs";
+import { a as ResultBudget, c as TruncatedOutput, i as LogSummary, n as Excerpt, o as SalvagedError, r as LogSummarizer, s as ToolResult, t as ErrorLineScanner } from "./bashResult-DcrRaBLv.mjs";
+import { t as RunnerSettings } from "./runnerSettings-DiV1lvzx.mjs";
+import { i as truncateForResult, r as summarizeLog } from "./index-DM7yJpMs.mjs";
+//#region src/services/bashResult/index.d.ts
+export declare function textResult(text: string, details?: Record<string, unknown>): ToolResult;
+export declare function errorResult(message: string): ToolResult;
+/** Human-readable byte count, matching how pi reports output sizes. */
+export declare function formatSize(bytes: number): string;
+export declare function countLines(text: string): number;
+export declare function createErrorScanner(maxEntries?: number, settings?: RunnerSettings): ErrorLineScanner;
+/**
+ * Reads `# @doom: {"maxResultBytes": 32768}` from the command's first line.
+ *
+ * The pragma is a shell comment, so it stays harmless if this parse is ever
+ * skipped, and it survives verbatim into the log where a wider result can be
+ * explained after the fact.
+ */
+export declare function parseResultPragma(command: string): ResultBudget;
+/**
+ * Collapses repeats so one failure repeated two hundred times costs one slot.
+ * Counting continues past the entry cap so the tallies stay honest.
+ */
+export declare function collectErrorLines(lines: Iterable<string>, maxEntries?: number, settings?: RunnerSettings): SalvagedError[];
+/**
+ * Bounds text to the budget, keeping a leading excerpt as well as the tail.
+ *
+ * Failures announce themselves at both ends: a command that could not start
+ * says so on line one, and a command that died says so on the last. Keeping
+ * only the tail loses the first kind entirely.
+ */
+export declare function boundExcerpt(text: string, maxLines?: number, maxBytes?: number, maxTokens?: number, settings?: RunnerSettings): Excerpt;
+/**
+ * Same budget as `boundExcerpt`, for callers that streamed the two ends
+ * separately and never held the middle. `totalLines` counts the whole source,
+ * so the marker states what was dropped rather than what was captured.
+ */
+export declare function composeExcerpt(headSource: string, tailSource: string, totalLines: number, maxLines?: number, maxBytes?: number, errors?: readonly SalvagedError[], maxTokens?: number, settings?: RunnerSettings): Excerpt;
+/** Applies Doom's line and byte ceilings to text already held in memory. */
+export declare function summarizeText(text: string, maxLines?: number, maxBytes?: number): Pick<LogSummary, 'tail' | 'tailLines'>;
+/** Bounds the complete model-facing result after status and recovery text are attached. */
+export declare function boundResultText(text: string, maxBytes?: number, settings?: RunnerSettings, maxTokens?: number): string;
+/** `name  pid 1234  up 3m  sleep 60` — one runner per line. */
+export declare function formatRunnerLine(record: RunnerRecord, now?: number): string;
+export declare function formatUptime(startedAt: string, now: number): string;
+export declare function formatRunResult(result: BashRunResult, budget?: ResultBudget, summarizeLog?: LogSummarizer, settings?: RunnerSettings, environment?: NodeJS.ProcessEnv): ToolResult;
+//#endregion
+export { type ErrorLineScanner, type Excerpt, type LogSummarizer, type LogSummary, type ResultBudget, type SalvagedError, type ToolResult, type TruncatedOutput, summarizeLog, truncateForResult };
+//# sourceMappingURL=responseEnvelope.d.mts.map

package/dist/responseEnvelope.d.mts.map

@@ -0,0 +1 @@
+{"version":3,"file":"responseEnvelope.d.mts","names":[],"sources":["../src/services/bashResult/index.ts"],"mappings":";;;;;;wBAiDgB,WAAW,cAAc,UAAS,0BAA+B;wBAIjE,YAAY,kBAAkB;;wBAK9B,WAAW;wBAUX,WAAW;wBAqCX,mBAAmB,qBAAmC,WAAW,iBAAiB;;;;;;;;wBAiBlF,kBAAkB,kBAAkB;;;;;wBA2DpC,kBACd,OAAO,kBACP,qBACA,WAAW,iBACV;;;;;;;;wBAyLa,aACd,cACA,mBACA,mBACA,oBACA,WAAW,iBACV;;;;;;wBAsCa,eACd,oBACA,oBACA,oBACA,mBACA,mBACA,kBAAiB,iBACjB,oBACA,WAAW,iBACV;;wBAsCa,cACd,cACA,mBACA,oBACC,KAAK;;wBAMQ,gBACd,cACA,mBACA,WAAW,gBACX;;wBAoBc,iBAAiB,QAAQ,cAAc;wBAKvC,aAAa,mBAAmB;wBA+BhC,gBACd,QAAQ,eACR,SAAQ,cACR,eAAc,eACd,WAAW,gBACX,cAAa,OAAO,aACnB"}

package/dist/responseEnvelope.mjs

@@ -0,0 +1,3 @@
+import { a as countLines, c as formatRunResult, d as formatUptime, f as parseResultPragma, i as composeExcerpt, l as formatRunnerLine, m as textResult, n as boundResultText, o as createErrorScanner, p as summarizeText, r as collectErrorLines, s as errorResult, t as boundExcerpt, u as formatSize } from "./bashResult-bIVSzoj-.mjs";
+import { i as truncateForResult, r as summarizeLog } from "./logReader-UfbDbwQl.mjs";
+export { boundExcerpt, boundResultText, collectErrorLines, composeExcerpt, countLines, createErrorScanner, errorResult, formatRunResult, formatRunnerLine, formatSize, formatUptime, parseResultPragma, summarizeLog, summarizeText, textResult, truncateForResult };

package/dist/rmuxBackend-CaEWooWn.d.mts

@@ -0,0 +1,36 @@
+import { t as ExitResult } from "./spawner-CdrN_HNk.mjs";
+import { r as RunHandle } from "./launcher-BG5t9nvG.mjs";
+import { r as PtyRun } from "./ptyHost-DWWtRrGn.mjs";
+//#region src/types/rmuxBackend.d.ts
+interface RmuxLaunchRequest {
+  id: string;
+  name: string;
+  command: string;
+  cwd: string;
+  sessionId: string;
+  interactive: boolean;
+}
+interface IRmuxBackend {
+  /** Returns undefined when no compatible RMUX binary is available before launch. */
+  launch(request: RmuxLaunchRequest): Promise<RunHandle | undefined>;
+  /** Reconnects completion monitoring for a persisted RMUX session. */
+  watch(id: string, target: string, sessionId?: string): Promise<ExitResult | undefined>;
+  /** Reads persisted terminal evidence without contacting RMUX. */
+  readOutcome(id: string, sessionId: string): ExitResult | undefined;
+  stop(target: string, expectedPid: number): Promise<boolean>;
+  input(target: string, text: string): Promise<boolean>;
+  /**
+   * The pane's current screen as text, or undefined when it cannot be read.
+   *
+   * A screen, not a byte stream: the multiplexer holds the rendered state and
+   * hands back what is on it now. That is what makes an attached view possible
+   * from another process, where the live PTY handle is out of reach, and it is
+   * why the log file cannot stand in: it is scrubbed of cursor movement before
+   * it is ever written.
+   */
+  capture(target: string): Promise<string | undefined>;
+  get(name: string): PtyRun | undefined;
+}
+//#endregion
+export { RmuxLaunchRequest as n, IRmuxBackend as t };
+//# sourceMappingURL=rmuxBackend-CaEWooWn.d.mts.map

package/dist/rmuxBackend-CaEWooWn.d.mts.map

@@ -0,0 +1 @@
+{"version":3,"file":"rmuxBackend-CaEWooWn.d.mts","names":[],"sources":["../src/types/rmuxBackend.ts"],"mappings":";;;;UAIiB;EACf;EACA;EACA;EACA;EACA;EACA;;UAGe;;EAEf,OAAO,SAAS,oBAAoB,QAAQ;;EAE5C,MAAM,YAAY,gBAAgB,qBAAqB,QAAQ;;EAE/D,YAAY,YAAY,oBAAoB;EAC5C,KAAK,gBAAgB,sBAAsB;EAC3C,MAAM,gBAAgB,eAAe;;;;;;;;;;EAUrC,QAAQ,iBAAiB;EACzB,IAAI,eAAe"}

package/dist/rmuxBackend-DfyQwJrc.mjs

@@ -0,0 +1,509 @@
+import { g as noninteractiveEnvironment, s as getLogMaxBytes, u as getResultMaxBytes } from "./runnerConfig-BQBlVAXn.mjs";
+import { NO_TERMINAL_INPUT_ENV, cleanupSupervisorFiles, readExitMetadata, runtimeEntry, shellJoin, supervisorPaths, watchForFile, writeCommandSpec } from "./services/runnerSupervisor/index.mjs";
+import { createRequire } from "node:module";
+import { createHash } from "node:crypto";
+import fs from "node:fs";
+import path from "node:path";
+import { RMUX } from "@rmux/sdk";
+//#region src/constants/rmuxBackend.ts
+const RMUX_BINARY_ENV = "PO_RMUX_BINARY";
+const LOG_DRAIN_TIMEOUT_MS = 2e3;
+const PANE_STATE_FORMAT = "#{pane_dead}:#{pane_dead_status}:#{session_name}";
+const PANE_PID_FORMAT = "#{pane_pid}";
+const STOP_CLOSE_TIMEOUT_MS = 1e3;
+const VENDOR_DIRECTORY = "vendor";
+const SESSION_PREFIX = "doom-runner-";
+const OWNED_TARGET_PATTERN = /^doom-runner-[A-Za-z0-9_-]+$/;
+const NON_INTERACTIVE_ENV = {
+	NO_COLOR: "1",
+	CI: "1"
+};
+//#endregion
+//#region src/services/rmuxBackend/index.ts
+/** Pane liveness, its exit status, and whether the session still exists, in one read. */
+const PACKAGE_BY_PLATFORM = {
+	"darwin-arm64": "@agimon-ai/po-runner-rmux-darwin-arm64",
+	"darwin-x64": "@agimon-ai/po-runner-rmux-darwin-x64",
+	"linux-arm64": "@agimon-ai/po-runner-rmux-linux-arm64",
+	"linux-x64": "@agimon-ai/po-runner-rmux-linux-x64"
+};
+var RmuxBackend = class {
+	paths;
+	env;
+	settings;
+	clientPromise;
+	runs = /* @__PURE__ */ new Map();
+	completions = /* @__PURE__ */ new Map();
+	constructor(paths, env = process.env, settings) {
+		this.paths = paths;
+		this.env = env;
+		this.settings = settings;
+	}
+	async launch(request) {
+		const rmux = await this.client();
+		if (!rmux) 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 opened = await rmux.cmd("new-session", "-d", "-P", "-F", PANE_PID_FORMAT, "-s", target, "-c", request.cwd, process.execPath, runtimeEntry("runnerHost"), aux.spec, aux.gate, aux.exit, { check: true });
+			created = true;
+			await rmux.cmd("set-option", "-t", target, "remain-on-exit", "on", { check: true });
+			await rmux.cmd("pipe-pane", "-t", target, this.logPipeCommand(logPath, aux.logDone, request), { check: true });
+			const pane = rmux.session(target).pane(0, 0);
+			const pid = reportedPid(String(opened.stdout ?? "")) ?? await panePid(rmux, target);
+			fs.writeFileSync(aux.gate, "", { mode: 384 });
+			released = true;
+			let buffering = true;
+			const completion = this.monitor(rmux, pane, target, aux);
+			this.trackCompletion(target, completion);
+			const stop = () => this.stop(target, pid);
+			const handle = {
+				id: request.id,
+				name: request.name,
+				pid,
+				logPath,
+				backend: "rmux",
+				backendTarget: target,
+				output: () => buffering ? readTail(logPath, getResultMaxBytes(this.env, this.settings) * 2) : "",
+				completion: () => completion,
+				detach: () => {
+					buffering = false;
+				},
+				stop
+			};
+			if (request.interactive) this.runs.set(request.name, this.interactiveRun(handle, pane, completion));
+			completion.finally(() => this.runs.delete(request.name)).catch((error) => process.emitWarning(`RMUX completion failed for ${target}: ${errorMessage(error)}`));
+			return handle;
+		} catch (error) {
+			if (released) throw error;
+			if (created) await rmux.session(target).kill().catch((cleanupError) => process.emitWarning(`Could not clean up failed RMUX launch ${target}: ${errorMessage(cleanupError)}`));
+			cleanupSupervisorFiles(aux);
+			process.emitWarning(request.interactive ? `RMUX launch unavailable for interactive runner: ${errorMessage(error)}` : `RMUX 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 rmux = await this.client();
+		if (!rmux) return false;
+		try {
+			if (await sessionMissing(rmux, target)) return true;
+			const pid = await panePid(rmux, target);
+			if (pid !== expectedPid) return false;
+			const signalled = signalPane(pid, target);
+			if (signalled === "gone") return true;
+			if (signalled === "failed") return false;
+			if (await waitForPaneStop(rmux, target, 3e3)) return true;
+			if (await sessionMissing(rmux, target)) return true;
+			if (await panePid(rmux, target) !== expectedPid) return false;
+			return closeOwnedSession(rmux, target);
+		} catch (error) {
+			process.emitWarning(`Could not stop RMUX target ${target}: ${errorMessage(error)}`);
+			return false;
+		}
+	}
+	async watch(id, target, sessionId) {
+		const rmux = await this.client();
+		if (!rmux) return void 0;
+		const pane = rmux.session(target).pane(0, 0);
+		try {
+			await rmux.displayMessage("#{pane_id}", { target });
+		} catch (error) {
+			process.emitWarning(`Could not watch RMUX target ${target}: ${errorMessage(error)}`);
+			return;
+		}
+		const completion = this.monitor(rmux, pane, target, this.auxPaths(id, sessionId));
+		this.trackCompletion(target, completion);
+		return completion;
+	}
+	async input(target, text) {
+		const rmux = await this.client();
+		if (!rmux) return false;
+		return await rmux.session(target).pane(0, 0).sendText(text).catch((error) => {
+			process.emitWarning(`Could not send input to RMUX target ${target}: ${errorMessage(error)}`);
+		}) !== void 0;
+	}
+	async capture(target) {
+		const rmux = await this.client();
+		if (!rmux) return void 0;
+		return rmux.session(target).pane(0, 0).captureText().catch((error) => {
+			process.emitWarning(`Could not capture RMUX target ${target}: ${errorMessage(error)}`);
+		});
+	}
+	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(`RMUX monitor failed for ${target}: ${errorMessage(error)}`));
+	}
+	client() {
+		this.clientPromise ??= this.resolveClient();
+		return this.clientPromise;
+	}
+	async resolveClient() {
+		const binaries = [resolveBundledRmuxBinary(import.meta.url, this.env), "rmux"].filter((value) => value !== void 0);
+		for (const binary of binaries) try {
+			if (binary !== "rmux") ensureExecutablePayload(binary);
+			const client = new RMUX({
+				binary,
+				socketName: socketName(this.paths.repositoryPath())
+			});
+			await client.capabilities();
+			return client;
+		} catch (error) {
+			process.emitWarning(`RMUX candidate ${binary} is unavailable: ${errorMessage(error)}`);
+		}
+	}
+	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(rmux, pane, target, aux) {
+		try {
+			const paneCode = await waitForRunEnd(rmux, target, aux.exit);
+			await waitForLogDrain(rmux, target, aux.logDone);
+			return readExitMetadata(aux.exit) ?? {
+				code: paneCode,
+				signal: null
+			};
+		} finally {
+			let timer;
+			const cleanup = async () => {
+				if (!await sessionMissing(rmux, target)) await pane.server.session(target).kill();
+			};
+			try {
+				await Promise.race([cleanup().catch((error) => process.emitWarning(`Could not clean up completed RMUX target ${target}: ${errorMessage(error)}`)), new Promise((resolve) => {
+					timer = setTimeout(() => {
+						process.emitWarning(`Timed out cleaning up RMUX target ${target} after ${STOP_CLOSE_TIMEOUT_MS}ms`);
+						resolve();
+					}, STOP_CLOSE_TIMEOUT_MS);
+				})]);
+			} finally {
+				if (timer) clearTimeout(timer);
+				cleanupSupervisorFiles(aux);
+			}
+		}
+	}
+	interactiveRun(handle, pane, completion) {
+		let screen = "";
+		let active = true;
+		const handlers = /* @__PURE__ */ new Set();
+		const refresh = async () => {
+			while (active) {
+				const next = await pane.captureText().catch((error) => {
+					process.emitWarning(`Could not capture RMUX screen for ${handle.name}: ${errorMessage(error)}`);
+					return 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(`RMUX interactive completion failed for ${handle.name}: ${errorMessage(error)}`));
+		return {
+			...handle,
+			write: (text) => {
+				pane.sendText(text).catch((error) => process.emitWarning(errorMessage(error)));
+			},
+			screen: () => screen,
+			onData: (handler) => {
+				handlers.add(handler);
+				return () => handlers.delete(handler);
+			},
+			resize: (cols, rows) => {
+				pane.resize({
+					width: cols,
+					height: rows
+				}).catch((error) => process.emitWarning(errorMessage(error)));
+			}
+		};
+	}
+};
+function rmuxPackageForTarget(platform, architecture) {
+	const target = `${platform}-${architecture}`;
+	const packageName = PACKAGE_BY_PLATFORM[target];
+	if (!packageName) process.emitWarning(`Bundled RMUX binary is unavailable for unsupported target ${target}`);
+	return packageName;
+}
+function resolveBundledRmuxBinary(moduleUrl = import.meta.url, env = process.env) {
+	const configured = env[RMUX_BINARY_ENV];
+	if (configured !== void 0 && configured !== "") return configured;
+	const packageName = rmuxPackageForTarget(process.platform, process.arch);
+	if (!packageName) return void 0;
+	try {
+		const manifest = createRequire(moduleUrl).resolve(`${packageName}/package.json`);
+		return path.join(path.dirname(manifest), VENDOR_DIRECTORY, "bin", "rmux");
+	} catch (error) {
+		process.emitWarning(`Bundled RMUX binary is unavailable for ${packageName}: ${errorMessage(error)}`);
+		return;
+	}
+}
+/**
+* Make the bundled payload runnable before the launcher is spawned.
+*
+* The prebuilt packages reach npm with plain 0644 files, so the executable bit
+* the build set is not what lands on a user machine. Restoring it on the one
+* binary we spawn is not enough: rmux execs two files of its own,
+* `bin/rmux-daemon` and `libexec/rmux/rmux`, and the launcher fails on that
+* first exec with a permission error. Every file the payload ships is restored
+* here instead, which also covers a helper a later rmux release adds.
+*
+* A configured override (PO_RMUX_BINARY) usually points at a stand-alone
+* binary, so only paths that really sit inside a package vendor tree get the
+* walk. Files that are already executable are left untouched, since chmod on a
+* binary owned by someone else would throw and drop an otherwise usable
+* candidate.
+*/
+function ensureExecutablePayload(binary) {
+	const vendor = path.resolve(path.dirname(binary), "..");
+	const payload = path.basename(vendor) === "vendor" ? fs.readdirSync(vendor, {
+		recursive: true,
+		withFileTypes: true
+	}).filter((entry) => entry.isFile()).map((entry) => path.join(entry.parentPath, entry.name)) : [binary];
+	for (const file of payload) if ((fs.statSync(file).mode & 73) === 0) fs.chmodSync(file, 493);
+}
+function socketName(repositoryPath) {
+	const hash = createHash("sha256").update(repositoryPath).digest("hex").slice(0, 12);
+	return `${SESSION_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 panePid(rmux, target) {
+	const response = await rmux.displayMessage(PANE_PID_FORMAT, { target });
+	const pid = reportedPid(typeof response["message"] === "string" ? response["message"] : "");
+	if (pid === void 0) throw new Error(`RMUX did not report a pane pid for ${target}`);
+	return pid;
+}
+/** A pane pid as rmux prints it, or nothing when the output holds no usable pid. */
+function reportedPid(output) {
+	const pid = Number(output.trim());
+	return Number.isInteger(pid) && pid > 0 ? pid : void 0;
+}
+/**
+* Waits for the run to end, preferring the supervisor's own record of it.
+*
+* The sidecar is written before the command's pane can end, and it outlives the
+* server that the pane's exit takes down with it. Watching for it means a run
+* that finishes inside a poll interval is observed when it finishes rather than
+* on the next tick. Asking the server stays the fallback for a supervisor that
+* died without recording anything.
+*/
+async function waitForRunEnd(rmux, target, exitPath) {
+	const landed = watchForFile(exitPath);
+	let active = true;
+	const readEvidence = async () => {
+		while (active) if (await landed.appeared(100)) return null;
+		return null;
+	};
+	const probePane = async () => {
+		while (active) {
+			await delay(100);
+			if (!active) return null;
+			const state = await readPaneExit(rmux, target);
+			if (state.exited) return state.code;
+		}
+		return null;
+	};
+	try {
+		return await Promise.race([readEvidence(), probePane()]);
+	} finally {
+		active = false;
+		landed.close();
+	}
+}
+/**
+* Gives the log sink a moment to mark the log complete.
+*
+* Normal completion retains the session until the sink records its final
+* writes. A lost session cannot guarantee a later marker, so it ends the wait.
+*/
+async function waitForLogDrain(rmux, target, donePath) {
+	const deadline = Date.now() + LOG_DRAIN_TIMEOUT_MS;
+	const landed = watchForFile(donePath);
+	let active = true;
+	const readEvidence = async () => {
+		while (active && Date.now() < deadline) if (await landed.appeared(25)) return;
+	};
+	const probeSession = async () => {
+		while (active && Date.now() < deadline) {
+			await delay(25);
+			if (!active) return;
+			if (await sessionMissing(rmux, target)) return;
+		}
+	};
+	try {
+		await Promise.race([readEvidence(), probeSession()]);
+	} finally {
+		active = false;
+		landed.close();
+	}
+}
+async function closeOwnedSession(rmux, target) {
+	return new Promise((resolve) => {
+		let settled = false;
+		const finish = (result) => {
+			if (settled) return;
+			settled = true;
+			clearTimeout(timer);
+			resolve(result);
+		};
+		const timer = setTimeout(() => {
+			process.emitWarning(`Timed out closing RMUX target ${target} after ${STOP_CLOSE_TIMEOUT_MS}ms`);
+			finish(false);
+		}, STOP_CLOSE_TIMEOUT_MS);
+		rmux.session(target).kill().then(() => finish(true), (error) => {
+			process.emitWarning(`Could not close RMUX target ${target}: ${errorMessage(error)}`);
+			finish(false);
+		});
+	});
+}
+async function waitForPaneStop(rmux, target, timeoutMs) {
+	const deadline = Date.now() + timeoutMs;
+	while (Date.now() < deadline) {
+		try {
+			if ((await readPaneExit(rmux, target)).exited) return true;
+		} catch (error) {
+			process.emitWarning(`Could not verify RMUX target ${target} stopped: ${errorMessage(error)}`);
+			return false;
+		}
+		await delay(100);
+	}
+	return false;
+}
+/**
+* One formatted read answers both questions this poll asks, so watching a run
+* costs the same single rmux call it always did.
+*/
+async function readPaneExit(rmux, target) {
+	let message;
+	try {
+		const response = await rmux.displayMessage(PANE_STATE_FORMAT, { target });
+		message = typeof response["message"] === "string" ? response["message"] : "";
+	} catch {
+		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
+	};
+}
+/** A session that cannot be found, on a server that may itself be gone. */
+async function sessionMissing(rmux, target) {
+	try {
+		return (await rmux.cmd("has-session", "-t", target)).returnCode !== 0;
+	} catch {
+		return true;
+	}
+}
+/**
+* A pane that was already gone and a signal that could not be delivered are
+* opposite answers to "is it stopped", so they are reported apart.
+*/
+function signalPane(pid, target) {
+	try {
+		process.kill(pid, "SIGTERM");
+		return "signalled";
+	} catch (error) {
+		if (error.code === "ESRCH") return "gone";
+		process.emitWarning(`Could not signal RMUX 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 RMUX 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
+export { rmuxPackageForTarget as n, RmuxBackend as t };
+
+//# sourceMappingURL=rmuxBackend-DfyQwJrc.mjs.map