nodejs-insta-private-api-mqt 1.3.79 → 1.3.80

package/dist/repositories/account.repository.js

@@ -114,8 +114,13 @@ class AccountRepository extends Repository {
         'X-FB-Connection-Type': 'MOBILE.LTE',
         'X-FB-Network-Properties': 'VPN;Metered;Validated;LocalAddrs=/10.0.0.2,;',
         'X-FB-Conn-UUID-Client': crypto.randomBytes(16).toString('hex'),
+        'X-IG-Bandwidth-Speed-KBPS': (Math.random() * 1500 + 1500).toFixed(3),
+        'X-IG-Bandwidth-TotalBytes-B': '0',
+        'X-IG-Bandwidth-TotalTime-MS': '0',
+        'X-IG-Connection-Type': 'MOBILE(LTE)',
+        'X-IG-Capabilities': '3brTv10=',
         'Accept-Encoding': 'gzip, deflate',
-        'X-FB-HTTP-Engine': 'Liger',
+        'X-FB-HTTP-Engine': 'MNS/TCP',
       };
 
       const response = await this.client.request.send({
@@ -184,52 +189,132 @@ class AccountRepository extends Repository {
           throw err;
         }
 
-        const bearerMatch = layoutStr.match(/Bearer IGT:2:[A-Za-z0-9+\/=]+/);
-        if (bearerMatch) {
-          this.client.state.authorization = bearerMatch[0];
-          this.client.state.updateAuthorization();
+        const bearerPatterns = [
+          /Bearer IGT:2:[A-Za-z0-9+\/=]+/,
+          /Bearer\s+IGT:2:[A-Za-z0-9+\/=]+/,
+          /\\?"Bearer IGT:2:([A-Za-z0-9+\/=]+)\\?"/,
+          /ig-set-authorization[\\"\s:]*Bearer IGT:2:([A-Za-z0-9+\/=]+)/i,
+        ];
+        for (const pattern of bearerPatterns) {
+          const bearerMatch = layoutStr.match(pattern);
+          if (bearerMatch) {
+            const token = bearerMatch[0].includes('Bearer IGT:2:')
+              ? bearerMatch[0].replace(/^.*?(Bearer IGT:2:[A-Za-z0-9+\/=]+).*$/, '$1')
+              : `Bearer IGT:2:${bearerMatch[1]}`;
+            this.client.state.authorization = token.replace(/\\?"/g, '').trim();
+            this.client.state.updateAuthorization();
+            break;
+          }
         }
 
-        const pkMatch = layoutStr.match(/\\"pk\\":(\d+)/);
-        if (pkMatch) {
-          this.client.state.cookieUserId = pkMatch[1];
+        const pkPatterns = [
+          /\\"pk\\":\s*(\d+)/,
+          /"pk":\s*(\d+)/,
+          /\\"pk_id\\":\s*\\"(\d+)\\"/,
+          /"pk_id":\s*"(\d+)"/,
+          /logged_in_user.*?"pk":\s*(\d+)/,
+          /logged_in_user.*?\\"pk\\":\s*(\d+)/,
+        ];
+        let extractedPk = null;
+        for (const pattern of pkPatterns) {
+          const pkMatch = layoutStr.match(pattern);
+          if (pkMatch) {
+            extractedPk = pkMatch[1];
+            this.client.state.cookieUserId = extractedPk;
+            this.client.state._userId = extractedPk;
+            break;
+          }
         }
 
-        const wwwClaimMatch = layoutStr.match(/IG-Set-WWW-Claim[\\"\s:]+([a-f0-9]+)/i);
-        if (wwwClaimMatch) {
-          this.client.state.igWWWClaim = wwwClaimMatch[1];
+        const wwwClaimPatterns = [
+          /IG-Set-WWW-Claim[\\"\s:]+([a-f0-9]+)/i,
+          /ig-set-www-claim[\\"\s:]+([a-f0-9]+)/i,
+          /www.claim[\\"\s:]+([a-f0-9]+)/i,
+          /x-ig-set-www-claim[\\"\s:]+([a-f0-9]+)/i,
+        ];
+        for (const pattern of wwwClaimPatterns) {
+          const wwwClaimMatch = layoutStr.match(pattern);
+          if (wwwClaimMatch) {
+            this.client.state.igWWWClaim = wwwClaimMatch[1];
+            break;
+          }
         }
 
-        const encKeyIdMatch = layoutStr.match(/IG-Set-Password-Encryption-Key-Id[\\"\s:]+(\d+)/i);
+        const encKeyIdMatch = layoutStr.match(/IG-Set-Password-Encryption-Key-Id[\\"\s:]+(\d+)/i) ||
+                              layoutStr.match(/password.encryption.key.id[\\"\s:]+(\d+)/i);
         if (encKeyIdMatch) {
           this.client.state.passwordEncryptionKeyId = parseInt(encKeyIdMatch[1]);
         }
 
-        const encPubKeyMatch = layoutStr.match(/IG-Set-Password-Encryption-Pub-Key[\\"\s:]+([A-Za-z0-9+\/=]+)/i);
+        const encPubKeyMatch = layoutStr.match(/IG-Set-Password-Encryption-Pub-Key[\\"\s:]+([A-Za-z0-9+\/=]+)/i) ||
+                               layoutStr.match(/password.encryption.pub.key[\\"\s:]+([A-Za-z0-9+\/=]+)/i);
         if (encPubKeyMatch) {
           this.client.state.passwordEncryptionPubKey = encPubKeyMatch[1];
         }
 
-        const loginResponseMatch = layoutStr.match(/\\"logged_in_user\\":\{[^}]*\\"pk\\":(\d+)[^}]*\\"username\\":\\"([^"\\]+)\\"/);
-        if (loginResponseMatch) {
-          return {
-            pk: parseInt(loginResponseMatch[1]),
-            pk_id: loginResponseMatch[1],
-            username: loginResponseMatch[2],
-          };
+        const midMatch = layoutStr.match(/ig-set-x-mid[\\"\s:]+([A-Za-z0-9+\/=_-]+)/i) ||
+                         layoutStr.match(/\\"x-mid\\"[\\"\s:]+([A-Za-z0-9+\/=_-]+)/i);
+        if (midMatch) {
+          this.client.state.mid = midMatch[1];
+        }
+
+        const loginResponsePatterns = [
+          /\\"logged_in_user\\":\{[^}]*\\"pk\\":(\d+)[^}]*\\"username\\":\\"([^"\\]+)\\"/,
+          /"logged_in_user":\{[^}]*"pk":(\d+)[^}]*"username":"([^"]+)"/,
+          /\\"logged_in_user\\".*?\\"pk\\":\s*(\d+).*?\\"username\\":\s*\\"([^"\\]+)\\"/s,
+        ];
+        for (const pattern of loginResponsePatterns) {
+          const loginResponseMatch = layoutStr.match(pattern);
+          if (loginResponseMatch) {
+            this.client.state.cookieUserId = loginResponseMatch[1];
+            this.client.state._userId = loginResponseMatch[1];
+            return {
+              pk: parseInt(loginResponseMatch[1]),
+              pk_id: loginResponseMatch[1],
+              username: loginResponseMatch[2],
+            };
+          }
+        }
+
+        if (extractedPk && this.client.state.authorization) {
+          try {
+            const userInfo = await this.currentUser();
+            const user = userInfo.user || userInfo;
+            if (user && user.pk) {
+              this.client.state.cookieUserId = String(user.pk);
+              this.client.state._userId = String(user.pk);
+            }
+            return user;
+          } catch (e) {
+            return { pk: parseInt(extractedPk), pk_id: extractedPk };
+          }
         }
       }
 
       if (body.logged_in_user) {
-        return body.logged_in_user;
+        const lu = body.logged_in_user;
+        if (lu.pk) {
+          this.client.state.cookieUserId = String(lu.pk);
+          this.client.state._userId = String(lu.pk);
+        }
+        return lu;
       }
 
-      try {
-        const userInfo = await this.currentUser();
-        return userInfo.user || userInfo;
-      } catch (e) {
-        return body;
+      if (this.client.state.authorization) {
+        try {
+          const userInfo = await this.currentUser();
+          const user = userInfo.user || userInfo;
+          if (user && user.pk) {
+            this.client.state.cookieUserId = String(user.pk);
+            this.client.state._userId = String(user.pk);
+          }
+          return user;
+        } catch (e) {
+          return body;
+        }
       }
+
+      return body;
     });
   }
 

package/dist/repositories/direct.repository.js

@@ -12,10 +12,31 @@ class DirectRepository extends Repository {
       const result = await requestFn();
       return result;
     } catch (error) {
-      const shouldRetry =
-        (error.data?.error_type === 'server_error' ||
-         error.data?.error_type === 'rate_limited') &&
-        retries < this.maxRetries;
+      const errorCode = error.data?.content?.error_code || error.data?.error_code;
+      const errorType = error.data?.error_type;
+      const statusCode = error.status || error.data?.status_code;
+
+      const isPromptContribution = errorCode === 4415001;
+      const isAuthIssue = statusCode === 400 && isPromptContribution;
+      const isServerError = errorType === 'server_error';
+      const isRateLimited = errorType === 'rate_limited';
+      const isLoginRequired = error.data?.message === 'login_required' || errorType === 'login_required';
+
+      if ((isAuthIssue || isLoginRequired) && retries < this.maxRetries) {
+        try {
+          if (this.client.state.authorization) {
+            this.client.state.updateAuthorization();
+          }
+          if (this.client.account && typeof this.client.account.syncPostLoginExperiments === 'function') {
+            await this.client.account.syncPostLoginExperiments().catch(() => {});
+          }
+        } catch (syncErr) {}
+        const delay = 2000 * (retries + 1);
+        await new Promise(resolve => setTimeout(resolve, delay));
+        return this.requestWithRetry(requestFn, retries + 1);
+      }
+
+      const shouldRetry = (isServerError || isRateLimited) && retries < this.maxRetries;
       if (shouldRetry) {
         const delay = 1000 * (retries + 1);
         await new Promise(resolve => setTimeout(resolve, delay));
@@ -159,6 +180,19 @@ class DirectRepository extends Repository {
   }
 
   async getInbox(cursor = null, limit = 20) {
+    if (!this.client.state.authorization) {
+      throw new Error('Not authenticated. Please login first before accessing inbox.');
+    }
+
+    const userId = this.client.state.cookieUserId || this.client.state._userId;
+    if (!userId || userId === '0' || userId === 0) {
+      this.client.state.updateAuthorization();
+      if (this.client.state.parsedAuthorization && this.client.state.parsedAuthorization.ds_user_id) {
+        this.client.state._userId = this.client.state.parsedAuthorization.ds_user_id;
+        this.client.state.cookieUserId = this.client.state.parsedAuthorization.ds_user_id;
+      }
+    }
+
     return this.requestWithRetry(async () => {
       const qs = { persistentBadging: true, limit };
       if (cursor) qs.cursor = cursor;

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "nodejs-insta-private-api-mqt",
-  "version": "1.3.79",
+  "version": "1.3.80",
   "description": "Complete Instagram MQTT protocol with FULL Featured REALTIME And api Rest All in one project .",
   "main": "dist/index.js",
   "scripts": {