tfv 5.0.1 → 6.1.0

package/lib/commands/switch.js

@@ -1,19 +1,40 @@
 'use strict'
 
-const {autoSwitch} = require('../modules/switch');
+const { autoSwitch } = require('../modules/switch');
 
 exports.command = 'auto-switch'
 exports.aliases = ['as']
 exports.desc = 'Auto-detect and switch to your project terraform version'
 exports.builder = (yargs) => {
   return yargs
-    .option('verbose', {
-      describe: 'Produce detailed output',
-      type: 'boolean'
+    .option('provider', {
+      alias: 'p',
+      describe: 'Provider: terraform (default) or tofu/opentofu',
+      type: 'string',
+      default: 'terraform',
     })
-    .epilog('Reads version from .terraform-version or required_version in .tf files\nExample: tfv auto-switch')
+    .option('silent', {
+      alias: 's',
+      describe: 'Suppress output (used by shell hooks)',
+      type: 'boolean',
+      default: false,
+    })
+    .epilog([
+      'Reads version from (in priority order):',
+      '  1. .terraform-version file',
+      '  2. terraform.tfstate',
+      '  3. required_version in .tf files',
+      'Examples:',
+      '  tfv auto-switch',
+      '  tfv as --provider tofu',
+    ].join('\n'))
 }
 
-exports.handler = async () => {
-  await autoSwitch();
+exports.handler = async (argv) => {
+  const { silent, provider } = argv;
+  if (silent) {
+    console.log = () => {};
+    console.warn = () => {};
+  }
+  await autoSwitch({ silent }, provider);
 }

package/lib/commands/upgrade.js

@@ -0,0 +1,26 @@
+'use strict'
+
+const { upgrade } = require('../modules/upgrade');
+
+exports.command = 'upgrade [ver]'
+exports.desc = 'Upgrade to the latest patch version in the active (or given) series'
+exports.builder = (yargs) => {
+  return yargs
+    .option('provider', {
+      alias: 'p',
+      describe: 'Provider: terraform (default) or tofu/opentofu',
+      type: 'string',
+      default: 'terraform',
+    })
+    .epilog([
+      'Examples:',
+      '  tfv upgrade               Upgrade active 1.6.x → latest 1.6.x patch',
+      '  tfv upgrade 1.8           Install + use latest 1.8.x',
+      '  tfv upgrade latest        Install + use absolute latest version',
+      '  tfv upgrade --provider tofu',
+    ].join('\n'))
+}
+
+exports.handler = async (argv) => {
+  await upgrade(argv.ver, argv.provider);
+}

package/lib/commands/use.js

@@ -1,22 +1,26 @@
 'use strict'
 
-const yargs = require('yargs');
-const {use} = require('../modules/use');
+const { use } = require('../modules/use');
 
-exports.command = 'use <version>'
-exports.desc = 'Switch to a specified terraform version\n'
+exports.command = 'use <ver>'
+exports.desc = 'Switch to a specified terraform or opentofu version'
 exports.builder = (yargs) => {
   return yargs
-    .option('verbose', {
-      describe: 'Produce detailed output',
-      type: 'boolean',
+    .option('provider', {
+      alias: 'p',
+      describe: 'Provider: terraform (default) or tofu/opentofu',
+      type: 'string',
+      default: 'terraform',
     })
-    .epilog('Example: tfv use 1.5.7')
+    .epilog([
+      'Examples:',
+      '  tfv use 1.7.3',
+      '  tfv use latest',
+      '  tfv use 1.7.3 --provider tofu',
+    ].join('\n'))
 }
 
-exports.handler = async () => {
-  const [,version] = yargs.argv._;
-
-  await use(version);
+exports.handler = async (argv) => {
+  const { ver, provider } = argv;
+  await use(ver, provider);
 }
-

package/lib/commands/validate.js

@@ -0,0 +1,21 @@
+'use strict'
+
+const { runTerraformCommand } = require('../modules/terraform-command');
+
+exports.command = 'validate'
+exports.desc = 'Run terraform validate. Accepts all terraform flags after --'
+exports.builder = (yargs) => {
+  return yargs
+    .option('provider', {
+      alias: 'p',
+      describe: 'Provider: terraform (default) or tofu/opentofu',
+      type: 'string',
+      default: 'terraform',
+    })
+    .epilog('Example: tfv validate -- -json')
+}
+
+exports.handler = async (argv) => {
+  const extraArgs = argv._.slice(1);
+  await runTerraformCommand('validate', null, extraArgs, argv.provider);
+}

package/lib/modules/current.js

@@ -0,0 +1,52 @@
+const { existsSync, readFileSync } = require('fs');
+const { spawnSync } = require('child_process');
+const { normalizeProvider, getCliName, getPaths, getBinTarget, checkPathConflict } = require('../utils/paths');
+const { P_END, P_OK, P_INFO, P_WARN, P_ERROR } = require('../utils/colors');
+
+exports.current = async (providerArg = 'terraform') => {
+  try {
+    const provider = normalizeProvider(providerArg);
+    const paths = getPaths();
+
+    let activeVersion = null;
+    if (existsSync(paths.active)) {
+      const active = JSON.parse(readFileSync(paths.active, 'utf-8'));
+      activeVersion = active[provider];
+    }
+
+    if (!activeVersion) {
+      console.log(`${P_WARN}No active ${provider} version set.${P_END}`);
+      console.log(`Run: ${P_OK}tfv use <version>${providerArg === 'terraform' ? '' : ` --provider ${providerArg}`}${P_END}`);
+      return;
+    }
+
+    // Confirm binary is present and get its real version output
+    const binary = getBinTarget(provider);
+    const cliName = getCliName(provider);
+
+    console.log(`${P_INFO}Active ${provider} version: ${P_OK}${activeVersion}${P_END}`);
+    console.log(`${P_INFO}Binary: ${binary}${P_END}`);
+
+    if (existsSync(binary)) {
+      const result = spawnSync(binary, ['version'], { stdio: 'pipe', encoding: 'utf-8' });
+      if (result.stdout) {
+        const firstLine = result.stdout.split('\n')[0];
+        console.log(`${P_INFO}Reported: ${firstLine}${P_END}`);
+      }
+    } else {
+      console.log(`${P_WARN}Binary not found at ${binary}. Re-run: tfv use ${activeVersion}${providerArg === 'terraform' ? '' : ` --provider ${providerArg}`}${P_END}`);
+    }
+
+    // Check if a conflicting installation shadows tfv's binary
+    const conflict = checkPathConflict(provider);
+    if (conflict.ok) {
+      console.log(`${P_OK}PATH OK — '${cliName}' resolves to tfv-managed binary${P_END}`);
+    } else {
+      console.log(`${P_WARN}PATH CONFLICT — '${cliName}' resolves to: ${conflict.resolved}${P_END}`);
+      console.log(`${P_WARN}Expected:                               ${conflict.expected}${P_END}`);
+      console.log(`${P_INFO}Run ${P_OK}tfv upgrade${P_END}${P_INFO} to re-anchor the PATH automatically.${P_END}`);
+    }
+  } catch (err) {
+    console.log(`${P_ERROR}Error: ${err.message}${P_END}`);
+  }
+};

package/lib/modules/doctor.js

@@ -0,0 +1,160 @@
+const { existsSync, readFileSync, readdirSync } = require('fs');
+const { join } = require('path');
+const { spawnSync } = require('child_process');
+const { platform, homedir } = require('os');
+const { getPaths, getBinTarget, getProviderStore, getCliName, normalizeProvider, checkPathConflict } = require('../utils/paths');
+const { P_END, P_OK, P_ERROR, P_WARN, P_INFO } = require('../utils/colors');
+
+const SHELL_CONFIGS = [
+  join(homedir(), '.zshrc'),
+  join(homedir(), '.bashrc'),
+  join(homedir(), '.bash_profile'),
+  join(homedir(), '.profile'),
+];
+const PATH_MARKER = '# tfv - terraform version manager';
+
+const ok   = (label, detail) => { console.log(`  ${P_OK}✔${P_END}  ${label}`); if (detail) console.log(`     ${P_INFO}${detail}${P_END}`); };
+const fail = (label, hint)   => { console.log(`  ${P_ERROR}✘${P_END}  ${label}`); if (hint) console.log(`     ${P_WARN}${hint}${P_END}`); };
+const info = (label, detail) => { console.log(`  ${P_INFO}–${P_END}  ${label}`); if (detail) console.log(`     ${P_INFO}${detail}${P_END}`); };
+
+exports.doctor = async () => {
+  const paths = getPaths();
+  const isWin = platform() === 'win32';
+  let issues = 0;
+
+  console.log(`\n${P_INFO}tfv doctor${P_END}\n`);
+
+  // ── Store ──────────────────────────────────────────────────────────────────
+  console.log(`${P_OK}Store${P_END}`);
+  for (const p of ['terraform', 'opentofu']) {
+    const store = getProviderStore(p);
+    if (existsSync(store)) {
+      ok(`~/.tfv/store/${p}/ exists`);
+    } else {
+      fail(`~/.tfv/store/${p}/ missing`, 'Run: tfv install latest' + (p === 'opentofu' ? ' --provider tofu' : ''));
+      issues++;
+    }
+  }
+
+  // ── Active versions & binaries ─────────────────────────────────────────────
+  console.log(`\n${P_OK}Active versions${P_END}`);
+  let activeData = { terraform: null, opentofu: null };
+  if (existsSync(paths.active)) {
+    try { activeData = JSON.parse(readFileSync(paths.active, 'utf-8')); } catch {}
+  }
+
+  for (const p of ['terraform', 'opentofu']) {
+    const cli = getCliName(p);
+    const binary = getBinTarget(p);
+    const active = activeData[p];
+
+    const store = getProviderStore(p);
+    const hasInstalled = existsSync(store) &&
+      readdirSync(store).filter(f => f !== 'arch.json').length > 0;
+
+    if (!active) {
+      if (hasInstalled) {
+        fail(`${cli}: no active version set`, `Run: tfv use <version>${p === 'opentofu' ? ' --provider tofu' : ''}`);
+        issues++;
+      } else {
+        info(`${cli}: not set up (no versions installed)`);
+      }
+      continue;
+    }
+
+    ok(`${cli}: active version is ${active}`);
+
+    if (!existsSync(binary)) {
+      fail(`${cli}: binary missing at ${binary}`, `Run: tfv use ${active}${p === 'opentofu' ? ' --provider tofu' : ''}`);
+      issues++;
+      continue;
+    }
+
+    ok(`${cli}: binary exists`);
+
+    const result = spawnSync(binary, ['version'], { stdio: 'pipe', encoding: 'utf-8' });
+    if (result.status === 0 && result.stdout) {
+      ok(`${cli}: executes  (${result.stdout.split('\n')[0].trim()})`);
+    } else {
+      fail(`${cli}: binary failed to execute`, result.stderr ? result.stderr.trim() : 'Unknown error');
+      issues++;
+    }
+  }
+
+  // ── PATH ──────────────────────────────────────────────────────────────────
+  console.log(`\n${P_OK}PATH${P_END}`);
+
+  if (isWin) {
+    info('PATH check skipped on Windows (managed via User PATH registry key)');
+  } else {
+    const pathEntries = (process.env.PATH || '').split(':');
+    const tfvBin = paths.bin;
+
+    if (pathEntries.includes(tfvBin)) {
+      ok('~/.tfv/bin is in PATH');
+
+      const tfvIdx = pathEntries.indexOf(tfvBin);
+      const systemDirs = ['/usr/bin', '/usr/local/bin', '/opt/homebrew/bin'];
+      const systemIdxs = systemDirs
+        .map(d => pathEntries.indexOf(d))
+        .filter(i => i >= 0);
+      const firstSystem = systemIdxs.length ? Math.min(...systemIdxs) : Infinity;
+
+      if (firstSystem < Infinity) {
+        if (tfvIdx < firstSystem) {
+          ok('~/.tfv/bin precedes system dirs in PATH');
+        } else {
+          fail('~/.tfv/bin comes AFTER system dirs in PATH', 'Run: tfv upgrade  to re-anchor PATH');
+          issues++;
+        }
+      }
+    } else {
+      fail('~/.tfv/bin is not in PATH', 'Run: tfv upgrade  to re-anchor PATH');
+      issues++;
+    }
+
+    for (const p of ['terraform', 'opentofu']) {
+      const active = activeData[p];
+      if (!active) continue;
+      const cli = getCliName(p);
+      const conflict = checkPathConflict(p);
+      if (conflict.ok) {
+        ok(`'${cli}' resolves to tfv-managed binary`);
+      } else {
+        fail(`'${cli}' resolves to wrong binary`, `Got: ${conflict.resolved}  Expected: ${conflict.expected}`);
+        issues++;
+      }
+    }
+
+    const configsWithMarker = SHELL_CONFIGS.filter(f => {
+      if (!existsSync(f)) return false;
+      try { return readFileSync(f, 'utf-8').includes(PATH_MARKER); } catch { return false; }
+    });
+    if (configsWithMarker.length > 0) {
+      ok(`PATH block found in shell config`, configsWithMarker.map(f => f.replace(homedir(), '~')).join(', '));
+    } else {
+      fail('PATH block not found in any shell config', `Add: export PATH="$HOME/.tfv/bin:$PATH"  to ~/.zshrc or ~/.bashrc`);
+      issues++;
+    }
+  }
+
+  // ── Cache ─────────────────────────────────────────────────────────────────
+  console.log(`\n${P_OK}Cache${P_END}`);
+  for (const p of ['terraform', 'opentofu']) {
+    const cacheFile = join(paths.cache, `${p}-versions.json`);
+    if (existsSync(cacheFile)) {
+      ok(`${p} version cache exists`);
+    } else {
+      info(`${p} version cache not yet created`, 'Will be built on next: tfv list --remote' + (p === 'opentofu' ? ' --provider tofu' : ''));
+    }
+  }
+
+  // ── Summary ───────────────────────────────────────────────────────────────
+  console.log();
+  if (issues === 0) {
+    console.log(`${P_OK}All checks passed. tfv is healthy.${P_END}\n`);
+  } else {
+    console.log(`${P_ERROR}${issues} issue(s) found. See details above.${P_END}\n`);
+    process.exit(1);
+  }
+};

package/lib/modules/exec.js

@@ -0,0 +1,36 @@
+const { existsSync } = require('fs');
+const { spawn } = require('child_process');
+const { normalizeProvider, getCliName, getVersionFile } = require('../utils/paths');
+const { P_END, P_OK, P_ERROR, P_WARN, P_INFO } = require('../utils/colors');
+
+exports.exec = async (version, extraArgs = [], providerArg = 'terraform') => {
+  try {
+    const provider = normalizeProvider(providerArg);
+    const cli = getCliName(provider);
+    const binary = getVersionFile(provider, version);
+
+    if (!existsSync(binary)) {
+      console.log(`${P_ERROR}${provider} ${version} is not installed.${P_END}`);
+      console.log(`Run: ${P_OK}tfv install ${version}${provider === 'opentofu' ? ' --provider tofu' : ''}${P_END}`);
+      process.exit(1);
+    }
+
+    console.log(`${P_INFO}Using ${provider} ${version} (active version unchanged)${P_END}`);
+    if (extraArgs.length > 0) {
+      console.log(`${P_OK}Running: ${cli} ${extraArgs.join(' ')}${P_END}\n`);
+    }
+
+    const tf = spawn(binary, extraArgs, { stdio: 'inherit', cwd: process.cwd() });
+
+    tf.on('error', (err) => {
+      console.log(`${P_ERROR}Error executing ${cli} ${version}: ${err.message}${P_END}`);
+      process.exit(1);
+    });
+
+    tf.on('close', code => process.exit(code ?? 0));
+
+  } catch (err) {
+    console.log(`${P_ERROR}Error: ${err.message}${P_END}`);
+    process.exit(1);
+  }
+};