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

package/src-ts/dist/realtime/commands/index.ts

@@ -1,20 +0,0 @@
-"use strict";
-var __createBinding = (this && this.__createBinding) || (Object.create ? (function(o, m, k, k2) {
-    if (k2 === undefined) k2 = k;
-    var desc = Object.getOwnPropertyDescriptor(m, k);
-    if (!desc || ("get" in desc ? !m.__esModule : desc.writable || desc.configurable)) {
-      desc = { enumerable: true, get: function() { return m[k]; } };
-    }
-    Object.defineProperty(o, k2, desc);
-}) : (function(o, m, k, k2) {
-    if (k2 === undefined) k2 = k;
-    o[k2] = m[k];
-}));
-var __exportStar = (this && this.__exportStar) || function(m, exports) {
-    for (var p in m) if (p !== "default" && !Object.prototype.hasOwnProperty.call(exports, p)) __createBinding(exports, m, p);
-};
-Object.defineProperty(exports, "__esModule", { value: true });
-__exportStar(require("./commands"), exports);
-__exportStar(require("./direct.commands"), exports);
-__exportStar(require("./enhanced.direct.commands"), exports);
-//# sourceMappingURL=index.js.map

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

@@ -1,293 +0,0 @@
-const debug = require('debug')('ig:delta');
-
-/**
- * Delta Sync Manager - Apply real Instagram delta updates to local state
- * Based on MessageSync format from reverse-engineered instagram_mqtt
- */
-class DeltaSyncManager {
-  constructor() {
-    this.state = {
-      threads: {},     // thread_id → ThreadUpdate
-      messages: {},    // item_id → MessageSyncMessage
-      typing: {},      // thread_id → TypingIndicator
-      presence: {}     // user_id → PresenceIndicator
-    };
-    this.listeners = [];
-    this.operations = { add: 0, update: 0, delete: 0 };
-  }
-
-  /**
-   * Apply delta operations (add/update/delete) to local state
-   */
-  applyDelta(delta) {
-    if (!delta || !delta.items || delta.items.length === 0) {
-      return { applied: 0, errors: [], stats: this.operations };
-    }
-
-    let applied = 0;
-    const errors = [];
-
-    delta.items.forEach(item => {
-      try {
-        const result = this.applyItem(item);
-        if (result) applied++;
-      } catch (e) {
-        errors.push({ 
-          itemId: item.id || item.item_id, 
-          error: e.message,
-          operation: item.op || item.type
-        });
-        debug(`❌ Error applying item:`, e.message);
-      }
-    });
-
-    // Notify listeners
-    if (applied > 0) {
-      this.notifyListeners(delta);
-    }
-
-    return { 
-      applied, 
-      errors, 
-      total: delta.items.length,
-      stats: this.operations
-    };
-  }
-
-  /**
-   * Apply single item (message, thread, typing, presence)
-   */
-  applyItem(item) {
-    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 (item.data?.message) {
-      return this.applyMessage(operation, item.data.message);
-    }
-
-    if (item.data?.thread) {
-      return this.applyThread(operation, item.data.thread);
-    }
-
-    if (item.data?.typing) {
-      return this.applyTyping(operation, item.data.typing);
-    }
-
-    if (item.data?.presence) {
-      return this.applyPresence(operation, item.data.presence);
-    }
-
-    // Fallback for direct objects
-    if (item.message) {
-      return this.applyMessage(operation, item.message);
-    }
-    if (item.thread) {
-      return this.applyThread(operation, item.thread);
-    }
-    if (item.typing) {
-      return this.applyTyping(operation, item.typing);
-    }
-    if (item.presence) {
-      return this.applyPresence(operation, item.presence);
-    }
-
-    return false;
-  }
-
-  /**
-   * Apply message delta (real Instagram MessageSyncMessage format)
-   */
-  applyMessage(operation, message) {
-    const msgId = message.item_id;
-
-    if (operation === 'delete' || operation === 'deletion') {
-      delete this.state.messages[msgId];
-      this.operations.delete++;
-      debug(`🗑️  Deleted message ${msgId}`);
-      return true;
-    }
-
-    if (operation === 'replace' || operation === 'update') {
-      if (!this.state.messages[msgId]) {
-        debug(`⚠️  Message ${msgId} not found for update`);
-        return false;
-      }
-      Object.assign(this.state.messages[msgId], message);
-      this.operations.update++;
-      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}: "${message.text?.substring(0, 30) || 'media'}"`);
-    return true;
-  }
-
-  /**
-   * Apply thread delta (real Instagram ThreadUpdate format)
-   */
-  applyThread(operation, thread) {
-    const threadId = thread.thread_id || thread.thread_v2_id;
-
-    if (operation === 'delete') {
-      delete this.state.threads[threadId];
-      this.operations.delete++;
-      debug(`🗑️  Deleted thread ${threadId}`);
-      return true;
-    }
-
-    if (operation === 'replace' || operation === 'update') {
-      if (!this.state.threads[threadId]) {
-        // Create new thread on update if doesn't exist
-        this.state.threads[threadId] = thread;
-        this.operations.add++;
-        debug(`➕ Created thread from update: ${thread.thread_title}`);
-        return true;
-      }
-      Object.assign(this.state.threads[threadId], thread);
-      this.operations.update++;
-      debug(`✏️  Updated thread ${threadId}: "${thread.thread_title}"`);
-      return true;
-    }
-
-    // add/default
-    this.state.threads[threadId] = thread;
-    this.operations.add++;
-    debug(`➕ Added thread: "${thread.thread_title}" (${thread.user_ids?.length || 1} members)`);
-    return true;
-  }
-
-  /**
-   * Apply typing indicator delta
-   */
-  applyTyping(operation, typing) {
-    const threadId = typing.thread_id;
-
-    if (operation === 'delete' || typing.state === 'stopped') {
-      delete this.state.typing[threadId];
-      this.operations.delete++;
-      debug(`⌨️  User ${typing.from_user_id} stopped typing in ${threadId}`);
-      return true;
-    }
-
-    this.state.typing[threadId] = typing;
-    this.operations.add++;
-    debug(`⌨️  User ${typing.from_user_id} typing in ${threadId}`);
-    return true;
-  }
-
-  /**
-   * Apply presence indicator delta
-   */
-  applyPresence(operation, presence) {
-    const userId = presence.user_id;
-
-    if (operation === 'delete' || presence.status === 'inactive') {
-      delete this.state.presence[userId];
-      this.operations.delete++;
-      debug(`🔴 User ${userId} offline`);
-      return true;
-    }
-
-    this.state.presence[userId] = presence;
-    this.operations.add++;
-    debug(`🟢 User ${userId} ${presence.status}`);
-    return true;
-  }
-
-  /**
-   * Subscribe to state changes
-   */
-  subscribe(callback) {
-    this.listeners.push(callback);
-    return () => {
-      this.listeners = this.listeners.filter(l => l !== callback);
-    };
-  }
-
-  /**
-   * Notify listeners of changes
-   */
-  notifyListeners(delta) {
-    this.listeners.forEach(callback => {
-      try {
-        callback(delta, this.getState());
-      } catch (e) {
-        debug('Listener error:', e.message);
-      }
-    });
-  }
-
-  /**
-   * Get current synchronized state
-   */
-  getState() {
-    return {
-      threads: JSON.parse(JSON.stringify(this.state.threads)),
-      messages: JSON.parse(JSON.stringify(this.state.messages)),
-      typing: JSON.parse(JSON.stringify(this.state.typing)),
-      presence: JSON.parse(JSON.stringify(this.state.presence))
-    };
-  }
-
-  /**
-   * Query methods
-   */
-  getThread(threadId) {
-    return this.state.threads[threadId] || null;
-  }
-
-  getThreadMessages(threadId) {
-    return Object.values(this.state.messages).filter(m => m.thread_id === threadId || m.thread_v2_id === threadId);
-  }
-
-  getThreads() {
-    return Object.values(this.state.threads);
-  }
-
-  getAllMessages() {
-    return Object.values(this.state.messages);
-  }
-
-  getTypingInThread(threadId) {
-    return this.state.typing[threadId] || null;
-  }
-
-  getUserPresence(userId) {
-    return this.state.presence[userId] || null;
-  }
-
-  /**
-   * Stats
-   */
-  getStats() {
-    return {
-      threads: Object.keys(this.state.threads).length,
-      messages: Object.keys(this.state.messages).length,
-      typing: Object.keys(this.state.typing).length,
-      presence: Object.keys(this.state.presence).length,
-      operations: this.operations
-    };
-  }
-
-  /**
-   * Clear all state
-   */
-  clear() {
-    this.state = {
-      threads: {},
-      messages: {},
-      typing: {},
-      presence: {}
-    };
-    this.operations = { add: 0, update: 0, delete: 0 };
-    debug('✓ State cleared');
-  }
-}
-
-module.exports = DeltaSyncManager;

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

@@ -1,185 +0,0 @@
-"use strict";
-Object.defineProperty(exports, "__esModule", { value: true });
-exports.ErrorHandler = void 0;
-const shared_1 = require("../../shared");
-
-const ERROR_TYPES = {
-    RATE_LIMIT: 'rate_limit',
-    AUTH_FAILURE: 'auth_failure',
-    NETWORK: 'network',
-    PROTOCOL: 'protocol',
-    SERVER: 'server',
-    UNKNOWN: 'unknown',
-};
-
-const RATE_LIMIT_PATTERNS = [
-    'rate limit', 'too many', 'throttl', 'spam', 'please wait',
-    'action blocked', 'try again later', 'temporarily blocked',
-    '429', 'flood',
-];
-
-const AUTH_PATTERNS = [
-    'auth', 'login', 'session', 'credential', 'token', 'expired',
-    'unauthorized', '401', 'forbidden', '403', 'password',
-    'challenge_required', 'checkpoint', 'checkpoint_required',
-    'login_required', 'consent_required', 'two_factor',
-];
-
-const NETWORK_PATTERNS = [
-    'ECONNRESET', 'ECONNREFUSED', 'ETIMEDOUT', 'ENOTFOUND',
-    'ENETUNREACH', 'socket hang up', 'network', 'dns',
-    'getaddrinfo', 'connect EHOSTUNREACH', 'EPIPE', 'EAI_AGAIN',
-];
-
-class ErrorHandler {
-    constructor(client) {
-        this.errorDebug = (0, shared_1.debugChannel)('realtime', 'errors');
-        this.errorCount = 0;
-        this.maxRetries = 15;
-        this.client = client;
-        this.errorHistory = [];
-        this.rateLimitUntil = 0;
-        this.consecutiveAuthFailures = 0;
-    }
-
-    classifyError(error) {
-        const msg = (error?.message || String(error)).toLowerCase();
-
-        for (const pattern of RATE_LIMIT_PATTERNS) {
-            if (msg.includes(pattern)) return ERROR_TYPES.RATE_LIMIT;
-        }
-        for (const pattern of AUTH_PATTERNS) {
-            if (msg.includes(pattern)) return ERROR_TYPES.AUTH_FAILURE;
-        }
-        for (const pattern of NETWORK_PATTERNS) {
-            if (msg.includes(pattern.toLowerCase())) return ERROR_TYPES.NETWORK;
-        }
-        if (msg.includes('connack') || msg.includes('protocol') || msg.includes('thrift') || msg.includes('parse')) {
-            return ERROR_TYPES.PROTOCOL;
-        }
-        if (msg.includes('500') || msg.includes('502') || msg.includes('503') || msg.includes('server')) {
-            return ERROR_TYPES.SERVER;
-        }
-        return ERROR_TYPES.UNKNOWN;
-    }
-
-    getBackoffForType(errorType, attemptNumber) {
-        const jitter = Math.floor(Math.random() * 2000);
-        switch (errorType) {
-            case ERROR_TYPES.RATE_LIMIT:
-                return Math.min(60000 * Math.pow(1.5, attemptNumber - 1), 600000) + jitter;
-            case ERROR_TYPES.AUTH_FAILURE:
-                return Math.min(10000 * Math.pow(2, attemptNumber - 1), 120000) + jitter;
-            case ERROR_TYPES.NETWORK:
-                return Math.min(2000 * Math.pow(2, attemptNumber - 1), 60000) + jitter;
-            case ERROR_TYPES.SERVER:
-                return Math.min(5000 * Math.pow(2, attemptNumber - 1), 120000) + jitter;
-            case ERROR_TYPES.PROTOCOL:
-                return Math.min(5000 * Math.pow(2, attemptNumber - 1), 60000) + jitter;
-            default:
-                return Math.min(3000 * Math.pow(2, attemptNumber - 1), 90000) + jitter;
-        }
-    }
-
-    handleConnectionError(error) {
-        this.errorCount++;
-        const errorType = this.classifyError(error);
-        const delay = this.getBackoffForType(errorType, this.errorCount);
-
-        this.errorHistory.push({
-            type: errorType,
-            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?.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.`);
-        }
-
-        if (errorType === ERROR_TYPES.AUTH_FAILURE) {
-            this.consecutiveAuthFailures++;
-            if (this.consecutiveAuthFailures >= 3) {
-                this.errorDebug('Multiple auth failures. Credentials may need refresh.');
-                this.client.emit('auth_failure', {
-                    count: this.consecutiveAuthFailures,
-                    error: error?.message || String(error),
-                });
-                return false;
-            }
-        } else {
-            this.consecutiveAuthFailures = 0;
-        }
-
-        if (this.errorCount >= this.maxRetries) {
-            this.client.emit('error', new Error(`Max retries (${this.maxRetries}) exceeded. Last error type: ${errorType}`));
-            return false;
-        }
-
-        this.errorDebug(`Scheduling retry in ${Math.round(delay/1000)}s (type: ${errorType})`);
-
-        setTimeout(() => {
-            if (typeof this.client.reconnect === 'function') {
-                this.client.reconnect();
-            } else if (typeof this.client._attemptReconnectSafely === 'function') {
-                this.client._attemptReconnectSafely().catch(() => {});
-            }
-        }, delay);
-
-        return true;
-    }
-
-    isRateLimited() {
-        return Date.now() < this.rateLimitUntil;
-    }
-
-    getRateLimitRemainingMs() {
-        return Math.max(0, this.rateLimitUntil - Date.now());
-    }
-
-    handlePayloadError(error, topic) {
-        this.errorDebug(`Payload Error on topic ${topic}: ${error.message}`);
-        this.client.emit('warning', {
-            type: 'payload_error',
-            topic,
-            error: error.message,
-        });
-    }
-
-    handleProtocolError(error) {
-        this.errorDebug(`Protocol Error: ${error.message}`);
-        this.client.emit('error', new Error(`MQTT Protocol Error: ${error.message}`));
-    }
-
-    resetErrorCounter() {
-        this.errorCount = 0;
-        this.consecutiveAuthFailures = 0;
-        this.errorDebug('Error counter reset');
-    }
-
-    getErrorStats() {
-        const recentErrors = this.errorHistory.filter(e => Date.now() - e.timestamp < 3600000);
-        const typeBreakdown = {};
-        for (const e of recentErrors) {
-            typeBreakdown[e.type] = (typeBreakdown[e.type] || 0) + 1;
-        }
-        return {
-            errorCount: this.errorCount,
-            maxRetries: this.maxRetries,
-            canRetry: this.errorCount < this.maxRetries,
-            isRateLimited: this.isRateLimited(),
-            rateLimitRemainingMs: this.getRateLimitRemainingMs(),
-            consecutiveAuthFailures: this.consecutiveAuthFailures,
-            recentErrorCount: recentErrors.length,
-            typeBreakdown,
-        };
-    }
-}
-
-ErrorHandler.ERROR_TYPES = ERROR_TYPES;
-exports.ErrorHandler = ErrorHandler;
-exports.ERROR_TYPES = ERROR_TYPES;

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

