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

package/dist/headless-CHUsBGhg.cjs

@@ -0,0 +1,180 @@
+const require_runnerConfig = require("./runnerConfig-D2tGq5ZM.cjs");
+const require_bashTool = require("./bashTool-CdgtqVFD.cjs");
+const require_bashResult = require("./bashResult-DNgtahGR.cjs");
+const require_reconcile = require("./reconcile-BugwYFbV.cjs");
+//#region src/constants/headless.ts
+const MS_PER_SECOND = 1e3;
+//#endregion
+//#region src/constants/runners.ts
+const COMMAND_NAME = "runners";
+const SERVER_COMMAND_DESCRIPTION = "Start and stop supervised background runners without a terminal UI.";
+//#endregion
+//#region src/services/runnersCommand/index.ts
+/** Splits on whitespace but keeps a double-quoted run together, so a path with spaces survives. */
+function tokenize(text) {
+	return text.match(/(?:"[^"]*"|\S)+/gu) ?? [];
+}
+function unquote(value) {
+	return value.length >= 2 && value.startsWith("\"") && value.endsWith("\"") ? value.slice(1, -1) : value;
+}
+/**
+* Parses `start`'s tail: `key=value` pairs up to the separator, then the
+* command verbatim.
+*
+* Without a separator the whole tail is the command, so typing
+* `/runners start pnpm build` does what it looks like. Options are read only
+* when a separator says where they end, which is what keeps a command such as
+* `FOO=bar pnpm test` from being mistaken for one.
+*/
+function parseStart(tail) {
+	const tokens = tokenize(tail);
+	const separator = tokens.indexOf("--");
+	if (separator === -1) return {
+		kind: "start",
+		command: tail.trim(),
+		interactive: false
+	};
+	const request = {
+		kind: "start",
+		command: tail.slice(tail.indexOf("--") + 2).trim(),
+		interactive: false
+	};
+	for (const token of tokens.slice(0, separator)) {
+		const split = token.indexOf("=");
+		if (split <= 0) continue;
+		const value = unquote(token.slice(split + 1));
+		const key = token.slice(0, split);
+		if (key === "name" && value !== "") request.name = value;
+		if (key === "cwd" && value !== "") request.cwd = value;
+		if (key === "interactive") request.interactive = value === "true";
+	}
+	return request;
+}
+/**
+* Parses `/runners` arguments. Anything other than a known verb opens Runner
+* Space, which is what the bare command has always done.
+*/
+function parseRunnersCommand(args) {
+	const trimmed = args.trim();
+	const [verb = "", id = "", ...rest] = trimmed.split(/\s+/u).filter(Boolean);
+	if (verb === "start") return parseStart(trimmed.slice(verb.length).trim());
+	if (verb !== "stop") return { kind: "space" };
+	const reason = rest.join(" ").trim();
+	return {
+		kind: "stop",
+		id,
+		...reason ? { reason } : {}
+	};
+}
+//#endregion
+//#region src/services/headless/index.ts
+function createHeadlessBashTool(bashRunService, summarizeLog, settings, environment = process.env) {
+	return {
+		name: require_bashTool.BASH_TOOL_NAME,
+		label: require_bashTool.BASH_TOOL_LABEL,
+		description: "Execute one Bash command in the current working directory. Foreground commands return bounded output; commands that outlive the threshold return a supervised runner id and streaming log path.",
+		promptSnippet: "Execute shell commands with bounded foreground output and supervised background runners",
+		promptGuidelines: [
+			`A command still running after ${Math.round(require_runnerConfig.getBackgroundThresholdMs() / MS_PER_SECOND)} seconds remains active as a background runner with an id and streaming log path.`,
+			"Pass background: true for commands that should remain active, such as dev servers, watchers, and tails.",
+			"Stop background runners when they are no longer needed."
+		],
+		parameters: require_bashTool.BashParamsSchema,
+		executionMode: "serial",
+		execute: async (_toolCallId, params, signal, onUpdate, context) => {
+			const { command, timeout, background, interactive, name } = params;
+			if (signal?.aborted) throw new Error("Operation aborted");
+			if (onUpdate) onUpdate(require_bashResult.textResult(`Starting ${interactive === true ? "interactive runner" : background === true ? "background runner" : "command"}...`));
+			let onOutput;
+			if (background !== true && interactive !== true && onUpdate) onOutput = (output) => onUpdate(require_bashResult.textResult(output));
+			const result = await bashRunService.run({
+				command,
+				timeoutMs: timeout === void 0 ? void 0 : timeout * MS_PER_SECOND,
+				background,
+				interactive,
+				name,
+				...onOutput ? { onOutput } : {},
+				...signal ? { signal } : {},
+				cwd: context.cwd,
+				sessionId: context.sessionId
+			});
+			if (signal?.aborted) throw new Error("Operation aborted");
+			return require_bashResult.formatRunResult(result, require_bashResult.parseResultPragma(command), summarizeLog, settings, environment);
+		}
+	};
+}
+function createHeadlessRunnersCommand(dependencies) {
+	return {
+		name: COMMAND_NAME,
+		description: SERVER_COMMAND_DESCRIPTION,
+		async execute(args, context) {
+			const request = parseRunnersCommand(args);
+			if (request.kind === "space") {
+				const active = await dependencies.runnerRegistry.listBySession(context.sessionId);
+				await context.client.notify({
+					body: `${active.length} active runner${active.length === 1 ? "" : "s"}.`,
+					level: "info"
+				});
+				return;
+			}
+			if (request.kind === "start") {
+				if (!request.command) throw new Error("Usage: /runners start [name=x] [cwd=y] [interactive=true] -- <command>");
+				const result = await dependencies.bashRunService.run({
+					command: request.command,
+					background: true,
+					sessionId: context.sessionId,
+					cwd: request.cwd === void 0 ? context.cwd : request.cwd,
+					...request.name ? { name: request.name } : {},
+					...request.interactive ? { interactive: true } : {}
+				});
+				await context.client.notify({
+					body: require_bashResult.formatRunResult(result, {}, void 0, dependencies.settings, dependencies.environment).content[0]?.text ?? "Runner started.",
+					level: "info"
+				});
+				return;
+			}
+			if (!request.id) throw new Error("Usage: /runners stop <runner-id> [reason]");
+			const record = await dependencies.runnerRegistry.get(request.id, context.sessionId);
+			if (!record) {
+				await context.client.notify({
+					body: `No active runner ${request.id} in this session.`,
+					level: "warning"
+				});
+				return;
+			}
+			const stopped = await require_reconcile.stopRunnerProcess(record, dependencies.launcher, dependencies.rmuxBackend, {
+				registry: dependencies.runnerRegistry,
+				intent: {
+					reason: "stopped",
+					terminationReason: "user_stop",
+					...request.reason ? { stopReason: request.reason } : {}
+				}
+			});
+			if (stopped) await dependencies.runnerRegistry.complete(request.id, {
+				reason: "stopped",
+				code: null,
+				signal: null,
+				...request.reason ? { stopReason: request.reason } : {}
+			}, context.sessionId);
+			await context.client.notify({
+				body: stopped ? `Stopped runner ${request.id}.` : `Could not stop runner ${request.id}.`,
+				level: stopped ? "info" : "error"
+			});
+		}
+	};
+}
+//#endregion
+Object.defineProperty(exports, "createHeadlessBashTool", {
+	enumerable: true,
+	get: function() {
+		return createHeadlessBashTool;
+	}
+});
+Object.defineProperty(exports, "createHeadlessRunnersCommand", {
+	enumerable: true,
+	get: function() {
+		return createHeadlessRunnersCommand;
+	}
+});
+
+//# sourceMappingURL=headless-CHUsBGhg.cjs.map

package/dist/headless-CHUsBGhg.cjs.map

@@ -0,0 +1 @@
+{"version":3,"file":"headless-CHUsBGhg.cjs","names":["BASH_TOOL_NAME","BASH_TOOL_LABEL","getBackgroundThresholdMs","BashParamsSchema","textResult","formatRunResult","parseResultPragma","stopRunnerProcess"],"sources":["../src/constants/headless.ts","../src/constants/runners.ts","../src/constants/runnersCommand.ts","../src/services/runnersCommand/index.ts","../src/services/headless/index.ts"],"sourcesContent":["export const MS_PER_SECOND = 1000;\n","export const COMMAND_NAME = 'runners';\nexport const COMMAND_DESCRIPTION =\n  'Open Runner Space: background processes started by bash. `/runners stop <id> [reason]` stops one, `/runners start [name=x] [cwd=y] [interactive=true] -- <command>` starts one.';\nexport const SERVER_COMMAND_DESCRIPTION = 'Start and stop supervised background runners without a terminal UI.';\n","export const RUNNERS_STOP_VERB = 'stop';\nexport const RUNNERS_START_VERB = 'start';\nexport const RUNNERS_COMMAND_SEPARATOR = '--';\nexport const NAME_KEY = 'name';\nexport const CWD_KEY = 'cwd';\nexport const INTERACTIVE_KEY = 'interactive';\n","import {\n  CWD_KEY,\n  INTERACTIVE_KEY,\n  NAME_KEY,\n  RUNNERS_COMMAND_SEPARATOR,\n  RUNNERS_START_VERB,\n  RUNNERS_STOP_VERB,\n} from '../../constants/runnersCommand';\n/** The `/runners` verb that stops one runner without opening Runner Space. */\n/** The `/runners` verb that starts one, for a client that cannot call the bash tool. */\n/**\n * Ends the options and begins the command.\n *\n * A command is arbitrary shell: it may hold `=`, and it may hold flags of its\n * own (`pnpm test -- --watch`). Only the first of these is the separator, so\n * everything the reader typed survives intact after it.\n */\n\nexport interface RunnersStartRequest {\n  kind: 'start';\n  /** The shell command to run; empty when the reader gave none. */\n  command: string;\n  cwd?: string;\n  name?: string;\n  interactive: boolean;\n}\n\nexport type RunnersCommandRequest =\n  /** No arguments: open Runner Space. */\n  | { kind: 'space' }\n  /** `stop <id> [reason]`: stop one runner headlessly; id is empty when it was left out. */\n  | { kind: 'stop'; id: string; reason?: string }\n  /** `start [key=value ...] -- <command>`: start one headlessly. */\n  | RunnersStartRequest;\n\n/** Splits on whitespace but keeps a double-quoted run together, so a path with spaces survives. */\nfunction tokenize(text: string): string[] {\n  return text.match(/(?:\"[^\"]*\"|\\S)+/gu) ?? [];\n}\n\nfunction unquote(value: string): string {\n  return value.length >= 2 && value.startsWith('\"') && value.endsWith('\"') ? value.slice(1, -1) : value;\n}\n\n/**\n * Parses `start`'s tail: `key=value` pairs up to the separator, then the\n * command verbatim.\n *\n * Without a separator the whole tail is the command, so typing\n * `/runners start pnpm build` does what it looks like. Options are read only\n * when a separator says where they end, which is what keeps a command such as\n * `FOO=bar pnpm test` from being mistaken for one.\n */\nfunction parseStart(tail: string): RunnersStartRequest {\n  const tokens = tokenize(tail);\n  const separator = tokens.indexOf(RUNNERS_COMMAND_SEPARATOR);\n  if (separator === -1) return { kind: 'start', command: tail.trim(), interactive: false };\n\n  const request: RunnersStartRequest = {\n    kind: 'start',\n    // Sliced from the raw text rather than rejoined from tokens: rejoining\n    // would collapse the spacing the reader wrote.\n    command: tail.slice(tail.indexOf(RUNNERS_COMMAND_SEPARATOR) + RUNNERS_COMMAND_SEPARATOR.length).trim(),\n    interactive: false,\n  };\n  for (const token of tokens.slice(0, separator)) {\n    const split = token.indexOf('=');\n    if (split <= 0) continue;\n    const value = unquote(token.slice(split + 1));\n    const key = token.slice(0, split);\n    if (key === NAME_KEY && value !== '') request.name = value;\n    if (key === CWD_KEY && value !== '') request.cwd = value;\n    if (key === INTERACTIVE_KEY) request.interactive = value === 'true';\n  }\n  return request;\n}\n\n/**\n * Parses `/runners` arguments. Anything other than a known verb opens Runner\n * Space, which is what the bare command has always done.\n */\nexport function parseRunnersCommand(args: string): RunnersCommandRequest {\n  const trimmed = args.trim();\n  const [verb = '', id = '', ...rest] = trimmed.split(/\\s+/u).filter(Boolean);\n  if (verb === RUNNERS_START_VERB) return parseStart(trimmed.slice(verb.length).trim());\n  if (verb !== RUNNERS_STOP_VERB) return { kind: 'space' };\n  const reason = rest.join(' ').trim();\n  return { kind: 'stop', id, ...(reason ? { reason } : {}) };\n}\n","import type {\n  DoomHeadlessCommand,\n  DoomHeadlessExecutionContext,\n  DoomHeadlessTool,\n  DoomHeadlessToolResult,\n} from '@agimon-ai/po-core/headless';\n\nimport { BASH_TOOL_LABEL, BASH_TOOL_NAME } from '../../constants/bashTool';\nimport { MS_PER_SECOND } from '../../constants/headless';\nimport { COMMAND_NAME, SERVER_COMMAND_DESCRIPTION } from '../../constants/runners';\nimport { type BashParams, BashParamsSchema } from '../../schemas/bashTool';\nimport { formatRunResult, parseResultPragma, textResult } from '../../services/bashResult';\nimport { stopRunnerProcess } from '../../services/reconcile';\nimport { getBackgroundThresholdMs } from '../../services/runnerConfig';\nimport type { RunnerDependencies } from '../../services/runnerDependencies/type';\nimport { parseRunnersCommand } from '../../services/runnersCommand';\nimport { type LogSummarizer } from '../../types/bashResult';\nimport type { IBashRunService } from '../../types/bashRunService';\nimport type { RunnerSettings } from '../../types/runnerSettings';\n\nexport function createHeadlessBashTool(\n  bashRunService: IBashRunService,\n  summarizeLog?: LogSummarizer,\n  settings?: RunnerSettings,\n  environment: NodeJS.ProcessEnv = process.env,\n): DoomHeadlessTool<typeof BashParamsSchema> {\n  return {\n    name: BASH_TOOL_NAME,\n    label: BASH_TOOL_LABEL,\n    description:\n      'Execute one Bash command in the current working directory. Foreground commands return bounded output; commands that outlive the threshold return a supervised runner id and streaming log path.',\n    promptSnippet: 'Execute shell commands with bounded foreground output and supervised background runners',\n    promptGuidelines: [\n      `A command still running after ${Math.round(getBackgroundThresholdMs() / MS_PER_SECOND)} seconds remains active as a background runner with an id and streaming log path.`,\n      'Pass background: true for commands that should remain active, such as dev servers, watchers, and tails.',\n      'Stop background runners when they are no longer needed.',\n    ],\n    parameters: BashParamsSchema,\n    executionMode: 'serial',\n    execute: async (\n      _toolCallId: string,\n      params: BashParams,\n      signal: AbortSignal | undefined,\n      onUpdate: ((result: DoomHeadlessToolResult) => void) | undefined,\n      context: DoomHeadlessExecutionContext,\n    ) => {\n      const { command, timeout, background, interactive, name } = params;\n      if (signal?.aborted) throw new Error('Operation aborted');\n      if (onUpdate)\n        onUpdate(\n          textResult(\n            `Starting ${interactive === true ? 'interactive runner' : background === true ? 'background runner' : 'command'}...`,\n          ),\n        );\n      let onOutput: ((output: string) => void) | undefined;\n      if (background !== true && interactive !== true && onUpdate) onOutput = (output) => onUpdate(textResult(output));\n      const result = await bashRunService.run({\n        command,\n        timeoutMs: timeout === undefined ? undefined : timeout * MS_PER_SECOND,\n        background,\n        interactive,\n        name,\n        ...(onOutput ? { onOutput } : {}),\n        ...(signal ? { signal } : {}),\n        cwd: context.cwd,\n        sessionId: context.sessionId,\n      });\n      if (signal?.aborted) throw new Error('Operation aborted');\n      return formatRunResult(result, parseResultPragma(command), summarizeLog, settings, environment);\n    },\n  };\n}\n\nexport function createHeadlessRunnersCommand(dependencies: RunnerDependencies): DoomHeadlessCommand {\n  return {\n    name: COMMAND_NAME,\n    description: SERVER_COMMAND_DESCRIPTION,\n    async execute(args: string, context: DoomHeadlessExecutionContext) {\n      const request = parseRunnersCommand(args);\n      if (request.kind === 'space') {\n        const active = await dependencies.runnerRegistry.listBySession(context.sessionId);\n        await context.client.notify({\n          body: `${active.length} active runner${active.length === 1 ? '' : 's'}.`,\n          level: 'info',\n        });\n        return;\n      }\n      if (request.kind === 'start') {\n        if (!request.command) throw new Error('Usage: /runners start [name=x] [cwd=y] [interactive=true] -- <command>');\n        const result = await dependencies.bashRunService.run({\n          command: request.command,\n          background: true,\n          sessionId: context.sessionId,\n          cwd: request.cwd === undefined ? context.cwd : request.cwd,\n          ...(request.name ? { name: request.name } : {}),\n          ...(request.interactive ? { interactive: true } : {}),\n        });\n        await context.client.notify({\n          body:\n            formatRunResult(result, {}, undefined, dependencies.settings, dependencies.environment).content[0]?.text ??\n            'Runner started.',\n          level: 'info',\n        });\n        return;\n      }\n      if (!request.id) throw new Error('Usage: /runners stop <runner-id> [reason]');\n      const record = await dependencies.runnerRegistry.get(request.id, context.sessionId);\n      if (!record) {\n        await context.client.notify({ body: `No active runner ${request.id} in this session.`, level: 'warning' });\n        return;\n      }\n      const stopped = await stopRunnerProcess(record, dependencies.launcher, dependencies.rmuxBackend, {\n        registry: dependencies.runnerRegistry,\n        intent: {\n          reason: 'stopped',\n          terminationReason: 'user_stop',\n          ...(request.reason ? { stopReason: request.reason } : {}),\n        },\n      });\n      if (stopped) {\n        await dependencies.runnerRegistry.complete(\n          request.id,\n          {\n            reason: 'stopped',\n            code: null,\n            signal: null,\n            ...(request.reason ? { stopReason: request.reason } : {}),\n          },\n          context.sessionId,\n        );\n      }\n      await context.client.notify({\n        body: stopped ? `Stopped runner ${request.id}.` : `Could not stop runner ${request.id}.`,\n        level: stopped ? 'info' : 'error',\n      });\n    },\n  };\n}\n"],"mappings":"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"}

package/dist/index-BZL7keVW.d.mts

@@ -0,0 +1,31 @@
+import { c as RtkProcessResult, o as RtkFilter, s as RtkProcessRequest, t as IRtkProcessor } from "./rtkProcessor-CVZvNhkJ.mjs";
+import { t as RunnerSettings } from "./runnerSettings-DiV1lvzx.mjs";
+//#region src/services/rtkProcessor/index.d.ts
+type BinaryResolver = () => string | undefined;
+declare class RtkProcessor implements IRtkProcessor {
+  private readonly resolveBinary;
+  private readonly timeoutMs;
+  private readonly env;
+  private readonly settings?;
+  /**
+   * Latched once a binary proves unrunnable on this host.
+   *
+   * A glibc build installed on a musl host satisfies os and cpu, so it
+   * resolves and then fails to exec. Without this the same doomed spawn is
+   * paid on every command, and each one is reported as a processing failure
+   * rather than the absence it actually is.
+   */
+  private unrunnable;
+  constructor(resolveBinary?: BinaryResolver, timeoutMs?: number, env?: Readonly<Record<string, string | undefined>>, settings?: RunnerSettings | undefined);
+  process(request: RtkProcessRequest): Promise<RtkProcessResult>;
+  private pipe;
+}
+/**
+ * Classifies only whitespace-delimited single commands. Shell syntax, expansion,
+ * quoting, and globbing are rejected instead of being partially interpreted.
+ */
+declare function classifyRtkFilter(command: string): RtkFilter | undefined;
+declare function rtkPackageForTarget(platform: string, architecture: string): string | undefined;
+//#endregion
+export { classifyRtkFilter as n, rtkPackageForTarget as r, RtkProcessor as t };
+//# sourceMappingURL=index-BZL7keVW.d.mts.map

package/dist/index-BZL7keVW.d.mts.map

@@ -0,0 +1 @@
+{"version":3,"file":"index-BZL7keVW.d.mts","names":[],"sources":["../src/services/rtkProcessor/index.ts"],"mappings":";;;KA8EK;cAEQ,wBAAwB;mBAYhB;mBACA;mBACA;mBACA;;;;;;;;;UANX;EAER,YACmB,gBAAe,gBACf,oBACA,MAAK,SAAS,qCACd,WAAW;EAGxB,QAAQ,SAAS,oBAAoB,QAAQ;UA0B3C;;;;;;iBAwGM,kBAAkB,kBAAkB;iBAyDpC,oBAAoB,kBAAkB"}

package/dist/index-BwB_jTI9.d.mts

@@ -0,0 +1,12 @@
+import { a as IBashRunService } from "./bashRunService-Ci0cGdYO.mjs";
+import { n as BashParamsSchema } from "./bashTool-B1EwZLo_.mjs";
+import { r as LogSummarizer } from "./bashResult-DcrRaBLv.mjs";
+import { t as RunnerSettings } from "./runnerSettings-DiV1lvzx.mjs";
+import { t as RunnerDependencies } from "./type-C31e1gla.mjs";
+import { DoomHeadlessCommand, DoomHeadlessTool } from "@agimon-ai/po-core/headless";
+//#region src/services/headless/index.d.ts
+declare function createHeadlessBashTool(bashRunService: IBashRunService, summarizeLog?: LogSummarizer, settings?: RunnerSettings, environment?: NodeJS.ProcessEnv): DoomHeadlessTool<typeof BashParamsSchema>;
+declare function createHeadlessRunnersCommand(dependencies: RunnerDependencies): DoomHeadlessCommand;
+//#endregion
+export { createHeadlessRunnersCommand as n, createHeadlessBashTool as t };
+//# sourceMappingURL=index-BwB_jTI9.d.mts.map

package/dist/index-BwB_jTI9.d.mts.map

@@ -0,0 +1 @@
+{"version":3,"file":"index-BwB_jTI9.d.mts","names":[],"sources":["../src/services/headless/index.ts"],"mappings":";;;;;;;iBAoBgB,uBACd,gBAAgB,iBAChB,eAAe,eACf,WAAW,gBACX,cAAa,OAAO,aACnB,wBAAwB;iBAgDX,6BAA6B,cAAc,qBAAqB"}

package/dist/index-D9-IXax4.d.mts

@@ -0,0 +1,43 @@
+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";
+import { n as RmuxLaunchRequest, t as IRmuxBackend } from "./rmuxBackend-CaEWooWn.mjs";
+import { t as RunnerSettings } from "./runnerSettings-DiV1lvzx.mjs";
+import { t as IRunnerPaths } from "./type-BXM03qSw.mjs";
+//#region src/services/rmuxBackend/index.d.ts
+declare class RmuxBackend implements IRmuxBackend {
+  private readonly paths;
+  private readonly env;
+  private readonly settings?;
+  private clientPromise;
+  private readonly runs;
+  private readonly completions;
+  constructor(paths: IRunnerPaths, env?: Readonly<Record<string, string | undefined>>, settings?: RunnerSettings | undefined);
+  launch(request: RmuxLaunchRequest): Promise<RunHandle | undefined>;
+  stop(target: string, expectedPid: number): Promise<boolean>;
+  watch(id: string, target: string, sessionId?: string): Promise<ExitResult | undefined>;
+  input(target: string, text: string): Promise<boolean>;
+  capture(target: string): Promise<string | undefined>;
+  get(name: string): PtyRun | undefined;
+  readOutcome(id: string, sessionId: string): ExitResult | undefined;
+  private trackCompletion;
+  private client;
+  private resolveClient;
+  private prepareFiles;
+  private auxPaths;
+  /**
+   * 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.
+   */
+  private logPipeCommand;
+  private monitor;
+  private interactiveRun;
+}
+declare function rmuxPackageForTarget(platform: string, architecture: string): string | undefined;
+//#endregion
+export { rmuxPackageForTarget as n, RmuxBackend as t };
+//# sourceMappingURL=index-D9-IXax4.d.mts.map

package/dist/index-D9-IXax4.d.mts.map

@@ -0,0 +1 @@
+{"version":3,"file":"index-D9-IXax4.d.mts","names":[],"sources":["../src/services/rmuxBackend/index.ts"],"mappings":";;;;;;;cAoDa,uBAAuB;mBAMf;mBACA;mBACA;UAPX;mBACS;mBACA;EAEjB,YACmB,OAAO,cACP,MAAK,SAAS,qCACd,WAAW;EAGxB,OAAO,SAAS,oBAAoB,QAAQ;EAuF5C,KAAK,gBAAgB,sBAAsB;EA6B3C,MAAM,YAAY,gBAAgB,qBAAqB,QAAQ;EAe/D,MAAM,gBAAgB,eAAe;EAcrC,QAAQ,iBAAiB;EAa/B,IAAI,eAAe;EAInB,YAAY,YAAY,oBAAoB;UAIpC;UAOA;UAKM;UAkBN;UAUA;;;;;;;;;UAYA;UAaM;UA+BN;;iBA4CM,qBAAqB,kBAAkB"}

package/dist/index-DBz0DxnL.d.mts

@@ -0,0 +1,39 @@
+import { a as RunnerTerminationIntent, i as RunnerRecord, n as IRunnerRegistry, r as RegisterRunnerInput, t as CompleteRunnerInput } from "./runnerRegistry-CtJiD02R.mjs";
+import { t as IProcessControl } from "./processControl-BAOa3oo_.mjs";
+import { t as IRunnerPaths } from "./type-BXM03qSw.mjs";
+import { ProcessRegistryService } from "@agimon-ai/foundation-process-registry";
+//#region src/services/runnerRegistry/index.d.ts
+/** The slice of the shared registry service this wrapper depends on. */
+type ProcessRegistryPort = Pick<ProcessRegistryService, 'registerProcess' | 'releaseProcess' | 'listProcesses' | 'close'>;
+/** Opens the SQLite-backed registry the rest of the monorepo already shares. */
+declare function createDefaultProcessRegistry(env?: Readonly<Record<string, string | undefined>>): ProcessRegistryPort;
+declare class RunnerRegistry implements IRunnerRegistry {
+  private readonly paths;
+  private readonly processControl;
+  private readonly registry;
+  private readonly environment;
+  private readonly subscriptions;
+  constructor(paths: IRunnerPaths, processControl: IProcessControl, registry: ProcessRegistryPort, environment: Readonly<Record<string, string | undefined>>);
+  register(input: RegisterRunnerInput): Promise<RunnerRecord>;
+  list(): Promise<RunnerRecord[]>;
+  listAcrossRepositories(): Promise<RunnerRecord[]>;
+  listBySession(sessionId: string): Promise<RunnerRecord[]>;
+  listByRootSession(rootSessionId: string): Promise<RunnerRecord[]>;
+  listAll(sessionId?: string): Promise<RunnerRecord[]>;
+  get(id: string, sessionId?: string): Promise<RunnerRecord | undefined>;
+  markPromoted(id: string): Promise<RunnerRecord | undefined>;
+  requestTermination(id: string, intent: RunnerTerminationIntent | undefined, sessionId?: string): Promise<RunnerRecord | undefined>;
+  complete(id: string, outcome: CompleteRunnerInput, sessionId?: string): Promise<RunnerRecord | undefined>;
+  release(id: string, sessionId?: string): Promise<void>;
+  pruneDead(): Promise<string[]>;
+  subscribe(listener: () => void, sessionId: string): () => void;
+  close(): void;
+  private notify;
+  private removeSubscription;
+  private subscriptionKey;
+  private repositoryPath;
+  private writeRecord;
+}
+//#endregion
+export { RunnerRegistry as n, createDefaultProcessRegistry as r, ProcessRegistryPort as t };
+//# sourceMappingURL=index-DBz0DxnL.d.mts.map

package/dist/index-DBz0DxnL.d.mts.map

@@ -0,0 +1 @@
+{"version":3,"file":"index-DBz0DxnL.d.mts","names":[],"sources":["../src/services/runnerRegistry/index.ts"],"mappings":";;;;;;KAoCY,sBAAsB,KAChC;;iBAKc,6BACd,MAAK,SAAS,sCACb;cA+CU,0BAA0B;mBAIlB;mBACA;mBACA;mBACA;mBANF;EAEjB,YACmB,OAAO,cACP,gBAAgB,iBAChB,UAAU,qBACV,aAAa,SAAS;EAGnC,SAAS,OAAO,sBAAsB,QAAQ;EAqD9C,QAAQ,QAAQ;EAShB,0BAA0B,QAAQ;EAQlC,cAAc,oBAAoB,QAAQ;EAK1C,kBAAkB,wBAAwB,QAAQ;EAKlD,QAAQ,qBAAqB,QAAQ;EAgBrC,IAAI,YAAY,qBAAqB,QAAQ;EAgB7C,aAAa,aAAa,QAAQ;EASlC,mBACJ,YACA,QAAQ,qCACR,qBACC,QAAQ;EAWL,SAAS,YAAY,SAAS,qBAAqB,qBAAqB,QAAQ;EAiChF,QAAQ,YAAY,qBAAqB;EAiBzC,aAAa;EAQnB,UAAU,sBAAsB;EAUhC;UAKQ;UAUA;UAOA;UAIA;UAIA"}

package/dist/index-DM7yJpMs.d.mts

@@ -0,0 +1,25 @@
+import { c as TruncatedOutput, i as LogSummary } from "./bashResult-DcrRaBLv.mjs";
+import { n as LogQuery, r as LogSlice, t as ILogReader } from "./logReader-MdW9ffvV.mjs";
+import { t as RunnerSettings } from "./runnerSettings-DiV1lvzx.mjs";
+//#region src/services/logReader/index.d.ts
+declare class LogReader implements ILogReader {
+  read(logPath: string, query?: LogQuery): LogSlice;
+}
+/**
+ * Grep with context, matching the `product-stack logs` semantics so the two
+ * surfaces behave the same. Overlapping and adjacent context windows merge.
+ */
+declare function filterLogText(text: string, query: Pick<LogQuery, 'grep' | 'ignoreCase' | 'contextLines'>): string;
+/** Reads a bounded head and tail plus exact metadata after the writer has flushed. */
+declare function summarizeLog(path: string, maxLines?: number, maxBytes?: number, maxTokens?: number, settings?: RunnerSettings): LogSummary;
+/**
+ * Keeps both ends of an oversized result and points at the file holding the rest.
+ *
+ * The notice states the file's real size and line count so the model does not
+ * guess at offsets when it goes on to read the file, which is the failure this
+ * whole policy exists to prevent.
+ */
+declare function truncateForResult(text: string, fullOutputPath: string, maxBytes?: number, maxLines?: number): TruncatedOutput;
+//#endregion
+export { truncateForResult as i, filterLogText as n, summarizeLog as r, LogReader as t };
+//# sourceMappingURL=index-DM7yJpMs.d.mts.map

package/dist/index-DM7yJpMs.d.mts.map

@@ -0,0 +1 @@
+{"version":3,"file":"index-DM7yJpMs.d.mts","names":[],"sources":["../src/services/logReader/index.ts"],"mappings":";;;;cAuBa,qBAAqB;EAChC,KAAK,iBAAiB,QAAO,WAAgB;;;;;;iBA0G/B,cAAc,cAAc,OAAO,KAAK;;iBA8BxC,aACd,cACA,mBACA,mBACA,oBACA,WAAW,iBACV;;;;;;;;iBAmEa,kBACd,cACA,wBACA,mBACA,oBACC"}

package/dist/index-Dhi8asLH.d.mts

@@ -0,0 +1,22 @@
+import { t as RunnerDependencies } from "./type-C31e1gla.mjs";
+import { DoomHostExecutionBudget } from "@agimon-ai/po-core/packageApi";
+//#region src/services/runnerDependencies/index.d.ts
+/**
+ * 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.
+ */
+declare function createRunnerDependencies(overrides: Partial<RunnerDependencies> & {
+  environment: Readonly<Record<string, string | undefined>>;
+  cwd?: string;
+  executionBudget?: DoomHostExecutionBudget;
+}): RunnerDependencies;
+//#endregion
+export { createRunnerDependencies as t };
+//# sourceMappingURL=index-Dhi8asLH.d.mts.map

package/dist/index-Dhi8asLH.d.mts.map

@@ -0,0 +1 @@
+{"version":3,"file":"index-Dhi8asLH.d.mts","names":[],"sources":["../src/services/runnerDependencies/index.ts"],"mappings":";;;;;;;;;;;;;;iBA4CgB,yBACd,WAAW,QAAQ;EACjB,aAAa,SAAS;EACtB;EACA,kBAAkB;IAEnB"}

package/dist/index.cjs

@@ -0,0 +1,19 @@
+Object.defineProperty(exports, Symbol.toStringTag, { value: "Module" });
+const require_runnerConfig = require("./runnerConfig-D2tGq5ZM.cjs");
+const require_headless = require("./headless-CHUsBGhg.cjs");
+const require_rmuxBackend = require("./rmuxBackend-DlxgqRZ1.cjs");
+const require_rtkProcessor = require("./rtkProcessor-Bc4L4o_8.cjs");
+const require_runnerDependencies = require("./runnerDependencies-KMZigIxB.cjs");
+exports.DEFAULT_BG_THRESHOLD_MS = require_runnerConfig.DEFAULT_BG_THRESHOLD_MS;
+exports.DEFAULT_LOG_MAX_BYTES = require_runnerConfig.DEFAULT_LOG_MAX_BYTES;
+exports.DEFAULT_LOG_TTL_MS = require_runnerConfig.DEFAULT_LOG_TTL_MS;
+exports.DEFAULT_RESULT_MAX_BYTES = require_runnerConfig.DEFAULT_RESULT_MAX_BYTES;
+exports.RmuxBackend = require_rmuxBackend.RmuxBackend;
+exports.createHeadlessBashTool = require_headless.createHeadlessBashTool;
+exports.createHeadlessRunnersCommand = require_headless.createHeadlessRunnersCommand;
+exports.createRunnerDependencies = require_runnerDependencies.createRunnerDependencies;
+exports.getBackgroundThresholdMs = require_runnerConfig.getBackgroundThresholdMs;
+exports.getLogMaxBytes = require_runnerConfig.getLogMaxBytes;
+exports.getLogTtlMs = require_runnerConfig.getLogTtlMs;
+exports.getResultMaxBytes = require_runnerConfig.getResultMaxBytes;
+exports.rtkPackageForTarget = require_rtkProcessor.rtkPackageForTarget;

package/dist/index.d.mts

@@ -0,0 +1,7 @@
+import { n as RmuxLaunchRequest, t as IRmuxBackend } from "./rmuxBackend-CaEWooWn.mjs";
+import { n as createHeadlessRunnersCommand, t as createHeadlessBashTool } from "./index-BwB_jTI9.mjs";
+import { A as getLogTtlMs, C as getBackgroundThresholdMs, M as getResultMaxBytes, c as DEFAULT_LOG_TTL_MS, k as getLogMaxBytes, n as DEFAULT_BG_THRESHOLD_MS, s as DEFAULT_LOG_MAX_BYTES, u as DEFAULT_RESULT_MAX_BYTES } from "./runnerConfig-BjtulXBI.mjs";
+import { t as RmuxBackend } from "./index-D9-IXax4.mjs";
+import { r as rtkPackageForTarget } from "./index-BZL7keVW.mjs";
+import { t as createRunnerDependencies } from "./index-Dhi8asLH.mjs";
+export { DEFAULT_BG_THRESHOLD_MS, DEFAULT_LOG_MAX_BYTES, DEFAULT_LOG_TTL_MS, DEFAULT_RESULT_MAX_BYTES, type IRmuxBackend, RmuxBackend, type RmuxLaunchRequest, createHeadlessBashTool, createHeadlessRunnersCommand, createRunnerDependencies, getBackgroundThresholdMs, getLogMaxBytes, getLogTtlMs, getResultMaxBytes, rtkPackageForTarget };

package/dist/index.mjs

@@ -0,0 +1,6 @@
+import { D as DEFAULT_RESULT_MAX_BYTES, T as DEFAULT_LOG_TTL_MS, c as getLogTtlMs, s as getLogMaxBytes, t as getBackgroundThresholdMs, u as getResultMaxBytes, w as DEFAULT_LOG_MAX_BYTES, y as DEFAULT_BG_THRESHOLD_MS } from "./runnerConfig-BQBlVAXn.mjs";
+import { n as createHeadlessRunnersCommand, t as createHeadlessBashTool } from "./headless-BGYfIlNk.mjs";
+import { t as RmuxBackend } from "./rmuxBackend-DfyQwJrc.mjs";
+import { r as rtkPackageForTarget } from "./rtkProcessor-B9KPdyzr.mjs";
+import { t as createRunnerDependencies } from "./runnerDependencies-DruByBGS.mjs";
+export { DEFAULT_BG_THRESHOLD_MS, DEFAULT_LOG_MAX_BYTES, DEFAULT_LOG_TTL_MS, DEFAULT_RESULT_MAX_BYTES, RmuxBackend, createHeadlessBashTool, createHeadlessRunnersCommand, createRunnerDependencies, getBackgroundThresholdMs, getLogMaxBytes, getLogTtlMs, getResultMaxBytes, rtkPackageForTarget };

package/dist/launcher-BDm6-DiQ.mjs

@@ -0,0 +1,150 @@
+import { g as noninteractiveEnvironment, u as getResultMaxBytes } from "./runnerConfig-BQBlVAXn.mjs";
+import { t as PI_SESSION_ID_ENV } from "./session-DE2Acesp.mjs";
+import { NO_TERMINAL_INPUT_ENV, cleanupSupervisorFiles, readExitMetadata, supervisorCommand, supervisorPaths, writeCommandSpec } from "./services/runnerSupervisor/index.mjs";
+import { LIFELINE_ENV } from "./services/lifeline/client.mjs";
+import fs from "node:fs";
+//#region src/constants/launcher.ts
+const NON_INTERACTIVE_ENV = {
+	FORCE_COLOR: "1",
+	CI: "1"
+};
+const TERM_GRACE_MS = 2e3;
+//#endregion
+//#region src/services/launcher/index.ts
+/**
+* Prompts belong on a screen, not in a log file, so `CI` stays set.
+*
+* Colour is kept: the log is replayed into the transcript, and the scrub keeps
+* SGR while still removing the cursor moves that made raw output unreadable.
+*/
+/** In-memory output is a multiple of the result ceiling; the log holds the rest. */
+var Launcher = class {
+	spawner;
+	processControl;
+	logFile;
+	clock;
+	paths;
+	lifeline;
+	environment;
+	settings;
+	constructor(spawner, processControl, logFile, clock, paths, lifeline, environment = process.env, settings) {
+		this.spawner = spawner;
+		this.processControl = processControl;
+		this.logFile = logFile;
+		this.clock = clock;
+		this.paths = paths;
+		this.lifeline = lifeline;
+		this.environment = environment;
+		this.settings = settings;
+	}
+	launch(request) {
+		const writer = this.logFile.open(request.id);
+		const memoryLimit = getResultMaxBytes(this.environment, this.settings) * 2;
+		let buffer = "";
+		let buffering = true;
+		let settled = false;
+		let resolveCompletion = () => void 0;
+		let rejectCompletion = () => void 0;
+		const completion = new Promise((resolve, reject) => {
+			resolveCompletion = resolve;
+			rejectCompletion = reject;
+		});
+		this.paths.ensureDirectories(request.sessionId);
+		const supervisor = supervisorPaths(this.paths.stateDirectory(request.sessionId), request.id);
+		const { [LIFELINE_ENV]: _inheritedLifeline, ...environment } = this.environment;
+		const env = {
+			...environment,
+			...NON_INTERACTIVE_ENV,
+			...noninteractiveEnvironment(environment),
+			...NO_TERMINAL_INPUT_ENV,
+			[PI_SESSION_ID_ENV]: request.sessionId,
+			[LIFELINE_ENV]: this.lifeline?.path()
+		};
+		cleanupSupervisorFiles(supervisor);
+		writeCommandSpec(supervisor.spec, {
+			command: request.command,
+			cwd: request.cwd,
+			env: defined(env)
+		});
+		fs.writeFileSync(supervisor.gate, "", { mode: 384 });
+		const child = this.spawner.spawn({
+			command: supervisorCommand(supervisor),
+			cwd: request.cwd,
+			env,
+			detached: true
+		});
+		const failLaunch = (error) => {
+			if (settled) return;
+			settled = true;
+			writer.close();
+			cleanupSupervisorFiles(supervisor);
+			try {
+				child.kill("SIGTERM");
+			} catch (killError) {
+				process.emitWarning(`Could not stop runner after log failure: ${String(killError)}`);
+			}
+			rejectCompletion(error instanceof Error ? error : new Error(String(error)));
+		};
+		child.onOutput((chunk) => {
+			if (settled) return;
+			try {
+				writer.append(chunk);
+			} catch (error) {
+				failLaunch(error);
+				return;
+			}
+			if (!buffering) return;
+			buffer += chunk;
+			if (buffer.length > memoryLimit) buffer = buffer.slice(-memoryLimit);
+		});
+		child.onError(failLaunch);
+		child.onExit((result) => {
+			if (settled) return;
+			settled = true;
+			writer.close();
+			const outcome = readExitMetadata(supervisor.exit) ?? result;
+			cleanupSupervisorFiles(supervisor);
+			resolveCompletion(outcome);
+		});
+		child.unref();
+		const stop = async () => child.pid === void 0 ? false : this.stop(child.pid);
+		return {
+			id: request.id,
+			name: request.name,
+			pid: child.pid,
+			logPath: writer.path,
+			backend: "native",
+			output: () => buffer,
+			completion: () => completion,
+			detach: () => {
+				buffering = false;
+				buffer = "";
+			},
+			stop
+		};
+	}
+	async stop(pid) {
+		if (!this.processControl.isAlive(pid)) return false;
+		this.processControl.signalGroup(pid, "SIGTERM");
+		const deadline = this.clock.now() + TERM_GRACE_MS;
+		while (this.clock.now() < deadline) {
+			if (!this.processControl.isAlive(pid)) return true;
+			await this.sleep(100);
+		}
+		this.processControl.signalGroup(pid, "SIGKILL");
+		return true;
+	}
+	sleep(ms) {
+		return new Promise((resolve) => {
+			this.clock.after(ms, resolve);
+		});
+	}
+};
+/** The spec is JSON, which has no way to carry an unset variable. */
+function defined(env) {
+	return Object.fromEntries(Object.entries(env).filter((entry) => entry[1] !== void 0));
+}
+//#endregion
+export { Launcher as t };
+
+//# sourceMappingURL=launcher-BDm6-DiQ.mjs.map

package/dist/launcher-BDm6-DiQ.mjs.map

@@ -0,0 +1 @@
+{"version":3,"file":"launcher-BDm6-DiQ.mjs","names":[],"sources":["../src/constants/launcher.ts","../src/services/launcher/index.ts"],"sourcesContent":["export const NON_INTERACTIVE_ENV = { FORCE_COLOR: '1', CI: '1' };\nexport const TERM_GRACE_MS = 2_000;\nexport const LIVENESS_POLL_MS = 100;\nexport const MEMORY_BUFFER_FACTOR = 2;\nexport const GATE_MODE = 0o600;\n","import fs from 'node:fs';\n\nimport {\n  GATE_MODE,\n  LIVENESS_POLL_MS,\n  MEMORY_BUFFER_FACTOR,\n  NON_INTERACTIVE_ENV,\n  TERM_GRACE_MS,\n} from '../../constants/launcher';\nimport { PI_SESSION_ID_ENV } from '../../constants/session';\nimport type { IClock } from '../../types/clock';\nimport type { ILauncher, LaunchRequest, RunHandle } from '../../types/launcher';\nimport type { ILifeline } from '../../types/lifeline';\nimport type { ILogFile } from '../../types/logFile';\nimport type { IProcessControl } from '../../types/processControl';\nimport type { RunnerSettings } from '../../types/runnerSettings';\nimport type { ExitResult, ISpawner } from '../../types/spawner';\nimport { LIFELINE_ENV } from '../lifeline/client';\nimport { getResultMaxBytes, noninteractiveEnvironment } from '../runnerConfig';\nimport type { IRunnerPaths } from '../runnerPaths/type';\nimport {\n  cleanupSupervisorFiles,\n  NO_TERMINAL_INPUT_ENV,\n  readExitMetadata,\n  supervisorCommand,\n  supervisorPaths,\n  writeCommandSpec,\n} from '../runnerSupervisor';\n\n/**\n * Prompts belong on a screen, not in a log file, so `CI` stays set.\n *\n * Colour is kept: the log is replayed into the transcript, and the scrub keeps\n * SGR while still removing the cursor moves that made raw output unreadable.\n */\n/** In-memory output is a multiple of the result ceiling; the log holds the rest. */\n\nexport class Launcher implements ILauncher {\n  constructor(\n    private readonly spawner: ISpawner,\n    private readonly processControl: IProcessControl,\n    private readonly logFile: ILogFile,\n    private readonly clock: IClock,\n    private readonly paths: IRunnerPaths,\n    private readonly lifeline?: ILifeline,\n    private readonly environment: Readonly<Record<string, string | undefined>> = process.env,\n    private readonly settings?: RunnerSettings,\n  ) {}\n\n  launch(request: LaunchRequest): RunHandle {\n    const writer = this.logFile.open(request.id);\n    const memoryLimit = getResultMaxBytes(this.environment, this.settings) * MEMORY_BUFFER_FACTOR;\n\n    let buffer = '';\n    let buffering = true;\n    let settled = false;\n    let resolveCompletion: (result: ExitResult) => void = () => undefined;\n    let rejectCompletion: (error: Error) => void = () => undefined;\n    const completion = new Promise<ExitResult>((resolve, reject) => {\n      resolveCompletion = resolve;\n      rejectCompletion = reject;\n    });\n\n    this.paths.ensureDirectories(request.sessionId);\n    const supervisor = supervisorPaths(this.paths.stateDirectory(request.sessionId), request.id);\n    const { [LIFELINE_ENV]: _inheritedLifeline, ...environment } = this.environment;\n    const env = {\n      ...environment,\n      ...NON_INTERACTIVE_ENV,\n      ...noninteractiveEnvironment(environment),\n      ...NO_TERMINAL_INPUT_ENV,\n      [PI_SESSION_ID_ENV]: request.sessionId,\n      [LIFELINE_ENV]: this.lifeline?.path(),\n    };\n    cleanupSupervisorFiles(supervisor);\n    writeCommandSpec(supervisor.spec, { command: request.command, cwd: request.cwd, env: defined(env) });\n    // Nothing has to be attached before this runner starts, so its gate opens at once.\n    fs.writeFileSync(supervisor.gate, '', { mode: GATE_MODE });\n\n    const child = this.spawner.spawn({\n      // runnerHost supervises the command: it forwards signals and, if the owning\n      // pi dies without running its shutdown handler, kills the group itself.\n      command: supervisorCommand(supervisor),\n      cwd: request.cwd,\n      env,\n      // Its own process group, so stopping a runner takes the whole tree with it.\n      detached: true,\n    });\n\n    const failLaunch = (error: unknown): void => {\n      if (settled) return;\n      settled = true;\n      writer.close();\n      cleanupSupervisorFiles(supervisor);\n      try {\n        child.kill('SIGTERM');\n      } catch (killError) {\n        process.emitWarning(`Could not stop runner after log failure: ${String(killError)}`);\n      }\n      rejectCompletion(error instanceof Error ? error : new Error(String(error)));\n    };\n    child.onOutput((chunk) => {\n      if (settled) return;\n      try {\n        writer.append(chunk);\n      } catch (error) {\n        failLaunch(error);\n        return;\n      }\n      if (!buffering) return;\n      buffer += chunk;\n      if (buffer.length > memoryLimit) buffer = buffer.slice(-memoryLimit);\n    });\n\n    child.onError(failLaunch);\n\n    child.onExit((result) => {\n      if (settled) return;\n      settled = true;\n      writer.close();\n      // The supervisor collapses a signalled command into an exit code, so its\n      // own sidecar is the only place the original signal survives.\n      const outcome = readExitMetadata(supervisor.exit) ?? result;\n      cleanupSupervisorFiles(supervisor);\n      resolveCompletion(outcome);\n    });\n\n    // The launcher must never hold the pi process open on a runner's behalf.\n    child.unref();\n\n    const stop = async (): Promise<boolean> => (child.pid === undefined ? false : this.stop(child.pid));\n\n    return {\n      id: request.id,\n      name: request.name,\n      pid: child.pid,\n      logPath: writer.path,\n      backend: 'native',\n      output: () => buffer,\n      completion: () => completion,\n      detach: () => {\n        buffering = false;\n        buffer = '';\n      },\n      stop,\n    };\n  }\n\n  async stop(pid: number): Promise<boolean> {\n    if (!this.processControl.isAlive(pid)) return false;\n\n    this.processControl.signalGroup(pid, 'SIGTERM');\n    const deadline = this.clock.now() + TERM_GRACE_MS;\n    while (this.clock.now() < deadline) {\n      if (!this.processControl.isAlive(pid)) return true;\n      await this.sleep(LIVENESS_POLL_MS);\n    }\n\n    this.processControl.signalGroup(pid, 'SIGKILL');\n    return true;\n  }\n\n  private sleep(ms: number): Promise<void> {\n    return new Promise((resolve) => {\n      this.clock.after(ms, resolve);\n    });\n  }\n}\n\n/** The spec is JSON, which has no way to carry an unset variable. */\nfunction defined(env: Readonly<Record<string, string | undefined>>): Record<string, string> {\n  return Object.fromEntries(Object.entries(env).filter((entry): entry is [string, string] => entry[1] !== undefined));\n}\n"],"mappings":";;;;;;AAAA,MAAa,sBAAsB;CAAE,aAAa;CAAK,IAAI;AAAI;AAC/D,MAAa,gBAAgB;;;;;;;;;;ACoC7B,IAAa,WAAb,MAA2C;CAEtB;CACA;CACA;CACA;CACA;CACA;CACA;CACA;CARnB,YACE,SACA,gBACA,SACA,OACA,OACA,UACA,cAA6E,QAAQ,KACrF,UACA;EARiB,KAAA,UAAA;EACA,KAAA,iBAAA;EACA,KAAA,UAAA;EACA,KAAA,QAAA;EACA,KAAA,QAAA;EACA,KAAA,WAAA;EACA,KAAA,cAAA;EACA,KAAA,WAAA;CAChB;CAEH,OAAO,SAAmC;EACxC,MAAM,SAAS,KAAK,QAAQ,KAAK,QAAQ,EAAE;EAC3C,MAAM,cAAc,kBAAkB,KAAK,aAAa,KAAK,QAAQ,IAAA;EAErE,IAAI,SAAS;EACb,IAAI,YAAY;EAChB,IAAI,UAAU;EACd,IAAI,0BAAwD,KAAA;EAC5D,IAAI,yBAAiD,KAAA;EACrD,MAAM,aAAa,IAAI,SAAqB,SAAS,WAAW;GAC9D,oBAAoB;GACpB,mBAAmB;EACrB,CAAC;EAED,KAAK,MAAM,kBAAkB,QAAQ,SAAS;EAC9C,MAAM,aAAa,gBAAgB,KAAK,MAAM,eAAe,QAAQ,SAAS,GAAG,QAAQ,EAAE;EAC3F,MAAM,GAAG,eAAe,oBAAoB,GAAG,gBAAgB,KAAK;EACpE,MAAM,MAAM;GACV,GAAG;GACH,GAAG;GACH,GAAG,0BAA0B,WAAW;GACxC,GAAG;IACF,oBAAoB,QAAQ;IAC5B,eAAe,KAAK,UAAU,KAAK;EACtC;EACA,uBAAuB,UAAU;EACjC,iBAAiB,WAAW,MAAM;GAAE,SAAS,QAAQ;GAAS,KAAK,QAAQ;GAAK,KAAK,QAAQ,GAAG;EAAE,CAAC;EAEnG,GAAG,cAAc,WAAW,MAAM,IAAI,EAAE,MAAA,IAAgB,CAAC;EAEzD,MAAM,QAAQ,KAAK,QAAQ,MAAM;GAG/B,SAAS,kBAAkB,UAAU;GACrC,KAAK,QAAQ;GACb;GAEA,UAAU;EACZ,CAAC;EAED,MAAM,cAAc,UAAyB;GAC3C,IAAI,SAAS;GACb,UAAU;GACV,OAAO,MAAM;GACb,uBAAuB,UAAU;GACjC,IAAI;IACF,MAAM,KAAK,SAAS;GACtB,SAAS,WAAW;IAClB,QAAQ,YAAY,4CAA4C,OAAO,SAAS,GAAG;GACrF;GACA,iBAAiB,iBAAiB,QAAQ,QAAQ,IAAI,MAAM,OAAO,KAAK,CAAC,CAAC;EAC5E;EACA,MAAM,UAAU,UAAU;GACxB,IAAI,SAAS;GACb,IAAI;IACF,OAAO,OAAO,KAAK;GACrB,SAAS,OAAO;IACd,WAAW,KAAK;IAChB;GACF;GACA,IAAI,CAAC,WAAW;GAChB,UAAU;GACV,IAAI,OAAO,SAAS,aAAa,SAAS,OAAO,MAAM,CAAC,WAAW;EACrE,CAAC;EAED,MAAM,QAAQ,UAAU;EAExB,MAAM,QAAQ,WAAW;GACvB,IAAI,SAAS;GACb,UAAU;GACV,OAAO,MAAM;GAGb,MAAM,UAAU,iBAAiB,WAAW,IAAI,KAAK;GACrD,uBAAuB,UAAU;GACjC,kBAAkB,OAAO;EAC3B,CAAC;EAGD,MAAM,MAAM;EAEZ,MAAM,OAAO,YAA+B,MAAM,QAAQ,KAAA,IAAY,QAAQ,KAAK,KAAK,MAAM,GAAG;EAEjG,OAAO;GACL,IAAI,QAAQ;GACZ,MAAM,QAAQ;GACd,KAAK,MAAM;GACX,SAAS,OAAO;GAChB,SAAS;GACT,cAAc;GACd,kBAAkB;GAClB,cAAc;IACZ,YAAY;IACZ,SAAS;GACX;GACA;EACF;CACF;CAEA,MAAM,KAAK,KAA+B;EACxC,IAAI,CAAC,KAAK,eAAe,QAAQ,GAAG,GAAG,OAAO;EAE9C,KAAK,eAAe,YAAY,KAAK,SAAS;EAC9C,MAAM,WAAW,KAAK,MAAM,IAAI,IAAI;EACpC,OAAO,KAAK,MAAM,IAAI,IAAI,UAAU;GAClC,IAAI,CAAC,KAAK,eAAe,QAAQ,GAAG,GAAG,OAAO;GAC9C,MAAM,KAAK,MAAA,GAAsB;EACnC;EAEA,KAAK,eAAe,YAAY,KAAK,SAAS;EAC9C,OAAO;CACT;CAEA,MAAc,IAA2B;EACvC,OAAO,IAAI,SAAS,YAAY;GAC9B,KAAK,MAAM,MAAM,IAAI,OAAO;EAC9B,CAAC;CACH;AACF;;AAGA,SAAS,QAAQ,KAA2E;CAC1F,OAAO,OAAO,YAAY,OAAO,QAAQ,GAAG,CAAC,CAAC,QAAQ,UAAqC,MAAM,OAAO,KAAA,CAAS,CAAC;AACpH"}