nodejs-insta-private-api-mqtt 1.0.0

package/dist/realtime/commands/index.d.ts

@@ -0,0 +1,2 @@
+export * from './commands';
+export * from './direct.commands';

package/dist/realtime/commands/index.js

@@ -0,0 +1,19 @@
+"use strict";
+var __createBinding = (this && this.__createBinding) || (Object.create ? (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    var desc = Object.getOwnPropertyDescriptor(m, k);
+    if (!desc || ("get" in desc ? !m.__esModule : desc.writable || desc.configurable)) {
+      desc = { enumerable: true, get: function() { return m[k]; } };
+    }
+    Object.defineProperty(o, k2, desc);
+}) : (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    o[k2] = m[k];
+}));
+var __exportStar = (this && this.__exportStar) || function(m, exports) {
+    for (var p in m) if (p !== "default" && !Object.prototype.hasOwnProperty.call(exports, p)) __createBinding(exports, m, p);
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+__exportStar(require("./commands"), exports);
+__exportStar(require("./direct.commands"), exports);
+//# sourceMappingURL=index.js.map

package/dist/realtime/commands/index.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"index.js","sourceRoot":"","sources":["../../../src/realtime/commands/index.ts"],"names":[],"mappings":";;;;;;;;;;;;;;;;AAAA,6CAA2B;AAC3B,oDAAkC"}

package/dist/realtime/delta-sync.manager.js

