@pixelzx/genesis 2026.7.8 → 2026.7.9

package/dist/register.subclis-BC8Xib58.js

@@ -0,0 +1,29 @@
+import { t as resolveCliArgvInvocation } from "./argv-invocation-DXsyrCs-.js";
+import { r as shouldRegisterPrimarySubcommandOnly, t as shouldEagerRegisterSubcommands } from "./command-registration-policy-B1cWNvAz.js";
+import { i as buildCommandGroupEntries, n as registerSubCliByName$1, o as defineImportedProgramCommandGroupSpecs, r as registerSubCliCommands$1 } from "./register.subclis-core-BQwVVxk1.js";
+import { i as registerCommandGroups, r as registerCommandGroupByName } from "./register-command-groups-BjShh-Db.js";
+import { n as getSubCliEntries } from "./subcli-descriptors-C4PhWAwd.js";
+//#region src/cli/program/register.subclis.ts
+const entrySpecs = [...defineImportedProgramCommandGroupSpecs([{
+	commandNames: ["completion"],
+	loadModule: () => import("./completion-cli-CD7DN6ny.js"),
+	exportName: "registerCompletionCli"
+}])];
+function resolveSubCliCommandGroups() {
+	return buildCommandGroupEntries(getSubCliEntries(), entrySpecs, (register) => register);
+}
+async function registerSubCliByName(program, name, options) {
+	if (await registerSubCliByName$1(program, name, options)) return true;
+	return registerCommandGroupByName(program, resolveSubCliCommandGroups(), name);
+}
+function registerSubCliCommands(program, argv = process.argv) {
+	registerSubCliCommands$1(program, argv);
+	const { primary } = resolveCliArgvInvocation(argv);
+	registerCommandGroups(program, resolveSubCliCommandGroups(), {
+		eager: shouldEagerRegisterSubcommands(),
+		primary,
+		registerPrimaryOnly: Boolean(primary && shouldRegisterPrimarySubcommandOnly(argv))
+	});
+}
+//#endregion
+export { registerSubCliCommands as n, registerSubCliByName as t };

package/dist/register.subclis-DMX7WW9_.js

@@ -0,0 +1,3 @@
+import "./subcli-descriptors-C4PhWAwd.js";
+import { t as registerSubCliByName } from "./register.subclis-BC8Xib58.js";
+export { registerSubCliByName };

package/dist/register.subclis-core-BQwVVxk1.js

