hyacinth-ai 0.9.6

package/dist/channels/plugins/feishu/feishu-client.js

@@ -0,0 +1,86 @@
+// ============================================================
+// Feishu 客户端封装
+// ============================================================
+//
+// 封装 @larksuiteoapi/node-sdk 的 Client、WSClient、EventDispatcher
+// 复用 OpenClaw 的缓存策略和超时处理思路。
+// ============================================================
+// ── 域名解析 ──
+/**
+ * SDK 的 Domain 枚举: Feishu=0, Lark=1
+ * 也可以传完整 URL 字符串（如 "https://open.feishu.cn"）
+ * 不能传 "feishu" / "lark" 这种短字符串——SDK 会原样拼接导致 Invalid URL
+ */
+function resolveDomain(config) {
+    if (config.domain === 'lark')
+        return 1; // Domain.Lark
+    return 0; // Domain.Feishu
+}
+function configHash(config) {
+    return `${config.appId}:${config.appSecret}:${config.domain}`;
+}
+// ── FeishuClientFactory ──
+export class FeishuClientFactory {
+    larkSDK = null;
+    clientCache = new Map();
+    async getSDK() {
+        if (!this.larkSDK) {
+            this.larkSDK = await import('@larksuiteoapi/node-sdk');
+        }
+        return this.larkSDK;
+    }
+    async createClient(config) {
+        const lark = await this.getSDK();
+        const hash = configHash(config);
+        const cached = this.clientCache.get('default');
+        if (cached && cached.configHash === hash) {
+            return cached.client;
+        }
+        const client = new lark.Client({
+            appId: config.appId,
+            appSecret: config.appSecret,
+            appType: lark.AppType.SelfBuild,
+            domain: resolveDomain(config),
+        });
+        this.clientCache.set('default', { client, configHash: hash });
+        return client;
+    }
+    async createWSClient(config, callbacks = {}) {
+        const lark = await this.getSDK();
+        return new lark.WSClient({
+            appId: config.appId,
+            appSecret: config.appSecret,
+            domain: resolveDomain(config),
+            loggerLevel: lark.LoggerLevel.warn,
+            ...callbacks,
+        });
+    }
+    async createDispatcher() {
+        const lark = await this.getSDK();
+        return new lark.EventDispatcher({});
+    }
+    getCachedClient() {
+        return this.clientCache.get('default')?.client ?? null;
+    }
+    clearCache() {
+        this.clientCache.clear();
+    }
+}
+// ── 模块级便捷函数（向后兼容） ──
+const defaultFactory = new FeishuClientFactory();
+export async function createFeishuClient(config) {
+    return defaultFactory.createClient(config);
+}
+export function getCachedClient() {
+    return defaultFactory.getCachedClient();
+}
+export function clearClientCache() {
+    defaultFactory.clearCache();
+}
+export async function createFeishuWSClient(config, callbacks = {}) {
+    return defaultFactory.createWSClient(config, callbacks);
+}
+export async function createEventDispatcher() {
+    return defaultFactory.createDispatcher();
+}
+//# sourceMappingURL=feishu-client.js.map

package/dist/channels/plugins/feishu/feishu-config.d.ts

