@pixelzx/genesis 2026.5.10-6 → 2026.5.14

package/dist/media-runtime-DFk_-1jK.js

@@ -0,0 +1,329 @@
+import { a as shouldLogVerbose, r as logVerbose } from "./globals-C5IxqXPj.js";
+import "./mime-DucH9KF3.js";
+import "./image-ops-DXau4yMa.js";
+import { x as sendTextMediaPayload } from "./reply-payload-ChFsXpe2.js";
+import "./local-roots-CENIlVYe.js";
+import "./store-BLvGOOM1.js";
+import "./local-media-access-EFjNHZJ6.js";
+import "./fetch-C1syqUDP.js";
+import "./resolve-Dqgvwx7j.js";
+import "./image-runtime-Cxmy4Vhx.js";
+import { a as runCapability, i as resolveMediaAttachmentLocalRoots, l as isAudioAttachment, o as createMediaAttachmentCache, s as normalizeMediaAttachments, t as buildProviderRegistry } from "./runner-DKiqEZqT.js";
+import "./runner.entries-CqQp6DL-.js";
+import { a as chunkText } from "./chunk-D6Ep3gqf.js";
+import "./audio-DhJSI41D.js";
+import { t as resolveChannelMediaMaxBytes } from "./media-limits-B_vUv30m.js";
+import "./agent-media-payload-DOgbom5R.js";
+import { t as sanitizeForPlainText } from "./sanitize-text-RhEEAlk4.js";
+import "./outbound-runtime-CQNa6Zqr.js";
+import "./outbound-attachment-yu6Ng1-T.js";
+import { n as loadQrCodeTuiRuntime } from "./qr-terminal-DZEH6jfO.js";
+import path from "node:path";
+import fs, { mkdtemp, rm, writeFile } from "node:fs/promises";
+import { deflateSync } from "node:zlib";
+//#region src/media/png-encode.ts
+/**
+* Minimal PNG encoder for generating simple RGBA images without native dependencies.
+* Used for QR codes, live probes, and other programmatic image generation.
+*/
+const CRC_TABLE = (() => {
+	const table = new Uint32Array(256);
+	for (let i = 0; i < 256; i += 1) {
+		let c = i;
+		for (let k = 0; k < 8; k += 1) c = c & 1 ? 3988292384 ^ c >>> 1 : c >>> 1;
+		table[i] = c >>> 0;
+	}
+	return table;
+})();
+/** Compute CRC32 checksum for a buffer (used in PNG chunk encoding). */
+function crc32(buf) {
+	let crc = 4294967295;
+	for (let i = 0; i < buf.length; i += 1) crc = CRC_TABLE[(crc ^ buf[i]) & 255] ^ crc >>> 8;
+	return (crc ^ 4294967295) >>> 0;
+}
+/** Create a PNG chunk with type, data, and CRC. */
+function pngChunk(type, data) {
+	const typeBuf = Buffer.from(type, "ascii");
+	const len = Buffer.alloc(4);
+	len.writeUInt32BE(data.length, 0);
+	const crc = crc32(Buffer.concat([typeBuf, data]));
+	const crcBuf = Buffer.alloc(4);
+	crcBuf.writeUInt32BE(crc, 0);
+	return Buffer.concat([
+		len,
+		typeBuf,
+		data,
+		crcBuf
+	]);
+}
+/** Write a pixel to an RGBA buffer. Ignores out-of-bounds writes. */
+function fillPixel(buf, x, y, width, r, g, b, a = 255) {
+	if (x < 0 || y < 0 || x >= width) return;
+	const idx = (y * width + x) * 4;
+	if (idx < 0 || idx + 3 >= buf.length) return;
+	buf[idx] = r;
+	buf[idx + 1] = g;
+	buf[idx + 2] = b;
+	buf[idx + 3] = a;
+}
+/** Encode an RGBA buffer as a PNG image. */
+function encodePngRgba(buffer, width, height) {
+	const stride = width * 4;
+	const raw = Buffer.alloc((stride + 1) * height);
+	for (let row = 0; row < height; row += 1) {
+		const rawOffset = row * (stride + 1);
+		raw[rawOffset] = 0;
+		buffer.copy(raw, rawOffset + 1, row * stride, row * stride + stride);
+	}
+	const compressed = deflateSync(raw);
+	const signature = Buffer.from([
+		137,
+		80,
+		78,
+		71,
+		13,
+		10,
+		26,
+		10
+	]);
+	const ihdr = Buffer.alloc(13);
+	ihdr.writeUInt32BE(width, 0);
+	ihdr.writeUInt32BE(height, 4);
+	ihdr[8] = 8;
+	ihdr[9] = 6;
+	ihdr[10] = 0;
+	ihdr[11] = 0;
+	ihdr[12] = 0;
+	return Buffer.concat([
+		signature,
+		pngChunk("IHDR", ihdr),
+		pngChunk("IDAT", compressed),
+		pngChunk("IEND", Buffer.alloc(0))
+	]);
+}
+//#endregion
+//#region src/media/qr-image.ts
+const DEFAULT_QR_PNG_SCALE = 6;
+const DEFAULT_QR_PNG_MARGIN_MODULES = 4;
+const MIN_QR_PNG_SCALE = 1;
+const MAX_QR_PNG_SCALE = 12;
+const MIN_QR_PNG_MARGIN_MODULES = 0;
+const MAX_QR_PNG_MARGIN_MODULES = 16;
+const QR_PNG_DATA_URL_PREFIX = "data:image/png;base64,";
+function resolveQrPngIntegerOption(params) {
+	if (params.value === void 0) return params.defaultValue;
+	if (!Number.isFinite(params.value)) throw new RangeError(`${params.name} must be a finite number.`);
+	const value = Math.floor(params.value);
+	if (value < params.min || value > params.max) throw new RangeError(`${params.name} must be between ${params.min} and ${params.max}.`);
+	return value;
+}
+function resolveQrTempPathSegment(name, value) {
+	if (!value || value === "." || value === ".." || path.basename(value) !== value) throw new RangeError(`${name} must be a non-empty filename segment.`);
+	return value;
+}
+async function renderQrPngBase64(input, opts = {}) {
+	const scale = resolveQrPngIntegerOption({
+		name: "scale",
+		value: opts.scale,
+		defaultValue: DEFAULT_QR_PNG_SCALE,
+		min: MIN_QR_PNG_SCALE,
+		max: MAX_QR_PNG_SCALE
+	});
+	const marginModules = resolveQrPngIntegerOption({
+		name: "marginModules",
+		value: opts.marginModules,
+		defaultValue: DEFAULT_QR_PNG_MARGIN_MODULES,
+		min: MIN_QR_PNG_MARGIN_MODULES,
+		max: MAX_QR_PNG_MARGIN_MODULES
+	});
+	const { renderPngBase64 } = await loadQrCodeTuiRuntime();
+	return await renderPngBase64(input, {
+		margin: marginModules,
+		scale
+	});
+}
+function formatQrPngDataUrl(base64) {
+	return `${QR_PNG_DATA_URL_PREFIX}${base64}`;
+}
+async function renderQrPngDataUrl(input, opts = {}) {
+	return formatQrPngDataUrl(await renderQrPngBase64(input, opts));
+}
+async function writeQrPngTempFile(input, opts) {
+	const dirPrefix = resolveQrTempPathSegment("dirPrefix", opts.dirPrefix);
+	const fileName = resolveQrTempPathSegment("fileName", opts.fileName ?? "qr.png");
+	const pngBase64 = await renderQrPngBase64(input, opts);
+	const dirPath = await mkdtemp(path.join(opts.tmpRoot, dirPrefix));
+	const filePath = path.join(dirPath, fileName);
+	try {
+		await writeFile(filePath, Buffer.from(pngBase64, "base64"));
+	} catch (err) {
+		await rm(dirPath, {
+			recursive: true,
+			force: true
+		}).catch(() => {});
+		throw err;
+	}
+	return {
+		filePath,
+		dirPath,
+		mediaLocalRoots: [dirPath]
+	};
+}
+//#endregion
+//#region src/media/temp-files.ts
+async function unlinkIfExists(filePath) {
+	if (!filePath) return;
+	try {
+		await fs.unlink(filePath);
+	} catch {}
+}
+//#endregion
+//#region src/media-understanding/audio-transcription-runner.ts
+async function runAudioTranscription(params) {
+	const attachments = params.attachments ?? normalizeMediaAttachments(params.ctx);
+	if (attachments.length === 0) return {
+		transcript: void 0,
+		attachments
+	};
+	const providerRegistry = buildProviderRegistry(params.providers, params.cfg);
+	const cache = createMediaAttachmentCache(attachments, {
+		...params.localPathRoots ? { localPathRoots: params.localPathRoots } : {},
+		ssrfPolicy: params.cfg.tools?.web?.fetch?.ssrfPolicy
+	});
+	try {
+		return {
+			transcript: (await runCapability({
+				capability: "audio",
+				cfg: params.cfg,
+				ctx: params.ctx,
+				attachments: cache,
+				media: attachments,
+				agentDir: params.agentDir,
+				providerRegistry,
+				config: params.cfg.tools?.media?.audio,
+				activeModel: params.activeModel
+			})).outputs.find((entry) => entry.kind === "audio.transcription")?.text?.trim() || void 0,
+			attachments
+		};
+	} finally {
+		await cache.cleanup();
+	}
+}
+//#endregion
+//#region src/media-understanding/audio-preflight.ts
+/**
+* Transcribes the first audio attachment BEFORE mention checking.
+* This allows voice notes to be processed in group chats with requireMention: true.
+* Returns the transcript or undefined if transcription fails or no audio is found.
+*/
+async function transcribeFirstAudio(params) {
+	const { ctx, cfg } = params;
+	if ((cfg.tools?.media?.audio)?.enabled === false) return;
+	const attachments = normalizeMediaAttachments(ctx);
+	if (!attachments || attachments.length === 0) return;
+	const firstAudio = attachments.find((att) => att && isAudioAttachment(att) && !att.alreadyTranscribed);
+	if (!firstAudio) return;
+	if (shouldLogVerbose()) logVerbose(`audio-preflight: transcribing attachment ${firstAudio.index} for mention check`);
+	try {
+		const { transcript } = await runAudioTranscription({
+			ctx,
+			cfg,
+			attachments,
+			agentDir: params.agentDir,
+			providers: params.providers,
+			activeModel: params.activeModel,
+			localPathRoots: resolveMediaAttachmentLocalRoots({
+				cfg,
+				ctx
+			})
+		});
+		if (!transcript) return;
+		firstAudio.alreadyTranscribed = true;
+		if (shouldLogVerbose()) logVerbose(`audio-preflight: transcribed ${transcript.length} chars from attachment ${firstAudio.index}`);
+		return transcript;
+	} catch (err) {
+		if (shouldLogVerbose()) logVerbose(`audio-preflight: transcription failed: ${String(err)}`);
+		return;
+	}
+}
+//#endregion
+//#region src/channels/plugins/outbound/direct-text-media.ts
+function resolveScopedChannelMediaMaxBytes(params) {
+	return resolveChannelMediaMaxBytes({
+		cfg: params.cfg,
+		resolveChannelLimitMb: params.resolveChannelLimitMb,
+		accountId: params.accountId
+	});
+}
+function createScopedChannelMediaMaxBytesResolver(channel) {
+	return (params) => resolveScopedChannelMediaMaxBytes({
+		cfg: params.cfg,
+		accountId: params.accountId,
+		resolveChannelLimitMb: ({ cfg, accountId }) => (cfg.channels?.[channel]?.accounts?.[accountId])?.mediaMaxMb ?? cfg.channels?.[channel]?.mediaMaxMb
+	});
+}
+function createDirectTextMediaOutbound(params) {
+	const sendDirect = async (sendParams) => {
+		const send = params.resolveSender(sendParams.deps);
+		const maxBytes = params.resolveMaxBytes({
+			cfg: sendParams.cfg,
+			accountId: sendParams.accountId
+		});
+		const result = await send(sendParams.to, sendParams.text, sendParams.buildOptions({
+			cfg: sendParams.cfg,
+			mediaUrl: sendParams.mediaUrl,
+			mediaAccess: sendParams.mediaAccess,
+			mediaLocalRoots: sendParams.mediaAccess?.localRoots,
+			mediaReadFile: sendParams.mediaAccess?.readFile,
+			accountId: sendParams.accountId,
+			replyToId: sendParams.replyToId,
+			maxBytes
+		}));
+		return {
+			channel: params.channel,
+			...result
+		};
+	};
+	const outbound = {
+		deliveryMode: "direct",
+		chunker: chunkText,
+		chunkerMode: "text",
+		textChunkLimit: 4e3,
+		sanitizeText: ({ text }) => sanitizeForPlainText(text),
+		sendPayload: async (ctx) => await sendTextMediaPayload({
+			channel: params.channel,
+			ctx,
+			adapter: outbound
+		}),
+		sendText: async ({ cfg, to, text, accountId, deps, replyToId }) => {
+			return await sendDirect({
+				cfg,
+				to,
+				text,
+				accountId,
+				deps,
+				replyToId,
+				buildOptions: params.buildTextOptions
+			});
+		},
+		sendMedia: async ({ cfg, to, text, mediaUrl, mediaAccess, mediaLocalRoots, mediaReadFile, accountId, deps, replyToId }) => {
+			return await sendDirect({
+				cfg,
+				to,
+				text,
+				mediaUrl,
+				mediaAccess: mediaAccess ?? (mediaLocalRoots || mediaReadFile ? {
+					...mediaLocalRoots?.length ? { localRoots: mediaLocalRoots } : {},
+					...mediaReadFile ? { readFile: mediaReadFile } : {}
+				} : void 0),
+				accountId,
+				deps,
+				replyToId,
+				buildOptions: params.buildMediaOptions
+			});
+		}
+	};
+	return outbound;
+}
+//#endregion
+export { unlinkIfExists as a, renderQrPngDataUrl as c, encodePngRgba as d, fillPixel as f, transcribeFirstAudio as i, writeQrPngTempFile as l, createScopedChannelMediaMaxBytesResolver as n, formatQrPngDataUrl as o, pngChunk as p, resolveScopedChannelMediaMaxBytes as r, renderQrPngBase64 as s, createDirectTextMediaOutbound as t, crc32 as u };

