@pixelzx/genesis 2026.6.28 → 2026.7.8

package/dist/monitor.runtime-BU4RKNXx.js

@@ -0,0 +1,2 @@
+import { t as monitorLineProvider } from "./monitor-BrGXztev.js";
+export { monitorLineProvider };

package/dist/monitor.runtime.js

@@ -1 +1 @@
-export * from "./monitor.runtime-GizvASio.js";
+export * from "./monitor.runtime-BU4RKNXx.js";

package/dist/monitor.webhook-DaTTjWrL.js

@@ -0,0 +1,180 @@
+import { t as safeEqualSecret } from "./secret-equal-CW95TizL.js";
+import { p as resolveClientIp } from "./net-BzaeD_3Q.js";
+import { a as createFixedWindowRateLimiter, o as createWebhookAnomalyTracker, r as WEBHOOK_RATE_LIMIT_DEFAULTS, t as WEBHOOK_ANOMALY_COUNTER_DEFAULTS } from "./webhook-memory-guards-KeWoCE64.js";
+import { r as applyBasicWebhookRequestGuards, s as readJsonWebhookBodyOrReject } from "./webhook-request-guards-CI6TiULn.js";
+import { l as withResolvedWebhookRequestPipeline, n as registerWebhookTargetWithPluginRoute, s as resolveWebhookTargetWithAuthOrRejectSync, t as registerWebhookTarget } from "./webhook-targets-mFxPlIOs.js";
+import "./browser-security-runtime-DXPHFJOj.js";
+import { t as createClaimableDedupe } from "./persistent-dedupe-Bxlz6pC3.js";
+import "./runtime-api-CcUMXjjy.js";
+//#region extensions/zalo/src/monitor.webhook.ts
+const ZALO_WEBHOOK_REPLAY_WINDOW_MS = 5 * 6e4;
+const webhookTargets = /* @__PURE__ */ new Map();
+const webhookRateLimiter = createFixedWindowRateLimiter({
+	windowMs: WEBHOOK_RATE_LIMIT_DEFAULTS.windowMs,
+	maxRequests: WEBHOOK_RATE_LIMIT_DEFAULTS.maxRequests,
+	maxTrackedKeys: WEBHOOK_RATE_LIMIT_DEFAULTS.maxTrackedKeys
+});
+const recentWebhookEvents = createClaimableDedupe({
+	ttlMs: ZALO_WEBHOOK_REPLAY_WINDOW_MS,
+	memoryMaxSize: 5e3
+});
+const webhookAnomalyTracker = createWebhookAnomalyTracker({
+	maxTrackedKeys: WEBHOOK_ANOMALY_COUNTER_DEFAULTS.maxTrackedKeys,
+	ttlMs: WEBHOOK_ANOMALY_COUNTER_DEFAULTS.ttlMs,
+	logEvery: WEBHOOK_ANOMALY_COUNTER_DEFAULTS.logEvery
+});
+function clearZaloWebhookSecurityStateForTest() {
+	webhookRateLimiter.clear();
+	recentWebhookEvents.clearMemory();
+	webhookAnomalyTracker.clear();
+}
+function getZaloWebhookRateLimitStateSizeForTest() {
+	return webhookRateLimiter.size();
+}
+function getZaloWebhookStatusCounterSizeForTest() {
+	return webhookAnomalyTracker.size();
+}
+function timingSafeEquals(left, right) {
+	return safeEqualSecret(left, right);
+}
+function buildReplayEventCacheKey(target, update) {
+	const messageId = update.message?.message_id;
+	if (!messageId) return null;
+	const chatId = update.message?.chat?.id ?? "";
+	const senderId = update.message?.from?.id ?? "";
+	return JSON.stringify([
+		target.path,
+		target.account.accountId,
+		update.event_name,
+		chatId,
+		senderId,
+		messageId
+	]);
+}
+var ZaloRetryableWebhookError = class extends Error {
+	constructor(message, options) {
+		super(message, options);
+		this.name = "ZaloRetryableWebhookError";
+	}
+};
+async function processZaloReplayGuardedUpdate(params) {
+	const replayEventKey = buildReplayEventCacheKey(params.target, params.update);
+	if (replayEventKey) {
+		if ((await recentWebhookEvents.claim(replayEventKey, { now: params.nowMs })).kind !== "claimed") return "duplicate";
+	}
+	params.target.statusSink?.({ lastInboundAt: Date.now() });
+	try {
+		await params.processUpdate({
+			update: params.update,
+			target: params.target
+		});
+		if (replayEventKey) await recentWebhookEvents.commit(replayEventKey);
+		return "processed";
+	} catch (error) {
+		if (replayEventKey) if (error instanceof ZaloRetryableWebhookError) recentWebhookEvents.release(replayEventKey, { error });
+		else await recentWebhookEvents.commit(replayEventKey);
+		throw error;
+	}
+}
+function recordWebhookStatus(runtime, path, statusCode) {
+	webhookAnomalyTracker.record({
+		key: `${path}:${statusCode}`,
+		statusCode,
+		log: runtime?.log,
+		message: (count) => `[zalo] webhook anomaly path=${path} status=${statusCode} count=${String(count)}`
+	});
+}
+function headerValue(value) {
+	return Array.isArray(value) ? value[0] : value;
+}
+function registerZaloWebhookTarget(target, opts) {
+	if (opts?.route) return registerWebhookTargetWithPluginRoute({
+		targetsByPath: webhookTargets,
+		target,
+		route: opts.route,
+		onLastPathTargetRemoved: opts.onLastPathTargetRemoved
+	}).unregister;
+	return registerWebhookTarget(webhookTargets, target, opts).unregister;
+}
+async function handleZaloWebhookRequest(req, res, processUpdate) {
+	return await withResolvedWebhookRequestPipeline({
+		req,
+		res,
+		targetsByPath: webhookTargets,
+		allowMethods: ["POST"],
+		handle: async ({ targets, path }) => {
+			const trustedProxies = targets[0]?.config.gateway?.trustedProxies;
+			const allowRealIpFallback = targets[0]?.config.gateway?.allowRealIpFallback === true;
+			const rateLimitKey = `${path}:${resolveClientIp({
+				remoteAddr: req.socket.remoteAddress,
+				forwardedFor: headerValue(req.headers["x-forwarded-for"]),
+				realIp: headerValue(req.headers["x-real-ip"]),
+				trustedProxies,
+				allowRealIpFallback
+			}) ?? req.socket.remoteAddress ?? "unknown"}`;
+			const nowMs = Date.now();
+			if (!applyBasicWebhookRequestGuards({
+				req,
+				res,
+				rateLimiter: webhookRateLimiter,
+				rateLimitKey,
+				nowMs
+			})) {
+				recordWebhookStatus(targets[0]?.runtime, path, res.statusCode);
+				return true;
+			}
+			const headerToken = String(req.headers["x-bot-api-secret-token"] ?? "");
+			const target = resolveWebhookTargetWithAuthOrRejectSync({
+				targets,
+				res,
+				isMatch: (entry) => timingSafeEquals(entry.secret, headerToken)
+			});
+			if (!target) {
+				recordWebhookStatus(targets[0]?.runtime, path, res.statusCode);
+				return true;
+			}
+			if (!applyBasicWebhookRequestGuards({
+				req,
+				res,
+				requireJsonContentType: true
+			})) {
+				recordWebhookStatus(target.runtime, path, res.statusCode);
+				return true;
+			}
+			const body = await readJsonWebhookBodyOrReject({
+				req,
+				res,
+				maxBytes: 1024 * 1024,
+				timeoutMs: 3e4,
+				emptyObjectOnEmpty: false,
+				invalidJsonMessage: "Bad Request"
+			});
+			if (!body.ok) {
+				recordWebhookStatus(target.runtime, path, res.statusCode);
+				return true;
+			}
+			const raw = body.value;
+			const record = raw && typeof raw === "object" ? raw : null;
+			const update = record && record.ok === true && record.result ? record.result : record ?? void 0;
+			if (!update?.event_name) {
+				res.statusCode = 400;
+				res.end("Bad Request");
+				recordWebhookStatus(target.runtime, path, res.statusCode);
+				return true;
+			}
+			processZaloReplayGuardedUpdate({
+				target,
+				update,
+				processUpdate,
+				nowMs
+			}).catch((err) => {
+				target.runtime.error?.(`[${target.account.accountId}] Zalo webhook failed: ${String(err)}`);
+			});
+			res.statusCode = 200;
+			res.end("ok");
+			return true;
+		}
+	});
+}
+//#endregion
+export { ZaloRetryableWebhookError, clearZaloWebhookSecurityStateForTest, getZaloWebhookRateLimitStateSizeForTest, getZaloWebhookStatusCounterSizeForTest, handleZaloWebhookRequest, processZaloReplayGuardedUpdate, registerZaloWebhookTarget };

