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

package/{dist-ts → dist}/dist/realtime/commands/enhanced.direct.commands.js

@@ -1125,7 +1125,6 @@ class EnhancedDirectCommands {
      * @returns {Promise<Object>} - REST broadcast response
      */
     async sendRavenPhoto({ photoBuffer, threadId, viewMode = 'once', mimeType = 'image/jpeg' }) {
-        var _a, _b, _c, _d;
         this.enhancedDebug(`Sending raven photo to thread ${threadId} (viewMode: ${viewMode})`);
         try {
             if (!photoBuffer || !Buffer.isBuffer(photoBuffer) || photoBuffer.length === 0) {
@@ -1238,10 +1237,10 @@ class EnhancedDirectCommands {
                 edits: JSON.stringify({ filter_type: 0, filter_strength: 0.5, crop_original_size: [720.0, 1280.0] }),
                 extra: JSON.stringify({ source_width: 720, source_height: 1280 }),
                 device: JSON.stringify({
-                    manufacturer: ((_a = ig.state.devicePayload) === null || _a === void 0 ? void 0 : _a.manufacturer) || 'samsung',
-                    model: ((_b = ig.state.devicePayload) === null || _b === void 0 ? void 0 : _b.model) || 'SM-S938B',
-                    android_version: ((_c = ig.state.devicePayload) === null || _c === void 0 ? void 0 : _c.android_version) || 35,
-                    android_release: ((_d = ig.state.devicePayload) === null || _d === void 0 ? void 0 : _d.android_release) || '15',
+                    manufacturer: ig.state.devicePayload?.manufacturer || 'samsung',
+                    model: ig.state.devicePayload?.model || 'SM-S938B',
+                    android_version: ig.state.devicePayload?.android_version || 35,
+                    android_release: ig.state.devicePayload?.android_release || '15',
                 }),
             };
             if (attachmentFbid) {
@@ -1292,7 +1291,6 @@ class EnhancedDirectCommands {
      * @returns {Promise<Object>} - REST broadcast response
      */
     async sendRavenVideo({ videoBuffer, threadId, viewMode = 'once', duration = 0, width = 720, height = 1280 }) {
-        var _a, _b, _c, _d;
         this.enhancedDebug(`Sending raven video to thread ${threadId} (viewMode: ${viewMode})`);
         try {
             if (!videoBuffer || !Buffer.isBuffer(videoBuffer) || videoBuffer.length === 0) {
@@ -1406,10 +1404,10 @@ class EnhancedDirectCommands {
                 }),
                 extra: JSON.stringify({ source_width: width, source_height: height }),
                 device: JSON.stringify({
-                    manufacturer: ((_a = ig.state.devicePayload) === null || _a === void 0 ? void 0 : _a.manufacturer) || 'samsung',
-                    model: ((_b = ig.state.devicePayload) === null || _b === void 0 ? void 0 : _b.model) || 'SM-S938B',
-                    android_version: ((_c = ig.state.devicePayload) === null || _c === void 0 ? void 0 : _c.android_version) || 35,
-                    android_release: ((_d = ig.state.devicePayload) === null || _d === void 0 ? void 0 : _d.android_release) || '15',
+                    manufacturer: ig.state.devicePayload?.manufacturer || 'samsung',
+                    model: ig.state.devicePayload?.model || 'SM-S938B',
+                    android_version: ig.state.devicePayload?.android_version || 35,
+                    android_release: ig.state.devicePayload?.android_release || '15',
                 }),
             };
             if (attachmentFbid) {

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

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

package/dist/dist/realtime/delta-sync.manager.d.ts

@@ -0,0 +1,82 @@
+declare const debug: any;
+/**
+ * Delta Sync Manager - Apply real Instagram delta updates to local state
+ * Based on MessageSync format from reverse-engineered instagram_mqtt
+ */
+declare class DeltaSyncManager {
+    constructor();
+    /**
+     * Apply delta operations (add/update/delete) to local state
+     */
+    applyDelta(delta: any): {
+        applied: number;
+        errors: any[];
+        stats: any;
+        total?: undefined;
+    } | {
+        applied: number;
+        errors: any[];
+        total: any;
+        stats: any;
+    };
+    /**
+     * Apply single item (message, thread, typing, presence)
+     */
+    applyItem(item: any): boolean;
+    /**
+     * Apply message delta (real Instagram MessageSyncMessage format)
+     */
+    applyMessage(operation: any, message: any): boolean;
+    /**
+     * Apply thread delta (real Instagram ThreadUpdate format)
+     */
+    applyThread(operation: any, thread: any): boolean;
+    /**
+     * Apply typing indicator delta
+     */
+    applyTyping(operation: any, typing: any): boolean;
+    /**
+     * Apply presence indicator delta
+     */
+    applyPresence(operation: any, presence: any): boolean;
+    /**
+     * Subscribe to state changes
+     */
+    subscribe(callback: any): () => void;
+    /**
+     * Notify listeners of changes
+     */
+    notifyListeners(delta: any): void;
+    /**
+     * Get current synchronized state
+     */
+    getState(): {
+        threads: any;
+        messages: any;
+        typing: any;
+        presence: any;
+    };
+    /**
+     * Query methods
+     */
+    getThread(threadId: any): any;
+    getThreadMessages(threadId: any): unknown[];
+    getThreads(): unknown[];
+    getAllMessages(): unknown[];
+    getTypingInThread(threadId: any): any;
+    getUserPresence(userId: any): any;
+    /**
+     * Stats
+     */
+    getStats(): {
+        threads: number;
+        messages: number;
+        typing: number;
+        presence: number;
+        operations: any;
+    };
+    /**
+     * Clear all state
+     */
+    clear(): void;
+}

package/{dist-ts → dist}/dist/realtime/delta-sync.manager.js

@@ -53,22 +53,21 @@ class DeltaSyncManager {
      * Apply single item (message, thread, typing, presence)
      */
     applyItem(item) {
-        var _a, _b, _c, _d;
         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 ((_a = item.data) === null || _a === void 0 ? void 0 : _a.message) {
+        if (item.data?.message) {
             return this.applyMessage(operation, item.data.message);
         }
-        if ((_b = item.data) === null || _b === void 0 ? void 0 : _b.thread) {
+        if (item.data?.thread) {
             return this.applyThread(operation, item.data.thread);
         }
-        if ((_c = item.data) === null || _c === void 0 ? void 0 : _c.typing) {
+        if (item.data?.typing) {
             return this.applyTyping(operation, item.data.typing);
         }
-        if ((_d = item.data) === null || _d === void 0 ? void 0 : _d.presence) {
+        if (item.data?.presence) {
             return this.applyPresence(operation, item.data.presence);
         }
         // Fallback for direct objects
@@ -90,7 +89,6 @@ class DeltaSyncManager {
      * Apply message delta (real Instagram MessageSyncMessage format)
      */
     applyMessage(operation, message) {
-        var _a, _b;
         const msgId = message.item_id;
         if (operation === 'delete' || operation === 'deletion') {
             delete this.state.messages[msgId];
@@ -105,20 +103,19 @@ class DeltaSyncManager {
             }
             Object.assign(this.state.messages[msgId], message);
             this.operations.update++;
-            debug(`✏️  Updated message ${msgId}: "${(_a = message.text) === null || _a === void 0 ? void 0 : _a.substring(0, 30)}"`);
+            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}: "${((_b = message.text) === null || _b === void 0 ? void 0 : _b.substring(0, 30)) || 'media'}"`);
+        debug(`➕ Added message ${msgId}: "${message.text?.substring(0, 30) || 'media'}"`);
         return true;
     }
     /**
      * Apply thread delta (real Instagram ThreadUpdate format)
      */
     applyThread(operation, thread) {
-        var _a;
         const threadId = thread.thread_id || thread.thread_v2_id;
         if (operation === 'delete') {
             delete this.state.threads[threadId];
@@ -142,7 +139,7 @@ class DeltaSyncManager {
         // add/default
         this.state.threads[threadId] = thread;
         this.operations.add++;
-        debug(`➕ Added thread: "${thread.thread_title}" (${((_a = thread.user_ids) === null || _a === void 0 ? void 0 : _a.length) || 1} members)`);
+        debug(`➕ Added thread: "${thread.thread_title}" (${thread.user_ids?.length || 1} members)`);
         return true;
     }
     /**

package/dist/dist/realtime/features/dm-sender.d.ts

@@ -0,0 +1,20 @@
+declare const shared_1: any;
+declare const uuid_1: any;
+/**
+ * Direct Message Sender via MQTT
+ */
+declare class DMSender {
+    constructor(client: any);
+    /**
+     * Send text message via MQTT
+     */
+    sendTextMessage(threadId: any, text: any, clientContext?: any): Promise<any>;
+    /**
+     * Send media message via MQTT (photo/video)
+     */
+    sendMediaMessage(threadId: any, mediaId: any, mediaType?: string, clientContext?: any): Promise<any>;
+    /**
+     * Send link message
+     */
+    sendLinkMessage(threadId: any, url: any, title?: any, clientContext?: any): Promise<any>;
+}

package/{src-ts/dist/realtime/features/dm-sender.ts → dist/dist/realtime/features/dm-sender.js}

@@ -30,7 +30,8 @@ class DMSender {
                 data: command,
                 threadId,
             });
-        } catch (err) {
+        }
+        catch (err) {
             this.dmDebug(`Failed to send message: ${err.message}`);
             throw err;
         }
@@ -54,7 +55,8 @@ class DMSender {
                 data: command,
                 threadId,
             });
-        } catch (err) {
+        }
+        catch (err) {
             this.dmDebug(`Failed to send media: ${err.message}`);
             throw err;
         }
@@ -79,7 +81,8 @@ class DMSender {
                 data: command,
                 threadId,
             });
-        } catch (err) {
+        }
+        catch (err) {
             this.dmDebug(`Failed to send link: ${err.message}`);
             throw err;
         }

package/dist/dist/realtime/features/error-handler.d.ts

@@ -0,0 +1,33 @@
+declare const shared_1: any;
+declare const ERROR_TYPES: {
+    RATE_LIMIT: string;
+    AUTH_FAILURE: string;
+    NETWORK: string;
+    PROTOCOL: string;
+    SERVER: string;
+    UNKNOWN: string;
+};
+declare const RATE_LIMIT_PATTERNS: string[];
+declare const AUTH_PATTERNS: string[];
+declare const NETWORK_PATTERNS: string[];
+declare class ErrorHandler {
+    constructor(client: any);
+    classifyError(error: any): string;
+    getBackoffForType(errorType: any, attemptNumber: any): number;
+    handleConnectionError(error: any): boolean;
+    isRateLimited(): boolean;
+    getRateLimitRemainingMs(): number;
+    handlePayloadError(error: any, topic: any): void;
+    handleProtocolError(error: any): void;
+    resetErrorCounter(): void;
+    getErrorStats(): {
+        errorCount: any;
+        maxRetries: any;
+        canRetry: boolean;
+        isRateLimited: boolean;
+        rateLimitRemainingMs: number;
+        consecutiveAuthFailures: any;
+        recentErrorCount: any;
+        typeBreakdown: {};
+    };
+}

package/{dist-ts → dist}/dist/realtime/features/error-handler.js

@@ -37,7 +37,7 @@ class ErrorHandler {
         this.consecutiveAuthFailures = 0;
     }
     classifyError(error) {
-        const msg = ((error === null || error === void 0 ? void 0 : error.message) || String(error)).toLowerCase();
+        const msg = (error?.message || String(error)).toLowerCase();
         for (const pattern of RATE_LIMIT_PATTERNS) {
             if (msg.includes(pattern))
                 return ERROR_TYPES.RATE_LIMIT;
@@ -81,13 +81,13 @@ class ErrorHandler {
         const delay = this.getBackoffForType(errorType, this.errorCount);
         this.errorHistory.push({
             type: errorType,
-            message: (error === null || error === void 0 ? void 0 : error.message) || String(error),
+            message: error?.message || String(error),
             timestamp: Date.now(),
             attempt: this.errorCount,
         });
         if (this.errorHistory.length > 50)
             this.errorHistory.shift();
-        this.errorDebug(`[${errorType.toUpperCase()}] Error (${this.errorCount}/${this.maxRetries}): ${(error === null || error === void 0 ? void 0 : error.message) || error}`);
+        this.errorDebug(`[${errorType.toUpperCase()}] Error (${this.errorCount}/${this.maxRetries}): ${error?.message || error}`);
         if (errorType === ERROR_TYPES.RATE_LIMIT) {
             this.rateLimitUntil = Date.now() + delay;
             this.errorDebug(`Rate limited. Waiting ${Math.round(delay / 1000)}s before retry.`);
@@ -98,7 +98,7 @@ class ErrorHandler {
                 this.errorDebug('Multiple auth failures. Credentials may need refresh.');
                 this.client.emit('auth_failure', {
                     count: this.consecutiveAuthFailures,
-                    error: (error === null || error === void 0 ? void 0 : error.message) || String(error),
+                    error: error?.message || String(error),
                 });
                 return false;
             }

package/dist/dist/realtime/features/gap-handler.d.ts

@@ -0,0 +1,19 @@
+declare const shared_1: any;
+/**
+ * Gap Handler - Handle message gaps and synchronization
+ */
+declare class GapHandler {
+    constructor(client: any);
+    /**
+     * Detect message gap in thread
+     */
+    detectGap(threadId: any, lastMessageId: any, newMessageId: any): boolean;
+    /**
+     * Handle gap by requesting missing messages
+     */
+    handleGap(threadId: any, gapFrom: any, gapTo: any): Promise<any>;
+    /**
+     * Clear gap tracking for thread
+     */
+    clearGap(threadId: any): void;
+}

package/dist/dist/realtime/features/persistent-logger.d.ts

@@ -0,0 +1,28 @@
+declare const fs: any;
+declare const path: any;
+declare const DEFAULT_MAX_FILE_SIZE: number;
+declare const DEFAULT_MAX_FILES = 5;
+declare const DEFAULT_FLUSH_INTERVAL = 30000;
+declare class PersistentLogger {
+    constructor(options?: {});
+    start(): void;
+    stop(): void;
+    debug(...args: any[]): void;
+    info(...args: any[]): void;
+    warn(...args: any[]): void;
+    error(...args: any[]): void;
+    _write(level: any, args: any): void;
+    _flush(): void;
+    _rotateIfNeeded(): void;
+    _cleanOldFiles(): void;
+    getLogFiles(): any;
+    getRecentLines(count?: number): any;
+    getStats(): {
+        started: any;
+        totalLines: any;
+        bufferSize: any;
+        currentFile: any;
+        currentFileSize: any;
+        logFiles: any;
+    };
+}

package/{dist-ts → dist}/dist/realtime/features/persistent-logger.js

@@ -31,7 +31,7 @@ class PersistentLogger {
             }
         }
         catch (e) {
-            console.error('[LOGGER] Failed to create log directory:', (e === null || e === void 0 ? void 0 : e.message) || e);
+            console.error('[LOGGER] Failed to create log directory:', e?.message || e);
         }
         this._rotateIfNeeded();
         this._flushTimer = setInterval(() => {
@@ -93,7 +93,7 @@ class PersistentLogger {
         }
         catch (e) {
             if (this.logToConsole) {
-                console.error('[LOGGER] Failed to flush:', (e === null || e === void 0 ? void 0 : e.message) || e);
+                console.error('[LOGGER] Failed to flush:', e?.message || e);
             }
         }
     }
@@ -115,7 +115,7 @@ class PersistentLogger {
         }
         catch (e) {
             if (this.logToConsole) {
-                console.error('[LOGGER] Rotation error:', (e === null || e === void 0 ? void 0 : e.message) || e);
+                console.error('[LOGGER] Rotation error:', e?.message || e);
             }
         }
     }

package/dist/dist/realtime/features/presence.manager.d.ts

@@ -0,0 +1,24 @@
+declare const shared_1: any;
+declare const uuid_1: any;
+/**
+ * Presence Manager - Handle online/offline status
+ */
+declare class PresenceManager {
+    constructor(client: any);
+    /**
+     * Update user presence
+     */
+    updatePresence(userId: any, status: any, lastActivity?: number): void;
+    /**
+     * Get user presence
+     */
+    getPresence(userId: any): any;
+    /**
+     * Broadcast user's own presence
+     */
+    broadcastPresence(status?: string): Promise<any>;
+    /**
+     * Handle presence update
+     */
+    handlePresenceUpdate(data: any): any;
+}

package/{src-ts/dist/realtime/features/presence.manager.ts → dist/dist/realtime/features/presence.manager.js}

@@ -57,7 +57,8 @@ class PresenceManager {
                 this.updatePresence(update.user_id, update.status, update.last_activity);
             }
             return update;
-        } catch (err) {
+        }
+        catch (err) {
             this.presenceDebug(`Failed to parse presence update: ${err.message}`);
             return null;
         }

package/dist/dist/realtime/features/session-health-monitor.d.ts

@@ -0,0 +1,93 @@
+declare const EventEmitter: any;
+declare const SESSION_CHECK_INTERVAL: number;
+declare const SESSION_CHECK_JITTER: number;
+declare const MIN_CHECK_INTERVAL: number;
+declare class SessionHealthMonitor extends EventEmitter {
+    constructor(realtimeClient: any, options?: {});
+    start(): void;
+    stop(): void;
+    _scheduleNextCheck(): void;
+    _performCheck(): Promise<boolean>;
+    _checkSessionValidity(): Promise<{
+        valid: boolean;
+        userId: any;
+        username: any;
+        fullName: any;
+        reason?: undefined;
+        statusCode?: undefined;
+        rateLimited?: undefined;
+        requiresRelogin?: undefined;
+        networkError?: undefined;
+    } | {
+        valid: boolean;
+        reason: string;
+        statusCode: any;
+        rateLimited: boolean;
+        userId?: undefined;
+        username?: undefined;
+        fullName?: undefined;
+        requiresRelogin?: undefined;
+        networkError?: undefined;
+    } | {
+        valid: boolean;
+        reason: any;
+        statusCode: any;
+        requiresRelogin: boolean;
+        userId?: undefined;
+        username?: undefined;
+        fullName?: undefined;
+        rateLimited?: undefined;
+        networkError?: undefined;
+    } | {
+        valid: boolean;
+        reason: string;
+        networkError: boolean;
+        userId?: undefined;
+        username?: undefined;
+        fullName?: undefined;
+        statusCode?: undefined;
+        rateLimited?: undefined;
+        requiresRelogin?: undefined;
+    } | {
+        valid: boolean;
+        reason: any;
+        statusCode: any;
+        userId?: undefined;
+        username?: undefined;
+        fullName?: undefined;
+        rateLimited?: undefined;
+        requiresRelogin?: undefined;
+        networkError?: undefined;
+    }>;
+    _attemptRelogin(): Promise<boolean>;
+    forceCheck(): Promise<boolean>;
+    isSessionValid(): any;
+    getStats(): {
+        running: any;
+        sessionValid: any;
+        startedAt: string;
+        totalRuntimeMs: number;
+        totalRuntimeHuman: string;
+        totalUptimeMs: any;
+        totalUptimeHuman: string;
+        uptimePercent: number;
+        currentSessionMs: number;
+        currentSessionHuman: string;
+        longestSessionMs: number;
+        longestSessionHuman: string;
+        totalChecks: any;
+        successfulChecks: any;
+        failedChecks: any;
+        sessionExpiries: any;
+        reconnects: any;
+        relogins: any;
+        successfulRelogins: any;
+        failedRelogins: any;
+        consecutiveFailures: any;
+        lastCheckAt: string;
+        lastCheckResult: any;
+    };
+    _recordUptimeSegment(): void;
+    _humanDuration(ms: any): string;
+    _log(...args: any[]): void;
+}