nodejs-insta-private-api-mqtt 1.3.14 → 1.3.15

package/README.md

@@ -262,52 +262,104 @@ startBot().catch(console.error);
 
 ---
 
-## 🖼️ FIXED: Send Media via MQTT (v5.70.0)
 
-The upload issue has been fully resolved. You can now send photos and videos directly through the MQTT protocol. The library now handles raw buffers correctly, matching the Instagram internal protocol for zero "Upload Failed" errors.
+## 🖼️ IMPORTANT: How media actually works (photos & videos)
 
-### Send Media via MQTT (v5.70.0)
+> **Critical clarification:** The previous README wording that claimed *"Send Media via MQTT"* was misleading. Instagram's real-time (MQTT) layer is a *sync/notification* channel — **it does not replace the HTTP upload + broadcast flow required to create new photo/video DM messages server-side**. The correct and reliable sequence to send media is:
 
-You can now send photos, videos, voice messages, and more directly through the MQTT protocol. The library handles the upload and linking automatically.
+1. **Upload the media (rupload) — HTTP**  
+   Upload the raw bytes to Instagram's rupload endpoint (this returns an `upload_id`). This step stores the media on Instagram's storage/CDN.
+
+2. **Create / broadcast the media message — HTTP**  
+   Use the Direct API `configure_photo` (or video equivalent) endpoint to create the DM message that references the `upload_id`. This action makes the message exist on Instagram's servers and associates it with the target thread(s).
+
+3. **MQTT = realtime sync / notification**  
+   Once the server-side message exists, MQTT will propagate a `MESSAGE_SYNC` (or similar) event so clients receive the message in realtime. MQTT does **not** perform the storage, processing or permanent creation of media on the server.
+
+---
+
+### Why this change matters
+
+- MQTT is excellent for **text**, **reactions**, **typing**, **presence** and **read receipts** — these can be (and are) sent directly over realtime topics.  
+- Media (images, videos, view-once content) require storage, processing and metadata which are handled by HTTP endpoints. Without the HTTP broadcast step, other clients will not see the uploaded bytes even if an MQTT "send" payload is transmitted.
+
+---
+
+### Correct examples (upload + broadcast)
+
+#### Upload a photo and broadcast (recommended pattern)
 
-#### 📷 Send a Photo
 ```javascript
+const fs = require('fs');
+const { v4: uuidv4 } = require('uuid');
+
 const photoBuffer = fs.readFileSync('./image.jpg');
-const upload = await ig.publish.photo({ file: photoBuffer });
 
-await realtime.directCommands.sendMedia({
-  threadId: 'THREAD_ID',
-  mediaId: upload.upload_id,
-  uploadId: upload.upload_id
+// 1) rupload (helper may exist as ig.publish.photo)
+const upload = await ig.publish.photo({ file: photoBuffer });
+// upload.upload_id should be available (or upload.uploadId)
+
+// 2) broadcast the uploaded photo via HTTP to the thread(s)
+const mutationToken = uuidv4();
+const payload = {
+  action: 'configure_photo',
+  upload_id: String(upload.upload_id || upload.uploadId || upload),
+  thread_ids: JSON.stringify([threadId]), // or JSON array of thread ids
+  client_context: mutationToken,
+  mutation_token: mutationToken,
+  _csrftoken: ig.state.cookieCsrfToken || '',
+  _uuid: ig.state.uuid || '',
+  device_id: ig.state.deviceId || ''
+};
+
+const response = await ig.request.send({
+  url: '/api/v1/direct_v2/threads/broadcast/configure_photo/',
+  method: 'POST',
+  form: payload,
+  timeout: 60000
 });
+
+// If response indicates success (status: 'ok' or similar), the message is now created server-side.
+// MQTT will usually emit a MESSAGE_SYNC event shortly after with the CDN URL for the image.
 ```
 
