@duckfly/proxy 1.0.3 → 1.0.5

package/README.md

@@ -24,6 +24,7 @@ This allows your API documentation and MCP (Model Context Protocol) servers to b
 - Continuously enriched API documentation
 - MCP server generation for AI integrations
 - Documentation aligned with real API usage
+- No code changes required; just point your application to the proxy
 
 ## Quick Start
 
@@ -39,15 +40,41 @@ npm install -g @duckfly/proxy
 npx @duckfly/proxy
 ```
 
-After running, the CLI will ask for:
+### Interactive mode
+
+When you run the CLI without arguments, it will guide you through the setup:
 
 | Prompt | Description | Default |
 |---|---|---|
-| **Token** | Your Duckfly application token | — |
+| **Token** | Your Duckfly application token | |
 | **Proxy Port** | Port where the proxy listens | `8080` |
-| **Target URL** | Your backend API address | `http://localhost:3000` |
+| **Target URL** | Your backend API address | App URL from token |
+
+Configuration is saved locally in `.duckfly-proxy.json` so you don't need to enter it every time.
+
+### Command line mode
+
+You can pass all options via CLI arguments. The CLI will only ask for what is missing.
+
+```bash
+# Full command line (no prompts)
+duckfly-proxy --token abc123 --port 8080 --target http://localhost:3000
+
+# Hybrid: pass what you know, it asks the rest
+duckfly-proxy --token abc123
+
+# With npx
+npx @duckfly/proxy --token abc123 --port 8080 --target http://localhost:3000
+```
+
+All available flags:
 
-Configuration is saved locally in `.duckfly-proxy.json` so you don't need to re-enter it every time.
+| Flag | Description |
+|---|---|
+| `--token <token>` | Duckfly application token |
+| `--port <N>` | Proxy port (default: 8080) |
+| `--target <url>` | URL to forward requests to |
+| `--help` | Show help |
 
 ## How It Works
 
@@ -75,7 +102,25 @@ Configuration is saved locally in `.duckfly-proxy.json` so you don't need to re-
 
 Duckfly Proxy processes only technical and structural information such as HTTP methods, routes, headers, and payload formats.
 
-Request and response values are replaced with **placeholders** before being sent, ensuring no sensitive or user-specific data is transmitted.
+Request and response values are replaced with **placeholders** before being sent, ensuring no sensitive or user specific data is transmitted.
+
+### What is sent
+
+- HTTP methods and route paths
+- Header names (values are redacted)
+- Body structure and field names (values replaced with type appropriate placeholders)
+- Status codes and content types
+
+### What is NOT sent
+
+- Authentication tokens, passwords, or secrets
+- Request/response body values
+- Cookie values
+- Query parameter values for sensitive fields
+
+## Host Alias
+
+When your application domain (from the Duckfly token) differs from `localhost`, the proxy automatically adjusts the Host header so that observed requests are associated with the correct domain. This happens automatically; no configuration is needed.
 
 ## License
 

package/bin/cli.js

@@ -8,42 +8,96 @@ const ApiClient = require('../src/api-client');
 const fs = require('fs');
 const path = require('path');
 
+// ─── Constants ───────────────────────────────────────────────────
+
+const DUCKFLY_API_URL = 'https://api.duckfly.dev';
+const DUCKFLY_PROXY_URL = 'https://proxy.duckfly.dev';
+
+const CONFIG_FILE = path.join(process.cwd(), '.duckfly-proxy.json');
+
+// ─── Logo ────────────────────────────────────────────────────────
+
 const yellow = chalk.hex('#FFD54F');
 const gold = chalk.hex('#FFC107');
 
 const DUCKFLY_LOGO = `
 ${yellow(`
