@pixelzx/genesis 2026.5.5-2 → 2026.5.5-3

package/dist/nodes-utils-BfpGcUca.js

@@ -0,0 +1,84 @@
+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

@@ -0,0 +1,34 @@
+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

@@ -0,0 +1,315 @@
+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 };