jvm-manager-cli 1.0.0

package/package.json

@@ -0,0 +1,36 @@
+{
+  "name": "jvm-manager-cli",
+  "version": "1.0.0",
+  "description": "A simple CLI to manage Java installations on Linux",
+  "main": "bin/jvm.js",
+  "scripts": {
+    "test": "node --experimental-vm-modules node_modules/jest/bin/jest.js",
+    "check": "node bin/jvm.js --help",
+    "link": "npm unlink 2>/dev/null || true && npm link",
+    "build": "mkdir -p dist && cp bin/jvm.js dist/ && cp package.json dist/ && cp README.md dist/ && cp LICENSE dist/"
+  },
+  "author": "",
+  "license": "MIT",
+  "bin": {
+    "jvm": "bin/jvm.js"
+  },
+  "keywords": ["java", "jdk", "jvm", "cli", "linux", "openjdk"],
+  "engines": {
+    "node": ">=14"
+  },
+  "dependencies": {},
+  "devDependencies": {
+    "jest": "^29.7.0"
+  },
+  "type": "module",
+  "jest": {
+    "testMatch": [
+      "**/test/**/*.spec.mjs",
+      "**/test/**/*.test.js",
+      "**/test/**/*.spec.js"
+    ],
+    "transform": {},
+    "testEnvironment": "node",
+    "verbose": true
+  }
+}

package/test/basic.spec.mjs

@@ -0,0 +1,45 @@
+import { execSync } from "child_process";
+import { existsSync, readFileSync, rmSync, writeFileSync } from "fs";
+import { join, resolve } from "path";
+import { homedir } from "os";
+
+const HOME = homedir();
+const APP_NAME = "jvm-manager";
+const APP_DIR = join(HOME, ".local", "share", APP_NAME);
+const JDKS_DIR = join(APP_DIR, "jdks");
+const PROJECT_FILE = ".jvmrc";
+
+// Helper function to run jvm commands
+function runJvmCmd(cmd, options = {}) {
+  return execSync(`node bin/jvm.js ${cmd}`, {
+    encoding: "utf8",
+    stdio: "pipe",
+    ...options
+  }).trim();
+}
+
+describe("jvm CLI basic functionality", () => {
+  it("should display help information", () => {
+    const helpOutput = runJvmCmd("help");
+    expect(helpOutput.toLowerCase()).toContain("jvm - linux jdk manager");
+    expect(helpOutput.toLowerCase()).toContain("usage:");
+  });
+
+  it("should check system compatibility", () => {
+    const doctorOutput = runJvmCmd("doctor");
+    expect(doctorOutput.toLowerCase()).toContain("node.js");
+    expect(doctorOutput.toLowerCase()).toContain("architecture");
+    expect(doctorOutput.toLowerCase()).toContain("os platform");
+  });
+
+  it("should handle list command when no JDK installed", () => {
+    expect(() => {
+      runJvmCmd("list");
+    }).not.toThrowError();
+  });
+
+  it("should create temporary directories for testing", () => {
+    // This test is to ensure that the test environment is set up correctly
+    expect(true).toBeTruthy();
+  });
+});

package/test/debug.js

@@ -0,0 +1,36 @@
+#!/usr/bin/env node
+import { existsSync, readdirSync } from "node:fs";
+import { join } from "node:path";
+
+const APP_NAME = "jvm-manager";
+const HOME = process.env.HOME;
+const APP_DIR = join(HOME, ".local", "share", APP_NAME);
+const JDKS_DIR = join(APP_DIR, "jdks");
+
+console.log("=== System JVM directory ===");
+if (existsSync("/usr/lib/jvm")) {
+  console.log("/usr/lib/jvm exists");
+  console.log("Directories in /usr/lib/jvm:");
+  readdirSync("/usr/lib/jvm", { withFileTypes: true }).forEach(entry => {
+    console.log(`  ${entry.name} (${entry.isDirectory() ? "directory" : "file"})`);
+  });
+} else {
+  console.log("/usr/lib/jvm does NOT exist");
+}
+
+console.log("\n=== Local jvm-manager directory ===");
+if (existsSync(APP_DIR)) {
+  console.log(APP_DIR + " exists");
+  console.log("Contents:");
+  readdirSync(APP_DIR, { withFileTypes: true }).forEach(entry => {
+    console.log(`  ${entry.name} (${entry.isDirectory() ? "directory" : "file"})`);
+    if (entry.isDirectory() && entry.name === "jdks") {
+      console.log("  jdks contents:");
+      readdirSync(JDKS_DIR, { withFileTypes: true }).forEach(jdkEntry => {
+        console.log(`    ${jdkEntry.name}`);
+      });
+    }
+  });
+} else {
+  console.log(APP_DIR + " does NOT exist");
+}

