loudmouth-ai 0.1.0 → 0.2.0

package/extensions/matrix/src/tool-actions.ts

@@ -1,160 +0,0 @@
-import type { AgentToolResult } from "@mariozechner/pi-agent-core";
-
-import type { CoreConfig } from "./types.js";
-import {
-  deleteMatrixMessage,
-  editMatrixMessage,
-  getMatrixMemberInfo,
-  getMatrixRoomInfo,
-  listMatrixPins,
-  listMatrixReactions,
-  pinMatrixMessage,
-  readMatrixMessages,
-  removeMatrixReactions,
-  sendMatrixMessage,
-  unpinMatrixMessage,
-} from "./matrix/actions.js";
-import { reactMatrixMessage } from "./matrix/send.js";
-import {
-  createActionGate,
-  jsonResult,
-  readNumberParam,
-  readReactionParams,
-  readStringParam,
-} from "clawdbot/plugin-sdk";
-
-const messageActions = new Set(["sendMessage", "editMessage", "deleteMessage", "readMessages"]);
-const reactionActions = new Set(["react", "reactions"]);
-const pinActions = new Set(["pinMessage", "unpinMessage", "listPins"]);
-
-function readRoomId(params: Record<string, unknown>, required = true): string {
-  const direct = readStringParam(params, "roomId") ?? readStringParam(params, "channelId");
-  if (direct) return direct;
-  if (!required) return readStringParam(params, "to") ?? "";
-  return readStringParam(params, "to", { required: true });
-}
-
-export async function handleMatrixAction(
-  params: Record<string, unknown>,
-  cfg: CoreConfig,
-): Promise<AgentToolResult<unknown>> {
-  const action = readStringParam(params, "action", { required: true });
-  const isActionEnabled = createActionGate(cfg.channels?.matrix?.actions);
-
-  if (reactionActions.has(action)) {
-    if (!isActionEnabled("reactions")) {
-      throw new Error("Matrix reactions are disabled.");
-    }
-    const roomId = readRoomId(params);
-    const messageId = readStringParam(params, "messageId", { required: true });
-    if (action === "react") {
-      const { emoji, remove, isEmpty } = readReactionParams(params, {
-        removeErrorMessage: "Emoji is required to remove a Matrix reaction.",
-      });
-      if (remove || isEmpty) {
-        const result = await removeMatrixReactions(roomId, messageId, {
-          emoji: remove ? emoji : undefined,
-        });
-        return jsonResult({ ok: true, removed: result.removed });
-      }
-      await reactMatrixMessage(roomId, messageId, emoji);
-      return jsonResult({ ok: true, added: emoji });
-    }
-    const reactions = await listMatrixReactions(roomId, messageId);
-    return jsonResult({ ok: true, reactions });
-  }
-
-  if (messageActions.has(action)) {
-    if (!isActionEnabled("messages")) {
-      throw new Error("Matrix messages are disabled.");
-    }
-    switch (action) {
-      case "sendMessage": {
-        const to = readStringParam(params, "to", { required: true });
-        const content = readStringParam(params, "content", {
-          required: true,
-          allowEmpty: true,
-        });
-        const mediaUrl = readStringParam(params, "mediaUrl");
-        const replyToId = readStringParam(params, "replyToId") ?? readStringParam(params, "replyTo");
-        const threadId = readStringParam(params, "threadId");
-        const result = await sendMatrixMessage(to, content, {
-          mediaUrl: mediaUrl ?? undefined,
-          replyToId: replyToId ?? undefined,
-          threadId: threadId ?? undefined,
-        });
-        return jsonResult({ ok: true, result });
-      }
-      case "editMessage": {
-        const roomId = readRoomId(params);
-        const messageId = readStringParam(params, "messageId", { required: true });
-        const content = readStringParam(params, "content", { required: true });
-        const result = await editMatrixMessage(roomId, messageId, content);
-        return jsonResult({ ok: true, result });
-      }
-      case "deleteMessage": {
-        const roomId = readRoomId(params);
-        const messageId = readStringParam(params, "messageId", { required: true });
-        const reason = readStringParam(params, "reason");
-        await deleteMatrixMessage(roomId, messageId, { reason: reason ?? undefined });
-        return jsonResult({ ok: true, deleted: true });
-      }
-      case "readMessages": {
-        const roomId = readRoomId(params);
-        const limit = readNumberParam(params, "limit", { integer: true });
-        const before = readStringParam(params, "before");
-        const after = readStringParam(params, "after");
-        const result = await readMatrixMessages(roomId, {
-          limit: limit ?? undefined,
-          before: before ?? undefined,
-          after: after ?? undefined,
-        });
-        return jsonResult({ ok: true, ...result });
-      }
-      default:
-        break;
-    }
-  }
-
-  if (pinActions.has(action)) {
-    if (!isActionEnabled("pins")) {
-      throw new Error("Matrix pins are disabled.");
-    }
-    const roomId = readRoomId(params);
-    if (action === "pinMessage") {
-      const messageId = readStringParam(params, "messageId", { required: true });
-      const result = await pinMatrixMessage(roomId, messageId);
-      return jsonResult({ ok: true, pinned: result.pinned });
-    }
-    if (action === "unpinMessage") {
-      const messageId = readStringParam(params, "messageId", { required: true });
-      const result = await unpinMatrixMessage(roomId, messageId);
-      return jsonResult({ ok: true, pinned: result.pinned });
-    }
-    const result = await listMatrixPins(roomId);
-    return jsonResult({ ok: true, pinned: result.pinned, events: result.events });
-  }
-
-  if (action === "memberInfo") {
-    if (!isActionEnabled("memberInfo")) {
-      throw new Error("Matrix member info is disabled.");
-    }
-    const userId = readStringParam(params, "userId", { required: true });
-    const roomId = readStringParam(params, "roomId") ?? readStringParam(params, "channelId");
-    const result = await getMatrixMemberInfo(userId, {
-      roomId: roomId ?? undefined,
-    });
-    return jsonResult({ ok: true, member: result });
-  }
-
-  if (action === "channelInfo") {
-    if (!isActionEnabled("channelInfo")) {
-      throw new Error("Matrix room info is disabled.");
-    }
-    const roomId = readRoomId(params);
-    const result = await getMatrixRoomInfo(roomId);
-    return jsonResult({ ok: true, room: result });
-  }
-
-  throw new Error(`Unsupported Matrix action: ${action}`);
-}

