acpx 0.9.0 → 0.11.0

package/dist/cli.js

@@ -1,13 +1,16 @@
 #!/usr/bin/env node
-import { a as runSessionQueueOwner, c as buildQueueOwnerArgOverride, h as __exportAll, l as flushPerfMetricsCapture, n as getTextErrorRemediationHints, p as probeQueueOwnerHealth, t as createOutputFormatter, u as installPerfMetricsCapture } from "./output-DPg20dvn.js";
-import { At as EXIT_CODES, F as findSession, I as findSessionByDirectoryWalk, P as findGitRepositoryRoot, Pt as OUTPUT_FORMATS, Rt as AgentSpawnError, St as exitCodeForOutputErrorCode, Tt as normalizeOutputError, bt as normalizeAgentName, ct as PromptInputValidationError, dt as parsePromptSource, mt as InterruptedError, pt as textPrompt, st as normalizeRuntimeSessionId, ut as mergePromptSourceWithText, vt as DEFAULT_AGENT_NAME, yt as listBuiltInAgents } from "./live-checkpoint-D5d-K9s1.js";
-import { _ as resolveOutputPolicy, b as loadPermissionPolicySpec, c as parseHistoryLimit, d as parseOutputFormat$1, f as parsePruneBeforeDate, g as resolveGlobalFlags, h as resolveAgentInvocation, i as addSessionOption, l as parseMaxTurns, m as parseTtlSeconds, n as addPromptInputOption, o as parseAllowedTools, p as parseSessionName, r as addSessionNameOption, s as parseDaysOlderThan, t as addGlobalFlags, u as parseNonEmptyValue, v as resolvePermissionMode, y as resolveSessionNameFromFlags } from "./flags-C-rwARqg.js";
-import { readFileSync, realpathSync } from "node:fs";
+import { a as runSessionQueueOwner, c as buildQueueOwnerArgOverride, g as __exportAll, h as isProcessAlive, l as flushPerfMetricsCapture, n as getTextErrorRemediationHints, o as runOnce, p as probeQueueOwnerHealth, t as createOutputFormatter, u as installPerfMetricsCapture } from "./output-D_BGt1YI.js";
+import { B as listSessions, Bt as OUTPUT_FORMATS, Et as normalizeAgentName$1, G as writeSessionRecord, Gt as AgentSpawnError, H as normalizeName, I as findGitRepositoryRoot, It as EXIT_CODES, L as findSession, M as getAcpxVersion, Ot as exitCodeForOutputErrorCode, R as findSessionByDirectoryWalk, Tt as listBuiltInAgents, Wt as AcpxOperationalError, _t as parsePromptSource, at as defaultSessionEventLog, bt as InterruptedError, ct as sessionEventLockPath, dt as isAcpJsonRpcMessage, gt as mergePromptSourceWithText, jt as normalizeOutputError, lt as sessionEventSegmentPath, mt as PromptInputValidationError, nt as serializeSessionRecordForDisk, rt as normalizeRuntimeSessionId, st as sessionEventActivePath, tt as parseSessionRecord, wt as DEFAULT_AGENT_NAME, xt as TimeoutError, yt as textPrompt } from "./live-checkpoint-BZrk9Mjz.js";
+import { _ as resolveGlobalFlags, b as resolveSessionNameFromFlags, c as parseHistoryLimit, d as parseOutputFormat$1, f as parsePruneBeforeDate, g as resolveAgentInvocation, h as parseTtlSeconds, i as addSessionOption, l as parseMaxTurns, m as parseTimeoutSeconds, n as addPromptInputOption, o as parseAllowedTools, p as parseSessionName, r as addSessionNameOption, s as parseDaysOlderThan, t as addGlobalFlags, u as parseNonEmptyValue, v as resolveOutputPolicy, x as loadPermissionPolicySpec, y as resolvePermissionMode } from "./flags-BKjjl3tF.js";
+import { realpathSync } from "node:fs";
 import { fileURLToPath, pathToFileURL } from "node:url";
 import path from "node:path";
-import { Command, CommanderError, InvalidArgumentError } from "commander";
+import { Command, CommanderError, InvalidArgumentError, Option } from "commander";
 import fs$1 from "node:fs/promises";
 import os from "node:os";
