nodejs-insta-private-api-mqt 1.3.70

package/dist/utils/helper-1.js

@@ -0,0 +1 @@
+// Helper utility file 1

package/dist/utils/helper-10.js

@@ -0,0 +1 @@
+// Helper utility file 10

package/dist/utils/helper-11.js

@@ -0,0 +1 @@
+// Helper utility file 11

package/dist/utils/helper-12.js

@@ -0,0 +1 @@
+// Helper utility file 12

package/dist/utils/helper-13.js

@@ -0,0 +1 @@
+// Helper utility file 13

package/dist/utils/helper-14.js

@@ -0,0 +1 @@
+// Helper utility file 14

package/dist/utils/helper-15.js

@@ -0,0 +1 @@
+// Helper utility file 15

package/dist/utils/helper-16.js

@@ -0,0 +1 @@
+// Helper utility file 16

package/dist/utils/helper-17.js

@@ -0,0 +1 @@
+// Helper utility file 17

package/dist/utils/helper-18.js

@@ -0,0 +1 @@
+// Helper utility file 18

package/dist/utils/helper-19.js

@@ -0,0 +1 @@
+// Helper utility file 19

package/dist/utils/helper-2.js

@@ -0,0 +1 @@
+// Helper utility file 2

package/dist/utils/helper-20.js

@@ -0,0 +1 @@
+// Helper utility file 20

package/dist/utils/helper-21.js

@@ -0,0 +1 @@
+// Helper utility file 21

package/dist/utils/helper-22.js

@@ -0,0 +1 @@
+// Helper utility file 22

package/dist/utils/helper-23.js

@@ -0,0 +1 @@
+// Helper utility file 23

package/dist/utils/helper-24.js

@@ -0,0 +1 @@
+// Helper utility file 24

package/dist/utils/helper-25.js

@@ -0,0 +1 @@
+// Helper utility file 25

package/dist/utils/helper-26.js

@@ -0,0 +1 @@
+// Helper utility file 26

package/dist/utils/helper-27.js

@@ -0,0 +1 @@
+// Helper utility file 27

package/dist/utils/helper-28.js

@@ -0,0 +1 @@
+// Helper utility file 28

package/dist/utils/helper-29.js

@@ -0,0 +1 @@
+// Helper utility file 29

package/dist/utils/helper-3.js

@@ -0,0 +1 @@
+// Helper utility file 3

package/dist/utils/helper-30.js

@@ -0,0 +1 @@
+// Helper utility file 30

package/dist/utils/helper-4.js

@@ -0,0 +1 @@
+// Helper utility file 4

package/dist/utils/helper-5.js

@@ -0,0 +1 @@
+// Helper utility file 5

package/dist/utils/helper-6.js

@@ -0,0 +1 @@
+// Helper utility file 6

package/dist/utils/helper-7.js

@@ -0,0 +1 @@
+// Helper utility file 7

package/dist/utils/helper-8.js

@@ -0,0 +1 @@
+// Helper utility file 8

package/dist/utils/helper-9.js

@@ -0,0 +1 @@
+// Helper utility file 9

package/dist/utils/index.js