@@ -0,0 +1,53 @@
+/** 连接模式 */
+export type FeishuConnectionMode = 'websocket';
+/** DM 策略 */
+export type FeishuDmPolicy = 'open' | 'allowlist' | 'disabled';
+/** 群组策略 */
+export type FeishuGroupPolicy = 'open' | 'allowlist' | 'disabled';
+/** 飞书渠道配置 */
+export interface FeishuChannelConfig {
+    /** 是否启用 */
+    enabled?: boolean;
+    /** 飞书应用 App ID */
+    appId: string;
+    /** 飞书应用 App Secret */
+    appSecret: string;
+    /** 连接模式（默认 websocket） */
+    connectionMode?: FeishuConnectionMode;
+    /** API 域名：feishu（国内飞书）/ lark（国际） */
+    domain?: 'feishu' | 'lark';
+    /** HTTP 请求超时（毫秒），默认 30_000 */
+    httpTimeoutMs?: number;
+    /** DM 策略（默认 'allowlist'） */
+    dmPolicy?: FeishuDmPolicy;
+    /**
+     * DM 允许列表（open_id 列表）
+     * - dmPolicy='allowlist' 时只允许列表内用户私聊
+     * - 包含 '*' 表示允许所有人
+     */
+    allowFrom?: string[];
+    /** 群组策略（默认 'allowlist'） */
+    groupPolicy?: FeishuGroupPolicy;
+    /**
+     * 群组允许列表（chat_id 列表）
+     * - groupPolicy='allowlist' 时只允许列表内群组接收消息
+     */
+    groupAllowFrom?: string[];
+    /** 群聊中是否需要 @提及 才回复（默认 true） */
+    requireMention?: boolean;
+    /** 是否解析发送者显示名称（默认 true，会消耗 API 配额） */
+    resolveSenderNames?: boolean;
+    /** 飞书消息是否同步到 TUI 界面（默认 false） */
+    tuiSync?: boolean;
+    /** session 复用策略：shared=共用主loop, per_chat=按聊天, per_user=按用户（默认 'per_user'） */
+    sessionMode?: 'shared' | 'per_chat' | 'per_user';
+    /** 消息历史条数限制（群聊），默认 10 */
+    historyLimit?: number;
+    /** 发送文本消息的最大长度（字符），默认 4000 */
+    textChunkLimit?: number;
+}
+/** 带默认值的完整配置 */
+export declare function resolveFeishuConfig(raw: Partial<FeishuChannelConfig>): FeishuChannelConfig;
+/** 校验配置是否完备 */
+export declare function validateFeishuConfig(config: FeishuChannelConfig): string | null;
+//# sourceMappingURL=feishu-config.d.ts.map

package/dist/channels/plugins/feishu/feishu-config.js

@@ -0,0 +1,35 @@
+// ============================================================
+// Feishu 渠道配置类型
+// ============================================================
+/** 带默认值的完整配置 */
+export function resolveFeishuConfig(raw) {
+    const appId = raw.appId ?? '';
+    const appSecret = raw.appSecret ?? '';
+    return {
+        enabled: raw.enabled ?? true,
+        appId,
+        appSecret,
+        connectionMode: raw.connectionMode ?? 'websocket',
+        domain: raw.domain ?? 'feishu',
+        httpTimeoutMs: raw.httpTimeoutMs ?? 30_000,
+        dmPolicy: raw.dmPolicy ?? 'allowlist',
+        allowFrom: raw.allowFrom ?? [],
+        groupPolicy: raw.groupPolicy ?? 'allowlist',
+        groupAllowFrom: raw.groupAllowFrom ?? [],
+        requireMention: raw.requireMention ?? true,
+        resolveSenderNames: raw.resolveSenderNames ?? true,
+        tuiSync: raw.tuiSync ?? false,
+        sessionMode: raw.sessionMode ?? 'per_user',
+        historyLimit: raw.historyLimit ?? 10,
+        textChunkLimit: raw.textChunkLimit ?? 4000,
+    };
+}
+/** 校验配置是否完备 */
+export function validateFeishuConfig(config) {
+    if (!config.appId)
+        return 'Feishu config: appId is required';
+    if (!config.appSecret)
+        return 'Feishu config: appSecret is required';
+    return null;
+}
+//# sourceMappingURL=feishu-config.js.map

package/dist/channels/plugins/feishu/feishu-event.d.ts