@@ -0,0 +1,249 @@
+import { t as resolveCliArgvInvocation } from "./argv-invocation-DXsyrCs-.js";
+import { r as shouldRegisterPrimarySubcommandOnly, t as shouldEagerRegisterSubcommands } from "./command-registration-policy-B1cWNvAz.js";
+import { i as registerCommandGroups, r as registerCommandGroupByName } from "./register-command-groups-BjShh-Db.js";
+import { n as getSubCliEntries$1, r as loadPrivateQaCliModule } from "./subcli-descriptors-C4PhWAwd.js";
+//#region src/cli/program/command-group-descriptors.ts
+function buildDescriptorIndex(descriptors) {
+	return new Map(descriptors.map((descriptor) => [descriptor.name, descriptor]));
+}
+function resolveCommandGroupEntries(descriptors, specs) {
+	const descriptorsByName = buildDescriptorIndex(descriptors);
+	return specs.map((spec) => ({
+		placeholders: spec.commandNames.map((name) => {
+			const descriptor = descriptorsByName.get(name);
+			if (!descriptor) throw new Error(`Unknown command descriptor: ${name}`);
+			return descriptor;
+		}),
+		register: spec.register
+	}));
+}
+function buildCommandGroupEntries(descriptors, specs, mapRegister) {
+	return resolveCommandGroupEntries(descriptors, specs).map((entry) => ({
+		placeholders: entry.placeholders,
+		register: mapRegister(entry.register)
+	}));
+}
+function defineImportedCommandGroupSpec(commandNames, loadModule, register) {
+	return {
+		commandNames,
+		register: async (args) => {
+			await register(await loadModule(), args);
+		}
+	};
+}
+function defineImportedProgramCommandGroupSpecs(definitions) {
+	return definitions.map((definition) => ({
+		commandNames: definition.commandNames,
+		register: async (program) => {
+			const register = (await definition.loadModule())[definition.exportName];
+			if (typeof register !== "function") throw new Error(`Missing program command registrar: ${definition.exportName}`);
+			await register(program);
+		}
+	}));
+}
+//#endregion
+//#region src/cli/program/register.subclis-core.ts
+async function registerSubCliWithPluginCommands(program, registerSubCli, pluginCliPosition, options) {
+	if (options.registerPluginCliCommands === false) {
+		await registerSubCli();
+		return;
+	}
+	const { registerPluginCliCommandsFromValidatedConfig } = await import("./cli-DRZG-g_Y.js");
+	if (pluginCliPosition === "before") await registerPluginCliCommandsFromValidatedConfig(program);
+	await registerSubCli();
+	if (pluginCliPosition === "after") await registerPluginCliCommandsFromValidatedConfig(program);
+}
+function buildEntrySpecs(options = {}) {
+	return [
+		...defineImportedProgramCommandGroupSpecs([
+			{
+				commandNames: ["acp"],
+				loadModule: () => import("./acp-cli-DR-AhXGk.js"),
+				exportName: "registerAcpCli"
+			},
+			{
+				commandNames: ["gateway"],
+				loadModule: () => import("./gateway-cli-CqpPxleQ.js"),
+				exportName: "registerGatewayCli"
+			},
+			{
+				commandNames: ["daemon"],
+				loadModule: () => import("./cli/daemon-cli.js"),
+				exportName: "registerDaemonCli"
+			},
+			{
+				commandNames: ["logs"],
+				loadModule: () => import("./logs-cli-D9A-A-9o.js"),
+				exportName: "registerLogsCli"
+			},
+			{
+				commandNames: ["system"],
+				loadModule: () => import("./system-cli-BXWEki_N.js"),
+				exportName: "registerSystemCli"
+			},
+			{
+				commandNames: ["models"],
+				loadModule: () => import("./models-cli-A3K5ngLW.js"),
+				exportName: "registerModelsCli"
+			},
+			{
+				commandNames: ["infer", "capability"],
+				loadModule: () => import("./capability-cli-n36Okw1e.js"),
+				exportName: "registerCapabilityCli"
+			},
+			{
+				commandNames: ["approvals"],
+				loadModule: () => import("./exec-approvals-cli-BMIvTLCd.js"),
+				exportName: "registerExecApprovalsCli"
+			},
+			{
+				commandNames: ["exec-policy"],
+				loadModule: () => import("./exec-policy-cli-DdKd7sII.js"),
+				exportName: "registerExecPolicyCli"
+			},
+			{
+				commandNames: ["nodes"],
+				loadModule: () => import("./nodes-cli-CQMWvWMg.js"),
+				exportName: "registerNodesCli"
+			},
+			{
+				commandNames: ["devices"],
+				loadModule: () => import("./devices-cli-DvMb9Y1g.js"),
+				exportName: "registerDevicesCli"
+			},
+			{
+				commandNames: ["node"],
+				loadModule: () => import("./node-cli-0u8AZQyg.js"),
+				exportName: "registerNodeCli"
+			},
+			{
+				commandNames: ["sandbox"],
+				loadModule: () => import("./sandbox-cli-C75oWfKU.js"),
+				exportName: "registerSandboxCli"
+			},
+			{
+				commandNames: [
+					"tui",
+					"terminal",
+					"chat"
+				],
+				loadModule: () => import("./tui-cli-5Sm6YmJ7.js"),
+				exportName: "registerTuiCli"
+			},
+			{
+				commandNames: ["cron"],
+				loadModule: () => import("./cron-cli-BvlxWG-0.js"),
+				exportName: "registerCronCli"
+			},
+			{
+				commandNames: ["dns"],
+				loadModule: () => import("./dns-cli-CP53zPKc.js"),
+				exportName: "registerDnsCli"
+			},
+			{
+				commandNames: ["docs"],
+				loadModule: () => import("./docs-cli-AJTdcSx0.js"),
+				exportName: "registerDocsCli"
+			},
+			{
+				commandNames: ["qa"],
+				loadModule: loadPrivateQaCliModule,
+				exportName: "registerQaLabCli"
+			},
+			{
+				commandNames: ["proxy"],
+				loadModule: () => import("./proxy-cli-Djw7wG9T.js"),
+				exportName: "registerProxyCli"
+			},
+			{
+				commandNames: ["hooks"],
+				loadModule: () => import("./hooks-cli-qlVfZ69O.js"),
+				exportName: "registerHooksCli"
+			},
+			{
+				commandNames: ["webhooks"],
+				loadModule: () => import("./webhooks-cli-4dCVavvu.js"),
+				exportName: "registerWebhooksCli"
+			},
+			{
+				commandNames: ["qr"],
+				loadModule: () => import("./qr-cli-XFbmt6Yy.js"),
+				exportName: "registerQrCli"
+			},
+			{
+				commandNames: ["clawbot"],
+				loadModule: () => import("./clawbot-cli-jsnS_FnN.js"),
+				exportName: "registerClawbotCli"
+			}
+		]),
+		{
+			commandNames: ["pairing"],
+			register: async (program) => {
+				await registerSubCliWithPluginCommands(program, async () => {
+					(await import("./pairing-cli-DrLS6V0X.js")).registerPairingCli(program);
+				}, "before", options);
+			}
+		},
+		{
+			commandNames: ["plugins"],
+			register: async (program) => {
+				await registerSubCliWithPluginCommands(program, async () => {
+					(await import("./plugins-cli-CUZMkYFB.js")).registerPluginsCli(program);
+				}, "after", options);
+			}
+		},
+		...defineImportedProgramCommandGroupSpecs([
+			{
+				commandNames: ["channels"],
+				loadModule: () => import("./channels-cli-Ch81ruvl.js"),
+				exportName: "registerChannelsCli"
+			},
+			{
+				commandNames: ["directory"],
+				loadModule: () => import("./directory-cli-CinbUxv4.js"),
+				exportName: "registerDirectoryCli"
+			},
+			{
+				commandNames: ["security"],
+				loadModule: () => import("./security-cli-ho4WnkD2.js"),
+				exportName: "registerSecurityCli"
+			},
+			{
+				commandNames: ["secrets"],
+				loadModule: () => import("./secrets-cli-ea7rK5BG.js"),
+				exportName: "registerSecretsCli"
+			},
+			{
+				commandNames: ["skills"],
+				loadModule: () => import("./skills-cli-sEQh3VlM.js"),
+				exportName: "registerSkillsCli"
+			},
+			{
+				commandNames: ["update"],
+				loadModule: () => import("./update-cli-BcUEQuiM.js"),
+				exportName: "registerUpdateCli"
+			}
+		])
+	];
+}
+function resolveSubCliCommandGroups(options) {
+	const descriptors = getSubCliEntries$1();
+	const descriptorNames = new Set(descriptors.map((descriptor) => descriptor.name));
+	return buildCommandGroupEntries(descriptors, buildEntrySpecs(options).filter((spec) => spec.commandNames.every((name) => descriptorNames.has(name))), (register) => register);
+}
+function getSubCliEntries() {
+	return getSubCliEntries$1();
+}
+async function registerSubCliByName(program, name, options) {
+	return registerCommandGroupByName(program, resolveSubCliCommandGroups(options), name);
+}
+function registerSubCliCommands(program, argv = process.argv) {
+	const { primary } = resolveCliArgvInvocation(argv);
+	registerCommandGroups(program, resolveSubCliCommandGroups(), {
+		eager: shouldEagerRegisterSubcommands(),
+		primary,
+		registerPrimaryOnly: Boolean(primary && shouldRegisterPrimarySubcommandOnly(argv))
+	});
+}
+//#endregion
+export { defineImportedCommandGroupSpec as a, buildCommandGroupEntries as i, registerSubCliByName as n, defineImportedProgramCommandGroupSpecs as o, registerSubCliCommands as r, getSubCliEntries as t };

