@openclaw/zalo 2026.5.2 → 2026.5.3-beta.2

package/dist/setup-core-DigRD3j1.js

@@ -0,0 +1,166 @@
+import { a as resolveZaloAccount, i as resolveDefaultZaloAccountId } from "./accounts-9NLDDlZ8.js";
+import { DEFAULT_ACCOUNT_ID, addWildcardAllowFrom, createDelegatedSetupWizardProxy, createPatchedAccountSetupAdapter, createSetupInputPresenceValidator, formatDocsLink, mergeAllowFromEntries, normalizeAccountId } from "openclaw/plugin-sdk/setup";
+//#region extensions/zalo/src/setup-allow-from.ts
+async function noteZaloTokenHelp(prompter) {
+	await prompter.note([
+		"1) Open Zalo Bot Platform: https://bot.zaloplatforms.com",
+		"2) Create a bot and get the token",
+		"3) Token looks like 12345689:abc-xyz",
+		"Tip: you can also set ZALO_BOT_TOKEN in your env.",
+		`Docs: ${formatDocsLink("/channels/zalo", "zalo")}`
+	].join("\n"), "Zalo bot token");
+}
+async function promptZaloAllowFrom(params) {
+	const { cfg, prompter } = params;
+	const accountId = params.accountId ?? resolveDefaultZaloAccountId(cfg);
+	const existingAllowFrom = resolveZaloAccount({
+		cfg,
+		accountId
+	}).config.allowFrom ?? [];
+	const unique = mergeAllowFromEntries(existingAllowFrom, [(await prompter.text({
+		message: "Zalo allowFrom (user id)",
+		placeholder: "123456789",
+		initialValue: existingAllowFrom[0] ? String(existingAllowFrom[0]) : void 0,
+		validate: (value) => {
+			const raw = (value ?? "").trim();
+			if (!raw) return "Required";
+			if (!/^\d+$/.test(raw)) return "Use a numeric Zalo user id";
+		}
+	})).trim()]);
+	if (accountId === DEFAULT_ACCOUNT_ID) return {
+		...cfg,
+		channels: {
+			...cfg.channels,
+			zalo: {
+				...cfg.channels?.zalo,
+				enabled: true,
+				dmPolicy: "allowlist",
+				allowFrom: unique
+			}
+		}
+	};
+	const currentAccount = cfg.channels?.zalo?.accounts?.[accountId];
+	return {
+		...cfg,
+		channels: {
+			...cfg.channels,
+			zalo: {
+				...cfg.channels?.zalo,
+				enabled: true,
+				accounts: {
+					...cfg.channels?.zalo?.accounts,
+					[accountId]: {
+						...currentAccount,
+						enabled: currentAccount?.enabled ?? true,
+						dmPolicy: "allowlist",
+						allowFrom: unique
+					}
+				}
+			}
+		}
+	};
+}
+//#endregion
+//#region extensions/zalo/src/setup-core.ts
+const channel = "zalo";
+const zaloSetupAdapter = createPatchedAccountSetupAdapter({
+	channelKey: channel,
+	validateInput: createSetupInputPresenceValidator({
+		defaultAccountOnlyEnvError: "ZALO_BOT_TOKEN can only be used for the default account.",
+		whenNotUseEnv: [{
+			someOf: ["token", "tokenFile"],
+			message: "Zalo requires token or --token-file (or --use-env)."
+		}]
+	}),
+	buildPatch: (input) => input.useEnv ? {} : input.tokenFile ? { tokenFile: input.tokenFile } : input.token ? { botToken: input.token } : {}
+});
+const zaloDmPolicy = {
+	label: "Zalo",
+	channel,
+	policyKey: "channels.zalo.dmPolicy",
+	allowFromKey: "channels.zalo.allowFrom",
+	resolveConfigKeys: (cfg, accountId) => (accountId ?? resolveDefaultZaloAccountId(cfg)) !== DEFAULT_ACCOUNT_ID ? {
+		policyKey: `channels.zalo.accounts.${accountId ?? resolveDefaultZaloAccountId(cfg)}.dmPolicy`,
+		allowFromKey: `channels.zalo.accounts.${accountId ?? resolveDefaultZaloAccountId(cfg)}.allowFrom`
+	} : {
+		policyKey: "channels.zalo.dmPolicy",
+		allowFromKey: "channels.zalo.allowFrom"
+	},
+	getCurrent: (cfg, accountId) => resolveZaloAccount({
+		cfg,
+		accountId: accountId ?? resolveDefaultZaloAccountId(cfg)
+	}).config.dmPolicy ?? "pairing",
+	setPolicy: (cfg, policy, accountId) => {
+		const resolvedAccountId = accountId && normalizeAccountId(accountId) ? normalizeAccountId(accountId) ?? DEFAULT_ACCOUNT_ID : resolveDefaultZaloAccountId(cfg);
+		const resolved = resolveZaloAccount({
+			cfg,
+			accountId: resolvedAccountId
+		});
+		if (resolvedAccountId === DEFAULT_ACCOUNT_ID) return {
+			...cfg,
+			channels: {
+				...cfg.channels,
+				zalo: {
+					...cfg.channels?.zalo,
+					enabled: true,
+					dmPolicy: policy,
+					...policy === "open" ? { allowFrom: addWildcardAllowFrom(resolved.config.allowFrom) } : {}
+				}
+			}
+		};
+		const currentAccount = cfg.channels?.zalo?.accounts?.[resolvedAccountId];
+		return {
+			...cfg,
+			channels: {
+				...cfg.channels,
+				zalo: {
+					...cfg.channels?.zalo,
+					enabled: true,
+					accounts: {
+						...cfg.channels?.zalo?.accounts,
+						[resolvedAccountId]: {
+							...currentAccount,
+							enabled: currentAccount?.enabled ?? true,
+							dmPolicy: policy,
+							...policy === "open" ? { allowFrom: addWildcardAllowFrom(resolved.config.allowFrom) } : {}
+						}
+					}
+				}
+			}
+		};
+	},
+	promptAllowFrom: async ({ cfg, prompter, accountId }) => promptZaloAllowFrom({
+		cfg,
+		prompter,
+		accountId: accountId ?? resolveDefaultZaloAccountId(cfg)
+	})
+};
+function createZaloSetupWizardProxy(loadWizard) {
+	return createDelegatedSetupWizardProxy({
+		channel,
+		loadWizard,
+		status: {
+			configuredLabel: "configured",
+			unconfiguredLabel: "needs token",
+			configuredHint: "recommended · configured",
+			unconfiguredHint: "recommended · newcomer-friendly",
+			configuredScore: 1,
+			unconfiguredScore: 10
+		},
+		credentials: [],
+		delegateFinalize: true,
+		dmPolicy: zaloDmPolicy,
+		disable: (cfg) => ({
+			...cfg,
+			channels: {
+				...cfg.channels,
+				zalo: {
+					...cfg.channels?.zalo,
+					enabled: false
+				}
+			}
+		})
+	});
+}
+//#endregion
+export { promptZaloAllowFrom as a, noteZaloTokenHelp as i, zaloDmPolicy as n, zaloSetupAdapter as r, createZaloSetupWizardProxy as t };