package/extensions/matrix/src/types.ts

@@ -1,95 +0,0 @@
-export type ReplyToMode = "off" | "first" | "all";
-export type GroupPolicy = "open" | "disabled" | "allowlist";
-export type DmPolicy = "pairing" | "allowlist" | "open" | "disabled";
-
-export type MatrixDmConfig = {
-  /** If false, ignore all incoming Matrix DMs. Default: true. */
-  enabled?: boolean;
-  /** Direct message access policy (default: pairing). */
-  policy?: DmPolicy;
-  /** Allowlist for DM senders (matrix user IDs, localparts, or "*"). */
-  allowFrom?: Array<string | number>;
-};
-
-export type MatrixRoomConfig = {
-  /** If false, disable the bot in this room (alias for allow: false). */
-  enabled?: boolean;
-  /** Legacy room allow toggle; prefer enabled. */
-  allow?: boolean;
-  /** Require mentioning the bot to trigger replies. */
-  requireMention?: boolean;
-  /** Optional tool policy overrides for this room. */
-  tools?: { allow?: string[]; deny?: string[] };
-  /** If true, reply without mention requirements. */
-  autoReply?: boolean;
-  /** Optional allowlist for room senders (user IDs or localparts). */
-  users?: Array<string | number>;
-  /** Optional skill filter for this room. */
-  skills?: string[];
-  /** Optional system prompt snippet for this room. */
-  systemPrompt?: string;
-};
-
-export type MatrixActionConfig = {
-  reactions?: boolean;
-  messages?: boolean;
-  pins?: boolean;
-  memberInfo?: boolean;
-  channelInfo?: boolean;
-};
-
-export type MatrixConfig = {
-  /** Optional display name for this account (used in CLI/UI lists). */
-  name?: string;
-  /** If false, do not start Matrix. Default: true. */
-  enabled?: boolean;
-  /** Matrix homeserver URL (https://matrix.example.org). */
-  homeserver?: string;
-  /** Matrix user id (@user:server). */
-  userId?: string;
-  /** Matrix access token. */
-  accessToken?: string;
-  /** Matrix password (used only to fetch access token). */
-  password?: string;
-  /** Optional device name when logging in via password. */
-  deviceName?: string;
-  /** Initial sync limit for startup (default: matrix-bot-sdk default). */
-  initialSyncLimit?: number;
-  /** Enable end-to-end encryption (E2EE). Default: false. */
-  encryption?: boolean;
-  /** If true, enforce allowlists for groups + DMs regardless of policy. */
-  allowlistOnly?: boolean;
-  /** Group message policy (default: allowlist). */
-  groupPolicy?: GroupPolicy;
-  /** Allowlist for group senders (user IDs or localparts). */
-  groupAllowFrom?: Array<string | number>;
-  /** Control reply threading when reply tags are present (off|first|all). */
-  replyToMode?: ReplyToMode;
-  /** How to handle thread replies (off|inbound|always). */
-  threadReplies?: "off" | "inbound" | "always";
-  /** Outbound text chunk size (chars). Default: 4000. */
-  textChunkLimit?: number;
-  /** Chunking mode: "length" (default) splits by size; "newline" splits on every newline. */
-  chunkMode?: "length" | "newline";
-  /** Max outbound media size in MB. */
-  mediaMaxMb?: number;
-  /** Auto-join invites (always|allowlist|off). Default: always. */
-  autoJoin?: "always" | "allowlist" | "off";
-  /** Allowlist for auto-join invites (room IDs, aliases). */
-  autoJoinAllowlist?: Array<string | number>;
-  /** Direct message policy + allowlist overrides. */
-  dm?: MatrixDmConfig;
-  /** Room config allowlist keyed by room ID, alias, or name. */
-  groups?: Record<string, MatrixRoomConfig>;
-  /** Room config allowlist keyed by room ID, alias, or name. Legacy; use groups. */
-  rooms?: Record<string, MatrixRoomConfig>;
-  /** Per-action tool gating (default: true for all). */
-  actions?: MatrixActionConfig;
-};
-
-export type CoreConfig = {
-  channels?: {
-    matrix?: MatrixConfig;
-  };
-  [key: string]: unknown;
-};

