@yu_robotics/remote-cli-router 1.0.1 → 1.0.4

package/dist/feishu/FeishuLongConnHandler.js

@@ -49,8 +49,14 @@ class FeishuLongConnHandler {
     connectionHub = null;
     appId;
     appSecret;
-    // Feishu message size limit (4000 chars per message)
+    // Feishu message size limit (4000 chars per message) - DEPRECATED for Card 2.0
     FEISHU_MESSAGE_LIMIT = 4000;
+    // Feishu Card 2.0 limits (from official docs)
+    // Note: Using conservative limits - official says 200, we use 150 with proper recursive counting
+    // The 150 limit leaves a 50-node safety buffer while still being practical
+    CARD_ELEMENT_LIMIT = 150; // Conservative: 150 tagged nodes per card (official: 200)
+    CARD_DATA_SIZE_LIMIT = 3000000; // Max 3MB (3,000,000 chars) for data field
+    CARD_SIZE_BUFFER = 100000; // Safety buffer: use 2.9MB instead of 3MB
     // Track message chains: messageId -> [messageId1, messageId2, ...]
     messageChains = new Map();
     // Track the last processed text length for each message chain
@@ -157,6 +163,9 @@ class FeishuLongConnHandler {
             case '/unbind':
                 await this.handleUnbindCommand(openId, messageId);
                 break;
+            case '/device':
+                await this.handleDeviceCommand(openId, messageId, parts.slice(1));
+                break;
             case '/help':
                 await this.handleHelpCommand(openId, messageId);
                 break;
@@ -178,14 +187,20 @@ class FeishuLongConnHandler {
                 await this.replyToMessage(messageId, '❌ You have not bound a device yet, please send /bind <binding-code> to bind first');
                 return;
             }
+            // Get active device
+            const activeDevice = await this.bindingManager.getActiveDevice(openId);
+            if (!activeDevice) {
+                await this.replyToMessage(messageId, '❌ No active device found. Please use /device list to view your devices');
+                return;
+            }
             // Check if ConnectionHub is available
             if (!this.connectionHub) {
                 await this.replyToMessage(messageId, '❌ Server error: ConnectionHub not initialized');
                 return;
             }
             // Check if device is online
-            if (!this.connectionHub.isDeviceOnline(binding.deviceId)) {
-                await this.replyToMessage(messageId, `❌ Device ${binding.deviceName} is currently offline, please ensure the device is started and connected to the server`);
+            if (!this.connectionHub.isDeviceOnline(activeDevice.deviceId)) {
+                await this.replyToMessage(messageId, `❌ Device ${activeDevice.deviceName} is currently offline, please ensure the device is started and connected to the server`);
                 return;
             }
             console.log(`[FeishuHandler] Passing through slash command: ${command}`);
@@ -195,10 +210,10 @@ class FeishuLongConnHandler {
             const feishuMessageId = await this.sendStreamingStart(openId, `🤔 Executing ${command}...`);
             console.log(`[FeishuHandler] Created card ${feishuMessageId} for slash command ${commandMessageId}`);
             if (this.onStartStreaming) {
-                this.onStartStreaming(commandMessageId, openId, feishuMessageId, binding.deviceId);
+                this.onStartStreaming(commandMessageId, openId, feishuMessageId, activeDevice.deviceId);
             }
             // Send slash command to device - the client will execute it locally
-            const success = await this.connectionHub.sendToDevice(binding.deviceId, {
+            const success = await this.connectionHub.sendToDevice(activeDevice.deviceId, {
                 type: types_1.MessageType.COMMAND,
                 messageId: commandMessageId,
                 timestamp: Date.now(),
@@ -226,10 +241,21 @@ class FeishuLongConnHandler {
                 await this.replyToMessage(messageId, '❌ Binding code is invalid or expired, please generate a new one');
                 return;
             }
+            // Check if device is already bound
+            const existingDevices = await this.bindingManager.getUserDevices(openId);
+            const alreadyBound = existingDevices.some(d => d.deviceId === bindingCode.deviceId);
+            if (alreadyBound) {
+                await this.replyToMessage(messageId, '❌ This device is already bound to your account');
+                return;
+            }
             // Bind user
             const deviceName = 'Device'; // Will be updated by client later
             await this.bindingManager.bindUser(openId, bindingCode.deviceId, deviceName);
-            await this.replyToMessage(messageId, `✅ Binding successful!\n\nDevice ID: ${bindingCode.deviceId}\n\nYou can now control your device through Feishu.`);
+            const isFirstDevice = existingDevices.length === 0;
+            const statusNote = isFirstDevice
+                ? '\n\n📱 This is your first device and will be set as active.'
+                : '\n\n📱 Use /device switch to activate this device.';
+            await this.replyToMessage(messageId, `✅ Binding successful!\n\nDevice ID: ${bindingCode.deviceId}\n\nYou can now control your device through Feishu.${statusNote}\n\nUse /device list to view all your devices.`);
         }
         catch (error) {
             console.error('Error binding user:', error);
@@ -246,9 +272,24 @@ class FeishuLongConnHandler {
                 await this.replyToMessage(messageId, '❌ You have not bound a device yet, please send /bind <binding-code> to bind first');
                 return;
             }
-            const isOnline = this.connectionHub?.isDeviceOnline(binding.deviceId) || false;
-            const status = isOnline ? '🟢 Online' : '🔴 Offline';
-            const message = `📊 Device Status\n\nDevice Name: ${binding.deviceName}\nDevice ID: ${binding.deviceId}\nStatus: ${status}\nBinding Time: ${new Date(binding.boundAt).toLocaleString('en-US')}`;
+            const devices = binding.devices;
+            if (devices.length === 0) {
+                await this.replyToMessage(messageId, '❌ No devices found');
+                return;
+            }
+            // Build status message
+            let message = `📊 Device Status\n\n`;
+            for (const device of devices) {
+                const isOnline = this.connectionHub?.isDeviceOnline(device.deviceId) || false;
+                const status = isOnline ? '🟢 Online' : '🔴 Offline';
+                const activeIndicator = device.isActive ? ' ⭐ ACTIVE' : '';
+                message += `\n**${device.deviceName}**${activeIndicator}\n`;
+                message += `Device ID: ${device.deviceId}\n`;
+                message += `Status: ${status}\n`;
+                message += `Bound: ${new Date(device.boundAt).toLocaleString('en-US')}\n`;
+                message += `Last Active: ${new Date(device.lastActiveAt).toLocaleString('en-US')}\n`;
+            }
+            message += `\n\nTotal Devices: ${devices.length}`;
             await this.replyToMessage(messageId, message);
         }
         catch (error) {
@@ -258,6 +299,8 @@ class FeishuLongConnHandler {
     }
     /**
      * Handle unbind command
+     * Usage: /unbind or /unbind all (unbind all devices)
+     * For unbinding specific device, use /device unbind <device-id>
      */
     async handleUnbindCommand(openId, messageId) {
         try {
@@ -266,14 +309,188 @@ class FeishuLongConnHandler {
                 await this.replyToMessage(messageId, '❌ You have not bound a device yet');
                 return;
             }
+            const deviceCount = binding.devices.length;
+            // Unbind all devices
             await this.bindingManager.unbindUser(openId);
-            await this.replyToMessage(messageId, `✅ Device ${binding.deviceName} has been unbound`);
+            await this.replyToMessage(messageId, `✅ Successfully unbound ${deviceCount} device(s)`);
         }
         catch (error) {
             console.error('Error handling unbind command:', error);
             await this.replyToMessage(messageId, '❌ Unbinding failed, please try again later');
         }
     }
+    /**
+     * Handle device command
+     * Usage:
+     *   /device - List all bound devices (same as /device list)
+     *   /device list - List all bound devices
+     *   /device switch <device-id|index> - Switch active device (by ID or index number)
+     *   /device <device-id|index> - Quick switch to device (by ID or index number)
+     *   /device unbind <device-id|index> - Unbind a specific device (by ID or index number)
+     */
+    async handleDeviceCommand(openId, messageId, args) {
+        try {
+            const binding = await this.bindingManager.getUserBinding(openId);
+            if (!binding) {
+                await this.replyToMessage(messageId, '❌ You have not bound a device yet, please send /bind <binding-code> to bind first');
+                return;
+            }
+            // No args - show device list
+            if (args.length === 0) {
+                await this.handleDeviceList(openId, messageId, binding);
+                return;
+            }
+            const subcommand = args[0]?.toLowerCase();
+            switch (subcommand) {
+                case 'list':
+                    await this.handleDeviceList(openId, messageId, binding);
+                    break;
+                case 'switch':
+                    if (args.length < 2) {
+                        await this.replyToMessage(messageId, '❌ Please provide device ID or index, format: /device switch <device-id-or-index>');
+                        return;
+                    }
+                    await this.handleDeviceSwitch(openId, messageId, args[1], binding);
+                    break;
+                case 'unbind':
+                    if (args.length < 2) {
+                        await this.replyToMessage(messageId, '❌ Please provide device ID or index, format: /device unbind <device-id-or-index>');
+                        return;
+                    }
+                    await this.handleDeviceUnbind(openId, messageId, args[1], binding);
+                    break;
+                default:
+                    // If the argument looks like a number (index) or device ID, treat it as a quick switch
+                    await this.handleDeviceSwitch(openId, messageId, args[0], binding);
+            }
+        }
+        catch (error) {
+            console.error('Error handling device command:', error);
+            await this.replyToMessage(messageId, '❌ Error processing device command, please try again later');
+        }
+    }
+    /**
+     * Handle /device list
+     */
+    async handleDeviceList(openId, messageId, binding) {
+        const devices = binding.devices;
+        if (devices.length === 0) {
+            await this.replyToMessage(messageId, '❌ No devices found');
+            return;
+        }
+        let message = `📱 Your Devices (${devices.length})\n\n`;
+        for (let i = 0; i < devices.length; i++) {
+            const device = devices[i];
+            const isOnline = this.connectionHub?.isDeviceOnline(device.deviceId) || false;
+            const status = isOnline ? '🟢 Online' : '🔴 Offline';
+            const activeIndicator = device.isActive ? ' ⭐ ACTIVE' : '';
+            message += `${i + 1}. **${device.deviceName}**${activeIndicator}\n`;
+            message += `   ID: \`${device.deviceId}\`\n`;
+            message += `   Status: ${status}\n`;
+            message += `   Bound: ${new Date(device.boundAt).toLocaleString('en-US')}\n\n`;
+        }
+        message += `\n💡 Quick switch: /device <index> or /device <device-id>`;
+        message += `\n   Example: /device 1 or /device switch 1`;
+        await this.replyToMessage(messageId, message);
+    }
+    /**
+     * Resolve device identifier (ID or index) to device ID
+     * @returns Resolved device ID or null if not found
+     */
+    resolveDeviceIdentifier(identifier, binding) {
+        // Try to parse as index (1-based)
+        const index = parseInt(identifier, 10);
+        if (!isNaN(index) && index > 0 && index <= binding.devices.length) {
+            return binding.devices[index - 1].deviceId;
+        }
+        // Treat as device ID - check if it exists
+        const device = binding.devices.find((d) => d.deviceId === identifier);
+        if (device) {
+            return device.deviceId;
+        }
+        return null;
+    }
+    /**
+     * Handle /device switch <device-id-or-index>
+     * Also handles quick switch: /device <device-id-or-index>
+     */
+    async handleDeviceSwitch(openId, messageId, identifier, binding) {
+        try {
+            // Get binding if not provided
+            const userBinding = binding || await this.bindingManager.getUserBinding(openId);
+            if (!userBinding) {
+                await this.replyToMessage(messageId, '❌ You have not bound a device yet');
+                return;
+            }
+            // Resolve identifier to device ID
+            const deviceId = this.resolveDeviceIdentifier(identifier, userBinding);
+            if (!deviceId) {
+                await this.replyToMessage(messageId, `❌ Device "${identifier}" not found. Use /device to see available devices and their indices.`);
+                return;
+            }
+            const result = await this.bindingManager.switchActiveDevice(openId, deviceId);
+            if (!result) {
+                await this.replyToMessage(messageId, '❌ Device switch failed');
+                return;
+            }
+            const device = await this.bindingManager.getActiveDevice(openId);
+            if (!device) {
+                await this.replyToMessage(messageId, '❌ Failed to get active device after switch');
+                return;
+            }
+            await this.replyToMessage(messageId, `✅ Switched to device: **${device.deviceName}**\n\nDevice ID: \`${device.deviceId}\``);
+        }
+        catch (error) {
+            console.error('Error switching device:', error);
+            await this.replyToMessage(messageId, '❌ Failed to switch device, please try again later');
+        }
+    }
+    /**
+     * Handle /device unbind <device-id-or-index>
+     */
+    async handleDeviceUnbind(openId, messageId, identifier, binding) {
+        try {
+            // Get binding if not provided
+            const userBinding = binding || await this.bindingManager.getUserBinding(openId);
+            if (!userBinding) {
+                await this.replyToMessage(messageId, '❌ You have not bound a device yet');
+                return;
+            }
+            // Resolve identifier to device ID
+            const deviceId = this.resolveDeviceIdentifier(identifier, userBinding);
+            if (!deviceId) {
+                await this.replyToMessage(messageId, `❌ Device "${identifier}" not found. Use /device to see available devices and their indices.`);
+                return;
+            }
+            const device = userBinding.devices.find((d) => d.deviceId === deviceId);
+            if (!device) {
+                await this.replyToMessage(messageId, '❌ Device not found');
+                return;
+            }
+            const wasActive = device.isActive;
+            const result = await this.bindingManager.unbindDevice(openId, deviceId);
+            if (!result) {
+                await this.replyToMessage(messageId, '❌ Failed to unbind device');
+                return;
+            }
+            let responseMessage = `✅ Device **${device.deviceName}** has been unbound`;
+            // If we unbound the active device, inform about the new active device
+            if (wasActive) {
+                const newActiveDevice = await this.bindingManager.getActiveDevice(openId);
+                if (newActiveDevice) {
+                    responseMessage += `\n\n📱 New active device: **${newActiveDevice.deviceName}**`;
+                }
+                else {
+                    responseMessage += `\n\n⚠️ No devices remaining. Use /bind to add a new device.`;
+                }
+            }
+            await this.replyToMessage(messageId, responseMessage);
+        }
+        catch (error) {
+            console.error('Error unbinding device:', error);
+            await this.replyToMessage(messageId, '❌ Failed to unbind device, please try again later');
+        }
+    }
     /**
      * Handle help command
      */
@@ -281,14 +498,30 @@ class FeishuLongConnHandler {
         const helpMessage = `📖 Feishu Remote Control Help
 
 Available commands:
-/bind <binding-code> - Bind your device
-/status - View device status
-/unbind - Unbind device
+/bind <binding-code> - Bind a new device
+/status - View all device statuses
+/unbind - Unbind all devices
+/device - List all your devices
+/device list - List all your devices
+/device switch <device-id-or-index> - Switch active device
+/device <device-id-or-index> - Quick switch to device
+/device unbind <device-id-or-index> - Unbind a specific device
 /help - Show help information
 
-Regular messages will be sent directly to your device for execution.
+Regular messages will be sent to your active device for execution.
+
+Multi-device support:
+• You can bind multiple devices to your account
+• Only one device is active at a time
+• Commands are sent to the active device
+• Use /device or /device list to see your devices
+• Switch by index: /device 1 or /device switch 2
+• Switch by ID: /device <device-id>
 
 Examples:
+• "/device" - List all devices
+• "/device 1" - Switch to device #1
+• "/device switch 2" - Switch to device #2
 • "List files in current directory"
 • "Run tests"
 • "View recent git commits"`;
@@ -305,14 +538,20 @@ Examples:
                 await this.replyToMessage(messageId, '❌ You have not bound a device yet, please send /bind <binding-code> to bind first');
                 return;
             }
+            // Get active device
+            const activeDevice = await this.bindingManager.getActiveDevice(openId);
+            if (!activeDevice) {
+                await this.replyToMessage(messageId, '❌ No active device found. Please use /device list to view your devices');
+                return;
+            }
             // Check if ConnectionHub is available
             if (!this.connectionHub) {
                 await this.replyToMessage(messageId, '❌ Server error: ConnectionHub not initialized');
                 return;
             }
             // Check if device is online
-            if (!this.connectionHub.isDeviceOnline(binding.deviceId)) {
-                await this.replyToMessage(messageId, `❌ Device ${binding.deviceName} is currently offline, please ensure the device is started and connected to the server`);
+            if (!this.connectionHub.isDeviceOnline(activeDevice.deviceId)) {
+                await this.replyToMessage(messageId, `❌ Device ${activeDevice.deviceName} is currently offline, please ensure the device is started and connected to the server`);
                 return;
             }
             // Generate message ID first
@@ -323,10 +562,10 @@ Examples:
             const feishuMessageId = await this.sendStreamingStart(openId, '🤔 Processing...');
             console.log(`[FeishuHandler] Created card ${feishuMessageId} for command ${commandMessageId}`);
             if (this.onStartStreaming) {
-                this.onStartStreaming(commandMessageId, openId, feishuMessageId, binding.deviceId);
+                this.onStartStreaming(commandMessageId, openId, feishuMessageId, activeDevice.deviceId);
             }
             // Send command to device
-            const success = await this.connectionHub.sendToDevice(binding.deviceId, {
+            const success = await this.connectionHub.sendToDevice(activeDevice.deviceId, {
                 type: types_1.MessageType.COMMAND,
                 messageId: commandMessageId,
                 timestamp: Date.now(),
@@ -474,6 +713,192 @@ Examples:
         }
         return chunks;
     }
+    /**
+     * Split Card 2.0 elements into chunks based on Feishu limits
+     *
+     * Feishu Card 2.0 has two main limits:
+     * 1. Element count: Max 200 tagged nodes per card (we use 150 for safety)
+     * 2. Data size: Max 3,000,000 characters in the data field (JSON.stringify result)
+     *
+     * This function splits elements array into chunks that satisfy both limits,
+     * and adds continuation indicators between chunks for better UX.
+     *
+     * Note: Element counting uses recursive tag counting - all nodes with 'tag' property
+     * are counted, including nested components, text elements, and container children.
+     *
+     * @param elements Array of Feishu Card 2.0 elements
+     * @returns Array of element chunks, each satisfying Feishu's limits
+     */
+    splitElementsIntoChunks(elements) {
+        // If empty or very small, return as-is
+        if (elements.length === 0) {
+            return [elements];
+        }
+        // Check if we need to split at all
+        const needsSplitting = this.checkIfElementsNeedSplitting(elements);
+        console.log(`[FeishuHandler] Elements check: count=${elements.length}, needsSplitting=${needsSplitting}`);
+        if (!needsSplitting) {
+            return [elements];
+        }
+        const chunks = [];
+        let currentChunk = [];
+        let currentChunkSize = 0;
+        let currentChunkTaggedNodes = 0;
+        // Reserve elements for continuation indicators (they add ~2 elements and ~200 bytes)
+        const continuationIndicatorSize = 200; // Approximate size of indicator element
+        const continuationIndicatorCount = 2; // Maximum 2 indicators per chunk (start + end)
+        for (let i = 0; i < elements.length; i++) {
+            const element = elements[i];
+            const elementSize = JSON.stringify(element).length;
+            const elementTaggedNodes = this.countTaggedNodes(element);
+            // Check if adding this element would exceed limits
+            // Reserve space for continuation indicators
+            const wouldExceedElementLimit = currentChunkTaggedNodes + elementTaggedNodes > (this.CARD_ELEMENT_LIMIT - continuationIndicatorCount);
+            const wouldExceedSizeLimit = currentChunkSize + elementSize + continuationIndicatorSize >
+                (this.CARD_DATA_SIZE_LIMIT - this.CARD_SIZE_BUFFER);
+            if (currentChunk.length > 0 && (wouldExceedElementLimit || wouldExceedSizeLimit)) {
+                // Start a new chunk
+                chunks.push(currentChunk);
+                console.log(`[FeishuHandler] Chunk finished: ${currentChunk.length} top-level elements, ${currentChunkTaggedNodes} tagged nodes, ${currentChunkSize} bytes`);
+                currentChunk = [];
+                currentChunkSize = 0;
+                currentChunkTaggedNodes = 0;
+            }
+            currentChunk.push(element);
+            currentChunkSize += elementSize;
+            currentChunkTaggedNodes += elementTaggedNodes;
+        }
+        // Add the last chunk if not empty
+        if (currentChunk.length > 0) {
+            chunks.push(currentChunk);
+            console.log(`[FeishuHandler] Chunk finished: ${currentChunk.length} top-level elements, ${currentChunkTaggedNodes} tagged nodes, ${currentChunkSize} bytes`);
+        }
+        console.log(`[FeishuHandler] Split ${elements.length} top-level elements into ${chunks.length} chunk(s)`);
+        chunks.forEach((chunk, i) => {
+            const chunkSize = JSON.stringify({ schema: '2.0', body: { elements: chunk } }).length;
+            const chunkTaggedNodes = chunk.reduce((sum, el) => sum + this.countTaggedNodes(el), 0);
+            console.log(`[FeishuHandler]   Chunk ${i + 1}: ${chunk.length} top-level, ${chunkTaggedNodes} tagged nodes, ${chunkSize} bytes`);
+        });
+        // Add continuation indicators between chunks
+        if (chunks.length > 1) {
+            for (let i = 0; i < chunks.length; i++) {
+                const isFirst = i === 0;
+                const isLast = i === chunks.length - 1;
+                if (!isLast) {
+                    // Add "continued in next message" indicator at the end
+                    chunks[i].push({
+                        tag: 'markdown',
+                        content: '\n\n_➡️ Continued in next message..._',
+                    });
+                }
+                if (!isFirst) {
+                    // Add "continued from previous message" indicator at the start
+                    chunks[i].unshift({
+                        tag: 'markdown',
+                        content: '_⬅️ Continued from previous message..._\n\n',
+                    });
+                }
+            }
+        }
+        return chunks;
+    }
+    /**
+     * Recursively count all nodes with 'tag' property in the element tree
+     * According to Feishu docs, all nodes with 'tag' property count towards the 200 limit
+     *
+     * @param obj The object or array to count tags in
+     * @returns Total count of nodes with 'tag' property
+     */
+    countTaggedNodes(obj) {
+        if (!obj || typeof obj !== 'object') {
+            return 0;
+        }
+        let count = 0;
+        // If this object has a 'tag' property, count it
+        if (obj.tag) {
+            count = 1;
+        }
+        // Recursively count in all properties
+        for (const key in obj) {
+            if (obj.hasOwnProperty(key)) {
+                const value = obj[key];
+                if (Array.isArray(value)) {
+                    // Recursively count in array elements
+                    for (const item of value) {
+                        count += this.countTaggedNodes(item);
+                    }
+                }
+                else if (typeof value === 'object' && value !== null) {
+                    // Recursively count in nested objects
+                    count += this.countTaggedNodes(value);
+                }
+            }
+        }
+        return count;
+    }
+    /**
+     * Check if elements array needs to be split based on Feishu limits
+     * @param elements Array of elements to check
+     * @returns true if splitting is needed
+     */
+    checkIfElementsNeedSplitting(elements) {
+        // Safety check: ensure elements is an array
+        if (!Array.isArray(elements)) {
+            console.error('[FeishuHandler] checkIfElementsNeedSplitting received non-array:', typeof elements);
+            return false;
+        }
+        // Check element count limit - MUST count ALL nodes with 'tag' property recursively
+        const totalTaggedNodes = elements.reduce((sum, element) => sum + this.countTaggedNodes(element), 0);
+        console.log(`[FeishuHandler] Element count check: top-level=${elements.length}, total tagged nodes=${totalTaggedNodes}, limit=${this.CARD_ELEMENT_LIMIT}`);
+        if (totalTaggedNodes > this.CARD_ELEMENT_LIMIT) {
+            console.log(`[FeishuHandler] Total tagged nodes (${totalTaggedNodes}) exceeds limit (${this.CARD_ELEMENT_LIMIT})`);
+            return true;
+        }
+        // Check data size limit
+        const cardData = {
+            schema: '2.0',
+            body: { elements },
+        };
+        const jsonSize = JSON.stringify(cardData).length;
+        const sizeLimit = this.CARD_DATA_SIZE_LIMIT - this.CARD_SIZE_BUFFER;
+        console.log(`[FeishuHandler] Card data size: ${jsonSize} bytes, limit: ${sizeLimit} bytes`);
+        // Use buffer for safety (2.9MB instead of 3MB)
+        if (jsonSize > sizeLimit) {
+            console.log(`[FeishuHandler] Data size (${jsonSize}) exceeds limit (${sizeLimit})`);
+            return true;
+        }
+        return false;
+    }
+    /**
+     * Create a continuation card message
+     * Used when elements need to be split across multiple cards
+     *
+     * @param openId User's open_id to send the message to
+     * @param elements Array of Feishu Card 2.0 elements
+     * @returns The new message ID, or null on error
+     */
+    async createContinuationCard(openId, elements) {
+        try {
+            const result = await this.client.im.message.create({
+                params: { receive_id_type: 'open_id' },
+                data: {
+                    receive_id: openId,
+                    msg_type: 'interactive',
+                    content: JSON.stringify({
+                        schema: '2.0',
+                        body: {
+                            elements,
+                        },
+                    }),
+                },
+            });
+            return result.data?.message_id || null;
+        }
+        catch (error) {
+            console.error('Failed to create continuation card:', error?.message || error);
+            return null;
+        }
+    }
     /**
      * Update streaming message content
      * Automatically creates new messages if content exceeds Feishu's size limit
@@ -498,19 +923,90 @@ Examples:
                 chain = [messageId]; // First message in chain
                 this.messageChains.set(messageId, chain);
             }
-            // For now, just update the single message with all elements
-            // TODO: In the future, implement message chaining if elements become too large
+            // Split elements into chunks based on Feishu Card 2.0 limits
+            const chunks = this.splitElementsIntoChunks(elements);
+            console.log(`[FeishuHandler] Need ${chunks.length} card(s), currently have ${chain.length} card(s)`);
+            // Update the first message with the first chunk
             await this.client.im.message.patch({
-                path: { message_id: messageId },
+                path: { message_id: chain[0] },
                 data: {
                     content: JSON.stringify({
                         schema: '2.0',
                         body: {
-                            elements,
+                            elements: chunks[0],
                         },
                     }),
                 },
             });
+            // Handle continuation chunks if needed
+            if (chunks.length > 1 && openId) {
+                const existingContinuationCards = chain.slice(1);
+                const neededContinuationCards = chunks.length - 1;
+                // Update existing continuation cards
+                for (let i = 0; i < Math.min(existingContinuationCards.length, neededContinuationCards); i++) {
+                    const cardMessageId = existingContinuationCards[i];
+                    const chunkIndex = i + 1;
+                    console.log(`[FeishuHandler] Updating existing continuation card ${i + 1}/${neededContinuationCards}`);
+                    await this.client.im.message.patch({
+                        path: { message_id: cardMessageId },
+                        data: {
+                            content: JSON.stringify({
+                                schema: '2.0',
+                                body: {
+                                    elements: chunks[chunkIndex],
+                                },
+                            }),
+                        },
+                    });
+                }
+                // Create new continuation cards if needed
+                if (neededContinuationCards > existingContinuationCards.length) {
+                    console.log(`[FeishuHandler] Creating ${neededContinuationCards - existingContinuationCards.length} new continuation card(s)`);
+                    for (let i = existingContinuationCards.length; i < neededContinuationCards; i++) {
+                        const chunkIndex = i + 1;
+                        const newMessageId = await this.createContinuationCard(openId, chunks[chunkIndex]);
+                        if (newMessageId) {
+                            chain.push(newMessageId);
+                        }
+                    }
+                }
+                // Delete excess continuation cards if we need fewer cards now
+                if (existingContinuationCards.length > neededContinuationCards) {
+                    const cardsToDelete = existingContinuationCards.slice(neededContinuationCards);
+                    console.log(`[FeishuHandler] Deleting ${cardsToDelete.length} excess continuation card(s)`);
+                    for (const cardMessageId of cardsToDelete) {
+                        try {
+                            await this.client.im.message.delete({
+                                path: { message_id: cardMessageId },
+                            });
+                        }
+                        catch (error) {
+                            console.error(`Failed to delete continuation card ${cardMessageId}:`, error?.message || error);
+                        }
+                    }
+                    // Update chain to remove deleted cards
+                    chain.length = chunks.length;
+                }
+                this.messageChains.set(messageId, chain);
+            }
+            else if (chunks.length === 1 && chain.length > 1) {
+                // No longer need continuation cards, delete all of them
+                const cardsToDelete = chain.slice(1);
+                console.log(`[FeishuHandler] No longer need continuation cards, deleting ${cardsToDelete.length} card(s)`);
+                for (const cardMessageId of cardsToDelete) {
+                    try {
+                        await this.client.im.message.delete({
+                            path: { message_id: cardMessageId },
+                        });
+                    }
+                    catch (error) {
+                        console.error(`Failed to delete continuation card ${cardMessageId}:`, error?.message || error);
+                    }
+                }
+                // Update chain to only keep the first message
+                chain.length = 1;
+                this.messageChains.set(messageId, chain);
+            }
             return true;
         }
         catch (error) {
@@ -527,10 +1023,10 @@ Examples:
      * @param sessionAbbr Optional session abbreviation
      * @param openId User's open_id for creating continuation messages
      */
-    async finalizeStreamingMessage(messageId, elements, sessionAbbr, openId) {
-        return this.withMessageLock(messageId, () => this._finalizeStreamingMessage(messageId, elements, sessionAbbr, openId));
+    async finalizeStreamingMessage(messageId, elements, sessionAbbr, openId, cwd) {
+        return this.withMessageLock(messageId, () => this._finalizeStreamingMessage(messageId, elements, sessionAbbr, openId, cwd));
     }
-    async _finalizeStreamingMessage(messageId, elements, sessionAbbr, openId) {
+    async _finalizeStreamingMessage(messageId, elements, sessionAbbr, openId, cwd) {
         try {
             // Get or initialize message chain
             let chain = this.messageChains.get(messageId);
@@ -538,11 +1034,16 @@ Examples:
                 chain = [messageId];
                 this.messageChains.set(messageId, chain);
             }
-            // Build note content with session abbreviation if available
+            // Build note content with session abbreviation and working directory if available
             let noteContent = '✅ Completed';
             if (sessionAbbr) {
                 noteContent += ` · Session: ${sessionAbbr}`;
             }
+            if (cwd) {
+                // Format cwd to show ~ for home directory
+                const formattedCwd = cwd.replace(process.env.HOME || '/Users', '~');
+                noteContent += `\n📂 **Working Directory:** \`${formattedCwd}\``;
+            }
             // Add completion note element as markdown
             const finalElements = [
                 ...elements,
@@ -551,19 +1052,88 @@ Examples:
                     content: noteContent,
                 },
             ];
-            // Update the message with final content
-            // TODO: In the future, implement message chaining if elements become too large
+            // Split elements into chunks based on Feishu Card 2.0 limits
+            const chunks = this.splitElementsIntoChunks(finalElements);
+            console.log(`[FeishuHandler] Finalizing: need ${chunks.length} card(s), currently have ${chain.length} card(s)`);
+            // Update the first message with the first chunk
             await this.client.im.message.patch({
-                path: { message_id: messageId },
+                path: { message_id: chain[0] },
                 data: {
                     content: JSON.stringify({
                         schema: '2.0',
                         body: {
-                            elements: finalElements,
+                            elements: chunks[0],
                         },
                     }),
                 },
             });
+            // Handle continuation chunks if needed
+            if (chunks.length > 1 && openId) {
+                const existingContinuationCards = chain.slice(1);
+                const neededContinuationCards = chunks.length - 1;
+                // Update existing continuation cards
+                for (let i = 0; i < Math.min(existingContinuationCards.length, neededContinuationCards); i++) {
+                    const cardMessageId = existingContinuationCards[i];
+                    const chunkIndex = i + 1;
+                    console.log(`[FeishuHandler] Finalize: Updating existing continuation card ${i + 1}/${neededContinuationCards}`);
+                    await this.client.im.message.patch({
+                        path: { message_id: cardMessageId },
+                        data: {
+                            content: JSON.stringify({
+                                schema: '2.0',
+                                body: {
+                                    elements: chunks[chunkIndex],
+                                },
+                            }),
+                        },
+                    });
+                }
+                // Create new continuation cards if needed
+                if (neededContinuationCards > existingContinuationCards.length) {
+                    console.log(`[FeishuHandler] Finalize: Creating ${neededContinuationCards - existingContinuationCards.length} new continuation card(s)`);
+                    for (let i = existingContinuationCards.length; i < neededContinuationCards; i++) {
+                        const chunkIndex = i + 1;
+                        const newMessageId = await this.createContinuationCard(openId, chunks[chunkIndex]);
+                        if (newMessageId) {
+                            chain.push(newMessageId);
+                        }
+                    }
+                }
+                // Delete excess continuation cards if we need fewer cards now
+                if (existingContinuationCards.length > neededContinuationCards) {
+                    const cardsToDelete = existingContinuationCards.slice(neededContinuationCards);
+                    console.log(`[FeishuHandler] Finalize: Deleting ${cardsToDelete.length} excess continuation card(s)`);
+                    for (const cardMessageId of cardsToDelete) {
+                        try {
+                            await this.client.im.message.delete({
+                                path: { message_id: cardMessageId },
+                            });
+                        }
+                        catch (error) {
+                            console.error(`Failed to delete continuation card ${cardMessageId}:`, error?.message || error);
+                        }
+                    }
+                    // Update chain to remove deleted cards
+                    chain.length = chunks.length;
+                }
+            }
+            else if (chunks.length === 1 && chain.length > 1) {
+                // No longer need continuation cards, delete all of them
+                const cardsToDelete = chain.slice(1);
+                console.log(`[FeishuHandler] Finalize: No longer need continuation cards, deleting ${cardsToDelete.length} card(s)`);
+                for (const cardMessageId of cardsToDelete) {
+                    try {
+                        await this.client.im.message.delete({
+                            path: { message_id: cardMessageId },
+                        });
+                    }
+                    catch (error) {
+                        console.error(`Failed to delete continuation card ${cardMessageId}:`, error?.message || error);
+                    }
+                }
+                // Update chain to only keep the first message
+                chain.length = 1;
+            }
             // Clean up message chain tracking
             this.messageChains.delete(messageId);
             this.lastProcessedLengths.delete(messageId);