package/dist/reply-dispatch-runtime-B8XDaURF.js

@@ -0,0 +1,13 @@
+import "./chunk-DNCIrobv.js";
+import "./conversation-label-generator-ySfrzBse.js";
+//#region src/plugin-sdk/reply-dispatch-runtime.ts
+const dispatchReplyWithBufferedBlockDispatcher = async (params) => {
+	const { dispatchReplyWithBufferedBlockDispatcher: dispatch } = await import("./provider-dispatcher-B9Bi64PF.js");
+	return await dispatch(params);
+};
+const dispatchReplyWithDispatcher = async (params) => {
+	const { dispatchReplyWithDispatcher: dispatch } = await import("./provider-dispatcher-B9Bi64PF.js");
+	return await dispatch(params);
+};
+//#endregion
+export { dispatchReplyWithDispatcher as n, dispatchReplyWithBufferedBlockDispatcher as t };

package/dist/reply-runtime-NyMLCW3E.js

@@ -0,0 +1,10 @@
+import "./tokens-DUMwK-9w.js";
+import "./chunk-DNCIrobv.js";
+import "./dispatch-MnxNMsTX.js";
+import "./inbound-dedupe-DaDhrn0h.js";
+import "./provider-dispatcher-W0BQ6JBa.js";
+import "./get-reply-tZVDzC6p.js";
+import "./abort-Cp36iDXn.js";
+import "./btw-command-C-2D5eT4.js";
+import "./conversation-label-generator-ySfrzBse.js";
+export {};

