@gaodefa/daocore 2026.5.73 → 2026.5.75

package/dist/setup-surface-BcnlyFJo.js

@@ -1,221 +0,0 @@
-import { s as hasConfiguredSecretInput } from "./types.secrets-Ct1DNG7D.js";
-import { t as DEFAULT_ACCOUNT_ID } from "./account-id-B32J-iNN.js";
-import { t as createSetupTranslator } from "./i18n-Bphgsdj4.js";
-import { B as runSingleChannelSecretStep, P as promptSingleChannelSecretInput, f as createStandardChannelSetupStatus, n as buildSingleChannelSecretPromptState } from "./setup-wizard-helpers-DXfnYF4t.js";
-import "./setup-Bk8ieh5V.js";
-import { i as resolveZaloAccount } from "./accounts-qPTOizTg.js";
-import { a as promptZaloAllowFrom, i as noteZaloTokenHelp, n as zaloDmPolicy } from "./setup-core-DP5EwSY0.js";
-//#region extensions/zalo/src/setup-surface.ts
-const t = createSetupTranslator();
-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: t("wizard.channels.statusConfigured"),
-		unconfiguredLabel: t("wizard.channels.statusNeedsToken"),
-		configuredHint: t("wizard.channels.statusRecommendedConfigured"),
-		unconfiguredHint: t("wizard.channels.statusRecommendedNewcomerFriendly"),
-		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: t("wizard.zalo.botToken"),
-			secretInputMode: options?.secretInputMode,
-			accountConfigured,
-			hasConfigToken,
-			allowEnv,
-			envValue: process.env.ZALO_BOT_TOKEN,
-			envPrompt: t("wizard.zalo.tokenEnvPrompt"),
-			keepPrompt: t("wizard.zalo.tokenKeep"),
-			inputPrompt: t("wizard.zalo.tokenInput"),
-			preferredEnvVar: "ZALO_BOT_TOKEN",
-			onMissingConfigured: async () => await noteZaloTokenHelp(prompter),
-			applyUseEnv: async (currentCfg) => accountId === "default" ? {
-				...currentCfg,
-				channels: {
-					...currentCfg.channels,
-					zalo: {
-						...currentCfg.channels?.zalo,
-						enabled: true
-					}
-				}
-			} : currentCfg,
-			applySet: async (currentCfg, value) => accountId === "default" ? {
-				...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: t("wizard.zalo.webhookModePrompt"),
-			initialValue: Boolean(resolvedAccount.config.webhookUrl)
-		})) {
-			const webhookUrl = (await prompter.text({
-				message: t("wizard.zalo.webhookUrlPrompt"),
-				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: t("wizard.zalo.webhookSecret"),
-				secretInputMode: options?.secretInputMode,
-				...buildSingleChannelSecretPromptState({
-					accountConfigured: hasConfiguredSecretInput(resolvedAccount.config.webhookSecret),
-					hasConfigToken: hasConfiguredSecretInput(resolvedAccount.config.webhookSecret),
-					allowEnv: false
-				}),
-				envPrompt: "",
-				keepPrompt: t("wizard.zalo.webhookSecretKeep"),
-				inputPrompt: t("wizard.zalo.webhookSecretInput"),
-				preferredEnvVar: "ZALO_WEBHOOK_SECRET"
-			});
-			while (webhookSecretResult.action === "set" && typeof webhookSecretResult.value === "string" && (webhookSecretResult.value.length < 8 || webhookSecretResult.value.length > 256)) {
-				await prompter.note(t("wizard.zalo.webhookSecretLength"), t("wizard.zalo.webhookTitle"));
-				webhookSecretResult = await promptSingleChannelSecretInput({
-					cfg: next,
-					prompter,
-					providerHint: "zalo-webhook",
-					credentialLabel: t("wizard.zalo.webhookSecret"),
-					secretInputMode: options?.secretInputMode,
-					...buildSingleChannelSecretPromptState({
-						accountConfigured: false,
-						hasConfigToken: false,
-						allowEnv: false
-					}),
-					envPrompt: "",
-					keepPrompt: t("wizard.zalo.webhookSecretKeep"),
-					inputPrompt: t("wizard.zalo.webhookSecretInput"),
-					preferredEnvVar: "ZALO_WEBHOOK_SECRET"
-				});
-			}
-			const webhookSecret = webhookSecretResult.action === "set" ? webhookSecretResult.value : resolvedAccount.config.webhookSecret;
-			const webhookPath = (await prompter.text({
-				message: t("wizard.zalo.webhookPathPrompt"),
-				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/setup-surface-BuTeC8Tu.js

@@ -1,320 +0,0 @@
-import { t as formatDocsLink } from "./links-738LMw6G.js";
-import { d as normalizeSecretInputString } from "./types.secrets-Ct1DNG7D.js";
-import { t as DEFAULT_ACCOUNT_ID } from "./account-id-B32J-iNN.js";
-import { t as createSetupTranslator } from "./i18n-Bphgsdj4.js";
-import { Q as splitSetupEntries, f as createStandardChannelSetupStatus, g as createTopLevelChannelGroupPolicySetter, m as createTopLevelChannelDmPolicy, p as createTopLevelChannelAllowFromSetter, v as mergeAllowFromEntries } from "./setup-wizard-helpers-DXfnYF4t.js";
-import "./setup-Bk8ieh5V.js";
-import "./setup-tools-BOGdbXzZ.js";
-import { D as formatUnknownError, g as saveDelegatedTokens, h as resolveMSTeamsCredentials, p as hasConfiguredMSTeamsCredentials } from "./graph-users-D2gOcc5D.js";
-import { c as resolveMSTeamsUserAllowlist, o as parseMSTeamsTeamEntry, s as resolveMSTeamsChannelAllowlist } from "./resolve-allowlist-BN__FO0F.js";
-//#region extensions/msteams/src/setup-core.ts
-const t$1 = createSetupTranslator();
-const msteamsSetupAdapter = {
-	resolveAccountId: () => DEFAULT_ACCOUNT_ID,
-	applyAccountConfig: ({ cfg }) => ({
-		...cfg,
-		channels: {
-			...cfg.channels,
-			msteams: {
-				...cfg.channels?.msteams,
-				enabled: true
-			}
-		}
-	})
-};
-const channel$1 = "msteams";
-async function promptMSTeamsCredentials(prompter) {
-	return {
-		appId: (await prompter.text({
-			message: t$1("wizard.msteams.appIdPrompt"),
-			validate: (value) => value?.trim() ? void 0 : t$1("common.required")
-		})).trim(),
-		appPassword: (await prompter.text({
-			message: t$1("wizard.msteams.appPasswordPrompt"),
-			validate: (value) => value?.trim() ? void 0 : t$1("common.required")
-		})).trim(),
-		tenantId: (await prompter.text({
-			message: t$1("wizard.msteams.tenantIdPrompt"),
-			validate: (value) => value?.trim() ? void 0 : t$1("common.required")
-		})).trim()
-	};
-}
-async function noteMSTeamsCredentialHelp(prompter) {
-	await prompter.note([
-		t$1("wizard.msteams.helpAzureBot"),
-		t$1("wizard.msteams.helpClientSecret"),
-		t$1("wizard.msteams.helpWebhook"),
-		t$1("wizard.msteams.helpEnvTip"),
-		t$1("wizard.channels.docs", { link: formatDocsLink("/channels/msteams", "msteams") })
-	].join("\n"), t$1("wizard.msteams.credentialsTitle"));
-}
-function createMSTeamsSetupWizardBase() {
-	return {
-		channel: channel$1,
-		resolveAccountIdForConfigure: () => DEFAULT_ACCOUNT_ID,
-		resolveShouldPromptAccountIds: () => false,
-		status: createStandardChannelSetupStatus({
-			channelLabel: "MS Teams",
-			configuredLabel: t$1("wizard.channels.statusConfigured"),
-			unconfiguredLabel: t$1("wizard.channels.statusNeedsAppCredentials"),
-			configuredHint: t$1("wizard.channels.statusConfigured"),
-			unconfiguredHint: t$1("wizard.channels.statusNeedsAppCreds"),
-			configuredScore: 2,
-			unconfiguredScore: 0,
-			includeStatusLine: true,
-			resolveConfigured: ({ cfg }) => Boolean(resolveMSTeamsCredentials(cfg.channels?.msteams)) || hasConfiguredMSTeamsCredentials(cfg.channels?.msteams)
-		}),
-		credentials: [],
-		finalize: async ({ cfg, prompter }) => {
-			const resolved = resolveMSTeamsCredentials(cfg.channels?.msteams);
-			const hasConfigCreds = hasConfiguredMSTeamsCredentials(cfg.channels?.msteams);
-			const canUseEnv = Boolean(!hasConfigCreds && normalizeSecretInputString(process.env.MSTEAMS_APP_ID) && normalizeSecretInputString(process.env.MSTEAMS_APP_PASSWORD) && normalizeSecretInputString(process.env.MSTEAMS_TENANT_ID));
-			let next = cfg;
-			let appId = null;
-			let appPassword = null;
-			let tenantId = null;
-			if (!resolved && !hasConfigCreds) await noteMSTeamsCredentialHelp(prompter);
-			if (canUseEnv) if (await prompter.confirm({
-				message: t$1("wizard.msteams.envPrompt"),
-				initialValue: true
-			})) next = msteamsSetupAdapter.applyAccountConfig({
-				cfg: next,
-				accountId: DEFAULT_ACCOUNT_ID,
-				input: {}
-			});
-			else ({appId, appPassword, tenantId} = await promptMSTeamsCredentials(prompter));
-			else if (hasConfigCreds) {
-				if (!await prompter.confirm({
-					message: t$1("wizard.msteams.credentialsKeep"),
-					initialValue: true
-				})) ({appId, appPassword, tenantId} = await promptMSTeamsCredentials(prompter));
-			} else ({appId, appPassword, tenantId} = await promptMSTeamsCredentials(prompter));
-			if (appId && appPassword && tenantId) next = {
-				...next,
-				channels: {
-					...next.channels,
-					msteams: {
-						...next.channels?.msteams,
-						enabled: true,
-						appId,
-						appPassword,
-						tenantId
-					}
-				}
-			};
-			return {
-				cfg: next,
-				accountId: DEFAULT_ACCOUNT_ID
-			};
-		}
-	};
-}
-//#endregion
-//#region extensions/msteams/src/setup-surface.ts
-const t = createSetupTranslator();
-const channel = "msteams";
-const setMSTeamsAllowFrom = createTopLevelChannelAllowFromSetter({ channel });
-const setMSTeamsGroupPolicy = createTopLevelChannelGroupPolicySetter({
-	channel,
-	enabled: true
-});
-function openDelegatedOAuthUrl(url) {
-	return Promise.reject(/* @__PURE__ */ new Error(`Automatic browser launch is not available. Open this URL manually: ${url}`));
-}
-function looksLikeGuid(value) {
-	return /^[0-9a-fA-F-]{16,}$/.test(value);
-}
-async function promptMSTeamsAllowFrom(params) {
-	const existing = params.cfg.channels?.msteams?.allowFrom ?? [];
-	await params.prompter.note([
-		t("wizard.msteams.allowlistIntro"),
-		t("wizard.msteams.allowlistResolve"),
-		t("wizard.msteams.examples"),
-		"- alex@example.com",
-		"- Alex Johnson",
-		"- 00000000-0000-0000-0000-000000000000"
-	].join("\n"), t("wizard.msteams.allowlistTitle"));
-	while (true) {
-		const parts = splitSetupEntries(await params.prompter.text({
-			message: t("wizard.msteams.allowFromPrompt"),
-			placeholder: "alex@example.com, Alex Johnson",
-			initialValue: existing[0] ? existing[0] : void 0,
-			validate: (value) => value.trim() ? void 0 : t("common.required")
-		}));
-		if (parts.length === 0) {
-			await params.prompter.note(t("wizard.msteams.enterAtLeastOneUser"), t("wizard.msteams.allowlistTitle"));
-			continue;
-		}
-		const resolved = await resolveMSTeamsUserAllowlist({
-			cfg: params.cfg,
-			entries: parts
-		}).catch(() => null);
-		if (!resolved) {
-			const ids = parts.filter((part) => looksLikeGuid(part));
-			if (ids.length !== parts.length) {
-				await params.prompter.note(t("wizard.msteams.graphLookupUnavailable"), t("wizard.msteams.allowlistTitle"));
-				continue;
-			}
-			const unique = mergeAllowFromEntries(existing, ids);
-			return setMSTeamsAllowFrom(params.cfg, unique);
-		}
-		const unresolved = resolved.filter((item) => !item.resolved || !item.id);
-		if (unresolved.length > 0) {
-			await params.prompter.note(t("wizard.msteams.couldNotResolve", { entries: unresolved.map((item) => item.input).join(", ") }), t("wizard.msteams.allowlistTitle"));
-			continue;
-		}
-		const unique = mergeAllowFromEntries(existing, resolved.map((item) => item.id));
-		return setMSTeamsAllowFrom(params.cfg, unique);
-	}
-}
-function setMSTeamsTeamsAllowlist(cfg, entries) {
-	const teams = { ...cfg.channels?.msteams?.teams ?? {} };
-	for (const entry of entries) {
-		const teamKey = entry.teamKey;
-		if (!teamKey) continue;
-		const existing = teams[teamKey] ?? {};
-		if (entry.channelKey) {
-			const channels = { ...existing.channels };
-			channels[entry.channelKey] = channels[entry.channelKey] ?? {};
-			teams[teamKey] = {
-				...existing,
-				channels
-			};
-		} else teams[teamKey] = existing;
-	}
-	return {
-		...cfg,
-		channels: {
-			...cfg.channels,
-			msteams: {
-				...cfg.channels?.msteams,
-				enabled: true,
-				teams
-			}
-		}
-	};
-}
-function listMSTeamsGroupEntries(cfg) {
-	return Object.entries(cfg.channels?.msteams?.teams ?? {}).flatMap(([teamKey, value]) => {
-		const channels = value?.channels ?? {};
-		const channelKeys = Object.keys(channels);
-		if (channelKeys.length === 0) return [teamKey];
-		return channelKeys.map((channelKey) => `${teamKey}/${channelKey}`);
-	});
-}
-async function resolveMSTeamsGroupAllowlist(params) {
-	let resolvedEntries = params.entries.map((entry) => parseMSTeamsTeamEntry(entry)).filter(Boolean);
-	if (params.entries.length === 0 || !resolveMSTeamsCredentials(params.cfg.channels?.msteams)) return resolvedEntries;
-	try {
-		const lookups = await resolveMSTeamsChannelAllowlist({
-			cfg: params.cfg,
-			entries: params.entries
-		});
-		const resolvedChannels = lookups.filter((entry) => entry.resolved && entry.teamId && entry.channelId);
-		const resolvedTeams = lookups.filter((entry) => entry.resolved && entry.teamId && !entry.channelId);
-		const unresolved = lookups.filter((entry) => !entry.resolved).map((entry) => entry.input);
-		resolvedEntries = [
-			...resolvedChannels.map((entry) => ({
-				teamKey: entry.teamId,
-				channelKey: entry.channelId
-			})),
-			...resolvedTeams.map((entry) => ({ teamKey: entry.teamId })),
-			...unresolved.map((entry) => parseMSTeamsTeamEntry(entry)).filter(Boolean)
-		];
-		const summary = [];
-		if (resolvedChannels.length > 0) summary.push(t("wizard.msteams.resolvedChannels", { entries: resolvedChannels.map((entry) => entry.channelId).filter(Boolean).join(", ") }));
-		if (resolvedTeams.length > 0) summary.push(t("wizard.msteams.resolvedTeams", { entries: resolvedTeams.map((entry) => entry.teamId).filter(Boolean).join(", ") }));
-		if (unresolved.length > 0) summary.push(t("wizard.msteams.unresolvedKept", { entries: unresolved.join(", ") }));
-		if (summary.length > 0) await params.prompter.note(summary.join("\n"), t("wizard.msteams.channelsLabel"));
-		return resolvedEntries;
-	} catch (err) {
-		await params.prompter.note(t("wizard.msteams.channelLookupFailed", { error: formatUnknownError(err) }), t("wizard.msteams.channelsLabel"));
-		return resolvedEntries;
-	}
-}
-const msteamsGroupAccess = {
-	label: t("wizard.msteams.channelsLabel"),
-	placeholder: "Team Name/Channel Name, teamId/conversationId",
-	currentPolicy: ({ cfg }) => cfg.channels?.msteams?.groupPolicy ?? "allowlist",
-	currentEntries: ({ cfg }) => listMSTeamsGroupEntries(cfg),
-	updatePrompt: ({ cfg }) => Boolean(cfg.channels?.msteams?.teams),
-	setPolicy: ({ cfg, policy }) => setMSTeamsGroupPolicy(cfg, policy),
-	resolveAllowlist: async ({ cfg, entries, prompter }) => await resolveMSTeamsGroupAllowlist({
-		cfg,
-		entries,
-		prompter
-	}),
-	applyAllowlist: ({ cfg, resolved }) => setMSTeamsTeamsAllowlist(cfg, resolved)
-};
-const msteamsDmPolicy = createTopLevelChannelDmPolicy({
-	label: "MS Teams",
-	channel,
-	policyKey: "channels.msteams.dmPolicy",
-	allowFromKey: "channels.msteams.allowFrom",
-	getCurrent: (cfg) => cfg.channels?.msteams?.dmPolicy ?? "pairing",
-	promptAllowFrom: promptMSTeamsAllowFrom
-});
-const msteamsSetupWizardBase = createMSTeamsSetupWizardBase();
-const msteamsSetupWizard = {
-	...msteamsSetupWizardBase,
-	finalize: async (params) => {
-		const baseFinalize = msteamsSetupWizardBase.finalize;
-		const baseResult = baseFinalize ? await baseFinalize(params) : void 0;
-		let next = baseResult?.cfg ?? params.cfg;
-		const finalCreds = resolveMSTeamsCredentials(next.channels?.msteams);
-		if (finalCreds?.type === "secret") {
-			if (await params.prompter.confirm({
-				message: t("wizard.msteams.delegatedAuthPrompt"),
-				initialValue: false
-			})) {
-				next = {
-					...next,
-					channels: {
-						...next.channels,
-						msteams: {
-							...next.channels?.msteams,
-							delegatedAuth: { enabled: true }
-						}
-					}
-				};
-				try {
-					const { loginMSTeamsDelegated } = await import("./oauth-BVxl4C5r.js");
-					const progress = params.prompter.progress(t("wizard.msteams.delegatedOAuthProgress"));
-					saveDelegatedTokens(await loginMSTeamsDelegated({
-						isRemote: true,
-						openUrl: openDelegatedOAuthUrl,
-						log: (msg) => params.prompter.note(msg),
-						note: (msg, title) => params.prompter.note(msg, title),
-						prompt: (msg) => params.prompter.text({ message: msg }),
-						progress
-					}, {
-						tenantId: finalCreds.tenantId,
-						clientId: finalCreds.appId,
-						clientSecret: finalCreds.appPassword
-					}));
-					progress.stop(t("wizard.msteams.delegatedAuthConfigured"));
-				} catch (err) {
-					await params.prompter.note(`Delegated auth setup failed: ${formatUnknownError(err)}\n` + t("wizard.msteams.delegatedAuthRetry"), t("wizard.msteams.delegatedAuthTitle"));
-				}
-			}
-		}
-		return {
-			...baseResult,
-			cfg: next
-		};
-	},
-	dmPolicy: msteamsDmPolicy,
-	groupAccess: msteamsGroupAccess,
-	disable: (cfg) => ({
-		...cfg,
-		channels: {
-			...cfg.channels,
-			msteams: {
-				...cfg.channels?.msteams,
-				enabled: false
-			}
-		}
-	})
-};
-//#endregion
-export { msteamsSetupAdapter as i, openDelegatedOAuthUrl as n, createMSTeamsSetupWizardBase as r, msteamsSetupWizard as t };

package/dist/shared-RXlS1jcs.js

@@ -1,121 +0,0 @@
-import { At as boolean, Rn as string, Tn as object, wn as number } from "./schemas-Del5uzR8.js";
-import { h as MarkdownConfigSchema, l as GroupPolicySchema, o as DmPolicySchema } from "./zod-schema.core-D3MmpZyV.js";
-import { u as ToolPolicySchema } from "./zod-schema.agent-runtime-FnpmRsf2.js";
-import { n as buildCatchallMultiAccountChannelSchema, r as buildChannelConfigSchema, t as AllowFromListSchema } from "./config-schema-CpJ4LFf2.js";
-import { s as createScopedChannelConfigAdapter, t as adaptScopedAccountAccessor } from "./channel-config-helpers-CQb9YOAn.js";
-import { n as describeAccountSnapshot } from "./account-helpers-BEXOONiv.js";
-import "./core-CwGP8lnn.js";
-import { t as formatAllowFromLowercase } from "./allow-from-BsbZfqm-.js";
-import "./channel-config-schema-vbY58Vzl.js";
-import { n as createDangerousNameMatchingMutableAllowlistWarningCollector } from "./channel-policy-Be-Ujzjr.js";
-import "./text-chunking-ObhJDe8L.js";
-import { a as resolveZalouserAccountSync, i as resolveDefaultZalouserAccountId, r as listZalouserAccountIds, t as checkZcaAuthenticated } from "./accounts-dI0jjof7.js";
-import { n as normalizeCompatibilityConfig, t as legacyConfigRules } from "./doctor-contract-BjV4tePD.js";
-import { n as isZalouserMutableGroupEntry } from "./security-audit-Dlpl4AzI.js";
-//#region extensions/zalouser/src/config-schema.ts
-const groupConfigSchema = object({
-	enabled: boolean().optional(),
-	requireMention: boolean().optional(),
-	tools: ToolPolicySchema
-});
-const ZalouserConfigSchema = buildCatchallMultiAccountChannelSchema(object({
-	name: string().optional(),
-	enabled: boolean().optional(),
-	markdown: MarkdownConfigSchema,
-	profile: string().optional(),
-	dangerouslyAllowNameMatching: boolean().optional(),
-	dmPolicy: DmPolicySchema.optional(),
-	allowFrom: AllowFromListSchema,
-	historyLimit: number().int().min(0).optional(),
-	groupAllowFrom: AllowFromListSchema,
-	groupPolicy: GroupPolicySchema.optional().default("allowlist"),
-	groups: object({}).catchall(groupConfigSchema).optional(),
-	messagePrefix: string().optional(),
-	responsePrefix: 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 { createZalouserPluginBase as t };

package/dist/shared-client-C3MyzMO-.js

@@ -1,2 +0,0 @@
-import { a as getSharedCodexAppServerClient, i as createIsolatedCodexAppServerClient, t as clearSharedCodexAppServerClientAndWait } from "./shared-client-ChFVc6qy.js";
-export { clearSharedCodexAppServerClientAndWait, createIsolatedCodexAppServerClient, getSharedCodexAppServerClient };