@@ -0,0 +1,280 @@
+const crypto = require('crypto');
+const { random } = require('lodash');
+
+class Utils {
+  // ========================
+  // ORIGINAL FUNCTIONS
+  // ========================
+
+  static generateUUID() {
+    if (crypto.randomUUID) return crypto.randomUUID();
+    return 'xxxxxxxx-xxxx-4xxx-yxxx-xxxxxxxxxxxx'.replace(/[xy]/g, function(c) {
+      const r = Math.random() * 16 | 0;
+      const v = c === 'x' ? r : (r & 0x3 | 0x8);
+      return v.toString(16);
+    });
+  }
+
+  static generateRandomString(length) {
+    const characters = 'ABCDEFGHIJKLMNOPQRSTUVWXYZabcdefghijklmnopqrstuvwxyz0123456789';
+    let result = '';
+    for (let i = 0; i < length; i++) {
+      result += characters.charAt(Math.floor(Math.random() * characters.length));
+    }
+    return result;
+  }
+
+  static generateDeviceId() {
+    return 'android-' + this.generateRandomString(16);
+  }
+
+  static generatePhoneId() {
+    return this.generateUUID();
+  }
+
+  static generateAdId() {
+    return this.generateUUID();
+  }
+
+  static sleep(ms) {
+    return new Promise(resolve => setTimeout(resolve, ms));
+  }
+
+  static randomDelay(min = 1000, max = 3000) {
+    return this.sleep(random(min, max));
+  }
+
+  static md5(data) {
+    return crypto.createHash('md5').update(data).digest('hex');
+  }
+
+  static sha256(data) {
+    return crypto.createHash('sha256').update(data).digest('hex');
+  }
+
+  static hmacSha256(data, key) {
+    return crypto.createHmac('sha256', key).update(data).digest('hex');
+  }
+
+  static base64Encode(data) {
+    return Buffer.from(data).toString('base64');
+  }
+
+  static base64Decode(data) {
+    return Buffer.from(data, 'base64').toString();
+  }
+
+  static getCurrentTimestamp() {
+    return Math.floor(Date.now() / 1000);
+  }
+
+  static getTimestampMs() {
+    return Date.now();
+  }
+
+  static formatUserAgent(appVersion, deviceString, language, appVersionCode) {
+    return `Instagram ${appVersion} Android (${deviceString}; ${language}; ${appVersionCode})`;
+  }
+
+  static formatWebUserAgent(devicePayload, build, appUserAgent) {
+    return `Mozilla/5.0 (Linux; Android ${devicePayload.android_release}; ${devicePayload.model} Build/${build}; wv) AppleWebKit/537.36 (KHTML, like Gecko) Version/4.0 Chrome/131.0.6778.139 Mobile Safari/537.36 ${appUserAgent}`;
+  }
+
+  static parseUserId(userIdOrUsername) {
+    if (typeof userIdOrUsername === 'number' || /^\d+$/.test(userIdOrUsername)) {
+      return userIdOrUsername.toString();
+    }
+    return null;
+  }
+
+  static isValidEmail(email) {
+    const emailRegex = /^[^\s@]+@[^\s@]+\.[^\s@]+$/;
+    return emailRegex.test(email);
+  }
+
+  static isValidUsername(username) {
+    const usernameRegex = /^[a-zA-Z0-9._]{1,30}$/;
+    return usernameRegex.test(username);
+  }
+
+  static sanitizeCaption(caption) {
+    if (!caption) return '';
+    return caption.replace(/[\u0000-\u001F\u007F-\u009F]/g, '');
+  }
+
+  static chunkArray(array, chunkSize) {
+    const chunks = [];
+    for (let i = 0; i < array.length; i += chunkSize) {
+      chunks.push(array.slice(i, i + chunkSize));
+    }
+    return chunks;
+  }
+
+  static retryOperation(operation, maxRetries = 3, delay = 1000) {
+    return new Promise((resolve, reject) => {
+      let retries = 0;
+
+      const attempt = async () => {
+        try {
+          const result = await operation();
+          resolve(result);
+        } catch (error) {
+          retries++;
+          if (retries >= maxRetries) {
+            reject(error);
+          } else {
+            setTimeout(attempt, delay * retries);
+          }
+        }
+      };
+
+      attempt();
+    });
+  }
+
+  static validateFileSize(filePath, maxSizeBytes) {
+    const fs = require('fs');
+    try {
+      const stats = fs.statSync(filePath);
+      return stats.size <= maxSizeBytes;
+    } catch (error) {
+      return false;
+    }
+  }
+
+  static getFileExtension(filePath) {
+    return filePath.split('.').pop().toLowerCase();
+  }
+
+  static isImageFile(filePath) {
+    const imageExtensions = ['jpg', 'jpeg', 'png', 'gif', 'bmp', 'webp'];
+    const extension = this.getFileExtension(filePath);
+    return imageExtensions.includes(extension);
+  }
+
+  static isVideoFile(filePath) {
+    const videoExtensions = ['mp4', 'mov', 'avi', 'mkv', 'webm', '3gp'];
+    const extension = this.getFileExtension(filePath);
+    return videoExtensions.includes(extension);
+  }
+
+  static humanizeError(error) {
+    const errorMessages = {
+      'IgLoginBadPasswordError': 'The password you entered is incorrect. Please check your password and try again.',
+      'IgLoginInvalidUserError': 'The username you entered doesn\'t appear to belong to an account. Please check your username and try again.',
+      'IgLoginTwoFactorRequiredError': 'Two-factor authentication is required. Please enter the verification code.',
+      'IgCheckpointError': 'Instagram requires additional verification. Please complete the security challenge.',
+      'IgActionSpamError': 'This action has been blocked by Instagram\'s spam detection. Please try again later.',
+      'IgNotFoundError': 'The requested content could not be found.',
+      'IgPrivateUserError': 'This account is private. You must follow this user to see their content.',
+      'IgUserHasLoggedOutError': 'Your session has expired. Please log in again.',
+      'IgInactiveUserError': 'This account is inactive or has been suspended.',
+      'IgSentryBlockError': 'This request has been blocked by Instagram\'s security system.',
+      'IgNetworkError': 'A network error occurred. Please check your internet connection and try again.',
+      'IgUploadError': 'Failed to upload the file. Please check the file format and size.',
+      'IgConfigureMediaError': 'Failed to configure the media. Please try again.',
+    };
+
+    if (error.response && error.response.status) {
+      return `Request failed with status ${error.response.status}: ${error.response.statusText || ''}`;
+    }
+
+    return errorMessages[error.name] || error.message || 'An unknown error occurred.';
+  }
+
+  static rateLimitDelay(retryAfter = null) {
+    if (retryAfter) {
+      return parseInt(retryAfter) * 1000;
+    }
+    return random(5000, 15000);
+  }
+
+  static createUserAgentFromDevice(device) {
+    return `Instagram 415.0.0.36.76 Android (${device.android_version}/${device.android_release}; ${device.dpi}dpi; ${device.resolution}; ${device.manufacturer}; ${device.model}; ${device.device}; ${device.cpu})`;
+  }
+
+  // ========================
+  // NEW ENHANCEMENTS
+  // ========================
+
+  static generateSecureRandomString(length) {
+    const characters = 'ABCDEFGHIJKLMNOPQRSTUVWXYZabcdefghijklmnopqrstuvwxyz0123456789';
+    const randomBytes = crypto.randomBytes(length);
+    let result = '';
+    for (let i = 0; i < length; i++) {
+      result += characters[randomBytes[i] % characters.length];
+    }
+    return result;
+  }
+
+  static fileHash(filePath, algorithm = 'sha256') {
+    const fs = require('fs');
+    const data = fs.readFileSync(filePath);
+    return crypto.createHash(algorithm).update(data).digest('hex');
+  }
+
+  static prettyBytes(bytes) {
+    const units = ['B', 'KB', 'MB', 'GB', 'TB'];
+    let i = 0;
+    while (bytes >= 1024 && i < units.length - 1) {
+      bytes /= 1024;
+      i++;
+    }
+    return `${bytes.toFixed(2)} ${units[i]}`;
+  }
+
+  static async retryWithBackoff(operation, maxRetries = 5, baseDelay = 1000) {
+    for (let attempt = 1; attempt <= maxRetries; attempt++) {
+      try {
+        return await operation();
+      } catch (error) {
+        if (attempt === maxRetries) throw error;
+        const delay = baseDelay * Math.pow(2, attempt - 1) + Math.random() * 500;
+        await this.sleep(delay);
+      }
+    }
+  }
+
+  static logError(error, context = '') {
+    console.error(`[${new Date().toISOString()}] ❌ ${context}:`, {
+      name: error.name,
+      message: error.message,
+      stack: error.stack?.split('\n').slice(0, 3).join('\n')
+    });
+  }
+
+  static debugLog(message) {
+    if (process.env.DEBUG === 'true') {
+      console.log(`[DEBUG] ${new Date().toISOString()} - ${message}`);
+    }
+  }
+
+  static generateAndroidDevice() {
+    const versions = ['11', '12', '13', '14'];
+    const models = ['Pixel 6', 'SM-G991B', 'Redmi Note 10', 'OnePlus 9'];
+    const manufacturer = ['Google', 'Samsung', 'Xiaomi', 'OnePlus'];
+    const randomIndex = Math.floor(Math.random() * models.length);
+    return {
+      android_release: versions[randomIndex],
+      model: models[randomIndex],
+      manufacturer: manufacturer[randomIndex],
+      dpi: 480,
+      resolution: '1080x2400',
+      device: models[randomIndex].replace(/\s+/g, '_').toLowerCase(),
+      cpu: 'arm64-v8a',
+      android_version: versions[randomIndex]
+    };
+  }
+
+  static generateHeaders(userAgent) {
+    return {
+      'User-Agent': userAgent,
+      'Accept': '*/*',
+      'Accept-Language': 'en-US',
+      'X-Requested-With': 'com.instagram.android',
+      'Connection': 'keep-alive'
+    };
+  }
+}
+
+module.exports = Utils;

