@pixelzx/genesis 2026.6.6-1 → 2026.6.7

package/dist/setup-surface-C5F8cr6e2.js

@@ -1,403 +0,0 @@
-import { t as formatDocsLink } from "./links-C1-jbHJx.js";
-import { n as normalizeAccountId, r as normalizeOptionalAccountId } from "./account-id-CTXHUezn.js";
-import { n as resolveNormalizedAccountEntry } from "./account-lookup-C8qPhTca.js";
-import { i as listCombinedAccountIds } from "./account-helpers-Cy1bqB4c.js";
-import { c as getChatChannelMeta } from "./core-CE92oVKC.js";
-import "./setup-Cru71eZi.js";
-import "./account-resolution-D0lCF0uW.js";
-import { n as isAccountConfigured, o as resolveTwitchToken } from "./twitch-B2ltIhRM.js";
-//#region extensions/twitch/src/config.ts
-/**
-* Default account ID for Twitch
-*/
-const DEFAULT_ACCOUNT_ID = "default";
-/**
-* Get account config from core config
-*
-* Handles two patterns:
-* 1. Simplified single-account: base-level properties create implicit "default" account
-* 2. Multi-account: explicit accounts object
-*
-* For "default" account, base-level properties take precedence over accounts.default
-* For other accounts, only the accounts object is checked
-*/
-function getAccountConfig(coreConfig, accountId) {
-	if (!coreConfig || typeof coreConfig !== "object") return null;
-	const cfg = coreConfig;
-	const normalizedAccountId = normalizeAccountId(accountId);
-	const twitchRaw = cfg.channels?.twitch;
-	const accounts = twitchRaw?.accounts;
-	if (normalizedAccountId === "default") {
-		const accountFromAccounts = resolveNormalizedAccountEntry(accounts, DEFAULT_ACCOUNT_ID, normalizeAccountId);
-		const baseLevel = {
-			username: typeof twitchRaw?.username === "string" ? twitchRaw.username : void 0,
-			accessToken: typeof twitchRaw?.accessToken === "string" ? twitchRaw.accessToken : void 0,
-			clientId: typeof twitchRaw?.clientId === "string" ? twitchRaw.clientId : void 0,
-			channel: typeof twitchRaw?.channel === "string" ? twitchRaw.channel : void 0,
-			enabled: typeof twitchRaw?.enabled === "boolean" ? twitchRaw.enabled : void 0,
-			allowFrom: Array.isArray(twitchRaw?.allowFrom) ? twitchRaw.allowFrom : void 0,
-			allowedRoles: Array.isArray(twitchRaw?.allowedRoles) ? twitchRaw.allowedRoles : void 0,
-			requireMention: typeof twitchRaw?.requireMention === "boolean" ? twitchRaw.requireMention : void 0,
-			clientSecret: typeof twitchRaw?.clientSecret === "string" ? twitchRaw.clientSecret : void 0,
-			refreshToken: typeof twitchRaw?.refreshToken === "string" ? twitchRaw.refreshToken : void 0,
-			expiresIn: typeof twitchRaw?.expiresIn === "number" ? twitchRaw.expiresIn : void 0,
-			obtainmentTimestamp: typeof twitchRaw?.obtainmentTimestamp === "number" ? twitchRaw.obtainmentTimestamp : void 0
-		};
-		const merged = {
-			...accountFromAccounts,
-			...baseLevel
-		};
-		if (merged.username) return merged;
-		if (accountFromAccounts) return accountFromAccounts;
-		return null;
-	}
-	const account = resolveNormalizedAccountEntry(accounts, normalizedAccountId, normalizeAccountId);
-	if (!account) return null;
-	return account;
-}
-/**
-* List all configured account IDs
-*
-* Includes both explicit accounts and implicit "default" from base-level config
-*/
-function listAccountIds(cfg) {
-	const twitchRaw = cfg.channels?.twitch;
-	const accountMap = twitchRaw?.accounts;
-	const hasBaseLevelConfig = twitchRaw && (typeof twitchRaw.username === "string" || typeof twitchRaw.accessToken === "string" || typeof twitchRaw.channel === "string");
-	return listCombinedAccountIds({
-		configuredAccountIds: Object.keys(accountMap ?? {}).map((accountId) => normalizeAccountId(accountId)),
-		implicitAccountId: hasBaseLevelConfig ? DEFAULT_ACCOUNT_ID : void 0
-	});
-}
-function resolveDefaultTwitchAccountId(cfg) {
-	const preferredRaw = typeof cfg.channels?.twitch?.defaultAccount === "string" ? cfg.channels.twitch.defaultAccount.trim() : "";
-	const preferred = preferredRaw ? normalizeAccountId(preferredRaw) : "";
-	const ids = listAccountIds(cfg);
-	if (preferred && ids.includes(preferred)) return preferred;
-	if (ids.includes("default")) return DEFAULT_ACCOUNT_ID;
-	return ids[0] ?? "default";
-}
-function resolveTwitchAccountContext(cfg, accountId) {
-	const resolvedAccountId = accountId?.trim() ? normalizeAccountId(accountId) : resolveDefaultTwitchAccountId(cfg);
-	const account = getAccountConfig(cfg, resolvedAccountId);
-	const tokenResolution = resolveTwitchToken(cfg, { accountId: resolvedAccountId });
-	return {
-		accountId: resolvedAccountId,
-		account,
-		tokenResolution,
-		configured: account ? isAccountConfigured(account, tokenResolution.token) : false,
-		availableAccountIds: listAccountIds(cfg)
-	};
-}
-function resolveTwitchSnapshotAccountId(cfg, account) {
-	const accountMap = (cfg.channels?.twitch)?.accounts ?? {};
-	return Object.entries(accountMap).find(([, value]) => value === account)?.[0] ?? "default";
-}
-//#endregion
-//#region extensions/twitch/src/setup-surface.ts
-/**
-* Twitch setup wizard surface for CLI setup.
-*/
-const channel = "twitch";
-const INVALID_ACCOUNT_ID_MESSAGE = "Invalid Twitch account id";
-function normalizeRequestedSetupAccountId(accountId) {
-	const normalized = normalizeOptionalAccountId(accountId);
-	if (!normalized) throw new Error(INVALID_ACCOUNT_ID_MESSAGE);
-	return normalized;
-}
-function resolveSetupAccountId(cfg, requestedAccountId) {
-	const requested = requestedAccountId?.trim();
-	if (requested) return normalizeRequestedSetupAccountId(requested);
-	const preferred = cfg.channels?.twitch?.defaultAccount?.trim();
-	return preferred ? normalizeAccountId(preferred) : resolveDefaultTwitchAccountId(cfg);
-}
-function setTwitchAccount(cfg, account, accountId = resolveSetupAccountId(cfg)) {
-	const resolvedAccountId = accountId.trim() ? normalizeRequestedSetupAccountId(accountId) : resolveSetupAccountId(cfg);
-	const existing = getAccountConfig(cfg, resolvedAccountId);
-	const merged = {
-		username: account.username ?? existing?.username ?? "",
-		accessToken: account.accessToken ?? existing?.accessToken ?? "",
-		clientId: account.clientId ?? existing?.clientId ?? "",
-		channel: account.channel ?? existing?.channel ?? "",
-		enabled: account.enabled ?? existing?.enabled ?? true,
-		allowFrom: account.allowFrom ?? existing?.allowFrom,
-		allowedRoles: account.allowedRoles ?? existing?.allowedRoles,
-		requireMention: account.requireMention ?? existing?.requireMention,
-		clientSecret: account.clientSecret ?? existing?.clientSecret,
-		refreshToken: account.refreshToken ?? existing?.refreshToken,
-		expiresIn: account.expiresIn ?? existing?.expiresIn,
-		obtainmentTimestamp: account.obtainmentTimestamp ?? existing?.obtainmentTimestamp
-	};
-	return {
-		...cfg,
-		channels: {
-			...cfg.channels,
-			twitch: {
-				...cfg.channels?.twitch,
-				enabled: true,
-				accounts: {
-					...(cfg.channels?.twitch)?.accounts,
-					[resolvedAccountId]: merged
-				}
-			}
-		}
-	};
-}
-async function noteTwitchSetupHelp(prompter) {
-	await prompter.note([
-		"Twitch requires a bot account with OAuth token.",
-		"1. Create a Twitch application at https://dev.twitch.tv/console",
-		"2. Generate a token with scopes: chat:read and chat:write",
-		"   Use https://twitchtokengenerator.com/ or https://twitchapps.com/tmi/",
-		"3. Copy the token (starts with 'oauth:') and Client ID",
-		"Env vars supported: GENESIS_TWITCH_ACCESS_TOKEN",
-		`Docs: ${formatDocsLink("/channels/twitch", "channels/twitch")}`
-	].join("\n"), "Twitch setup");
-}
-async function promptToken(prompter, account, envToken) {
-	const existingToken = account?.accessToken ?? "";
-	if (existingToken && !envToken) {
-		if (await prompter.confirm({
-			message: "Access token already configured. Keep it?",
-			initialValue: true
-		})) return existingToken;
-	}
-	return (await prompter.text({
-		message: "Twitch OAuth token (oauth:...)",
-		initialValue: envToken ?? "",
-		validate: (value) => {
-			const raw = value?.trim() ?? "";
-			if (!raw) return "Required";
-			if (!raw.startsWith("oauth:")) return "Token should start with 'oauth:'";
-		}
-	})).trim();
-}
-async function promptUsername(prompter, account) {
-	return (await prompter.text({
-		message: "Twitch bot username",
-		initialValue: account?.username ?? "",
-		validate: (value) => value?.trim() ? void 0 : "Required"
-	})).trim();
-}
-async function promptClientId(prompter, account) {
-	return (await prompter.text({
-		message: "Twitch Client ID",
-		initialValue: account?.clientId ?? "",
-		validate: (value) => value?.trim() ? void 0 : "Required"
-	})).trim();
-}
-async function promptChannelName(prompter, account) {
-	return (await prompter.text({
-		message: "Channel to join",
-		initialValue: account?.channel ?? "",
-		validate: (value) => value?.trim() ? void 0 : "Required"
-	})).trim();
-}
-async function promptRefreshTokenSetup(prompter, account) {
-	if (!await prompter.confirm({
-		message: "Enable automatic token refresh (requires client secret and refresh token)?",
-		initialValue: Boolean(account?.clientSecret && account?.refreshToken)
-	})) return {};
-	return {
-		clientSecret: (await prompter.text({
-			message: "Twitch Client Secret (for token refresh)",
-			initialValue: account?.clientSecret ?? "",
-			validate: (value) => value?.trim() ? void 0 : "Required"
-		})).trim() || void 0,
-		refreshToken: (await prompter.text({
-			message: "Twitch Refresh Token",
-			initialValue: account?.refreshToken ?? "",
-			validate: (value) => value?.trim() ? void 0 : "Required"
-		})).trim() || void 0
-	};
-}
-async function configureWithEnvToken(cfg, prompter, account, envToken, forceAllowFrom, dmPolicy, accountId = resolveSetupAccountId(cfg)) {
-	const resolvedAccountId = accountId.trim() ? normalizeRequestedSetupAccountId(accountId) : resolveSetupAccountId(cfg);
-	if (resolvedAccountId !== "default") return null;
-	if (!await prompter.confirm({
-		message: "Twitch env var GENESIS_TWITCH_ACCESS_TOKEN detected. Use env token?",
-		initialValue: true
-	})) return null;
-	const cfgWithAccount = setTwitchAccount(cfg, {
-		username: await promptUsername(prompter, account),
-		clientId: await promptClientId(prompter, account),
-		accessToken: "",
-		enabled: true
-	}, resolvedAccountId);
-	if (forceAllowFrom && dmPolicy.promptAllowFrom) return { cfg: await dmPolicy.promptAllowFrom({
-		cfg: cfgWithAccount,
-		prompter,
-		accountId: resolvedAccountId
-	}) };
-	return { cfg: cfgWithAccount };
-}
-function setTwitchAccessControl(cfg, allowedRoles, requireMention, accountId) {
-	const resolvedAccountId = resolveSetupAccountId(cfg, accountId);
-	const account = getAccountConfig(cfg, resolvedAccountId);
-	if (!account) return cfg;
-	return setTwitchAccount(cfg, {
-		...account,
-		allowedRoles,
-		requireMention
-	}, resolvedAccountId);
-}
-function resolveTwitchGroupPolicy(cfg, accountId) {
-	const account = getAccountConfig(cfg, resolveSetupAccountId(cfg, accountId));
-	if (account?.allowedRoles?.includes("all")) return "open";
-	if (account?.allowedRoles?.includes("moderator")) return "allowlist";
-	return "disabled";
-}
-function setTwitchGroupPolicy(cfg, policy, accountId) {
-	return setTwitchAccessControl(cfg, policy === "open" ? ["all"] : policy === "allowlist" ? ["moderator", "vip"] : [], true, accountId);
-}
-const twitchDmPolicy = {
-	label: "Twitch",
-	channel,
-	policyKey: "channels.twitch.accounts.default.allowedRoles",
-	allowFromKey: "channels.twitch.accounts.default.allowFrom",
-	resolveConfigKeys: (cfg, accountId) => {
-		const resolvedAccountId = resolveSetupAccountId(cfg, accountId);
-		return {
-			policyKey: `channels.twitch.accounts.${resolvedAccountId}.allowedRoles`,
-			allowFromKey: `channels.twitch.accounts.${resolvedAccountId}.allowFrom`
-		};
-	},
-	getCurrent: (cfg, accountId) => {
-		const account = getAccountConfig(cfg, resolveSetupAccountId(cfg, accountId));
-		if (account?.allowedRoles?.includes("all")) return "open";
-		if (account?.allowFrom && account.allowFrom.length > 0) return "allowlist";
-		return "disabled";
-	},
-	setPolicy: (cfg, policy, accountId) => {
-		return setTwitchAccessControl(cfg, policy === "open" ? ["all"] : policy === "allowlist" ? [] : ["moderator"], true, accountId);
-	},
-	promptAllowFrom: async ({ cfg, prompter, accountId }) => {
-		const resolvedAccountId = resolveSetupAccountId(cfg, accountId);
-		const account = getAccountConfig(cfg, resolvedAccountId);
-		const existingAllowFrom = account?.allowFrom ?? [];
-		const allowFrom = (await prompter.text({
-			message: "Twitch allowFrom (user IDs, one per line, recommended for security)",
-			placeholder: "123456789",
-			initialValue: existingAllowFrom[0] || void 0
-		}) ?? "").split(/[\n,;]+/g).map((s) => s.trim()).filter(Boolean);
-		return setTwitchAccount(cfg, {
-			...account ?? void 0,
-			allowFrom
-		}, resolvedAccountId);
-	}
-};
-const twitchGroupAccess = {
-	label: "Twitch chat",
-	placeholder: "",
-	skipAllowlistEntries: true,
-	currentPolicy: ({ cfg, accountId }) => resolveTwitchGroupPolicy(cfg, accountId),
-	currentEntries: ({ cfg, accountId }) => {
-		return getAccountConfig(cfg, resolveSetupAccountId(cfg, accountId))?.allowFrom ?? [];
-	},
-	updatePrompt: ({ cfg, accountId }) => {
-		const account = getAccountConfig(cfg, resolveSetupAccountId(cfg, accountId));
-		return Boolean(account?.allowedRoles?.length || account?.allowFrom?.length);
-	},
-	setPolicy: ({ cfg, accountId, policy }) => setTwitchGroupPolicy(cfg, policy, accountId),
-	resolveAllowlist: async () => [],
-	applyAllowlist: ({ cfg }) => cfg
-};
-const twitchSetupAdapter = {
-	resolveAccountId: ({ cfg }) => resolveSetupAccountId(cfg),
-	applyAccountConfig: ({ cfg, accountId }) => setTwitchAccount(cfg, { enabled: true }, accountId)
-};
-const twitchSetupWizard = {
-	channel,
-	resolveAccountIdForConfigure: ({ cfg, accountOverride }) => resolveSetupAccountId(cfg, accountOverride),
-	resolveShouldPromptAccountIds: () => false,
-	status: {
-		configuredLabel: "configured",
-		unconfiguredLabel: "needs username, token, and clientId",
-		configuredHint: "configured",
-		unconfiguredHint: "needs setup",
-		resolveConfigured: ({ cfg, accountId }) => {
-			return resolveTwitchAccountContext(cfg, resolveSetupAccountId(cfg, accountId)).configured;
-		},
-		resolveStatusLines: ({ cfg, accountId }) => {
-			const resolvedAccountId = resolveSetupAccountId(cfg, accountId);
-			const configured = resolveTwitchAccountContext(cfg, resolvedAccountId).configured;
-			return [`Twitch${resolvedAccountId !== "default" ? ` (${resolvedAccountId})` : ""}: ${configured ? "configured" : "needs username, token, and clientId"}`];
-		}
-	},
-	credentials: [],
-	finalize: async ({ cfg, accountId: requestedAccountId, prompter, forceAllowFrom }) => {
-		const accountId = resolveSetupAccountId(cfg, requestedAccountId);
-		const account = getAccountConfig(cfg, accountId);
-		if (!account || !isAccountConfigured(account)) await noteTwitchSetupHelp(prompter);
-		const envToken = process.env.GENESIS_TWITCH_ACCESS_TOKEN?.trim();
-		if (accountId === "default" && envToken && !account?.accessToken) {
-			const envResult = await configureWithEnvToken(cfg, prompter, account, envToken, forceAllowFrom, twitchDmPolicy, accountId);
-			if (envResult) return envResult;
-		}
-		const username = await promptUsername(prompter, account);
-		const token = await promptToken(prompter, account, envToken);
-		const clientId = await promptClientId(prompter, account);
-		const channelName = await promptChannelName(prompter, account);
-		const { clientSecret, refreshToken } = await promptRefreshTokenSetup(prompter, account);
-		const cfgWithAccount = setTwitchAccount(cfg, {
-			username,
-			accessToken: token,
-			clientId,
-			channel: channelName,
-			clientSecret,
-			refreshToken,
-			enabled: true
-		}, accountId);
-		return { cfg: forceAllowFrom && twitchDmPolicy.promptAllowFrom ? await twitchDmPolicy.promptAllowFrom({
-			cfg: cfgWithAccount,
-			prompter,
-			accountId
-		}) : cfgWithAccount };
-	},
-	dmPolicy: twitchDmPolicy,
-	groupAccess: twitchGroupAccess,
-	disable: (cfg) => {
-		const twitch = cfg.channels?.twitch;
-		return {
-			...cfg,
-			channels: {
-				...cfg.channels,
-				twitch: {
-					...twitch,
-					enabled: false
-				}
-			}
-		};
-	}
-};
-const twitchSetupPlugin = {
-	id: channel,
-	meta: getChatChannelMeta(channel),
-	capabilities: { chatTypes: ["group"] },
-	config: {
-		listAccountIds: (cfg) => listAccountIds(cfg),
-		resolveAccount: (cfg, accountId) => {
-			const resolvedAccountId = normalizeAccountId(accountId ?? resolveDefaultTwitchAccountId(cfg));
-			const account = getAccountConfig(cfg, resolvedAccountId);
-			if (!account) return {
-				accountId: resolvedAccountId,
-				username: "",
-				accessToken: "",
-				clientId: "",
-				channel: "",
-				enabled: false
-			};
-			return {
-				accountId: resolvedAccountId,
-				...account
-			};
-		},
-		defaultAccountId: (cfg) => resolveDefaultTwitchAccountId(cfg),
-		isConfigured: (account, cfg) => resolveTwitchAccountContext(cfg, account?.accountId).configured,
-		isEnabled: (account) => account.enabled !== false
-	},
-	setup: twitchSetupAdapter,
-	setupWizard: twitchSetupWizard
-};
-//#endregion
-export { getAccountConfig as a, resolveTwitchAccountContext as c, DEFAULT_ACCOUNT_ID as i, resolveTwitchSnapshotAccountId as l, twitchSetupPlugin as n, listAccountIds as o, twitchSetupWizard as r, resolveDefaultTwitchAccountId as s, twitchSetupAdapter as t };

