@kodelyth/zalouser 2026.5.39 → 2026.6.1

package/dist/setup-entry.js

@@ -0,0 +1,11 @@
+import { defineBundledChannelSetupEntry } from "klaw/plugin-sdk/channel-entry-contract";
+//#region extensions/zalouser/setup-entry.ts
+var setup_entry_default = defineBundledChannelSetupEntry({
+	importMetaUrl: import.meta.url,
+	plugin: {
+		specifier: "./setup-plugin-api.js",
+		exportName: "zalouserSetupPlugin"
+	}
+});
+//#endregion
+export { setup_entry_default as default };

package/dist/setup-plugin-api.js

@@ -0,0 +1,2 @@
+import { t as zalouserSetupPlugin } from "./channel.setup-CqyWwqcQ.js";
+export { zalouserSetupPlugin };

package/dist/setup-surface-Cfj4GQlB.js

@@ -0,0 +1,360 @@
+import { a as resolveZalouserAccountSync, i as resolveDefaultZalouserAccountId, r as listZalouserAccountIds, t as checkZcaAuthenticated } from "./accounts-DOefD_if.js";
+import { i as writeQrDataUrlToTempFile } from "./shared-DjK0e2FC.js";
+import { b as waitForZaloQrLogin, c as logoutZaloProfile, d as resolveZaloGroupsByEntries, l as resolveZaloAllowFromEntries, y as startZaloQrLogin } from "./zalo-js-B80cRyDF.js";
+import { DEFAULT_ACCOUNT_ID, addWildcardAllowFrom, createSetupTranslator, formatCliCommand, formatDocsLink, formatResolvedUnresolvedNote, mergeAllowFromEntries, normalizeAccountId, patchScopedAccountConfig } from "klaw/plugin-sdk/setup";
+//#region \0rolldown/runtime.js
+var __defProp = Object.defineProperty;
+var __exportAll = (all, no_symbols) => {
+	let target = {};
+	for (var name in all) __defProp(target, name, {
+		get: all[name],
+		enumerable: true
+	});
+	if (!no_symbols) __defProp(target, Symbol.toStringTag, { value: "Module" });
+	return target;
+};
+//#endregion
+//#region extensions/zalouser/src/setup-surface.ts
+var setup_surface_exports = /* @__PURE__ */ __exportAll({ zalouserSetupWizard: () => zalouserSetupWizard });
+const t = createSetupTranslator();
+const channel = "zalouser";
+const ZALOUSER_ALLOW_FROM_PLACEHOLDER = t("wizard.zalouser.allowFromPlaceholder");
+const ZALOUSER_GROUPS_PLACEHOLDER = t("wizard.zalouser.groupsPlaceholder");
+const ZALOUSER_DM_ACCESS_TITLE = t("wizard.zalouser.dmAccessTitle");
+const ZALOUSER_ALLOWLIST_TITLE = t("wizard.zalouser.allowlistTitle");
+const ZALOUSER_GROUPS_TITLE = t("wizard.zalouser.groupsTitle");
+function parseZalouserEntries(raw) {
+	return raw.split(/[\n,;]+/g).map((entry) => entry.trim()).filter(Boolean);
+}
+function setZalouserAccountScopedConfig(cfg, accountId, defaultPatch, accountPatch = defaultPatch) {
+	return patchScopedAccountConfig({
+		cfg,
+		channelKey: channel,
+		accountId,
+		patch: defaultPatch,
+		accountPatch
+	});
+}
+function setZalouserDmPolicy(cfg, accountId, policy) {
+	const resolvedAccountId = normalizeAccountId(accountId) ?? DEFAULT_ACCOUNT_ID;
+	const resolved = resolveZalouserAccountSync({
+		cfg,
+		accountId: resolvedAccountId
+	});
+	return setZalouserAccountScopedConfig(cfg, resolvedAccountId, {
+		dmPolicy: policy,
+		...policy === "open" ? { allowFrom: addWildcardAllowFrom(resolved.config.allowFrom) } : {}
+	}, {
+		dmPolicy: policy,
+		...policy === "open" ? { allowFrom: addWildcardAllowFrom(resolved.config.allowFrom) } : {}
+	});
+}
+function setZalouserGroupPolicy(cfg, accountId, groupPolicy) {
+	return setZalouserAccountScopedConfig(cfg, accountId, { groupPolicy });
+}
+function setZalouserGroupAllowlist(cfg, accountId, groupKeys) {
+	return setZalouserAccountScopedConfig(cfg, accountId, { groups: Object.fromEntries(groupKeys.map((key) => [key, {
+		enabled: true,
+		requireMention: true
+	}])) });
+}
+function ensureZalouserPluginEnabled(cfg) {
+	const next = {
+		...cfg,
+		plugins: {
+			...cfg.plugins,
+			entries: {
+				...cfg.plugins?.entries,
+				zalouser: {
+					...cfg.plugins?.entries?.zalouser,
+					enabled: true
+				}
+			}
+		}
+	};
+	const allow = next.plugins?.allow;
+	if (!Array.isArray(allow) || allow.includes(channel)) return next;
+	return {
+		...next,
+		plugins: {
+			...next.plugins,
+			allow: [...allow, channel]
+		}
+	};
+}
+async function noteZalouserHelp(prompter) {
+	await prompter.note([
+		t("wizard.zalouser.helpQrLogin"),
+		"",
+		t("wizard.zalouser.helpZcaJs"),
+		"",
+		`Docs: ${formatDocsLink("/channels/zalouser", "zalouser")}`
+	].join("\n"), t("wizard.zalouser.setupTitle"));
+}
+async function promptZalouserAllowFrom(params) {
+	const { cfg, prompter, accountId } = params;
+	const resolved = resolveZalouserAccountSync({
+		cfg,
+		accountId
+	});
+	const existingAllowFrom = resolved.config.allowFrom ?? [];
+	while (true) {
+		const parts = parseZalouserEntries(await prompter.text({
+			message: t("wizard.zalouser.allowFromPrompt"),
+			placeholder: ZALOUSER_ALLOW_FROM_PLACEHOLDER,
+			initialValue: existingAllowFrom.length > 0 ? existingAllowFrom.join(", ") : void 0
+		}));
+		if (parts.length === 0) {
+			await prompter.note([
+				t("wizard.zalouser.noDmAllowlist"),
+				t("wizard.zalouser.directChatsBlocked"),
+				t("wizard.zalouser.peersLookupTip", { command: formatCliCommand("klaw directory peers list --channel zalouser") })
+			].join("\n"), ZALOUSER_ALLOWLIST_TITLE);
+			return setZalouserAccountScopedConfig(cfg, accountId, {
+				dmPolicy: "allowlist",
+				allowFrom: []
+			});
+		}
+		const resolvedEntries = await resolveZaloAllowFromEntries({
+			profile: resolved.profile,
+			entries: parts
+		});
+		const unresolved = resolvedEntries.filter((item) => !item.resolved).map((item) => item.input);
+		if (unresolved.length > 0) {
+			await prompter.note(t("wizard.zalouser.couldNotResolve", { entries: unresolved.join(", ") }), ZALOUSER_ALLOWLIST_TITLE);
+			continue;
+		}
+		const unique = mergeAllowFromEntries(existingAllowFrom, resolvedEntries.filter((item) => item.resolved && item.id).map((item) => item.id));
+		const notes = resolvedEntries.filter((item) => item.note).map((item) => `${item.input} -> ${item.id} (${item.note})`);
+		if (notes.length > 0) await prompter.note(notes.join("\n"), ZALOUSER_ALLOWLIST_TITLE);
+		return setZalouserAccountScopedConfig(cfg, accountId, {
+			dmPolicy: "allowlist",
+			allowFrom: unique
+		});
+	}
+}
+const zalouserDmPolicy = {
+	label: "Zalo Personal",
+	channel,
+	policyKey: "channels.zalouser.dmPolicy",
+	allowFromKey: "channels.zalouser.allowFrom",
+	resolveConfigKeys: (cfg, accountId) => (accountId ?? resolveDefaultZalouserAccountId(cfg)) !== DEFAULT_ACCOUNT_ID ? {
+		policyKey: `channels.zalouser.accounts.${accountId ?? resolveDefaultZalouserAccountId(cfg)}.dmPolicy`,
+		allowFromKey: `channels.zalouser.accounts.${accountId ?? resolveDefaultZalouserAccountId(cfg)}.allowFrom`
+	} : {
+		policyKey: "channels.zalouser.dmPolicy",
+		allowFromKey: "channels.zalouser.allowFrom"
+	},
+	getCurrent: (cfg, accountId) => resolveZalouserAccountSync({
+		cfg,
+		accountId: accountId ?? resolveDefaultZalouserAccountId(cfg)
+	}).config.dmPolicy ?? "pairing",
+	setPolicy: (cfg, policy, accountId) => setZalouserDmPolicy(cfg, accountId ?? resolveDefaultZalouserAccountId(cfg), policy),
+	promptAllowFrom: async ({ cfg, prompter, accountId }) => {
+		return await promptZalouserAllowFrom({
+			cfg,
+			prompter,
+			accountId: accountId && normalizeAccountId(accountId) ? normalizeAccountId(accountId) ?? DEFAULT_ACCOUNT_ID : resolveDefaultZalouserAccountId(cfg)
+		});
+	}
+};
+async function promptZalouserQuickstartDmPolicy(params) {
+	const { cfg, prompter, accountId } = params;
+	const resolved = resolveZalouserAccountSync({
+		cfg,
+		accountId
+	});
+	const existingPolicy = resolved.config.dmPolicy ?? "pairing";
+	const existingAllowFrom = resolved.config.allowFrom ?? [];
+	const existingLabel = existingAllowFrom.length > 0 ? existingAllowFrom.join(", ") : "unset";
+	await prompter.note([
+		t("wizard.zalouser.dmHelpSeparate"),
+		t("wizard.zalouser.dmHelpPairing"),
+		t("wizard.zalouser.dmHelpAllowlist"),
+		t("wizard.zalouser.dmHelpOpen"),
+		t("wizard.zalouser.dmHelpDisabled"),
+		"",
+		`Current: dmPolicy=${existingPolicy}, allowFrom=${existingLabel}`,
+		t("wizard.zalouser.dmHelpAllowlistEmpty")
+	].join("\n"), ZALOUSER_DM_ACCESS_TITLE);
+	const policy = await prompter.select({
+		message: t("wizard.zalouser.dmPolicyPrompt"),
+		options: [
+			{
+				value: "pairing",
+				label: t("wizard.channels.dmPolicyPairing")
+			},
+			{
+				value: "allowlist",
+				label: t("wizard.channels.dmPolicyAllowlistOption")
+			},
+			{
+				value: "open",
+				label: t("wizard.channels.dmPolicyOpenOption")
+			},
+			{
+				value: "disabled",
+				label: t("wizard.channels.dmPolicyDisabledOption")
+			}
+		],
+		initialValue: existingPolicy
+	});
+	if (policy === "allowlist") return await promptZalouserAllowFrom({
+		cfg,
+		prompter,
+		accountId
+	});
+	return setZalouserDmPolicy(cfg, accountId, policy);
+}
+const zalouserSetupWizard = {
+	channel,
+	status: {
+		configuredLabel: t("wizard.channels.statusLoggedIn"),
+		unconfiguredLabel: t("wizard.channels.statusNeedsQrLogin"),
+		configuredHint: t("wizard.channels.statusRecommendedLoggedIn"),
+		unconfiguredHint: t("wizard.channels.statusRecommendedQrLogin"),
+		configuredScore: 1,
+		unconfiguredScore: 15,
+		resolveConfigured: async ({ cfg, accountId }) => {
+			const ids = accountId ? [accountId] : listZalouserAccountIds(cfg);
+			for (const resolvedAccountId of ids) if (await checkZcaAuthenticated(resolveZalouserAccountSync({
+				cfg,
+				accountId: resolvedAccountId
+			}).profile)) return true;
+			return false;
+		},
+		resolveStatusLines: async ({ cfg, accountId, configured }) => {
+			return [`${accountId && accountId !== DEFAULT_ACCOUNT_ID ? `Zalo Personal (${accountId})` : "Zalo Personal"}: ${configured ? "logged in" : "needs QR login"}`];
+		}
+	},
+	prepare: async ({ cfg, accountId, prompter, options }) => {
+		let next = cfg;
+		const account = resolveZalouserAccountSync({
+			cfg: next,
+			accountId
+		});
+		if (!await checkZcaAuthenticated(account.profile)) {
+			await noteZalouserHelp(prompter);
+			if (await prompter.confirm({
+				message: t("wizard.zalouser.loginQrPrompt"),
+				initialValue: true
+			})) {
+				const start = await startZaloQrLogin({
+					profile: account.profile,
+					timeoutMs: 35e3
+				});
+				if (start.qrDataUrl) {
+					const qrPath = await writeQrDataUrlToTempFile(start.qrDataUrl, account.profile);
+					await prompter.note([
+						start.message,
+						qrPath ? t("wizard.zalouser.qrImageSaved", { path: qrPath }) : t("wizard.zalouser.qrImageWriteFailed"),
+						t("wizard.zalouser.scanApproveContinue")
+					].join("\n"), t("wizard.zalouser.qrLoginTitle"));
+					if (await prompter.confirm({
+						message: t("wizard.zalouser.qrScannedPrompt"),
+						initialValue: true
+					})) {
+						const waited = await waitForZaloQrLogin({
+							profile: account.profile,
+							timeoutMs: 12e4
+						});
+						await prompter.note(waited.message, waited.connected ? t("common.done") : t("wizard.zalouser.loginPendingTitle"));
+					}
+				} else await prompter.note(start.message, t("wizard.zalouser.loginPendingTitle"));
+			}
+		} else if (!await prompter.confirm({
+			message: t("wizard.zalouser.keepSessionPrompt"),
+			initialValue: true
+		})) {
+			await logoutZaloProfile(account.profile);
+			const start = await startZaloQrLogin({
+				profile: account.profile,
+				force: true,
+				timeoutMs: 35e3
+			});
+			if (start.qrDataUrl) {
+				const qrPath = await writeQrDataUrlToTempFile(start.qrDataUrl, account.profile);
+				await prompter.note([start.message, qrPath ? t("wizard.zalouser.qrImageSaved", { path: qrPath }) : void 0].filter(Boolean).join("\n"), t("wizard.zalouser.qrLoginTitle"));
+				const waited = await waitForZaloQrLogin({
+					profile: account.profile,
+					timeoutMs: 12e4
+				});
+				await prompter.note(waited.message, waited.connected ? t("common.done") : t("wizard.zalouser.loginPendingTitle"));
+			}
+		}
+		next = setZalouserAccountScopedConfig(next, accountId, { profile: account.profile !== "default" ? account.profile : void 0 }, {
+			profile: account.profile,
+			enabled: true
+		});
+		if (options?.quickstartDefaults) next = await promptZalouserQuickstartDmPolicy({
+			cfg: next,
+			prompter,
+			accountId
+		});
+		return { cfg: next };
+	},
+	credentials: [],
+	groupAccess: {
+		label: "Zalo groups",
+		placeholder: ZALOUSER_GROUPS_PLACEHOLDER,
+		currentPolicy: ({ cfg, accountId }) => resolveZalouserAccountSync({
+			cfg,
+			accountId
+		}).config.groupPolicy ?? "allowlist",
+		currentEntries: ({ cfg, accountId }) => Object.keys(resolveZalouserAccountSync({
+			cfg,
+			accountId
+		}).config.groups ?? {}),
+		updatePrompt: ({ cfg, accountId }) => Boolean(resolveZalouserAccountSync({
+			cfg,
+			accountId
+		}).config.groups),
+		setPolicy: ({ cfg, accountId, policy }) => setZalouserGroupPolicy(cfg, accountId, policy),
+		resolveAllowlist: async ({ cfg, accountId, entries, prompter }) => {
+			if (entries.length === 0) {
+				await prompter.note([
+					t("wizard.zalouser.noGroupAllowlist"),
+					t("wizard.zalouser.groupChatsBlocked"),
+					t("wizard.zalouser.groupsLookupTip", { command: formatCliCommand("klaw directory groups list --channel zalouser") }),
+					t("wizard.zalouser.groupMentionRequirement")
+				].join("\n"), ZALOUSER_GROUPS_TITLE);
+				return [];
+			}
+			const updatedAccount = resolveZalouserAccountSync({
+				cfg,
+				accountId
+			});
+			try {
+				const resolved = await resolveZaloGroupsByEntries({
+					profile: updatedAccount.profile,
+					entries
+				});
+				const resolvedIds = resolved.filter((entry) => entry.resolved && entry.id).map((entry) => entry.id);
+				const unresolved = resolved.filter((entry) => !entry.resolved).map((entry) => entry.input);
+				const keys = [...resolvedIds, ...unresolved.map((entry) => entry.trim()).filter(Boolean)];
+				const resolution = formatResolvedUnresolvedNote({
+					resolved: resolvedIds,
+					unresolved
+				});
+				if (resolution) await prompter.note(resolution, ZALOUSER_GROUPS_TITLE);
+				return keys;
+			} catch (err) {
+				await prompter.note(t("wizard.zalouser.groupLookupFailed", { error: String(err) }), ZALOUSER_GROUPS_TITLE);
+				return entries.map((entry) => entry.trim()).filter(Boolean);
+			}
+		},
+		applyAllowlist: ({ cfg, accountId, resolved }) => setZalouserGroupAllowlist(cfg, accountId, resolved)
+	},
+	finalize: async ({ cfg, accountId, forceAllowFrom, options, prompter }) => {
+		let next = cfg;
+		if (forceAllowFrom && !options?.quickstartDefaults) next = await promptZalouserAllowFrom({
+			cfg: next,
+			prompter,
+			accountId
+		});
+		return { cfg: ensureZalouserPluginEnabled(next) };
+	},
+	dmPolicy: zalouserDmPolicy
+};
+//#endregion
+export { zalouserSetupWizard as n, setup_surface_exports as t };