package/dist/utils/insta-mqtt-helper.js

@@ -0,0 +1,128 @@
+"use strict";
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.addTransactionCapability = void 0;
+const async_hooks_1 = require("async_hooks");
+const async_mutex_1 = require("async-mutex");
+const p_queue_1 = __importDefault(require("p-queue"));
+// Logger stub if not provided
+const defaultLogger = {
+    trace: (obj, msg) => console.log('[TRACE]', msg, obj),
+    debug: (obj, msg) => console.log('[DEBUG]', msg, obj),
+    info: (obj, msg) => console.log('[INFO]', msg, obj),
+    warn: (obj, msg) => console.warn('[WARN]', msg, obj),
+    error: (obj, msg) => console.error('[ERROR]', msg, obj),
+};
+/**
+ * Adds transaction capability and sequential processing to the Instagram Realtime Client
+ * ensuring messages are sent in order (e.g. "Salut" before "Ce faci").
+ *
+ * @param client The RealtimeClient instance from nodejs-insta-private-api-mqt
+ * @param logger Optional logger
+ * @returns The wrapped client with transaction capabilities
+ */
+const addTransactionCapability = (client, logger = defaultLogger) => {
+    const txStorage = new async_hooks_1.AsyncLocalStorage();
+    // Global queue for all direct thread operations to ensure sequence
+    // concurrency: 1 is CRITICAL for ensuring messages arrive in order "Salut" -> "Ce faci" -> "Unde esti"
+    const globalQueue = new p_queue_1.default({ concurrency: 1 });
+    // Per-thread queues if we want parallelism across different threads but serial within a thread
+    const threadQueues = new Map();
+    function getThreadQueue(threadId) {
+        if (!threadQueues.has(threadId)) {
+            threadQueues.set(threadId, new p_queue_1.default({ concurrency: 1 }));
+        }
+        return threadQueues.get(threadId);
+    }
+    // Mutex for critical sections
+    const clientMutex = new async_mutex_1.Mutex();
+    // Helper to check if we are in a transaction
+    function isInTransaction() {
+        return !!txStorage.getStore();
+    }
+    // Wrap the directCommands (EnhancedDirectCommands)
+    if (client.directCommands) {
+        const originalSendText = client.directCommands.sendText.bind(client.directCommands);
+        client.directCommands.sendText = async (...args) => {
+            const firstArg = args[0];
+            const threadId = (firstArg && typeof firstArg === 'object') ? firstArg.threadId : firstArg;
+            const queue = typeof threadId === 'string' ? getThreadQueue(threadId) : globalQueue;
+            return queue.add(async () => {
+                logger.trace({ threadId }, 'Queueing message send to ensure order');
+                return originalSendText(...args);
+            });
+        };
+        const methodsToWrap = ['sendLink', 'sendPhoto', 'sendVideo', 'sendVoice', 'sendLike', 'sendPost'];
+        methodsToWrap.forEach(method => {
+            if (client.directCommands[method]) {
+                const originalMethod = client.directCommands[method].bind(client.directCommands);
+                client.directCommands[method] = async (...args) => {
+                    const firstArg = args[0];
+                    const threadId = (firstArg && typeof firstArg === 'object') ? firstArg.threadId : firstArg;
+                    const queue = typeof threadId === 'string' ? getThreadQueue(threadId) : globalQueue;
+                    return queue.add(async () => {
+                        logger.trace({ method, threadId }, 'Queueing direct command');
+                        return originalMethod(...args);
+                    });
+                };
+            }
+        });
+    }
+    // Also wrap the underlying publish method if needed for raw MQTT operations
+    if (client.mqtt && client.mqtt.publish) {
+        const originalPublish = client.mqtt.publish.bind(client.mqtt);
+        client.mqtt.publish = async (...args) => {
+            const [topic, payload] = args;
+            // Determine if this is a direct message related topic
+            const isDirectRelated = topic.includes('direct') || topic.includes('send_message');
+            if (isDirectRelated) {
+                return globalQueue.add(async () => {
+                    logger.trace({ topic }, 'Queueing MQTT publish');
+                    return originalPublish(...args);
+                });
+            }
+            return originalPublish(...args);
+        };
+    }
+    /**
+     * Transaction wrapper similar to the Baileys one.
+     * Allows grouping multiple operations into a single atomic-like unit (logically).
+     */
+    const transaction = async (work) => {
+        const existing = txStorage.getStore();
+        if (existing) {
+            return work();
+        }
+        // We use the mutex to lock the client during the transaction
+        return clientMutex.runExclusive(async () => {
+            const ctx = {
+                id: Date.now(),
+                timestamp: new Date()
+            };
+            return txStorage.run(ctx, async () => {
+                try {
+                    logger.trace('Starting transaction');
+                    const result = await work();
+                    logger.trace('Transaction completed');
+                    return result;
+                }
+                catch (error) {
+                    logger.error({ error }, 'Transaction failed');
+                    throw error;
+                }
+            });
+        });
+    };
+    // Expose the transaction method on the client
+    client.transaction = transaction;
+    client.isInTransaction = isInTransaction;
+    return {
+        client,
+        transaction,
+        isInTransaction
+    };
+};
+exports.addTransactionCapability = addTransactionCapability;
+exports.default = exports.addTransactionCapability;

