flowviant 0.12.0 → 0.14.0

package/bin/lib/config.mjs

@@ -4,7 +4,7 @@ import { readFileSync } from 'node:fs';
 import { join } from 'node:path';
 import { homedir } from 'node:os';
 
-export const VERSION = '0.12.0';
+export const VERSION = '0.14.0';
 
 // Credential stored by `flowviant login` (device auth) — the no-token,
 // no-env-var path. An explicit --fleet flag or FLOWVIANT_FLEET env still wins.

package/bin/lib/live.mjs

@@ -54,6 +54,23 @@ async function registerLiveTarget(intentId, kind, url) {
   }
 }
 
+// The preview's tunnel is going down (replaced by another task's, or the daemon
+// is stopping/restarting) — tell Flowviant to drop the link so it doesn't keep
+// offering a dead URL that 530s. Best-effort + short timeout so teardown is snappy.
+const LIVE_TARGET_CLEAR_URL = FLEET_URL.replace(/\/agents\/?$/, '/live-target-clear');
+function clearLiveTarget(intentId, kind) {
+  return fetch(LIVE_TARGET_CLEAR_URL, {
+    method: 'POST',
+    headers: {
+      Authorization: `Bearer ${FLEET_TOKEN}`,
+      'User-Agent': USER_AGENT,
+      'Content-Type': 'application/json',
+    },
+    signal: AbortSignal.timeout(5_000),
+    body: JSON.stringify({ intentId, kind }),
+  }).catch(() => {});
+}
+
 // Safe mode's curated toolset. Bash is scoped to the specific CLIs the agent
 // needs (git/gh/npm/bun) — NOT bare `Bash`, which would auto-approve arbitrary
 // shell (rm -rf, curl|sh, reading ~/.ssh) and defeat the point of safe mode.
