@fluwa-tool/sdk 1.0.31 → 1.0.32

package/dist/features/network/FetchInterceptor.d.ts

@@ -5,6 +5,7 @@
 import { ILogger } from '../../core/Logger';
 import { IRequestLogger } from './RequestLogger';
 import { IMockResolver } from './MockResolver';
+import { IUrlFilter } from './UrlFilter';
 export interface IFetchInterceptor {
     install(): void;
     uninstall(): void;
@@ -22,7 +23,8 @@ export declare class FetchInterceptor implements IFetchInterceptor {
     private originalFetch;
     private isInstalled;
     private isIntercepting;
-    constructor(logger: ILogger, requestLogger: IRequestLogger, mockResolver: IMockResolver, sessionId: string, appName: string);
+    private urlFilter;
+    constructor(logger: ILogger, requestLogger: IRequestLogger, mockResolver: IMockResolver, sessionId: string, appName: string, urlFilter?: IUrlFilter);
     /**
      * Instalar o interceptador
      * Substitui fetch global

package/dist/features/network/FetchInterceptor.js

@@ -11,7 +11,7 @@ const types_1 = require("../../types");
  * Preserva fetch original e sobrescreve com versão interceptada
  */
 class FetchInterceptor {
-    constructor(logger, requestLogger, mockResolver, sessionId, appName) {
+    constructor(logger, requestLogger, mockResolver, sessionId, appName, urlFilter) {
         this.logger = logger;
         this.requestLogger = requestLogger;
         this.mockResolver = mockResolver;
@@ -20,6 +20,8 @@ class FetchInterceptor {
         this.originalFetch = null;
         this.isInstalled = false;
         this.isIntercepting = false; // Flag para prevenir re-intercepção
+        this.urlFilter = null; // URL filter para evitar loops infinitos
+        this.urlFilter = urlFilter || null;
     }
     /**
      * Instalar o interceptador
@@ -65,18 +67,25 @@ class FetchInterceptor {
         return async (...args) => {
             const startTime = performance.now();
             const [resource, init] = args;
+            // Extrair URL da requisição (necessário para o filter)
+            const url = typeof resource === 'string' ? resource : (resource instanceof Request ? resource.url : resource.toString());
             // Evitar re-intercepção: se já estamos interceptando, usar fetch original
             if (this.isIntercepting) {
                 return this.originalFetch.apply(globalThis, args);
             }
-            // Ignorar requisições internas do Fluwa (header X-Fluwa-Internal)
+            // ✅ Verificar URL Filter: ignorar requisições para servidor Fluwa ou URLs excluídas
+            // Isso previne loops infinitos onde o servidor Fluwa faz requisições que são interceptadas
+            if (this.urlFilter && !this.urlFilter.shouldIntercept(url)) {
+                this.logger.debug(`🔧 [FetchInterceptor] Ignorando URL excluída: ${url} (bypass filtering)`);
+                return this.originalFetch.apply(globalThis, args);
+            }
+            // Ignorar requisições internas do Fluwa (header X-Fluwa-Internal - legacy support)
             if (this.isFluwaInternalRequest(init)) {
                 // Usar fetch original para requisições internas
                 return this.originalFetch.apply(globalThis, args);
             }
             // Extrair informações da requisição
             const method = (init?.method || 'GET').toUpperCase();
-            const url = typeof resource === 'string' ? resource : (resource instanceof Request ? resource.url : resource.toString());
             const requestId = this.generateId();
             const requestMetadata = {
                 id: requestId,

package/dist/features/network/UrlFilter.d.ts

@@ -0,0 +1,134 @@
+/**
+ * 🔧 URL Filter System for Fluwa SDK
+ *
+ * Provides a robust filtering mechanism to prevent intercepting internal Fluwa server
+ * requests, avoiding infinite request loops and ensuring proper request tracking.
+ *
+ * Problem: Fluwa SDK intercepts ALL HTTP requests, including those made by Fluwa Server
+ * itself to the Fluwa server (POST /api/requests, GET /api/scenarios/active).
+ * This creates infinite loops where internal requests are tracked and re-triggered.
+ *
+ * Solution: Filter URLs BEFORE they reach the Fluwa interceptors (fetch, XHR).
+ * Only requests NOT in the exclusion list will be tracked by Fluwa.
+ *
+ * @example
+ * ```typescript
+ * const filter = createUrlFilter({
+ *   serverUrl: 'http://192.168.0.6:5555',
+ *   excludedUrls: ['/api/requests', '/api/scenarios'],
+ *   mode: 'startsWith',
+ *   debug: true
+ * });
+ *
+ * // Check if URL should be intercepted
+ * const shouldIntercept = filter.shouldIntercept('https://api.example.com/users');
+ * ```
+ */
+/**
+ * Configuration object for URL filtering
+ */
+export interface UrlFilterConfig {
+    /** Base URL of the Fluwa server (e.g., 'http://192.168.0.6:5555') */
+    serverUrl: string;
+    /** Additional URLs to exclude from interception (optional) */
+    excludedUrls?: string[];
+    /** Matching strategy for URL comparison */
+    mode?: 'startsWith' | 'exact' | 'regex';
+    /** Enable debug logging for filter decisions */
+    debug?: boolean;
+}
+/**
+ * Result of a URL filtering check
+ */
+export interface FilterCheckResult {
+    /** Whether the URL should be intercepted by Fluwa */
+    shouldIntercept: boolean;
+    /** Reason why the URL was filtered (for debugging) */
+    reason?: string;
+    /** Which rule matched this URL (for debugging) */
+    matchedRule?: string;
+}
+/**
+ * URL Filter interface with filtering methods
+ */
+export interface IUrlFilter {
+    /**
+     * Check if a URL should be intercepted by Fluwa
+     * @param url - Full URL or path to check
+     * @returns Whether the URL should be intercepted
+     */
+    shouldIntercept(url: string): boolean;
+    /**
+     * Get detailed information about why a URL was filtered
+     * @param url - Full URL or path to check
+     * @returns Detailed filter result with reasoning
+     */
+    checkUrl(url: string): FilterCheckResult;
+    /**
+     * Get the list of all excluded URL patterns
+     * @returns Array of excluded patterns
+     */
+    getExcludedPatterns(): string[];
+}
+/**
+ * UrlFilter implementation
+ * Encapsulates URL filtering logic with support for multiple matching strategies
+ */
+export declare class UrlFilter implements IUrlFilter {
+    private normalizedServerUrl;
+    private normalizedExcludedUrls;
+    private matchMode;
+    private debug;
+    constructor(config: UrlFilterConfig);
+    /**
+     * Normalize URLs for consistent comparison
+     * - Remove trailing slashes
+     * - Handle both full URLs and paths
+     */
+    private normalizeUrl;
+    /**
+     * Check if URL matches using the configured matching mode
+     */
+    private matchesPattern;
+    /**
+     * Detailed URL check with reasoning
+     * Returns why a URL was filtered or allowed
+     */
+    checkUrl(url: string): FilterCheckResult;
+    /**
+     * Simple yes/no check for URL interception
+     * Useful for early filtering before deeper processing
+     */
+    shouldIntercept(url: string): boolean;
+    /**
+     * Get all excluded patterns for debugging and introspection
+     */
+    getExcludedPatterns(): string[];
+}
+/**
+ * Standard exclusion patterns for internal Fluwa server requests
+ * These are the known endpoints that should NOT be tracked by Fluwa SDK
+ */
+export declare const FLUWA_INTERNAL_PATHS: string[];
+/**
+ * Factory function to create a pre-configured filter for Fluwa SDK
+ * Automatically excludes known internal server paths
+ *
+ * @param serverUrl - Base URL of the Fluwa server
+ * @param additionalExclusions - Extra URLs to exclude (optional)
+ * @param debug - Enable debug logging
+ * @returns Configured UrlFilter instance
+ *
+ * @example
+ * ```typescript
+ * const filter = createFluwaSdkFilter('http://192.168.0.6:5555', [
+ *   '/custom-internal-endpoint'
+ * ]);
+ *
+ * // Check if request should bypass Fluwa interception
+ * if (!filter.shouldIntercept(requestUrl)) {
+ *   // Make request without Fluwa tracking
+ * }
+ * ```
+ */
+export declare function createFluwaSdkFilter(serverUrl: string, additionalExclusions?: string[], debug?: boolean): IUrlFilter;

package/dist/features/network/UrlFilter.js

@@ -0,0 +1,179 @@
+"use strict";
+/**
+ * 🔧 URL Filter System for Fluwa SDK
+ *
+ * Provides a robust filtering mechanism to prevent intercepting internal Fluwa server
+ * requests, avoiding infinite request loops and ensuring proper request tracking.
+ *
+ * Problem: Fluwa SDK intercepts ALL HTTP requests, including those made by Fluwa Server
+ * itself to the Fluwa server (POST /api/requests, GET /api/scenarios/active).
+ * This creates infinite loops where internal requests are tracked and re-triggered.
+ *
+ * Solution: Filter URLs BEFORE they reach the Fluwa interceptors (fetch, XHR).
+ * Only requests NOT in the exclusion list will be tracked by Fluwa.
+ *
+ * @example
+ * ```typescript
+ * const filter = createUrlFilter({
+ *   serverUrl: 'http://192.168.0.6:5555',
+ *   excludedUrls: ['/api/requests', '/api/scenarios'],
+ *   mode: 'startsWith',
+ *   debug: true
+ * });
+ *
+ * // Check if URL should be intercepted
+ * const shouldIntercept = filter.shouldIntercept('https://api.example.com/users');
+ * ```
+ */
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.FLUWA_INTERNAL_PATHS = exports.UrlFilter = void 0;
+exports.createFluwaSdkFilter = createFluwaSdkFilter;
+/**
+ * UrlFilter implementation
+ * Encapsulates URL filtering logic with support for multiple matching strategies
+ */
+class UrlFilter {
+    constructor(config) {
+        const { serverUrl, excludedUrls = [], mode = 'startsWith', debug = false } = config;
+        this.normalizedServerUrl = this.normalizeUrl(serverUrl);
+        this.normalizedExcludedUrls = excludedUrls.map((url) => this.normalizeUrl(url));
+        this.matchMode = mode;
+        this.debug = debug;
+    }
+    /**
+     * Normalize URLs for consistent comparison
+     * - Remove trailing slashes
+     * - Handle both full URLs and paths
+     */
+    normalizeUrl(url) {
+        try {
+            // Handle full URLs
+            if (url.startsWith('http://') || url.startsWith('https://')) {
+                return url.replace(/\/$/, '');
+            }
+            // Handle relative paths
+            return url.replace(/\/$/, '');
+        }
+        catch {
+            return url;
+        }
+    }
+    /**
+     * Check if URL matches using the configured matching mode
+     */
+    matchesPattern(url, pattern) {
+        const normalizedUrl = this.normalizeUrl(url);
+        switch (this.matchMode) {
+            case 'exact':
+                return normalizedUrl === pattern;
+            case 'regex': {
+                try {
+                    const regex = new RegExp(pattern);
+                    return regex.test(normalizedUrl);
+                }
+                catch (error) {
+                    console.warn(`🔧 [UrlFilter] Invalid regex pattern: "${pattern}"`, error);
+                    return false;
+                }
+            }
+            case 'startsWith':
+            default:
+                return normalizedUrl.startsWith(pattern);
+        }
+    }
+    /**
+     * Detailed URL check with reasoning
+     * Returns why a URL was filtered or allowed
+     */
+    checkUrl(url) {
+        const normalizedUrl = this.normalizeUrl(url);
+        // Check if URL is the Fluwa server itself
+        if (this.matchesPattern(normalizedUrl, this.normalizedServerUrl)) {
+            const result = {
+                shouldIntercept: false,
+                reason: 'URL is Fluwa server (internal request)',
+                matchedRule: 'serverUrl',
+            };
+            if (this.debug) {
+                console.log(`🔧 [UrlFilter] Excluded: ${url} - ${result.reason}`);
+            }
+            return result;
+        }
+        // Check against explicitly excluded URLs
+        for (const excludedUrl of this.normalizedExcludedUrls) {
+            if (this.matchesPattern(normalizedUrl, excludedUrl)) {
+                const result = {
+                    shouldIntercept: false,
+                    reason: `URL matches excluded pattern: "${excludedUrl}"`,
+                    matchedRule: excludedUrl,
+                };
+                if (this.debug) {
+                    console.log(`🔧 [UrlFilter] Excluded: ${url} - ${result.reason}`);
+                }
+                return result;
+            }
+        }
+        // URL should be intercepted by Fluwa
+        const result = {
+            shouldIntercept: true,
+            reason: 'URL should be tracked by Fluwa',
+        };
+        if (this.debug) {
+            console.log(`🔧 [UrlFilter] Intercepting: ${url}`);
+        }
+        return result;
+    }
+    /**
+     * Simple yes/no check for URL interception
+     * Useful for early filtering before deeper processing
+     */
+    shouldIntercept(url) {
+        return this.checkUrl(url).shouldIntercept;
+    }
+    /**
+     * Get all excluded patterns for debugging and introspection
+     */
+    getExcludedPatterns() {
+        return [this.normalizedServerUrl, ...this.normalizedExcludedUrls];
+    }
+}
+exports.UrlFilter = UrlFilter;
+/**
+ * Standard exclusion patterns for internal Fluwa server requests
+ * These are the known endpoints that should NOT be tracked by Fluwa SDK
+ */
+exports.FLUWA_INTERNAL_PATHS = [
+    '/api/requests', // Request registration endpoint
+    '/api/scenarios', // Scenario management
+    '/api/recordings', // Recording management
+    '/health', // Health check endpoint
+];
+/**
+ * Factory function to create a pre-configured filter for Fluwa SDK
+ * Automatically excludes known internal server paths
+ *
+ * @param serverUrl - Base URL of the Fluwa server
+ * @param additionalExclusions - Extra URLs to exclude (optional)
+ * @param debug - Enable debug logging
+ * @returns Configured UrlFilter instance
+ *
+ * @example
+ * ```typescript
+ * const filter = createFluwaSdkFilter('http://192.168.0.6:5555', [
+ *   '/custom-internal-endpoint'
+ * ]);
+ *
+ * // Check if request should bypass Fluwa interception
+ * if (!filter.shouldIntercept(requestUrl)) {
+ *   // Make request without Fluwa tracking
+ * }
+ * ```
+ */
+function createFluwaSdkFilter(serverUrl, additionalExclusions, debug) {
+    return new UrlFilter({
+        serverUrl,
+        excludedUrls: [...exports.FLUWA_INTERNAL_PATHS, ...(additionalExclusions || [])],
+        mode: 'startsWith',
+        debug,
+    });
+}

package/dist/features/network/XMLHttpRequestInterceptor.d.ts

@@ -5,6 +5,7 @@
 import { ILogger } from '../../core/Logger';
 import { IRequestLogger } from './RequestLogger';
 import { IMockResolver } from './MockResolver';
+import { IUrlFilter } from './UrlFilter';
 export interface IXMLHttpRequestInterceptor {
     install(): void;
     uninstall(): void;
@@ -19,7 +20,8 @@ export declare class XMLHttpRequestInterceptor implements IXMLHttpRequestInterce
     private originalSend;
     private originalSetRequestHeader;
     private isInstalled;
-    constructor(logger: ILogger, requestLogger: IRequestLogger, mockResolver: IMockResolver, sessionId: string, appName: string);
+    private urlFilter;
+    constructor(logger: ILogger, requestLogger: IRequestLogger, mockResolver: IMockResolver, sessionId: string, appName: string, urlFilter?: IUrlFilter);
     install(): void;
     uninstall(): void;
     private safeParseBody;

package/dist/features/network/XMLHttpRequestInterceptor.js

@@ -7,13 +7,15 @@ Object.defineProperty(exports, "__esModule", { value: true });
 exports.XMLHttpRequestInterceptor = void 0;
 const types_1 = require("../../types");
 class XMLHttpRequestInterceptor {
-    constructor(logger, requestLogger, mockResolver, sessionId, appName) {
+    constructor(logger, requestLogger, mockResolver, sessionId, appName, urlFilter) {
         this.logger = logger;
         this.requestLogger = requestLogger;
         this.mockResolver = mockResolver;
         this.sessionId = sessionId;
         this.appName = appName;
         this.isInstalled = false;
+        this.urlFilter = null; // URL filter para evitar loops infinitos
+        this.urlFilter = urlFilter || null;
     }
     install() {
         if (this.isInstalled) {
@@ -58,6 +60,12 @@ class XMLHttpRequestInterceptor {
             const url = xhr._fluwaUrl;
             const requestId = xhr._fluwaRequestId;
             const headers = xhr._fluwaHeaders || {};
+            // ✅ Verificar URL Filter: ignorar requisições para servidor Fluwa ou URLs excluídas
+            // Isso previne loops infinitos onde o servidor Fluwa faz requisições que são interceptadas
+            if (self.urlFilter && !self.urlFilter.shouldIntercept(url)) {
+                self.logger.debug(`🔧 [XMLHttpRequestInterceptor] Ignorando URL excluída: ${url} (bypass filtering)`);
+                return self.originalSend.apply(this, [body]);
+            }
             const requestMetadata = {
                 id: requestId,
                 method,

package/dist/index.d.ts

@@ -27,3 +27,4 @@ export declare function isFluwaTooIialized(): boolean;
 export * from './types';
 export { Logger, LogLevel } from './core/Logger';
 export { ConfigManager } from './core/Config';
+export { UrlFilter, createFluwaSdkFilter, FLUWA_INTERNAL_PATHS, type UrlFilterConfig, type FilterCheckResult, type IUrlFilter, } from './features/network/UrlFilter';

package/dist/index.js

@@ -22,7 +22,7 @@ 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.ConfigManager = exports.LogLevel = exports.Logger = void 0;
+exports.FLUWA_INTERNAL_PATHS = exports.createFluwaSdkFilter = exports.UrlFilter = exports.ConfigManager = exports.LogLevel = exports.Logger = void 0;
 exports.initFluwaTool = initFluwaTool;
 exports.disableFluwaTool = disableFluwaTool;
 exports.enableFluwaTool = enableFluwaTool;
@@ -36,6 +36,7 @@ const FetchInterceptor_1 = require("./features/network/FetchInterceptor");
 const XMLHttpRequestInterceptor_1 = require("./features/network/XMLHttpRequestInterceptor");
 const RequestLogger_1 = require("./features/network/RequestLogger");
 const MockResolver_1 = require("./features/network/MockResolver");
+const UrlFilter_1 = require("./features/network/UrlFilter");
 const IdGenerator_1 = require("./core/IdGenerator");
 // ============================================
 // ESTADO GLOBAL
@@ -49,6 +50,7 @@ let wsClient;
 let fetchInterceptor;
 let xmlHttpRequestInterceptor;
 let mockResolver;
+let urlFilter = null; // URL filter para evitar loops infinitos
 // ============================================
 // INICIALIZAÇÃO
 // ============================================
@@ -82,14 +84,19 @@ async function initFluwaTool(partialConfig = {}) {
         mockResolver = new MockResolver_1.MockResolver(httpClient, logger);
         // 5. Criar logger de requisições
         const requestLogger = new RequestLogger_1.RequestLogger(httpClient, logger);
-        // 6. Criar interceptador de fetch
-        fetchInterceptor = new FetchInterceptor_1.FetchInterceptor(logger, requestLogger, mockResolver, sessionId, config.getAppName());
-        // 6b. Criar interceptador de XMLHttpRequest (para axios, jQuery, etc)
-        xmlHttpRequestInterceptor = new XMLHttpRequestInterceptor_1.XMLHttpRequestInterceptor(logger, requestLogger, mockResolver, sessionId, config.getAppName());
-        // 7. Instalar interceptadores
+        // 6. ✅ Criar URL Filter para evitar loops infinitos
+        // Automatically excludes Fluwa server URLs and internal endpoints
+        const { excludedUrls } = config.getConfig();
+        urlFilter = (0, UrlFilter_1.createFluwaSdkFilter)(serverUrl, excludedUrls, config.getConfig().debug);
+        logger.debug(`URL Filter configurado com ${urlFilter.getExcludedPatterns().length} padrões excluídos`);
+        // 7. Criar interceptador de fetch
+        fetchInterceptor = new FetchInterceptor_1.FetchInterceptor(logger, requestLogger, mockResolver, sessionId, config.getAppName(), urlFilter);
+        // 7b. Criar interceptador de XMLHttpRequest (para axios, jQuery, etc)
+        xmlHttpRequestInterceptor = new XMLHttpRequestInterceptor_1.XMLHttpRequestInterceptor(logger, requestLogger, mockResolver, sessionId, config.getAppName(), urlFilter);
+        // 8. Instalar interceptadores
         fetchInterceptor.install();
         xmlHttpRequestInterceptor.install();
-        // 8. Conectar WebSocket
+        // 9. Conectar WebSocket
         logger.debug('Conectando ao WebSocket...');
         try {
             await wsClient.connect();
@@ -98,7 +105,7 @@ async function initFluwaTool(partialConfig = {}) {
         catch (error) {
             logger.warn('Falha ao conectar WebSocket, continuando em modo offline', error);
         }
-        // 9. Enviar init session
+        // 10. Enviar init session
         wsClient.send({
             type: types_1.WebSocketMessageType.INIT_SESSION,
             sessionId,
@@ -182,3 +189,7 @@ Object.defineProperty(exports, "Logger", { enumerable: true, get: function () {
 Object.defineProperty(exports, "LogLevel", { enumerable: true, get: function () { return Logger_2.LogLevel; } });
 var Config_2 = require("./core/Config");
 Object.defineProperty(exports, "ConfigManager", { enumerable: true, get: function () { return Config_2.ConfigManager; } });
+var UrlFilter_2 = require("./features/network/UrlFilter");
+Object.defineProperty(exports, "UrlFilter", { enumerable: true, get: function () { return UrlFilter_2.UrlFilter; } });
+Object.defineProperty(exports, "createFluwaSdkFilter", { enumerable: true, get: function () { return UrlFilter_2.createFluwaSdkFilter; } });
+Object.defineProperty(exports, "FLUWA_INTERNAL_PATHS", { enumerable: true, get: function () { return UrlFilter_2.FLUWA_INTERNAL_PATHS; } });

package/dist/types/index.d.ts

@@ -13,6 +13,8 @@ export interface FluwaConfig {
     debug?: boolean;
     /** Timeout para requisições (ms) */
     requestTimeout?: number;
+    /** URLs adicionais para excluir da interception (evita loops infinitos) */
+    excludedUrls?: string[];
 }
 export declare enum HttpMethod {
     GET = "GET",

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@fluwa-tool/sdk",
-  "version": "1.0.31",
+  "version": "1.0.32",
   "description": "Fluwa DevTools SDK for network interception and mocking",
   "main": "dist/index.js",
   "types": "dist/index.d.ts",