package/examples/listen-to-messages.js

@@ -0,0 +1,86 @@
+const { IgApiClient, RealtimeClient } = require('../dist/index');
+const fs = require('fs');
+const path = require('path');
+
+// Listen to Instagram Direct Messages in Real-Time
+// Setup: export INSTAGRAM_USERNAME, INSTAGRAM_PASSWORD, INSTAGRAM_EMAIL
+// Run: node examples/listen-to-messages.js
+
+async function main() {
+  const username = process.env.INSTAGRAM_USERNAME;
+  const password = process.env.INSTAGRAM_PASSWORD;
+  const email = process.env.INSTAGRAM_EMAIL;
+  
+  if (!username || !password || !email) {
+    console.error('Missing credentials!');
+    console.error('Set: INSTAGRAM_USERNAME, INSTAGRAM_PASSWORD, INSTAGRAM_EMAIL');
+    process.exit(1);
+  }
+
+  try {
+    console.log('\n📱 Instagram Direct Messages Listener\n');
+    
+    const ig = new IgApiClient();
+    
+    // Try to load saved session
+    const sessionFile = path.join(__dirname, '../.session');
+    if (fs.existsSync(sessionFile)) {
+      console.log('Loading saved session...');
+      const session = JSON.parse(fs.readFileSync(sessionFile, 'utf8'));
+      await ig.loadSession(session);
+    } else {
+      console.log('Logging in...');
+      await ig.login({ username, password, email });
+      const session = await ig.saveSession();
+      fs.writeFileSync(sessionFile, JSON.stringify(session));
+    }
+    
+    console.log(`✓ Logged in as @${username}\n`);
+    
+    const realtime = new RealtimeClient(ig);
+    
+    realtime.on('connected', () => {
+      console.log('✓ Connected to MQTT\n');
+      console.log('Waiting for messages... (send a DM to yourself)\n');
+    });
+    
+    realtime.on('receive', (topic, messages) => {
+      if (Array.isArray(messages)) {
+        messages.forEach(msg => {
+          if (msg.body) {
+            console.log('━━━━━━━━━━━━━━━━━━━━━━━');
+            console.log(`From: ${msg.from_user_id}`);
+            console.log(`Message: ${msg.body}`);
+            console.log('━━━━━━━━━━━━━━━━━━━━━━━\n');
+          }
+          if (msg.message_data?.body) {
+            console.log('━━━━━━━━━━━━━━━━━━━━━━━');
+            console.log(`From: ${msg.from_user_id}`);
+            console.log(`Message: ${msg.message_data.body}`);
+            console.log('━━━━━━━━━━━━━━━━━━━━━━━\n');
+          }
+        });
+      }
+    });
+    
+    realtime.on('error', (error) => {
+      console.error('✗ Error:', error.message);
+    });
+    
+    console.log('Connecting to Instagram MQTT...');
+    
+    await realtime.connect({
+      graphQlSubs: ['ig_sub_direct'],
+      irisData: null
+    });
+    
+    console.log('Press Ctrl+C to stop\n');
+    await new Promise(() => {});
+    
+  } catch (error) {
+    console.error('Error:', error.message);
+    process.exit(1);
+  }
+}
+
+main();