package/dist/memory-core-host-runtime-cli-sTNTqMrk.js

@@ -0,0 +1,9 @@
+import "./utils-DaGfogP-.js";
+import "./runtime-CQ7eH0le.js";
+import "./theme-BrRleVfL.js";
+import "./globals-C5IxqXPj.js";
+import "./command-secret-gateway-CeBdQ0UB.js";
+import "./progress-B0hhA4sH.js";
+import "./cli-utils-D3GqJh_O.js";
+import "./help-format-Fg7GgTXl.js";
+export {};

package/dist/message-Bv8VSWOM.js

@@ -0,0 +1,232 @@
+import { i as GATEWAY_CLIENT_NAMES, r as GATEWAY_CLIENT_MODES } from "./client-info-CfESmEX1.js";
+import "./message-channel-BbI8d0sw.js";
+import { a as projectOutboundPayloadPlanForDelivery, s as projectOutboundPayloadPlanForMirror, t as createOutboundPayloadPlan } from "./payloads-UZ7eO_3Y.js";
+import { n as normalizePollInput } from "./polls-BKRXbZMN.js";
+import { t as deliverOutboundPayloads } from "./deliver-BW-R0_jC.js";
+import { n as resolveOutboundChannelPlugin } from "./channel-resolution-ZkY7eiwu.js";
+import { n as resolveMessageChannelSelection } from "./channel-selection-ClvwJ1rQ.js";
+import { t as buildOutboundSessionContext } from "./session-context-Bx2PuSkU.js";
+import { r as resolveOutboundTarget } from "./targets-BWH-RdWm.js";
+//#region src/infra/outbound/message.ts
+let messageConfigRuntimePromise = null;
+let messageGatewayRuntimePromise = null;
+function loadMessageConfigRuntime() {
+	messageConfigRuntimePromise ??= import("./message.config.runtime-N1B9drOV.js");
+	return messageConfigRuntimePromise;
+}
+function loadMessageGatewayRuntime() {
+	messageGatewayRuntimePromise ??= import("./message.gateway.runtime-CagO8Iac.js");
+	return messageGatewayRuntimePromise;
+}
+function buildMessagePollResult(params) {
+	return {
+		channel: params.channel,
+		to: params.to,
+		question: params.normalized.question,
+		options: params.normalized.options,
+		maxSelections: params.normalized.maxSelections,
+		durationSeconds: params.normalized.durationSeconds ?? null,
+		durationHours: params.normalized.durationHours ?? null,
+		via: "gateway",
+		...params.dryRun ? { dryRun: true } : { result: params.result }
+	};
+}
+async function resolveRequiredChannel(params) {
+	return (await resolveMessageChannelSelection({
+		cfg: params.cfg,
+		channel: params.channel
+	})).channel;
+}
+function resolveRequiredPlugin(channel, cfg) {
+	const plugin = resolveOutboundChannelPlugin({
+		channel,
+		cfg
+	});
+	if (!plugin) throw new Error(`Unknown channel: ${channel}`);
+	return plugin;
+}
+function resolveGatewayOptions(opts) {
+	return {
+		url: opts?.mode === GATEWAY_CLIENT_MODES.BACKEND || opts?.clientName === GATEWAY_CLIENT_NAMES.GATEWAY_CLIENT ? void 0 : opts?.url,
+		token: opts?.token,
+		timeoutMs: typeof opts?.timeoutMs === "number" && Number.isFinite(opts.timeoutMs) ? Math.max(1, Math.floor(opts.timeoutMs)) : 1e4,
+		clientName: opts?.clientName ?? GATEWAY_CLIENT_NAMES.CLI,
+		clientDisplayName: opts?.clientDisplayName,
+		mode: opts?.mode ?? GATEWAY_CLIENT_MODES.CLI
+	};
+}
+async function callMessageGateway(params) {
+	const { callGatewayLeastPrivilege } = await loadMessageGatewayRuntime();
+	const gateway = resolveGatewayOptions(params.gateway);
+	return await callGatewayLeastPrivilege({
+		url: gateway.url,
+		token: gateway.token,
+		method: params.method,
+		params: params.params,
+		timeoutMs: gateway.timeoutMs,
+		clientName: gateway.clientName,
+		clientDisplayName: gateway.clientDisplayName,
+		mode: gateway.mode
+	});
+}
+async function resolveMessageConfig(cfg) {
+	if (cfg) return cfg;
+	const { loadConfig } = await loadMessageConfigRuntime();
+	return loadConfig();
+}
+async function resolveGatewayIdempotencyKey(idempotencyKey) {
+	if (idempotencyKey) return idempotencyKey;
+	const { randomIdempotencyKey } = await loadMessageGatewayRuntime();
+	return randomIdempotencyKey();
+}
+async function sendMessage(params) {
+	const cfg = await resolveMessageConfig(params.cfg);
+	const channel = await resolveRequiredChannel({
+		cfg,
+		channel: params.channel
+	});
+	const deliveryMode = resolveRequiredPlugin(channel, cfg).outbound?.deliveryMode ?? "direct";
+	const outboundPlan = createOutboundPayloadPlan([{
+		text: params.content,
+		mediaUrl: params.mediaUrl,
+		mediaUrls: params.mediaUrls
+	}]);
+	const normalizedPayloads = projectOutboundPayloadPlanForDelivery(outboundPlan);
+	const mirrorProjection = projectOutboundPayloadPlanForMirror(outboundPlan);
+	const mirrorText = mirrorProjection.text;
+	const mirrorMediaUrls = mirrorProjection.mediaUrls;
+	const primaryMediaUrl = mirrorMediaUrls[0] ?? params.mediaUrl ?? null;
+	if (params.dryRun) return {
+		channel,
+		to: params.to,
+		via: deliveryMode === "gateway" ? "gateway" : "direct",
+		mediaUrl: primaryMediaUrl,
+		mediaUrls: mirrorMediaUrls.length ? mirrorMediaUrls : void 0,
+		dryRun: true
+	};
+	if (deliveryMode !== "gateway") {
+		const outboundChannel = channel;
+		const resolvedTarget = resolveOutboundTarget({
+			channel: outboundChannel,
+			to: params.to,
+			cfg,
+			accountId: params.accountId,
+			mode: "explicit"
+		});
+		if (!resolvedTarget.ok) throw resolvedTarget.error;
+		const outboundSession = buildOutboundSessionContext({
+			cfg,
+			agentId: params.agentId,
+			sessionKey: params.requesterSessionKey ?? params.mirror?.sessionKey,
+			requesterAccountId: params.requesterAccountId ?? params.accountId,
+			requesterSenderId: params.requesterSenderId,
+			requesterSenderName: params.requesterSenderName,
+			requesterSenderUsername: params.requesterSenderUsername,
+			requesterSenderE164: params.requesterSenderE164
+		});
+		const results = await deliverOutboundPayloads({
+			cfg,
+			channel: outboundChannel,
+			to: resolvedTarget.to,
+			session: outboundSession,
+			accountId: params.accountId,
+			payloads: normalizedPayloads,
+			replyToId: params.replyToId,
+			threadId: params.threadId,
+			gifPlayback: params.gifPlayback,
+			forceDocument: params.forceDocument,
+			deps: params.deps,
+			bestEffort: params.bestEffort,
+			abortSignal: params.abortSignal,
+			silent: params.silent,
+			mirror: params.mirror ? {
+				...params.mirror,
+				text: mirrorText || params.content,
+				mediaUrls: mirrorMediaUrls.length ? mirrorMediaUrls : void 0,
+				idempotencyKey: params.mirror.idempotencyKey ?? params.idempotencyKey
+			} : void 0
+		});
+		return {
+			channel,
+			to: params.to,
+			via: "direct",
+			mediaUrl: primaryMediaUrl,
+			mediaUrls: mirrorMediaUrls.length ? mirrorMediaUrls : void 0,
+			result: results.at(-1)
+		};
+	}
+	const result = await callMessageGateway({
+		gateway: params.gateway,
+		method: "send",
+		params: {
+			to: params.to,
+			message: params.content,
+			mediaUrl: params.mediaUrl,
+			mediaUrls: mirrorMediaUrls.length ? mirrorMediaUrls : params.mediaUrls,
+			gifPlayback: params.gifPlayback,
+			accountId: params.accountId,
+			agentId: params.agentId,
+			channel,
+			replyToId: params.replyToId,
+			sessionKey: params.mirror?.sessionKey,
+			idempotencyKey: await resolveGatewayIdempotencyKey(params.idempotencyKey)
+		}
+	});
+	return {
+		channel,
+		to: params.to,
+		via: "gateway",
+		mediaUrl: primaryMediaUrl,
+		mediaUrls: mirrorMediaUrls.length ? mirrorMediaUrls : void 0,
+		result
+	};
+}
+async function sendPoll(params) {
+	const cfg = await resolveMessageConfig(params.cfg);
+	const channel = await resolveRequiredChannel({
+		cfg,
+		channel: params.channel
+	});
+	const pollInput = {
+		question: params.question,
+		options: params.options,
+		maxSelections: params.maxSelections,
+		durationSeconds: params.durationSeconds,
+		durationHours: params.durationHours
+	};
+	const outbound = resolveRequiredPlugin(channel, cfg)?.outbound;
+	if (!outbound?.sendPoll) throw new Error(`Unsupported poll channel: ${channel}`);
+	const normalized = outbound.pollMaxOptions ? normalizePollInput(pollInput, { maxOptions: outbound.pollMaxOptions }) : normalizePollInput(pollInput);
+	if (params.dryRun) return buildMessagePollResult({
+		channel,
+		to: params.to,
+		normalized,
+		dryRun: true
+	});
+	const result = await callMessageGateway({
+		gateway: params.gateway,
+		method: "poll",
+		params: {
+			to: params.to,
+			question: normalized.question,
+			options: normalized.options,
+			maxSelections: normalized.maxSelections,
+			durationSeconds: normalized.durationSeconds,
+			durationHours: normalized.durationHours,
+			threadId: params.threadId,
+			silent: params.silent,
+			isAnonymous: params.isAnonymous,
+			channel,
+			accountId: params.accountId,
+			idempotencyKey: await resolveGatewayIdempotencyKey(params.idempotencyKey)
+		}
+	});
+	return buildMessagePollResult({
+		channel,
+		to: params.to,
+		normalized,
+		result
+	});
+}
+//#endregion
+export { sendPoll as n, sendMessage as t };

package/dist/message-action-runner-DNNLPZC7.js

@@ -0,0 +1,2 @@
+import { n as runMessageAction, t as getToolResult } from "./message-action-runner-Dx2CS7oR.js";
+export { getToolResult, runMessageAction };