@pixelzx/genesis 2026.5.5-2 → 2026.5.5-3

package/dist/lifecycle-core-CTjCo-k0.js

@@ -0,0 +1,422 @@
+import { n as defaultRuntime } from "./runtime-CQ7eH0le.js";
+import { d as resolveIsNixMode } from "./paths-DmR9mjUX.js";
+import { t as createGatewayCredentialPlan } from "./credential-planner-Bf6MFQ6Y.js";
+import { n as isGatewaySecretRefUnavailableError, t as GatewaySecretRefUnavailableError } from "./credentials-C7JHJpIV.js";
+import { t as resolveGatewayAuthToken } from "./auth-token-resolution-B0f5W3e0.js";
+import { l as readBestEffortConfig, u as readConfigFileSnapshot } from "./io-DNd8mbjy.js";
+import { i as isSystemdUserServiceAvailable } from "./systemd-BmENWaxT.js";
+import { i as startGatewayService, t as describeGatewayServiceRestart } from "./service-CyR3mZIU.js";
+import { i as filterContainerGenericHints, m as createDaemonActionContext, p as buildDaemonServiceSnapshot } from "./shared-BdZN5DvO.js";
+import "./config-3He3LWHw.js";
+import { n as formatConfigIssueLines } from "./issue-format-CctGyTV-.js";
+import { r as checkTokenDrift } from "./service-audit-DIL0OiMa.js";
+import { n as renderSystemdUnavailableHints } from "./systemd-hints-CJxKhtPZ.js";
+import { t as isWSL } from "./wsl-Be1oClcA.js";
+//#region src/cli/daemon-cli/gateway-token-drift.ts
+function authModeDisablesToken(mode) {
+	return mode === "password" || mode === "none" || mode === "trusted-proxy";
+}
+function isPasswordFallbackActive(params) {
+	const plan = createGatewayCredentialPlan({
+		config: params.cfg,
+		env: params.env
+	});
+	if (plan.authMode !== void 0) return false;
+	return plan.passwordCanWin && !plan.tokenCanWin;
+}
+async function resolveGatewayTokenForDriftCheck(params) {
+	const env = params.env ?? process.env;
+	const mode = params.cfg.gateway?.auth?.mode;
+	if (authModeDisablesToken(mode)) return;
+	if (isPasswordFallbackActive({
+		cfg: params.cfg,
+		env
+	})) return;
+	const resolved = await resolveGatewayAuthToken({
+		cfg: params.cfg,
+		env,
+		envFallback: "never",
+		unresolvedReasonStyle: "detailed"
+	});
+	if (resolved.token) return resolved.token;
+	if (!resolved.secretRefConfigured) return;
+	throw new GatewaySecretRefUnavailableError("gateway.auth.token");
+}
+//#endregion
+//#region src/cli/daemon-cli/lifecycle-core.ts
+async function maybeAugmentSystemdHints(hints) {
+	if (process.platform !== "linux") return hints;
+	if (await isSystemdUserServiceAvailable().catch(() => false)) return hints;
+	return [...hints, ...renderSystemdUnavailableHints({
+		wsl: await isWSL(),
+		kind: "generic_unavailable"
+	})];
+}
+function emitActionMessage(params) {
+	params.emit(params.payload);
+	if (!params.json && params.payload.message) defaultRuntime.log(params.payload.message);
+}
+async function handleServiceNotLoaded(params) {
+	const hints = filterContainerGenericHints(await maybeAugmentSystemdHints(params.renderStartHints()));
+	params.emit({
+		ok: true,
+		result: "not-loaded",
+		message: `${params.serviceNoun} service ${params.service.notLoadedText}.`,
+		hints,
+		service: buildDaemonServiceSnapshot(params.service, params.loaded)
+	});
+	if (!params.json) {
+		defaultRuntime.log(`${params.serviceNoun} service ${params.service.notLoadedText}.`);
+		for (const hint of hints) defaultRuntime.log(`Start with: ${hint}`);
+	}
+}
+async function resolveServiceLoadedOrFail(params) {
+	try {
+		return await params.service.isLoaded({ env: process.env });
+	} catch (err) {
+		params.fail(`${params.serviceNoun} service check failed: ${String(err)}`);
+		return null;
+	}
+}
+/**
+* Best-effort config validation. Returns a string describing the issues if
+* config exists and is invalid, or null if config is valid/missing/unreadable.
+*
+* Note: This reads the config file snapshot in the current CLI environment.
+* Configs using env vars only available in the service context (launchd/systemd)
+* may produce false positives, but the check is intentionally best-effort —
+* a false positive here is safer than a crash on startup. (#35862)
+*/
+async function getConfigValidationError() {
+	try {
+		const snapshot = await readConfigFileSnapshot();
+		if (!snapshot.exists || snapshot.valid) return null;
+		return snapshot.issues.length > 0 ? formatConfigIssueLines(snapshot.issues, "", { normalizeRoot: true }).join("\n") : "Unknown validation issue.";
+	} catch {
+		return null;
+	}
+}
+async function runServiceUninstall(params) {
+	const { stdout, emit, fail } = createDaemonActionContext({
+		action: "uninstall",
+		json: Boolean(params.opts?.json)
+	});
+	if (resolveIsNixMode(process.env)) {
+		fail("Nix mode detected; service uninstall is disabled.");
+		return;
+	}
+	let loaded = false;
+	try {
+		loaded = await params.service.isLoaded({ env: process.env });
+	} catch {
+		loaded = false;
+	}
+	if (loaded && params.stopBeforeUninstall) try {
+		await params.service.stop({
+			env: process.env,
+			stdout
+		});
+	} catch {}
+	try {
+		await params.service.uninstall({
+			env: process.env,
+			stdout
+		});
+	} catch (err) {
+		fail(`${params.serviceNoun} uninstall failed: ${String(err)}`);
+		return;
+	}
+	loaded = false;
+	try {
+		loaded = await params.service.isLoaded({ env: process.env });
+	} catch {
+		loaded = false;
+	}
+	if (loaded && params.assertNotLoadedAfterUninstall) {
+		fail(`${params.serviceNoun} service still loaded after uninstall.`);
+		return;
+	}
+	emit({
+		ok: true,
+		result: "uninstalled",
+		service: buildDaemonServiceSnapshot(params.service, loaded)
+	});
+}
+async function runServiceStart(params) {
+	const json = Boolean(params.opts?.json);
+	const { stdout, emit, fail } = createDaemonActionContext({
+		action: "start",
+		json
+	});
+	const loaded = await resolveServiceLoadedOrFail({
+		serviceNoun: params.serviceNoun,
+		service: params.service,
+		fail
+	});
+	if (loaded === null) return;
+	{
+		const configError = await getConfigValidationError();
+		if (configError) {
+			fail(`${params.serviceNoun} aborted: config is invalid.\n${configError}\nFix the config and retry, or run "genesis doctor" to repair.`);
+			return;
+		}
+	}
+	if (!loaded) try {
+		const handled = await params.onNotLoaded?.({
+			json,
+			stdout,
+			fail
+		});
+		if (handled) {
+			emit({
+				ok: true,
+				result: handled.result,
+				message: handled.message,
+				warnings: handled.warnings,
+				service: buildDaemonServiceSnapshot(params.service, handled.loaded ?? false)
+			});
+			if (!json && handled.message) defaultRuntime.log(handled.message);
+			return;
+		}
+	} catch (err) {
+		const hints = params.renderStartHints();
+		fail(`${params.serviceNoun} start failed: ${String(err)}`, hints);
+		return;
+	}
+	try {
+		const startResult = await startGatewayService(params.service, {
+			env: process.env,
+			stdout
+		});
+		if (startResult.outcome === "missing-install") {
+			await handleServiceNotLoaded({
+				serviceNoun: params.serviceNoun,
+				service: params.service,
+				loaded: startResult.state.loaded,
+				renderStartHints: params.renderStartHints,
+				json,
+				emit
+			});
+			return;
+		}
+		if (startResult.outcome === "scheduled") {
+			emitActionMessage({
+				json,
+				emit,
+				payload: {
+					ok: true,
+					result: "scheduled",
+					message: describeGatewayServiceRestart(params.serviceNoun, { outcome: "scheduled" }).message,
+					service: buildDaemonServiceSnapshot(params.service, startResult.state.loaded)
+				}
+			});
+			return;
+		}
+		emit({
+			ok: true,
+			result: "started",
+			service: buildDaemonServiceSnapshot(params.service, startResult.state.loaded)
+		});
+	} catch (err) {
+		const hints = params.renderStartHints();
+		fail(`${params.serviceNoun} start failed: ${String(err)}`, hints);
+		return;
+	}
+}
+async function runServiceStop(params) {
+	const json = Boolean(params.opts?.json);
+	const { stdout, emit, fail } = createDaemonActionContext({
+		action: "stop",
+		json
+	});
+	const loaded = await resolveServiceLoadedOrFail({
+		serviceNoun: params.serviceNoun,
+		service: params.service,
+		fail
+	});
+	if (loaded === null) return;
+	if (!loaded) {
+		try {
+			const handled = await params.onNotLoaded?.({
+				json,
+				stdout,
+				fail
+			});
+			if (handled) {
+				emit({
+					ok: true,
+					result: handled.result,
+					message: handled.message,
+					warnings: handled.warnings,
+					service: buildDaemonServiceSnapshot(params.service, false)
+				});
+				if (!json && handled.message) defaultRuntime.log(handled.message);
+				return;
+			}
+		} catch (err) {
+			fail(`${params.serviceNoun} stop failed: ${String(err)}`);
+			return;
+		}
+		emit({
+			ok: true,
+			result: "not-loaded",
+			message: `${params.serviceNoun} service ${params.service.notLoadedText}.`,
+			service: buildDaemonServiceSnapshot(params.service, loaded)
+		});
+		if (!json) defaultRuntime.log(`${params.serviceNoun} service ${params.service.notLoadedText}.`);
+		return;
+	}
+	try {
+		await params.service.stop({
+			env: process.env,
+			stdout
+		});
+	} catch (err) {
+		fail(`${params.serviceNoun} stop failed: ${String(err)}`);
+		return;
+	}
+	let stopped = false;
+	try {
+		stopped = await params.service.isLoaded({ env: process.env });
+	} catch {
+		stopped = false;
+	}
+	emit({
+		ok: true,
+		result: "stopped",
+		service: buildDaemonServiceSnapshot(params.service, stopped)
+	});
+}
+async function runServiceRestart(params) {
+	const json = Boolean(params.opts?.json);
+	const { stdout, emit, fail } = createDaemonActionContext({
+		action: "restart",
+		json
+	});
+	const warnings = [];
+	let handledRecovery = null;
+	let recoveredLoadedState = null;
+	const emitScheduledRestart = (restartStatus, serviceLoaded) => {
+		emitActionMessage({
+			json,
+			emit,
+			payload: {
+				ok: true,
+				result: restartStatus.daemonActionResult,
+				message: restartStatus.message,
+				service: buildDaemonServiceSnapshot(params.service, serviceLoaded),
+				warnings: warnings.length ? warnings : void 0
+			}
+		});
+		return true;
+	};
+	const loaded = await resolveServiceLoadedOrFail({
+		serviceNoun: params.serviceNoun,
+		service: params.service,
+		fail
+	});
+	if (loaded === null) return false;
+	{
+		const configError = await getConfigValidationError();
+		if (configError) {
+			fail(`${params.serviceNoun} aborted: config is invalid.\n${configError}\nFix the config and retry, or run "genesis doctor" to repair.`);
+			return false;
+		}
+	}
+	if (!loaded) {
+		try {
+			handledRecovery = await params.onNotLoaded?.({
+				json,
+				stdout,
+				fail
+			}) ?? null;
+		} catch (err) {
+			fail(`${params.serviceNoun} restart failed: ${String(err)}`);
+			return false;
+		}
+		if (!handledRecovery) {
+			await handleServiceNotLoaded({
+				serviceNoun: params.serviceNoun,
+				service: params.service,
+				loaded,
+				renderStartHints: params.renderStartHints,
+				json,
+				emit
+			});
+			return false;
+		}
+		if (handledRecovery.warnings?.length) warnings.push(...handledRecovery.warnings);
+		recoveredLoadedState = handledRecovery.loaded ?? null;
+	}
+	if (loaded && params.checkTokenDrift) try {
+		const command = await params.service.readCommand(process.env);
+		const serviceToken = command?.environment?.GENESIS_GATEWAY_TOKEN;
+		const driftIssue = checkTokenDrift({
+			serviceToken,
+			configToken: await resolveGatewayTokenForDriftCheck({
+				cfg: await readBestEffortConfig(),
+				env: {
+					...process.env,
+					...command?.environment
+				}
+			})
+		});
+		if (driftIssue) {
+			const warning = driftIssue.detail ? `${driftIssue.message} ${driftIssue.detail}` : driftIssue.message;
+			warnings.push(warning);
+			if (!json) {
+				defaultRuntime.log(`\n⚠️  ${driftIssue.message}`);
+				if (driftIssue.detail) defaultRuntime.log(`   ${driftIssue.detail}\n`);
+			}
+		}
+	} catch (err) {
+		if (isGatewaySecretRefUnavailableError(err, "gateway.auth.token")) {
+			const warning = "Unable to verify gateway token drift: gateway.auth.token SecretRef is configured but unavailable in this command path.";
+			warnings.push(warning);
+			if (!json) defaultRuntime.log(`\n⚠️  ${warning}\n`);
+		}
+	}
+	try {
+		let restartResult = { outcome: "completed" };
+		if (loaded) restartResult = await params.service.restart({
+			env: process.env,
+			stdout
+		});
+		let restartStatus = describeGatewayServiceRestart(params.serviceNoun, restartResult);
+		if (restartStatus.scheduled) return emitScheduledRestart(restartStatus, loaded || recoveredLoadedState === true);
+		if (params.postRestartCheck) {
+			const postRestartResult = await params.postRestartCheck({
+				json,
+				stdout,
+				warnings,
+				fail
+			});
+			if (postRestartResult) {
+				restartStatus = describeGatewayServiceRestart(params.serviceNoun, postRestartResult);
+				if (restartStatus.scheduled) return emitScheduledRestart(restartStatus, loaded || recoveredLoadedState === true);
+			}
+		}
+		let restarted = loaded;
+		if (loaded) try {
+			restarted = await params.service.isLoaded({ env: process.env });
+		} catch {
+			restarted = true;
+		}
+		else if (recoveredLoadedState !== null) restarted = recoveredLoadedState;
+		emit({
+			ok: true,
+			result: "restarted",
+			message: handledRecovery?.message,
+			service: buildDaemonServiceSnapshot(params.service, restarted),
+			warnings: warnings.length ? warnings : void 0
+		});
+		if (!json && handledRecovery?.message) defaultRuntime.log(handledRecovery.message);
+		return true;
+	} catch (err) {
+		const hints = params.renderStartHints();
+		fail(`${params.serviceNoun} restart failed: ${String(err)}`, hints);
+		return false;
+	}
+}
+//#endregion
+export { runServiceUninstall as i, runServiceStart as n, runServiceStop as r, runServiceRestart as t };

