@openclaw/zalouser 2026.5.2-beta.2 → 2026.5.3-beta.1

package/dist/accounts-C00IMUgd.js

@@ -0,0 +1,63 @@
+import { DEFAULT_ACCOUNT_ID, createAccountListHelpers, normalizeAccountId, resolveMergedAccountConfig } from "openclaw/plugin-sdk/account-resolution";
+import { normalizeOptionalString } from "openclaw/plugin-sdk/text-runtime";
+//#region extensions/zalouser/src/accounts.ts
+let zalouserAccountsRuntimePromise;
+async function loadZalouserAccountsRuntime() {
+	zalouserAccountsRuntimePromise ??= import("./accounts.runtime-uG7S8cXT.js");
+	return await zalouserAccountsRuntimePromise;
+}
+const { listAccountIds: listZalouserAccountIds, resolveDefaultAccountId: resolveDefaultZalouserAccountId } = createAccountListHelpers("zalouser");
+function mergeZalouserAccountConfig(cfg, accountId) {
+	const merged = resolveMergedAccountConfig({
+		channelConfig: cfg.channels?.zalouser,
+		accounts: (cfg.channels?.zalouser)?.accounts,
+		accountId,
+		omitKeys: ["defaultAccount"]
+	});
+	return {
+		...merged,
+		groupPolicy: merged.groupPolicy ?? "allowlist"
+	};
+}
+function resolveProfile(config, accountId) {
+	if (config.profile?.trim()) return config.profile.trim();
+	if (process.env.ZALOUSER_PROFILE?.trim()) return process.env.ZALOUSER_PROFILE.trim();
+	if (process.env.ZCA_PROFILE?.trim()) return process.env.ZCA_PROFILE.trim();
+	if (accountId !== DEFAULT_ACCOUNT_ID) return accountId;
+	return "default";
+}
+function resolveZalouserAccountBase(params) {
+	const accountId = normalizeAccountId(params.accountId ?? resolveDefaultZalouserAccountId(params.cfg));
+	const baseEnabled = (params.cfg.channels?.zalouser)?.enabled !== false;
+	const merged = mergeZalouserAccountConfig(params.cfg, accountId);
+	return {
+		accountId,
+		enabled: baseEnabled && merged.enabled !== false,
+		merged,
+		profile: resolveProfile(merged, accountId)
+	};
+}
+function resolveZalouserAccountSync(params) {
+	const { accountId, enabled, merged, profile } = resolveZalouserAccountBase(params);
+	return {
+		accountId,
+		name: normalizeOptionalString(merged.name),
+		enabled,
+		profile,
+		authenticated: false,
+		config: merged
+	};
+}
+async function getZcaUserInfo(profile) {
+	const info = await (await loadZalouserAccountsRuntime()).getZaloUserInfo(profile);
+	if (!info) return null;
+	return {
+		userId: info.userId,
+		displayName: info.displayName
+	};
+}
+async function checkZcaAuthenticated(profile) {
+	return await (await loadZalouserAccountsRuntime()).checkZaloAuthenticated(profile);
+}
+//#endregion
+export { resolveZalouserAccountSync as a, resolveDefaultZalouserAccountId as i, getZcaUserInfo as n, listZalouserAccountIds as r, checkZcaAuthenticated as t };

package/dist/accounts.runtime-uG7S8cXT.js

@@ -0,0 +1,2 @@
+import { n as getZaloUserInfo, t as checkZaloAuthenticated } from "./zalo-js-CHCUlY3c.js";
+export { checkZaloAuthenticated, getZaloUserInfo };

package/dist/api-BRwdUWuS.js

