@dutodev/cli 0.4.0 → 0.4.2

package/README.md

@@ -51,24 +51,47 @@ Todos os túneis sobem juntos, numa única tela. A CLI procura o arquivo na past
 
 ### Host e cabeçalhos
 
-Por padrão, o serviço local recebe o Host público (`web-<usuário>.duto.dev`). Se ele escolhe o que responder pelo Host, como um proxy reverso local ou um app com vários domínios, troque o Host com `host:` e ajuste cabeçalhos com `headers:`:
+Por padrão, o serviço local recebe a requisição como ela chegou da internet: `Host: web-<usuário>.duto.dev`, `X-Forwarded-Proto: https` e os cabeçalhos da Cloudflare (`CF-Connecting-IP` e outros). Na maioria dos apps isso basta. Quando o app decide algo pelo domínio, há duas ferramentas por túnel:
 
 ```yaml
 tunnels:
   loja:
     port: 8080
-    host: loja.meuapp.test      # o serviço recebe este Host
-  painel:
-    port: 8080                  # mesma porta: vale quando cada túnel tem um host
-    host: painel.meuapp.test
-    headers:
-      X-Ambiente: tunel         # acrescenta ou sobrescreve
+    headers:                    # acrescenta ou sobrescreve cabeçalhos
+      X-Forwarded-Host: loja.meuapp.test
       X-Debug: ""               # valor vazio remove o cabeçalho
+  painel:
+    port: 8081
+    host: painel.meuapp.test    # troca o Host que o serviço recebe
 ```
 
-- Com `host:`, o `X-Forwarded-Host` não é enviado, para o app não ver o domínio público. Se quiser enviá-lo, coloque-o em `headers:`.
-- Na linha de comando: `duto 8080 --host loja.meuapp.test`.
-- Links que o app montar a partir do Host trocado só abrem na sua máquina.
+**Qual usar:**
+
+| Situação | Use | Por quê |
+|---|---|---|
+| Um proxy reverso local (Traefik, Nginx, Caddy) escolhe o serviço pelo Host | `host:` | O proxy só conhece os domínios locais |
+| Vários túneis na mesma porta, um por domínio | `host:` ou `headers:` diferentes em cada um | A porta pode se repetir; cada túnel tem o próprio endereço |
+| O app identifica o domínio ou o cliente pelo `X-Forwarded-Host`, mas monta URLs a partir do `Host` | `headers:` com `X-Forwarded-Host` | O app vê o domínio local e continua gerando links públicos |
+| Login OAuth em que o app calcula o `redirect_uri` sozinho | evite `host:`; tente `headers:` | Veja abaixo |
+
+**O que o `host:` faz:**
+
+- O serviço recebe o Host informado, e o `X-Forwarded-Host` não é enviado. Para enviá-lo assim mesmo, coloque-o em `headers:`.
+- Os redirecionamentos voltam com o endereço público. Um `Location: http://painel.meuapp.test:8081/login` chega ao navegador como `https://painel-<usuário>.duto.dev/login`. Isso vale também dentro de parâmetros codificados no `Location`. Para desligar, use `rewrite_redirects: false` no túnel.
+- Links no corpo das respostas (HTML, JSON) não são reescritos. URLs que o app montar a partir do Host só abrem na sua máquina.
+- Na linha de comando: `duto 8081 --host painel.meuapp.test`, e `--no-rewrite-redirects` para desligar a troca.
+
+**OAuth e `host:`.** No fluxo de autorização por código, o app manda um `redirect_uri` duas vezes: na ida do navegador ao provedor de login e depois, servidor a servidor, ao trocar o código por token. O provedor exige que as duas sejam idênticas. Com `host:`, o app gera as duas com o domínio local. O Duto corrige a primeira, que passa pelo navegador, mas não alcança a segunda, que não passa pelo túnel. O provedor recusa a troca, em geral com `invalid_request` ou `invalid_grant`, e o app costuma voltar ao login em loop (`ERR_TOO_MANY_REDIRECTS`).
+
+Saídas, da mais simples para a mais trabalhosa:
+
+1. Não troque o Host. O app gera o `redirect_uri` com o endereço público nas duas vezes.
+2. Se o app precisa ver o domínio local para outras decisões e lê o `X-Forwarded-Host`, passe o domínio por `headers:` e mantenha o Host público.
+3. Configure no app a URL pública de retorno, se ele permitir.
+
+Em todos os casos, cadastre `https://<nome>-<usuário>.duto.dev/<caminho de retorno>` como URL de retorno no provedor. A comparação costuma ser exata, sem curingas: cada pessoa do time tem o próprio endereço.
+
+**Sobre o `X-Forwarded-*`.** `X-Forwarded-Host`, `X-Forwarded-Proto` e `X-Forwarded-For` são uma convenção antiga entre proxies reversos para contar ao app o que o cliente pediu de verdade. A versão padronizada é o cabeçalho `Forwarded` (RFC 7239), menos usado na prática. Frameworks costumam ler esses cabeçalhos só quando o proxy é marcado como confiável (`trusted proxies`, `trust proxy`, `USE_X_FORWARDED_HOST`), então o efeito de `headers:` depende de como o app está configurado. Por outro lado, se um app lê o `X-Forwarded-Host` sem essa checagem, qualquer cliente pode forjá-lo em produção. Vale garantir que o proxy da frente sobrescreva ou remova esse cabeçalho.
 
 ## A tela
 
