react-native-qalink 0.1.3 → 0.3.0

package/dist/core/device.js

@@ -0,0 +1,35 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.resetDeviceId = exports.getDeviceId = void 0;
+
+let cachedDeviceId = null;
+
+function generateDeviceId() {
+  return 'dev_xxxxxxxx-xxxx-4xxx-yxxx-xxxxxxxxxxxx'.replace(/[xy]/g, (c) => {
+    const r = Math.random() * 16 | 0;
+    const v = c === 'x' ? r : (r & 0x3 | 0x8);
+    return v.toString(16);
+  });
+}
+
+const STORAGE_KEY = '@qalink_device_id';
+
+async function getDeviceId() {
+  if (cachedDeviceId) return cachedDeviceId;
+  try {
+    const AsyncStorage = require('@react-native-async-storage/async-storage').default;
+    const stored = await AsyncStorage.getItem(STORAGE_KEY);
+    if (stored) { cachedDeviceId = stored; return cachedDeviceId; }
+    const newId = generateDeviceId();
+    await AsyncStorage.setItem(STORAGE_KEY, newId);
+    cachedDeviceId = newId;
+    return cachedDeviceId;
+  } catch {
+    if (!cachedDeviceId) cachedDeviceId = generateDeviceId();
+    return cachedDeviceId;
+  }
+}
+exports.getDeviceId = getDeviceId;
+
+function resetDeviceId() { cachedDeviceId = null; }
+exports.resetDeviceId = resetDeviceId;

package/dist/core/sanitize.js

@@ -0,0 +1,62 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.sanitizeHeaders = exports.sanitizePayload = exports.isAuthUrl = void 0;
+
+const DEFAULT_SENSITIVE_FIELDS = [
+  'password','passwd','pass','secret','token','access_token','refresh_token',
+  'id_token','authorization','auth','api_key','apikey','api_secret',
+  'credit_card','card_number','cvv','cvc','ssn','social_security',
+  'pin','otp','private_key','client_secret',
+];
+
+const AUTH_URL_PATTERNS = [
+  '/auth/','/login','/signin','/sign-in','/signup','/sign-up',
+  '/register','/password','/token','/oauth','/credentials','/session',
+];
+
+function isAuthUrl(url) {
+  const lower = url.toLowerCase();
+  return AUTH_URL_PATTERNS.some(p => lower.includes(p));
+}
+exports.isAuthUrl = isAuthUrl;
+
+function sanitizePayload(payload, extraSensitiveFields = []) {
+  if (!payload) return { sanitized: payload, hadSensitiveData: false };
+  const allSensitive = [...DEFAULT_SENSITIVE_FIELDS, ...extraSensitiveFields.map(f => f.toLowerCase())];
+  let hadSensitiveData = false;
+
+  const sanitize = (obj) => {
+    if (typeof obj === 'string') {
+      try { const parsed = JSON.parse(obj); return JSON.stringify(sanitize(parsed)); } catch { return obj; }
+    }
+    if (Array.isArray(obj)) return obj.map(sanitize);
+    if (obj !== null && typeof obj === 'object') {
+      const result = {};
+      for (const [key, value] of Object.entries(obj)) {
+        if (allSensitive.includes(key.toLowerCase())) {
+          result[key] = '[REDACTED]';
+          hadSensitiveData = true;
+        } else {
+          result[key] = sanitize(value);
+        }
+      }
+      return result;
+    }
+    return obj;
+  };
+
+  return { sanitized: sanitize(payload), hadSensitiveData };
+}
+exports.sanitizePayload = sanitizePayload;
+
+function sanitizeHeaders(headers, sensitiveHeaders = []) {
+  const defaultSensitive = ['authorization','x-api-key','cookie','set-cookie','x-auth-token'];
+  const allSensitive = [...defaultSensitive, ...sensitiveHeaders.map(h => h.toLowerCase())];
+  return Object.fromEntries(
+    Object.entries(headers).map(([key, value]) => [
+      key,
+      allSensitive.includes(key.toLowerCase()) ? '[REDACTED]' : value,
+    ])
+  );
+}
+exports.sanitizeHeaders = sanitizeHeaders;

