@colinlu50/openclaw-lark-stream 2026.3.17

package/src/channel/directory.js

@@ -0,0 +1,191 @@
+/**
+ * Copyright (c) 2026 ByteDance Ltd. and/or its affiliates
+ * SPDX-License-Identifier: MIT
+ *
+ * Directory listing for Feishu peers (users) and groups.
+ *
+ * Provides both config-based (offline) and live API directory
+ * lookups so the outbound subsystem and UI can resolve targets.
+ */
+import { getLarkAccount } from '../core/accounts';
+import { LarkClient } from '../core/lark-client';
+import { normalizeFeishuTarget } from '../core/targets';
+// ---------------------------------------------------------------------------
+// Shared helpers
+// ---------------------------------------------------------------------------
+/** Case-insensitive substring match on id and optional name. */
+function matchesQuery(id, name, query) {
+    if (!query)
+        return true;
+    return id.toLowerCase().includes(query) || (name?.toLowerCase().includes(query) ?? false);
+}
+/** Filter items and apply optional limit. */
+function applyLimitSlice(items, limit) {
+    return limit && limit > 0 ? items.slice(0, limit) : items;
+}
+// ---------------------------------------------------------------------------
+// Config-based (offline) directory
+// ---------------------------------------------------------------------------
+/**
+ * List users known from the channel config (allowFrom + dms fields).
+ *
+ * Does not make any API calls -- useful when the bot is not yet
+ * connected or when credentials are unavailable.
+ */
+export async function listFeishuDirectoryPeers(params) {
+    const account = getLarkAccount(params.cfg, params.accountId);
+    const feishuCfg = account.config;
+    const q = params.query?.trim().toLowerCase() || '';
+    const ids = new Set();
+    // Collect from allowFrom entries.
+    for (const entry of feishuCfg?.allowFrom ?? []) {
+        const trimmed = String(entry).trim();
+        if (trimmed && trimmed !== '*') {
+            ids.add(trimmed);
+        }
+    }
+    // Collect from per-user DM config keys.
+    for (const userId of Object.keys(feishuCfg?.dms ?? {})) {
+        const trimmed = userId.trim();
+        if (trimmed) {
+            ids.add(trimmed);
+        }
+    }
+    const peers = Array.from(ids)
+        .map((raw) => raw.trim())
+        .filter(Boolean)
+        .map((raw) => normalizeFeishuTarget(raw) ?? raw)
+        .filter((id) => matchesQuery(id, undefined, q))
+        .map((id) => ({ kind: 'user', id }));
+    return applyLimitSlice(peers, params.limit);
+}
+/**
+ * List groups known from the channel config (groups + groupAllowFrom).
+ */
+export async function listFeishuDirectoryGroups(params) {
+    const account = getLarkAccount(params.cfg, params.accountId);
+    const feishuCfg = account.config;
+    const q = params.query?.trim().toLowerCase() || '';
+    const ids = new Set();
+    // Collect from per-group config keys.
+    for (const groupId of Object.keys(feishuCfg?.groups ?? {})) {
+        const trimmed = groupId.trim();
+        if (trimmed && trimmed !== '*') {
+            ids.add(trimmed);
+        }
+    }
+    // Collect from groupAllowFrom entries.
+    for (const entry of feishuCfg?.groupAllowFrom ?? []) {
+        const trimmed = String(entry).trim();
+        if (trimmed && trimmed !== '*') {
+            ids.add(trimmed);
+        }
+    }
+    const groups = Array.from(ids)
+        .map((raw) => raw.trim())
+        .filter(Boolean)
+        .filter((id) => matchesQuery(id, undefined, q))
+        .map((id) => ({ kind: 'group', id }));
+    return applyLimitSlice(groups, params.limit);
+}
+// ---------------------------------------------------------------------------
+// Live API directory
+// ---------------------------------------------------------------------------
+/**
+ * List users via the Feishu contact/v3/users API.
+ *
+ * Falls back to config-based listing when credentials are missing or
+ * the API call fails.
+ */
+export async function listFeishuDirectoryPeersLive(params) {
+    const account = getLarkAccount(params.cfg, params.accountId);
+    if (!account.configured) {
+        return listFeishuDirectoryPeers(params);
+    }
+    try {
+        const client = LarkClient.fromAccount(account).sdk;
+        const peers = [];
+        const limit = params.limit ?? 50;
+        if (limit <= 0)
+            return [];
+        const q = params.query?.trim().toLowerCase() || '';
+        let pageToken;
+        do {
+            const remaining = limit - peers.length;
+            const response = await client.contact.user.list({
+                params: {
+                    page_size: Math.min(remaining, 50),
+                    page_token: pageToken,
+                },
+            });
+            if (response.code !== 0 || !response.data?.items)
+                break;
+            for (const user of response.data.items) {
+                if (user.open_id && matchesQuery(user.open_id, user.name, q)) {
+                    peers.push({
+                        kind: 'user',
+                        id: user.open_id,
+                        name: user.name || undefined,
+                    });
+                }
+                if (peers.length >= limit)
+                    break;
+            }
+            pageToken = response.data?.page_token;
+        } while (pageToken && peers.length < limit);
+        return peers;
+    }
+    catch {
+        // Fallback to config-based listing on API failure.
+        return listFeishuDirectoryPeers(params);
+    }
+}
+/**
+ * List groups via the Feishu im/v1/chats API.
+ *
+ * Falls back to config-based listing when credentials are missing or
+ * the API call fails.
+ */
+export async function listFeishuDirectoryGroupsLive(params) {
+    const account = getLarkAccount(params.cfg, params.accountId);
+    if (!account.configured) {
+        return listFeishuDirectoryGroups(params);
+    }
+    try {
+        const client = LarkClient.fromAccount(account).sdk;
+        const groups = [];
+        const limit = params.limit ?? 50;
+        if (limit <= 0)
+            return [];
+        const q = params.query?.trim().toLowerCase() || '';
+        let pageToken;
+        do {
+            const remaining = limit - groups.length;
+            const response = await client.im.chat.list({
+                params: {
+                    page_size: Math.min(remaining, 100),
+                    page_token: pageToken,
+                },
+            });
+            if (response.code !== 0 || !response.data?.items)
+                break;
+            for (const chat of response.data.items) {
+                if (chat.chat_id && matchesQuery(chat.chat_id, chat.name, q)) {
+                    groups.push({
+                        kind: 'group',
+                        id: chat.chat_id,
+                        name: chat.name || undefined,
+                    });
+                }
+                if (groups.length >= limit)
+                    break;
+            }
+            pageToken = response.data?.page_token;
+        } while (pageToken && groups.length < limit);
+        return groups;
+    }
+    catch {
+        // Fallback to config-based listing on API failure.
+        return listFeishuDirectoryGroups(params);
+    }
+}

