nodejs-insta-private-api-mqt 1.3.70

package/dist/realtime/proto-parser.js

@@ -0,0 +1,195 @@
+const protobuf = require('protobufjs');
+const pako = require('pako');
+const debug = require('debug')('ig:proto');
+
+/**
+ * Protobuf Parser - Instagram MQTT messages
+ * Simplified embedded proto without external file dependencies
+ */
+class ProtoParser {
+  constructor() {
+    this.root = null;
+    this.loadedTypes = {};
+    this.init();
+  }
+
+  init() {
+    try {
+      // Inline proto definitions - no file dependencies
+      const proto = `
+syntax = "proto3";
+
+package ig.iris;
+
+message IrisPayload {
+  string action = 1;
+  int64 seq_id = 2;
+  repeated IrisItem items = 3;
+}
+
+message IrisItem {
+  string id = 1;
+  string type = 2;
+  int64 timestamp = 3;
+  string op = 4;
+  string path = 5;
+  MessageSyncMessage message = 6;
+  ThreadUpdate thread = 7;
+  TypingIndicator typing = 8;
+  PresenceIndicator presence = 9;
+}
+
+message MessageSyncMessage {
+  string item_id = 1;
+  int64 user_id = 2;
+  int64 timestamp = 3;
+  string thread_id = 4;
+  string thread_v2_id = 5;
+  string item_type = 6;
+  string text = 7;
+  bool is_sent = 8;
+  bool is_delivered = 9;
+  bool is_read = 10;
+  string emoji_reaction = 11;
+}
+
+message ThreadUpdate {
+  string thread_id = 1;
+  string thread_v2_id = 2;
+  repeated int64 user_ids = 3;
+  string thread_title = 4;
+  int64 last_activity_at = 5;
+  bool is_group = 6;
+  bool is_archived = 7;
+  bool is_muted = 8;
+  string thread_type = 9;
+}
+
+message TypingIndicator {
+  int64 thread_id = 1;
+  int64 from_user_id = 2;
+  string state = 3;
+  int64 timestamp = 4;
+}
+
+message PresenceIndicator {
+  int64 user_id = 1;
+  string status = 2;
+  int64 last_seen_at = 3;
+}
+      `;
+
+      // Parse proto definition
+      this.root = protobuf.parse(proto).root;
+      
+      // Load types
+      this.loadedTypes = {
+        IrisPayload: this.root.lookupType('ig.iris.IrisPayload'),
+        IrisItem: this.root.lookupType('ig.iris.IrisItem'),
+        MessageSyncMessage: this.root.lookupType('ig.iris.MessageSyncMessage'),
+        ThreadUpdate: this.root.lookupType('ig.iris.ThreadUpdate'),
+        TypingIndicator: this.root.lookupType('ig.iris.TypingIndicator'),
+        PresenceIndicator: this.root.lookupType('ig.iris.PresenceIndicator')
+      };
+
+      debug('✓ Proto parser initialized with', Object.keys(this.loadedTypes).length, 'types');
+    } catch (e) {
+      debug('❌ Proto init failed:', e.message);
+      this.root = null;
+    }
+  }
+
+  decompress(buffer) {
+    try {
+      return pako.inflate(buffer);
+    } catch (e) {
+      try {
+        return pako.ungzip(buffer);
+      } catch (e2) {
+        return buffer;
+      }
+    }
+  }
+
+  parsePayload(topicId, rawPayload) {
+    try {
+      if (!rawPayload || rawPayload.length === 0) {
+        return { error: 'Empty', decoded: null };
+      }
+
+      const payload = this.decompress(rawPayload);
+      debug(`📦 Topic ${topicId}: ${payload.length} bytes`);
+
+      if (this.loadedTypes.IrisPayload) {
+        try {
+          const decoded = this.loadedTypes.IrisPayload.decode(payload);
+          const message = this.loadedTypes.IrisPayload.toObject(decoded, {
+            longs: String,
+            enums: String,
+            bytes: String
+          });
+          
+          debug(`✓ Decoded ${message.items?.length || 0} items`);
+          return { decoded: message, format: 'protobuf' };
+        } catch (e) {
+          debug(`Proto decode failed, trying JSON`);
+          try {
+            const json = JSON.parse(payload.toString('utf-8'));
+            return { decoded: json, format: 'json' };
+          } catch (e2) {
+            return { error: 'Parse failed', decoded: null };
+          }
+        }
+      }
+
+      return { error: 'Proto not ready', decoded: null };
+    } catch (e) {
+      debug('Parse error:', e.message);
+      return { error: e.message, decoded: null };
+    }
+  }
+
+  extractMessages(payload) {
+    if (!payload || !payload.items) return [];
+    
+    const messages = [];
+    payload.items.forEach(item => {
+      if (item.message) {
+        messages.push({
+          id: item.id,
+          type: 'message',
+          message: item.message
+        });
+      }
+      if (item.thread) {
+        messages.push({
+          id: item.id,
+          type: 'thread',
+          thread: item.thread
+        });
+      }
+      if (item.typing) {
+        messages.push({
+          id: item.id,
+          type: 'typing',
+          typing: item.typing
+        });
+      }
+    });
+
+    return messages;
+  }
+
+  isReady() {
+    return this.root !== null && Object.keys(this.loadedTypes).length > 0;
+  }
+
+  getStats() {
+    return {
+      ready: this.isReady(),
+      types: Object.keys(this.loadedTypes).length
+    };
+  }
+}
+
+module.exports = ProtoParser;

