nodejs-insta-private-api-mqt 1.3.85 → 1.3.87

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

@@ -0,0 +1,2 @@
+declare var __createBinding: any;
+declare var __exportStar: any;

package/dist/dist/realtime/parsers/iris-parser.d.ts

@@ -0,0 +1,18 @@
+/**
+ * Iris Parser
+ *
+ * Parses Iris messages from Instagram's realtime system.
+ * Iris is Instagram's internal messaging system for real-time updates.
+ */
+declare class IrisParser {
+    /**
+     * Parse an Iris message
+     * @param {Buffer|string} data - The raw message data
+     * @returns {Object} Parsed Iris data
+     */
+    parse(data: any): {
+        type: string;
+        data: any;
+        raw: any;
+    };
+}

package/dist/dist/realtime/parsers/iris.parser.d.ts

@@ -0,0 +1,3 @@
+declare class IrisParser {
+    parseMessage(topic: any, payload: any): any;
+}

package/dist/dist/realtime/parsers/json-parser.d.ts

@@ -0,0 +1,18 @@
+/**
+ * JSON Parser
+ *
+ * Parses JSON messages from Instagram's realtime system.
+ * This is a general-purpose parser for JSON-formatted messages.
+ */
+declare class JsonParser {
+    /**
+     * Parse a JSON message
+     * @param {Buffer|string} data - The raw message data
+     * @returns {Object} Parsed JSON data
+     */
+    parse(data: any): {
+        type: string;
+        data: any;
+        raw: any;
+    };
+}

package/dist/dist/realtime/parsers/json.parser.d.ts

@@ -0,0 +1,6 @@
+declare class JsonParser {
+    parseMessage(topic: any, payload: any): {
+        topic: any;
+        data: any;
+    };
+}

package/dist/dist/realtime/parsers/region-hint-parser.d.ts

@@ -0,0 +1,18 @@
+/**
+ * Region Hint Parser
+ *
+ * Parses region hint messages from Instagram's realtime system.
+ * These messages contain information about the user's region/location.
+ */
+declare class RegionHintParser {
+    /**
+     * Parse a region hint message
+     * @param {Buffer|string} data - The raw message data
+     * @returns {Object} Parsed region hint data
+     */
+    parse(data: any): {
+        type: string;
+        data: any;
+        raw: any;
+    };
+}

package/dist/dist/realtime/parsers/region-hint.parser.d.ts

@@ -0,0 +1,4 @@
+declare const thrift_1: any;
+declare class RegionHintParser {
+    constructor();
+}

package/dist/dist/realtime/parsers/skywalker-parser.d.ts

@@ -0,0 +1,18 @@
+/**
+ * Skywalker Parser
+ *
+ * Parses Skywalker messages from Instagram's realtime system.
+ * Skywalker is Instagram's pub/sub system for real-time updates.
+ */
+declare class SkywalkerParser {
+    /**
+     * Parse a Skywalker message
+     * @param {Buffer|string} data - The raw message data
+     * @returns {Object} Parsed Skywalker data
+     */
+    parse(data: any): {
+        type: string;
+        data: any;
+        raw: any;
+    };
+}

package/dist/dist/realtime/parsers/skywalker.parser.d.ts

@@ -0,0 +1,7 @@
+declare const thrift_1: any;
+declare class SkywalkerParser {
+    parseMessage(topic: any, payload: any): {
+        topic: any;
+        data: any;
+    };
+}

package/dist/dist/realtime/parsers-advanced.d.ts