package/dist/msteams-CmdWCuQl.js

@@ -0,0 +1,35 @@
+import "./utils-CWrkFsp0.js";
+import "./types.secrets-BbgGt42I.js";
+import "./config-schema-jug-eHfF.js";
+import "./zod-schema.providers-core-CC0dJ5Im.js";
+import "./file-lock-DG9hueEc.js";
+import "./mime-uYFJ8ocK.js";
+import "./ssrf-BR9EvI4i.js";
+import "./fetch-guard-CsgToyd0.js";
+import "./tokens-DUMwK-9w.js";
+import "./json-store-BuW_6QaZ.js";
+import "./store-Il9HLBFt.js";
+import "./dm-policy-shared-6bTNkZt-.js";
+import "./history-C378qdHW.js";
+import "./setup-wizard-helpers-2j--bU0j.js";
+import "./channel-reply-pipeline-BbFpiuUk.js";
+import "./channel-pairing-DQW7B5h7.js";
+import "./status-helpers-pM311_XZ.js";
+import "./http-body-C0x1hv3x.js";
+import { t as createOptionalChannelSetupSurface } from "./channel-setup-6SjcuGHU.js";
+import "./inbound-reply-dispatch-B7wRXjgc.js";
+import "./web-media-DSScZWxE.js";
+import "./outbound-media-C9X7oRIU.js";
+import "./ssrf-policy-ChAc-ige.js";
+import "./session-envelope-tBfpcRRu.js";
+//#region src/plugin-sdk/msteams.ts
+const msteamsSetup = createOptionalChannelSetupSurface({
+	channel: "msteams",
+	label: "Microsoft Teams",
+	npmSpec: "@genesis/msteams",
+	docsPath: "/channels/msteams"
+});
+const msteamsSetupWizard = msteamsSetup.setupWizard;
+const msteamsSetupAdapter = msteamsSetup.setupAdapter;
+//#endregion
+export { msteamsSetupWizard as n, msteamsSetupAdapter as t };

