@pixelzx/genesis 2026.6.4-1 → 2026.6.5

package/dist/status.gather-CItmFIHS.js

@@ -0,0 +1,292 @@
+import { n as resolvePreferredGenesisTmpDir, t as POSIX_GENESIS_TMP_DIR } from "./tmp-genesis-dir-h5HSqKoN.js";
+import { _ as resolveStateDir, o as resolveConfigPath, u as resolveGatewayPort } from "./paths-Bv2rGpO9.js";
+import { a as trimToUndefined } from "./credential-planner-B91uV5hz.js";
+import "./credentials-CzcSOHw5.js";
+import { r as createConfigIO } from "./io-B1sv_bx7.js";
+import { i as parseStrictPositiveInteger } from "./parse-finite-number-BbGMkOzg.js";
+import { a as inspectPortUsage, s as formatPortDiagnostics } from "./ports-C52nWpb8.js";
+import { r as resolveGatewayService } from "./service-DiHWY6iI.js";
+import { c as pickProbeHostForBind, o as normalizeListenerAddress, s as parsePortFromArgs } from "./shared-Bes_qipP.js";
+import "./config-Cuf4dwjh.js";
+import { t as readLastGatewayErrorLine } from "./diagnostics-CEJnS076.js";
+import { r as resolveBestEffortGatewayBindHostForDisplay, t as inspectBestEffortPrimaryTailnetIPv4 } from "./network-discovery-display-DQ3ZKUsu.js";
+import path from "node:path";
+//#region src/logging/log-file-path.ts
+const LOG_PREFIX = "genesis";
+const LOG_SUFFIX = ".log";
+function canUseNodeFs() {
+	const getBuiltinModule = process.getBuiltinModule;
+	if (typeof getBuiltinModule !== "function") return false;
+	try {
+		return getBuiltinModule("fs") !== void 0;
+	} catch {
+		return false;
+	}
+}
+function formatLocalDate(date) {
+	return `${date.getFullYear()}-${String(date.getMonth() + 1).padStart(2, "0")}-${String(date.getDate()).padStart(2, "0")}`;
+}
+function resolveDefaultRollingLogFile(date = /* @__PURE__ */ new Date()) {
+	const logDir = canUseNodeFs() ? resolvePreferredGenesisTmpDir() : POSIX_GENESIS_TMP_DIR;
+	return path.join(logDir, `${LOG_PREFIX}-${formatLocalDate(date)}${LOG_SUFFIX}`);
+}
+function resolveConfiguredLogFilePath(config) {
+	return config?.logging?.file ?? resolveDefaultRollingLogFile();
+}
+//#endregion
+//#region src/cli/daemon-cli/status.gather.ts
+let gatewayProbeAuthModulePromise;
+let daemonInspectModulePromise;
+let serviceAuditModulePromise;
+let gatewayTlsModulePromise;
+let daemonProbeModulePromise;
+let restartHealthModulePromise;
+function loadGatewayProbeAuthModule() {
+	gatewayProbeAuthModulePromise ??= import("./probe-auth-IkpI5BiS.js");
+	return gatewayProbeAuthModulePromise;
+}
+function loadDaemonInspectModule() {
+	daemonInspectModulePromise ??= import("./inspect-CSDCZnL_.js");
+	return daemonInspectModulePromise;
+}
+function loadServiceAuditModule() {
+	serviceAuditModulePromise ??= import("./service-audit-CsA36wBu.js");
+	return serviceAuditModulePromise;
+}
+function loadGatewayTlsModule() {
+	gatewayTlsModulePromise ??= import("./gateway-Dfh6-1ov.js");
+	return gatewayTlsModulePromise;
+}
+function loadDaemonProbeModule() {
+	daemonProbeModulePromise ??= import("./probe-CDfjQSnz.js");
+	return daemonProbeModulePromise;
+}
+function loadRestartHealthModule() {
+	restartHealthModulePromise ??= import("./restart-health-hw909zlD.js");
+	return restartHealthModulePromise;
+}
+function resolveSnapshotRuntimeConfig(snapshot) {
+	if (!snapshot?.valid || !snapshot.runtimeConfig) return null;
+	return snapshot.runtimeConfig;
+}
+function appendProbeNote(existing, extra) {
+	const values = [existing, extra].filter((value) => Boolean(value?.trim()));
+	if (values.length === 0) return;
+	return [...new Set(values)].join(" ");
+}
+function shouldReportPortUsage(status, rpcOk) {
+	if (status !== "busy") return false;
+	if (rpcOk === true) return false;
+	return true;
+}
+async function loadDaemonConfigContext(serviceEnv) {
+	const mergedDaemonEnv = {
+		...process.env,
+		...serviceEnv ?? void 0
+	};
+	const cliConfigPath = resolveConfigPath(process.env, resolveStateDir(process.env));
+	const daemonConfigPath = resolveConfigPath(mergedDaemonEnv, resolveStateDir(mergedDaemonEnv));
+	const cliIO = createConfigIO({
+		env: process.env,
+		configPath: cliConfigPath,
+		pluginValidation: "skip"
+	});
+	const sharesDaemonConfigContext = !serviceEnv && cliConfigPath === daemonConfigPath;
+	const daemonIO = sharesDaemonConfigContext ? cliIO : createConfigIO({
+		env: mergedDaemonEnv,
+		configPath: daemonConfigPath,
+		pluginValidation: "skip"
+	});
+	const cliSnapshotPromise = cliIO.readConfigFileSnapshot().catch(() => null);
+	const daemonSnapshotPromise = sharesDaemonConfigContext ? cliSnapshotPromise : daemonIO.readConfigFileSnapshot().catch(() => null);
+	const [cliSnapshot, daemonSnapshot] = await Promise.all([cliSnapshotPromise, daemonSnapshotPromise]);
+	const cliCfg = resolveSnapshotRuntimeConfig(cliSnapshot) ?? cliIO.loadConfig();
+	const daemonCfg = sharesDaemonConfigContext && cliSnapshot === daemonSnapshot ? cliCfg : resolveSnapshotRuntimeConfig(daemonSnapshot) ?? daemonIO.loadConfig();
+	const cliConfigSummary = {
+		path: cliSnapshot?.path ?? cliConfigPath,
+		exists: cliSnapshot?.exists ?? false,
+		valid: cliSnapshot?.valid ?? true,
+		...cliSnapshot?.issues?.length ? { issues: cliSnapshot.issues } : {},
+		controlUi: cliCfg.gateway?.controlUi
+	};
+	const daemonConfigSummary = {
+		path: daemonSnapshot?.path ?? daemonConfigPath,
+		exists: daemonSnapshot?.exists ?? false,
+		valid: daemonSnapshot?.valid ?? true,
+		...daemonSnapshot?.issues?.length ? { issues: daemonSnapshot.issues } : {},
+		controlUi: daemonCfg.gateway?.controlUi
+	};
+	return {
+		mergedDaemonEnv,
+		cliCfg,
+		daemonCfg,
+		cliConfigSummary,
+		daemonConfigSummary,
+		configMismatch: cliConfigSummary.path !== daemonConfigSummary.path
+	};
+}
+async function resolveGatewayStatusSummary(params) {
+	const portFromArgs = parsePortFromArgs(params.commandProgramArguments);
+	const daemonPort = portFromArgs ?? resolveGatewayPort(params.daemonCfg, params.mergedDaemonEnv);
+	const portSource = portFromArgs ? "service args" : "env/config";
+	const bindMode = params.daemonCfg.gateway?.bind ?? "loopback";
+	const customBindHost = params.daemonCfg.gateway?.customBindHost;
+	const { bindHost, warning: bindHostWarning } = await resolveBestEffortGatewayBindHostForDisplay({
+		bindMode,
+		customBindHost,
+		warningPrefix: "Status is using fallback network details because interface discovery failed"
+	});
+	const { tailnetIPv4, warning: tailnetWarning } = inspectBestEffortPrimaryTailnetIPv4({ warningPrefix: "Status could not inspect tailnet addresses" });
+	const probeHost = pickProbeHostForBind(bindMode, tailnetIPv4, customBindHost);
+	const probeUrlOverride = trimToUndefined(params.rpcUrlOverride) ?? null;
+	const scheme = params.daemonCfg.gateway?.tls?.enabled === true ? "wss" : "ws";
+	const probeUrl = probeUrlOverride ?? `${scheme}://${probeHost}:${daemonPort}`;
+	let probeNote = !probeUrlOverride && bindMode === "lan" ? `bind=lan listens on 0.0.0.0 (all interfaces); probing via ${probeHost}.` : !probeUrlOverride && bindMode === "loopback" ? "Loopback-only gateway; only local clients can connect." : void 0;
+	probeNote = appendProbeNote(probeNote, bindHostWarning);
+	probeNote = appendProbeNote(probeNote, tailnetWarning);
+	return {
+		gateway: {
+			bindMode,
+			bindHost,
+			customBindHost,
+			port: daemonPort,
+			portSource,
+			probeUrl,
+			...probeNote ? { probeNote } : {}
+		},
+		daemonPort,
+		cliPort: resolveGatewayPort(params.cliCfg, process.env),
+		probeUrlOverride
+	};
+}
+function toPortStatusSummary(diagnostics) {
+	if (!diagnostics) return;
+	return {
+		port: diagnostics.port,
+		status: diagnostics.status,
+		listeners: diagnostics.listeners,
+		hints: diagnostics.hints
+	};
+}
+async function inspectDaemonPortStatuses(params) {
+	const [portDiagnostics, portCliDiagnostics] = await Promise.all([inspectPortUsage(params.daemonPort).catch(() => null), params.cliPort !== params.daemonPort ? inspectPortUsage(params.cliPort).catch(() => null) : null]);
+	return {
+		portStatus: toPortStatusSummary(portDiagnostics),
+		portCliStatus: toPortStatusSummary(portCliDiagnostics)
+	};
+}
+async function gatherDaemonStatus(opts) {
+	const service = resolveGatewayService();
+	const command = await service.readCommand(process.env).catch(() => null);
+	const serviceEnv = command?.environment ? {
+		...process.env,
+		...command.environment
+	} : process.env;
+	const [loaded, runtime] = await Promise.all([service.isLoaded({ env: serviceEnv }).catch(() => false), service.readRuntime(serviceEnv).catch((err) => ({
+		status: "unknown",
+		detail: String(err)
+	}))]);
+	const configAudit = command ? await loadServiceAuditModule().then(({ auditGatewayServiceConfig }) => auditGatewayServiceConfig({
+		env: process.env,
+		command
+	})) : {
+		ok: true,
+		issues: []
+	};
+	const { mergedDaemonEnv, cliCfg, daemonCfg, cliConfigSummary, daemonConfigSummary, configMismatch } = await loadDaemonConfigContext(command?.environment);
+	const { gateway, daemonPort, cliPort, probeUrlOverride } = await resolveGatewayStatusSummary({
+		cliCfg,
+		daemonCfg,
+		mergedDaemonEnv,
+		commandProgramArguments: command?.programArguments,
+		rpcUrlOverride: opts.rpc.url
+	});
+	const { portStatus, portCliStatus } = await inspectDaemonPortStatuses({
+		daemonPort,
+		cliPort
+	});
+	const extraServices = opts.deep ? await loadDaemonInspectModule().then(({ findExtraGatewayServices }) => findExtraGatewayServices(process.env, { deep: true })).catch(() => []) : [];
+	const timeoutMs = parseStrictPositiveInteger(opts.rpc.timeout ?? "10000") ?? 1e4;
+	const tlsEnabled = daemonCfg.gateway?.tls?.enabled === true;
+	const shouldUseLocalTlsRuntime = opts.probe && !probeUrlOverride && tlsEnabled;
+	const tlsRuntime = shouldUseLocalTlsRuntime ? await loadGatewayTlsModule().then(({ loadGatewayTlsRuntime }) => loadGatewayTlsRuntime(daemonCfg.gateway?.tls)) : void 0;
+	let daemonProbeAuth;
+	let rpcAuthWarning;
+	if (opts.probe) {
+		const probeMode = daemonCfg.gateway?.mode === "remote" ? "remote" : "local";
+		const probeAuthResolution = await loadGatewayProbeAuthModule().then(({ resolveGatewayProbeAuthSafeWithSecretInputs }) => resolveGatewayProbeAuthSafeWithSecretInputs({
+			cfg: daemonCfg,
+			mode: probeMode,
+			env: mergedDaemonEnv,
+			explicitAuth: {
+				token: opts.rpc.token,
+				password: opts.rpc.password
+			}
+		}));
+		daemonProbeAuth = probeAuthResolution.auth;
+		rpcAuthWarning = probeAuthResolution.warning;
+	}
+	const rpc = opts.probe ? await loadDaemonProbeModule().then(({ probeGatewayStatus }) => probeGatewayStatus({
+		url: gateway.probeUrl,
+		token: daemonProbeAuth?.token,
+		password: daemonProbeAuth?.password,
+		tlsFingerprint: shouldUseLocalTlsRuntime && tlsRuntime?.enabled ? tlsRuntime.fingerprintSha256 : void 0,
+		timeoutMs,
+		json: opts.rpc.json,
+		requireRpc: opts.requireRpc,
+		configPath: daemonConfigSummary.path
+	})) : void 0;
+	if (rpc?.ok) rpcAuthWarning = void 0;
+	const health = opts.probe && loaded && rpc?.ok !== true ? await loadRestartHealthModule().then(({ inspectGatewayRestart }) => inspectGatewayRestart({
+		service,
+		port: daemonPort,
+		env: serviceEnv
+	})).catch(() => void 0) : void 0;
+	let lastError;
+	if (loaded && runtime?.status === "running" && portStatus && portStatus.status !== "busy") lastError = await readLastGatewayErrorLine(mergedDaemonEnv) ?? void 0;
+	return {
+		logFile: resolveConfiguredLogFilePath(cliCfg),
+		service: {
+			label: service.label,
+			loaded,
+			loadedText: service.loadedText,
+			notLoadedText: service.notLoadedText,
+			command,
+			runtime,
+			configAudit
+		},
+		config: {
+			cli: cliConfigSummary,
+			daemon: daemonConfigSummary,
+			...configMismatch ? { mismatch: true } : {}
+		},
+		gateway,
+		port: portStatus,
+		...portCliStatus ? { portCli: portCliStatus } : {},
+		lastError,
+		...rpc ? { rpc: {
+			...rpc,
+			url: gateway.probeUrl,
+			...rpcAuthWarning ? { authWarning: rpcAuthWarning } : {}
+		} } : {},
+		...health ? { health: {
+			healthy: health.healthy,
+			staleGatewayPids: health.staleGatewayPids
+		} } : {},
+		extraServices
+	};
+}
+function renderPortDiagnosticsForCli(status, rpcOk) {
+	if (!status.port || !shouldReportPortUsage(status.port.status, rpcOk)) return [];
+	return formatPortDiagnostics({
+		port: status.port.port,
+		status: status.port.status,
+		listeners: status.port.listeners,
+		hints: status.port.hints
+	});
+}
+function resolvePortListeningAddresses(status) {
+	return Array.from(new Set(status.port?.listeners?.map((l) => l.address ? normalizeListenerAddress(l.address) : "").filter((v) => Boolean(v)) ?? []));
+}
+//#endregion
+export { renderPortDiagnosticsForCli as n, resolvePortListeningAddresses as r, gatherDaemonStatus as t };

