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

package/dist/extensions/server.mjs

@@ -0,0 +1,1146 @@
+import { c as getLogTtlMs } from "../runnerConfig-BQBlVAXn.mjs";
+import { r as summarizeLog, t as LogReader } from "../logReader-UfbDbwQl.mjs";
+import { n as createHeadlessRunnersCommand, t as createHeadlessBashTool } from "../headless-BGYfIlNk.mjs";
+import { n as reconcileActiveRunners, r as stopRunnerProcess, t as cleanupLegacyRunnerStore } from "../reconcile-DMeNSxwn.mjs";
+import { t as activeRunnerRecovery } from "../compaction-DCw80VZj.mjs";
+import { t as RmuxBackend } from "../rmuxBackend-DfyQwJrc.mjs";
+import { n as TmuxBackend, r as PtyBackendChain, t as createRunnerDependencies } from "../runnerDependencies-DruByBGS.mjs";
+import { n as resolveRunnerStoreDirectory, r as runnerStateDirFor, t as RunnerPaths } from "../runnerPaths-B_dAAeco.mjs";
+import { a as isRunnerRecord, i as formatRunnerStatus, r as formatRunnerFinished } from "../runnerRegistry-CeOHEjBv.mjs";
+import fs from "node:fs";
+import path from "node:path";
+import { resolveRootSessionId } from "@agimon-ai/po-core/childProcess";
+import { composeServerProviderOverrides, defineServerPlugin, packageResourcePath, readPackageResource } from "@agimon-ai/po-core/serverFacet";
+import { composeRootHooks, defineChannel, defineHook, defineResource, defineRoot, defineRoute, defineServerCommand, defineServerTool } from "@agimon-ai/po-core/extensionFile";
+import { DOOM_BACKGROUND_WORK_SERVICE, readDoomBackgroundWorkService } from "@agimon-ai/po-core/backgroundWork";
+import { createDoomTelemetry } from "@agimon-ai/po-telemetry";
+import { CONFIG_DIR_NAME } from "@earendil-works/pi-coding-agent";
+import { Hono } from "hono";
+import { streamSSE } from "hono/streaming";
+import { apiResponse, defineApiRoutes } from "@agimon-ai/po-core/web";
+import { DOOM_HELP_WHEN } from "@agimon-ai/po-core/help";
+//#region src/constants/runnerSettings.ts
+const RUNNER_SETTINGS_FILE = "po-runner.json";
+const RATIO_KEYS = ["headRatio", "errorBudgetRatio"];
+const MAX_RESULT_BYTES_CEILING = 262144;
+const MAX_RESULT_LINES_CEILING = 5e3;
+const MAX_RESULT_TOKENS_CEILING = 1e5;
+//#endregion
+//#region src/constants/runnerRuntime.ts
+const RUNNER_STATUS_KEY = "doom-runner-runners";
+const BACKGROUND_WORK_PROVIDER = "doom-runner";
+const HISTORY_SWEEP_INTERVAL_MS = 6e5;
+//#endregion
+//#region src/constants/webRunners.ts
+const RUNNER_RUNS_TYPE = "runner_runs";
+//#endregion
+//#region src/services/webRunnerRuns/index.ts
+/** How long a finished runner stays in the cockpit's feed after it exited. */
+/** One on-disk metadata record, or undefined when the text is not a runner record. */
+function parseRunnerRecord(raw) {
+	try {
+		const parsed = JSON.parse(raw);
+		return isRunnerRecord(parsed) ? parsed : void 0;
+	} catch {
+		return;
+	}
+}
+function toRunnerRunView(record) {
+	return {
+		id: record.id,
+		name: record.name,
+		pid: record.pid,
+		command: record.command,
+		cwd: record.cwd,
+		interactive: record.interactive,
+		backend: record.backend,
+		state: record.state,
+		promoted: record.promoted,
+		startedAt: record.startedAt,
+		logPath: record.logPath,
+		...record.exit ? { exit: {
+			reason: record.exit.reason,
+			code: record.exit.code,
+			signal: record.exit.signal,
+			...record.exit.terminationReason === void 0 ? {} : { terminationReason: record.exit.terminationReason },
+			...record.exit.stopReason === void 0 ? {} : { stopReason: record.exit.stopReason },
+			finishedAt: record.exit.finishedAt
+		} } : {}
+	};
+}
+function finishedAt(record) {
+	const parsed = record.exit === void 0 ? NaN : Date.parse(record.exit.finishedAt);
+	return Number.isFinite(parsed) ? parsed : Date.parse(record.startedAt);
+}
+/**
+* The feed the cockpit shows: running runners first, newest start first, then
+* the recently finished ones, newest exit first. Finished runners older than
+* the retention window are left out; the registry keeps them for the CLI.
+*/
+function presentRunnerRuns(records, now) {
+	const running = records.filter((record) => record.state === "running").sort((left, right) => right.startedAt.localeCompare(left.startedAt));
+	const finished = records.filter((record) => record.state === "completed" && now - finishedAt(record) <= 6e5).sort((left, right) => finishedAt(right) - finishedAt(left));
+	return [...running, ...finished].map(toRunnerRunView);
+}
+//#endregion
+//#region src/services/runnerServerRuntime/index.ts
+const COMPLETION_RETRY_MS = 1e3;
+function createRunnerServerRuntime(container, directEvents, wakeAgent, execution) {
+	const telemetry = execution ? createDoomTelemetry({
+		serviceName: "doom-runner",
+		packageName: "@agimon-ai/po-runner",
+		cwd: execution.cwd,
+		env: execution.environment,
+		enableLogs: true,
+		enableTraces: true
+	}) : void 0;
+	let sessionId;
+	let recoveredCompactionId;
+	let supervision;
+	let runtimeDisposal;
+	let disposal;
+	let backgroundWorkItems = [];
+	let backgroundWorkProvider;
+	const watched = /* @__PURE__ */ new Set();
+	let unsubscribeWatched;
+	let wakes = Promise.resolve();
+	let closing = false;
+	let retryTimer;
+	let statusTimer;
+	let historyTimer;
+	let historySweep;
+	const sweepHistory = () => {
+		if (closing) return Promise.resolve();
+		historySweep ??= (async () => {
+			const ttl = getLogTtlMs(container.environment);
+			const result = container.paths.sweepHistoryAsync ? await container.paths.sweepHistoryAsync(ttl) : container.paths.sweepHistory(ttl);
+			for (const error of result.errors) process.emitWarning(error);
+		})().catch((error) => process.emitWarning(`Could not sweep doom-runner history: ${String(error)}`)).finally(() => {
+			historySweep = void 0;
+		});
+		return historySweep;
+	};
+	const ensureSession = (requestedSessionId) => {
+		if (closing) return Promise.reject(/* @__PURE__ */ new Error("Runner runtime is closing."));
+		if (sessionId !== void 0 && sessionId !== requestedSessionId) throw new Error(`Runner runtime belongs to session ${sessionId}.`);
+		sessionId ??= requestedSessionId;
+		supervision ??= (async () => {
+			await telemetry?.recordEvent("doom_runner.session_started", { outcome: "started" });
+			if (closing) return;
+			container.paths.setSessionId(requestedSessionId);
+			if (await container.lifeline.arm(requestedSessionId) === void 0) throw new Error("Could not arm runner supervision lifeline.");
+			if (closing) return;
+			const promotedIds = (await container.runnerRegistry.listAll(requestedSessionId)).filter((record) => record.state === "running" && record.promoted).map((record) => record.id);
+			const legacy = await cleanupLegacyRunnerStore({
+				registry: container.runnerRegistry,
+				launcher: container.launcher,
+				rmuxBackend: container.rmuxBackend,
+				processControl: container.processControl,
+				currentHostPid: process.pid,
+				paths: container.paths
+			});
+			for (const error of legacy.errors) process.emitWarning(error);
+			if (closing) return;
+			const reconciled = await reconcileActiveRunners({
+				registry: container.runnerRegistry,
+				launcher: container.launcher,
+				rmuxBackend: container.rmuxBackend,
+				processControl: container.processControl,
+				currentHostPid: process.pid,
+				startup: true,
+				startupSessionId: requestedSessionId
+			});
+			for (const error of reconciled.errors) process.emitWarning(error);
+			await telemetry?.recordEvent("doom_runner.reconciled", {
+				"runner.reclaimed_count": legacy.reclaimed.length + reconciled.reclaimed.length,
+				"runner.error_count": legacy.errors.length + reconciled.errors.length,
+				outcome: legacy.errors.length + reconciled.errors.length === 0 ? "completed" : "degraded"
+			});
+			if (!closing) {
+				unsubscribeRunnerUpdates ??= container.runnerRegistry.subscribe(() => requestPublish(requestedSessionId), requestedSessionId);
+				for (const id of promotedIds) watchRunner(id);
+				requestPublish(requestedSessionId);
+				await sweepHistory();
+				if (closing) return;
+				statusTimer ??= setInterval(() => {
+					refreshSession(requestedSessionId);
+				}, 500);
+				statusTimer.unref?.();
+				historyTimer ??= setInterval(() => {
+					sweepHistory();
+				}, HISTORY_SWEEP_INTERVAL_MS);
+				historyTimer.unref?.();
+			}
+		})().catch((error) => {
+			supervision = void 0;
+			throw error;
+		});
+		return supervision;
+	};
+	const disposeRuntime = () => {
+		runtimeDisposal ??= (async () => {
+			await supervision?.catch((error) => process.emitWarning(`Could not initialize headless runner supervision: ${String(error)}`));
+			const ownedSessionId = sessionId;
+			if (ownedSessionId === void 0) return;
+			const records = await container.runnerRegistry.listBySession(ownedSessionId).catch(() => []);
+			await Promise.all(records.map(async (record) => {
+				try {
+					if (!await stopRunnerProcess(record, container.launcher, container.rmuxBackend, {
+						registry: container.runnerRegistry,
+						intent: {
+							reason: "stopped",
+							terminationReason: "parent_session_cleanup",
+							stopReason: "session ended"
+						}
+					}) && container.processControl.isAlive(record.pid)) {
+						process.emitWarning(`Could not stop runner ${record.id} during session shutdown`);
+						return;
+					}
+					await container.runnerRegistry.complete(record.id, {
+						reason: "stopped",
+						code: null,
+						signal: null,
+						stopReason: "session ended"
+					}, ownedSessionId);
+				} catch (error) {
+					process.emitWarning(`Could not clean up runner ${record.id}: ${String(error)}`);
+				}
+			}));
+			try {
+				await container.ptyHost.disposeAll();
+			} finally {
+				container.lifeline.dispose();
+				container.runnerRegistry.close();
+			}
+		})();
+		return runtimeDisposal;
+	};
+	let refreshInFlight;
+	const refreshSession = (ownedSessionId) => {
+		if (closing) return Promise.resolve();
+		refreshInFlight ??= refreshNow(ownedSessionId).finally(() => {
+			refreshInFlight = void 0;
+		});
+		return refreshInFlight;
+	};
+	const refreshNow = async (ownedSessionId) => {
+		if (closing) return;
+		try {
+			const reconciled = await reconcileActiveRunners({
+				registry: container.runnerRegistry,
+				launcher: container.launcher,
+				rmuxBackend: container.rmuxBackend,
+				processControl: container.processControl,
+				currentHostPid: process.pid,
+				startup: false,
+				active: await container.runnerRegistry.listBySession(ownedSessionId)
+			});
+			for (const error of reconciled.errors) process.emitWarning(error);
+			if (!closing) {
+				requestPublish(ownedSessionId);
+				wakeForFinished(ownedSessionId);
+			}
+		} catch (error) {
+			process.emitWarning(`Could not refresh doom-runner: ${String(error)}`);
+		}
+	};
+	const publishRuns = async (ownedSessionId) => {
+		try {
+			const records = await container.runnerRegistry.listAll(ownedSessionId);
+			if (closing) return;
+			if (execution) {
+				const root = resolveRootSessionId(ownedSessionId, container.environment);
+				const count = (await container.runnerRegistry.list()).filter((record) => (record.rootSessionId ?? record.sessionId) === root).length;
+				if (closing) return;
+				execution.client.setStatus(RUNNER_STATUS_KEY, formatRunnerStatus(count));
+			}
+			if (closing) return;
+			const nextBackgroundWork = records.filter((record) => record.state === "running" || watched.has(record.id)).map((record) => ({
+				id: record.id,
+				sessionId: record.sessionId,
+				label: record.name,
+				...record.state === "running" ? { status: record.state } : {}
+			}));
+			if (JSON.stringify(nextBackgroundWork) !== JSON.stringify(backgroundWorkItems)) {
+				backgroundWorkItems = nextBackgroundWork;
+				backgroundWorkProvider?.update();
+			}
+			directEvents.publish(RUNNER_RUNS_TYPE, ownedSessionId, { runs: presentRunnerRuns(records, Date.now()) });
+		} catch (error) {
+			process.emitWarning(`Could not publish runner state: ${String(error)}`);
+		}
+	};
+	let publishInFlight;
+	let publishAgain = false;
+	let unsubscribeRunnerUpdates;
+	const requestPublish = (ownedSessionId) => {
+		if (closing) return;
+		publishAgain = true;
+		if (publishInFlight !== void 0) return;
+		publishInFlight = (async () => {
+			do {
+				publishAgain = false;
+				await publishRuns(ownedSessionId);
+			} while (publishAgain && !closing);
+		})().catch((error) => {
+			process.emitWarning(`Could not schedule runner state publication: ${String(error)}`);
+		}).finally(() => {
+			publishInFlight = void 0;
+			if (publishAgain) requestPublish(ownedSessionId);
+		});
+	};
+	const wakeForFinished = (ownedSessionId) => {
+		if (closing) return;
+		wakes = wakes.then(async () => {
+			if (closing) return;
+			let retry = false;
+			for (const id of watched) {
+				if (closing) return;
+				try {
+					const record = await container.runnerRegistry.get(id, ownedSessionId);
+					if (closing) return;
+					if (record?.state === "running") continue;
+					if (record) await wakeAgent?.(formatRunnerFinished(record), `runner-finished:${JSON.stringify([ownedSessionId, id])}`);
+					if (record) await telemetry?.recordEvent("doom_runner.process_finished", {
+						outcome: "completed",
+						"runner.exit_code": record.exit?.code ?? 0,
+						"runner.backend": record.backend
+					});
+					watched.delete(id);
+					requestPublish(ownedSessionId);
+				} catch (error) {
+					retry = true;
+					process.emitWarning(`Could not report finished runner ${id}: ${String(error)}`);
+				}
+			}
+			if (retry && !closing && retryTimer === void 0) {
+				retryTimer = setTimeout(() => {
+					retryTimer = void 0;
+					wakeForFinished(ownedSessionId);
+				}, COMPLETION_RETRY_MS);
+				retryTimer.unref?.();
+			}
+			if (watched.size === 0) {
+				clearTimeout(retryTimer);
+				retryTimer = void 0;
+				unsubscribeWatched?.();
+				unsubscribeWatched = void 0;
+			}
+		}).catch((error) => {
+			process.emitWarning(`Could not report a finished runner: ${String(error)}`);
+		});
+	};
+	const watchRunner = (id) => {
+		const ownedSessionId = sessionId;
+		if (!wakeAgent || closing || ownedSessionId === void 0) return;
+		watched.add(id);
+		requestPublish(ownedSessionId);
+		unsubscribeWatched ??= container.runnerRegistry.subscribe(() => wakeForFinished(ownedSessionId), ownedSessionId);
+		wakeForFinished(ownedSessionId);
+	};
+	return {
+		container,
+		activity: {
+			name: "runner",
+			start: async (executionContext) => {
+				await ensureSession(executionContext.sessionId);
+				requestPublish(executionContext.sessionId);
+				return () => {};
+			}
+		},
+		ensureSession,
+		watchRunner,
+		async recoverCompaction(event) {
+			if (event.status !== "completed" || closing || !execution || typeof event.entryId !== "string" || event.entryId === recoveredCompactionId) return;
+			const compacted = (await execution.session.entries()).findLast((entry) => entry.type === "compaction");
+			if (closing || compacted?.id !== event.entryId) return;
+			await ensureSession(execution.sessionId);
+			let records;
+			try {
+				records = await container.runnerRegistry.listBySession(execution.sessionId);
+			} catch {
+				return;
+			}
+			if (closing) return;
+			const active = records.filter((record) => record.state === "running");
+			const text = activeRunnerRecovery(active);
+			if (!text) return;
+			await execution.session.appendMessage?.({
+				type: "doom-runner-compaction",
+				text,
+				display: false,
+				details: {
+					sessionId: execution.sessionId,
+					runnerIds: active.map((record) => record.id)
+				}
+			});
+			if (!closing) recoveredCompactionId = event.entryId;
+		},
+		backgroundWorkPlugin: (context) => {
+			context.inject([DOOM_BACKGROUND_WORK_SERVICE], (serviceContext) => {
+				const service = readDoomBackgroundWorkService(serviceContext);
+				if (!service) return void 0;
+				const registration = service.register({
+					provider: BACKGROUND_WORK_PROVIDER,
+					listActiveWork: () => backgroundWorkItems
+				});
+				backgroundWorkProvider = registration;
+				return () => {
+					registration.dispose();
+					if (backgroundWorkProvider === registration) backgroundWorkProvider = void 0;
+				};
+			});
+		},
+		dispose() {
+			if (disposal) return disposal;
+			closing = true;
+			disposal = (async () => {
+				closing = true;
+				clearInterval(statusTimer);
+				clearInterval(historyTimer);
+				clearTimeout(retryTimer);
+				retryTimer = void 0;
+				watched.clear();
+				unsubscribeWatched?.();
+				unsubscribeWatched = void 0;
+				unsubscribeRunnerUpdates?.();
+				unsubscribeRunnerUpdates = void 0;
+				await wakes;
+				await publishInFlight;
+				await historySweep;
+				await refreshInFlight;
+				try {
+					execution?.client.setStatus(RUNNER_STATUS_KEY, void 0);
+				} catch (error) {
+					process.emitWarning(`Could not clear runner status: ${String(error)}`);
+				}
+				await disposeRuntime();
+				await telemetry?.recordEvent("doom_runner.session_finished", { outcome: "stopped" });
+				await telemetry?.shutdown();
+			})();
+			return disposal;
+		}
+	};
+}
+//#endregion
+//#region src/services/runnerSettings/index.ts
+/** Pi's convention is one JSON file per extension under the config directory. */
+const EMPTY = {
+	settings: {},
+	issues: []
+};
+const COUNT_KEYS = [
+	"maxResultBytes",
+	"maxResultLines",
+	"successMaxResultBytes",
+	"maxResultTokens",
+	"successMaxResultTokens",
+	"errorMaxEntries",
+	"errorMaxVariantsJoined"
+];
+const KNOWN_KEYS = /* @__PURE__ */ new Set([
+	...RATIO_KEYS,
+	...COUNT_KEYS,
+	"errorPatterns"
+]);
+/** Ceilings so a project file cannot flood the model's context. */
+const CEILINGS = {
+	maxResultBytes: MAX_RESULT_BYTES_CEILING,
+	successMaxResultBytes: MAX_RESULT_BYTES_CEILING,
+	maxResultTokens: MAX_RESULT_TOKENS_CEILING,
+	successMaxResultTokens: MAX_RESULT_TOKENS_CEILING,
+	maxResultLines: MAX_RESULT_LINES_CEILING,
+	errorMaxEntries: 100,
+	errorMaxVariantsJoined: 100
+};
+var RunnerSettingsLoader = class {
+	load(cwd, trusted) {
+		if (!trusted) return EMPTY;
+		let raw;
+		try {
+			raw = fs.readFileSync(path.join(cwd, CONFIG_DIR_NAME, RUNNER_SETTINGS_FILE), "utf8");
+		} catch (error) {
+			if (error.code === "ENOENT") return EMPTY;
+			return {
+				settings: {},
+				issues: [`${RUNNER_SETTINGS_FILE} could not be read`]
+			};
+		}
+		let parsed;
+		try {
+			parsed = JSON.parse(raw);
+		} catch {
+			return {
+				settings: {},
+				issues: [`${RUNNER_SETTINGS_FILE} is not valid JSON`]
+			};
+		}
+		return validate(parsed);
+	}
+};
+function validate(parsed) {
+	if (typeof parsed !== "object" || parsed === null || Array.isArray(parsed)) return {
+		settings: {},
+		issues: [`${RUNNER_SETTINGS_FILE} must contain a JSON object`]
+	};
+	const source = parsed;
+	const settings = {};
+	const issues = [];
+	for (const key of Object.keys(source)) if (!KNOWN_KEYS.has(key)) issues.push(`unknown key ${key}`);
+	for (const key of COUNT_KEYS) {
+		const value = source[key];
+		if (value === void 0) continue;
+		if (typeof value !== "number" || !Number.isInteger(value) || value <= 0) {
+			issues.push(`${key} must be a positive integer`);
+			continue;
+		}
+		settings[key] = Math.min(value, CEILINGS[key] ?? value);
+	}
+	for (const key of RATIO_KEYS) {
+		const value = source[key];
+		if (value === void 0) continue;
+		if (typeof value !== "number" || !Number.isFinite(value) || value <= 0 || value >= 1) {
+			issues.push(`${key} must be a number above 0 and below 1`);
+			continue;
+		}
+		settings[key] = value;
+	}
+	const patterns = source.errorPatterns;
+	if (patterns !== void 0) {
+		if (!Array.isArray(patterns) || patterns.some((entry) => typeof entry !== "string")) issues.push("errorPatterns must be an array of strings");
+		else {
+			const accepted = [];
+			for (const pattern of patterns.slice(0, 32)) {
+				if (pattern.length > 512) {
+					issues.push("errorPatterns entry is too long");
+					continue;
+				}
+				try {
+					new RegExp(pattern, "iu");
+					accepted.push(pattern);
+				} catch {
+					issues.push(`errorPatterns entry is not a valid regular expression: ${pattern}`);
+				}
+			}
+			if (accepted.length > 0) settings.errorPatterns = accepted;
+		}
+	}
+	return {
+		settings,
+		issues
+	};
+}
+//#endregion
+//#region src/extensions/workspaces/sessions/(backend)/_lib/serverRoot.ts
+const RUNNER_SERVER_SCOPE_SERVICE = "doom/runner-server-scope";
+const createRunnerServerRoot = ({ host, agent, signal }) => {
+	if (!host.context.directEvents) throw new Error("Runner headless facet requires the session direct event bus.");
+	if (!host.context.cwd || !host.context.environment) throw new Error("Runner headless facet requires session cwd and environment.");
+	const loaded = new RunnerSettingsLoader().load(host.context.cwd, true);
+	const settings = Object.freeze({
+		...loaded.settings,
+		...loaded.settings.errorPatterns ? { errorPatterns: Object.freeze([...loaded.settings.errorPatterns]) } : {}
+	});
+	for (const issue of loaded.issues) process.emitWarning(`${RUNNER_SETTINGS_FILE}: ${issue}`);
+	const dependencies = createRunnerDependencies({
+		settings,
+		cwd: host.context.cwd,
+		environment: host.context.environment,
+		...host.context.executionBudget === void 0 ? {} : { executionBudget: host.context.executionBudget }
+	});
+	const execution = agent?.context;
+	const wakeAgent = execution && (async (content, requestId) => {
+		try {
+			if (!execution.session.admitPrompt) throw new Error("The session cannot admit a runner notification.");
+			await execution.session.admitPrompt(content, "steer", void 0, requestId);
+		} catch (error) {
+			await Promise.resolve().then(() => execution.client.notify({
+				body: String(error),
+				level: "warning"
+			})).catch(() => void 0);
+			throw error;
+		}
+	});
+	const runtime = createRunnerServerRuntime(dependencies, host.context.directEvents, wakeAgent, execution);
+	const bash = (wakeOnExit) => createHeadlessBashTool({ run: async (request) => {
+		await runtime.ensureSession(request.sessionId);
+		const result = await dependencies.bashRunService.run({
+			...request,
+			...signal ? { signal: request.signal ? AbortSignal.any([signal, request.signal]) : signal } : {}
+		});
+		if (wakeOnExit && result.kind === "promoted") runtime.watchRunner(result.id);
+		return result;
+	} }, (path, lines, bytes, tokens) => summarizeLog(path, lines, bytes, tokens, settings), settings, dependencies.environment);
+	const value = {
+		tool: bash(true),
+		remoteTool: bash(false),
+		command: createHeadlessRunnersCommand(dependencies),
+		recoverCompaction: runtime.recoverCompaction
+	};
+	return {
+		value,
+		services: [runtime.backgroundWorkPlugin, (context) => {
+			context.plugin((providerContext) => providerContext.provide(RUNNER_SERVER_SCOPE_SERVICE, value));
+		}],
+		activities: [runtime.activity],
+		onStart: execution ? () => runtime.ensureSession(execution.sessionId) : void 0,
+		onStop: runtime.dispose
+	};
+};
+//#endregion
+//#region src/extensions/workspaces/sessions/(backend)/root.server.ts
+var root_server_default = defineRoot(createRunnerServerRoot);
+//#endregion
+//#region src/services/runnersChannel/index.ts
+function runnerPayload(value) {
+	return typeof value === "object" && value !== null && Array.isArray(value.runs);
+}
+/**
+* The runners data channel consumes lifecycle-owned snapshots from the session
+* server. Durable registry files are read by the owning session only, never by
+* this hub channel.
+*/
+function createRunnersChannel() {
+	return {
+		frameType: RUNNER_RUNS_TYPE,
+		start(host) {
+			const latest = /* @__PURE__ */ new Map();
+			const subscriptions = /* @__PURE__ */ new Map();
+			return {
+				payloadFor(scope) {
+					const runs = latest.get(scope.sessionId);
+					return runs === void 0 ? void 0 : { runs };
+				},
+				sessionAdded(scope) {
+					subscriptions.get(scope.sessionId)?.();
+					latest.delete(scope.sessionId);
+					const unsubscribe = host.directEvents.subscribe(RUNNER_RUNS_TYPE, scope.sessionId, (payload) => {
+						if (!runnerPayload(payload)) return;
+						latest.set(scope.sessionId, payload.runs);
+						host.publish(scope.sessionId, payload);
+					}, { replayLatest: true });
+					subscriptions.set(scope.sessionId, unsubscribe);
+				},
+				sessionRemoved(sessionId) {
+					subscriptions.get(sessionId)?.();
+					subscriptions.delete(sessionId);
+					latest.delete(sessionId);
+				},
+				close() {
+					for (const unsubscribe of subscriptions.values()) unsubscribe();
+					subscriptions.clear();
+					latest.clear();
+				}
+			};
+		}
+	};
+}
+//#endregion
+//#region src/extensions/(backend)/channel/runnerRuns.server.ts
+var runnerRuns_server_default = defineChannel(function runnerRunsChannel() {
+	return createRunnersChannel();
+});
+//#endregion
+//#region src/constants/runnerLogApi.ts
+const LOG_DIR_NAME = "logs";
+const STATE_EXTENSION = ".json";
+const RUNNING_STATE = "running";
+const STATE_POLL_MS = 1e3;
+const HEARTBEAT_MS = 15e3;
+const MAX_LINES = 5e3;
+const SAFE_SEGMENT = /^[\w.@-]+$/;
+const RAW_LOG_SUFFIX = ".raw";
+const NOT_ATTACHABLE = "No attachable runner by that name in this session.";
+//#endregion
+//#region src/constants/webRunnerLog.ts
+const RUNNER_API_BASE_PATH = "runner";
+const RUN_ID_PARAM = "runId";
+const RUNNER_SCREEN_EVENT = "screen";
+const RUNNER_LOG_STREAM_EVENT = "append";
+const RUNNER_LOG_PING_EVENT = "ping";
+//#endregion
+//#region src/services/logTail/index.ts
+/** How often the tail restats the file; the same cadence the CLI's --follow uses. */
+/**
+* Polling tail: read the delta between the last offset and the file's current
+* size, and hand back only complete lines.
+*
+* Same reliability posture as this package's runner watcher: the poll is the
+* mechanism, not an accelerator for a change notification. fs.watchFile only
+* fires when it observes a difference from a baseline it took itself, so a
+* write that lands before its first stat is a change it never reports; a
+* restat every tick has no such window.
+*
+* A write that lands mid-line is common, so the trailing fragment is held
+* until its newline arrives rather than emitted as a line that will change.
+*/
+var LogTail = class {
+	follow(logPath, options) {
+		let offset = options.from;
+		let pending = "";
+		let closed = false;
+		const drain = (size) => {
+			if (size < offset) {
+				offset = 0;
+				pending = "";
+			}
+			if (size === offset) return;
+			const length = size - offset;
+			const buffer = Buffer.alloc(length);
+			const descriptor = fs.openSync(logPath, "r");
+			let bytesRead;
+			try {
+				bytesRead = fs.readSync(descriptor, buffer, 0, length, offset);
+			} finally {
+				fs.closeSync(descriptor);
+			}
+			offset = size;
+			if (bytesRead <= 0) return;
+			pending += buffer.subarray(0, bytesRead).toString("utf8");
+			const lines = pending.split("\n");
+			pending = lines.pop() ?? "";
+			if (lines.length > 0) options.onLines(lines, offset - Buffer.byteLength(pending, "utf8"));
+		};
+		const tick = () => {
+			if (closed) return;
+			try {
+				drain(fs.statSync(logPath).size);
+			} catch (error) {
+				if (error.code === "ENOENT") return;
+				options.onError(error instanceof Error ? error : new Error(String(error)));
+			}
+		};
+		const timer = setInterval(tick, 250);
+		timer.unref?.();
+		return { close() {
+			if (closed) return;
+			closed = true;
+			clearInterval(timer);
+		} };
+	}
+};
+//#endregion
+//#region src/types/webRunnerLog.ts
+/** The named SSE event carrying a RunnerLogStreamEvent payload. */
+/**
+* The named SSE event that carries nothing.
+*
+* A runner can be alive and silent for minutes, which on the wire is
+* indistinguishable from a connection that died. This is sent on a timer so
+* the socket keeps proving itself. Readers that only listen for `append`
+* ignore it, which is what makes it safe to add.
+*/
+/** Query parameter names, shared so the page and the route cannot drift apart. */
+const RUNNER_LOG_PARAMS = {
+	lines: "lines",
+	grep: "grep",
+	ignoreCase: "ignoreCase",
+	contextLines: "contextLines",
+	from: "from"
+};
+//#endregion
+//#region src/types/apiRoutes.ts
+/**
+* This package's routes, as data.
+*
+* No scope and no base path: the build reads both off
+* `src/extensions/workspaces/sessions/(backend)/api/runner/`, so the mount is
+* stated once, by the folder that creates it. This package stated it four times
+* before, once per URL builder, each of them re-spelling `/plugins/` and the
+* session prefix by hand.
+*
+* The Hono app registers these paths verbatim and the browser addresses them,
+* so a path cannot move on one side alone. `:runId` is Hono's own parameter
+* syntax for that reason; a caller supplies the value as `params`, and the
+* client encodes the segment.
+*/
+var apiRoutes_default = defineApiRoutes({
+	log: {
+		method: "GET",
+		path: `/runners/:${RUN_ID_PARAM}/log`,
+		query: [
+			RUNNER_LOG_PARAMS.lines,
+			RUNNER_LOG_PARAMS.grep,
+			RUNNER_LOG_PARAMS.ignoreCase,
+			RUNNER_LOG_PARAMS.contextLines
+		],
+		response: apiResponse()
+	},
+	/**
+	* The live tail of that same log.
+	*
+	* `stream: true`, so the client exposes a URL and no call method: the
+	* consumer is the browser's own `EventSource`, and a relayed call would
+	* buffer a stream that never ends.
+	*/
+	logStream: {
+		method: "GET",
+		path: `/runners/:${RUN_ID_PARAM}/log/stream`,
+		query: [RUNNER_LOG_PARAMS.from],
+		stream: true
+	},
+	/** The unscrubbed pane bytes, for a terminal emulator rather than a reader. */
+	screenStream: {
+		method: "GET",
+		path: `/runners/:${RUN_ID_PARAM}/screen/stream`,
+		query: [RUNNER_LOG_PARAMS.from],
+		stream: true
+	},
+	input: {
+		method: "POST",
+		path: `/runners/:${RUN_ID_PARAM}/screen/input`
+	}
+});
+//#endregion
+//#region src/services/runnerLogApi/index.ts
+/** How often a follow re-reads the record to notice the runner exiting. */
+/**
+* How often a silent but living stream proves it is still there. Short enough
+* that an idle proxy does not reap the socket, long enough to cost nothing.
+*/
+/** Kept in step with LogQuery's own default, so an unasked-for tail is the same size everywhere. */
+/** A page that asks for more than this gets this; the whole point of the route is a bounded read. */
+/** Path segments the client supplies are names, never paths. */
+/** Backends that expose a pane another process can read and write. */
+const MULTIPLEXER_BACKENDS = /* @__PURE__ */ new Set(["rmux", "tmux"]);
+/** Rejects anything that could climb out of the session's own directory before a path is built. */
+function isSafeSegment(value) {
+	return value !== "" && value !== "." && value !== ".." && SAFE_SEGMENT.test(value);
+}
+/**
+* The log file a run wrote, or undefined when there is no such run or its
+* record points somewhere it has no business pointing.
+*
+* The record names its own log path, and that record is written by another
+* process, so the path is checked rather than trusted: it must sit inside this
+* session's own logs directory. Without that check a doctored record would
+* turn this route into an arbitrary file read.
+*/
+function resolveLogFile(stateDir, logsDir, sessionId, runId) {
+	const statePath = path.join(stateDir, `${runId}${STATE_EXTENSION}`);
+	let raw;
+	try {
+		raw = fs.readFileSync(statePath, "utf8");
+	} catch {
+		return;
+	}
+	const record = parseRunnerRecord(raw);
+	if (record === void 0 || record.id !== runId || record.sessionId !== sessionId) return void 0;
+	const resolved = path.resolve(record.logPath);
+	if (resolved !== logsDir && !resolved.startsWith(`${logsDir}${path.sep}`)) return void 0;
+	return record;
+}
+function isRecord(value) {
+	return typeof value === "object" && value !== null && !Array.isArray(value);
+}
+function numberParam(value, fallback, max) {
+	const parsed = value === void 0 ? NaN : Number.parseInt(value, 10);
+	if (!Number.isFinite(parsed) || parsed < 0) return fallback;
+	return Math.min(parsed, max);
+}
+function logQueryOf(url) {
+	const grep = url.searchParams.get(RUNNER_LOG_PARAMS.grep) ?? void 0;
+	return {
+		lines: numberParam(url.searchParams.get(RUNNER_LOG_PARAMS.lines) ?? void 0, 200, MAX_LINES),
+		...grep === void 0 || grep === "" ? {} : { grep },
+		ignoreCase: url.searchParams.get(RUNNER_LOG_PARAMS.ignoreCase) === "true",
+		contextLines: numberParam(url.searchParams.get(RUNNER_LOG_PARAMS.contextLines) ?? void 0, 0, MAX_LINES)
+	};
+}
+/**
+* This package's HTTP surface: one runner's log, as a bounded slice and as a
+* live tail.
+*
+* The routes are mounted inside one session's own server, so they name a runner
+* and nothing else; the session is the host, not a parameter. The reader only
+* ever returns the last N lines of what matched, so both routes stay bounded no
+* matter how large the file on disk is.
+*
+* Paths come from src/types/apiRoutes, the one table the browser's generated
+* client reads too, so this app and the cockpit cannot disagree about where a
+* route lives. They stay relative to the mount the host strips.
+*/
+function createRunnerLogApi(options) {
+	const logReader = options.logReader ?? new LogReader();
+	const logTail = options.logTail ?? new LogTail();
+	const sessionId = options.sessionId;
+	const paths = new RunnerPaths(options.cwd, options.environment);
+	const storeDir = options.storeDir ?? resolveRunnerStoreDirectory(options.environment ?? process.env);
+	const stateDir = options.storeDir === void 0 ? paths.stateDirectory(sessionId) : runnerStateDirFor(storeDir, sessionId);
+	const logsDir = options.storeDir === void 0 ? paths.logDirectory(sessionId) : path.join(storeDir, sessionId, LOG_DIR_NAME);
+	const app = new Hono();
+	let paneBackend = options.pane;
+	const pane = () => {
+		paneBackend ??= (() => {
+			const paths = new RunnerPaths(options.cwd, options.environment);
+			return new PtyBackendChain(new RmuxBackend(paths), new TmuxBackend(paths));
+		})();
+		return paneBackend;
+	};
+	/** The record behind a request, or undefined when this session has no such run. */
+	const runnerOf = (runId) => isSafeSegment(runId) ? resolveLogFile(stateDir, logsDir, sessionId, runId) : void 0;
+	/**
+	* The pane a request may attach to.
+	*
+	* Same posture as the log routes: the record is written by another process,
+	* so nothing on it is trusted until it is checked. The target must be one
+	* this package owns, the run must still be up, and it must have been started
+	* interactive. A non-interactive run has no terminal to type into, and a
+	* subprocess-backed run has no pane at all.
+	*/
+	const attachableOf = (runId) => {
+		const record = runnerOf(runId);
+		if (record === void 0 || record.state !== "running" || record.interactive !== true) return void 0;
+		const target = record.backendTarget;
+		if (target === void 0 || !MULTIPLEXER_BACKENDS.has(record.backend) || !isSafeSegment(target)) return void 0;
+		return {
+			record,
+			target
+		};
+	};
+	app.get(apiRoutes_default.log.path, (context) => {
+		const runId = context.req.param(RUN_ID_PARAM);
+		const record = runnerOf(runId);
+		if (record === void 0) return context.json({ error: `No runner '${runId}' in this session.` }, 404);
+		const body = {
+			...logReader.read(record.logPath, logQueryOf(new URL(context.req.url))),
+			runId,
+			running: record.state === RUNNING_STATE
+		};
+		return context.json(body);
+	});
+	app.get(apiRoutes_default.logStream.path, (context) => {
+		const runId = context.req.param(RUN_ID_PARAM);
+		const record = runnerOf(runId);
+		if (record === void 0) return context.json({ error: `No runner '${runId}' in this session.` }, 404);
+		const from = numberParam(new URL(context.req.url).searchParams.get(RUNNER_LOG_PARAMS.from) ?? void 0, 0, Number.MAX_SAFE_INTEGER);
+		return streamSSE(context, async (stream) => {
+			const send = (event) => stream.writeSSE({
+				event: RUNNER_LOG_STREAM_EVENT,
+				data: JSON.stringify(event)
+			});
+			let pump = Promise.resolve();
+			const queue = (event) => {
+				pump = pump.then(() => send(event)).catch(() => void 0);
+			};
+			let finish = () => void 0;
+			const done = new Promise((resolve) => {
+				finish = resolve;
+			});
+			const handle = logTail.follow(record.logPath, {
+				from,
+				onLines: (lines, completeThrough) => queue({
+					lines,
+					offset: completeThrough
+				}),
+				onError: () => finish()
+			});
+			const poll = setInterval(() => {
+				const current = runnerOf(runId);
+				if (current !== void 0 && current.state === "running") return;
+				queue({
+					lines: [],
+					ended: true
+				});
+				finish();
+			}, STATE_POLL_MS);
+			const heartbeat = setInterval(() => {
+				pump = pump.then(() => stream.writeSSE({
+					event: RUNNER_LOG_PING_EVENT,
+					data: ""
+				})).catch(() => void 0);
+			}, HEARTBEAT_MS);
+			stream.onAbort(() => finish());
+			await done;
+			clearInterval(poll);
+			clearInterval(heartbeat);
+			handle.close();
+			await pump;
+		});
+	});
+	app.get(apiRoutes_default.screenStream.path, (context) => {
+		const runId = context.req.param(RUN_ID_PARAM);
+		const attachable = attachableOf(runId);
+		if (attachable === void 0) return context.json({ error: NOT_ATTACHABLE }, 404);
+		const rawPath = `${attachable.record.logPath}${RAW_LOG_SUFFIX}`;
+		const from = numberParam(new URL(context.req.url).searchParams.get(RUNNER_LOG_PARAMS.from) ?? void 0, 0, Number.MAX_SAFE_INTEGER);
+		return streamSSE(context, async (stream) => {
+			let pump = Promise.resolve();
+			const queue = (event) => {
+				pump = pump.then(() => stream.writeSSE({
+					event: RUNNER_SCREEN_EVENT,
+					data: JSON.stringify(event)
+				})).catch(() => void 0);
+			};
+			let finish = () => void 0;
+			const done = new Promise((resolve) => {
+				finish = resolve;
+			});
+			let offset = from;
+			const drain = () => {
+				let size;
+				try {
+					size = fs.statSync(rawPath).size;
+				} catch {
+					return;
+				}
+				if (size < offset) offset = 0;
+				if (size === offset) return;
+				const length = size - offset;
+				const buffer = Buffer.alloc(length);
+				const descriptor = fs.openSync(rawPath, "r");
+				let read;
+				try {
+					read = fs.readSync(descriptor, buffer, 0, length, offset);
+				} finally {
+					fs.closeSync(descriptor);
+				}
+				if (read <= 0) return;
+				offset += read;
+				queue({
+					chunk: buffer.subarray(0, read).toString("base64"),
+					offset
+				});
+			};
+			const poll = setInterval(() => {
+				const current = runnerOf(runId);
+				drain();
+				if (current === void 0 || current.state !== "running") {
+					queue({
+						chunk: "",
+						offset,
+						ended: true
+					});
+					finish();
+				}
+			}, 100);
+			stream.onAbort(() => finish());
+			await done;
+			clearInterval(poll);
+			await pump;
+		});
+	});
+	/**
+	* Types into a live pane.
+	*
+	* This is the one route in the package that writes rather than reads, so it
+	* is deliberately narrow: an owned target, still running, started
+	* interactive, and a body that is nothing but text.
+	*/
+	app.post(apiRoutes_default.input.path, async (context) => {
+		const runId = context.req.param(RUN_ID_PARAM);
+		const attachable = attachableOf(runId);
+		if (attachable === void 0) return context.json({ error: NOT_ATTACHABLE }, 404);
+		let body;
+		try {
+			body = await context.req.json();
+		} catch {
+			return context.json({ error: "Expected a JSON body carrying text." }, 400);
+		}
+		const text = isRecord(body) ? body.text : void 0;
+		if (typeof text !== "string" || text === "") return context.json({ error: "Expected a non-empty text." }, 400);
+		if (text.length > 4096) return context.json({ error: "That is more input than a pane takes." }, 413);
+		if (!await pane().input(attachable.target, text)) return context.json({ error: "The runner did not take the input." }, 502);
+		return context.json({ delivered: true });
+	});
+	return app;
+}
+//#endregion
+//#region src/extensions/workspaces/sessions/(backend)/api/runner/route.server.ts
+/**
+* Mounts this package's HTTP API at `runner`, which the folder names.
+*
+* The folder is the declaration: the build reads the base path off it and hands
+* the browser a client bound to the same segment, so the mount is stated once
+* rather than in a constant and in four URL builders that were each free to
+* drift.
+*/
+var route_server_default = defineRoute({
+	basePath: RUNNER_API_BASE_PATH,
+	start(context) {
+		const app = createRunnerLogApi({
+			sessionId: context.sessionId ?? "",
+			cwd: context.cwd,
+			environment: context.environment
+		});
+		return {
+			fetch: (request) => app.fetch(request),
+			close: () => void 0
+		};
+	}
+});
+//#endregion
+//#region src/extensions/workspaces/sessions/(backend)/command/runners.server.ts
+var runners_server_default = defineServerCommand((context) => context.root.command);
+//#endregion
+//#region src/extensions/workspaces/sessions/(backend)/hook/session-compact.server.ts
+var session_compact_server_default = defineHook(({ root }) => ({
+	event: "session_compact",
+	handle: root.recoverCompaction
+}));
+//#endregion
+//#region src/extensions/workspaces/sessions/(backend)/resource/po-use-runner.server.ts
+var po_use_runner_server_default = defineResource({
+	name: "po-use-runner",
+	description: "Use Doom Pi Runner to supervise shell commands, inspect durable logs, provide interactive input, and stop background runs.",
+	when: DOOM_HELP_WHEN,
+	kind: "skill",
+	path: packageResourcePath(import.meta.url, "src/prompts/po-use-runner/SKILL.md"),
+	read: () => readPackageResource(import.meta.url, "src/prompts/po-use-runner/SKILL.md")
+});
+//#endregion
+//#region src/extensions/workspaces/sessions/(backend)/tool/bash.server.ts
+var bash_server_default = defineServerTool((context) => context.root.tool);
+//#endregion
+//#region generated/server.ts
+const at = (value, context) => typeof value === "function" ? value(context) : value;
+const via = (identity, value) => value === void 0 ? void 0 : {
+	...identity,
+	...value
+};
+const facet = defineServerPlugin({
+	name: "@agimon-ai/po-runner",
+	providerOverrides: composeServerProviderOverrides(root_server_default),
+	global: () => ({ get channels() {
+		return [() => via({ frameType: "runner_runs" }, runnerRuns_server_default())];
+	} }),
+	workspace: () => ({ get channels() {
+		return [() => via({ frameType: "runner_runs" }, runnerRuns_server_default())];
+	} }),
+	session: async (context) => {
+		const scopeSession = await root_server_default(context);
+		const contextSession = {
+			...context,
+			root: scopeSession.value
+		};
+		return {
+			...composeRootHooks(scopeSession),
+			get api() {
+				return [at(route_server_default, contextSession)];
+			},
+			get channels() {
+				return [() => via({ frameType: "runner_runs" }, runnerRuns_server_default())];
+			},
+			get commands() {
+				return [via({ name: "runners" }, at(runners_server_default, contextSession))];
+			},
+			get hooks() {
+				return [via({ event: "session_compact" }, at(session_compact_server_default, contextSession))];
+			},
+			get resources() {
+				return [at(po_use_runner_server_default, contextSession)];
+			},
+			get tools() {
+				return [via({ name: "bash" }, at(bash_server_default, contextSession))];
+			},
+			services: [...scopeSession.services ?? []],
+			get activities() {
+				return [...scopeSession.activities ?? []];
+			}
+		};
+	}
+});
+//#endregion
+export { facet as default, facet };
+
+//# sourceMappingURL=server.mjs.map