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

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

@@ -0,0 +1,23 @@
+"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);

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

@@ -0,0 +1,260 @@
+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) {
+        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) {
+            return this.applyMessage(operation, item.data.message);
+        }
+        if ((_b = item.data) === null || _b === void 0 ? void 0 : _b.thread) {
+            return this.applyThread(operation, item.data.thread);
+        }
+        if ((_c = item.data) === null || _c === void 0 ? void 0 : _c.typing) {
+            return this.applyTyping(operation, item.data.typing);
+        }
+        if ((_d = item.data) === null || _d === void 0 ? void 0 : _d.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) {
+        var _a, _b;
+        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}: "${(_a = message.text) === null || _a === void 0 ? void 0 : _a.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'}"`);
+        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];
+            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}" (${((_a = thread.user_ids) === null || _a === void 0 ? void 0 : _a.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/dist-ts/dist/realtime/features/dm-sender.js

@@ -0,0 +1,94 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.DMSender = void 0;
+const shared_1 = require("../../shared");
+const uuid_1 = require("uuid");
+/**
+ * Direct Message Sender via MQTT
+ */
+class DMSender {
+    constructor(client) {
+        this.dmDebug = (0, shared_1.debugChannel)('realtime', 'dm-sender');
+        this.client = client;
+    }
+    /**
+     * Send text message via MQTT
+     */
+    async sendTextMessage(threadId, text, clientContext = null) {
+        var _a;
+        this.dmDebug(`Sending text message to thread ${threadId}: "${text.substring(0, 50)}..."`);
+        const command = {
+            action: 'send_item',
+            thread_id: threadId,
+            item_type: 'text',
+            text,
+            timestamp: Date.now(),
+            client_context: clientContext || (0, uuid_1.v4)(),
+        };
+        try {
+            return await ((_a = this.client.directCommands) === null || _a === void 0 ? void 0 : _a.sendCommand({
+                action: 'send_item',
+                data: command,
+                threadId,
+            }));
+        }
+        catch (err) {
+            this.dmDebug(`Failed to send message: ${err.message}`);
+            throw err;
+        }
+    }
+    /**
+     * Send media message via MQTT (photo/video)
+     */
+    async sendMediaMessage(threadId, mediaId, mediaType = 'photo', clientContext = null) {
+        var _a;
+        this.dmDebug(`Sending ${mediaType} to thread ${threadId}`);
+        const command = {
+            action: 'send_item',
+            thread_id: threadId,
+            item_type: mediaType,
+            media_id: mediaId,
+            timestamp: Date.now(),
+            client_context: clientContext || (0, uuid_1.v4)(),
+        };
+        try {
+            return await ((_a = this.client.directCommands) === null || _a === void 0 ? void 0 : _a.sendCommand({
+                action: 'send_item',
+                data: command,
+                threadId,
+            }));
+        }
+        catch (err) {
+            this.dmDebug(`Failed to send media: ${err.message}`);
+            throw err;
+        }
+    }
+    /**
+     * Send link message
+     */
+    async sendLinkMessage(threadId, url, title = null, clientContext = null) {
+        var _a;
+        this.dmDebug(`Sending link to thread ${threadId}: ${url}`);
+        const command = {
+            action: 'send_item',
+            thread_id: threadId,
+            item_type: 'link',
+            url,
+            title: title || url,
+            timestamp: Date.now(),
+            client_context: clientContext || (0, uuid_1.v4)(),
+        };
+        try {
+            return await ((_a = this.client.directCommands) === null || _a === void 0 ? void 0 : _a.sendCommand({
+                action: 'send_item',
+                data: command,
+                threadId,
+            }));
+        }
+        catch (err) {
+            this.dmDebug(`Failed to send link: ${err.message}`);
+            throw err;
+        }
+    }
+}
+exports.DMSender = DMSender;

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

@@ -0,0 +1,167 @@
+"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 === null || error === void 0 ? void 0 : 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 === null || error === void 0 ? void 0 : 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}`);
+        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 === null || error === void 0 ? void 0 : 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/dist-ts/dist/realtime/features/gap-handler.js

@@ -0,0 +1,60 @@
+"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;