@gaodefa/daocore 2026.5.48 → 2026.5.51

package/dist/channel-z0v-MMYk.js

@@ -0,0 +1,562 @@
+import { a as normalizeLowercaseStringOrEmpty, c as normalizeOptionalString } from "./string-coerce-DyL154ka.js";
+import { t as DEFAULT_ACCOUNT_ID } from "./account-id-B32J-iNN.js";
+import { r as buildChannelConfigSchema } from "./config-schema-CpJ4LFf2.js";
+import { n as resolveChannelGroupRequireMention } from "./group-policy-CRl_OjIo.js";
+import { i as createLazyRuntimeNamedExport } from "./lazy-runtime-D-7_JraP.js";
+import { i as readRemoteMediaBuffer } from "./fetch-CThiKx3T.js";
+import { t as sanitizeForPlainText } from "./sanitize-text-CQuP0iX6.js";
+import { t as createMessageReceiptFromOutboundResults } from "./receipt-vrVTwZtS.js";
+import { s as createScopedChannelConfigAdapter, t as adaptScopedAccountAccessor } from "./channel-config-helpers-CQb9YOAn.js";
+import { n as missingTargetError } from "./target-errors-Cjh6i-kG.js";
+import "./string-coerce-runtime-DcopKqDR.js";
+import { n as describeAccountSnapshot } from "./account-helpers-BEXOONiv.js";
+import { i as createChatChannelPlugin } from "./core-D9SaX41X.js";
+import "./channel-core-Dr6fp5Ub.js";
+import { i as runPassiveAccountLifecycle, t as createAccountStatusSink } from "./channel-lifecycle.core-CDt0hRZR.js";
+import { n as formatNormalizedAllowFromEntries } from "./allow-from-BsbZfqm-.js";
+import { _ as createAllowlistProviderOpenWarningCollector, m as composeAccountWarningCollectors, n as createDangerousNameMatchingMutableAllowlistWarningCollector } from "./channel-policy-Be-Ujzjr.js";
+import { t as createChannelDirectoryAdapter } from "./directory-runtime-C8foW0XO.js";
+import { f as listResolvedDirectoryGroupEntriesFromMapKeys, p as listResolvedDirectoryUserEntriesFromAllowFrom } from "./directory-config-helpers-DoW5C2Kp.js";
+import { t as resolveApprovalApprovers } from "./approval-approvers-BaAy3FfF.js";
+import { t as createResolvedApproverActionAuthAdapter } from "./approval-auth-helpers-DSaKGCWn.js";
+import { t as loadOutboundMediaFromUrl } from "./outbound-media-CaqyBwi1.js";
+import "./outbound-runtime-BWFKdtGY.js";
+import { a as resolveChannelMediaMaxBytes } from "./media-runtime-CPXTkSQr.js";
+import { t as chunkTextForOutbound } from "./text-chunking-ObhJDe8L.js";
+import { t as PAIRING_APPROVED_MESSAGE } from "./pairing-message-DUsvXiNR.js";
+import { d as createDefaultChannelRuntimeState, u as createComputedAccountStatusAdapter } from "./status-helpers-nyf_mfYa.js";
+import { r as GoogleChatConfigSchema } from "./bundled-channel-config-schema-C65cOOX-.js";
+import { n as buildPassiveProbedChannelStatusSummary } from "./extension-shared-D6I0yOLZ.js";
+import "./channel-lifecycle-DDnbT5P-.js";
+import { r as defineChannelMessageAdapter } from "./channel-message-YAmKOwAT.js";
+import { t as extractToolSend } from "./tool-send-CH_ybyG1.js";
+import { a as resolveGoogleChatConfigAccessorAccount, i as resolveGoogleChatAccount, n as listGoogleChatAccountIds, r as resolveDefaultGoogleChatAccountId } from "./accounts-DQk3FQH3.js";
+import "./runtime-api-CZGRk5D1.js";
+import { i as resolveGoogleChatOutboundSpace, n as isGoogleChatUserTarget, r as normalizeGoogleChatTarget, t as isGoogleChatSpaceTarget } from "./targets-DQxwAOx5.js";
+import { n as normalizeCompatibilityConfig, t as legacyConfigRules } from "./doctor-contract-m7RVblE4.js";
+import { n as collectRuntimeConfigAssignments, r as secretTargetRegistryEntries } from "./secret-contract-D5TKi70t.js";
+import { n as googlechatSetupAdapter, t as googlechatSetupWizard } from "./setup-surface-lloytZXk.js";
+//#region extensions/googlechat/src/approval-auth.ts
+function normalizeGoogleChatApproverId(value) {
+	const normalized = normalizeGoogleChatTarget(String(value));
+	if (!normalized || !isGoogleChatUserTarget(normalized)) return;
+	const suffix = normalizeLowercaseStringOrEmpty(normalized.slice(6));
+	if (!suffix || suffix.includes("@")) return;
+	return `users/${suffix}`;
+}
+const googleChatApprovalAuth = createResolvedApproverActionAuthAdapter({
+	channelLabel: "Google Chat",
+	resolveApprovers: ({ cfg, accountId }) => {
+		const account = resolveGoogleChatAccount({
+			cfg,
+			accountId
+		}).config;
+		return resolveApprovalApprovers({
+			allowFrom: account.dm?.allowFrom,
+			defaultTo: account.defaultTo,
+			normalizeApprover: normalizeGoogleChatApproverId
+		});
+	},
+	normalizeSenderId: (value) => normalizeGoogleChatApproverId(value)
+});
+//#endregion
+//#region extensions/googlechat/src/group-policy.ts
+function resolveGoogleChatGroupRequireMention(params) {
+	return resolveChannelGroupRequireMention({
+		cfg: params.cfg,
+		channel: "googlechat",
+		groupId: params.groupId,
+		accountId: params.accountId
+	});
+}
+//#endregion
+//#region extensions/googlechat/src/channel.adapters.ts
+const loadGoogleChatChannelRuntime$2 = createLazyRuntimeNamedExport(() => import("./channel.runtime-CBvyS9OE.js"), "googleChatChannelRuntime");
+function createGoogleChatSendReceipt(params) {
+	const messageId = params.messageId?.trim();
+	return createMessageReceiptFromOutboundResults({
+		results: messageId ? [{
+			channel: "googlechat",
+			messageId,
+			chatId: params.chatId,
+			conversationId: params.chatId
+		}] : [],
+		threadId: params.chatId,
+		kind: params.kind
+	});
+}
+const formatAllowFromEntry = (entry) => normalizeLowercaseStringOrEmpty(entry.trim().replace(/^(googlechat|google-chat|gchat):/i, "").replace(/^user:/i, "").replace(/^users\//i, ""));
+const collectGoogleChatSecurityWarnings = composeAccountWarningCollectors(createAllowlistProviderOpenWarningCollector({
+	providerConfigPresent: (cfg) => cfg.channels?.googlechat !== void 0,
+	resolveGroupPolicy: (account) => account.config.groupPolicy,
+	buildOpenWarning: {
+		surface: "Google Chat spaces",
+		openBehavior: "allows any space to trigger (mention-gated)",
+		remediation: "Set channels.googlechat.groupPolicy=\"allowlist\" and configure channels.googlechat.groups"
+	}
+}), (account) => account.config.dm?.policy === "open" && "- Google Chat DMs are open to anyone. Set channels.googlechat.dm.policy=\"pairing\" or \"allowlist\".");
+const googlechatGroupsAdapter = { resolveRequireMention: resolveGoogleChatGroupRequireMention };
+const googlechatDirectoryAdapter = createChannelDirectoryAdapter({
+	listPeers: async (params) => listResolvedDirectoryUserEntriesFromAllowFrom({
+		...params,
+		resolveAccount: adaptScopedAccountAccessor(resolveGoogleChatAccount),
+		resolveAllowFrom: (account) => account.config.dm?.allowFrom,
+		normalizeId: (entry) => normalizeGoogleChatTarget(entry) ?? entry
+	}),
+	listGroups: async (params) => listResolvedDirectoryGroupEntriesFromMapKeys({
+		...params,
+		resolveAccount: adaptScopedAccountAccessor(resolveGoogleChatAccount),
+		resolveGroups: (account) => account.config.groups
+	})
+});
+const googlechatSecurityAdapter = {
+	dm: {
+		channelKey: "googlechat",
+		resolvePolicy: (account) => account.config.dm?.policy,
+		resolveAllowFrom: (account) => account.config.dm?.allowFrom,
+		allowFromPathSuffix: "dm.",
+		normalizeEntry: (raw) => formatAllowFromEntry(raw)
+	},
+	collectWarnings: collectGoogleChatSecurityWarnings
+};
+const googlechatThreadingAdapter = { scopedAccountReplyToMode: {
+	resolveAccount: (cfg, accountId) => resolveGoogleChatAccount({
+		cfg,
+		accountId
+	}),
+	resolveReplyToMode: (account, _chatType) => account.config.replyToMode,
+	fallback: "off"
+} };
+const googlechatPairingTextAdapter = {
+	idLabel: "googlechatUserId",
+	message: PAIRING_APPROVED_MESSAGE,
+	normalizeAllowEntry: (entry) => formatAllowFromEntry(entry),
+	notify: async ({ cfg, id, message, accountId }) => {
+		const account = resolveGoogleChatAccount({
+			cfg,
+			accountId
+		});
+		if (account.credentialSource === "none") return;
+		const user = normalizeGoogleChatTarget(id) ?? id;
+		const space = await resolveGoogleChatOutboundSpace({
+			account,
+			target: isGoogleChatUserTarget(user) ? user : `users/${user}`
+		});
+		const { sendGoogleChatMessage } = await loadGoogleChatChannelRuntime$2();
+		await sendGoogleChatMessage({
+			account,
+			space,
+			text: message
+		});
+	}
+};
+const googlechatOutboundAdapter = {
+	base: {
+		deliveryMode: "direct",
+		chunker: chunkTextForOutbound,
+		chunkerMode: "markdown",
+		textChunkLimit: 4e3,
+		sanitizeText: ({ text }) => sanitizeForPlainText(text),
+		resolveTarget: ({ to }) => {
+			const trimmed = normalizeOptionalString(to) ?? "";
+			if (trimmed) {
+				const normalized = normalizeGoogleChatTarget(trimmed);
+				if (!normalized) return {
+					ok: false,
+					error: missingTargetError("Google Chat", "<spaces/{space}|users/{user}>")
+				};
+				return {
+					ok: true,
+					to: normalized
+				};
+			}
+			return {
+				ok: false,
+				error: missingTargetError("Google Chat", "<spaces/{space}|users/{user}>")
+			};
+		}
+	},
+	attachedResults: {
+		channel: "googlechat",
+		sendText: async ({ cfg, to, text, accountId, replyToId, threadId }) => {
+			const account = resolveGoogleChatAccount({
+				cfg,
+				accountId
+			});
+			const space = await resolveGoogleChatOutboundSpace({
+				account,
+				target: to
+			});
+			const thread = typeof threadId === "number" ? String(threadId) : threadId ?? replyToId ?? void 0;
+			const { sendGoogleChatMessage } = await loadGoogleChatChannelRuntime$2();
+			const messageId = (await sendGoogleChatMessage({
+				account,
+				space,
+				text,
+				thread
+			}))?.messageName ?? "";
+			return {
+				messageId,
+				chatId: space,
+				receipt: createGoogleChatSendReceipt({
+					messageId,
+					chatId: space,
+					kind: "text"
+				})
+			};
+		},
+		sendMedia: async ({ cfg, to, text, mediaUrl, mediaAccess, mediaLocalRoots, mediaReadFile, accountId, replyToId, threadId }) => {
+			if (!mediaUrl) throw new Error("Google Chat mediaUrl is required.");
+			const account = resolveGoogleChatAccount({
+				cfg,
+				accountId
+			});
+			const space = await resolveGoogleChatOutboundSpace({
+				account,
+				target: to
+			});
+			const thread = typeof threadId === "number" ? String(threadId) : threadId ?? replyToId ?? void 0;
+			const effectiveMaxBytes = resolveChannelMediaMaxBytes({
+				cfg,
+				resolveChannelLimitMb: ({ cfg, accountId }) => (cfg.channels?.googlechat)?.accounts?.[accountId]?.mediaMaxMb ?? (cfg.channels?.googlechat)?.mediaMaxMb,
+				accountId
+			}) ?? (account.config.mediaMaxMb ?? 20) * 1024 * 1024;
+			const loaded = /^https?:\/\//i.test(mediaUrl) ? await readRemoteMediaBuffer({
+				url: mediaUrl,
+				maxBytes: effectiveMaxBytes
+			}) : await loadOutboundMediaFromUrl(mediaUrl, {
+				maxBytes: effectiveMaxBytes,
+				mediaAccess,
+				mediaLocalRoots,
+				mediaReadFile
+			});
+			const { sendGoogleChatMessage, uploadGoogleChatAttachment } = await loadGoogleChatChannelRuntime$2();
+			const upload = await uploadGoogleChatAttachment({
+				account,
+				space,
+				filename: loaded.fileName ?? "attachment",
+				buffer: loaded.buffer,
+				contentType: loaded.contentType
+			});
+			const messageId = (await sendGoogleChatMessage({
+				account,
+				space,
+				text,
+				thread,
+				attachments: upload.attachmentUploadToken ? [{
+					attachmentUploadToken: upload.attachmentUploadToken,
+					contentName: loaded.fileName
+				}] : void 0
+			}))?.messageName ?? "";
+			return {
+				messageId,
+				chatId: space,
+				receipt: createGoogleChatSendReceipt({
+					messageId,
+					chatId: space,
+					kind: "media"
+				})
+			};
+		}
+	}
+};
+const googlechatMessageAdapter = defineChannelMessageAdapter({
+	id: "googlechat",
+	durableFinal: { capabilities: {
+		text: true,
+		media: true,
+		thread: true,
+		messageSendingHooks: true
+	} },
+	send: {
+		text: googlechatOutboundAdapter.attachedResults.sendText,
+		media: googlechatOutboundAdapter.attachedResults.sendMedia
+	}
+});
+//#endregion
+//#region extensions/googlechat/src/doctor.ts
+function asObjectRecord(value) {
+	return value && typeof value === "object" && !Array.isArray(value) ? value : null;
+}
+function isGoogleChatMutableAllowEntry(raw) {
+	const text = raw.trim();
+	if (!text || text === "*") return false;
+	const withoutPrefix = text.replace(/^(googlechat|google-chat|gchat):/i, "").trim();
+	if (!withoutPrefix) return false;
+	return withoutPrefix.replace(/^users\//i, "").includes("@");
+}
+const collectGoogleChatMutableAllowlistWarnings = createDangerousNameMatchingMutableAllowlistWarningCollector({
+	channel: "googlechat",
+	detector: isGoogleChatMutableAllowEntry,
+	collectLists: (scope) => {
+		const lists = [{
+			pathLabel: `${scope.prefix}.groupAllowFrom`,
+			list: scope.account.groupAllowFrom
+		}];
+		const dm = asObjectRecord(scope.account.dm);
+		if (dm) lists.push({
+			pathLabel: `${scope.prefix}.dm.allowFrom`,
+			list: dm.allowFrom
+		});
+		const groups = asObjectRecord(scope.account.groups);
+		if (groups) for (const [groupKey, groupRaw] of Object.entries(groups)) {
+			const group = asObjectRecord(groupRaw);
+			if (!group) continue;
+			lists.push({
+				pathLabel: `${scope.prefix}.groups.${groupKey}.users`,
+				list: group.users
+			});
+		}
+		return lists;
+	}
+});
+//#endregion
+//#region extensions/googlechat/src/gateway.ts
+const loadGoogleChatChannelRuntime$1 = createLazyRuntimeNamedExport(() => import("./channel.runtime-CBvyS9OE.js"), "googleChatChannelRuntime");
+async function startGoogleChatGatewayAccount(ctx) {
+	const account = ctx.account;
+	const statusSink = createAccountStatusSink({
+		accountId: account.accountId,
+		setStatus: ctx.setStatus
+	});
+	ctx.log?.info?.(`[${account.accountId}] starting Google Chat webhook`);
+	const { resolveGoogleChatWebhookPath, startGoogleChatMonitor } = await loadGoogleChatChannelRuntime$1();
+	statusSink({
+		running: true,
+		lastStartAt: Date.now(),
+		webhookPath: resolveGoogleChatWebhookPath({ account }),
+		audienceType: account.config.audienceType,
+		audience: account.config.audience
+	});
+	await runPassiveAccountLifecycle({
+		abortSignal: ctx.abortSignal,
+		start: async () => await startGoogleChatMonitor({
+			account,
+			config: ctx.cfg,
+			runtime: ctx.runtime,
+			abortSignal: ctx.abortSignal,
+			webhookPath: account.config.webhookPath,
+			webhookUrl: account.config.webhookUrl,
+			statusSink
+		}),
+		stop: async (unregister) => {
+			unregister?.();
+		},
+		onStop: async () => {
+			statusSink({
+				running: false,
+				lastStopAt: Date.now()
+			});
+		}
+	});
+}
+//#endregion
+//#region extensions/googlechat/src/channel.ts
+const loadGoogleChatChannelRuntime = createLazyRuntimeNamedExport(() => import("./channel.runtime-CBvyS9OE.js"), "googleChatChannelRuntime");
+const meta = {
+	id: "googlechat",
+	label: "Google Chat",
+	selectionLabel: "Google Chat (Chat API)",
+	docsPath: "/channels/googlechat",
+	docsLabel: "googlechat",
+	blurb: "Google Workspace Chat app with HTTP webhook.",
+	aliases: ["gchat", "google-chat"],
+	order: 55,
+	detailLabel: "Google Chat",
+	systemImage: "message.badge",
+	markdownCapable: true
+};
+const googleChatConfigAdapter = createScopedChannelConfigAdapter({
+	sectionKey: "googlechat",
+	listAccountIds: listGoogleChatAccountIds,
+	resolveAccount: adaptScopedAccountAccessor(resolveGoogleChatAccount),
+	resolveAccessorAccount: resolveGoogleChatConfigAccessorAccount,
+	defaultAccountId: resolveDefaultGoogleChatAccountId,
+	clearBaseFields: [
+		"serviceAccount",
+		"serviceAccountFile",
+		"audienceType",
+		"audience",
+		"webhookPath",
+		"webhookUrl",
+		"botUser",
+		"name"
+	],
+	resolveAllowFrom: (account) => account.config.dm?.allowFrom,
+	formatAllowFrom: (allowFrom) => formatNormalizedAllowFromEntries({
+		allowFrom,
+		normalizeEntry: formatAllowFromEntry
+	}),
+	resolveDefaultTo: (account) => account.config.defaultTo
+});
+const googlechatActions = {
+	describeMessageTool: ({ cfg, accountId }) => {
+		const accounts = accountId ? [resolveGoogleChatAccount({
+			cfg,
+			accountId
+		})].filter((account) => account.enabled && account.credentialSource !== "none") : listGoogleChatAccountIds(cfg).map((id) => resolveGoogleChatAccount({
+			cfg,
+			accountId: id
+		})).filter((account) => account.enabled && account.credentialSource !== "none");
+		if (accounts.length === 0) return null;
+		const actions = new Set(["send", "upload-file"]);
+		if (accounts.some((account) => account.config.actions?.reactions !== false)) {
+			actions.add("react");
+			actions.add("reactions");
+		}
+		return { actions: Array.from(actions) };
+	},
+	extractToolSend: ({ args }) => extractToolSend(args, "sendMessage"),
+	handleAction: async (ctx) => {
+		const { googlechatMessageActions } = await import("./actions-BQ2B4Vhj.js");
+		if (!googlechatMessageActions.handleAction) throw new Error("Google Chat actions are not available.");
+		return await googlechatMessageActions.handleAction(ctx);
+	}
+};
+const googlechatPlugin = createChatChannelPlugin({
+	base: {
+		id: "googlechat",
+		meta: { ...meta },
+		setup: googlechatSetupAdapter,
+		setupWizard: googlechatSetupWizard,
+		capabilities: {
+			chatTypes: [
+				"direct",
+				"group",
+				"thread"
+			],
+			reactions: true,
+			threads: true,
+			media: true,
+			nativeCommands: false,
+			blockStreaming: true
+		},
+		streaming: { blockStreamingCoalesceDefaults: {
+			minChars: 1500,
+			idleMs: 1e3
+		} },
+		reload: { configPrefixes: ["channels.googlechat"] },
+		configSchema: buildChannelConfigSchema(GoogleChatConfigSchema),
+		config: {
+			...googleChatConfigAdapter,
+			isConfigured: (account) => account.credentialSource !== "none",
+			describeAccount: (account) => describeAccountSnapshot({
+				account,
+				configured: account.credentialSource !== "none",
+				extra: { credentialSource: account.credentialSource }
+			})
+		},
+		approvalCapability: googleChatApprovalAuth,
+		secrets: {
+			secretTargetRegistryEntries,
+			collectRuntimeConfigAssignments
+		},
+		groups: googlechatGroupsAdapter,
+		messaging: {
+			targetPrefixes: [
+				"googlechat",
+				"google-chat",
+				"gchat"
+			],
+			normalizeTarget: normalizeGoogleChatTarget,
+			targetResolver: {
+				looksLikeId: (raw, normalized) => {
+					const value = normalized ?? raw.trim();
+					return isGoogleChatSpaceTarget(value) || isGoogleChatUserTarget(value);
+				},
+				hint: "<spaces/{space}|users/{user}>"
+			}
+		},
+		directory: googlechatDirectoryAdapter,
+		message: googlechatMessageAdapter,
+		resolver: { resolveTargets: async ({ inputs, kind }) => {
+			return inputs.map((input) => {
+				const normalized = normalizeGoogleChatTarget(input);
+				if (!normalized) return {
+					input,
+					resolved: false,
+					note: "empty target"
+				};
+				if (kind === "user" && isGoogleChatUserTarget(normalized)) return {
+					input,
+					resolved: true,
+					id: normalized
+				};
+				if (kind === "group" && isGoogleChatSpaceTarget(normalized)) return {
+					input,
+					resolved: true,
+					id: normalized
+				};
+				return {
+					input,
+					resolved: false,
+					note: "use spaces/{space} or users/{user}"
+				};
+			});
+		} },
+		actions: googlechatActions,
+		doctor: {
+			dmAllowFromMode: "nestedOnly",
+			groupModel: "route",
+			groupAllowFromFallbackToAllowFrom: false,
+			warnOnEmptyGroupSenderAllowlist: false,
+			legacyConfigRules,
+			normalizeCompatibilityConfig,
+			collectMutableAllowlistWarnings: collectGoogleChatMutableAllowlistWarnings
+		},
+		status: createComputedAccountStatusAdapter({
+			defaultRuntime: createDefaultChannelRuntimeState(DEFAULT_ACCOUNT_ID),
+			collectStatusIssues: (accounts) => accounts.flatMap((entry) => {
+				const accountId = entry.accountId ?? "default";
+				const enabled = entry.enabled !== false;
+				const configured = entry.configured === true;
+				if (!enabled || !configured) return [];
+				const issues = [];
+				if (!entry.audience) issues.push({
+					channel: "googlechat",
+					accountId,
+					kind: "config",
+					message: "Google Chat audience is missing (set channels.googlechat.audience).",
+					fix: "Set channels.googlechat.audienceType and channels.googlechat.audience."
+				});
+				if (!entry.audienceType) issues.push({
+					channel: "googlechat",
+					accountId,
+					kind: "config",
+					message: "Google Chat audienceType is missing (app-url or project-number).",
+					fix: "Set channels.googlechat.audienceType and channels.googlechat.audience."
+				});
+				return issues;
+			}),
+			buildChannelSummary: ({ snapshot }) => buildPassiveProbedChannelStatusSummary(snapshot, {
+				credentialSource: snapshot.credentialSource ?? "none",
+				audienceType: snapshot.audienceType ?? null,
+				audience: snapshot.audience ?? null,
+				webhookPath: snapshot.webhookPath ?? null,
+				webhookUrl: snapshot.webhookUrl ?? null
+			}),
+			probeAccount: async ({ account }) => (await loadGoogleChatChannelRuntime()).probeGoogleChat(account),
+			resolveAccountSnapshot: ({ account }) => ({
+				accountId: account.accountId,
+				name: account.name,
+				enabled: account.enabled,
+				configured: account.credentialSource !== "none",
+				extra: {
+					credentialSource: account.credentialSource,
+					audienceType: account.config.audienceType,
+					audience: account.config.audience,
+					webhookPath: account.config.webhookPath,
+					webhookUrl: account.config.webhookUrl,
+					dmPolicy: account.config.dm?.policy ?? "pairing"
+				}
+			})
+		}),
+		gateway: { startAccount: startGoogleChatGatewayAccount }
+	},
+	pairing: { text: googlechatPairingTextAdapter },
+	security: googlechatSecurityAdapter,
+	threading: googlechatThreadingAdapter,
+	outbound: googlechatOutboundAdapter
+});
+//#endregion
+export { googlechatPlugin as t };

package/dist/channel.runtime-1o_vRC84.js

@@ -0,0 +1,109 @@
+import { d as normalizeSecretInputString } from "./types.secrets-Ct1DNG7D.js";
+import { t as createAccountStatusSink } from "./channel-lifecycle.core-CDt0hRZR.js";
+import { t as PAIRING_APPROVED_MESSAGE } from "./pairing-message-DUsvXiNR.js";
+import "./channel-lifecycle-DDnbT5P-.js";
+import "./accounts-DcI0wEyL.js";
+import "./runtime-api-CZm1iIlw.js";
+import { i as getMe, n as ZaloApiError, t as resolveZaloProxyFetch } from "./proxy-CVYWu1-7.js";
+import { t as sendMessageZalo } from "./send-I0iE28XZ.js";
+//#region extensions/zalo/src/probe.ts
+async function probeZalo(token, timeoutMs = 5e3, fetcher) {
+	if (!token?.trim()) return {
+		ok: false,
+		error: "No token provided",
+		elapsedMs: 0
+	};
+	const startTime = Date.now();
+	try {
+		const response = await getMe(token.trim(), timeoutMs, fetcher);
+		const elapsedMs = Date.now() - startTime;
+		if (response.ok && response.result) return {
+			ok: true,
+			bot: response.result,
+			elapsedMs
+		};
+		return {
+			ok: false,
+			error: "Invalid response from Zalo API",
+			elapsedMs
+		};
+	} catch (err) {
+		const elapsedMs = Date.now() - startTime;
+		if (err instanceof ZaloApiError) return {
+			ok: false,
+			error: err.description ?? err.message,
+			elapsedMs
+		};
+		if (err instanceof Error) {
+			if (err.name === "AbortError") return {
+				ok: false,
+				error: `Request timed out after ${timeoutMs}ms`,
+				elapsedMs
+			};
+			return {
+				ok: false,
+				error: err.message,
+				elapsedMs
+			};
+		}
+		return {
+			ok: false,
+			error: String(err),
+			elapsedMs
+		};
+	}
+}
+//#endregion
+//#region extensions/zalo/src/channel.runtime.ts
+async function notifyZaloPairingApproval(params) {
+	const { resolveZaloAccount } = await import("./accounts-CiDgcaPY.js");
+	const account = resolveZaloAccount({ cfg: params.cfg });
+	if (!account.token) throw new Error("Zalo token not configured");
+	await sendMessageZalo(params.id, PAIRING_APPROVED_MESSAGE, { token: account.token });
+}
+async function sendZaloText(params) {
+	return await sendMessageZalo(params.to, params.text, params);
+}
+async function probeZaloAccount(params) {
+	return await probeZalo(params.account.token, params.timeoutMs, resolveZaloProxyFetch(params.account.config.proxy));
+}
+async function startZaloGatewayAccount(ctx) {
+	const account = ctx.account;
+	const token = account.token.trim();
+	const mode = account.config.webhookUrl ? "webhook" : "polling";
+	let zaloBotLabel = "";
+	const fetcher = resolveZaloProxyFetch(account.config.proxy);
+	try {
+		const probe = await probeZalo(token, 2500, fetcher);
+		const name = probe.ok ? probe.bot?.name?.trim() : null;
+		if (name) zaloBotLabel = ` (${name})`;
+		if (!probe.ok) ctx.log?.warn?.(`[${account.accountId}] Zalo probe failed before provider start (${String(probe.elapsedMs)}ms): ${probe.error}`);
+		ctx.setStatus({
+			accountId: account.accountId,
+			bot: probe.bot
+		});
+	} catch (err) {
+		ctx.log?.warn?.(`[${account.accountId}] Zalo probe threw before provider start: ${err instanceof Error ? err.stack ?? err.message : String(err)}`);
+	}
+	const statusSink = createAccountStatusSink({
+		accountId: ctx.accountId,
+		setStatus: ctx.setStatus
+	});
+	ctx.log?.info(`[${account.accountId}] starting provider${zaloBotLabel} mode=${mode}`);
+	const { monitorZaloProvider } = await import("./monitor-Dg9KC5G4.js");
+	return monitorZaloProvider({
+		token,
+		account,
+		config: ctx.cfg,
+		runtime: ctx.runtime,
+		abortSignal: ctx.abortSignal,
+		useWebhook: Boolean(account.config.webhookUrl),
+		webhookUrl: account.config.webhookUrl,
+		webhookSecret: normalizeSecretInputString(account.config.webhookSecret),
+		webhookPath: account.config.webhookPath,
+		fetcher,
+		statusSink
+	});
+}
+//#endregion
+export { notifyZaloPairingApproval, probeZaloAccount, sendZaloText, startZaloGatewayAccount };