@pixelzx/genesis 2026.5.5-3 → 2026.5.5-4

package/dist/nodes-utils-BfpGcUca.js

@@ -1,84 +0,0 @@
-import { s as normalizeOptionalLowercaseString } from "./string-coerce-C1IzJjqi.js";
-import { t as callGatewayTool } from "./gateway-C0YHaLXO.js";
-import { i as parsePairingList, n as resolveNodeIdFromNodeList, r as parseNodeList, t as resolveNodeFromNodeList } from "./node-resolve-BkIWTwFE.js";
-//#region src/agents/tools/nodes-utils.ts
-function messageFromError(error) {
-	if (error instanceof Error) return error.message;
-	if (typeof error === "string") return error;
-	if (typeof error === "object" && error !== null && "message" in error && typeof error.message === "string") return error.message;
-	if (typeof error === "object" && error !== null) try {
-		return JSON.stringify(error);
-	} catch {
-		return "";
-	}
-	return "";
-}
-function shouldFallbackToPairList(error) {
-	const message = normalizeOptionalLowercaseString(messageFromError(error)) ?? "";
-	if (!message.includes("node.list")) return false;
-	return message.includes("unknown method") || message.includes("method not found") || message.includes("not implemented") || message.includes("unsupported");
-}
-async function loadNodes(opts) {
-	try {
-		return parseNodeList(await callGatewayTool("node.list", opts, {}));
-	} catch (error) {
-		if (!shouldFallbackToPairList(error)) throw error;
-		const { paired } = parsePairingList(await callGatewayTool("node.pair.list", opts, {}));
-		return paired.map((n) => ({
-			nodeId: n.nodeId,
-			displayName: n.displayName,
-			platform: n.platform,
-			remoteIp: n.remoteIp
-		}));
-	}
-}
-function isLocalMacNode(node) {
-	return normalizeOptionalLowercaseString(node.platform)?.startsWith("mac") === true && typeof node.nodeId === "string" && node.nodeId.startsWith("mac-");
-}
-function compareDefaultNodeOrder(a, b) {
-	const aConnectedAt = Number.isFinite(a.connectedAtMs) ? a.connectedAtMs ?? 0 : -1;
-	const bConnectedAt = Number.isFinite(b.connectedAtMs) ? b.connectedAtMs ?? 0 : -1;
-	if (aConnectedAt !== bConnectedAt) return bConnectedAt - aConnectedAt;
-	return a.nodeId.localeCompare(b.nodeId);
-}
-function selectDefaultNodeFromList(nodes, options = {}) {
-	const capability = options.capability?.trim();
-	const withCapability = capability ? nodes.filter((n) => Array.isArray(n.caps) ? n.caps.includes(capability) : true) : nodes;
-	if (withCapability.length === 0) return null;
-	const connected = withCapability.filter((n) => n.connected);
-	const candidates = connected.length > 0 ? connected : withCapability;
-	if (candidates.length === 1) return candidates[0];
-	if (options.preferLocalMac ?? true) {
-		const local = candidates.filter(isLocalMacNode);
-		if (local.length === 1) return local[0];
-	}
-	if ((options.fallback ?? "none") === "none") return null;
-	return [...candidates].toSorted(compareDefaultNodeOrder)[0] ?? null;
-}
-function pickDefaultNode(nodes) {
-	return selectDefaultNodeFromList(nodes, {
-		capability: "canvas",
-		fallback: "first",
-		preferLocalMac: true
-	});
-}
-async function listNodes(opts) {
-	return loadNodes(opts);
-}
-function resolveNodeIdFromList(nodes, query, allowDefault = false) {
-	return resolveNodeIdFromNodeList(nodes, query, {
-		allowDefault,
-		pickDefaultNode
-	});
-}
-async function resolveNodeId(opts, query, allowDefault = false) {
-	return (await resolveNode(opts, query, allowDefault)).nodeId;
-}
-async function resolveNode(opts, query, allowDefault = false) {
-	return resolveNodeFromNodeList(await loadNodes(opts), query, {
-		allowDefault,
-		pickDefaultNode
-	});
-}
-//#endregion
-export { selectDefaultNodeFromList as a, resolveNodeIdFromList as i, resolveNode as n, resolveNodeId as r, listNodes as t };