package/dist/realtime/protocols/iris.handshake.js

@@ -0,0 +1,74 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.IrisHandshake = void 0;
+const uuid_1 = require("uuid");
+const shared_1 = require("../../shared");
+/**
+ * IRIS Handshake - Instagram Real-time Iris Sync Protocol
+ * Handles authentication and subscription to IRIS topics
+ */
+class IrisHandshake {
+    constructor(client) {
+        this.irisDebug = (0, shared_1.debugChannel)('realtime', 'iris');
+        this.client = client;
+    }
+    /**
+     * Create IRIS client payload for handshake
+     */
+    createClientPayload() {
+        return {
+            clientVersion: '415.0.0.36.76',
+            clientUserID: this.client.ig.state.cookieUserId,
+            clientContext: {
+                clientContextVersion: '1',
+                clientContextType: 'mobile',
+                appVersion: '415.0.0.36.76',
+                userAgent: this.client.ig.state.appUserAgent,
+            },
+            subscribeProtoMask: 0,
+            capabilities: {
+                supportsPresenceEvents: true,
+                supportsTypingIndicators: true,
+                supportsMessageReactions: true,
+                supportsForegroundState: true,
+            },
+        };
+    }
+    /**
+     * Generate IRIS subscription request
+     */
+    generateSubscriptionRequest(topics) {
+        this.irisDebug(`Generating IRIS subscription for topics: ${topics.join(', ')}`);
+        return {
+            requestId: (0, uuid_1.v4)(),
+            clientVersion: '415.0.0.36.76',
+            subscriptions: topics.map(topic => ({
+                topic,
+                active: true,
+                priority: 10,
+            })),
+        };
+    }
+    /**
+     * Handle IRIS response
+     */
+    handleIrisResponse(data) {
+        try {
+            const response = typeof data === 'string' ? JSON.parse(data) : data;
+            this.irisDebug(`IRIS Response: ${response.type || 'unknown'}`);
+            
+            if (response.type === 'heartbeat') {
+                this.client.emit('iris_heartbeat', response);
+            } else if (response.type === 'error') {
+                this.client.emit('error', new Error(`IRIS Error: ${response.message}`));
+            } else if (response.type === 'subscription_response') {
+                this.client.emit('iris_subscription', response);
+            }
+            return response;
+        } catch (err) {
+            this.irisDebug(`Failed to parse IRIS response: ${err.message}`);
+            return null;
+        }
+    }
+}
+exports.IrisHandshake = IrisHandshake;

package/dist/realtime/protocols/proto-definitions.js

