@montytools/cli 0.2.5 → 0.2.7

package/bin/monty.mjs

@@ -17,6 +17,8 @@ import { CATALOG, REGISTRIES } from "./catalog.mjs";
 const CONFIG_DIR = join(homedir(), ".monty");
 const CONFIG_PATH = join(CONFIG_DIR, "config.json");
 const DEFAULT_HOST = "https://usemonty.dev";
+const DEV_SESSION_HEARTBEAT_MS = 30_000;
+const DEV_SESSION_REQUEST_TIMEOUT_MS = 10_000;
 // Every app's source lives in one predictable place. `monty create` stamps
 // here by default (override with --dir) and `monty login` provisions it.
 const MONTY_HOME = join(homedir(), "Monty");
@@ -487,6 +489,7 @@ async function dev() {
   let hbTimer = null;
   let publishing = false;
   let ended = false;
+  const sessionId = `dev_${randomBytes(16).toString("hex")}`;
   const buildFile = join(appDir, ".monty", "build");
   const buildId = existsSync(buildFile) ? readFileSync(buildFile, "utf8").trim() : undefined;
   // The DEV schema channel: heartbeats carry the compiled schema, and edits
@@ -511,24 +514,38 @@ async function dev() {
     } catch { /* transient fs hiccup — next beat retries */ }
   }
 
-  async function endSession() {
-    if (ended) return;
-    ended = true;
-    if (hbTimer) clearInterval(hbTimer);
-    try { tunnelChild?.kill(); } catch { /* already gone */ }
+  async function clearDevSession(timeoutMs = 2000) {
     if (cfg?.key) {
       try {
         await fetch(`${host}/api/dev-session`, {
           method: "POST",
           headers: { authorization: `Bearer ${cfg.key}`, "content-type": "application/json" },
-          body: JSON.stringify({ slug: meta.slug, end: true }),
-          signal: AbortSignal.timeout(2000),
+          body: JSON.stringify({ slug: meta.slug, sessionId, end: true }),
+          signal: AbortSignal.timeout(timeoutMs),
         });
       } catch { /* best effort */ }
     }
   }
 
-  async function heartbeat(originUrl) {
+  async function endSession() {
+    if (ended) return;
+    ended = true;
+    if (hbTimer) clearInterval(hbTimer);
+    try { tunnelChild?.kill(); } catch { /* already gone */ }
+    await clearDevSession();
+  }
+
+  function stopSuperseded(fix) {
+    if (ended) return;
+    ended = true;
+    if (hbTimer) clearInterval(hbTimer);
+    try { tunnelChild?.kill(); } catch { /* already gone */ }
+    try { child.kill(); } catch { /* already gone */ }
+    console.log(`dev-session: superseded — ${fix}`);
+    setTimeout(() => process.exit(0), 50);
+  }
+
+  async function heartbeat(originUrl, { claim = false } = {}) {
     await refreshSchemaIfChanged();
     try {
       const r = await fetch(`${host}/api/dev-session`, {
@@ -537,16 +554,23 @@ async function dev() {
         body: JSON.stringify({
           slug: meta.slug,
           tunnelUrl: originUrl,
+          sessionId,
+          claim,
           name: currentMeta.name,
           icon: currentMeta.icon,
           buildId,
           schemaJson: currentMeta.schemaJson,
         }),
+        signal: AbortSignal.timeout(DEV_SESSION_REQUEST_TIMEOUT_MS),
       });
       const data = await r.json().catch(() => null);
       if (!r.ok) {
+        if (data?.code === "DEV_SESSION_SUPERSEDED") {
+          stopSuperseded(data.fix ?? "A newer `monty dev` session is active for this app.");
+          return false;
+        }
         console.log(`dev-session: ${data?.code ?? r.status}${data?.fix ? ` — ${data.fix}` : ""}`);
-        return;
+        return false;
       }
       if (data?.publishRequested && !publishing) {
         publishing = true;
@@ -567,7 +591,11 @@ async function dev() {
         });
         publishing = false;
       }
-    } catch { /* transient network hiccup — next beat retries */ }
+      return true;
+    } catch {
+      console.log("dev-session: heartbeat failed — retrying on the next beat");
+      return false;
+    }
   }
 
   async function startDevSession() {
@@ -575,27 +603,60 @@ async function dev() {
       console.log("dev: not logged in — workspace dev mode disabled (run `monty login`)");
       return;
     }
+    await clearDevSession();
     let originUrl = `http://localhost:${port}`;
+    let tunnelUpdate = Promise.resolve();
+    let tunnelVersion = 0;
+    async function activateTunnelUrl(url, { initial = false } = {}) {
+      const version = ++tunnelVersion;
+      if (!initial) {
+        console.log(`tunnel: changed to ${url}`);
+        await clearDevSession();
+      }
+      console.log("tunnel: waiting for DNS to go live (prevents cached failures in your browser)…");
+      const dnsLive = await waitForDns(url.replace("https://", ""));
+      if (ended || version !== tunnelVersion) return "superseded";
+      if (!dnsLive) {
+        if (initial) {
+          console.log("tunnel: DNS never propagated — dev mode registered on localhost (visible on this machine's browser only)");
+        } else {
+          console.log("tunnel: DNS never propagated for the new URL — keeping Studio offline until the next tunnel URL");
+        }
+        return "failed";
+      }
+      originUrl = url;
+      console.log(initial ? "tunnel: DNS live" : "tunnel: DNS live; Studio URL updated");
+      if (!initial && !(await heartbeat(originUrl))) {
+        console.log("dev-session: Studio still has no registered tunnel; the next heartbeat will retry");
+      }
+      return "activated";
+    }
+    const registerTunnelUrl = (url) => {
+      tunnelUpdate = tunnelUpdate.then(async () => {
+        if (ended || url === originUrl) return;
+        await activateTunnelUrl(url);
+      }).catch(() => {
+        console.log("tunnel: URL update failed — waiting for the next tunnel URL");
+      });
+    };
     if (!rest.includes("--no-tunnel")) {
       console.log("tunnel: starting (cloudflared quick tunnel)…");
-      const t = await startTunnel(port);
+      const t = await startTunnel(port, registerTunnelUrl);
       tunnelChild = t.child;
       if (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)");
-        }
+        await activateTunnelUrl(t.url, { initial: true });
       } else {
         console.log("tunnel: unavailable — dev mode registered on localhost (visible on this machine's browser only)");
       }
     }