+import { randomUUID } from "node:crypto";
+import { ZodError, z } from "zod";
+import { performance } from "node:perf_hooks";
 //#region src/cli-public.ts
 function configurePublicCli(options) {
 	const builtInAgents = options.listBuiltInAgents(options.config.agents);
@@ -53,6 +56,319 @@ function isLegacyZedCodexAcpInvocation(agentCommand) {
 	return /@zed-industries\/codex-acp\b/u.test(agentCommand);
 }
 //#endregion
+//#region src/session/export.ts
+var SessionExportError = class extends AcpxOperationalError {
+	code;
+	exitCode = 2;
+	constructor(message, code) {
+		super(message, {
+			outputCode: "USAGE",
+			detailCode: code,
+			origin: "cli"
+		});
+		this.code = code;
+	}
+};
+function sessionLookupError(message, code) {
+	return new SessionExportError(message, code);
+}
+async function loadSessionRecord(sessionLookup) {
+	const cwd = path.resolve(sessionLookup.cwd ?? process.cwd());
+	const name = normalizeName(sessionLookup.name);
+	if (sessionLookup.agentCommand) {
+		const active = await findSession({
+			agentCommand: sessionLookup.agentCommand,
+			cwd,
+			name
+		});
+		if (active) return active;
+		return (await listSessions()).find((session) => {
+			if (session.agentCommand !== sessionLookup.agentCommand || session.cwd !== cwd) return false;
+			if (name == null) return session.name == null;
+			return session.name === name;
+		});
+	}
+	const matches = (await listSessions()).filter((session) => {
+		if (session.cwd !== cwd) return false;
+		if (name == null) return session.name == null;
+		return session.name === name;
+	});
+	if (matches.length > 1) throw sessionLookupError("multiple sessions match export lookup", "ambiguous-session");
+	return matches[0];
+}
+function parseEventLockPayload(raw) {
+	try {
+		const parsed = JSON.parse(raw);
+		if (!parsed || typeof parsed !== "object" || Array.isArray(parsed)) return {};
+		const record = parsed;
+		return { pid: typeof record.pid === "number" ? record.pid : void 0 };
+	} catch {
+		return {};
+	}
+}
+async function hasLiveEventLock(recordId) {
+	try {
+		return isProcessAlive(parseEventLockPayload(await fs$1.readFile(sessionEventLockPath(recordId), "utf8")).pid);
+	} catch (error) {
+		if (error.code === "ENOENT") return false;
+		throw error;
+	}
+}
+async function isSessionActive(record) {
+	if (record.closed) return false;
+	return isProcessAlive(record.pid) || await hasLiveEventLock(record.acpxRecordId);
+}
+async function readHistoryFile(filePath) {
+	const payload = await fs$1.readFile(filePath, "utf8").catch((error) => {
+		if (error.code === "ENOENT") return "";
+		throw error;
+	});
+	const history = [];
+	for (const line of payload.split("\n").filter((entry) => entry.trim().length > 0)) try {
+		const parsed = JSON.parse(line);
+		if (isAcpJsonRpcMessage(parsed)) history.push(parsed);
+	} catch {}
+	return history;
+}
+async function readSessionHistory(record) {
+	const history = [];
+	const maxSegments = Number.isInteger(record.eventLog.max_segments) ? record.eventLog.max_segments : 0;
+	for (let segment = maxSegments; segment >= 1; segment -= 1) history.push(...await readHistoryFile(sessionEventSegmentPath(record.acpxRecordId, segment)));
+	history.push(...await readHistoryFile(sessionEventActivePath(record.acpxRecordId)));
+	return history;
+}
+function cwdRelativeToHome(cwd, home) {
+	const relative = path.relative(home, cwd);
+	if (relative.length === 0) return ".";
+	if (relative.length > 0 && !relative.startsWith("..") && !path.isAbsolute(relative)) return relative;
+	return cwd;
+}
+function serializeSessionRecordForArchive(record, cwdRelative) {
+	const state = serializeSessionRecordForDisk(record);
+	state.cwd = cwdRelative;
+	if (state.event_log && typeof state.event_log === "object" && !Array.isArray(state.event_log)) state.event_log = {
+		...state.event_log,
+		active_path: ".stream.ndjson"
+	};
+	return state;
+}
+async function exportSession(sessionLookup, outputPath) {
+	const record = await loadSessionRecord(sessionLookup);
+	if (!record) throw sessionLookupError("session not found", "not-found");
+	if (await isSessionActive(record)) throw sessionLookupError("session is currently locked by a running queue owner; close it first with `acpx sessions close`", "session-locked");
+	const home = os.homedir();
+	const cwdRelative = cwdRelativeToHome(record.cwd, home);
+	const exported = {
+		format_version: 1,
+		exported_at: (/* @__PURE__ */ new Date()).toISOString(),
+		exported_by: "acpx",
+		session: {
+			record_id: record.acpxRecordId,
+			name: record.name ?? null,
+			agent: record.agentCommand,
+			agent_name: normalizeAgentName(sessionLookup.agentName),
+			cwd_relative: cwdRelative,
+			cwd_original: cwdRelative,
+			created_at: record.createdAt,
+			updated_at: record.lastUsedAt,
+			state: serializeSessionRecordForArchive(record, cwdRelative)
+		},
+		history: await readSessionHistory(record)
+	};
+	await fs$1.mkdir(path.dirname(path.resolve(outputPath)), { recursive: true });
+	await fs$1.writeFile(outputPath, `${JSON.stringify(exported, null, 2)}\n`, "utf8");
+}
+function normalizeAgentName(agentName) {
+	const normalized = agentName?.trim().toLowerCase();
+	if (!normalized || normalized.length === 0) return;
+	return normalized === "factory-droid" || normalized === "factorydroid" ? "droid" : normalized;
+}
+//#endregion
+//#region src/session/import.ts
+const SUPPORTED_FORMAT_VERSION = 1;
+const exportedSessionSchema = z.object({
+	format_version: z.literal(SUPPORTED_FORMAT_VERSION),
+	exported_at: z.string(),
+	exported_by: z.string(),
+	session: z.object({
+		record_id: z.string(),
+		name: z.string().nullable(),
+		agent: z.string(),
+		agent_name: z.string().optional(),
+		cwd_relative: z.string(),
+		cwd_original: z.string().optional(),
+		cwd_absolute_original: z.string().optional(),
+		created_at: z.string(),
+		updated_at: z.string(),
+		state: z.unknown()
+	}),
+	history: z.array(z.unknown())
+});
+var SessionImportError = class extends AcpxOperationalError {
+	code;
+	exitCode = 2;
+	constructor(message, code) {
+		super(message, {
+			outputCode: "USAGE",
+			detailCode: code,
+			origin: "cli"
+		});
+		this.code = code;
+	}
+};
+function importError(message, code) {
+	return new SessionImportError(message, code);
+}
+function parseArchiveJson(raw) {
+	try {
+		return JSON.parse(raw);
+	} catch (error) {
+		throw importError(`Invalid session export archive JSON: ${error instanceof Error ? error.message : String(error)}`, "invalid-archive");
+	}
+}
+function assertSupportedFormatVersion(parsed) {
+	const record = parsed && typeof parsed === "object" ? parsed : {};
+	if (record.format_version !== SUPPORTED_FORMAT_VERSION) throw importError(`Unsupported session export format_version ${String(record.format_version)}; supported version is ${SUPPORTED_FORMAT_VERSION}`, "unsupported-format-version");
+}
+function parseArchive(raw) {
+	const parsed = parseArchiveJson(raw);
+	assertSupportedFormatVersion(parsed);
+	try {
+		return exportedSessionSchema.parse(parsed);
+	} catch (error) {
+		if (error instanceof ZodError) throw importError(`Invalid session export archive: ${error.issues[0]?.message}`, "invalid-archive");
+		throw error;
+	}
+}
+async function generateRecordId(sessionsDir) {
+	for (;;) {
+		const recordId = randomUUID();
+		const filePath = path.join(sessionsDir, `${encodeURIComponent(recordId)}.json`);
+		try {
+			await fs$1.access(filePath);
+		} catch (error) {
+			if (error.code === "ENOENT") return recordId;
+			throw error;
+		}
+	}
+}
+function resolveImportedCwd(cwdRelative, newCwd) {
+	if (newCwd) return path.resolve(newCwd);
+	if (path.isAbsolute(cwdRelative)) return cwdRelative;
+	return path.join(os.homedir(), cwdRelative);
+}
+function resolveImportedName(parsed, requestedName) {
+	return requestedName ?? parsed.session.name ?? void 0;
+}
+function assertExpectedAgentCommand(parsed, sourceRecord, options) {
+	const expectedAgentCommand = options.expectedAgentCommand;
+	if (!expectedAgentCommand) return;
+	const expectedAgentName = normalizeAgentIdentity(options.expectedAgentName);
+	const archiveAgentName = normalizeAgentIdentity(parsed.session.agent_name);
+	const archiveCommandMatches = agentCommandMatchesExpected(parsed.session.agent, expectedAgentCommand, expectedAgentName);
+	const stateCommandMatches = agentCommandMatchesExpected(sourceRecord.agentCommand, expectedAgentCommand, expectedAgentName);
+	if (archiveCommandMatches && stateCommandMatches && archiveAgentNameMatches({
+		archiveAgentName,
+		expectedAgentName,
+		archiveCommand: parsed.session.agent,
+		stateCommand: sourceRecord.agentCommand,
+		expectedAgentCommand
+	})) {
+		sourceRecord.agentCommand = expectedAgentCommand;
+		return;
+	}
+	throw importError("Session export archive agent does not match the requested agent", "agent-mismatch");
+}
+function archiveAgentNameMatches(params) {
+	if (params.archiveCommand === params.expectedAgentCommand && params.stateCommand === params.expectedAgentCommand) return true;
+	return params.archiveAgentName == null || params.expectedAgentName == null || params.archiveAgentName === params.expectedAgentName;
+}
+function normalizeAgentIdentity(agentName) {
+	const normalized = agentName?.trim().toLowerCase();
+	if (!normalized || normalized.length === 0) return;
+	return normalized === "factory-droid" || normalized === "factorydroid" ? "droid" : normalized;
+}
+function agentCommandMatchesExpected(archivedCommand, expectedAgentCommand, expectedAgentName) {
+	if (archivedCommand === expectedAgentCommand) return true;
+	return expectedAgentName ? commandLooksLikeBuiltInAgent(archivedCommand, expectedAgentName) : false;
+}
+function commandLooksLikeBuiltInAgent(command, agentName) {
+	const normalized = command.trim();
+	switch (agentName) {
+		case "pi": return /(?:^|\s)pi-acp(?:@|\s|$)/.test(normalized);
+		case "codex": return /(?:^|\s)@agentclientprotocol\/codex-acp(?:@|\s|$)/.test(normalized);
+		case "claude": return /(?:^|\s)@agentclientprotocol\/claude-agent-acp(?:@|\s|$)/.test(normalized);
+		default: return false;
+	}
+}
+async function assertDestinationScopeAvailable(record) {
+	if (!await findSession({
+		agentCommand: record.agentCommand,
+		cwd: record.cwd,
+		name: record.name
+	})) return;
+	throw importError("A session already exists for the import destination scope; pass --name or --cwd to import a separate copy", "session-scope-exists");
+}
+async function assertProviderSessionAvailable(record) {
+	if (!(await listSessions()).find((session) => session.acpSessionId === record.acpSessionId)) return;
+	throw importError("A local session already uses this provider session id; prune or remove the existing record before importing this archive", "session-provider-exists");
+}
+function buildImportedRecord(parsed, sourceRecord, options) {
+	const eventLog = {
+		...defaultSessionEventLog(options.newRecordId),
+		max_segment_bytes: sourceRecord.eventLog.max_segment_bytes,
+		max_segments: sourceRecord.eventLog.max_segments,
+		segment_count: parsed.history.length > 0 ? 1 : sourceRecord.eventLog.segment_count
+	};
+	return {
+		...sourceRecord,
+		acpxRecordId: options.newRecordId,
+		cwd: options.cwd,
+		name: resolveImportedName(parsed, options.name),
+		closed: false,
+		closedAt: void 0,
+		pid: void 0,
+		agentStartedAt: void 0,
+		lastAgentExitCode: void 0,
+		lastAgentExitSignal: void 0,
+		lastAgentExitAt: void 0,
+		lastAgentDisconnectReason: void 0,
+		eventLog,
+		importedFrom: {
+			recordId: parsed.session.record_id,
+			cwdOriginal: parsed.session.cwd_original ?? parsed.session.cwd_relative,
+			exportedBy: parsed.exported_by,
+			exportedAt: parsed.exported_at
+		}
+	};
+}
+async function importSession(archivePath, options = {}) {
+	const parsed = parseArchive(await fs$1.readFile(archivePath, "utf8"));
+	const sourceRecord = parseSessionRecord(parsed.session.state);
+	if (!sourceRecord) throw importError("Invalid session export archive: session.state is not a session record", "invalid-archive");
+	assertExpectedAgentCommand(parsed, sourceRecord, options);
+	const sessionsDir = path.join(os.homedir(), ".acpx", "sessions");
+	await fs$1.mkdir(sessionsDir, { recursive: true });
+	const cwd = resolveImportedCwd(parsed.session.cwd_relative, options.newCwd);
+	const newRecordId = await generateRecordId(sessionsDir);
+	const newRecord = buildImportedRecord(parsed, sourceRecord, {
+		newRecordId,
+		cwd,
+		name: options.name
+	});
+	await assertDestinationScopeAvailable(newRecord);
+	await assertProviderSessionAvailable(newRecord);
+	await writeSessionRecord(newRecord);
+	if (parsed.history.length > 0) {
+		const history = parsed.history;
+		await fs$1.writeFile(sessionEventActivePath(newRecordId), `${history.map((entry) => JSON.stringify(entry)).join("\n")}\n`, "utf8");
+	}
+	return {
+		record_id: newRecordId,
+		cwd
+	};
+}
+//#endregion
 //#region src/cli/output/json-output.ts
 function emitJsonResult(format, payload) {
 	if (format !== "json") return false;
@@ -71,11 +387,11 @@ let sessionModulePromise;
 let outputModulePromise;
 let outputRenderModulePromise;
 function loadSessionModule() {
-	sessionModulePromise ??= import("./output-DPg20dvn.js").then((n) => n.i);
+	sessionModulePromise ??= import("./output-D_BGt1YI.js").then((n) => n.i);
 	return sessionModulePromise;
 }
 function loadOutputModule() {
-	outputModulePromise ??= import("./output-DPg20dvn.js").then((n) => n.r);
+	outputModulePromise ??= import("./output-D_BGt1YI.js").then((n) => n.r);
 	return outputModulePromise;
 }
 function loadOutputRenderModule() {
@@ -121,7 +437,7 @@ function resolveRequestedOutputPolicy(globalFlags) {
 		suppressReads: globalFlags.suppressReads === true
 	};
 }
-function sessionOptionsFromGlobalFlags(globalFlags) {
+function sessionOptionsFromGlobalFlags$1(globalFlags) {
 	return {
 		model: globalFlags.model,
 		allowedTools: globalFlags.allowedTools,
@@ -129,7 +445,7 @@ function sessionOptionsFromGlobalFlags(globalFlags) {
 		systemPrompt: globalFlags.systemPrompt
 	};
 }
-async function resolvePermissionPolicyFromFlags(globalFlags) {
+async function resolvePermissionPolicyFromFlags$1(globalFlags) {
 	try {
 		return await loadPermissionPolicySpec(globalFlags.permissionPolicy, globalFlags.cwd);
 	} catch (error) {
@@ -151,7 +467,8 @@ function buildSessionStartOptions(params) {
 		terminal: params.globalFlags.terminal,
 		timeoutMs: params.globalFlags.timeout,
 		verbose: params.globalFlags.verbose,
-		sessionOptions: sessionOptionsFromGlobalFlags(params.globalFlags)
+		sessionOptions: sessionOptionsFromGlobalFlags$1(params.globalFlags),
+		onModelWarning: params.globalFlags.jsonStrict ? void 0 : (message) => process.stderr.write(`[acpx] warning: ${message}\n`)
 	};
 }
 function resolveSessionListFilterCwd(flags, agentCwd) {
@@ -190,7 +507,7 @@ async function handlePrompt(explicitAgentName, promptParts, flags, command, conf
 	const globalFlags = resolveGlobalFlags(command, config);
 	const outputPolicy = resolveRequestedOutputPolicy(globalFlags);
 	const permissionMode = resolvePermissionMode(globalFlags, config.defaultPermissions);
-	const permissionPolicy = await resolvePermissionPolicyFromFlags(globalFlags);
+	const permissionPolicy = await resolvePermissionPolicyFromFlags$1(globalFlags);
 	const prompt = await readPrompt(promptParts, flags.file, globalFlags.cwd);
 	const agent = resolveAgentInvocation(explicitAgentName, globalFlags, config);
 	const [{ createOutputFormatter }, { printPromptSessionBanner, printQueuedPromptByFormat }, { sendSession }] = await Promise.all([
@@ -198,7 +515,7 @@ async function handlePrompt(explicitAgentName, promptParts, flags, command, conf
 		loadOutputRenderModule(),
 		loadSessionModule()
 	]);
-	const record = await findRoutedSessionOrThrow(agent.agentCommand, agent.agentName, agent.cwd, flags.session);
+	const record = await findRoutedSessionOrThrow(agent.agentCommand, agent.agentName, agent.cwd, resolveSessionNameFromFlags(flags, command));
 	const outputFormatter = createOutputFormatter(outputPolicy.format, {
 		jsonContext: { sessionId: record.acpxRecordId },
 		suppressReads: outputPolicy.suppressReads
@@ -254,7 +571,7 @@ async function handleExec(explicitAgentName, promptParts, flags, command, config
 	const globalFlags = resolveGlobalFlags(command, config);
 	const outputPolicy = resolveRequestedOutputPolicy(globalFlags);
 	const permissionMode = resolvePermissionMode(globalFlags, config.defaultPermissions);
-	const permissionPolicy = await resolvePermissionPolicyFromFlags(globalFlags);
+	const permissionPolicy = await resolvePermissionPolicyFromFlags$1(globalFlags);
 	const prompt = await readPrompt(promptParts, flags.file, globalFlags.cwd);
 	const [{ createOutputFormatter }, { runOnce }] = await Promise.all([loadOutputModule(), loadSessionModule()]);
 	const outputFormatter = createOutputFormatter(outputPolicy.format, { suppressReads: outputPolicy.suppressReads });
@@ -411,7 +728,7 @@ async function handleSetConfigOption(explicitAgentName, configId, value, flags,
 }
 async function tryListAgentSessions(agent, flags, globalFlags, config) {
 	const permissionMode = resolvePermissionMode(globalFlags, config.defaultPermissions);
-	const permissionPolicy = await resolvePermissionPolicyFromFlags(globalFlags);
+	const permissionPolicy = await resolvePermissionPolicyFromFlags$1(globalFlags);
 	const { listAgentSessions } = await loadSessionModule();
 	try {
 		return await listAgentSessions({
@@ -466,7 +783,7 @@ async function handleSessionsClose(explicitAgentName, sessionName, command, conf
 async function handleSessionsNew(explicitAgentName, flags, command, config) {
 	const globalFlags = resolveGlobalFlags(command, config);
 	const permissionMode = resolvePermissionMode(globalFlags, config.defaultPermissions);
-	const permissionPolicy = await resolvePermissionPolicyFromFlags(globalFlags);
+	const permissionPolicy = await resolvePermissionPolicyFromFlags$1(globalFlags);
 	const agent = resolveAgentInvocation(explicitAgentName, globalFlags, config);
 	const [{ createSession, closeSession }, { printCreatedSessionBanner, printNewSessionByFormat }] = await Promise.all([loadSessionModule(), loadOutputRenderModule()]);
 	const replaced = await findSession({
@@ -496,7 +813,7 @@ async function handleSessionsNew(explicitAgentName, flags, command, config) {
 async function handleSessionsEnsure(explicitAgentName, flags, command, config) {
 	const globalFlags = resolveGlobalFlags(command, config);
 	const permissionMode = resolvePermissionMode(globalFlags, config.defaultPermissions);
-	const permissionPolicy = await resolvePermissionPolicyFromFlags(globalFlags);
+	const permissionPolicy = await resolvePermissionPolicyFromFlags$1(globalFlags);
 	const agent = resolveAgentInvocation(explicitAgentName, globalFlags, config);
 	const [{ ensureSession }, { printCreatedSessionBanner, printEnsuredSessionByFormat }] = await Promise.all([loadSessionModule(), loadOutputRenderModule()]);
 	const result = await ensureSession(buildSessionStartOptions({
@@ -618,6 +935,46 @@ async function handleSessionsHistory(explicitAgentName, sessionName, flags, comm
 	const globalFlags = resolveGlobalFlags(command, config);
 	printSessionHistoryByFormat(await findScopedSessionOrThrow(resolveAgentInvocation(explicitAgentName, globalFlags, config), sessionName), flags.limit, globalFlags.format);
 }
+async function handleSessionsExport(explicitAgentName, sessionName, flags, command, config) {
+	const globalFlags = resolveGlobalFlags(command, config);
+	const agent = resolveAgentInvocation(explicitAgentName, globalFlags, config);
+	const cwd = flags.sourceCwd ? path.resolve(agent.cwd, flags.sourceCwd) : agent.cwd;
+	await exportSession({
+		agentName: globalFlags.agent ? void 0 : agent.agentName,
+		agentCommand: agent.agentCommand,
+		cwd,
+		name: sessionName
+	}, flags.output);
+	if (emitJsonResult(globalFlags.format, {
+		action: "session_exported",
+		output: flags.output
+	})) return;
+	if (globalFlags.format === "quiet") {
+		process.stdout.write(`${flags.output}\n`);
+		return;
+	}
+	process.stdout.write(`exported session to ${flags.output}\n`);
+}
+async function handleSessionsImport(explicitAgentName, archivePath, flags, command, config) {
+	const globalFlags = resolveGlobalFlags(command, config);
+	const agent = resolveAgentInvocation(explicitAgentName, globalFlags, config);
+	const result = await importSession(archivePath, {
+		name: flags.name,
+		newCwd: flags.destinationCwd ? path.resolve(globalFlags.cwd, flags.destinationCwd) : void 0,
+		expectedAgentName: globalFlags.agent ? void 0 : agent.agentName,
+		expectedAgentCommand: agent.agentCommand
+	});
+	if (emitJsonResult(globalFlags.format, {
+		action: "session_imported",
+		record_id: result.record_id,
+		cwd: result.cwd
+	})) return;
+	if (globalFlags.format === "quiet") {
+		process.stdout.write(`${result.record_id}\n`);
+		return;
+	}
+	process.stdout.write(`imported session ${result.record_id} at ${result.cwd}\n`);
+}
 async function handleSessionsPrune(explicitAgentName, flags, command, config) {
 	const globalFlags = resolveGlobalFlags(command, config);
 	const agent = resolveAgentInvocation(explicitAgentName, globalFlags, config);
@@ -632,6 +989,285 @@ async function handleSessionsPrune(explicitAgentName, flags, command, config) {
 	}), globalFlags.format);
 }
 //#endregion
+//#region src/cli/compare-command.ts
+const DEFAULT_COMPARE_TIMEOUT_MS = 3e5;
+const FINAL_MESSAGE_PREVIEW_CHARS = 200;
+var CaptureFormatter = class {
+	setContext(_context) {}
+	onAcpMessage(_message) {}
+	onError(params) {}
+	onPermissionEscalation(_event) {}
+	flush() {}
+};
+function asRecord$2(value) {
+	return Boolean(value) && typeof value === "object" && !Array.isArray(value) ? value : void 0;
+}
+function numberField(source, keys) {
+	if (!source) return null;
+	for (const key of keys) {
+		const value = source[key];
+		if (typeof value === "number" && Number.isFinite(value)) return value;
+	}
+	return null;
+}
+function collapseWhitespace(value) {
+	return value.replace(/\s+/g, " ").trim();
+}
+function truncate(value, maxChars) {
+	if (value.length <= maxChars) return value;
+	return `${value.slice(0, Math.max(0, maxChars - 3))}...`;
+}
+async function readStdin() {
+	let data = "";
+	for await (const chunk of process.stdin) data += String(chunk);
+	return data;
+}
+async function readPromptFile(filePath, promptText, cwd) {
+	const prompt = mergePromptSourceWithText(filePath === "-" ? await readStdin() : await fs$1.readFile(path.resolve(cwd, filePath), "utf8"), promptText);
+	if (prompt.length === 0) throw new InvalidArgumentError("Prompt from --file is empty");
+	return prompt;
+}
+async function readPromptFromStdin() {
+	if (process.stdin.isTTY) throw new InvalidArgumentError("Prompt is required (pass as final argument, --file, or pipe via stdin)");
+	const prompt = parsePromptSource(await readStdin());
+	if (prompt.length === 0) throw new InvalidArgumentError("Prompt from stdin is empty");
+	return prompt;
+}
+async function readPromptInput(filePath, promptText, cwd) {
+	try {
+		if (filePath) return await readPromptFile(filePath, promptText, cwd);
+		const joined = promptText.trim();
+		if (joined.length > 0) return textPrompt(joined);
+		return await readPromptFromStdin();
+	} catch (error) {
+		if (error instanceof PromptInputValidationError) throw new InvalidArgumentError(error.message);
+		throw error;
+	}
+}
+function promptTokensAfterDoubleDash(command) {
+	const commandName = command.name();
+	const commandIndex = process.argv.findIndex((token, index) => index >= 2 && token === commandName);
+	if (commandIndex < 0) return [];
+	const delimiterIndex = process.argv.findIndex((token, index) => index > commandIndex && token === "--");
+	return delimiterIndex < 0 ? [] : process.argv.slice(delimiterIndex + 1);
+}
+function splitCompareArgs(args, filePath, command) {
+	if (filePath) {
+		if (args.length === 0) throw new InvalidArgumentError("At least one agent is required");
+		return {
+			agents: args,
+			promptText: ""
+		};
+	}
+	const promptTokens = promptTokensAfterDoubleDash(command);
+	if (promptTokens.length > 0) {
+		const agents = args.slice(0, -promptTokens.length);
+		if (agents.length === 0) throw new InvalidArgumentError("At least one agent is required");
+		return {
+			agents,
+			promptText: promptTokens.join(" ")
+		};
+	}
+	if (args.length < 2) throw new InvalidArgumentError("Usage: acpx compare <agent>... '<prompt>'");
+	return {
+		agents: args.slice(0, -1),
+		promptText: args[args.length - 1] ?? ""
+	};
+}
+function captureUsage(update, capture) {
+	const source = asRecord$2(asRecord$2(update._meta)?.usage) ?? update;
+	capture.usage = {
+		input_tokens: numberField(source, ["input_tokens", "inputTokens"]) ?? void 0,
+		output_tokens: numberField(source, ["output_tokens", "outputTokens"]) ?? void 0,
+		total_tokens: numberField(source, [
+			"total_tokens",
+			"totalTokens",
+			"size",
+			"used"
+		]) ?? void 0
+	};
+}
+function captureSessionUpdate(notification, capture) {
+	const update = asRecord$2(notification.update);
+	if (!update) return;
+	if (update.sessionUpdate === "agent_message_chunk") {
+		const content = asRecord$2(update.content);
+		if (content?.type === "text" && typeof content.text === "string") capture.finalMessage += content.text;
+		return;
+	}
+	if (update.sessionUpdate === "usage_update") captureUsage(update, capture);
+}
+function rowStatusFromPermissionStats(stats) {
+	return stats.denied + stats.cancelled > 0 ? "permission_denied" : "ok";
+}
+function sessionOptionsFromGlobalFlags(globalFlags) {
+	return {
+		model: globalFlags.model,
+		allowedTools: globalFlags.allowedTools,
+		maxTurns: globalFlags.maxTurns,
+		systemPrompt: globalFlags.systemPrompt
+	};
+}
+async function resolvePermissionPolicyFromFlags(globalFlags) {
+	try {
+		return await loadPermissionPolicySpec(globalFlags.permissionPolicy, globalFlags.cwd);
+	} catch (error) {
+		throw new InvalidArgumentError(`Invalid permission policy: ${error instanceof Error ? error.message : String(error)}`);
+	}
+}
+function buildSuccessRow(agentName, result, capture, startedAt) {
+	const permissionStats = result.permissionStats;
+	return {
+		agent: agentName,
+		status: result.stopReason === "cancelled" ? "cancelled" : rowStatusFromPermissionStats(permissionStats),
+		stop_reason: result.stopReason,
+		wall_ms: Math.round(performance.now() - startedAt),
+		input_tokens: capture.usage.input_tokens ?? null,
+		output_tokens: capture.usage.output_tokens ?? null,
+		total_tokens: capture.usage.total_tokens ?? null,
+		final_message: truncate(collapseWhitespace(capture.finalMessage), FINAL_MESSAGE_PREVIEW_CHARS),
+		error: null,
+		permission_requests: permissionStats.requested,
+		permission_denied: permissionStats.denied + permissionStats.cancelled
+	};
+}
+function buildErrorRow(agentName, caught, capture, startedAt) {
+	return {
+		agent: agentName,
+		status: caught instanceof TimeoutError ? "cancelled" : "error",
+		stop_reason: null,
+		wall_ms: Math.round(performance.now() - startedAt),
+		input_tokens: capture.usage.input_tokens ?? null,
+		output_tokens: capture.usage.output_tokens ?? null,
+		total_tokens: capture.usage.total_tokens ?? null,
+		final_message: truncate(collapseWhitespace(capture.finalMessage), FINAL_MESSAGE_PREVIEW_CHARS),
+		error: truncate(collapseWhitespace(caught instanceof Error ? caught.message : String(caught)), FINAL_MESSAGE_PREVIEW_CHARS),
+		permission_requests: 0,
+		permission_denied: 0
+	};
+}
+async function runAgentForCompare(params) {
+	const capture = {
+		finalMessage: "",
+		usage: {},
+		errors: []
+	};
+	const formatter = new CaptureFormatter();
+	const t0 = performance.now();
+	try {
+		const agent = resolveAgentInvocation(params.agentName, params.globalFlags, params.config);
+		const result = await runOnce({
+			agentCommand: agent.agentCommand,
+			cwd: agent.cwd,
+			prompt: params.prompt,
+			mcpServers: params.config.mcpServers,
+			permissionMode: resolvePermissionMode(params.globalFlags, params.config.defaultPermissions),
+			nonInteractivePermissions: params.globalFlags.nonInteractivePermissions,
+			permissionPolicy: params.permissionPolicy,
+			authCredentials: params.config.auth,
+			authPolicy: params.globalFlags.authPolicy,
+			terminal: params.globalFlags.terminal,
+			outputFormatter: formatter,
+			suppressSdkConsoleErrors: true,
+			timeoutMs: params.globalFlags.timeout ?? DEFAULT_COMPARE_TIMEOUT_MS,
+			verbose: params.globalFlags.verbose,
+			promptRetries: params.globalFlags.promptRetries,
+			sessionOptions: sessionOptionsFromGlobalFlags(params.globalFlags),
+			onSessionUpdate: (notification) => captureSessionUpdate(notification, capture)
+		});
+		return buildSuccessRow(params.agentName, result, capture, t0);
+	} catch (caught) {
+		return buildErrorRow(params.agentName, caught, capture, t0);
+	}
+}
+function formatCell(value) {
+	if (value == null || value === "") return "-";
+	if (typeof value === "string") return collapseWhitespace(value);
+	if (typeof value === "number" || typeof value === "boolean") return String(value);
+	return collapseWhitespace(JSON.stringify(value));
+}
+function renderTable(rows) {
+	const headers = [
+		"agent",
+		"status",
+		"wall_ms",
+		"input",
+		"output",
+		"total",
+		"permissions",
+		"stop_reason",
+		"final_message",
+		"error"
+	];
+	const body = rows.map((row) => [
+		row.agent,
+		row.status,
+		row.wall_ms,
+		row.input_tokens,
+		row.output_tokens,
+		row.total_tokens,
+		`${row.permission_denied}/${row.permission_requests}`,
+		row.stop_reason,
+		row.final_message,
+		row.error
+	]);
+	const widths = headers.map((header, index) => Math.max(header.length, ...body.map((cells) => formatCell(cells[index]).length)));
+	const formatRow = (cells) => cells.map((cell, index) => truncate(formatCell(cell), widths[index] ?? 24).padEnd(widths[index] ?? 24)).join("  ").trimEnd();
+	return [
+		formatRow(headers),
+		widths.map((width) => "-".repeat(width)).join("  "),
+		...body.map(formatRow)
+	].join("\n");
+}
+function printRows(rows, format) {
+	if (format === "json") {
+		process.stdout.write(`${JSON.stringify(rows)}\n`);
+		return;
+	}
+	if (format === "quiet") {
+		for (const row of rows) process.stdout.write(`${row.agent}\t${row.status}\n`);
+		return;
+	}
+	process.stdout.write(`${renderTable(rows)}\n`);
+}
+function updateCompareExitCode(rows) {
+	if (rows.some((row) => row.status === "error")) {
+		process.exitCode = EXIT_CODES.ERROR;
+		return;
+	}
+	if (rows.some((row) => row.status === "permission_denied")) {
+		process.exitCode = EXIT_CODES.PERMISSION_DENIED;
+		return;
+	}
+	if (rows.some((row) => row.status === "cancelled")) process.exitCode = EXIT_CODES.TIMEOUT;
+}
+function resolvePromptFile(flags) {
+	if (flags.file && flags.promptFile && flags.file !== flags.promptFile) throw new InvalidArgumentError("Use only one prompt file flag: --file or --prompt-file");
+	return flags.file ?? flags.promptFile;
+}
+function registerCompareCommand(program, config) {
+	program.command("compare").description("Run one prompt across multiple agents and summarize the results").argument("<args...>", "Agents followed by prompt text, or agents with --file").option("--cwd <dir>", "Target workspace").option("--approve-all", "Auto-approve all permission requests").option("--approve-reads", "Auto-approve read/search requests and prompt for writes").option("--deny-all", "Deny all permission requests").option("--timeout <seconds>", "Per-agent timeout in seconds", parseTimeoutSeconds).option("--format <fmt>", "Output format: text, json, quiet", parseOutputFormat$1).option("--json", "Alias for --format json").option("-f, --file <path>", "Read prompt text from file path (use - for stdin)", (value) => parseNonEmptyValue("Prompt file", value)).option("--prompt-file <path>", "Alias for --file", (value) => parseNonEmptyValue("Prompt file", value)).action(async function(args, flags) {
+		if (config.disableExec) throw new Error("compare subcommand is disabled by configuration (disableExec: true)");
+		const globalFlags = resolveGlobalFlags(this, config);
+		if (globalFlags.agent) throw new InvalidArgumentError("Do not combine compare with --agent; pass agent names");
+		const outputPolicy = resolveOutputPolicy(flags.json === true ? "json" : globalFlags.format, globalFlags.jsonStrict === true);
+		const promptFile = resolvePromptFile(flags);
+		const { agents, promptText } = splitCompareArgs(args, promptFile, this);
+		const prompt = await readPromptInput(promptFile, promptText, globalFlags.cwd);
+		const permissionPolicy = await resolvePermissionPolicyFromFlags(globalFlags);
+		const rows = [];
+		for (const agentName of agents) rows.push(await runAgentForCompare({
+			agentName,
+			prompt,
+			config,
+			globalFlags,
+			permissionPolicy
+		}));
+		printRows(rows, outputPolicy.format);
+		updateCompareExitCode(rows);
+	});
+}
+//#endregion
 //#region src/mcp-servers.ts
 function asRecord$1(value) {
 	if (!value || typeof value !== "object" || Array.isArray(value)) return;
@@ -735,7 +1371,6 @@ function parseOptionalMcpServers(value, sourcePath, fieldName = "mcpServers") {
 }
 //#endregion
 //#region src/cli/config.ts
-const DEFAULT_TIMEOUT_MS = void 0;
 const DEFAULT_TTL_MS = 3e5;
 const DEFAULT_PERMISSION_MODE = "approve-reads";
 const DEFAULT_NON_INTERACTIVE_PERMISSION_POLICY = "deny";
@@ -802,7 +1437,7 @@ function parseOutputFormat(value, sourcePath) {
 function parseDefaultAgent(value, sourcePath) {
 	if (value == null) return;
 	if (typeof value !== "string" || value.trim().length === 0) throw new Error(`Invalid config defaultAgent in ${sourcePath}: expected non-empty string`);
-	return normalizeAgentName(value);
+	return normalizeAgentName$1(value);
 }
 function parseAgents(value, sourcePath) {
 	if (value == null) return;
@@ -813,7 +1448,7 @@ function parseAgents(value, sourcePath) {
 		const command = raw.command;
 		if (typeof command !== "string" || command.trim().length === 0) throw new Error(`Invalid config agents.${name}.command in ${sourcePath}: expected non-empty string`);
 		const args = parseAgentArgs(raw.args, name, sourcePath);
-		parsed[normalizeAgentName(name)] = args.length > 0 ? `${command.trim()} ${args.map(quoteCommandArg).join(" ")}` : command.trim();
+		parsed[normalizeAgentName$1(name)] = args.length > 0 ? `${command.trim()} ${args.map(quoteCommandArg).join(" ")}` : command.trim();
 	}
 	return parsed;
 }
@@ -937,7 +1572,6 @@ function hasConfigKey(config, key) {
 function resolveTimeoutMs(projectConfig, projectPath, globalConfig, globalPath) {
 	if (hasConfigKey(projectConfig, "timeout")) return parseTimeoutMs(projectConfig?.timeout, projectPath);
 	if (hasConfigKey(globalConfig, "timeout")) return parseTimeoutMs(globalConfig?.timeout, globalPath);
-	return DEFAULT_TIMEOUT_MS;
 }
 function resolveMcpServers(projectConfig, projectPath, globalConfig, globalPath) {
 	if (hasConfigKey(projectConfig, "mcpServers")) return parseMcpServers(projectConfig?.mcpServers, projectPath);
@@ -1409,6 +2043,16 @@ function registerStatusCommand(parent, explicitAgentName, config, description) {
 }
 //#endregion
 //#region src/cli/command-registration.ts
+var LocalAttributeOption = class extends Option {
+	localAttributeName;
+	constructor(flags, description, localAttributeName) {
+		super(flags, description);
+		this.localAttributeName = localAttributeName;
+	}
+	attributeName() {
+		return this.localAttributeName;
+	}
+};
 function addSessionsListOptions(command) {
 	return command.option("--local", "List local acpx session records instead of agent protocol sessions").option("--cursor <cursor>", "Opaque ACP session/list cursor", (value) => parseNonEmptyValue("Cursor", value)).option("--filter-cwd <dir>", "Filter agent sessions by working directory", (value) => parseNonEmptyValue("Filter cwd", value));
 }
@@ -1439,6 +2083,12 @@ function registerSessionsCommand(parent, explicitAgentName, config) {
 	sessionsCommand.command("read").description("Read full session history").argument("[name]", "Session name", parseSessionName).option("--tail <count>", "Show only the last N entries instead of all history", parseHistoryLimit).action(async function(name, flags) {
 		await handleSessionsHistory(explicitAgentName, name, { limit: flags.tail ?? 0 }, this, config);
 	});
+	sessionsCommand.command("export").description("Export a portable session archive").argument("[name]", "Session name", parseSessionName).requiredOption("--output <path>", "Output archive path", (value) => parseNonEmptyValue("Output path", value)).addOption(new LocalAttributeOption("--cwd <cwd>", "Session cwd to export", "sourceCwd").argParser((value) => parseNonEmptyValue("Session cwd", value))).action(async function(name, flags) {
+		await handleSessionsExport(explicitAgentName, name, flags, this, config);
+	});
+	sessionsCommand.command("import").description("Import a portable session archive").argument("<archive-path>", "Archive path", (value) => parseNonEmptyValue("Archive path", value)).option("--name <name>", "Imported session name", parseSessionName).addOption(new LocalAttributeOption("--cwd <cwd>", "Imported session cwd", "destinationCwd").argParser((value) => parseNonEmptyValue("Imported session cwd", value))).action(async function(archivePath, flags) {
+		await handleSessionsImport(explicitAgentName, archivePath, flags, this, config);
+	});
 	sessionsCommand.command("prune").description("Delete closed sessions and free disk space").option("--dry-run", "Preview what would be pruned without deleting anything").option("--before <date>", "Prune sessions closed before this date", parsePruneBeforeDate).option("--older-than <days>", "Prune sessions closed more than N days ago", parseDaysOlderThan).option("--include-history", "Also delete event stream files (.stream.ndjson)").action(async function(flags) {
 		await handleSessionsPrune(explicitAgentName, flags, this, config);
 	});
@@ -1491,7 +2141,7 @@ function registerAgentCommand(program, agentName, config) {
 }
 function registerFlowCommand(program, config) {
 	program.command("flow").description("Run multi-step ACP workflows from flow files").command("run").description("Run a flow file").argument("<file>", "Flow module path").option("--input-json <json>", "Flow input as JSON").option("--input-file <path>", "Read flow input JSON from file").option("--default-agent <name>", "Default agent profile for ACP nodes without profile", (value) => parseNonEmptyValue("Default agent", value)).action(async function(file, flags) {
-		const { handleFlowRun } = await import("./cli-Bf3yjqzE.js");
+		const { handleFlowRun } = await import("./cli-CC2w0U-A.js");
 		await handleFlowRun(file, flags, this, config);
 	});
 }
@@ -1506,6 +2156,7 @@ function registerDefaultCommands(program, config) {
 	});
 	registerSessionsCommand(program, void 0, config);
 	registerConfigCommand(program, config);
+	registerCompareCommand(program, config);
 	registerFlowCommand(program, config);
 }
 //#endregion
@@ -1587,54 +2238,12 @@ async function runQueueOwnerFromEnv(env) {
 	await runSessionQueueOwner(parseQueueOwnerPayload(payload));
 }
 //#endregion
-//#region src/version.ts
-const UNKNOWN_VERSION = "0.0.0-unknown";
-const MODULE_DIR = path.dirname(fileURLToPath(import.meta.url));
-let cachedVersion = null;
-function parseVersion(value) {
-	if (typeof value !== "string") return null;
-	const trimmed = value.trim();
-	return trimmed.length > 0 ? trimmed : null;
-}
-function readPackageVersion(packageJsonPath) {
-	try {
-		return parseVersion(JSON.parse(readFileSync(packageJsonPath, "utf8")).version);
-	} catch {
-		return null;
-	}
-}
-function resolveVersionFromAncestors(startDir) {
-	let current = startDir;
-	while (true) {
-		const packageVersion = readPackageVersion(path.join(current, "package.json"));
-		if (packageVersion) return packageVersion;
-		const parent = path.dirname(current);
-		if (parent === current) return null;
-		current = parent;
-	}
-}
-function resolveAcpxVersion(params) {
-	const envVersion = resolvePackageEnvVersion(params?.env ?? process.env);
-	if (envVersion) return envVersion;
-	if (params?.packageJsonPath) return readPackageVersion(params.packageJsonPath) ?? UNKNOWN_VERSION;
-	return resolveVersionFromAncestors(MODULE_DIR) ?? UNKNOWN_VERSION;
-}
-function resolvePackageEnvVersion(env) {
-	const envPackageName = parseVersion(env.npm_package_name);
-	const envVersion = parseVersion(env.npm_package_version);
-	return envPackageName === "acpx" ? envVersion : null;
-}
-function getAcpxVersion() {
-	if (cachedVersion) return cachedVersion;
-	cachedVersion = resolveAcpxVersion();
-	return cachedVersion;
-}
-//#endregion
 //#region src/cli-core.ts
 const TOP_LEVEL_VERBS = new Set([
 	"prompt",
 	"exec",
 	"cancel",
+	"compare",
 	"flow",
 	"set-mode",
 	"set",
@@ -1872,13 +2481,18 @@ async function handleProgramParseError(error, requestedOutputPolicy) {
 	process.exit(exitCodeForOutputErrorCode(normalized.code));
 }
 async function main(argv = process.argv) {
-	const rawArgs = argv.slice(2);
+	const rawArgs = normalizeLifecycleScriptArgs(argv.slice(2));
+	const normalizedArgv = [
+		argv[0] ?? "node",
+		argv[1] ?? "acpx",
+		...rawArgs
+	];
 	if (await handleQueueOwnerCommand(argv)) return;
 	if (isTopLevelVersionRequest(rawArgs)) {
 		process.stdout.write(`${getAcpxVersion()}\n`);
 		return;
 	}
-	await maybeHandleSkillflag(argv);
+	await maybeHandleSkillflag(normalizedArgv);
 	const config = await loadResolvedConfig(detectInitialCwd(rawArgs));
 	const requestedJsonStrict = detectJsonStrict(rawArgs);
 	const requestedOutputPolicy = {
@@ -1907,7 +2521,7 @@ async function main(argv = process.argv) {
 	try {
 		await runWithOutputPolicy(requestedOutputPolicy, async () => {
 			try {
-				await program.parseAsync(argv);
+				await program.parseAsync(normalizedArgv);
 			} catch (error) {
 				await handleProgramParseError(error, requestedOutputPolicy);
 			}
@@ -1916,6 +2530,10 @@ async function main(argv = process.argv) {
 		flushPerfMetricsCapture();
 	}
 }
+function normalizeLifecycleScriptArgs(rawArgs) {
+	if (rawArgs[0] === "--" && (process.env.npm_lifecycle_event || process.env.npm_lifecycle_script)) return rawArgs.slice(1);
+	return rawArgs;
+}
 //#endregion
 //#region src/cli.ts
 function installBrokenPipeHandler(stream) {