flowviant 0.6.0

package/bin/lib/preview.mjs

@@ -0,0 +1,169 @@
+/**
+ * Live preview (live mode). When a task opens its PR and parks for review, the
+ * daemon starts the branch's dev server IN THE AGENT'S WORKTREE and opens a
+ * cloudflared quick tunnel to it, so the reviewer can drive the real running
+ * change in Flowviant (broker-not-host: Flowviant only stores the tunnel URL;
+ * the reviewer's browser talks to it directly).
+ *
+ * Zero-config where possible: the preview config is read from
+ * `.flowviant/preview.json` if present, otherwise INFERRED from package.json
+ * (framework → port). cloudflared is AUTO-FETCHED if it isn't installed. No
+ * cloudflared / no inferable config → no live preview, and review falls back to
+ * the captured evidence the agent attached (never a hard failure).
+ *
+ * Config shape:
+ *   { "ui": { "cmd": "<start dev server>", "port": 5173 },
+ *     "api": { "cmd": "<start api>",        "port": 8787 } }
+ */
+
+import { spawn, execFileSync } from 'node:child_process';
+import { readFileSync, writeFileSync, existsSync, mkdirSync, chmodSync } from 'node:fs';
+import { join } from 'node:path';
+import { homedir, platform, arch } from 'node:os';
+
+// ── Config: explicit file, else infer from package.json ────────────────────
+
+function readPreviewConfig(repoRoot) {
+  const p = join(repoRoot, '.flowviant', 'preview.json');
+  if (!existsSync(p)) return null;
+  try {
+    return JSON.parse(readFileSync(p, 'utf8'));
+  } catch {
+    return null;
+  }
+}
+
+// Framework → conventional dev-server port. If we can't identify one, we don't
+// guess — an explicit .flowviant/preview.json is the escape hatch.
+const FRAMEWORK_PORTS = [
+  { re: /\bvite\b/, port: 5173 },
+  { re: /\bnext\b/, port: 3000 },
+  { re: /react-scripts/, port: 3000 },
+  { re: /\bastro\b/, port: 4321 },
+  { re: /\bnuxt\b/, port: 3000 },
+  { re: /\bremix\b/, port: 3000 },
+  { re: /\bsvelte/, port: 5173 },
+  { re: /\bgatsby\b/, port: 8000 },
+  { re: /\bexpo\b/, port: 8081 },
+];
+
+function pkgManager(repoRoot) {
+  if (existsSync(join(repoRoot, 'bun.lock')) || existsSync(join(repoRoot, 'bun.lockb'))) return 'bun';
+  if (existsSync(join(repoRoot, 'pnpm-lock.yaml'))) return 'pnpm';
+  if (existsSync(join(repoRoot, 'yarn.lock'))) return 'yarn';
+  return 'npm';
+}
+
+function inferPreviewConfig(repoRoot) {
+  const pkgPath = join(repoRoot, 'package.json');
+  if (!existsSync(pkgPath)) return null;
+  let pkg;
+  try {
+    pkg = JSON.parse(readFileSync(pkgPath, 'utf8'));
+  } catch {
+    return null;
+  }
+  const scripts = pkg.scripts || {};
+  const script = scripts.dev ? 'dev' : scripts.start ? 'start' : null;
+  if (!script) return null;
+  const deps = { ...pkg.dependencies, ...pkg.devDependencies };
+  const hay = `${scripts[script]} ${Object.keys(deps).join(' ')}`.toLowerCase();
+  const fw = FRAMEWORK_PORTS.find((f) => f.re.test(hay));
+  if (!fw) return null; // can't safely guess the port
+  const pm = pkgManager(repoRoot);
+  const install = pm === 'npm' ? 'npm install' : `${pm} install`;
+  const run = pm === 'yarn' ? `yarn ${script}` : `${pm} run ${script}`;
+  return { ui: { cmd: `${install} && ${run}`, port: fw.port } };
+}
+
+/** The preview config for a repo — explicit file wins, else inferred. */
+export function loadPreviewConfig(repoRoot) {
+  return readPreviewConfig(repoRoot) ?? inferPreviewConfig(repoRoot);
+}
+
+// ── cloudflared: use if installed, else auto-fetch ─────────────────────────
+
+function onPath() {
+  try {
+    execFileSync('cloudflared', ['--version'], { stdio: 'ignore' });
+    return true;
+  } catch {
+    return false;
+  }
+}
+
+/** Resolve a cloudflared binary: PATH → cached fetch → download. Returns the
+ *  command/path to run, or null if unavailable (Windows/macOS auto-fetch is
+ *  skipped — those install cleanly via brew/winget). */
+async function ensureCloudflared(log) {
+  if (onPath()) return 'cloudflared';
+  const os = platform();
+  const dir = join(homedir(), '.flowviant', 'bin');
+  const bin = join(dir, os === 'win32' ? 'cloudflared.exe' : 'cloudflared');
+  if (existsSync(bin)) return bin;
+  // Raw single-file binaries exist for linux + windows; macOS ships a tarball,
+  // so point mac users at brew instead of unpacking here.
+  if (os === 'darwin') {
+    log?.('cloudflared not found — install it (`brew install cloudflared`) to enable live previews.');
+    return null;
+  }
+  const osName = os === 'win32' ? 'windows' : 'linux';
+  const a = arch() === 'arm64' ? 'arm64' : 'amd64';
+  const url = `https://github.com/cloudflare/cloudflared/releases/latest/download/cloudflared-${osName}-${a}${
+    os === 'win32' ? '.exe' : ''
+  }`;
+  log?.(`fetching cloudflared (${osName}-${a}) to enable live previews…`);
+  try {
+    const res = await fetch(url, { redirect: 'follow' });
+    if (!res.ok) throw new Error(`http ${res.status}`);
+    mkdirSync(dir, { recursive: true });
+    writeFileSync(bin, Buffer.from(await res.arrayBuffer()));
+    if (os !== 'win32') chmodSync(bin, 0o755);
+    return bin;
+  } catch (e) {
+    log?.(`could not fetch cloudflared (${e.message}) — install it manually to enable live previews.`);
+    return null;
+  }
+}
+
+const TUNNEL_RE = /https:\/\/[a-z0-9-]+\.trycloudflare\.com/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.
+ */
+export async function startPreview({ worktree, kind, cmd, port, log, timeoutMs = 90_000 }) {
+  const cf = await ensureCloudflared(log);
+  if (!cf) return null; // fall back to captured evidence
+  return new Promise((resolve) => {
+    const server = spawn(cmd, { cwd: worktree, shell: true, stdio: ['ignore', 'ignore', 'ignore'] });
+    const tunnel = spawn(cf, ['tunnel', '--url', `http://localhost:${port}`], {
+      stdio: ['ignore', 'pipe', 'pipe'],
+    });
+    let settled = false;
+    const stop = () => {
+      try { server.kill('SIGKILL'); } catch { /* gone */ }
+      try { tunnel.kill('SIGKILL'); } catch { /* gone */ }
+    };
+    const finish = (val) => {
+      if (settled) return;
+      settled = true;
+      clearTimeout(timer);
+      if (!val) stop();
+      resolve(val);
+    };
+    const onData = (d) => {
+      const m = TUNNEL_RE.exec(d.toString());
+      if (m) finish({ url: m[0], kind, stop });
+    };
+    tunnel.stdout.on('data', onData);
+    tunnel.stderr.on('data', onData);
+    tunnel.on('error', () => finish(null));
+    tunnel.on('close', () => finish(null));
+    const timer = setTimeout(() => {
+      log?.('preview tunnel did not come up in time — skipping (captured evidence still applies).');
+      finish(null);
+    }, timeoutMs);
+  });
+}

