@pixelzx/genesis 2026.5.5-4 → 2026.5.5-5

package/dist/prepare.runtime.js

@@ -1 +1 @@
-export * from "./prepare.runtime-BfnpyhHB.js";
+export * from "./prepare.runtime-DDAttJh0.js";

package/dist/probe-A3zmoqnI.js

@@ -0,0 +1,241 @@
+import { i as formatErrorMessage } from "./errors-Jbvi20TW.js";
+import { a as isLoopbackHost } from "./net-AycWGi8-.js";
+import { n as resolveSafeTimeoutDelayMs, t as MAX_SAFE_TIMEOUT_DELAY_MS } from "./timer-delay-Co_I1iPe.js";
+import { n as GatewayClientRequestError, t as GatewayClient } from "./client-B0QJbO9O.js";
+import { i as GATEWAY_CLIENT_NAMES, r as GATEWAY_CLIENT_MODES } from "./client-info-CfESmEX1.js";
+import { l as READ_SCOPE } from "./method-scopes-CVKEoi44.js";
+import { randomUUID } from "node:crypto";
+//#region src/gateway/probe.ts
+const MIN_PROBE_TIMEOUT_MS = 250;
+const MAX_TIMER_DELAY_MS = MAX_SAFE_TIMEOUT_DELAY_MS;
+const PAIRING_REQUIRED_PATTERN = /\bpairing required\b/i;
+const OPERATOR_READ_SCOPE = "operator.read";
+const OPERATOR_WRITE_SCOPE = "operator.write";
+const OPERATOR_ADMIN_SCOPE = "operator.admin";
+function clampProbeTimeoutMs(timeoutMs) {
+	return resolveSafeTimeoutDelayMs(timeoutMs, { minMs: 250 });
+}
+function formatProbeCloseError(close) {
+	return `gateway closed (${close.code}): ${close.reason}`;
+}
+function emptyProbeAuth() {
+	return {
+		role: null,
+		scopes: [],
+		capability: "unknown"
+	};
+}
+function resolveProbeAuthSummary(params) {
+	const scopes = Array.isArray(params.scopes) ? params.scopes : [];
+	return {
+		role: params.role ?? null,
+		scopes,
+		capability: resolveGatewayProbeCapability({
+			auth: { scopes },
+			authMetadataPresent: params.authMetadataPresent,
+			error: params.error,
+			close: params.close,
+			verifiedRead: params.verifiedRead,
+			connectLatencyMs: params.connectLatencyMs
+		})
+	};
+}
+function isPairingPendingProbeFailure(params) {
+	return PAIRING_REQUIRED_PATTERN.test(params.close?.reason ?? params.error ?? "");
+}
+function resolveGatewayProbeCapability(params) {
+	if (isPairingPendingProbeFailure(params)) return "pairing_pending";
+	const scopes = Array.isArray(params.auth?.scopes) ? params.auth.scopes : [];
+	if (scopes.includes(OPERATOR_ADMIN_SCOPE)) return "admin_capable";
+	if (scopes.includes(OPERATOR_WRITE_SCOPE)) return "write_capable";
+	if (scopes.includes(OPERATOR_READ_SCOPE) || params.verifiedRead === true) return "read_only";
+	if (params.connectLatencyMs != null && params.authMetadataPresent === true) return "connected_no_operator_scope";
+	return "unknown";
+}
+async function probeGateway(opts) {
+	const startedAt = Date.now();
+	const instanceId = randomUUID();
+	let connectLatencyMs = null;
+	let connectError = null;
+	let connectErrorDetails = null;
+	let close = null;
+	let auth = emptyProbeAuth();
+	let authMetadataPresent = false;
+	const detailLevel = opts.includeDetails === false ? "none" : opts.detailLevel ?? "full";
+	const deviceIdentity = await (async () => {
+		let hostname;
+		try {
+			hostname = new URL(opts.url).hostname;
+		} catch {
+			return null;
+		}
+		if (isLoopbackHost(hostname) && !(opts.auth?.token || opts.auth?.password)) return null;
+		try {
+			const { loadOrCreateDeviceIdentity } = await import("./device-identity-AXkw1aze.js");
+			return loadOrCreateDeviceIdentity();
+		} catch {
+			return null;
+		}
+	})();
+	return await new Promise((resolve) => {
+		let settled = false;
+		let timer = null;
+		const clearProbeTimer = () => {
+			if (timer) {
+				clearTimeout(timer);
+				timer = null;
+			}
+		};
+		const armProbeTimer = (onTimeout) => {
+			clearProbeTimer();
+			timer = setTimeout(onTimeout, clampProbeTimeoutMs(opts.timeoutMs));
+		};
+		const settle = (result) => {
+			if (settled) return;
+			settled = true;
+			clearProbeTimer();
+			client.stop();
+			const { connectErrorDetails: resultConnectErrorDetails, ...rest } = result;
+			resolve({
+				url: opts.url,
+				...rest,
+				...resultConnectErrorDetails != null ? { connectErrorDetails: resultConnectErrorDetails } : {}
+			});
+		};
+		const settleProbe = (params) => {
+			settle({
+				ok: params.ok,
+				connectLatencyMs,
+				error: params.error,
+				connectErrorDetails,
+				close,
+				auth: resolveProbeAuthSummary({
+					role: auth.role,
+					scopes: auth.scopes,
+					authMetadataPresent,
+					error: params.error,
+					close,
+					verifiedRead: params.verifiedRead,
+					connectLatencyMs
+				}),
+				health: params.health,
+				status: params.status,
+				presence: params.presence,
+				configSnapshot: params.configSnapshot
+			});
+		};
+		const client = new GatewayClient({
+			url: opts.url,
+			token: opts.auth?.token,
+			password: opts.auth?.password,
+			tlsFingerprint: opts.tlsFingerprint,
+			scopes: [READ_SCOPE],
+			clientName: GATEWAY_CLIENT_NAMES.CLI,
+			clientVersion: "dev",
+			mode: GATEWAY_CLIENT_MODES.PROBE,
+			instanceId,
+			deviceIdentity,
+			onConnectError: (err) => {
+				connectError = formatErrorMessage(err);
+				connectErrorDetails = err instanceof GatewayClientRequestError ? err.details : null;
+			},
+			onClose: (code, reason) => {
+				close = {
+					code,
+					reason
+				};
+				if (connectLatencyMs == null) settleProbe({
+					ok: false,
+					error: connectError || formatProbeCloseError(close),
+					health: null,
+					status: null,
+					presence: null,
+					configSnapshot: null
+				});
+			},
+			onHelloOk: async (hello) => {
+				connectLatencyMs = Date.now() - startedAt;
+				authMetadataPresent = typeof hello?.auth === "object" && hello.auth !== null;
+				auth = resolveProbeAuthSummary({
+					role: typeof hello?.auth?.role === "string" ? hello.auth.role : null,
+					scopes: Array.isArray(hello?.auth?.scopes) ? hello.auth.scopes.filter((scope) => typeof scope === "string") : [],
+					authMetadataPresent
+				});
+				if (detailLevel === "none") {
+					settleProbe({
+						ok: true,
+						error: null,
+						verifiedRead: false,
+						health: null,
+						status: null,
+						presence: null,
+						configSnapshot: null
+					});
+					return;
+				}
+				armProbeTimer(() => {
+					settleProbe({
+						ok: false,
+						error: "timeout",
+						health: null,
+						status: null,
+						presence: null,
+						configSnapshot: null
+					});
+				});
+				try {
+					if (detailLevel === "presence") {
+						const presence = await client.request("system-presence");
+						settleProbe({
+							ok: true,
+							error: null,
+							verifiedRead: true,
+							health: null,
+							status: null,
+							presence: Array.isArray(presence) ? presence : null,
+							configSnapshot: null
+						});
+						return;
+					}
+					const [health, status, presence, configSnapshot] = await Promise.all([
+						client.request("health"),
+						client.request("status"),
+						client.request("system-presence"),
+						client.request("config.get", {})
+					]);
+					settleProbe({
+						ok: true,
+						error: null,
+						verifiedRead: true,
+						health,
+						status,
+						presence: Array.isArray(presence) ? presence : null,
+						configSnapshot
+					});
+				} catch (err) {
+					settleProbe({
+						ok: false,
+						error: formatErrorMessage(err),
+						health: null,
+						status: null,
+						presence: null,
+						configSnapshot: null
+					});
+				}
+			}
+		});
+		armProbeTimer(() => {
+			settleProbe({
+				ok: false,
+				error: connectError ? `connect failed: ${connectError}` : "timeout",
+				health: null,
+				status: null,
+				presence: null,
+				configSnapshot: null
+			});
+		});
+		client.start();
+	});
+}
+//#endregion
+export { probeGateway as a, isPairingPendingProbeFailure as i, MIN_PROBE_TIMEOUT_MS as n, resolveGatewayProbeCapability as o, clampProbeTimeoutMs as r, MAX_TIMER_DELAY_MS as t };

