tfv 5.0.1 → 6.1.0

package/lib/modules/terraform-command.js

@@ -1,19 +1,17 @@
 const fs = require('fs');
-const {spawn} = require('child_process');
-const {P_END, P_OK, P_ERROR, P_WARN, P_INFO} = require('../utils/colors');
+const { spawn } = require('child_process');
+const { normalizeProvider, getCliName, getBinTarget } = require('../utils/paths');
+const { P_END, P_OK, P_ERROR, P_WARN, P_INFO } = require('../utils/colors');
 
 /**
- * Removes comments from Terraform content
- * Handles: # comments, // comments, and block comments
+ * Removes comments from Terraform content.
+ * Handles: # comments, // comments, and block comments.
  */
 const removeComments = (content) => {
-  // Remove block comments /* */
   content = content.replace(/\/\*[\s\S]*?\*\//g, '');
 
-  // Remove single line comments (# and //)
   const lines = content.split('\n');
   const cleanedLines = lines.map(line => {
-    // Find position of # or // that's not inside a string
     let inString = false;
     let stringChar = '';
     let commentStart = -1;
@@ -35,70 +33,47 @@ const removeComments = (content) => {
       }
     }
 
-    if (commentStart !== -1) {
-      return line.substring(0, commentStart);
-    }
-    return line;
+    return commentStart !== -1 ? line.substring(0, commentStart) : line;
   });
 
   return cleanedLines.join('\n');
 };
 
 /**
- * Extracts terraform targets from file content
- * Returns array of target strings like "aws_instance.example", "module.vpc", etc.
+ * Extracts terraform targets from file content.
  */
 const extractTargets = (content) => {
   const targets = [];
+  const clean = removeComments(content);
 
-  // Remove comments first
-  const cleanContent = removeComments(content);
-
-  // Pattern for resource blocks: resource "type" "name"
   const resourcePattern = /resource\s+"([^"]+)"\s+"([^"]+)"/g;
-  let match;
-  while ((match = resourcePattern.exec(cleanContent)) !== null) {
-    targets.push(`${match[1]}.${match[2]}`);
-  }
-
-  // Pattern for data blocks: data "type" "name"
   const dataPattern = /data\s+"([^"]+)"\s+"([^"]+)"/g;
-  while ((match = dataPattern.exec(cleanContent)) !== null) {
-    targets.push(`data.${match[1]}.${match[2]}`);
-  }
-
-  // Pattern for module blocks: module "name"
   const modulePattern = /module\s+"([^"]+)"/g;
-  while ((match = modulePattern.exec(cleanContent)) !== null) {
-    targets.push(`module.${match[1]}`);
-  }
+
+  let match;
+  while ((match = resourcePattern.exec(clean)) !== null) targets.push(`${match[1]}.${match[2]}`);
+  while ((match = dataPattern.exec(clean)) !== null) targets.push(`data.${match[1]}.${match[2]}`);
+  while ((match = modulePattern.exec(clean)) !== null) targets.push(`module.${match[1]}`);
 
   return targets;
 };
 