package/bin/lib/single.mjs

@@ -0,0 +1,66 @@
+/**
+ * Back-compat single-token + static-fleet modes. A single token drains the whole
+ * queue in one continuous Claude session in the current checkout; FLOWVIANT_TOKENS
+ * runs one such worker per token, each in its own git worktree.
+ */
+
+import { mkdtempSync, rmSync } from 'node:fs';
+import { tmpdir } from 'node:os';
+import { join } from 'node:path';
+import { MCP_URL, POLL_SECONDS, tokens } from './config.mjs';
+import { sleep, mcpConfigFor, runTurn, sawSentinel, blockedId, SYSTEM_MULTI, KICKOFF, RESUME } from './claude.mjs';
+import { git, repoRootOrDie } from './git.mjs';
+
+export async function runWorker({ token, cwd, label }) {
+  const { dir, path: mcpConfig } = mcpConfigFor(token, MCP_URL);
+  try {
+    let out = await runTurn({ prompt: KICKOFF, resume: false, system: SYSTEM_MULTI, cwd, mcpConfig, label });
+    while (!sawSentinel(out, 'ALL_CLEAR')) {
+      if (blockedId(out)) {
+        console.log(`${label} » waiting on you in Flowviant — answer the blocker. Re-checking in ${POLL_SECONDS}s…`);
+      }
+      await sleep(POLL_SECONDS);
+      out = await runTurn({ prompt: RESUME, resume: true, system: SYSTEM_MULTI, cwd, mcpConfig, label });
+    }
+    console.log(`${label} » queue clear.`);
+  } finally {
+    rmSync(dir, { recursive: true, force: true });
+  }
+}
+
+export async function runStaticFleet() {
+  console.log(`» flowviant fleet → ${tokens.length} workers · ${MCP_URL}`);
+  const repoRoot = repoRootOrDie();
+  const baseDir = mkdtempSync(join(tmpdir(), 'flowviant-fleet-'));
+  const worktrees = [];
+  const cleanup = () => {
+    for (const wt of worktrees) {
+      try {
+        git(['worktree', 'remove', '--force', wt], repoRoot);
+      } catch {
+        /* best-effort */
+      }
+    }
+    try {
+      rmSync(baseDir, { recursive: true, force: true });
+    } catch {
+      /* best-effort */
+    }
+  };
+  process.on('SIGINT', () => {
+    cleanup();
+    process.exit(130);
+  });
+
+  const jobs = tokens.map((token, i) => {
+    const label = `[w${i + 1}]`;
+    const wt = join(baseDir, `worker-${i + 1}`);
+    git(['worktree', 'add', '--detach', wt, 'HEAD'], repoRoot);
+    worktrees.push(wt);
+    console.log(`${label} worktree ready (token fva_…${token.slice(-4)})`);
+    return runWorker({ token, cwd: wt, label });
+  });
+  await Promise.allSettled(jobs);
+  cleanup();
+  console.log('» fleet done — all queues clear.');
+}

