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

package/dist/launcher-BG5t9nvG.d.mts

@@ -0,0 +1,39 @@
+import { t as ExitResult } from "./spawner-CdrN_HNk.mjs";
+//#region src/types/launcher.d.ts
+interface LaunchRequest {
+  id: string;
+  /** Runner name, already allocated and free of collisions. */
+  name: string;
+  command: string;
+  cwd: string;
+  sessionId: string;
+}
+interface RunHandle {
+  readonly id: string;
+  readonly name: string;
+  readonly pid: number | undefined;
+  readonly logPath: string;
+  readonly backend: 'rmux' | 'tmux' | 'native';
+  readonly backendTarget?: string;
+  /**
+   * Output captured so far, tail-capped. The log file always holds everything.
+   */
+  output(): string;
+  /** Resolves when the process exits, or rejects if it never started. */
+  completion(): Promise<ExitResult>;
+  /**
+   * Stops buffering output in memory and lets the process outlive this handle.
+   * Called when a run is promoted to a background runner.
+   */
+  detach(): void;
+  /** Signals the process group and waits for it to go away. */
+  stop(): Promise<boolean>;
+}
+interface ILauncher {
+  launch(request: LaunchRequest): RunHandle;
+  /** SIGTERM the group led by `pid`, then SIGKILL if it outlasts the grace period. */
+  stop(pid: number): Promise<boolean>;
+}
+//#endregion
+export { LaunchRequest as n, RunHandle as r, ILauncher as t };
+//# sourceMappingURL=launcher-BG5t9nvG.d.mts.map

package/dist/launcher-BG5t9nvG.d.mts.map

@@ -0,0 +1 @@
+{"version":3,"file":"launcher-BG5t9nvG.d.mts","names":[],"sources":["../src/types/launcher.ts"],"mappings":";;UAEiB;EACf;;EAEA;EACA;EACA;EACA;;UAGe;WACN;WACA;WACA;WACA;WACA;WACA;;;;EAIT;;EAEA,cAAc,QAAQ;;;;;EAKtB;;EAEA,QAAQ;;UAGO;EACf,OAAO,SAAS,gBAAgB;;EAEhC,KAAK,cAAc"}

package/dist/launcher-SlyE8R3b.cjs