package/dist/music-generation-provider-D1C-gv82.js

@@ -0,0 +1,63 @@
+import { a as isComfyCapabilityConfigured, s as runComfyWorkflow, t as DEFAULT_COMFY_MODEL } from "./workflow-runtime-C0jGj382.js";
+//#region extensions/comfy/music-generation-provider.ts
+const COMFY_MAX_INPUT_IMAGES = 1;
+function toGeneratedTrack(asset) {
+	return {
+		buffer: asset.buffer,
+		mimeType: asset.mimeType,
+		fileName: asset.fileName
+	};
+}
+function resolveInputImage(inputImage) {
+	if (!inputImage) return;
+	if (!inputImage.buffer) throw new Error("Comfy music generation requires loaded reference image bytes.");
+	return {
+		buffer: inputImage.buffer,
+		mimeType: inputImage.mimeType ?? "image/png",
+		fileName: inputImage.fileName
+	};
+}
+function buildComfyMusicGenerationProvider() {
+	return {
+		id: "comfy",
+		label: "ComfyUI",
+		defaultModel: DEFAULT_COMFY_MODEL,
+		models: [DEFAULT_COMFY_MODEL],
+		isConfigured: ({ cfg, agentDir }) => isComfyCapabilityConfigured({
+			cfg,
+			agentDir,
+			capability: "music"
+		}),
+		capabilities: {
+			generate: {},
+			edit: {
+				enabled: true,
+				maxInputImages: COMFY_MAX_INPUT_IMAGES
+			}
+		},
+		async generateMusic(req) {
+			if ((req.inputImages?.length ?? 0) > COMFY_MAX_INPUT_IMAGES) throw new Error(`Comfy music generation supports at most ${COMFY_MAX_INPUT_IMAGES} reference image.`);
+			const result = await runComfyWorkflow({
+				cfg: req.cfg,
+				agentDir: req.agentDir,
+				authStore: req.authStore,
+				prompt: req.prompt,
+				model: req.model,
+				capability: "music",
+				outputKinds: ["audio"],
+				inputImage: resolveInputImage(req.inputImages?.[0])
+			});
+			return {
+				tracks: result.assets.map(toGeneratedTrack),
+				model: result.model,
+				metadata: {
+					promptId: result.promptId,
+					outputNodeIds: result.outputNodeIds,
+					inputImageCount: req.inputImages?.length ?? 0
+				}
+			};
+		}
+	};
+}
+//#endregion
+export { buildComfyMusicGenerationProvider as t };