@@ -100,6 +123,7 @@ Fora de um terminal interativo (pipe, CI) ou com `--no-ui`, a CLI imprime um log
 |---|---|
 | `--name <nome>` | Endereço fixo `<nome>-<usuário>.duto.dev` |
 | `--host <host>` | Host que o serviço local recebe no lugar do público |
+| `--no-rewrite-redirects` | Com `--host`, mantém os redirecionamentos como o serviço mandou |
 | `--no-ui` / `--ui` | Desliga / força a tela cheia |
 
 ## Configuração

package/dist/index.js

@@ -240,7 +240,7 @@ var CONFIG_FILES = ["duto.yml", "duto.yaml"];
 var LABEL = "[a-z0-9](?:[a-z0-9-]*[a-z0-9])?";
 var HOST_RE = new RegExp(`^${LABEL}(?:\\.${LABEL})*(?::\\d{1,5})?$`);
 var HEADER_NAME_RE = /^[!#$%&'*+.^_`|~0-9A-Za-z-]+$/;
-var TUNNEL_KEYS = ["port", "host", "headers"];
+var TUNNEL_KEYS = ["port", "host", "headers", "rewrite_redirects"];
 function parseHost(raw) {
   const host = raw.trim().toLowerCase();
   return HOST_RE.test(host) ? host : null;
@@ -263,7 +263,6 @@ function parseConfig(text, file = CONFIG_FILES[0]) {
     throw fail3('declare os t\xFAneis em "tunnels:", um por linha (ex.: web: 3000).');
   }
   const specs = [];
-  const seen = /* @__PURE__ */ new Map();
   for (const pair of tunnels.items) {
     const raw = isScalar(pair.key) ? String(pair.key.value) : "";
     const line = lineAt(pair.key?.range?.[0]);
@@ -282,7 +281,7 @@ function parseConfig(text, file = CONFIG_FILES[0]) {
       const body = pair.value;
       for (const item of body.items) {
         const key = isScalar(item.key) ? String(item.key.value) : "";
-        if (!TUNNEL_KEYS.includes(key)) throw fail3(`chave desconhecida em "${raw}": ${key} (use port, host ou headers)`, line);
+        if (!TUNNEL_KEYS.includes(key)) throw fail3(`chave desconhecida em "${raw}": ${key} (use port, host, headers ou rewrite_redirects)`, line);
       }
       const hostNode = body.get("host", true);
       if (hostNode !== void 0) {
@@ -309,17 +308,15 @@ function parseConfig(text, file = CONFIG_FILES[0]) {
         }
         spec.headers = headers;
       }
-    }
-    const users = seen.get(port) ?? [];
-    const clash = users.find((u) => !u.host || !spec.host || u.host === spec.host);
-    if (clash) {
-      throw fail3(
-        clash.host && clash.host === spec.host ? `a porta ${port} com host ${spec.host} aparece em "${clash.raw}" e em "${raw}"` : `a porta ${port} aparece em "${clash.raw}" e em "${raw}". Para usar a mesma porta, d\xEA um host a cada um.`,
-        line
-      );
+      const rewriteNode = body.get("rewrite_redirects", true);
+      if (rewriteNode !== void 0) {
+        const value = isScalar(rewriteNode) ? rewriteNode.value : void 0;
+        if (typeof value !== "boolean") throw fail3(`rewrite_redirects de "${raw}" deve ser true ou false`, line);
+        if (!spec.host) throw fail3(`rewrite_redirects de "${raw}" s\xF3 vale junto com host:`, line);
+        if (value === false) spec.rewriteRedirects = false;
+      }
     }
     if (specs.some((s) => s.name === name)) throw fail3(`o nome "${raw}" aparece duas vezes`, line);
-    seen.set(port, [...users, { raw, host: spec.host }]);
     specs.push(spec);
   }
   return specs;
@@ -433,6 +430,12 @@ function rewrite(h, route) {
   }
   return out;
 }
+var escapeRe = (s) => s.replace(/[.*+?^${}()|[\]\\]/g, "\\$&");
+function rewriteLocation(location, localHost2, publicHost) {
+  const host = escapeRe(localHost2.replace(/:\d+$/, ""));
+  const re = new RegExp(`https?(://|%3A%2F%2F)${host}(?::\\d+|%3A\\d+)?(?=$|[/?#&]|%2F|%3F|%23|%26)`, "gi");
+  return location.replace(re, (_m, sep) => `https${sep}${publicHost}`);
+}
 function hostOf(req) {
   return (req.headers.host ?? "").replace(/:\d+$/, "").toLowerCase();
 }
@@ -473,6 +476,9 @@ async function startProxy(o) {
       (up) => {
         const resCap = new Capture(TEXT.test(up.headers["content-type"] ?? ""), max);
         let bytes = 0;
+        if (route.host && route.rewriteRedirects !== false && typeof up.headers.location === "string") {
+          up.headers.location = rewriteLocation(up.headers.location, route.host, hostOf(req));
+        }
         res.writeHead(up.statusCode ?? 502, up.statusMessage, up.headers);
         up.on("data", (c) => {
           bytes += c.length;
@@ -690,7 +696,7 @@ var Session = class {
     this.emit();
   }
   blank(spec, adHoc) {
-    return { key: keyOf(spec), name: spec.name, port: spec.port, ...spec.host ? { host: spec.host } : {}, ...spec.headers ? { headers: spec.headers } : {}, url: null, hostname: null, endpointId: null, status: "opening", error: null, adHoc, requests: 0, errors: 0 };
+    return { key: keyOf(spec), name: spec.name, port: spec.port, ...spec.host ? { host: spec.host } : {}, ...spec.headers ? { headers: spec.headers } : {}, ...spec.rewriteRedirects === false ? { rewriteRedirects: false } : {}, url: null, hostname: null, endpointId: null, status: "opening", error: null, adHoc, requests: 0, errors: 0 };
   }
   async open(t, existing, retrying = false) {
     if (this.stopped) return;
@@ -714,7 +720,7 @@ var Session = class {
       t.hostname = res.hostname;
       t.endpointId = res.endpointId;
       t.error = null;
-      this.routes.set(res.hostname.toLowerCase(), { tunnel: t.key, port: t.port, host: t.host, headers: t.headers });
+      this.routes.set(res.hostname.toLowerCase(), { tunnel: t.key, port: t.port, host: t.host, headers: t.headers, rewriteRedirects: t.rewriteRedirects });
       t.status = await isPortListening(t.port) ? "live" : "no-listener";
       this.ensureCloudflared(res.tunnelToken);
       this.emit();
@@ -904,9 +910,9 @@ async function runSession(specs, source, flags) {
   const session = new Session({ api, deviceId: config.deviceId, deviceName: hostname(), cloudflaredPath, source });
   if (wantsUi(flags)) {
     const { runFullscreen } = await import("./fullscreen-5437X7MP.js");
-    process.exit(await runFullscreen(session, specs, "0.4.0"));
+    process.exit(await runFullscreen(session, specs, "0.4.2"));
   }
-  console.log(`${mark()} ${paint("muted", `${"0.4.0"} \xB7 ${source} \xB7 Ctrl+C para encerrar`)}`);
+  console.log(`${mark()} ${paint("muted", `${"0.4.2"} \xB7 ${source} \xB7 Ctrl+C para encerrar`)}`);
   const stopLog = runPlain(session, (l) => console.log(l));
   const stopped = new Promise((resolve) => {
     const onSignal = () => {
@@ -948,11 +954,13 @@ ${paint("signal", "Dica:")} crie um duto.yml com os t\xFAneis do projeto e rode
   const port = parsePort(rawPort);
   const name = parseName(flags.name) ?? null;
   const host = parseHostFlag(flags.host);
-  return runSession([{ name, port, ...host ? { host } : {} }], "linha de comando", flags);
+  const keepRedirects = flags.rewriteRedirects === false;
+  if (keepRedirects && !host) fail2("--no-rewrite-redirects s\xF3 vale junto com --host");
+  return runSession([{ name, port, ...host ? { host } : {}, ...keepRedirects ? { rewriteRedirects: false } : {} }], "linha de comando", flags);
 }
 var cli = cac("duto");
-cli.command("[port]", "Sem porta: abre os t\xFAneis do duto.yml. Com porta: abre um t\xFAnel para ela").option("--name <nome>", "Nome do endere\xE7o fixo (ex.: web \u2192 https://web-<usu\xE1rio>.duto.dev)").option("--host <host>", "Host que o servi\xE7o local recebe no lugar do p\xFAblico (ex.: meuapp.test)").option("--no-ui", "Sem tela cheia: s\xF3 um log das requisi\xE7\xF5es (\xFAtil em scripts)").option("--ui", "For\xE7a a tela cheia (no Windows ela vem desligada)").action((port, opts) => tunnel(port, opts));
-cli.command("http <port>", "O mesmo que duto <porta> (para quem vem do ngrok)").option("--name <nome>", "Nome do endere\xE7o fixo").option("--host <host>", "Host que o servi\xE7o local recebe no lugar do p\xFAblico").option("--no-ui", "Sem tela cheia").action((port, opts) => tunnel(port, opts));
+cli.command("[port]", "Sem porta: abre os t\xFAneis do duto.yml. Com porta: abre um t\xFAnel para ela").option("--name <nome>", "Nome do endere\xE7o fixo (ex.: web \u2192 https://web-<usu\xE1rio>.duto.dev)").option("--host <host>", "Host que o servi\xE7o local recebe no lugar do p\xFAblico (ex.: meuapp.test)").option("--no-rewrite-redirects", "Com --host: n\xE3o troca o host local pelo p\xFAblico nos redirecionamentos").option("--no-ui", "Sem tela cheia: s\xF3 um log das requisi\xE7\xF5es (\xFAtil em scripts)").option("--ui", "For\xE7a a tela cheia (no Windows ela vem desligada)").action((port, opts) => tunnel(port, opts));
+cli.command("http <port>", "O mesmo que duto <porta> (para quem vem do ngrok)").option("--name <nome>", "Nome do endere\xE7o fixo").option("--host <host>", "Host que o servi\xE7o local recebe no lugar do p\xFAblico").option("--no-rewrite-redirects", "Com --host: mant\xE9m os redirecionamentos como o servi\xE7o mandou").option("--no-ui", "Sem tela cheia").action((port, opts) => tunnel(port, opts));
 cli.command("login <token>", "Salva o authtoken (pegue em https://duto.dev)").action(async (token) => {
   try {
     const me = await createApiClient({ baseUrl: apiUrl(), token: String(token) }).me();
@@ -991,7 +999,7 @@ cli.help(
     body: s.body.replace(/^\s*For more info, run any command with the `--help` flag:/m, "  Mais detalhes de um comando: duto <comando> --help").replace("Display this message", "Mostra esta ajuda").replace("Display version number", "Mostra a vers\xE3o")
   }))
 );
-cli.version("0.4.0");
+cli.version("0.4.2");
 try {
   cli.parse(process.argv, { run: false });
   await cli.runMatchedCommand();

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@dutodev/cli",
-  "version": "0.4.0",
+  "version": "0.4.2",
   "description": "Exponha uma porta local em https://<nome>-<usuário>.duto.dev com um comando.",
   "license": "MIT",
   "type": "module",