@@ -0,0 +1,293 @@
+const debug = require('debug')('ig:delta');
+
+/**
+ * Delta Sync Manager - Apply real Instagram delta updates to local state
+ * Based on MessageSync format from reverse-engineered instagram_mqtt
+ */
+class DeltaSyncManager {
+  constructor() {
+    this.state = {
+      threads: {},     // thread_id → ThreadUpdate
+      messages: {},    // item_id → MessageSyncMessage
+      typing: {},      // thread_id → TypingIndicator
+      presence: {}     // user_id → PresenceIndicator
+    };
+    this.listeners = [];
+    this.operations = { add: 0, update: 0, delete: 0 };
+  }
+
+  /**
+   * Apply delta operations (add/update/delete) to local state
+   */
+  applyDelta(delta) {
+    if (!delta || !delta.items || delta.items.length === 0) {
+      return { applied: 0, errors: [], stats: this.operations };
+    }
+
+    let applied = 0;
+    const errors = [];
+
+    delta.items.forEach(item => {
+      try {
+        const result = this.applyItem(item);
+        if (result) applied++;
+      } catch (e) {
+        errors.push({ 
+          itemId: item.id || item.item_id, 
+          error: e.message,
+          operation: item.op || item.type
+        });
+        debug(`❌ Error applying item:`, e.message);
+      }
+    });
+
+    // Notify listeners
+    if (applied > 0) {
+      this.notifyListeners(delta);
+    }
+
+    return { 
+      applied, 
+      errors, 
+      total: delta.items.length,
+      stats: this.operations
+    };
+  }
+
+  /**
+   * Apply single item (message, thread, typing, presence)
+   */
+  applyItem(item) {
+    if (!item) return false;
+
+    // Get operation type from IrisItem
+    const operation = item.op || item.type || 'add'; // add, replace, delete
+
+    // Extract data from 'data' oneof field
+    if (item.data?.message) {
+      return this.applyMessage(operation, item.data.message);
+    }
+
+    if (item.data?.thread) {
+      return this.applyThread(operation, item.data.thread);
+    }
+
+    if (item.data?.typing) {
+      return this.applyTyping(operation, item.data.typing);
+    }
+
+    if (item.data?.presence) {
+      return this.applyPresence(operation, item.data.presence);
+    }
+
+    // Fallback for direct objects
+    if (item.message) {
+      return this.applyMessage(operation, item.message);
+    }
+    if (item.thread) {
+      return this.applyThread(operation, item.thread);
+    }
+    if (item.typing) {
+      return this.applyTyping(operation, item.typing);
+    }
+    if (item.presence) {
+      return this.applyPresence(operation, item.presence);
+    }
+
+    return false;
+  }
+
+  /**
+   * Apply message delta (real Instagram MessageSyncMessage format)
+   */
+  applyMessage(operation, message) {
+    const msgId = message.item_id;
+
+    if (operation === 'delete' || operation === 'deletion') {
+      delete this.state.messages[msgId];
+      this.operations.delete++;
+      debug(`🗑️  Deleted message ${msgId}`);
+      return true;
+    }
+
+    if (operation === 'replace' || operation === 'update') {
+      if (!this.state.messages[msgId]) {
+        debug(`⚠️  Message ${msgId} not found for update`);
+        return false;
+      }
+      Object.assign(this.state.messages[msgId], message);
+      this.operations.update++;
+      debug(`✏️  Updated message ${msgId}: "${message.text?.substring(0, 30)}"`);
+      return true;
+    }
+
+    // add/default
+    this.state.messages[msgId] = message;
+    this.operations.add++;
+    debug(`➕ Added message ${msgId}: "${message.text?.substring(0, 30) || 'media'}"`);
+    return true;
+  }
+
+  /**
+   * Apply thread delta (real Instagram ThreadUpdate format)
+   */
+  applyThread(operation, thread) {
+    const threadId = thread.thread_id || thread.thread_v2_id;
+
+    if (operation === 'delete') {
+      delete this.state.threads[threadId];
+      this.operations.delete++;
+      debug(`🗑️  Deleted thread ${threadId}`);
+      return true;
+    }
+
+    if (operation === 'replace' || operation === 'update') {
+      if (!this.state.threads[threadId]) {
+        // Create new thread on update if doesn't exist
+        this.state.threads[threadId] = thread;
+        this.operations.add++;
+        debug(`➕ Created thread from update: ${thread.thread_title}`);
+        return true;
+      }
+      Object.assign(this.state.threads[threadId], thread);
+      this.operations.update++;
+      debug(`✏️  Updated thread ${threadId}: "${thread.thread_title}"`);
+      return true;
+    }
+
+    // add/default
+    this.state.threads[threadId] = thread;
+    this.operations.add++;
+    debug(`➕ Added thread: "${thread.thread_title}" (${thread.user_ids?.length || 1} members)`);
+    return true;
+  }
+
+  /**
+   * Apply typing indicator delta
+   */
+  applyTyping(operation, typing) {
+    const threadId = typing.thread_id;
+
+    if (operation === 'delete' || typing.state === 'stopped') {
+      delete this.state.typing[threadId];
+      this.operations.delete++;
+      debug(`⌨️  User ${typing.from_user_id} stopped typing in ${threadId}`);
+      return true;
+    }
+
+    this.state.typing[threadId] = typing;
+    this.operations.add++;
+    debug(`⌨️  User ${typing.from_user_id} typing in ${threadId}`);
+    return true;
+  }
+
+  /**
+   * Apply presence indicator delta
+   */
+  applyPresence(operation, presence) {
+    const userId = presence.user_id;
+
+    if (operation === 'delete' || presence.status === 'inactive') {
+      delete this.state.presence[userId];
+      this.operations.delete++;
+      debug(`🔴 User ${userId} offline`);
+      return true;
+    }
+
+    this.state.presence[userId] = presence;
+    this.operations.add++;
+    debug(`🟢 User ${userId} ${presence.status}`);
+    return true;
+  }
+
+  /**
+   * Subscribe to state changes
+   */
+  subscribe(callback) {
+    this.listeners.push(callback);
+    return () => {
+      this.listeners = this.listeners.filter(l => l !== callback);
+    };
+  }
+
+  /**
+   * Notify listeners of changes
+   */
+  notifyListeners(delta) {
+    this.listeners.forEach(callback => {
+      try {
+        callback(delta, this.getState());
+      } catch (e) {
+        debug('Listener error:', e.message);
+      }
+    });
+  }
+
+  /**
+   * Get current synchronized state
+   */
+  getState() {
+    return {
+      threads: JSON.parse(JSON.stringify(this.state.threads)),
+      messages: JSON.parse(JSON.stringify(this.state.messages)),
+      typing: JSON.parse(JSON.stringify(this.state.typing)),
+      presence: JSON.parse(JSON.stringify(this.state.presence))
+    };
+  }
+
+  /**
+   * Query methods
+   */
+  getThread(threadId) {
+    return this.state.threads[threadId] || null;
+  }
+
+  getThreadMessages(threadId) {
+    return Object.values(this.state.messages).filter(m => m.thread_id === threadId || m.thread_v2_id === threadId);
+  }
+
+  getThreads() {
+    return Object.values(this.state.threads);
+  }
+
+  getAllMessages() {
+    return Object.values(this.state.messages);
+  }
+
+  getTypingInThread(threadId) {
+    return this.state.typing[threadId] || null;
+  }
+
+  getUserPresence(userId) {
+    return this.state.presence[userId] || null;
+  }
+
+  /**
+   * Stats
+   */
+  getStats() {
+    return {
+      threads: Object.keys(this.state.threads).length,
+      messages: Object.keys(this.state.messages).length,
+      typing: Object.keys(this.state.typing).length,
+      presence: Object.keys(this.state.presence).length,
+      operations: this.operations
+    };
+  }
+
+  /**
+   * Clear all state
+   */
+  clear() {
+    this.state = {
+      threads: {},
+      messages: {},
+      typing: {},
+      presence: {}
+    };
+    this.operations = { add: 0, update: 0, delete: 0 };
+    debug('✓ State cleared');
+  }
+}
+
+module.exports = DeltaSyncManager;