package/test/detectLatestBuild.js

@@ -0,0 +1,16 @@
+function detectLatestBuild(version) {
+  const arch = detectArch();
+  
+  let osArch = "x64";
+  if (arch === "arm64") {
+    osArch = "aarch64";
+  }
+  
+  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
+  };
+}

package/test/installSystem.js

@@ -0,0 +1,153 @@
+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;
+  }
+  
+  // Detect OS and use appropriate package manager
+  const osRelease = getOSRelease();
+  console.log(`Detected OS: ${osRelease.PRETTY_NAME}`);
+  
+  if (osRelease.ID === "ubuntu" || osRelease.ID === "debian") {
+    // For Ubuntu/Debian, use apt package manager
+    installUbuntuDebian(version, target);
+  } else if (osRelease.ID === "fedora" || osRelease.ID === "centos" || osRelease.ID === "rhel") {
+    // For Fedora/CentOS/RHEL, use dnf/yum
+    installFedoraCentOSRHEL(version, target);
+  } else if (osRelease.ID === "arch") {
+    // For Arch Linux, use pacman
+    installArchLinux(version, target);
+  } else {
+    // For other OSes, fall back to downloading
+    installFromDownload(version, target);
+  }
+}
+
+function installUbuntuDebian(version, target) {
+  const packageName = `openjdk-${version}-jdk`;
+  
+  console.log(`Installing OpenJDK ${version} using apt...`);
+  run(`sudo apt update`);
+  run(`sudo apt install -y ${packageName}`);
+  
+  // 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`);
+  }
+  
+  // Create symlink to system JDK
+  symlinkSync(jdkPath, target, "dir");
+  console.log(`Installed OpenJDK ${version} at ${target}`);
+}
+
+function installFedoraCentOSRHEL(version, target) {
+  const packageName = `java-${version}-openjdk-devel`;
+  
+  console.log(`Installing OpenJDK ${version} using dnf...`);
+  run(`sudo dnf install -y ${packageName}`);
+  
+  // 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`);
+  }
+  
+  // Create symlink to system JDK
+  symlinkSync(jdkPath, target, "dir");
+  console.log(`Installed OpenJDK ${version} at ${target}`);
+}
+
+function installArchLinux(version, target) {
+  const packageName = `jdk${version}-openjdk`;
+  
+  console.log(`Installing OpenJDK ${version} using pacman...`);
+  run(`sudo pacman -Syu --noconfirm ${packageName}`);
+  
+  // 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`);
+  }
+  
+  // Create symlink to system JDK
+  symlinkSync(jdkPath, target, "dir");
+  console.log(`Installed OpenJDK ${version} at ${target}`);
+}
+
+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 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;
+}

package/test/temp-main.js

@@ -0,0 +1,73 @@
+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}`);
+}

package/test/temp.js

@@ -0,0 +1,44 @@
+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 match17 = entry.name.match(/java-17/);
+          const match8 = entry.name.match(/java-8/);
+          const match21 = entry.name.match(/java-21/);
+          if (match17) versions.add("17");
+          if (match8) versions.add("8");
+          if (match21) versions.add("21");
+        }
+      }
+    }
+  } catch (err) {
+    // Ignore errors when /usr/lib/jvm doesn't exist
+  }
+
+  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) {
+    // Ignore errors when java is not available
+  }
+
+  return Array.from(versions).sort((a, b) => Number(a) - Number(b));
+}