@@ -0,0 +1,102 @@
+export interface FeishuMessageEvent {
+    /** SDK 事件 ID（来自 header.event_id，用于去重） */
+    _eventId?: string;
+    message: {
+        message_id: string;
+        chat_id: string;
+        chat_type: string;
+        message_type: string;
+        content: string;
+        root_id?: string;
+        parent_id?: string;
+        thread_id?: string;
+        mentions?: Array<{
+            key: string;
+            id: {
+                open_id?: string;
+                union_id?: string;
+            };
+            name: string;
+        }>;
+        create_time?: string;
+    };
+    sender: {
+        sender_id: {
+            open_id?: string;
+            user_id?: string;
+            union_id?: string;
+        };
+    };
+}
+export interface FeishuMessageContext {
+    messageId: string;
+    chatId: string;
+    chatType: string;
+    isGroup: boolean;
+    senderOpenId: string;
+    senderUserId?: string;
+    content: string;
+    contentType: string;
+    /** 图片 image_key（message_type: 'image' 时填入） */
+    imageKey?: string;
+    rootId?: string;
+    parentId?: string;
+    threadId?: string;
+    mentionedBot: boolean;
+    senderName?: string;
+    createTimeMs?: number;
+}
+/**
+ * 解析飞书消息内容
+ */
+export interface ParsedMessage {
+    text: string;
+    /** 图片 image_key（message_type: 'image' 时填入） */
+    imageKey?: string;
+    contentType: string;
+}
+export declare function parseMessageContent(rawContent: string, msgType: string): ParsedMessage;
+/**
+ * 检查消息中是否 @提到了 bot
+ * @param event 原始消息事件
+ * @param botOpenId bot 的 open_id（可选，如果提供则精确匹配）
+ */
+export declare function checkBotMentioned(event: FeishuMessageEvent, botOpenId?: string): boolean;
+/**
+ * 检查是否有任何提及
+ */
+export declare function hasAnyMention(event: FeishuMessageEvent): boolean;
+export declare class FeishuDedupeStore {
+    private readonly dedupeWindowMs;
+    private readonly cleanupIntervalMs;
+    private recentMessages;
+    private lastCleanup;
+    constructor(dedupeWindowMs?: number, // 10 分钟（覆盖飞书重传间隔）
+    cleanupIntervalMs?: number);
+    /**
+     * 检查消息是否重复。返回 true 表示新消息，false 表示已处理过。
+     */
+    check(messageId: string): boolean;
+    /**
+     * 清理所有去重记录
+     */
+    clear(): void;
+}
+/**
+ * 检查消息是否重复（基于 message_id）
+ * 返回 true 表示是新消息，false 表示已处理过
+ */
+export declare function checkMessageDedupe(messageId: string): boolean;
+/**
+ * 解析飞书消息事件为标准化上下文
+ */
+export declare function parseFeishuMessageEvent(event: FeishuMessageEvent, botOpenId?: string): FeishuMessageContext;
+/**
+ * 检查 DM 访问权限
+ */
+export declare function checkDmAccess(senderOpenId: string, dmPolicy: 'open' | 'allowlist' | 'disabled', allowFrom: string[]): boolean;
+/**
+ * 检查群组访问权限
+ */
+export declare function checkGroupAccess(chatId: string, groupPolicy: 'open' | 'allowlist' | 'disabled', groupAllowFrom: string[]): boolean;
+//# sourceMappingURL=feishu-event.d.ts.map

package/dist/channels/plugins/feishu/feishu-event.js

