@montytools/cli 0.1.6 → 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,26 +397,40 @@ 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>.`);
 }
 
 // ── monty dev ──────────────────────────────────────────────────────────────
+// Development mode: vite locally + a Cloudflare quick tunnel registered as
+// the app's DEV channel, so workspace admins see the app live (HMR included)
+// at usemonty.dev while it runs. Data is #dev-sandboxed automatically (vite
+// dev build). The heartbeat doubles as the publish poll: when an owner
+// clicks Publish in the workspace, this process builds + uploads for real.
 async function dev() {
-  const appDir = process.cwd();
-  if (!existsSync(join(appDir, "monty.config.ts"))) {
-    fail("NOT_A_MONTY_APP", "No monty.config.ts here. Run `monty dev` from your app's root directory.");
-  }
+  const appDir = requireAppDir("dev");
   const meta = await compileConfig(appDir);
-  const host = loadConfig()?.host ?? DEFAULT_HOST;
+  const cfg = loadConfig();
+  const host = cfg?.host ?? DEFAULT_HOST;
   // Auto-pick a free port (agents run several apps side by side); an
   // explicit --port is honored strictly.
   const requested = flag("port");
@@ -426,18 +441,173 @@ async function dev() {
     cwd: appDir,
     stdio: ["ignore", "pipe", "inherit"],
   });
+
+  let tunnelChild = null;
+  let hbTimer = null;
+  let publishing = false;
+  let ended = false;
+  const buildFile = join(appDir, ".monty", "build");
+  const buildId = existsSync(buildFile) ? readFileSync(buildFile, "utf8").trim() : undefined;
+
+  async function endSession() {
+    if (ended) return;
+    ended = true;
+    if (hbTimer) clearInterval(hbTimer);
+    try { tunnelChild?.kill(); } catch { /* already gone */ }
+    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),
+        });
+      } catch { /* best effort */ }
+    }
+  }
+
+  async function heartbeat(originUrl) {
+    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 }),
+      });
+      const data = await r.json().catch(() => null);
+      if (!r.ok) {
+        console.log(`dev-session: ${data?.code ?? r.status}${data?.fix ? ` — ${data.fix}` : ""}`);
+        return;
+      }
+      if (data?.publishRequested && !publishing) {
+        publishing = true;
+        console.log("publish: requested from the workspace — building & uploading…");
+        await new Promise((resolve) => {
+          const pub = spawn(process.execPath, [fileURLToPath(import.meta.url), "deploy", "--from-dev"], {
+            cwd: appDir,
+            stdio: ["ignore", "inherit", "inherit"],
+          });
+          pub.on("exit", (code) => {
+            console.log(
+              code === 0
+                ? "publish: done — the workspace now serves the new version (dev session continues)"
+                : "publish: FAILED — fix the errors above, then click Publish again",
+            );
+            resolve(undefined);
+          });
+        });
+        publishing = false;
+      }
+    } catch { /* transient network hiccup — next beat retries */ }
+  }
+
+  async function startDevSession() {
+    if (!cfg?.key) {
+      console.log("dev: not logged in — workspace dev mode disabled (run `monty login`)");
+      return;
+    }
+    let originUrl = `http://localhost:${port}`;
+    if (!rest.includes("--no-tunnel")) {
+      console.log("tunnel: starting (cloudflared quick tunnel)…");
+      const t = await startTunnel(port);
+      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)");
+        }
+      } else {
+        console.log("tunnel: unavailable — dev mode registered on localhost (visible on this machine's browser only)");
+      }
+    }
+    await heartbeat(originUrl);
+    console.log(`workspace: ${host}/apps/${meta.slug} — DEV mode for admins while this runs; click Publish there to ship`);
+    hbTimer = setInterval(() => void heartbeat(originUrl), 30_000);
+  }
+
   let announced = false;
   child.stdout.on("data", (chunk) => {
     const text = chunk.toString();
     process.stdout.write(text);
     if (!announced && /localhost:\d+/.test(text)) {
       announced = true;
-      console.log(`open: ${host}/apps/${meta.slug}?dev=http://localhost:${port}`);
       console.log(`data: sandboxed to "${meta.slug}#dev" (live records untouched)`);
       console.log(`ready: http://localhost:${port}`);
+      void startDevSession();
+    }
+  });
+  child.on("exit", (code) => {
+    void endSession().then(() => process.exit(code ?? 0));
+  });
+  process.on("SIGINT", () => {
+    void endSession().then(() => process.exit(130));
+  });
+  process.on("SIGTERM", () => {
+    void endSession().then(() => process.exit(143));
+  });
+}
+
+
+// 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.
+function startTunnel(port) {
+  return new Promise((resolve) => {
+    let child;
+    try {
+      child = spawn("npx", ["-y", "cloudflared", "tunnel", "--url", `http://localhost:${port}`], {
+        stdio: ["ignore", "pipe", "pipe"],
+      });
+    } catch {
+      return resolve({ child: null, url: null });
     }
+    let settled = false;
+    const timer = setTimeout(() => {
+      if (!settled) {
+        settled = true;
+        resolve({ child, url: null });
+      }
+    }, 45_000);
+    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] });
+      }
+    };
+    child.stdout.on("data", scan);
+    child.stderr.on("data", scan);
+    child.on("exit", () => {
+      if (!settled) {
+        settled = true;
+        clearTimeout(timer);
+        resolve({ child: null, url: null });
+      }
+    });
   });
