@pixelzx/genesis 2026.6.29 → 2026.7.8

package/dist/probe-B4ekJ-Xv.js

@@ -1,74 +0,0 @@
-import { i as formatErrorMessage } from "./errors-CufR9eHH.js";
-import { n as withProgress } from "./progress-DwK5aAgj.js";
-//#region src/cli/daemon-cli/probe.ts
-let probeGatewayModulePromise;
-async function loadProbeGatewayModule() {
-	probeGatewayModulePromise ??= import("./probe-4IiQQG_7.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-S0AZ899k.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 };

package/dist/probe-B9hiEFIU.js

@@ -1,2 +0,0 @@
-import { t as probeSignal } from "./probe-Ct62B_e4.js";
-export { probeSignal };

package/dist/probe-CDrkDwhe.js

@@ -1,240 +0,0 @@
-import { i as formatErrorMessage } from "./errors-CufR9eHH.js";
-import { a as isLoopbackHost } from "./net-BzaeD_3Q.js";
-import { n as GatewayClientRequestError, o as MAX_SAFE_TIMEOUT_DELAY_MS, s as resolveSafeTimeoutDelayMs, t as GatewayClient } from "./client-BLrVaUap.js";
-import { i as GATEWAY_CLIENT_NAMES, r as GATEWAY_CLIENT_MODES } from "./client-info-CjxzJxIU.js";
-import { l as READ_SCOPE } from "./method-scopes-D_AZ7OsK.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-c3oj6IhI.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-Ct62B_e4.js

@@ -1,45 +0,0 @@
-import { i as formatErrorMessage } from "./errors-CufR9eHH.js";
-import "./error-runtime-DZiTdNNG.js";
-import { n as signalRpcRequest, t as signalCheck } from "./client-JSnNx9t8.js";
-//#region extensions/signal/src/probe.ts
-function parseSignalVersion(value) {
-	if (typeof value === "string" && value.trim()) return value.trim();
-	if (typeof value === "object" && value !== null) {
-		const version = value.version;
-		if (typeof version === "string" && version.trim()) return version.trim();
-	}
-	return null;
-}
-async function probeSignal(baseUrl, timeoutMs) {
-	const started = Date.now();
-	const result = {
-		ok: false,
-		status: null,
-		error: null,
-		elapsedMs: 0,
-		version: null
-	};
-	const check = await signalCheck(baseUrl, timeoutMs);
-	if (!check.ok) return {
-		...result,
-		status: check.status ?? null,
-		error: check.error ?? "unreachable",
-		elapsedMs: Date.now() - started
-	};
-	try {
-		result.version = parseSignalVersion(await signalRpcRequest("version", void 0, {
-			baseUrl,
-			timeoutMs
-		}));
-	} catch (err) {
-		result.error = formatErrorMessage(err);
-	}
-	return {
-		...result,
-		ok: true,
-		status: check.status ?? null,
-		elapsedMs: Date.now() - started
-	};
-}
-//#endregion
-export { probeSignal as t };

package/dist/probe-pLHVFHK6.js

@@ -1,243 +0,0 @@
-import { i as formatErrorMessage } from "./errors-CufR9eHH.js";
-import { a as normalizeLowercaseStringOrEmpty } from "./string-coerce-DPP_aYVc.js";
-import { m as resolveUserPath } from "./utils-CWrkFsp0.js";
-import { r as runCommandWithTimeout } from "./exec-BbrLAvgI.js";
-import { a as loadConfig } from "./io-Cy5vajWd.js";
-import "./text-runtime-DVUvIDNC.js";
-import "./error-runtime-DZiTdNNG.js";
-import { t as detectBinary } from "./detect-binary-EimN6WHe.js";
-import "./setup-Bdm7tVM0.js";
-import "./config-runtime-AtYct3A3.js";
-import "./process-runtime-C1mjqmKZ.js";
-import { spawn } from "node:child_process";
-import { createInterface } from "node:readline";
-//#region extensions/imessage/src/constants.ts
-/** Default timeout for iMessage probe/RPC operations (10 seconds). */
-const DEFAULT_IMESSAGE_PROBE_TIMEOUT_MS = 1e4;
-//#endregion
-//#region extensions/imessage/src/client.ts
-function isTestEnv() {
-	const vitest = normalizeLowercaseStringOrEmpty(process.env.VITEST);
-	return Boolean(vitest);
-}
-var IMessageRpcClient = class {
-	constructor(opts = {}) {
-		this.pending = /* @__PURE__ */ new Map();
-		this.closedResolve = null;
-		this.child = null;
-		this.reader = null;
-		this.nextId = 1;
-		this.cliPath = opts.cliPath?.trim() || "imsg";
-		this.dbPath = opts.dbPath?.trim() ? resolveUserPath(opts.dbPath) : void 0;
-		this.runtime = opts.runtime;
-		this.onNotification = opts.onNotification;
-		this.closed = new Promise((resolve) => {
-			this.closedResolve = resolve;
-		});
-	}
-	async start() {
-		if (this.child) return;
-		if (isTestEnv()) throw new Error("Refusing to start imsg rpc in test environment; mock iMessage RPC client");
-		const args = ["rpc"];
-		if (this.dbPath) args.push("--db", this.dbPath);
-		const child = spawn(this.cliPath, args, { stdio: [
-			"pipe",
-			"pipe",
-			"pipe"
-		] });
-		this.child = child;
-		this.reader = createInterface({ input: child.stdout });
-		this.reader.on("line", (line) => {
-			const trimmed = line.trim();
-			if (!trimmed) return;
-			this.handleLine(trimmed);
-		});
-		child.stderr?.on("data", (chunk) => {
-			const lines = chunk.toString().split(/\r?\n/);
-			for (const line of lines) {
-				if (!line.trim()) continue;
-				this.runtime?.error?.(`imsg rpc: ${line.trim()}`);
-			}
-		});
-		child.on("error", (err) => {
-			this.failAll(err instanceof Error ? err : new Error(String(err)));
-			this.closedResolve?.();
-		});
-		child.on("close", (code, signal) => {
-			if (code !== 0 && code !== null) {
-				const reason = signal ? `signal ${signal}` : `code ${code}`;
-				this.failAll(/* @__PURE__ */ new Error(`imsg rpc exited (${reason})`));
-			} else this.failAll(/* @__PURE__ */ new Error("imsg rpc closed"));
-			this.closedResolve?.();
-		});
-	}
-	async stop() {
-		if (!this.child) return;
-		this.reader?.close();
-		this.reader = null;
-		this.child.stdin?.end();
-		const child = this.child;
-		this.child = null;
-		await Promise.race([this.closed, new Promise((resolve) => {
-			setTimeout(() => {
-				if (!child.killed) child.kill("SIGTERM");
-				resolve();
-			}, 500);
-		})]);
-	}
-	async waitForClose() {
-		await this.closed;
-	}
-	async request(method, params, opts) {
-		if (!this.child || !this.child.stdin) throw new Error("imsg rpc not running");
-		const id = this.nextId++;
-		const line = `${JSON.stringify({
-			jsonrpc: "2.0",
-			id,
-			method,
-			params: params ?? {}
-		})}\n`;
-		const timeoutMs = opts?.timeoutMs ?? 1e4;
-		const response = new Promise((resolve, reject) => {
-			const key = String(id);
-			const timer = timeoutMs > 0 ? setTimeout(() => {
-				this.pending.delete(key);
-				reject(/* @__PURE__ */ new Error(`imsg rpc timeout (${method})`));
-			}, timeoutMs) : void 0;
-			this.pending.set(key, {
-				resolve: (value) => resolve(value),
-				reject,
-				timer
-			});
-		});
-		this.child.stdin.write(line);
-		return await response;
-	}
-	handleLine(line) {
-		let parsed;
-		try {
-			parsed = JSON.parse(line);
-		} catch (err) {
-			const detail = formatErrorMessage(err);
-			this.runtime?.error?.(`imsg rpc: failed to parse ${line}: ${detail}`);
-			return;
-		}
-		if (parsed.id !== void 0 && parsed.id !== null) {
-			const key = String(parsed.id);
-			const pending = this.pending.get(key);
-			if (!pending) return;
-			if (pending.timer) clearTimeout(pending.timer);
-			this.pending.delete(key);
-			if (parsed.error) {
-				const baseMessage = parsed.error.message ?? "imsg rpc error";
-				const details = parsed.error.data;
-				const code = parsed.error.code;
-				const suffixes = [];
-				if (typeof code === "number") suffixes.push(`code=${code}`);
-				if (details !== void 0) {
-					const detailText = typeof details === "string" ? details : JSON.stringify(details, null, 2);
-					if (detailText) suffixes.push(detailText);
-				}
-				const msg = suffixes.length > 0 ? `${baseMessage}: ${suffixes.join(" ")}` : baseMessage;
-				pending.reject(new Error(msg));
-				return;
-			}
-			pending.resolve(parsed.result);
-			return;
-		}
-		if (parsed.method) this.onNotification?.({
-			method: parsed.method,
-			params: parsed.params
-		});
-	}
-	failAll(err) {
-		for (const [key, pending] of this.pending.entries()) {
-			if (pending.timer) clearTimeout(pending.timer);
-			pending.reject(err);
-			this.pending.delete(key);
-		}
-	}
-};
-async function createIMessageRpcClient(opts = {}) {
-	const client = new IMessageRpcClient(opts);
-	await client.start();
-	return client;
-}
-//#endregion
-//#region extensions/imessage/src/probe.ts
-const rpcSupportCache = /* @__PURE__ */ new Map();
-async function probeRpcSupport(cliPath, timeoutMs) {
-	const cached = rpcSupportCache.get(cliPath);
-	if (cached) return cached;
-	try {
-		const result = await runCommandWithTimeout([
-			cliPath,
-			"rpc",
-			"--help"
-		], { timeoutMs });
-		const combined = `${result.stdout}\n${result.stderr}`.trim();
-		const normalized = normalizeLowercaseStringOrEmpty(combined);
-		if (normalized.includes("unknown command") && normalized.includes("rpc")) {
-			const fatal = {
-				supported: false,
-				fatal: true,
-				error: "imsg CLI does not support the \"rpc\" subcommand (update imsg)"
-			};
-			rpcSupportCache.set(cliPath, fatal);
-			return fatal;
-		}
-		if (result.code === 0) {
-			const supported = { supported: true };
-			rpcSupportCache.set(cliPath, supported);
-			return supported;
-		}
-		return {
-			supported: false,
-			error: combined || `imsg rpc --help failed (code ${String(result.code ?? "unknown")})`
-		};
-	} catch (err) {
-		return {
-			supported: false,
-			error: String(err)
-		};
-	}
-}
-/**
-* Probe iMessage RPC availability.
-* @param timeoutMs - Explicit timeout in ms. If undefined, uses config or default.
-* @param opts - Additional options (cliPath, dbPath, runtime).
-*/
-async function probeIMessage(timeoutMs, opts = {}) {
-	const cfg = opts.cliPath || opts.dbPath ? void 0 : loadConfig();
-	const cliPath = opts.cliPath?.trim() || cfg?.channels?.imessage?.cliPath?.trim() || "imsg";
-	const dbPath = opts.dbPath?.trim() || cfg?.channels?.imessage?.dbPath?.trim();
-	const effectiveTimeout = timeoutMs ?? cfg?.channels?.imessage?.probeTimeoutMs ?? 1e4;
-	if (!await detectBinary(cliPath)) return {
-		ok: false,
-		error: `imsg not found (${cliPath})`
-	};
-	const rpcSupport = await probeRpcSupport(cliPath, effectiveTimeout);
-	if (!rpcSupport.supported) return {
-		ok: false,
-		error: rpcSupport.error ?? "imsg rpc unavailable",
-		fatal: rpcSupport.fatal
-	};
-	const client = await createIMessageRpcClient({
-		cliPath,
-		dbPath,
-		runtime: opts.runtime
-	});
-	try {
-		await client.request("chats.list", { limit: 1 }, { timeoutMs: effectiveTimeout });
-		return { ok: true };
-	} catch (err) {
-		return {
-			ok: false,
-			error: String(err)
-		};
-	} finally {
-		await client.stop();
-	}
-}
-//#endregion
-export { createIMessageRpcClient as n, DEFAULT_IMESSAGE_PROBE_TIMEOUT_MS as r, probeIMessage as t };