flashjdk 1.0.0

package/lib/jdk-service.js

@@ -0,0 +1,409 @@
+'use strict';
+
+const fs = require('fs');
+const os = require('os');
+const path = require('path');
+const { execFile } = require('child_process');
+
+const projectRoot = path.join(__dirname, '..');
+const pkg = require(path.join(projectRoot, 'package.json'));
+
+function normalizePath(rawPath) {
+    if (!rawPath || typeof rawPath !== 'string') return '';
+    let value = rawPath.trim().replace(/^["']|["']$/g, '');
+    while (value.length > 1 && /[\\/]$/.test(value)) {
+        value = value.slice(0, -1);
+    }
+    try {
+        return fs.existsSync(value) ? fs.realpathSync(value) : path.resolve(value);
+    } catch {
+        return value;
+    }
+}
+
+function existsDir(target) {
+    try {
+        return fs.statSync(target).isDirectory();
+    } catch {
+        return false;
+    }
+}
+
+function existsFile(target) {
+    try {
+        return fs.statSync(target).isFile();
+    } catch {
+        return false;
+    }
+}
+
+function getPlatformKind() {
+    if (process.platform === 'win32') return 'windows';
+    if (process.platform === 'darwin') return 'macos';
+    return 'linux';
+}
+
+function getCacheInfo() {
+    if (process.platform === 'win32') {
+        const base = process.env.APPDATA || path.join(os.homedir(), 'AppData', 'Roaming');
+        return {
+            dir: path.join(base, 'flashjdk'),
+            file: path.join(base, 'flashjdk', 'jdk-roots-cache.json'),
+            format: 'json',
+        };
+    }
+
+    return {
+        dir: path.join(os.homedir(), '.config', 'flashjdk'),
+        file: path.join(os.homedir(), '.config', 'flashjdk', 'custom-roots.txt'),
+        format: 'text',
+    };
+}
+
+function getDefaultRoots() {
+    const home = os.homedir();
+    if (process.platform === 'win32') {
+        return [
+            'C:\\Program Files\\Java',
+            'C:\\Program Files (x86)\\Java',
+            'D:\\Java',
+            'D:\\ProgramFiles\\Java',
+            'E:\\Java',
+            path.join(home, '.jdks'),
+        ];
+    }
+
+    if (process.platform === 'darwin') {
+        return [
+            '/Library/Java/JavaVirtualMachines',
+            path.join(home, 'Library', 'Java', 'JavaVirtualMachines'),
+            '/usr/local/opt',
+            '/opt/homebrew/opt',
+            path.join(home, '.sdkman', 'candidates', 'java'),
+            path.join(home, '.jdks'),
+        ];
+    }
+
+    return [
+        '/usr/lib/jvm',
+        '/usr/local/java',
+        '/usr/local/jdk',
+        '/opt/java',
+        '/opt/jdk',
+        path.join(home, '.sdkman', 'candidates', 'java'),
+        path.join(home, '.jdks'),
+    ];
+}
+
+function uniquePaths(paths) {
+    const seen = new Set();
+    const output = [];
+    for (const item of paths) {
+        const normalized = normalizePath(item);
+        const key = process.platform === 'win32' ? normalized.toLowerCase() : normalized;
+        if (!normalized || seen.has(key)) continue;
+        seen.add(key);
+        output.push(normalized);
+    }
+    return output;
+}
+
+function samePath(left, right) {
+    const a = normalizePath(left);
+    const b = normalizePath(right);
+    return process.platform === 'win32' ? a.toLowerCase() === b.toLowerCase() : a === b;
+}
+
+function readCachedRoots() {
+    const cache = getCacheInfo();
+    if (!existsFile(cache.file)) return [];
+
+    try {
+        if (cache.format === 'json') {
+            const parsed = JSON.parse(fs.readFileSync(cache.file, 'utf8'));
+            return uniquePaths(Array.isArray(parsed.customRoots) ? parsed.customRoots : []);
+        }
+
+        const lines = fs.readFileSync(cache.file, 'utf8')
+            .split(/\r?\n/)
+            .map(line => line.trim())
+            .filter(line => line && !line.startsWith('#'));
+        return uniquePaths(lines);
+    } catch {
+        return [];
+    }
+}
+
+function writeCachedRoots(roots) {
+    const cache = getCacheInfo();
+    fs.mkdirSync(cache.dir, { recursive: true });
+    const normalized = uniquePaths(roots).filter(existsDir);
+
+    if (cache.format === 'json') {
+        fs.writeFileSync(cache.file, JSON.stringify({ customRoots: normalized }, null, 2), 'utf8');
+    } else {
+        fs.writeFileSync(cache.file, `${normalized.join('\n')}\n`, 'utf8');
+    }
+
+    return normalized;
+}
+
+function getSearchRoots() {
+    return uniquePaths([...getDefaultRoots(), ...readCachedRoots()]);
+}
+
+function javaExecutable(jdkHome) {
+    return path.join(jdkHome, 'bin', process.platform === 'win32' ? 'java.exe' : 'java');
+}
+
+function isJdkHome(jdkHome) {
+    return existsFile(javaExecutable(jdkHome));
+}
+
+function safeChildren(root) {
+    try {
+        return fs.readdirSync(root, { withFileTypes: true })
+            .filter(entry => entry.isDirectory())
+            .map(entry => path.join(root, entry.name));
+    } catch {
+        return [];
+    }
+}
+
+function findMacJdks(root) {
+    const found = [];
+    for (const child of safeChildren(root)) {
+        if (child.endsWith('.jdk')) {
+            const home = path.join(child, 'Contents', 'Home');
+            if (isJdkHome(home)) found.push(home);
+            continue;
+        }
+
+        const directBundle = path.join(child, 'Contents', 'Home');
+        if (isJdkHome(directBundle)) found.push(directBundle);
+
+        const libexec = path.join(child, 'libexec');
+        for (const inner of safeChildren(libexec)) {
+            if (!inner.endsWith('.jdk')) continue;
+            const home = path.join(inner, 'Contents', 'Home');
+            if (isJdkHome(home)) found.push(home);
+        }
+
+        if (isJdkHome(child)) found.push(child);
+    }
+
+    if (isJdkHome(root)) found.push(root);
+    return found;
+}
+
+function findJdksInRoot(root) {
+    const normalizedRoot = normalizePath(root);
+    if (!existsDir(normalizedRoot)) return [];
+
+    if (process.platform === 'darwin') {
+        return findMacJdks(normalizedRoot);
+    }
+
+    const found = [];
+    if (isJdkHome(normalizedRoot)) found.push(normalizedRoot);
+
+    for (const child of safeChildren(normalizedRoot)) {
+        if (isJdkHome(child)) found.push(child);
+    }
+
+    return found;
+}
+
+function runFile(command, args, options = {}) {
+    return new Promise(resolve => {
+        execFile(command, args, {
+            windowsHide: true,
+            timeout: options.timeout || 15000,
+            maxBuffer: 1024 * 1024,
+            env: options.env || process.env,
+        }, (error, stdout, stderr) => {
+            resolve({
+                ok: !error,
+                code: error && typeof error.code === 'number' ? error.code : 0,
+                stdout: stdout || '',
+                stderr: stderr || '',
+                message: error ? error.message : '',
+            });
+        });
+    });
+}
+
+async function getJavaVersion(jdkHome) {
+    const result = await runFile(javaExecutable(jdkHome), ['-version'], { timeout: 5000 });
+    return (result.stderr || result.stdout || '').trim();
+}
+
+async function listJdks() {
+    const currentJavaHome = normalizePath(process.env.JAVA_HOME || '');
+    const roots = getSearchRoots();
+    const cachedRoots = readCachedRoots();
+    const homes = uniquePaths(roots.flatMap(findJdksInRoot));
+    const items = [];
+
+    for (const home of homes) {
+        items.push({
+            home,
+            current: !!currentJavaHome && samePath(home, currentJavaHome),
+            version: await getJavaVersion(home),
+        });
+    }
+
+    return {
+        currentJavaHome,
+        cache: getCacheInfo(),
+        roots: roots.map(root => ({ path: root, exists: existsDir(root), cached: cachedRoots.some(cached => samePath(cached, root)) })),
+        jdks: items,
+    };
+}
+
+function addSearchRoot(root) {
+    const normalized = normalizePath(root);
+    if (!existsDir(normalized)) {
+        const error = new Error(`Path does not exist: ${normalized}`);
+        error.code = 'ENOENT';
+        throw error;
+    }
+
+    return writeCachedRoots([...readCachedRoots(), normalized]);
+}
+
+function buildWindowsEnvScript() {
+    return `
+param([string]$JdkHome)
+$ErrorActionPreference = "Stop"
+function Test-IsJdkEntry {
+    param([string]$Entry)
+    if ([string]::IsNullOrWhiteSpace($Entry)) { return $false }
+    $e = [Environment]::ExpandEnvironmentVariables($Entry.Trim().Trim('"').TrimEnd('\\').TrimEnd('/'))
+    if (Test-Path -LiteralPath (Join-Path $e "java.exe")) { return $true }
+    $vendorPattern = '(jdk|jre|java|openjdk|temurin|zulu|corretto|graal|dragonwell|kona|semeru|liberica|oracle)'
+    return ($e -imatch "\\\\$vendorPattern[^\\\\]*\\\\bin$") -or
+           ($e -imatch "\\\\$vendorPattern[^\\\\]*\\\\jre\\\\bin$")
+}
+$newBin = Join-Path $JdkHome "bin"
+$newJre = Join-Path $JdkHome "jre\\bin"
+if (-not (Test-Path -LiteralPath (Join-Path $newBin "java.exe"))) {
+    throw "java.exe not found under $newBin"
+}
+$machinePath = [Environment]::GetEnvironmentVariable("Path", "Machine")
+$parts = @($machinePath -split ";" | Where-Object { $_ -ne "" })
+$cleaned = @($parts | Where-Object { -not (Test-IsJdkEntry $_) })
+$newEntries = @($newBin)
+if (Test-Path -LiteralPath $newJre) { $newEntries += $newJre }
+$finalParts = @($newEntries + $cleaned | Select-Object -Unique)
+[Environment]::SetEnvironmentVariable("Path", ($finalParts -join ";"), "Machine")
+[Environment]::SetEnvironmentVariable("JAVA_HOME", $JdkHome, "Machine")
+Write-Output "JAVA_HOME=$JdkHome"
+`;
+}
+
+function getProfileFile() {
+    const shell = path.basename(process.env.SHELL || 'bash');
+    if (shell === 'zsh') return path.join(os.homedir(), '.zshrc');
+    if (shell === 'bash') {
+        return process.platform === 'darwin'
+            ? path.join(os.homedir(), '.bash_profile')
+            : path.join(os.homedir(), '.bashrc');
+    }
+    return path.join(os.homedir(), '.profile');
+}
+
+function escapeRegExp(value) {
+    return value.replace(/[.*+?^${}()|[\]\\]/g, '\\$&');
+}
+
+function updateUnixProfile(jdkHome) {
+    const profileFile = getProfileFile();
+    const begin = '# flashjdk: managed block - do not edit';
+    const end = '# flashjdk: end';
+    const block = `${begin}
+export JAVA_HOME="${jdkHome.replace(/"/g, '\\"')}"
+export PATH="$JAVA_HOME/bin:$PATH"
+${end}`;
+
+    let content = '';
+    if (existsFile(profileFile)) {
+        content = fs.readFileSync(profileFile, 'utf8');
+    }
+
+    const pattern = new RegExp(`\\n?${escapeRegExp(begin)}[\\s\\S]*?${escapeRegExp(end)}\\n?`, 'g');
+    const cleaned = content.replace(pattern, '\n').replace(/\n{3,}/g, '\n\n').trimEnd();
+    const next = `${cleaned}${cleaned ? '\n\n' : ''}${block}\n`;
+    fs.writeFileSync(profileFile, next, 'utf8');
+    return profileFile;
+}
+
+async function switchJdk(jdkHome) {
+    const normalized = normalizePath(jdkHome);
+    if (!isJdkHome(normalized)) {
+        const error = new Error(`Not a valid JDK home: ${normalized}`);
+        error.code = 'EINVAL';
+        throw error;
+    }
+
+    let result;
+    if (process.platform === 'win32') {
+        result = await runFile('powershell.exe', [
+            '-NoProfile',
+            '-ExecutionPolicy',
+            'Bypass',
+            '-Command',
+            buildWindowsEnvScript(),
+            normalized,
+        ], { timeout: 20000 });
+
+        if (!result.ok) {
+            const error = new Error(result.stderr || result.stdout || result.message || 'Failed to update Windows environment variables.');
+            error.code = result.code;
+            error.details = 'Windows requires running this app as Administrator to update Machine PATH and JAVA_HOME.';
+            throw error;
+        }
+    } else {
+        const profileFile = updateUnixProfile(normalized);
+        result = { ok: true, stdout: `Updated ${profileFile}`, stderr: '' };
+    }
+
+    process.env.JAVA_HOME = normalized;
+    const pathKey = process.platform === 'win32'
+        ? Object.keys(process.env).find(key => key.toLowerCase() === 'path') || 'Path'
+        : 'PATH';
+    process.env[pathKey] = `${path.join(normalized, 'bin')}${path.delimiter}${process.env[pathKey] || ''}`;
+    if (process.platform === 'win32') {
+        for (const key of Object.keys(process.env)) {
+            if (key !== pathKey && key.toLowerCase() === 'path') delete process.env[key];
+        }
+    }
+
+    return {
+        home: normalized,
+        output: `${result.stdout}${result.stderr}`.trim(),
+        version: await getJavaVersion(normalized),
+        restartHint: process.platform === 'win32'
+            ? 'Open a new terminal window after switching.'
+            : `Open a new terminal or source ${getProfileFile()}.`,
+    };
+}
+
+function getAppInfo() {
+    return {
+        name: pkg.name,
+        version: pkg.version,
+        platform: getPlatformKind(),
+        node: process.version,
+        cache: getCacheInfo(),
+    };
+}
+
+module.exports = {
+    addSearchRoot,
+    getAppInfo,
+    getSearchRoots,
+    listJdks,
+    normalizePath,
+    switchJdk,
+};

package/package.json

@@ -0,0 +1,46 @@
+{
+  "name": "flashjdk",
+  "version": "1.0.0",
+  "description": "flashJDK — 极速切换 JDK 版本，自动更新 PATH 和 JAVA_HOME，支持 Windows / macOS / Linux",
+  "keywords": [
+    "jdk",
+    "java",
+    "flashjdk",
+    "java-home",
+    "jdk-version",
+    "jdk-switch",
+    "windows",
+    "macos",
+    "linux",
+    "cross-platform",
+    "cli"
+  ],
+  "homepage": "https://github.com/lydAndtry/flashJDK",
+  "bugs": {
+    "url": "https://github.com/lydAndtry/flashJDK/issues"
+  },
+  "repository": {
+    "type": "git",
+    "url": "git+https://github.com/lydAndtry/flashJDK.git"
+  },
+  "license": "Apache-2.0",
+  "author": "liyongde",
+  "bin": {
+    "flashjdk": "bin/flashjdk.js"
+  },
+  "files": [
+    "bin/",
+    "lib/",
+    "scripts/",
+    "README.md",
+    "LICENSE"
+  ],
+  "os": [
+    "win32",
+    "darwin",
+    "linux"
+  ],
+  "engines": {
+    "node": ">=12.0.0"
+  }
+}