@@ -0,0 +1,157 @@
+const require_rolldown_runtime = require("./rolldown-runtime-VH7oDXx4.cjs");
+const require_runnerConfig = require("./runnerConfig-D2tGq5ZM.cjs");
+const require_session = require("./session-SfIPtdZO.cjs");
+const require_services_runnerSupervisor_index = require("./services/runnerSupervisor/index.cjs");
+const require_services_lifeline_client = require("./services/lifeline/client.cjs");
+let node_fs = require("node:fs");
+node_fs = require_rolldown_runtime.__toESM(node_fs, 1);
+//#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 = require_runnerConfig.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 = require_services_runnerSupervisor_index.supervisorPaths(this.paths.stateDirectory(request.sessionId), request.id);
+		const { [require_services_lifeline_client.LIFELINE_ENV]: _inheritedLifeline, ...environment } = this.environment;
+		const env = {
+			...environment,
+			...NON_INTERACTIVE_ENV,
+			...require_runnerConfig.noninteractiveEnvironment(environment),
+			...require_services_runnerSupervisor_index.NO_TERMINAL_INPUT_ENV,
+			[require_session.PI_SESSION_ID_ENV]: request.sessionId,
+			[require_services_lifeline_client.LIFELINE_ENV]: this.lifeline?.path()
+		};
+		require_services_runnerSupervisor_index.cleanupSupervisorFiles(supervisor);
+		require_services_runnerSupervisor_index.writeCommandSpec(supervisor.spec, {
+			command: request.command,
+			cwd: request.cwd,
+			env: defined(env)
+		});
+		node_fs.default.writeFileSync(supervisor.gate, "", { mode: 384 });
+		const child = this.spawner.spawn({
+			command: require_services_runnerSupervisor_index.supervisorCommand(supervisor),
+			cwd: request.cwd,
+			env,
+			detached: true
+		});
+		const failLaunch = (error) => {
+			if (settled) return;
+			settled = true;
+			writer.close();
+			require_services_runnerSupervisor_index.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 = require_services_runnerSupervisor_index.readExitMetadata(supervisor.exit) ?? result;
+			require_services_runnerSupervisor_index.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
+Object.defineProperty(exports, "Launcher", {
+	enumerable: true,
+	get: function() {
+		return Launcher;
+	}
+});
+
+//# sourceMappingURL=launcher-SlyE8R3b.cjs.map

package/dist/launcher-SlyE8R3b.cjs.map

@@ -0,0 +1 @@
+{"version":3,"file":"launcher-SlyE8R3b.cjs","names":["getResultMaxBytes","supervisorPaths","LIFELINE_ENV","noninteractiveEnvironment","NO_TERMINAL_INPUT_ENV","PI_SESSION_ID_ENV","supervisorCommand","readExitMetadata"],"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":"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"}

package/dist/launcher.cjs

@@ -0,0 +1,3 @@
+Object.defineProperty(exports, Symbol.toStringTag, { value: "Module" });
+const require_launcher = require("./launcher-SlyE8R3b.cjs");
+exports.Launcher = require_launcher.Launcher;

package/dist/launcher.d.mts

@@ -0,0 +1,33 @@
+import { t as IClock } from "./clock-euJkweLq.mjs";
+import { n as ISpawner } from "./spawner-CdrN_HNk.mjs";
+import { n as LaunchRequest, r as RunHandle, t as ILauncher } from "./launcher-BG5t9nvG.mjs";
+import { t as ILifeline } from "./lifeline-eJdZV0nN.mjs";
+import { t as ILogFile } from "./logFile-C7oQ_v-g.mjs";
+import { t as IProcessControl } from "./processControl-BAOa3oo_.mjs";
+import { t as RunnerSettings } from "./runnerSettings-DiV1lvzx.mjs";
+import { t as IRunnerPaths } from "./type-BXM03qSw.mjs";
+//#region src/services/launcher/index.d.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. */
+export declare class Launcher implements ILauncher {
+  private readonly spawner;
+  private readonly processControl;
+  private readonly logFile;
+  private readonly clock;
+  private readonly paths;
+  private readonly lifeline?;
+  private readonly environment;
+  private readonly settings?;
+  constructor(spawner: ISpawner, processControl: IProcessControl, logFile: ILogFile, clock: IClock, paths: IRunnerPaths, lifeline?: ILifeline | undefined, environment?: Readonly<Record<string, string | undefined>>, settings?: RunnerSettings | undefined);
+  launch(request: LaunchRequest): RunHandle;
+  stop(pid: number): Promise<boolean>;
+  private sleep;
+}
+//#endregion
+export type { ILauncher, LaunchRequest, RunHandle };
+//# sourceMappingURL=launcher.d.mts.map

package/dist/launcher.d.mts.map

@@ -0,0 +1 @@
+{"version":3,"file":"launcher.d.mts","names":[],"sources":["../src/services/launcher/index.ts"],"mappings":";;;;;;;;;;;;;;;;qBAqCa,oBAAoB;mBAEZ;mBACA;mBACA;mBACA;mBACA;mBACA;mBACA;mBACA;EARnB,YACmB,SAAS,UACT,gBAAgB,iBAChB,SAAS,UACT,OAAO,QACP,OAAO,cACP,WAAW,uBACX,cAAa,SAAS,qCACtB,WAAW;EAG9B,OAAO,SAAS,gBAAgB;EAmG1B,KAAK,cAAc;UAcjB"}

package/dist/launcher.mjs

@@ -0,0 +1,2 @@
+import { t as Launcher } from "./launcher-BDm6-DiQ.mjs";
+export { Launcher };

package/dist/lifeline-BZaQA0rm.mjs

@@ -0,0 +1,88 @@
+import { createHash } from "node:crypto";
+import fs from "node:fs";
+import path from "node:path";
+import net from "node:net";
+import os from "node:os";
+//#region src/constants/lifeline.ts
+const SOCKET_NAME = "lifeline.sock";
+//#endregion
+//#region src/services/lifeline/index.ts
+/** Unix socket paths are capped at 104 bytes, so a long agent directory falls back to the temp dir. */
+var NodeLifeline = class {
+	paths;
+	server;
+	target;
+	/** Closing a server stops it accepting; only the connections carry the death signal. */
+	connections = /* @__PURE__ */ new Set();
+	constructor(paths) {
+		this.paths = paths;
+	}
+	async arm(sessionId) {
+		if (this.target) return this.target;
+		try {
+			this.paths.ensureDirectories(sessionId);
+			const target = this.socketPath(sessionId);
+			fs.rmSync(target, { force: true });
+			const server = net.createServer((connection) => {
+				connection.unref();
+				connection.resume();
+				this.connections.add(connection);
+				connection.on("close", () => this.connections.delete(connection));
+			});
+			await listen(server, target);
+			fs.chmodSync(target, 384);
+			server.unref();
+			this.server = server;
+			this.target = target;
+			return target;
+		} catch (error) {
+			process.emitWarning(`Could not arm the doom-runner lifeline: ${String(error)}`);
+			return;
+		}
+	}
+	path() {
+		return this.target;
+	}
+	dispose() {
+		for (const connection of this.connections) connection.destroy();
+		this.connections.clear();
+		if (this.server) {
+			try {
+				this.server.close();
+			} catch (error) {
+				process.emitWarning(`Could not close the doom-runner lifeline: ${String(error)}`);
+			}
+			this.server = void 0;
+		}
+		if (this.target) {
+			try {
+				fs.rmSync(this.target, { force: true });
+			} catch (error) {
+				process.emitWarning(`Could not remove the doom-runner lifeline: ${String(error)}`);
+			}
+			this.target = void 0;
+		}
+	}
+	/** Keeps the socket beside the session it belongs to unless that path is too long to bind. */
+	socketPath(sessionId) {
+		const preferred = path.join(this.paths.stateDirectory(sessionId), SOCKET_NAME);
+		if (Buffer.byteLength(preferred) <= 100) return preferred;
+		const hash = createHash("sha256").update(preferred).digest("hex").slice(0, 12);
+		return path.join(os.tmpdir(), `doom-runner-${hash}.sock`);
+	}
+};
+/** Binding must complete before the first runner launches, so arming waits for it. */
+function listen(server, target) {
+	return new Promise((resolve, reject) => {
+		server.once("error", reject);
+		server.listen(target, () => {
+			server.removeListener("error", reject);
+			server.on("error", (error) => process.emitWarning(`doom-runner lifeline failed: ${error.message}`));
+			resolve();
+		});
+	});
+}
+//#endregion
+export { NodeLifeline as t };
+
+//# sourceMappingURL=lifeline-BZaQA0rm.mjs.map

package/dist/lifeline-BZaQA0rm.mjs.map

@@ -0,0 +1 @@
+{"version":3,"file":"lifeline-BZaQA0rm.mjs","names":[],"sources":["../src/constants/lifeline.ts","../src/services/lifeline/index.ts"],"sourcesContent":["export const SOCKET_NAME = 'lifeline.sock';\nexport const SOCKET_PATH_LIMIT = 100;\nexport const SOCKET_HASH_LENGTH = 12;\nexport const SOCKET_MODE = 0o600;\n","import { createHash } from 'node:crypto';\nimport fs from 'node:fs';\nimport net from 'node:net';\nimport os from 'node:os';\nimport path from 'node:path';\n\nimport { SOCKET_HASH_LENGTH, SOCKET_MODE, SOCKET_NAME, SOCKET_PATH_LIMIT } from '../../constants/lifeline';\nimport type { ILifeline } from '../../types/lifeline';\nimport type { IRunnerPaths } from '../runnerPaths/type';\n\n/** Unix socket paths are capped at 104 bytes, so a long agent directory falls back to the temp dir. */\n\nexport class NodeLifeline implements ILifeline {\n  private server: net.Server | undefined;\n  private target: string | undefined;\n  /** Closing a server stops it accepting; only the connections carry the death signal. */\n  private readonly connections = new Set<net.Socket>();\n\n  constructor(private readonly paths: IRunnerPaths) {}\n\n  async arm(sessionId: string): Promise<string | undefined> {\n    if (this.target) return this.target;\n    try {\n      this.paths.ensureDirectories(sessionId);\n      const target = this.socketPath(sessionId);\n      // A socket left behind by a SIGKILLed predecessor refuses connections, never accepts them.\n      fs.rmSync(target, { force: true });\n      const server = net.createServer((connection) => {\n        // Runners need only the close edge, so their liveness and their data are equally irrelevant.\n        connection.unref();\n        connection.resume();\n        this.connections.add(connection);\n        connection.on('close', () => this.connections.delete(connection));\n      });\n      await listen(server, target);\n      fs.chmodSync(target, SOCKET_MODE);\n      // The lifeline must never be the reason pi stays alive.\n      server.unref();\n      this.server = server;\n      this.target = target;\n      return target;\n    } catch (error) {\n      // Runners stay unwatched rather than unlaunchable, so a session without a\n      // lifeline degrades to running them unsupervised instead of failing.\n      process.emitWarning(`Could not arm the doom-runner lifeline: ${String(error)}`);\n      return undefined;\n    }\n  }\n\n  path(): string | undefined {\n    return this.target;\n  }\n\n  dispose(): void {\n    // Dropping the connections is what a runner sees, and it is the whole point\n    // of disposing: closing the server alone would leave every runner waiting.\n    for (const connection of this.connections) connection.destroy();\n    this.connections.clear();\n    if (this.server) {\n      try {\n        this.server.close();\n      } catch (error) {\n        process.emitWarning(`Could not close the doom-runner lifeline: ${String(error)}`);\n      }\n      this.server = undefined;\n    }\n    if (this.target) {\n      try {\n        fs.rmSync(this.target, { force: true });\n      } catch (error) {\n        process.emitWarning(`Could not remove the doom-runner lifeline: ${String(error)}`);\n      }\n      this.target = undefined;\n    }\n  }\n\n  /** Keeps the socket beside the session it belongs to unless that path is too long to bind. */\n  private socketPath(sessionId: string): string {\n    const preferred = path.join(this.paths.stateDirectory(sessionId), SOCKET_NAME);\n    if (Buffer.byteLength(preferred) <= SOCKET_PATH_LIMIT) return preferred;\n    const hash = createHash('sha256').update(preferred).digest('hex').slice(0, SOCKET_HASH_LENGTH);\n    return path.join(os.tmpdir(), `doom-runner-${hash}.sock`);\n  }\n}\n\n/** Binding must complete before the first runner launches, so arming waits for it. */\nfunction listen(server: net.Server, target: string): Promise<void> {\n  return new Promise((resolve, reject) => {\n    server.once('error', reject);\n    server.listen(target, () => {\n      server.removeListener('error', reject);\n      // Later errors would otherwise reach the process as unhandled.\n      server.on('error', (error: Error) => process.emitWarning(`doom-runner lifeline failed: ${error.message}`));\n      resolve();\n    });\n  });\n}\n"],"mappings":";;;;;;AAAA,MAAa,cAAc;;;;ACY3B,IAAa,eAAb,MAA+C;CAMhB;CAL7B;CACA;;CAEA,8BAA+B,IAAI,IAAgB;CAEnD,YAAY,OAAsC;EAArB,KAAA,QAAA;CAAsB;CAEnD,MAAM,IAAI,WAAgD;EACxD,IAAI,KAAK,QAAQ,OAAO,KAAK;EAC7B,IAAI;GACF,KAAK,MAAM,kBAAkB,SAAS;GACtC,MAAM,SAAS,KAAK,WAAW,SAAS;GAExC,GAAG,OAAO,QAAQ,EAAE,OAAO,KAAK,CAAC;GACjC,MAAM,SAAS,IAAI,cAAc,eAAe;IAE9C,WAAW,MAAM;IACjB,WAAW,OAAO;IAClB,KAAK,YAAY,IAAI,UAAU;IAC/B,WAAW,GAAG,eAAe,KAAK,YAAY,OAAO,UAAU,CAAC;GAClE,CAAC;GACD,MAAM,OAAO,QAAQ,MAAM;GAC3B,GAAG,UAAU,QAAA,GAAmB;GAEhC,OAAO,MAAM;GACb,KAAK,SAAS;GACd,KAAK,SAAS;GACd,OAAO;EACT,SAAS,OAAO;GAGd,QAAQ,YAAY,2CAA2C,OAAO,KAAK,GAAG;GAC9E;EACF;CACF;CAEA,OAA2B;EACzB,OAAO,KAAK;CACd;CAEA,UAAgB;EAGd,KAAK,MAAM,cAAc,KAAK,aAAa,WAAW,QAAQ;EAC9D,KAAK,YAAY,MAAM;EACvB,IAAI,KAAK,QAAQ;GACf,IAAI;IACF,KAAK,OAAO,MAAM;GACpB,SAAS,OAAO;IACd,QAAQ,YAAY,6CAA6C,OAAO,KAAK,GAAG;GAClF;GACA,KAAK,SAAS,KAAA;EAChB;EACA,IAAI,KAAK,QAAQ;GACf,IAAI;IACF,GAAG,OAAO,KAAK,QAAQ,EAAE,OAAO,KAAK,CAAC;GACxC,SAAS,OAAO;IACd,QAAQ,YAAY,8CAA8C,OAAO,KAAK,GAAG;GACnF;GACA,KAAK,SAAS,KAAA;EAChB;CACF;;CAGA,WAAmB,WAA2B;EAC5C,MAAM,YAAY,KAAK,KAAK,KAAK,MAAM,eAAe,SAAS,GAAG,WAAW;EAC7E,IAAI,OAAO,WAAW,SAAS,KAAA,KAAwB,OAAO;EAC9D,MAAM,OAAO,WAAW,QAAQ,CAAC,CAAC,OAAO,SAAS,CAAC,CAAC,OAAO,KAAK,CAAC,CAAC,MAAM,GAAA,EAAqB;EAC7F,OAAO,KAAK,KAAK,GAAG,OAAO,GAAG,eAAe,KAAK,MAAM;CAC1D;AACF;;AAGA,SAAS,OAAO,QAAoB,QAA+B;CACjE,OAAO,IAAI,SAAS,SAAS,WAAW;EACtC,OAAO,KAAK,SAAS,MAAM;EAC3B,OAAO,OAAO,cAAc;GAC1B,OAAO,eAAe,SAAS,MAAM;GAErC,OAAO,GAAG,UAAU,UAAiB,QAAQ,YAAY,gCAAgC,MAAM,SAAS,CAAC;GACzG,QAAQ;EACV,CAAC;CACH,CAAC;AACH"}

package/dist/lifeline-BuV_erib.cjs

@@ -0,0 +1,98 @@
+const require_rolldown_runtime = require("./rolldown-runtime-VH7oDXx4.cjs");
+let node_crypto = require("node:crypto");
+let node_fs = require("node:fs");
+node_fs = require_rolldown_runtime.__toESM(node_fs, 1);
+let node_path = require("node:path");
+node_path = require_rolldown_runtime.__toESM(node_path, 1);
+let node_net = require("node:net");
+node_net = require_rolldown_runtime.__toESM(node_net, 1);
+let node_os = require("node:os");
+node_os = require_rolldown_runtime.__toESM(node_os, 1);
+//#region src/constants/lifeline.ts
+const SOCKET_NAME = "lifeline.sock";
+//#endregion
+//#region src/services/lifeline/index.ts
+/** Unix socket paths are capped at 104 bytes, so a long agent directory falls back to the temp dir. */
+var NodeLifeline = class {
+	paths;
+	server;
+	target;
+	/** Closing a server stops it accepting; only the connections carry the death signal. */
+	connections = /* @__PURE__ */ new Set();
+	constructor(paths) {
+		this.paths = paths;
+	}
+	async arm(sessionId) {
+		if (this.target) return this.target;
+		try {
+			this.paths.ensureDirectories(sessionId);
+			const target = this.socketPath(sessionId);
+			node_fs.default.rmSync(target, { force: true });
+			const server = node_net.default.createServer((connection) => {
+				connection.unref();
+				connection.resume();
+				this.connections.add(connection);
+				connection.on("close", () => this.connections.delete(connection));
+			});
+			await listen(server, target);
+			node_fs.default.chmodSync(target, 384);
+			server.unref();
+			this.server = server;
+			this.target = target;
+			return target;
+		} catch (error) {
+			process.emitWarning(`Could not arm the doom-runner lifeline: ${String(error)}`);
+			return;
+		}
+	}
+	path() {
+		return this.target;
+	}
+	dispose() {
+		for (const connection of this.connections) connection.destroy();
+		this.connections.clear();
+		if (this.server) {
+			try {
+				this.server.close();
+			} catch (error) {
+				process.emitWarning(`Could not close the doom-runner lifeline: ${String(error)}`);
+			}
+			this.server = void 0;
+		}
+		if (this.target) {
+			try {
+				node_fs.default.rmSync(this.target, { force: true });
+			} catch (error) {
+				process.emitWarning(`Could not remove the doom-runner lifeline: ${String(error)}`);
+			}
+			this.target = void 0;
+		}
+	}
+	/** Keeps the socket beside the session it belongs to unless that path is too long to bind. */
+	socketPath(sessionId) {
+		const preferred = node_path.default.join(this.paths.stateDirectory(sessionId), SOCKET_NAME);
+		if (Buffer.byteLength(preferred) <= 100) return preferred;
+		const hash = (0, node_crypto.createHash)("sha256").update(preferred).digest("hex").slice(0, 12);
+		return node_path.default.join(node_os.default.tmpdir(), `doom-runner-${hash}.sock`);
+	}
+};
+/** Binding must complete before the first runner launches, so arming waits for it. */
+function listen(server, target) {
+	return new Promise((resolve, reject) => {
+		server.once("error", reject);
+		server.listen(target, () => {
+			server.removeListener("error", reject);
+			server.on("error", (error) => process.emitWarning(`doom-runner lifeline failed: ${error.message}`));
+			resolve();
+		});
+	});
+}
+//#endregion
+Object.defineProperty(exports, "NodeLifeline", {
+	enumerable: true,
+	get: function() {
+		return NodeLifeline;
+	}
+});
+
+//# sourceMappingURL=lifeline-BuV_erib.cjs.map

package/dist/lifeline-BuV_erib.cjs.map

@@ -0,0 +1 @@
+{"version":3,"file":"lifeline-BuV_erib.cjs","names":["net","path","createHash","os"],"sources":["../src/constants/lifeline.ts","../src/services/lifeline/index.ts"],"sourcesContent":["export const SOCKET_NAME = 'lifeline.sock';\nexport const SOCKET_PATH_LIMIT = 100;\nexport const SOCKET_HASH_LENGTH = 12;\nexport const SOCKET_MODE = 0o600;\n","import { createHash } from 'node:crypto';\nimport fs from 'node:fs';\nimport net from 'node:net';\nimport os from 'node:os';\nimport path from 'node:path';\n\nimport { SOCKET_HASH_LENGTH, SOCKET_MODE, SOCKET_NAME, SOCKET_PATH_LIMIT } from '../../constants/lifeline';\nimport type { ILifeline } from '../../types/lifeline';\nimport type { IRunnerPaths } from '../runnerPaths/type';\n\n/** Unix socket paths are capped at 104 bytes, so a long agent directory falls back to the temp dir. */\n\nexport class NodeLifeline implements ILifeline {\n  private server: net.Server | undefined;\n  private target: string | undefined;\n  /** Closing a server stops it accepting; only the connections carry the death signal. */\n  private readonly connections = new Set<net.Socket>();\n\n  constructor(private readonly paths: IRunnerPaths) {}\n\n  async arm(sessionId: string): Promise<string | undefined> {\n    if (this.target) return this.target;\n    try {\n      this.paths.ensureDirectories(sessionId);\n      const target = this.socketPath(sessionId);\n      // A socket left behind by a SIGKILLed predecessor refuses connections, never accepts them.\n      fs.rmSync(target, { force: true });\n      const server = net.createServer((connection) => {\n        // Runners need only the close edge, so their liveness and their data are equally irrelevant.\n        connection.unref();\n        connection.resume();\n        this.connections.add(connection);\n        connection.on('close', () => this.connections.delete(connection));\n      });\n      await listen(server, target);\n      fs.chmodSync(target, SOCKET_MODE);\n      // The lifeline must never be the reason pi stays alive.\n      server.unref();\n      this.server = server;\n      this.target = target;\n      return target;\n    } catch (error) {\n      // Runners stay unwatched rather than unlaunchable, so a session without a\n      // lifeline degrades to running them unsupervised instead of failing.\n      process.emitWarning(`Could not arm the doom-runner lifeline: ${String(error)}`);\n      return undefined;\n    }\n  }\n\n  path(): string | undefined {\n    return this.target;\n  }\n\n  dispose(): void {\n    // Dropping the connections is what a runner sees, and it is the whole point\n    // of disposing: closing the server alone would leave every runner waiting.\n    for (const connection of this.connections) connection.destroy();\n    this.connections.clear();\n    if (this.server) {\n      try {\n        this.server.close();\n      } catch (error) {\n        process.emitWarning(`Could not close the doom-runner lifeline: ${String(error)}`);\n      }\n      this.server = undefined;\n    }\n    if (this.target) {\n      try {\n        fs.rmSync(this.target, { force: true });\n      } catch (error) {\n        process.emitWarning(`Could not remove the doom-runner lifeline: ${String(error)}`);\n      }\n      this.target = undefined;\n    }\n  }\n\n  /** Keeps the socket beside the session it belongs to unless that path is too long to bind. */\n  private socketPath(sessionId: string): string {\n    const preferred = path.join(this.paths.stateDirectory(sessionId), SOCKET_NAME);\n    if (Buffer.byteLength(preferred) <= SOCKET_PATH_LIMIT) return preferred;\n    const hash = createHash('sha256').update(preferred).digest('hex').slice(0, SOCKET_HASH_LENGTH);\n    return path.join(os.tmpdir(), `doom-runner-${hash}.sock`);\n  }\n}\n\n/** Binding must complete before the first runner launches, so arming waits for it. */\nfunction listen(server: net.Server, target: string): Promise<void> {\n  return new Promise((resolve, reject) => {\n    server.once('error', reject);\n    server.listen(target, () => {\n      server.removeListener('error', reject);\n      // Later errors would otherwise reach the process as unhandled.\n      server.on('error', (error: Error) => process.emitWarning(`doom-runner lifeline failed: ${error.message}`));\n      resolve();\n    });\n  });\n}\n"],"mappings":";;;;;;;;;;;AAAA,MAAa,cAAc;;;;ACY3B,IAAa,eAAb,MAA+C;CAMhB;CAL7B;CACA;;CAEA,8BAA+B,IAAI,IAAgB;CAEnD,YAAY,OAAsC;EAArB,KAAA,QAAA;CAAsB;CAEnD,MAAM,IAAI,WAAgD;EACxD,IAAI,KAAK,QAAQ,OAAO,KAAK;EAC7B,IAAI;GACF,KAAK,MAAM,kBAAkB,SAAS;GACtC,MAAM,SAAS,KAAK,WAAW,SAAS;GAExC,QAAA,QAAG,OAAO,QAAQ,EAAE,OAAO,KAAK,CAAC;GACjC,MAAM,SAASA,SAAAA,QAAI,cAAc,eAAe;IAE9C,WAAW,MAAM;IACjB,WAAW,OAAO;IAClB,KAAK,YAAY,IAAI,UAAU;IAC/B,WAAW,GAAG,eAAe,KAAK,YAAY,OAAO,UAAU,CAAC;GAClE,CAAC;GACD,MAAM,OAAO,QAAQ,MAAM;GAC3B,QAAA,QAAG,UAAU,QAAA,GAAmB;GAEhC,OAAO,MAAM;GACb,KAAK,SAAS;GACd,KAAK,SAAS;GACd,OAAO;EACT,SAAS,OAAO;GAGd,QAAQ,YAAY,2CAA2C,OAAO,KAAK,GAAG;GAC9E;EACF;CACF;CAEA,OAA2B;EACzB,OAAO,KAAK;CACd;CAEA,UAAgB;EAGd,KAAK,MAAM,cAAc,KAAK,aAAa,WAAW,QAAQ;EAC9D,KAAK,YAAY,MAAM;EACvB,IAAI,KAAK,QAAQ;GACf,IAAI;IACF,KAAK,OAAO,MAAM;GACpB,SAAS,OAAO;IACd,QAAQ,YAAY,6CAA6C,OAAO,KAAK,GAAG;GAClF;GACA,KAAK,SAAS,KAAA;EAChB;EACA,IAAI,KAAK,QAAQ;GACf,IAAI;IACF,QAAA,QAAG,OAAO,KAAK,QAAQ,EAAE,OAAO,KAAK,CAAC;GACxC,SAAS,OAAO;IACd,QAAQ,YAAY,8CAA8C,OAAO,KAAK,GAAG;GACnF;GACA,KAAK,SAAS,KAAA;EAChB;CACF;;CAGA,WAAmB,WAA2B;EAC5C,MAAM,YAAYC,UAAAA,QAAK,KAAK,KAAK,MAAM,eAAe,SAAS,GAAG,WAAW;EAC7E,IAAI,OAAO,WAAW,SAAS,KAAA,KAAwB,OAAO;EAC9D,MAAM,QAAA,GAAOC,YAAAA,WAAAA,CAAW,QAAQ,CAAC,CAAC,OAAO,SAAS,CAAC,CAAC,OAAO,KAAK,CAAC,CAAC,MAAM,GAAA,EAAqB;EAC7F,OAAOD,UAAAA,QAAK,KAAKE,QAAAA,QAAG,OAAO,GAAG,eAAe,KAAK,MAAM;CAC1D;AACF;;AAGA,SAAS,OAAO,QAAoB,QAA+B;CACjE,OAAO,IAAI,SAAS,SAAS,WAAW;EACtC,OAAO,KAAK,SAAS,MAAM;EAC3B,OAAO,OAAO,cAAc;GAC1B,OAAO,eAAe,SAAS,MAAM;GAErC,OAAO,GAAG,UAAU,UAAiB,QAAQ,YAAY,gCAAgC,MAAM,SAAS,CAAC;GACzG,QAAQ;EACV,CAAC;CACH,CAAC;AACH"}

package/dist/lifeline-eJdZV0nN.d.mts

@@ -0,0 +1,19 @@
+//#region src/types/lifeline.d.ts
+/**
+ * A Unix socket the owning pi process listens on for the life of a session.
+ *
+ * Runner supervisors connect to it and watch for the close edge, which arrives
+ * on every owner exit path including SIGKILL. That is the one death signal a
+ * graceful shutdown handler cannot provide.
+ */
+interface ILifeline {
+  /** Binds the socket and starts listening. Idempotent; resolves with the path. */
+  arm(sessionId: string): Promise<string | undefined>;
+  /** Path of the armed lifeline, if arming succeeded. */
+  path(): string | undefined;
+  /** Stops listening and removes the socket. */
+  dispose(): void;
+}
+//#endregion
+export { ILifeline as t };
+//# sourceMappingURL=lifeline-eJdZV0nN.d.mts.map

package/dist/lifeline-eJdZV0nN.d.mts.map

@@ -0,0 +1 @@
+{"version":3,"file":"lifeline-eJdZV0nN.d.mts","names":[],"sources":["../src/types/lifeline.ts"],"mappings":";;;;;;;;UAOiB;;EAEf,IAAI,oBAAoB;;EAExB;;EAEA"}

package/dist/lifeline.cjs

@@ -0,0 +1,6 @@
+Object.defineProperty(exports, Symbol.toStringTag, { value: "Module" });
+const require_services_lifeline_client = require("./services/lifeline/client.cjs");
+const require_lifeline = require("./lifeline-BuV_erib.cjs");
+exports.LIFELINE_ENV = require_services_lifeline_client.LIFELINE_ENV;
+exports.NodeLifeline = require_lifeline.NodeLifeline;
+exports.watchOwner = require_services_lifeline_client.watchOwner;

package/dist/lifeline.d.mts

@@ -0,0 +1,21 @@
+import { t as ILifeline } from "./lifeline-eJdZV0nN.mjs";
+import { t as IRunnerPaths } from "./type-BXM03qSw.mjs";
+import { LIFELINE_ENV, watchOwner } from "./services/lifeline/client.mjs";
+//#region src/services/lifeline/index.d.ts
+/** Unix socket paths are capped at 104 bytes, so a long agent directory falls back to the temp dir. */
+export declare class NodeLifeline implements ILifeline {
+  private readonly paths;
+  private server;
+  private target;
+  /** Closing a server stops it accepting; only the connections carry the death signal. */
+  private readonly connections;
+  constructor(paths: IRunnerPaths);
+  arm(sessionId: string): Promise<string | undefined>;
+  path(): string | undefined;
+  dispose(): void;
+  /** Keeps the socket beside the session it belongs to unless that path is too long to bind. */
+  private socketPath;
+}
+//#endregion
+export { type ILifeline, LIFELINE_ENV, watchOwner };
+//# sourceMappingURL=lifeline.d.mts.map

package/dist/lifeline.d.mts.map

@@ -0,0 +1 @@
+{"version":3,"file":"lifeline.d.mts","names":[],"sources":["../src/services/lifeline/index.ts"],"mappings":";;;;;qBAYa,wBAAwB;mBAMN;UALrB;UACA;;mBAES;EAEjB,YAA6B,OAAO;EAE9B,IAAI,oBAAoB;EA6B9B;EAIA;;UAwBQ"}

package/dist/lifeline.mjs

@@ -0,0 +1,3 @@
+import { LIFELINE_ENV, watchOwner } from "./services/lifeline/client.mjs";
+import { t as NodeLifeline } from "./lifeline-BZaQA0rm.mjs";
+export { LIFELINE_ENV, NodeLifeline, watchOwner };

package/dist/logFile-C7oQ_v-g.d.mts

@@ -0,0 +1,16 @@
+//#region src/types/logFile.d.ts
+/** An open append handle for one runner's log. */
+interface LogWriter {
+  readonly path: string;
+  append(text: string): void;
+  /** Bytes currently in the file at `path`; rotation restarts the count. */
+  size(): number;
+  close(): void;
+}
+/** Opens runner log files, truncating any output left by a previous runner of the same name. */
+interface ILogFile {
+  open(id: string): LogWriter;
+}
+//#endregion
+export { LogWriter as n, ILogFile as t };
+//# sourceMappingURL=logFile-C7oQ_v-g.d.mts.map

package/dist/logFile-C7oQ_v-g.d.mts.map

@@ -0,0 +1 @@
+{"version":3,"file":"logFile-C7oQ_v-g.d.mts","names":[],"sources":["../src/types/logFile.ts"],"mappings":";;UACiB;WACN;EACT,OAAO;;EAEP;EACA;;;UAIe;EACf,KAAK,aAAa"}

package/dist/logFile-CNvepZh0.cjs

@@ -0,0 +1,67 @@
+const require_rolldown_runtime = require("./rolldown-runtime-VH7oDXx4.cjs");
+const require_runnerConfig = require("./runnerConfig-D2tGq5ZM.cjs");
+let node_fs = require("node:fs");
+node_fs = require_rolldown_runtime.__toESM(node_fs, 1);
+//#region src/services/logFile/index.ts
+var LogFile = class {
+	paths;
+	constructor(paths) {
+		this.paths = paths;
+	}
+	open(id) {
+		this.paths.ensureDirectories();
+		const logPath = this.paths.logPathFor(id);
+		const rotatedPath = this.paths.rotatedLogPathFor(id);
+		const maxBytes = require_runnerConfig.getLogMaxBytes();
+		let handle = node_fs.default.openSync(logPath, "w");
+		let written = 0;
+		let closed = false;
+		/**
+		* A run that keeps producing output for hours would otherwise grow one file
+		* without limit. Rotating keeps the newest window at the advertised path
+		* and the window before it alongside, so on-disk cost is bounded at roughly
+		* twice the ceiling, the path a result advertises stays valid, and the line
+		* counts a reader reports still describe the file it actually read.
+		*/
+		const rotate = () => {
+			node_fs.default.closeSync(handle);
+			try {
+				node_fs.default.renameSync(logPath, rotatedPath);
+			} catch (error) {
+				process.emitWarning(`Could not rotate runner log ${logPath}: ${String(error)}`);
+			}
+			handle = node_fs.default.openSync(logPath, "w");
+			written = 0;
+		};
+		return {
+			path: logPath,
+			append(text) {
+				const chunk = Buffer.from(text, "utf8");
+				if (written > 0 && written + chunk.byteLength > maxBytes) rotate();
+				node_fs.default.writeSync(handle, chunk);
+				written += chunk.byteLength;
+			},
+			size() {
+				return written;
+			},
+			close() {
+				if (closed) return;
+				closed = true;
+				try {
+					node_fs.default.closeSync(handle);
+				} catch (error) {
+					process.emitWarning(`Could not close runner log ${logPath}: ${String(error)}`);
+				}
+			}
+		};
+	}
+};
+//#endregion
+Object.defineProperty(exports, "LogFile", {
+	enumerable: true,
+	get: function() {
+		return LogFile;
+	}
+});
+
+//# sourceMappingURL=logFile-CNvepZh0.cjs.map

package/dist/logFile-CNvepZh0.cjs.map

@@ -0,0 +1 @@
+{"version":3,"file":"logFile-CNvepZh0.cjs","names":["getLogMaxBytes","fs"],"sources":["../src/services/logFile/index.ts"],"sourcesContent":["import fs from 'node:fs';\n\nimport type { ILogFile, LogWriter } from '../../types/logFile';\nimport { getLogMaxBytes } from '../runnerConfig';\nimport type { IRunnerPaths } from '../runnerPaths/type';\n\nexport class LogFile implements ILogFile {\n  constructor(private readonly paths: IRunnerPaths) {}\n\n  open(id: string): LogWriter {\n    this.paths.ensureDirectories();\n    const logPath = this.paths.logPathFor(id);\n    const rotatedPath = this.paths.rotatedLogPathFor(id);\n    const maxBytes = getLogMaxBytes();\n\n    // A reused name starts clean: the previous runner's output is already\n    // available to whoever wanted it, and mixing two runs in one file makes\n    // both unreadable.\n    let handle = fs.openSync(logPath, 'w');\n    let written = 0;\n    let closed = false;\n\n    /**\n     * A run that keeps producing output for hours would otherwise grow one file\n     * without limit. Rotating keeps the newest window at the advertised path\n     * and the window before it alongside, so on-disk cost is bounded at roughly\n     * twice the ceiling, the path a result advertises stays valid, and the line\n     * counts a reader reports still describe the file it actually read.\n     */\n    const rotate = (): void => {\n      fs.closeSync(handle);\n      try {\n        fs.renameSync(logPath, rotatedPath);\n      } catch (error) {\n        // Holding the ceiling matters more than keeping the previous window,\n        // so the new file is opened either way and the loss is reported.\n        process.emitWarning(`Could not rotate runner log ${logPath}: ${String(error)}`);\n      }\n      handle = fs.openSync(logPath, 'w');\n      written = 0;\n    };\n\n    return {\n      path: logPath,\n      append(text: string): void {\n        const chunk = Buffer.from(text, 'utf8');\n        // An empty file always takes the chunk, so a single write larger than\n        // the ceiling is stored rather than rotated away into nothing.\n        if (written > 0 && written + chunk.byteLength > maxBytes) rotate();\n        fs.writeSync(handle, chunk);\n        written += chunk.byteLength;\n      },\n      size(): number {\n        return written;\n      },\n      close(): void {\n        // Closing twice is normal: a launch that fails closes the log before\n        // the exit handler does. Only a first close that fails is news.\n        if (closed) return;\n        closed = true;\n        try {\n          fs.closeSync(handle);\n        } catch (error) {\n          process.emitWarning(`Could not close runner log ${logPath}: ${String(error)}`);\n        }\n      },\n    };\n  }\n}\n"],"mappings":";;;;;AAMA,IAAa,UAAb,MAAyC;CACV;CAA7B,YAAY,OAAsC;EAArB,KAAA,QAAA;CAAsB;CAEnD,KAAK,IAAuB;EAC1B,KAAK,MAAM,kBAAkB;EAC7B,MAAM,UAAU,KAAK,MAAM,WAAW,EAAE;EACxC,MAAM,cAAc,KAAK,MAAM,kBAAkB,EAAE;EACnD,MAAM,WAAWA,qBAAAA,eAAe;EAKhC,IAAI,SAASC,QAAAA,QAAG,SAAS,SAAS,GAAG;EACrC,IAAI,UAAU;EACd,IAAI,SAAS;;;;;;;;EASb,MAAM,eAAqB;GACzB,QAAA,QAAG,UAAU,MAAM;GACnB,IAAI;IACF,QAAA,QAAG,WAAW,SAAS,WAAW;GACpC,SAAS,OAAO;IAGd,QAAQ,YAAY,+BAA+B,QAAQ,IAAI,OAAO,KAAK,GAAG;GAChF;GACA,SAASA,QAAAA,QAAG,SAAS,SAAS,GAAG;GACjC,UAAU;EACZ;EAEA,OAAO;GACL,MAAM;GACN,OAAO,MAAoB;IACzB,MAAM,QAAQ,OAAO,KAAK,MAAM,MAAM;IAGtC,IAAI,UAAU,KAAK,UAAU,MAAM,aAAa,UAAU,OAAO;IACjE,QAAA,QAAG,UAAU,QAAQ,KAAK;IAC1B,WAAW,MAAM;GACnB;GACA,OAAe;IACb,OAAO;GACT;GACA,QAAc;IAGZ,IAAI,QAAQ;IACZ,SAAS;IACT,IAAI;KACF,QAAA,QAAG,UAAU,MAAM;IACrB,SAAS,OAAO;KACd,QAAQ,YAAY,8BAA8B,QAAQ,IAAI,OAAO,KAAK,GAAG;IAC/E;GACF;EACF;CACF;AACF"}