feat: Fixes jenv for linux

kevinwang5658 · kevinwang5658 · commit d8820c8545d4 · 2026-04-20T14:13:59.000-04:00
diff --git a/scripts/init.sh b/scripts/init.sh
@@ -1,4 +1,8 @@
 tart clone ghcr.io/cirruslabs/macos-tahoe-base:latest codify-test-vm
 tart set codify-test-vm --memory 6124 --cpu 4
 
+tart clone ghcr.io/cirruslabs/ubuntu:latest codify-test-vm-linux
+tart set codify-test-vm-linux --memory 6124 --cpu 4
+
+
 # tart clone ghcr.io/kevinwang5658/sonoma-codify:v0.0.3 codify-sonoma
diff --git a/scripts/run-tests.ts b/scripts/run-tests.ts
@@ -98,7 +98,7 @@ async function launchPersistentTest(test: string, debug: boolean, operatingSyste
 
   console.log('Done refreshing files on VM. Starting tests...');
   VerbosityLevel.set(3);
-  await codifySpawn(`tart exec ${vmName} ${shell} -c ${operatingSystem === 'darwin' ? '-i' : ''} "cd ${dir} && FORCE_COLOR=true npm run test -- ${test} --disable-console-intercept ${debugFlag} --no-file-parallelism"`, { throws: false });
+  await codifySpawn(`tart exec -i ${vmName} ${shell} -c -i "cd ${dir} && FORCE_COLOR=true npm run test -- ${test} --disable-console-intercept ${debugFlag} --no-file-parallelism"`, { throws: false });
   // }
 }
 
