flowviant 0.102.2 → 0.104.0

package/bin/lib/versionOrder.mjs

@@ -0,0 +1,42 @@
+/**
+ * VERSION ORDER — the one parser and comparator every version decision on this
+ * box uses: the takeover downgrade guard (instance.mjs), the self-update
+ * signals (update.mjs, fleet.mjs), the behind marks in the read-only views
+ * (views.mjs) and the newest nvm Node (loginPath.mjs).
+ *
+ * Split out (SOLID F005) because four hand-written rules disagreed on a
+ * version they could not read: one called it EQUAL, one called each
+ * unreadable part ZERO, one called it "not older", one never asked. A
+ * comparison now answers UNKNOWN (`null`) out loud, and each caller states its
+ * own policy for it. Every policy so far is the house one: unknown gates
+ * nothing (the takeover guard refuses only a measured downgrade).
+ *
+ * What parses: an optional leading `v`, one to three dot-separated decimal
+ * parts (a missing minor or patch reads as zero — `0.57` is `0.57.0`, the
+ * legacy shape the update tests pin), and an optional `-prerelease`/`+build`
+ * tail, which orders nothing (every rule this replaced ignored it too).
+ * Anything else — a letter inside a part, a fourth part, an empty string — is
+ * unknown.
+ */
+const VERSION_RE = /^v?(\d+)(?:\.(\d+))?(?:\.(\d+))?(?:[-+][0-9A-Za-z.+-]*)?$/;
+
+/** `[major, minor, patch]`, or null when the text is not a version. */
+export function parseVersion(v) {
+  if (typeof v !== 'string' && typeof v !== 'number') return null;
+  const m = VERSION_RE.exec(String(v).trim());
+  if (!m) return null;
+  const parts = [m[1], m[2] ?? '0', m[3] ?? '0'].map(Number);
+  return parts.every(Number.isSafeInteger) ? parts : null;
+}
+
+/** -1 | 0 | 1, or null (UNKNOWN) when either side does not parse. */
+export function compareVersions(a, b) {
+  const x = parseVersion(a);
+  const y = parseVersion(b);
+  if (!x || !y) return null;
+  for (let i = 0; i < 3; i++) if (x[i] !== y[i]) return x[i] > y[i] ? 1 : -1;
+  return 0;
+}
+
+/** True only when BOTH parse and `a` is strictly older. Unknown is not older. */
+export const versionBelow = (a, b) => compareVersions(a, b) === -1;

package/bin/lib/views.mjs

@@ -11,22 +11,19 @@ import { execFileSync, spawn } from 'node:child_process';
 import { closeSync, existsSync, openSync, readSync, statSync } from 'node:fs';
 import { FLEET_URL, USER_AGENT, VERSION } from './config.mjs';
 import { detectRepoRoot, listStoredProjects, projectLabel, resolveStoredCredential } from './credentials.mjs';
-import { daemonLogPath, desktopStatusRemote, installChannel } from './desktopContract.mjs';
+import { desktopStatusRemote, installChannel } from './desktopContract.mjs';
+import { daemonLogPath } from './daemonState.mjs';
 import { daemonRunningFor } from './instance.mjs';
-import { agoFrom } from './machines.mjs';
-import { detectRuntimes } from './runtimes.mjs';
+import { agoFrom } from './machineListing.mjs';
+import { detectRuntimes } from './runtimeDetection.mjs';
 import { c } from './ui.mjs';
+import { versionBelow } from './versionOrder.mjs';
 
 const APP_URL = process.env.FLOWVIANT_APP_URL || 'https://app.flowviant.com';
 
-function olderVersion(version, latest) {
-  const parse = (v) => /^v?(\d+)\.(\d+)\.(\d+)/.exec(String(v ?? ''))?.slice(1, 4).map(Number);
-  const a = parse(version);
-  const b = parse(latest);
-  if (!a || !b) return false;
-  for (let i = 0; i < 3; i++) if (a[i] !== b[i]) return a[i] < b[i];
-  return false;
-}
+// "Behind" in these views is versionBelow (versionOrder.mjs): an unreadable
+// version is never marked older — a read-only view states nothing it cannot
+// measure.
 
 function agentLine(agent, now) {
   if (agent.asks) return `${agent.name} · ${c.yellow('asks you a question')}`;
@@ -69,7 +66,7 @@ export function renderStatus(status, { now = Date.now() } = {}) {
       if (rt.parkedByLimit && rt.message) lines.push(label('limit', `${rt.id} hit its limit: “${rt.message}”`));
     }
     const version = remote?.daemonVersion ?? status.version;
-    if (remote?.latest && olderVersion(version, remote.latest)) {
+    if (remote?.latest && versionBelow(version, remote.latest)) {
       lines.push(label('update', `flowviant ${remote.latest} is out; this computer runs ${version}. It updates itself when idle.`));
     }
     lines.push('');
@@ -194,6 +191,32 @@ export async function runDoctor({ cwd = process.cwd(), fetchImpl = fetch } = {})
     entry ? `Connected to ${projectLabel(entry)}` : 'This repo is not connected to a project',
     'Run `flowviant login` here and approve it in your browser.');
 
+  // EVERY COPY ON THIS BOX, and which one a daemon runs from. An old copy with a
+  // live daemon is the usual reason the app reports a version older than the
+  // one just installed: `uninstall --others` skips a copy a daemon runs from,
+  // and a global npm install that needed sudo cannot update itself.
+  try {
+    const { buildUninstallPlan } = await import('./uninstall.mjs');
+    const { copyKind } = await import('./uninstallCopies.mjs');
+    const plan = await buildUninstallPlan();
+    // Copies a daemon can run from; an rc file's PATH line is not one.
+    const copies = plan.copies.filter((copy) => copyKind(copy.kind).runsFrom);
+    for (const copy of copies) {
+      const kind = copyKind(copy.kind);
+      const where = kind.label;
+      const running = copy.runningPid ? `, a daemon runs from it (pid ${copy.runningPid})` : '';
+      const older = copy.version && versionBelow(copy.version, VERSION);
+      const text = `flowviant ${copy.version ?? '(unknown version)'} · ${where} · ${copy.path}${copy.current ? ' (this one)' : ''}${running}`;
+      if (older && copy.runningPid) {
+        add(false, text, `An older daemon is serving. Run \`flowviant stop\`, then \`flowviant uninstall --others\`${kind.removeHint}, then start flowviant again.`);
+      } else if (older) {
+        add(false, text, `An older copy. Remove it with \`flowviant uninstall --others\`${kind.removeHint}.`);
+      } else {
+        add(true, text);
+      }
+    }
+  } catch { /* the listing is best-effort */ }
+
   const health = String(FLEET_URL).replace(/\/api\/.*$/, '/health');
   let reach = null;
   try {