package/dist/realtime/features/dm-sender.js

@@ -0,0 +1,88 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.DMSender = void 0;
+const shared_1 = require("../../shared");
+const uuid_1 = require("uuid");
+/**
+ * Direct Message Sender via MQTT
+ */
+class DMSender {
+    constructor(client) {
+        this.dmDebug = (0, shared_1.debugChannel)('realtime', 'dm-sender');
+        this.client = client;
+    }
+    /**
+     * Send text message via MQTT
+     */
+    async sendTextMessage(threadId, text, clientContext = null) {
+        this.dmDebug(`Sending text message to thread ${threadId}: "${text.substring(0, 50)}..."`);
+        const command = {
+            action: 'send_item',
+            thread_id: threadId,
+            item_type: 'text',
+            text,
+            timestamp: Date.now(),
+            client_context: clientContext || (0, uuid_1.v4)(),
+        };
+        try {
+            return await this.client.directCommands?.sendCommand({
+                action: 'send_item',
+                data: command,
+                threadId,
+            });
+        } catch (err) {
+            this.dmDebug(`Failed to send message: ${err.message}`);
+            throw err;
+        }
+    }
+    /**
+     * Send media message via MQTT (photo/video)
+     */
+    async sendMediaMessage(threadId, mediaId, mediaType = 'photo', clientContext = null) {
+        this.dmDebug(`Sending ${mediaType} to thread ${threadId}`);
+        const command = {
+            action: 'send_item',
+            thread_id: threadId,
+            item_type: mediaType,
+            media_id: mediaId,
+            timestamp: Date.now(),
+            client_context: clientContext || (0, uuid_1.v4)(),
+        };
+        try {
+            return await this.client.directCommands?.sendCommand({
+                action: 'send_item',
+                data: command,
+                threadId,
+            });
+        } catch (err) {
+            this.dmDebug(`Failed to send media: ${err.message}`);
+            throw err;
+        }
+    }
+    /**
+     * Send link message
+     */
+    async sendLinkMessage(threadId, url, title = null, clientContext = null) {
+        this.dmDebug(`Sending link to thread ${threadId}: ${url}`);
+        const command = {
+            action: 'send_item',
+            thread_id: threadId,
+            item_type: 'link',
+            url,
+            title: title || url,
+            timestamp: Date.now(),
+            client_context: clientContext || (0, uuid_1.v4)(),
+        };
+        try {
+            return await this.client.directCommands?.sendCommand({
+                action: 'send_item',
+                data: command,
+                threadId,
+            });
+        } catch (err) {
+            this.dmDebug(`Failed to send link: ${err.message}`);
+            throw err;
+        }
+    }
+}
+exports.DMSender = DMSender;

package/dist/realtime/features/error-handler.js

@@ -0,0 +1,73 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.ErrorHandler = void 0;
+const shared_1 = require("../../shared");
+/**
+ * MQTT Error Handler with recovery strategies
+ */
+class ErrorHandler {
+    constructor(client) {
+        this.errorDebug = (0, shared_1.debugChannel)('realtime', 'errors');
+        this.errorCount = 0;
+        this.maxRetries = 5;
+        this.client = client;
+    }
+    /**
+     * Handle MQTT connection error
+     */
+    handleConnectionError(error) {
+        this.errorCount++;
+        this.errorDebug(`Connection Error (${this.errorCount}/${this.maxRetries}): ${error.message}`);
+        
+        if (this.errorCount >= this.maxRetries) {
+            this.client.emit('error', new Error('Max connection retries exceeded'));
+            return false;
+        }
+        
+        // Exponential backoff
+        const delay = Math.min(1000 * Math.pow(2, this.errorCount - 1), 30000);
+        this.errorDebug(`Retrying in ${delay}ms...`);
+        
+        setTimeout(() => {
+            this.client.reconnect();
+        }, delay);
+        
+        return true;
+    }
+    /**
+     * Handle payload validation error
+     */
+    handlePayloadError(error, topic) {
+        this.errorDebug(`Payload Error on topic ${topic}: ${error.message}`);
+        this.client.emit('warning', {
+            type: 'payload_error',
+            topic,
+            error: error.message,
+        });
+    }
+    /**
+     * Handle protocol error
+     */
+    handleProtocolError(error) {
+        this.errorDebug(`Protocol Error: ${error.message}`);
+        this.client.emit('error', new Error(`MQTT Protocol Error: ${error.message}`));
+    }
+    /**
+     * Reset error counter on successful connection
+     */
+    resetErrorCounter() {
+        this.errorCount = 0;
+        this.errorDebug('Error counter reset');
+    }
+    /**
+     * Get error stats
+     */
+    getErrorStats() {
+        return {
+            errorCount: this.errorCount,
+            maxRetries: this.maxRetries,
+            canRetry: this.errorCount < this.maxRetries,
+        };
+    }
+}
+exports.ErrorHandler = ErrorHandler;