@@ -125,6 +125,10 @@ async function launchPersistentVm(operatingSystem: string) {
   await testSpawn(`sshpass -p "admin" rsync -avz -e 'ssh -o PubkeyAuthentication=no -o StrictHostKeyChecking=no -o UserKnownHostsFile=/dev/null' --exclude 'node_modules' --exclude '.git' --exclude 'dist' --exclude '.fleet' ${process.cwd()} admin@${ipAddr}:~`);
   if (operatingSystem === 'darwin') {
     await testSpawn(`tart exec ${newVmName} ${shell} -i -c "mv ~/.zprofile ~/.zshenv"`);
+  } else {
+    await testSpawn(`tart exec ${newVmName} ${shell} -i -c "curl -o- https://raw.githubusercontent.com/nvm-sh/nvm/v0.40.4/install.sh | bash"`)
+    await testSpawn(`tart exec ${newVmName} ${shell} -i -c "nvm install 24; nvm alias default 24"`)
+    await testSpawn(`tart exec ${newVmName} ${shell} -i -c "echo 'export XDG_RUNTIME_DIR=/run/user/$(id -u)' >> ~/.bashrc"`)
   }
 
   await testSpawn(`tart exec ${newVmName} ${shell} -i -c "cd ~/codify-homebrew-plugin && npm ci"`);
diff --git a/src/resources/java/jenv/java-versions-parameter.ts b/src/resources/java/jenv/java-versions-parameter.ts
@@ -7,28 +7,67 @@ import { Utils } from '../../../utils/index.js';
 import { JenvConfig } from './jenv.js';
 import { nanoid } from 'nanoid';
 
-export const OPENJDK_SUPPORTED_VERSIONS = [8, 11, 17, 21, 22]
 export const JAVA_VERSION_INTEGER = /^\d+$/;
 
+// Maps an integer version to the Homebrew Cellar prefix (macOS)
+function toBrewPath(version: number): string {
+  return `/opt/homebrew/Cellar/openjdk@${version}`;
+}
+
+// Maps an integer version to the system JVM path (Linux)
+// Covers both x86_64 (amd64) and aarch64 (arm64) architectures
+async function toLinuxJvmPath(version: number): Promise<string> {
+  const candidates = [
+    `/usr/lib/jvm/java-${version}-openjdk-amd64`,
+    `/usr/lib/jvm/java-${version}-openjdk-arm64`,
+    `/usr/lib/jvm/java-${version}-openjdk`,
+    `/usr/lib/jvm/temurin-${version}`,
+    `/usr/lib/jvm/java-${version}`,
+  ];
+
+  for (const candidate of candidates) {
+    if (await FileUtils.exists(candidate)) {
+      return candidate;
+    }
+  }
+
+  // Return the most common path as the default even if it doesn't exist yet
+  const isArm = await Utils.isArmArch();
+  return `/usr/lib/jvm/java-${version}-openjdk-${isArm ? 'arm64' : 'amd64'}`;
+}
+
+function parseVersionFromBrewPath(p: string): string | undefined {
+  return p.split('/').at(4)?.split('@').at(1);
+}
+
 export class JenvAddParameter extends ArrayStatefulParameter<JenvConfig, string> {
   getSettings(): ArrayParameterSetting {
     return {
       type: 'array',
       itemType: 'directory',
       isElementEqual: (a, b) => b.includes(a),
       transformation: {
-        to: (input: string[]) =>
-          input.map((i) => {
-            if (OPENJDK_SUPPORTED_VERSIONS.includes(Number.parseInt(i, 10))) {
-              return `/opt/homebrew/Cellar/openjdk@${Number.parseInt(i, 10)}`
+        to: async (input: string[]) =>
+          Promise.all(input.map(async (i) => {
+            const parsed = Number.parseInt(i, 10);
+            if (JAVA_VERSION_INTEGER.test(i) && !Number.isNaN(parsed)) {
+              return Utils.isMacOS()
+                ? toBrewPath(parsed)
+                : await toLinuxJvmPath(parsed);
             }
 
             return i;
-          }),
+          })),
         // De-dupe the results for imports.
         from: (output: string[]) => [...new Set(output.map((i) => {
           if (i.startsWith('/opt/homebrew/Cellar/openjdk@')) {
-            return i.split('/').at(4)?.split('@').at(1)
+            return parseVersionFromBrewPath(i);
+          }
+
+          // Linux: /usr/lib/jvm/java-17-openjdk-amd64 → "17"
+          const linuxMatch = i.match(/\/usr\/lib\/jvm\/(?:java-|temurin-)(\d+)/);
+          if (linuxMatch) {
+            return linuxMatch[1];
           }
 
           return i;
@@ -41,12 +80,12 @@ export class JenvAddParameter extends ArrayStatefulParameter<JenvConfig, string>
     const $ = getPty();
 
     const { data: jenvRoot } = await $.spawn('jenv root')
-    const versions = (await fs.readdir(`${jenvRoot}/versions`)).filter((v) => v !== '.DS_store');
+    const versions = (await fs.readdir(`${jenvRoot.trim()}/versions`)).filter((v) => v !== '.DS_store' && v !== '.DS_Store');
 
     // We use a set because jenv sets an alias for 11.0.24, 11.0 and 11. We only care about the original location here
     const versionPaths = new Set(
       await Promise.all(versions.map((v) =>
-        fs.readlink(`${jenvRoot}/versions/${v}`)
+        fs.readlink(`${jenvRoot.trim()}/versions/${v}`)
       ))
     )
 
@@ -58,42 +97,47 @@ export class JenvAddParameter extends ArrayStatefulParameter<JenvConfig, string>
       // Re-map the path back to what was provided in the config
       .map((v) => {
         const matched = params?.find((p) => v.includes(p));
-        return matched === undefined
-          ? v
-          : matched;
+        return matched === undefined ? v : matched;
       })
       .filter((v) => {
-        const versionStr = v.split('/').at(4)!.split('@').at(1)!;
-        return installedVersions.includes(versionStr);
+        // macOS Homebrew path: /opt/homebrew/Cellar/openjdk@17/...
+        if (v.startsWith('/opt/homebrew/Cellar/openjdk@')) {
+          const versionStr = parseVersionFromBrewPath(v);
+          return versionStr !== undefined && installedVersions.some((iv) => iv.startsWith(versionStr));
+        }
+
+        // Linux JVM path: /usr/lib/jvm/java-17-openjdk-amd64
+        const linuxMatch = v.match(/\/usr\/lib\/jvm\/(?:java-|temurin-)(\d+)/);
+        if (linuxMatch) {
+          const versionStr = linuxMatch[1];
+          return installedVersions.some((iv) => iv.startsWith(versionStr));
+        }
+
+        // Generic path: match against installed version strings
+        return installedVersions.some((iv) => v.includes(iv));
       });
   }
 
   override async addItem(param: string): Promise<void> {
     let location = param;
 
-    // Check if we should auto install it from homebrew first
+    // macOS: auto-install from Homebrew
     if (param.startsWith('/opt/homebrew/Cellar/openjdk@')) {
-
-      // Doesn't currently exist on the file system, let's parse and install from homebrew before adding
       if (!(await FileUtils.exists(param))) {
         const isHomebrewInstalled = await Utils.isHomebrewInstalled();
         if (!isHomebrewInstalled) {
           throw new Error('Homebrew not detected. Cannot automatically install java version. Jenv does not automatically install' +
             ' java versions, see the jenv docs: https://www.jenv.be. Please manually install a version of java and provide a path to the jenv resource')
         }
 
-        const versionStr = param.split('/').at(4)?.split('@').at(1);
+        const versionStr = parseVersionFromBrewPath(param);
         if (!versionStr) {
           throw new Error(`jenv: malformed version str: ${versionStr}`)
         }
 
         const parsedVersion = Number.parseInt(versionStr, 10)
-        if (!OPENJDK_SUPPORTED_VERSIONS.includes(parsedVersion)) {
-          throw new Error(`Unsupported version of java specified. Only [${OPENJDK_SUPPORTED_VERSIONS.join(', ')}] is supported`)
-        }
-
         const $ = getPty();
-        const openjdkName = (parsedVersion === 22) ? 'openjdk' : `openjdk@${parsedVersion}`;
+        const openjdkName = `openjdk@${parsedVersion}`;
         const { status } = await $.spawnSafe(`brew list --formula -1 ${openjdkName}`, { interactive: true });
 
         // That version is not currently installed with homebrew. Let's install it
@@ -107,7 +151,7 @@ export class JenvAddParameter extends ArrayStatefulParameter<JenvConfig, string>
           throw new Error('Unable to determine location of jdk installed by homebrew. Please report this to the Codify team');
         }
 
-      // Already exists on the file system let's re-map to the actual path
+      // Already exists on the file system: re-map to the actual versioned path
       } else if (!param.endsWith('libexec/openjdk.jdk/Contents/Home')) {
         const versions = (await fs.readdir(param)).filter((v) => v !== '.DS_Store')
         const sortedVersions = semver.sort(versions);
@@ -117,6 +161,24 @@ export class JenvAddParameter extends ArrayStatefulParameter<JenvConfig, string>
       }
     }
 
+    // Linux: auto-install via apt
+    if (Utils.isLinux()) {
+      const linuxMatch = param.match(/\/usr\/lib\/jvm\/(?:java-|temurin-)(\d+)/);
+      if (linuxMatch && !(await FileUtils.exists(param))) {
+        const version = linuxMatch[1];
+        const $ = getPty();
+        const packageName = `openjdk-${version}-jdk`;
+        const { status } = await $.spawnSafe(`dpkg -s ${packageName}`, { interactive: true, requiresRoot: true });
+
+        if (status === SpawnStatus.ERROR) {
+          console.log(`apt detected. Attempting to install java version ${packageName} automatically`)
+          await $.spawn(`apt-get install -y ${packageName}`, { interactive: true, requiresRoot: true })
+        }
+
+        location = await toLinuxJvmPath(Number.parseInt(version, 10));
+      }
+    }
+
     const $ = getPty();
     try {
       await $.spawn(`jenv add ${location}`, { interactive: true });
@@ -135,7 +197,7 @@ export class JenvAddParameter extends ArrayStatefulParameter<JenvConfig, string>
     const isHomebrewInstalled = await Utils.isHomebrewInstalled();
 
     if (isHomebrewInstalled && param.startsWith('/opt/homebrew/Cellar/openjdk@')) {
-      const versionStr = param.split('/').at(4)?.split('@').at(1);
+      const versionStr = parseVersionFromBrewPath(param);
       if (!versionStr) {
         throw new Error(`jenv: malformed version str: ${versionStr}`)
       }
@@ -152,6 +214,16 @@ export class JenvAddParameter extends ArrayStatefulParameter<JenvConfig, string>
       return
     }
 
+    if (Utils.isLinux()) {
+      const linuxMatch = param.match(/\/usr\/lib\/jvm\/(?:java-|temurin-)(\d+)/);
+      if (linuxMatch) {
+        const version = linuxMatch[1];
+        await $.spawn(`jenv remove ${param}`, { interactive: true })
+        await $.spawn(`sudo apt-get remove -y openjdk-${version}-jdk`, { interactive: true })
+        return;
+      }
+    }
+
     await $.spawn(`jenv remove ${param}`, { interactive: true });
   }
 
diff --git a/src/resources/java/jenv/jenv.ts b/src/resources/java/jenv/jenv.ts
@@ -3,10 +3,11 @@ import { OS, ResourceConfig } from '@codifycli/schemas';
 import * as fs from 'node:fs';
 
 import { FileUtils } from '../../../utils/file-utils.js';
+import { Utils } from '../../../utils/index.js';
 import { JenvGlobalParameter } from './global-parameter.js';
 import {
   JenvAddParameter,
-  OPENJDK_SUPPORTED_VERSIONS
+  JAVA_VERSION_INTEGER,
 } from './java-versions-parameter.js';
 import Schema from './jenv-schema.json';
 
@@ -19,9 +20,9 @@ export class JenvResource extends Resource<JenvConfig> {
   getSettings(): ResourceSettings<JenvConfig> {
     return {
       id: 'jenv',
-      operatingSystems: [OS.Darwin],
+      operatingSystems: [OS.Darwin, OS.Linux],
       schema: Schema,
-      dependencies: ['homebrew'],
+      dependencies: Utils.isMacOS() ? ['homebrew'] : [],
       parameterSettings: {
         add: { type: 'stateful', definition: new JenvAddParameter(), order: 1 },
         global: { type: 'stateful', definition: new JenvGlobalParameter(), order: 2 },
@@ -33,18 +34,16 @@ export class JenvResource extends Resource<JenvConfig> {
     if (parameters.add) {
       for (const version of parameters.add) {
         if (version.startsWith('/opt/homebrew/Cellar/openjdk@')) {
-          const versionStr = version.split('/').at(4)?.split('@').at(1);
-
-          if (!OPENJDK_SUPPORTED_VERSIONS.includes(Number.parseInt(versionStr!, 10))) {
-            throw new Error(`Version must be one of [${OPENJDK_SUPPORTED_VERSIONS.join(', ')}]`)
-          }
-
           continue;
         }
 
-        if (!fs.existsSync(version)) {
-          throw new Error(`Path does not exist. ${version} cannot be found on the file system`)
+        if (JAVA_VERSION_INTEGER.test(version)) {
+          continue;
         }
+
+        // if (!fs.existsSync(version)) {
+        //   throw new Error(`Path does not exist. ${version} cannot be found on the file system`)
+        // }
       }
     }
   }
@@ -69,15 +68,26 @@ export class JenvResource extends Resource<JenvConfig> {
 
   override async create(): Promise<void> {
     const $ = getPty();
-    await this.assertBrewInstalled()
 
-    const jenvQuery = await $.spawnSafe('which jenv', { interactive: true })
-    if (jenvQuery.status === SpawnStatus.ERROR) {
-      await $.spawn('brew install jenv', { interactive: true })
+    if (Utils.isMacOS()) {
+      await this.assertBrewInstalled()
+
+      const jenvQuery = await $.spawnSafe('which jenv', { interactive: true })
+      if (jenvQuery.status === SpawnStatus.ERROR) {
+        await $.spawn('brew install jenv', { interactive: true })
+      }
+    } else {
+      const jenvQuery = await $.spawnSafe('which jenv', { interactive: true })
+      if (jenvQuery.status === SpawnStatus.ERROR) {
+        const result = await $.spawnSafe('git clone https://github.com/jenv/jenv.git ~/.jenv', { interactive: true })
+        if (result.status === SpawnStatus.ERROR && !result.data.includes('already exists and is not an empty directory.')) {
+          throw new Error(result.data);
+        }
+      }
     }
 
-    const jenvDoctor = await $.spawn('jenv doctor', { interactive: true })
-    if (jenvDoctor.data.includes('Jenv is not loaded in')) {
+    const jenvDoctor = await $.spawnSafe('jenv doctor', { interactive: true })
+    if (jenvDoctor.data.includes('Jenv is not loaded in') || jenvDoctor.status === SpawnStatus.ERROR) {
       await FileUtils.addToStartupFile('export PATH="$HOME/.jenv/bin:$PATH"')
       await FileUtils.addToStartupFile('eval "$(jenv init -)"')
 
diff --git a/test/java/jenv/jenv.test.ts b/test/java/jenv/jenv.test.ts