package/dist/lifecycle.runtime-BxpD2Ol7.js

@@ -0,0 +1,2 @@
+import { i as runDaemonUninstall, n as runDaemonStart, r as runDaemonStop, t as runDaemonRestart } from "./lifecycle-B_RLw4uY.js";
+export { runDaemonRestart, runDaemonStart, runDaemonStop, runDaemonUninstall };

package/dist/lifecycle.runtime.js

@@ -1 +1 @@
-export * from "./lifecycle.runtime-9oo2JCI2.js";
+export * from "./lifecycle.runtime-BxpD2Ol7.js";

package/dist/list-BXa4zUF-.js

@@ -0,0 +1,2 @@
+import { n as modelsListCommand, t as modelsStatusCommand } from "./list-CgC_rsta.js";
+export { modelsListCommand, modelsStatusCommand };

package/dist/list-BugTSXmQ.js

@@ -0,0 +1,131 @@
+import { n as defaultRuntime, r as writeRuntimeJson } from "./runtime-CQ7eH0le.js";
+import { t as formatDocsLink } from "./links-DmsJCU7L.js";
+import { r as theme } from "./theme-BrRleVfL.js";
+import { n as isChannelVisibleInConfiguredLists } from "./channel-meta-BEaGWV3f.js";
+import { l as loadAuthProfileStoreWithoutExternalProfiles } from "./store-zVJHt5-N.js";
+import "./auth-profiles-qkJp8etH.js";
+import { t as listReadOnlyChannelPluginsForConfig } from "./read-only-Bc9RJswo.js";
+import { n as withProgress } from "./progress-C6QDkZMg.js";
+import { t as formatUsageReportLines } from "./provider-usage-DkdPMGc6.js";
+import { t as loadProviderUsageSummary } from "./provider-usage.load-Ckz1tFpH.js";
+import { c as requireValidConfig, s as formatChannelAccountLabel } from "./shared-DJU_HCJ1.js";
+import { t as buildChannelAccountSnapshot } from "./status-DLLzNv5C.js";
+//#region src/commands/channels/list.ts
+const colorValue = (value) => {
+	if (value === "none") return theme.error(value);
+	if (value === "env") return theme.accent(value);
+	return theme.success(value);
+};
+function formatEnabled(value) {
+	return value === false ? theme.error("disabled") : theme.success("enabled");
+}
+function formatConfigured(value) {
+	return value ? theme.success("configured") : theme.warn("not configured");
+}
+function formatTokenSource(source) {
+	return `token=${colorValue(source || "none")}`;
+}
+function formatSource(label, source) {
+	return `${label}=${colorValue(source || "none")}`;
+}
+function formatLinked(value) {
+	return value ? theme.success("linked") : theme.warn("not linked");
+}
+function shouldShowConfigured(channel) {
+	return isChannelVisibleInConfiguredLists(channel.meta);
+}
+function formatAccountLine(params) {
+	const { channel, snapshot } = params;
+	const label = formatChannelAccountLabel({
+		channel: channel.id,
+		accountId: snapshot.accountId,
+		name: snapshot.name,
+		channelStyle: theme.accent,
+		accountStyle: theme.heading
+	});
+	const bits = [];
+	if (snapshot.linked !== void 0) bits.push(formatLinked(snapshot.linked));
+	if (shouldShowConfigured(channel) && typeof snapshot.configured === "boolean") bits.push(formatConfigured(snapshot.configured));
+	if (snapshot.tokenSource) bits.push(formatTokenSource(snapshot.tokenSource));
+	if (snapshot.botTokenSource) bits.push(formatSource("bot", snapshot.botTokenSource));
+	if (snapshot.appTokenSource) bits.push(formatSource("app", snapshot.appTokenSource));
+	if (snapshot.baseUrl) bits.push(`base=${theme.muted(snapshot.baseUrl)}`);
+	if (typeof snapshot.enabled === "boolean") bits.push(formatEnabled(snapshot.enabled));
+	return `- ${label}: ${bits.join(", ")}`;
+}
+async function loadUsageWithProgress(runtime) {
+	try {
+		return await withProgress({
+			label: "Fetching usage snapshot…",
+			indeterminate: true,
+			enabled: true
+		}, async () => await loadProviderUsageSummary({ skipPluginAuthWithoutCredentialSource: true }));
+	} catch (err) {
+		runtime.error(String(err));
+		return null;
+	}
+}
+async function channelsListCommand(opts, runtime = defaultRuntime) {
+	const cfg = await requireValidConfig(runtime);
+	if (!cfg) return;
+	const includeUsage = opts.usage !== false;
+	const plugins = listReadOnlyChannelPluginsForConfig(cfg);
+	const authStore = loadAuthProfileStoreWithoutExternalProfiles();
+	const authProfiles = Object.entries(authStore.profiles).map(([profileId, profile]) => ({
+		id: profileId,
+		provider: profile.provider,
+		type: profile.type,
+		isExternal: false
+	}));
+	if (opts.json) {
+		const usage = includeUsage ? await loadProviderUsageSummary({ skipPluginAuthWithoutCredentialSource: true }) : void 0;
+		const chat = {};
+		for (const plugin of plugins) chat[plugin.id] = plugin.config.listAccountIds(cfg);
+		writeRuntimeJson(runtime, {
+			chat,
+			auth: authProfiles,
+			...usage ? { usage } : {}
+		});
+		return;
+	}
+	const lines = [];
+	lines.push(theme.heading("Chat channels:"));
+	for (const plugin of plugins) {
+		const accounts = plugin.config.listAccountIds(cfg);
+		if (!accounts || accounts.length === 0) continue;
+		for (const accountId of accounts) {
+			const snapshot = await buildChannelAccountSnapshot({
+				plugin,
+				cfg,
+				accountId
+			});
+			lines.push(formatAccountLine({
+				channel: plugin,
+				snapshot
+			}));
+		}
+	}
+	lines.push("");
+	lines.push(theme.heading("Auth providers (OAuth + API keys):"));
+	if (authProfiles.length === 0) lines.push(theme.muted("- none"));
+	else for (const profile of authProfiles) {
+		const external = profile.isExternal ? theme.muted(" (synced)") : "";
+		lines.push(`- ${theme.accent(profile.id)} (${theme.success(profile.type)}${external})`);
+	}
+	runtime.log(lines.join("\n"));
+	if (includeUsage) {
+		runtime.log("");
+		const usage = await loadUsageWithProgress(runtime);
+		if (usage) {
+			const usageLines = formatUsageReportLines(usage);
+			if (usageLines.length > 0) {
+				usageLines[0] = theme.accent(usageLines[0]);
+				runtime.log(usageLines.join("\n"));
+			}
+		}
+	}
+	runtime.log("");
+	runtime.log(`Docs: ${formatDocsLink("/gateway/configuration", "gateway/configuration")}`);
+}
+//#endregion
+export { channelsListCommand as t };