@@ -0,0 +1,80 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.PROTO_DEFINITIONS = void 0;
+/**
+ * Protobuf Definitions for Instagram MQTT Protocol
+ * These are the message schemas used in IRIS, Skywalker, and DirectMessage topics
+ */
+exports.PROTO_DEFINITIONS = {
+    DirectRealtimePayload: {
+        type: 'object',
+        fields: {
+            messageType: { type: 'uint32', id: 1 },
+            payload: { type: 'bytes', id: 2 },
+            timestamp: { type: 'uint64', id: 3 },
+        }
+    },
+    IrisMessage: {
+        type: 'object',
+        fields: {
+            messageId: { type: 'string', id: 1 },
+            threadId: { type: 'string', id: 2 },
+            userId: { type: 'uint64', id: 3 },
+            text: { type: 'string', id: 4 },
+            timestamp: { type: 'uint64', id: 5 },
+            itemType: { type: 'string', id: 6 },
+            mediaId: { type: 'string', id: 7 },
+            isDelivered: { type: 'bool', id: 8 },
+            isSeen: { type: 'bool', id: 9 },
+        }
+    },
+    SkywalkerCommand: {
+        type: 'object',
+        fields: {
+            action: { type: 'string', id: 1 },
+            threadId: { type: 'string', id: 2 },
+            data: { type: 'bytes', id: 3 },
+            timestamp: { type: 'uint64', id: 4 },
+            clientContext: { type: 'string', id: 5 },
+        }
+    },
+    PresenceEvent: {
+        type: 'object',
+        fields: {
+            userId: { type: 'uint64', id: 1 },
+            status: { type: 'string', id: 2 }, // online, offline, away
+            lastActivity: { type: 'uint64', id: 3 },
+            device: { type: 'string', id: 4 }, // mobile, web, unknown
+        }
+    },
+    TypingIndicator: {
+        type: 'object',
+        fields: {
+            threadId: { type: 'string', id: 1 },
+            userId: { type: 'uint64', id: 2 },
+            isTyping: { type: 'bool', id: 3 },
+            timestamp: { type: 'uint64', id: 4 },
+        }
+    },
+    MessageReaction: {
+        type: 'object',
+        fields: {
+            messageId: { type: 'string', id: 1 },
+            threadId: { type: 'string', id: 2 },
+            userId: { type: 'uint64', id: 3 },
+            emoji: { type: 'string', id: 4 },
+            timestamp: { type: 'uint64', id: 5 },
+            operation: { type: 'string', id: 6 }, // add, remove
+        }
+    },
+    ClientPayload: {
+        type: 'object',
+        fields: {
+            clientVersion: { type: 'string', id: 1 },
+            clientUserID: { type: 'uint64', id: 2 },
+            clientContext: { type: 'object', id: 3 },
+            capabilities: { type: 'object', id: 4 },
+            subscribeProtoMask: { type: 'uint32', id: 5 },
+        }
+    },
+};

package/dist/realtime/protocols/skywalker.protocol.js

@@ -0,0 +1,91 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.SkywalkerProtocol = void 0;
+const shared_1 = require("../../shared");
+const uuid_1 = require("uuid");
+/**
+ * Skywalker Protocol - Real-time presence, typing, and reactions
+ */
+class SkywalkerProtocol {
+    constructor(client) {
+        this.skyDebug = (0, shared_1.debugChannel)('realtime', 'skywalker');
+        this.client = client;
+    }
+    /**
+     * Send typing indicator
+     */
+    async sendTypingIndicator(threadId, isTyping = true) {
+        this.skyDebug(`${isTyping ? 'Starting' : 'Stopping'} typing in thread ${threadId}`);
+        const command = {
+            action: isTyping ? 'typing_on' : 'typing_off',
+            thread_id: threadId,
+            timestamp: Date.now(),
+            client_context: (0, uuid_1.v4)(),
+        };
+        return this.client.directCommands?.sendCommand({
+            action: 'send_typing',
+            data: command,
+            threadId,
+        });
+    }
+    /**
+     * Send message reaction
+     */
+    async sendReaction(messageId, threadId, reactionEmoji) {
+        this.skyDebug(`Sending reaction ${reactionEmoji} to message ${messageId}`);
+        const command = {
+            action: 'reaction',
+            message_id: messageId,
+            thread_id: threadId,
+            emoji: reactionEmoji,
+            timestamp: Date.now(),
+            client_context: (0, uuid_1.v4)(),
+        };
+        return this.client.directCommands?.sendCommand({
+            action: 'send_reaction',
+            data: command,
+            threadId,
+        });
+    }
+    /**
+     * Handle Skywalker event
+     */
+    handleSkywalkerEvent(data) {
+        try {
+            const event = typeof data === 'string' ? JSON.parse(data) : data;
+            this.skyDebug(`Skywalker Event: ${event.type || 'unknown'}`);
+            
+            if (event.type === 'typing_on') {
+                this.client.emit('typing', {
+                    user_id: event.from_user_id,
+                    thread_id: event.thread_id,
+                    is_typing: true,
+                });
+            } else if (event.type === 'typing_off') {
+                this.client.emit('typing', {
+                    user_id: event.from_user_id,
+                    thread_id: event.thread_id,
+                    is_typing: false,
+                });
+            } else if (event.type === 'reaction') {
+                this.client.emit('reaction', {
+                    message_id: event.message_id,
+                    user_id: event.from_user_id,
+                    emoji: event.emoji,
+                    thread_id: event.thread_id,
+                });
+            } else if (event.type === 'presence') {
+                this.client.emit('presence', {
+                    user_id: event.user_id,
+                    status: event.status, // online, offline, away
+                    last_activity: event.last_activity,
+                });
+            }
+            return event;
+        } catch (err) {
+            this.skyDebug(`Failed to parse Skywalker event: ${err.message}`);
+            return null;
+        }
+    }
+}
+exports.SkywalkerProtocol = SkywalkerProtocol;

package/dist/realtime/realtime.client.events.js

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