package/dist/setup-entry.js

@@ -0,0 +1,15 @@
+import { defineBundledChannelSetupEntry } from "openclaw/plugin-sdk/channel-entry-contract";
+//#region extensions/zalo/setup-entry.ts
+var setup_entry_default = defineBundledChannelSetupEntry({
+	importMetaUrl: import.meta.url,
+	plugin: {
+		specifier: "./api.js",
+		exportName: "zaloPlugin"
+	},
+	secrets: {
+		specifier: "./secret-contract-api.js",
+		exportName: "channelSecrets"
+	}
+});
+//#endregion
+export { setup_entry_default as default };

package/dist/setup-surface-2Up3yWov.js

@@ -0,0 +1,216 @@
+import { a as resolveZaloAccount } from "./accounts-9NLDDlZ8.js";
+import { a as promptZaloAllowFrom, i as noteZaloTokenHelp, n as zaloDmPolicy } from "./setup-core-DigRD3j1.js";
+import { DEFAULT_ACCOUNT_ID, buildSingleChannelSecretPromptState, createStandardChannelSetupStatus, hasConfiguredSecretInput, promptSingleChannelSecretInput, runSingleChannelSecretStep } from "openclaw/plugin-sdk/setup";
+//#region extensions/zalo/src/setup-surface.ts
+const channel = "zalo";
+function setZaloUpdateMode(cfg, accountId, mode, webhookUrl, webhookSecret, webhookPath) {
+	const isDefault = accountId === DEFAULT_ACCOUNT_ID;
+	if (mode === "polling") {
+		if (isDefault) {
+			const { webhookUrl: _url, webhookSecret: _secret, webhookPath: _path, ...rest } = cfg.channels?.zalo ?? {};
+			return {
+				...cfg,
+				channels: {
+					...cfg.channels,
+					zalo: rest
+				}
+			};
+		}
+		const accounts = { ...cfg.channels?.zalo?.accounts };
+		const { webhookUrl: _url, webhookSecret: _secret, webhookPath: _path, ...rest } = accounts[accountId] ?? {};
+		accounts[accountId] = rest;
+		return {
+			...cfg,
+			channels: {
+				...cfg.channels,
+				zalo: {
+					...cfg.channels?.zalo,
+					accounts
+				}
+			}
+		};
+	}
+	if (isDefault) return {
+		...cfg,
+		channels: {
+			...cfg.channels,
+			zalo: {
+				...cfg.channels?.zalo,
+				webhookUrl,
+				webhookSecret,
+				webhookPath
+			}
+		}
+	};
+	const accounts = { ...cfg.channels?.zalo?.accounts };
+	accounts[accountId] = {
+		...accounts[accountId],
+		webhookUrl,
+		webhookSecret,
+		webhookPath
+	};
+	return {
+		...cfg,
+		channels: {
+			...cfg.channels,
+			zalo: {
+				...cfg.channels?.zalo,
+				accounts
+			}
+		}
+	};
+}
+const zaloSetupWizard = {
+	channel,
+	status: createStandardChannelSetupStatus({
+		channelLabel: "Zalo",
+		configuredLabel: "configured",
+		unconfiguredLabel: "needs token",
+		configuredHint: "recommended · configured",
+		unconfiguredHint: "recommended · newcomer-friendly",
+		configuredScore: 1,
+		unconfiguredScore: 10,
+		includeStatusLine: true,
+		resolveConfigured: ({ cfg, accountId }) => {
+			const account = resolveZaloAccount({
+				cfg,
+				accountId,
+				allowUnresolvedSecretRef: true
+			});
+			return Boolean(account.token) || hasConfiguredSecretInput(account.config.botToken) || Boolean(account.config.tokenFile?.trim());
+		}
+	}),
+	credentials: [],
+	finalize: async ({ cfg, accountId, forceAllowFrom, options, prompter }) => {
+		let next = cfg;
+		const resolvedAccount = resolveZaloAccount({
+			cfg: next,
+			accountId,
+			allowUnresolvedSecretRef: true
+		});
+		const accountConfigured = Boolean(resolvedAccount.token);
+		const allowEnv = accountId === DEFAULT_ACCOUNT_ID;
+		const hasConfigToken = Boolean(hasConfiguredSecretInput(resolvedAccount.config.botToken) || resolvedAccount.config.tokenFile);
+		next = (await runSingleChannelSecretStep({
+			cfg: next,
+			prompter,
+			providerHint: "zalo",
+			credentialLabel: "bot token",
+			secretInputMode: options?.secretInputMode,
+			accountConfigured,
+			hasConfigToken,
+			allowEnv,
+			envValue: process.env.ZALO_BOT_TOKEN,
+			envPrompt: "ZALO_BOT_TOKEN detected. Use env var?",
+			keepPrompt: "Zalo token already configured. Keep it?",
+			inputPrompt: "Enter Zalo bot token",
+			preferredEnvVar: "ZALO_BOT_TOKEN",
+			onMissingConfigured: async () => await noteZaloTokenHelp(prompter),
+			applyUseEnv: async (currentCfg) => accountId === DEFAULT_ACCOUNT_ID ? {
+				...currentCfg,
+				channels: {
+					...currentCfg.channels,
+					zalo: {
+						...currentCfg.channels?.zalo,
+						enabled: true
+					}
+				}
+			} : currentCfg,
+			applySet: async (currentCfg, value) => accountId === DEFAULT_ACCOUNT_ID ? {
+				...currentCfg,
+				channels: {
+					...currentCfg.channels,
+					zalo: {
+						...currentCfg.channels?.zalo,
+						enabled: true,
+						botToken: value
+					}
+				}
+			} : {
+				...currentCfg,
+				channels: {
+					...currentCfg.channels,
+					zalo: {
+						...currentCfg.channels?.zalo,
+						enabled: true,
+						accounts: {
+							...currentCfg.channels?.zalo?.accounts,
+							[accountId]: {
+								...currentCfg.channels?.zalo?.accounts?.[accountId],
+								enabled: true,
+								botToken: value
+							}
+						}
+					}
+				}
+			}
+		})).cfg;
+		if (await prompter.confirm({
+			message: "Use webhook mode for Zalo?",
+			initialValue: Boolean(resolvedAccount.config.webhookUrl)
+		})) {
+			const webhookUrl = (await prompter.text({
+				message: "Webhook URL (https://...) ",
+				initialValue: resolvedAccount.config.webhookUrl,
+				validate: (value) => value?.trim()?.startsWith("https://") ? void 0 : "HTTPS URL required"
+			})).trim();
+			const defaultPath = (() => {
+				try {
+					return new URL(webhookUrl).pathname || "/zalo-webhook";
+				} catch {
+					return "/zalo-webhook";
+				}
+			})();
+			let webhookSecretResult = await promptSingleChannelSecretInput({
+				cfg: next,
+				prompter,
+				providerHint: "zalo-webhook",
+				credentialLabel: "webhook secret",
+				secretInputMode: options?.secretInputMode,
+				...buildSingleChannelSecretPromptState({
+					accountConfigured: hasConfiguredSecretInput(resolvedAccount.config.webhookSecret),
+					hasConfigToken: hasConfiguredSecretInput(resolvedAccount.config.webhookSecret),
+					allowEnv: false
+				}),
+				envPrompt: "",
+				keepPrompt: "Zalo webhook secret already configured. Keep it?",
+				inputPrompt: "Webhook secret (8-256 chars)",
+				preferredEnvVar: "ZALO_WEBHOOK_SECRET"
+			});
+			while (webhookSecretResult.action === "set" && typeof webhookSecretResult.value === "string" && (webhookSecretResult.value.length < 8 || webhookSecretResult.value.length > 256)) {
+				await prompter.note("Webhook secret must be between 8 and 256 characters.", "Zalo webhook");
+				webhookSecretResult = await promptSingleChannelSecretInput({
+					cfg: next,
+					prompter,
+					providerHint: "zalo-webhook",
+					credentialLabel: "webhook secret",
+					secretInputMode: options?.secretInputMode,
+					...buildSingleChannelSecretPromptState({
+						accountConfigured: false,
+						hasConfigToken: false,
+						allowEnv: false
+					}),
+					envPrompt: "",
+					keepPrompt: "Zalo webhook secret already configured. Keep it?",
+					inputPrompt: "Webhook secret (8-256 chars)",
+					preferredEnvVar: "ZALO_WEBHOOK_SECRET"
+				});
+			}
+			const webhookSecret = webhookSecretResult.action === "set" ? webhookSecretResult.value : resolvedAccount.config.webhookSecret;
+			const webhookPath = (await prompter.text({
+				message: "Webhook path (optional)",
+				initialValue: resolvedAccount.config.webhookPath ?? defaultPath
+			})).trim();
+			next = setZaloUpdateMode(next, accountId, "webhook", webhookUrl, webhookSecret, webhookPath || void 0);
+		} else next = setZaloUpdateMode(next, accountId, "polling");
+		if (forceAllowFrom) next = await promptZaloAllowFrom({
+			cfg: next,
+			prompter,
+			accountId
+		});
+		return { cfg: next };
+	},
+	dmPolicy: zaloDmPolicy
+};
+//#endregion
+export { zaloSetupWizard };

