@gaodefa/daocore 2026.5.29 → 2026.5.30

package/dist/setup-surface-BFPNu1qA.js

@@ -0,0 +1,405 @@
+import { t as formatDocsLink } from "./links-CM5vg8_V.js";
+import { n as normalizeAccountId, r as normalizeOptionalAccountId } from "./account-id-B32J-iNN.js";
+import { n as resolveNormalizedAccountEntry } from "./account-lookup-CQEoGO1F.js";
+import { a as listCombinedAccountIds } from "./account-helpers-BEXOONiv.js";
+import { c as getChatChannelMeta } from "./core-D0Y2H55f.js";
+import { t as createSetupTranslator } from "./i18n-Bm-nunfC.js";
+import "./setup-Bk8ieh5V.js";
+import "./account-resolution-DvO8jOO3.js";
+import { n as isAccountConfigured, o as resolveTwitchToken } from "./twitch-DZndfy5z.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 t = createSetupTranslator();
+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([
+		t("wizard.twitch.helpRequiresBot"),
+		t("wizard.twitch.helpCreateApp"),
+		t("wizard.twitch.helpGenerateToken"),
+		t("wizard.twitch.helpTokenTools"),
+		t("wizard.twitch.helpCopyToken"),
+		t("wizard.twitch.helpEnvVars"),
+		`Docs: ${formatDocsLink("/channels/twitch", "channels/twitch")}`
+	].join("\n"), t("wizard.twitch.setupTitle"));
+}
+async function promptToken(prompter, account, envToken) {
+	const existingToken = account?.accessToken ?? "";
+	if (existingToken && !envToken) {
+		if (await prompter.confirm({
+			message: t("wizard.twitch.accessTokenKeep"),
+			initialValue: true
+		})) return existingToken;
+	}
+	return (await prompter.text({
+		message: t("wizard.twitch.oauthTokenPrompt"),
+		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: t("wizard.twitch.botUsernamePrompt"),
+		initialValue: account?.username ?? "",
+		validate: (value) => value?.trim() ? void 0 : "Required"
+	})).trim();
+}
+async function promptClientId(prompter, account) {
+	return (await prompter.text({
+		message: t("wizard.twitch.clientIdPrompt"),
+		initialValue: account?.clientId ?? "",
+		validate: (value) => value?.trim() ? void 0 : "Required"
+	})).trim();
+}
+async function promptChannelName(prompter, account) {
+	return (await prompter.text({
+		message: t("wizard.twitch.channelJoinPrompt"),
+		initialValue: account?.channel ?? "",
+		validate: (value) => value?.trim() ? void 0 : "Required"
+	})).trim();
+}
+async function promptRefreshTokenSetup(prompter, account) {
+	if (!await prompter.confirm({
+		message: t("wizard.twitch.refreshTokenPrompt"),
+		initialValue: Boolean(account?.clientSecret && account?.refreshToken)
+	})) return {};
+	return {
+		clientSecret: (await prompter.text({
+			message: t("wizard.twitch.clientSecretPrompt"),
+			initialValue: account?.clientSecret ?? "",
+			validate: (value) => value?.trim() ? void 0 : "Required"
+		})).trim() || void 0,
+		refreshToken: (await prompter.text({
+			message: t("wizard.twitch.refreshTokenInputPrompt"),
+			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: t("wizard.twitch.envPrompt"),
+		initialValue: true
+	})) return null;
+	const cfgWithAccount = setTwitchAccount(cfg, {
+		username: await promptUsername(prompter, account),
+		clientId: await promptClientId(prompter, account),
+		accessToken: envToken,
+		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: t("wizard.twitch.allowFromPrompt"),
+			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: t("wizard.channels.statusConfigured"),
+		unconfiguredLabel: t("wizard.channels.statusNeedsUsernameTokenClientId"),
+		configuredHint: t("wizard.channels.statusConfigured"),
+		unconfiguredHint: t("wizard.channels.statusNeedsSetup"),
+		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 ? t("wizard.channels.statusConfigured") : t("wizard.channels.statusNeedsUsernameTokenClientId")}`];
+		}
+	},
+	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.DAOCORE_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-CedShqhO.js

@@ -0,0 +1,288 @@
+import { c as normalizeOptionalString } from "./string-coerce-DyL154ka.js";
+import { t as formatDocsLink } from "./links-CM5vg8_V.js";
+import { t as DEFAULT_ACCOUNT_ID } from "./account-id-B32J-iNN.js";
+import "./string-coerce-runtime-DcopKqDR.js";
+import { a as createSetupInputPresenceValidator } from "./setup-helpers-BC9z9VvG.js";
+import { t as createSetupTranslator } from "./i18n-Bm-nunfC.js";
+import { J as setSetupChannelEnabled, Q as splitSetupEntries, a as createAllowFromSection, f as createStandardChannelSetupStatus, v as mergeAllowFromEntries } from "./setup-wizard-helpers-DXfnYF4t.js";
+import "./setup-Bk8ieh5V.js";
+import { i as resolveLineAccount, n as normalizeAccountId, r as resolveDefaultLineAccountId, t as listLineAccountIds } from "./accounts-BoYYrY7x.js";
+//#region extensions/line/src/account-helpers.ts
+function hasLineCredentials(account) {
+	return Boolean(account.channelAccessToken?.trim() && account.channelSecret?.trim());
+}
+function parseLineAllowFromId(raw) {
+	const trimmed = raw.trim().replace(/^line:(?:user:)?/i, "");
+	if (!/^U[a-f0-9]{32}$/i.test(trimmed)) return null;
+	return trimmed;
+}
+//#endregion
+//#region extensions/line/src/setup-core.ts
+function patchLineAccountConfig(params) {
+	const accountId = normalizeAccountId(params.accountId);
+	const lineConfig = params.cfg.channels?.line ?? {};
+	const clearFields = params.clearFields ?? [];
+	if (accountId === "default") {
+		const nextLine = { ...lineConfig };
+		for (const field of clearFields) delete nextLine[field];
+		return {
+			...params.cfg,
+			channels: {
+				...params.cfg.channels,
+				line: {
+					...nextLine,
+					...params.enabled ? { enabled: true } : {},
+					...params.patch
+				}
+			}
+		};
+	}
+	const nextAccount = { ...lineConfig.accounts?.[accountId] };
+	for (const field of clearFields) delete nextAccount[field];
+	return {
+		...params.cfg,
+		channels: {
+			...params.cfg.channels,
+			line: {
+				...lineConfig,
+				...params.enabled ? { enabled: true } : {},
+				accounts: {
+					...lineConfig.accounts,
+					[accountId]: {
+						...nextAccount,
+						...params.enabled ? { enabled: true } : {},
+						...params.patch
+					}
+				}
+			}
+		}
+	};
+}
+function isLineConfigured(cfg, accountId) {
+	return hasLineCredentials(resolveLineAccount({
+		cfg,
+		accountId
+	}));
+}
+const lineSetupAdapter = {
+	resolveAccountId: ({ accountId }) => normalizeAccountId(accountId),
+	applyAccountName: ({ cfg, accountId, name }) => patchLineAccountConfig({
+		cfg,
+		accountId,
+		patch: name?.trim() ? { name: name.trim() } : {}
+	}),
+	validateInput: createSetupInputPresenceValidator({
+		defaultAccountOnlyEnvError: "LINE_CHANNEL_ACCESS_TOKEN can only be used for the default account.",
+		whenNotUseEnv: [{
+			someOf: ["channelAccessToken", "tokenFile"],
+			message: "LINE requires channelAccessToken or --token-file (or --use-env)."
+		}, {
+			someOf: ["channelSecret", "secretFile"],
+			message: "LINE requires channelSecret or --secret-file (or --use-env)."
+		}]
+	}),
+	applyAccountConfig: ({ cfg, accountId, input }) => {
+		const typedInput = input;
+		const normalizedAccountId = normalizeAccountId(accountId);
+		if (normalizedAccountId === "default") return patchLineAccountConfig({
+			cfg,
+			accountId: normalizedAccountId,
+			enabled: true,
+			clearFields: typedInput.useEnv ? [
+				"channelAccessToken",
+				"channelSecret",
+				"tokenFile",
+				"secretFile"
+			] : void 0,
+			patch: typedInput.useEnv ? {} : {
+				...typedInput.tokenFile ? { tokenFile: typedInput.tokenFile } : typedInput.channelAccessToken ? { channelAccessToken: typedInput.channelAccessToken } : {},
+				...typedInput.secretFile ? { secretFile: typedInput.secretFile } : typedInput.channelSecret ? { channelSecret: typedInput.channelSecret } : {}
+			}
+		});
+		return patchLineAccountConfig({
+			cfg,
+			accountId: normalizedAccountId,
+			enabled: true,
+			patch: {
+				...typedInput.tokenFile ? { tokenFile: typedInput.tokenFile } : typedInput.channelAccessToken ? { channelAccessToken: typedInput.channelAccessToken } : {},
+				...typedInput.secretFile ? { secretFile: typedInput.secretFile } : typedInput.channelSecret ? { channelSecret: typedInput.channelSecret } : {}
+			}
+		});
+	}
+};
+//#endregion
+//#region extensions/line/src/setup-surface.ts
+const t = createSetupTranslator();
+const channel = "line";
+const LINE_SETUP_HELP_LINES = [
+	t("wizard.line.helpOpenConsole"),
+	t("wizard.line.helpCopyCredentials"),
+	t("wizard.line.helpEnableWebhook"),
+	t("wizard.line.helpWebhookUrl"),
+	t("wizard.channels.docs", { link: formatDocsLink("/channels/line", "channels/line") })
+];
+const LINE_ALLOW_FROM_HELP_LINES = [
+	t("wizard.line.allowlistIntro"),
+	t("wizard.line.idsCaseSensitive"),
+	t("wizard.line.examples"),
+	"- U1234567890abcdef1234567890abcdef",
+	"- line:user:U1234567890abcdef1234567890abcdef",
+	t("wizard.line.multipleEntries"),
+	t("wizard.channels.docs", { link: formatDocsLink("/channels/line", "channels/line") })
+];
+const lineDmPolicy = {
+	label: "LINE",
+	channel,
+	policyKey: "channels.line.dmPolicy",
+	allowFromKey: "channels.line.allowFrom",
+	resolveConfigKeys: (cfg, accountId) => (accountId ?? resolveDefaultLineAccountId(cfg)) !== "default" ? {
+		policyKey: `channels.line.accounts.${accountId ?? resolveDefaultLineAccountId(cfg)}.dmPolicy`,
+		allowFromKey: `channels.line.accounts.${accountId ?? resolveDefaultLineAccountId(cfg)}.allowFrom`
+	} : {
+		policyKey: "channels.line.dmPolicy",
+		allowFromKey: "channels.line.allowFrom"
+	},
+	getCurrent: (cfg, accountId) => resolveLineAccount({
+		cfg,
+		accountId: accountId ?? resolveDefaultLineAccountId(cfg)
+	}).config.dmPolicy ?? "pairing",
+	setPolicy: (cfg, policy, accountId) => patchLineAccountConfig({
+		cfg,
+		accountId: accountId ?? resolveDefaultLineAccountId(cfg),
+		enabled: true,
+		patch: policy === "open" ? {
+			dmPolicy: "open",
+			allowFrom: mergeAllowFromEntries(resolveLineAccount({
+				cfg,
+				accountId: accountId ?? resolveDefaultLineAccountId(cfg)
+			}).config.allowFrom, ["*"])
+		} : { dmPolicy: policy },
+		clearFields: policy === "pairing" || policy === "disabled" ? ["allowFrom"] : void 0
+	})
+};
+const lineSetupWizard = {
+	channel,
+	status: createStandardChannelSetupStatus({
+		channelLabel: "LINE",
+		configuredLabel: t("wizard.channels.statusConfigured"),
+		unconfiguredLabel: t("wizard.channels.statusNeedsTokenSecret"),
+		configuredHint: t("wizard.channels.statusConfigured"),
+		unconfiguredHint: t("wizard.channels.statusNeedsTokenSecret"),
+		configuredScore: 1,
+		unconfiguredScore: 0,
+		includeStatusLine: true,
+		resolveConfigured: ({ cfg, accountId }) => isLineConfigured(cfg, accountId ?? resolveDefaultLineAccountId(cfg)),
+		resolveExtraStatusLines: ({ cfg }) => [`Accounts: ${listLineAccountIds(cfg).length || 0}`]
+	}),
+	introNote: {
+		title: t("wizard.line.messagingApiTitle"),
+		lines: LINE_SETUP_HELP_LINES,
+		shouldShow: ({ cfg, accountId }) => !isLineConfigured(cfg, accountId ?? resolveDefaultLineAccountId(cfg))
+	},
+	credentials: [{
+		inputKey: "token",
+		providerHint: channel,
+		credentialLabel: t("wizard.line.channelAccessToken"),
+		preferredEnvVar: "LINE_CHANNEL_ACCESS_TOKEN",
+		helpTitle: t("wizard.line.messagingApiTitle"),
+		helpLines: LINE_SETUP_HELP_LINES,
+		envPrompt: t("wizard.line.tokenEnvPrompt"),
+		keepPrompt: t("wizard.line.tokenKeepPrompt"),
+		inputPrompt: t("wizard.line.tokenInputPrompt"),
+		allowEnv: ({ accountId }) => accountId === DEFAULT_ACCOUNT_ID,
+		inspect: ({ cfg, accountId }) => {
+			const resolved = resolveLineAccount({
+				cfg,
+				accountId
+			});
+			return {
+				accountConfigured: Boolean(normalizeOptionalString(resolved.channelAccessToken) && normalizeOptionalString(resolved.channelSecret)),
+				hasConfiguredValue: Boolean(normalizeOptionalString(resolved.config.channelAccessToken) ?? normalizeOptionalString(resolved.config.tokenFile)),
+				resolvedValue: normalizeOptionalString(resolved.channelAccessToken),
+				envValue: accountId === "default" ? normalizeOptionalString(process.env.LINE_CHANNEL_ACCESS_TOKEN) : void 0
+			};
+		},
+		applyUseEnv: ({ cfg, accountId }) => patchLineAccountConfig({
+			cfg,
+			accountId,
+			enabled: true,
+			clearFields: ["channelAccessToken", "tokenFile"],
+			patch: {}
+		}),
+		applySet: ({ cfg, accountId, resolvedValue }) => patchLineAccountConfig({
+			cfg,
+			accountId,
+			enabled: true,
+			clearFields: ["tokenFile"],
+			patch: { channelAccessToken: resolvedValue }
+		})
+	}, {
+		inputKey: "password",
+		providerHint: "line-secret",
+		credentialLabel: t("wizard.line.channelSecret"),
+		preferredEnvVar: "LINE_CHANNEL_SECRET",
+		helpTitle: t("wizard.line.messagingApiTitle"),
+		helpLines: LINE_SETUP_HELP_LINES,
+		envPrompt: t("wizard.line.secretEnvPrompt"),
+		keepPrompt: t("wizard.line.secretKeepPrompt"),
+		inputPrompt: t("wizard.line.secretInputPrompt"),
+		allowEnv: ({ accountId }) => accountId === DEFAULT_ACCOUNT_ID,
+		inspect: ({ cfg, accountId }) => {
+			const resolved = resolveLineAccount({
+				cfg,
+				accountId
+			});
+			return {
+				accountConfigured: Boolean(normalizeOptionalString(resolved.channelAccessToken) && normalizeOptionalString(resolved.channelSecret)),
+				hasConfiguredValue: Boolean(normalizeOptionalString(resolved.config.channelSecret) ?? normalizeOptionalString(resolved.config.secretFile)),
+				resolvedValue: normalizeOptionalString(resolved.channelSecret),
+				envValue: accountId === "default" ? normalizeOptionalString(process.env.LINE_CHANNEL_SECRET) : void 0
+			};
+		},
+		applyUseEnv: ({ cfg, accountId }) => patchLineAccountConfig({
+			cfg,
+			accountId,
+			enabled: true,
+			clearFields: ["channelSecret", "secretFile"],
+			patch: {}
+		}),
+		applySet: ({ cfg, accountId, resolvedValue }) => patchLineAccountConfig({
+			cfg,
+			accountId,
+			enabled: true,
+			clearFields: ["secretFile"],
+			patch: { channelSecret: resolvedValue }
+		})
+	}],
+	allowFrom: createAllowFromSection({
+		helpTitle: t("wizard.line.allowlistTitle"),
+		helpLines: LINE_ALLOW_FROM_HELP_LINES,
+		message: t("wizard.line.allowFromPrompt"),
+		placeholder: "U1234567890abcdef1234567890abcdef",
+		invalidWithoutCredentialNote: t("wizard.line.allowFromInvalid"),
+		parseInputs: splitSetupEntries,
+		parseId: parseLineAllowFromId,
+		apply: ({ cfg, accountId, allowFrom }) => patchLineAccountConfig({
+			cfg,
+			accountId,
+			enabled: true,
+			patch: {
+				dmPolicy: "allowlist",
+				allowFrom
+			}
+		})
+	}),
+	dmPolicy: lineDmPolicy,
+	completionNote: {
+		title: t("wizard.line.webhookTitle"),
+		lines: [
+			t("wizard.line.completionEnableWebhook"),
+			t("wizard.line.completionDefaultWebhook"),
+			t("wizard.line.completionWebhookPath"),
+			t("wizard.channels.docs", { link: formatDocsLink("/channels/line", "channels/line") })
+		]
+	},
+	disable: (cfg) => setSetupChannelEnabled(cfg, channel, false)
+};
+//#endregion
+export { lineSetupAdapter as n, hasLineCredentials as r, lineSetupWizard as t };