-  child.on("exit", (code) => process.exit(code ?? 0));
 }
 
 // ── monty add / components / docs ──────────────────────────────────────────
@@ -540,9 +710,9 @@ async function docs() {
 
 // ── monty deploy ───────────────────────────────────────────────────────────
 async function deploy() {
-  const appDir = process.cwd();
-  if (!existsSync(join(appDir, "monty.config.ts"))) {
-    fail("NOT_A_MONTY_APP", "No monty.config.ts here. Run `monty deploy` from your app's root directory.");
+  const appDir = requireAppDir("deploy");
+  if (!rest.includes("--from-dev")) {
+    console.log("note: direct deploy skips workspace review — the usual flow is `monty dev` + the Publish button in the workspace.");
   }
   const config = loadConfig();
   if (!config?.key) {

package/package.json

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

package/skills/monty-build/SKILL.md

@@ -19,9 +19,13 @@ the territory.
 2. **The loop:** `monty create <slug> --name "Name" --icon <lucide-icon>` →
    (if the prompt includes a `build id`, pass it: `--build <id>` — the
    workspace's New app screen tracks your progress live) →
-   `monty install` → edit `monty.config.ts` (zod tables) + `src/routes/` → verify with
-   `monty dev` (localhost:5173, already authenticated, sandboxed data) →
-   `monty deploy`. You are done when deploy prints the URL.
+   `monty install` → edit `monty.config.ts` (zod tables) + `src/routes/` →
+   verify with `monty dev` (auto-port, already authenticated, sandboxed
+   data). **You are done when `monty dev` prints the workspace dev URL and
+   the app works — leave `monty dev` running.** Publishing to the whole
+   workspace is the OWNER'S click (Publish in the workspace menu bar);
+   **never run `monty deploy` yourself** unless the user explicitly asks
+   for a direct production deploy.
 3. **Everything through the CLI.** `monty install`, `monty build`,
    `monty typecheck`, `monty dev`, `monty deploy` — never run vite, tsc,
    pnpm, or npm scripts directly. `monty dev` auto-picks a free port and

package/template/AGENTS.md

@@ -111,9 +111,15 @@ monty dev         # Vite + HMR, auto-picks a free port and prints it
 ```
 
 Headless? Verify with `monty build` then `monty typecheck` (typecheck builds
-first when needed — the build generates `src/routeTree.gen.ts`). `monty
-deploy` runs both itself (it never uploads code that doesn't compile), so
-deploy is self-verifying.
+first when needed — the build generates `src/routeTree.gen.ts`).
+
+**Development vs production:** while `monty dev` runs, the app is live in
+the workspace in DEV mode (workspace admins only, tunneled, `#dev` sandboxed
+data). Shipping to the whole team is the owner's **Publish** click in the
+workspace menu bar — it signals your running `monty dev`, which builds,
+typechecks, and uploads. You are done when the app works in dev mode;
+leave `monty dev` running and let the owner publish. Only run
+`monty deploy` directly if the user explicitly asks.
 
 **Driving your app in a browser (agents):** while `monty dev` runs, opening
 `http://localhost:5173` is ALREADY AUTHENTICATED — no sign-in screen (the dev

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",