-#### 🎥 Send a Video
+#### Upload and broadcast a video
+
 ```javascript
 const videoBuffer = fs.readFileSync('./video.mp4');
-const upload = await ig.publish.video({
-  video: videoBuffer,
-  duration: 10000, // ms
-});
 
-await realtime.directCommands.sendMedia({
-  threadId: 'THREAD_ID',
-  mediaId: upload.upload_id,
-  uploadId: upload.upload_id
+// 1) rupload video (may be ig.publish.video)
+const upload = await ig.publish.video({ video: videoBuffer, duration: 15000 });
+
+// 2) broadcast via HTTP similar to photo but to the upload_video endpoint
+const mutationToken = uuidv4();
+const payload = {
+  action: 'configure_video',
+  upload_id: String(upload.upload_id || upload.uploadId || upload),
+  thread_ids: JSON.stringify([threadId]),
+  client_context: mutationToken,
+  mutation_token: mutationToken,
+  _csrftoken: ig.state.cookieCsrfToken || '',
+  _uuid: ig.state.uuid || '',
+  device_id: ig.state.deviceId || ''
+};
+
+const response = await ig.request.send({
+  url: '/api/v1/direct_v2/threads/broadcast/configure_video/',
+  method: 'POST',
+  form: payload,
+  timeout: 90000
 });
 ```
 
-#### 🎤 Send Voice Message
-```javascript
-const audioBuffer = fs.readFileSync('./voice.mp4');
-const upload = await ig.publish.audio({ file: audioBuffer });
+---
 
-await realtime.directCommands.sendMedia({
-  threadId: 'THREAD_ID',
-  mediaId: upload.upload_id,
-  uploadId: upload.upload_id
-});
-```
+### What was removed/changed
+- Any claim that photos/videos can be **created** solely through MQTT was corrected.
+- Examples and helper text were updated to show the required HTTP upload + broadcast flow.
+- MQTT examples for text and realtime events remain unchanged; MQTT should still be used for fast realtime behavior.
+
+---
 
 
 We've completely overhauled how the MQTT connection works. You no longer need to manually manage connection states every time your bot restarts. Just like **Baileys**, if a session is present in the default folder, the library takes care of everything for you.
@@ -1359,6 +1411,205 @@ const fs = require('fs');
 
 ---
 
