feat: support installing specific versions for alpine

Author: aminya

packages/setup-alpine/src/apk-repository.ts

@@ -25,10 +25,10 @@ export async function addApkRepository(repoUrl: string): Promise<boolean> {
 
     // Add repository to the file
     info(`Adding repository: ${repoUrl}`)
-    await execRoot("sh", ["-c", `echo "${repoUrl}" >> ${reposFile}`], { stdio: "inherit" })
+    await execRoot("sh", ["-c", `echo "${repoUrl}" >> ${reposFile}`])
 
     // Update package index after adding repository
-    await execRoot("apk", ["update"], { stdio: "inherit" })
+    await execRoot("apk", ["update"])
 
     info(`Successfully added repository: ${repoUrl}`)
     return true

packages/setup-alpine/src/index.ts

@@ -1,21 +1,11 @@
 import { execRoot } from "admina"
 import { info, warning } from "ci-log"
 import { hasApk } from "./has-apk.js"
-import { type ApkPackage, filterAndQualifyApkPackages } from "./qualify-install.js"
+import { type ApkPackage, filterAndQualifyApkPackages, formatPackageWithVersion } from "./qualify-install.js"
 import { updateApkMemoized } from "./update.js"
 
 export type { ApkPackage }
 
-/**
- * Options for installing APK packages
- */
-export interface InstallApkPackageOptions {
-  /** The package name to install */
-  package: ApkPackage
-  /** Whether to update the package index before installing */
-  update?: boolean
-}
-
 /**
  * Install a package using Alpine's apk package manager
  * @param packages The packages to install
@@ -47,13 +37,13 @@ export async function installApkPackage(packages: ApkPackage[], update = false):
     }
 
     // Install the packages
-    info(`Installing ${packagesToInstall.map((pack) => pack.name).join(" ")}`)
-    await execRoot("apk", ["add", ...packagesToInstall.map((pack) => pack.name)], { stdio: "inherit" })
+    info(`Installing ${packagesToInstall.join(" ")}`)
+    await execRoot("apk", ["add", ...packagesToInstall])
 
-    info(`Successfully installed ${packagesToInstall.map((pack) => pack.name).join(" ")}`)
+    info(`Successfully installed ${packagesToInstall.join(" ")}`)
     return true
   } catch (error) {
-    warning(`Failed to install ${packages.map((pack) => pack.name).join(" ")}: ${error}`)
+    warning(`Failed to install ${packages.map((pkg) => formatPackageWithVersion(pkg)).join(" ")}: ${error}`)
     return false
   }
 }

packages/setup-alpine/src/qualify-install.ts

@@ -17,22 +17,67 @@ export type ApkPackage = {
   fallBackToLatest?: boolean
 }
 
-export async function filterAndQualifyApkPackages(packages: ApkPackage[]) {
-  // Filter out packages that are already installed
-  const installedPackages = await Promise.all(packages.map(checkPackageInstalled))
-  return packages.filter((_pack, index) => !installedPackages[index])
-}
 /**
  * Check if a package is already installed
- * @param pack The package to check
+ * @param pkg The package to check
  * @returns Whether the package is installed
  */
-
-async function checkPackageInstalled(pack: ApkPackage): Promise<boolean> {
+export async function checkPackageInstalled(pkg: ApkPackage): Promise<boolean> {
   try {
-    const { exitCode } = await execRoot("apk", ["info", "-e", pack.name], { reject: false })
-    return exitCode === 0
+    // First check if the package is installed at all
+    const { exitCode } = await execRoot("apk", ["info", "-e", pkg.name], {
+      reject: false,
+      stdio: ["ignore", "pipe", "ignore"],
+    })
+
+    if (exitCode !== 0) {
+      return false
+    }
+
+    // If no specific version is required, we're done
+    if (pkg.version === undefined) {
+      return true
+    }
+
+    // Check the installed version
+    const { stdout: versionOutput } = await execRoot("apk", ["info", "-v", pkg.name], {
+      stdio: ["ignore", "pipe", "ignore"],
+    })
+
+    // Parse the version from output (format is typically "package-name-version")
+    const installedVersion = versionOutput.trim().split("-").slice(-1)[0]
+
+    return installedVersion === pkg.version
   } catch (error) {
     return false
   }
 }
+
+/**
+ * Filter out packages that are already installed and qualify those that need installation
+ * @param packages List of packages to check
+ * @returns List of packages that need to be installed
+ */
+export async function filterAndQualifyApkPackages(packages: ApkPackage[]): Promise<string[]> {
+  const results = await Promise.all(
+    packages.map(async (pack) => {
+      const isInstalled = await checkPackageInstalled(pack)
+      return isInstalled ? undefined : pack
+    }),
+  )
+
+  return results.filter((pack): pack is ApkPackage => pack !== undefined)
+    .map(formatPackageWithVersion)
+}
+
+/**
+ * Format a package with its version if specified
+ * @param pkg The package object
+ * @returns Formatted package string (name=version or just name)
+ */
+export function formatPackageWithVersion(pkg: ApkPackage): string {
+  if (pkg.version !== undefined) {
+    return `${pkg.name}=${pkg.version}`
+  }
+  return pkg.name
+}