package/dist/shared-DjK0e2FC.js

@@ -0,0 +1,160 @@
+import { a as resolveZalouserAccountSync, i as resolveDefaultZalouserAccountId, r as listZalouserAccountIds, t as checkZcaAuthenticated } from "./accounts-DOefD_if.js";
+import { n as normalizeCompatibilityConfig, t as legacyConfigRules } from "./doctor-contract-B9EvrW0j.js";
+import { n as isZalouserMutableGroupEntry } from "./security-audit-D_rftvs-.js";
+import { formatAllowFromLowercase } from "klaw/plugin-sdk/allow-from";
+import { AllowFromListSchema, DmPolicySchema, GroupPolicySchema, MarkdownConfigSchema, ToolPolicySchema, buildCatchallMultiAccountChannelSchema, buildChannelConfigSchema } from "klaw/plugin-sdk/channel-config-schema";
+import { DEFAULT_ACCOUNT_ID, normalizeAccountId } from "klaw/plugin-sdk/core";
+import { isDangerousNameMatchingEnabled as isDangerousNameMatchingEnabled$1 } from "klaw/plugin-sdk/dangerous-name-runtime";
+import { chunkTextForOutbound } from "klaw/plugin-sdk/text-chunking";
+import { isNumericTargetId, sendPayloadWithChunkedTextAndMedia } from "klaw/plugin-sdk/reply-payload";
+import { adaptScopedAccountAccessor, createScopedChannelConfigAdapter } from "klaw/plugin-sdk/channel-config-helpers";
+import fsp from "node:fs/promises";
+import path from "node:path";
+import { resolvePreferredKlawTmpDir } from "klaw/plugin-sdk/temp-path";
+import { createDelegatedSetupWizardProxy, createPatchedAccountSetupAdapter, createSetupTranslator } from "klaw/plugin-sdk/setup-runtime";
+import { describeAccountSnapshot } from "klaw/plugin-sdk/account-helpers";
+import { z } from "zod";
+import { createDangerousNameMatchingMutableAllowlistWarningCollector } from "klaw/plugin-sdk/channel-policy";
+//#region extensions/zalouser/src/qr-temp-file.ts
+async function writeQrDataUrlToTempFile(qrDataUrl, profile) {
+	const base64 = (qrDataUrl.trim().match(/^data:image\/png;base64,(.+)$/i)?.[1] ?? "").trim();
+	if (!base64) return null;
+	const safeProfile = profile.replace(/[^a-zA-Z0-9_-]+/g, "-") || "default";
+	const filePath = path.join(resolvePreferredKlawTmpDir(), `klaw-zalouser-qr-${safeProfile}.png`);
+	await fsp.writeFile(filePath, Buffer.from(base64, "base64"));
+	return filePath;
+}
+//#endregion
+//#region extensions/zalouser/src/setup-core.ts
+const t = createSetupTranslator();
+const channel = "zalouser";
+const zalouserSetupAdapter = createPatchedAccountSetupAdapter({
+	channelKey: channel,
+	validateInput: () => null,
+	buildPatch: () => ({})
+});
+function createZalouserSetupWizardProxy(loadWizard) {
+	return createDelegatedSetupWizardProxy({
+		channel,
+		loadWizard,
+		status: {
+			configuredLabel: t("wizard.channels.statusLoggedIn"),
+			unconfiguredLabel: t("wizard.channels.statusNeedsQrLogin"),
+			configuredHint: t("wizard.channels.statusRecommendedLoggedIn"),
+			unconfiguredHint: t("wizard.channels.statusRecommendedQrLogin"),
+			configuredScore: 1,
+			unconfiguredScore: 15
+		},
+		credentials: [],
+		delegatePrepare: true,
+		delegateFinalize: true
+	});
+}
+//#endregion
+//#region extensions/zalouser/src/config-schema.ts
+const groupConfigSchema = z.object({
+	enabled: z.boolean().optional(),
+	requireMention: z.boolean().optional(),
+	tools: ToolPolicySchema
+});
+const ZalouserConfigSchema = buildCatchallMultiAccountChannelSchema(z.object({
+	name: z.string().optional(),
+	enabled: z.boolean().optional(),
+	markdown: MarkdownConfigSchema,
+	profile: z.string().optional(),
+	dangerouslyAllowNameMatching: z.boolean().optional(),
+	dmPolicy: DmPolicySchema.optional(),
+	allowFrom: AllowFromListSchema,
+	historyLimit: z.number().int().min(0).optional(),
+	groupAllowFrom: AllowFromListSchema,
+	groupPolicy: GroupPolicySchema.optional().default("allowlist"),
+	groups: z.object({}).catchall(groupConfigSchema).optional(),
+	messagePrefix: z.string().optional(),
+	responsePrefix: z.string().optional()
+}));
+//#endregion
+//#region extensions/zalouser/src/doctor.ts
+function asObjectRecord(value) {
+	return value && typeof value === "object" && !Array.isArray(value) ? value : null;
+}
+const zalouserDoctor = {
+	dmAllowFromMode: "topOnly",
+	groupModel: "hybrid",
+	groupAllowFromFallbackToAllowFrom: false,
+	warnOnEmptyGroupSenderAllowlist: false,
+	legacyConfigRules,
+	normalizeCompatibilityConfig,
+	collectMutableAllowlistWarnings: createDangerousNameMatchingMutableAllowlistWarningCollector({
+		channel: "zalouser",
+		detector: isZalouserMutableGroupEntry,
+		collectLists: (scope) => {
+			const groups = asObjectRecord(scope.account.groups);
+			return groups ? [{
+				pathLabel: `${scope.prefix}.groups`,
+				list: Object.keys(groups)
+			}] : [];
+		}
+	})
+};
+//#endregion
+//#region extensions/zalouser/src/shared.ts
+const zalouserMeta = {
+	id: "zalouser",
+	label: "Zalo Personal",
+	selectionLabel: "Zalo (Personal Account)",
+	docsPath: "/channels/zalouser",
+	docsLabel: "zalouser",
+	blurb: "Zalo personal account via QR code login.",
+	aliases: ["zlu"],
+	order: 85,
+	quickstartAllowFrom: false
+};
+const zalouserConfigAdapter = createScopedChannelConfigAdapter({
+	sectionKey: "zalouser",
+	listAccountIds: listZalouserAccountIds,
+	resolveAccount: adaptScopedAccountAccessor(resolveZalouserAccountSync),
+	defaultAccountId: resolveDefaultZalouserAccountId,
+	clearBaseFields: [
+		"profile",
+		"name",
+		"dmPolicy",
+		"allowFrom",
+		"historyLimit",
+		"groupAllowFrom",
+		"groupPolicy",
+		"groups",
+		"messagePrefix"
+	],
+	resolveAllowFrom: (account) => account.config.allowFrom,
+	formatAllowFrom: (allowFrom) => formatAllowFromLowercase({
+		allowFrom,
+		stripPrefixRe: /^(zalouser|zlu):/i
+	})
+});
+function createZalouserPluginBase(params) {
+	return {
+		id: "zalouser",
+		meta: zalouserMeta,
+		setupWizard: params.setupWizard,
+		capabilities: {
+			chatTypes: ["direct", "group"],
+			media: true,
+			reactions: true,
+			threads: false,
+			polls: false,
+			nativeCommands: false,
+			blockStreaming: true
+		},
+		doctor: zalouserDoctor,
+		reload: { configPrefixes: ["channels.zalouser"] },
+		configSchema: buildChannelConfigSchema(ZalouserConfigSchema),
+		config: {
+			...zalouserConfigAdapter,
+			isConfigured: async (account) => await checkZcaAuthenticated(account.profile),
+			describeAccount: (account) => describeAccountSnapshot({ account })
+		},
+		setup: params.setup
+	};
+}
+//#endregion
+export { DEFAULT_ACCOUNT_ID as a, isNumericTargetId as c, writeQrDataUrlToTempFile as i, normalizeAccountId as l, createZalouserSetupWizardProxy as n, chunkTextForOutbound as o, zalouserSetupAdapter as r, isDangerousNameMatchingEnabled$1 as s, createZalouserPluginBase as t, sendPayloadWithChunkedTextAndMedia as u };