package/src/channel/event-handlers.d.ts

@@ -0,0 +1,15 @@
+/**
+ * Copyright (c) 2026 ByteDance Ltd. and/or its affiliates
+ * SPDX-License-Identifier: MIT
+ *
+ * Event handlers for the Feishu WebSocket monitor.
+ *
+ * Extracted from monitor.ts to improve testability and reduce
+ * function size. Each handler receives a MonitorContext with all
+ * dependencies needed to process the event.
+ */
+import type { MonitorContext } from './types';
+export declare function handleMessageEvent(ctx: MonitorContext, data: unknown): Promise<void>;
+export declare function handleReactionEvent(ctx: MonitorContext, data: unknown): Promise<void>;
+export declare function handleBotMembershipEvent(ctx: MonitorContext, data: unknown, action: 'added' | 'removed'): Promise<void>;
+export declare function handleCardActionEvent(ctx: MonitorContext, data: unknown): Promise<unknown>;

package/src/channel/event-handlers.js

@@ -0,0 +1,221 @@
+/**
+ * Copyright (c) 2026 ByteDance Ltd. and/or its affiliates
+ * SPDX-License-Identifier: MIT
+ *
+ * Event handlers for the Feishu WebSocket monitor.
+ *
+ * Extracted from monitor.ts to improve testability and reduce
+ * function size. Each handler receives a MonitorContext with all
+ * dependencies needed to process the event.
+ */
+import { handleFeishuMessage } from '../messaging/inbound/handler';
+import { handleFeishuReaction, resolveReactionContext } from '../messaging/inbound/reaction-handler';
+import { isMessageExpired } from '../messaging/inbound/dedup';
+import { withTicket } from '../core/lark-ticket';
+import { larkLogger } from '../core/lark-logger';
+import { handleCardAction } from '../tools/auto-auth';
+import { enqueueFeishuChatTask, buildQueueKey, hasActiveTask, getActiveDispatcher } from './chat-queue';
+import { extractRawTextFromEvent, isLikelyAbortText } from './abort-detect';
+const elog = larkLogger('channel/event-handlers');
+// ---------------------------------------------------------------------------
+// Event ownership validation
+// ---------------------------------------------------------------------------
+/**
+ * Verify that the event's app_id matches the current account.
+ *
+ * Lark SDK EventDispatcher flattens the v2 envelope header (which
+ * contains `app_id`) into the handler `data` object, so `app_id` is
+ * available directly on `data`.
+ *
+ * Returns `false` (discard event) when the app_id does not match.
+ */
+function isEventOwnershipValid(ctx, data) {
+    const expectedAppId = ctx.lark.account.appId;
+    if (!expectedAppId)
+        return true; // appId not configured — skip check
+    const eventAppId = data.app_id;
+    if (eventAppId == null)
+        return true; // SDK did not provide app_id — defensive skip
+    if (eventAppId !== expectedAppId) {
+        elog.warn('event app_id mismatch, discarding', {
+            accountId: ctx.accountId,
+            expected: expectedAppId,
+            received: String(eventAppId),
+        });
+        return false;
+    }
+    return true;
+}
+// ---------------------------------------------------------------------------
+// Message handler
+// ---------------------------------------------------------------------------
+export async function handleMessageEvent(ctx, data) {
+    if (!isEventOwnershipValid(ctx, data))
+        return;
+    const { accountId, log, error } = ctx;
+    try {
+        const event = data;
+        const msgId = event.message?.message_id ?? 'unknown';
+        const chatId = event.message?.chat_id ?? '';
+        const threadId = event.message?.thread_id || undefined;
+        // Dedup — skip duplicate messages (e.g. from WebSocket reconnects).
+        if (!ctx.messageDedup.tryRecord(msgId, accountId)) {
+            log(`feishu[${accountId}]: duplicate message ${msgId}, skipping`);
+            return;
+        }
+        // Expiry — discard stale messages from reconnect replay.
+        if (isMessageExpired(event.message?.create_time)) {
+            log(`feishu[${accountId}]: message ${msgId} expired, discarding`);
+            return;
+        }
+        // ---- Abort fast-path ----
+        // If the message looks like an abort trigger and there is an active
+        // reply dispatcher for this chat, fire abortCard() immediately
+        // (before the message enters the serial queue) so the streaming
+        // card is terminated without waiting for the current task.
+        const abortText = extractRawTextFromEvent(event);
+        if (abortText && isLikelyAbortText(abortText)) {
+            const queueKey = buildQueueKey(accountId, chatId, threadId);
+            if (hasActiveTask(queueKey)) {
+                const active = getActiveDispatcher(queueKey);
+                if (active) {
+                    log(`feishu[${accountId}]: abort fast-path triggered for chat ${chatId} (text="${abortText}")`);
+                    active.abortController?.abort();
+                    active.abortCard().catch((err) => {
+                        error(`feishu[${accountId}]: abort fast-path abortCard failed: ${String(err)}`);
+                    });
+                }
+            }
+        }
+        const { status } = enqueueFeishuChatTask({
+            accountId,
+            chatId,
+            threadId,
+            task: async () => {
+                try {
+                    await withTicket({
+                        messageId: msgId,
+                        chatId,
+                        accountId,
+                        startTime: Date.now(),
+                        senderOpenId: event.sender?.sender_id?.open_id || '',
+                        chatType: event.message?.chat_type || undefined,
+                        threadId,
+                    }, () => handleFeishuMessage({
+                        cfg: ctx.cfg,
+                        event,
+                        botOpenId: ctx.lark.botOpenId,
+                        runtime: ctx.runtime,
+                        chatHistories: ctx.chatHistories,
+                        accountId,
+                    }));
+                }
+                catch (err) {
+                    error(`feishu[${accountId}]: error handling message: ${String(err)}`);
+                }
+            },
+        });
+        log(`feishu[${accountId}]: message ${msgId} in chat ${chatId}${threadId ? ` thread ${threadId}` : ''} — ${status}`);
+    }
+    catch (err) {
+        error(`feishu[${accountId}]: error handling message: ${String(err)}`);
+    }
+}
+// ---------------------------------------------------------------------------
+// Reaction handler
+// ---------------------------------------------------------------------------
+export async function handleReactionEvent(ctx, data) {
+    if (!isEventOwnershipValid(ctx, data))
+        return;
+    const { accountId, log, error } = ctx;
+    try {
+        const event = data;
+        const msgId = event.message_id ?? 'unknown';
+        log(`feishu[${accountId}]: reaction event on message ${msgId}`);
+        // ---- Dedup: deterministic key based on message + emoji + operator ----
+        const emojiType = event.reaction_type?.emoji_type ?? '';
+        const operatorOpenId = event.user_id?.open_id ?? '';
+        const dedupKey = `${msgId}:reaction:${emojiType}:${operatorOpenId}`;
+        if (!ctx.messageDedup.tryRecord(dedupKey, accountId)) {
+            log(`feishu[${accountId}]: duplicate reaction ${dedupKey}, skipping`);
+            return;
+        }
+        // ---- Expiry: discard stale reaction events ----
+        if (isMessageExpired(event.action_time)) {
+            log(`feishu[${accountId}]: reaction on ${msgId} expired, discarding`);
+            return;
+        }
+        // ---- Pre-resolve real chatId before enqueuing ----
+        // The API call (3s timeout) runs outside the queue so it doesn't
+        // block the serial chain, and is read-only so ordering is irrelevant.
+        const preResolved = await resolveReactionContext({
+            cfg: ctx.cfg,
+            event,
+            botOpenId: ctx.lark.botOpenId,
+            runtime: ctx.runtime,
+            accountId,
+        });
+        if (!preResolved)
+            return;
+        // ---- Enqueue with the real chatId (matches normal message queue key) ----
+        const { status } = enqueueFeishuChatTask({
+            accountId,
+            chatId: preResolved.chatId,
+            threadId: preResolved.threadId,
+            task: async () => {
+                try {
+                    await withTicket({
+                        messageId: msgId,
+                        chatId: preResolved.chatId,
+                        accountId,
+                        startTime: Date.now(),
+                        senderOpenId: operatorOpenId,
+                        chatType: preResolved.chatType,
+                        threadId: preResolved.threadId,
+                    }, () => handleFeishuReaction({
+                        cfg: ctx.cfg,
+                        event,
+                        botOpenId: ctx.lark.botOpenId,
+                        runtime: ctx.runtime,
+                        chatHistories: ctx.chatHistories,
+                        accountId,
+                        preResolved,
+                    }));
+                }
+                catch (err) {
+                    error(`feishu[${accountId}]: error handling reaction: ${String(err)}`);
+                }
+            },
+        });
+        log(`feishu[${accountId}]: reaction on ${msgId} (chatId=${preResolved.chatId}) — ${status}`);
+    }
+    catch (err) {
+        error(`feishu[${accountId}]: error handling reaction event: ${String(err)}`);
+    }
+}
+// ---------------------------------------------------------------------------
+// Bot membership handler
+// ---------------------------------------------------------------------------
+export async function handleBotMembershipEvent(ctx, data, action) {
+    if (!isEventOwnershipValid(ctx, data))
+        return;
+    const { accountId, log, error } = ctx;
+    try {
+        const event = data;
+        log(`feishu[${accountId}]: bot ${action} ${action === 'removed' ? 'from' : 'to'} chat ${event.chat_id}`);
+    }
+    catch (err) {
+        error(`feishu[${accountId}]: error handling bot ${action} event: ${String(err)}`);
+    }
+}
+// ---------------------------------------------------------------------------
+// Card action handler
+// ---------------------------------------------------------------------------
+export async function handleCardActionEvent(ctx, data) {
+    try {
+        return await handleCardAction(data, ctx.cfg, ctx.accountId);
+    }
+    catch (err) {
+        elog.warn(`card.action.trigger handler error: ${err}`);
+    }
+}

