@gaodefa/daocore 2026.5.54 → 2026.5.56

package/dist/channel-plugin-runtime-DbH-PJHG.js

@@ -0,0 +1,998 @@
+import { a as normalizeLowercaseStringOrEmpty, c as normalizeOptionalString } from "./string-coerce-DyL154ka.js";
+import { t as formatDocsLink } from "./links-CM5vg8_V.js";
+import { s as hasConfiguredSecretInput } from "./types.secrets-Ct1DNG7D.js";
+import { n as normalizeAccountId, t as DEFAULT_ACCOUNT_ID } from "./account-id-B32J-iNN.js";
+import { At as boolean, Et as array, Nn as record, Rn as string, Tn as object, Xn as union, dn as literal, wn as number, yt as _enum } from "./schemas-Del5uzR8.js";
+import { R as requireOpenAllowFrom, h as MarkdownConfigSchema, l as GroupPolicySchema, n as BlockStreamingCoalesceSchema, o as DmPolicySchema } from "./zod-schema.core-D3MmpZyV.js";
+import { r as buildChannelConfigSchema } from "./config-schema-CpJ4LFf2.js";
+import { p as resolvePayloadMediaUrls, x as sendTextMediaPayload } from "./reply-payload-DMPQsrQC.js";
+import { f as renderMessagePresentationFallbackText, l as normalizeMessagePresentation } from "./payload-BDV15CYA.js";
+import { n as resolveChannelGroupRequireMention } from "./group-policy-CRl_OjIo.js";
+import { r as createLazyRuntimeModule } from "./lazy-runtime-D-7_JraP.js";
+import { s as createScopedChannelConfigAdapter, t as adaptScopedAccountAccessor } from "./channel-config-helpers-CQb9YOAn.js";
+import "./string-coerce-runtime-DcopKqDR.js";
+import { n as describeAccountSnapshot } from "./account-helpers-BEXOONiv.js";
+import { a as createSetupInputPresenceValidator, n as applySetupAccountConfigPatch, s as migrateBaseNameToDefaultAccount, t as applyAccountNameToChannelSection } from "./setup-helpers-BC9z9VvG.js";
+import { d as stripTargetKindPrefix, i as createChatChannelPlugin, n as buildThreadAwareOutboundSessionRoute, t as buildChannelOutboundSessionRoute, u as stripChannelTargetPrefix } from "./core-DC7Ny2oO.js";
+import "./channel-core-DI56iN4a.js";
+import { r as buildSecretInputSchema } from "./secret-input-s8BgZnEq.js";
+import { t as createAccountStatusSink } from "./channel-lifecycle.core-CDt0hRZR.js";
+import { n as formatNormalizedAllowFromEntries } from "./allow-from-BsbZfqm-.js";
+import { n as createDangerousNameMatchingMutableAllowlistWarningCollector, r as createRestrictSendersChannelSecurity } from "./channel-policy-Be-Ujzjr.js";
+import { t as createChannelDirectoryAdapter } from "./directory-runtime-C8foW0XO.js";
+import { t as createSetupTranslator } from "./i18n-Bm-nunfC.js";
+import { f as createStandardChannelSetupStatus } from "./setup-wizard-helpers-DXfnYF4t.js";
+import "./setup-Bk8ieh5V.js";
+import "./setup-runtime-BvIWHDKO.js";
+import { t as resolveApprovalApprovers } from "./approval-approvers-BaAy3FfF.js";
+import { t as createResolvedApproverActionAuthAdapter } from "./approval-auth-helpers-DSaKGCWn.js";
+import { o as isPrivateNetworkOptInEnabled } from "./ssrf-policy-DsqKLgib.js";
+import "./ssrf-runtime-Gwgbj2qf.js";
+import { t as chunkTextForOutbound } from "./text-chunking-ObhJDe8L.js";
+import { d as createDefaultChannelRuntimeState, u as createComputedAccountStatusAdapter } from "./status-helpers-nyf_mfYa.js";
+import { n as buildPassiveProbedChannelStatusSummary } from "./extension-shared-D6I0yOLZ.js";
+import "./channel-config-primitives-iidLm0ld.js";
+import "./channel-lifecycle-DDnbT5P-.js";
+import { k as createChannelMessageAdapterFromOutbound } from "./channel-message-YAmKOwAT.js";
+import { r as createLoggedPairingApprovalNotifier } from "./channel-pairing-BQeyBt0a.js";
+import { i as createAttachedChannelResultAdapter, t as attachChannelToResult } from "./channel-send-result-swFdRKhg.js";
+import { g as normalizeMattermostBaseUrl, i as resolveMattermostReplyToMode, n as resolveDefaultMattermostAccountId, r as resolveMattermostAccount, t as listMattermostAccountIds } from "./accounts-DoryUQ_b.js";
+import { t as resolveMattermostGatewayAuthBypassPaths } from "./gateway-auth-bypass-BHgOAkk8.js";
+import { n as normalizeCompatibilityConfig, t as legacyConfigRules } from "./doctor-contract-S7D83ciX.js";
+import { n as collectRuntimeConfigAssignments, r as secretTargetRegistryEntries } from "./secret-contract-CmNEpCHk.js";
+//#region extensions/mattermost/src/approval-auth.ts
+const MATTERMOST_USER_ID_RE = /^[a-z0-9]{26}$/;
+function normalizeMattermostApproverId(value) {
+	const lowered = normalizeLowercaseStringOrEmpty(String(value).trim().replace(/^(mattermost|user):/i, "").replace(/^@/, "").trim());
+	return MATTERMOST_USER_ID_RE.test(lowered) ? lowered : void 0;
+}
+const mattermostApprovalAuth = createResolvedApproverActionAuthAdapter({
+	channelLabel: "Mattermost",
+	resolveApprovers: ({ cfg, accountId }) => {
+		const account = resolveMattermostAccount({
+			cfg,
+			accountId
+		}).config;
+		return resolveApprovalApprovers({
+			allowFrom: account.allowFrom,
+			normalizeApprover: normalizeMattermostApproverId
+		});
+	},
+	normalizeSenderId: (value) => normalizeMattermostApproverId(value)
+});
+//#endregion
+//#region extensions/mattermost/src/channel-config-shared.ts
+const mattermostMeta = {
+	id: "mattermost",
+	label: "Mattermost",
+	selectionLabel: "Mattermost (plugin)",
+	detailLabel: "Mattermost Bot",
+	docsPath: "/channels/mattermost",
+	docsLabel: "mattermost",
+	blurb: "self-hosted Slack-style chat; install the plugin to enable.",
+	systemImage: "bubble.left.and.bubble.right",
+	order: 65,
+	quickstartAllowFrom: true
+};
+function normalizeMattermostAllowEntry(entry) {
+	return normalizeLowercaseStringOrEmpty(entry.trim().replace(/^(mattermost|user):/i, "").replace(/^@/, ""));
+}
+function formatMattermostAllowEntry(entry) {
+	const trimmed = entry.trim();
+	if (!trimmed) return "";
+	if (trimmed.startsWith("@")) {
+		const username = trimmed.slice(1).trim();
+		return username ? `@${normalizeLowercaseStringOrEmpty(username)}` : "";
+	}
+	return normalizeLowercaseStringOrEmpty(trimmed.replace(/^(mattermost|user):/i, ""));
+}
+const mattermostConfigAdapter = createScopedChannelConfigAdapter({
+	sectionKey: "mattermost",
+	listAccountIds: listMattermostAccountIds,
+	resolveAccount: adaptScopedAccountAccessor(resolveMattermostAccount),
+	defaultAccountId: resolveDefaultMattermostAccountId,
+	clearBaseFields: [
+		"botToken",
+		"baseUrl",
+		"name"
+	],
+	resolveAllowFrom: (account) => account.config.allowFrom,
+	formatAllowFrom: (allowFrom) => formatNormalizedAllowFromEntries({
+		allowFrom,
+		normalizeEntry: formatMattermostAllowEntry
+	})
+});
+function isMattermostConfigured$1(account) {
+	return Boolean(account.botToken && account.baseUrl);
+}
+function describeMattermostAccount(account) {
+	return describeAccountSnapshot({
+		account,
+		configured: isMattermostConfigured$1(account),
+		extra: {
+			botTokenSource: account.botTokenSource,
+			baseUrl: account.baseUrl
+		}
+	});
+}
+//#endregion
+//#region extensions/mattermost/src/config-schema-core.ts
+const MattermostGroupSchema = object({ 
+/** Whether mentions are required to trigger the bot in this group. */
+requireMention: boolean().optional() }).strict();
+function requireMattermostOpenAllowFrom(params) {
+	requireOpenAllowFrom({
+		policy: params.policy,
+		allowFrom: params.allowFrom,
+		ctx: params.ctx,
+		path: ["allowFrom"],
+		message: "channels.mattermost.dmPolicy=\"open\" requires channels.mattermost.allowFrom to include \"*\""
+	});
+}
+const DmChannelRetrySchema = object({
+	/** Maximum number of retry attempts for DM channel creation (default: 3) */
+	maxRetries: number().int().min(0).max(10).optional(),
+	/** Initial delay in milliseconds before first retry (default: 1000) */
+	initialDelayMs: number().int().min(100).max(6e4).optional(),
+	/** Maximum delay in milliseconds between retries (default: 10000) */
+	maxDelayMs: number().int().min(1e3).max(6e4).optional(),
+	/** Timeout for each individual DM channel creation request in milliseconds (default: 30000) */
+	timeoutMs: number().int().min(5e3).max(12e4).optional()
+}).strict().refine((data) => {
+	if (data.initialDelayMs !== void 0 && data.maxDelayMs !== void 0) return data.initialDelayMs <= data.maxDelayMs;
+	return true;
+}, {
+	message: "initialDelayMs must be less than or equal to maxDelayMs",
+	path: ["initialDelayMs"]
+}).optional();
+const MattermostSlashCommandsSchema = object({
+	/** Enable native slash commands. "auto" resolves to false (opt-in). */
+	native: union([boolean(), literal("auto")]).optional(),
+	/** Also register skill-based commands. */
+	nativeSkills: union([boolean(), literal("auto")]).optional(),
+	/** Path for the callback endpoint on the gateway HTTP server. */
+	callbackPath: string().optional(),
+	/** Explicit callback URL (e.g. behind reverse proxy). */
+	callbackUrl: string().optional()
+}).strict().optional();
+const MattermostNetworkSchema = object({ 
+/** Dangerous opt-in for self-hosted Mattermost on trusted private/internal hosts. */
+dangerouslyAllowPrivateNetwork: boolean().optional() }).strict().optional();
+const MattermostStreamingModeSchema = _enum([
+	"off",
+	"partial",
+	"block",
+	"progress"
+]);
+const MattermostStreamingProgressSchema = object({
+	label: union([string(), literal(false)]).optional(),
+	labels: array(string()).optional(),
+	maxLines: number().int().positive().optional(),
+	maxLineChars: number().int().positive().optional(),
+	toolProgress: boolean().optional()
+}).strict();
+const MattermostStreamingPreviewSchema = object({ toolProgress: boolean().optional() }).strict();
+const MattermostStreamingBlockSchema = object({
+	enabled: boolean().optional(),
+	coalesce: BlockStreamingCoalesceSchema.optional()
+}).strict();
+const MattermostStreamingSchema = union([
+	MattermostStreamingModeSchema,
+	boolean(),
+	object({
+		mode: MattermostStreamingModeSchema.optional(),
+		chunkMode: _enum(["length", "newline"]).optional(),
+		preview: MattermostStreamingPreviewSchema.optional(),
+		progress: MattermostStreamingProgressSchema.optional(),
+		block: MattermostStreamingBlockSchema.optional()
+	}).strict()
+]);
+const MattermostAccountSchemaBase = object({
+	name: string().optional(),
+	capabilities: array(string()).optional(),
+	dangerouslyAllowNameMatching: boolean().optional(),
+	markdown: MarkdownConfigSchema,
+	enabled: boolean().optional(),
+	configWrites: boolean().optional(),
+	botToken: buildSecretInputSchema().optional(),
+	baseUrl: string().optional(),
+	chatmode: _enum([
+		"oncall",
+		"onmessage",
+		"onchar"
+	]).optional(),
+	oncharPrefixes: array(string()).optional(),
+	requireMention: boolean().optional(),
+	dmPolicy: DmPolicySchema.optional().default("pairing"),
+	allowFrom: array(union([string(), number()])).optional(),
+	groupAllowFrom: array(union([string(), number()])).optional(),
+	groupPolicy: GroupPolicySchema.optional().default("allowlist"),
+	textChunkLimit: number().int().positive().optional(),
+	chunkMode: _enum(["length", "newline"]).optional(),
+	streaming: MattermostStreamingSchema.optional(),
+	blockStreaming: boolean().optional(),
+	blockStreamingCoalesce: BlockStreamingCoalesceSchema.optional(),
+	replyToMode: _enum([
+		"off",
+		"first",
+		"all",
+		"batched"
+	]).optional(),
+	responsePrefix: string().optional(),
+	actions: object({ reactions: boolean().optional() }).optional(),
+	commands: MattermostSlashCommandsSchema,
+	interactions: object({
+		callbackBaseUrl: string().optional(),
+		allowedSourceIps: array(string()).optional()
+	}).optional(),
+	/** Per-group configuration (keyed by Mattermost channel ID or "*" for default). */
+	groups: record(string(), MattermostGroupSchema.optional()).optional(),
+	/** Network policy overrides for self-hosted Mattermost on trusted private/internal hosts. */
+	network: MattermostNetworkSchema,
+	/** Retry configuration for DM channel creation */
+	dmChannelRetry: DmChannelRetrySchema
+}).strict();
+const MattermostAccountSchema = MattermostAccountSchemaBase.superRefine((value, ctx) => {
+	requireMattermostOpenAllowFrom({
+		policy: value.dmPolicy,
+		allowFrom: value.allowFrom,
+		ctx
+	});
+});
+//#endregion
+//#region extensions/mattermost/src/config-surface.ts
+const MattermostChannelConfigSchema = buildChannelConfigSchema(MattermostAccountSchemaBase.extend({
+	accounts: record(string(), MattermostAccountSchema.optional()).optional(),
+	defaultAccount: string().optional()
+}).superRefine((value, ctx) => {
+	requireMattermostOpenAllowFrom({
+		policy: value.dmPolicy,
+		allowFrom: value.allowFrom,
+		ctx
+	});
+}), { uiHints: {
+	"": {
+		label: "Mattermost",
+		help: "Mattermost channel provider configuration for bot auth, access policy, slash commands, and preview streaming."
+	},
+	dmPolicy: {
+		label: "Mattermost DM Policy",
+		help: "Direct message access control (\"pairing\" recommended). \"open\" requires channels.mattermost.allowFrom=[\"*\"]."
+	},
+	streaming: {
+		label: "Mattermost Streaming Mode",
+		help: "Unified Mattermost stream preview mode: \"off\" | \"partial\" | \"block\" | \"progress\". \"progress\" keeps a single editable progress draft until final delivery."
+	},
+	"streaming.mode": {
+		label: "Mattermost Streaming Mode",
+		help: "Canonical Mattermost preview mode: \"off\" | \"partial\" | \"block\" | \"progress\"."
+	},
+	"streaming.progress.label": {
+		label: "Mattermost Progress Label",
+		help: "Initial progress draft title. Use \"auto\" for built-in single-word labels, a custom string, or false to hide the title."
+	},
+	"streaming.progress.labels": {
+		label: "Mattermost Progress Label Pool",
+		help: "Candidate labels for streaming.progress.label=\"auto\". Leave unset to use DaoCore built-in progress labels."
+	},
+	"streaming.progress.maxLines": {
+		label: "Mattermost Progress Max Lines",
+		help: "Maximum number of compact progress lines to keep below the draft label (default: 8)."
+	},
+	"streaming.progress.maxLineChars": {
+		label: "Mattermost Progress Max Line Chars",
+		help: "Maximum characters per compact progress line before truncation (default: 120). Prose cuts at word boundaries; commands and paths keep useful suffixes."
+	},
+	"streaming.progress.toolProgress": {
+		label: "Mattermost Progress Tool Lines",
+		help: "Show compact tool/progress lines in progress draft mode (default: true). Set false to keep only the label until final delivery."
+	},
+	"streaming.progress.commandText": {
+		label: "Mattermost Progress Command Text",
+		help: "Command/exec detail in progress draft lines: \"raw\" preserves released behavior; \"status\" shows only the tool label."
+	},
+	"streaming.preview.toolProgress": {
+		label: "Mattermost Draft Tool Progress",
+		help: "Show tool/progress activity in the live draft preview post (default: true). Set false to hide interim tool updates while the draft preview stays active."
+	},
+	"streaming.preview.commandText": {
+		label: "Mattermost Draft Command Text",
+		help: "Command/exec detail in preview tool-progress lines: \"raw\" preserves released behavior; \"status\" shows only the tool label."
+	},
+	"streaming.block.enabled": {
+		label: "Mattermost Block Streaming Enabled",
+		help: "Enable chunked block-style Mattermost preview delivery when channels.mattermost.streaming.mode=\"block\"."
+	},
+	"streaming.block.coalesce": {
+		label: "Mattermost Block Streaming Coalesce",
+		help: "Merge streamed Mattermost block replies before final delivery."
+	}
+} });
+//#endregion
+//#region extensions/mattermost/src/doctor.ts
+function isMattermostMutableAllowEntry(raw) {
+	const text = raw.trim();
+	if (!text || text === "*") return false;
+	const lowered = normalizeLowercaseStringOrEmpty(text.replace(/^(mattermost|user):/i, "").replace(/^@/, "").trim());
+	if (/^[a-z0-9]{26}$/.test(lowered)) return false;
+	return true;
+}
+const mattermostDoctor = {
+	legacyConfigRules,
+	normalizeCompatibilityConfig,
+	collectMutableAllowlistWarnings: createDangerousNameMatchingMutableAllowlistWarningCollector({
+		channel: "mattermost",
+		detector: isMattermostMutableAllowEntry,
+		collectLists: (scope) => [{
+			pathLabel: `${scope.prefix}.allowFrom`,
+			list: scope.account.allowFrom
+		}, {
+			pathLabel: `${scope.prefix}.groupAllowFrom`,
+			list: scope.account.groupAllowFrom
+		}]
+	})
+};
+//#endregion
+//#region extensions/mattermost/src/group-mentions.ts
+function resolveMattermostGroupRequireMention(params) {
+	const account = resolveMattermostAccount({
+		cfg: params.cfg,
+		accountId: params.accountId
+	});
+	const requireMentionOverride = typeof params.requireMentionOverride === "boolean" ? params.requireMentionOverride : account.requireMention;
+	return resolveChannelGroupRequireMention({
+		cfg: params.cfg,
+		channel: "mattermost",
+		groupId: params.groupId,
+		accountId: params.accountId,
+		requireMentionOverride
+	});
+}
+//#endregion
+//#region extensions/mattermost/src/normalize.ts
+function normalizeMattermostMessagingTarget(raw) {
+	const trimmed = raw.trim();
+	if (!trimmed) return;
+	const lower = normalizeLowercaseStringOrEmpty(trimmed);
+	if (lower.startsWith("channel:")) {
+		const id = trimmed.slice(8).trim();
+		return id ? `channel:${id}` : void 0;
+	}
+	if (lower.startsWith("group:")) {
+		const id = trimmed.slice(6).trim();
+		return id ? `channel:${id}` : void 0;
+	}
+	if (lower.startsWith("user:")) {
+		const id = trimmed.slice(5).trim();
+		return id ? `user:${id}` : void 0;
+	}
+	if (lower.startsWith("mattermost:")) {
+		const id = trimmed.slice(11).trim();
+		return id ? `user:${id}` : void 0;
+	}
+	if (trimmed.startsWith("@")) {
+		const id = trimmed.slice(1).trim();
+		return id ? `@${id}` : void 0;
+	}
+	if (trimmed.startsWith("#")) return;
+}
+function looksLikeMattermostTargetId(raw, _normalized) {
+	const trimmed = raw.trim();
+	if (!trimmed) return false;
+	if (/^(user|channel|group|mattermost):/i.test(trimmed)) return true;
+	if (trimmed.startsWith("@")) return true;
+	return /^[a-z0-9]{26}$/i.test(trimmed) || /^[a-z0-9]{26}__[a-z0-9]{26}$/i.test(trimmed);
+}
+//#endregion
+//#region extensions/mattermost/src/session-route.ts
+function resolveMattermostOutboundSessionRoute(params) {
+	let trimmed = stripChannelTargetPrefix(params.target, "mattermost");
+	if (!trimmed) return null;
+	const lower = normalizeLowercaseStringOrEmpty(trimmed);
+	const resolvedKind = params.resolvedTarget?.kind;
+	const isUser = resolvedKind === "user" || resolvedKind !== "channel" && resolvedKind !== "group" && (lower.startsWith("user:") || trimmed.startsWith("@"));
+	if (trimmed.startsWith("@")) trimmed = trimmed.slice(1).trim();
+	const rawId = stripTargetKindPrefix(trimmed);
+	if (!rawId) return null;
+	return buildThreadAwareOutboundSessionRoute({
+		route: buildChannelOutboundSessionRoute({
+			cfg: params.cfg,
+			agentId: params.agentId,
+			channel: "mattermost",
+			accountId: params.accountId,
+			peer: {
+				kind: isUser ? "direct" : "channel",
+				id: rawId
+			},
+			chatType: isUser ? "direct" : "channel",
+			from: isUser ? `mattermost:${rawId}` : `mattermost:channel:${rawId}`,
+			to: isUser ? `user:${rawId}` : `channel:${rawId}`
+		}),
+		replyToId: params.replyToId,
+		threadId: params.threadId,
+		currentSessionKey: params.currentSessionKey,
+		canRecoverCurrentThread: ({ route }) => route.chatType !== "direct" || (params.cfg.session?.dmScope ?? "main") !== "main"
+	});
+}
+//#endregion
+//#region extensions/mattermost/src/setup-core.ts
+const channel$1 = "mattermost";
+function isMattermostConfigured(account) {
+	return (Boolean(account.botToken?.trim()) || hasConfiguredSecretInput(account.config.botToken)) && Boolean(account.baseUrl);
+}
+function resolveMattermostAccountWithSecrets(cfg, accountId) {
+	return resolveMattermostAccount({
+		cfg,
+		accountId,
+		allowUnresolvedSecretRef: true
+	});
+}
+function applyMattermostSetupConfigPatch(params) {
+	const namedConfig = applyAccountNameToChannelSection({
+		cfg: params.cfg,
+		channelKey: channel$1,
+		accountId: params.accountId,
+		name: params.name
+	});
+	return applySetupAccountConfigPatch({
+		cfg: params.accountId !== "default" ? migrateBaseNameToDefaultAccount({
+			cfg: namedConfig,
+			channelKey: channel$1
+		}) : namedConfig,
+		channelKey: channel$1,
+		accountId: params.accountId,
+		patch: params.patch
+	});
+}
+const mattermostSetupAdapter = {
+	resolveAccountId: ({ accountId }) => normalizeAccountId(accountId),
+	applyAccountName: ({ cfg, accountId, name }) => applyAccountNameToChannelSection({
+		cfg,
+		channelKey: channel$1,
+		accountId,
+		name
+	}),
+	validateInput: createSetupInputPresenceValidator({
+		defaultAccountOnlyEnvError: "Mattermost env vars can only be used for the default account.",
+		whenNotUseEnv: [{
+			someOf: ["botToken", "token"],
+			message: "Mattermost requires --bot-token and --http-url (or --use-env)."
+		}, {
+			someOf: ["httpUrl"],
+			message: "Mattermost requires --bot-token and --http-url (or --use-env)."
+		}],
+		validate: ({ input }) => {
+			const token = input.botToken ?? input.token;
+			const baseUrl = normalizeMattermostBaseUrl(input.httpUrl);
+			if (!input.useEnv && (!token || !baseUrl)) return "Mattermost requires --bot-token and --http-url (or --use-env).";
+			if (input.httpUrl && !baseUrl) return "Mattermost --http-url must include a valid base URL.";
+			return null;
+		}
+	}),
+	applyAccountConfig: ({ cfg, accountId, input }) => {
+		const token = input.botToken ?? input.token;
+		const baseUrl = normalizeMattermostBaseUrl(input.httpUrl);
+		return applyMattermostSetupConfigPatch({
+			cfg,
+			accountId,
+			name: input.name,
+			patch: input.useEnv ? {} : {
+				...token ? { botToken: token } : {},
+				...baseUrl ? { baseUrl } : {}
+			}
+		});
+	}
+};
+//#endregion
+//#region extensions/mattermost/src/setup-surface.ts
+const t = createSetupTranslator();
+const channel = "mattermost";
+const mattermostSetupWizard = {
+	channel,
+	status: createStandardChannelSetupStatus({
+		channelLabel: "Mattermost",
+		configuredLabel: t("wizard.channels.statusConfigured"),
+		unconfiguredLabel: t("wizard.channels.statusNeedsTokenUrl"),
+		configuredHint: t("wizard.channels.statusConfigured"),
+		unconfiguredHint: t("wizard.channels.statusNeedsSetup"),
+		configuredScore: 2,
+		unconfiguredScore: 1,
+		resolveConfigured: ({ cfg, accountId }) => isMattermostConfigured(resolveMattermostAccountWithSecrets(cfg, accountId ?? "default"))
+	}),
+	introNote: {
+		title: t("wizard.mattermost.botTokenTitle"),
+		lines: [
+			t("wizard.mattermost.helpOpenConsole"),
+			t("wizard.mattermost.helpCreateBot"),
+			t("wizard.mattermost.helpBaseUrl"),
+			t("wizard.mattermost.helpBotMember"),
+			t("wizard.channels.docs", { link: formatDocsLink("/mattermost", "mattermost") })
+		],
+		shouldShow: ({ cfg, accountId }) => !isMattermostConfigured(resolveMattermostAccountWithSecrets(cfg, accountId))
+	},
+	envShortcut: {
+		prompt: t("wizard.mattermost.envPrompt"),
+		preferredEnvVar: "MATTERMOST_BOT_TOKEN",
+		isAvailable: ({ cfg, accountId }) => {
+			if (accountId !== "default") return false;
+			const resolvedAccount = resolveMattermostAccountWithSecrets(cfg, accountId);
+			const hasConfigValues = hasConfiguredSecretInput(resolvedAccount.config.botToken) || Boolean(resolvedAccount.config.baseUrl?.trim());
+			return Boolean(process.env.MATTERMOST_BOT_TOKEN?.trim() && process.env.MATTERMOST_URL?.trim() && !hasConfigValues);
+		},
+		apply: ({ cfg, accountId }) => applySetupAccountConfigPatch({
+			cfg,
+			channelKey: channel,
+			accountId,
+			patch: {}
+		})
+	},
+	credentials: [{
+		inputKey: "botToken",
+		providerHint: channel,
+		credentialLabel: t("wizard.mattermost.botToken"),
+		preferredEnvVar: "MATTERMOST_BOT_TOKEN",
+		envPrompt: t("wizard.mattermost.envPrompt"),
+		keepPrompt: t("wizard.mattermost.botTokenKeep"),
+		inputPrompt: t("wizard.mattermost.botTokenInput"),
+		inspect: ({ cfg, accountId }) => {
+			const resolvedAccount = resolveMattermostAccountWithSecrets(cfg, accountId);
+			return {
+				accountConfigured: isMattermostConfigured(resolvedAccount),
+				hasConfiguredValue: hasConfiguredSecretInput(resolvedAccount.config.botToken)
+			};
+		},
+		applySet: async ({ cfg, accountId, value }) => applyMattermostSetupConfigPatch({
+			cfg,
+			accountId,
+			patch: { botToken: value }
+		})
+	}],
+	textInputs: [{
+		inputKey: "httpUrl",
+		message: t("wizard.mattermost.baseUrlPrompt"),
+		confirmCurrentValue: false,
+		currentValue: ({ cfg, accountId }) => resolveMattermostAccountWithSecrets(cfg, accountId).baseUrl ?? process.env.MATTERMOST_URL?.trim(),
+		initialValue: ({ cfg, accountId }) => resolveMattermostAccountWithSecrets(cfg, accountId).baseUrl ?? process.env.MATTERMOST_URL?.trim(),
+		shouldPrompt: ({ cfg, accountId, credentialValues, currentValue }) => {
+			const resolvedAccount = resolveMattermostAccountWithSecrets(cfg, accountId);
+			const tokenConfigured = Boolean(resolvedAccount.botToken?.trim()) || hasConfiguredSecretInput(resolvedAccount.config.botToken);
+			return Boolean(credentialValues.botToken) || !tokenConfigured || !currentValue;
+		},
+		validate: ({ value }) => normalizeMattermostBaseUrl(value) ? void 0 : "Mattermost base URL must include a valid base URL.",
+		normalizeValue: ({ value }) => normalizeMattermostBaseUrl(value) ?? value.trim(),
+		applySet: async ({ cfg, accountId, value }) => applyMattermostSetupConfigPatch({
+			cfg,
+			accountId,
+			patch: { baseUrl: value }
+		})
+	}],
+	disable: (cfg) => ({
+		...cfg,
+		channels: {
+			...cfg.channels,
+			mattermost: {
+				...cfg.channels?.mattermost,
+				enabled: false
+			}
+		}
+	})
+};
+//#endregion
+//#region extensions/mattermost/src/channel.ts
+const loadMattermostChannelRuntime = createLazyRuntimeModule(() => import("./channel.runtime-w3cW8r41.js"));
+function buildMattermostPresentationButtons(presentation) {
+	return presentation.blocks.filter((block) => block.type === "buttons").map((block) => block.buttons.flatMap((button) => button.value ? [{
+		text: button.label,
+		callback_data: button.value,
+		style: button.style
+	}] : []));
+}
+const MATTERMOST_PRESENTATION_CAPABILITIES = {
+	supported: true,
+	buttons: true,
+	selects: false,
+	context: true,
+	divider: false,
+	limits: { text: { markdownDialect: "markdown" } }
+};
+function hasMattermostPresentationButtons(presentation) {
+	return buildMattermostPresentationButtons(presentation).some((row) => row.length > 0);
+}
+function readMattermostPresentationButtons(payload) {
+	const buttons = (payload.channelData?.mattermost)?.presentationButtons;
+	return Array.isArray(buttons) ? buttons : void 0;
+}
+const mattermostSecurityAdapter = createRestrictSendersChannelSecurity({
+	channelKey: "mattermost",
+	resolveDmPolicy: (account) => account.config.dmPolicy,
+	resolveDmAllowFrom: (account) => account.config.allowFrom,
+	resolveGroupPolicy: (account) => account.config.groupPolicy,
+	surface: "Mattermost channels",
+	openScope: "any member",
+	groupPolicyPath: "channels.mattermost.groupPolicy",
+	groupAllowFromPath: "channels.mattermost.groupAllowFrom",
+	policyPathSuffix: "dmPolicy",
+	normalizeDmEntry: (raw) => normalizeMattermostAllowEntry(raw)
+});
+function describeMattermostMessageTool({ cfg, accountId }) {
+	const enabledAccounts = (accountId ? [resolveMattermostAccount({
+		cfg,
+		accountId
+	})] : listMattermostAccountIds(cfg).map((listedAccountId) => resolveMattermostAccount({
+		cfg,
+		accountId: listedAccountId
+	}))).filter((account) => account.enabled).filter((account) => Boolean(account.botToken?.trim() && account.baseUrl?.trim()));
+	const actions = [];
+	if (enabledAccounts.length > 0) actions.push("send");
+	const baseReactions = (cfg.channels?.mattermost?.actions)?.reactions;
+	if (enabledAccounts.some((account) => {
+		return account.config.actions?.reactions ?? baseReactions ?? true;
+	})) actions.push("react");
+	return {
+		actions,
+		capabilities: enabledAccounts.length > 0 ? ["presentation"] : []
+	};
+}
+function hasConfiguredMattermostDirectoryAccount({ cfg, accountId }) {
+	return (accountId ? [resolveMattermostAccount({
+		cfg,
+		accountId
+	})] : listMattermostAccountIds(cfg).map((listedAccountId) => resolveMattermostAccount({
+		cfg,
+		accountId: listedAccountId
+	}))).some((account) => Boolean(account.enabled && account.botToken?.trim() && account.baseUrl?.trim()));
+}
+async function listMattermostDirectoryGroups(params) {
+	if (!hasConfiguredMattermostDirectoryAccount(params)) return [];
+	return (await loadMattermostChannelRuntime()).listMattermostDirectoryGroups(params);
+}
+async function listMattermostDirectoryPeers(params) {
+	if (!hasConfiguredMattermostDirectoryAccount(params)) return [];
+	return (await loadMattermostChannelRuntime()).listMattermostDirectoryPeers(params);
+}
+const mattermostMessageActions = {
+	describeMessageTool: describeMattermostMessageTool,
+	supportsAction: ({ action }) => {
+		return action === "send" || action === "react";
+	},
+	handleAction: async ({ action, params, cfg, accountId }) => {
+		if (action === "react") {
+			const resolvedAccountId = accountId ?? resolveDefaultMattermostAccountId(cfg);
+			const mattermostConfig = cfg.channels?.mattermost;
+			if (!(resolveMattermostAccount({
+				cfg,
+				accountId: resolvedAccountId
+			}).config.actions?.reactions ?? mattermostConfig?.actions?.reactions ?? true)) throw new Error("Mattermost reactions are disabled in config");
+			const { postId, emojiName, remove } = parseMattermostReactActionParams(params);
+			if (remove) {
+				const result = await (await loadMattermostChannelRuntime()).removeMattermostReaction({
+					cfg,
+					postId,
+					emojiName,
+					accountId: resolvedAccountId
+				});
+				if (!result.ok) throw new Error(result.error);
+				return {
+					content: [{
+						type: "text",
+						text: `Removed reaction :${emojiName}: from ${postId}`
+					}],
+					details: {}
+				};
+			}
+			const result = await (await loadMattermostChannelRuntime()).addMattermostReaction({
+				cfg,
+				postId,
+				emojiName,
+				accountId: resolvedAccountId
+			});
+			if (!result.ok) throw new Error(result.error);
+			return {
+				content: [{
+					type: "text",
+					text: `Reacted with :${emojiName}: on ${postId}`
+				}],
+				details: {}
+			};
+		}
+		if (action !== "send") throw new Error(`Unsupported Mattermost action: ${action}`);
+		const to = typeof params.to === "string" ? params.to.trim() : typeof params.target === "string" ? params.target.trim() : "";
+		if (!to) throw new Error("Mattermost send requires a target (to).");
+		const presentation = normalizeMessagePresentation(params.presentation);
+		const message = presentation ? renderMessagePresentationFallbackText({
+			text: typeof params.message === "string" ? params.message : "",
+			presentation
+		}) : typeof params.message === "string" ? params.message : "";
+		const replyToId = normalizeOptionalString(params.replyToId) ?? normalizeOptionalString(params.replyTo);
+		const resolvedAccountId = accountId || void 0;
+		const mediaUrl = typeof params.media === "string" ? params.media.trim() || void 0 : void 0;
+		const result = await (await loadMattermostChannelRuntime()).sendMessageMattermost(to, message, {
+			cfg,
+			accountId: resolvedAccountId,
+			replyToId,
+			buttons: presentation ? buildMattermostPresentationButtons(presentation) : void 0,
+			attachmentText: typeof params.attachmentText === "string" ? params.attachmentText : void 0,
+			mediaUrl
+		});
+		return {
+			content: [{
+				type: "text",
+				text: JSON.stringify({
+					ok: true,
+					channel: "mattermost",
+					messageId: result.messageId,
+					channelId: result.channelId
+				})
+			}],
+			details: {}
+		};
+	}
+};
+function parseMattermostReactActionParams(params) {
+	const postId = normalizeOptionalString(params.messageId) ?? normalizeOptionalString(params.postId);
+	if (!postId) throw new Error("Mattermost react requires messageId (post id)");
+	const emojiName = normalizeOptionalString(params.emoji)?.replace(/^:+|:+$/g, "");
+	if (!emojiName) throw new Error("Mattermost react requires emoji");
+	return {
+		postId,
+		emojiName,
+		remove: params.remove === true
+	};
+}
+const mattermostOutbound = {
+	deliveryMode: "direct",
+	chunker: chunkTextForOutbound,
+	chunkerMode: "markdown",
+	textChunkLimit: 4e3,
+	deliveryCapabilities: { durableFinal: {
+		text: true,
+		media: true,
+		payload: true,
+		replyTo: true,
+		thread: true,
+		messageSendingHooks: true
+	} },
+	presentationCapabilities: MATTERMOST_PRESENTATION_CAPABILITIES,
+	renderPresentation: ({ payload, presentation }) => {
+		if (payload.mediaUrls && payload.mediaUrls.length > 1) return null;
+		const buttons = buildMattermostPresentationButtons(presentation);
+		if (!hasMattermostPresentationButtons(presentation)) return null;
+		return {
+			...payload,
+			text: renderMessagePresentationFallbackText({
+				text: payload.text,
+				presentation
+			}),
+			channelData: {
+				...payload.channelData,
+				mattermost: {
+					...payload.channelData?.mattermost,
+					presentationButtons: buttons
+				}
+			}
+		};
+	},
+	sendPayload: async (ctx) => {
+		const buttons = readMattermostPresentationButtons(ctx.payload);
+		if (buttons?.length) {
+			const mediaUrl = resolvePayloadMediaUrls({
+				...ctx.payload,
+				mediaUrl: ctx.payload.mediaUrl ?? ctx.mediaUrl
+			}).map((url) => url.trim()).find(Boolean);
+			return attachChannelToResult("mattermost", await (await loadMattermostChannelRuntime()).sendMessageMattermost(ctx.to, ctx.payload.text ?? ctx.text, {
+				cfg: ctx.cfg,
+				accountId: ctx.accountId ?? void 0,
+				mediaUrl,
+				mediaLocalRoots: ctx.mediaLocalRoots,
+				mediaReadFile: ctx.mediaReadFile,
+				replyToId: ctx.replyToId ?? (ctx.threadId != null ? String(ctx.threadId) : void 0),
+				buttons
+			}));
+		}
+		return await sendTextMediaPayload({
+			channel: "mattermost",
+			ctx,
+			adapter: mattermostOutbound
+		});
+	},
+	resolveTarget: ({ to }) => {
+		const trimmed = to?.trim();
+		if (!trimmed) return {
+			ok: false,
+			error: /* @__PURE__ */ new Error("Delivering to Mattermost requires --to <channelId|@username|user:ID|channel:ID>")
+		};
+		return {
+			ok: true,
+			to: trimmed
+		};
+	},
+	...createAttachedChannelResultAdapter({
+		channel: "mattermost",
+		sendText: async ({ cfg, to, text, accountId, replyToId, threadId }) => await (await loadMattermostChannelRuntime()).sendMessageMattermost(to, text, {
+			cfg,
+			accountId: accountId ?? void 0,
+			replyToId: replyToId ?? (threadId != null ? String(threadId) : void 0)
+		}),
+		sendMedia: async ({ cfg, to, text, mediaUrl, mediaLocalRoots, accountId, replyToId, threadId }) => await (await loadMattermostChannelRuntime()).sendMessageMattermost(to, text, {
+			cfg,
+			accountId: accountId ?? void 0,
+			mediaUrl,
+			mediaLocalRoots,
+			replyToId: replyToId ?? (threadId != null ? String(threadId) : void 0)
+		})
+	})
+};
+const mattermostMessageAdapter = createChannelMessageAdapterFromOutbound({
+	id: "mattermost",
+	outbound: mattermostOutbound,
+	live: {
+		capabilities: {
+			draftPreview: true,
+			previewFinalization: true,
+			progressUpdates: true
+		},
+		finalizer: { capabilities: {
+			finalEdit: true,
+			normalFallback: true,
+			discardPending: true
+		} }
+	}
+});
+const mattermostPlugin = createChatChannelPlugin({
+	base: {
+		id: "mattermost",
+		meta: { ...mattermostMeta },
+		setup: mattermostSetupAdapter,
+		setupWizard: mattermostSetupWizard,
+		capabilities: {
+			chatTypes: [
+				"direct",
+				"channel",
+				"group",
+				"thread"
+			],
+			reactions: true,
+			threads: true,
+			media: true,
+			nativeCommands: true
+		},
+		streaming: { blockStreamingCoalesceDefaults: {
+			minChars: 1500,
+			idleMs: 1e3
+		} },
+		reload: { configPrefixes: ["channels.mattermost"] },
+		configSchema: MattermostChannelConfigSchema,
+		config: {
+			...mattermostConfigAdapter,
+			isConfigured: isMattermostConfigured$1,
+			describeAccount: describeMattermostAccount
+		},
+		approvalCapability: mattermostApprovalAuth,
+		doctor: mattermostDoctor,
+		groups: { resolveRequireMention: resolveMattermostGroupRequireMention },
+		actions: mattermostMessageActions,
+		message: mattermostMessageAdapter,
+		secrets: {
+			secretTargetRegistryEntries,
+			collectRuntimeConfigAssignments
+		},
+		directory: createChannelDirectoryAdapter({
+			listGroups: listMattermostDirectoryGroups,
+			listGroupsLive: listMattermostDirectoryGroups,
+			listPeers: listMattermostDirectoryPeers,
+			listPeersLive: listMattermostDirectoryPeers
+		}),
+		messaging: {
+			targetPrefixes: ["mattermost"],
+			defaultMarkdownTableMode: "off",
+			normalizeTarget: normalizeMattermostMessagingTarget,
+			resolveDeliveryTarget: ({ conversationId, parentConversationId }) => {
+				const parent = parentConversationId?.trim();
+				const child = conversationId.trim();
+				return parent && parent !== child ? {
+					to: `channel:${parent}`,
+					threadId: child
+				} : { to: normalizeMattermostMessagingTarget(`channel:${child}`) };
+			},
+			resolveOutboundSessionRoute: (params) => resolveMattermostOutboundSessionRoute(params),
+			targetResolver: {
+				looksLikeId: looksLikeMattermostTargetId,
+				hint: "<channelId|user:ID|channel:ID>",
+				resolveTarget: async ({ cfg, accountId, input }) => {
+					const resolved = await (await loadMattermostChannelRuntime()).resolveMattermostOpaqueTarget({
+						input,
+						cfg,
+						accountId
+					});
+					if (!resolved) return null;
+					return {
+						to: resolved.to,
+						kind: resolved.kind,
+						source: "directory"
+					};
+				}
+			}
+		},
+		status: createComputedAccountStatusAdapter({
+			defaultRuntime: createDefaultChannelRuntimeState(DEFAULT_ACCOUNT_ID, {
+				connected: false,
+				lastConnectedAt: null,
+				lastDisconnect: null
+			}),
+			buildChannelSummary: ({ snapshot }) => buildPassiveProbedChannelStatusSummary(snapshot, {
+				botTokenSource: snapshot.botTokenSource ?? "none",
+				connected: snapshot.connected ?? false,
+				baseUrl: snapshot.baseUrl ?? null
+			}),
+			probeAccount: async ({ account, timeoutMs }) => {
+				const token = account.botToken?.trim();
+				const baseUrl = account.baseUrl?.trim();
+				if (!token || !baseUrl) return {
+					ok: false,
+					error: "bot token or baseUrl missing"
+				};
+				return await (await loadMattermostChannelRuntime()).probeMattermost(baseUrl, token, timeoutMs, isPrivateNetworkOptInEnabled(account.config));
+			},
+			resolveAccountSnapshot: ({ account, runtime }) => ({
+				accountId: account.accountId,
+				name: account.name,
+				enabled: account.enabled,
+				configured: Boolean(account.botToken && account.baseUrl),
+				extra: {
+					botTokenSource: account.botTokenSource,
+					baseUrl: account.baseUrl,
+					connected: runtime?.connected ?? false,
+					lastConnectedAt: runtime?.lastConnectedAt ?? null,
+					lastDisconnect: runtime?.lastDisconnect ?? null
+				}
+			})
+		}),
+		gateway: {
+			resolveGatewayAuthBypassPaths: ({ cfg }) => resolveMattermostGatewayAuthBypassPaths(cfg),
+			startAccount: async (ctx) => {
+				const account = ctx.account;
+				const statusSink = createAccountStatusSink({
+					accountId: ctx.accountId,
+					setStatus: ctx.setStatus
+				});
+				statusSink({
+					baseUrl: account.baseUrl,
+					botTokenSource: account.botTokenSource
+				});
+				ctx.log?.info(`[${account.accountId}] starting channel`);
+				return (await loadMattermostChannelRuntime()).monitorMattermostProvider({
+					botToken: account.botToken ?? void 0,
+					baseUrl: account.baseUrl ?? void 0,
+					accountId: account.accountId,
+					config: ctx.cfg,
+					runtime: ctx.runtime,
+					abortSignal: ctx.abortSignal,
+					statusSink
+				});
+			}
+		}
+	},
+	pairing: { text: {
+		idLabel: "mattermostUserId",
+		message: "DaoCore: your access has been approved.",
+		normalizeAllowEntry: (entry) => normalizeMattermostAllowEntry(entry),
+		notify: createLoggedPairingApprovalNotifier(({ id }) => `[mattermost] User ${id} approved for pairing`)
+	} },
+	threading: {
+		scopedAccountReplyToMode: {
+			resolveAccount: (cfg, accountId) => resolveMattermostAccount({
+				cfg,
+				accountId: accountId ?? resolveDefaultMattermostAccountId(cfg)
+			}),
+			resolveReplyToMode: (account, chatType) => resolveMattermostReplyToMode(account, chatType === "direct" || chatType === "group" || chatType === "channel" ? chatType : "channel")
+		},
+		resolveReplyTransport: ({ threadId, replyToId }) => ({
+			replyToId: replyToId ?? (threadId != null ? String(threadId) : void 0),
+			threadId
+		})
+	},
+	security: mattermostSecurityAdapter,
+	outbound: mattermostOutbound
+});
+//#endregion
+export { describeMattermostAccount as a, mattermostMeta as c, MattermostChannelConfigSchema as i, mattermostSetupWizard as n, isMattermostConfigured$1 as o, mattermostSetupAdapter as r, mattermostConfigAdapter as s, mattermostPlugin as t };