jvm-manager-cli 1.0.0

package/bin/jvm.js

@@ -0,0 +1,796 @@
+#!/usr/bin/env node
+
+import { execSync } from 'child_process';
+import { existsSync, mkdirSync, readFileSync, readdirSync, rmSync, symlinkSync, writeFileSync } from 'fs';
+import { dirname, join, resolve } from 'path';
+import { homedir } from 'os';
+
+const APP_NAME = 'jvm-manager';
+const HOME = homedir();
+const APP_DIR = join(HOME, '.local', 'share', APP_NAME);
+const JDKS_DIR = join(APP_DIR, 'jdks');
+const CURRENT_GLOBAL = join(APP_DIR, 'current');
+const PROJECT_FILE = '.jvmrc';
+
+function ensureDirs() {
+  if (!existsSync(APP_DIR)) {
+    mkdirSync(APP_DIR, { recursive: true });
+  }
+  if (!existsSync(JDKS_DIR)) {
+    mkdirSync(JDKS_DIR, { recursive: true });
+  }
+}
+
+function run(cmd, options = {}) {
+  return execSync(cmd, {
+    stdio: ['ignore', 'pipe', 'pipe'],
+    encoding: 'utf8',
+    ...options
+  }).trim();
+}
+
+function fail(msg) {
+  console.error(`Error: ${msg}`);
+  process.exit(1);
+}
+
+function usage() {
+  console.log(`jvm - Linux JDK manager
+
+Usage:
+  jvm install <version>           Install JDK to local store
+  jvm list                        List installed JDKs (including system)
+  jvm use <version> [--global]    Switch JDK globally (default)
+  jvm use <version> --project     Write .jvmrc in current project
+  jvm current                     Show current global and project JDK
+  jvm env [--global|--project]    Print export lines for shell
+  jvm doctor                      Check system for compatibility
+  jvm remove <version>            Remove installed JDK
+  jvm link <system-path> <version> Link system JDK to local store
+
+Examples:
+  jvm install 17
+  jvm use 21 --global
+  jvm use 17 --project
+  jvm link /usr/lib/jvm/java-17-openjdk-amd64 17
+  eval "$(jvm env --project)"`);
+}
+
+function detectArch() {
+  const arch = process.arch;
+  if (arch === 'x64') return 'x64';
+  if (arch === 'arm64') return 'aarch64';
+  fail(`Unsupported architecture: ${arch}`);
+}
+
+function getOSRelease() {
+  const releaseFile = '/etc/os-release';
+  if (!existsSync(releaseFile)) {
+    return {
+      ID: 'unknown',
+      PRETTY_NAME: 'Unknown'
+    };
+  }
+  
+  const content = readFileSync(releaseFile, 'utf8');
+  const releaseInfo = {};
+  
+  content.split('\n').forEach(line => {
+    const trimmed = line.trim();
+    if (trimmed && !trimmed.startsWith('#')) {
+      const [key, value] = trimmed.split('=');
+      releaseInfo[key] = value ? value.replace(/['"]/g, '') : '';
+    }
+  });
+  
+  return releaseInfo;
+}
+
+function install(version) {
+  ensureDirs();
+  if (!/^\d+$/.test(version)) {
+    fail('Version should be a major number, e.g. 8, 11, 17, 21');
+  }
+  const target = join(JDKS_DIR, version);
+  if (existsSync(target)) {
+    console.log(`JDK ${version} already installed: ${target}`);
+    return;
+  }
+  
+  const osRelease = getOSRelease();
+  console.log(`Detected OS: ${osRelease.PRETTY_NAME}`);
+  
+  // 检查用户是否有 sudo 权限
+  try {
+    run('sudo -n true');
+  } catch (err) {
+    console.log('This command requires sudo privileges. Please enter your password when prompted.');
+  }
+  
+  if (osRelease.ID === 'ubuntu' || osRelease.ID === 'debian') {
+    installUbuntuDebian(version, target);
+  } else if (osRelease.ID === 'fedora' || osRelease.ID === 'centos' || osRelease.ID === 'rhel') {
+    installFedoraCentOSRHEL(version, target);
+  } else if (osRelease.ID === 'arch') {
+    installArchLinux(version, target);
+  } else {
+    installFromDownload(version, target);
+  }
+}
+
+function installUbuntuDebian(version, target) {
+  const packageName = `openjdk-${version}-jdk`;
+  
+  console.log(`Installing OpenJDK ${version} using apt...`);
+  
+  try {
+    // Try to update package list
+    try {
+      run('sudo apt update -qq');
+    } catch (err) {
+      console.error('Failed to update package list. Please try running `sudo apt update` manually first.');
+      console.error(err);
+      fail('Failed to install OpenJDK');
+    }
+    
+    // Try to install package without interactive prompts
+    try {
+      run(`sudo apt install -y -qq ${packageName}`);
+    } catch (err) {
+      console.error('Failed to install package. Please try running the following command manually:');
+      console.error(`  sudo apt install -y ${packageName}`);
+      console.error(err);
+      fail('Failed to install OpenJDK');
+    }
+    
+    // Find the installed JDK path
+    let jdkPath;
+    if (existsSync('/usr/lib/jvm')) {
+      const entries = readdirSync('/usr/lib/jvm', { withFileTypes: true });
+      for (const entry of entries) {
+        if (entry.isDirectory() && entry.name.includes(`java-${version}`)) {
+          jdkPath = join('/usr/lib/jvm', entry.name);
+          break;
+        }
+      }
+    }
+    
+    if (!jdkPath) {
+      fail(`Could not find installed OpenJDK ${version} in /usr/lib/jvm`);
+    }
+    
+    symlinkSync(jdkPath, target, 'dir');
+    console.log(`Installed OpenJDK ${version} at ${target}`);
+  } catch (err) {
+    console.error(`Error: ${err}`);
+    console.error('Please ensure you have sudo privileges and try again.');
+    fail('Installation failed');
+  }
+}
+
+function installFedoraCentOSRHEL(version, target) {
+  const packageName = `java-${version}-openjdk-devel`;
+  
+  console.log(`Installing OpenJDK ${version} using dnf...`);
+  
+  try {
+    // Try to update package list
+    try {
+      run('sudo dnf check-update -q');
+    } catch (err) {
+      console.error('Failed to check for updates. Please try running `sudo dnf check-update` manually first.');
+      console.error(err);
+      fail('Failed to install OpenJDK');
+    }
+    
+    // Try to install package without interactive prompts
+    try {
+      run(`sudo dnf install -y -q ${packageName}`);
+    } catch (err) {
+      console.error('Failed to install package. Please try running the following command manually:');
+      console.error(`  sudo dnf install -y ${packageName}`);
+      console.error(err);
+      fail('Failed to install OpenJDK');
+    }
+    
+    // Find the installed JDK path
+    let jdkPath;
+    if (existsSync('/usr/lib/jvm')) {
+      const entries = readdirSync('/usr/lib/jvm', { withFileTypes: true });
+      for (const entry of entries) {
+        if (entry.isDirectory() && entry.name.includes(`java-${version}`)) {
+          jdkPath = join('/usr/lib/jvm', entry.name);
+          break;
+        }
+      }
+    }
+    
+    if (!jdkPath) {
+      fail(`Could not find installed OpenJDK ${version} in /usr/lib/jvm`);
+    }
+    
+    symlinkSync(jdkPath, target, 'dir');
+    console.log(`Installed OpenJDK ${version} at ${target}`);
+  } catch (err) {
+    console.error(`Error: ${err}`);
+    console.error('Please ensure you have sudo privileges and try again.');
+    fail('Installation failed');
+  }
+}
+
+function installArchLinux(version, target) {
+  const packageName = `jdk${version}-openjdk`;
+  
+  console.log(`Installing OpenJDK ${version} using pacman...`);
+  
+  try {
+    // Try to install package without interactive prompts
+    try {
+      run(`sudo pacman -Syu --noconfirm ${packageName}`);
+    } catch (err) {
+      console.error('Failed to install package. Please try running the following command manually:');
+      console.error(`  sudo pacman -Syu --noconfirm ${packageName}`);
+      console.error(err);
+      fail('Failed to install OpenJDK');
+    }
+    
+    // Find the installed JDK path
+    let jdkPath;
+    if (existsSync('/usr/lib/jvm')) {
+      const entries = readdirSync('/usr/lib/jvm', { withFileTypes: true });
+      for (const entry of entries) {
+        if (entry.isDirectory() && entry.name.includes(`java-${version}`)) {
+          jdkPath = join('/usr/lib/jvm', entry.name);
+          break;
+        }
+      }
+    }
+    
+    if (!jdkPath) {
+      fail(`Could not find installed OpenJDK ${version} in /usr/lib/jvm`);
+    }
+    
+    symlinkSync(jdkPath, target, 'dir');
+    console.log(`Installed OpenJDK ${version} at ${target}`);
+  } catch (err) {
+    console.error(`Error: ${err}`);
+    console.error('Please ensure you have sudo privileges and try again.');
+    fail('Installation failed');
+  }
+}
+
+function installFromDownload(version, target) {
+  const { link, filename } = detectLatestBuild(version);
+  const tmpDir = run('mktemp -d');
+  const tarPath = join(tmpDir, filename);
+
+  try {
+    console.log(`Downloading JDK ${version}...`);
+    run('curl -fL "' + link + '" -o "' + tarPath + '"', { stdio: 'inherit' });
+    mkdirSync(target, { recursive: true });
+    run('tar -xzf "' + tarPath + '" -C "' + target + '" --strip-components=1', { stdio: 'inherit' });
+  } catch (error) {
+    rmSync(target, { recursive: true, force: true });
+    throw error;
+  } finally {
+    rmSync(tmpDir, { recursive: true, force: true });
+  }
+  console.log(`Installed JDK ${version} at ${target}`);
+}
+
+function detectLatestBuild(version) {
+  const arch = detectArch();
+  
+  let osArch = 'x64';
+  if (arch === 'arm64') {
+    osArch = 'aarch64';
+  }
+  
+  if (version >= 17) {
+    const url = 'https://download.java.net/java/GA/jdk' + version + '/latest/openjdk-' + version + '_linux-' + osArch + '_bin.tar.gz';
+    const filename = 'openjdk-' + version + '_linux-' + osArch + '_bin.tar.gz';
+    return { link: url, filename: filename };
+  } else if (version === 11) {
+    const url = 'https://download.java.net/java/GA/jdk11/9/GPL/openjdk-11.0.2_linux-' + osArch + '_bin.tar.gz';
+    const filename = 'openjdk-11.0.2_linux-' + osArch + '_bin.tar.gz';
+    return { link: url, filename: filename };
+  } else if (version === 8) {
+    const url = 'https://download.java.net/java/GA/jdk8u402/40265a1938f34f94a9e96e1708e6c9f3/21/GPL/openjdk-8u402-linux-' + osArch + '_bin.tar.gz';
+    const filename = 'openjdk-8u402-linux-' + osArch + '_bin.tar.gz';
+    return { link: url, filename: filename };
+  } else {
+    fail(`Unsupported OpenJDK version: ${version}`);
+  }
+}
+
+function listInstalled() {
+  ensureDirs();
+  
+  const versions = new Map();
+  
+  if (existsSync(JDKS_DIR)) {
+    const localEntries = readdirSync(JDKS_DIR, { withFileTypes: true })
+      .filter(d => d.isDirectory() || d.isSymbolicLink())
+      .map(d => {
+        let jdkPath = join(JDKS_DIR, d.name);
+        
+        if (d.isSymbolicLink()) {
+          try {
+            const realPath = run('readlink -f "' + jdkPath + '"');
+            return {
+              name: d.name,
+              path: realPath
+            };
+          } catch (err) {
+            return {
+              name: d.name,
+              path: jdkPath
+            };
+          }
+        }
+        
+        return {
+          name: d.name,
+          path: jdkPath
+        };
+      });
+    
+    for (const entry of localEntries) {
+      versions.set(entry.name, entry.path);
+    }
+  }
+  
+  if (existsSync('/usr/lib/jvm')) {
+    const systemEntries = readdirSync('/usr/lib/jvm', { withFileTypes: true })
+      .filter(d => d.isDirectory() && (d.name.includes('-amd64') || d.name.includes('-aarch64')))
+      .map(d => {
+        const match = d.name.match(/java-(\d+)/);
+        if (match) {
+          const version = match[1];
+          return {
+            name: version,
+            path: join('/usr/lib/jvm', d.name)
+          };
+        }
+        return null;
+      })
+      .filter(Boolean);
+    
+    for (const entry of systemEntries) {
+      if (!versions.has(entry.name)) {
+        versions.set(entry.name, entry.path);
+      }
+    }
+  }
+  
+  if (versions.size === 0) {
+    console.log('No JDK installed. Try: jvm install 17');
+    return;
+  }
+  
+  let current = null;
+  try {
+    current = existsSync(CURRENT_GLOBAL) ? readlinkSafe(CURRENT_GLOBAL) : null;
+  } catch {
+    current = null;
+  }
+  
+  const sortedVersions = Array.from(versions.entries()).sort((a, b) => Number(a[0]) - Number(b[0]));
+  
+  console.log('Installed JDK versions:');
+  for (const [version, path] of sortedVersions) {
+    let isCurrent = false;
+    if (current) {
+      isCurrent = path === current || (typeof path === 'string' && typeof current === 'string' && (path.includes(current) || current.includes(path)));
+    }
+    
+    const marker = isCurrent ? '*' : ' ';
+    console.log(`${marker} ${version} - ${path}`);
+  }
+}
+
+function detectSystemJdks() {
+  const versions = new Set();
+  
+  try {
+    if (existsSync('/usr/lib/jvm')) {
+      const entries = readdirSync('/usr/lib/jvm', { withFileTypes: true });
+      for (const entry of entries) {
+        if (entry.isDirectory() && (entry.name.includes('-amd64') || entry.name.includes('-aarch64'))) {
+          const match = entry.name.match(/java-(\d+)/);
+          if (match) {
+            versions.add(match[1]);
+          }
+        }
+      }
+    }
+  } catch (err) {
+    console.log(err);
+  }
+  
+  try {
+    const versionStr = run('java -version 2>&1 | head -1');
+    const match = versionStr.match(/version "(.*)"/);
+    if (match) {
+      const javaVersion = match[1];
+      if (javaVersion.startsWith('1.')) {
+        const oldVersion = javaVersion.match(/1\.(\d+)\.0/);
+        if (oldVersion) {
+          versions.add(oldVersion[1]);
+        }
+      } else {
+        const newVersion = javaVersion.match(/(\d+)/);
+        if (newVersion) {
+          versions.add(newVersion[1]);
+        }
+      }
+    }
+  } catch (err) {
+    console.log(err);
+  }
+  
+  return Array.from(versions).sort((a, b) => Number(a) - Number(b));
+}
+
+function readlinkSafe(path) {
+  return run('readlink -f "' + path + '"');
+}
+
+function findSystemJdkPath(version) {
+  if (!/^\d+$/.test(version)) {
+    fail('Version should be a major number, e.g. 8, 11, 17, 21');
+  }
+  
+  try {
+    if (existsSync('/usr/lib/jvm')) {
+      const entries = readdirSync('/usr/lib/jvm', { withFileTypes: true });
+      for (const entry of entries) {
+        const match = entry.name.match(new RegExp('java-' + version, 'i'));
+        if (match) {
+          const candidate = join('/usr/lib/jvm', entry.name);
+          if (existsSync(join(candidate, 'bin', 'java'))) {
+            return candidate;
+          }
+        }
+      }
+    }
+    
+    const javaHome = process.env.JAVA_HOME;
+    if (javaHome && existsSync(javaHome)) {
+      const currentVersion = getJavaVersionFromPath(javaHome);
+      if (currentVersion === version) {
+        return javaHome;
+      }
+    }
+    
+    const whichJava = run('which java');
+    if (whichJava) {
+      const realPath = run('readlink -f "' + whichJava + '"');
+      const candidate = resolve(dirname(dirname(realPath)));
+      const currentVersion = getJavaVersionFromPath(candidate);
+      if (currentVersion === version) {
+        return candidate;
+      }
+    }
+  } catch (err) {
+    console.log(err);
+  }
+  
+  fail('Could not find system JDK with version ' + version);
+}
+
+function getJavaVersionFromPath(path) {
+  try {
+    const releaseFile = join(path, 'release');
+    if (existsSync(releaseFile)) {
+      const content = readFileSync(releaseFile, 'utf8');
+      const match = content.match(/JAVA_VERSION="(\d+)/);
+      if (match) {
+        return match[1];
+      }
+    }
+    const versionStr = run('"' + join(path, 'bin', 'java') + '" -version 2>&1 | head -1');
+    const match = versionStr.match(/version "(.*)"/);
+    if (match) {
+      const javaVersion = match[1];
+      if (javaVersion.startsWith('1.')) {
+        const oldVersion = javaVersion.match(/1\.(\d+)\.0/);
+        if (oldVersion) {
+          return oldVersion[1];
+        }
+      } else {
+        const newVersion = javaVersion.match(/(\d+)/);
+        if (newVersion) {
+          return newVersion[1];
+        }
+      }
+    }
+  } catch (err) {
+    console.log(err);
+  }
+  return null;
+}
+
+function linkSystemJdk(systemPath, version) {
+  ensureDirs();
+  
+  if (!existsSync(systemPath)) {
+    fail('System path ' + systemPath + ' does not exist');
+  }
+  
+  const binPath = join(systemPath, 'bin', 'java');
+  if (!existsSync(binPath)) {
+    fail('Path ' + systemPath + ' does not contain a valid JDK (missing bin/java)');
+  }
+  
+  const target = join(JDKS_DIR, version);
+  if (existsSync(target)) {
+    fail('JDK ' + version + ' already installed: ' + target);
+  }
+  
+  symlinkSync(systemPath, target, 'dir');
+  console.log('Linked system JDK ' + version + ' to ' + target);
+}
+
+function setGlobal(version) {
+  ensureDirs();
+  let target;
+  
+  const localTarget = join(JDKS_DIR, version);
+  if (existsSync(localTarget)) {
+    target = localTarget;
+  } else {
+    target = findSystemJdkPath(version);
+  }
+  
+  if (!existsSync(target)) {
+    fail('JDK ' + version + ' is not installed. Run: jvm install ' + version);
+  }
+  
+  rmSync(CURRENT_GLOBAL, { recursive: true, force: true });
+  symlinkSync(target, CURRENT_GLOBAL, 'dir');
+  console.log('Global JDK set to ' + version);
+  console.log('Run: eval "$(jvm env --global)"');
+}
+
+function setProject(version) {
+  ensureDirs();
+  const localTarget = join(JDKS_DIR, version);
+  let target = localTarget;
+  
+  if (!existsSync(localTarget)) {
+    try {
+      target = findSystemJdkPath(version);
+    } catch (err) {
+      fail('JDK ' + version + ' is not installed. Run: jvm install ' + version + ' or jvm link <path> ' + version);
+    }
+  }
+  
+  if (!existsSync(target)) {
+    fail('JDK ' + version + ' is not installed. Run: jvm install ' + version + ' or jvm link <path> ' + version);
+  }
+  
+  const cwd = process.cwd();
+  const file = join(cwd, PROJECT_FILE);
+  writeFileSync(file, version + '\n', 'utf8');
+  console.log('Project JDK set to ' + version + ' via ' + PROJECT_FILE);
+  console.log('Run: eval "$(jvm env --project)"');
+}
+
+function findProjectVersion(startDir) {
+  let dir = resolve(startDir);
+  while (true) {
+    const file = join(dir, PROJECT_FILE);
+    if (existsSync(file)) {
+      const version = readFileSync(file, 'utf8').trim();
+      return { version, file };
+    }
+    const parent = dirname(dir);
+    if (parent === dir) break;
+    dir = parent;
+  }
+  return null;
+}
+
+function printEnv(mode) {
+  ensureDirs();
+  if (mode === 'project') {
+    const found = findProjectVersion(process.cwd());
+    if (!found) {
+      fail('No ' + PROJECT_FILE + ' found in current path.');
+    }
+    let target = join(JDKS_DIR, found.version);
+    
+    if (!existsSync(target)) {
+      try {
+        target = findSystemJdkPath(found.version);
+      } catch (err) {
+        fail('Project JDK ' + found.version + ' not installed. Run: jvm install ' + found.version + ' or jvm link <path> ' + found.version);
+      }
+    }
+    
+    console.log('export JAVA_HOME="' + target + '"');
+    console.log('export PATH="$JAVA_HOME/bin:$PATH"');
+    return;
+  }
+  
+  if (!existsSync(CURRENT_GLOBAL)) {
+    fail('Global JDK is not set. Run: jvm use <version> --global');
+  }
+  const target = readlinkSafe(CURRENT_GLOBAL);
+  console.log('export JAVA_HOME="' + target + '"');
+  console.log('export PATH="$JAVA_HOME/bin:$PATH"');
+}
+
+function showCurrent() {
+  ensureDirs();
+  const project = findProjectVersion(process.cwd());
+  if (project) {
+    console.log('Project: ' + project.version + ' (' + project.file + ')');
+  } else {
+    console.log('Project: <none>');
+  }
+  if (existsSync(CURRENT_GLOBAL)) {
+    const g = readlinkSafe(CURRENT_GLOBAL);
+    if (g.startsWith('/usr')) {
+      console.log('Global: ' + g + ' (system)');
+    } else {
+      console.log('Global: ' + g);
+    }
+  } else {
+    console.log('Global: <none>');
+  }
+}
+
+function removeJdk(version) {
+  ensureDirs();
+  const target = join(JDKS_DIR, version);
+  if (!existsSync(target)) {
+    fail('JDK ' + version + ' not installed');
+  }
+  
+  if (existsSync(target)) {
+    if (existsSync(join(target, 'release'))) {
+      try {
+        const content = readFileSync(join(target, 'release'), 'utf8');
+        if (!content.includes('JAVA_VERSION')) {
+          console.log('Warning: ' + target + " doesn't contain typical JDK release file.");
+        }
+      } catch (err) {
+        console.log(err);
+      }
+    }
+    
+    const current = existsSync(CURRENT_GLOBAL) ? readlinkSafe(CURRENT_GLOBAL) : null;
+    
+    if (existsSync(target) && !run('test -L "' + target + '"')) {
+      rmSync(target, { recursive: true, force: true });
+    } else if (existsSync(target) && run('test -L "' + target + '"')) {
+      rmSync(target, { recursive: true, force: true });
+    } else {
+      fail('Failed to remove ' + target);
+    }
+    
+    if (current && current === target) {
+      rmSync(CURRENT_GLOBAL, { recursive: true, force: true });
+      console.log('Removed JDK ' + version + ' and cleared global selection');
+    } else {
+      console.log('Removed JDK ' + version);
+    }
+  } else {
+    fail('JDK ' + version + ' not found');
+  }
+}
+
+function doctor() {
+  const checks = [
+    { name: 'Node.js', fn: () => process.versions.node },
+    { name: 'Architecture', fn: () => process.arch },
+    { name: 'OS Platform', fn: () => process.platform },
+    { name: 'curl', fn: () => run('curl --version | head -1') },
+    { name: 'tar', fn: () => run('tar --version | head -1') },
+    { name: 'mktemp', fn: () => run('which mktemp') },
+    { name: 'readlink', fn: () => run('readlink --version | head -1') },
+    { name: 'App Dir Permissions', fn: () => run('test -w "' + APP_DIR + '" || echo "Not writable: ' + APP_DIR + '"') },
+    { name: 'JDK Store Permissions', fn: () => run('test -w "' + JDKS_DIR + '" || echo "Not writable: ' + JDKS_DIR + '"') },
+    { name: 'System Java', fn: () => run('which java') },
+    { name: 'System JDKs', fn: () => {
+      const versions = detectSystemJdks();
+      return versions.length > 0 ? versions.join(', ') : 'Not detected';
+    }}
+  ];
+  
+  console.log('jvm doctor checks:');
+  for (const check of checks) {
+    try {
+      const result = check.fn();
+      console.log('  ' + check.name + ': ' + result);
+    } catch (err) {
+      console.log('  ' + check.name + ': Not available');
+    }
+  }
+}
+
+function parseFlags(args) {
+  const flags = new Set(args.filter(a => a.startsWith('--')));
+  return {
+    global: flags.has('--global'),
+    project: flags.has('--project')
+  };
+}
+
+function main() {
+  const args = process.argv.slice(2);
+  const cmd = args[0];
+  if (!cmd || cmd === '-h' || cmd === '--help' || cmd === 'help') {
+    usage();
+    return;
+  }
+  
+  try {
+    if (cmd === 'install') {
+      const version = args[1];
+      if (!version) fail('Missing version. Example: jvm install 17');
+      install(version);
+      return;
+    }
+    if (cmd === 'link') {
+      const systemPath = args[1];
+      const version = args[2];
+      if (!systemPath || !version) fail('Usage: jvm link <system-path> <version>');
+      linkSystemJdk(systemPath, version);
+      return;
+    }
+    if (cmd === 'list') {
+      listInstalled();
+      return;
+    }
+    if (cmd === 'use') {
+      const version = args[1];
+      if (!version) fail('Missing version. Example: jvm use 21 --global');
+      const flags = parseFlags(args.slice(2));
+      if (flags.global && flags.project) {
+        fail('Cannot use --global and --project together');
+      }
+      if (flags.project) {
+        setProject(version);
+      } else {
+        setGlobal(version);
+      }
+      return;
+    }
+    if (cmd === 'env') {
+      const flags = parseFlags(args.slice(1));
+      if (flags.global && flags.project) {
+        fail('Cannot use --global and --project together');
+      }
+      if (flags.project) {
+        printEnv('project');
+      } else {
+        printEnv('global');
+      }
+      return;
+    }
+    if (cmd === 'current') {
+      showCurrent();
+      return;
+    }
+    if (cmd === 'doctor') {
+      doctor();
+      return;
+    }
+    if (cmd === 'remove') {
+      const version = args[1];
+      if (!version) fail('Missing version. Example: jvm remove 17');
+      removeJdk(version);
+      return;
+    }
+  } catch (error) {
+    const message = error?.stderr || error?.message || String(error);
+    fail(message);
+  }
+  
+  fail('Unknown command: ' + cmd);
+}
+
+main();