fix: Fixed a bunch of resources not pre-installing curl and unzip if it doesn't exist. Added fixes for alias, android-studio (linux support), asdf, aws-cli, npm, npm-login, nvm, ollama, pyenv, terraform, uv

Author: kevinwang5658

CLAUDE.md

@@ -247,6 +247,16 @@ const { data } = await $.spawn('command', {
 })
 ```
 
+**Never use `sudo` inside `$.spawn` or `$.spawnSafe`.** Use `{ requiresRoot: true }` in the options instead. The framework handles privilege escalation through the parent process.
+
+```typescript
+// Wrong
+await $.spawn('sudo rm -f /usr/local/bin/ollama');
+
+// Correct
+await $.spawn('rm -f /usr/local/bin/ollama', { requiresRoot: true });
+```
+
 **File Operations:**
 ```typescript
 await FileUtils.addToStartupFile(lineToAdd)
@@ -264,6 +274,34 @@ Utils.isLinux()
 Utils.isWindows()
 ```
 
+**Package Installation:**
+
+Always use `Utils.installViaPkgMgr(pkg)` from `@codifycli/plugin-core` to install system packages. This is platform-agnostic and automatically dispatches to the correct package manager (Homebrew on macOS, apt on Debian/Ubuntu, etc.). Never hardcode package manager calls like `brew install`, `apt-get install -y`, or `sudo apt install` in resource code.
+
+```typescript
+// Correct — works on macOS and Linux
+await Utils.installViaPkgMgr('curl');
+await Utils.uninstallViaPkgMgr('curl');
+
+// Wrong — hardcoded to a specific platform/package manager
+await $.spawn('sudo apt-get install -y curl');
+await $.spawn('brew install curl');
+```
+
+This applies to prerequisite checks too. When a resource needs a system dependency (e.g. `curl`, `git`, `make`), always install via `Utils.installViaPkgMgr` rather than spawning a package manager directly.
+
+**Imports — `Utils` from plugin-core vs local utils:**
+
+Always import `Utils` from `@codifycli/plugin-core`, not from `../../utils` or `../../../utils`. The local `src/utils/` module contains macOS-specific helpers (`findApplication`, `isArmArch`, `isRosetta2Installed`, `downloadUrlIntoFile`, etc.) that are only needed when those specific capabilities are required. For everything else — OS detection, package management, shell utilities — use the plugin-core `Utils`.
+
+```typescript
+// Correct
+import { Utils } from '@codifycli/plugin-core';
+
+// Only use local utils when you specifically need macOS/spotlight helpers
+import { Utils as LocalUtils } from '../../../utils/index.js';
+```
+
 ## Build Process
 
 The build process (`scripts/build.ts`) does:

scripts/init.sh

@@ -4,5 +4,9 @@ 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
 
+## Will need to manually install nodeJS on the vm
+tart run codify-test-vm-linux
+tart exec -i codify-test-vm-linux bash -c -i "curl -o- https://raw.githubusercontent.com/nvm-sh/nvm/v0.40.4/install.sh | bash"
+tart exec -i codify-test-vm-linux bash -c -i "nvm install 24; nvm alias default 24"
 
 # tart clone ghcr.io/kevinwang5658/sonoma-codify:v0.0.3 codify-sonoma

scripts/run-tests.ts

@@ -36,9 +36,9 @@ async function main(argument: string, args: {
   }
 
   if (args.persistent) {
-    if (!argument) {
-      throw new Error('No test specified for persistent mode');
-    }
+    // if (!argument) {
+    //   throw new Error('No test specified for persistent mode');
+    // }
 
     await launchPersistentTest(argument, debug, args.operatingSystem);
     return process.exit(0);
@@ -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 -i ${vmName} ${shell} -c -i 'cd ${dir} && XDG_RUNTIME_DIR="/run/user/$(id -u)" DBUS_SESSION_BUS_ADDRESS="unix:path=$XDG_RUNTIME_DIR/bus" 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} && XDG_RUNTIME_DIR="/run/user/$(id -u)" DBUS_SESSION_BUS_ADDRESS="unix:path=$XDG_RUNTIME_DIR/bus" FORCE_COLOR=true npm run test -- ${test ? test : ''} --disable-console-intercept ${debugFlag} --no-file-parallelism'`, { throws: false });
   // }
 }
 

