@dutodev/cli 0.4.4 → 0.4.6

package/README.md

@@ -106,7 +106,7 @@ Com os túneis no ar, o terminal mostra cada túnel (URL, destino local, requisi
 | `tab`, `↑↓` | Alterna entre túneis e requisições e move a seleção |
 | `q` ou Ctrl+C | Fecha os túneis e sai |
 
-Se o túnel está no ar mas nada responde na porta local, quem abrir o endereço no navegador vê uma página do Duto que tenta de novo a cada 3 segundos e volta sozinha quando o serviço sobe. Clientes que não são navegador (`curl`, APIs) recebem a mesma resposta em texto. Em ambos os casos o status é `503` com `Retry-After: 3`.
+Se o túnel está no ar mas nada responde na porta local, quem abrir o endereço no navegador vê uma página do Duto que volta sozinha quando o serviço sobe. Ela espera por uma conexão só (SSE): a CLI checa a porta na sua máquina e avisa a página assim que o serviço responde, sem recarregar de tempos em tempos. Clientes que não são navegador (`curl`, APIs) recebem a mesma resposta em texto. Em ambos os casos o status é `503` com `Retry-After: 3`. Os caminhos `/__duto/…` são reservados para isso e nunca chegam ao seu app.
 
 Fora de um terminal interativo (pipe, CI) ou com `--no-ui`, a CLI imprime um log simples. No Windows a tela cheia vem desligada; use `--ui` para tentar.
 

package/dist/{fullscreen-5437X7MP.js → fullscreen-EPWB53EP.js}

@@ -373,6 +373,7 @@ async function withFullscreen(stdout, run2) {
   const onSignal = () => ac.abort();
   process.on("SIGINT", onSignal);
   process.on("SIGTERM", onSignal);
+  process.on("SIGHUP", onSignal);
   process.once("exit", restore);
   stdout.write(ENTER_SCREEN);
   try {
@@ -380,6 +381,7 @@ async function withFullscreen(stdout, run2) {
   } finally {
     process.off("SIGINT", onSignal);
     process.off("SIGTERM", onSignal);
+    process.off("SIGHUP", onSignal);
     process.off("exit", restore);
     restore();
   }

package/dist/index.js

@@ -33,7 +33,7 @@ var fail = (msg) => `${paint("err", "\u2716", process.stderr)} ${msg}`;
 
 // src/index.ts
 import { hostname } from "os";
-import { relative } from "path";
+import { join as join5, relative } from "path";
 import cac from "cac";
 
 // src/api.ts
@@ -368,6 +368,24 @@ var esc = (s) => s.replace(/[&<>"']/g, (c) => ({ "&": "&amp;", "<": "&lt;", ">":
 function wantsHtml(accept) {
   return /\btext\/html\b/i.test(accept ?? "");
 }
+var WAIT_SCRIPT = `
+<script>
+(function () {
+  var delay = 3000;
+  function poll() {
+    setTimeout(function () {
+      fetch(location.href, { method: "HEAD", cache: "no-store" })
+        .then(function (r) { if (r.status !== 503) location.reload(); else again(); })
+        .catch(again);
+    }, delay);
+  }
+  function again() { delay = Math.min(delay * 2, 30000); poll(); }
+  if (!window.EventSource) return poll();
+  var fails = 0, es = new EventSource("/__duto/espera");
+  es.addEventListener("up", function () { es.close(); location.reload(); });
+  es.onerror = function () { if (++fails >= 3) { es.close(); poll(); } };
+})();
+</script>`;
 function unavailablePage(o) {
   const tunnel2 = esc(o.tunnel);
   const local = `localhost:${o.port}`;
@@ -376,7 +394,7 @@ function unavailablePage(o) {
 <head>
 <meta charset="utf-8">
 <meta name="viewport" content="width=device-width, initial-scale=1">
-${o.retry ? '<meta http-equiv="refresh" content="3">\n' : ""}<meta name="robots" content="noindex">
+<meta name="robots" content="noindex">
 <title>Nada respondendo em ${local} \xB7 duto</title>
 <style>
 :root{--bg:#f6f6f3;--fg:#0f1110;--muted:#5f6360;--line:#dcddd8;--card:#fff;--signal:#2dd4bf;--signal-text:#0f766e}
@@ -400,8 +418,8 @@ h1 code{font-size:.86em;font-weight:600}
 <h1>Nada respondendo em <code>${local}</code></h1>
 <p>O t\xFAnel <code>${tunnel2}</code> est\xE1 no ar, mas o servi\xE7o local n\xE3o respondeu. Suba o servidor na m\xE1quina que abriu o t\xFAnel.</p>
 <p>Se voc\xEA s\xF3 recebeu este link, avise quem o enviou.</p>
-<div class="retry">${o.retry ? "<b>Tentando de novo a cada 3 s.</b> A p\xE1gina volta sozinha quando o servi\xE7o responder." : "Recarregue a p\xE1gina quando o servi\xE7o estiver no ar."}</div>
-</main>
+<div class="retry">${o.retry ? `<b>Aguardando o servi\xE7o.</b> A p\xE1gina volta sozinha quando ele responder.<noscript> Recarregue quando o servi\xE7o estiver no ar.</noscript>` : "Recarregue a p\xE1gina quando o servi\xE7o estiver no ar."}</div>
+</main>${o.retry ? WAIT_SCRIPT : ""}
 </body>
 </html>
 `;
@@ -485,16 +503,64 @@ function rewriteLocation(location, localHost2, publicHost) {
 function hostOf(req) {
   return (req.headers.host ?? "").replace(/:\d+$/, "").toLowerCase();
 }
+var DUTO_PREFIX = "/__duto/";
+var WAIT_PATH = "/__duto/espera";
+var WAIT_MAX_MS = 10 * 6e4;
+async function isUp(port) {
+  return await probe("127.0.0.1", port) || await probe("::1", port);
+}
+function waitForService(res, port, checkMs, pingMs) {
+  res.writeHead(200, { "content-type": "text/event-stream", "cache-control": "no-store", "x-accel-buffering": "no" });
+  res.write(": duto\n\n");
+  let busy = false;
+  const stop = () => {
+    clearInterval(check);
+    clearInterval(ping);
+    clearTimeout(limit);
+  };
+  const check = setInterval(async () => {
+    if (busy) return;
+    busy = true;
+    const up = await isUp(port);
+    busy = false;
+    if (up && !res.writableEnded) {
+      stop();
+      res.end("event: up\ndata: 1\n\n");
+    }
+  }, checkMs);
+  const ping = setInterval(() => res.write(": ping\n\n"), pingMs);
+  const limit = setTimeout(() => {
+    stop();
+    res.end();
+  }, WAIT_MAX_MS);
+  res.on("close", stop);
+}
 async function startProxy(o) {
   const max = o.maxBody ?? MAX_BODY;
   let nextId = 1;
+  const routeWaitMs = o.routeWaitMs ?? 3e3;
+  async function routeFor(req) {
+    const host = hostOf(req);
+    for (let waited = 0; ; waited += 50) {
+      const route = o.routes.get(host);
+      if (route || waited >= routeWaitMs) return route;
+      await new Promise((r) => setTimeout(r, 50));
+    }
+  }
   const server = createServer(async (req, res) => {
-    const route = o.routes.get(hostOf(req));
+    req.pause();
+    const route = await routeFor(req);
     if (!route) {
       res.writeHead(404, { "content-type": "text/plain; charset=utf-8" });
       res.end("T\xFAnel n\xE3o encontrado nesta sess\xE3o");
       return;
     }
+    if ((req.url ?? "").startsWith(DUTO_PREFIX)) {
+      if (req.url === WAIT_PATH && req.method === "GET") return waitForService(res, route.port, o.waitCheckMs ?? 1e3, o.waitPingMs ?? 25e3);
+      res.writeHead(404, { "content-type": "text/plain; charset=utf-8" });
+      res.end("Rota reservada do Duto");
+      return;
+    }
     const id = nextId++;
     const started = Date.now();
     const headers = rewrite(req.headers, route);
@@ -563,7 +629,7 @@ async function startProxy(o) {
   });
   server.on("upgrade", async (req, client, head) => {
     client.on("error", () => client.destroy());
-    const route = o.routes.get(hostOf(req));
+    const route = await routeFor(req);
     if (!route) return void client.end("HTTP/1.1 404 Not Found\r\nConnection: close\r\n\r\n");
     const id = nextId++;
     const started = Date.now();
@@ -628,6 +694,74 @@ async function startProxy(o) {
   };
 }
 
+// src/session/orphans.ts
+import { spawnSync } from "child_process";
+import { existsSync as existsSync4, mkdirSync as mkdirSync3, readdirSync, readFileSync as readFileSync3, rmSync as rmSync2, writeFileSync as writeFileSync3 } from "fs";
+import { join as join4 } from "path";
+var fileOf = (dir, cfPid) => join4(dir, `cloudflared-${cfPid}.json`);
+function recordCloudflared(dir, cfPid, sessionPid = process.pid) {
+  try {
+    mkdirSync3(dir, { recursive: true });
+    writeFileSync3(fileOf(dir, cfPid), JSON.stringify({ sessionPid, cfPid, at: Date.now() }));
+  } catch {
+  }
+}
+function forgetCloudflared(dir, cfPid) {
+  rmSync2(fileOf(dir, cfPid), { force: true });
+}
+var realProc = {
+  alive(pid) {
+    try {
+      process.kill(pid, 0);
+      return true;
+    } catch (err) {
+      return err.code === "EPERM";
+    }
+  },
+  isCloudflared(pid) {
+    try {
+      if (process.platform === "linux") return readFileSync3(`/proc/${pid}/cmdline`, "utf8").includes("cloudflared");
+      if (process.platform === "darwin") return spawnSync("ps", ["-p", String(pid), "-o", "command="], { encoding: "utf8" }).stdout.includes("cloudflared");
+    } catch {
+      return false;
+    }
+    return false;
+  },
+  kill(pid) {
+    try {
+      process.kill(pid, "SIGTERM");
+    } catch {
+    }
+  }
+};
+function reapOrphans(dir, proc = realProc) {
+  if (!existsSync4(dir)) return 0;
+  let killed = 0;
+  for (const name of readdirSync(dir)) {
+    if (!/^cloudflared-\d+\.json$/.test(name)) continue;
+    const path = join4(dir, name);
+    let rec;
+    try {
+      rec = JSON.parse(readFileSync3(path, "utf8"));
+    } catch {
+      rmSync2(path, { force: true });
+      continue;
+    }
+    const { sessionPid, cfPid } = rec;
+    if (typeof sessionPid !== "number" || typeof cfPid !== "number") {
+      rmSync2(path, { force: true });
+      continue;
+    }
+    if (proc.alive(sessionPid)) continue;
+    if (proc.alive(cfPid) && proc.isCloudflared(cfPid)) {
+      proc.kill(cfPid);
+      killed++;
+    }
+    rmSync2(path, { force: true });
+  }
+  return killed;
+}
+
 // src/session/records.ts
 var RecordStore = class {
   constructor(max = 500) {
@@ -709,6 +843,7 @@ var Session = class {
   }
   /** Abre os túneis em sequência; falhas ficam no estado e não interrompem os outros. */
   async start(specs) {
+    if (this.o.runDir) reapOrphans(this.o.runDir);
     this.proxy = await startProxy({ routes: this.routes, store: this.records });
     this.tunnels = specs.map((s) => this.blank(s, false));
     this.emit();
@@ -797,6 +932,11 @@ var Session = class {
       stdio: ["ignore", "ignore", "pipe"]
     });
     this.child = c;
+    const runDir = this.o.runDir;
+    if (runDir && c.pid) {
+      recordCloudflared(runDir, c.pid);
+      c.once("exit", () => forgetCloudflared(runDir, c.pid));
+    }
     let buf = "";
     c.stderr?.on("data", (chunk) => {
       if (c !== this.child) return;
@@ -954,21 +1094,23 @@ async function runSession(specs, source, flags) {
   } catch (err) {
     fail2(err instanceof Error ? err.message : String(err));
   }
-  const session = new Session({ api, deviceId: config.deviceId, deviceName: hostname(), cloudflaredPath, source });
+  const session = new Session({ api, deviceId: config.deviceId, deviceName: hostname(), cloudflaredPath, source, runDir: join5(dutoHome(), "run") });
   if (wantsUi(flags)) {
-    const { runFullscreen } = await import("./fullscreen-5437X7MP.js");
-    process.exit(await runFullscreen(session, specs, "0.4.4"));
+    const { runFullscreen } = await import("./fullscreen-EPWB53EP.js");
+    process.exit(await runFullscreen(session, specs, "0.4.6"));
   }
-  console.log(`${mark()} ${paint("muted", `${"0.4.4"} \xB7 ${source} \xB7 Ctrl+C para encerrar`)}`);
+  console.log(`${mark()} ${paint("muted", `${"0.4.6"} \xB7 ${source} \xB7 Ctrl+C para encerrar`)}`);
   const stopLog = runPlain(session, (l) => console.log(l));
   const stopped = new Promise((resolve) => {
     const onSignal = () => {
       process.off("SIGINT", onSignal);
       process.off("SIGTERM", onSignal);
+      process.off("SIGHUP", onSignal);
       resolve();
     };
     process.on("SIGINT", onSignal);
     process.on("SIGTERM", onSignal);
+    process.on("SIGHUP", onSignal);
   });
   await Promise.race([session.start(specs), stopped]);
   await stopped;
@@ -1046,7 +1188,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.4");
+cli.version("0.4.6");
 try {
   cli.parse(process.argv, { run: false });
   await cli.runMatchedCommand();

package/package.json

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