package/dist/test-api.js

@@ -0,0 +1,5 @@
+import { a as resolveZalouserAccountSync, i as resolveDefaultZalouserAccountId, n as getZcaUserInfo, r as listZalouserAccountIds, t as checkZcaAuthenticated } from "./accounts-DOefD_if.js";
+import { r as parseZalouserOutboundTarget } from "./session-route-CalHiv1d.js";
+import { a as listZaloGroupMembers, b as waitForZaloQrLogin, c as logoutZaloProfile, d as resolveZaloGroupsByEntries, i as listZaloFriendsMatching, l as resolveZaloAllowFromEntries, n as getZaloUserInfo, s as listZaloGroupsMatching, t as checkZaloAuthenticated, y as startZaloQrLogin } from "./zalo-js-B80cRyDF.js";
+import { i as sendMessageZalouser } from "./send-uRjUB8mG.js";
+export { checkZaloAuthenticated, checkZcaAuthenticated, getZaloUserInfo, getZcaUserInfo, listZaloFriendsMatching, listZaloGroupMembers, listZaloGroupsMatching, listZalouserAccountIds, logoutZaloProfile, parseZalouserOutboundTarget, resolveDefaultZalouserAccountId, resolveZaloAllowFromEntries, resolveZaloGroupsByEntries, resolveZalouserAccountSync, sendMessageZalouser, startZaloQrLogin, waitForZaloQrLogin };