@@ -0,0 +1,257 @@
+// ============================================================
+// Feishu 事件解析
+// ============================================================
+//
+// 解析飞书消息事件，包括：
+//   - 消息内容提取（text/post/interactive 格式）
+//   - 提及检测（@bot 判断）
+//   - 消息去重
+// ============================================================
+// ── 内容解析 ──
+/**
+ * 解析文本消息内容
+ */
+function parseTextContent(rawContent) {
+    try {
+        const parsed = JSON.parse(rawContent);
+        return typeof parsed.text === 'string' ? parsed.text : '';
+    }
+    catch {
+        return rawContent;
+    }
+}
+/**
+ * 解析富文本（post）消息内容
+ */
+function parsePostContent(rawContent) {
+    try {
+        const parsed = JSON.parse(rawContent);
+        // post 格式: { "zh_cn": { "content": [[{ "tag": "text", "text": "..." }]] } }
+        const content = parsed?.zh_cn?.content || parsed?.content;
+        if (!Array.isArray(content))
+            return '';
+        const lines = [];
+        for (const paragraph of content) {
+            if (!Array.isArray(paragraph))
+                continue;
+            const lineParts = [];
+            for (const element of paragraph) {
+                if (element?.tag === 'text' && typeof element.text === 'string') {
+                    lineParts.push(element.text);
+                }
+                else if (element?.tag === 'a' && typeof element.text === 'string') {
+                    lineParts.push(element.text);
+                }
+                else if (element?.tag === 'at' && typeof element.user_name === 'string') {
+                    lineParts.push(`@${element.user_name}`);
+                }
+            }
+            if (lineParts.length > 0)
+                lines.push(lineParts.join(''));
+        }
+        return lines.join('\n');
+    }
+    catch {
+        return '';
+    }
+}
+/**
+ * 解析交互式卡片（interactive）消息内容
+ */
+function parseInteractiveContent(rawContent) {
+    try {
+        const parsed = JSON.parse(rawContent);
+        // 从卡片元素中提取文本
+        const elements = parsed?.body?.elements || parsed?.elements;
+        if (!Array.isArray(elements))
+            return '[Interactive Card]';
+        const texts = [];
+        for (const el of elements) {
+            if (el?.tag === 'markdown' || el?.tag === 'lark_md') {
+                if (typeof el.content === 'string')
+                    texts.push(el.content);
+            }
+            else if (el?.tag === 'plain_text') {
+                if (typeof el.content === 'string')
+                    texts.push(el.content);
+            }
+            else if (el?.tag === 'div' && el?.text && typeof el.text.content === 'string') {
+                texts.push(el.text.content);
+            }
+        }
+        return texts.length > 0 ? texts.join('\n') : '[Interactive Card]';
+    }
+    catch {
+        return '[Interactive Card]';
+    }
+}
+export function parseMessageContent(rawContent, msgType) {
+    if (!rawContent)
+        return { text: '', contentType: msgType };
+    switch (msgType) {
+        case 'text':
+            return { text: parseTextContent(rawContent), contentType: 'text' };
+        case 'post':
+            return { text: parsePostContent(rawContent), contentType: 'post' };
+        case 'interactive':
+            return { text: parseInteractiveContent(rawContent), contentType: 'interactive' };
+        case 'image':
+            try {
+                const parsed = JSON.parse(rawContent);
+                return { text: '[图片]', imageKey: parsed.image_key, contentType: 'image' };
+            }
+            catch {
+                return { text: '[图片消息]', contentType: 'image' };
+            }
+        default:
+            try {
+                const parsed = JSON.parse(rawContent);
+                if (typeof parsed === 'string')
+                    return { text: parsed, contentType: msgType };
+                if (parsed?.text && typeof parsed.text === 'string')
+                    return { text: parsed.text, contentType: msgType };
+                return { text: `[${msgType} message]`, contentType: msgType };
+            }
+            catch {
+                return { text: rawContent, contentType: msgType };
+            }
+    }
+}
+// ── 提及检测 ──
+/**
+ * 检查消息中是否 @提到了 bot
+ * @param event 原始消息事件
+ * @param botOpenId bot 的 open_id（可选，如果提供则精确匹配）
+ */
+export function checkBotMentioned(event, botOpenId) {
+    const mentions = event.message.mentions;
+    if (!mentions || mentions.length === 0)
+        return false;
+    if (botOpenId) {
+        return mentions.some((m) => m.id.open_id === botOpenId);
+    }
+    // 如果没有 botOpenId，只要有提及就算（保守策略）
+    return mentions.length > 0;
+}
+/**
+ * 检查是否有任何提及
+ */
+export function hasAnyMention(event) {
+    return (event.message.mentions?.length ?? 0) > 0;
+}
+// ── 消息去重 ──
+export class FeishuDedupeStore {
+    dedupeWindowMs;
+    cleanupIntervalMs;
+    recentMessages = new Map();
+    lastCleanup = Date.now();
+    constructor(dedupeWindowMs = 600_000, // 10 分钟（覆盖飞书重传间隔）
+    cleanupIntervalMs = 300_000) {
+        this.dedupeWindowMs = dedupeWindowMs;
+        this.cleanupIntervalMs = cleanupIntervalMs;
+    }
+    /**
+     * 检查消息是否重复。返回 true 表示新消息，false 表示已处理过。
+     */
+    check(messageId) {
+        const now = Date.now();
+        if (now - this.lastCleanup > this.cleanupIntervalMs) {
+            for (const [id, timestamp] of this.recentMessages) {
+                if (now - timestamp > this.dedupeWindowMs) {
+                    this.recentMessages.delete(id);
+                }
+            }
+            this.lastCleanup = now;
+        }
+        if (this.recentMessages.has(messageId)) {
+            return false;
+        }
+        this.recentMessages.set(messageId, now);
+        return true;
+    }
+    /**
+     * 清理所有去重记录
+     */
+    clear() {
+        this.recentMessages.clear();
+        this.lastCleanup = Date.now();
+    }
+}
+const defaultDedupeStore = new FeishuDedupeStore();
+/**
+ * 检查消息是否重复（基于 message_id）
+ * 返回 true 表示是新消息，false 表示已处理过
+ */
+export function checkMessageDedupe(messageId) {
+    return defaultDedupeStore.check(messageId);
+}
+// ── 事件解析入口 ──
+/**
+ * 解析飞书消息事件为标准化上下文
+ */
+export function parseFeishuMessageEvent(event, botOpenId) {
+    const chatType = event.message.chat_type;
+    const isGroup = chatType === 'group' || chatType === 'topic_group';
+    const rawContent = event.message.content;
+    const msgType = event.message.message_type;
+    const parsed = parseMessageContent(rawContent, msgType);
+    const senderOpenId = event.sender.sender_id.open_id?.trim() ?? '';
+    const senderUserId = event.sender.sender_id.user_id?.trim();
+    return {
+        messageId: event.message.message_id,
+        chatId: event.message.chat_id,
+        chatType,
+        isGroup,
+        senderOpenId: senderOpenId || senderUserId || '',
+        senderUserId: senderUserId || undefined,
+        content: parsed.text,
+        contentType: parsed.contentType,
+        imageKey: parsed.imageKey,
+        rootId: event.message.root_id || undefined,
+        parentId: event.message.parent_id || undefined,
+        threadId: event.message.thread_id || undefined,
+        mentionedBot: checkBotMentioned(event, botOpenId),
+        createTimeMs: event.message.create_time
+            ? Number(event.message.create_time)
+            : undefined,
+    };
+}
+// ── 访问控制 ──
+/**
+ * 检查 DM 访问权限
+ */
+export function checkDmAccess(senderOpenId, dmPolicy, allowFrom) {
+    if (dmPolicy === 'disabled')
+        return false;
+    if (dmPolicy === 'open')
+        return true;
+    // allowlist 模式
+    if (allowFrom.length === 0)
+        return true; // 未配置白名单时默认允许
+    if (allowFrom.includes('*'))
+        return true;
+    return allowFrom.some((entry) => {
+        const normalized = entry.toLowerCase().trim();
+        return (normalized === senderOpenId.toLowerCase() ||
+            normalized === `user:${senderOpenId.toLowerCase()}` ||
+            normalized === `open_id:${senderOpenId.toLowerCase()}`);
+    });
+}
+/**
+ * 检查群组访问权限
+ */
+export function checkGroupAccess(chatId, groupPolicy, groupAllowFrom) {
+    if (groupPolicy === 'disabled')
+        return false;
+    if (groupPolicy === 'open')
+        return true;
+    // allowlist 模式
+    if (groupAllowFrom.length === 0)
+        return true;
+    return groupAllowFrom.some((entry) => {
+        const normalized = entry.toLowerCase().trim();
+        return (normalized === chatId.toLowerCase() ||
+            normalized === `chat:${chatId.toLowerCase()}`);
+    });
+}
+//# sourceMappingURL=feishu-event.js.map

