@montytools/cli 0.2.0 → 0.2.1

package/bin/monty.mjs

@@ -7,6 +7,7 @@ import { spawn, spawnSync } from "node:child_process";
 import { randomBytes } from "node:crypto";
 import { cpSync, mkdirSync, readFileSync, rmSync, writeFileSync, readdirSync, statSync, existsSync } from "node:fs";
 import { createServer } from "node:http";
+import { connect as netConnect } from "node:net";
 import { homedir } from "node:os";
 import { basename, dirname, join, relative } from "node:path";
 import { fileURLToPath } from "node:url";
@@ -396,14 +397,25 @@ function typecheckApp() {
 }
 
 
+// Probe by CONNECTING (not binding): SO_REUSEADDR lets a wildcard bind
+// "succeed" on macOS even when a specific loopback address holds the port,
+// so bind-probes lie. A successful connect = someone is listening.
+function portTaken(host, port) {
+  return new Promise((resolve) => {
+    const sock = netConnect({ host, port });
+    const done = (taken) => {
+      sock.destroy();
+      resolve(taken);
+    };
+    sock.once("connect", () => done(true));
+    sock.once("error", () => done(false));
+    sock.setTimeout(400, () => done(false));
+  });
+}
+
 async function freePort(start) {
   for (let p = start; p < start + 50; p++) {
-    const ok = await new Promise((resolve) => {
-      const probe = createServer();
-      probe.once("error", () => resolve(false));
-      probe.listen(p, "127.0.0.1", () => probe.close(() => resolve(true)));
-    });
-    if (ok) return p;
+    if (!(await portTaken("127.0.0.1", p)) && !(await portTaken("::1", p))) return p;
   }
   fail("NO_FREE_PORT", `No free port between ${start} and ${start + 49}. Pass --port <n>.`);
 }
@@ -499,8 +511,14 @@ async function dev() {
       const t = await startTunnel(port);
       tunnelChild = t.child;
       if (t.url) {
-        originUrl = t.url;
         console.log(`tunnel: ${t.url}`);
+        console.log("tunnel: waiting for DNS to go live (prevents cached failures in your browser)…");
+        if (await waitForDns(t.url.replace("https://", ""))) {
+          originUrl = t.url;
+          console.log("tunnel: DNS live");
+        } else {
+          console.log("tunnel: DNS never propagated — dev mode registered on localhost (visible on this machine's browser only)");
+        }
       } else {
         console.log("tunnel: unavailable — dev mode registered on localhost (visible on this machine's browser only)");
       }
@@ -532,6 +550,26 @@ async function dev() {
   });
 }
 
+
+// trycloudflare DNS takes up to a couple of minutes to propagate. Registering
+// the origin before it resolves would make admins' browsers cache NXDOMAIN
+// (macOS negative cache ≈ 30 min of a broken iframe) — so gate on DNS via
+// DoH, which never touches the local resolver.
+async function waitForDns(hostname) {
+  for (let i = 0; i < 36; i++) {
+    try {
+      const r = await fetch(
+        `https://cloudflare-dns.com/dns-query?name=${hostname}&type=A`,
+        { headers: { accept: "application/dns-json" } },
+      );
+      const d = await r.json();
+      if (Array.isArray(d.Answer) && d.Answer.some((a) => a.type === 1)) return true;
+    } catch { /* transient — retry */ }
+    await new Promise((res) => setTimeout(res, 5000));
+  }
+  return false;
+}
+
 // Cloudflare quick tunnel via the cloudflared npm wrapper (downloads the
 // binary on first use). Resolves with the public URL, or null on failure —
 // dev mode then falls back to localhost-only registration.

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@montytools/cli",
-  "version": "0.2.0",
+  "version": "0.2.1",
   "type": "module",
   "bin": {
     "monty": "./bin/monty.mjs"

package/template/package.json

@@ -10,7 +10,7 @@
   },
   "dependencies": {
     "@fontsource-variable/roboto": "^5.2.10",
-    "@montytools/sdk": "^0.1.0",
+    "@montytools/sdk": "^0.1.1",
     "@tanstack/react-router": "1.170.17",
     "class-variance-authority": "^0.7.1",
     "clsx": "^2.1.1",