package/dist/realtime/features/gap-handler.js

@@ -0,0 +1,61 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.GapHandler = void 0;
+const shared_1 = require("../../shared");
+/**
+ * Gap Handler - Handle message gaps and synchronization
+ */
+class GapHandler {
+    constructor(client) {
+        this.gapDebug = (0, shared_1.debugChannel)('realtime', 'gap');
+        this.threadGaps = new Map();
+        this.client = client;
+    }
+    /**
+     * Detect message gap in thread
+     */
+    detectGap(threadId, lastMessageId, newMessageId) {
+        const lastId = parseInt(lastMessageId, 10);
+        const newId = parseInt(newMessageId, 10);
+        const gap = Math.abs(newId - lastId) > 1;
+        
+        if (gap) {
+            this.gapDebug(`Gap detected in thread ${threadId}: ${lastMessageId} -> ${newMessageId}`);
+            this.threadGaps.set(threadId, { from: lastMessageId, to: newMessageId });
+            this.client.emit('gap', {
+                thread_id: threadId,
+                gap_from: lastMessageId,
+                gap_to: newMessageId,
+            });
+        }
+        return gap;
+    }
+    /**
+     * Handle gap by requesting missing messages
+     */
+    async handleGap(threadId, gapFrom, gapTo) {
+        this.gapDebug(`Handling gap in ${threadId}: fetching messages ${gapFrom}-${gapTo}`);
+        try {
+            // Request missing messages from REST API
+            const thread = await this.client.ig.direct.getThread(threadId);
+            const messages = await thread.getMessages({ limit: 50 });
+            
+            this.client.emit('gap_filled', {
+                thread_id: threadId,
+                messages_count: messages.length,
+            });
+            return messages;
+        } catch (err) {
+            this.gapDebug(`Failed to handle gap: ${err.message}`);
+            this.client.emit('error', new Error(`Gap handling failed for thread ${threadId}`));
+            return [];
+        }
+    }
+    /**
+     * Clear gap tracking for thread
+     */
+    clearGap(threadId) {
+        this.threadGaps.delete(threadId);
+    }
+}
+exports.GapHandler = GapHandler;

package/dist/realtime/features/presence.manager.js

@@ -0,0 +1,66 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.PresenceManager = void 0;
+const shared_1 = require("../../shared");
+const uuid_1 = require("uuid");
+/**
+ * Presence Manager - Handle online/offline status
+ */
+class PresenceManager {
+    constructor(client) {
+        this.presenceDebug = (0, shared_1.debugChannel)('realtime', 'presence');
+        this.userPresence = new Map();
+        this.client = client;
+    }
+    /**
+     * Update user presence
+     */
+    updatePresence(userId, status, lastActivity = Date.now()) {
+        this.presenceDebug(`User ${userId} is ${status}`);
+        this.userPresence.set(userId, { status, lastActivity });
+        this.client.emit('presence', {
+            user_id: userId,
+            status,
+            last_activity: lastActivity,
+        });
+    }
+    /**
+     * Get user presence
+     */
+    getPresence(userId) {
+        return this.userPresence.get(userId) || { status: 'offline', lastActivity: null };
+    }
+    /**
+     * Broadcast user's own presence
+     */
+    async broadcastPresence(status = 'online') {
+        this.presenceDebug(`Broadcasting presence: ${status}`);
+        const payload = {
+            action: 'presence_status',
+            status,
+            timestamp: Date.now(),
+            client_context: (0, uuid_1.v4)(),
+        };
+        return this.client.directCommands?.sendCommand({
+            action: 'send_presence',
+            data: payload,
+            threadId: '',
+        });
+    }
+    /**
+     * Handle presence update
+     */
+    handlePresenceUpdate(data) {
+        try {
+            const update = typeof data === 'string' ? JSON.parse(data) : data;
+            if (update.user_id && update.status) {
+                this.updatePresence(update.user_id, update.status, update.last_activity);
+            }
+            return update;
+        } catch (err) {
+            this.presenceDebug(`Failed to parse presence update: ${err.message}`);
+            return null;
+        }
+    }
+}
+exports.PresenceManager = PresenceManager;

