react-native-qalink 0.1.2 → 0.2.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,186 @@
 "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 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 ✅');
-    }
-    /**
-     * 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);
+  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 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}`);
+
+    // ── 1. enabled flag ───────────────────────────────────────────────────────
+    if (config.enabled === false) {
+      this._log('SDK disabled (enabled: false). No data will be sent.');
+      return;
     }
-    /** 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';
+
+    this.config = {
+      enabled: true,
+      environment: 'dev',
+      logNetworkBodies: false,
+      sensitiveHeaders: [],
+      sensitiveUrlPatterns: [],
+      sensitiveBodyFields: [],
+      captureRuntimeErrors: true,
+      console: { captureLogs: true, captureWarnings: true, captureErrors: true, ignorePatterns: [], includePatterns: [] },
+      debug: false,
+      ...config,
+      console: {
+        captureLogs: true, captureWarnings: true, captureErrors: true,
+        ignorePatterns: [], includePatterns: [],
+        ...(config.console ?? {}),
+      },
+    };
+
+    // ── 2. deviceId ───────────────────────────────────────────────────────────
+    this._deviceId = await (0, device_1.getDeviceId)();
+
+    // ── 3. WebSocket ──────────────────────────────────────────────────────────
+    this.transport = new websocket_1.WebSocketTransport(this.config.serverUrl, this.config.debug);
+    this.transport.connect();
+
+    // ── 4. session_start ──────────────────────────────────────────────────────
+    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;
+
+    // ── 5. Interceptors ───────────────────────────────────────────────────────
+    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));
     }
-    /** 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 });
+  }
+
+  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;
+    let sanitizedRes = responsePayload;
+    let hadSensitiveData = false;
+
+    if (requestPayload) {
+      if (isAuth) {
+        sanitizedReq = '[REDACTED - auth endpoint]';
+        hadSensitiveData = true;
+      } else {
+        const result = (0, sanitize_1.sanitizePayload)(requestPayload, extraFields);
+        sanitizedReq = result.sanitized;
+        hadSensitiveData = result.hadSensitiveData;
+      }
     }
-    log(...args) {
-        var _a;
-        if ((_a = this.config) === null || _a === void 0 ? void 0 : _a.debug) {
-            console.log('[QALink]', ...args);
-        }
+    if (responsePayload) {
+      const result = (0, sanitize_1.sanitizePayload)(responsePayload, extraFields);
+      sanitizedRes = result.sanitized;
+      if (result.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;
+
+// Re-exports
 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/console.js

@@ -1,8 +1,8 @@
 "use strict";
 Object.defineProperty(exports, "__esModule", { value: true });
-exports.setupConsoleInterceptor = setupConsoleInterceptor;
+exports.setupConsoleInterceptor = void 0;
 const session_1 = require("../core/session");
-// Guardamos referencia a los métodos originales ANTES de sobrescribir
+
 const originalConsole = {
     log: console.log.bind(console),
     warn: console.warn.bind(console),
@@ -10,132 +10,88 @@ const originalConsole = {
     info: console.info.bind(console),
     debug: console.debug.bind(console),
 };
-/**
- * Patrones que identifican logs internos de React Native
- * para clasificarlos correctamente en el dashboard.
- */
-const RN_WARNING_PATTERNS = [
-    'Warning:',
-    'VirtualizedList',
-    'Each child in a list',
-    'componentWillMount',
-    'componentWillReceiveProps',
-    'componentWillUpdate',
-    'findDOMNode',
-    'ReactDOM.render',
-    'key prop',
-    'unique "key"',
-    'Maximum update depth',
-];
-const RN_ERROR_PATTERNS = [
-    'Invariant Violation',
-    'Text strings must be rendered',
-    'Cannot update a component',
-    'Element type is invalid',
-    'Objects are not valid as a React child',
-    'TypeError',
-    'ReferenceError',
-    'Cannot read property',
-    'Cannot read properties',
-    'is not a function',
-    'undefined is not an object',
-    'null is not an object',
-];
-const METRO_ERROR_PATTERNS = [
-    'Unable to resolve module',
-    'Module not found',
-    'SyntaxError',
-    'TransformError',
-    'bundling failed',
-    'Metro Bundler',
-    'Error: Metro',
-];
-const THIRD_PARTY_PATTERNS = [
-    '[react-navigation]',
-    '[react-query]',
-    '[redux]',
-    '[mobx]',
-    '[zustand]',
-    'Reanimated',
-    'Gesture Handler',
-    'SafeAreaProvider',
-];
+
+const RN_WARNING_PATTERNS = ['Warning:', 'VirtualizedList', 'Each child in a list', 'componentWillMount', 'componentWillReceiveProps', 'componentWillUpdate', 'findDOMNode', 'ReactDOM.render', 'key prop', 'unique "key"', 'Maximum update depth'];
+const RN_ERROR_PATTERNS = ['Invariant Violation', 'Text strings must be rendered', 'Cannot update a component', 'Element type is invalid', 'Objects are not valid as a React child', 'TypeError', 'ReferenceError', 'Cannot read property', 'Cannot read properties', 'is not a function', 'undefined is not an object', 'null is not an object'];
+const METRO_ERROR_PATTERNS = ['Unable to resolve module', 'Module not found', 'SyntaxError', 'TransformError', 'bundling failed', 'Metro Bundler', 'Error: Metro'];
+const THIRD_PARTY_PATTERNS = ['[react-navigation]', '[react-query]', '[redux]', '[mobx]', '[zustand]', 'Reanimated', 'Gesture Handler', 'SafeAreaProvider'];
+
 function classifyConsoleMessage(message) {
-    if (METRO_ERROR_PATTERNS.some(p => message.includes(p)))
-        return 'rn_error';
-    if (RN_ERROR_PATTERNS.some(p => message.includes(p)))
-        return 'rn_error';
-    if (RN_WARNING_PATTERNS.some(p => message.includes(p)))
-        return 'rn_warning';
-    if (THIRD_PARTY_PATTERNS.some(p => message.includes(p)))
-        return 'third_party';
+    if (METRO_ERROR_PATTERNS.some(p => message.includes(p))) return 'rn_error';
+    if (RN_ERROR_PATTERNS.some(p => message.includes(p))) return 'rn_error';
+    if (RN_WARNING_PATTERNS.some(p => message.includes(p))) return 'rn_warning';
+    if (THIRD_PARTY_PATTERNS.some(p => message.includes(p))) return 'third_party';
     return 'user_log';
 }