package/dist/probe-BI2aKtuv.js

@@ -0,0 +1,74 @@
+import { i as formatErrorMessage } from "./errors-Jbvi20TW.js";
+import { n as withProgress } from "./progress-C6QDkZMg.js";
+//#region src/cli/daemon-cli/probe.ts
+let probeGatewayModulePromise;
+async function loadProbeGatewayModule() {
+	probeGatewayModulePromise ??= import("./probe-Dtp1ekg0.js");
+	return await probeGatewayModulePromise;
+}
+function resolveProbeFailureMessage(result) {
+	const closeHint = result.close ? `gateway closed (${result.close.code}): ${result.close.reason}` : null;
+	if (closeHint && (!result.error || result.error === "timeout")) return closeHint;
+	return result.error ?? closeHint ?? "gateway probe failed";
+}
+async function probeGatewayStatus(opts) {
+	const kind = opts.requireRpc ? "read" : "connect";
+	try {
+		const result = await withProgress({
+			label: "Checking gateway status...",
+			indeterminate: true,
+			enabled: opts.json !== true
+		}, async () => {
+			const { probeGateway } = await loadProbeGatewayModule();
+			const probeOpts = {
+				url: opts.url,
+				auth: {
+					token: opts.token,
+					password: opts.password
+				},
+				tlsFingerprint: opts.tlsFingerprint,
+				timeoutMs: opts.timeoutMs,
+				includeDetails: false
+			};
+			if (opts.requireRpc) {
+				const { callGateway } = await import("./call-DHNRfD2p.js");
+				await callGateway({
+					url: opts.url,
+					token: opts.token,
+					password: opts.password,
+					tlsFingerprint: opts.tlsFingerprint,
+					method: "status",
+					timeoutMs: opts.timeoutMs,
+					...opts.configPath ? { configPath: opts.configPath } : {}
+				});
+				return {
+					ok: true,
+					authProbe: await probeGateway(probeOpts).catch(() => null)
+				};
+			}
+			return await probeGateway(probeOpts);
+		});
+		const auth = "auth" in result ? result.auth : result.authProbe?.auth;
+		if (result.ok) return {
+			ok: true,
+			kind,
+			capability: kind === "read" ? auth?.capability && auth.capability !== "unknown" ? auth.capability : "read_only" : auth?.capability,
+			auth
+		};
+		return {
+			ok: false,
+			kind,
+			capability: auth?.capability,
+			auth,
+			error: resolveProbeFailureMessage(result)
+		};
+	} catch (err) {
+		return {
+			ok: false,
+			kind,
+			error: formatErrorMessage(err)
+		};
+	}
+}
+//#endregion
+export { probeGatewayStatus };