flowviant 0.99.0 → 0.101.0

package/bin/lib/uninstall.mjs

@@ -0,0 +1,286 @@
+import * as nodeFs from 'node:fs';
+import { execFile as nodeExecFile } from 'node:child_process';
+import { homedir } from 'node:os';
+import { basename, dirname, isAbsolute, join, resolve, sep } from 'node:path';
+import { promisify } from 'node:util';
+import { runningCompiledBinary } from './update.mjs';
+import { VERSION } from './config.mjs';
+
+const execFileAsync = promisify(nodeExecFile);
+const inside = (path, dir) => path === dir || path.startsWith(`${dir}${sep}`);
+const errorWords = (error) => String(error?.stderr || error?.message || error).trim();
+
+function defaults(options = {}) {
+  return {
+    fs: nodeFs,
+    home: homedir(),
+    path: process.env.PATH || '',
+    execFile: (file, args, opts) => execFileAsync(file, args, opts),
+    pidLive: (pid) => { try { process.kill(pid, 0); return true; } catch { return false; } },
+    procReader: (pid, file) => file === 'exe' || file === 'cwd'
+      ? nodeFs.readlinkSync(`/proc/${pid}/${file}`) : nodeFs.readFileSync(`/proc/${pid}/${file}`),
+    procAvailable: nodeFs.existsSync('/proc/self/cmdline'),
+    compiled: runningCompiledBinary(),
+    execPath: process.execPath,
+    argvPath: process.argv[1],
+    stopAllDaemons: null,
+    projects: null,
+    disconnect: null,
+    prompt: null,
+    tty: Boolean(process.stdin.isTTY),
+    log: (line) => console.error(line),
+    stdout: (line) => process.stdout.write(`${line}\n`),
+    ...options,
+  };
+}
+
+function real(fs, path) { try { return fs.realpathSync(path); } catch { return resolve(path); } }
+function readVersion(fs, path) {
+  try {
+    const value = JSON.parse(fs.readFileSync(path, 'utf8')).version;
+    return typeof value === 'string' ? value : undefined;
+  } catch { return undefined; }
+}
+function files(fs, dir) { try { return fs.readdirSync(dir); } catch { return []; } }
+function regular(fs, path) { try { return fs.statSync(path).isFile(); } catch { return false; } }
+function executable(fs, path) { try { const stat = fs.statSync(path); return stat.isFile() && Boolean(stat.mode & 0o111); } catch { return false; } }
+// A compiled flowviant is an ELF or Mach-O file. A shell wrapper someone named
+// `flowviant` is not a copy of ours and is never removed.
+function compiledExecutable(fs, path) {
+  try {
+    const fd = fs.openSync(path, 'r');
+    const head = Buffer.alloc(4);
+    try { fs.readSync(fd, head, 0, 4, 0); } finally { fs.closeSync(fd); }
+    const magic = head.readUInt32BE(0);
+    return magic === 0x7f454c46 || [0xfeedfacf, 0xcffaedfe, 0xfeedface, 0xcefaedfe, 0xcafebabe].includes(magic);
+  } catch { return false; }
+}
+function exactBlock(dir, rc) {
+  const line = basename(rc) === 'flowviant.fish'
+    ? `fish_add_path "${dir}"` : `export PATH="${dir}:$PATH"`;
+  return `\n# flowviant\n${line}\n`;
+}
+
+function liveDaemons(o) {
+  const found = [];
+  for (const name of files(o.fs, join(o.home, '.flowviant'))) {
+    if (!/^daemon-[0-9a-f]{12}\.lock$/.test(name)) continue;
+    try {
+      const pid = JSON.parse(o.fs.readFileSync(join(o.home, '.flowviant', name), 'utf8')).pid;
+      if (!Number.isInteger(pid) || pid <= 0 || !o.pidLive(pid)) continue;
+      let paths = [];
+      if (o.procAvailable) {
+        try {
+          const exe = o.procReader(pid, 'exe');
+          const command = o.procReader(pid, 'cmdline');
+          const args = Buffer.from(command).toString('utf8').split('\0').filter(Boolean);
+          let scripts = args.filter((arg) => isAbsolute(arg));
+          const relative = args.filter((arg) => !arg.startsWith('-') && arg.includes('/') && !isAbsolute(arg));
+          if (relative.length) {
+            const cwd = String(o.procReader(pid, 'cwd'));
+            scripts.push(...relative.map((arg) => resolve(cwd, arg)));
+          }
+          const executable = String(exe).replace(/ \(deleted\)$/, '');
+          paths = basename(executable).startsWith('node') && !scripts.length ? [] :
+            [executable, ...scripts].map((path) => real(o.fs, path));
+        } catch { /* The live pid is still protected when its command is hidden. */ }
+      }
+      found.push({ pid, paths });
+    } catch { /* An unreadable lock is not evidence of a live daemon. */ }
+  }
+  return found;
+}
+
+export async function buildUninstallPlan(options = {}) {
+  const o = defaults(options);
+  const copies = [];
+  const add = (kind, path, removal = path, version) => {
+    if (!copies.some((c) => c.kind === kind && c.path === path)) copies.push({ kind, path, removal, ...(version ? { version } : {}) });
+  };
+  let npmRoot;
+  try { npmRoot = String((await o.execFile('npm', ['root', '-g'], { timeout: 5000 })).stdout).trim(); }
+  catch { /* npm may not be installed. */ }
+  const npmPackage = npmRoot && join(npmRoot, 'flowviant');
+  if (npmPackage && o.fs.existsSync(npmPackage)) add('npm-global', npmPackage, npmPackage, readVersion(o.fs, join(npmPackage, 'package.json')));
+
+  const npxRoot = join(o.home, '.npm', '_npx');
+  for (const hash of files(o.fs, npxRoot)) {
+    const dir = join(npxRoot, hash);
+    const pkg = join(dir, 'node_modules', 'flowviant');
+    if (!o.fs.existsSync(pkg)) continue;
+    const version = readVersion(o.fs, join(pkg, 'package.json'));
+    let alone = false;
+    try {
+      const meta = JSON.parse(o.fs.readFileSync(join(dir, 'package.json'), 'utf8'));
+      const names = Object.keys({ ...meta.dependencies, ...meta.devDependencies, ...meta.optionalDependencies });
+      alone = names.length === 1 && names[0] === 'flowviant';
+    } catch { /* Unknown cache contents must not be removed as a whole. */ }
+    add('npx-cache', pkg, dir, version);
+    copies.at(-1).skipReason = alone ? null : 'cache contains other packages or its dependencies could not be read';
+  }
+
+  const ownBin = join(o.home, '.flowviant', 'bin');
+  // Trusted: the installer's default directory and any directory an installer
+  // PATH block names. Anything else on PATH must prove itself.
+  const trusted = new Set([real(o.fs, ownBin)]);
+  const addBinary = (dir, fromPath = false) => {
+    const candidate = join(dir, 'flowviant');
+    if (!(fromPath ? executable(o.fs, candidate) : regular(o.fs, candidate))) return;
+    const target = real(o.fs, candidate);
+    if (inside(target, npxRoot)) return;
+    const packagePath = target.match(/^(.*\/node_modules\/flowviant)(?:\/|$)/)?.[1];
+    if (packagePath) {
+      if (!copies.some((c) => c.kind === 'npm-global' && real(o.fs, c.path) === real(o.fs, packagePath))) {
+        let npmPrefix = dirname(dirname(packagePath));
+        if (basename(npmPrefix) === 'lib') npmPrefix = dirname(npmPrefix);
+        const version = readVersion(o.fs, join(packagePath, 'package.json'));
+        copies.push({ kind: 'npm-global', path: packagePath, removal: packagePath,
+          npmPrefix, ...(version ? { version } : {}) });
+      }
+      return;
+    }
+    // Outside the installer's own directory a file must PROVE it is ours:
+    // compiled, and answering `--version` with a version (checked below).
+    const proven = trusted.has(real(o.fs, dir));
+    if (!proven && !compiledExecutable(o.fs, target)) return;
+    add('binary', target);
+    if (!proven) copies.at(-1).mustProve = true;
+  };
+  addBinary(join(o.home, '.flowviant', 'bin'));
+  for (const dir of o.path.split(':').filter(Boolean)) addBinary(dir, true);
+  for (const rc of ['.zshrc', '.bashrc', '.profile', '.config/fish/conf.d/flowviant.fish']) {
+    const path = join(o.home, rc);
+    let content;
+    try { content = o.fs.readFileSync(path, 'utf8'); } catch { continue; }
+    const pattern = basename(path) === 'flowviant.fish'
+      ? /\n# flowviant\nfish_add_path "([^"\n]+)"\n/g
+      : /\n# flowviant\nexport PATH="([^"\n]+):\$PATH"\n/g;
+    for (const match of content.matchAll(pattern)) {
+      const dir = match[1];
+      if (match[0] !== exactBlock(dir, path)) continue;
+      copies.push({ kind: 'path-line', path, removal: path, block: match[0] });
+      trusted.add(real(o.fs, dir));
+      addBinary(dir);
+    }
+  }
+  const own = real(o.fs, o.compiled ? o.execPath : o.argvPath || '');
+  if (o.compiled && regular(o.fs, own)) add('binary', own);
+  for (const copy of copies.filter((c) => c.kind === 'binary')) {
+    if (o.compiled && copy.path === own) { copy.version = VERSION; continue; }
+    try {
+      const output = await o.execFile(copy.path, ['--version'], { timeout: 5000 });
+      const version = String(output.stdout).trim();
+      if (/^\d+\.\d+\.\d+/.test(version)) copy.version = version;
+    } catch { /* A foreign or older binary may not answer. */ }
+  }
+  for (let i = copies.length - 1; i >= 0; i--) {
+    if (copies[i].mustProve && !copies[i].version && !(o.compiled && copies[i].path === own)) copies.splice(i, 1);
+    else delete copies[i].mustProve;
+  }
+  const daemons = liveDaemons(o);
+  for (const copy of copies) {
+    const source = real(o.fs, copy.path);
+    copy.current = copy.kind === 'path-line' ? false :
+      (copy.kind === 'binary' ? source === own : inside(own, source));
+    const daemon = daemons.find((d) => !o.procAvailable || !d.paths.length || d.paths.some((p) =>
+      copy.kind === 'binary' ? p === source : inside(p, source)));
+    if (daemon && copy.kind !== 'path-line') copy.runningPid = daemon.pid;
+  }
+  return { copies, daemons, home: o.home };
+}
+
+function removePathBlock(o, path, block) {
+  const before = o.fs.readFileSync(path);
+  const at = before.indexOf(Buffer.from(block));
+  if (at < 0) return false;
+  const after = Buffer.concat([before.subarray(0, at), before.subarray(at + Buffer.byteLength(block))]);
+  const mode = o.fs.statSync(path).mode & 0o7777;
+  const temp = `${path}.${process.pid}.flowviant-tmp`;
+  try {
+    o.fs.writeFileSync(temp, after, { mode });
+    o.fs.chmodSync(temp, mode);
+    o.fs.renameSync(temp, path);
+  } finally { try { o.fs.rmSync(temp, { force: true }); } catch { /* Renamed. */ } }
+  return true;
+}
+
+export async function runUninstall(options = {}) {
+  const o = defaults(options);
+  const { others = false, purge = false, yes = false, json = false } = options;
+  const result = { ok: true, removed: [], skipped: [], kept: [], errors: [] };
+  const line = (m) => o.log(m);
+  const plan = await buildUninstallPlan(o);
+  if (!json || !yes) {
+    for (const c of plan.copies) line(`${c.kind} ${c.path}${c.version ? ` (${c.version})` : ''}${c.runningPid ? ` (daemon pid ${c.runningPid})` : ''}`);
+    if (!plan.copies.length && !purge) line('no flowviant copies found on this machine.');
+  }
+  if (!yes && (plan.copies.length || purge)) {
+    if (!o.tty || json) result.errors.push('re-run with --yes to remove');
+    else if (!/^y(es)?$/i.test(await o.prompt?.('Remove these? [y/N] ') || '')) result.errors.push('cancelled');
+    if (result.errors.length) {
+      result.ok = false;
+      if (json) o.stdout(JSON.stringify(result)); else result.errors.forEach(line);
+      return result;
+    }
+  }
+
+  if (!others) {
+    try {
+      const stop = o.stopAllDaemons || (await import('./instance.mjs')).stopAllDaemons;
+      const tally = await stop({ log: line });
+      if (tally.failed) result.errors.push(`${tally.failed} daemon(s) could not be stopped`);
+    } catch (e) { result.errors.push(`stopping daemons: ${errorWords(e)}`); }
+  }
+  if (purge && !others) {
+    try {
+      const projects = o.projects || (await import('./credentials.mjs')).listStoredProjects;
+      const disconnect = o.disconnect || (async (entry, log) => {
+        const { disconnectHere, realDisconnectDeps, leaveUrlFrom } = await import('./machines.mjs');
+        const { FLEET_URL } = await import('./config.mjs');
+        return disconnectHere(entry, await realDisconnectDeps({ url: leaveUrlFrom(FLEET_URL), log }), { log });
+      });
+      for (const entry of await projects()) {
+        try {
+          const messages = [];
+          const res = await disconnect(entry, (m) => { messages.push(m); line(m); });
+          const failure = messages.find((m) => /could not tell the app|does not take a leave|not disconnected|could not forget/.test(m));
+          if (!res.ok || failure) result.errors.push(`registry removal for ${entry.projectId}: ${failure || messages.at(-1) || 'failed'}`);
+        } catch (e) { result.errors.push(`registry removal for ${entry.projectId}: ${errorWords(e)}`); }
+      }
+    } catch (e) { result.errors.push(`reading projects: ${errorWords(e)}`); }
+  }
+
+  for (const c of plan.copies) {
+    const item = { kind: c.kind, path: c.path };
+    let reason = c.skipReason;
+    if (others && c.current) reason = 'running copy';
+    if (others && c.runningPid) reason = `a daemon is running from it (pid ${c.runningPid})`;
+    if (others && c.kind === 'path-line' && plan.daemons.length && !o.procAvailable) reason = 'a daemon may be using this copy';
+    if (others && c.kind === 'path-line' && plan.copies.some((copy) => copy.kind === 'binary' && copy.current && c.block === exactBlock(dirname(copy.path), c.path))) reason = 'needed by the running binary';
+    if (reason) {
+      result.skipped.push({ ...item, reason });
+      if (!json) line(`skipped ${c.path}: ${reason}`);
+      continue;
+    }
+    try {
+      if (c.kind === 'npm-global') await o.execFile('npm',
+        c.npmPrefix ? ['uninstall', '-g', '--prefix', c.npmPrefix, 'flowviant'] : ['uninstall', '-g', 'flowviant'],
+        { timeout: 120000 });
+      else if (c.kind === 'path-line') removePathBlock(o, c.path, c.block);
+      else o.fs.rmSync(c.removal, { recursive: c.kind === 'npx-cache', force: true });
+      result.removed.push(item);
+      if (!json) line(`removed ${c.path}`);
+    } catch (e) { result.errors.push(`${c.path}: ${errorWords(e)}`); }
+  }
+  if (purge && !others) {
+    try { o.fs.rmSync(join(o.home, '.flowviant'), { recursive: true, force: true }); }
+    catch (e) { result.errors.push(`local purge: ${errorWords(e)}`); }
+  } else {
+    result.kept.push(join(o.home, '.flowviant'));
+    if (!json && !others) line('Kept logins and local state in ~/.flowviant; reinstalling resumes them.');
+  }
+  result.ok = result.errors.length === 0;
+  for (const error of result.errors) if (!json) line(`error: ${error}`);
+  if (json) o.stdout(JSON.stringify(result));
+  return result;
+}

