name?: string;

};

/**

* Escape regex metacharacters so user-controlled mention fields are treated literally.

*/

export function escapeRegExp(input: string): string {

return input.replace(/[.*+?^${}()|[\]\\]/g, "\\$&");

}

export function isFeishuBroadcastMention(mention: FeishuMentionLike): boolean {

const normalizedKey = mention.key?.trim().toLowerCase();

if (normalizedKey === "@all" || normalizedKey === "@_all") {

return (entries ?? []).map((entry) => normalizeIrcAllowEntry(String(entry))).filter(Boolean);

}

export function formatIrcSenderId(message: IrcInboundMessage): string {

const base = message.senderNick.trim();

const user = message.senderUser?.trim();

const host = message.senderHost?.trim();

if (user && host) {

return `${base}!${user}@${host}`;

}

if (user) {

return `${base}!${user}`;

}

if (host) {

return `${base}@${host}`;

}

return base;

}

export function buildIrcAllowlistCandidates(

message: IrcInboundMessage,

params?: { allowNameMatching?: boolean },

import type { webhook } from "@line/bot-sdk";

import type { NextFunction, Request, Response } from "express";

import type { OpenClawConfig } from "openclaw/plugin-sdk/config-types";

import { DEFAULT_GROUP_HISTORY_LIMIT, type HistoryEntry } from "openclaw/plugin-sdk/reply-history";

import { getRuntimeConfig } from "openclaw/plugin-sdk/runtime-config-snapshot";

import { createLineWebhookReplayCache, handleLineWebhookEvents } from "./bot-handlers.js";

import type { LineInboundContext } from "./bot-message-context.js";

import type { ResolvedLineAccount } from "./types.js";

import { startLineWebhook } from "./webhook.js";

export interface LineBotOptions {

channelAccessToken: string;

account,

};

}

export function createLineWebhookCallback(

bot: LineBot,

channelSecret: string,

path = "/line/webhook",

): { path: string; handler: (req: Request, res: Response, _next: NextFunction) => Promise<void> } {

const { handler } = startLineWebhook({

channelSecret,

onEvents: bot.handleWebhook,

path,

});

return { path, handler };

}

}

return account.config.replyToMode ?? "off";

}

export function listEnabledMattermostAccounts(cfg: OpenClawConfig): ResolvedMattermostAccount[] {

return listMattermostAccountIds(cfg)

.map((accountId) => resolveMattermostAccount({ cfg, accountId }))

.filter((account) => account.enabled);

}

import { resolveMarkdownTableMode } from "openclaw/plugin-sdk/markdown-table-runtime";

import { convertMarkdownTables } from "openclaw/plugin-sdk/text-runtime";

import { loadOutboundMediaFromUrl, type OpenClawConfig } from "../runtime-api.js";

import { createMSTeamsConversationStoreFs } from "./conversation-store-fs.js";

import {

classifyMSTeamsSendError,

formatMSTeamsSendErrorHint,

return { conversationId };

}

/**

* List all known conversation references (for debugging/CLI).

*/

export async function listMSTeamsConversations(): Promise<

Array<{

conversationId: string;

userName?: string;

conversationType?: string;

}>

> {

const store = createMSTeamsConversationStoreFs();

const all = await store.list();

return all.map(({ conversationId, reference }) => ({

conversationId,

userName: reference.user?.name,

conversationType: reference.conversation?.conversationType,

}));

}

resolveDefaultAccountId: () => resolveDefaultNextcloudTalkAccountId(params.cfg),

});

}

export function listEnabledNextcloudTalkAccounts(cfg: CoreConfig): ResolvedNextcloudTalkAccount[] {

return listNextcloudTalkAccountIds(cfg)

.map((accountId) => resolveNextcloudTalkAccount({ cfg, accountId }))

.filter((account) => account.enabled);

}

import { normalizeResolvedSecretInputString } from "openclaw/plugin-sdk/secret-input";

export function normalizeSlackToken(raw?: unknown): string | undefined {

return normalizeResolvedSecretInputString({

value: raw,

path: "channels.slack.*.token",

});

}

export function resolveSlackBotToken(

raw?: unknown,

path = "channels.slack.botToken",