+
 function serializeArg(arg) {
-    var _a;
-    if (arg === null)
-        return 'null';
-    if (arg === undefined)
-        return 'undefined';
-    if (typeof arg === 'string')
-        return arg;
-    if (typeof arg === 'number' || typeof arg === 'boolean')
-        return String(arg);
-    if (arg instanceof Error)
-        return `${arg.name}: ${arg.message}\n${(_a = arg.stack) !== null && _a !== void 0 ? _a : ''}`;
-    try {
-        return JSON.stringify(arg, null, 2);
-    }
-    catch (_b) {
-        return String(arg);
-    }
+    if (arg === null) return 'null';
+    if (arg === undefined) return 'undefined';
+    if (typeof arg === 'string') return arg;
+    if (typeof arg === 'number' || typeof arg === 'boolean') return String(arg);
+    if (arg instanceof Error) return `${arg.name}: ${arg.message}\n${arg.stack ?? ''}`;
+    try { return JSON.stringify(arg, null, 2); } catch { return String(arg); }
 }
+
 function shouldCapture(message, config) {
-    var _a;
-    if (!config)
-        return true;
-    // Ignorar si matchea algún patrón de exclusión
-    if ((_a = config.ignorePatterns) === null || _a === void 0 ? void 0 : _a.some(p => message.includes(p)))
-        return false;
-    // Si hay patrones de inclusión, solo capturar si matchea alguno
+    if (!config) return true;
+    if (config.ignorePatterns?.some(p => message.includes(p))) return false;
     if (config.includePatterns && config.includePatterns.length > 0) {
         return config.includePatterns.some(p => message.includes(p));
     }
     return true;
 }
