nodejs-insta-private-api-mqtt 1.3.39 → 1.3.40

package/dist/realtime/commands/enhanced.direct.commands.js

@@ -4,769 +4,663 @@ exports.EnhancedDirectCommands = void 0;
 const shared_1 = require("../../shared");
 const uuid_1 = require("uuid");
 const constants_1 = require("../../constants");
+const thrift_1 = require("../../thrift");
 
 /**
  * Enhanced Direct Commands - sends MQTT directly with proper payload formatting
+ * Fixed to match instagram_mqtt library format for proper functionality
  */
 class EnhancedDirectCommands {
     constructor(client) {
         this.realtimeClient = client;
         this.enhancedDebug = (0, shared_1.debugChannel)('realtime', 'enhanced-commands');
+        
+        // Foreground state config for Thrift encoding (matching instagram_mqtt)
+        this.foregroundStateConfig = [
+            thrift_1.ThriftDescriptors.boolean('inForegroundApp', 1),
+            thrift_1.ThriftDescriptors.boolean('inForegroundDevice', 2),
+            thrift_1.ThriftDescriptors.int32('keepAliveTimeout', 3),
+            thrift_1.ThriftDescriptors.listOfBinary('subscribeTopics', 4),
+            thrift_1.ThriftDescriptors.listOfBinary('subscribeGenericTopics', 5),
+            thrift_1.ThriftDescriptors.listOfBinary('unsubscribeTopics', 6),
+            thrift_1.ThriftDescriptors.listOfBinary('unsubscribeGenericTopics', 7),
+            thrift_1.ThriftDescriptors.int64('requestId', 8),
+        ];
     }
 
     /**
-     * Send text via MQTT with proper payload format
+     * Get MQTT client from realtime client
      */
-    async sendTextViaRealtime(threadId, text) {
-        this.enhancedDebug(`Sending text to ${threadId}: "${text}"`);
-        
-        try {
-            const mqtt = this.realtimeClient.mqtt || this.realtimeClient._mqtt;
-            if (!mqtt || typeof mqtt.publish !== 'function') {
-                throw new Error('MQTT client not available');
+    getMqtt() {
+        // Try several known property names for mqtt client (some libs/wrappers expose differently)
+        const candidates = [
+            'mqtt',
+            '_mqtt',
+            'client',
+            '_client',
+            'connection',
+            'mqttClient',
+        ];
+        let mqtt = null;
+        for (const key of candidates) {
+            // eslint-disable-next-line no-prototype-builtins
+            if (this.realtimeClient && Object.prototype.hasOwnProperty.call(this.realtimeClient, key) && this.realtimeClient[key]) {
+                mqtt = this.realtimeClient[key];
+                break;
             }
-            
-            // Build proper command payload
-            const clientContext = (0, uuid_1.v4)();
-            const command = {
-                action: 'send_item',
-                thread_id: threadId,
-                item_type: 'text',
-                text: text,
-                timestamp: Date.now(),
-                client_context: clientContext,
-            };
-            
-            // Compress JSON payload
-            const json = JSON.stringify(command);
-            const { compressDeflate } = shared_1;
-            const payload = await compressDeflate(json);
-            
-            // Send to MQTT
-            this.enhancedDebug(`Publishing to MQTT topic ${constants_1.Topics.SEND_MESSAGE.id}`);
-            const result = await mqtt.publish({
-                topic: constants_1.Topics.SEND_MESSAGE.id,
-                qosLevel: 1,
-                payload: payload,
-            });
-            
-            this.enhancedDebug(`✅ Message sent via MQTT!`);
-            return result;
-        } catch (err) {
-            this.enhancedDebug(`Failed: ${err.message}`);
-            throw err;
         }
+        // fallback: maybe the realtimeClient itself *is* the mqtt client
+        if (!mqtt && this.realtimeClient && typeof this.realtimeClient.publish === 'function') {
+            mqtt = this.realtimeClient;
+        }
+
+        if (!mqtt || typeof mqtt.publish !== 'function') {
+            throw new Error('MQTT client not available or does not expose publish(). Found client keys: ' +
+                (this.realtimeClient ? Object.keys(this.realtimeClient).join(',') : 'none'));
+        }
+        return mqtt;
     }
 
     /**
-     * Delete message via MQTT
+     * Robust mqtt publish wrapper - handles both:
+     * - mqtt.publish({ topic, payload, qosLevel }) returning a Promise or using callback
+     * - mqtt.publish(topic, payload, { qos }, cb)
      */
-    async deleteMessage(threadId, itemId) {
-        this.enhancedDebug(`Deleting message ${itemId} from thread ${threadId}`);
-        
+    async publishToMqtt(mqtt, publishObj) {
+        // publishObj: { topic, payload, qosLevel }
+        const topic = publishObj.topic;
+        const payload = publishObj.payload;
+        const qosLevel = typeof publishObj.qosLevel !== 'undefined' ? publishObj.qosLevel : 1;
+
+        // Try object-style publish first (some wrappers expect object)
         try {
-            const mqtt = this.realtimeClient.mqtt || this.realtimeClient._mqtt;
-            if (!mqtt || typeof mqtt.publish !== 'function') {
-                throw new Error('MQTT client not available');
+            const maybePromise = mqtt.publish({
+                topic,
+                payload,
+                qosLevel,
+            });
+            if (maybePromise && typeof maybePromise.then === 'function') {
+                return await maybePromise;
             }
-            
-            const clientContext = (0, uuid_1.v4)();
-            const command = {
-                action: 'delete_item',
-                thread_id: threadId,
-                item_id: itemId,
-                timestamp: Date.now(),
-                client_context: clientContext,
-            };
-            
-            const json = JSON.stringify(command);
-            const { compressDeflate } = shared_1;
-            const payload = await compressDeflate(json);
-            
-            this.enhancedDebug(`Publishing delete command to MQTT topic ${constants_1.Topics.SEND_MESSAGE.id}`);
-            const result = await mqtt.publish({
-                topic: constants_1.Topics.SEND_MESSAGE.id,
-                qosLevel: 1,
-                payload: payload,
+            // if it returned synchronously, maybe it still used callback style
+            return await new Promise((resolve, reject) => {
+                try {
+                    mqtt.publish({ topic, payload, qosLevel }, (err, res) => {
+                        if (err)
+                            return reject(err);
+                        return resolve(res);
+                    });
+                } catch (err) {
+                    reject(err);
+                }
             });
-            
-            this.enhancedDebug(`✅ Message deleted via MQTT!`);
-            return result;
-        } catch (err) {
-            this.enhancedDebug(`Delete failed: ${err.message}`);
-            throw err;
+        } catch (e) {
+            // fallthrough to positional try
+        }
+
+        // Try positional-style publish (topic, payload, options, callback)
+        try {
+            return await new Promise((resolve, reject) => {
+                try {
+                    mqtt.publish(topic, payload, { qos: qosLevel }, (err, res) => {
+                        if (err)
+                            return reject(err);
+                        return resolve(res);
+                    });
+                } catch (err) {
+                    reject(err);
+                }
+            });
+        } catch (e) {
+            // final fallback: some clients return synchronously or throw - try positional without callback
+            try {
+                const res = mqtt.publish(topic, payload, { qos: qosLevel });
+                if (res && typeof res.then === 'function') {
+                    return await res;
+                }
+                // last attempt: resolve with returned value
+                return res;
+            } catch (err) {
+                // give clear error
+                throw new Error(`MQTT publish failed: no known publish signature worked. Errors: ${err && err.message ? err.message : String(err)}`);
+            }
         }
     }
 
     /**
-     * Edit message via MQTT
+     * Send foreground state via MQTT with Thrift encoding (matching instagram_mqtt)
      */
-    async editMessage(threadId, itemId, newText) {
-        this.enhancedDebug(`Editing message ${itemId}: "${newText}"`);
+    async sendForegroundState(state) {
+        this.enhancedDebug(`Updated foreground state: ${JSON.stringify(state)}`);
         
         try {
-            const mqtt = this.realtimeClient.mqtt || this.realtimeClient._mqtt;
-            if (!mqtt || typeof mqtt.publish !== 'function') {
-                throw new Error('MQTT client not available');
-            }
+            const mqtt = this.getMqtt();
             
-            const clientContext = (0, uuid_1.v4)();
-            const command = {
-                action: 'edit_item',
-                thread_id: threadId,
-                item_id: itemId,
-                text: newText,
-                timestamp: Date.now(),
-                client_context: clientContext,
-            };
-            
-            const json = JSON.stringify(command);
-            const { compressDeflate } = shared_1;
-            const payload = await compressDeflate(json);
+            const thriftBuffer = (0, thrift_1.thriftWriteFromObject)(state, this.foregroundStateConfig);
+            const concat = Buffer.concat([
+                Buffer.alloc(1, 0),
+                thriftBuffer
+            ]);
+
+            // ensure we pass Buffer to compressDeflate
+            const payload = await (0, shared_1.compressDeflate)(concat);
             
-            this.enhancedDebug(`Publishing edit command to MQTT topic ${constants_1.Topics.SEND_MESSAGE.id}`);
-            const result = await mqtt.publish({
-                topic: constants_1.Topics.SEND_MESSAGE.id,
-                qosLevel: 1,
+            const result = await this.publishToMqtt(mqtt, {
+                topic: constants_1.Topics.FOREGROUND_STATE.id,
                 payload: payload,
+                qosLevel: 1,
             });
             
-            this.enhancedDebug(`✅ Message edited via MQTT!`);
+            // Update keepAlive if provided
+            if ((0, shared_1.notUndefined)(state.keepAliveTimeout)) {
+                mqtt.keepAlive = state.keepAliveTimeout;
+            }
+            
+            this.enhancedDebug(`✅ Foreground state updated via MQTT!`);
             return result;
         } catch (err) {
-            this.enhancedDebug(`Edit failed: ${err.message}`);
+            this.enhancedDebug(`Foreground state failed: ${err && err.message ? err.message : String(err)}`);
             throw err;
         }
     }
 
     /**
-     * Reply to message via MQTT (Quote Reply)
+     * Base command sender (matching instagram_mqtt format)
      */
-    async replyToMessage(threadId, messageId, replyText) {
-        this.enhancedDebug(`Replying to ${messageId} in thread ${threadId}: "${replyText}"`);
-        
+    async sendCommand({ action, data, threadId, clientContext }) {
         try {
-            const mqtt = this.realtimeClient.mqtt || this.realtimeClient._mqtt;
-            if (!mqtt || typeof mqtt.publish !== 'function') {
-                throw new Error('MQTT client not available');
+            const mqtt = this.getMqtt();
+            
+            if (clientContext) {
+                data.client_context = clientContext;
             }
             
-            const clientContext = (0, uuid_1.v4)();
-            const command = {
-                action: 'send_item',
+            const json = JSON.stringify({
+                action,
                 thread_id: threadId,
-                item_type: 'text',
-                text: replyText,
-                replying_to_item_id: messageId,
-                timestamp: Date.now(),
-                client_context: clientContext,
-            };
-            
-            const json = JSON.stringify(command);
-            const { compressDeflate } = shared_1;
-            const payload = await compressDeflate(json);
+                ...data,
+            });
+
+            // ensure Buffer (some compress implementations expect Buffer)
+            const payload = await (0, shared_1.compressDeflate)(Buffer.from(json));
             
-            this.enhancedDebug(`Publishing reply command to MQTT topic ${constants_1.Topics.SEND_MESSAGE.id}`);
-            const result = await mqtt.publish({
+            return this.publishToMqtt(mqtt, {
                 topic: constants_1.Topics.SEND_MESSAGE.id,
                 qosLevel: 1,
                 payload: payload,
             });
-            
-            this.enhancedDebug(`✅ Reply sent via MQTT!`);
-            return result;
         } catch (err) {
-            this.enhancedDebug(`Reply failed: ${err.message}`);
+            this.enhancedDebug(`sendCommand failed: ${err && err.message ? err.message : String(err)}`);
             throw err;
         }
     }
 
     /**
-     * Subscribe to follow notifications via MQTT
+     * Base item sender (matching instagram_mqtt format)
      */
-    async subscribeToFollowNotifications() {
-        this.enhancedDebug(`Subscribing to follow notifications via MQTT`);
+    async sendItem({ threadId, itemType, data, clientContext }) {
+        return this.sendCommand({
+            action: 'send_item',
+            threadId,
+            clientContext: clientContext || (0, uuid_1.v4)(),
+            data: {
+                item_type: itemType,
+                ...data,
+            },
+        });
+    }
+
+    /**
+     * Send text via MQTT (matching instagram_mqtt format)
+     */
+    async sendText({ text, clientContext, threadId }) {
+        this.enhancedDebug(`Sending text to ${threadId}: "${text}"`);
         
-        try {
-            const mqtt = this.realtimeClient.mqtt || this.realtimeClient._mqtt;
-            if (!mqtt || typeof mqtt.publish !== 'function') {
-                throw new Error('MQTT client not available');
-            }
-            
-            const clientContext = (0, uuid_1.v4)();
-            const command = {
-                action: 'subscribe',
-                subscription_type: 'follow_notifications',
-                timestamp: Date.now(),
-                client_context: clientContext,
-            };
-            
-            const json = JSON.stringify(command);
-            const { compressDeflate } = shared_1;
-            const payload = await compressDeflate(json);
-            
-            this.enhancedDebug(`Publishing follow subscription to MQTT`);
-            const result = await mqtt.publish({
-                topic: constants_1.Topics.SEND_MESSAGE.id,
-                qosLevel: 1,
-                payload: payload,
-            });
-            
-            this.enhancedDebug(`✅ Follow notifications subscribed via MQTT!`);
-            return result;
-        } catch (err) {
-            this.enhancedDebug(`Follow subscription failed: ${err.message}`);
-            throw err;
-        }
+        const result = await this.sendItem({
+            itemType: 'text',
+            threadId,
+            clientContext,
+            data: {
+                text,
+            },
+        });
+        
+        this.enhancedDebug(`✅ Text sent via MQTT!`);
+        return result;
     }
 
     /**
-     * Subscribe to mention notifications via MQTT
+     * Alias for sendText
      */
-    async subscribeToMentionNotifications() {
-        this.enhancedDebug(`Subscribing to mention notifications via MQTT`);
+    async sendTextViaRealtime(threadId, text, clientContext) {
+        return this.sendText({
+            text,
+            threadId,
+            clientContext,
+        });
+    }
+
+    /**
+     * Send hashtag via MQTT (matching instagram_mqtt format)
+     */
+    async sendHashtag({ text, threadId, hashtag, clientContext }) {
+        this.enhancedDebug(`Sending hashtag #${hashtag} to ${threadId}`);
         
-        try {
-            const mqtt = this.realtimeClient.mqtt || this.realtimeClient._mqtt;
-            if (!mqtt || typeof mqtt.publish !== 'function') {
-                throw new Error('MQTT client not available');
-            }
-            
-            const clientContext = (0, uuid_1.v4)();
-            const command = {
-                action: 'subscribe',
-                subscription_type: 'mention_notifications',
-                timestamp: Date.now(),
-                client_context: clientContext,
-            };
-            
-            const json = JSON.stringify(command);
-            const { compressDeflate } = shared_1;
-            const payload = await compressDeflate(json);
-            
-            this.enhancedDebug(`Publishing mention subscription to MQTT`);
-            const result = await mqtt.publish({
-                topic: constants_1.Topics.SEND_MESSAGE.id,
-                qosLevel: 1,
-                payload: payload,
-            });
-            
-            this.enhancedDebug(`✅ Mention notifications subscribed via MQTT!`);
-            return result;
-        } catch (err) {
-            this.enhancedDebug(`Mention subscription failed: ${err.message}`);
-            throw err;
-        }
+        const result = await this.sendItem({
+            itemType: 'hashtag',
+            threadId,
+            clientContext,
+            data: {
+                text: text || '',
+                hashtag,
+                item_id: hashtag,
+            },
+        });
+        
+        this.enhancedDebug(`✅ Hashtag sent via MQTT!`);
+        return result;
     }
 
     /**
-     * Subscribe to call notifications via MQTT
+     * Send like via MQTT (matching instagram_mqtt format)
      */
-    async subscribeToCallNotifications() {
-        this.enhancedDebug(`Subscribing to call notifications via MQTT`);
+    async sendLike({ threadId, clientContext }) {
+        this.enhancedDebug(`Sending like in thread ${threadId}`);
         
-        try {
-            const mqtt = this.realtimeClient.mqtt || this.realtimeClient._mqtt;
-            if (!mqtt || typeof mqtt.publish !== 'function') {
-                throw new Error('MQTT client not available');
-            }
-            
-            const clientContext = (0, uuid_1.v4)();
-            const command = {
-                action: 'subscribe',
-                subscription_type: 'call_notifications',
-                timestamp: Date.now(),
-                client_context: clientContext,
-            };
-            
-            const json = JSON.stringify(command);
-            const { compressDeflate } = shared_1;
-            const payload = await compressDeflate(json);
-            
-            this.enhancedDebug(`Publishing call subscription to MQTT`);
-            const result = await mqtt.publish({
-                topic: constants_1.Topics.SEND_MESSAGE.id,
-                qosLevel: 1,
-                payload: payload,
-            });
-            
-            this.enhancedDebug(`✅ Call notifications subscribed via MQTT!`);
-            return result;
-        } catch (err) {
-            this.enhancedDebug(`Call subscription failed: ${err.message}`);
-            throw err;
-        }
+        const result = await this.sendItem({
+            itemType: 'like',
+            threadId,
+            clientContext,
+            data: {},
+        });
+        
+        this.enhancedDebug(`✅ Like sent via MQTT!`);
+        return result;
     }
 
     /**
-     * Add member to thread via MQTT
+     * Send location via MQTT (matching instagram_mqtt format)
      */
-    async addMemberToThread(threadId, userId) {
-        this.enhancedDebug(`Adding user ${userId} to thread ${threadId} via MQTT`);
+    async sendLocation({ text, locationId, threadId, clientContext }) {
+        this.enhancedDebug(`Sending location ${locationId} to ${threadId}`);
         
-        try {
-            const mqtt = this.realtimeClient.mqtt || this.realtimeClient._mqtt;
-            if (!mqtt || typeof mqtt.publish !== 'function') {
-                throw new Error('MQTT client not available');
-            }
-            
-            const clientContext = (0, uuid_1.v4)();
-            const command = {
-                action: 'add_member',
-                thread_id: threadId,
-                user_id: userId,
-                timestamp: Date.now(),
-                client_context: clientContext,
-            };
-            
-            const json = JSON.stringify(command);
-            const { compressDeflate } = shared_1;
-            const payload = await compressDeflate(json);
-            
-            this.enhancedDebug(`Publishing add member command to MQTT`);
-            const result = await mqtt.publish({
-                topic: constants_1.Topics.SEND_MESSAGE.id,
-                qosLevel: 1,
-                payload: payload,
-            });
-            
-            this.enhancedDebug(`✅ Member added to thread via MQTT!`);
-            return result;
-        } catch (err) {
-            this.enhancedDebug(`Add member failed: ${err.message}`);
-            throw err;
-        }
+        const result = await this.sendItem({
+            itemType: 'location',
+            threadId,
+            clientContext,
+            data: {
+                text: text || '',
+                venue_id: locationId,
+                item_id: locationId,
+            },
+        });
+        
+        this.enhancedDebug(`✅ Location sent via MQTT!`);
+        return result;
     }
 
     /**
-     * Remove member from thread via MQTT
+     * Send media via MQTT (matching instagram_mqtt format - media_share)
      */
-    async removeMemberFromThread(threadId, userId) {
-        this.enhancedDebug(`Removing user ${userId} from thread ${threadId} via MQTT`);
+    async sendMedia({ text, mediaId, threadId, clientContext }) {
+        this.enhancedDebug(`Sending media ${mediaId} to ${threadId}`);
         
-        try {
-            const mqtt = this.realtimeClient.mqtt || this.realtimeClient._mqtt;
-            if (!mqtt || typeof mqtt.publish !== 'function') {
-                throw new Error('MQTT client not available');
-            }
-            
-            const clientContext = (0, uuid_1.v4)();
-            const command = {
-                action: 'remove_member',
-                thread_id: threadId,
-                user_id: userId,
-                timestamp: Date.now(),
-                client_context: clientContext,
-            };
-            
-            const json = JSON.stringify(command);
-            const { compressDeflate } = shared_1;
-            const payload = await compressDeflate(json);
-            
-            this.enhancedDebug(`Publishing remove member command to MQTT`);
-            const result = await mqtt.publish({
-                topic: constants_1.Topics.SEND_MESSAGE.id,
-                qosLevel: 1,
-                payload: payload,
-            });
-            
-            this.enhancedDebug(`✅ Member removed from thread via MQTT!`);
-            return result;
-        } catch (err) {
-            this.enhancedDebug(`Remove member failed: ${err.message}`);
-            throw err;
-        }
+        const result = await this.sendItem({
+            itemType: 'media_share',
+            threadId,
+            clientContext,
+            data: {
+                text: text || '',
+                media_id: mediaId,
+            },
+        });
+        
+        this.enhancedDebug(`✅ Media sent via MQTT!`);
+        return result;
     }
 
     /**
-     * Send reaction (emoji) via MQTT
+     * Send profile via MQTT (matching instagram_mqtt format)
      */
-    async sendReaction({ itemId, reactionType = 'like', clientContext, threadId, reactionStatus = 'created', emoji }) {
-        this.enhancedDebug(`Sending ${reactionType} reaction to message ${itemId} via MQTT`);
+    async sendProfile({ text, userId, threadId, clientContext }) {
+        this.enhancedDebug(`Sending profile ${userId} to ${threadId}`);
         
-        try {
-            const mqtt = this.realtimeClient.mqtt || this.realtimeClient._mqtt;
-            if (!mqtt || typeof mqtt.publish !== 'function') {
-                throw new Error('MQTT client not available');
-            }
-            
-            const ctx = clientContext || (0, uuid_1.v4)();
-            const command = {
-                action: 'send_reaction',
-                thread_id: threadId,
+        const result = await this.sendItem({
+            itemType: 'profile',
+            threadId,
+            clientContext,
+            data: {
+                text: text || '',
+                profile_user_id: userId,
+                item_id: userId,
+            },
+        });
+        
+        this.enhancedDebug(`✅ Profile sent via MQTT!`);
+        return result;
+    }
+
+    /**
+     * Send reaction via MQTT (matching instagram_mqtt format)
+     */
+    async sendReaction({ itemId, reactionType, clientContext, threadId, reactionStatus, targetItemType, emoji }) {
+        this.enhancedDebug(`Sending ${reactionType || 'like'} reaction to message ${itemId}`);
+        
+        const result = await this.sendItem({
+            itemType: 'reaction',
+            threadId,
+            clientContext,
+            data: {
                 item_id: itemId,
-                reaction_type: reactionType,
-                reaction_status: reactionStatus,
+                node_type: 'item',
+                reaction_type: reactionType || (emoji ? 'emoji' : 'like'),
+                reaction_status: reactionStatus || 'created',
+                target_item_type: targetItemType,
                 emoji: emoji || '',
-                timestamp: Date.now(),
-                client_context: ctx,
-            };
-            
-            const json = JSON.stringify(command);
-            const { compressDeflate } = shared_1;
-            const payload = await compressDeflate(json);
-            
-            this.enhancedDebug(`Publishing reaction to MQTT`);
-            const result = await mqtt.publish({
-                topic: constants_1.Topics.SEND_MESSAGE.id,
-                qosLevel: 1,
-                payload: payload,
-            });
-            
-            this.enhancedDebug(`✅ Reaction sent via MQTT!`);
-            return result;
-        } catch (err) {
-            this.enhancedDebug(`Reaction failed: ${err.message}`);
-            throw err;
-        }
+            },
+        });
+        
+        this.enhancedDebug(`✅ Reaction sent via MQTT!`);
+        return result;
     }
 
     /**
-     * Mark message as seen via MQTT
+     * Send user story via MQTT (matching instagram_mqtt format - reel_share)
+     */
+    async sendUserStory({ text, storyId, threadId, clientContext }) {
+        this.enhancedDebug(`Sending story ${storyId} to ${threadId}`);
+        
+        const result = await this.sendItem({
+            itemType: 'reel_share',
+            threadId,
+            clientContext,
+            data: {
+                text: text || '',
+                item_id: storyId,
+                media_id: storyId,
+            },
+        });
+        
+        this.enhancedDebug(`✅ Story sent via MQTT!`);
+        return result;
+    }
+
+    /**
+     * Mark as seen via MQTT (matching instagram_mqtt format - mark_seen action)
      */
     async markAsSeen({ threadId, itemId }) {
-        this.enhancedDebug(`Marking message ${itemId} as seen in thread ${threadId} via MQTT`);
+        this.enhancedDebug(`Marking message ${itemId} as seen in thread ${threadId}`);
         
-        try {
-            const mqtt = this.realtimeClient.mqtt || this.realtimeClient._mqtt;
-            if (!mqtt || typeof mqtt.publish !== 'function') {
-                throw new Error('MQTT client not available');
-            }
-            
-            const clientContext = (0, uuid_1.v4)();
-            const command = {
-                action: 'mark_as_seen',
-                thread_id: threadId,
+        const result = await this.sendCommand({
+            action: 'mark_seen',
+            threadId,
+            data: {
                 item_id: itemId,
-                timestamp: Date.now(),
-                client_context: clientContext,
-            };
-            
-            const json = JSON.stringify(command);
-            const { compressDeflate } = shared_1;
-            const payload = await compressDeflate(json);
-            
-            this.enhancedDebug(`Publishing mark as seen to MQTT`);
-            const result = await mqtt.publish({
-                topic: constants_1.Topics.SEND_MESSAGE.id,
-                qosLevel: 1,
-                payload: payload,
-            });
-            
-            this.enhancedDebug(`✅ Message marked as seen via MQTT!`);
-            return result;
-        } catch (err) {
-            this.enhancedDebug(`Mark as seen failed: ${err.message}`);
-            throw err;
-        }
+            },
+        });
+        
+        this.enhancedDebug(`✅ Message marked as seen via MQTT!`);
+        return result;
     }
 
     /**
-     * Indicate activity (typing) via MQTT
+     * Indicate activity (typing) via MQTT (matching instagram_mqtt format - activity_status)
      */
-    async indicateActivity({ threadId, isActive = true, clientContext }) {
-        this.enhancedDebug(`Indicating ${isActive ? 'typing' : 'stopped'} in thread ${threadId} via MQTT`);
+    async indicateActivity({ threadId, isActive, clientContext }) {
+        const active = typeof isActive === 'undefined' ? true : isActive;
+        this.enhancedDebug(`Indicating ${active ? 'typing' : 'stopped'} in thread ${threadId}`);
         
-        try {
-            const mqtt = this.realtimeClient.mqtt || this.realtimeClient._mqtt;
-            if (!mqtt || typeof mqtt.publish !== 'function') {
-                throw new Error('MQTT client not available');
-            }
-            
-            const ctx = clientContext || (0, uuid_1.v4)();
-            const command = {
-                action: 'indicate_activity',
-                thread_id: threadId,
-                is_active: isActive,
-                timestamp: Date.now(),
-                client_context: ctx,
-            };
-            
-            const json = JSON.stringify(command);
-            const { compressDeflate } = shared_1;
-            const payload = await compressDeflate(json);
-            
-            this.enhancedDebug(`Publishing activity indicator to MQTT`);
-            const result = await mqtt.publish({
-                topic: constants_1.Topics.SEND_MESSAGE.id,
-                qosLevel: 1,
-                payload: payload,
-            });
-            
-            this.enhancedDebug(`✅ Activity indicator sent via MQTT!`);
-            return result;
-        } catch (err) {
-            this.enhancedDebug(`Activity indicator failed: ${err.message}`);
-            throw err;
-        }
+        const result = await this.sendCommand({
+            action: 'indicate_activity',
+            threadId,
+            clientContext: clientContext || (0, uuid_1.v4)(),
+            data: {
+                activity_status: active ? '1' : '0',
+            },
+        });
+        
+        this.enhancedDebug(`✅ Activity indicator sent via MQTT!`);
+        return result;
     }
 
     /**
-     * Send media (image/video) via MQTT
+     * Delete message via MQTT
      */
-    async sendMedia({ text, mediaId, threadId, clientContext }) {
-        this.enhancedDebug(`Sending media ${mediaId} to ${threadId} via MQTT`);
+    async deleteMessage(threadId, itemId) {
+        this.enhancedDebug(`Deleting message ${itemId} from thread ${threadId}`);
         
-        try {
-            const mqtt = this.realtimeClient.mqtt || this.realtimeClient._mqtt;
-            if (!mqtt || typeof mqtt.publish !== 'function') {
-                throw new Error('MQTT client not available');
-            }
-            
-            const ctx = clientContext || (0, uuid_1.v4)();
-            const command = {
-                action: 'send_item',
-                thread_id: threadId,
-                item_type: 'media',
-                media_id: mediaId,
-                text: text || '',
-                timestamp: Date.now(),
-                client_context: ctx,
-            };
-            
-            const json = JSON.stringify(command);
-            const { compressDeflate } = shared_1;
-            const payload = await compressDeflate(json);
-            
-            this.enhancedDebug(`Publishing media to MQTT`);
-            const result = await mqtt.publish({
-                topic: constants_1.Topics.SEND_MESSAGE.id,
-                qosLevel: 1,
-                payload: payload,
-            });
-            
-            this.enhancedDebug(`✅ Media sent via MQTT!`);
-            return result;
-        } catch (err) {
-            this.enhancedDebug(`Media send failed: ${err.message}`);
-            throw err;
-        }
+        const result = await this.sendCommand({
+            action: 'delete_item',
+            threadId,
+            clientContext: (0, uuid_1.v4)(),
+            data: {
+                item_id: itemId,
+            },
+        });
+        
+        this.enhancedDebug(`✅ Message deleted via MQTT!`);
+        return result;
     }
 
     /**
-     * Send location via MQTT
+     * Edit message via MQTT
      */
-    async sendLocation({ text, locationId, threadId, clientContext }) {
-        this.enhancedDebug(`Sending location ${locationId} to ${threadId} via MQTT`);
+    async editMessage(threadId, itemId, newText) {
+        this.enhancedDebug(`Editing message ${itemId}: "${newText}"`);
         
-        try {
-            const mqtt = this.realtimeClient.mqtt || this.realtimeClient._mqtt;
-            if (!mqtt || typeof mqtt.publish !== 'function') {
-                throw new Error('MQTT client not available');
-            }
-            
-            const ctx = clientContext || (0, uuid_1.v4)();
-            const command = {
-                action: 'send_item',
-                thread_id: threadId,
-                item_type: 'location',
-                location_id: locationId,
-                text: text || '',
-                timestamp: Date.now(),
-                client_context: ctx,
-            };
-            
-            const json = JSON.stringify(command);
-            const { compressDeflate } = shared_1;
-            const payload = await compressDeflate(json);
-            
-            this.enhancedDebug(`Publishing location to MQTT`);
-            const result = await mqtt.publish({
-                topic: constants_1.Topics.SEND_MESSAGE.id,
-                qosLevel: 1,
-                payload: payload,
-            });
-            
-            this.enhancedDebug(`✅ Location sent via MQTT!`);
-            return result;
-        } catch (err) {
-            this.enhancedDebug(`Location send failed: ${err.message}`);
-            throw err;
-        }
+        const result = await this.sendCommand({
+            action: 'edit_item',
+            threadId,
+            clientContext: (0, uuid_1.v4)(),
+            data: {
+                item_id: itemId,
+                text: newText,
+            },
+        });
+        
+        this.enhancedDebug(`✅ Message edited via MQTT!`);
+        return result;
     }
 
     /**
-     * Send profile via MQTT
+     * Reply to message via MQTT (Quote Reply)
      */
-    async sendProfile({ text, userId, threadId, clientContext }) {
-        this.enhancedDebug(`Sending profile ${userId} to ${threadId} via MQTT`);
+    async replyToMessage(threadId, messageId, replyText) {
+        this.enhancedDebug(`Replying to ${messageId} in thread ${threadId}: "${replyText}"`);
         
-        try {
-            const mqtt = this.realtimeClient.mqtt || this.realtimeClient._mqtt;
-            if (!mqtt || typeof mqtt.publish !== 'function') {
-                throw new Error('MQTT client not available');
-            }
-            
-            const ctx = clientContext || (0, uuid_1.v4)();
-            const command = {
-                action: 'send_item',
-                thread_id: threadId,
-                item_type: 'profile',
-                user_id: userId,
-                text: text || '',
-                timestamp: Date.now(),
-                client_context: ctx,
-            };
-            
-            const json = JSON.stringify(command);
-            const { compressDeflate } = shared_1;
-            const payload = await compressDeflate(json);
-            
-            this.enhancedDebug(`Publishing profile to MQTT`);
-            const result = await mqtt.publish({
-                topic: constants_1.Topics.SEND_MESSAGE.id,
-                qosLevel: 1,
-                payload: payload,
-            });
-            
-            this.enhancedDebug(`✅ Profile sent via MQTT!`);
-            return result;
-        } catch (err) {
-            this.enhancedDebug(`Profile send failed: ${err.message}`);
-            throw err;
-        }
+        const result = await this.sendItem({
+            itemType: 'text',
+            threadId,
+            clientContext: (0, uuid_1.v4)(),
+            data: {
+                text: replyText,
+                replied_to_item_id: messageId,
+            },
+        });
+        
+        this.enhancedDebug(`✅ Reply sent via MQTT!`);
+        return result;
     }
 
     /**
-     * Send hashtag via MQTT
+     * Add member to thread via MQTT
      */
-    async sendHashtag({ text, hashtag, threadId, clientContext }) {
-        this.enhancedDebug(`Sending hashtag ${hashtag} to ${threadId} via MQTT`);
+    async addMemberToThread(threadId, userId) {
+        this.enhancedDebug(`Adding user ${userId} to thread ${threadId}`);
         
-        try {
-            const mqtt = this.realtimeClient.mqtt || this.realtimeClient._mqtt;
-            if (!mqtt || typeof mqtt.publish !== 'function') {
-                throw new Error('MQTT client not available');
-            }
-            
-            const ctx = clientContext || (0, uuid_1.v4)();
-            const command = {
-                action: 'send_item',
-                thread_id: threadId,
-                item_type: 'hashtag',
-                hashtag: hashtag,
-                text: text || '',
-                timestamp: Date.now(),
-                client_context: ctx,
-            };
-            
-            const json = JSON.stringify(command);
-            const { compressDeflate } = shared_1;
-            const payload = await compressDeflate(json);
-            
-            this.enhancedDebug(`Publishing hashtag to MQTT`);
-            const result = await mqtt.publish({
-                topic: constants_1.Topics.SEND_MESSAGE.id,
-                qosLevel: 1,
-                payload: payload,
-            });
-            
-            this.enhancedDebug(`✅ Hashtag sent via MQTT!`);
-            return result;
-        } catch (err) {
-            this.enhancedDebug(`Hashtag send failed: ${err.message}`);
-            throw err;
-        }
+        const result = await this.sendCommand({
+            action: 'add_users',
+            threadId,
+            clientContext: (0, uuid_1.v4)(),
+            data: {
+                user_ids: Array.isArray(userId) ? userId : [userId],
+            },
+        });
+        
+        this.enhancedDebug(`✅ Member added to thread via MQTT!`);
+        return result;
     }
 
     /**
-     * Send like via MQTT
+     * Remove member from thread via MQTT
      */
-    async sendLike({ threadId, clientContext }) {
-        this.enhancedDebug(`Sending like in thread ${threadId} via MQTT`);
+    async removeMemberFromThread(threadId, userId) {
+        this.enhancedDebug(`Removing user ${userId} from thread ${threadId}`);
         
-        try {
-            const mqtt = this.realtimeClient.mqtt || this.realtimeClient._mqtt;
-            if (!mqtt || typeof mqtt.publish !== 'function') {
-                throw new Error('MQTT client not available');
-            }
-            
-            const ctx = clientContext || (0, uuid_1.v4)();
-            const command = {
-                action: 'send_item',
-                thread_id: threadId,
-                item_type: 'like',
-                timestamp: Date.now(),
-                client_context: ctx,
-            };
-            
-            const json = JSON.stringify(command);
-            const { compressDeflate } = shared_1;
-            const payload = await compressDeflate(json);
-            
-            this.enhancedDebug(`Publishing like to MQTT`);
-            const result = await mqtt.publish({
-                topic: constants_1.Topics.SEND_MESSAGE.id,
-                qosLevel: 1,
-                payload: payload,
-            });
-            
-            this.enhancedDebug(`✅ Like sent via MQTT!`);
-            return result;
-        } catch (err) {
-            this.enhancedDebug(`Like send failed: ${err.message}`);
-            throw err;
-        }
+        const result = await this.sendCommand({
+            action: 'remove_users',
+            threadId,
+            clientContext: (0, uuid_1.v4)(),
+            data: {
+                user_ids: Array.isArray(userId) ? userId : [userId],
+            },
+        });
+        
+        this.enhancedDebug(`✅ Member removed from thread via MQTT!`);
+        return result;
     }
 
     /**
-     * Send user story via MQTT
+     * Leave thread via MQTT
      */
-    async sendUserStory({ text, storyId, threadId, clientContext }) {
-        this.enhancedDebug(`Sending story ${storyId} to ${threadId} via MQTT`);
+    async leaveThread(threadId) {
+        this.enhancedDebug(`Leaving thread ${threadId}`);
         
-        try {
-            const mqtt = this.realtimeClient.mqtt || this.realtimeClient._mqtt;
-            if (!mqtt || typeof mqtt.publish !== 'function') {
-                throw new Error('MQTT client not available');
-            }
-            
-            const ctx = clientContext || (0, uuid_1.v4)();
-            const command = {
-                action: 'send_item',
-                thread_id: threadId,
-                item_type: 'story',
-                story_id: storyId,
-                text: text || '',
-                timestamp: Date.now(),
-                client_context: ctx,
-            };
-            
-            const json = JSON.stringify(command);
-            const { compressDeflate } = shared_1;
-            const payload = await compressDeflate(json);
-            
-            this.enhancedDebug(`Publishing story to MQTT`);
-            const result = await mqtt.publish({
-                topic: constants_1.Topics.SEND_MESSAGE.id,
-                qosLevel: 1,
-                payload: payload,
-            });
-            
-            this.enhancedDebug(`✅ Story sent via MQTT!`);
-            return result;
-        } catch (err) {
-            this.enhancedDebug(`Story send failed: ${err.message}`);
-            throw err;
-        }
+        const result = await this.sendCommand({
+            action: 'leave',
+            threadId,
+            clientContext: (0, uuid_1.v4)(),
+            data: {},
+        });
+        
+        this.enhancedDebug(`✅ Left thread via MQTT!`);
+        return result;
+    }
+
+    /**
+     * Mute thread via MQTT
+     */
+    async muteThread(threadId, muteUntil = null) {
+        this.enhancedDebug(`Muting thread ${threadId}`);
+        
+        const result = await this.sendCommand({
+            action: 'mute',
+            threadId,
+            clientContext: (0, uuid_1.v4)(),
+            data: {
+                mute_until: muteUntil,
+            },
+        });
+        
+        this.enhancedDebug(`✅ Thread muted via MQTT!`);
+        return result;
+    }
+
+    /**
+     * Unmute thread via MQTT
+     */
+    async unmuteThread(threadId) {
+        this.enhancedDebug(`Unmuting thread ${threadId}`);
+        
+        const result = await this.sendCommand({
+            action: 'unmute',
+            threadId,
+            clientContext: (0, uuid_1.v4)(),
+            data: {},
+        });
+        
+        this.enhancedDebug(`✅ Thread unmuted via MQTT!`);
+        return result;
+    }
+
+    /**
+     * Update thread title via MQTT
+     */
+    async updateThreadTitle(threadId, title) {
+        this.enhancedDebug(`Updating thread ${threadId} title to: "${title}"`);
+        
+        const result = await this.sendCommand({
+            action: 'update_title',
+            threadId,
+            clientContext: (0, uuid_1.v4)(),
+            data: {
+                title: title,
+            },
+        });
+        
+        this.enhancedDebug(`✅ Thread title updated via MQTT!`);
+        return result;
+    }
+
+    /**
+     * Send link via MQTT
+     */
+    async sendLink({ link, text, threadId, clientContext }) {
+        this.enhancedDebug(`Sending link ${link} to ${threadId}`);
+        
+        const result = await this.sendItem({
+            itemType: 'link',
+            threadId,
+            clientContext,
+            data: {
+                link_text: text || '',
+                // use array (not JSON string) to match instagram_mqtt expectations
+                link_urls: [link],
+            },
+        });
+        
+        this.enhancedDebug(`✅ Link sent via MQTT!`);
+        return result;
+    }
+
+    /**
+     * Send animated media (GIF/sticker) via MQTT
+     */
+    async sendAnimatedMedia({ id, isSticker, threadId, clientContext }) {
+        this.enhancedDebug(`Sending animated media ${id} to ${threadId}`);
+        
+        const result = await this.sendItem({
+            itemType: 'animated_media',
+            threadId,
+            clientContext,
+            data: {
+                id: id,
+                is_sticker: isSticker || false,
+            },
+        });
+        
+        this.enhancedDebug(`✅ Animated media sent via MQTT!`);
+        return result;
+    }
+
+    /**
+     * Send voice message via MQTT (after upload)
+     */
+    async sendVoice({ uploadId, waveform, waveformSamplingFrequencyHz, threadId, clientContext }) {
+        this.enhancedDebug(`Sending voice ${uploadId} to ${threadId}`);
+        
+        const result = await this.sendItem({
+            itemType: 'voice_media',
+            threadId,
+            clientContext,
+            data: {
+                upload_id: uploadId,
+                waveform: waveform,
+                waveform_sampling_frequency_hz: waveformSamplingFrequencyHz || 10,
+            },
+        });
+        
+        this.enhancedDebug(`✅ Voice sent via MQTT!`);
+        return result;
     }
 
     /**
      * Send photo via Realtime (Upload + Broadcast)
-     * This method uploads the photo first, then broadcasts it to the thread
-     * 
-     * @param {Object} options - Photo sending options
-     * @param {Buffer} options.photoBuffer - Image buffer (JPEG/PNG)
-     * @param {string} options.threadId - Thread ID to send to
-     * @param {string} [options.caption] - Optional caption
-     * @param {string} [options.mimeType='image/jpeg'] - MIME type
-     * @param {string} [options.clientContext] - Optional client context
      */
     async sendPhotoViaRealtime({ photoBuffer, threadId, caption = '', mimeType = 'image/jpeg', clientContext }) {
         this.enhancedDebug(`Sending photo to thread ${threadId} via Realtime`);
         
         try {
-            // Validate inputs
             if (!photoBuffer || !Buffer.isBuffer(photoBuffer) || photoBuffer.length === 0) {
                 throw new Error('photoBuffer must be a non-empty Buffer');
             }
@@ -774,13 +668,11 @@ class EnhancedDirectCommands {
                 throw new Error('threadId is required');
             }
 
-            // Get the ig client from realtime client
             const ig = this.realtimeClient.ig;
             if (!ig || !ig.request) {
                 throw new Error('Instagram client not available. Make sure you are logged in.');
             }
 
-            // Step 1: Upload photo using rupload endpoint
             this.enhancedDebug(`Step 1: Uploading photo (${photoBuffer.length} bytes)...`);
             
             const uploadId = Date.now().toString();
@@ -824,11 +716,10 @@ class EnhancedDirectCommands {
                 }
                 this.enhancedDebug(`✅ Photo uploaded! upload_id: ${serverUploadId}`);
             } catch (uploadErr) {
-                this.enhancedDebug(`Upload error: ${uploadErr.message}`);
-                throw new Error(`Photo upload failed: ${uploadErr.message}`);
+                this.enhancedDebug(`Upload error: ${uploadErr && uploadErr.message ? uploadErr.message : String(uploadErr)}`);
+                throw new Error(`Photo upload failed: ${uploadErr && uploadErr.message ? uploadErr.message : String(uploadErr)}`);
             }
 
-            // Step 2: Broadcast the uploaded photo to the thread
             this.enhancedDebug(`Step 2: Broadcasting photo to thread ${threadId}...`);
             
             const broadcastForm = {
@@ -851,18 +742,18 @@ class EnhancedDirectCommands {
                 this.enhancedDebug(`✅ Photo sent successfully to thread ${threadId}!`);
                 return broadcastResponse;
             } catch (broadcastErr) {
-                this.enhancedDebug(`Broadcast error: ${broadcastErr.message}`);
-                throw new Error(`Photo broadcast failed: ${broadcastErr.message}`);
+                this.enhancedDebug(`Broadcast error: ${broadcastErr && broadcastErr.message ? broadcastErr.message : String(broadcastErr)}`);
+                throw new Error(`Photo broadcast failed: ${broadcastErr && broadcastErr.message ? broadcastErr.message : String(broadcastErr)}`);
             }
 
         } catch (err) {
-            this.enhancedDebug(`sendPhotoViaRealtime failed: ${err.message}`);
+            this.enhancedDebug(`sendPhotoViaRealtime failed: ${err && err.message ? err.message : String(err)}`);
             throw err;
         }
     }
 
     /**
-     * Alias for sendPhotoViaRealtime (for compatibility)
+     * Alias for sendPhotoViaRealtime
      */
     async sendPhoto(options) {
         return this.sendPhotoViaRealtime(options);
@@ -870,21 +761,11 @@ class EnhancedDirectCommands {
 
     /**
      * Send video via Realtime (Upload + Broadcast)
-     * 
-     * @param {Object} options - Video sending options
-     * @param {Buffer} options.videoBuffer - Video buffer (MP4)
-     * @param {string} options.threadId - Thread ID to send to
-     * @param {string} [options.caption] - Optional caption
-     * @param {number} [options.duration] - Video duration in seconds
-     * @param {number} [options.width] - Video width
-     * @param {number} [options.height] - Video height
-     * @param {string} [options.clientContext] - Optional client context
      */
     async sendVideoViaRealtime({ videoBuffer, threadId, caption = '', duration = 0, width = 720, height = 1280, clientContext }) {
         this.enhancedDebug(`Sending video to thread ${threadId} via Realtime`);
         
         try {
-            // Validate inputs
             if (!videoBuffer || !Buffer.isBuffer(videoBuffer) || videoBuffer.length === 0) {
                 throw new Error('videoBuffer must be a non-empty Buffer');
             }
@@ -892,13 +773,11 @@ class EnhancedDirectCommands {
                 throw new Error('threadId is required');
             }
 
-            // Get the ig client from realtime client
             const ig = this.realtimeClient.ig;
             if (!ig || !ig.request) {
                 throw new Error('Instagram client not available. Make sure you are logged in.');
             }
 
-            // Step 1: Upload video using rupload endpoint
             this.enhancedDebug(`Step 1: Uploading video (${videoBuffer.length} bytes)...`);
             
             const uploadId = Date.now().toString();
@@ -906,7 +785,7 @@ class EnhancedDirectCommands {
             
             const ruploadParams = {
                 upload_id: uploadId,
-                media_type: 2, // 2 = video
+                media_type: 2,
                 xsharing_user_ids: JSON.stringify([]),
                 upload_media_duration_ms: Math.round(duration * 1000),
                 upload_media_width: width,
@@ -939,11 +818,10 @@ class EnhancedDirectCommands {
                 }
                 this.enhancedDebug(`✅ Video uploaded! upload_id: ${serverUploadId}`);
             } catch (uploadErr) {
-                this.enhancedDebug(`Video upload error: ${uploadErr.message}`);
-                throw new Error(`Video upload failed: ${uploadErr.message}`);
+                this.enhancedDebug(`Video upload error: ${uploadErr && uploadErr.message ? uploadErr.message : String(uploadErr)}`);
+                throw new Error(`Video upload failed: ${uploadErr && uploadErr.message ? uploadErr.message : String(uploadErr)}`);
             }
 
-            // Step 2: Broadcast the uploaded video to the thread
             this.enhancedDebug(`Step 2: Broadcasting video to thread ${threadId}...`);
             
             const broadcastForm = {
@@ -967,21 +845,215 @@ class EnhancedDirectCommands {
                 this.enhancedDebug(`✅ Video sent successfully to thread ${threadId}!`);
                 return broadcastResponse;
             } catch (broadcastErr) {
-                this.enhancedDebug(`Video broadcast error: ${broadcastErr.message}`);
-                throw new Error(`Video broadcast failed: ${broadcastErr.message}`);
+                this.enhancedDebug(`Video broadcast error: ${broadcastErr && broadcastErr.message ? broadcastErr.message : String(broadcastErr)}`);
+                throw new Error(`Video broadcast failed: ${broadcastErr && broadcastErr.message ? broadcastErr.message : String(broadcastErr)}`);
             }
 
         } catch (err) {
-            this.enhancedDebug(`sendVideoViaRealtime failed: ${err.message}`);
+            this.enhancedDebug(`sendVideoViaRealtime failed: ${err && err.message ? err.message : String(err)}`);
             throw err;
         }
     }
 
     /**
-     * Alias for sendVideoViaRealtime (for compatibility)
+     * Alias for sendVideoViaRealtime
      */
     async sendVideo(options) {
         return this.sendVideoViaRealtime(options);
     }
+
+    /**
+     * Approve pending thread via MQTT
+     */
+    async approveThread(threadId) {
+        this.enhancedDebug(`Approving thread ${threadId}`);
+        
+        const result = await this.sendCommand({
+            action: 'approve',
+            threadId,
+            clientContext: (0, uuid_1.v4)(),
+            data: {},
+        });
+        
+        this.enhancedDebug(`✅ Thread approved via MQTT!`);
+        return result;
+    }
+
+    /**
+     * Decline pending thread via MQTT
+     */
+    async declineThread(threadId) {
+        this.enhancedDebug(`Declining thread ${threadId}`);
+        
+        const result = await this.sendCommand({
+            action: 'decline',
+            threadId,
+            clientContext: (0, uuid_1.v4)(),
+            data: {},
+        });
+        
+        this.enhancedDebug(`✅ Thread declined via MQTT!`);
+        return result;
+    }
+
+    /**
+     * Block user in thread via MQTT
+     */
+    async blockUserInThread(threadId, userId) {
+        this.enhancedDebug(`Blocking user ${userId} in thread ${threadId}`);
+        
+        const result = await this.sendCommand({
+            action: 'block',
+            threadId,
+            clientContext: (0, uuid_1.v4)(),
+            data: {
+                user_id: userId,
+            },
+        });
+        
+        this.enhancedDebug(`✅ User blocked in thread via MQTT!`);
+        return result;
+    }
+
+    /**
+     * Report thread via MQTT
+     */
+    async reportThread(threadId, reason) {
+        this.enhancedDebug(`Reporting thread ${threadId}`);
+        
+        const result = await this.sendCommand({
+            action: 'report',
+            threadId,
+            clientContext: (0, uuid_1.v4)(),
+            data: {
+                reason: reason || 'spam',
+            },
+        });
+        
+        this.enhancedDebug(`✅ Thread reported via MQTT!`);
+        return result;
+    }
+
+    /**
+     * Remove reaction via MQTT
+     */
+    async removeReaction({ itemId, threadId, clientContext }) {
+        this.enhancedDebug(`Removing reaction from message ${itemId}`);
+        
+        const result = await this.sendItem({
+            itemType: 'reaction',
+            threadId,
+            clientContext,
+            data: {
+                item_id: itemId,
+                node_type: 'item',
+                reaction_type: 'like',
+                reaction_status: 'deleted',
+            },
+        });
+        
+        this.enhancedDebug(`✅ Reaction removed via MQTT!`);
+        return result;
+    }
+
+    /**
+     * Send disappearing photo via MQTT
+     */
+    async sendDisappearingPhoto({ uploadId, threadId, viewMode = 'once', clientContext }) {
+        this.enhancedDebug(`Sending disappearing photo to ${threadId}`);
+        
+        const result = await this.sendItem({
+            itemType: 'expiring_media_message',
+            threadId,
+            clientContext,
+            data: {
+                upload_id: uploadId,
+                view_mode: viewMode,
+                allow_replay: viewMode === 'replayable',
+            },
+        });
+        
+        this.enhancedDebug(`✅ Disappearing photo sent via MQTT!`);
+        return result;
+    }
+
+    /**
+     * Send disappearing video via MQTT
+     */
+    async sendDisappearingVideo({ uploadId, threadId, viewMode = 'once', clientContext }) {
+        this.enhancedDebug(`Sending disappearing video to ${threadId}`);
+        
+        const result = await this.sendItem({
+            itemType: 'expiring_media_message',
+            threadId,
+            clientContext,
+            data: {
+                upload_id: uploadId,
+                view_mode: viewMode,
+                allow_replay: viewMode === 'replayable',
+                media_type: 2,
+            },
+        });
+        
+        this.enhancedDebug(`✅ Disappearing video sent via MQTT!`);
+        return result;
+    }
+
+    /**
+     * Mark visual message as seen via MQTT
+     */
+    async markVisualMessageSeen({ threadId, itemId, clientContext }) {
+        this.enhancedDebug(`Marking visual message ${itemId} as seen`);
+        
+        const result = await this.sendCommand({
+            action: 'mark_visual_item_seen',
+            threadId,
+            clientContext: clientContext || (0, uuid_1.v4)(),
+            data: {
+                item_id: itemId,
+            },
+        });
+        
+        this.enhancedDebug(`✅ Visual message marked as seen via MQTT!`);
+        return result;
+    }
+
+    /**
+     * Screenshot notification via MQTT
+     */
+    async sendScreenshotNotification({ threadId, itemId, clientContext }) {
+        this.enhancedDebug(`Sending screenshot notification for ${itemId}`);
+        
+        const result = await this.sendCommand({
+            action: 'screenshot_notification',
+            threadId,
+            clientContext: clientContext || (0, uuid_1.v4)(),
+            data: {
+                item_id: itemId,
+            },
+        });
+        
+        this.enhancedDebug(`✅ Screenshot notification sent via MQTT!`);
+        return result;
+    }
+
+    /**
+     * Replay notification via MQTT
+     */
+    async sendReplayNotification({ threadId, itemId, clientContext }) {
+        this.enhancedDebug(`Sending replay notification for ${itemId}`);
+        
+        const result = await this.sendCommand({
+            action: 'replay_notification',
+            threadId,
+            clientContext: clientContext || (0, uuid_1.v4)(),
+            data: {
+                item_id: itemId,
+            },
+        });
+        
+        this.enhancedDebug(`✅ Replay notification sent via MQTT!`);
+        return result;
+    }
 }
-exports.EnhancedDirectCommands = EnhancedDirectCommands;
+exports.EnhancedDirectCommands = EnhancedDirectCommands;