package/bin/lib/update.mjs

@@ -30,7 +30,14 @@
  */
 
 import { execFileSync, spawn } from 'node:child_process';
-import { fileURLToPath } from 'node:url';
+import { createHash } from 'node:crypto';
+import { createReadStream, createWriteStream } from 'node:fs';
+import { chmod, mkdtemp, open, rename, rm } from 'node:fs/promises';
+import { dirname, join } from 'node:path';
+import { platform, arch } from 'node:process';
+import { pipeline } from 'node:stream/promises';
+import { Readable } from 'node:stream';
+import { runningViaNpx, terminalCommand } from './launchCommand.mjs';
 import { VERSION } from './config.mjs';
 import { note, ok, warn } from './ui.mjs';
 
@@ -45,22 +52,66 @@ export function cmpVersion(a, b) {
   return 0;
 }
 
-/**
- * npx runs from a per-invocation cache dir. `npm i -g` would install to a
- * DIFFERENT location than the one executing, so re-execing our own path would
- * loop on the stale cached copy. Detect npx and skip the install (nag instead —
- * relaunching with `npx flowviant@latest` is the npx-native update).
- */
-export function runningViaNpx() {
-  const ua = process.env.npm_config_user_agent || '';
-  const argv1 = process.argv[1] || '';
-  let self = '';
+/** Bun marks compiled entrypoints with a virtual /$bunfs/ script path. */
+export function runningCompiledBinary() {
+  return Boolean(process.versions.bun && process.argv[1]?.startsWith('/$bunfs/'));
+}
+
+const RELEASE_ORIGIN = 'https://api.flowviant.com';
+
+/** Download and verify before replacing the executable. Exposed for temp-dir tests. */
+export async function installBinaryUpdate({
+  executable = process.execPath,
+  target = `${platform === 'darwin' ? 'darwin' : platform}-${arch}`,
+  fetchImpl = fetch,
+  origin = RELEASE_ORIGIN,
+  minimumVersion = null,
+} = {}) {
+  if (!/^(linux|darwin)-(x64|arm64)$/.test(target)) throw new Error(`unsupported binary target ${target}`);
+  const manifestResponse = await fetchImpl(`${origin}/dl/latest.json`);
+  if (!manifestResponse.ok) throw new Error(`release manifest: HTTP ${manifestResponse.status}`);
+  const manifest = await manifestResponse.json();
+  const version = manifest?.version;
+  const file = manifest?.files?.[target];
+  if (!/^\d+\.\d+\.\d+$/.test(version) ||
+      file?.name !== `flowviant-${version}-${target}` ||
+      !/^[a-f0-9]{64}$/.test(file?.sha256) ||
+      !Number.isSafeInteger(file?.bytes) || file.bytes <= 0) {
+    throw new Error('invalid release manifest');
+  }
+  if (minimumVersion && cmpVersion(version, minimumVersion) < 0) {
+    throw new Error(`release manifest still serves ${version}; waiting for ${minimumVersion}`);
+  }
+  const binaryResponse = await fetchImpl(`${origin}/dl/${version}/${file.name}`);
+  if (!binaryResponse.ok || !binaryResponse.body) throw new Error(`binary download: HTTP ${binaryResponse.status}`);
+  const parent = dirname(executable);
+  const temporaryDir = await mkdtemp(join(parent, '.flowviant-update-'));
+  const temporaryFile = join(temporaryDir, file.name);
   try {
-    self = fileURLToPath(import.meta.url);
-  } catch {
-    /* non-file URL — ignore */
+    await pipeline(Readable.fromWeb(binaryResponse.body), createWriteStream(temporaryFile, { mode: 0o755 }));
+    const digest = createHash('sha256');
+    let bytes = 0;
+    for await (const chunk of createReadStream(temporaryFile)) {
+      digest.update(chunk);
+      bytes += chunk.length;
+    }
+    if (bytes !== file.bytes || digest.digest('hex') !== file.sha256) {
+      throw new Error('downloaded binary failed SHA-256 or size verification');
+    }
+    await chmod(temporaryFile, 0o755);
+    const handle = await open(temporaryFile, 'r');
+    try { await handle.sync(); } finally { await handle.close(); }
+    await rename(temporaryFile, executable);
+    // The rename has committed. Directory fsync is best effort on filesystems
+    // that do not support it; a failure here must not claim the binary survived.
+    try {
+      const dirHandle = await open(parent, 'r');
+      try { await dirHandle.sync(); } finally { await dirHandle.close(); }
+    } catch { /* rename already succeeded */ }
+    return version;
+  } finally {
+    await rm(temporaryDir, { recursive: true, force: true }).catch(() => {});
   }
-  return /\bnpx\b/.test(ua) || /[\\/]_npx[\\/]/.test(argv1) || /[\\/]_npx[\\/]/.test(self);
 }
 
 /**
@@ -70,7 +121,7 @@ export function runningViaNpx() {
  * this process alive only as a thin proxy waiting on the child, so the user's
  * shell stays attached to one foreground process.
  */
-function reexec(teardown, { viaNpx = false, target = null } = {}) {
+function reexec(teardown, { viaNpx = false, viaBinary = false, target = null } = {}) {
   try {
     teardown?.();
   } catch {
@@ -84,7 +135,7 @@ function reexec(teardown, { viaNpx = false, target = null } = {}) {
   // on npx's install prompt — the same rule FLOWVIANT_REEXEC keeps below.
   const [cmd, args] = viaNpx
     ? ['npx', ['-y', 'flowviant@latest', ...process.argv.slice(2)]]
-    : [process.execPath, process.argv.slice(1)];
+    : [process.execPath, process.argv.slice(viaBinary ? 2 : 1)];
   const child = spawn(cmd, args, {
     stdio: 'inherit',
     // MARK THE CHILD AS A RESTART, not as a person typing `flowviant`.
@@ -113,6 +164,7 @@ function reexec(teardown, { viaNpx = false, target = null } = {}) {
       // the global path there is no install step whose failure would throw and
       // stop it.
       ...(target ? { FLOWVIANT_UPDATE_TARGET: target } : {}),
+      FLOWVIANT_UPDATE_FROM: VERSION,
     },
   });
   child.on('exit', (code) => process.exit(code ?? 0));
@@ -138,9 +190,18 @@ function installLatest() {
 
 /** `flowviant update` — explicit, manual update. Does not re-exec into a daemon
  *  (the user ran a one-shot command); it installs and tells them to relaunch. */
-export function runUpdateCommand() {
+export async function runUpdateCommand() {
+  if (runningCompiledBinary()) {
+    try {
+      const version = await installBinaryUpdate();
+      ok(`updated to ${version}. Relaunch \`flowviant\` to run the new version.`);
+    } catch (e) {
+      warn(`update failed (${e?.message ?? e}) — running binary untouched.`);
+    }
+    return;
+  }
   if (runningViaNpx()) {
-    note('running via npx — just relaunch with `npx flowviant@latest` to get the newest.');
+    note('running via npx — relaunch `flowviant` to get the newest.');
     return;
   }
   try {
@@ -148,7 +209,7 @@ export function runUpdateCommand() {
     installLatest();
     ok('updated. Relaunch `flowviant` to run the new version.');
   } catch (e) {
-    warn(`update failed (${e?.message ?? e}). Try: npm i -g flowviant@latest`);
+    warn(`update failed (${e?.message ?? e}). Try: ${terminalCommand('update')}`);
   }
 }
 
@@ -170,13 +231,14 @@ const INSTALL_RETRY_MS = 15 * 60_000;
  * React to the server's {latest, min} signal from a roster poll.
  * @returns true if it kicked off a self-update + re-exec (caller must stop).
  */
-export function handleVersionSignal({ latest, min, autoUpdate, safeToUpdate, teardown }) {
+export async function handleVersionSignal({ latest, min, autoUpdate, safeToUpdate, teardown }) {
   const cur = VERSION;
   const belowMin = min && cmpVersion(cur, min) < 0;
   const belowLatest = latest && cmpVersion(cur, latest) < 0;
   if (!belowMin && !belowLatest) return false; // current — nothing to do
   const target = latest || min;
   const npx = runningViaNpx();
+  const binary = runningCompiledBinary();
   const wantInstall = belowMin || autoUpdate;
 
   // A RESTART THAT DID NOT TAKE must not be tried again on the next poll. The
@@ -189,13 +251,42 @@ export function handleVersionSignal({ latest, min, autoUpdate, safeToUpdate, tea
       naggedFor = target;
       warn(
         `restarted to pick up ${target} but came back as ${cur} — staying put. Update by hand: ${
-          npx ? 'relaunch with `npx flowviant@latest`' : 'npm i -g flowviant@latest'
+          binary ? 'run `flowviant update`' : npx ? 'relaunch `flowviant`' : `run \`${terminalCommand('update')}\``
         }.`
       );
     }
     return false;
   }
 
+  if (wantInstall && binary) {
+    if (!safeToUpdate) {
+      if (naggedFor !== target) {
+        naggedFor = target;
+        note(`flowviant ${cur} → ${target} available — self-updating once no turn is running.`);
+      }
+      return false;
+    }
+    if (Date.now() - lastInstallFailAt < INSTALL_RETRY_MS) return false;
+    try {
+      note(`flowviant ${cur} → ${target}: downloading binary…`);
+      const installed = await installBinaryUpdate({ minimumVersion: target });
+      ok('updated — restarting into the new version.');
+      // The replacement is committed. Older copies are cleaned by the NEW
+      // binary in a detached child: in-process, the re-exec below could cut an
+      // `npm uninstall` off halfway and leave a broken global package. The
+      // child skips any copy a daemon still runs from.
+      try {
+        spawn(process.execPath, ['uninstall', '--others', '--yes', '--json'], { detached: true, stdio: 'ignore' }).unref();
+      } catch (e) { warn(`older-copy cleanup: ${e?.message ?? e}`); }
+      reexec(teardown, { viaBinary: true, target: installed });
+      return true;
+    } catch (e) {
+      lastInstallFailAt = Date.now();
+      warn(`binary self-update failed (${e?.message ?? e}) — running binary untouched; retrying in 15m.`);
+      return false;
+    }
+  }
+
   // UNDER NPX THERE IS NOTHING TO INSTALL — the relaunch IS the update, because
   // `npx -y flowviant@latest` resolves `latest` against the registry. Same two
   // gates as the global path: the operator's AUTO_UPDATE choice, and an idle
@@ -215,7 +306,7 @@ export function handleVersionSignal({ latest, min, autoUpdate, safeToUpdate, tea
     return true;
   }
 
-  if (wantInstall && !npx) {
+  if (wantInstall && !npx && !binary) {
     if (!safeToUpdate) {
       // Outdated but a turn is running — wait until the machine is quiet. Nag
       // once meanwhile.
@@ -265,7 +356,7 @@ export function handleVersionSignal({ latest, min, autoUpdate, safeToUpdate, tea
     } catch (e) {
       lastInstallFailAt = Date.now();
       warn(
-        `self-update failed (${e?.message ?? e}) — retrying in 15m; to fix it now: npm i -g flowviant@latest`
+        `self-update failed (${e?.message ?? e}) — retrying in 15m; to fix it now: ${terminalCommand('update')}`
       );
       return false;
     }
@@ -274,7 +365,7 @@ export function handleVersionSignal({ latest, min, autoUpdate, safeToUpdate, tea
   // Can't or won't auto-install → nag once per target version.
   if (naggedFor !== target) {
     naggedFor = target;
-    const how = npx ? 'relaunch with `npx flowviant@latest`' : 'run `npm i -g flowviant@latest`';
+    const how = binary ? 'run `flowviant update`' : npx ? 'relaunch `flowviant`' : `run \`${terminalCommand('update')}\``;
     if (belowMin) {
       warn(`flowviant ${cur} is below the minimum ${min} — live mode may not work. Update: ${how}.`);
     } else {

package/bin/lib/workAgentTurns.mjs

@@ -2,7 +2,8 @@
 import { limitLine } from './workAgentReview.mjs';
 import { existsSync, readFileSync, writeFileSync } from 'node:fs';
 import { join } from 'node:path';
-import { FLEET_URL, FLEET_TOKEN, USER_AGENT } from './config.mjs';
+import { FLEET_URL, FLEET_TOKEN, USER_AGENT, PROJECT_ID } from './config.mjs';
+import { setRuntimeLimit } from './desktopContract.mjs';
 import { git, isSafePathSegment } from './git.mjs';
 import { parseTurnResult } from './agentPlan.mjs';
 import { stashCard } from './agentCards.mjs';
@@ -813,7 +814,9 @@ export function createWorkAgentTurns({
        * sentence it failed with.
        */
       const limit = res ? null : limitLine(out);
+      if (res) setRuntimeLimit(PROJECT_ID, rt, null);
       if (limit) {
+        setRuntimeLimit(PROJECT_ID, rt, limit);
         // Every agent ON THIS CLI parks, because that account is shared: one
         // hitting the limit means all of them have. Named since 2026-09-24 —
         // a machine can hold a Claude login and a Codex login, and a Codex

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "flowviant",
-  "version": "0.99.0",
+  "version": "0.101.0",
   "description": "Run your own coding CLIs as build agents for Flowviant — Claude Code, Codex or Antigravity, on your own credentials. Holds your sessions, keeps a worktree per tab, and ships branches on your word.",
   "type": "module",
   "bin": {
@@ -19,7 +19,6 @@
     "test": "node --test bin/lib/*.test.mjs"
   },
   "dependencies": {
-    "@anthropic-ai/claude-agent-sdk": "^0.3.0",
     "libsodium-wrappers-sumo": "^0.8.4",
     "ws": "^8.18.0"
   },