package/dist/realtime/index.js

@@ -0,0 +1,30 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.PresenceTypingMixin = exports.EnhancedDirectCommands = exports.GapHandler = exports.ErrorHandler = exports.DMSender = exports.PresenceManager = exports.SkywalkerProtocol = exports.IrisHandshake = exports.RealtimeClient = void 0;
+
+const realtime_client_1 = require("./realtime.client");
+Object.defineProperty(exports, "RealtimeClient", { enumerable: true, get: function () { return realtime_client_1.RealtimeClient; } });
+
+const iris_handshake_1 = require("./protocols/iris.handshake");
+Object.defineProperty(exports, "IrisHandshake", { enumerable: true, get: function () { return iris_handshake_1.IrisHandshake; } });
+
+const skywalker_protocol_1 = require("./protocols/skywalker.protocol");
+Object.defineProperty(exports, "SkywalkerProtocol", { enumerable: true, get: function () { return skywalker_protocol_1.SkywalkerProtocol; } });
+
+const presence_manager_1 = require("./features/presence.manager");
+Object.defineProperty(exports, "PresenceManager", { enumerable: true, get: function () { return presence_manager_1.PresenceManager; } });
+
+const dm_sender_1 = require("./features/dm-sender");
+Object.defineProperty(exports, "DMSender", { enumerable: true, get: function () { return dm_sender_1.DMSender; } });
+
+const error_handler_1 = require("./features/error-handler");
+Object.defineProperty(exports, "ErrorHandler", { enumerable: true, get: function () { return error_handler_1.ErrorHandler; } });
+
+const gap_handler_1 = require("./features/gap-handler");
+Object.defineProperty(exports, "GapHandler", { enumerable: true, get: function () { return gap_handler_1.GapHandler; } });
+
+const presence_typing_mixin_1 = require("./mixins/presence-typing.mixin");
+Object.defineProperty(exports, "PresenceTypingMixin", { enumerable: true, get: function () { return presence_typing_mixin_1.PresenceTypingMixin; } });
+
+const enhanced_direct_commands_1 = require("./commands/enhanced.direct.commands");
+Object.defineProperty(exports, "EnhancedDirectCommands", { enumerable: true, get: function () { return enhanced_direct_commands_1.EnhancedDirectCommands; } });

package/dist/realtime/messages/app-presence.event.d.ts

@@ -0,0 +1,9 @@
+export interface AppPresenceEvent {
+    user_id: string;
+    is_active: boolean;
+    last_activity_at_ms: string;
+    in_threads: any[];
+}
+export interface AppPresenceEventWrapper {
+    presence_event: AppPresenceEvent;
+}

package/dist/realtime/messages/app-presence.event.js

@@ -0,0 +1,3 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+//# sourceMappingURL=app-presence.event.js.map

package/dist/realtime/messages/app-presence.event.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"app-presence.event.js","sourceRoot":"","sources":["../../../src/realtime/messages/app-presence.event.ts"],"names":[],"mappings":""}

package/dist/realtime/messages/index.d.ts

@@ -0,0 +1,3 @@
+export * from './message-sync.message';
+export * from './realtime-sub.direct.data';
+export * from './app-presence.event';

package/dist/realtime/messages/index.js

@@ -0,0 +1,20 @@
+"use strict";
+var __createBinding = (this && this.__createBinding) || (Object.create ? (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    var desc = Object.getOwnPropertyDescriptor(m, k);
+    if (!desc || ("get" in desc ? !m.__esModule : desc.writable || desc.configurable)) {
+      desc = { enumerable: true, get: function() { return m[k]; } };
+    }
+    Object.defineProperty(o, k2, desc);
+}) : (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    o[k2] = m[k];
+}));
+var __exportStar = (this && this.__exportStar) || function(m, exports) {
+    for (var p in m) if (p !== "default" && !Object.prototype.hasOwnProperty.call(exports, p)) __createBinding(exports, m, p);
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+__exportStar(require("./message-sync.message"), exports);
+__exportStar(require("./realtime-sub.direct.data"), exports);
+__exportStar(require("./app-presence.event"), exports);
+//# sourceMappingURL=index.js.map

package/dist/realtime/messages/index.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"index.js","sourceRoot":"","sources":["../../../src/realtime/messages/index.ts"],"names":[],"mappings":";;;;;;;;;;;;;;;;AAAA,yDAAuC;AACvC,6DAA2C;AAC3C,uDAAqC"}