@montytools/cli 0.2.4 → 0.2.6

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");
@@ -489,35 +491,69 @@ async function dev() {
   let ended = false;
   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
+  // to monty.config.ts are re-compiled (softly) so schema changes reach the
+  // platform within one heartbeat. Publish owns the PROD schema.
+  let currentMeta = meta;
+  const configPath = join(appDir, "monty.config.ts");
+  let configMtime = statSync(configPath).mtimeMs;
+
+  async function refreshSchemaIfChanged() {
+    try {
+      const m = statSync(configPath).mtimeMs;
+      if (m === configMtime) return;
+      configMtime = m;
+      const fresh = await compileConfig(appDir, { soft: true });
+      if (fresh) {
+        currentMeta = fresh;
+        console.log(
+          `schema: monty.config.ts changed — dev schema updated (${Object.keys(fresh.schemaJson.tables).length} tables)`,
+        );
+      }
+    } 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),
+          signal: AbortSignal.timeout(timeoutMs),
         });
       } catch { /* best effort */ }
     }
   }
 
+  async function endSession() {
+    if (ended) return;
+    ended = true;
+    if (hbTimer) clearInterval(hbTimer);
+    try { tunnelChild?.kill(); } catch { /* already gone */ }
+    await clearDevSession();
+  }
+
   async function heartbeat(originUrl) {
+    await refreshSchemaIfChanged();
     try {
       const r = await fetch(`${host}/api/dev-session`, {
         method: "POST",
         headers: { authorization: `Bearer ${cfg.key}`, "content-type": "application/json" },
-        body: JSON.stringify({ slug: meta.slug, tunnelUrl: originUrl, name: meta.name, icon: meta.icon, buildId }),
+        body: JSON.stringify({
+          slug: meta.slug,
+          tunnelUrl: originUrl,
+          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) {
         console.log(`dev-session: ${data?.code ?? r.status}${data?.fix ? ` — ${data.fix}` : ""}`);
-        return;
+        return false;
       }
       if (data?.publishRequested && !publishing) {
         publishing = true;
@@ -538,7 +574,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() {
@@ -546,27 +586,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);
+    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;
@@ -600,6 +673,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);
@@ -629,7 +703,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 {
@@ -646,12 +720,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);
@@ -819,7 +900,7 @@ async function deploy() {
   console.log(`deployed: ${body.url} (version ${body.version})`);
 }
 
-async function compileConfig(appDir) {
+async function compileConfig(appDir, { soft = false } = {}) {
   const { build } = await import("esbuild");
   const tmpDir = join(appDir, ".monty");
   mkdirSync(tmpDir, { recursive: true });
@@ -843,11 +924,19 @@ async function compileConfig(appDir) {
     });
     const result = spawnSync(process.execPath, [out], { encoding: "utf8" });
     if (result.status !== 0) {
+      if (soft) {
+        console.log("schema: monty.config.ts doesn't compile right now — keeping the last good schema");
+        return null;
+      }
       fail("CONFIG_COMPILE_FAILED", `monty.config.ts threw while loading:\n${result.stderr}\nFix the config (it must only call defineApp with zod tables).`);
     }
     return JSON.parse(result.stdout);
   } catch (e) {
     if (e?.errors) {
+      if (soft) {
+        console.log("schema: monty.config.ts doesn't compile right now — keeping the last good schema");
+        return null;
+      }
       fail("CONFIG_COMPILE_FAILED", `esbuild could not bundle monty.config.ts: ${e.errors[0]?.text ?? e.message}`);
     }
     throw e;

package/package.json

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