package/dist/reply.runtime-edT3K6N7.js

@@ -0,0 +1,2 @@
+import { t as getReplyFromConfig } from "./get-reply-tZVDzC6p.js";
+export { getReplyFromConfig };

package/dist/reply.runtime.js

@@ -1 +1 @@
-export * from "./reply.runtime-FitoWYiX.js";
+export * from "./reply.runtime-edT3K6N7.js";

package/dist/restart-health-1UMkTis9.js

@@ -0,0 +1,202 @@
+import { a as normalizeLowercaseStringOrEmpty, c as normalizeOptionalString } from "./string-coerce-DPP_aYVc.js";
+import { v as sleep } from "./utils-CWrkFsp0.js";
+import { a as inspectPortUsage, o as classifyPortListener, s as formatPortDiagnostics } from "./ports-C52nWpb8.js";
+import { t as killProcessTree } from "./kill-tree-BbGiB2xY.js";
+import { a as probeGateway } from "./probe-DDW3LKLY.js";
+//#region src/cli/daemon-cli/restart-health.ts
+const DEFAULT_RESTART_HEALTH_TIMEOUT_MS = 6e4;
+const DEFAULT_RESTART_HEALTH_DELAY_MS = 500;
+const DEFAULT_RESTART_HEALTH_ATTEMPTS = Math.ceil(DEFAULT_RESTART_HEALTH_TIMEOUT_MS / 500);
+const STOPPED_FREE_EARLY_EXIT_GRACE_MS = 1e4;
+const WINDOWS_STOPPED_FREE_EARLY_EXIT_GRACE_MS = 9e4;
+function hasListenerAttributionGap(portUsage) {
+	if (portUsage.status !== "busy" || portUsage.listeners.length > 0) return false;
+	if (portUsage.errors?.length) return true;
+	return portUsage.hints.some((hint) => hint.includes("process details are unavailable"));
+}
+function listenerOwnedByRuntimePid(params) {
+	return params.listener.pid === params.runtimePid || params.listener.ppid === params.runtimePid;
+}
+function looksLikeAuthClose(code, reason) {
+	if (code !== 1008) return false;
+	const normalized = normalizeLowercaseStringOrEmpty(reason);
+	return normalized.includes("auth") || normalized.includes("token") || normalized.includes("password") || normalized.includes("scope") || normalized.includes("role");
+}
+async function confirmGatewayReachable(port) {
+	const token = normalizeOptionalString(process.env.GENESIS_GATEWAY_TOKEN);
+	const password = normalizeOptionalString(process.env.GENESIS_GATEWAY_PASSWORD);
+	const probe = await probeGateway({
+		url: `ws://127.0.0.1:${port}`,
+		auth: token || password ? {
+			token,
+			password
+		} : void 0,
+		timeoutMs: 3e3,
+		includeDetails: false
+	});
+	return probe.ok || looksLikeAuthClose(probe.close?.code, probe.close?.reason);
+}
+async function inspectGatewayPortHealth(port) {
+	let portUsage;
+	try {
+		portUsage = await inspectPortUsage(port);
+	} catch (err) {
+		portUsage = {
+			port,
+			status: "unknown",
+			listeners: [],
+			hints: [],
+			errors: [String(err)]
+		};
+	}
+	let healthy = false;
+	if (portUsage.status === "busy") try {
+		healthy = await confirmGatewayReachable(port);
+	} catch {}
+	return {
+		portUsage,
+		healthy
+	};
+}
+async function inspectGatewayRestart(params) {
+	const env = params.env ?? process.env;
+	let runtime = { status: "unknown" };
+	try {
+		runtime = await params.service.readRuntime(env);
+	} catch (err) {
+		runtime = {
+			status: "unknown",
+			detail: String(err)
+		};
+	}
+	let portUsage;
+	try {
+		portUsage = await inspectPortUsage(params.port);
+	} catch (err) {
+		portUsage = {
+			port: params.port,
+			status: "unknown",
+			listeners: [],
+			hints: [],
+			errors: [String(err)]
+		};
+	}
+	if (portUsage.status === "busy" && runtime.status !== "running") try {
+		if (await confirmGatewayReachable(params.port)) return {
+			runtime,
+			portUsage,
+			healthy: true,
+			staleGatewayPids: []
+		};
+	} catch {}
+	const gatewayListeners = portUsage.status === "busy" ? portUsage.listeners.filter((listener) => classifyPortListener(listener, params.port) === "gateway") : [];
+	const fallbackListenerPids = params.includeUnknownListenersAsStale && process.platform === "win32" && runtime.status !== "running" && portUsage.status === "busy" ? portUsage.listeners.filter((listener) => classifyPortListener(listener, params.port) === "unknown").map((listener) => listener.pid).filter((pid) => Number.isFinite(pid)) : [];
+	const running = runtime.status === "running";
+	const runtimePid = runtime.pid;
+	const listenerAttributionGap = hasListenerAttributionGap(portUsage);
+	const ownsPort = runtimePid != null ? portUsage.listeners.some((listener) => listenerOwnedByRuntimePid({
+		listener,
+		runtimePid
+	})) || listenerAttributionGap : gatewayListeners.length > 0 || listenerAttributionGap;
+	let healthy = running && ownsPort;
+	if (!healthy && running && portUsage.status === "busy") try {
+		healthy = await confirmGatewayReachable(params.port);
+	} catch {}
+	const staleGatewayPids = Array.from(new Set([...gatewayListeners.filter((listener) => Number.isFinite(listener.pid)).filter((listener) => {
+		if (!running) return true;
+		if (runtimePid == null) return false;
+		return !listenerOwnedByRuntimePid({
+			listener,
+			runtimePid
+		});
+	}).map((listener) => listener.pid), ...fallbackListenerPids.filter((pid) => runtime.pid == null || pid !== runtime.pid || !running)]));
+	return {
+		runtime,
+		portUsage,
+		healthy,
+		staleGatewayPids
+	};
+}
+function shouldEarlyExitStoppedFree(snapshot, attempt, minAttempt) {
+	return attempt >= minAttempt && snapshot.runtime.status === "stopped" && snapshot.portUsage.status === "free";
+}
+function stoppedFreeEarlyExitGraceMs() {
+	return process.platform === "win32" ? WINDOWS_STOPPED_FREE_EARLY_EXIT_GRACE_MS : STOPPED_FREE_EARLY_EXIT_GRACE_MS;
+}
+function withWaitContext(snapshot, waitOutcome, elapsedMs) {
+	return {
+		...snapshot,
+		waitOutcome,
+		elapsedMs
+	};
+}
+async function waitForGatewayHealthyRestart(params) {
+	const attempts = params.attempts ?? DEFAULT_RESTART_HEALTH_ATTEMPTS;
+	const delayMs = params.delayMs ?? 500;
+	let snapshot = await inspectGatewayRestart({
+		service: params.service,
+		port: params.port,
+		env: params.env,
+		includeUnknownListenersAsStale: params.includeUnknownListenersAsStale
+	});
+	let consecutiveStoppedFreeCount = 0;
+	const STOPPED_FREE_THRESHOLD = 6;
+	const minAttemptForEarlyExit = Math.min(Math.ceil(stoppedFreeEarlyExitGraceMs() / delayMs), Math.floor(attempts / 2));
+	for (let attempt = 0; attempt < attempts; attempt += 1) {
+		if (snapshot.healthy) return withWaitContext(snapshot, "healthy", attempt * delayMs);
+		if (snapshot.staleGatewayPids.length > 0 && snapshot.runtime.status !== "running") return withWaitContext(snapshot, "stale-pids", attempt * delayMs);
+		if (shouldEarlyExitStoppedFree(snapshot, attempt, minAttemptForEarlyExit)) {
+			consecutiveStoppedFreeCount += 1;
+			if (consecutiveStoppedFreeCount >= STOPPED_FREE_THRESHOLD) return withWaitContext(snapshot, "stopped-free", attempt * delayMs);
+		} else if (snapshot.runtime.status !== "stopped" || snapshot.portUsage.status !== "free") consecutiveStoppedFreeCount = 0;
+		await sleep(delayMs);
+		snapshot = await inspectGatewayRestart({
+			service: params.service,
+			port: params.port,
+			env: params.env,
+			includeUnknownListenersAsStale: params.includeUnknownListenersAsStale
+		});
+	}
+	return withWaitContext(snapshot, "timeout", attempts * delayMs);
+}
+async function waitForGatewayHealthyListener(params) {
+	const attempts = params.attempts ?? DEFAULT_RESTART_HEALTH_ATTEMPTS;
+	const delayMs = params.delayMs ?? 500;
+	let snapshot = await inspectGatewayPortHealth(params.port);
+	for (let attempt = 0; attempt < attempts; attempt += 1) {
+		if (snapshot.healthy) return snapshot;
+		await sleep(delayMs);
+		snapshot = await inspectGatewayPortHealth(params.port);
+	}
+	return snapshot;
+}
+function renderPortUsageDiagnostics(snapshot) {
+	const lines = [];
+	if (snapshot.portUsage.status === "busy") lines.push(...formatPortDiagnostics(snapshot.portUsage));
+	else lines.push(`Gateway port ${snapshot.portUsage.port} status: ${snapshot.portUsage.status}.`);
+	if (snapshot.portUsage.errors?.length) lines.push(`Port diagnostics errors: ${snapshot.portUsage.errors.join("; ")}`);
+	return lines;
+}
+function renderRestartDiagnostics(snapshot) {
+	const lines = [];
+	const runtimeSummary = [
+		snapshot.runtime.status ? `status=${snapshot.runtime.status}` : null,
+		snapshot.runtime.state ? `state=${snapshot.runtime.state}` : null,
+		snapshot.runtime.pid != null ? `pid=${snapshot.runtime.pid}` : null,
+		snapshot.runtime.lastExitStatus != null ? `lastExit=${snapshot.runtime.lastExitStatus}` : null
+	].filter(Boolean).join(", ");
+	if (runtimeSummary) lines.push(`Service runtime: ${runtimeSummary}`);
+	lines.push(...renderPortUsageDiagnostics(snapshot));
+	return lines;
+}
+function renderGatewayPortHealthDiagnostics(snapshot) {
+	return renderPortUsageDiagnostics(snapshot);
+}
+async function terminateStaleGatewayPids(pids) {
+	const targets = Array.from(new Set(pids.filter((pid) => Number.isFinite(pid) && pid > 0)));
+	for (const pid of targets) killProcessTree(pid, { graceMs: 300 });
+	if (targets.length > 0) await sleep(500);
+	return targets;
+}
+//#endregion
+export { renderGatewayPortHealthDiagnostics as a, waitForGatewayHealthyListener as c, inspectGatewayRestart as i, waitForGatewayHealthyRestart as l, DEFAULT_RESTART_HEALTH_DELAY_MS as n, renderRestartDiagnostics as o, DEFAULT_RESTART_HEALTH_TIMEOUT_MS as r, terminateStaleGatewayPids as s, DEFAULT_RESTART_HEALTH_ATTEMPTS as t };