-/**
- * Extracts targets from one or more terraform files
- */
 const extractTargetsFromFiles = (files) => {
   const allTargets = [];
   const fileList = Array.isArray(files) ? files : [files];
 
   fileList.forEach(filename => {
     if (!fs.existsSync(filename)) {
-      console.log(`${P_WARN}Warning: File '${filename}' not found, skipping${P_END}`);
+      console.log(`${P_WARN}Warning: '${filename}' not found, skipping${P_END}`);
       return;
     }
 
-    const content = fs.readFileSync(filename, 'utf8');
-    const targets = extractTargets(content);
-
+    const targets = extractTargets(fs.readFileSync(filename, 'utf8'));
     if (targets.length > 0) {
       console.log(`${P_INFO}Found ${targets.length} target(s) in '${filename}':${P_END}`);
-      targets.forEach(target => {
-        console.log(`  - ${target}`);
-        if (!allTargets.includes(target)) {
-          allTargets.push(target);
-        }
+      targets.forEach(t => {
+        console.log(`  - ${t}`);
+        if (!allTargets.includes(t)) allTargets.push(t);
       });
     } else {
       console.log(`${P_WARN}No targets found in '${filename}'${P_END}`);
@@ -109,54 +84,61 @@ const extractTargetsFromFiles = (files) => {
 };
 
 /**
- * Runs a terraform command (plan, apply, destroy) with optional file-based targets
- * @param {string} command - The terraform command (plan, apply, destroy)
- * @param {string|string[]} files - Optional file(s) to extract targets from
- * @param {string[]} extraArgs - Additional arguments to pass to terraform
+ * Runs a terraform/tofu command with optional file-based targets.
+ * Uses the active tfv-managed binary from ~/.tfv/bin so that `tfv plan`
+ * and a bare `terraform plan` always use the exact same binary.
+ *
+ * @param {string} command   - terraform subcommand (plan, apply, destroy, init, fmt, validate…)
+ * @param {string|string[]} files  - optional file(s) to extract -target args from
+ * @param {string[]} extraArgs     - additional flags passed after --
+ * @param {string} providerArg     - 'terraform' (default) or 'tofu'/'opentofu'
  */
-exports.runTerraformCommand = async (command, files, extraArgs = []) => {
+exports.runTerraformCommand = async (command, files, extraArgs = [], providerArg = 'terraform') => {
   try {
+    const provider = normalizeProvider(providerArg);
+    const cli = getCliName(provider);
+
+    // Resolve the exact binary tfv manages; fall back to PATH-resolved cli name
+    // This guarantees tfv commands and bare `terraform`/`tofu` point to the same binary.
+    const binaryPath = getBinTarget(provider);
+    const binary = fs.existsSync(binaryPath) ? binaryPath : cli;
+
     const args = [command];
 
-    // Extract targets from files if provided
     if (files && (Array.isArray(files) ? files.length > 0 : true)) {
       console.log(`${P_OK}Extracting targets from file(s)...${P_END}\n`);
       const targets = extractTargetsFromFiles(files);
 
       if (targets.length > 0) {
         console.log(`\n${P_OK}Total unique targets: ${targets.length}${P_END}\n`);
-        targets.forEach(target => {
-          args.push('-target', target);
-        });
+        targets.forEach(t => args.push('-target', t));
       } else {
-        console.log(`${P_WARN}No targets extracted from files. Running without file-based targets.${P_END}\n`);
+        console.log(`${P_WARN}No targets extracted. Running without file-based targets.${P_END}\n`);
       }
     }
 
-    // Add any extra arguments passed through
-    if (extraArgs && extraArgs.length > 0) {
-      args.push(...extraArgs);
-    }
+    if (extraArgs && extraArgs.length > 0) args.push(...extraArgs);
 
-    console.log(`${P_OK}Running: terraform ${args.join(' ')}${P_END}\n`);
+    console.log(`${P_OK}Running: ${cli} ${args.join(' ')}${P_END}\n`);
 
-    // Execute terraform command
-    const tf = spawn('terraform', args, {
-      stdio: 'inherit',
-      cwd: process.cwd()
-    });
+    const tf = spawn(binary, args, { stdio: 'inherit', cwd: process.cwd() });
 
     tf.on('error', (err) => {
-      console.log(`${P_ERROR}Error executing terraform: ${err.message}${P_END}`);
+      console.log(`${P_ERROR}Error executing ${cli}: ${err.message}${P_END}`);
+      if (err.code === 'ENOENT') {
+        console.log(`${P_WARN}${cli} not found. Run: tfv install latest${providerArg === 'terraform' ? '' : ` --provider ${providerArg}`}${P_END}`);
+      }
       process.exit(1);
     });
 
-    tf.on('close', (code) => {
-      process.exit(code);
-    });
+    tf.on('close', code => process.exit(code));
 
   } catch (err) {
     console.log(`${P_ERROR}Error: ${err.message}${P_END}`);
     process.exit(1);
   }
 };
+
+// Export helpers for testing
+exports.removeComments = removeComments;
+exports.extractTargets = extractTargets;

package/lib/modules/upgrade.js

@@ -0,0 +1,93 @@
+const { existsSync, readFileSync, readdirSync } = require('fs');
+const { normalizeProvider, getProviderStore, getPaths, fixPathConflict } = require('../utils/paths');
+const { fetchAllVersions } = require('./remote');
+const { install } = require('./install');
+const { use } = require('./use');
+const { P_END, P_OK, P_INFO, P_WARN, P_ERROR } = require('../utils/colors');
+
+/**
+ * Upgrade to the latest available patch within a version series.
+ *
+ * tfv upgrade           → upgrades active version's patch (e.g. 1.6.3 → 1.6.7)
+ * tfv upgrade 1.8       → installs + uses latest 1.8.x
+ * tfv upgrade latest    → installs + uses absolute latest version
+ */
+exports.upgrade = async (target, providerArg = 'terraform') => {
+  try {
+    const provider = normalizeProvider(providerArg);
+    const allVersions = await fetchAllVersions(provider);
+
+    let seriesPrefix;
+
+    if (!target || target === 'current') {
+      // Determine from active version
+      const paths = getPaths();
+      if (!existsSync(paths.active)) {
+        console.log(`${P_ERROR}No active ${provider} version. Run: tfv use <version>  first.${P_END}`);
+        process.exit(1);
+      }
+      const active = JSON.parse(readFileSync(paths.active, 'utf-8'));
+      const activeVersion = active[provider];
+      if (!activeVersion) {
+        console.log(`${P_ERROR}No active ${provider} version set.${P_END}`);
+        process.exit(1);
+      }
+      const parts = activeVersion.split('.');
+      seriesPrefix = `${parts[0]}.${parts[1]}`;
+      console.log(`${P_INFO}Upgrading ${provider} ${activeVersion} (${seriesPrefix}.x series)...${P_END}`);
+    } else if (target === 'latest') {
+      const latest = allVersions[0];
+      console.log(`${P_INFO}Latest available ${provider} version: ${latest}${P_END}`);
+      const installed = await install(latest, null, providerArg);
+      if (installed) await use(installed, provider);
+      return;
+    } else {
+      // Target is a series like "1.8" or "1.8.0"
+      const parts = target.split('.');
+      seriesPrefix = parts.length >= 2 ? `${parts[0]}.${parts[1]}` : `${parts[0]}`;
+      console.log(`${P_INFO}Finding latest ${provider} in ${seriesPrefix}.x series...${P_END}`);
+    }
+
+    const seriesVersions = allVersions.filter(v => v.startsWith(`${seriesPrefix}.`));
+    if (seriesVersions.length === 0) {
+      console.log(`${P_ERROR}No versions found in ${seriesPrefix}.x series${P_END}`);
+      process.exit(1);
+    }
+
+    const latestInSeries = seriesVersions[0]; // Already sorted descending
+
+    // Check if already on latest
+    const paths = getPaths();
+    if (existsSync(paths.active)) {
+      const active = JSON.parse(readFileSync(paths.active, 'utf-8'));
+      if (active[provider] === latestInSeries) {
+        console.log(`${P_OK}Already on latest ${provider} in ${seriesPrefix}.x series: ${latestInSeries}${P_END}`);
+        return;
+      }
+    }
+
+    // Check if already in store
+    const store = getProviderStore(provider);
+    const inStore = readdirSync(store)
+      .filter(f => f !== 'arch.json')
+      .map(f => f.replace('.exe', ''))
+      .includes(latestInSeries);
+
+    if (inStore) {
+      console.log(`${P_INFO}${provider} ${latestInSeries} already installed, switching...${P_END}`);
+      await use(latestInSeries, provider);
+    } else {
+      console.log(`${P_INFO}Installing ${provider} ${latestInSeries}...${P_END}`);
+      const installed = await install(latestInSeries, null, providerArg);
+      if (installed) await use(installed, provider);
+    }
+
+    // Re-run PATH setup on upgrade in case a system tool (brew/apt) was
+    // installed after tfv and is now shadowing ~/.tfv/bin
+    fixPathConflict();
+
+  } catch (err) {
+    console.log(`${P_ERROR}Upgrade failed: ${err.message}${P_END}`);
+    process.exit(1);
+  }
+};

package/lib/modules/use.js

@@ -1,71 +1,75 @@
 const os = require('os');
-const {join} = require('path');
-const {spawnSync} = require('child_process');
-const {readdirSync, mkdirSync, copyFileSync, existsSync} = require('fs');
-const {setWindowsTerraform} = require('./ps1');
-const {P_END, P_OK, P_INFO, P_ERROR} = require('../utils/colors');
+const { existsSync, readdirSync, copyFileSync, readFileSync, writeFileSync } = require('fs');
+const {
+  normalizeProvider, getCliName, getProviderStore,
+  getBinTarget, getVersionFile, getPaths, initDirs
+} = require('../utils/paths');
 const { checkStore } = require('../utils/store');
+const { ensureWindowsPath } = require('./ps1');
+const { P_END, P_OK, P_INFO, P_ERROR } = require('../utils/colors');
 
-exports.use = async (tfVer) => {
+exports.use = async (tfVer, providerArg = 'terraform') => {
   try {
-    const store = join(__dirname, '../..', 'store');
-
-    checkStore(store);
-
-    let version = os.platform() === 'win32' ? `${tfVer}.exe` : tfVer;
-
-    if (tfVer === 'latest') {
-      [version] = readdirSync(store).sort((a, b) => {
-        let aVer = a.replace(/(.exe)/g, '');
-        let bVer = b.replace(/(.exe)/g, '');
-
-        const major = /.*\./g;
-
-        const [aMajor] = aVer.match(major);
-        const aMin = aVer.replace(aMajor, '');
-        const aMinUpdate = aMin.length === 1 ? `0${aMin}` : aMin;
-        aVer = `${aMajor}${aMinUpdate}`.replace(/\.(?!.*\.)/g, '');
-
-        const [bMajor] = bVer.match(major);
-        const bMin = bVer.replace(bMajor, '');
-        const bMinUpdate = bMin.length === 1 ? `0${bMin}` : bMin;
-        bVer = `${bMajor}${bMinUpdate}`.replace(/\.(?!.*\.)/g, '');
-
-        return Number(bVer) - Number(aVer);
-      });
-
-      console.log(`${P_INFO}Your latest installed version is ${version}${P_END}`);
+    initDirs();
+
+    const provider = normalizeProvider(providerArg);
+    checkStore(provider);
+
+    const store = getProviderStore(provider);
+    const isWin = os.platform() === 'win32';
+    let version = tfVer;
+
+    if (version === 'latest') {
+      const files = readdirSync(store)
+        .filter(f => f !== 'arch.json')
+        .map(f => f.replace('.exe', ''));
+
+      version = files.sort((a, b) => {
+        const aParts = a.split('.').map(n => parseInt(n, 10) || 0);
+        const bParts = b.split('.').map(n => parseInt(n, 10) || 0);
+        for (let i = 0; i < 3; i++) {
+          const diff = (bParts[i] || 0) - (aParts[i] || 0);
+          if (diff !== 0) return diff;
+        }
+        return 0;
+      })[0];
+
+      console.log(`${P_INFO}Latest installed ${provider} version: ${version}${P_END}`);
     }
 
-    console.log(`${P_INFO}Switching to terraform ${version.replace('.exe', '')}${P_END}`);
-
-    const source = `${store}/${version}`;
+    const source = getVersionFile(provider, version);
 
     if (!existsSync(source)) {
-      console.log(`${P_ERROR}terraform ${version} is not installed${P_END}`);
-      return console.log(`To install this version Run: ${P_OK}tfv install ${version}${P_END}`);
+      console.log(`${P_ERROR}${provider} ${version} is not installed${P_END}`);
+      const pFlag = providerArg === 'terraform' ? '' : ` --provider ${providerArg}`;
+      return console.log(`To install, run: ${P_OK}tfv install ${version}${pFlag}${P_END}`);
     }
 
-    let destination;
+    console.log(`${P_INFO}Switching to ${provider} ${version}...${P_END}`);
 
-    if (['darwin', 'linux'].includes(os.platform())) {
-      const bin = os.platform() === 'darwin' ? '/usr/local/bin' : `${os.homedir()}/bin`;
+    const destination = getBinTarget(provider);
+    copyFileSync(source, destination);
 
-      destination = `${bin}/terraform`;
-      if (existsSync(destination)) spawnSync('sudo', ['rm', '-f', `${destination}`], {stdio: 'inherit', shell: true});
-      spawnSync('sudo', ['cp', `${source}`, `${destination}`], {stdio: 'inherit', shell: true});
+    if (!isWin) {
+      const { chmodSync } = require('fs');
+      chmodSync(destination, '755');
     }
 
-    if (os.platform() === 'win32') {
-      mkdirSync('C:\\terraform', { recursive: true });
-      destination = 'C:\\terraform\\terraform.exe';
+    // Update active.json
+    const paths = getPaths();
+    const active = existsSync(paths.active)
+      ? JSON.parse(readFileSync(paths.active, 'utf-8'))
+      : { terraform: null, opentofu: null };
+    active[provider] = version;
+    writeFileSync(paths.active, JSON.stringify(active, null, 2));
 
-      copyFileSync(source, destination);
-      setWindowsTerraform();
-    }
+    // Ensure ~/.tfv/bin is on PATH for Windows (idempotent)
+    if (isWin) ensureWindowsPath();
+
+    console.log(`${P_OK}Now using ${provider} ${version}${P_END}`);
 
-    console.log(`${P_OK}Successful!${P_END}`)
-  } catch ({message}) {
-    console.log('ERROR:', message)
+  } catch (err) {
+    console.log(`${P_ERROR}Error: ${err.message}${P_END}`);
+    process.exit(1);
   }
-}
+};

package/lib/utils/formatVersions.js

@@ -1,6 +1,58 @@
-exports.formatVersions = (content) => {
-  const pattern = /(>terraform_).*(?=<\/a>)/g;
-  const versions = content.match(pattern).map(v => v.replace('>terraform_', ''));
+/**
+ * Parse Terraform versions from HashiCorp JSON API response.
+ * API: https://releases.hashicorp.com/terraform/index.json
+ * Returns sorted array of STABLE version strings only (descending).
+ * Use formatAllVersions() to include pre-releases.
+ */
+exports.formatVersions = (jsonData) => {
+  const data = typeof jsonData === 'string' ? JSON.parse(jsonData) : jsonData;
+  return Object.keys(data.versions || {})
+    .filter(v => !v.includes('-'))   // stable only: exclude 1.8.0-beta1, rc1, alpha etc.
+    .sort(semverDesc);
+};
 
-  return versions;
-}
+/**
+ * Same as formatVersions but includes pre-release builds.
+ * Used when user explicitly requests a pre-release version.
+ */
+exports.formatAllVersions = (jsonData) => {
+  const data = typeof jsonData === 'string' ? JSON.parse(jsonData) : jsonData;
+  return Object.keys(data.versions || {}).sort(semverDesc);
+};
+
+/**
+ * Parse OpenTofu versions from GitHub releases API response.
+ * API: https://api.github.com/repos/opentofu/opentofu/releases
+ * Returns sorted array of STABLE version strings only (descending).
+ */
+exports.formatOpenTofuVersions = (jsonData) => {
+  const releases = typeof jsonData === 'string' ? JSON.parse(jsonData) : jsonData;
+  return releases
+    .filter(r => !r.prerelease && !r.draft)
+    .map(r => r.tag_name.replace(/^v/, ''))
+    .filter(v => !v.includes('-'))   // extra guard for stable-only
+    .sort(semverDesc);
+};
+
+/**
+ * Same as formatOpenTofuVersions but includes pre-release builds.
+ */
+exports.formatAllOpenTofuVersions = (jsonData) => {
+  const releases = typeof jsonData === 'string' ? JSON.parse(jsonData) : jsonData;
+  return releases
+    .filter(r => !r.draft)
+    .map(r => r.tag_name.replace(/^v/, ''))
+    .sort(semverDesc);
+};
+
+const semverDesc = (a, b) => {
+  const aParts = a.split('.').map(n => parseInt(n, 10) || 0);
+  const bParts = b.split('.').map(n => parseInt(n, 10) || 0);
+  for (let i = 0; i < 3; i++) {
+    const diff = (bParts[i] || 0) - (aParts[i] || 0);
+    if (diff !== 0) return diff;
+  }
+  return 0;
+};
+
+exports.semverDesc = semverDesc;

package/lib/utils/paths.js

@@ -0,0 +1,156 @@
+const { homedir, platform } = require('os');
+const { join } = require('path');
+const { mkdirSync, existsSync, writeFileSync, readFileSync } = require('fs');
+
+const TFV_HOME = join(homedir(), '.tfv');
+
+const PROVIDERS = { terraform: 'terraform', tf: 'terraform', tofu: 'opentofu', opentofu: 'opentofu' };
+
+const normalizeProvider = (provider = 'terraform') => PROVIDERS[provider] || 'terraform';
+
+const getCliName = (provider) => normalizeProvider(provider) === 'opentofu' ? 'tofu' : 'terraform';
+
+const getPaths = () => ({
+  home: TFV_HOME,
+  bin: join(TFV_HOME, 'bin'),
+  store: join(TFV_HOME, 'store'),
+  cache: join(TFV_HOME, 'cache'),
+  terraform: join(TFV_HOME, 'store', 'terraform'),
+  opentofu: join(TFV_HOME, 'store', 'opentofu'),
+  active: join(TFV_HOME, 'active.json'),
+});
+
+const getProviderStore = (provider = 'terraform') => {
+  const normalized = normalizeProvider(provider);
+  return join(TFV_HOME, 'store', normalized);
+};
+
+const getBinTarget = (provider = 'terraform') => {
+  const cli = getCliName(provider);
+  const isWin = platform() === 'win32';
+  return join(TFV_HOME, 'bin', isWin ? `${cli}.exe` : cli);
+};
+
+const getVersionFile = (provider, version) => {
+  const store = getProviderStore(provider);
+  const isWin = platform() === 'win32';
+  return join(store, isWin ? `${version}.exe` : version);
+};
+
+const initDirs = () => {
+  const paths = getPaths();
+  [paths.home, paths.bin, paths.terraform, paths.opentofu, paths.cache].forEach(dir => {
+    if (!existsSync(dir)) mkdirSync(dir, { recursive: true });
+  });
+
+  ['terraform', 'opentofu'].forEach(p => {
+    const archFile = join(paths[p], 'arch.json');
+    if (!existsSync(archFile)) writeFileSync(archFile, '{}');
+  });
+
+  if (!existsSync(paths.active)) {
+    writeFileSync(paths.active, JSON.stringify({ terraform: null, opentofu: null }, null, 2));
+  }
+};
+
+const SHELL_CONFIGS = [
+  join(homedir(), '.zshrc'),
+  join(homedir(), '.bashrc'),
+  join(homedir(), '.bash_profile'),
+  join(homedir(), '.profile'),
+];
+const PATH_MARKER = '# tfv - terraform version manager';
+const PATH_LINE = 'export PATH="$HOME/.tfv/bin:$PATH"';
+
+/**
+ * Checks whether the shell-resolved binary (via `which`/`where`) matches
+ * the tfv-managed binary at ~/.tfv/bin/<cli>.
+ * Returns { ok: true } or { ok: false, resolved, expected }.
+ */
+const checkPathConflict = (provider = 'terraform') => {
+  const { spawnSync } = require('child_process');
+  const isWin = platform() === 'win32';
+  const cli = getCliName(provider);
+  const expected = getBinTarget(provider);
+
+  const result = isWin
+    ? spawnSync('where', [cli], { stdio: 'pipe', encoding: 'utf-8', shell: true })
+    : spawnSync('which', [cli], { stdio: 'pipe', encoding: 'utf-8' });
+
+  if (!result || result.status !== 0 || !result.stdout.trim()) {
+    return { ok: true }; // not found anywhere else — no conflict
+  }
+
+  const resolved = result.stdout.trim().split('\n')[0].trim();
+  if (resolved === expected) return { ok: true };
+
+  return { ok: false, resolved, expected };
+};
+
+/**
+ * Fixes a PATH conflict automatically.
+ *
+ * macOS / Linux:
+ *   Removes any existing tfv PATH block from shell configs, then re-appends
+ *   it at the very END so it runs after brew/apt/other tools and always wins.
+ *
+ * Windows:
+ *   Moves ~/.tfv/bin to the front of the User PATH in the registry (no admin needed).
+ */
+const fixPathConflict = () => {
+  const isWin = platform() === 'win32';
+
+  if (isWin) {
+    const { spawnSync } = require('child_process');
+    const BIN_DIR = join(TFV_HOME, 'bin');
+
+    const get = spawnSync(
+      'powershell',
+      ['-NoProfile', '-NonInteractive', '-Command',
+        '[Environment]::GetEnvironmentVariable("PATH", "User")'],
+      { stdio: 'pipe', encoding: 'utf-8' }
+    );
+
+    const current = (get.stdout || '').trim();
+    const entries = current.split(';').map(p => p.trim()).filter(p => p && p !== BIN_DIR);
+    const fixed = [BIN_DIR, ...entries].join(';');
+
+    spawnSync(
+      'powershell',
+      ['-NoProfile', '-NonInteractive', '-Command',
+        `[Environment]::SetEnvironmentVariable("PATH", "${fixed}", "User")`],
+      { stdio: 'pipe' }
+    );
+    return;
+  }
+
+  // macOS / Linux — update each shell config file
+  const block = `\n${PATH_MARKER}\n${PATH_LINE}\n`;
+
+  SHELL_CONFIGS.forEach(file => {
+    if (!existsSync(file)) return;
+
+    // Strip any existing tfv PATH block
+    let content = readFileSync(file, 'utf-8');
+    content = content.replace(
+      new RegExp(`\\n?${PATH_MARKER}\\n${PATH_LINE.replace(/[.*+?^${}()|[\]\\]/g, '\\$&')}\\n?`, 'g'),
+      ''
+    );
+
+    // Append at the very end so it always runs last and wins
+    writeFileSync(file, content.trimEnd() + block);
+  });
+};
+
+module.exports = {
+  TFV_HOME,
+  getPaths,
+  getProviderStore,
+  getBinTarget,
+  getVersionFile,
+  normalizeProvider,
+  getCliName,
+  initDirs,
+  checkPathConflict,
+  fixPathConflict,
+};