package/dist/nodes.helpers-CMXxavTs.js

@@ -1,34 +0,0 @@
-import { c as normalizeOptionalString } from "./string-coerce-C1IzJjqi.js";
-import { fn as ErrorCodes, pn as errorShape, t as formatValidationErrors } from "./protocol-Batc2DmY.js";
-import { t as formatForLog } from "./ws-log-B59Ub3FE.js";
-//#region src/gateway/server-methods/nodes.helpers.ts
-function respondInvalidParams(params) {
-	params.respond(false, void 0, errorShape(ErrorCodes.INVALID_REQUEST, `invalid ${params.method} params: ${formatValidationErrors(params.validator.errors)}`));
-}
-async function respondUnavailableOnThrow(respond, fn) {
-	try {
-		await fn();
-	} catch (err) {
-		respond(false, void 0, errorShape(ErrorCodes.UNAVAILABLE, formatForLog(err)));
-	}
-}
-function safeParseJson(value) {
-	const trimmed = normalizeOptionalString(value);
-	if (!trimmed) return;
-	try {
-		return JSON.parse(trimmed);
-	} catch {
-		return { payloadJSON: value };
-	}
-}
-function respondUnavailableOnNodeInvokeError(respond, res) {
-	if (res.ok) return true;
-	const nodeError = res.error && typeof res.error === "object" ? res.error : null;
-	const nodeCode = normalizeOptionalString(nodeError?.code) ?? "";
-	const nodeMessage = normalizeOptionalString(nodeError?.message) ?? "node invoke failed";
-	const message = nodeCode ? `${nodeCode}: ${nodeMessage}` : nodeMessage;
-	respond(false, void 0, errorShape(ErrorCodes.UNAVAILABLE, message, { details: { nodeError: res.error ?? null } }));
-	return false;
-}
-//#endregion
-export { safeParseJson as i, respondUnavailableOnNodeInvokeError as n, respondUnavailableOnThrow as r, respondInvalidParams as t };

package/dist/notify-DaNP5Zyh.js