@@ -0,0 +1,93 @@
+declare const debug: any;
+declare const ProtoParser: any;
+declare const protoParser: any;
+/**
+ * Advanced Topic-Specific Parsers
+ */
+declare function parseIris(topicId: any, payload: any): {
+    type: string;
+    messages: any;
+    threads: any;
+    typing: any;
+    error?: undefined;
+    raw?: undefined;
+} | {
+    type: string;
+    error: any;
+    raw: any;
+    messages?: undefined;
+    threads?: undefined;
+    typing?: undefined;
+};
+declare function parseGraphQL(topicId: any, payload: any): {
+    type: string;
+    data: any;
+    messages: any;
+    error?: undefined;
+} | {
+    type: string;
+    error: any;
+    data?: undefined;
+    messages?: undefined;
+};
+declare function parseDelta(topicId: any, payload: any): {
+    type: string;
+    seqId: any;
+    action: any;
+    items: any;
+    metadata: any;
+    error?: undefined;
+} | {
+    type: string;
+    error: any;
+    seqId?: undefined;
+    action?: undefined;
+    items?: undefined;
+    metadata?: undefined;
+};
+declare function parsePresence(topicId: any, payload: any): {
+    type: string;
+    items: any;
+    error?: undefined;
+} | {
+    type: string;
+    error: any;
+    items?: undefined;
+};
+declare function parseFeed(topicId: any, payload: any): {
+    type: string;
+    decoded: any;
+    items: any;
+    error: any;
+};
+declare function parseLive(topicId: any, payload: any): {
+    type: string;
+    decoded: any;
+    items: any;
+    error: any;
+};
+declare function parseRegionHint(topicId: any, payload: any): {
+    type: string;
+    region: any;
+    endpoint: any;
+    data: any;
+    raw?: undefined;
+    error?: undefined;
+} | {
+    type: string;
+    raw: any;
+    error: any;
+    region?: undefined;
+    endpoint?: undefined;
+    data?: undefined;
+};
+declare const PARSERS: {
+    iris: typeof parseIris;
+    graphql: typeof parseGraphQL;
+    delta: typeof parseDelta;
+    presence: typeof parsePresence;
+    feed: typeof parseFeed;
+    live: typeof parseLive;
+    'region-hint': typeof parseRegionHint;
+};
+declare function parseByType(topicType: any, topicId: any, payload: any): any;

package/{dist-ts → dist}/dist/realtime/parsers-advanced.js

@@ -49,14 +49,11 @@ function parsePresence(topicId, payload) {
     if (result.success) {
         return {
             type: 'presence',
-            items: result.messages.map(m => {
-                var _a;
-                return ({
-                    userId: m.id,
-                    status: ((_a = m.typing) === null || _a === void 0 ? void 0 : _a.state) || 'unknown',
-                    timestamp: m.timestamp
-                });
-            })
+            items: result.messages.map(m => ({
+                userId: m.id,
+                status: m.typing?.state || 'unknown',
+                timestamp: m.timestamp
+            }))
         };
     }
     return { type: 'presence', error: result.error };

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

@@ -0,0 +1,27 @@
+declare const protobuf: any;
+declare const pako: any;
+declare const debug: any;
+/**
+ * Protobuf Parser - Instagram MQTT messages
+ * Simplified embedded proto without external file dependencies
+ */
+declare class ProtoParser {
+    constructor();
+    init(): void;
+    decompress(buffer: any): any;
+    parsePayload(topicId: any, rawPayload: any): {
+        decoded: any;
+        format: string;
+        error?: undefined;
+    } | {
+        error: any;
+        decoded: any;
+        format?: undefined;
+    };
+    extractMessages(payload: any): any[];
+    isReady(): boolean;
+    getStats(): {
+        ready: boolean;
+        types: number;
+    };
+}

package/{dist-ts → dist}/dist/realtime/proto-parser.js

@@ -108,7 +108,6 @@ message PresenceIndicator {
         }
     }
     parsePayload(topicId, rawPayload) {
-        var _a;
         try {
             if (!rawPayload || rawPayload.length === 0) {
                 return { error: 'Empty', decoded: null };
@@ -123,7 +122,7 @@ message PresenceIndicator {
                         enums: String,
                         bytes: String
                     });
-                    debug(`✓ Decoded ${((_a = message.items) === null || _a === void 0 ? void 0 : _a.length) || 0} items`);
+                    debug(`✓ Decoded ${message.items?.length || 0} items`);
                     return { decoded: message, format: 'protobuf' };
                 }
                 catch (e) {

package/dist/dist/realtime/protocols/iris.handshake.d.ts

@@ -0,0 +1,41 @@
+declare const uuid_1: any;
+declare const shared_1: any;
+/**
+ * IRIS Handshake - Instagram Real-time Iris Sync Protocol
+ * Handles authentication and subscription to IRIS topics
+ */
+declare class IrisHandshake {
+    constructor(client: any);
+    /**
+     * Create IRIS client payload for handshake
+     */
+    createClientPayload(): {
+        clientVersion: string;
+        clientUserID: any;
+        clientContext: {
+            clientContextVersion: string;
+            clientContextType: string;
+            appVersion: string;
+            userAgent: any;
+        };
+        subscribeProtoMask: number;
+        capabilities: {
+            supportsPresenceEvents: boolean;
+            supportsTypingIndicators: boolean;
+            supportsMessageReactions: boolean;
+            supportsForegroundState: boolean;
+        };
+    };
+    /**
+     * Generate IRIS subscription request
+     */
+    generateSubscriptionRequest(topics: any): {
+        requestId: any;
+        clientVersion: string;
+        subscriptions: any;
+    };
+    /**
+     * Handle IRIS response
+     */
+    handleIrisResponse(data: any): any;
+}

package/dist/dist/realtime/protocols/skywalker.protocol.d.ts

@@ -0,0 +1,20 @@
+declare const shared_1: any;
+declare const uuid_1: any;
+/**
+ * Skywalker Protocol - Real-time presence, typing, and reactions
+ */
+declare class SkywalkerProtocol {
+    constructor(client: any);
+    /**
+     * Send typing indicator
+     */
+    sendTypingIndicator(threadId: any, isTyping?: boolean): Promise<any>;
+    /**
+     * Send message reaction
+     */
+    sendReaction(messageId: any, threadId: any, reactionEmoji: any): Promise<any>;
+    /**
+     * Handle Skywalker event
+     */
+    handleSkywalkerEvent(data: any): any;
+}

package/{src-ts/dist/realtime/protocols/skywalker.protocol.ts → dist/dist/realtime/protocols/skywalker.protocol.js}

@@ -54,27 +54,29 @@ class SkywalkerProtocol {
         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') {
+            }
+            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') {
+            }
+            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') {
+            }
+            else if (event.type === 'presence') {
                 this.client.emit('presence', {
                     user_id: event.user_id,
                     status: event.status, // online, offline, away
@@ -82,7 +84,8 @@ class SkywalkerProtocol {
                 });
             }
             return event;
-        } catch (err) {
+        }
+        catch (err) {
             this.skyDebug(`Failed to parse Skywalker event: ${err.message}`);
             return null;
         }