package/dist/index.js

@@ -1,171 +1,177 @@
 "use strict";
-var __createBinding = (this && this.__createBinding) || (Object.create ? (function(o, m, k, k2) {
-    if (k2 === undefined) k2 = k;
-    var desc = Object.getOwnPropertyDescriptor(m, k);
-    if (!desc || ("get" in desc ? !m.__esModule : desc.writable || desc.configurable)) {
-      desc = { enumerable: true, get: function() { return m[k]; } };
-    }
-    Object.defineProperty(o, k2, desc);
-}) : (function(o, m, k, k2) {
-    if (k2 === undefined) k2 = k;
-    o[k2] = m[k];
-}));
-var __exportStar = (this && this.__exportStar) || function(m, exports) {
-    for (var p in m) if (p !== "default" && !Object.prototype.hasOwnProperty.call(exports, p)) __createBinding(exports, m, p);
-};
 Object.defineProperty(exports, "__esModule", { value: true });
-exports.getSourceLabel = exports.QALink = void 0;
+exports.QALink = void 0;
 const websocket_1 = require("./transport/websocket");
-const axios_1 = require("./interceptors/axios");
-const fetch_1 = require("./interceptors/fetch");
-const errors_1 = require("./interceptors/errors");
-const console_1 = require("./interceptors/console");
-const runtime_1 = require("./interceptors/runtime");
-const session_1 = require("./core/session");
+const axios_1     = require("./interceptors/axios");
+const fetch_1     = require("./interceptors/fetch");
+const errors_1    = require("./interceptors/errors");
+const console_1   = require("./interceptors/console");
+const runtime_1   = require("./interceptors/runtime");
+const metro_1     = require("./interceptors/metro");
+const session_1   = require("./core/session");
+const device_1    = require("./core/device");
+const sanitize_1  = require("./core/sanitize");
+
 class QALinkSDK {
-    constructor() {
-        this.transport = null;
-        this.config = null;
-        this.cleanups = [];
-        this.initialized = false;
-        this.currentScreen = 'unknown';
-    }
-    /**
-     * Inicializa el SDK. Llamar al inicio de la app, antes de cualquier request.
-     *
-     * @example
-     * QALink.init({
-     *   serverUrl: 'ws://192.168.1.100:3000',
-     *   appVersion: '1.2.3',
-     *   captureRuntimeErrors: true,
-     *   console: {
-     *     captureLogs: true,
-     *     captureWarnings: true,
-     *     captureErrors: true,
-     *     ignorePatterns: ['[react-query]'],
-     *   },
-     * });
-     */
-    async init(config) {
-        var _a;
-        if (this.initialized) {
-            console.warn('[QALink] Already initialized. Call destroy() first.');
-            return;
-        }
-        if (config.enabled === false)
-            return;
-        this.config = Object.assign(Object.assign({ enabled: true, logNetworkBodies: false, sensitiveHeaders: [], sensitiveUrlPatterns: [], captureRuntimeErrors: true, console: {
-                captureLogs: true,
-                captureWarnings: true,
-                captureErrors: true,
-                ignorePatterns: [],
-                includePatterns: [],
-            }, debug: false }, config), { 
-            // Merge profundo de console config
-            console: Object.assign({ captureLogs: true, captureWarnings: true, captureErrors: true, ignorePatterns: [], includePatterns: [] }, ((_a = config.console) !== null && _a !== void 0 ? _a : {})) });
-        // 1. WebSocket
-        this.transport = new websocket_1.WebSocketTransport(this.config.serverUrl, this.config.debug);
-        this.transport.connect();
-        // 2. Evento de inicio de sesión
-        const deviceInfo = await (0, session_1.getDeviceInfo)(config.appVersion);
-        const sessionEvent = {
-            id: (0, session_1.generateId)(),
-            type: 'session_start',
-            sessionId: (0, session_1.getSessionId)(),
-            timestamp: Date.now(),
-            deviceInfo,
-            appVersion: config.appVersion,
-        };
-        this.transport.send(sessionEvent);
-        const getScreen = () => this.currentScreen;
-        // 3. Interceptor de fetch nativo
-        this.cleanups.push((0, fetch_1.setupFetchInterceptor)(this.transport, this.config));
-        // 4. Interceptor de consola (console.log/warn/error + Metro logs)
-        this.cleanups.push((0, console_1.setupConsoleInterceptor)(this.transport, this.config, getScreen));
-        // 5. Handler de errores del runtime de RN (pantalla roja, yellow box, promises)
-        if (this.config.captureRuntimeErrors) {
-            this.cleanups.push((0, runtime_1.setupRuntimeErrorHandler)(this.transport, this.config, getScreen));
-        }
-        // 6. Handler legacy de errores JS (fallback para versiones viejas de RN)
-        this.cleanups.push((0, errors_1.setupErrorHandlers)(this.transport, this.config));
-        this.initialized = true;
-        this.log('SDK initialized ✅', { sessionId: (0, session_1.getSessionId)() });
-    }
-    /**
-     * Registra interceptor para una instancia específica de Axios.
-     *
-     * @example
-     * import axios from 'axios';
-     * QALink.interceptAxios(axios);
-     *
-     * // También con instancias custom:
-     * const api = axios.create({ baseURL: 'https://api.miapp.com' });
-     * QALink.interceptAxios(api);
-     */
-    interceptAxios(axiosInstance) {
-        if (!this.transport || !this.config) {
-            console.warn('[QALink] Call init() before interceptAxios()');
-            return;
-        }
-        this.cleanups.push((0, axios_1.setupAxiosInterceptor)(axiosInstance, this.transport, this.config));
-        this.log('Axios interceptor installed ✅');
+  constructor() {
+    this.transport    = null;
+    this.config       = null;
+    this.cleanups     = [];
+    this.initialized  = false;
+    this.currentScreen= 'unknown';
+    this._deviceId    = 'unknown';
+  }
+
+  async init(config) {
+    if (this.initialized) {
+      console.warn('[QALink] Already initialized. Call destroy() first.');
+      return;
     }
-    /**
-     * Registra una acción del usuario (breadcrumb).
-     *
-     * @example
-     * QALink.addBreadcrumb('TAP → Confirmar Compra', { total: 150 });
-     */
-    addBreadcrumb(action, data) {
-        var _a, _b;
-        if (!this.transport || !this.initialized)
-            return;
-        const event = {
-            id: (0, session_1.generateId)(),
-            type: 'breadcrumb',
-            action,
-            screen: this.currentScreen,
-            data,
-            timestamp: Date.now(),
-            sessionId: (0, session_1.getSessionId)(),
-        };
-        this.transport.send(event);
-        (_b = (_a = this.config) === null || _a === void 0 ? void 0 : _a.onEvent) === null || _b === void 0 ? void 0 : _b.call(_a, event);
+
+    if (config.enabled === false) {
+      this._log('SDK disabled. No data will be sent.');
+      return;
     }
-    /**
-     * Registra la pantalla actual. Llamar en cada cambio de navegación.
-     * Genera automáticamente un breadcrumb de navegación.
-     */
-    setScreen(screenName) {
-        if (!this.initialized)
-            return;
-        this.currentScreen = screenName;
-        this.addBreadcrumb(`NAVIGATE → ${screenName}`);
+
+    this.config = {
+      enabled: true,
+      environment: 'dev',
+      logNetworkBodies: false,
+      sensitiveHeaders: [],
+      sensitiveUrlPatterns: [],
+      sensitiveBodyFields: [],
+      captureRuntimeErrors: true,
+      captureMetroErrors: true,
+      console: { captureLogs: true, captureWarnings: true, captureErrors: true, ignorePatterns: [], includePatterns: [] },
+      debug: false,
+      ...config,
+      console: {
+        captureLogs: true, captureWarnings: true, captureErrors: true,
+        ignorePatterns: [], includePatterns: [],
+        ...(config.console ?? {}),
+      },
+    };
+
+    this._deviceId = await (0, device_1.getDeviceId)();
+
+    this.transport = new websocket_1.WebSocketTransport(this.config.serverUrl, this.config.debug);
+    this.transport.connect();
+
+    const deviceInfo = await (0, session_1.getDeviceInfo)(config.appVersion);
+    const sessionEvent = {
+      id: (0, session_1.generateId)(),
+      type: 'session_start',
+      sessionId: (0, session_1.getSessionId)(),
+      deviceId: this._deviceId,
+      timestamp: Date.now(),
+      deviceInfo,
+      appVersion: config.appVersion,
+      environment: this.config.environment ?? 'dev',
+    };
+    this.transport.send(sessionEvent);
+
+    const getScreen = () => this.currentScreen;
+    const getDevId  = () => this._deviceId;
+
+    this.cleanups.push((0, fetch_1.setupFetchInterceptor)(this.transport, this.config, getDevId));
+    this.cleanups.push((0, console_1.setupConsoleInterceptor)(this.transport, this.config, getScreen));
+
+    if (this.config.captureRuntimeErrors) {
+      this.cleanups.push((0, runtime_1.setupRuntimeErrorHandler)(this.transport, this.config, getScreen));
     }
-    /** Estado actual de la conexión WebSocket */
-    getStatus() {
-        var _a, _b;
-        return (_b = (_a = this.transport) === null || _a === void 0 ? void 0 : _a.getStatus()) !== null && _b !== void 0 ? _b : 'not initialized';
+
+    // Metro — activo por defecto, desactivar con captureMetroErrors: false
+    if (this.config.captureMetroErrors !== false) {
+      this.cleanups.push((0, metro_1.setupMetroInterceptor)(this.transport, this.config, getDevId));
     }
-    /** Limpia todos los interceptores y desconecta. Útil en tests. */
-    destroy() {
-        var _a;
-        this.cleanups.forEach(fn => fn());
-        this.cleanups = [];
-        (_a = this.transport) === null || _a === void 0 ? void 0 : _a.disconnect();
-        this.transport = null;
-        this.config = null;
-        this.initialized = false;
+
+    this.cleanups.push((0, errors_1.setupErrorHandlers)(this.transport, this.config));
+
+    this.initialized = true;
+    this._log('SDK initialized ✅', {
+      sessionId: (0, session_1.getSessionId)(),
+      deviceId: this._deviceId,
+      environment: this.config.environment,
+      captureMetroErrors: this.config.captureMetroErrors,
+    });
+  }
+
+  interceptAxios(axiosInstance) {
+    if (!this.transport || !this.config) { console.warn('[QALink] Call init() before interceptAxios()'); return; }
+    this.cleanups.push((0, axios_1.setupAxiosInterceptor)(axiosInstance, this.transport, this.config));
+    this._log('Axios interceptor installed ✅');
+  }
+
+  addBreadcrumb(action, data) {
+    if (!this.transport || !this.initialized) return;
+    const event = {
+      id: (0, session_1.generateId)(),
+      type: 'breadcrumb',
+      action, screen: this.currentScreen, data,
+      timestamp: Date.now(),
+      sessionId: (0, session_1.getSessionId)(),
+      deviceId: this._deviceId,
+    };
+    this.transport.send(event);
+    this.config?.onEvent?.(event);
+  }
+
+  logRequest(options) {
+    if (!this.transport || !this.initialized) return;
+    const { method, url, statusCode, requestPayload, responsePayload, durationMs } = options;
+    const isAuth = (0, sanitize_1.isAuthUrl)(url);
+    const extraFields = this.config?.sensitiveBodyFields ?? [];
+    let sanitizedReq = requestPayload, sanitizedRes = responsePayload, hadSensitiveData = false;
+
+    if (requestPayload) {
+      if (isAuth) { sanitizedReq = '[REDACTED - auth endpoint]'; hadSensitiveData = true; }
+      else { const r = (0, sanitize_1.sanitizePayload)(requestPayload, extraFields); sanitizedReq = r.sanitized; hadSensitiveData = r.hadSensitiveData; }
     }
-    log(...args) {
-        var _a;
-        if ((_a = this.config) === null || _a === void 0 ? void 0 : _a.debug) {
-            console.log('[QALink]', ...args);
-        }
+    if (responsePayload) {
+      const r = (0, sanitize_1.sanitizePayload)(responsePayload, extraFields);
+      sanitizedRes = r.sanitized;
+      if (r.hadSensitiveData) hadSensitiveData = true;
     }
+
+    const event = {
+      id: (0, session_1.generateId)(),
+      type: 'network_log',
+      method: method.toUpperCase(), url, statusCode,
+      requestPayload: sanitizedReq, responsePayload: sanitizedRes, durationMs,
+      timestamp: Date.now(),
+      sessionId: (0, session_1.getSessionId)(),
+      deviceId: this._deviceId,
+      screen: this.currentScreen,
+      sanitized: hadSensitiveData,
+    };
+    this.transport.send(event);
+    this.config?.onEvent?.(event);
+    this._log(`logRequest: ${method.toUpperCase()} ${url} ${statusCode ?? '?'}${hadSensitiveData ? ' [sanitized]' : ''}`);
+  }
+
+  setScreen(screenName) {
+    if (!this.initialized) return;
+    this.currentScreen = screenName;
+    this.addBreadcrumb(`NAVIGATE → ${screenName}`);
+  }
+
+  getDeviceId() { return this._deviceId; }
+  getStatus()   { return this.transport?.getStatus() ?? 'not initialized'; }
+
+  destroy() {
+    this.cleanups.forEach(fn => fn());
+    this.cleanups = [];
+    this.transport?.disconnect();
+    this.transport = null; this.config = null; this.initialized = false;
+  }
+
+  _log(...args) {
+    if (this.config?.debug) console.log('[QALink]', ...args);
+  }
 }
-exports.QALink = new QALinkSDK();
-__exportStar(require("./types"), exports);
+
+const QALink = new QALinkSDK();
+exports.QALink = QALink;
+
 var classifier_1 = require("./core/classifier");
 Object.defineProperty(exports, "getSourceLabel", { enumerable: true, get: function () { return classifier_1.getSourceLabel; } });
-//# sourceMappingURL=index.js.map

package/dist/interceptors/fetch.js

@@ -1,83 +1,108 @@
 "use strict";
 Object.defineProperty(exports, "__esModule", { value: true });
-exports.setupFetchInterceptor = setupFetchInterceptor;
+exports.setupFetchInterceptor = void 0;
 const classifier_1 = require("../core/classifier");
-const session_1 = require("../core/session");
+const session_1    = require("../core/session");
+const sanitize_1   = require("../core/sanitize");
+
 const originalFetch = global.fetch;
-function setupFetchInterceptor(transport, config) {
-    global.fetch = async (input, init) => {
-        var _a, _b, _c, _d, _e, _f, _g, _h;
-        const requestId = (0, session_1.generateId)();
-        const startTime = Date.now();
-        const method = (_b = (_a = init === null || init === void 0 ? void 0 : init.method) === null || _a === void 0 ? void 0 : _a.toUpperCase()) !== null && _b !== void 0 ? _b : 'GET';
-        const url = typeof input === 'string' ? input : input instanceof URL ? input.toString() : input.url;
-        if (shouldIgnoreUrl(url, (_c = config.sensitiveUrlPatterns) !== null && _c !== void 0 ? _c : [])) {
-            return originalFetch(input, init);
-        }
-        let response;
-        let responseBody;
-        let statusCode;
+
+function setupFetchInterceptor(transport, config, getDeviceId) {
+  global.fetch = async (input, init) => {
+    const requestId = (0, session_1.generateId)();
+    const startTime = Date.now();
+    const method = init?.method?.toUpperCase() ?? 'GET';
+    const url = typeof input === 'string' ? input : input instanceof URL ? input.toString() : input.url;
+
+    if (shouldIgnoreUrl(url, config.sensitiveUrlPatterns ?? [])) {
+      return originalFetch(input, init);
+    }
+
+    let response, responseBody, statusCode;
+    const isAuth = (0, sanitize_1.isAuthUrl)(url);
+
+    try {
+      response   = await originalFetch(input, init);
+      statusCode = response.status;
+
+      if (config.logNetworkBodies) {
         try {
-            response = await originalFetch(input, init);
-            statusCode = response.status;
-            if (config.logNetworkBodies) {
-                try {
-                    const cloned = response.clone();
-                    responseBody = await cloned.json().catch(() => cloned.text());
-                }
-                catch (_j) {
-                    responseBody = '[could not read body]';
-                }
-            }
-            const event = {
-                id: requestId,
-                type: statusCode >= 400 ? 'network_error' : 'network_request',
-                method,
-                url,
-                statusCode,
-                requestHeaders: (0, session_1.sanitizeHeaders)(headersToObject(new Headers(init === null || init === void 0 ? void 0 : init.headers)), config.sensitiveHeaders),
-                requestBody: (0, session_1.sanitizeBody)(init === null || init === void 0 ? void 0 : init.body, (_d = config.logNetworkBodies) !== null && _d !== void 0 ? _d : false),
-                responseBody: (0, session_1.sanitizeBody)(responseBody, (_e = config.logNetworkBodies) !== null && _e !== void 0 ? _e : false),
-                durationMs: Date.now() - startTime,
-                timestamp: Date.now(),
-                source: (0, classifier_1.classifyErrorSource)(statusCode),
-                sessionId: (0, session_1.getSessionId)(),
-            };
-            transport.send(event);
-            (_f = config.onEvent) === null || _f === void 0 ? void 0 : _f.call(config, event);
-            return response;
+          const cloned = response.clone();
+          responseBody = await cloned.json().catch(() => cloned.text());
+        } catch { responseBody = '[could not read body]'; }
+      }
+
+      let reqBody = init?.body;
+      let sanitizedFlag = false;
+      if (reqBody && config.logNetworkBodies) {
+        if (isAuth) {
+          reqBody = '[REDACTED - auth endpoint]';
+          sanitizedFlag = true;
+        } else {
+          const { sanitized, hadSensitiveData } = (0, sanitize_1.sanitizePayload)(reqBody, config.sensitiveBodyFields);
+          reqBody = sanitized;
+          sanitizedFlag = hadSensitiveData;
         }
-        catch (error) {
-            const event = {
-                id: requestId,
-                type: 'network_error',
-                method,
-                url,
-                statusCode: undefined,
-                requestHeaders: (0, session_1.sanitizeHeaders)(headersToObject(new Headers(init === null || init === void 0 ? void 0 : init.headers)), config.sensitiveHeaders),
-                requestBody: (0, session_1.sanitizeBody)(init === null || init === void 0 ? void 0 : init.body, (_g = config.logNetworkBodies) !== null && _g !== void 0 ? _g : false),
-                durationMs: Date.now() - startTime,
-                timestamp: Date.now(),
-                source: (0, classifier_1.classifyErrorSource)(undefined, error),
-                sessionId: (0, session_1.getSessionId)(),
-            };
-            transport.send(event);
-            (_h = config.onEvent) === null || _h === void 0 ? void 0 : _h.call(config, event);
-            throw error;
-        }
-    };
-    return () => {
-        global.fetch = originalFetch;
-    };
+      } else {
+        reqBody = '[body omitted - enable logNetworkBodies]';
+      }
+
+      let resBody = responseBody;
+      if (resBody && config.logNetworkBodies) {
+        const { sanitized } = (0, sanitize_1.sanitizePayload)(resBody, config.sensitiveBodyFields);
+        resBody = sanitized;
+      } else if (!config.logNetworkBodies) {
+        resBody = '[body omitted - enable logNetworkBodies]';
+      }
+
+      const event = {
+        id: requestId,
+        type: statusCode >= 400 ? 'network_error' : 'network_request',
+        method, url, statusCode,
+        requestHeaders: (0, sanitize_1.sanitizeHeaders)(headersToObject(new Headers(init?.headers)), config.sensitiveHeaders),
+        requestBody: reqBody,
+        responseBody: resBody,
+        durationMs: Date.now() - startTime,
+        timestamp: Date.now(),
+        source: (0, classifier_1.classifyErrorSource)(statusCode),
+        sessionId: (0, session_1.getSessionId)(),
+        deviceId: getDeviceId(),
+      };
+
+      transport.send(event);
+      config.onEvent?.(event);
+      return response;
+
+    } catch (error) {
+      const event = {
+        id: requestId,
+        type: 'network_error',
+        method, url,
+        statusCode: undefined,
+        requestHeaders: (0, sanitize_1.sanitizeHeaders)(headersToObject(new Headers(init?.headers)), config.sensitiveHeaders),
+        requestBody: '[body omitted on error]',
+        durationMs: Date.now() - startTime,
+        timestamp: Date.now(),
+        source: (0, classifier_1.classifyErrorSource)(undefined, error),
+        sessionId: (0, session_1.getSessionId)(),
+        deviceId: getDeviceId(),
+      };
+      transport.send(event);
+      config.onEvent?.(event);
+      throw error;
+    }
+  };
+
+  return () => { global.fetch = originalFetch; };
 }
+exports.setupFetchInterceptor = setupFetchInterceptor;
+
 function headersToObject(headers) {
-    const result = {};
-    headers.forEach((value, key) => {
-        result[key] = value;
-    });
-    return result;
+  const result = {};
+  headers.forEach((value, key) => { result[key] = value; });
+  return result;
 }
+
 function shouldIgnoreUrl(url, patterns) {
-    return patterns.some(pattern => url.includes(pattern));
+  return patterns.some(p => url.includes(p));
 }
-//# sourceMappingURL=fetch.js.map

package/dist/interceptors/metro.js

@@ -0,0 +1,109 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.setupMetroInterceptor = void 0;
+const session_1 = require("../core/session");
+
+const METRO_PATTERNS = [
+  { pattern: /Unable to resolve module ['"]([^'"]+)['"]\s+from\s+['"]([^'"]+)['"]/i, type: 'module_not_found' },
+  { pattern: /SyntaxError:.+\((\d+):(\d+)\)/i,                                       type: 'syntax_error'    },
+  { pattern: /TransformError/i,                                                        type: 'transform_error' },
+  { pattern: /bundling failed/i,                                                       type: 'bundling_failed' },
+  { pattern: /Metro(?:\s+Bundler)?:/i,                                                 type: 'metro_generic'   },
+  { pattern: /error: .+\.(?:js|ts|tsx|jsx):\s*\d+:\d+/i,                             type: 'build_error'     },
+  { pattern: /Requiring unknown module/i,                                              type: 'module_not_found'},
+  { pattern: /Module not found/i,                                                      type: 'module_not_found'},
+  { pattern: /cannot find module/i,                                                    type: 'module_not_found'},
+  { pattern: /ENOENT:.+require/i,                                                      type: 'module_not_found'},
+];
+
+function parseFileInfo(message) {
+  const m1 = message.match(/([^\s:]+\.(?:js|ts|tsx|jsx)):(\d+):(\d+)/);
+  if (m1) return { file: m1[1], lineNumber: parseInt(m1[2], 10), column: parseInt(m1[3], 10) };
+  const m2 = message.match(/([^\s(]+\.(?:js|ts|tsx|jsx))\s*\((\d+):(\d+)\)/);
+  if (m2) return { file: m2[1], lineNumber: parseInt(m2[2], 10), column: parseInt(m2[3], 10) };
+  return {};
+}
+
+function isMetroMessage(message) {
+  return METRO_PATTERNS.some(({ pattern }) => pattern.test(message));
+}
+
+function getMetroSubtype(message) {
+  for (const { pattern, type } of METRO_PATTERNS) {
+    if (pattern.test(message)) return type;
+  }
+  return 'metro_generic';
+}
+
+function argsToString(args) {
+  return args
+    .map(a => typeof a === 'string' ? a : a instanceof Error ? `${a.message}\n${a.stack ?? ''}` : String(a))
+    .join(' ');
+}
+
+function setupMetroInterceptor(transport, config, getDeviceId) {
+  const cleanups = [];
+
+  // ── 1. Interceptar console.error ──────────────────────────────────────────
+  const previousConsoleError = console.error;
+
+  console.error = (...args) => {
+    previousConsoleError(...args);
+    if (config.captureMetroErrors === false) return;
+    const message = argsToString(args);
+    if (!isMetroMessage(message)) return;
+    if (message.startsWith('[QALink]')) return;
+
+    const { file, lineNumber, column } = parseFileInfo(message);
+    const event = {
+      id:        (0, session_1.generateId)(),
+      type:      'metro_error',
+      metroType: getMetroSubtype(message),
+      message:   message.slice(0, 2000),
+      file, lineNumber, column,
+      timestamp: Date.now(),
+      sessionId: (0, session_1.getSessionId)(),
+      deviceId:  getDeviceId(),
+    };
+    transport.send(event);
+    config.onEvent?.(event);
+  };
+
+  cleanups.push(() => { console.error = previousConsoleError; });
+
+  // ── 2. ErrorUtils — crashes fatales de Metro ──────────────────────────────
+  try {
+    if (typeof ErrorUtils !== 'undefined' && ErrorUtils.getGlobalHandler) {
+      const originalHandler = ErrorUtils.getGlobalHandler();
+
+      ErrorUtils.setGlobalHandler((error, isFatal) => {
+        try {
+          if (config.captureMetroErrors !== false && error?.message && isMetroMessage(error.message)) {
+            const { file, lineNumber, column } = parseFileInfo(error.message);
+            const event = {
+              id:        (0, session_1.generateId)(),
+              type:      'metro_error',
+              metroType: getMetroSubtype(error.message),
+              message:   error.message.slice(0, 2000),
+              stack:     error.stack,
+              file, lineNumber, column,
+              timestamp: Date.now(),
+              sessionId: (0, session_1.getSessionId)(),
+              deviceId:  getDeviceId(),
+            };
+            transport.send(event);
+            config.onEvent?.(event);
+          }
+        } catch {}
+        originalHandler(error, isFatal);
+      });
+
+      cleanups.push(() => {
+        try { ErrorUtils.setGlobalHandler(originalHandler); } catch {}
+      });
+    }
+  } catch {}
+
+  return () => cleanups.forEach(fn => { try { fn(); } catch {} });
+}
+exports.setupMetroInterceptor = setupMetroInterceptor;

package/package.json

@@ -1,23 +1,14 @@
 {
   "name": "react-native-qalink",
-  "version": "0.1.3",
+  "version": "0.3.0",
   "description": "Real-time error capture SDK for React Native — helps QA teams identify if bugs are frontend or backend",
   "main": "dist/index.js",
   "types": "dist/index.d.ts",
   "files": ["dist", "README.md"],
-  "keywords": ["react-native", "debugging", "qa", "error-tracking", "network-interceptor"],
-  "peerDependencies": {
-    "react-native": ">=0.70.0",
-    "axios": ">=1.0.0"
-  },
+  "keywords": ["react-native", "debugging", "qa", "error-tracking", "network-interceptor", "metro"],
+  "peerDependencies": { "react-native": ">=0.70.0", "axios": ">=1.0.0" },
   "peerDependenciesMeta": { "axios": { "optional": true } },
-  "devDependencies": {
-    "typescript": "^5.0.0",
-    "@types/react-native": "^0.72.0"
-  },
-  "scripts": {
-    "build": "tsc",
-    "typecheck": "tsc --noEmit"
-  },
+  "devDependencies": { "typescript": "^5.0.0", "@types/react-native": "^0.72.0" },
+  "scripts": { "build": "tsc", "typecheck": "tsc --noEmit" },
   "license": "MIT"
 }