package/package.json

@@ -0,0 +1,82 @@
+{
+  "name": "nodejs-insta-private-api-mqt",
+  "version": "1.3.70",
+  "description": "Complete Instagram MQTT protocol with FULL Featured REALTIME And api Rest All in one project .",
+  "main": "dist/index.js",
+  "scripts": {
+    "test": "node examples/listen-to-messages.js",
+    "start": "node examples/listen-to-messages.js",
+    "example": "node complete-example.js",
+    "listen": "node complete-example.js"
+  },
+  "keywords": [
+    "instagram",
+    "api",
+    "private",
+    "client",
+    "dm",
+    "direct",
+    "messages",
+    "stories",
+    "upload",
+    "mqtt",
+    "realtime",
+    "notifications",
+    "bot",
+    "automation",
+    "bulk-messaging",
+    "session-persistence",
+    "message-management",
+    "view-once",
+    "disappearing-media",
+    "media-download",
+    "baileys",
+    "ios",
+    "iphone",
+    "ipad",
+    "android",
+    "device-emulation",
+    "iphone-16",
+    "iphone-15",
+    "samsung",
+    "pixel"
+  ],
+  "author": "BorutoSrg",
+  "license": "MIT",
+  "dependencies": {
+    "axios": "^1.13.5",
+    "chalk": "^5.6.2",
+    "chance": "^1.1.13",
+    "crypto": "^1.0.1",
+    "crypto-js": "^4.2.0",
+    "debug": "^4.4.3",
+    "eventemitter3": "^5.0.4",
+    "form-data": "^4.0.5",
+    "https-proxy-agent": "^7.0.6",
+    "instagram-private-api": "^1.46.1",
+    "lodash": "^4.17.23",
+    "mqtts": "^1.5.0",
+    "node-persist": "^4.0.4",
+    "pako": "^2.1.0",
+    "protobufjs": "^7.5.4",
+    "socks": "^2.8.7",
+    "tough-cookie": "^4.1.4",
+    "ts-custom-error": "^3.3.1",
+    "uuid": "^9.0.1"
+  },
+  "devDependencies": {
+    "node-fetch": "^3.3.2",
+    "typescript": "^5.9.3"
+  },
+  "engines": {
+    "node": ">=18.0.0"
+  },
+  "repository": {
+    "type": "git",
+    "url": "https://github.com/Kunboruto20/nodejs-insta-private-api.git"
+  },
+  "bugs": {
+    "url": "https://github.com/Kunboruto20/nodejs-insta-private-api/issues"
+  },
+  "homepage": "https://github.com/Kunboruto20/nodejs-insta-private-api#readme"
+}