package/dist/setup-surface-CArOZxWv.js

@@ -1,72 +0,0 @@
-import { c as validateUrbitBaseUrl, f as normalizeShip, i as resolveTlonSetupStatusLines, n as createTlonSetupWizardBase, o as isBlockedUrbitHostname, r as resolveTlonSetupConfigured, t as applyTlonSetupConfig, u as resolveTlonAccount } from "./setup-core-DFDx-2sA.js";
-//#region extensions/tlon/src/setup-surface.ts
-function parseList(value) {
-	return value.split(/[\n,;]+/g).map((entry) => entry.trim()).filter(Boolean);
-}
-const tlonSetupWizard = createTlonSetupWizardBase({
-	resolveConfigured: async ({ cfg, accountId }) => await resolveTlonSetupConfigured(cfg, accountId),
-	resolveStatusLines: async ({ cfg, accountId }) => await resolveTlonSetupStatusLines(cfg, accountId),
-	finalize: async ({ cfg, accountId, prompter }) => {
-		let next = cfg;
-		const resolved = resolveTlonAccount(next, accountId);
-		const validatedUrl = validateUrbitBaseUrl(resolved.url ?? "");
-		if (!validatedUrl.ok) throw new Error(`Invalid URL: ${validatedUrl.error}`);
-		let dangerouslyAllowPrivateNetwork = resolved.dangerouslyAllowPrivateNetwork ?? false;
-		if (isBlockedUrbitHostname(validatedUrl.hostname)) {
-			dangerouslyAllowPrivateNetwork = await prompter.confirm({
-				message: "Ship URL looks like a private/internal host. Allow private network access? (SSRF risk)",
-				initialValue: dangerouslyAllowPrivateNetwork
-			});
-			if (!dangerouslyAllowPrivateNetwork) throw new Error("Refusing private/internal ship URL without explicit network opt-in");
-		}
-		next = applyTlonSetupConfig({
-			cfg: next,
-			accountId,
-			input: { dangerouslyAllowPrivateNetwork }
-		});
-		const currentGroups = resolved.groupChannels;
-		if (await prompter.confirm({
-			message: "Add group channels manually? (optional)",
-			initialValue: currentGroups.length > 0
-		})) {
-			const entry = await prompter.text({
-				message: "Group channels (comma-separated)",
-				placeholder: "chat/~host-ship/general, chat/~host-ship/support",
-				initialValue: currentGroups.join(", ") || void 0
-			});
-			next = applyTlonSetupConfig({
-				cfg: next,
-				accountId,
-				input: { groupChannels: parseList(entry ?? "") }
-			});
-		}
-		const currentAllowlist = resolved.dmAllowlist;
-		if (await prompter.confirm({
-			message: "Restrict DMs with an allowlist?",
-			initialValue: currentAllowlist.length > 0
-		})) {
-			const entry = await prompter.text({
-				message: "DM allowlist (comma-separated ship names)",
-				placeholder: "~zod, ~nec",
-				initialValue: currentAllowlist.join(", ") || void 0
-			});
-			next = applyTlonSetupConfig({
-				cfg: next,
-				accountId,
-				input: { dmAllowlist: parseList(entry ?? "").map((ship) => normalizeShip(ship)) }
-			});
-		}
-		const autoDiscoverChannels = await prompter.confirm({
-			message: "Enable auto-discovery of group channels?",
-			initialValue: resolved.autoDiscoverChannels ?? true
-		});
-		next = applyTlonSetupConfig({
-			cfg: next,
-			accountId,
-			input: { autoDiscoverChannels }
-		});
-		return { cfg: next };
-	}
-});
-//#endregion
-export { tlonSetupWizard as t };

package/dist/setup-surface-D5kQP_5C.js

@@ -1,219 +0,0 @@
-import { o as hasConfiguredSecretInput } from "./types.secrets-BbgGt42I.js";
-import { t as DEFAULT_ACCOUNT_ID } from "./account-id-CTXHUezn.js";
-import { B as runSingleChannelSecretStep, P as promptSingleChannelSecretInput, f as createStandardChannelSetupStatus, n as buildSingleChannelSecretPromptState } from "./setup-wizard-helpers-XPwLXYcv.js";
-import "./setup-Cru71eZi.js";
-import { i as resolveZaloAccount } from "./accounts-DAo-x54e.js";
-import { a as promptZaloAllowFrom, i as noteZaloTokenHelp, n as zaloDmPolicy } from "./setup-core-BDZ0GEn7.js";
-//#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" ? {
-				...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: "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 };