@@ -0,0 +1,139 @@
+import "./setup-surface-NCOuKu-l.js";
+import "./setup-core-CqipqY98.js";
+import { r as parseZalouserOutboundTarget } from "./session-route-C0-Xr8bt.js";
+import "./channel-ou_w_2j-.js";
+import "./security-audit-BZLhil-V.js";
+import { i as listZaloFriendsMatching, n as getZaloUserInfo, s as listZaloGroupsMatching, t as checkZaloAuthenticated } from "./zalo-js-CHCUlY3c.js";
+import "./channel.setup-CiDeBFrn.js";
+import { i as sendMessageZalouser, n as sendImageZalouser, r as sendLinkZalouser } from "./send-BsmySxe3.js";
+import { formatErrorMessage } from "openclaw/plugin-sdk/error-runtime";
+import { Type } from "typebox";
+//#region extensions/zalouser/src/tool.ts
+const ACTIONS = [
+	"send",
+	"image",
+	"link",
+	"friends",
+	"groups",
+	"me",
+	"status"
+];
+function stringEnum(values, options = {}) {
+	return Type.Unsafe({
+		type: "string",
+		enum: [...values],
+		...options
+	});
+}
+const ZalouserToolSchema = Type.Object({
+	action: stringEnum(ACTIONS, { description: `Action to perform: ${ACTIONS.join(", ")}` }),
+	threadId: Type.Optional(Type.String({ description: "Thread ID for messaging" })),
+	message: Type.Optional(Type.String({ description: "Message text" })),
+	isGroup: Type.Optional(Type.Boolean({ description: "Is group chat" })),
+	profile: Type.Optional(Type.String({ description: "Profile name" })),
+	query: Type.Optional(Type.String({ description: "Search query" })),
+	url: Type.Optional(Type.String({ description: "URL for media/link" }))
+}, { additionalProperties: false });
+function json(payload) {
+	return {
+		content: [{
+			type: "text",
+			text: JSON.stringify(payload, null, 2)
+		}],
+		details: payload
+	};
+}
+function resolveAmbientZalouserTarget(context) {
+	const deliveryContext = context?.deliveryContext;
+	const rawTarget = deliveryContext?.to;
+	if ((deliveryContext?.channel === void 0 || deliveryContext.channel === "zalouser") && typeof rawTarget === "string" && rawTarget.trim()) try {
+		return parseZalouserOutboundTarget(rawTarget);
+	} catch {}
+	if (deliveryContext?.channel && deliveryContext.channel !== "zalouser") return {};
+	const ambientThreadId = deliveryContext?.threadId;
+	if (typeof ambientThreadId === "string" && ambientThreadId.trim()) return { threadId: ambientThreadId.trim() };
+	if (typeof ambientThreadId === "number" && Number.isFinite(ambientThreadId)) return { threadId: String(ambientThreadId) };
+	return {};
+}
+function resolveZalouserSendTarget(params, context) {
+	const explicitThreadId = typeof params.threadId === "string" ? params.threadId.trim() : "";
+	const ambientTarget = resolveAmbientZalouserTarget(context);
+	return {
+		threadId: explicitThreadId || ambientTarget.threadId,
+		isGroup: typeof params.isGroup === "boolean" ? params.isGroup : ambientTarget.isGroup
+	};
+}
+async function executeZalouserTool(_toolCallId, params, _signal, _onUpdate, context) {
+	try {
+		switch (params.action) {
+			case "send": {
+				const target = resolveZalouserSendTarget(params, context);
+				if (!target.threadId || !params.message) throw new Error("threadId and message required for send action");
+				const result = await sendMessageZalouser(target.threadId, params.message, {
+					profile: params.profile,
+					isGroup: target.isGroup
+				});
+				if (!result.ok) throw new Error(result.error || "Failed to send message");
+				return json({
+					success: true,
+					messageId: result.messageId
+				});
+			}
+			case "image": {
+				const target = resolveZalouserSendTarget(params, context);
+				if (!target.threadId) throw new Error("threadId required for image action");
+				if (!params.url) throw new Error("url required for image action");
+				const result = await sendImageZalouser(target.threadId, params.url, {
+					profile: params.profile,
+					caption: params.message,
+					isGroup: target.isGroup
+				});
+				if (!result.ok) throw new Error(result.error || "Failed to send image");
+				return json({
+					success: true,
+					messageId: result.messageId
+				});
+			}
+			case "link": {
+				const target = resolveZalouserSendTarget(params, context);
+				if (!target.threadId || !params.url) throw new Error("threadId and url required for link action");
+				const result = await sendLinkZalouser(target.threadId, params.url, {
+					profile: params.profile,
+					caption: params.message,
+					isGroup: target.isGroup
+				});
+				if (!result.ok) throw new Error(result.error || "Failed to send link");
+				return json({
+					success: true,
+					messageId: result.messageId
+				});
+			}
+			case "friends": return json(await listZaloFriendsMatching(params.profile, params.query));
+			case "groups": return json(await listZaloGroupsMatching(params.profile, params.query));
+			case "me": return json(await getZaloUserInfo(params.profile) ?? { error: "Not authenticated" });
+			case "status": {
+				const authenticated = await checkZaloAuthenticated(params.profile);
+				return json({
+					authenticated,
+					output: authenticated ? "authenticated" : "not authenticated"
+				});
+			}
+			default:
+				params.action;
+				throw new Error(`Unknown action: ${String(params.action)}. Valid actions: send, image, link, friends, groups, me, status`);
+		}
+	} catch (err) {
+		return json({ error: formatErrorMessage(err) });
+	}
+}
+function createZalouserTool(context) {
+	return {
+		name: "zalouser",
+		label: "Zalo Personal",
+		description: "Send messages and access data via Zalo personal account. Actions: send (text message), image (send image URL), link (send link), friends (list/search friends), groups (list groups), me (profile info), status (auth check).",
+		parameters: ZalouserToolSchema,
+		execute: async (toolCallId, params, signal, onUpdate) => await executeZalouserTool(toolCallId, params, signal, onUpdate, context)
+	};
+}
+//#endregion
+export { createZalouserTool as t };

package/dist/api.js

@@ -0,0 +1,7 @@
+import { n as zalouserSetupWizard } from "./setup-surface-NCOuKu-l.js";
+import { n as zalouserSetupAdapter, t as createZalouserSetupWizardProxy } from "./setup-core-CqipqY98.js";
+import { t as zalouserPlugin } from "./channel-ou_w_2j-.js";
+import { n as isZalouserMutableGroupEntry, t as collectZalouserSecurityAuditFindings } from "./security-audit-BZLhil-V.js";
+import { t as zalouserSetupPlugin } from "./channel.setup-CiDeBFrn.js";
+import { t as createZalouserTool } from "./api-BRwdUWuS.js";
+export { collectZalouserSecurityAuditFindings, createZalouserSetupWizardProxy, createZalouserTool, isZalouserMutableGroupEntry, zalouserPlugin, zalouserSetupAdapter, zalouserSetupPlugin, zalouserSetupWizard };