package/bin/lib/ui.mjs

@@ -0,0 +1,26 @@
+/** Zero-dep ANSI output. Respects NO_COLOR and non-TTY pipes. */
+
+const COLOR = !!process.stdout.isTTY && !process.env.NO_COLOR;
+const wrap = (open) => (s) => (COLOR ? `\x1b[${open}m${s}\x1b[0m` : `${s}`);
+
+export const c = {
+  bold: wrap(1), dim: wrap(2),
+  red: wrap(31), green: wrap(32), yellow: wrap(33),
+  blue: wrap(34), magenta: wrap(35), cyan: wrap(36), gray: wrap(90),
+};
+
+// Stable, cycled colours so each agent's label is easy to scan in a fleet.
+export const LABEL_COLORS = [c.cyan, c.magenta, c.blue, c.yellow, c.green, c.red];
+
+const stamp = () => {
+  const d = new Date();
+  const p = (n) => String(n).padStart(2, '0');
+  return c.gray(`${p(d.getHours())}:${p(d.getMinutes())}:${p(d.getSeconds())}`);
+};
+const line = (sym, msg) => console.log(`${stamp()} ${sym} ${msg}`);
+
+export const info = (m) => line(c.dim('·'), c.dim(m));
+export const note = (m) => line(c.blue('›'), m);
+export const ok = (m) => line(c.green('✓'), m);
+export const warn = (m) => line(c.yellow('!'), m);
+export const fail = (m) => line(c.red('✗'), m);

package/package.json

@@ -0,0 +1,37 @@
+{
+  "name": "flowviant",
+  "version": "0.6.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": {
+    "flowviant": "bin/cli.mjs"
+  },
+  "files": [
+    "bin",
+    "README.md",
+    "LICENSE"
+  ],
+  "engines": {
+    "node": ">=20"
+  },
+  "dependencies": {
+    "@anthropic-ai/claude-agent-sdk": "^0.3.0"
+  },
+  "keywords": [
+    "flowviant",
+    "claude",
+    "claude-code",
+    "agent",
+    "mcp",
+    "ai"
+  ],
+  "homepage": "https://flowviant.com",
+  "repository": {
+    "type": "git",
+    "url": "https://github.com/flowviant/cli.git"
+  },
+  "license": "MIT",
+  "bugs": {
+    "url": "https://github.com/flowviant/cli/issues"
+  }
+}