nodejs-insta-private-api-mqt 1.3.83 → 1.3.84

package/dist-ts/dist/realtime/proto-parser.js

@@ -0,0 +1,186 @@
+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) {
+        var _a;
+        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 ${((_a = message.items) === null || _a === void 0 ? void 0 : _a.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-ts/dist/realtime/protocols/iris.handshake.js

@@ -0,0 +1,76 @@
+"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-ts/dist/realtime/protocols/skywalker.protocol.js

@@ -0,0 +1,96 @@
+"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) {
+        var _a;
+        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 (_a = this.client.directCommands) === null || _a === void 0 ? void 0 : _a.sendCommand({
+            action: 'send_typing',
+            data: command,
+            threadId,
+        });
+    }
+    /**
+     * Send message reaction
+     */
+    async sendReaction(messageId, threadId, reactionEmoji) {
+        var _a;
+        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 (_a = this.client.directCommands) === null || _a === void 0 ? void 0 : _a.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-ts/dist/realtime/realtime.client.events.js

@@ -0,0 +1,2 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });