nodejs-insta-private-api-mqt 1.4.6 → 1.4.7

package/dist/dist/constants/index.js

@@ -13,7 +13,7 @@ const LOGIN_EXPERIMENTS = 'ig_android_fci_onboarding_friend_search,ig_android_de
 const FACEBOOK_ANALYTICS_APPLICATION_ID = '567067343352427';
 const FACEBOOK_OTA_FIELDS = 'update%7Bdownload_uri%2Cdownload_uri_delta_base%2Cversion_code_delta_base%2Cdownload_uri_delta%2Cfallback_to_full_update%2Cfile_size_delta%2Cversion_code%2Cpublished_date%2Cfile_size%2Cota_bundle_type%2Cresources_checksum%2Callowed_networks%2Crelease_id%7D';
 const FACEBOOK_ORCA_APPLICATION_ID = '124024574287414';
-const BLOKS_VERSION_ID = 'ce555e5500576acd8e84a66018f54a05720f2dce29f0bb5a1f97f0c10d6fac48';
+const BLOKS_VERSION_ID = '5e47baf35c5a270b44c8906c8b99063564b30ef69779f3dee0b828bee2e4ef5b';
 const SUPPORTED_CAPABILITIES = [
     {
         value: '119.0,120.0,121.0,122.0,123.0,124.0,125.0,126.0,127.0,128.0,129.0,130.0,131.0,132.0,133.0,134.0,135.0,136.0,137.0,138.0,139.0,140.0,141.0,142.0',

package/dist/dist/repositories/account.repository.js

@@ -345,6 +345,175 @@ class AccountRepository extends Repository {
         return fallback;
     }
 
+    /**
+     * Fetches the latest bloksVersionId from Instagram's launcher/sync endpoint.
+     * Saves result to bloks-version.json in the session folder (authinfo_instagram/<username>/).
+     * If fetch fails, keeps the existing bloksVersionId from state or falls back to hardcoded.
+     */
+    async _fetchAndSaveBloksVersion(username) {
+        const fs = require('fs');
+        const path = require('path');
+        const FALLBACK_BLOKS = '5e47baf35c5a270b44c8906c8b99063564b30ef69779f3dee0b828bee2e4ef5b';
+
+        // Session folder: authinfo_instagram/<username>/
+        const sessionDir = path.join(
+            process.cwd(),
+            'authinfo_instagram',
+            username ? String(username) : 'default'
+        );
+        const bloksFile = path.join(sessionDir, 'bloks-version.json');
+
+        try { fs.mkdirSync(sessionDir, { recursive: true }); } catch (e) {}
+
+        const state = this.client.state || {};
+        const userAgent = this._resolveUserAgent();
+        const lang = state.language || 'ro_RO';
+        const nowSec = Math.floor(Date.now() / 1000);
+        const androidDeviceId =
+            state.androidDeviceId || state.deviceId ||
+            `android-${crypto.randomBytes(8).toString('hex')}`;
+        const deviceUUID = state.uuid || state.deviceId ||
+            (crypto.randomUUID ? crypto.randomUUID() : require('uuid').v4());
+        const networkProps = buildNetworkProperties();
+
+        // Current bloksVersionId as starting point
+        const currentBloks = state.bloksVersionId || FALLBACK_BLOKS;
+
+        // Helper: extract 64-char hex bloksVersionId from any object/string
+        const extractBloks = (body) => {
+            if (!body) return null;
+            const bodyStr = typeof body === 'string' ? body : JSON.stringify(body);
+            // Direct fields
+            if (body.bloks_version_id && /^[a-f0-9]{64}$/.test(body.bloks_version_id)) return body.bloks_version_id;
+            if (body.bloksVersionId && /^[a-f0-9]{64}$/.test(body.bloksVersionId)) return body.bloksVersionId;
+            // Search in JSON string
+            const m = bodyStr.match(/"bloks_version_id"\s*:\s*"([a-f0-9]{64})"/) ||
+                      bodyStr.match(/"bloksVersionId"\s*:\s*"([a-f0-9]{64})"/) ||
+                      bodyStr.match(/"x-bloks-version-id"\s*:\s*"([a-f0-9]{64})"/) ||
+                      bodyStr.match(/([a-f0-9]{64})/);
+            if (m && m[1] && /^[a-f0-9]{64}$/.test(m[1])) return m[1];
+            return null;
+        };
+
+        // Helper: safe state setter for bloksVersionId
+        // state.bloksVersionId may be read-only (getter-only via Object.defineProperty)
+        // so we force-redefine it
+        const setBloksInState = (val) => {
+            try {
+                // Try direct set first
+                this.client.state.bloksVersionId = val;
+                return;
+            } catch (e) {}
+            try {
+                // Force redefine the property as writable
+                Object.defineProperty(this.client.state, 'bloksVersionId', {
+                    value: val,
+                    writable: true,
+                    configurable: true,
+                    enumerable: true,
+                });
+                return;
+            } catch (e) {}
+            try { this.client.state._bloksVersionId = val; } catch (e) {}
+            try {
+                // Last resort: patch constants object if that's where it comes from
+                if (this.client.state.constants) {
+                    this.client.state.constants.BLOKS_VERSION_ID = val;
+                }
+            } catch (e) {}
+        };
+
+        const commonHeaders = {
+            'accept-language': `${lang.replace('_', '-')}, en-US`,
+            'content-type': 'application/x-www-form-urlencoded; charset=UTF-8',
+            'x-bloks-version-id': currentBloks,
+            'x-ig-android-id': androidDeviceId,
+            'x-ig-app-id': String(state.fbAnalyticsApplicationId || '567067343352427'),
+            'x-ig-app-locale': lang,
+            'x-ig-device-locale': lang,
+            'x-ig-mapped-locale': lang,
+            'x-ig-capabilities': '3brTv10=',
+            'x-ig-connection-type': 'MOBILE(UNKNOWN)',
+            'x-fb-connection-type': 'MOBILE.UNKNOWN',
+            'x-fb-client-ip': 'True',
+            'x-fb-server-cluster': 'True',
+            'x-fb-http-engine': 'MNS/TCP',
+            'x-fb-network-properties': networkProps,
+            'x-ig-timezone-offset': String(typeof state.timezoneOffset === 'number' ? state.timezoneOffset : 7200),
+            'x-mid': state.mid || `aZ${crypto.randomBytes(8).toString('hex')}`,
+            'x-pigeon-rawclienttime': `${nowSec}.${Math.floor(Math.random() * 1000).toString().padStart(3, '0')}`,
+            'x-pigeon-session-id': state.pigeonSessionId || `UFS-${crypto.randomBytes(16).toString('hex')}-0`,
+            'x-tigon-is-retry': 'False',
+            'x-ig-www-claim': state.igWWWClaim || '0',
+            'accept-encoding': 'gzip, deflate',
+            'user-agent': userAgent,
+            'x-fb-rmd': 'state=URL_ELIGIBLE',
+        };
+
+        let fetchedBloks = null;
+        let rawBody = null;
+        let endpointUsed = null;
+
+        try {
+            // Endpoint 1: launcher/sync — sometimes returns bloks in config
+            const r1 = await this.client.request.send({
+                method: 'POST',
+                url: '/api/v1/launcher/sync/',
+                form: this.client.request.sign({ id: deviceUUID, server_config_retrieval: '1' }),
+                headers: { ...commonHeaders, 'x-fb-friendly-name': 'IgApi: launcher/sync/' },
+            });
+            rawBody = r1.body;
+            fetchedBloks = extractBloks(r1.body);
+            if (fetchedBloks) endpointUsed = 'launcher/sync';
+        } catch (e) {}
+
+        if (!fetchedBloks) {
+            try {
+                // Endpoint 2: qe/sync — often contains bloks version in headers/body
+                const r2 = await this.client.request.send({
+                    method: 'POST',
+                    url: '/api/v1/qe/sync/',
+                    form: this.client.request.sign({ id: deviceUUID, server_config_retrieval: '1' }),
+                    headers: { ...commonHeaders, 'x-fb-friendly-name': 'IgApi: qe/sync/' },
+                });
+                // Check response headers too
+                const hdrs = r2.headers || {};
+                const bloksHeader = hdrs['x-bloks-version-id'] || hdrs['bloks-version-id'];
+                if (bloksHeader && /^[a-f0-9]{64}$/.test(bloksHeader)) {
+                    fetchedBloks = bloksHeader;
+                    endpointUsed = 'qe/sync (header)';
+                } else {
+                    fetchedBloks = extractBloks(r2.body);
+                    if (fetchedBloks) endpointUsed = 'qe/sync (body)';
+                }
+                if (!rawBody) rawBody = r2.body;
+            } catch (e) {}
+        }
+
+        const gotNew = !!(fetchedBloks && fetchedBloks !== currentBloks);
+        const bloksToUse = fetchedBloks || currentBloks;
+
+        // Update state safely
+        setBloksInState(bloksToUse);
+
+        // Save to bloks-version.json in session folder
+        const saveData = {
+            username: username || 'unknown',
+            bloksVersionId: bloksToUse,
+            previousBloksVersionId: currentBloks,
+            updatedAt: new Date().toISOString(),
+            gotNewVersion: gotNew,
+            fetchSuccess: !!fetchedBloks,
+            endpointUsed: endpointUsed || 'none — kept existing',
+            rawResponse: rawBody || null,
+        };
+        try {
+            fs.writeFileSync(bloksFile, JSON.stringify(saveData, null, 2), 'utf8');
+        } catch (writeErr) {}
+
+        return bloksToUse;
+    }
+
     async ensureCsrfToken() {
         const cookieToken = this.client.state.cookieCsrfToken;
         if (cookieToken && cookieToken !== 'missing' && cookieToken !== 'pending') {
@@ -883,6 +1052,9 @@ class AccountRepository extends Repository {
 
         if (!username || !password) throw new Error('Username and password are required');
 
+        // Fetch latest bloksVersionId from Instagram and save to session folder
+        try { await this._fetchAndSaveBloksVersion(username); } catch (e) {}
+
         await this.ensureCsrfToken();
 
         try { await this._launcherMobileConfig(true); } catch (e) {}

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "nodejs-insta-private-api-mqt",
-  "version": "1.4.6",
+  "version": "1.4.7",
   "description": "Complete Instagram MQTT protocol with full-featured REALTIME and REST API — all in one project.",
 
   "main": "dist/dist/index.js",