@pixelzx/genesis 2026.5.5-3 → 2026.5.5-4

package/dist/health-D_wk2s7j.js

@@ -0,0 +1,3 @@
+import { t as formatHealthChannelLines } from "./health-format-BrEM-ug-.js";
+import { n as healthCommand, t as getHealthSnapshot } from "./health-MRnjOx-_.js";
+export { formatHealthChannelLines, getHealthSnapshot, healthCommand };

package/dist/health-MRnjOx-_.js

@@ -0,0 +1,469 @@
+import { i as formatErrorMessage } from "./errors-Jbvi20TW.js";
+import { r as writeRuntimeJson } from "./runtime-CQ7eH0le.js";
+import { t as isTruthyEnvValue } from "./env-CLDDxlAx.js";
+import { n as isRich } from "./theme-BrRleVfL.js";
+import { n as info } from "./globals-C5IxqXPj.js";
+import { n as asNullableRecord } from "./record-coerce-BpObaVhi.js";
+import { c as normalizeAgentId } from "./session-key-EpIbK3Oz.js";
+import { x as resolveDefaultAgentId } from "./agent-scope-CDjZLqNk.js";
+import { u as resolveStorePath } from "./paths-DD6L4IvS.js";
+import { r as resolveHeartbeatSummaryForAgent } from "./heartbeat-summary-Dri6qdcY.js";
+import { n as buildGatewayConnectionDetails, r as callGateway } from "./call-ORivR4Db.js";
+import { t as listReadOnlyChannelPluginsForConfig } from "./read-only-Bc9RJswo.js";
+import { a as resolvePreferredAccountId, t as buildChannelAccountBindings } from "./bindings-DtpefBLK.js";
+import { i as resolveChannelDefaultAccountId } from "./helpers-C1NDWBfW.js";
+import { t as inspectReadOnlyChannelAccount } from "./read-only-account-inspect-B4b6Utks.js";
+import { n as withProgress } from "./progress-C6QDkZMg.js";
+import { t as formatHealthChannelLines } from "./health-format-BrEM-ug-.js";
+import { t as styleHealthChannelLine } from "./health-style-DgGV37ag.js";
+import { t as logGatewayConnectionDetails } from "./status.gateway-connection-CkCJi_UH.js";
+//#region src/commands/health.ts
+const DEFAULT_TIMEOUT_MS = 1e4;
+let configModulePromise;
+function loadConfigModule() {
+	configModulePromise ??= import("./config-DDoTcXdn.js");
+	return configModulePromise;
+}
+const debugHealth = (...args) => {
+	if (isTruthyEnvValue(process.env.GENESIS_DEBUG_HEALTH)) console.warn("[health:debug]", ...args);
+};
+const formatDurationParts = (ms) => {
+	if (!Number.isFinite(ms)) return "unknown";
+	if (ms < 1e3) return `${Math.max(0, Math.round(ms))}ms`;
+	const units = [
+		{
+			label: "w",
+			size: 10080 * 60 * 1e3
+		},
+		{
+			label: "d",
+			size: 1440 * 60 * 1e3
+		},
+		{
+			label: "h",
+			size: 3600 * 1e3
+		},
+		{
+			label: "m",
+			size: 60 * 1e3
+		},
+		{
+			label: "s",
+			size: 1e3
+		}
+	];
+	let remaining = Math.max(0, Math.floor(ms));
+	const parts = [];
+	for (const unit of units) {
+		const value = Math.floor(remaining / unit.size);
+		if (value > 0) {
+			parts.push(`${value}${unit.label}`);
+			remaining -= value * unit.size;
+		}
+	}
+	if (parts.length === 0) return "0s";
+	return parts.join(" ");
+};
+const resolveHeartbeatSummary = (cfg, agentId) => resolveHeartbeatSummaryForAgent(cfg, agentId);
+const resolveAgentOrder = (cfg) => {
+	const defaultAgentId = resolveDefaultAgentId(cfg);
+	const entries = Array.isArray(cfg.agents?.list) ? cfg.agents.list : [];
+	const seen = /* @__PURE__ */ new Set();
+	const ordered = [];
+	for (const entry of entries) {
+		if (!entry || typeof entry !== "object") continue;
+		if (typeof entry.id !== "string" || !entry.id.trim()) continue;
+		const id = normalizeAgentId(entry.id);
+		if (!id || seen.has(id)) continue;
+		seen.add(id);
+		ordered.push({
+			id,
+			name: typeof entry.name === "string" ? entry.name : void 0
+		});
+	}
+	if (!seen.has(defaultAgentId)) ordered.unshift({ id: defaultAgentId });
+	if (ordered.length === 0) ordered.push({ id: defaultAgentId });
+	return {
+		defaultAgentId,
+		ordered
+	};
+};
+const buildSessionSummary = async (storePath) => {
+	const { loadSessionStore } = await import("./store-BdedeUHG.js");
+	const store = loadSessionStore(storePath);
+	const sessions = Object.entries(store).filter(([key]) => key !== "global" && key !== "unknown").map(([key, entry]) => ({
+		key,
+		updatedAt: entry?.updatedAt ?? 0
+	})).toSorted((a, b) => b.updatedAt - a.updatedAt);
+	const recent = sessions.slice(0, 5).map((s) => ({
+		key: s.key,
+		updatedAt: s.updatedAt || null,
+		age: s.updatedAt ? Date.now() - s.updatedAt : null
+	}));
+	return {
+		path: storePath,
+		count: sessions.length,
+		recent
+	};
+};
+async function inspectHealthAccount(plugin, cfg, accountId) {
+	return plugin.config.inspectAccount?.(cfg, accountId) ?? await inspectReadOnlyChannelAccount({
+		channelId: plugin.id,
+		cfg,
+		accountId
+	});
+}
+function readBooleanField(value, key) {
+	const record = asNullableRecord(value);
+	if (!record) return;
+	return typeof record[key] === "boolean" ? record[key] : void 0;
+}
+async function resolveHealthAccountContext(params) {
+	const diagnostics = [];
+	let account;
+	try {
+		account = params.plugin.config.resolveAccount(params.cfg, params.accountId);
+	} catch (error) {
+		diagnostics.push(`${params.plugin.id}:${params.accountId}: failed to resolve account (${formatErrorMessage(error)}).`);
+		account = await inspectHealthAccount(params.plugin, params.cfg, params.accountId);
+	}
+	if (!account) return {
+		account: {},
+		enabled: false,
+		configured: false,
+		diagnostics
+	};
+	const enabledFallback = readBooleanField(account, "enabled") ?? true;
+	let enabled = enabledFallback;
+	if (params.plugin.config.isEnabled) try {
+		enabled = params.plugin.config.isEnabled(account, params.cfg);
+	} catch (error) {
+		enabled = enabledFallback;
+		diagnostics.push(`${params.plugin.id}:${params.accountId}: failed to evaluate enabled state (${formatErrorMessage(error)}).`);
+	}
+	const configuredFallback = readBooleanField(account, "configured") ?? true;
+	let configured = configuredFallback;
+	if (params.plugin.config.isConfigured) try {
+		configured = await params.plugin.config.isConfigured(account, params.cfg);
+	} catch (error) {
+		configured = configuredFallback;
+		diagnostics.push(`${params.plugin.id}:${params.accountId}: failed to evaluate configured state (${formatErrorMessage(error)}).`);
+	}
+	return {
+		account,
+		enabled,
+		configured,
+		diagnostics
+	};
+}
+async function getHealthSnapshot(params) {
+	const timeoutMs = params?.timeoutMs;
+	const { loadConfig } = await loadConfigModule();
+	const cfg = loadConfig();
+	const { defaultAgentId, ordered } = resolveAgentOrder(cfg);
+	const channelBindings = buildChannelAccountBindings(cfg);
+	const sessionCache = /* @__PURE__ */ new Map();
+	const agents = [];
+	for (const entry of ordered) {
+		const storePath = resolveStorePath(cfg.session?.store, { agentId: entry.id });
+		const sessions = sessionCache.get(storePath) ?? await buildSessionSummary(storePath);
+		sessionCache.set(storePath, sessions);
+		agents.push({
+			agentId: entry.id,
+			name: entry.name,
+			isDefault: entry.id === defaultAgentId,
+			heartbeat: resolveHeartbeatSummary(cfg, entry.id),
+			sessions
+		});
+	}
+	const defaultAgent = agents.find((agent) => agent.isDefault) ?? agents[0];
+	const heartbeatSeconds = defaultAgent?.heartbeat.everyMs ? Math.round(defaultAgent.heartbeat.everyMs / 1e3) : 0;
+	const sessions = defaultAgent?.sessions ?? await buildSessionSummary(resolveStorePath(cfg.session?.store, { agentId: defaultAgentId }));
+	const start = Date.now();
+	const cappedTimeout = timeoutMs === void 0 ? DEFAULT_TIMEOUT_MS : Math.max(50, timeoutMs);
+	const doProbe = params?.probe !== false;
+	const channels = {};
+	const plugins = listReadOnlyChannelPluginsForConfig(cfg);
+	const channelOrder = plugins.map((plugin) => plugin.id);
+	const channelLabels = {};
+	for (const plugin of plugins) {
+		channelLabels[plugin.id] = plugin.meta.label ?? plugin.id;
+		const accountIds = plugin.config.listAccountIds(cfg);
+		const defaultAccountId = resolveChannelDefaultAccountId({
+			plugin,
+			cfg,
+			accountIds
+		});
+		const boundAccounts = channelBindings.get(plugin.id)?.get(defaultAgentId) ?? [];
+		const preferredAccountId = resolvePreferredAccountId({
+			accountIds,
+			defaultAccountId,
+			boundAccounts
+		});
+		const boundAccountIdsAll = Array.from(new Set(Array.from(channelBindings.get(plugin.id)?.values() ?? []).flatMap((ids) => ids)));
+		const accountIdsToProbe = Array.from(new Set([
+			preferredAccountId,
+			defaultAccountId,
+			...accountIds,
+			...boundAccountIdsAll
+		].filter((value) => value && value.trim())));
+		debugHealth("channel", {
+			id: plugin.id,
+			accountIds,
+			defaultAccountId,
+			boundAccounts,
+			preferredAccountId,
+			accountIdsToProbe
+		});
+		const accountSummaries = {};
+		for (const accountId of accountIdsToProbe) {
+			const { account, enabled, configured, diagnostics } = await resolveHealthAccountContext({
+				plugin,
+				cfg,
+				accountId
+			});
+			if (diagnostics.length > 0) debugHealth("account.diagnostics", {
+				channel: plugin.id,
+				accountId,
+				diagnostics
+			});
+			let probe;
+			let lastProbeAt = null;
+			if (enabled && configured && doProbe && plugin.status?.probeAccount) try {
+				probe = await plugin.status.probeAccount({
+					account,
+					timeoutMs: cappedTimeout,
+					cfg
+				});
+				lastProbeAt = Date.now();
+			} catch (err) {
+				probe = {
+					ok: false,
+					error: formatErrorMessage(err)
+				};
+				lastProbeAt = Date.now();
+			}
+			const probeRecord = probe && typeof probe === "object" ? probe : null;
+			const bot = probeRecord && typeof probeRecord.bot === "object" ? probeRecord.bot : null;
+			if (bot?.username) debugHealth("probe.bot", {
+				channel: plugin.id,
+				accountId,
+				username: bot.username
+			});
+			const snapshot = {
+				accountId,
+				enabled,
+				configured
+			};
+			if (probe !== void 0) snapshot.probe = probe;
+			if (lastProbeAt) snapshot.lastProbeAt = lastProbeAt;
+			const summary = plugin.status?.buildChannelSummary ? await plugin.status.buildChannelSummary({
+				account,
+				cfg,
+				defaultAccountId: accountId,
+				snapshot
+			}) : void 0;
+			const record = summary && typeof summary === "object" ? summary : {
+				accountId,
+				configured,
+				probe,
+				lastProbeAt
+			};
+			if (record.configured === void 0) record.configured = configured;
+			if (record.lastProbeAt === void 0 && lastProbeAt) record.lastProbeAt = lastProbeAt;
+			record.accountId = accountId;
+			accountSummaries[accountId] = record;
+		}
+		const fallbackSummary = accountSummaries[preferredAccountId] ?? accountSummaries[defaultAccountId] ?? accountSummaries[accountIdsToProbe[0] ?? preferredAccountId] ?? accountSummaries[Object.keys(accountSummaries)[0]];
+		if (fallbackSummary) channels[plugin.id] = {
+			...fallbackSummary,
+			accounts: accountSummaries
+		};
+	}
+	return {
+		ok: true,
+		ts: Date.now(),
+		durationMs: Date.now() - start,
+		channels,
+		channelOrder,
+		channelLabels,
+		heartbeatSeconds,
+		defaultAgentId,
+		agents,
+		sessions: {
+			path: sessions.path,
+			count: sessions.count,
+			recent: sessions.recent
+		}
+	};
+}
+async function healthCommand(opts, runtime) {
+	const cfg = opts.config ?? await readBestEffortHealthConfig();
+	const summary = await withProgress({
+		label: "Checking gateway health…",
+		indeterminate: true,
+		enabled: opts.json !== true
+	}, async () => await callGateway({
+		method: "health",
+		params: opts.verbose ? { probe: true } : void 0,
+		timeoutMs: opts.timeoutMs,
+		config: cfg
+	}));
+	if (opts.json) writeRuntimeJson(runtime, summary);
+	else {
+		const debugEnabled = isTruthyEnvValue(process.env.GENESIS_DEBUG_HEALTH);
+		const rich = isRich();
+		if (opts.verbose) logGatewayConnectionDetails({
+			runtime,
+			info,
+			message: buildGatewayConnectionDetails({ config: cfg }).message
+		});
+		const localAgents = resolveAgentOrder(cfg);
+		const defaultAgentId = summary.defaultAgentId ?? localAgents.defaultAgentId;
+		const agents = Array.isArray(summary.agents) ? summary.agents : [];
+		const fallbackAgents = [];
+		for (const entry of localAgents.ordered) {
+			const storePath = resolveStorePath(cfg.session?.store, { agentId: entry.id });
+			fallbackAgents.push({
+				agentId: entry.id,
+				name: entry.name,
+				isDefault: entry.id === localAgents.defaultAgentId,
+				heartbeat: resolveHeartbeatSummary(cfg, entry.id),
+				sessions: await buildSessionSummary(storePath)
+			});
+		}
+		const resolvedAgents = agents.length > 0 ? agents : fallbackAgents;
+		const displayAgents = opts.verbose ? resolvedAgents : resolvedAgents.filter((agent) => agent.agentId === defaultAgentId);
+		const channelBindings = buildChannelAccountBindings(cfg);
+		const displayPlugins = listReadOnlyChannelPluginsForConfig(cfg);
+		if (debugEnabled) {
+			runtime.log(info("[debug] local channel accounts"));
+			for (const plugin of displayPlugins) {
+				const accountIds = plugin.config.listAccountIds(cfg);
+				const defaultAccountId = resolveChannelDefaultAccountId({
+					plugin,
+					cfg,
+					accountIds
+				});
+				runtime.log(`  ${plugin.id}: accounts=${accountIds.join(", ") || "(none)"} default=${defaultAccountId}`);
+				for (const accountId of accountIds) {
+					const { account, configured, diagnostics } = await resolveHealthAccountContext({
+						plugin,
+						cfg,
+						accountId
+					});
+					const record = asNullableRecord(account);
+					const tokenSource = record && typeof record.tokenSource === "string" ? record.tokenSource : void 0;
+					runtime.log(`    - ${accountId}: configured=${configured}${tokenSource ? ` tokenSource=${tokenSource}` : ""}`);
+					for (const diagnostic of diagnostics) runtime.log(`      ! ${diagnostic}`);
+				}
+			}
+			runtime.log(info("[debug] bindings map"));
+			for (const [channelId, byAgent] of channelBindings.entries()) {
+				const entries = Array.from(byAgent.entries()).map(([agentId, ids]) => `${agentId}=[${ids.join(", ")}]`);
+				runtime.log(`  ${channelId}: ${entries.join(" ")}`);
+			}
+			runtime.log(info("[debug] gateway channel probes"));
+			for (const [channelId, channelSummary] of Object.entries(summary.channels ?? {})) {
+				const accounts = channelSummary.accounts ?? {};
+				const probes = Object.entries(accounts).map(([accountId, accountSummary]) => {
+					const probe = asNullableRecord(accountSummary.probe);
+					const bot = probe ? asNullableRecord(probe.bot) : null;
+					return `${accountId}=${(bot && typeof bot.username === "string" ? bot.username : null) ?? "(no bot)"}`;
+				});
+				runtime.log(`  ${channelId}: ${probes.join(", ") || "(none)"}`);
+			}
+		}
+		const channelAccountFallbacks = Object.fromEntries(displayPlugins.map((plugin) => {
+			const accountIds = plugin.config.listAccountIds(cfg);
+			const preferred = resolvePreferredAccountId({
+				accountIds,
+				defaultAccountId: resolveChannelDefaultAccountId({
+					plugin,
+					cfg,
+					accountIds
+				}),
+				boundAccounts: channelBindings.get(plugin.id)?.get(defaultAgentId) ?? []
+			});
+			return [plugin.id, [preferred]];
+		}));
+		const accountIdsByChannel = (() => {
+			const entries = displayAgents.length > 0 ? displayAgents : resolvedAgents;
+			const byChannel = {};
+			for (const [channelId, byAgent] of channelBindings.entries()) {
+				const accountIds = [];
+				for (const agent of entries) {
+					const ids = byAgent.get(agent.agentId) ?? [];
+					for (const id of ids) if (!accountIds.includes(id)) accountIds.push(id);
+				}
+				if (accountIds.length > 0) byChannel[channelId] = accountIds;
+			}
+			for (const [channelId, fallbackIds] of Object.entries(channelAccountFallbacks)) if (!byChannel[channelId] || byChannel[channelId].length === 0) byChannel[channelId] = fallbackIds;
+			return byChannel;
+		})();
+		const channelLines = Object.keys(accountIdsByChannel).length > 0 ? formatHealthChannelLines(summary, {
+			accountMode: opts.verbose ? "all" : "default",
+			accountIdsByChannel
+		}) : formatHealthChannelLines(summary, { accountMode: opts.verbose ? "all" : "default" });
+		for (const line of channelLines) runtime.log(styleHealthChannelLine(line, rich));
+		for (const plugin of displayPlugins) {
+			const channelSummary = summary.channels?.[plugin.id];
+			if (!channelSummary || channelSummary.linked !== true) continue;
+			if (!plugin.status?.logSelfId) continue;
+			const boundAccounts = channelBindings.get(plugin.id)?.get(defaultAgentId) ?? [];
+			const accountIds = plugin.config.listAccountIds(cfg);
+			const accountId = resolvePreferredAccountId({
+				accountIds,
+				defaultAccountId: resolveChannelDefaultAccountId({
+					plugin,
+					cfg,
+					accountIds
+				}),
+				boundAccounts
+			});
+			const accountContext = await resolveHealthAccountContext({
+				plugin,
+				cfg,
+				accountId
+			});
+			if (!accountContext.enabled || !accountContext.configured) continue;
+			if (accountContext.diagnostics.length > 0) continue;
+			try {
+				plugin.status.logSelfId({
+					account: accountContext.account,
+					cfg,
+					runtime,
+					includeChannelPrefix: true
+				});
+			} catch (error) {
+				debugHealth("logSelfId.failed", {
+					channel: plugin.id,
+					accountId,
+					error: formatErrorMessage(error)
+				});
+			}
+		}
+		if (resolvedAgents.length > 0) {
+			const agentLabels = resolvedAgents.map((agent) => agent.isDefault ? `${agent.agentId} (default)` : agent.agentId);
+			runtime.log(info(`Agents: ${agentLabels.join(", ")}`));
+		}
+		const heartbeatParts = displayAgents.map((agent) => {
+			const everyMs = agent.heartbeat?.everyMs;
+			return `${everyMs ? formatDurationParts(everyMs) : "disabled"} (${agent.agentId})`;
+		}).filter(Boolean);
+		if (heartbeatParts.length > 0) runtime.log(info(`Heartbeat interval: ${heartbeatParts.join(", ")}`));
+		if (displayAgents.length === 0) {
+			runtime.log(info(`Session store: ${summary.sessions.path} (${summary.sessions.count} entries)`));
+			if (summary.sessions.recent.length > 0) for (const r of summary.sessions.recent) runtime.log(`- ${r.key} (${r.updatedAt ? `${Math.round((Date.now() - r.updatedAt) / 6e4)}m ago` : "no activity"})`);
+		} else for (const agent of displayAgents) {
+			runtime.log(info(`Session store (${agent.agentId}): ${agent.sessions.path} (${agent.sessions.count} entries)`));
+			if (agent.sessions.recent.length > 0) for (const r of agent.sessions.recent) runtime.log(`- ${r.key} (${r.updatedAt ? `${Math.round((Date.now() - r.updatedAt) / 6e4)}m ago` : "no activity"})`);
+		}
+	}
+}
+async function readBestEffortHealthConfig() {
+	const { readBestEffortConfig } = await loadConfigModule();
+	return await readBestEffortConfig();
+}
+//#endregion
+export { healthCommand as n, getHealthSnapshot as t };

package/dist/heartbeat-runner-NuhhYnxs.js

@@ -0,0 +1,5 @@
+import { n as resolveHeartbeatIntervalMs, r as resolveHeartbeatSummaryForAgent, t as isHeartbeatEnabledForAgent } from "./heartbeat-summary-Dri6qdcY.js";
+import { i as setHeartbeatsEnabled, t as areHeartbeatsEnabled } from "./heartbeat-wake-CrIAzATu.js";
+import { r as isCronSystemEvent } from "./heartbeat-events-filter-CJtU_JvY.js";
+import { n as runHeartbeatOnce, r as startHeartbeatRunner, t as resolveHeartbeatPrompt } from "./heartbeat-runner-Y4NeUV3L.js";
+export { areHeartbeatsEnabled, isCronSystemEvent, isHeartbeatEnabledForAgent, resolveHeartbeatIntervalMs, resolveHeartbeatPrompt, resolveHeartbeatSummaryForAgent, runHeartbeatOnce, setHeartbeatsEnabled, startHeartbeatRunner };