+
+---
+
+### Example 3: CLI Photo Sender (upload HTTP + broadcast HTTP, with MQTT sync)
+
+This example is a ready-to-run CLI script that demonstrates the correct flow to **send a photo** to one or more threads:
+1. upload the photo to Instagram's rupload endpoint (HTTP),
+2. broadcast (configure) the photo to the target thread(s) using the Direct API (HTTP),
+3. use MQTT (RealtimeClient) only for realtime sync and confirmation.
+
+Save this as `examples/send-photo-cli.js`.
+
+```javascript
+#!/usr/bin/env node
+// examples/send-photo-cli.js
+// Node 18+, install nodejs-insta-private-api-mqtt in the project
+
+const fs = require('fs');
+const path = require('path');
+const readline = require('readline/promises');
+const { stdin: input, stdout: output } = require('process');
+const { v4: uuidv4 } = require('uuid');
+
+(async () => {
+  const rl = readline.createInterface({ input, output });
+  try {
+    console.log('\\n--- Instagram Photo Sender (HTTP + broadcast) ---\\n');
+    const username = (await rl.question('Enter your Instagram username: ')).trim();
+    const password = (await rl.question('Enter your Instagram password: ')).trim();
+    if (!username || !password) {
+      console.error('username & password required'); process.exit(1);
+    }
+
+    const { IgApiClient, RealtimeClient, useMultiFileAuthState } = require('nodejs-insta-private-api-mqtt');
+    const AUTH_FOLDER = path.resolve(process.cwd(), './auth_info_instagram');
+
+    const authState = await useMultiFileAuthState(AUTH_FOLDER);
+    const ig = new IgApiClient();
+    ig.state.generateDevice?.(username);
+
+    // load saved credentials if available
+    if (authState.hasSession && authState.hasSession()) {
+      try { await authState.loadCreds?.(ig); console.log('[*] Loaded saved creds'); } catch(e){}
+    }
+
+    // login if needed
+    if (!authState.hasSession || (typeof authState.hasSession === 'function' && !authState.hasSession())) {
+      await ig.login({ username, password });
+      await authState.saveCreds?.(ig);
+      console.log('[+] Logged in and saved creds');
+    }
+
+    // start realtime client (optional, helps sync)
+    const realtime = new RealtimeClient(ig);
+    realtime.on?.('connected', () => console.log('✅ MQTT connected (realtime)'));
+
+    // fetch inbox and list threads
+    const inbox = await ig.direct.getInbox();
+    const threads = inbox.threads || inbox.items || inbox.threads_response?.threads || [];
+    if (!threads || threads.length === 0) {
+      console.error('No threads found in inbox. Exiting.'); process.exit(1);
+    }
+
+    console.log('\\nAvailable threads:');
+    const indexToThread = [];
+    threads.slice(0, 50).forEach((t, i) => {
+      const id = String(t.thread_id || t.threadId || t.id || t.thread_id_str || (t.thread && t.thread.thread_id) || '');
+      const title = t.thread_title || t.title || t.item_title || (t.users || t.participants || []).map(u => u.username || u.full_name).slice(0,3).join(', ') || 'Unnamed';
+      indexToThread.push({ id, title });
+      console.log(`${i+1}. ${title} (thread_id: ${id})`);
+    });
+
+    const pick = (await rl.question('\\nSelect thread numbers (e.g. "1 2 3"): ')).trim();
+    const picks = pick.split(/[\s,]+/).map(x => parseInt(x,10)).filter(n => Number.isFinite(n) && n >= 1 && n <= indexToThread.length);
+    const selected = picks.map(p => indexToThread[p-1].id);
+
+    const photoPath = (await rl.question('\\nEnter your Photo path here (absolute or relative): ')).trim();
+    const resolved = path.isAbsolute(photoPath) ? photoPath : path.resolve(process.cwd(), photoPath);
+    if (!fs.existsSync(resolved)) { console.error('File not found', resolved); process.exit(1); }
+    const buffer = fs.readFileSync(resolved);
+    console.log('Photo size (MB):', (buffer.length/(1024*1024)).toFixed(2));
+
+    // RUUPLOAD (HTTP) - try to use ig.publish.photo helper if available
+    let uploadId;
+    try {
+      if (typeof ig.publish?.photo === 'function') {
+        const up = await ig.publish.photo({ file: buffer });
+        uploadId = up.upload_id || up.uploadId || up;
+      } else {
+        // manual rupload via request
+        uploadId = Date.now().toString();
+        const objectName = `${uploadId}_0_${Math.floor(Math.random() * 1e10)}`;
+        const ruploadParams = {
+          retry_context: JSON.stringify({ num_step_auto_retry: 0, num_reupload: 0, num_step_manual_retry: 0 }),
+          media_type: '1',
+          upload_id: uploadId,
+          xsharing_user_ids: JSON.stringify([]),
+          image_compression: JSON.stringify({ lib_name: 'moz', lib_version: '3.1.m', quality: '80' })
+        };
+        const headers = {
+          'X-Instagram-Rupload-Params': JSON.stringify(ruploadParams),
+          'Content-Type': 'application/octet-stream',
+          'X-Entity-Type': 'image/jpeg',
+          'Offset': '0',
+          'X-Entity-Name': objectName,
+          'X-Entity-Length': String(buffer.length),
+          'Content-Length': String(buffer.length),
+        };
+        await ig.request.send({
+          url: `/rupload_igphoto/${objectName}`,
+          method: 'POST',
+          headers,
+          body: buffer,
+          timeout: 120000,
+        });
+      }
+      console.log('[+] Upload completed. upload_id =', uploadId);
+    } catch (err) {
+      console.error('Upload failed:', err?.message || err); process.exit(1);
+    }
+
+    // BROADCAST (HTTP) - create message on server
+    try {
+      const mutationToken = uuidv4();
+      const payload = {
+        action: 'configure_photo',
+        upload_id: String(uploadId),
+        thread_ids: JSON.stringify(selected),
+        client_context: mutationToken,
+        mutation_token: mutationToken,
+        _csrftoken: ig.state.cookieCsrfToken || '',
+        _uuid: ig.state.uuid || '',
+        device_id: ig.state.deviceId || ''
+      };
+      const resp = await ig.request.send({
+        url: '/api/v1/direct_v2/threads/broadcast/configure_photo/',
+        method: 'POST',
+        form: payload,
+        timeout: 60000,
+      });
+      console.log('✅ Broadcast response received:', resp && (resp.status || resp.body || resp.data) ? 'OK' : JSON.stringify(resp).slice(0,120));
+    } catch (err) {
+      console.error('Broadcast failed:', err?.message || err);
+      process.exit(1);
+    }
+
+    console.log('\\nDone. MQTT will sync and you should see the message in the app.');
+    rl.close();
+    process.exit(0);
+  } catch (e) {
+    console.error('Fatal:', e);
+    process.exit(1);
+  }
+})();
+```
+
+---
+
+### Example 4: Video Sender (upload + broadcast)
+
+This is similar to the photo sender but uses the video upload flow and longer timeouts. Use `ig.publish.video()` if available; otherwise rupload manually and call `/api/v1/direct_v2/threads/broadcast/configure_video/`.
+
+```javascript
+// pseudo-code outline
+const videoBuffer = fs.readFileSync('./video.mp4');
+const upload = await ig.publish.video({ video: videoBuffer, duration: 12000 });
+// upload.upload_id -> then broadcast with configure_video payload similar to the photo flow
+```
+
+**Notes:** video uploads often require multipart/segmented upload and longer timeouts; prefer library helper `ig.publish.video()`.
+
+---
+
+### Example 5: Share a file / document (workaround)
+
+Instagram DM does not provide a simple "attach arbitrary file" endpoint. Common workarounds:
+
+1. Upload the file to a hosting service (S3, Dropbox, your own server), then send the link as a text message via MQTT (or HTTP direct send).  
+2. If the file is an image or video, use the rupload + broadcast flow above.
+
+Example (send link message):
+
+```javascript
+// send link as text via realtime (MQTT)
+await realtime.directCommands.sendTextViaRealtime(threadId, 'Download the file here: https://myhost.example.com/myfile.pdf');
+```
+
+---
+
+### Tips for bots sending media
+
+- Always **upload first**, then **broadcast**. Do not rely on MQTT-only calls for media.
+- Use retries and exponential backoff for both rupload and broadcast steps (Instagram can return transient 503).
+- Save `upload_id` and broadcast responses for debugging.
+- If you need to send the same file to many threads, upload once, reuse the same `upload_id` in multiple broadcast calls.
+
+---
+
+
 ## API Reference
 
 ### IgApiClient