package/extensions/mattermost/clawdbot.plugin.json

@@ -1,11 +0,0 @@
-{
-  "id": "mattermost",
-  "channels": [
-    "mattermost"
-  ],
-  "configSchema": {
-    "type": "object",
-    "additionalProperties": false,
-    "properties": {}
-  }
-}

package/extensions/mattermost/index.ts

@@ -1,18 +0,0 @@
-import type { ClawdbotPluginApi } from "clawdbot/plugin-sdk";
-import { emptyPluginConfigSchema } from "clawdbot/plugin-sdk";
-
-import { mattermostPlugin } from "./src/channel.js";
-import { setMattermostRuntime } from "./src/runtime.js";
-
-const plugin = {
-  id: "mattermost",
-  name: "Mattermost",
-  description: "Mattermost channel plugin",
-  configSchema: emptyPluginConfigSchema(),
-  register(api: ClawdbotPluginApi) {
-    setMattermostRuntime(api.runtime);
-    api.registerChannel({ plugin: mattermostPlugin });
-  },
-};
-
-export default plugin;

package/extensions/mattermost/package.json

@@ -1,25 +0,0 @@
-{
-  "name": "@clawdbot/mattermost",
-  "version": "2026.1.25",
-  "type": "module",
-  "description": "Clawdbot Mattermost channel plugin",
-  "clawdbot": {
-    "extensions": [
-      "./index.ts"
-    ],
-    "channel": {
-      "id": "mattermost",
-      "label": "Mattermost",
-      "selectionLabel": "Mattermost (plugin)",
-      "docsPath": "/channels/mattermost",
-      "docsLabel": "mattermost",
-      "blurb": "self-hosted Slack-style chat; install the plugin to enable.",
-      "order": 65
-    },
-    "install": {
-      "npmSpec": "@clawdbot/mattermost",
-      "localPath": "extensions/mattermost",
-      "defaultChoice": "npm"
-    }
-  }
-}

package/extensions/mattermost/src/channel.test.ts