src/resources/android/android-studio.test.ts

@@ -1,11 +1,11 @@
-import { CreatePlan, Resource, ResourceSettings, getPty, z } from '@codifycli/plugin-core';
+import { CreatePlan, DestroyPlan, Resource, ResourceSettings, Utils, getPty, z } from '@codifycli/plugin-core';
 import { OS } from '@codifycli/schemas';
 import * as fs from 'node:fs/promises';
 import os from 'node:os';
 import path from 'node:path';
 import plist from 'plist';
 
-import { Utils } from '../../utils/index.js';
+import { Utils as LocalUtils } from '../../utils/index.js';
 import { AndroidStudioPlist, AndroidStudioVersionData } from './types.js';
 
 export const schema = z.object({
@@ -18,71 +18,131 @@ export const schema = z.object({
   directory: z
     .string()
     .describe(
-      'The directory to install Android Studios into. Defaults to /Applications'
+      'The directory to install Android Studios into. Defaults to /Applications on macOS, /opt on Linux'
     )
     .optional(),
 }).meta({ $comment: 'https://codifycli.com/docs/resources/android-studio' })
 
 export type AndroidStudioConfig = z.infer<typeof schema>;
 
+const LINUX_INSTALL_DIR = '/opt';
+const MACOS_INSTALL_DIR = '/Applications';
+const LINUX_STUDIO_DIR = 'android-studio';
+
 export class AndroidStudioResource extends Resource<AndroidStudioConfig> {
 
   allAndroidStudioVersions?: AndroidStudioVersionData[];
 
   override getSettings(): ResourceSettings<AndroidStudioConfig> {
+    const defaultDir = Utils.isMacOS() ? MACOS_INSTALL_DIR : LINUX_INSTALL_DIR;
     return {
       id: 'android-studio',
-      operatingSystems: [OS.Darwin],
+      operatingSystems: [OS.Darwin, OS.Linux],
       schema,
       parameterSettings: {
-        directory: { type: 'directory', default: '/Applications' },
+        directory: { type: 'directory', default: defaultDir },
         version: { type: 'version' }
       }
     };
   }
 
   override async refresh(parameters: Partial<AndroidStudioConfig>): Promise<Partial<AndroidStudioConfig> | null> {
-    // Attempt to fetch all versions. The plist doesn't give detailed info on the version
     this.allAndroidStudioVersions = await this.fetchAllAndroidStudioVersions()
 
-    const installedVersions = (await Utils.findApplication('Android Studio')
+    if (Utils.isMacOS()) {
+      return this.refreshMacOS(parameters);
+    }
+
+    return this.refreshLinux(parameters);
+  }
+
+  override async create(plan: CreatePlan<AndroidStudioConfig>): Promise<void> {
+    if (!this.allAndroidStudioVersions) {
+      this.allAndroidStudioVersions = await this.fetchAllAndroidStudioVersions()
+    }
+
+    if (Utils.isMacOS()) {
+      return this.createMacOS(plan);
+    }
+
+    return this.createLinux(plan);
+  }
+
+  override async destroy(plan: DestroyPlan<AndroidStudioConfig>): Promise<void> {
+    if (Utils.isMacOS()) {
+      const directory = plan.currentConfig.directory ?? MACOS_INSTALL_DIR;
+      await fs.rm(path.join(directory, 'Android Studio.app'), { force: true, recursive: true });
+    } else {
+      const $ = getPty();
+      const directory = plan.currentConfig.directory ?? LINUX_INSTALL_DIR;
+      await $.spawnSafe(`rm -rf "${path.join(directory, LINUX_STUDIO_DIR)}"`, { requiresRoot: true });
+    }
+  }
+
+  private async refreshMacOS(parameters: Partial<AndroidStudioConfig>): Promise<Partial<AndroidStudioConfig> | null> {
+    const installedVersions = (await LocalUtils.findApplication('Android Studio')
       .then((locations) => Promise.all(
         locations.map((l) => this.addPlistData(l))
       )))
       .filter(Boolean)
       .map((l) => l!)
       .map((installed) => this.addWebInfo(installed, this.allAndroidStudioVersions!))
 
-    const match = this.matchVersionAndDirectory(parameters, installedVersions);
-    if (match) {
-      return match;
+    return this.matchVersionAndDirectory(parameters, installedVersions);
+  }
+
+  private async refreshLinux(parameters: Partial<AndroidStudioConfig>): Promise<Partial<AndroidStudioConfig> | null> {
+    const directory = parameters.directory ?? LINUX_INSTALL_DIR;
+    const studioDir = path.join(directory, LINUX_STUDIO_DIR);
+    const studioBin = path.join(studioDir, 'bin', 'studio');
+
+    try {
+      await fs.access(studioBin);
+    } catch {
+      return null;
     }
 
-    return null;
-  }
+    // Read product-info.json to determine the installed version
+    let installedVersion: string | undefined;
+    try {
+      const productInfoRaw = await fs.readFile(path.join(studioDir, 'product-info.json'), 'utf8');
+      const productInfo = JSON.parse(productInfoRaw) as { dataDirectoryName?: string; version?: string; buildNumber?: string };
+      installedVersion = productInfo.version;
 
-  override async create(plan: CreatePlan<AndroidStudioConfig>): Promise<void> {
-    const $ = getPty();
+      if (!installedVersion && productInfo.buildNumber) {
+        const matched = this.allAndroidStudioVersions?.find((v) => v.build === productInfo.buildNumber);
+        installedVersion = matched?.version;
+      }
+    } catch {
+      // product-info.json not readable — still report as installed, version unknown
+    }
 
-    if (!this.allAndroidStudioVersions) {
-      this.allAndroidStudioVersions = await this.fetchAllAndroidStudioVersions()
+    if (parameters.version && installedVersion && !installedVersion.includes(parameters.version)) {
+      return null;
     }
 
-    const versionToDownload = this.getVersionData(plan.desiredConfig.version, this.allAndroidStudioVersions)
+    return {
+      directory,
+      version: installedVersion,
+    };
+  }
+
+  private async createMacOS(plan: CreatePlan<AndroidStudioConfig>): Promise<void> {
+    const $ = getPty();
+
+    const versionToDownload = this.getVersionData(plan.desiredConfig.version, this.allAndroidStudioVersions!)
     if (!versionToDownload) {
       throw new Error(`Unable to find desired version: ${plan.desiredConfig.version}`);
     }
 
-    const downloadLink = await Utils.isArmArch()
+    const isArm = await LocalUtils.isArmArch();
+    const downloadLink = isArm
       ? versionToDownload.download.find((v) => v.link.includes('mac_arm.dmg'))!
       : versionToDownload.download.find((v) => v.link.includes('mac.dmg'))!
 
-    // Create a temporary tmp dir
     const temporaryDir = await fs.mkdtemp(path.join(os.tmpdir(), 'codify-android-'))
 
     try {
-
-      // Download and unzip the terraform binary
       await $.spawn(`curl -fsSL ${downloadLink.link} -o android-studio.dmg`, { cwd: temporaryDir });
 
       const { data } = await $.spawn('hdiutil attach android-studio.dmg', { cwd: temporaryDir });
@@ -98,26 +158,46 @@ export class AndroidStudioResource extends Resource<AndroidStudioConfig> {
 
       try {
         const contents = await fs.readdir(mountedDir);
-
-        // Depending on it's preview or regular the name is different
-        const appName = contents
-          .find((l) => l.includes('Android'))
+        const appName = contents.find((l) => l.includes('Android'))
 
         // Must rsync because mounted dirs are read-only (can't delete via mv)
         await $.spawn(`rsync -rl "${appName}" Applications/`, { cwd: mountedDir })
       } finally {
-        // Unmount
         await $.spawnSafe(`hdiutil detach "${mountedDir}"`)
       }
-
     } finally {
-      // Delete the tmp directory
       await fs.rm(temporaryDir, { recursive: true, force: true });
     }
   }
 
-  override async destroy(): Promise<void> {
-    await fs.rm('/Applications/Android Studio.app', { force: true, recursive: true });
+  private async createLinux(plan: CreatePlan<AndroidStudioConfig>): Promise<void> {
+    const $ = getPty();
+
+    const versionToDownload = this.getVersionData(plan.desiredConfig.version, this.allAndroidStudioVersions!)
+    if (!versionToDownload) {
+      throw new Error(`Unable to find desired version: ${plan.desiredConfig.version}`);
+    }
+
+    const downloadLink = versionToDownload.download.find((v) => v.link.includes('-linux.tar.gz'));
+
+    if (!downloadLink) {
+      throw new Error(`Unable to find a Linux download link for version: ${plan.desiredConfig.version}`);
+    }
+
+    const directory = plan.desiredConfig.directory ?? LINUX_INSTALL_DIR;
+    const temporaryDir = await fs.mkdtemp(path.join(os.tmpdir(), 'codify-android-'))
+
+    try {
+      await $.spawn(`curl -fsSL ${downloadLink.link} -o android-studio.tar.gz`, { cwd: temporaryDir });
+      await $.spawn(`tar -xzf android-studio.tar.gz`, { cwd: temporaryDir });
+
+      // Remove existing install if present
+      await fs.rm(path.join(directory, LINUX_STUDIO_DIR), { force: true, recursive: true });
+
+      await $.spawn(`mv android-studio "${directory}/"`, { cwd: temporaryDir, requiresRoot: true });
+    } finally {
+      await fs.rm(temporaryDir, { recursive: true, force: true });
+    }
   }
 
   private async fetchAllAndroidStudioVersions(): Promise<AndroidStudioVersionData[]> {

src/resources/android/android-studio.ts

@@ -1,4 +1,4 @@
-import { CreatePlan, ExampleConfig, FileUtils, Resource, ResourceSettings, SpawnStatus, getPty, z } from '@codifycli/plugin-core';
+import { CreatePlan, ExampleConfig, FileUtils, Resource, ResourceSettings, SpawnStatus, Utils as CoreUtils, getPty, z } from '@codifycli/plugin-core';
 import { OS } from '@codifycli/schemas';
 import fs from 'node:fs/promises';
 import os from 'node:os';
@@ -88,6 +88,11 @@ export class AsdfResource extends Resource<AsdfConfig> {
     }
 
     if (Utils.isLinux()) {
+      const curlCheck = await $.spawnSafe('which curl');
+      if (curlCheck.status === SpawnStatus.ERROR) {
+        await CoreUtils.installViaPkgMgr('curl');
+      }
+
       const { data: latestVersion } = await $.spawn('curl -s https://api.github.com/repos/asdf-vm/asdf/releases/latest | grep \'"tag_name":\' | sed -E \'s/.*"([^"]+)".*/\\1/\'');
 
       // Create .asdf directory if it doesn't exist

src/resources/asdf/asdf.ts

@@ -84,6 +84,11 @@ softwareupdate --install-rosetta
         : 'https://awscli.amazonaws.com/awscli-exe-linux-x86_64.zip';
 
       console.log(`Installing AWS CLI for Linux (${isArmArch ? 'ARM64' : 'x86_64'})...`);
+      const unzipCheck = await $.spawnSafe('which unzip');
+      if (unzipCheck.status === SpawnStatus.ERROR) {
+        await Utils.installViaPkgMgr('unzip');
+      }
+
       await FileUtils.downloadFile(downloadUrl, path.join(tmpDir, 'awscliv2.zip'));
       await $.spawn('unzip -q awscliv2.zip', { cwd: tmpDir });
       await $.spawn('./aws/install', { cwd: tmpDir, requiresRoot: true });

src/resources/aws-cli/cli/aws-cli.ts

@@ -6,7 +6,7 @@
   "description": "Install and manage packages using NPM.",
   "type": "object",
   "properties": {
-    "install": {
+    "globalInstall": {
       "type": "array",
       "description": "An array of npm packages to install globally. Use the npm@version syntax to pin a specific version (e.g. \"nodemon@3.1.10\").",
       "items": {