voxflow 1.15.0 → 1.15.2

package/lib/commands/upgrade.js

@@ -0,0 +1,249 @@
+/**
+ * VoxFlow CLI — Upgrade command
+ *
+ * One-shot self-update: fetch the latest version from the npm registry,
+ * compare against the running version, and run the appropriate package
+ * manager (npm / pnpm / yarn — auto-detected from the install prefix).
+ * Optionally re-installs bundled skills so SKILL.md files stay in sync
+ * with the new binary.
+ *
+ * Designed to be safe to run from inside a Skill flow — the agent can
+ * invoke `voxflow upgrade -y` non-interactively when it detects an
+ * outdated CLI mid-session.
+ */
+
+const { spawn, execFileSync } = require('child_process');
+const https = require('https');
+
+const PKG_NAME = 'voxflow';
+const REGISTRY_URL = `https://registry.npmjs.org/${PKG_NAME}/latest`;
+const NETWORK_TIMEOUT_MS = 5_000;
+
+function parseFlag(args, ...flags) {
+  for (const flag of flags) {
+    const idx = args.indexOf(flag);
+    if (idx !== -1 && idx + 1 < args.length) return args[idx + 1];
+  }
+  return null;
+}
+
+function parseBoolFlag(args, ...flags) {
+  return flags.some((f) => args.includes(f));
+}
+
+function fetchLatestVersion() {
+  return new Promise((resolve, reject) => {
+    const req = https.get(REGISTRY_URL, { timeout: NETWORK_TIMEOUT_MS }, (res) => {
+      if (res.statusCode !== 200) {
+        res.resume();
+        reject(new Error(`registry HTTP ${res.statusCode}`));
+        return;
+      }
+      let body = '';
+      res.setEncoding('utf8');
+      res.on('data', (c) => { body += c; });
+      res.on('end', () => {
+        try {
+          const v = JSON.parse(body).version;
+          if (typeof v === 'string') resolve(v);
+          else reject(new Error('no version in registry response'));
+        } catch (err) { reject(err); }
+      });
+    });
+    req.on('error', reject);
+    req.on('timeout', () => req.destroy(new Error('timeout')));
+  });
+}
+
+function cmpVersion(a, b) {
+  const parse = (v) => String(v).split('-')[0].split('.').map((n) => parseInt(n, 10) || 0);
+  const pa = parse(a);
+  const pb = parse(b);
+  for (let i = 0; i < 3; i++) {
+    const diff = (pa[i] || 0) - (pb[i] || 0);
+    if (diff !== 0) return diff;
+  }
+  return 0;
+}
+
+/**
+ * Detect which package manager owns the global voxflow install.
+ *
+ * Heuristic: walk up from `process.argv[1]` (the resolved bin path) looking
+ * for a directory that contains `pnpm` / `yarn` / `npm` in its prefix or
+ * config. Falls back to npm if nothing else fits.
+ */
+function detectPackageManager() {
+  const binPath = process.argv[1] || '';
+  const lower = binPath.toLowerCase();
+  if (lower.includes('/pnpm/') || lower.includes('\\pnpm\\')) return 'pnpm';
+  if (lower.includes('/yarn/') || lower.includes('\\yarn\\')) return 'yarn';
+  // bun global install
+  if (lower.includes('/.bun/') || lower.includes('\\.bun\\')) return 'bun';
+  // Honor explicit override.
+  if (process.env.VOXFLOW_UPGRADE_PM) return process.env.VOXFLOW_UPGRADE_PM;
+  return 'npm';
+}
+
+function buildInstallCommand(pm, target) {
+  switch (pm) {
+    case 'pnpm': return { cmd: 'pnpm', args: ['add', '-g', target] };
+    case 'yarn': return { cmd: 'yarn', args: ['global', 'add', target] };
+    case 'bun':  return { cmd: 'bun',  args: ['add', '-g', target] };
+    case 'npm':
+    default:     return { cmd: 'npm',  args: ['install', '-g', target] };
+  }
+}
+
+function commandExists(cmd) {
+  try {
+    execFileSync(process.platform === 'win32' ? 'where' : 'which', [cmd], { stdio: 'ignore' });
+    return true;
+  } catch {
+    return false;
+  }
+}
+
+function runStreaming(cmd, args, { cwd } = {}) {
+  return new Promise((resolve, reject) => {
+    const child = spawn(cmd, args, { cwd, stdio: 'inherit', shell: false });
+    child.on('error', reject);
+    child.on('exit', (code) => {
+      if (code === 0) resolve();
+      else reject(new Error(`${cmd} ${args.join(' ')} exited with code ${code}`));
+    });
+  });
+}
+
+async function upgrade(opts = {}) {
+  const currentVersion = require('../../package.json').version;
+  const wantedVersion = opts.version || null;
+
+  let latest = wantedVersion;
+  if (!latest) {
+    process.stderr.write('Checking npm registry for latest voxflow...\n');
+    latest = await fetchLatestVersion();
+  }
+
+  process.stdout.write(`Current: voxflow@${currentVersion}\n`);
+  process.stdout.write(`Target:  voxflow@${latest}\n`);
+
+  const isUpToDate = !wantedVersion && cmpVersion(latest, currentVersion) <= 0;
+
+  if (opts.check) {
+    if (isUpToDate) {
+      process.stdout.write('\n✓ Already on the latest version. Nothing to do.\n');
+      return { upgraded: false, current: currentVersion, latest, available: false };
+    }
+    process.stdout.write(`\n▲ Newer version available: ${currentVersion} → ${latest}\n`);
+    process.stdout.write('  Run `voxflow upgrade -y` to install (non-interactive).\n');
+    return { upgraded: false, current: currentVersion, latest, available: true };
+  }
+
+  if (isUpToDate && !opts.force) {
+    process.stdout.write('\n✓ Already on the latest version. Nothing to do.\n');
+    process.stdout.write('  (use --force to reinstall, --version <ver> for a specific version,\n');
+    process.stdout.write('   or `voxflow skills install --all` to refresh skill files only)\n');
+    return { upgraded: false, current: currentVersion, latest };
+  }
+
+  if (opts.dryRun) {
+    const pm = detectPackageManager();
+    const { cmd, args } = buildInstallCommand(pm, `${PKG_NAME}@${latest}`);
+    process.stdout.write(`\n[dry-run] would run: ${cmd} ${args.join(' ')}\n`);
+    if (opts.installSkills) process.stdout.write('[dry-run] would run: voxflow skills install --all -y\n');
+    return { upgraded: false, current: currentVersion, latest, dryRun: true };
+  }
+
+  // Confirmation gate (skipped with -y / non-TTY).
+  if (!opts.yes && process.stdin.isTTY) {
+    const ok = await confirm(`Upgrade voxflow ${currentVersion} → ${latest}? [Y/n] `);
+    if (!ok) {
+      process.stdout.write('Aborted.\n');
+      return { upgraded: false, current: currentVersion, latest, aborted: true };
+    }
+  }
+
+  const pm = detectPackageManager();
+  if (!commandExists(pm)) {
+    throw new Error(
+      `Detected package manager "${pm}" is not on PATH. ` +
+      `Set VOXFLOW_UPGRADE_PM=npm (or pnpm/yarn/bun) and retry.`
+    );
+  }
+  const target = `${PKG_NAME}@${latest}`;
+  const { cmd, args } = buildInstallCommand(pm, target);
+
+  process.stdout.write(`\n==> Running: ${cmd} ${args.join(' ')}\n`);
+  await runStreaming(cmd, args);
+
+  process.stdout.write(`\n✓ voxflow@${latest} installed.\n`);
+
+  if (opts.installSkills !== false) {
+    process.stdout.write('\n==> Re-installing bundled skills (so SKILL.md stays in sync)...\n');
+    // Use the freshly-installed binary by name; PATH should pick up the same
+    // bin entry. We pass -y so it stays non-interactive in agent flows.
+    try {
+      await runStreaming(PKG_NAME, ['skills', 'install', '--all', '-y']);
+    } catch (err) {
+      process.stderr.write(`\nWarning: skills install failed (${err.message}).\n`);
+      process.stderr.write(`Run it manually: voxflow skills install --all\n`);
+    }
+  }
+
+  process.stdout.write(`\n✓ Upgrade complete. voxflow${latest === currentVersion ? '' : ` ${currentVersion} →`} ${latest}\n`);
+  return { upgraded: true, current: currentVersion, latest };
+}
+
+function confirm(prompt) {
+  return new Promise((resolve) => {
+    process.stdout.write(prompt);
+    let buf = '';
+    const onData = (chunk) => {
+      buf += chunk.toString();
+      if (buf.includes('\n')) {
+        process.stdin.off('data', onData);
+        process.stdin.pause();
+        const answer = buf.trim().toLowerCase();
+        resolve(answer === '' || answer === 'y' || answer === 'yes');
+      }
+    };
+    process.stdin.resume();
+    process.stdin.on('data', onData);
+  });
+}
+
+async function handle(args) {
+  const opts = {
+    yes: parseBoolFlag(args, '-y', '--yes'),
+    check: parseBoolFlag(args, '--check'),
+    dryRun: parseBoolFlag(args, '--dry-run'),
+    force: parseBoolFlag(args, '--force'),
+    installSkills: !parseBoolFlag(args, '--no-skills'),
+    version: parseFlag(args, '--version'),
+  };
+  await upgrade(opts);
+}
+
+const meta = {
+  upgrade: {
+    usage: '[opts]',
+    description: 'Update voxflow CLI to the latest npm version + refresh bundled skills',
+    options: [
+      `-y, --yes            Skip confirmation prompt (use in agent / CI flows)`,
+      `--check              Only check for newer version (no install)`,
+      `--dry-run            Print the install command without running it`,
+      `--force              Reinstall even when already on the latest version`,
+      `--no-skills          Skip the post-install \`voxflow skills install --all\``,
+      `--version <ver>      Install a specific version instead of latest`,
+    ],
+    examples: [
+      'voxflow upgrade              # interactive prompt',
+      'voxflow upgrade -y           # silent (for agents / Skills)',
+      'voxflow upgrade --check      # just see if a newer version exists',
+      'voxflow upgrade --version 1.12.0',
+    ],
+  },
+};
+
+module.exports = { upgrade, handle, meta, _test: { cmpVersion, detectPackageManager, buildInstallCommand } };