@openclaw/zalouser 2026.5.2 → 2026.5.3-beta.2

package/dist/setup-surface-NCOuKu-l.js

@@ -0,0 +1,359 @@
+import { a as resolveZalouserAccountSync, i as resolveDefaultZalouserAccountId, r as listZalouserAccountIds, t as checkZcaAuthenticated } from "./accounts-C00IMUgd.js";
+import { r as writeQrDataUrlToTempFile } from "./setup-core-CqipqY98.js";
+import { b as waitForZaloQrLogin, c as logoutZaloProfile, d as resolveZaloGroupsByEntries, l as resolveZaloAllowFromEntries, y as startZaloQrLogin } from "./zalo-js-CHCUlY3c.js";
+import { DEFAULT_ACCOUNT_ID, addWildcardAllowFrom, formatCliCommand, formatDocsLink, formatResolvedUnresolvedNote, mergeAllowFromEntries, normalizeAccountId, patchScopedAccountConfig } from "openclaw/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 channel = "zalouser";
+const ZALOUSER_ALLOW_FROM_PLACEHOLDER = "Alice, 123456789, or leave empty to configure later";
+const ZALOUSER_GROUPS_PLACEHOLDER = "Family, Work, 123456789, or leave empty for now";
+const ZALOUSER_DM_ACCESS_TITLE = "Zalo Personal DM access";
+const ZALOUSER_ALLOWLIST_TITLE = "Zalo Personal allowlist";
+const ZALOUSER_GROUPS_TITLE = "Zalo groups";
+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([
+		"Zalo Personal Account login via QR code.",
+		"",
+		"This plugin uses zca-js directly (no external CLI dependency).",
+		"",
+		`Docs: ${formatDocsLink("/channels/zalouser", "zalouser")}`
+	].join("\n"), "Zalo Personal Setup");
+}
+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: "Zalouser allowFrom (name or user id)",
+			placeholder: ZALOUSER_ALLOW_FROM_PLACEHOLDER,
+			initialValue: existingAllowFrom.length > 0 ? existingAllowFrom.join(", ") : void 0
+		}));
+		if (parts.length === 0) {
+			await prompter.note([
+				"No DM allowlist entries added yet.",
+				"Direct chats will stay blocked until you add people later.",
+				`Tip: use \`${formatCliCommand("openclaw directory peers list --channel zalouser")}\` to look up people after onboarding.`
+			].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(`Could not resolve: ${unresolved.join(", ")}. Use numeric user ids or exact friend names.`, 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([
+		"Direct chats are configured separately from group chats.",
+		"- pairing (default): unknown people get a pairing code",
+		"- allowlist: only listed people can DM",
+		"- open: anyone can DM",
+		"- disabled: ignore DMs",
+		"",
+		`Current: dmPolicy=${existingPolicy}, allowFrom=${existingLabel}`,
+		"If you choose allowlist now, you can leave it empty and add people later."
+	].join("\n"), ZALOUSER_DM_ACCESS_TITLE);
+	const policy = await prompter.select({
+		message: "Zalo Personal DM policy",
+		options: [
+			{
+				value: "pairing",
+				label: "Pairing (recommended)"
+			},
+			{
+				value: "allowlist",
+				label: "Allowlist (specific users only)"
+			},
+			{
+				value: "open",
+				label: "Open (public inbound DMs)"
+			},
+			{
+				value: "disabled",
+				label: "Disabled (ignore DMs)"
+			}
+		],
+		initialValue: existingPolicy
+	});
+	if (policy === "allowlist") return await promptZalouserAllowFrom({
+		cfg,
+		prompter,
+		accountId
+	});
+	return setZalouserDmPolicy(cfg, accountId, policy);
+}
+const zalouserSetupWizard = {
+	channel,
+	status: {
+		configuredLabel: "logged in",
+		unconfiguredLabel: "needs QR login",
+		configuredHint: "recommended · logged in",
+		unconfiguredHint: "recommended · QR login",
+		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: "Login via QR code now?",
+				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 ? `QR image saved to: ${qrPath}` : "Could not write QR image file; use gateway web login UI instead.",
+						"Scan + approve on phone, then continue."
+					].join("\n"), "QR Login");
+					if (await prompter.confirm({
+						message: "Did you scan and approve the QR on your phone?",
+						initialValue: true
+					})) {
+						const waited = await waitForZaloQrLogin({
+							profile: account.profile,
+							timeoutMs: 12e4
+						});
+						await prompter.note(waited.message, waited.connected ? "Success" : "Login pending");
+					}
+				} else await prompter.note(start.message, "Login pending");
+			}
+		} else if (!await prompter.confirm({
+			message: "Zalo Personal already logged in. Keep session?",
+			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 ? `QR image saved to: ${qrPath}` : void 0].filter(Boolean).join("\n"), "QR Login");
+				const waited = await waitForZaloQrLogin({
+					profile: account.profile,
+					timeoutMs: 12e4
+				});
+				await prompter.note(waited.message, waited.connected ? "Success" : "Login pending");
+			}
+		}
+		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([
+					"No group allowlist entries added yet.",
+					"Group chats will stay blocked until you add groups later.",
+					`Tip: use \`${formatCliCommand("openclaw directory groups list --channel zalouser")}\` after onboarding to find group IDs.`,
+					"Mention requirement stays on by default for groups you allow later."
+				].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(`Group lookup failed; keeping entries as typed. ${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-DSy8aIUx.js

@@ -0,0 +1,120 @@
+import { a as resolveZalouserAccountSync, i as resolveDefaultZalouserAccountId, r as listZalouserAccountIds, t as checkZcaAuthenticated } from "./accounts-C00IMUgd.js";
+import { n as normalizeCompatibilityConfig, t as legacyConfigRules } from "./doctor-contract-DgqHp8E2.js";
+import { n as isZalouserMutableGroupEntry } from "./security-audit-BZLhil-V.js";
+import { formatAllowFromLowercase } from "openclaw/plugin-sdk/allow-from";
+import { AllowFromListSchema, DmPolicySchema, GroupPolicySchema, MarkdownConfigSchema, ToolPolicySchema, buildCatchallMultiAccountChannelSchema, buildChannelConfigSchema } from "openclaw/plugin-sdk/channel-config-schema";
+import { DEFAULT_ACCOUNT_ID, normalizeAccountId } from "openclaw/plugin-sdk/core";
+import { isDangerousNameMatchingEnabled as isDangerousNameMatchingEnabled$1 } from "openclaw/plugin-sdk/dangerous-name-runtime";
+import { chunkTextForOutbound } from "openclaw/plugin-sdk/text-chunking";
+import { isNumericTargetId, sendPayloadWithChunkedTextAndMedia } from "openclaw/plugin-sdk/reply-payload";
+import { adaptScopedAccountAccessor, createScopedChannelConfigAdapter } from "openclaw/plugin-sdk/channel-config-helpers";
+import { describeAccountSnapshot } from "openclaw/plugin-sdk/account-helpers";
+import { z } from "openclaw/plugin-sdk/zod";
+import { createDangerousNameMatchingMutableAllowlistWarningCollector } from "openclaw/plugin-sdk/channel-policy";
+//#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 { isNumericTargetId as a, isDangerousNameMatchingEnabled$1 as i, DEFAULT_ACCOUNT_ID as n, normalizeAccountId as o, chunkTextForOutbound as r, sendPayloadWithChunkedTextAndMedia as s, createZalouserPluginBase as t };

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-C00IMUgd.js";
+import { r as parseZalouserOutboundTarget } from "./session-route-C0-Xr8bt.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-CHCUlY3c.js";
+import { i as sendMessageZalouser } from "./send-BsmySxe3.js";
+export { checkZaloAuthenticated, checkZcaAuthenticated, getZaloUserInfo, getZcaUserInfo, listZaloFriendsMatching, listZaloGroupMembers, listZaloGroupsMatching, listZalouserAccountIds, logoutZaloProfile, parseZalouserOutboundTarget, resolveDefaultZalouserAccountId, resolveZaloAllowFromEntries, resolveZaloGroupsByEntries, resolveZalouserAccountSync, sendMessageZalouser, startZaloQrLogin, waitForZaloQrLogin };