package/dist/music-generation-provider-Da4aNlMi.js

@@ -0,0 +1,170 @@
+import { c as normalizeOptionalString } from "./string-coerce-DPP_aYVc.js";
+import { n as extensionForMime } from "./mime-uYFJ8ocK.js";
+import { r as fetchWithTimeout } from "./fetch-timeout-DjhWl8zC.js";
+import { r as assertOkOrThrowHttpError } from "./provider-http-errors-BjlTaQX1.js";
+import { a as postJsonRequest, u as resolveProviderHttpRequestConfig } from "./shared-CfvUPtvc.js";
+import "./text-runtime-DVUvIDNC.js";
+import { t as isProviderApiKeyConfigured } from "./provider-auth-hCEy91hA.js";
+import "./media-mime-CF0YSNhP.js";
+import "./provider-http-BpPt7Muz.js";
+import { a as resolveApiKeyForProvider } from "./provider-auth-runtime-aZ5vluMN.js";
+//#region extensions/minimax/music-generation-provider.ts
+const DEFAULT_MINIMAX_MUSIC_BASE_URL = "https://api.minimax.io";
+const DEFAULT_MINIMAX_MUSIC_MODEL = "music-2.5+";
+const DEFAULT_TIMEOUT_MS = 12e4;
+function resolveMinimaxMusicBaseUrl(cfg) {
+	const direct = normalizeOptionalString(cfg?.models?.providers?.minimax?.baseUrl);
+	if (!direct) return DEFAULT_MINIMAX_MUSIC_BASE_URL;
+	try {
+		return new URL(direct).origin;
+	} catch {
+		return DEFAULT_MINIMAX_MUSIC_BASE_URL;
+	}
+}
+function assertMinimaxBaseResp(baseResp, context) {
+	if (!baseResp || typeof baseResp.status_code !== "number" || baseResp.status_code === 0) return;
+	throw new Error(`${context} (${baseResp.status_code}): ${baseResp.status_msg ?? "unknown error"}`);
+}
+function decodePossibleBinary(data) {
+	const trimmed = data.trim();
+	if (/^[0-9a-f]+$/iu.test(trimmed) && trimmed.length % 2 === 0) return Buffer.from(trimmed, "hex");
+	return Buffer.from(trimmed, "base64");
+}
+function decodePossibleText(data) {
+	const trimmed = data.trim();
+	if (!trimmed) return "";
+	if (/^[0-9a-f]+$/iu.test(trimmed) && trimmed.length % 2 === 0) return Buffer.from(trimmed, "hex").toString("utf8").trim();
+	return trimmed;
+}
+function isLikelyRemoteUrl(value) {
+	const trimmed = normalizeOptionalString(value);
+	return Boolean(trimmed && /^https?:\/\//iu.test(trimmed));
+}
+async function downloadTrackFromUrl(params) {
+	const response = await fetchWithTimeout(params.url, { method: "GET" }, params.timeoutMs ?? DEFAULT_TIMEOUT_MS, params.fetchFn);
+	await assertOkOrThrowHttpError(response, "MiniMax generated music download failed");
+	const mimeType = normalizeOptionalString(response.headers.get("content-type")) ?? "audio/mpeg";
+	const ext = extensionForMime(mimeType)?.replace(/^\./u, "") || "mp3";
+	return {
+		buffer: Buffer.from(await response.arrayBuffer()),
+		mimeType,
+		fileName: `track-1.${ext}`
+	};
+}
+function buildPrompt(req) {
+	const parts = [req.prompt.trim()];
+	if (typeof req.durationSeconds === "number" && Number.isFinite(req.durationSeconds)) parts.push(`Target duration: about ${Math.max(1, Math.round(req.durationSeconds))} seconds.`);
+	return parts.join("\n\n");
+}
+function resolveMinimaxMusicModel(model) {
+	const trimmed = normalizeOptionalString(model);
+	if (!trimmed) return DEFAULT_MINIMAX_MUSIC_MODEL;
+	return trimmed;
+}
+function buildMinimaxMusicGenerationProvider() {
+	return {
+		id: "minimax",
+		label: "MiniMax",
+		defaultModel: DEFAULT_MINIMAX_MUSIC_MODEL,
+		models: [
+			DEFAULT_MINIMAX_MUSIC_MODEL,
+			"music-2.5",
+			"music-2.0"
+		],
+		isConfigured: ({ agentDir }) => isProviderApiKeyConfigured({
+			provider: "minimax",
+			agentDir
+		}),
+		capabilities: {
+			generate: {
+				maxTracks: 1,
+				supportsLyrics: true,
+				supportsInstrumental: true,
+				supportsDuration: true,
+				supportsFormat: true,
+				supportedFormats: ["mp3"]
+			},
+			edit: { enabled: false }
+		},
+		async generateMusic(req) {
+			if ((req.inputImages?.length ?? 0) > 0) throw new Error("MiniMax music generation does not support image reference inputs.");
+			if (req.instrumental === true && normalizeOptionalString(req.lyrics)) throw new Error("MiniMax music generation cannot use lyrics when instrumental=true.");
+			if (req.format && req.format !== "mp3") throw new Error("MiniMax music generation currently supports mp3 output only.");
+			const auth = await resolveApiKeyForProvider({
+				provider: "minimax",
+				cfg: req.cfg,
+				agentDir: req.agentDir,
+				store: req.authStore
+			});
+			if (!auth.apiKey) throw new Error("MiniMax API key missing");
+			const fetchFn = fetch;
+			const { baseUrl, allowPrivateNetwork, headers, dispatcherPolicy } = resolveProviderHttpRequestConfig({
+				baseUrl: resolveMinimaxMusicBaseUrl(req.cfg),
+				defaultBaseUrl: DEFAULT_MINIMAX_MUSIC_BASE_URL,
+				allowPrivateNetwork: false,
+				defaultHeaders: { Authorization: `Bearer ${auth.apiKey}` }
+			});
+			const jsonHeaders = new Headers(headers);
+			jsonHeaders.set("Content-Type", "application/json");
+			const model = resolveMinimaxMusicModel(req.model);
+			const lyrics = normalizeOptionalString(req.lyrics);
+			const body = {
+				model,
+				prompt: buildPrompt(req),
+				...req.instrumental === true ? { is_instrumental: true } : {},
+				...lyrics ? { lyrics } : req.instrumental === true ? {} : { lyrics_optimizer: true },
+				output_format: "url",
+				audio_setting: {
+					sample_rate: 44100,
+					bitrate: 256e3,
+					format: "mp3"
+				}
+			};
+			const { response: res, release } = await postJsonRequest({
+				url: `${baseUrl}/v1/music_generation`,
+				headers: jsonHeaders,
+				body,
+				timeoutMs: req.timeoutMs ?? DEFAULT_TIMEOUT_MS,
+				fetchFn,
+				pinDns: false,
+				allowPrivateNetwork,
+				dispatcherPolicy
+			});
+			try {
+				await assertOkOrThrowHttpError(res, "MiniMax music generation failed");
+				const payload = await res.json();
+				assertMinimaxBaseResp(payload.base_resp, "MiniMax music generation failed");
+				const audioCandidate = normalizeOptionalString(payload.audio) ?? normalizeOptionalString(payload.data?.audio);
+				const audioUrl = normalizeOptionalString(payload.audio_url) || normalizeOptionalString(payload.data?.audio_url) || (isLikelyRemoteUrl(audioCandidate) ? audioCandidate : void 0);
+				const inlineAudio = isLikelyRemoteUrl(audioCandidate) ? void 0 : audioCandidate;
+				const lyrics = decodePossibleText(payload.lyrics ?? payload.data?.lyrics ?? "");
+				const track = audioUrl ? await downloadTrackFromUrl({
+					url: audioUrl,
+					timeoutMs: req.timeoutMs,
+					fetchFn
+				}) : inlineAudio ? {
+					buffer: decodePossibleBinary(inlineAudio),
+					mimeType: "audio/mpeg",
+					fileName: "track-1.mp3"
+				} : null;
+				if (!track) throw new Error("MiniMax music generation response missing audio output");
+				return {
+					tracks: [track],
+					...lyrics ? { lyrics: [lyrics] } : {},
+					model,
+					metadata: {
+						...normalizeOptionalString(payload.task_id) ? { taskId: normalizeOptionalString(payload.task_id) } : {},
+						...audioUrl ? { audioUrl } : {},
+						instrumental: req.instrumental === true,
+						...lyrics ? { requestedLyrics: true } : {},
+						...typeof req.durationSeconds === "number" ? { requestedDurationSeconds: req.durationSeconds } : {}
+					}
+				};
+			} finally {
+				await release();
+			}
+		}
+	};
+}
+//#endregion
+export { buildMinimaxMusicGenerationProvider as t };