tfv 5.0.1 → 6.1.0

package/lib/modules/install.js

@@ -1,127 +1,193 @@
 const https = require('https');
+const crypto = require('crypto');
 const os = require('os');
+const path = require('path');
+const { join } = path;
 const {
-  chmodSync,
-  existsSync,
-  unlinkSync,
-  readFileSync,
-  writeFileSync,
-  createWriteStream
+  chmodSync, existsSync, unlinkSync,
+  readFileSync, writeFileSync, createWriteStream
 } = require('fs');
-const {join} = require('path');
-const {arch} = process;
-const unzip = require('decompress');
-const {fetchAllVersions} = require('./remote');
-const {formatVersions} = require('../utils/formatVersions');
-const {P_END, P_ERROR, P_INFO, P_OK, P_WARN} = require('../utils/colors');
-
-exports.install = async (installVersion, sysArchitecture) => {
+const AdmZip = require('adm-zip');
+const { fetchAllVersions, fetchUrl } = require('./remote');
+const { normalizeProvider, getProviderStore, getVersionFile, initDirs } = require('../utils/paths');
+const { P_END, P_ERROR, P_INFO, P_OK, P_WARN } = require('../utils/colors');
+
+const getDownloadUrl = (provider, version, sysOs, archOption) => {
+  if (provider === 'opentofu') {
+    const osName = sysOs === 'darwin' ? 'darwin' : sysOs === 'win32' ? 'windows' : 'linux';
+    return `https://github.com/opentofu/opentofu/releases/download/v${version}/tofu_${version}_${osName}_${archOption}.zip`;
+  }
+  const osName = sysOs === 'win32' ? 'windows' : sysOs;
+  return `https://releases.hashicorp.com/terraform/${version}/terraform_${version}_${osName}_${archOption}.zip`;
+};
+
+const getSha256Url = (provider, version, sysOs, archOption) => {
+  if (provider === 'opentofu') {
+    return `https://github.com/opentofu/opentofu/releases/download/v${version}/tofu_${version}_SHA256SUMS`;
+  }
+  return `https://releases.hashicorp.com/terraform/${version}/terraform_${version}_SHA256SUMS`;
+};
+
+const getZipName = (provider, version, sysOs, archOption) => {
+  const osName = sysOs === 'win32' ? 'windows' : sysOs === 'darwin' ? 'darwin' : 'linux';
+  const prefix = provider === 'opentofu' ? 'tofu' : 'terraform';
+  return `${prefix}_${version}_${osName}_${archOption}.zip`;
+};
+
+const verifyChecksum = async (filePath, provider, version, sysOs, archOption) => {
+  const sumsUrl = getSha256Url(provider, version, sysOs, archOption);
+  const zipName = getZipName(provider, version, sysOs, archOption);
+
+  const sumsData = await fetchUrl(sumsUrl);
+  const matchLine = sumsData.split('\n').find(l => l.includes(zipName));
+
+  if (!matchLine) throw new Error(`Checksum entry not found for ${zipName}`);
+
+  const [expectedHash] = matchLine.trim().split(/\s+/);
+  const fileBuffer = readFileSync(filePath);
+  const actualHash = crypto.createHash('sha256').update(fileBuffer).digest('hex');
+
+  if (actualHash !== expectedHash) {
+    throw new Error(`SHA256 mismatch!\n  Expected: ${expectedHash}\n  Got:      ${actualHash}`);
+  }
+};
+
+const showProgress = (received, total) => {
+  if (!total) return;
+  const pct = Math.min(100, Math.floor((received / total) * 100));
+  const filled = Math.floor(pct / 2);
+  const bar = '\u2588'.repeat(filled) + '\u2591'.repeat(50 - filled);
+  process.stdout.write(`\r  [${bar}] ${pct}% (${(received / 1024 / 1024).toFixed(1)} MB)`);
+};
+
+const providerFlag = (providerArg) => providerArg === 'terraform' ? '' : ` --provider ${providerArg}`;
+
+exports.install = async (installVersion, sysArchitecture, providerArg = 'terraform') => {
   try {
+    initDirs();
+
+    const provider = normalizeProvider(providerArg);
     let version = installVersion;
-    const store = join(__dirname, '../..', 'store');
-    const data = await fetchAllVersions();
-    const result = formatVersions(data);
+
+    // isExplicitPreRelease: user typed e.g. "1.8.0-beta1" intentionally.
+    // In that case we skip stable-only validation and let the download confirm existence.
+    const isExplicitPreRelease = version !== 'latest'
+      && !`${version}`.endsWith('^')
+      && `${version}`.includes('-');
+
+    // Stable versions only — used for latest/^ resolution and validation of stable requests.
+    const stableVersions = isExplicitPreRelease ? [] : await fetchAllVersions(provider);
 
     if (version === 'latest') {
-      [version] = result.filter(v => {
-        const [, inTest] = v.split('-');
-        if (!inTest) return v;
-      });
+      version = stableVersions[0];
     }
 
     if (`${version}`.endsWith('^')) {
-      [version] = result.filter(v => {
-        const [, inTest] = v.split('-');
-        if (v.startsWith(version.replace('^', '')) && !inTest) return v
-      });
-      version = version ? version : installVersion.replace('^', '');
+      const prefix = version.replace('^', '');
+      version = stableVersions.find(v => v.startsWith(prefix)) || prefix;
     }
 
-    if (!result.find(v => v === version)) {
-      console.log(`${P_ERROR}Terraform ${version} not found.${P_END}`);
-      console.log(`To view a list of available version, run ${P_OK}tfv list --remote${P_END}`);
+    // Validate explicit stable version exists; skip check for explicit pre-releases.
+    if (!isExplicitPreRelease && !stableVersions.includes(version)) {
+      console.log(`${P_ERROR}${provider} ${version} not found.${P_END}`);
+      console.log(`To view available versions, run ${P_OK}tfv list --remote${providerFlag(providerArg)}${P_END}`);
       process.exit(1);
     }
 
-    const getVersion = os.platform() === 'win32' ? `${version}.exe` : version;
+    if (isExplicitPreRelease) {
+      console.log(`${P_WARN}Installing pre-release version ${version}. Use stable versions for production.${P_END}`);
+    }
+
+    const store = getProviderStore(provider);
+    const storedFile = getVersionFile(provider, version);
 
-    if (existsSync(`${store}/${getVersion}`)) {
-      console.log(`${P_WARN}Terraform ${version} is already installed${P_END}`);
-      return console.log(`To use this version Run: ${P_OK}tfv use ${version}${P_END}`)
+    if (existsSync(storedFile)) {
+      console.log(`${P_WARN}${provider} ${version} is already installed${P_END}`);
+      return console.log(`To use this version run: ${P_OK}tfv use ${version}${providerFlag(providerArg)}${P_END}`);
     }
 
-    const sysOs = os.platform() === 'win32' ? 'windows' : os.platform();
-    let sysArch = arch === 'x64' ? 'amd64' : arch;
+    const sysOs = os.platform();
+    let sysArch = process.arch === 'x64' ? 'amd64' : process.arch;
 
-    if (os.platform() === 'darwin' && version.startsWith('0')) {
-      sysArch = 'amd64'
+    // Older terraform versions on macOS only had amd64 builds
+    if (provider === 'terraform' && sysOs === 'darwin' && version.startsWith('0')) {
+      sysArch = 'amd64';
     }
 
     const archOption = sysArchitecture || sysArch;
+    const url = getDownloadUrl(provider, version, sysOs, archOption);
+    const tmpZip = join(os.tmpdir(), `tfv-${provider}-${version}.zip`);
 
-    const url = `https://releases.hashicorp.com/terraform/${version}/terraform_${version}_${sysOs}_${archOption}.zip`;
+    await new Promise((resolve, reject) => {
+      console.log(`${P_INFO}Downloading ${provider} ${version} (${archOption})...${P_END}`);
 
-    const manageTfArch = async (version) => {
-      const archMap = `${store}/arch.json`;
-      const archStore = readFileSync(`${archMap}`, 'utf8');
-      const parseArchFile = JSON.parse(archStore);
-      parseArchFile[version] = archOption;
-      writeFileSync(`${archMap}`, JSON.stringify(parseArchFile, null, 2));
-    }
+      // Defined before use to avoid temporal dead zone
+      const handleResponse = (res) => {
+        const total = parseInt(res.headers['content-length'], 10);
+        let received = 0;
 
-    const fileName = join(__dirname, '../..', `${version}.zip`);
+        const fileStream = createWriteStream(tmpZip);
+        res.on('data', chunk => {
+          received += chunk.length;
+          showProgress(received, total);
+        });
+        res.pipe(fileStream);
 
-    const unzipFile = async (version) => {
-      if (existsSync(fileName)) {
-        await unzip(fileName, store, {
-          map: file => {
-            const [, ext] = `${file.path}`.split('.');
-            file.path = ext ? `${version}.${ext}` : `${version}`;
-            return file;
-          }
+        fileStream.on('error', reject);
+        fileStream.on('finish', () => {
+          fileStream.close();
+          process.stdout.write('\n');
+          resolve();
         });
+      };
+
+      const req = https.get(url, { headers: { 'User-Agent': 'tfv-cli' } }, (res) => {
+        // Follow redirect — GitHub releases redirect to S3/CDN
+        if (res.statusCode >= 300 && res.statusCode < 400 && res.headers.location) {
+          return https.get(res.headers.location, { headers: { 'User-Agent': 'tfv-cli' } }, handleResponse)
+            .on('error', reject);
+        }
+        handleResponse(res);
+      });
 
-        unlinkSync(fileName);
-      }
-    }
+      req.on('error', reject);
+    });
 
-    const makeExecutable = async (version) => {
-      if (sysOs !== 'windows') {
-        chmodSync(`${store}/${version}`, '755');
+    console.log(`${P_INFO}Verifying SHA256 checksum...${P_END}`);
+    await verifyChecksum(tmpZip, provider, version, sysOs, archOption);
+    console.log(`${P_OK}Checksum verified.${P_END}`);
+
+    console.log(`${P_INFO}Extracting...${P_END}`);
+    const zip = new AdmZip(tmpZip);
+    for (const entry of zip.getEntries()) {
+      if (entry.isDirectory) continue;
+      const ext = path.extname(entry.entryName).toLowerCase(); // '' or '.exe'
+      if (!ext || ext === '.exe') {
+        // Rename binary to the version number, preserving .exe on Windows
+        const destName = ext ? `${version}${ext}` : version;
+        writeFileSync(path.join(store, destName), entry.getData());
       }
+      // All other entries (LICENSE.txt, CHANGELOG.md, etc.) are simply skipped
     }
 
-    return new Promise((resolve, reject) => {
-      const req = https.get(url, (res) => {
-        console.log(`${P_INFO}Installing terraform ${version} (for ${archOption} architecture) ${P_END}`);
-
-        const fileStream = createWriteStream(fileName);
-        res.pipe(fileStream);
-
-        fileStream.on('error', (err) => {
-          console.log(`${P_ERROR}Error writing stream ${P_END}\n`, err);
-        });
+    unlinkSync(tmpZip);
 
-        fileStream.on('close', async () => {
-          await unzipFile(version);
-          await manageTfArch(version);
-          await makeExecutable(version);
-          resolve(version);
-        });
+    if (sysOs !== 'win32') {
+      chmodSync(storedFile, '755');
+    }
 
-        fileStream.on('finish', () => {
-          fileStream.close();
-          console.log(`${P_OK}Successful!${P_END}`);
-          console.log(`To use this version Run: ${P_OK}tfv use ${version}${P_END}`);
-        })
-      });
+    // Save arch mapping
+    const archFile = join(store, 'arch.json');
+    const archMap = JSON.parse(readFileSync(archFile, 'utf-8'));
+    archMap[version] = archOption;
+    writeFileSync(archFile, JSON.stringify(archMap, null, 2));
 
-      req.on('error', (err) => {
-        reject(console.log(`${P_ERROR}Error downloading the terraform ${version}${P_END}\n`, err))
-      });
-    });
+    console.log(`${P_OK}Installed ${provider} ${version} successfully!${P_END}`);
+    console.log(`To use this version run: ${P_OK}tfv use ${version}${providerFlag(providerArg)}${P_END}`);
+    return version;
 
-  } catch ({message}) {
-    console.log('ERROR:', message)
+  } catch (err) {
+    console.log(`${P_ERROR}Install failed: ${err.message}${P_END}`);
+    process.exit(1);
   }
-}
+};

package/lib/modules/list.js

@@ -1,138 +1,99 @@
-const fs = require('fs');
-const {join} = require('path');
-const {spawnSync} = require('child_process')
-const {fetchAllVersions} = require('./remote');
-const {formatVersions} = require('../utils/formatVersions');
-const {P_END, P_OK} = require('../utils/colors');
-const {checkStore} = require('../utils/store');
+const { existsSync, readdirSync, readFileSync } = require('fs');
+const { join } = require('path');
+const { spawnSync } = require('child_process');
+const { fetchAllVersions } = require('./remote');
+const { normalizeProvider, getProviderStore, getCliName, getPaths } = require('../utils/paths');
+const { checkStore } = require('../utils/store');
+const { P_END, P_OK, P_WARN } = require('../utils/colors');
 
-const MAX_COLUMNS_PER_TABLE = 6;
+const MAX_COLUMNS = 6;
 
-/**
- * Groups versions by their major.minor prefix
- */
-const groupVersionsByRelease = (versions) => {
+const groupByRelease = (versions) => {
   const groups = {};
-
-  versions.forEach(version => {
-    const parts = version.split('.');
+  versions.forEach(v => {
+    const parts = v.split('.');
     if (parts.length >= 2) {
-      const majorMinor = `${parts[0]}.${parts[1]}`;
-      if (!groups[majorMinor]) {
-        groups[majorMinor] = [];
-      }
-      groups[majorMinor].push(version);
+      const key = `${parts[0]}.${parts[1]}`;
+      if (!groups[key]) groups[key] = [];
+      groups[key].push(v);
     }
   });
-
   return groups;
 };
 
-/**
- * Displays versions in table format with first version of each release as column header
- * Breaks into multiple tables if columns exceed MAX_COLUMNS_PER_TABLE
- */
-const displayVersionTable = (versions) => {
-  const groups = groupVersionsByRelease(versions);
-
-  // Sort release groups by version (descending)
+const displayRemoteTable = (versions) => {
+  const groups = groupByRelease(versions);
   const sortedKeys = Object.keys(groups).sort((a, b) => {
-    const [aMajor, aMinor] = a.split('.').map(Number);
-    const [bMajor, bMinor] = b.split('.').map(Number);
-    if (bMajor !== aMajor) return bMajor - aMajor;
-    return bMinor - aMinor;
-  });
-
-  // Sort versions within each group (descending)
-  sortedKeys.forEach(key => {
-    groups[key].sort((a, b) => {
-      const aParts = a.split('.').map(n => parseInt(n) || 0);
-      const bParts = b.split('.').map(n => parseInt(n) || 0);
-      for (let i = 0; i < Math.max(aParts.length, bParts.length); i++) {
-        const aVal = aParts[i] || 0;
-        const bVal = bParts[i] || 0;
-        if (bVal !== aVal) return bVal - aVal;
-      }
-      return 0;
-    });
+    const [aMaj, aMin] = a.split('.').map(Number);
+    const [bMaj, bMin] = b.split('.').map(Number);
+    return bMaj !== aMaj ? bMaj - aMaj : bMin - aMin;
   });
 
-  // Split into chunks of MAX_COLUMNS_PER_TABLE
   const chunks = [];
-  for (let i = 0; i < sortedKeys.length; i += MAX_COLUMNS_PER_TABLE) {
-    chunks.push(sortedKeys.slice(i, i + MAX_COLUMNS_PER_TABLE));
+  for (let i = 0; i < sortedKeys.length; i += MAX_COLUMNS) {
+    chunks.push(sortedKeys.slice(i, i + MAX_COLUMNS));
   }
 
-  // Display each chunk as a separate table
-  chunks.forEach((chunkKeys, chunkIndex) => {
-    // Find max rows needed for this chunk
-    const maxRows = Math.max(...chunkKeys.map(key => groups[key].length));
-
-    // Build table data
+  chunks.forEach((chunkKeys, idx) => {
+    const maxRows = Math.max(...chunkKeys.map(k => groups[k].length));
     const tableData = [];
     for (let row = 0; row < maxRows; row++) {
       const rowObj = {};
-      chunkKeys.forEach(key => {
-        // Use major.minor.x format as header (e.g., "1.5.x")
-        const header = `${key}.x`;
-        const value = groups[key][row] || '';
-        rowObj[header] = value;
-      });
+      chunkKeys.forEach(k => { rowObj[`${k}.x`] = groups[k][row] || ''; });
       tableData.push(rowObj);
     }
-
-    if (chunks.length > 1) {
-      console.log(`\n${P_OK}Table ${chunkIndex + 1} of ${chunks.length}${P_END}`);
-    }
+    if (chunks.length > 1) console.log(`\n${P_OK}Table ${idx + 1} of ${chunks.length}${P_END}`);
     console.table(tableData);
   });
 };
 
-exports.list = async (local, remote) => {
+exports.list = async (local, remote, providerArg = 'terraform') => {
   try {
-    let versions;
+    const provider = normalizeProvider(providerArg);
+    const cliName = getCliName(provider);
 
     if (remote) {
-      const data = await fetchAllVersions();
-      versions = formatVersions(data);
-
-      console.log(`${P_OK}List of all available terraform versions${P_END}\n`);
-      return displayVersionTable(versions);
+      const versions = await fetchAllVersions(provider);
+      console.log(`${P_OK}Available ${provider} versions (${versions.length} total)${P_END}\n`);
+      return displayRemoteTable(versions);
     }
 
-    if (local) {
-      const store = join(__dirname, '../..', 'store');
+    // Default: local
+    checkStore(provider);
+    const store = getProviderStore(provider);
 
-      checkStore(store);
-
-      const tfVersion = spawnSync('terraform', ['version'], {stdio: 'pipe', encoding: 'utf-8'});
-      const pattern = /v\d+\.\d+\.\d+/;
-      const versionOutput = tfVersion.stdout.match(pattern);
-
-      const archMap = `${store}/arch.json`;
-      const archStore = fs.readFileSync(`${archMap}`, 'utf8');
-      const parseArchFile = JSON.parse(archStore);
-      const installedVersions = [];
-
-      versions = fs.readdirSync(store).forEach(f => {
-        if (f !== 'arch.json') {
-          const versionNumber = f.replace('.exe', '');
-          const vnObj = {};
-
-          vnObj['Terraform Version'] = versionNumber;
+    // Get currently active version
+    const paths = getPaths();
+    let activeVersion = null;
+    if (existsSync(paths.active)) {
+      const active = JSON.parse(readFileSync(paths.active, 'utf-8'));
+      activeVersion = active[provider];
+    }
 
-          if (versionOutput && versionNumber === versionOutput[0].replace('v', '')) {
-            vnObj['System Arch'] = `${parseArchFile[versionNumber]} 🚀`;
-          }
-          else vnObj['System Arch'] = parseArchFile[versionNumber];
-          installedVersions.push(vnObj);
+    const archFile = join(store, 'arch.json');
+    const archMap = existsSync(archFile) ? JSON.parse(readFileSync(archFile, 'utf-8')) : {};
+
+    const rows = readdirSync(store)
+      .filter(f => f !== 'arch.json')
+      .map(f => f.replace('.exe', ''))
+      .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;
         }
-      });
-
-      console.log(`${P_OK}Terraform versions installed by tfv${P_END}`);
-      return console.table(installedVersions);
-    }
-  } catch ({message}) {
-    console.log(message)
+        return 0;
+      })
+      .map(v => ({
+        'Version': v === activeVersion ? `${v} 🚀` : v,
+        'Arch': archMap[v] || 'unknown',
+        'Status': v === activeVersion ? 'active' : '',
+      }));
+
+    console.log(`${P_OK}Installed ${provider} versions${P_END}`);
+    console.table(rows);
+  } catch (err) {
+    console.log(err.message);
   }
-}
+};

package/lib/modules/pin.js

@@ -0,0 +1,35 @@
+const { existsSync, readFileSync, writeFileSync } = require('fs');
+const { join } = require('path');
+const { normalizeProvider, getPaths } = require('../utils/paths');
+const { P_END, P_OK, P_WARN, P_ERROR } = require('../utils/colors');
+
+exports.pin = async (version, providerArg = 'terraform') => {
+  try {
+    const provider = normalizeProvider(providerArg);
+    let pinVersion = version;
+
+    if (!pinVersion || pinVersion === 'current') {
+      const paths = getPaths();
+      if (!existsSync(paths.active)) {
+        console.log(`${P_ERROR}No active ${provider} version found.${P_END}`);
+        console.log(`Run: ${P_OK}tfv use <version>${providerArg === 'terraform' ? '' : ` --provider ${providerArg}`}${P_END}`);
+        process.exit(1);
+      }
+      const active = JSON.parse(readFileSync(paths.active, 'utf-8'));
+      pinVersion = active[provider];
+      if (!pinVersion) {
+        console.log(`${P_ERROR}No active ${provider} version set.${P_END}`);
+        console.log(`Run: ${P_OK}tfv use <version>${providerArg === 'terraform' ? '' : ` --provider ${providerArg}`}${P_END}`);
+        process.exit(1);
+      }
+    }
+
+    const targetFile = join(process.cwd(), '.terraform-version');
+    writeFileSync(targetFile, pinVersion);
+
+    console.log(`${P_OK}Pinned ${provider} ${pinVersion} to .terraform-version${P_END}`);
+    console.log(`${P_OK}Other team members can run: tfv auto-switch${P_END}`);
+  } catch (err) {
+    console.log(`${P_ERROR}Error: ${err.message}${P_END}`);
+  }
+};

package/lib/modules/prune.js

@@ -0,0 +1,100 @@
+const { existsSync, readdirSync, unlinkSync, readFileSync, writeFileSync } = require('fs');
+const { join } = require('path');
+const readline = require('readline');
+const { normalizeProvider, getProviderStore, getVersionFile, getPaths } = require('../utils/paths');
+const { P_END, P_OK, P_ERROR, P_WARN, P_INFO } = require('../utils/colors');
+
+const sortVersionsDesc = (versions) => versions.sort((a, b) => {
+  const ap = a.split('.').map(n => parseInt(n, 10) || 0);
+  const bp = b.split('.').map(n => parseInt(n, 10) || 0);
+  for (let i = 0; i < 3; i++) {
+    const d = (bp[i] || 0) - (ap[i] || 0);
+    if (d !== 0) return d;
+  }
+  return 0;
+});
+
+const confirm = (question) => new Promise(resolve => {
+  const rl = readline.createInterface({ input: process.stdin, output: process.stdout });
+  rl.question(question, ans => { rl.close(); resolve(ans.trim().toLowerCase()); });
+});
+
+exports.prune = async (providerArg = 'terraform', keep = 0, yes = false) => {
+  try {
+    const provider = normalizeProvider(providerArg);
+    const store = getProviderStore(provider);
+
+    if (!existsSync(store)) {
+      console.log(`${P_ERROR}No store found for ${provider}.${P_END}`);
+      process.exit(1);
+    }
+
+    const archFile = join(store, 'arch.json');
+    const archMap = existsSync(archFile) ? JSON.parse(readFileSync(archFile, 'utf-8')) : {};
+
+    const paths = getPaths();
+    let activeVersion = null;
+    if (existsSync(paths.active)) {
+      const active = JSON.parse(readFileSync(paths.active, 'utf-8'));
+      activeVersion = active[provider];
+    }
+
+    const installed = sortVersionsDesc(
+      readdirSync(store)
+        .filter(f => f !== 'arch.json')
+        .map(f => f.replace(/\.exe$/, ''))
+    );
+
+    if (installed.length === 0) {
+      console.log(`${P_WARN}No ${provider} versions installed.${P_END}`);
+      return;
+    }
+
+    // Build the keep set: active version is always kept; top N by semver if --keep N
+    const keepSet = new Set();
+    if (activeVersion) keepSet.add(activeVersion);
+    if (keep > 0) installed.slice(0, keep).forEach(v => keepSet.add(v));
+
+    const toRemove = installed.filter(v => !keepSet.has(v));
+
+    if (toRemove.length === 0) {
+      console.log(`${P_OK}Nothing to prune for ${provider}.${P_END}`);
+      if (activeVersion) console.log(`${P_INFO}Active version ${activeVersion} is kept.${P_END}`);
+      return;
+    }
+
+    console.log(`${P_INFO}Versions to remove (${provider}):${P_END}`);
+    toRemove.forEach(v => console.log(`  ${P_WARN}${v}${P_END}`));
+    console.log();
+    if (activeVersion) console.log(`${P_OK}Keeping (active): ${activeVersion}${P_END}`);
+    if (keep > 0) {
+      const kept = installed.filter(v => keepSet.has(v) && v !== activeVersion);
+      if (kept.length) console.log(`${P_OK}Keeping (--keep ${keep}): ${kept.join(', ')}${P_END}`);
+    }
+
+    if (!yes) {
+      const ans = await confirm(`\nRemove ${toRemove.length} version(s)? [y/N] `);
+      if (ans !== 'y' && ans !== 'yes') {
+        console.log(`${P_WARN}Aborted.${P_END}`);
+        return;
+      }
+    }
+
+    console.log();
+    toRemove.forEach(v => {
+      const file = getVersionFile(provider, v);
+      if (existsSync(file)) {
+        unlinkSync(file);
+        delete archMap[v];
+        console.log(`${P_OK}Removed ${provider} ${v}${P_END}`);
+      }
+    });
+
+    writeFileSync(archFile, JSON.stringify(archMap, null, 2));
+    console.log(`\n${P_OK}Done. Pruned ${toRemove.length} version(s).${P_END}`);
+
+  } catch (err) {
+    console.log(`${P_ERROR}Error: ${err.message}${P_END}`);
+    process.exit(1);
+  }
+};