nodejs-insta-private-api-mqtt 1.2.10 → 1.3.11

package/dist/realtime/realtime.client.js

@@ -17,6 +17,7 @@ const error_handler_1 = require("./features/error-handler");
 const gap_handler_1 = require("./features/gap-handler");
 const enhanced_direct_commands_1 = require("./commands/enhanced.direct.commands");
 const presence_typing_mixin_1 = require("./mixins/presence-typing.mixin");
+
 class RealtimeClient extends eventemitter3_1.EventEmitter {
     get mqtt() {
         return this._mqtt;
@@ -47,25 +48,75 @@ class RealtimeClient extends eventemitter3_1.EventEmitter {
         this.realtimeDebug(`Applying mixins: ${mixins.map(m => m.name).join(', ')}`);
         (0, mixins_1.applyMixins)(mixins, this, this.ig);
 
-        // Auto-connect if session is available
+        // ---------- AUTO-CONNECT BLOCK (UPDATED to wait for MQTT creds like APK) ----------
+        // Keep folder same as before for compatibility, but WAIT until device/mqtt creds present
         const folder = './auth_info_ig';
         const { useMultiFileAuthState } = require('../useMultiFileAuthState');
         const fs = require('fs');
         const path = require('path');
+
+        // store optional attached authState for later use
+        this._attachedAuthState = null;
+
+        // helper: wait/poll until mqtt/device credentials available (CountDownLatch equivalent)
+        const waitForMqttCredentials = async (auth, timeoutMs = 15000, pollMs = 250) => {
+            const start = Date.now();
+            const hasCreds = () => {
+                try {
+                    const d = (auth && typeof auth.getData === 'function') ? auth.getData() : (auth && auth.data ? auth.data : null);
+                    if (!d) return false;
+                    // Acceptable indicators: device.deviceSecret OR mqttAuth.jwt OR mqttAuth.deviceSecret
+                    if (d.device && (d.device.deviceSecret || d.device.secret)) return true;
+                    if (d.mqttAuth && (d.mqttAuth.jwt || d.mqttAuth.deviceSecret)) return true;
+                    // fallback: creds/sessionid present (not ideal but better than nothing)
+                    if (d.creds && (d.creds.sessionId || d.creds.csrfToken || d.creds.authorization)) return true;
+                    return false;
+                } catch (e) {
+                    return false;
+                }
+            };
+            // Poll until available or timeout
+            while (Date.now() - start < timeoutMs) {
+                if (hasCreds()) return true;
+                await new Promise(r => setTimeout(r, pollMs));
+            }
+            return false;
+        };
+
+        // Attempt auto-start only if creds.json exists — but wait for device/mqtt creds like APK does.
         if (fs.existsSync(path.join(folder, 'creds.json'))) {
             setTimeout(async () => {
                 try {
                     const auth = await useMultiFileAuthState(folder);
-                    if (auth.hasSession()) {
-                        console.log('[REALTIME] Auto-starting MQTT from constructor...');
-                        await auth.loadCreds(this.ig);
-                        await this.connectFromSavedSession(auth);
+                    // attach for later use
+                    this._attachedAuthState = auth;
+                    if (auth.hasSession && auth.hasSession()) {
+                        console.log('[REALTIME] Auto-start candidate session detected — loading creds...');
+                        try {
+                            await auth.loadCreds(this.ig);
+                        } catch (e) {
+                            // ignore load errors but log
+                            console.warn('[REALTIME] loadCreds warning:', e?.message || e);
+                        }
+                        // Wait for MQTT/device credentials to be present (APK-like behaviour)
+                        const ready = await waitForMqttCredentials(auth, 20000, 300);
+                        if (!ready) {
+                            console.warn('[REALTIME] MQTT/device credentials not found within timeout — auto-connect aborted (will still allow manual connect).');
+                            return;
+                        }
+                        console.log('[REALTIME] Device/MQTT credentials present — attempting connectFromSavedSession...');
+                        try {
+                            await this.connectFromSavedSession(auth);
+                        } catch (e) {
+                            console.error('[REALTIME] Constructor auto-connect failed:', e?.message || e);
+                        }
                     }
                 } catch (e) {
-                    console.error('[REALTIME] Constructor auto-connect failed:', e.message);
+                    console.error('[REALTIME] Constructor auto-start exception:', e?.message || e);
                 }
             }, 100);
         }
+        // ---------- END AUTO-CONNECT BLOCK ----------
     }
 
     /**
@@ -193,17 +244,32 @@ class RealtimeClient extends eventemitter3_1.EventEmitter {
         try {
             const authHeader = this.ig.state.authorization;
             if (!authHeader) return null;
-            // Extract base64 part from "Bearer IGT:2:{base64}"
-            const base64Part = authHeader.replace('Bearer IGT:2:', '').replace('Bearer ', '');
-            // Decode from base64
-            const decoded = Buffer.from(base64Part, 'base64').toString();
-            const payload = JSON.parse(decoded);
-            // Get sessionid and URL-decode it
-            let sessionid = payload.sessionid;
-            if (sessionid) {
-                sessionid = decodeURIComponent(sessionid);
+            // Attempt to decode possible bearer formats safely
+            const raw = String(authHeader || '');
+            // strip known prefixes
+            const candidate = raw.replace(/^Bearer\s*/i, '').replace(/^IGT:2:/i, '');
+            // if contains '.', might be JWT-like (header.payload.sig)
+            if (candidate.includes('.')) {
+                const parts = candidate.split('.');
+                if (parts.length >= 2) {
+                    try {
+                        const payload = Buffer.from(parts[1], 'base64').toString('utf8');
+                        const parsed = JSON.parse(payload);
+                        return parsed.sessionid || parsed.session_id || parsed.session || null;
+                    } catch (e) {
+                        // ignore parse error
+                    }
+                }
             }
-            return sessionid || null;
+            // fallback: try base64 decode whole candidate
+            try {
+                const decoded = Buffer.from(candidate, 'base64').toString('utf8');
+                const parsed = JSON.parse(decoded);
+                return parsed.sessionid || parsed.session_id || null;
+            } catch (e) {
+                // ignore
+            }
+            return null;
         } catch (e) {
             return null;
         }
@@ -221,45 +287,106 @@ class RealtimeClient extends eventemitter3_1.EventEmitter {
 
         // Ensure deviceId is a string to avoid substring errors
         const deviceId = String(this.ig.state.phoneId || this.ig.state.deviceId || 'device_unknown');
-        let sessionid;
-        // First try: Extract from JWT authorization header (PRIMARY METHOD)
-        sessionid = this.extractSessionIdFromJWT();
-        if (sessionid) {
-            this.realtimeDebug(`SessionID extracted from JWT: ${sessionid.substring(0, 20)}...`);
+
+        // Try multiple ways to determine sessionid/password and deviceSecret
+        let sessionid = null;
+        try {
+            // 1. Try extracting from JWT/Authorization header
+            sessionid = this.extractSessionIdFromJWT();
+            if (sessionid) {
+                this.realtimeDebug(`SessionID extracted from JWT-like auth: ${String(sessionid).substring(0, 20)}...`);
+            }
+        } catch (e) {
+            sessionid = null;
         }
-        // Second try: Direct cookie lookup
+
+        // 2. Try state helpers (some libs expose extractCookieValue)
         if (!sessionid) {
             try {
-                sessionid = this.ig.state.extractCookieValue('sessionid');
+                if (typeof this.ig.state.extractCookieValue === 'function') {
+                    sessionid = this.ig.state.extractCookieValue('sessionid');
+                }
             } catch (e) {
                 sessionid = null;
             }
         }
-        // Third try: Parsed authorization
+
+        // 3. Try raw state fields
         if (!sessionid) {
             try {
-                sessionid = this.ig.state.parsedAuthorization?.sessionid;
-            } catch (e2) {
+                sessionid = this.ig.state.sessionId || this.ig.state.sessionid || this.ig.state.cookies?.sessionid || null;
+            } catch (e) {
                 sessionid = null;
             }
         }
-        // Fourth try: CookieJar introspection
+
+        // 4. Try cookieJar inspection (best effort)
         if (!sessionid) {
             try {
-                const cookies = this.ig.state.cookieJar.getCookiesSync('https://i.instagram.com/');
-                const sessionCookie = cookies.find(c => c.key === 'sessionid');
-                sessionid = sessionCookie?.value;
+                if (this.ig.state.cookieJar && typeof this.ig.state.cookieJar.getCookiesSync === 'function') {
+                    const cookies = this.ig.state.cookieJar.getCookiesSync('https://i.instagram.com/') || [];
+                    const found = cookies.find(c => (c.key === 'sessionid' || c.name === 'sessionid'));
+                    if (found) sessionid = found.value;
+                }
             } catch (e) {
-                sessionid = null;
+                // ignore
             }
         }
-        // Last resort: Generate from userId + timestamp
+
+        // 5. Last resort fallback (generated)
         if (!sessionid) {
             const userId = this.ig.state.cookieUserId || this.ig.state.userId || '0';
             sessionid = String(userId) + '_' + Date.now();
             this.realtimeDebug(`SessionID generated (fallback): ${sessionid}`);
         }
-        const password = `sessionid=${sessionid}`;
+
+        // Determine deviceSecret if available via attached authState or ig.state
+        let deviceSecret = null;
+        try {
+            if (this._attachedAuthState && typeof this._attachedAuthState.getData === 'function') {
+                const d = this._attachedAuthState.getData();
+                if (d && d.device && (d.device.deviceSecret || d.device.secret)) {
+                    deviceSecret = d.device.deviceSecret || d.device.secret;
+                }
+                // also check mqttAuth
+                if (!deviceSecret && d && d.mqttAuth && (d.mqttAuth.deviceSecret || d.mqttAuth.secret)) {
+                    deviceSecret = d.mqttAuth.deviceSecret || d.mqttAuth.secret;
+                }
+            }
+        } catch (e) {}
+        // also try ig.state
+        try {
+            if (!deviceSecret && (this.ig.state.deviceSecret || this.ig.state.mqttDeviceSecret)) {
+                deviceSecret = this.ig.state.deviceSecret || this.ig.state.mqttDeviceSecret;
+            }
+        } catch (e) {}
+
+        // Determine mqttAuth token if present
+        let mqttJwt = null;
+        try {
+            if (this._attachedAuthState && typeof this._attachedAuthState.getData === 'function') {
+                const d = this._attachedAuthState.getData();
+                if (d && d.mqttAuth && d.mqttAuth.jwt) mqttJwt = d.mqttAuth.jwt;
+            }
+            // fallback to ig.state
+            if (!mqttJwt && this.ig.state.mqttJwt) mqttJwt = this.ig.state.mqttJwt;
+        } catch (e) {}
+
+        // Build password: prefer mqttJwt if present, else sessionid style string
+        let password;
+        if (mqttJwt) {
+            password = `jwt=${mqttJwt}`;
+        } else {
+            password = `sessionid=${sessionid}`;
+        }
+
+        // Determine clientType and other clientInfo modifications if secure deviceSecret exists
+        const clientType = deviceSecret ? 'secure_cookie_auth' : 'cookie_auth';
+
+        const clientMqttSessionId = (BigInt(Date.now()) & BigInt(0xffffffff));
+
+        const subscribeTopics = [88, 135, 149, 150, 133, 146];
+
         this.connection = new mqttot_1.MQTToTConnection({
             clientIdentifier: deviceId.substring(0, 20),
             clientInfo: {
@@ -274,11 +401,11 @@ class RealtimeClient extends eventemitter3_1.EventEmitter {
                 isInitiallyForeground: true,
                 networkType: 1,
                 networkSubtype: 0,
-                clientMqttSessionId: BigInt(Date.now()) & BigInt(0xffffffff),
-                subscribeTopics: [88, 135, 149, 150, 133, 146],
-                clientType: 'cookie_auth',
+                clientMqttSessionId: clientMqttSessionId,
+                subscribeTopics,
+                clientType,
                 appId: BigInt(567067343352427),
-                deviceSecret: '',
+                deviceSecret: deviceSecret || '',
                 clientStack: 3,
                 ...(this.initOptions?.connectOverrides || {}),
             },
@@ -390,6 +517,11 @@ class RealtimeClient extends eventemitter3_1.EventEmitter {
 
         console.log('[RealtimeClient] Connecting from saved session...');
 
+        // Attach authState to this instance so constructConnection can read deviceSecret/mqttAuth
+        try {
+            this._attachedAuthState = authStateHelper;
+        } catch (e) {}
+
         const savedOptions = authStateHelper.getMqttConnectOptions?.();
         
         const connectOptions = {
@@ -405,6 +537,18 @@ class RealtimeClient extends eventemitter3_1.EventEmitter {
             hasIrisData: !!connectOptions.irisData
         });
 
+        // If authState has mqttAuth with expiresAt, optionally warn if expired (non-fatal)
+        try {
+            const d = authStateHelper.getData?.() || authStateHelper.data || {};
+            const mqttAuth = d.mqttAuth || null;
+            if (mqttAuth && mqttAuth.expiresAt) {
+                const t = new Date(mqttAuth.expiresAt).getTime();
+                if (!isNaN(t) && Date.now() > t) {
+                    console.warn('[RealtimeClient] Warning: saved mqttAuth token appears expired.');
+                }
+            }
+        } catch (e) {}
+
         await this.connect(connectOptions);
 
         if (authStateHelper.saveMqttSession) {