pikiloom 0.4.26 → 0.4.27

package/dist/channels/feishu/bot.js

@@ -1,11 +1,3 @@
-/**
- * bot-feishu.ts — Feishu bot orchestration: commands, streaming, artifacts, lifecycle.
- *
- * Follows the same pattern as bot-telegram.ts:
- *   - Commands use shared data layer (bot-commands.ts) + Feishu renderer
- *   - Messages flow through the streaming pipeline
- *   - LivePreview provides real-time streaming updates via card edits
- */
 import os from 'node:os';
 import fs from 'node:fs';
 import path from 'node:path';
@@ -44,11 +36,6 @@ function describeError(err) {
         parts.push(`cause=${describeError(cause)}`);
     return parts.join(' | ');
 }
-/**
- * Decision echo rendered as a separate Feishu message after a human-loop
- * prompt resolves — so the answer becomes part of the conversation history
- * rather than living only inside the now-closed card.
- */
 function buildInteractionEchoMarkdown(summary) {
     if (summary.status === 'cancelled')
         return '*⊘ Prompt cancelled.*';
@@ -99,15 +86,11 @@ function formatToolLog(activity) {
     const summary = deduped.slice(0, 6).join(' | ');
     return summary.length <= 240 ? summary : `${summary.slice(0, 237).trimEnd()}...`;
 }
-// ---------------------------------------------------------------------------
-// FeishuBot
-// ---------------------------------------------------------------------------
 export class FeishuBot extends Bot {
     appId;
     appSecret;
     domain;
     channel;
-    /** Maps chatId → (messageId → sessionKey) for reply-chain session tracking. */
     sessionMessages = new SessionMessageRegistry();
     nextTaskId = 1;
     shutdownInFlight = false;
@@ -118,16 +101,10 @@ export class FeishuBot extends Bot {
     constructor() {
         super();
         const config = getActiveUserConfig();
-        // Merge Feishu-specific allowed IDs into base
         if (process.env.FEISHU_ALLOWED_CHAT_IDS) {
             for (const id of parseAllowedChatIds(process.env.FEISHU_ALLOWED_CHAT_IDS))
                 this.allowedChatIds.add(id);
         }
-        // NOTE: persisted known chats are restored into channel.knownChats in run()
-        // (for the startup greeting / per-chat menu) — deliberately NOT into
-        // allowedChatIds. allowedChatIds is the explicit allowlist; folding known
-        // chats into it flips _isAllowed() from allow-all into allowlist-only and
-        // silently drops every new chat.
         this.appId = String(config.feishuAppId || process.env.FEISHU_APP_ID || '').trim();
         this.appSecret = String(config.feishuAppSecret || process.env.FEISHU_APP_SECRET || '').trim();
         this.domain = (process.env.FEISHU_DOMAIN || 'https://open.feishu.cn').trim();
@@ -169,7 +146,6 @@ export class FeishuBot extends Bot {
             return;
         void this.setupMenu().catch(err => this.log(`menu refresh failed: ${err}`));
     }
-    // ---- signal handling ------------------------------------------------------
     installSignalHandlers() {
         this.removeSignalHandlers();
         const onSigint = () => this.beginShutdown('SIGINT');
@@ -210,13 +186,8 @@ export class FeishuBot extends Bot {
         shutdownAllDrivers();
     }
     buildRestartEnv() {
-        // Hand off only the explicit allowlist. Known chats persist to setting.json
-        // (recordKnownChatId) and are restored via loadKnownChatIds, so they must NOT
-        // ride along in the allowlist env — that would re-pollute allowedChatIds on
-        // the next boot and lock out new chats.
         return buildKnownChatEnv(this.allowedChatIds, [], 'FEISHU_ALLOWED_CHAT_IDS');
     }
-    // ---- session tracking -----------------------------------------------------
     createTaskId(session) {
         return buildSessionTaskId(session, this.nextTaskId++);
     }
@@ -250,7 +221,6 @@ export class FeishuBot extends Bot {
             return selected;
         return this.ensureSession(ctx.chatId, text, files);
     }
-    // ---- commands -------------------------------------------------------------
     async cmdStart(ctx) {
         const d = getStartData(this, ctx.chatId);
         await ctx.reply(renderStart(d));
@@ -376,7 +346,6 @@ export class FeishuBot extends Bot {
                 return;
             }
             catch {
-                // Not a valid agent name — show list
             }
         }
         await this.sendCommandView(ctx, buildAgentsCommandView(this, ctx.chatId));
@@ -534,12 +503,6 @@ export class FeishuBot extends Bot {
             this.debug(`[human-loop] echo send failed chat=${chatId} prompt=${prompt.promptId}: ${err?.message || err}`);
         }
     }
-    /**
-     * IM presenter for programmatic submissions (e.g. /goal-driven turns) so
-     * they stream to Feishu the same way a typed message does. Without this,
-     * /goal just emits a confirmation reply and the rest of the turn is
-     * invisible to the IM user.
-     */
     async createImTaskPresenter(opts) {
         if (typeof opts.chatId !== 'string')
             return null;
@@ -623,7 +586,6 @@ export class FeishuBot extends Bot {
         }
         catch { }
     }
-    // ---- streaming bridge -----------------------------------------------------
     async handleMessage(msg, ctx) {
         const text = msg.text.trim();
         if (!text && !msg.files.length)
@@ -635,7 +597,6 @@ export class FeishuBot extends Bot {
                 await ctx.reply('Please answer the active prompt using the buttons above.');
                 return;
             }
-            // Completed prompts close themselves via onInteractionAnswered.
             if (!result.completed)
                 await this.refreshHumanLoopPrompt(ctx.chatId, result.prompt.promptId);
             return;
@@ -643,11 +604,7 @@ export class FeishuBot extends Bot {
         const session = this.resolveIncomingSession(ctx, text, msg.files);
         const cs = this.chat(ctx.chatId);
         this.applySessionSelection(cs, session);
-        // Tie the user's own message to its session so a future Feishu reply to it
-        // (their own message, or a quote-chain rooted at it) resolves back to this
-        // session instead of falling through to the chat's current default.
         this.registerSessionMessage(ctx.chatId, ctx.messageId, session);
-        // File-only message: stage files
         if (!text && msg.files.length) {
             const hadPendingWork = this.sessionHasPendingWork(session);
             const stageTask = this.queueSessionTask(session, async () => {
@@ -705,9 +662,6 @@ export class FeishuBot extends Bot {
         this.emitStreamQueued(session.key, taskId);
         const queuePosition = waiting ? this.getQueuePosition(session.key, taskId) : 0;
         const placeholderKeyboard = this.buildStopKeyboard(this.actionIdForTask(taskId), { queued: waiting });
-        // Use the canonical resolver so the labels in the IM card match what
-        // runStream actually invokes the agent with (and what the dashboard's
-        // `start` event reports).
         const startConfig = this.resolveSessionStreamConfig(session);
         const model = startConfig.model;
         const effort = startConfig.effort;
@@ -737,7 +691,6 @@ export class FeishuBot extends Bot {
                     return;
                 }
                 this.emitStreamStart(taskId, session);
-                // Task is now running — update keyboard from Recall/Steer to Stop
                 const runningKeyboard = this.buildStopKeyboard(this.actionIdForTask(taskId));
                 if (placeholderId && waiting) {
                     try {
@@ -766,7 +719,6 @@ export class FeishuBot extends Bot {
                     });
                     livePreview.start();
                 }
-                // MCP sendFile callback: sends files to IM in real-time during the stream
                 const mcpSendFile = this.createMcpSendFileCallback(ctx);
                 const result = await this.runStream(prompt, session, files, (nextText, nextThinking, nextActivity = '', meta, plan) => {
                     livePreview?.update(nextText, nextThinking, nextActivity, meta, plan);
@@ -794,8 +746,6 @@ export class FeishuBot extends Bot {
                     incomplete: !!result.incomplete,
                     ...(result.ok ? {} : { error: result.error || result.message }),
                 });
-                // If LivePreview already gave up on the placeholder (Feishu rejected too
-                // many consecutive edits) skip the doomed edit attempt and send fresh.
                 const effectivePlaceholderId = livePreview?.isPlaceholderAbandoned() ? null : placeholderId;
                 const finalReplyIds = await this.sendFinalReply({ chatId: ctx.chatId }, effectivePlaceholderId, session.agent, result);
                 this.registerSessionMessages(ctx.chatId, finalReplyIds, session);
@@ -837,10 +787,6 @@ export class FeishuBot extends Bot {
             this.finishTask(taskId);
         });
     }
-    /** Edit the placeholder if possible; otherwise send `text` as a fresh card
-     *  anchored to the placeholder so the user always sees the result. Returns
-     *  the message id that now carries `text` (the placeholder id if the edit
-     *  succeeded, or a newly-created id on fallback). */
     async editOrSendFresh(chatId, placeholderId, text, opts = {}) {
         const tag = opts.logTag || 'editOrSendFresh';
         if (placeholderId) {
@@ -851,8 +797,6 @@ export class FeishuBot extends Bot {
             catch (e) {
                 this.debug(`[${tag}] placeholder edit failed, falling back to send chat=${chatId} placeholder=${placeholderId}: ${e?.message || e}`);
             }
-            // Try anchoring the fresh send to the placeholder so the result stays in
-            // the same visual thread.
             try {
                 const sent = await this.channel.send(chatId, text, {
                     replyTo: placeholderId,
@@ -865,7 +809,6 @@ export class FeishuBot extends Bot {
                 this.debug(`[${tag}] reply send failed, dropping reply anchor chat=${chatId} placeholder=${placeholderId}: ${e?.message || e}`);
             }
         }
-        // Last resort: standalone fresh card.
         try {
             return await this.channel.send(chatId, text, { keyboard: opts.keyboard });
         }
@@ -891,14 +834,11 @@ export class FeishuBot extends Bot {
         const messageIds = [];
         const MAX_CARD = FEISHU_BOT_CARD_MAX;
         if (rendered.fullText.length <= MAX_CARD) {
-            // Fits in one card — try to edit the placeholder, fall back to a fresh
-            // card if Feishu rejected the patch (message too old, recalled, ...).
             const finalId = await this.editOrSendFresh(anchor.chatId, placeholderId, rendered.fullText, { logTag: 'final-reply' });
             if (finalId)
                 messageIds.push(finalId);
         }
         else {
-            // Split: first card has header + truncated body + footer, continuation as separate cards
             const maxFirst = MAX_CARD - rendered.headerText.length - rendered.footerText.length;
             let firstBody;
             let remaining;
@@ -926,7 +866,6 @@ export class FeishuBot extends Bot {
                 }
             }
         }
-        // Dispatch any image MessageBlocks the agent produced this turn.
         const lastId = messageIds[messageIds.length - 1];
         const dispatched = await dispatchImageBlocks(this.channel, result.assistantBlocks, {
             chatId: anchor.chatId,
@@ -939,7 +878,6 @@ export class FeishuBot extends Bot {
         }
         return messageIds;
     }
-    /** Create an MCP sendFile callback bound to a Feishu chat context. */
     createMcpSendFileCallback(ctx) {
         return async (filePath, opts) => {
             try {
@@ -956,7 +894,6 @@ export class FeishuBot extends Bot {
             }
         };
     }
-    // ---- command router -------------------------------------------------------
     async handleCommand(cmd, args, ctx) {
         try {
             switch (cmd) {
@@ -1003,12 +940,10 @@ export class FeishuBot extends Bot {
                     await this.cmdRestart(ctx);
                     return;
                 default:
-                    // Skill commands
                     if (cmd.startsWith(FeishuBot.SKILL_CMD_PREFIX)) {
                         await this.cmdSkill(cmd, args, ctx);
                         return;
                     }
-                    // Unknown command — treat as message
                     await this.handleMessage({ text: `/${cmd}${args ? ' ' + args : ''}`, files: [] }, ctx);
             }
         }
@@ -1039,7 +974,6 @@ export class FeishuBot extends Bot {
             raw: ctx.raw,
         };
     }
-    // ---- callback handlers ----------------------------------------------------
     async handleCallback(data, ctx) {
         try {
             if (await this.handleHumanLoopCallback(data, ctx))
@@ -1129,7 +1063,6 @@ export class FeishuBot extends Bot {
         const result = await this.steerTaskByActionId(actionId);
         if (!result.task)
             return true;
-        // The queued task will naturally run next after the running task is interrupted
         return true;
     }
     async handleSwitchNavigateCallback(data, ctx) {
@@ -1187,7 +1120,6 @@ export class FeishuBot extends Bot {
             }
         }
         catch {
-            // non-critical
         }
     }
     async handleMessageRecalled(messageId, chatId) {
@@ -1202,7 +1134,6 @@ export class FeishuBot extends Bot {
         }
         this.log(`[message-recalled] cancelled queued task chat=${chatId} msg=${messageId} session=${task.sessionKey}`);
     }
-    // ---- lifecycle ------------------------------------------------------------
     async run() {
         const tmpDir = path.join(os.tmpdir(), 'pikiloom');
         fs.mkdirSync(tmpDir, { recursive: true });
@@ -1215,8 +1146,6 @@ export class FeishuBot extends Bot {
                 ? this.allowedChatIds
                 : undefined,
         });
-        // Restore persisted known chats into the channel so the startup greeting and
-        // per-chat menu can address them — without polluting the allowlist.
         for (const id of loadKnownChatIds('feishu'))
             this.channel.knownChats.add(id);
         this.processRuntimeCleanup?.();

package/dist/channels/feishu/channel.js

@@ -1,13 +1,3 @@
-/**
- * Feishu channel — Feishu/Lark Open Platform transport using official SDK.
- *
- * Uses @larksuiteoapi/node-sdk for:
- *   - WSClient + EventDispatcher: WebSocket event receiving with auto-reconnect
- *   - Client.im: message send/edit/delete, image/file upload, resource download
- *   - Automatic tenant_access_token management
- *
- * All messages are sent as regular interactive cards (no CardKit streaming).
- */
 import * as lark from '@larksuiteoapi/node-sdk';
 import fs from 'node:fs';
 import path from 'node:path';
@@ -75,7 +65,6 @@ function requireMessageId(resp, action) {
     const msg = resp?.msg || resp?.message || 'no message_id returned';
     throw new Error(`${action} failed: code=${code ?? '?'} msg=${msg}`);
 }
-/** Treat "card content didn't change" responses as a successful no-op edit. */
 function isFeishuNotModifiedMessage(msg) {
     if (!msg)
         return false;
@@ -95,9 +84,6 @@ function buildPostContent(paragraphs, title = '') {
         },
     });
 }
-// ---------------------------------------------------------------------------
-// Card builder helper
-// ---------------------------------------------------------------------------
 function inferActionLayout(actions) {
     if (actions.length >= 3)
         return 'trisection';
@@ -147,8 +133,6 @@ function buildCardFromView(view) {
             element.layout = layout;
         actionElements.push(element);
     }
-    // Card JSON 2.0 supports tables in markdown but dropped `tag: action`.
-    // Use v2 for content-only cards; fall back to v1 when buttons are needed.
     if (actionElements.length) {
         const card = {
             config: { wide_screen_mode: true, update_multi: true },
@@ -175,9 +159,6 @@ function buildCardFromView(view) {
     }
     return card;
 }
-// ---------------------------------------------------------------------------
-// FeishuChannel
-// ---------------------------------------------------------------------------
 class FeishuChannel extends Channel {
     capabilities = {
         ...DEFAULT_CHANNEL_CAPABILITIES,
@@ -186,10 +167,6 @@ class FeishuChannel extends Channel {
         messageReactions: true,
         sendImage: true,
     };
-    /** Implementation of Channel.sendImage — uploads the buffer as an image
-     *  message. When a caption is supplied, falls back to a post with both an
-     *  img tag and a text line (Feishu's `msg_type:'image'` doesn't have a
-     *  native caption field). */
     async sendImage(chatId, bytes, opts) {
         const caption = opts.caption?.trim() || '';
         const replyTo = opts.replyTo ? String(opts.replyTo) : undefined;
@@ -217,11 +194,9 @@ class FeishuChannel extends Channel {
     eventDispatcher;
     running = false;
     messageChains = new Map();
-    /** Recently processed message IDs — guards against Feishu server retries. */
     _seenMessageIds = new Set();
     _seenMessageIdQueue = [];
     static SEEN_MESSAGE_CAP = 256;
-    /** Maps open_id → chat_id for resolving menu event context. */
     _openIdToChat = new Map();
     _hCommand = null;
     _hMessage = null;
@@ -229,7 +204,6 @@ class FeishuChannel extends Channel {
     _hRecall = null;
     _hError = null;
     knownChats = new Set();
-    /** Resolves when wsClient.start() settles (used by listen() to block). */
     _listenResolve = null;
     constructor(opts) {
         super();
@@ -238,7 +212,6 @@ class FeishuChannel extends Channel {
         this.domain = (opts.domain ?? 'https://open.feishu.cn').replace(/\/+$/, '');
         this.workdir = opts.workdir ?? process.cwd();
         this.allowedChatIds = opts.allowedChatIds ?? new Set();
-        // Resolve SDK domain enum or custom string
         const sdkDomain = this.domain.includes('larksuite.com')
             ? lark.Domain.Lark
             : this.domain === 'https://open.feishu.cn'
@@ -253,17 +226,12 @@ class FeishuChannel extends Channel {
         this.eventDispatcher = new lark.EventDispatcher({});
         this._registerEvents();
     }
-    // ---- Hook registration ---------------------------------------------------
     onCommand(h) { this._hCommand = h; }
     onMessage(h) { this._hMessage = h; }
     onCallback(h) { this._hCardAction = h; }
     onMessageRecalled(h) { this._hRecall = h; }
     onError(h) { this._hError = h; }
-    // ========================================================================
-    // Lifecycle
-    // ========================================================================
     async connect() {
-        // Get bot info via raw request (SDK doesn't have a dedicated bot info method)
         try {
             const resp = await this.client.request({
                 method: 'GET',
@@ -329,7 +297,6 @@ class FeishuChannel extends Channel {
         }
         if (!this.running || !this.wsClient)
             return;
-        // Block until disconnect() is called
         await new Promise(resolve => {
             this._listenResolve = resolve;
             if (!this.running)
@@ -348,9 +315,6 @@ class FeishuChannel extends Channel {
         this._listenResolve?.();
         this._listenResolve = null;
     }
-    // ========================================================================
-    // Event handling (via SDK EventDispatcher)
-    // ========================================================================
     _registerEvents() {
         this.eventDispatcher.register({
             'im.message.receive_v1': (data) => {
@@ -394,7 +358,6 @@ class FeishuChannel extends Channel {
         const msgType = msg.message_type;
         if (!chatId || !messageId)
             return;
-        // Dedup: Feishu server may retry events when the ack is slow
         if (this._seenMessageIds.has(messageId)) {
             this._debug(`[recv] dedup: message=${messageId} already processed, skipping`);
             return;
@@ -410,7 +373,6 @@ class FeishuChannel extends Channel {
         }
         this._trackChat(chatId);
         const sender = event.sender;
-        // Skip messages from the bot itself
         if (sender?.sender_type === 'app')
             return;
         const from = {
@@ -418,10 +380,8 @@ class FeishuChannel extends Channel {
             userId: sender?.sender_id?.user_id,
             name: '',
         };
-        // Track open_id → chat_id for menu event resolution
         if (from.openId)
             this._openIdToChat.set(from.openId, chatId);
-        // Group: require @mention
         if (chatType === 'group') {
             if (shouldLog('debug'))
                 this._debug(`[recv] group check mention: bot=${JSON.stringify(this.bot)}, mentions=${JSON.stringify(msg.mentions)}`);
@@ -432,7 +392,6 @@ class FeishuChannel extends Channel {
         }
         const parentId = typeof msg.parent_id === 'string' && msg.parent_id ? msg.parent_id : null;
         const ctx = this._makeCtx(chatId, messageId, from, chatType, event, parentId);
-        // Parse message content
         let text = '';
         const files = [];
         try {
@@ -474,11 +433,9 @@ class FeishuChannel extends Channel {
             return;
         }
         const trimmedText = text.trim();
-        // Queue dispatch per chat to preserve ordering
         const key = chatId;
         const prev = this.messageChains.get(key) || Promise.resolve();
         const current = prev.catch(() => { }).then(async () => {
-            // Command dispatch
             if (trimmedText.startsWith('/') && this._hCommand) {
                 const spaceIdx = trimmedText.indexOf(' ');
                 const cmd = (spaceIdx > 0 ? trimmedText.slice(1, spaceIdx) : trimmedText.slice(1)).toLowerCase();
@@ -486,7 +443,6 @@ class FeishuChannel extends Channel {
                 await this._hCommand(cmd, args, ctx);
                 return;
             }
-            // Message dispatch
             if (!this._hMessage)
                 return;
             if (!trimmedText && !files.length)
@@ -532,7 +488,6 @@ class FeishuChannel extends Channel {
         const openId = event.operator?.operator_id?.open_id;
         if (!eventKey || !openId || !this._hCommand)
             return;
-        // Try: event payload → cache → API resolve
         const chatId = this._openIdToChat.get(openId)
             ?? await this._resolveP2pChatId(openId);
         if (!chatId) {
@@ -559,10 +514,6 @@ class FeishuChannel extends Channel {
         this._debug(`[recv] message_recalled chat=${chatId} msg=${messageId}`);
         await this._hRecall(messageId, chatId, event);
     }
-    /**
-     * Resolve a p2p chat_id for a given open_id by sending a minimal message
-     * via open_id and extracting the chat_id from the API response.
-     */
     async _resolveP2pChatId(openId) {
         try {
             const resp = await this.client.im.message.create({
@@ -575,7 +526,6 @@ class FeishuChannel extends Channel {
             });
             const chatId = resp?.data?.chat_id ?? null;
             const msgId = resp?.data?.message_id;
-            // Clean up the placeholder message
             if (msgId) {
                 try {
                     await this.client.im.message.delete({ path: { message_id: msgId } });
@@ -594,9 +544,6 @@ class FeishuChannel extends Channel {
             return null;
         }
     }
-    // ========================================================================
-    // Outgoing primitives (Channel interface)
-    // ========================================================================
     async setMenu(commands) {
         this._debug(`[menu] ${commands.length} commands. Configure in Feishu Developer Console → Bot → Custom Menu:`);
         for (const c of commands) {
@@ -622,7 +569,6 @@ class FeishuChannel extends Channel {
     async send(chatId, text, opts = {}) {
         const rows = keyboardToRows(opts.keyboard);
         const view = { markdown: text.trim() || '(empty)', rows };
-        // Reply to a specific message if replyTo is set
         if (opts.replyTo) {
             return await this.replyCard(String(opts.replyTo), view);
         }
@@ -645,9 +591,6 @@ class FeishuChannel extends Channel {
             return;
         const card = buildCardFromView(view);
         this._logOutgoing('edit', `chat=${chatId} msg_id=${msgId} chars=${view.markdown.length} rows=${view.rows?.length || 0}`);
-        // The Lark SDK's response interceptor returns the JSON body for any HTTP 2xx, so
-        // Feishu application errors (`code != 0`) never throw — they look like success here.
-        // Inspect the response code ourselves so callers can fall back to a fresh send.
         let resp;
         try {
             resp = await this.client.im.message.patch({
@@ -692,7 +635,6 @@ class FeishuChannel extends Channel {
         catch { }
     }
     async sendTyping(_chatId) {
-        // Feishu has no typing indicator API — no-op
     }
     async setMessageReaction(_chatId, msgId, reactions) {
         const messageId = String(msgId || '').trim();
@@ -707,10 +649,6 @@ class FeishuChannel extends Channel {
             }).catch(() => { });
         }
     }
-    // ========================================================================
-    // Feishu-specific outgoing
-    // ========================================================================
-    /** Send a text message (not card). For simple notifications. */
     async sendText(chatId, text) {
         const resp = await this.client.im.message.create({
             params: { receive_id_type: 'chat_id' },
@@ -736,7 +674,6 @@ class FeishuChannel extends Channel {
             });
         return requireMessageId(resp, 'send post');
     }
-    /** Upload an image and return the image_key. */
     async uploadImage(imageBuffer) {
         this._logOutgoing('uploadImage', `bytes=${imageBuffer.byteLength}`);
         const resp = await this.client.im.image.create({
@@ -750,7 +687,6 @@ class FeishuChannel extends Channel {
             throw new Error('Image upload failed: no image_key returned');
         return imageKey;
     }
-    /** Upload a file and return the file_key. */
     async uploadFile(fileBuffer, fileName) {
         const ext = path.extname(fileName).toLowerCase().slice(1);
         const fileType = (['pdf', 'doc', 'xls', 'ppt'].includes(ext) ? ext : 'stream');
@@ -767,7 +703,6 @@ class FeishuChannel extends Channel {
             throw new Error('File upload failed: no file_key returned');
         return fileKey;
     }
-    /** Upload and send a local file. */
     async sendFile(chatId, filePath, opts = {}) {
         const stat = fs.statSync(filePath);
         if (stat.size > FILE_MAX_BYTES) {
@@ -807,9 +742,6 @@ class FeishuChannel extends Channel {
             : await this.client.im.message.create({ params: { receive_id_type: 'chat_id' }, data: { receive_id: String(chatId), msg_type: 'file', content: msgContent } });
         return requireMessageId(resp, 'send file');
     }
-    // ========================================================================
-    // Download resources from received messages
-    // ========================================================================
     async _downloadResource(messageId, fileKey, type, filename) {
         const resp = await this.client.im.messageResource.get({
             path: { message_id: messageId, file_key: fileKey },
@@ -820,7 +752,6 @@ class FeishuChannel extends Channel {
         const localPath = path.join(this.workdir, `_feishu_${name}`);
         fs.mkdirSync(this.workdir, { recursive: true });
         await resp.writeFile(localPath);
-        // Check downloaded file size
         const stat = fs.statSync(localPath);
         if (stat.size > FILE_MAX_BYTES) {
             fs.rmSync(localPath, { force: true });
@@ -828,9 +759,6 @@ class FeishuChannel extends Channel {
         }
         return localPath;
     }
-    // ========================================================================
-    // Internal helpers
-    // ========================================================================
     _makeCtx(chatId, messageId, from, chatType, raw, replyToMessageId) {
         return {
             chatId,
@@ -847,11 +775,6 @@ class FeishuChannel extends Channel {
     _isAllowed(chatId) {
         return this.allowedChatIds.size === 0 || this.allowedChatIds.has(chatId);
     }
-    /**
-     * Add a chat to the in-memory `knownChats` set and persist it to setting.json
-     * so a future cold start (e.g. crash-respawn) can still address it. The
-     * persistence call is fire-and-forget — disk errors must not break receive.
-     */
     _trackChat(chatId) {
         if (this.knownChats.has(chatId))
             return;
@@ -873,7 +796,6 @@ class FeishuChannel extends Channel {
     _cleanMention(text) {
         return text.replace(/@_user_\d+/g, '').trim();
     }
-    /** Extract plain text from a rich text (post) message content. */
     _extractPostText(content) {
         const post = content.zh_cn || content.en_us || content;
         const parts = [];

package/dist/channels/feishu/markdown.js

@@ -1,6 +1,3 @@
-/**
- * Feishu markdown adaptation helpers.
- */
 function isGfmTableRow(line) {
     return /^\|.+\|$/.test(line.trim());
 }
@@ -21,7 +18,6 @@ function adaptLine(line) {
     if (next.startsWith('**') && !next.endsWith('**'))
         next = `${next}**`;
     next = next.replace(/\[([^\]]+)\]\(([^)]+)\)/g, '$1 <$2>');
-    // Strip inline backtick code — Feishu renders them with heavy styling
     next = next.replace(/`([^`\n]+)`/g, '$1');
     return next;
 }
@@ -76,7 +72,6 @@ export function adaptMarkdownForFeishu(markdown) {
             i++;
             continue;
         }
-        // Pass GFM tables through — rendered natively with card schema 2.0
         if (i + 1 < lines.length && isGfmTableRow(lines[i]) && isGfmTableSeparator(lines[i + 1])) {
             while (i < lines.length && isGfmTableRow(lines[i])) {
                 out.push(lines[i]);