package/dist/restart-health-DOVEX2Dr.js

@@ -0,0 +1,2 @@
+import { a as renderGatewayPortHealthDiagnostics, c as waitForGatewayHealthyListener, i as inspectGatewayRestart, l as waitForGatewayHealthyRestart, n as DEFAULT_RESTART_HEALTH_DELAY_MS, o as renderRestartDiagnostics, r as DEFAULT_RESTART_HEALTH_TIMEOUT_MS, s as terminateStaleGatewayPids, t as DEFAULT_RESTART_HEALTH_ATTEMPTS } from "./restart-health-1UMkTis9.js";
+export { DEFAULT_RESTART_HEALTH_ATTEMPTS, DEFAULT_RESTART_HEALTH_DELAY_MS, DEFAULT_RESTART_HEALTH_TIMEOUT_MS, inspectGatewayRestart, renderGatewayPortHealthDiagnostics, renderRestartDiagnostics, terminateStaleGatewayPids, waitForGatewayHealthyListener, waitForGatewayHealthyRestart };

package/dist/root-help-DOab9o7V.js

@@ -0,0 +1,44 @@
+import { n as VERSION } from "./version-qod78efn.js";
+import { n as collectUniqueCommandDescriptors, t as addCommandDescriptorsToProgram } from "./command-descriptor-utils-AegwfgPx.js";
+import { t as getCoreCliCommandDescriptors } from "./core-command-descriptors-DvifuN8K.js";
+import { n as getSubCliEntries } from "./subcli-descriptors-C4PhWAwd.js";
+import { t as configureProgramHelp } from "./help-48t8dOvz.js";
+import { t as getPluginCliCommandDescriptors } from "./cli-CyvueCG9.js";
+import { Command } from "commander";
+//#region src/cli/program/root-help.ts
+async function buildRootHelpProgram(renderOptions) {
+	const program = new Command();
+	configureProgramHelp(program, {
+		programVersion: VERSION,
+		channelOptions: [],
+		messageChannelOptions: "",
+		agentChannelOptions: ""
+	});
+	addCommandDescriptorsToProgram(program, collectUniqueCommandDescriptors([
+		getCoreCliCommandDescriptors(),
+		getSubCliEntries(),
+		await getPluginCliCommandDescriptors(renderOptions?.config, renderOptions?.env, { pluginSdkResolution: renderOptions?.pluginSdkResolution })
+	]));
+	return program;
+}
+async function renderRootHelpText(renderOptions) {
+	const program = await buildRootHelpProgram(renderOptions);
+	let output = "";
+	const originalWrite = process.stdout.write.bind(process.stdout);
+	const captureWrite = ((chunk) => {
+		output += String(chunk);
+		return true;
+	});
+	process.stdout.write = captureWrite;
+	try {
+		program.outputHelp();
+	} finally {
+		process.stdout.write = originalWrite;
+	}
+	return output;
+}
+async function outputRootHelp(renderOptions) {
+	process.stdout.write(await renderRootHelpText(renderOptions));
+}
+//#endregion
+export { outputRootHelp };