-    await heartbeat(originUrl);
-    console.log(`studio: ${host}/studio/${meta.slug} — your app is live there while this runs; click Publish to ship`);
-    hbTimer = setInterval(() => void heartbeat(originUrl), 30_000);
+    const registered = await heartbeat(originUrl, { claim: true });
+    console.log(
+      registered
+        ? `studio: ${host}/studio/${meta.slug} — your app is live there while this runs; click Publish to ship`
+        : `studio: waiting for ${host}/api/dev-session — leave this running; the next heartbeat will retry`,
+    );
+    hbTimer = setInterval(() => void heartbeat(originUrl), DEV_SESSION_HEARTBEAT_MS);
   }
 
   let announced = false;
@@ -629,6 +690,7 @@ async function resolvesVia(dohBase, hostname) {
   try {
     const r = await fetch(`${dohBase}?name=${hostname}&type=A`, {
       headers: { accept: "application/dns-json" },
+      signal: AbortSignal.timeout(3000),
     });
     const d = await r.json();
     return Array.isArray(d.Answer) && d.Answer.some((a) => a.type === 1);
@@ -658,7 +720,7 @@ async function waitForDns(hostname) {
 // 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.
-function startTunnel(port) {
+function startTunnel(port, onUrlChange) {
   return new Promise((resolve) => {
     let child;
     try {
@@ -675,12 +737,19 @@ function startTunnel(port) {
         resolve({ child, url: null });
       }
     }, 45_000);
+    let currentUrl = null;
     const scan = (chunk) => {
-      const m = /https:\/\/[a-z0-9-]+\.trycloudflare\.com/.exec(String(chunk));
-      if (m && !settled) {
-        settled = true;
-        clearTimeout(timer);
-        resolve({ child, url: m[0] });
+      const urls = String(chunk).match(/https:\/\/[a-z0-9-]+\.trycloudflare\.com/g) ?? [];
+      for (const url of urls) {
+        if (url === currentUrl) continue;
+        currentUrl = url;
+        if (!settled) {
+          settled = true;
+          clearTimeout(timer);
+          resolve({ child, url });
+        } else {
+          onUrlChange?.(url);
+        }
       }
     };
     child.stdout.on("data", scan);

package/package.json

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