@duckfly/proxy 1.0.0 → 1.0.4

package/README.md

@@ -43,7 +43,7 @@ After running, the CLI will ask for:
 
 | Prompt | Description | Default |
 |---|---|---|
-| **Token** | Your Duckfly application token | — |
+| **Token** | Your Duckfly application token | N/D |
 | **Proxy Port** | Port where the proxy listens | `8080` |
 | **Target URL** | Your backend API address | `http://localhost:3000` |
 

package/bin/cli.js

@@ -51,9 +51,7 @@ let config = {
   appUrl: null,
   domainPackageId: null,
   proxyPort: 8080,
-  targetUrl: 'http://localhost:3000',
-  apiUrl: DUCKFLY_API_URL,
-  proxyUrl: DUCKFLY_PROXY_URL
+  targetUrl: null,
 };
 
 const CONFIG_FILE = path.join(process.cwd(), '.duckfly-proxy.json');
@@ -62,7 +60,8 @@ 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) {
@@ -73,7 +72,8 @@ function loadConfig() {
 
 function saveConfig() {
   try {
-    fs.writeFileSync(CONFIG_FILE, JSON.stringify(config, null, 2));
+    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 (error) {
     console.log(chalk.yellow('⚠️  Não foi possível salvar a configuração'));
   }
@@ -85,7 +85,7 @@ async function validateToken(token) {
   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);
@@ -96,7 +96,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;
@@ -143,10 +142,7 @@ async function askQuestions() {
     }
   }
 
-  config.apiUrl = DUCKFLY_API_URL;
-  config.proxyUrl = DUCKFLY_PROXY_URL;
-
-  const questions = [
+  const { proxyPort } = await inquirer.prompt([
     {
       type: 'input',
       name: 'proxyPort',
@@ -159,12 +155,37 @@ async function askQuestions() {
         }
         return true;
       }
-    },
+    }
+  ]);
+
+  config.proxyPort = proxyPort;
+
+  // Alias: se o domínio do proxy não bate com o da aplicação, ativa automaticamente
+  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 capturadas 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 { }
+  }
+
+  const isWildcard = config.appUrl && config.appUrl.includes('*');
+  const defaultTarget = isWildcard ? null : (config.appUrl || config.targetUrl);
+
+  const { targetUrl } = await inquirer.prompt([
     {
       type: 'input',
       name: 'targetUrl',
       message: chalk.yellow('🎯 URL de destino (para onde encaminhar as requisições):'),
-      default: config.targetUrl,
+      default: defaultTarget,
       validate: (input) => {
         try {
           new URL(input);
@@ -174,13 +195,11 @@ async function askQuestions() {
         }
       }
     }
-  ];
-
-  const answers = await inquirer.prompt(questions);
+  ]);
 
-  Object.assign(config, answers);
+  config.targetUrl = targetUrl;
 
-  return answers;
+  return;
 }
 
 let proxyServer = null;
@@ -188,7 +207,7 @@ 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,8 +219,8 @@ 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 capturadas e documentadas automaticamente!\n'));
     console.log(chalk.gray('Pressione Ctrl+C para parar o proxy\n'));
 
     saveConfig();
@@ -242,8 +261,11 @@ async function main() {
     if (!useExisting) {
       config.token = null;
       config.appName = null;
+      config.appUrl = null;
+      config.domainPackageId = null;
       config.proxyPort = 8080;
-      config.targetUrl = 'http://localhost:3000';
+      config.targetUrl = null;
+      try { fs.unlinkSync(CONFIG_FILE); } catch { }
     }
   }
 

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@duckfly/proxy",
-  "version": "1.0.0",
+  "version": "1.0.4",
   "description": "Duckfly Proxy observes real API usage to continuously enrich and generate API documentation and MCP servers on Duckfly.",
   "main": "dist/index.js",
   "bin": {
@@ -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;
@@ -85,10 +86,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(),