@@ -1,43 +0,0 @@
-import { describe, expect, it } from "vitest";
-
-import { mattermostPlugin } from "./channel.js";
-
-describe("mattermostPlugin", () => {
-  describe("messaging", () => {
-    it("keeps @username targets", () => {
-      const normalize = mattermostPlugin.messaging?.normalizeTarget;
-      if (!normalize) return;
-
-      expect(normalize("@Alice")).toBe("@Alice");
-      expect(normalize("@alice")).toBe("@alice");
-    });
-
-    it("normalizes mattermost: prefix to user:", () => {
-      const normalize = mattermostPlugin.messaging?.normalizeTarget;
-      if (!normalize) return;
-
-      expect(normalize("mattermost:USER123")).toBe("user:USER123");
-    });
-  });
-
-  describe("pairing", () => {
-    it("normalizes allowlist entries", () => {
-      const normalize = mattermostPlugin.pairing?.normalizeAllowEntry;
-      if (!normalize) return;
-
-      expect(normalize("@Alice")).toBe("alice");
-      expect(normalize("user:USER123")).toBe("user123");
-    });
-  });
-
-  describe("config", () => {
-    it("formats allowFrom entries", () => {
-      const formatAllowFrom = mattermostPlugin.config.formatAllowFrom;
-
-      const formatted = formatAllowFrom({
-        allowFrom: ["@Alice", "user:USER123", "mattermost:BOT999"],
-      });
-      expect(formatted).toEqual(["@alice", "user123", "bot999"]);
-    });
-  });
-});

package/extensions/mattermost/src/channel.ts