package/dist/dist/realtime/realtime.client.d.ts

@@ -0,0 +1,169 @@
+declare const constants_1: any;
+declare const commands_1: any;
+declare const shared_1: any;
+declare const mqttot_1: any;
+declare const mqtts_1: any;
+declare const errors_1: any;
+declare const eventemitter3_1: any;
+declare const mixins_1: any;
+declare const iris_handshake_1: any;
+declare const skywalker_protocol_1: any;
+declare const presence_manager_1: any;
+declare const dm_sender_1: any;
+declare const error_handler_1: any;
+declare const gap_handler_1: any;
+declare const enhanced_direct_commands_1: any;
+declare const presence_typing_mixin_1: any;
+declare const SessionHealthMonitor: any;
+declare const PersistentLogger: any;
+declare const fs: any;
+declare const path: any;
+declare const INSTAGRAM_VERSION: any;
+/**
+ * RealtimeClient
+ * - Extends EventEmitter to emit high-level events for consumers.
+ * - Responsible for constructing the thrift payload, creating the MQTToTClient and wiring its events.
+ */
+declare class RealtimeClient extends eventemitter3_1.EventEmitter {
+    get mqtt(): any;
+    /**
+     * constructor(ig, mixins)
+     * - ig: instance of instagram client (used for building payloads & fetching inbox)
+     * - mixins: collection of mixins applied to this realtime client (message-sync, realtime-sub, presence/typing)
+     */
+    constructor(ig: any, mixins?: any[]);
+    /**
+     * _loadPersistedMqttSession()
+     * - Attempt to read <authFolder>/mqtt-session.json on startup and restore
+     *   client-generated ids so the client can reuse previous session identifiers.
+     */
+    _loadPersistedMqttSession(): boolean;
+    /**
+     * startRealTimeListener(options)
+     * - Convenience method to fetch initial inbox (IRIS) and connect with those subscriptions.
+     */
+    startRealTimeListener(options?: {}): Promise<{
+        success: boolean;
+    }>;
+    _setupMessageHandlers(): void;
+    _handleIrisReset(): Promise<void>;
+    _handleGraphQLEvent(data: any): void;
+    _handlePubsubEvent(data: any): void;
+    _parseMessage(data: any): any;
+    _parseIrisMessage(data: any): {
+        id: any;
+        userId: any;
+        username: any;
+        text: any;
+        itemType: any;
+        thread_id: any;
+        timestamp: any;
+        status: string;
+    };
+    /**
+     * setInitOptions(initOptions)
+     * - Normalizes init options for connect calls (accepts array or object)
+     */
+    setInitOptions(initOptions: any): void;
+    extractSessionIdFromJWT(): any;
+    /**
+     * constructConnection()
+     * - Build the MQTToTConnection payload (thrift object) used to connect.
+     * - Pulls deviceId, sessionid, device secrets and app-specific headers to populate the payload.
+     */
+    constructConnection(): void;
+    /**
+     * connect(options)
+     * - Creates the MQTToTClient using mqttot.MQTToTClient and the payloadProvider.
+     * - Attaches idempotent lifecycle handlers for connect/close/error.
+     * - Starts keepalive/watchdog timers and message listeners after successful connect.
+     */
+    connect(options: any): Promise<void>;
+    /**
+     * Attempt to detect server-provided MQTT session id and persist it.
+     * This method is defensive: it tries multiple places on the mqtt client object.
+     *
+     * Also: schedule credential refresh if mqttAuth.expiresAt is present (so tokens are refreshed
+     * before they expire).
+     */
+    _onMqttConnected(): Promise<void>;
+    /**
+     * _refreshMqttCredentials()
+     * - Attempt to refresh mqtt credentials using attached auth helper if possible.
+     * - This method is defensive: many auth helpers won't expose refresh methods, so it tries possible hooks and logs results.
+     */
+    _refreshMqttCredentials(): Promise<boolean>;
+    /**
+     * Persist mqtt session details locally and via attached auth helper if available.
+     * Writes <authFolder>/mqtt-session.json as a local backup.
+     */
+    _persistMqttSession(): Promise<void>;
+    /**
+     * _attemptReconnectSafely()
+     * - Ensure only a single reconnect flow runs at once.
+     * - Disconnects existing mqtt client, waits briefly, refreshes credentials when appropriate,
+     *   and calls connect() again with exponential backoff retries.
+     */
+    _attemptReconnectSafely(lastError: any): Promise<void>;
+    /**
+     * _ensureIrisSnapshotAndSubscribe()
+     * - Ensure IRIS snapshot is present and subscribe to it.
+     * - Tries a fresh fetch after connect to get the latest snapshot.
+     */
+    _ensureIrisSnapshotAndSubscribe(): Promise<boolean>;
+    /**
+     * Attach message_sync listener to mqtt if available
+     * - Some mqtt clients provide a listen() helper; attach to both numeric id and string names for compatibility.
+     */
+    _ensureMessageSyncListener(): Promise<void>;
+    _afterConnectHandlers(): Promise<void>;
+    enableHealthMonitor(options?: {}): any;
+    enablePersistentLogger(options?: {}): any;
+    getHealthStats(): any;
+    getLoggerStats(): any;
+    /**
+     * connectFromSavedSession(authStateHelper, options)
+     * - Reconstructs connect options from saved authState and then calls connect()
+     * - Attempts to fetch a fresh IRIS snapshot (up to a few attempts) for safety.
+     */
+    connectFromSavedSession(authStateHelper: any, options?: {}): Promise<this>;
+    /**
+     * saveSession(authStateHelper)
+     * - Helper to persist current MQTT session to auth helper if available.
+     */
+    saveSession(authStateHelper: any): Promise<boolean>;
+    /**
+     * disconnect()
+     * - Perform a graceful shutdown: clear timers and disconnect mqtt client.
+     */
+    disconnect(): any;
+    /**
+     * graphQlSubscribe(sub)
+     * - Helper that delegates to Commands.updateSubscriptions (which uses qos 0).
+     */
+    graphQlSubscribe(sub: any): any;
+    /**
+     * skywalkerSubscribe(sub)
+     * - Delegate to Commands.updateSubscriptions (pubsub topic).
+     */
+    skywalkerSubscribe(sub: any): any;
+    /**
+     * irisSubscribe({ seq_id, snapshot_at_ms })
+     * - Subscribe to IRIS using the provided snapshot properties.
+     */
+    irisSubscribe({ seq_id, snapshot_at_ms, }: {
+        seq_id: any;
+        snapshot_at_ms: any;
+    }): any;
+    /**
+     * Start an "active query" keepalive loop
+     * - This sends a lightweight PUBSUB foreground pulse and a REALTIME_SUB reaffirmation
+     *   on a periodic basis to keep the server-side connection state active.
+     *
+     * Behavior & protections:
+     * - Idle-aware: will skip sending if client received traffic within idleThresholdMs (to avoid unnecessary traffic).
+     * - Interval configurable via initOptions.activeKeepaliveMs (default 45s).
+     * - GraphQL subs reaffirmation uses initOptions.graphQlSubs or defaultGraphQlSubs.
+     */
+    _startActiveQueryKeepalive(): void;
+}