package/dist/test-api.js

@@ -0,0 +1,2 @@
+import { r as resolveZaloRuntimeGroupPolicy, t as evaluateZaloGroupAccess } from "./group-access-DZR43lOR.js";
+export { evaluateZaloGroupAccess, resolveZaloRuntimeGroupPolicy };

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@openclaw/zalo",
-  "version": "2026.5.2",
+  "version": "2026.5.3-beta.2",
   "description": "OpenClaw Zalo channel plugin",
   "repository": {
     "type": "git",
@@ -15,7 +15,7 @@
     "openclaw": "workspace:*"
   },
   "peerDependencies": {
-    "openclaw": ">=2026.5.2"
+    "openclaw": ">=2026.5.3-beta.2"
   },
   "peerDependenciesMeta": {
     "openclaw": {
@@ -46,14 +46,23 @@
       "minHostVersion": ">=2026.4.10"
     },
     "compat": {
-      "pluginApi": ">=2026.5.2"
+      "pluginApi": ">=2026.5.3-beta.2"
     },
     "build": {
-      "openclawVersion": "2026.5.2"
+      "openclawVersion": "2026.5.3-beta.2"
     },
     "release": {
       "publishToClawHub": true,
       "publishToNpm": true
-    }
-  }
+    },
+    "runtimeExtensions": [
+      "./dist/index.js"
+    ],
+    "runtimeSetupEntry": "./dist/setup-entry.js"
+  },
+  "files": [
+    "dist/**",
+    "openclaw.plugin.json",
+    "README.md"
+  ]
 }

package/api.ts

@@ -1,9 +0,0 @@
-export { zaloPlugin } from "./src/channel.js";
-export {
-  createZaloSetupWizardProxy,
-  evaluateZaloGroupAccess,
-  resolveZaloRuntimeGroupPolicy,
-  zaloDmPolicy,
-  zaloSetupAdapter,
-  zaloSetupWizard,
-} from "./setup-api.js";

package/channel-plugin-api.ts

@@ -1 +0,0 @@
-export { zaloPlugin } from "./src/channel.js";

package/contract-api.ts

@@ -1,5 +0,0 @@
-export { evaluateZaloGroupAccess, resolveZaloRuntimeGroupPolicy } from "./src/group-access.js";
-export {
-  collectRuntimeConfigAssignments,
-  secretTargetRegistryEntries,
-} from "./src/secret-contract.js";

package/index.test.ts

@@ -1,15 +0,0 @@
-import { assertBundledChannelEntries } from "openclaw/plugin-sdk/channel-test-helpers";
-import { describe } from "vitest";
-import entry from "./index.js";
-import setupEntry from "./setup-entry.js";
-
-describe("zalo bundled entries", () => {
-  assertBundledChannelEntries({
-    entry,
-    expectedId: "zalo",
-    expectedName: "Zalo",
-    setupEntry,
-    channelMessage: "declares the channel plugin without a runtime-barrel cycle",
-    setupMessage: "declares the setup plugin without a runtime-barrel cycle",
-  });
-});