+
+// FLAG para prevenir loops de recursión
+let _isSending = false;
+
 function setupConsoleInterceptor(transport, config, getCurrentScreen) {
-    var _a;
-    const consoleConfig = (_a = config.console) !== null && _a !== void 0 ? _a : {};
-    const { captureLogs = true, captureWarnings = true, captureErrors = true, } = consoleConfig;
+    const consoleConfig = config.console ?? {};
+    const { captureLogs = true, captureWarnings = true, captureErrors = true } = consoleConfig;
+
     function intercept(level, eventType, originalFn) {
         return (...args) => {
-            var _a;
-            // Siempre llamar al original primero — Metro sigue mostrando todo
+            // SIEMPRE llamar el original primero
             originalFn(...args);
+
+            // Evitar loop recursivo — si ya estamos enviando, no volver a entrar
+            if (_isSending) return;
+
             const serializedArgs = args.map(serializeArg);
             const message = serializedArgs.join(' ');
-            if (!shouldCapture(message, consoleConfig))
-                return;
-            // Evitar loop infinito si QALink mismo hace console.log en debug mode
-            if (message.startsWith('[QALink]'))
-                return;
-            const category = classifyConsoleMessage(message);
-            const event = {
-                id: (0, session_1.generateId)(),
-                type: eventType,
-                level,
-                message,
-                args: serializedArgs,
-                category,
-                timestamp: Date.now(),
-                screen: getCurrentScreen(),
-                sessionId: (0, session_1.getSessionId)(),
-            };
-            transport.send(event);
-            (_a = config.onEvent) === null || _a === void 0 ? void 0 : _a.call(config, event);
+
+            // Ignorar logs internos de QALink
+            if (message.startsWith('[QALink]')) return;
+
+            // Ignorar errores de call stack para evitar loop infinito
+            if (message.includes('Maximum call stack') || message.includes('call stack size exceeded')) return;
+
+            if (!shouldCapture(message, consoleConfig)) return;
+
+            try {
+                _isSending = true;
+                const category = classifyConsoleMessage(message);
+                const event = {
+                    id: (0, session_1.generateId)(),
+                    type: eventType,
+                    level,
+                    message,
+                    args: serializedArgs,
+                    category,
+                    timestamp: Date.now(),
+                    screen: getCurrentScreen(),
+                    sessionId: (0, session_1.getSessionId)(),
+                };
+                transport.send(event);
+                config.onEvent?.(event);
+            } catch {
+                // Nunca romper la app por un error del interceptor
+            } finally {
+                _isSending = false;
+            }
         };
     }
-    // Sobrescribir métodos de consola
+
     if (captureLogs) {
         console.log = intercept('log', 'console_log', originalConsole.log);
         console.info = intercept('info', 'console_log', originalConsole.info);
@@ -147,7 +103,7 @@ function setupConsoleInterceptor(transport, config, getCurrentScreen) {
     if (captureErrors) {
         console.error = intercept('error', 'console_error', originalConsole.error);
     }
-    // Cleanup: restaurar consola original
+
     return () => {
         console.log = originalConsole.log;
         console.warn = originalConsole.warn;
@@ -156,4 +112,4 @@ function setupConsoleInterceptor(transport, config, getCurrentScreen) {
         console.debug = originalConsole.debug;
     };
 }
-//# sourceMappingURL=console.js.map
+exports.setupConsoleInterceptor = setupConsoleInterceptor;

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/package.json

@@ -1,6 +1,6 @@
 {
   "name": "react-native-qalink",
-  "version": "0.1.2",
+  "version": "0.2.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",
@@ -15,9 +15,6 @@
     "typescript": "^5.0.0",
     "@types/react-native": "^0.72.0"
   },
-  "scripts": {
-    "build": "tsc",
-    "typecheck": "tsc --noEmit"
-  },
+  "scripts": { "build": "tsc", "typecheck": "tsc --noEmit" },
   "license": "MIT"
 }