package/dist/core/request.js

@@ -1,3 +1,18 @@
+/**
+ * request.fixed.js
+ *
+ * Repaired Request wrapper for nodejs-insta-private-api(-mqtt).
+ * Changes / fixes applied:
+ *  - Removed global Content-Type header (was forcing urlencoded for all requests).
+ *  - Made axios timeout configurable via client.state.requestTimeout (fallback 120s).
+ *  - Set maxContentLength / maxBodyLength = Infinity to allow binary uploads.
+ *  - Accept both `data` and `body` when callers pass payload; ensures axios receives `data`.
+ *  - Preserve ability to pass signal (AbortController) through axios config.
+ *  - Keep updateState / cookie handling intact.
+ *
+ * Replace the original request.js with this file (or apply same changes).
+ */
+
 const axios = require('axios');
 const crypto = require('crypto');
 const { random } = require('lodash');
@@ -7,15 +22,25 @@ class Request {
     this.client = client;
     this.end$ = { complete: () => {} };
     this.error$ = { complete: () => {} };
-    
-    // Create axios instance with default config
+
+    // Determine timeout: prefer client.state.requestTimeout if provided, otherwise 120s
+    const timeoutMs = (this.client && this.client.state && this.client.state.requestTimeout)
+      ? this.client.state.requestTimeout
+      : 120000;
+
+    // Create axios instance with sensible defaults for uploads
     this.httpClient = axios.create({
       baseURL: 'https://i.instagram.com/',
-      timeout: 30000,
-      headers: {
-        'Content-Type': 'application/x-www-form-urlencoded; charset=UTF-8'
-      }
+      timeout: timeoutMs,
+      // Allow large uploads
+      maxContentLength: Infinity,
+      maxBodyLength: Infinity,
+      // Do not set a global Content-Type here -- requests will set their own appropriate Content-Type
+      // headers: { 'Content-Type': 'application/x-www-form-urlencoded; charset=UTF-8' }
     });
+
+    // Optional: you can add interceptors for debugging if needed
+    // this.httpClient.interceptors.response.use(resp => resp, err => Promise.reject(err));
   }
 
   signature(data) {
@@ -46,51 +71,96 @@ class Request {
     return `${signature}\n${body}\n`;
   }
 
-  async send(options) {
+  /**
+   * Send a request.
+   * options should follow axios request config shape but this wrapper supports:
+   *  - options.form -> object (will be turned into application/x-www-form-urlencoded)
+   *  - options.qs -> query params
+   *  - options.data or options.body -> request payload (we prefer data)
+   */
+  async send(options = {}) {
+    // base axios config
     const config = {
-      ...options,
+      url: options.url || options.path || options.uri || '',
+      method: (options.method || 'GET').toUpperCase(),
       headers: {
         ...this.getDefaultHeaders(),
         ...(options.headers || {})
-      }
+      },
+      // allow override of responseType if needed
+      responseType: options.responseType || undefined,
+      // allow axios to handle decompress etc.
+      decompress: options.decompress !== undefined ? options.decompress : true,
     };
 
-    // Handle form data
-    if (options.form) {
-      if (options.method === 'POST' || options.method === 'PUT') {
-        const formData = new URLSearchParams();
-        Object.keys(options.form).forEach(key => {
-          formData.append(key, options.form[key]);
-        });
-        config.data = formData.toString();
+    // Query string / params
+    if (options.qs) {
+      config.params = options.qs;
+    }
+
+    // Abort signal support (axios v0.22+ supports signal)
+    if (options.signal) {
+      config.signal = options.signal;
+    }
+
+    // Handle form data (application/x-www-form-urlencoded)
+    if (options.form && (config.method === 'POST' || config.method === 'PUT' || config.method === 'PATCH')) {
+      // Build a urlencoded string
+      const formData = new URLSearchParams();
+      Object.keys(options.form).forEach(key => {
+        const val = options.form[key];
+        // For arrays/objects convert to JSON string to be safe
+        if (typeof val === 'object') {
+          formData.append(key, JSON.stringify(val));
+        } else {
+          formData.append(key, String(val));
+        }
+      });
+      config.data = formData.toString();
+      config.headers['Content-Type'] = 'application/x-www-form-urlencoded; charset=UTF-8';
+    } else {
+      // If caller supplied data or body, prefer data
+      if (options.data !== undefined) {
+        config.data = options.data;
+      } else if (options.body !== undefined) {
+        // Accept legacy 'body' name used in some wrappers: ensure binary stays as-is
+        config.data = options.body;
       }
     }
 
-    // Handle query parameters
-    if (options.qs) {
-      config.params = options.qs;
+    // If caller explicitly passed paramsSerializer (rare), keep it
+    if (options.paramsSerializer) {
+      config.paramsSerializer = options.paramsSerializer;
     }
 
     try {
-      const response = await this.httpClient(config);
+      // Use axios instance
+      const response = await this.httpClient.request(config);
+      // Update internal client state (cookies, headers, auth, etc.)
       this.updateState(response);
-      
-      if (response.data.status === 'ok' || response.status === 200) {
-        return { body: response.data, headers: response.headers };
+
+      // Normalize success check: either HTTP 200 or response.data.status === 'ok'
+      const data = response.data;
+      if ((data && data.status && data.status === 'ok') || response.status === 200 || response.status === 201) {
+        return { body: data, headers: response.headers, status: response.status };
       }
-      
+
+      // If not explicitly ok, throw a processed error
       throw this.handleResponseError(response);
     } catch (error) {
-      if (error.response) {
+      // If axios error with response, map to IG-specific errors
+      if (error && error.response) {
         throw this.handleResponseError(error.response);
       }
+
+      // Re-throw axios error (timeout, network, abort, etc.)
       throw error;
     }
   }
 
   updateState(response) {
-    const headers = response.headers;
-    
+    const headers = response.headers || {};
+
     if (headers['x-ig-set-www-claim']) {
       this.client.state.igWWWClaim = headers['x-ig-set-www-claim'];
     }
@@ -104,14 +174,16 @@ class Request {
       this.client.state.passwordEncryptionPubKey = headers['ig-set-password-encryption-pub-key'];
     }
 
-    // Update cookies from Set-Cookie headers
-    const setCookieHeaders = headers['set-cookie'];
-    if (setCookieHeaders) {
+    // Update cookies from Set-Cookie headers (if cookieJar is available)
+    const setCookieHeaders = headers['set-cookie'] || headers['Set-Cookie'];
+    if (setCookieHeaders && Array.isArray(setCookieHeaders) && this.client.state && this.client.state.cookieStore && typeof this.client.state.cookieStore.setCookieSync === 'function') {
       setCookieHeaders.forEach(cookieString => {
         try {
-          this.client.state.cookieStore.setCookieSync(cookieString, this.client.state.constants.HOST);
+          // host constant fallback if available
+          const host = (this.client.state.constants && this.client.state.constants.HOST) ? this.client.state.constants.HOST : 'https://i.instagram.com';
+          this.client.state.cookieStore.setCookieSync(cookieString, host);
         } catch (e) {
-          // Ignore cookie parsing errors
+          // ignore cookie parsing errors
         }
       });
     }
@@ -119,61 +191,62 @@ class Request {
 
   handleResponseError(response) {
     const data = response.data || {};
-    
-    if (data.spam) {
+    const status = response.status;
+
+    if (data && data.spam) {
       const error = new Error('Action blocked as spam');
       error.name = 'IgActionSpamError';
       error.response = response;
       return error;
     }
-    
-    if (response.status === 404) {
+
+    if (status === 404) {
       const error = new Error('Not found');
       error.name = 'IgNotFoundError';
       error.response = response;
       return error;
     }
-    
-    if (data.message === 'challenge_required') {
+
+    if (data && data.message === 'challenge_required') {
       this.client.state.checkpoint = data;
       const error = new Error('Challenge required');
       error.name = 'IgCheckpointError';
       error.response = response;
       return error;
     }
-    
-    if (data.message === 'user_has_logged_out') {
+
+    if (data && data.message === 'user_has_logged_out') {
       const error = new Error('User has logged out');
       error.name = 'IgUserHasLoggedOutError';
       error.response = response;
       return error;
     }
-    
-    if (data.message === 'login_required') {
+
+    if (data && data.message === 'login_required') {
       const error = new Error('Login required');
       error.name = 'IgLoginRequiredError';
       error.response = response;
       return error;
     }
-    
-    if (data.error_type === 'sentry_block') {
+
+    if (data && data.error_type === 'sentry_block') {
       const error = new Error('Sentry block');
       error.name = 'IgSentryBlockError';
       error.response = response;
       return error;
     }
-    
-    if (data.error_type === 'inactive user') {
+
+    if (data && data.error_type === 'inactive user') {
       const error = new Error('Inactive user');
       error.name = 'IgInactiveUserError';
       error.response = response;
       return error;
     }
 
-    const error = new Error(data.message || 'Request failed');
+    const error = new Error((data && data.message) ? data.message : 'Request failed');
     error.name = 'IgResponseError';
     error.response = response;
-    error.status = response.status;
+    error.status = status;
     error.data = data;
     return error;
   }
@@ -190,16 +263,16 @@ class Request {
       'X-IG-Bandwidth-Speed-KBPS': '-1.000',
       'X-IG-Bandwidth-TotalBytes-B': '0',
       'X-IG-Bandwidth-TotalTime-MS': '0',
-      'X-IG-Extended-CDN-Thumbnail-Cache-Busting-Value': this.client.state.thumbnailCacheBustingValue.toString(),
+      'X-IG-Extended-CDN-Thumbnail-Cache-Busting-Value': (this.client.state.thumbnailCacheBustingValue || 0).toString(),
       'X-Bloks-Version-Id': this.client.state.bloksVersionId,
       'X-IG-WWW-Claim': this.client.state.igWWWClaim || '0',
-      'X-Bloks-Is-Layout-RTL': this.client.state.isLayoutRTL.toString(),
+      'X-Bloks-Is-Layout-RTL': (this.client.state.isLayoutRTL !== undefined) ? this.client.state.isLayoutRTL.toString() : 'false',
       'X-IG-Connection-Type': this.client.state.connectionTypeHeader,
       'X-IG-Capabilities': this.client.state.capabilitiesHeader,
       'X-IG-App-ID': this.client.state.fbAnalyticsApplicationId,
       'X-IG-Device-ID': this.client.state.uuid,
       'X-IG-Android-ID': this.client.state.deviceId,
-      'Accept-Language': this.client.state.language.replace('_', '-'),
+      'Accept-Language': (this.client.state.language || 'en_US').replace('_', '-'),
       'X-FB-HTTP-Engine': 'Liger',
       'Authorization': this.client.state.authorization,
       'Host': 'i.instagram.com',
@@ -209,4 +282,5 @@ class Request {
   }
 }
 
-module.exports = Request;
+module.exports = Request;
+