package/index.ts

@@ -1,20 +0,0 @@
-import { defineBundledChannelEntry } from "openclaw/plugin-sdk/channel-entry-contract";
-
-export default defineBundledChannelEntry({
-  id: "zalo",
-  name: "Zalo",
-  description: "Zalo channel plugin",
-  importMetaUrl: import.meta.url,
-  plugin: {
-    specifier: "./channel-plugin-api.js",
-    exportName: "zaloPlugin",
-  },
-  secrets: {
-    specifier: "./secret-contract-api.js",
-    exportName: "channelSecrets",
-  },
-  runtime: {
-    specifier: "./runtime-api.js",
-    exportName: "setZaloRuntime",
-  },
-});

package/runtime-api.test.ts

@@ -1,17 +0,0 @@
-import { runDirectImportSmoke } from "openclaw/plugin-sdk/plugin-test-contracts";
-import { describe, expect, it } from "vitest";
-
-describe("zalo runtime api", () => {
-  it("loads the narrow runtime api without reentering setup surfaces", async () => {
-    const stdout = await runDirectImportSmoke(
-      `const runtime = await import("./extensions/zalo/runtime-api.ts");
-process.stdout.write(JSON.stringify({
-  hasZaloPlugin: Object.hasOwn(runtime, "zaloPlugin"),
-  hasZaloSetupWizard: Object.hasOwn(runtime, "zaloSetupWizard"),
-  type: typeof runtime.setZaloRuntime,
-}));`,
-    );
-
-    expect(stdout).toBe('{"hasZaloPlugin":false,"hasZaloSetupWizard":false,"type":"function"}');
-  }, 45_000);
-});

package/runtime-api.ts