-                 @@@@@@@@@              
-               @%+-------=%@            
-             @@+-----------=@@          
-            @@=-----=##=-----@@         
-            @*------@@=#---+*%@         
-            @+------+%%+-=%*+*%@@       
-            @*---------=#%++%+++#%%@    
-            @@=-------=@%#++++++++%@    
-             @@+-------=*%%@@@@@@@      
-              @@@*-------===%@          
-           @%+---------------#@         
-         @%----------+--------#@        
-    @@@@%=------------#-------=@@       
-    @*------+*=-------%-------=@@       
-    @%--+@*+---------##-------+@        
-     @%=-=#%%#+----+%*------=+@@        
-      @@*==+%%##%%#=-----===*@@@        
-        @@#=============+*%#+=+*@@      
-           @@@%****#%%*+#@@@@%@@@       
-                @@@@%#++#@@@            
+                 @@@@@@@@@
+               @%+-------=%@
+             @@+-----------=@@
+            @@=-----=##=-----@@
+            @*------@@=#---+*%@
+            @+------+%%+-=%*+*%@@
+            @*---------=#%++%+++#%%@
+            @@=-------=@%#++++++++%@
+             @@+-------=*%%@@@@@@@
+              @@@*-------===%@
+           @%+---------------#@
+         @%----------+--------#@
+    @@@@%=------------#-------=@@
+    @*------+*=-------%-------=@@
+    @%--+@*+---------##-------+@
+     @%=-=#%%#+----+%*------=+@@
+      @@*==+%%##%%#=-----===*@@@
+        @@#=============+*%#+=+*@@
+           @@@%****#%%*+#@@@@%@@@
+                @@@@%#++#@@@
 `)}
 ${gold('═══════════════════════════════════════════════════════════════════════════════════════════')}
 ${chalk.bold.yellow('                        🦆 DUCKFLY PROXY v1.0.0                                  ')}
 ${gold('═══════════════════════════════════════════════════════════════════════════════════════════')}
-${chalk.gray('                  Capture and document your APIs automatically                      ')}
+${chalk.gray('                  Observe and document your APIs automatically                      ')}
 ${chalk.gray('                          https://duckfly.dev                                        ')}
 ${gold('═══════════════════════════════════════════════════════════════════════════════════════════')}
 `;
 
