nodejs-insta-private-api-mqtt 1.0.0

package/dist/realtime/proto/ig-messages.proto

@@ -0,0 +1,83 @@
+// Instagram Direct Messages Protocol (Protobuf)
+// Used for real-time message sync via MQTT
+
+syntax = "proto3";
+
+package ig.iris;
+
+// DirectMessage - Single message in a thread
+message DirectMessage {
+  int64 message_id = 1;
+  int64 user_id = 2;
+  string content = 3;
+  int64 timestamp = 4;
+  
+  // Message type: text, photo, video, etc.
+  string type = 5;
+  
+  // Reactions: emoji -> count
+  map<string, int32> reactions = 6;
+  
+  // Whether user has seen
+  bool is_sent = 7;
+  bool is_delivered = 8;
+  bool is_read = 9;
+}
+
+// DirectThread - Conversation thread
+message DirectThread {
+  int64 thread_id = 1;
+  repeated int64 participant_ids = 2;
+  string thread_title = 3;
+  int64 last_message_ts = 4;
+  
+  // Admin user ID
+  int64 admin_user_id = 5;
+  
+  // Is group thread
+  bool is_group = 6;
+  
+  // Is archived
+  bool is_archived = 7;
+}
+
+// TypingIndicator - User typing signal
+message TypingIndicator {
+  int64 thread_id = 1;
+  int64 from_user_id = 2;
+  int64 timestamp = 3;
+  
+  // 0 = typing, 1 = stopped
+  int32 state = 4;
+}
+
+// PresenceStatus - User online/offline
+message PresenceStatus {
+  int64 user_id = 1;
+  
+  // 0 = offline, 1 = active, 2 = idle
+  int32 status = 2;
+  
+  int64 timestamp = 3;
+  int64 last_active = 4;
+}
+
+// DeltaMessage - Incremental sync update
+message DeltaMessage {
+  int64 sequence_id = 1;
+  string operation = 2; // add, update, delete
+  
+  oneof data {
+    DirectMessage message = 3;
+    DirectThread thread = 4;
+    TypingIndicator typing = 5;
+    PresenceStatus presence = 6;
+  }
+}
+
+// Acknowledgment - Server expects ACK for delivery
+message Acknowledgment {
+  int64 message_id = 1;
+  int64 thread_id = 2;
+  int64 timestamp = 3;
+}

package/dist/realtime/proto/iris.proto

@@ -0,0 +1,188 @@
+syntax = "proto3";
+
+package ig.iris;
+
+import "common.proto";
+
+// Real Instagram Iris Protocol - Direct Messages & Realtime
+// Based on reverse-engineered instagram_mqtt package
+
+message IrisPayload {
+  string action = 1;
+  int64 seq_id = 2;
+  repeated IrisItem items = 3;
+  map<string, string> metadata = 4;
+}
+
+message IrisItem {
+  string id = 1;
+  string type = 2; // message, thread, typing, presence, deletion
+  int64 timestamp = 3;
+  
+  oneof data {
+    MessageSyncMessage message = 4;
+    ThreadUpdate thread = 5;
+    TypingIndicator typing = 6;
+    PresenceIndicator presence = 7;
+  }
+  
+  string op = 8; // add, replace, delete
+  string path = 9; // JSON path to item
+}
+
+// Message from sync - includes text, media, reactions
+message MessageSyncMessage {
+  string item_id = 1;
+  int64 user_id = 2;
+  int64 timestamp = 3;
+  
+  string thread_id = 4;
+  string thread_v2_id = 5;
+  
+  // Message type: text, media, like, hashtag, media_share, location, voice_media, animated_media
+  string item_type = 6;
+  string text = 7;
+  
+  // Media references
+  MediaData media = 8;
+  VoiceMediaData voice_media = 9;
+  AnimatedMediaData animated_media = 10;
+  MediaShareData media_share = 11;
+  
+  // Reactions
+  ReactionData reactions = 12;
+  
+  // Metadata
+  bool is_sent = 13;
+  bool is_delivered = 14;
+  bool is_read = 15;
+  
+  // Voice/Video Call info
+  string raven_media_type = 16;
+  map<string, string> extra_data = 17;
+}
+
+message MediaData {
+  string id = 1;
+  int32 media_type = 2; // 1=image, 2=video, 8=album
+  
+  int32 original_width = 3;
+  int32 original_height = 4;
+  
+  repeated string image_urls = 5;
+  repeated string video_urls = 6;
+}
+
+message VoiceMediaData {
+  string id = 1;
+  string audio_src = 2;
+  int32 duration = 3;
+  repeated int32 waveform_data = 4;
+  
+  bool seen = 5;
+  int32 seen_count = 6;
+}
+
+message AnimatedMediaData {
+  string id = 1;
+  string url = 2;
+  bool is_sticker = 3;
+  bool is_random = 4;
+}
+
+message MediaShareData {
+  string id = 1;
+  string code = 2;
+  int32 media_type = 3;
+  
+  int32 original_width = 4;
+  int32 original_height = 5;
+  
+  string caption = 6;
+  int32 like_count = 7;
+  int32 comment_count = 8;
+  int64 taken_at = 9;
+}
+
+message ReactionData {
+  map<int64, string> emojis = 1; // user_id -> emoji
+  int32 likes_count = 2;
+  int32 emojis_count = 3;
+  
+  repeated ReactionItem likes = 4;
+  repeated ReactionItem emoji_reactions = 5;
+}
+
+message ReactionItem {
+  int64 sender_id = 1;
+  int64 timestamp = 2;
+  string client_context = 3;
+  string emoji = 4;
+}
+
+// Thread Update - conversation data
+message ThreadUpdate {
+  string thread_id = 1;
+  string thread_v2_id = 2;
+  
+  // Participants
+  repeated int64 user_ids = 3;
+  repeated int64 left_user_ids = 4;
+  repeated int64 admin_user_ids = 5;
+  
+  // Thread info
+  string thread_title = 6;
+  int64 last_activity_at = 7;
+  
+  bool is_group = 8;
+  bool is_archived = 9;
+  bool is_muted = 10;
+  bool is_pinned = 11;
+  bool is_spam = 12;
+  
+  string thread_type = 13; // private, group
+  int32 folder = 14;
+  
+  // Last message in thread
+  MessageSyncMessage last_message = 15;
+  
+  // Pagination
+  bool has_older = 16;
+  bool has_newer = 17;
+  string newest_cursor = 18;
+  string oldest_cursor = 19;
+  string next_cursor = 20;
+  
+  map<string, ThreadMetadata> metadata = 21;
+}
+
+message ThreadMetadata {
+  string key = 1;
+  string value = 2;
+}
+
+// Typing indicator
+message TypingIndicator {
+  int64 thread_id = 1;
+  int64 from_user_id = 2;
+  string state = 3; // started, stopped
+  int64 timestamp = 4;
+}
+
+// User presence indicator
+message PresenceIndicator {
+  int64 user_id = 1;
+  string status = 2; // active, inactive
+  int64 last_seen_at = 3;
+  int64 timestamp = 4;
+}
+
+// Delta - incremental update
+message Delta {
+  string operation = 1; // add, update, delete
+  string path = 2;
+  
+  IrisItem item = 3;
+  
+  map<string, string> context = 4;
+}

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: '311.0.0.0',
+            clientUserID: this.client.ig.state.cookieUserId,
+            clientContext: {
+                clientContextVersion: '1',
+                clientContextType: 'mobile',
+                appVersion: '311.0.0.0',
+                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: '311.0.0.0',
+            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