@@ -1,339 +0,0 @@
-import {
-  applyAccountNameToChannelSection,
-  buildChannelConfigSchema,
-  DEFAULT_ACCOUNT_ID,
-  deleteAccountFromConfigSection,
-  formatPairingApproveHint,
-  migrateBaseNameToDefaultAccount,
-  normalizeAccountId,
-  setAccountEnabledInConfigSection,
-  type ChannelPlugin,
-} from "clawdbot/plugin-sdk";
-
-import { MattermostConfigSchema } from "./config-schema.js";
-import { resolveMattermostGroupRequireMention } from "./group-mentions.js";
-import {
-  looksLikeMattermostTargetId,
-  normalizeMattermostMessagingTarget,
-} from "./normalize.js";
-import { mattermostOnboardingAdapter } from "./onboarding.js";
-import {
-  listMattermostAccountIds,
-  resolveDefaultMattermostAccountId,
-  resolveMattermostAccount,
-  type ResolvedMattermostAccount,
-} from "./mattermost/accounts.js";
-import { normalizeMattermostBaseUrl } from "./mattermost/client.js";
-import { monitorMattermostProvider } from "./mattermost/monitor.js";
-import { probeMattermost } from "./mattermost/probe.js";
-import { sendMessageMattermost } from "./mattermost/send.js";
-import { getMattermostRuntime } from "./runtime.js";
-
-const meta = {
-  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,
-} as const;
-
-function normalizeAllowEntry(entry: string): string {
-  return entry
-    .trim()
-    .replace(/^(mattermost|user):/i, "")
-    .replace(/^@/, "")
-    .toLowerCase();
-}
-
-function formatAllowEntry(entry: string): string {
-  const trimmed = entry.trim();
-  if (!trimmed) return "";
-  if (trimmed.startsWith("@")) {
-    const username = trimmed.slice(1).trim();
-    return username ? `@${username.toLowerCase()}` : "";
-  }
-  return trimmed.replace(/^(mattermost|user):/i, "").toLowerCase();
-}
-
-export const mattermostPlugin: ChannelPlugin<ResolvedMattermostAccount> = {
-  id: "mattermost",
-  meta: {
-    ...meta,
-  },
-  onboarding: mattermostOnboardingAdapter,
-  pairing: {
-    idLabel: "mattermostUserId",
-    normalizeAllowEntry: (entry) => normalizeAllowEntry(entry),
-    notifyApproval: async ({ id }) => {
-      console.log(`[mattermost] User ${id} approved for pairing`);
-    },
-  },
-  capabilities: {
-    chatTypes: ["direct", "channel", "group", "thread"],
-    threads: true,
-    media: true,
-  },
-  streaming: {
-    blockStreamingCoalesceDefaults: { minChars: 1500, idleMs: 1000 },
-  },
-  reload: { configPrefixes: ["channels.mattermost"] },
-  configSchema: buildChannelConfigSchema(MattermostConfigSchema),
-  config: {
-    listAccountIds: (cfg) => listMattermostAccountIds(cfg),
-    resolveAccount: (cfg, accountId) => resolveMattermostAccount({ cfg, accountId }),
-    defaultAccountId: (cfg) => resolveDefaultMattermostAccountId(cfg),
-    setAccountEnabled: ({ cfg, accountId, enabled }) =>
-      setAccountEnabledInConfigSection({
-        cfg,
-        sectionKey: "mattermost",
-        accountId,
-        enabled,
-        allowTopLevel: true,
-      }),
-    deleteAccount: ({ cfg, accountId }) =>
-      deleteAccountFromConfigSection({
-        cfg,
-        sectionKey: "mattermost",
-        accountId,
-        clearBaseFields: ["botToken", "baseUrl", "name"],
-      }),
-    isConfigured: (account) => Boolean(account.botToken && account.baseUrl),
-    describeAccount: (account) => ({
-      accountId: account.accountId,
-      name: account.name,
-      enabled: account.enabled,
-      configured: Boolean(account.botToken && account.baseUrl),
-      botTokenSource: account.botTokenSource,
-      baseUrl: account.baseUrl,
-    }),
-    resolveAllowFrom: ({ cfg, accountId }) =>
-      (resolveMattermostAccount({ cfg, accountId }).config.allowFrom ?? []).map((entry) =>
-        String(entry),
-      ),
-    formatAllowFrom: ({ allowFrom }) =>
-      allowFrom
-        .map((entry) => formatAllowEntry(String(entry)))
-        .filter(Boolean),
-  },
-  security: {
-    resolveDmPolicy: ({ cfg, accountId, account }) => {
-      const resolvedAccountId = accountId ?? account.accountId ?? DEFAULT_ACCOUNT_ID;
-      const useAccountPath = Boolean(cfg.channels?.mattermost?.accounts?.[resolvedAccountId]);
-      const basePath = useAccountPath
-        ? `channels.mattermost.accounts.${resolvedAccountId}.`
-        : "channels.mattermost.";
-      return {
-        policy: account.config.dmPolicy ?? "pairing",
-        allowFrom: account.config.allowFrom ?? [],
-        policyPath: `${basePath}dmPolicy`,
-        allowFromPath: basePath,
-        approveHint: formatPairingApproveHint("mattermost"),
-        normalizeEntry: (raw) => normalizeAllowEntry(raw),
-      };
-    },
-    collectWarnings: ({ account, cfg }) => {
-      const defaultGroupPolicy = cfg.channels?.defaults?.groupPolicy;
-      const groupPolicy = account.config.groupPolicy ?? defaultGroupPolicy ?? "allowlist";
-      if (groupPolicy !== "open") return [];
-      return [
-        `- Mattermost channels: groupPolicy="open" allows any member to trigger (mention-gated). Set channels.mattermost.groupPolicy="allowlist" + channels.mattermost.groupAllowFrom to restrict senders.`,
-      ];
-    },
-  },
-  groups: {
-    resolveRequireMention: resolveMattermostGroupRequireMention,
-  },
-  messaging: {
-    normalizeTarget: normalizeMattermostMessagingTarget,
-    targetResolver: {
-      looksLikeId: looksLikeMattermostTargetId,
-      hint: "<channelId|user:ID|channel:ID>",
-    },
-  },
-  outbound: {
-    deliveryMode: "direct",
-    chunker: (text, limit) => getMattermostRuntime().channel.text.chunkMarkdownText(text, limit),
-    chunkerMode: "markdown",
-    textChunkLimit: 4000,
-    resolveTarget: ({ to }) => {
-      const trimmed = to?.trim();
-      if (!trimmed) {
-        return {
-          ok: false,
-          error: new Error(
-            "Delivering to Mattermost requires --to <channelId|@username|user:ID|channel:ID>",
-          ),
-        };
-      }
-      return { ok: true, to: trimmed };
-    },
-    sendText: async ({ to, text, accountId, replyToId }) => {
-      const result = await sendMessageMattermost(to, text, {
-        accountId: accountId ?? undefined,
-        replyToId: replyToId ?? undefined,
-      });
-      return { channel: "mattermost", ...result };
-    },
-    sendMedia: async ({ to, text, mediaUrl, accountId, replyToId }) => {
-      const result = await sendMessageMattermost(to, text, {
-        accountId: accountId ?? undefined,
-        mediaUrl,
-        replyToId: replyToId ?? undefined,
-      });
-      return { channel: "mattermost", ...result };
-    },
-  },
-  status: {
-    defaultRuntime: {
-      accountId: DEFAULT_ACCOUNT_ID,
-      running: false,
-      connected: false,
-      lastConnectedAt: null,
-      lastDisconnect: null,
-      lastStartAt: null,
-      lastStopAt: null,
-      lastError: null,
-    },
-    buildChannelSummary: ({ snapshot }) => ({
-      configured: snapshot.configured ?? false,
-      botTokenSource: snapshot.botTokenSource ?? "none",
-      running: snapshot.running ?? false,
-      connected: snapshot.connected ?? false,
-      lastStartAt: snapshot.lastStartAt ?? null,
-      lastStopAt: snapshot.lastStopAt ?? null,
-      lastError: snapshot.lastError ?? null,
-      baseUrl: snapshot.baseUrl ?? null,
-      probe: snapshot.probe,
-      lastProbeAt: snapshot.lastProbeAt ?? 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 probeMattermost(baseUrl, token, timeoutMs);
-    },
-    buildAccountSnapshot: ({ account, runtime, probe }) => ({
-      accountId: account.accountId,
-      name: account.name,
-      enabled: account.enabled,
-      configured: Boolean(account.botToken && account.baseUrl),
-      botTokenSource: account.botTokenSource,
-      baseUrl: account.baseUrl,
-      running: runtime?.running ?? false,
-      connected: runtime?.connected ?? false,
-      lastConnectedAt: runtime?.lastConnectedAt ?? null,
-      lastDisconnect: runtime?.lastDisconnect ?? null,
-      lastStartAt: runtime?.lastStartAt ?? null,
-      lastStopAt: runtime?.lastStopAt ?? null,
-      lastError: runtime?.lastError ?? null,
-      probe,
-      lastInboundAt: runtime?.lastInboundAt ?? null,
-      lastOutboundAt: runtime?.lastOutboundAt ?? null,
-    }),
-  },
-  setup: {
-    resolveAccountId: ({ accountId }) => normalizeAccountId(accountId),
-    applyAccountName: ({ cfg, accountId, name }) =>
-      applyAccountNameToChannelSection({
-        cfg,
-        channelKey: "mattermost",
-        accountId,
-        name,
-      }),
-    validateInput: ({ accountId, input }) => {
-      if (input.useEnv && accountId !== DEFAULT_ACCOUNT_ID) {
-        return "Mattermost env vars can only be used for the default account.";
-      }
-      const token = input.botToken ?? input.token;
-      const baseUrl = input.httpUrl;
-      if (!input.useEnv && (!token || !baseUrl)) {
-        return "Mattermost requires --bot-token and --http-url (or --use-env).";
-      }
-      if (baseUrl && !normalizeMattermostBaseUrl(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 = input.httpUrl?.trim();
-      const namedConfig = applyAccountNameToChannelSection({
-        cfg,
-        channelKey: "mattermost",
-        accountId,
-        name: input.name,
-      });
-      const next =
-        accountId !== DEFAULT_ACCOUNT_ID
-          ? migrateBaseNameToDefaultAccount({
-              cfg: namedConfig,
-              channelKey: "mattermost",
-            })
-          : namedConfig;
-      if (accountId === DEFAULT_ACCOUNT_ID) {
-        return {
-          ...next,
-          channels: {
-            ...next.channels,
-            mattermost: {
-              ...next.channels?.mattermost,
-              enabled: true,
-              ...(input.useEnv
-                ? {}
-                : {
-                    ...(token ? { botToken: token } : {}),
-                    ...(baseUrl ? { baseUrl } : {}),
-                  }),
-            },
-          },
-        };
-      }
-      return {
-        ...next,
-        channels: {
-          ...next.channels,
-          mattermost: {
-            ...next.channels?.mattermost,
-            enabled: true,
-            accounts: {
-              ...next.channels?.mattermost?.accounts,
-              [accountId]: {
-                ...next.channels?.mattermost?.accounts?.[accountId],
-                enabled: true,
-                ...(token ? { botToken: token } : {}),
-                ...(baseUrl ? { baseUrl } : {}),
-              },
-            },
-          },
-        },
-      };
-    },
-  },
-  gateway: {
-    startAccount: async (ctx) => {
-      const account = ctx.account;
-      ctx.setStatus({
-        accountId: account.accountId,
-        baseUrl: account.baseUrl,
-        botTokenSource: account.botTokenSource,
-      });
-      ctx.log?.info(`[${account.accountId}] starting channel`);
-      return monitorMattermostProvider({
-        botToken: account.botToken ?? undefined,
-        baseUrl: account.baseUrl ?? undefined,
-        accountId: account.accountId,
-        config: ctx.cfg,
-        runtime: ctx.runtime,
-        abortSignal: ctx.abortSignal,
-        statusSink: (patch) => ctx.setStatus({ accountId: ctx.accountId, ...patch }),
-      });
-    },
-  },
-};