package/src/channel/monitor.d.ts

@@ -0,0 +1,17 @@
+/**
+ * Copyright (c) 2026 ByteDance Ltd. and/or its affiliates
+ * SPDX-License-Identifier: MIT
+ *
+ * WebSocket monitoring for the Lark/Feishu channel plugin.
+ *
+ * Manages per-account WSClient connections and routes inbound Feishu
+ * events (messages, bot membership changes, read receipts) to the
+ * appropriate handlers.
+ */
+import type { MonitorFeishuOpts } from './types';
+export type { MonitorFeishuOpts } from './types';
+/**
+ * Start monitoring for all enabled Feishu accounts (or a single
+ * account when `opts.accountId` is specified).
+ */
+export declare function monitorFeishuProvider(opts?: MonitorFeishuOpts): Promise<void>;

package/src/channel/monitor.js

@@ -0,0 +1,129 @@
+/**
+ * Copyright (c) 2026 ByteDance Ltd. and/or its affiliates
+ * SPDX-License-Identifier: MIT
+ *
+ * WebSocket monitoring for the Lark/Feishu channel plugin.
+ *
+ * Manages per-account WSClient connections and routes inbound Feishu
+ * events (messages, bot membership changes, read receipts) to the
+ * appropriate handlers.
+ */
+import { getLarkAccount, getEnabledLarkAccounts } from '../core/accounts';
+import { LarkClient } from '../core/lark-client';
+import { MessageDedup } from '../messaging/inbound/dedup';
+import { larkLogger } from '../core/lark-logger';
+import { drainShutdownHooks } from '../core/shutdown-hooks';
+import { handleMessageEvent, handleReactionEvent, handleBotMembershipEvent, handleCardActionEvent, } from './event-handlers';
+const mlog = larkLogger('channel/monitor');
+// ---------------------------------------------------------------------------
+// Single-account monitor
+// ---------------------------------------------------------------------------
+/**
+ * Start monitoring a single Feishu account.
+ *
+ * Creates a LarkClient, probes bot identity, registers event handlers,
+ * and starts a WebSocket connection. Returns a Promise that resolves
+ * when the abort signal fires (or immediately if already aborted).
+ */
+async function monitorSingleAccount(params) {
+    const { account, runtime, abortSignal } = params;
+    const { accountId } = account;
+    const log = runtime?.log ?? ((...args) => mlog.info(args.map(String).join(' ')));
+    const error = runtime?.error ?? ((...args) => mlog.error(args.map(String).join(' ')));
+    // Only websocket mode is supported in the monitor path.
+    const connectionMode = account.config.connectionMode ?? 'websocket';
+    if (connectionMode !== 'websocket') {
+        log(`feishu[${accountId}]: webhook mode not implemented in monitor`);
+        return;
+    }
+    // Message dedup — filters duplicate deliveries from WebSocket reconnects.
+    const dedupCfg = account.config.dedup;
+    const messageDedup = new MessageDedup({
+        ttlMs: dedupCfg?.ttlMs,
+        maxEntries: dedupCfg?.maxEntries,
+    });
+    log(`feishu[${accountId}]: message dedup enabled (ttl=${messageDedup['ttlMs']}ms, max=${messageDedup['maxEntries']})`);
+    log(`feishu[${accountId}]: starting WebSocket connection...`);
+    // Create LarkClient instance — manages SDK client, WS, and bot identity.
+    const lark = LarkClient.fromAccount(account);
+    // Attach dedup instance so it is disposed together with the client.
+    lark.messageDedup = messageDedup;
+    /** Per-chat history maps (used for group-chat context window). */
+    const chatHistories = new Map();
+    const ctx = {
+        get cfg() {
+            return LarkClient.runtime.config.loadConfig();
+        },
+        lark,
+        accountId,
+        chatHistories,
+        messageDedup,
+        runtime,
+        log,
+        error,
+    };
+    await lark.startWS({
+        handlers: {
+            'im.message.receive_v1': (data) => handleMessageEvent(ctx, data),
+            'im.message.message_read_v1': async () => { },
+            'im.message.reaction.created_v1': (data) => handleReactionEvent(ctx, data),
+            'im.chat.member.bot.added_v1': (data) => handleBotMembershipEvent(ctx, data, 'added'),
+            'im.chat.member.bot.deleted_v1': (data) => handleBotMembershipEvent(ctx, data, 'removed'),
+            // 飞书 SDK EventDispatcher.register 不支持带返回值的处理器，此处 as any 是 SDK 类型限制的变通
+            'card.action.trigger': ((data) => 
+            // eslint-disable-next-line @typescript-eslint/no-explicit-any
+            handleCardActionEvent(ctx, data)),
+        },
+        abortSignal,
+    });
+    // startWS resolves when abortSignal fires — probe result is logged inside startWS.
+    log(`feishu[${accountId}]: bot open_id resolved: ${lark.botOpenId ?? 'unknown'}`);
+    log(`feishu[${accountId}]: WebSocket client started`);
+    mlog.info(`websocket started for account ${accountId}`);
+}
+// ---------------------------------------------------------------------------
+// Public API
+// ---------------------------------------------------------------------------
+/**
+ * Start monitoring for all enabled Feishu accounts (or a single
+ * account when `opts.accountId` is specified).
+ */
+export async function monitorFeishuProvider(opts = {}) {
+    const cfg = opts.config;
+    if (!cfg) {
+        throw new Error('Config is required for Feishu monitor');
+    }
+    // Store the original global config so plugin commands (doctor, diagnose)
+    // can access cross-account information even when running inside an
+    // account-scoped config context.
+    LarkClient.setGlobalConfig(cfg);
+    const log = opts.runtime?.log ?? ((...args) => mlog.info(args.map(String).join(' ')));
+    // Single-account mode.
+    if (opts.accountId) {
+        const account = getLarkAccount(cfg, opts.accountId);
+        if (!account.enabled || !account.configured) {
+            throw new Error(`Feishu account "${opts.accountId}" not configured or disabled`);
+        }
+        await monitorSingleAccount({
+            cfg,
+            account,
+            runtime: opts.runtime,
+            abortSignal: opts.abortSignal,
+        });
+        await drainShutdownHooks({ log });
+        return;
+    }
+    // Multi-account mode: start all enabled accounts in parallel.
+    const accounts = getEnabledLarkAccounts(cfg);
+    if (accounts.length === 0) {
+        throw new Error('No enabled Feishu accounts configured');
+    }
+    log(`feishu: starting ${accounts.length} account(s): ${accounts.map((a) => a.accountId).join(', ')}`);
+    await Promise.all(accounts.map((account) => monitorSingleAccount({
+        cfg,
+        account,
+        runtime: opts.runtime,
+        abortSignal: opts.abortSignal,
+    })));
+    await drainShutdownHooks({ log });
+}