package/dist/channels/plugins/feishu/feishu-log-suppressor.d.ts

@@ -0,0 +1,7 @@
+/**
+ * 安装 TUI 日志拦截器。
+ * 持久拦截 console.log，将框架内部日志重定向到 stderr。
+ * 调用返回的 restore 函数可恢复原始 console.log。
+ */
+export declare function installSDKLogSuppressor(): () => void;
+//# sourceMappingURL=feishu-log-suppressor.d.ts.map

package/dist/channels/plugins/feishu/feishu-log-suppressor.js

@@ -0,0 +1,34 @@
+// ============================================================
+// TUI 日志拦截器
+// ============================================================
+//
+// TUI 模式下，console.log 输出会污染终端界面（覆盖输入行）。
+// 此模块拦截 console.log，将非 TUI 的日志重定向到 stderr
+// （TUI 会把 stderr 写入日志文件，避免污染终端界面）。
+//
+// 拦截规则：
+//   - 飞书 SDK 日志：[info]: / [warn]: / [error]: 前缀
+//   - TrainingScheduler 日志：[TrainingScheduler] 前缀
+//   - 其他框架内部日志：[ClassName] 前缀格式
+// ============================================================
+/**
+ * 安装 TUI 日志拦截器。
+ * 持久拦截 console.log，将框架内部日志重定向到 stderr。
+ * 调用返回的 restore 函数可恢复原始 console.log。
+ */
+export function installSDKLogSuppressor() {
+    const origLog = console.log;
+    console.log = (...args) => {
+        const msg = args.map(String).join(' ');
+        // 框架内部日志特征：[ClassName] 前缀 或 SDK 特定关键词
+        if (/^\[(info|warn|error)\]/.test(msg) ||
+            /^\[\w+\]/.test(msg) || // [TrainingScheduler]、[HeartbeatScheduler] 等
+            /event-dispatch|ws client|persistent connection/i.test(msg)) {
+            process.stderr.write(`${msg}\n`);
+            return;
+        }
+        origLog(...args);
+    };
+    return () => { console.log = origLog; };
+}
+//# sourceMappingURL=feishu-log-suppressor.js.map

package/dist/channels/plugins/feishu/feishu-message-queue.d.ts

@@ -0,0 +1,27 @@
+import type { ChannelEvent } from '../../interface.js';
+type Logger = {
+    info: (msg: string) => void;
+    error: (msg: string) => void;
+    warn?: (msg: string) => void;
+};
+type ProcessFn = (event: ChannelEvent) => Promise<void>;
+export declare class FeishuMessageQueue {
+    private queues;
+    private processing;
+    private processFn;
+    private logger;
+    private static MAX_QUEUE_SIZE;
+    constructor(logger?: Logger);
+    /** 设置消息处理函数 */
+    setProcessFn(fn: ProcessFn): void;
+    /** 入队消息（fire-and-forget，立即返回） */
+    enqueue(sessionId: string, event: ChannelEvent): void;
+    /** 串行处理下一条消息 */
+    private processNext;
+    /** 获取指定 session 的队列长度 */
+    getQueueSize(sessionId: string): number;
+    /** 清理所有队列 */
+    clear(): void;
+}
+export {};
+//# sourceMappingURL=feishu-message-queue.d.ts.map