@@ -1,61 +0,0 @@
-"use strict";
-Object.defineProperty(exports, "__esModule", { value: true });
-exports.GapHandler = void 0;
-const shared_1 = require("../../shared");
-/**
- * Gap Handler - Handle message gaps and synchronization
- */
-class GapHandler {
-    constructor(client) {
-        this.gapDebug = (0, shared_1.debugChannel)('realtime', 'gap');
-        this.threadGaps = new Map();
-        this.client = client;
-    }
-    /**
-     * Detect message gap in thread
-     */
-    detectGap(threadId, lastMessageId, newMessageId) {
-        const lastId = parseInt(lastMessageId, 10);
-        const newId = parseInt(newMessageId, 10);
-        const gap = Math.abs(newId - lastId) > 1;
-        
-        if (gap) {
-            this.gapDebug(`Gap detected in thread ${threadId}: ${lastMessageId} -> ${newMessageId}`);
-            this.threadGaps.set(threadId, { from: lastMessageId, to: newMessageId });
-            this.client.emit('gap', {
-                thread_id: threadId,
-                gap_from: lastMessageId,
-                gap_to: newMessageId,
-            });
-        }
-        return gap;
-    }
-    /**
-     * Handle gap by requesting missing messages
-     */
-    async handleGap(threadId, gapFrom, gapTo) {
-        this.gapDebug(`Handling gap in ${threadId}: fetching messages ${gapFrom}-${gapTo}`);
-        try {
-            // Request missing messages from REST API
-            const thread = await this.client.ig.direct.getThread(threadId);
-            const messages = await thread.getMessages({ limit: 50 });
-            
-            this.client.emit('gap_filled', {
-                thread_id: threadId,
-                messages_count: messages.length,
-            });
-            return messages;
-        } catch (err) {
-            this.gapDebug(`Failed to handle gap: ${err.message}`);
-            this.client.emit('error', new Error(`Gap handling failed for thread ${threadId}`));
-            return [];
-        }
-    }
-    /**
-     * Clear gap tracking for thread
-     */
-    clearGap(threadId) {
-        this.threadGaps.delete(threadId);
-    }
-}
-exports.GapHandler = GapHandler;