@@ -1,315 +0,0 @@
-import { i as formatErrorMessage } from "./errors-Jbvi20TW.js";
-import { c as normalizeOptionalString } from "./string-coerce-C1IzJjqi.js";
-import "./text-runtime-B4pK_Jpd.js";
-import "./error-runtime-Cv5whxJ8.js";
-import { l as listDevicePairing } from "./device-pairing-BorvqhX6.js";
-import "./api-DZiRkVPk.js";
-import { promises } from "node:fs";
-import path from "node:path";
-//#region extensions/device-pair/notify.ts
-const NOTIFY_STATE_FILE = "device-pair-notify.json";
-const NOTIFY_POLL_INTERVAL_MS = 1e4;
-const NOTIFY_MAX_SEEN_AGE_MS = 1440 * 60 * 1e3;
-function formatStringList(values) {
-	if (!Array.isArray(values) || values.length === 0) return "none";
-	const normalized = values.map((value) => value.trim()).filter((value) => value.length > 0);
-	return normalized.length > 0 ? normalized.join(", ") : "none";
-}
-function formatRoleList(request) {
-	const role = normalizeOptionalString(request.role);
-	if (role) return role;
-	return formatStringList(request.roles);
-}
-function formatScopeList(request) {
-	return formatStringList(request.scopes);
-}
-function formatPendingRequests(pending) {
-	if (pending.length === 0) return "No pending device pairing requests.";
-	const lines = ["Pending device pairing requests:"];
-	for (const req of pending) {
-		const label = normalizeOptionalString(req.displayName) || req.deviceId;
-		const platform = normalizeOptionalString(req.platform);
-		const ip = normalizeOptionalString(req.remoteIp);
-		const parts = [
-			`- ${req.requestId}`,
-			label ? `name=${label}` : null,
-			platform ? `platform=${platform}` : null,
-			`role=${formatRoleList(req)}`,
-			`scopes=${formatScopeList(req)}`,
-			ip ? `ip=${ip}` : null
-		].filter(Boolean);
-		lines.push(parts.join(" · "));
-	}
-	return lines.join("\n");
-}
-function resolveNotifyStatePath(stateDir) {
-	return path.join(stateDir, NOTIFY_STATE_FILE);
-}
-function normalizeNotifyState(raw) {
-	const root = typeof raw === "object" && raw !== null ? raw : {};
-	const subscribersRaw = Array.isArray(root.subscribers) ? root.subscribers : [];
-	const notifiedRaw = typeof root.notifiedRequestIds === "object" && root.notifiedRequestIds !== null ? root.notifiedRequestIds : {};
-	const subscribers = [];
-	for (const item of subscribersRaw) {
-		if (typeof item !== "object" || item === null) continue;
-		const record = item;
-		const to = normalizeOptionalString(record.to) ?? "";
-		if (!to) continue;
-		const accountId = normalizeOptionalString(record.accountId) ?? void 0;
-		const messageThreadId = typeof record.messageThreadId === "string" ? normalizeOptionalString(record.messageThreadId) || void 0 : typeof record.messageThreadId === "number" && Number.isFinite(record.messageThreadId) ? Math.trunc(record.messageThreadId) : void 0;
-		const mode = record.mode === "once" ? "once" : "persistent";
-		const addedAtMs = typeof record.addedAtMs === "number" && Number.isFinite(record.addedAtMs) ? Math.trunc(record.addedAtMs) : Date.now();
-		subscribers.push({
-			to,
-			accountId,
-			messageThreadId,
-			mode,
-			addedAtMs
-		});
-	}
-	const notifiedRequestIds = {};
-	for (const [requestId, ts] of Object.entries(notifiedRaw)) {
-		const normalizedRequestId = normalizeOptionalString(requestId);
-		if (!normalizedRequestId) continue;
-		if (typeof ts !== "number" || !Number.isFinite(ts) || ts <= 0) continue;
-		notifiedRequestIds[normalizedRequestId] = Math.trunc(ts);
-	}
-	return {
-		subscribers,
-		notifiedRequestIds
-	};
-}
-async function readNotifyState(filePath) {
-	try {
-		const content = await promises.readFile(filePath, "utf8");
-		return normalizeNotifyState(JSON.parse(content));
-	} catch {
-		return {
-			subscribers: [],
-			notifiedRequestIds: {}
-		};
-	}
-}
-async function writeNotifyState(filePath, state) {
-	await promises.mkdir(path.dirname(filePath), { recursive: true });
-	const content = JSON.stringify(state, null, 2);
-	await promises.writeFile(filePath, `${content}\n`, "utf8");
-}
-function notifySubscriberKey(subscriber) {
-	return JSON.stringify([
-		subscriber.to,
-		subscriber.accountId ?? "",
-		normalizeNotifyThreadKey(subscriber.messageThreadId)
-	]);
-}
-function normalizeNotifyThreadKey(messageThreadId) {
-	if (typeof messageThreadId === "number" && Number.isFinite(messageThreadId)) return String(Math.trunc(messageThreadId));
-	if (typeof messageThreadId !== "string") return "";
-	const normalized = normalizeOptionalString(messageThreadId);
-	if (!normalized) return "";
-	if (!/^-?\d+$/u.test(normalized)) return normalized;
-	try {
-		return BigInt(normalized).toString();
-	} catch {
-		return normalized;
-	}
-}
-function resolveNotifyTarget(ctx) {
-	const to = normalizeOptionalString(ctx.senderId) || normalizeOptionalString(ctx.from) || normalizeOptionalString(ctx.to) || "";
-	if (!to) return null;
-	return {
-		to,
-		...ctx.accountId ? { accountId: ctx.accountId } : {},
-		...ctx.messageThreadId != null ? { messageThreadId: ctx.messageThreadId } : {}
-	};
-}
-function upsertNotifySubscriber(subscribers, target, mode) {
-	const key = notifySubscriberKey(target);
-	const index = subscribers.findIndex((entry) => notifySubscriberKey(entry) === key);
-	const next = {
-		...target,
-		mode,
-		addedAtMs: Date.now()
-	};
-	if (index === -1) {
-		subscribers.push(next);
-		return true;
-	}
-	if (subscribers[index]?.mode === mode) return false;
-	subscribers[index] = next;
-	return true;
-}
-function buildPairingRequestNotificationText(request) {
-	const label = normalizeOptionalString(request.displayName) || request.deviceId;
-	const platform = normalizeOptionalString(request.platform);
-	const ip = normalizeOptionalString(request.remoteIp);
-	const role = formatRoleList(request);
-	const scopes = formatScopeList(request);
-	return [
-		"📲 New device pairing request",
-		`ID: ${request.requestId}`,
-		`Name: ${label}`,
-		...platform ? [`Platform: ${platform}`] : [],
-		`Role: ${role}`,
-		`Scopes: ${scopes}`,
-		...ip ? [`IP: ${ip}`] : [],
-		"",
-		`Approve: /pair approve ${request.requestId}`,
-		"List pending: /pair pending"
-	].join("\n");
-}
-function requestTimestampMs(request) {
-	if (typeof request.ts !== "number" || !Number.isFinite(request.ts)) return null;
-	const ts = Math.trunc(request.ts);
-	return ts > 0 ? ts : null;
-}
-function shouldNotifySubscriberForRequest(subscriber, request) {
-	if (subscriber.mode !== "once") return true;
-	const ts = requestTimestampMs(request);
-	if (ts == null) return false;
-	return ts >= subscriber.addedAtMs;
-}
-async function notifySubscriber(params) {
-	const send = (await params.api.runtime.channel.outbound.loadAdapter("telegram"))?.sendText;
-	if (!send) {
-		params.api.logger.warn("device-pair: telegram outbound adapter unavailable for pairing notifications");
-		return false;
-	}
-	try {
-		await send({
-			cfg: params.api.config,
-			to: params.subscriber.to,
-			text: params.text,
-			...params.subscriber.accountId ? { accountId: params.subscriber.accountId } : {},
-			...params.subscriber.messageThreadId != null ? { threadId: params.subscriber.messageThreadId } : {}
-		});
-		return true;
-	} catch (err) {
-		params.api.logger.warn(`device-pair: failed to send pairing notification to ${params.subscriber.to}: ${formatErrorMessage(err)}`);
-		return false;
-	}
-}
-async function notifyPendingPairingRequests(params) {
-	const state = await readNotifyState(params.statePath);
-	const pending = (await listDevicePairing()).pending;
-	const now = Date.now();
-	const pendingIds = new Set(pending.map((entry) => entry.requestId));
-	let changed = false;
-	for (const [requestId, ts] of Object.entries(state.notifiedRequestIds)) if (!pendingIds.has(requestId) || now - ts > NOTIFY_MAX_SEEN_AGE_MS) {
-		delete state.notifiedRequestIds[requestId];
-		changed = true;
-	}
-	if (state.subscribers.length > 0) {
-		const oneShotDelivered = /* @__PURE__ */ new Set();
-		for (const request of pending) {
-			if (state.notifiedRequestIds[request.requestId]) continue;
-			const text = buildPairingRequestNotificationText(request);
-			let delivered = false;
-			for (const subscriber of state.subscribers) {
-				if (!shouldNotifySubscriberForRequest(subscriber, request)) continue;
-				const sent = await notifySubscriber({
-					api: params.api,
-					subscriber,
-					text
-				});
-				delivered = delivered || sent;
-				if (sent && subscriber.mode === "once") oneShotDelivered.add(notifySubscriberKey(subscriber));
-			}
-			if (delivered) {
-				state.notifiedRequestIds[request.requestId] = now;
-				changed = true;
-			}
-		}
-		if (oneShotDelivered.size > 0) {
-			const initialCount = state.subscribers.length;
-			state.subscribers = state.subscribers.filter((subscriber) => !oneShotDelivered.has(notifySubscriberKey(subscriber)));
-			if (state.subscribers.length !== initialCount) changed = true;
-		}
-	}
-	if (changed) await writeNotifyState(params.statePath, state);
-}
-async function armPairNotifyOnce(params) {
-	if (params.ctx.channel !== "telegram") return false;
-	const target = resolveNotifyTarget(params.ctx);
-	if (!target) return false;
-	const statePath = resolveNotifyStatePath(params.api.runtime.state.resolveStateDir());
-	const state = await readNotifyState(statePath);
-	let changed = false;
-	if (upsertNotifySubscriber(state.subscribers, target, "once")) changed = true;
-	if (changed) await writeNotifyState(statePath, state);
-	return true;
-}
-async function handleNotifyCommand(params) {
-	if (params.ctx.channel !== "telegram") return { text: "Pairing notifications are currently supported only on Telegram." };
-	const target = resolveNotifyTarget(params.ctx);
-	if (!target) return { text: "Could not resolve Telegram target for this chat." };
-	const statePath = resolveNotifyStatePath(params.api.runtime.state.resolveStateDir());
-	const state = await readNotifyState(statePath);
-	const targetKey = notifySubscriberKey(target);
-	const current = state.subscribers.find((entry) => notifySubscriberKey(entry) === targetKey);
-	if (params.action === "on" || params.action === "enable") {
-		if (upsertNotifySubscriber(state.subscribers, target, "persistent")) await writeNotifyState(statePath, state);
-		return { text: "✅ Pair request notifications enabled for this Telegram chat.\nI will ping here when a new device pairing request arrives." };
-	}
-	if (params.action === "off" || params.action === "disable") {
-		const currentIndex = state.subscribers.findIndex((entry) => notifySubscriberKey(entry) === targetKey);
-		if (currentIndex !== -1) {
-			state.subscribers.splice(currentIndex, 1);
-			await writeNotifyState(statePath, state);
-		}
-		return { text: "✅ Pair request notifications disabled for this Telegram chat." };
-	}
-	if (params.action === "once" || params.action === "arm") {
-		await armPairNotifyOnce({
-			api: params.api,
-			ctx: params.ctx
-		});
-		return { text: "✅ One-shot pairing notification armed for this Telegram chat.\nI will notify on the next new pairing request, then auto-disable." };
-	}
-	if (params.action === "status" || params.action === "") {
-		const pending = await listDevicePairing();
-		const enabled = Boolean(current);
-		const mode = current?.mode ?? "off";
-		return { text: [
-			`Pair request notifications: ${enabled ? "enabled" : "disabled"} for this chat.`,
-			`Mode: ${mode}`,
-			`Subscribers: ${state.subscribers.length}`,
-			`Pending requests: ${pending.pending.length}`,
-			"",
-			"Use /pair notify on|off|once"
-		].join("\n") };
-	}
-	return { text: "Usage: /pair notify on|off|once|status" };
-}
-function registerPairingNotifierService(api) {
-	let notifyInterval = null;
-	api.registerService({
-		id: "device-pair-notifier",
-		start: async (ctx) => {
-			const statePath = resolveNotifyStatePath(ctx.stateDir);
-			const tick = async () => {
-				await notifyPendingPairingRequests({
-					api,
-					statePath
-				});
-			};
-			await tick().catch((err) => {
-				api.logger.warn(`device-pair: initial notify poll failed: ${formatErrorMessage(err)}`);
-			});
-			notifyInterval = setInterval(() => {
-				tick().catch((err) => {
-					api.logger.warn(`device-pair: notify poll failed: ${formatErrorMessage(err)}`);
-				});
-			}, NOTIFY_POLL_INTERVAL_MS);
-			notifyInterval.unref?.();
-		},
-		stop: async () => {
-			if (notifyInterval) {
-				clearInterval(notifyInterval);
-				notifyInterval = null;
-			}
-		}
-	});
-}
-//#endregion
-export { registerPairingNotifierService as i, formatPendingRequests as n, handleNotifyCommand as r, armPairNotifyOnce as t };