flowviant 0.9.0 → 0.10.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.9.0';
+export const VERSION = '0.10.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/fleet.mjs

@@ -5,7 +5,7 @@
  * MCP token, and only spawns Claude when the server says an agent has work.
  */
 
-import { mkdirSync, existsSync } from 'node:fs';
+import { mkdirSync, existsSync, rmSync } from 'node:fs';
 import { execFileSync } from 'node:child_process';
 import { createHash } from 'node:crypto';
 import { homedir } from 'node:os';
@@ -23,6 +23,16 @@ import {
   REFRESH_BEFORE_SECONDS,
   LIVE,
 } from './config.mjs';
+import {
+  git,
+  resetWorktree,
+  repoRootOrDie,
+  detectBaseRef,
+  originSlug,
+  isValidPrUrl,
+  isValidBranch,
+  isSafePathSegment,
+} from './git.mjs';
 import { c, LABEL_COLORS, info, note, ok, warn, fail } from './ui.mjs';
 import {
   sleep,
@@ -34,7 +44,6 @@ import {
   SINGLE_KICKOFF,
   SINGLE_RESUME,
 } from './claude.mjs';
-import { git, repoRootOrDie, detectBaseRef, resetWorktree } from './git.mjs';
 import { runLiveWorker } from './live.mjs';
 import { preflight } from './preflight.mjs';
 
@@ -45,6 +54,7 @@ async function fetchRoster(haveIds) {
   // Cloudflare Bot Fight Mode (403). A descriptive product UA passes.
   const res = await fetch(url, {
     headers: { Authorization: `Bearer ${FLEET_TOKEN}`, 'User-Agent': USER_AGENT },
+    signal: AbortSignal.timeout(30_000), // a black-holed poll must not stall the loop
   });
   if (res.status === 401 || res.status === 403) {
     // Fleet credential revoked/expired — retrying can't recover; signal exit.
@@ -54,7 +64,20 @@ async function fetchRoster(haveIds) {
   }
   if (!res.ok) throw new Error(`fleet poll failed (${res.status})`);
   const body = await res.json();
-  return body.data; // { mcpUrl, leaseTtlSeconds, agents: [{agentId,name,token,reviewGate,hasWork}] }
+  // Validate the shape here so a malformed 200 (deploy hiccup, error envelope)
+  // throws a NORMAL retryable error inside the loop's try/catch, instead of a
+  // `roster.agents.map` TypeError escaping to top-level and killing the daemon.
+  const data = body?.data;
+  if (!data || !Array.isArray(data.agents)) {
+    throw new Error('fleet poll returned an unexpected shape');
+  }
+  // Drop roster agents with an unsafe id BEFORE they're used as a path segment.
+  data.agents = data.agents.filter((a) => {
+    if (isSafePathSegment(a?.agentId)) return true;
+    warn(`ignoring roster agent with an invalid id: ${JSON.stringify(a?.agentId)}`);
+    return false;
+  });
+  return data; // { mcpUrl, leaseTtlSeconds, agents: [{agentId,name,token,reviewGate,hasWork}] }
 }
 
 // One roster agent's loop: persistent worktree, one intent per turn, reset to
@@ -186,6 +209,14 @@ export async function runFleetDaemon() {
       } catch {
         /* best-effort */
       }
+      // Stop the detached preview (dev server + cloudflared tunnel) — it's its
+      // own process group and survives our exit, otherwise leaking a port-bound
+      // server + a live tunnel serving a stale branch until reboot.
+      try {
+        w.state.stopPreview?.();
+      } catch {
+        /* best-effort */
+      }
     }
   };
   process.on('SIGINT', () => {
@@ -210,6 +241,7 @@ export async function runFleetDaemon() {
           'User-Agent': USER_AGENT,
           'Content-Type': 'application/json',
         },
+        signal: AbortSignal.timeout(30_000),
         body: JSON.stringify(body),
       });
     } catch {
@@ -225,6 +257,18 @@ export async function runFleetDaemon() {
           note(`${c.cyan('merge')} ${c.dim(`— ${job.title}`)}`);
           let merged = false;
           let failedReason = null; // permanent — tell the thread, clear the flag
+          // Refuse a PR URL that isn't an https github.com PR in THIS repo — a
+          // bad/hostile server must not merge a PR in another repo the user's
+          // gh can write to (and a leading '-' would be a gh flag).
+          if (!isValidPrUrl(job.prUrl, originSlug(repoRoot))) {
+            mergeAttempts.delete(job.id);
+            await reportMergeOutcome(MERGE_FAILED_URL, {
+              intentId: job.id,
+              message: 'refused: PR URL is not a pull request in this repository',
+            });
+            warn(`merge REFUSED for "${job.title}": untrusted PR URL ${String(job.prUrl)}`);
+            return;
+          }
           try {
             execFileSync('gh', ['pr', 'merge', job.prUrl, '--squash', '--delete-branch'], {
               cwd: repoRoot,
@@ -234,8 +278,13 @@ export async function runFleetDaemon() {
           } catch (e) {
             const err = e.stderr?.toString?.() || e.message || '';
             const line = err.split('\n')[0] || 'gh pr merge failed';
-            if (/already merged|not open|closed/i.test(err)) merged = true;
-            else if (/conflict|not mergeable|CONFLICTING/i.test(err)) {
+            // Only "already merged" is a real success; a CLOSED-without-merge PR
+            // also matches "not open"/"closed" but nothing landed on main —
+            // report it as a failure so the thread learns the truth.
+            if (/already merged/i.test(err)) merged = true;
+            else if (/not open|closed/i.test(err)) {
+              failedReason = 'the PR was closed without merging';
+            } else if (/conflict|not mergeable|CONFLICTING/i.test(err)) {
               // Permanent until a human/agent acts — don't spin on it.
               failedReason = `merge conflict with ${baseRef} — the branch needs a rebase`;
             } else {
@@ -279,7 +328,10 @@ export async function runFleetDaemon() {
       (async () => {
         try {
           note(`${c.cyan('cleanup')} ${c.dim(`— ${job.title} (restarted)`)}`);
-          if (job.prUrl) {
+          // Same guards as merge: only close a PR in THIS repo, only delete a
+          // well-formed non-base branch. A bad server must not close a stranger's
+          // PR or delete `main` (`--delete` with `main`) via a cleanup job.
+          if (job.prUrl && isValidPrUrl(job.prUrl, originSlug(repoRoot))) {
             try {
               execFileSync(
                 'gh',
@@ -299,15 +351,18 @@ export async function runFleetDaemon() {
               const err = e.stderr?.toString?.() || e.message || '';
               warn(`cleanup for "${job.title}": ${err.split('\n')[0] || 'gh pr close failed'}`);
             }
-          } else if (job.branch) {
+          } else if (job.branch && isValidBranch(job.branch, repoRoot, baseRef)) {
             try {
-              execFileSync('git', ['push', 'origin', '--delete', job.branch], {
+              // Explicit refspec form so a leading '-' can't be a git flag.
+              execFileSync('git', ['push', 'origin', `:refs/heads/${job.branch}`], {
                 cwd: repoRoot,
                 stdio: ['ignore', 'pipe', 'pipe'],
               });
             } catch {
               /* branch already gone — fine */
             }
+          } else if (job.prUrl || job.branch) {
+            warn(`cleanup REFUSED for "${job.title}": untrusted PR/branch value`);
           }
           await reportMergeOutcome(CLEANUP_DONE_URL, { intentId: job.id });
           ok(`${c.cyan('cleaned')} ${c.dim(`— ${job.title}`)}`);
@@ -417,6 +472,11 @@ export async function runFleetDaemon() {
           onChild: (ch) => {
             state.child = ch;
           },
+          // Hold the preview's stop fn so teardown/removal can kill the detached
+          // dev-server + tunnel (they survive our exit otherwise).
+          onPreview: (stop) => {
+            state.stopPreview = stop;
+          },
           // A turn that couldn't reach the MCP server: forget the cached token so
           // the next reconcile poll re-mints a fresh one (self-heals a token that
           // was rotated/expired out from under a running session).
@@ -441,6 +501,11 @@ export async function runFleetDaemon() {
         } catch {
           /* best-effort */
         }
+        try {
+          w.state.stopPreview?.();
+        } catch {
+          /* best-effort */
+        }
         try {
           git(['worktree', 'remove', '--force', w.wt], repoRoot);
         } catch {
@@ -449,6 +514,7 @@ export async function runFleetDaemon() {
         workers.delete(id);
         tokenByAgent.delete(id);
         hasWorkByAgent.delete(id);
+        mintedAt.delete(id); // was leaked on removal (finding 14)
       }
     }
 

package/bin/lib/git.mjs

@@ -15,6 +15,50 @@ export function repoRootOrDie() {
   }
 }
 
+// ── Server-value validation ────────────────────────────────────────────────
+// prUrl / branch / agentId arrive from the fleet server. execFileSync blocks
+// SHELL injection but NOT git/gh option injection (a leading '-' becomes a
+// flag) or cross-repo/cross-path abuse. These guards make a malicious or buggy
+// server unable to touch a repo/branch/path outside the expected scope.
+
+/** The `owner/repo` the daemon is running inside, from origin's URL. Null if
+ *  origin isn't a github remote. */
+export function originSlug(repoRoot) {
+  try {
+    const url = git(['remote', 'get-url', 'origin'], repoRoot);
+    const m = url.match(/github\.com[:/]([^/]+)\/(.+?)(?:\.git)?$/i);
+    return m ? `${m[1]}/${m[2]}` : null;
+  } catch {
+    return null;
+  }
+}
+
+/** A PR URL is accepted only if it's an https github.com PR in THIS repo. */
+export function isValidPrUrl(prUrl, slug) {
+  if (typeof prUrl !== 'string' || !slug) return false;
+  const m = prUrl.match(/^https:\/\/github\.com\/([^/]+\/[^/]+)\/pull\/\d+$/);
+  return !!m && m[1].toLowerCase() === slug.toLowerCase();
+}
+
+/** A branch name is accepted only if git considers it a well-formed ref, it's
+ *  not the base branch, and it doesn't start with '-' (option injection). */
+export function isValidBranch(branch, repoRoot, baseRef) {
+  if (typeof branch !== 'string' || !branch || branch.startsWith('-')) return false;
+  if (baseRef && (branch === baseRef || `origin/${branch}` === baseRef)) return false;
+  try {
+    git(['check-ref-format', '--branch', branch], repoRoot);
+    return true;
+  } catch {
+    return false;
+  }
+}
+
+/** A roster agent id used as a filesystem path segment — strict allowlist so
+ *  it can't traverse (`..`, `/`) out of the worktrees dir. */
+export function isSafePathSegment(id) {
+  return typeof id === 'string' && /^[A-Za-z0-9_-]{1,128}$/.test(id);
+}
+
 export function detectBaseRef(repoRoot) {
   try {
     return git(['rev-parse', '--abbrev-ref', 'origin/HEAD'], repoRoot); // e.g. origin/main

package/bin/lib/live.mjs

@@ -16,7 +16,7 @@
  * live fleet + repo to shake out. Old (poll/sentinel) mode is untouched.
  */
 
-import { readFileSync, writeFileSync } from 'node:fs';
+import { readFileSync, writeFileSync, rmSync } from 'node:fs';
 import { join } from 'node:path';
 import { query } from '@anthropic-ai/claude-agent-sdk';
 import {
@@ -31,7 +31,7 @@ import {
 } from './config.mjs';
 import { c, info, ok, warn } from './ui.mjs';
 import { sleep } from './claude.mjs';
-import { git, resetWorktree } from './git.mjs';
+import { git, resetWorktree, isValidBranch } from './git.mjs';
 import { loadPreviewConfig, startPreview } from './preview.mjs';
 
 // Register a branch preview's tunnel URL with Flowviant (fleet-authed). The
@@ -46,6 +46,7 @@ async function registerLiveTarget(intentId, kind, url) {
         'User-Agent': USER_AGENT,
         'Content-Type': 'application/json',
       },
+      signal: AbortSignal.timeout(30_000),
       body: JSON.stringify({ intentId, kind, url }),
     });
   } catch {
@@ -124,6 +125,7 @@ async function mcpCall(mcpUrl, token, name, args) {
       // without this every live MCP call fails against api.flowviant.com.
       'User-Agent': USER_AGENT,
     },
+    signal: AbortSignal.timeout(30_000),
     body: JSON.stringify({
       jsonrpc: '2.0',
       id: ++rpcId,
@@ -206,6 +208,13 @@ function writeTaskMarker(cwd, intentId) {
     /* best-effort — worst case the next restart resets to base */
   }
 }
+function clearTaskMarker(cwd) {
+  try {
+    rmSync(markerPath(cwd), { force: true });
+  } catch {
+    /* best-effort */
+  }
+}
 
 // A stop word from any teammate halts the agent (interrupt at the next boundary,
 // then hold for direction) — the "stop, you're going the wrong way" valve.
@@ -246,6 +255,52 @@ async function waitForMessage(mcpUrl, token, runId, afterId, isAlive) {
 
 // One task: claim → seed → stream/mirror/inject/park → complete. Returns
 // { outcome: 'nothing' | 'done' | 'blocked' | 'stalled' | 'error' }.
+// Distinguish "YOUR OWN Claude account is out of quota" (the user must wait or
+// hand off — a park) from a transient Anthropic-side hiccup (retry soon — a
+// plain error). Only the former parks. resetAt is lifted from the limit
+// response's retry headers when present, so the thread can say when it's back.
+export function classifyRateLimit(e) {
+  const status = e?.status ?? e?.statusCode ?? e?.response?.status;
+  const msg = String(e?.message ?? e ?? '').toLowerCase();
+  const overloaded = status === 529 || msg.includes('overloaded');
+  const isRateLimit =
+    !overloaded &&
+    (status === 429 ||
+      /rate.?limit|usage limit|quota|too many requests|exceeded your|reached your|limit reached/.test(
+        msg,
+      ));
+  if (!isRateLimit) return { isRateLimit: false };
+  let resetAt;
+  const hdrs = e?.headers ?? e?.response?.headers;
+  const get = (k) => hdrs?.get?.(k) ?? hdrs?.[k];
+  const retryAfter = Number(get?.('retry-after'));
+  const resetHdr = get?.('anthropic-ratelimit-unified-reset');
+  if (Number.isFinite(retryAfter) && retryAfter > 0) {
+    resetAt = new Date(Date.now() + retryAfter * 1000).toISOString();
+  } else if (resetHdr != null) {
+    const epoch = Number(resetHdr);
+    if (Number.isFinite(epoch) && epoch > 0) resetAt = new Date(epoch * 1000).toISOString();
+    else if (!Number.isNaN(Date.parse(resetHdr))) resetAt = new Date(resetHdr).toISOString();
+  }
+  return { isRateLimit: true, resetAt };
+}
+
+// Wait out a Claude-account limit, heartbeating so the 30-min lease stays warm
+// and the task isn't reclaimed while paused. Caps the wait so an unknown or very
+// distant reset still retries eventually (and re-parks if still limited).
+async function parkUntilReset(resetAt, { mcpUrl, getToken, runId, isAlive }) {
+  const MAX_PARK_MS = 60 * 60 * 1000; // never sit longer than an hour before retrying
+  const DEFAULT_PARK_MS = 15 * 60 * 1000; // no reset given → try again in 15 min
+  const now = Date.now();
+  const target = resetAt ? Date.parse(resetAt) : now + DEFAULT_PARK_MS;
+  const until = Math.min(Number.isFinite(target) ? target : now + DEFAULT_PARK_MS, now + MAX_PARK_MS);
+  while (isAlive() && Date.now() < until) {
+    const token = getToken();
+    if (token) await mcpCall(mcpUrl, token, 'heartbeat', { runId }).catch(() => {});
+    await sleep(IDLE_SECONDS);
+  }
+}
+
 export async function runLiveTask({ mcpUrl, token, cwd, baseRef, isAlive, resumeIntentId, onChild }) {
   const claim = await mcpCall(mcpUrl, token, 'claim_next_intent', {}).catch(() => null);
   if (!claim || claim.claimed !== true) return { outcome: 'nothing' };
@@ -261,7 +316,10 @@ export async function runLiveTask({ mcpUrl, token, cwd, baseRef, isAlive, resume
 
   // Revision resumes its PR branch; a genuinely fresh task gets a clean base
   // checkout; a resume (in-memory or marker) keeps its dirty worktree untouched.
-  if (brief.branch) {
+  // The branch is server-supplied — validate it's a well-formed non-base ref
+  // (not a leading-'-' git option) before checkout; on a bad value fall back to
+  // a clean base rather than executing it.
+  if (brief.branch && isValidBranch(brief.branch, cwd, baseRef)) {
     try {
       git(['fetch', 'origin', '--quiet'], cwd);
       git(['checkout', brief.branch], cwd);
@@ -284,7 +342,13 @@ export async function runLiveTask({ mcpUrl, token, cwd, baseRef, isAlive, resume
   }
 
   const env = { ...process.env };
-  delete env.ANTHROPIC_API_KEY; // force the user's Claude Code subscription
+  // Force the user's Claude Code subscription — strip EVERY var that could
+  // divert to API billing or a proxy (poll mode strips these too; live mode
+  // was only clearing API_KEY, so an exported AUTH_TOKEN/BASE_URL silently
+  // billed the API on the default path).
+  delete env.ANTHROPIC_API_KEY;
+  delete env.ANTHROPIC_AUTH_TOKEN;
+  delete env.ANTHROPIC_BASE_URL;
 
   // Prior channel transcript — present when resuming a parked/re-claimed task;
   // seed it so a fresh session picks up where the conversation left off. afterId
@@ -401,7 +465,14 @@ export async function runLiveTask({ mcpUrl, token, cwd, baseRef, isAlive, resume
         await flush();
         turnId = null;
 
-        if (completed) return { outcome: 'done', title, intentId };
+        // Task finished — clear the marker so this worktree is NOT treated as a
+        // resume of this intent later (esp. if the task is restarted from
+        // scratch, which discards it: a stale marker would resume the discarded
+        // attempt's dirty files).
+        if (completed) {
+          clearTaskMarker(cwd);
+          return { outcome: 'done', title, intentId };
+        }
 
         if (sawBlocker) {
           const res = await waitForResolution(mcpUrl, token, blockerId, isAlive);
@@ -425,6 +496,11 @@ export async function runLiveTask({ mcpUrl, token, cwd, baseRef, isAlive, resume
         // Torn down out from under us (restart / reassign in Flowviant): the
         // server killed this run — abandon the session, don't keep building.
         if (poll && poll.ok === false && poll.reason === 'run_not_active') {
+          // Discarded (restart/reassign): clear the marker AND reset the
+          // worktree so the next fresh claim starts from clean base, never
+          // resuming the abandoned attempt.
+          clearTaskMarker(cwd);
+          resetWorktree(cwd, baseRef);
           return { outcome: 'torn_down', title, intentId };
         }
         const fresh = (poll?.messages ?? []).filter((x) => x.role === 'user');
@@ -463,6 +539,14 @@ export async function runLiveTask({ mcpUrl, token, cwd, baseRef, isAlive, resume
     }
     return { outcome: completed ? 'done' : 'stalled', title, intentId };
   } catch (e) {
+    const rl = classifyRateLimit(e);
+    if (rl.isRateLimit) {
+      // The user's OWN Claude account is tapped. Park the run so the thread shows
+      // it as their plan's limit (not a Flowviant error) and the lease stays warm
+      // for a resume in place — never reset this worktree's work.
+      await mcpCall(mcpUrl, token, 'report_paused', { runId, resetAt: rl.resetAt }).catch(() => {});
+      return { outcome: 'rate_limited', resetAt: rl.resetAt, runId, title, intentId };
+    }
     return { outcome: 'error', error: e?.message ?? String(e), title, intentId };
   } finally {
     onChild?.(null); // no longer busy — token may rotate between tasks
@@ -493,6 +577,7 @@ export async function runLiveWorker({
   isAlive,
   onTokenSuspect,
   onChild,
+  onPreview,
 }) {
   // The intent this worker is holding across iterations. When a task parks on a
   // blocker its worktree keeps uncommitted work; on the resume claim we must NOT
@@ -519,6 +604,10 @@ export async function runLiveWorker({
       }
       preview = 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.
+    onPreview?.(null);
   };
   const startReviewPreview = async (intentId) => {
     stopPreview();
@@ -544,6 +633,7 @@ export async function runLiveWorker({
       log: (m) => info(`${label} ${c.dim(m)}`),
     });
     if (preview) {
+      onPreview?.(stopPreview); // hand the daemon a stop handle for shutdown
       await registerLiveTarget(intentId, kind, preview.url);
       ok(`${label} ${c.dim('live preview ready — open the node to drive it in your review')}`);
     }
@@ -581,7 +671,10 @@ export async function runLiveWorker({
     // stalled / errored → same worktree resumes). Finishing or finding no work
     // clears it so the next fresh task starts from a clean base.
     lastIntentId =
-      res.outcome === 'parked' || res.outcome === 'stalled' || res.outcome === 'error'
+      res.outcome === 'parked' ||
+      res.outcome === 'stalled' ||
+      res.outcome === 'error' ||
+      res.outcome === 'rate_limited'
         ? res.intentId
         : null;
     if (res.outcome === 'nothing') {
@@ -615,6 +708,25 @@ export async function runLiveWorker({
       // on reconnect. Nothing to do but stop cleanly.
       break;
     }
+    if (res.outcome === 'rate_limited') {
+      // The agent's OWN Claude account hit its limit — not a Flowviant failure.
+      // Hold the worktree + lease and wait it out (heartbeating so it isn't
+      // reclaimed), then resume the SAME task in place. Never reset the worktree.
+      const when = res.resetAt ? ` until ~${new Date(res.resetAt).toLocaleTimeString()}` : '';
+      enter(
+        'paused',
+        warn,
+        `${c.yellow('paused')} ${c.dim(`— your Claude account hit its usage limit; holding your work${when}`)}`,
+      );
+      await parkUntilReset(res.resetAt, {
+        mcpUrl: getMcpUrl() ?? MCP_URL,
+        getToken: () => getToken(agentId),
+        runId: res.runId,
+        isAlive,
+      });
+      phase = '';
+      continue;
+    }
     // stalled / error — usually a stale token or a stuck turn. Refresh + retry.
     enter('reconnect', warn, `${c.yellow(res.outcome)} ${c.dim('— refreshing token, retrying')}`);
     onTokenSuspect?.(agentId);

package/bin/lib/login.mjs

@@ -37,6 +37,7 @@ async function post(url, body) {
   const res = await fetch(url, {
     method: 'POST',
     headers: { 'Content-Type': 'application/json', 'User-Agent': USER_AGENT },
+    signal: AbortSignal.timeout(30_000),
     body: JSON.stringify(body),
   });
   if (!res.ok) throw new Error(`HTTP ${res.status}`);

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "flowviant",
-  "version": "0.9.0",
+  "version": "0.10.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": {