@@ -598,6 +615,7 @@ export async function runLiveWorker({
   // kept up while it's in review (a gated agent parks, so it lives until review
   // resolves). Replaced when the next task finishes; torn down on shutdown.
   let preview = null;
+  let previewTarget = null; // { intentId, kind } of the currently-registered link
   const stopPreview = () => {
     if (preview) {
       try {
@@ -607,6 +625,11 @@ export async function runLiveWorker({
       }
       preview = null;
     }
+    // Drop the app-side link so it stops offering a now-dead tunnel (530).
+    if (previewTarget) {
+      void clearLiveTarget(previewTarget.intentId, previewTarget.kind);
+      previewTarget = null;
+    }
     // Detached preview children (dev server + tunnel) survive process exit, so
     // the daemon's SIGINT teardown needs a handle to stop them — clear it here
     // once they're down.
@@ -645,6 +668,7 @@ export async function runLiveWorker({
     if (preview) {
       onPreview?.(stopPreview); // hand the daemon a stop handle for shutdown
       await registerLiveTarget(intentId, kind, preview.url);
+      previewTarget = { intentId, kind }; // so teardown can drop the link
       ok(`${label} ${c.dim('live preview ready — open the node to drive it in your review')}`);
     }
   };

package/bin/lib/preview.mjs

@@ -201,11 +201,18 @@ async function ensureCloudflared(log) {
 }
 
 const TUNNEL_RE = /https:\/\/[a-z0-9-]+\.trycloudflare\.com/i;
+// Where a dev server announces it bound — "Local: http://localhost:3001/".
+const BIND_RE = /https?:\/\/(?:localhost|127\.0\.0\.1|0\.0\.0\.0):(\d+)/i;
 
 /**
  * Start the dev server + tunnel for one worktree. Resolves { url, kind, stop }
  * once the tunnel URL is captured, or null if it can't come up. stop() kills
  * both the server and the tunnel.
+ *
+ * The tunnel target is the port the server ACTUALLY bound (read from its
+ * output), not the guessed one — vite/vinext/next hop to the next free port when
+ * theirs is taken, and tunneling to the guess then 502s. We fall back to the
+ * configured port only if the server never announces one.
  */
 export async function startPreview({ worktree, kind, cmd, port, log, timeoutMs = 180_000 }) {
   const cf = await ensureCloudflared(log);
@@ -219,11 +226,8 @@ export async function startPreview({ worktree, kind, cmd, port, log, timeoutMs =
     const env = { ...process.env, VINEXT_NO_DEV_LOCK: '1', BROWSER: 'none' };
     // detached so each gets its own process group — `bun run dev` via a shell
     // spawns a grandchild dev server that would otherwise SURVIVE a kill of the
-    // shell, keep port bound, and get silently re-fronted by the NEXT task's
-    // tunnel (reviewer sees the wrong branch). We kill the whole group instead.
-    // stdout/stderr are piped (not ignored) so we can show WHY a preview didn't
-    // come up — a swallowed "another dev server is already running" was a real
-    // dead-end.
+    // shell. We kill the whole group instead. stdout/stderr piped so we can read
+    // the bound port and surface failures.
     const server = spawn(cmd, {
       cwd: worktree,
       shell: true,
@@ -231,21 +235,14 @@ export async function startPreview({ worktree, kind, cmd, port, log, timeoutMs =
       stdio: ['ignore', 'pipe', 'pipe'],
       env,
     });
-    // Ring buffer of the dev server's recent output, surfaced on failure.
+
+    let settled = false;
+    let tunnel = null;
+    let tunnelStarted = false;
     let out = '';
-    const capture = (d) => {
-      out = (out + d.toString()).slice(-4000);
-    };
-    server.stdout.on('data', capture);
-    server.stderr.on('data', capture);
     const tail = () => out.trim().split('\n').slice(-15).join('\n');
-    const tunnel = spawn(cf, ['tunnel', '--url', `http://localhost:${port}`], {
-      detached: true,
-      stdio: ['ignore', 'pipe', 'pipe'],
-    });
-    let settled = false;
     const killGroup = (child) => {
-      if (!child.pid) return;
+      if (!child?.pid) return;
       try {
         process.kill(-child.pid, 'SIGKILL'); // negative pid = the whole group
       } catch {
@@ -260,24 +257,55 @@ export async function startPreview({ worktree, kind, cmd, port, log, timeoutMs =
       killGroup(server);
       killGroup(tunnel);
     };
+    let bindTimer;
+    let timer;
     const finish = (val) => {
       if (settled) return;
       settled = true;
       clearTimeout(timer);
+      clearTimeout(bindTimer);
       if (!val) stop();
       resolve(val);
     };
-    const onData = (d) => {
-      const m = TUNNEL_RE.exec(d.toString());
-      if (m) finish({ url: m[0], kind, stop });
+
+    // Open the tunnel once we know the real port (detected or fallback).
+    const openTunnel = (p) => {
+      if (tunnelStarted || settled) return;
+      tunnelStarted = true;
+      clearTimeout(bindTimer);
+      log?.(`preview: dev server on :${p} — opening the tunnel…`);
+      // --http-host-header localhost: send the origin the Host it expects. Vite
+      // (5+) rejects any Host it doesn't recognize (server.allowedHosts), and the
+      // tunnel's public hostname isn't in that list → "Blocked request". Rewriting
+      // the Host to localhost — what a local browser sends anyway — passes the
+      // check with zero repo config, and is harmless to servers that don't check.
+      tunnel = spawn(
+        cf,
+        ['tunnel', '--url', `http://localhost:${p}`, '--http-host-header', 'localhost'],
+        { detached: true, stdio: ['ignore', 'pipe', 'pipe'] },
+      );
+      const onTunnel = (d) => {
+        const m = TUNNEL_RE.exec(d.toString());
+        if (m) finish({ url: m[0], kind, stop });
+      };
+      tunnel.stdout.on('data', onTunnel);
+      tunnel.stderr.on('data', onTunnel);
+      tunnel.on('error', () => finish(null));
+      tunnel.on('close', () => finish(null));
     };
-    tunnel.stdout.on('data', onData);
-    tunnel.stderr.on('data', onData);
-    tunnel.on('error', () => finish(null));
-    tunnel.on('close', () => finish(null));
-    // The dev server exiting BEFORE the tunnel came up is the loud failure mode
-    // (crash on boot, or a singleton lock refusing to start) — surface its
-    // output instead of a silent timeout.
+
+    const onServer = (d) => {
+      const s = d.toString();
+      out = (out + s).slice(-4000);
+      if (!tunnelStarted) {
+        const m = BIND_RE.exec(s);
+        if (m) openTunnel(Number(m[1]));
+      }
+    };
+    server.stdout.on('data', onServer);
+    server.stderr.on('data', onServer);
+    // A dev server that exits before it's reachable (crash on boot, a singleton
+    // lock refusing to start) is the loud failure mode — surface its output.
     server.on('exit', (code) => {
       if (settled) return;
       log?.(
@@ -287,7 +315,11 @@ export async function startPreview({ worktree, kind, cmd, port, log, timeoutMs =
       );
       finish(null);
     });
-    const timer = setTimeout(() => {
+
+    // If the server never prints a URL we recognize (quiet server), tunnel to the
+    // configured port as a last resort.
+    bindTimer = setTimeout(() => openTunnel(port), 30_000);
+    timer = setTimeout(() => {
       log?.(
         `preview tunnel did not come up in ${Math.round(timeoutMs / 1000)}s — skipping.${
           tail() ? `\n  last dev-server output:\n${tail()}` : ''

package/bin/lib/update.mjs

@@ -110,8 +110,28 @@ export function handleVersionSignal({ latest, min, autoUpdate, safeToUpdate, tea
       }
       return false;
     }
+    // Loop guard: the server can announce a version before it's published. npm is
+    // the source of truth — only install if npm ACTUALLY has something newer than
+    // us, else `npm i -g @latest` reinstalls our own version and we'd re-exec
+    // forever.
+    let published = null;
     try {
-      note(`flowviant ${cur} → ${target}: self-updating…`);
+      published = execFileSync('npm', ['view', 'flowviant', 'version'], {
+        encoding: 'utf8',
+        stdio: ['ignore', 'pipe', 'ignore'],
+      }).trim();
+    } catch {
+      /* offline / npm hiccup — treat as "can't confirm", skip this poll */
+    }
+    if (!published || cmpVersion(published, cur) <= 0) {
+      if (naggedFor !== target) {
+        naggedFor = target;
+        note(`update ${target} announced but npm still serves ${published ?? '?'} — waiting for the publish.`);
+      }
+      return false;
+    }
+    try {
+      note(`flowviant ${cur} → ${published}: self-updating…`);
       installLatest();
       ok('updated — restarting into the new version.');
       reexec(teardown);

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "flowviant",
-  "version": "0.12.0",
+  "version": "0.14.0",
   "description": "Run your own Claude Code as headless build agents for Flowviant — on your own credentials. Claims dispatched work, opens PRs, captures review evidence, and routes questions back to you.",
   "type": "module",
   "bin": {