package/src/channel/onboarding-config.d.ts

@@ -0,0 +1,17 @@
+/**
+ * Copyright (c) 2026 ByteDance Ltd. and/or its affiliates
+ * SPDX-License-Identifier: MIT
+ *
+ * Onboarding configuration mutation helpers.
+ *
+ * Pure functions that apply Feishu channel configuration changes
+ * to a ClawdbotConfig. Extracted from onboarding.ts for reuse
+ * in CLI commands and other configuration flows.
+ */
+import type { ClawdbotConfig, DmPolicy } from 'openclaw/plugin-sdk';
+export declare function setFeishuDmPolicy(cfg: ClawdbotConfig, dmPolicy: DmPolicy): ClawdbotConfig;
+export declare function setFeishuAllowFrom(cfg: ClawdbotConfig, allowFrom: string[]): ClawdbotConfig;
+export declare function setFeishuGroupPolicy(cfg: ClawdbotConfig, groupPolicy: 'open' | 'allowlist' | 'disabled'): ClawdbotConfig;
+export declare function setFeishuGroupAllowFrom(cfg: ClawdbotConfig, groupAllowFrom: string[]): ClawdbotConfig;
+export declare function setFeishuGroups(cfg: ClawdbotConfig, groups: Record<string, object>): ClawdbotConfig;
+export declare function parseAllowFromInput(raw: string): string[];