-const DUCKFLY_API_URL = 'https://api.duckfly.dev';
-const DUCKFLY_PROXY_URL = 'https://proxy.duckfly.dev';
+// ─── CLI arg parsing ─────────────────────────────────────────────
+
+function parseArgs() {
+  const argv = process.argv.slice(2);
+  const args = {};
+  for (let i = 0; i < argv.length; i++) {
+    const arg = argv[i];
+    if (!arg.startsWith('--')) continue;
+    const key = arg.slice(2);
+    const next = argv[i + 1];
+    if (!next || next.startsWith('--')) {
+      args[key] = true;
+    } else {
+      args[key] = next;
+      i++;
+    }
+  }
+  return args;
+}
+
+const CLI_KEYS = ['token', 'port', 'target'];
+
+function hasCliArgs(cliArgs) {
+  return CLI_KEYS.some(k => cliArgs[k] !== undefined);
+}
+
+// ─── Help ────────────────────────────────────────────────────────
+
+function showHelp() {
+  console.log(chalk.bold.yellow('\n🦆 Duckfly Proxy\n'));
+  console.log(chalk.white('Uso: duckfly-proxy [opções]\n'));
+  console.log(chalk.white('Opções:'));
+  console.log(chalk.yellow('  --token <token>     ') + chalk.gray('Token do Duckfly'));
+  console.log(chalk.yellow('  --port <N>          ') + chalk.gray('Porta do proxy (default: 8080)'));
+  console.log(chalk.yellow('  --target <url>      ') + chalk.gray('URL de destino para encaminhar as requisições'));
+  console.log(chalk.yellow('  --help              ') + chalk.gray('Mostrar esta ajuda'));
+  console.log('');
+  console.log(chalk.white('Exemplos:'));
+  console.log(chalk.gray('  # Modo interativo completo'));
+  console.log(chalk.white('  duckfly-proxy\n'));
+  console.log(chalk.gray('  # Tudo via CLI (sem prompts)'));
+  console.log(chalk.white('  duckfly-proxy --token abc123 --port 8080 --target http://localhost:3000\n'));
+  console.log(chalk.gray('  # Híbrido (passa o que sabe, pergunta o que falta)'));
+  console.log(chalk.white('  duckfly-proxy --token abc123\n'));
+}
+
+// ─── State ───────────────────────────────────────────────────────
 
 let config = {
   token: null,
@@ -51,21 +105,21 @@ let config = {
   appUrl: null,
   domainPackageId: null,
   proxyPort: 8080,
-  targetUrl: 'http://localhost:3000',
-  apiUrl: DUCKFLY_API_URL,
-  proxyUrl: DUCKFLY_PROXY_URL
+  targetUrl: null,
+  hostAlias: null,
 };
 
-const CONFIG_FILE = path.join(process.cwd(), '.duckfly-proxy.json');
+// ─── Config persistence ──────────────────────────────────────────
 
 function loadConfig() {
   try {
     if (fs.existsSync(CONFIG_FILE)) {
       const saved = JSON.parse(fs.readFileSync(CONFIG_FILE, 'utf8'));
-      config = { ...config, ...saved };
+      const { apiUrl, proxyUrl, ...rest } = saved;
+      config = { ...config, ...rest };
       return true;
     }
-  } catch (error) {
+  } catch {
     console.log(chalk.yellow('⚠️  Erro ao carregar configuração salva'));
   }
   return false;
@@ -73,21 +127,23 @@ function loadConfig() {
 
 function saveConfig() {
   try {
-    fs.writeFileSync(CONFIG_FILE, JSON.stringify(config, null, 2));
-  } catch (error) {
+    const { token, appName, appUrl, domainPackageId, proxyPort, targetUrl, hostAlias } = config;
+    fs.writeFileSync(CONFIG_FILE, JSON.stringify({ token, appName, appUrl, domainPackageId, proxyPort, targetUrl, hostAlias }, null, 2));
+  } catch {
     console.log(chalk.yellow('⚠️  Não foi possível salvar a configuração'));
   }
 }
 
+// ─── Token validation ────────────────────────────────────────────
+
 async function validateToken(token) {
   const spinner = new Spinner(chalk.yellow('%s Validando token...'));
   spinner.setSpinnerString('|/-\\');
   spinner.start();
 
   try {
-    const apiClient = new ApiClient(config.apiUrl, config.proxyUrl, token);
+    const apiClient = new ApiClient(DUCKFLY_API_URL, DUCKFLY_PROXY_URL, token);
     const result = await apiClient.validateToken();
-
     spinner.stop(true);
 
     if (result.valid) {
@@ -96,7 +152,6 @@ async function validateToken(token) {
       console.log(chalk.gray('─'.repeat(60)));
       console.log(chalk.yellow('  Nome:        ') + chalk.white(result.appName));
       console.log(chalk.yellow('  URL:         ') + chalk.white(result.appUrl));
-      console.log(chalk.yellow('  Package ID:  ') + chalk.white(result.domainPackageId));
       console.log(chalk.gray('─'.repeat(60)) + '\n');
 
       config.appName = result.appName;
@@ -114,81 +169,101 @@ async function validateToken(token) {
   }
 }
 
-async function askQuestions() {
-  if (!config.token) {
+// ─── Hybrid prompts ──────────────────────────────────────────────
+
+async function askTokenIfMissing(cliArgs) {
+  if (cliArgs.token) {
+    config.token = String(cliArgs.token).trim();
+  } else {
     const { token } = await inquirer.prompt([
       {
         type: 'password',
         name: 'token',
         message: chalk.yellow('🔑 Cole seu token do Duckfly:'),
         mask: '*',
-        validate: (input) => {
-          if (!input || input.trim().length === 0) {
-            return 'Token não pode ser vazio';
-          }
-          return true;
-        }
-      }
+        validate: input => (!!input && input.trim().length > 0) || 'Token não pode ser vazio',
+      },
     ]);
+    config.token = token.trim();
+  }
 
-    config.token = token;
-
-    console.log('');
-    const valid = await validateToken(config.token);
-
-    if (!valid) {
-      console.log(chalk.red('❌ Token inválido. Não é possível continuar.\n'));
-      console.log(chalk.yellow('💡 Obtenha um token válido em: ') + chalk.white('https://duckfly.dev\n'));
-      process.exit(1);
-    }
+  console.log('');
+  const valid = await validateToken(config.token);
+  if (!valid) {
+    console.log(chalk.red('❌ Token inválido. Não é possível continuar.\n'));
+    console.log(chalk.yellow('💡 Obtenha um token válido em: ') + chalk.white('https://duckfly.dev\n'));
+    process.exit(1);
   }
+}
 
-  config.apiUrl = DUCKFLY_API_URL;
-  config.proxyUrl = DUCKFLY_PROXY_URL;
-
-  const questions = [
-    {
-      type: 'input',
-      name: 'proxyPort',
-      message: chalk.yellow('🔌 Porta do proxy (porta que vai receber as requisições):'),
-      default: config.proxyPort,
-      validate: (input) => {
-        const port = parseInt(input);
-        if (isNaN(port) || port < 1 || port > 65535) {
-          return 'Porta inválida (1-65535)';
-        }
-        return true;
-      }
-    },
-    {
-      type: 'input',
-      name: 'targetUrl',
-      message: chalk.yellow('🎯 URL de destino (para onde encaminhar as requisições):'),
-      default: config.targetUrl,
-      validate: (input) => {
-        try {
-          new URL(input);
+async function askProxyConfig(cliArgs) {
+  // Port
+  if (cliArgs.port != null) {
+    config.proxyPort = parseInt(cliArgs.port, 10);
+  } else {
+    const { proxyPort } = await inquirer.prompt([
+      {
+        type: 'input',
+        name: 'proxyPort',
+        message: chalk.yellow('🔌 Porta do proxy (porta que vai receber as requisições):'),
+        default: config.proxyPort,
+        validate: input => {
+          const port = parseInt(input, 10);
+          if (Number.isNaN(port) || port < 1 || port > 65535) return 'Porta inválida (1-65535)';
           return true;
-        } catch {
-          return 'URL inválida (ex: http://localhost:3000)';
-        }
-      }
-    }
-  ];
+        },
+      },
+    ]);
+    config.proxyPort = proxyPort;
+  }
 
-  const answers = await inquirer.prompt(questions);
+  // Host alias (automatic)
+  config.hostAlias = null;
+  if (config.appUrl) {
+    try {
+      const appHost = new URL(config.appUrl).host;
+      const proxyHost = `localhost:${config.proxyPort}`;
+
+      if (appHost && appHost !== proxyHost && appHost !== `127.0.0.1:${config.proxyPort}`) {
+        config.hostAlias = appHost;
+        console.log('');
+        console.log(chalk.blue('   O domínio da aplicação (') + chalk.bold.white(appHost) + chalk.blue(') difere do proxy local.'));
+        console.log(chalk.blue('   As requisições observadas serão enviadas com o domínio ') + chalk.bold.white(appHost));
+        console.log(chalk.blue('   para que possam ser processadas corretamente pela aplicação.\n'));
+      }
+    } catch { }
+  }
 
-  Object.assign(config, answers);
+  // Target URL
+  if (cliArgs.target) {
+    config.targetUrl = cliArgs.target;
+  } else {
+    const isWildcard = config.appUrl && config.appUrl.includes('*');
+    const defaultTarget = isWildcard ? null : (config.appUrl || config.targetUrl);
 
-  return answers;
+    const { targetUrl } = await inquirer.prompt([
+      {
+        type: 'input',
+        name: 'targetUrl',
+        message: chalk.yellow('🎯 URL de destino (para onde encaminhar as requisições):'),
+        default: defaultTarget,
+        validate: input => {
+          try { new URL(input); return true; } catch { return 'URL inválida (ex: http://localhost:3000)'; }
+        },
+      },
+    ]);
+    config.targetUrl = targetUrl;
+  }
 }
 
+// ─── Proxy startup ───────────────────────────────────────────────
+
 let proxyServer = null;
 
 async function startProxy() {
   console.log(chalk.yellow('\n🚀 Iniciando Duckfly Proxy...\n'));
 
-  proxyServer = new ProxyServer(config);
+  proxyServer = new ProxyServer({ ...config, apiUrl: DUCKFLY_API_URL, proxyUrl: DUCKFLY_PROXY_URL });
 
   try {
     await proxyServer.start();
@@ -200,66 +275,74 @@ async function startProxy() {
     console.log(chalk.yellow('  Proxy rodando em:  ') + chalk.white(`http://localhost:${config.proxyPort}`));
     console.log(chalk.yellow('  Encaminhando para: ') + chalk.white(config.targetUrl));
     console.log(chalk.gray('─'.repeat(60)));
-    console.log(chalk.yellow('\n💡 Dica: Configure sua aplicação para apontar para ') + chalk.white(`http://localhost:${config.proxyPort}`));
-    console.log(chalk.yellow('   Todas as requisições serão capturadas e documentadas automaticamente!\n'));
+    console.log(chalk.blue('\n💡 Dica: Configure sua aplicação para apontar para ') + chalk.white(`http://localhost:${config.proxyPort}`));
+    console.log(chalk.blue('   Todas as requisições serão observadas e documentadas automaticamente!\n'));
     console.log(chalk.gray('Pressione Ctrl+C para parar o proxy\n'));
 
     saveConfig();
-
   } catch (error) {
     console.log(chalk.red('❌ Erro ao iniciar proxy: ') + chalk.gray(error.message));
     process.exit(1);
   }
 }
 
-async function main() {
-  console.clear();
+// ─── Main ────────────────────────────────────────────────────────
 
-  console.log(DUCKFLY_LOGO);
-
-  const hasConfig = loadConfig();
-  let useExisting = false;
+async function main() {
+  const cliArgs = parseArgs();
 
-  if (hasConfig) {
-    console.log(chalk.green('✅ Configuração anterior encontrada!\n'));
-    console.log(chalk.gray('─'.repeat(60)));
-    console.log(chalk.yellow('  App:    ') + chalk.white(config.appName || 'N/A'));
-    console.log(chalk.yellow('  Porta:  ') + chalk.white(config.proxyPort));
-    console.log(chalk.yellow('  Alvo:   ') + chalk.white(config.targetUrl));
-    console.log(chalk.gray('─'.repeat(60)) + '\n');
+  if (cliArgs.help) {
+    showHelp();
+    process.exit(0);
+  }
 
-    const answer = await inquirer.prompt([
-      {
-        type: 'confirm',
-        name: 'useExisting',
-        message: chalk.yellow('Deseja usar a configuração salva?'),
-        default: true
-      }
-    ]);
+  console.clear();
+  console.log(DUCKFLY_LOGO);
 
-    useExisting = answer.useExisting;
+  const hasCli = hasCliArgs(cliArgs);
 
-    if (!useExisting) {
-      config.token = null;
-      config.appName = null;
-      config.proxyPort = 8080;
-      config.targetUrl = 'http://localhost:3000';
-    }
-  }
+  // If no CLI args, try loading saved config
+  if (!hasCli) {
+    const hasConfig = loadConfig();
 
-  if (!useExisting) {
-    await askQuestions();
-  } else {
-    console.log('');
-    const valid = await validateToken(config.token);
+    if (hasConfig) {
+      console.log(chalk.green('✅ Configuração anterior encontrada!\n'));
+      console.log(chalk.gray('─'.repeat(60)));
+      console.log(chalk.yellow('  App:    ') + chalk.white(config.appName || 'N/A'));
+      console.log(chalk.yellow('  Porta:  ') + chalk.white(config.proxyPort));
+      console.log(chalk.yellow('  Alvo:   ') + chalk.white(config.targetUrl));
+      console.log(chalk.gray('─'.repeat(60)) + '\n');
 
-    if (!valid) {
-      console.log(chalk.red('❌ Token salvo está inválido. Configurando novamente...\n'));
-      config.token = null;
-      await askQuestions();
+      const { useExisting } = await inquirer.prompt([
+        { type: 'confirm', name: 'useExisting', message: chalk.yellow('Deseja usar a configuração salva?'), default: true },
+      ]);
+
+      if (useExisting) {
+        console.log('');
+        const valid = await validateToken(config.token);
+        if (!valid) {
+          console.log(chalk.red('❌ Token salvo está inválido. Configurando novamente...\n'));
+          config.token = null;
+        } else {
+          await startProxy();
+          return;
+        }
+      } else {
+        config.token = null;
+        config.appName = null;
+        config.appUrl = null;
+        config.domainPackageId = null;
+        config.proxyPort = 8080;
+        config.targetUrl = null;
+        try { fs.unlinkSync(CONFIG_FILE); } catch { }
+      }
     }
   }
 
+  // Fresh setup (interactive or CLI args)
+  await askTokenIfMissing(cliArgs);
+  await askProxyConfig(cliArgs);
+  saveConfig();
   await startProxy();
 }
 

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@duckfly/proxy",
-  "version": "1.0.3",
+  "version": "1.0.5",
   "description": "Duckfly Proxy observes real API usage to continuously enrich and generate API documentation and MCP servers on Duckfly.",
   "main": "dist/index.js",
   "bin": {
@@ -20,7 +20,7 @@
     "duckfly",
     "http",
     "request",
-    "capture"
+    "observe"
   ],
   "author": "Duckfly",
   "license": "MIT",
@@ -47,4 +47,4 @@
   "publishConfig": {
     "access": "public"
   }
-}
+}

package/src/api-client.js

@@ -9,7 +9,7 @@ class ApiClient {
 
   async validateToken() {
     try {
-      const url = `${this.apiUrl}/internal/v1/core/token/${this.token}`;
+      const url = `${this.apiUrl}/internal/v1/core/token/${this.token}?source=plugin-proxy`;
 
       const response = await axios.get(url, {
         timeout: 30000,

package/src/proxy-server.js

@@ -9,6 +9,7 @@ const { sanitizeRequestData } = require('./sanitizer');
 class ProxyServer {
   constructor(config) {
     this.config = config;
+    this.hostAlias = config.hostAlias || null;
     this.proxy = httpProxy.createProxyServer({});
     this.app = express();
     this.server = null;
@@ -44,15 +45,28 @@ class ProxyServer {
     });
 
     this.proxy.on('proxyRes', (proxyRes, req, res) => {
+      const MAX_CAPTURE = 10 * 1024 * 1024; // 10MB
+      const contentType = (proxyRes.headers['content-type'] || '').toLowerCase();
+      const binaryTypes = ['image/', 'video/', 'audio/', 'application/octet-stream', 'application/pdf', 'application/zip'];
+      const skipBody = binaryTypes.some(t => contentType.includes(t));
+
       let bodyChunks = [];
+      let bodySize = 0;
+      let overflow = false;
 
       proxyRes.on('data', (chunk) => {
-        bodyChunks.push(chunk);
+        bodySize += chunk.length;
+        if (!skipBody && !overflow) {
+          if (bodySize <= MAX_CAPTURE) {
+            bodyChunks.push(chunk);
+          } else {
+            overflow = true;
+            bodyChunks = [];
+          }
+        }
       });
 
       proxyRes.on('end', () => {
-        const responseBody = Buffer.concat(bodyChunks);
-
         const statusColor = proxyRes.statusCode >= 400 ? chalk.red :
           proxyRes.statusCode >= 300 ? chalk.yellow :
             chalk.green;
@@ -61,9 +75,18 @@ class ProxyServer {
           chalk.blue('←'),
           statusColor(proxyRes.statusCode),
           chalk.gray(req.url),
-          chalk.dim(`${responseBody.length} bytes`)
+          chalk.dim(`${bodySize} bytes`)
         );
 
+        let responseBody;
+        if (skipBody) {
+          responseBody = Buffer.from(`[Binary content: ${contentType}, ${bodySize} bytes]`);
+        } else if (overflow) {
+          responseBody = Buffer.from(`[Body too large: ${bodySize} bytes]`);
+        } else {
+          responseBody = Buffer.concat(bodyChunks);
+        }
+
         this.captureResponse(req, proxyRes, responseBody);
       });
     });
@@ -85,10 +108,16 @@ class ProxyServer {
 
   captureRequest(req, res) {
     try {
+      const headers = { ...req.headers };
+
+      if (this.hostAlias) {
+        headers.host = this.hostAlias;
+      }
+
       req._captureData = {
         method: req.method,
         url: req.url,
-        headers: { ...req.headers },
+        headers,
         body: this.parseBody(req.rawBody, req.headers['content-type']),
         protocol: req.socket.encrypted ? 'https' : 'http',
         timestamp: new Date().toISOString(),
@@ -98,7 +127,7 @@ class ProxyServer {
         }
       };
     } catch (error) {
-      console.log(chalk.yellow('⚠'), chalk.gray('Erro ao capturar requisição:'), error.message);
+      console.log(chalk.yellow('⚠'), chalk.gray('Erro ao observar requisição:'), error.message);
     }
   }
 
@@ -140,7 +169,7 @@ class ProxyServer {
       this.stats.captured++;
 
     } catch (error) {
-      console.log(chalk.yellow('⚠'), chalk.gray('Erro ao capturar resposta:'), error.message);
+      console.log(chalk.yellow('⚠'), chalk.gray('Erro ao observar resposta:'), error.message);
     }
   }
 
@@ -396,7 +425,7 @@ class ProxyServer {
     process.stdout.write('\r' + chalk.bold.white('📊 Estatísticas:') + '\x1b[K\n');
     process.stdout.write('\r' + chalk.yellow('  Uptime:       ') + chalk.white(`${hours}h ${minutes}m ${seconds}s`) + '\x1b[K\n');
     process.stdout.write('\r' + chalk.yellow('  Total:        ') + chalk.white(this.stats.totalRequests) + '\x1b[K\n');
-    process.stdout.write('\r' + chalk.yellow('  Capturadas:   ') + chalk.white(this.stats.captured) + '\x1b[K\n');
+    process.stdout.write('\r' + chalk.yellow('  Observadas:   ') + chalk.white(this.stats.captured) + '\x1b[K\n');
     process.stdout.write('\r' + chalk.yellow('  Enviadas:     ') + chalk.green(this.stats.sent) + '\x1b[K\n');
     process.stdout.write('\r' + chalk.yellow('  Falhas:       ') + (this.stats.failed > 0 ? chalk.red(this.stats.failed) : chalk.gray(this.stats.failed)) + '\x1b[K\n');
     process.stdout.write('\r' + chalk.yellow('  Na fila:      ') + chalk.yellow(this.requestQueue.getQueueSize()) + '\x1b[K\n');