package/dist/status.gather-qB6WOoH7.js

@@ -0,0 +1,2 @@
+import { n as renderPortDiagnosticsForCli, r as resolvePortListeningAddresses, t as gatherDaemonStatus } from "./status.gather-CItmFIHS.js";
+export { gatherDaemonStatus, renderPortDiagnosticsForCli, resolvePortListeningAddresses };

package/dist/status.runtime-ClZCgYx1.js

@@ -0,0 +1,2 @@
+import { t as runDaemonStatus } from "./status-DzlIHiTS.js";
+export { runDaemonStatus };

package/dist/status.runtime.js

@@ -1 +1 @@
-export * from "./status.runtime-BrErwtfc.js";
+export * from "./status.runtime-ClZCgYx1.js";

package/dist/status.scan-overview-B0b0Mvng.js

@@ -0,0 +1,379 @@
+import { c as normalizeOptionalString, s as normalizeOptionalLowercaseString } from "./string-coerce-DPP_aYVc.js";
+import { o as resolveConfigPath } from "./paths-Bv2rGpO9.js";
+import { i as runExec } from "./exec-BbrLAvgI.js";
+import { n as defaultSlotIdForKey } from "./slots-BpEPHdhK.js";
+import { r as normalizeControlUiBasePath } from "./control-ui-shared-DMYCWX54.js";
+import { t as resolveOsSummary } from "./os-summary-BGb4fJGT.js";
+import { t as buildGatewayConnectionDetailsWithResolvers } from "./connection-details-BIhOlH1Y.js";
+import { i as hasConfiguredChannelsForReadOnlyScope } from "./channel-plugin-ids-CiapHLHH.js";
+import { t as createEmptyTaskRegistrySummary } from "./task-registry.summary-D2tNVhio.js";
+import { n as createEmptyTaskAuditSummary } from "./task-registry.audit.shared-DNlulHlg.js";
+import { t as pickGatewaySelfPresence } from "./gateway-presence-a7iDXXWt.js";
+import { t as resolveGatewayProbeTarget } from "./probe-target-BLQkJJXc.js";
+import { existsSync } from "node:fs";
+//#region src/commands/status.scan.shared.ts
+let gatewayProbeModulePromise;
+let probeGatewayModulePromise;
+function loadGatewayProbeModule() {
+	gatewayProbeModulePromise ??= import("./status.gateway-probe-1aUV3oa_.js");
+	return gatewayProbeModulePromise;
+}
+function loadProbeGatewayModule() {
+	probeGatewayModulePromise ??= import("./probe-BOlTfbzG.js");
+	return probeGatewayModulePromise;
+}
+function hasExplicitMemorySearchConfig(cfg, agentId) {
+	if (cfg.agents?.defaults && Object.prototype.hasOwnProperty.call(cfg.agents.defaults, "memorySearch")) return true;
+	return (Array.isArray(cfg.agents?.list) ? cfg.agents.list : []).some((agent) => agent?.id === agentId && Object.prototype.hasOwnProperty.call(agent, "memorySearch"));
+}
+function resolveMemoryPluginStatus(cfg) {
+	if (!(cfg.plugins?.enabled !== false)) return {
+		enabled: false,
+		slot: null,
+		reason: "plugins disabled"
+	};
+	const raw = normalizeOptionalString(cfg.plugins?.slots?.memory) ?? "";
+	if (normalizeOptionalLowercaseString(raw) === "none") return {
+		enabled: false,
+		slot: null,
+		reason: "plugins.slots.memory=\"none\""
+	};
+	return {
+		enabled: true,
+		slot: raw || defaultSlotIdForKey("memory")
+	};
+}
+async function resolveGatewayProbeSnapshot(params) {
+	const gatewayConnection = buildGatewayConnectionDetailsWithResolvers({ config: params.cfg });
+	const { gatewayMode, remoteUrlMissing } = resolveGatewayProbeTarget(params.cfg);
+	const shouldResolveAuth = params.opts.skipProbe !== true && (!remoteUrlMissing || params.opts.resolveAuthWhenRemoteUrlMissing === true);
+	const shouldProbe = params.opts.skipProbe !== true && (!remoteUrlMissing || params.opts.probeWhenRemoteUrlMissing === true);
+	const gatewayProbeAuthResolution = shouldResolveAuth ? await loadGatewayProbeModule().then(({ resolveGatewayProbeAuthResolution }) => resolveGatewayProbeAuthResolution(params.cfg)) : {
+		auth: {},
+		warning: void 0
+	};
+	let gatewayProbeAuthWarning = gatewayProbeAuthResolution.warning;
+	const gatewayProbe = shouldProbe ? await loadProbeGatewayModule().then(({ probeGateway }) => probeGateway({
+		url: gatewayConnection.url,
+		auth: gatewayProbeAuthResolution.auth,
+		timeoutMs: Math.min(params.opts.all ? 5e3 : 2500, params.opts.timeoutMs ?? 1e4),
+		detailLevel: params.opts.detailLevel ?? "presence"
+	})).catch(() => null) : null;
+	if ((params.opts.mergeAuthWarningIntoProbeError ?? true) && gatewayProbeAuthWarning && gatewayProbe?.ok === false) {
+		gatewayProbe.error = gatewayProbe.error ? `${gatewayProbe.error}; ${gatewayProbeAuthWarning}` : gatewayProbeAuthWarning;
+		gatewayProbeAuthWarning = void 0;
+	}
+	const gatewayReachable = gatewayProbe?.ok === true;
+	const gatewaySelf = gatewayProbe?.presence ? pickGatewaySelfPresence(gatewayProbe.presence) : null;
+	return {
+		gatewayConnection,
+		remoteUrlMissing,
+		gatewayMode,
+		gatewayProbeAuth: gatewayProbeAuthResolution.auth,
+		gatewayProbeAuthWarning,
+		gatewayProbe,
+		gatewayReachable,
+		gatewaySelf,
+		...remoteUrlMissing ? { gatewayCallOverrides: {
+			url: gatewayConnection.url,
+			token: gatewayProbeAuthResolution.auth.token,
+			password: gatewayProbeAuthResolution.auth.password
+		} } : {}
+	};
+}
+function buildTailscaleHttpsUrl(params) {
+	return params.tailscaleMode !== "off" && params.tailscaleDns ? `https://${params.tailscaleDns}${normalizeControlUiBasePath(params.controlUiBasePath)}` : null;
+}
+async function resolveSharedMemoryStatusSnapshot(params) {
+	const { cfg, agentStatus, memoryPlugin } = params;
+	if (!memoryPlugin.enabled || !memoryPlugin.slot) return null;
+	const agentId = agentStatus.defaultId ?? "main";
+	const defaultStorePath = params.requireDefaultStore?.(agentId);
+	if (defaultStorePath && !hasExplicitMemorySearchConfig(cfg, agentId) && !existsSync(defaultStorePath)) return null;
+	const resolvedMemory = params.resolveMemoryConfig(cfg, agentId);
+	if (!resolvedMemory) return null;
+	if (!(hasExplicitMemorySearchConfig(cfg, agentId) || existsSync(resolvedMemory.store.path))) return null;
+	const { manager } = await params.getMemorySearchManager({
+		cfg,
+		agentId,
+		purpose: "status"
+	});
+	if (!manager) return null;
+	try {
+		await manager.probeVectorAvailability();
+	} catch {}
+	const status = manager.status();
+	await manager.close?.().catch(() => {});
+	return {
+		agentId,
+		...status
+	};
+}
+//#endregion
+//#region src/commands/status.scan.bootstrap-shared.ts
+function buildColdStartUpdateResult() {
+	return {
+		root: null,
+		installKind: "unknown",
+		packageManager: "unknown"
+	};
+}
+function buildColdStartAgentLocalStatuses() {
+	return {
+		defaultId: "main",
+		agents: [],
+		totalSessions: 0,
+		bootstrapPendingCount: 0
+	};
+}
+function buildColdStartStatusSummary() {
+	return {
+		runtimeVersion: null,
+		heartbeat: {
+			defaultAgentId: "main",
+			agents: []
+		},
+		channelSummary: [],
+		queuedSystemEvents: [],
+		tasks: createEmptyTaskRegistrySummary(),
+		taskAudit: createEmptyTaskAuditSummary(),
+		sessions: {
+			paths: [],
+			count: 0,
+			defaults: {
+				model: null,
+				contextTokens: null
+			},
+			recent: [],
+			byAgent: []
+		}
+	};
+}
+function shouldSkipStatusScanNetworkChecks(params) {
+	return params.coldStart && !params.hasConfiguredChannels && params.all !== true;
+}
+async function createStatusScanCoreBootstrap(params) {
+	const tailscaleMode = params.cfg.gateway?.tailscale?.mode ?? "off";
+	const skipColdStartNetworkChecks = shouldSkipStatusScanNetworkChecks({
+		coldStart: params.coldStart,
+		hasConfiguredChannels: params.hasConfiguredChannels,
+		all: params.opts.all
+	});
+	const updateTimeoutMs = params.opts.all ? 6500 : 2500;
+	const tailscaleDnsPromise = tailscaleMode === "off" ? Promise.resolve(null) : params.getTailnetHostname((cmd, args) => runExec(cmd, args, {
+		timeoutMs: 1200,
+		maxBuffer: 2e5
+	})).catch(() => null);
+	return {
+		tailscaleMode,
+		tailscaleDnsPromise,
+		updatePromise: skipColdStartNetworkChecks ? Promise.resolve(buildColdStartUpdateResult()) : params.getUpdateCheckResult({
+			timeoutMs: updateTimeoutMs,
+			fetchGit: true,
+			includeRegistry: true
+		}),
+		agentStatusPromise: skipColdStartNetworkChecks ? Promise.resolve(buildColdStartAgentLocalStatuses()) : params.getAgentLocalStatuses(params.cfg),
+		gatewayProbePromise: resolveGatewayProbeSnapshot({
+			cfg: params.cfg,
+			opts: {
+				...params.opts,
+				...skipColdStartNetworkChecks ? { skipProbe: true } : {}
+			}
+		}),
+		skipColdStartNetworkChecks,
+		resolveTailscaleHttpsUrl: async () => buildTailscaleHttpsUrl({
+			tailscaleMode,
+			tailscaleDns: await tailscaleDnsPromise,
+			controlUiBasePath: params.cfg.gateway?.controlUi?.basePath
+		})
+	};
+}
+//#endregion
+//#region src/commands/status.scan.config-shared.ts
+function shouldSkipStatusScanMissingConfigFastPath(env = process.env) {
+	return env.VITEST === "true" || env.VITEST_POOL_ID !== void 0 || env.NODE_ENV === "test";
+}
+function resolveStatusScanColdStart(params) {
+	const env = params?.env ?? process.env;
+	return !(params?.allowMissingConfigFastPath === true && shouldSkipStatusScanMissingConfigFastPath(env)) && !existsSync(resolveConfigPath(env));
+}
+async function loadStatusScanCommandConfig(params) {
+	const coldStart = resolveStatusScanColdStart({
+		env: params.env ?? process.env,
+		allowMissingConfigFastPath: params.allowMissingConfigFastPath
+	});
+	const sourceConfig = coldStart && params.allowMissingConfigFastPath === true ? {} : await params.readBestEffortConfig();
+	const { resolvedConfig, diagnostics } = coldStart && params.allowMissingConfigFastPath === true ? {
+		resolvedConfig: sourceConfig,
+		diagnostics: []
+	} : await params.resolveConfig(sourceConfig);
+	return {
+		coldStart,
+		sourceConfig,
+		resolvedConfig,
+		secretDiagnostics: diagnostics
+	};
+}
+//#endregion
+//#region src/commands/status.scan-overview.ts
+let statusScanDepsRuntimeModulePromise;
+let statusAgentLocalModulePromise;
+let statusUpdateModulePromise;
+let statusScanRuntimeModulePromise;
+let gatewayCallModulePromise;
+let statusSummaryModulePromise;
+let configModulePromise;
+let commandConfigResolutionModulePromise;
+let commandSecretTargetsModulePromise;
+function loadStatusScanDepsRuntimeModule() {
+	statusScanDepsRuntimeModulePromise ??= import("./status.scan.deps.runtime-BqLDIauZ.js");
+	return statusScanDepsRuntimeModulePromise;
+}
+function loadStatusAgentLocalModule() {
+	statusAgentLocalModulePromise ??= import("./status.agent-local-D3oU0vVl.js");
+	return statusAgentLocalModulePromise;
+}
+function loadStatusUpdateModule() {
+	statusUpdateModulePromise ??= import("./status.update-WMBD7poS.js");
+	return statusUpdateModulePromise;
+}
+function loadStatusScanRuntimeModule() {
+	statusScanRuntimeModulePromise ??= import("./status.scan.runtime-B3rWFKOh.js");
+	return statusScanRuntimeModulePromise;
+}
+function loadGatewayCallModule() {
+	gatewayCallModulePromise ??= import("./call-BI4JvjcR.js");
+	return gatewayCallModulePromise;
+}
+function loadStatusSummaryModule() {
+	statusSummaryModulePromise ??= import("./status.summary-B3PlFnWw.js");
+	return statusSummaryModulePromise;
+}
+function loadConfigModule() {
+	configModulePromise ??= import("./config-XlU0nEeW.js");
+	return configModulePromise;
+}
+function loadCommandConfigResolutionModule() {
+	commandConfigResolutionModulePromise ??= import("./command-config-resolution-CAsa4fGg.js");
+	return commandConfigResolutionModulePromise;
+}
+function loadCommandSecretTargetsModule() {
+	commandSecretTargetsModulePromise ??= import("./command-secret-targets-ClllKT49.js");
+	return commandSecretTargetsModulePromise;
+}
+async function resolveStatusChannelsStatus(params) {
+	if (!params.gatewayReachable) return null;
+	const { callGateway } = await loadGatewayCallModule();
+	return await callGateway({
+		config: params.cfg,
+		method: "channels.status",
+		params: {
+			probe: false,
+			timeoutMs: Math.min(8e3, params.opts.timeoutMs ?? 1e4)
+		},
+		timeoutMs: Math.min(params.opts.all ? 5e3 : 2500, params.opts.timeoutMs ?? 1e4),
+		...params.useGatewayCallOverrides === true ? params.gatewayCallOverrides ?? {} : {}
+	}).catch(() => null);
+}
+async function collectStatusScanOverview(params) {
+	if (params.labels?.loadingConfig) params.progress?.setLabel(params.labels.loadingConfig);
+	const { coldStart, sourceConfig, resolvedConfig: cfg, secretDiagnostics } = await loadStatusScanCommandConfig({
+		commandName: params.commandName,
+		allowMissingConfigFastPath: params.allowMissingConfigFastPath,
+		readBestEffortConfig: async () => (await loadConfigModule()).readBestEffortConfig(),
+		resolveConfig: async (loadedConfig) => await (await loadCommandConfigResolutionModule()).resolveCommandConfigWithSecrets({
+			config: loadedConfig,
+			commandName: params.commandName,
+			targetIds: (await loadCommandSecretTargetsModule()).getStatusCommandSecretTargetIds(loadedConfig),
+			mode: "read_only_status",
+			...params.runtime ? { runtime: params.runtime } : {}
+		})
+	});
+	params.progress?.tick();
+	const hasConfiguredChannels = params.resolveHasConfiguredChannels ? params.resolveHasConfiguredChannels(cfg, sourceConfig) : hasConfiguredChannelsForReadOnlyScope({
+		config: cfg,
+		activationSourceConfig: sourceConfig
+	});
+	const osSummary = resolveOsSummary();
+	const bootstrap = await createStatusScanCoreBootstrap({
+		coldStart,
+		cfg,
+		hasConfiguredChannels,
+		opts: params.opts,
+		getTailnetHostname: async (runner) => await loadStatusScanDepsRuntimeModule().then(({ getTailnetHostname }) => getTailnetHostname(runner)),
+		getUpdateCheckResult: async (updateParams) => await loadStatusUpdateModule().then(({ getUpdateCheckResult }) => getUpdateCheckResult(updateParams)),
+		getAgentLocalStatuses: async (bootstrapCfg) => await loadStatusAgentLocalModule().then(({ getAgentLocalStatuses }) => getAgentLocalStatuses(bootstrapCfg))
+	});
+	if (params.labels?.checkingTailscale) params.progress?.setLabel(params.labels.checkingTailscale);
+	const tailscaleDns = await bootstrap.tailscaleDnsPromise;
+	params.progress?.tick();
+	if (params.labels?.checkingForUpdates) params.progress?.setLabel(params.labels.checkingForUpdates);
+	const update = await bootstrap.updatePromise;
+	params.progress?.tick();
+	if (params.labels?.resolvingAgents) params.progress?.setLabel(params.labels.resolvingAgents);
+	const agentStatus = await bootstrap.agentStatusPromise;
+	params.progress?.tick();
+	if (params.labels?.probingGateway) params.progress?.setLabel(params.labels.probingGateway);
+	const gatewaySnapshot = await bootstrap.gatewayProbePromise;
+	params.progress?.tick();
+	const tailscaleHttpsUrl = await bootstrap.resolveTailscaleHttpsUrl();
+	const { channelsStatus, channelIssues, channels } = params.includeChannelsData !== false ? await (async () => {
+		if (params.labels?.queryingChannelStatus) params.progress?.setLabel(params.labels.queryingChannelStatus);
+		const channelsStatus = await resolveStatusChannelsStatus({
+			cfg,
+			gatewayReachable: gatewaySnapshot.gatewayReachable,
+			opts: params.opts,
+			gatewayCallOverrides: gatewaySnapshot.gatewayCallOverrides,
+			useGatewayCallOverrides: params.useGatewayCallOverridesForChannelsStatus
+		});
+		params.progress?.tick();
+		const { collectChannelStatusIssues, buildChannelsTable } = await loadStatusScanRuntimeModule().then(({ statusScanRuntime }) => statusScanRuntime);
+		const channelIssues = channelsStatus ? collectChannelStatusIssues(channelsStatus) : [];
+		if (params.labels?.summarizingChannels) params.progress?.setLabel(params.labels.summarizingChannels);
+		const channels = await buildChannelsTable(cfg, {
+			showSecrets: params.showSecrets,
+			sourceConfig
+		});
+		params.progress?.tick();
+		return {
+			channelsStatus,
+			channelIssues,
+			channels
+		};
+	})() : {
+		channelsStatus: null,
+		channelIssues: [],
+		channels: {
+			rows: [],
+			details: []
+		}
+	};
+	return {
+		coldStart,
+		hasConfiguredChannels,
+		skipColdStartNetworkChecks: bootstrap.skipColdStartNetworkChecks,
+		cfg,
+		sourceConfig,
+		secretDiagnostics,
+		osSummary,
+		tailscaleMode: bootstrap.tailscaleMode,
+		tailscaleDns,
+		tailscaleHttpsUrl,
+		update,
+		gatewaySnapshot,
+		channelsStatus,
+		channelIssues,
+		channels,
+		agentStatus
+	};
+}
+async function resolveStatusSummaryFromOverview(params) {
+	if (params.overview.skipColdStartNetworkChecks) return buildColdStartStatusSummary();
+	return await loadStatusSummaryModule().then(({ getStatusSummary }) => getStatusSummary({
+		config: params.overview.cfg,
+		sourceConfig: params.overview.sourceConfig,
+		includeChannelSummary: params.includeChannelSummary
+	}));
+}
+//#endregion
+export { resolveSharedMemoryStatusSnapshot as i, resolveStatusSummaryFromOverview as n, resolveMemoryPluginStatus as r, collectStatusScanOverview as t };