@@ -1,75 +0,0 @@
-export {
-  addWildcardAllowFrom,
-  applyAccountNameToChannelSection,
-  applyBasicWebhookRequestGuards,
-  applySetupAccountConfigPatch,
-  type BaseProbeResult,
-  type BaseTokenResolution,
-  buildBaseAccountStatusSnapshot,
-  buildChannelConfigSchema,
-  buildSecretInputSchema,
-  buildSingleChannelSecretPromptState,
-  buildTokenChannelStatusSummary,
-  type ChannelAccountSnapshot,
-  type ChannelMessageActionAdapter,
-  type ChannelMessageActionName,
-  type ChannelPlugin,
-  type ChannelStatusIssue,
-  chunkTextForOutbound,
-  createChannelPairingController,
-  createChannelReplyPipeline,
-  createDedupeCache,
-  createFixedWindowRateLimiter,
-  createWebhookAnomalyTracker,
-  DEFAULT_ACCOUNT_ID,
-  deliverTextOrMediaReply,
-  evaluateSenderGroupAccess,
-  formatAllowFromLowercase,
-  formatPairingApproveHint,
-  type GroupPolicy,
-  hasConfiguredSecretInput,
-  isNormalizedSenderAllowed,
-  isNumericTargetId,
-  jsonResult,
-  logTypingFailure,
-  type MarkdownTableMode,
-  mergeAllowFromEntries,
-  migrateBaseNameToDefaultAccount,
-  normalizeAccountId,
-  normalizeResolvedSecretInputString,
-  normalizeSecretInputString,
-  type OpenClawConfig,
-  type OutboundReplyPayload,
-  PAIRING_APPROVED_MESSAGE,
-  type PluginRuntime,
-  promptSingleChannelSecretInput,
-  readJsonWebhookBodyOrReject,
-  readStringParam,
-  registerPluginHttpRoute,
-  type RegisterWebhookPluginRouteOptions,
-  registerWebhookTarget,
-  type RegisterWebhookTargetOptions,
-  registerWebhookTargetWithPluginRoute,
-  type ReplyPayload,
-  resolveClientIp,
-  resolveDefaultGroupPolicy,
-  resolveDirectDmAuthorizationOutcome,
-  resolveInboundRouteEnvelopeBuilderWithRuntime,
-  resolveOpenProviderRuntimeGroupPolicy,
-  resolveSenderCommandAuthorizationWithRuntime,
-  resolveWebhookPath,
-  resolveWebhookTargetWithAuthOrRejectSync,
-  runSingleChannelSecretStep,
-  type RuntimeEnv,
-  type SecretInput,
-  type SenderGroupAccessDecision,
-  sendPayloadWithChunkedTextAndMedia,
-  setTopLevelChannelDmPolicyWithAllowFrom,
-  setZaloRuntime,
-  waitForAbortSignal,
-  warnMissingProviderGroupPolicyFallbackOnce,
-  WEBHOOK_ANOMALY_COUNTER_DEFAULTS,
-  WEBHOOK_RATE_LIMIT_DEFAULTS,
-  withResolvedWebhookRequestPipeline,
-  type WizardPrompter,
-} from "./src/runtime-api.js";

package/secret-contract-api.ts

@@ -1,5 +0,0 @@
-export {
-  channelSecrets,
-  collectRuntimeConfigAssignments,
-  secretTargetRegistryEntries,
-} from "./src/secret-contract.js";

package/setup-api.ts

@@ -1,34 +0,0 @@
-import { loadBundledEntryExportSync } from "openclaw/plugin-sdk/channel-entry-contract";
-
-type SetupSurfaceModule = typeof import("./src/setup-surface.js");
-
-function createLazyObjectValue<T extends object>(load: () => T): T {
-  return new Proxy({} as T, {
-    get(_target, property, receiver) {
-      return Reflect.get(load(), property, receiver);
-    },
-    has(_target, property) {
-      return property in load();
-    },
-    ownKeys() {
-      return Reflect.ownKeys(load());
-    },
-    getOwnPropertyDescriptor(_target, property) {
-      const descriptor = Object.getOwnPropertyDescriptor(load(), property);
-      return descriptor ? { ...descriptor, configurable: true } : undefined;
-    },
-  });
-}
-
-function loadSetupSurfaceModule(): SetupSurfaceModule {
-  return loadBundledEntryExportSync<SetupSurfaceModule>(import.meta.url, {
-    specifier: "./src/setup-surface.js",
-  });
-}
-
-export { zaloDmPolicy, zaloSetupAdapter, createZaloSetupWizardProxy } from "./src/setup-core.js";
-export { evaluateZaloGroupAccess, resolveZaloRuntimeGroupPolicy } from "./src/group-access.js";
-
-export const zaloSetupWizard: SetupSurfaceModule["zaloSetupWizard"] = createLazyObjectValue(
-  () => loadSetupSurfaceModule().zaloSetupWizard as object,
-) as SetupSurfaceModule["zaloSetupWizard"];

package/setup-entry.ts

@@ -1,13 +0,0 @@
-import { defineBundledChannelSetupEntry } from "openclaw/plugin-sdk/channel-entry-contract";
-
-export default defineBundledChannelSetupEntry({
-  importMetaUrl: import.meta.url,
-  plugin: {
-    specifier: "./api.js",
-    exportName: "zaloPlugin",
-  },
-  secrets: {
-    specifier: "./secret-contract-api.js",
-    exportName: "channelSecrets",
-  },
-});