@pixelzx/genesis 2026.5.5-3 → 2026.5.5-4

package/dist/lifecycle-DJidJ8WM.js

@@ -0,0 +1,229 @@
+import { c as normalizeOptionalString } from "./string-coerce-C1IzJjqi.js";
+import { n as defaultRuntime } from "./runtime-CQ7eH0le.js";
+import { r as theme } from "./theme-BrRleVfL.js";
+import { t as formatCliCommand } from "./command-format-DAeUlu7u.js";
+import { u as resolveGatewayPort } from "./paths-DmR9mjUX.js";
+import { l as readBestEffortConfig } from "./io-DNd8mbjy.js";
+import { i as launchAgentPlistExists, s as repairLaunchAgentBootstrap } from "./launchd-OykeouWG.js";
+import { d as formatGatewayPidList, f as signalVerifiedGatewayPidSync, u as findVerifiedGatewayListenerPidsOnPortSync } from "./schtasks-Dig0WvsR.js";
+import { r as resolveGatewayService } from "./service-D6nRIQp0.js";
+import { l as renderGatewayServiceStartHints, s as parsePortFromArgs } from "./shared-BdZN5DvO.js";
+import { n as isRestartEnabled } from "./commands.flags-CR-1vURU.js";
+import "./config-3He3LWHw.js";
+import { a as probeGateway } from "./probe-CakOsrSu.js";
+import { i as runServiceUninstall, n as runServiceStart, r as runServiceStop, t as runServiceRestart } from "./lifecycle-core-DCeS7I2A.js";
+import { a as renderGatewayPortHealthDiagnostics, c as waitForGatewayHealthyListener, l as waitForGatewayHealthyRestart, o as renderRestartDiagnostics, s as terminateStaleGatewayPids, t as DEFAULT_RESTART_HEALTH_ATTEMPTS } from "./restart-health-BWUPc4R-.js";
+//#region src/cli/daemon-cli/launchd-recovery.ts
+const LAUNCH_AGENT_RECOVERY_MESSAGE = "Gateway LaunchAgent was installed but not loaded; re-bootstrapped launchd service.";
+async function recoverInstalledLaunchAgent(params) {
+	if (process.platform !== "darwin") return null;
+	const env = params.env ?? process.env;
+	if (!await launchAgentPlistExists(env).catch(() => false)) return null;
+	if (!(await repairLaunchAgentBootstrap({ env }).catch(() => ({
+		ok: false,
+		status: "bootstrap-failed"
+	}))).ok) return null;
+	return {
+		result: params.result,
+		loaded: true,
+		message: LAUNCH_AGENT_RECOVERY_MESSAGE
+	};
+}
+//#endregion
+//#region src/cli/daemon-cli/lifecycle.ts
+const POST_RESTART_HEALTH_ATTEMPTS = DEFAULT_RESTART_HEALTH_ATTEMPTS;
+const POST_RESTART_HEALTH_DELAY_MS = 500;
+const WINDOWS_POST_RESTART_HEALTH_TIMEOUT_MS = 18e4;
+function postRestartHealthAttempts() {
+	return process.platform === "win32" ? Math.ceil(WINDOWS_POST_RESTART_HEALTH_TIMEOUT_MS / POST_RESTART_HEALTH_DELAY_MS) : POST_RESTART_HEALTH_ATTEMPTS;
+}
+function formatRestartFailure(params) {
+	if (params.health.waitOutcome === "stopped-free") {
+		const elapsedSeconds = Math.max(1, Math.round((params.health.elapsedMs ?? 0) / 1e3));
+		return {
+			statusLine: `Gateway restart failed after ${elapsedSeconds}s: service stayed stopped and port ${params.port} stayed free.`,
+			failMessage: `Gateway restart failed after ${elapsedSeconds}s: service stayed stopped and health checks never came up.`
+		};
+	}
+	return {
+		statusLine: `Timed out after ${params.timeoutSeconds}s waiting for gateway port ${params.port} to become healthy.`,
+		failMessage: `Gateway restart timed out after ${params.timeoutSeconds}s waiting for health checks.`
+	};
+}
+async function resolveGatewayLifecyclePort(service = resolveGatewayService()) {
+	const command = await service.readCommand(process.env).catch(() => null);
+	const serviceEnv = command?.environment ?? void 0;
+	const mergedEnv = {
+		...process.env,
+		...serviceEnv ?? void 0
+	};
+	return parsePortFromArgs(command?.programArguments) ?? resolveGatewayPort(await readBestEffortConfig(), mergedEnv);
+}
+function resolveGatewayPortFallback() {
+	return readBestEffortConfig().then((cfg) => resolveGatewayPort(cfg, process.env)).catch(() => resolveGatewayPort(void 0, process.env));
+}
+async function assertUnmanagedGatewayRestartEnabled(port) {
+	const probe = await probeGateway({
+		url: `${!!(await readBestEffortConfig().catch(() => void 0))?.gateway?.tls?.enabled ? "wss" : "ws"}://127.0.0.1:${port}`,
+		auth: {
+			token: normalizeOptionalString(process.env.GENESIS_GATEWAY_TOKEN),
+			password: normalizeOptionalString(process.env.GENESIS_GATEWAY_PASSWORD)
+		},
+		timeoutMs: 1e3
+	}).catch(() => null);
+	if (!probe?.ok) return;
+	if (!isRestartEnabled(probe.configSnapshot)) throw new Error("Gateway restart is disabled in the running gateway config (commands.restart=false); unmanaged SIGUSR1 restart would be ignored");
+}
+function resolveVerifiedGatewayListenerPids(port) {
+	return findVerifiedGatewayListenerPidsOnPortSync(port).filter((pid) => Number.isFinite(pid) && pid > 0);
+}
+async function stopGatewayWithoutServiceManager(port) {
+	const pids = resolveVerifiedGatewayListenerPids(port);
+	if (pids.length === 0) return null;
+	for (const pid of pids) signalVerifiedGatewayPidSync(pid, "SIGTERM");
+	return {
+		result: "stopped",
+		message: `Gateway stop signal sent to unmanaged process${pids.length === 1 ? "" : "es"} on port ${port}: ${formatGatewayPidList(pids)}.`
+	};
+}
+async function restartGatewayWithoutServiceManager(port) {
+	await assertUnmanagedGatewayRestartEnabled(port);
+	const pids = resolveVerifiedGatewayListenerPids(port);
+	if (pids.length === 0) return null;
+	if (pids.length > 1) throw new Error(`multiple gateway processes are listening on port ${port}: ${formatGatewayPidList(pids)}; use "genesis gateway status --deep" before retrying restart`);
+	signalVerifiedGatewayPidSync(pids[0], "SIGUSR1");
+	return {
+		result: "restarted",
+		message: `Gateway restart signal sent to unmanaged process on port ${port}: ${pids[0]}.`
+	};
+}
+async function runDaemonUninstall(opts = {}) {
+	return await runServiceUninstall({
+		serviceNoun: "Gateway",
+		service: resolveGatewayService(),
+		opts,
+		stopBeforeUninstall: true,
+		assertNotLoadedAfterUninstall: true
+	});
+}
+async function runDaemonStart(opts = {}) {
+	return await runServiceStart({
+		serviceNoun: "Gateway",
+		service: resolveGatewayService(),
+		renderStartHints: renderGatewayServiceStartHints,
+		onNotLoaded: process.platform === "darwin" ? async () => await recoverInstalledLaunchAgent({ result: "started" }) : void 0,
+		opts
+	});
+}
+async function runDaemonStop(opts = {}) {
+	const service = resolveGatewayService();
+	let gatewayPortPromise;
+	return await runServiceStop({
+		serviceNoun: "Gateway",
+		service,
+		opts,
+		onNotLoaded: async () => {
+			gatewayPortPromise ??= resolveGatewayLifecyclePort(service).catch(() => resolveGatewayPortFallback());
+			return await stopGatewayWithoutServiceManager(await gatewayPortPromise);
+		}
+	});
+}
+/**
+* Restart the gateway service service.
+* @returns `true` if restart succeeded, `false` if the service was not loaded.
+* Throws/exits on check or restart failures.
+*/
+async function runDaemonRestart(opts = {}) {
+	const json = Boolean(opts.json);
+	const service = resolveGatewayService();
+	let restartedWithoutServiceManager = false;
+	const restartPort = await resolveGatewayLifecyclePort(service).catch(() => resolveGatewayPortFallback());
+	const restartHealthAttempts = postRestartHealthAttempts();
+	const restartWaitMs = restartHealthAttempts * POST_RESTART_HEALTH_DELAY_MS;
+	const restartWaitSeconds = Math.round(restartWaitMs / 1e3);
+	return await runServiceRestart({
+		serviceNoun: "Gateway",
+		service,
+		renderStartHints: renderGatewayServiceStartHints,
+		opts,
+		checkTokenDrift: true,
+		onNotLoaded: async () => {
+			const handled = await restartGatewayWithoutServiceManager(restartPort);
+			if (handled) {
+				restartedWithoutServiceManager = true;
+				return handled;
+			}
+			return await recoverInstalledLaunchAgent({ result: "restarted" });
+		},
+		postRestartCheck: async ({ warnings, fail, stdout }) => {
+			if (restartedWithoutServiceManager) {
+				const health = await waitForGatewayHealthyListener({
+					port: restartPort,
+					attempts: restartHealthAttempts,
+					delayMs: POST_RESTART_HEALTH_DELAY_MS
+				});
+				if (health.healthy) return;
+				const diagnostics = renderGatewayPortHealthDiagnostics(health);
+				const timeoutLine = `Timed out after ${restartWaitSeconds}s waiting for gateway port ${restartPort} to become healthy.`;
+				if (!json) {
+					defaultRuntime.log(theme.warn(timeoutLine));
+					for (const line of diagnostics) defaultRuntime.log(theme.muted(line));
+				} else {
+					warnings.push(timeoutLine);
+					warnings.push(...diagnostics);
+				}
+				fail(`Gateway restart timed out after ${restartWaitSeconds}s waiting for health checks.`, [formatCliCommand("genesis gateway status --deep"), formatCliCommand("genesis doctor")]);
+				throw new Error("unreachable after gateway restart health failure");
+			}
+			let health = await waitForGatewayHealthyRestart({
+				service,
+				port: restartPort,
+				attempts: restartHealthAttempts,
+				delayMs: POST_RESTART_HEALTH_DELAY_MS,
+				includeUnknownListenersAsStale: process.platform === "win32"
+			});
+			if (!health.healthy && health.staleGatewayPids.length > 0) {
+				const staleMsg = `Found stale gateway process(es): ${health.staleGatewayPids.join(", ")}.`;
+				warnings.push(staleMsg);
+				if (!json) {
+					defaultRuntime.log(theme.warn(staleMsg));
+					defaultRuntime.log(theme.muted("Stopping stale process(es) and retrying restart..."));
+				}
+				await terminateStaleGatewayPids(health.staleGatewayPids);
+				const retryRestart = await service.restart({
+					env: process.env,
+					stdout
+				});
+				if (retryRestart.outcome === "scheduled") return retryRestart;
+				health = await waitForGatewayHealthyRestart({
+					service,
+					port: restartPort,
+					attempts: restartHealthAttempts,
+					delayMs: POST_RESTART_HEALTH_DELAY_MS,
+					includeUnknownListenersAsStale: process.platform === "win32"
+				});
+			}
+			if (health.healthy) return;
+			const diagnostics = renderRestartDiagnostics(health);
+			const failure = formatRestartFailure({
+				health,
+				port: restartPort,
+				timeoutSeconds: restartWaitSeconds
+			});
+			const runningNoPortLine = health.runtime.status === "running" && health.portUsage.status === "free" ? `Gateway process is running but port ${restartPort} is still free (startup hang/crash loop or very slow VM startup).` : null;
+			if (!json) {
+				defaultRuntime.log(theme.warn(failure.statusLine));
+				if (runningNoPortLine) defaultRuntime.log(theme.warn(runningNoPortLine));
+				for (const line of diagnostics) defaultRuntime.log(theme.muted(line));
+			} else {
+				warnings.push(failure.statusLine);
+				if (runningNoPortLine) warnings.push(runningNoPortLine);
+				warnings.push(...diagnostics);
+			}
+			fail(failure.failMessage, [formatCliCommand("genesis gateway status --deep"), formatCliCommand("genesis doctor")]);
+			throw new Error("unreachable after gateway restart failure");
+		}
+	});
+}
+//#endregion
+export { runDaemonUninstall as i, runDaemonStart as n, runDaemonStop as r, runDaemonRestart as t };

package/dist/lifecycle-core-DCeS7I2A.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-D6nRIQp0.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-FsztusUk.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-DWcLMs_A.js

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

package/dist/lifecycle.runtime.js

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

package/dist/list-BZ3mMSpA.js

@@ -0,0 +1,2 @@
+import { t as channelsListCommand } from "./list-CzQs_k0U.js";
+export { channelsListCommand };