package/src/channel/onboarding-config.js

@@ -0,0 +1,88 @@
+/**
+ * Copyright (c) 2026 ByteDance Ltd. and/or its affiliates
+ * SPDX-License-Identifier: MIT
+ *
+ * Onboarding configuration mutation helpers.
+ *
+ * Pure functions that apply Feishu channel configuration changes
+ * to a ClawdbotConfig. Extracted from onboarding.ts for reuse
+ * in CLI commands and other configuration flows.
+ */
+import { addWildcardAllowFrom } from 'openclaw/plugin-sdk';
+// ---------------------------------------------------------------------------
+// Config mutation helpers
+// ---------------------------------------------------------------------------
+export function setFeishuDmPolicy(cfg, dmPolicy) {
+    const allowFrom = dmPolicy === 'open'
+        ? addWildcardAllowFrom(cfg.channels?.feishu?.allowFrom)?.map((entry) => String(entry))
+        : undefined;
+    return {
+        ...cfg,
+        channels: {
+            ...cfg.channels,
+            feishu: {
+                ...cfg.channels?.feishu,
+                dmPolicy,
+                ...(allowFrom ? { allowFrom } : {}),
+            },
+        },
+    };
+}
+export function setFeishuAllowFrom(cfg, allowFrom) {
+    return {
+        ...cfg,
+        channels: {
+            ...cfg.channels,
+            feishu: {
+                ...cfg.channels?.feishu,
+                allowFrom,
+            },
+        },
+    };
+}
+export function setFeishuGroupPolicy(cfg, groupPolicy) {
+    return {
+        ...cfg,
+        channels: {
+            ...cfg.channels,
+            feishu: {
+                ...cfg.channels?.feishu,
+                enabled: true,
+                groupPolicy,
+            },
+        },
+    };
+}
+export function setFeishuGroupAllowFrom(cfg, groupAllowFrom) {
+    return {
+        ...cfg,
+        channels: {
+            ...cfg.channels,
+            feishu: {
+                ...cfg.channels?.feishu,
+                groupAllowFrom,
+            },
+        },
+    };
+}
+export function setFeishuGroups(cfg, groups) {
+    return {
+        ...cfg,
+        channels: {
+            ...cfg.channels,
+            feishu: {
+                ...cfg.channels?.feishu,
+                groups,
+            },
+        },
+    };
+}
+// ---------------------------------------------------------------------------
+// Input helpers
+// ---------------------------------------------------------------------------
+export function parseAllowFromInput(raw) {
+    return raw
+        .split(/[\n,;]+/g)
+        .map((entry) => entry.trim())
+        .filter(Boolean);
+}