Various improvements and fixes to setup-bun (#40)

* Do not save cache on hit
* Support Windows (canary only)
* Support `registry-url` and `scope`

src/action.ts

@@ -1,42 +1,178 @@
-import { tmpdir } from "node:os";
-import * as action from "@actions/core";
-import setup from "./setup.js";
-import { existsSync, readFileSync } from "fs";
-import * as path from "path";
+import { homedir } from "node:os";
+import { join } from "node:path";
+import {
+  mkdirSync,
+  readdirSync,
+  symlinkSync,
+  renameSync,
+  copyFileSync,
+} from "node:fs";
+import { addPath, info, warning } from "@actions/core";
+import { isFeatureAvailable, restoreCache, saveCache } from "@actions/cache";
+import { downloadTool, extractZip } from "@actions/tool-cache";
+import { getExecOutput } from "@actions/exec";
+import { writeBunfig } from "./bunfig";
 
-if (!process.env.RUNNER_TEMP) {
-  process.env.RUNNER_TEMP = tmpdir();
+export type Input = {
+  customUrl?: string;
+  version?: string;
+  os?: string;
+  arch?: string;
+  avx2?: boolean;
+  profile?: boolean;
+  scope?: string;
+  registryUrl?: string;
+};
+
+export type Output = {
+  version: string;
+  revision: string;
+  cacheHit: boolean;
+};
+
+export default async (options: Input): Promise<Output> => {
+  const bunfigPath = join(process.cwd(), "bunfig.toml");
+  writeBunfig(bunfigPath, options);
+
+  const url = getDownloadUrl(options);
+  const cacheEnabled = isCacheEnabled(options);
+
+  const binPath = join(homedir(), ".bun", "bin");
+  try {
+    mkdirSync(binPath, { recursive: true });
+  } catch (error) {
+    if (error.code !== "EEXIST") {
+      throw error;
+    }
+  }
+  addPath(binPath);
+
+  const exe = (name: string) =>
+    process.platform === "win32" ? `${name}.exe` : name;
+  const bunPath = join(binPath, exe("bun"));
+  try {
+    symlinkSync(bunPath, join(binPath, exe("bunx")));
+  } catch (error) {
+    if (error.code !== "EEXIST") {
+      throw error;
+    }
+  }
+
+  let revision: string | undefined;
+  let cacheHit = false;
+  if (cacheEnabled) {
+    const cacheRestored = await restoreCache([bunPath], url);
+    if (cacheRestored) {
+      revision = await getRevision(bunPath);
+      if (revision) {
+        cacheHit = true;
+        info(`Using a cached version of Bun: ${revision}`);
+      } else {
+        warning(
+          `Found a cached version of Bun: ${revision} (but it appears to be corrupted?)`
+        );
+      }
+    }
+  }
+
+  if (!cacheHit) {
+    info(`Downloading a new version of Bun: ${url}`);
+    const zipPath = await downloadTool(url);
+    const extractedZipPath = await extractZip(zipPath);
+    const extractedBunPath = await extractBun(extractedZipPath);
+    try {
+      renameSync(extractedBunPath, bunPath);
+    } catch {
+      // If mv does not work, try to copy the file instead.
+      // For example: EXDEV: cross-device link not permitted
+      copyFileSync(extractedBunPath, bunPath);
+    }
+    revision = await getRevision(bunPath);
+  }
+
+  if (!revision) {
+    throw new Error(
+      "Downloaded a new version of Bun, but failed to check its version? Try again."
+    );
+  }
+
+  if (cacheEnabled && !cacheHit) {
+    try {
+      await saveCache([bunPath], url);
+    } catch (error) {
+      warning("Failed to save Bun to cache.");
+    }
+  }
+
+  const [version] = revision.split("+");
+  return {
+    version,
+    revision,
+    cacheHit,
+  };
+};
+
+function isCacheEnabled(options: Input): boolean {
+  const { customUrl, version } = options;
+  if (customUrl) {
+    return false;
+  }
+  if (!version || /latest|canary|action/i.test(version)) {
+    return false;
+  }
+  return isFeatureAvailable();
 }
 
-function readVersionFromPackageJson(): string | undefined {
-  const { GITHUB_WORKSPACE } = process.env;
-  if (!GITHUB_WORKSPACE) {
-    return;
+function getDownloadUrl(options: Input): string {
+  const { customUrl } = options;
+  if (customUrl) {
+    return customUrl;
   }
-  const pathToPackageJson = path.join(GITHUB_WORKSPACE, "package.json");
-  if (!existsSync(pathToPackageJson)) {
-    return;
-  }
-  const { packageManager } = JSON.parse(
-    readFileSync(pathToPackageJson, "utf8")
-  ) as { packageManager?: string };
-  return packageManager?.split("bun@")[1];
+  const { version, os, arch, avx2, profile } = options;
+  const eversion = encodeURIComponent(version ?? "latest");
+  const eos = encodeURIComponent(os ?? process.platform);
+  const earch = encodeURIComponent(arch ?? process.arch);
+  const eavx2 = encodeURIComponent(avx2 ?? true);
+  const eprofile = encodeURIComponent(profile ?? false);
+  const { href } = new URL(
+    `${eversion}/${eos}/${earch}?avx2=${eavx2}&profile=${eprofile}`,
+    "https://bun.sh/download/"
+  );
+  return href;
 }
 
-setup({
-  version:
-    readVersionFromPackageJson() || action.getInput("bun-version") || undefined,
-  customUrl: action.getInput("bun-download-url") || undefined,
-  registryUrl: action.getInput("registry-url") || undefined,
-  scope: action.getInput("scope") || undefined,
-})
-  .then(({ version, revision, cacheHit, registryUrl, scope }) => {
-    action.setOutput("bun-version", version);
-    action.setOutput("bun-revision", revision);
-    action.setOutput("cache-hit", cacheHit);
-    action.setOutput("registry-url", registryUrl);
-    action.setOutput("scope", scope);
-  })
-  .catch((error) => {
-    action.setFailed(error);
+async function extractBun(path: string): Promise<string> {
+  for (const entry of readdirSync(path, { withFileTypes: true })) {
+    const { name } = entry;
+    const entryPath = join(path, name);
+    if (entry.isFile()) {
+      if (name === "bun" || name === "bun.exe") {
+        return entryPath;
+      }
+      if (/^bun.*\.zip/.test(name)) {
+        const extractedPath = await extractZip(entryPath);
+        return extractBun(extractedPath);
+      }
+    }
+    if (/^bun/.test(name) && entry.isDirectory()) {
+      return extractBun(entryPath);
+    }
+  }
+  throw new Error("Could not find executable: bun");
+}
+
+async function getRevision(exe: string): Promise<string | undefined> {
+  const revision = await getExecOutput(exe, ["--revision"], {
+    ignoreReturnCode: true,
   });
+  if (revision.exitCode === 0 && /^\d+\.\d+\.\d+/.test(revision.stdout)) {
+    return revision.stdout.trim();
+  }
+  const version = await getExecOutput(exe, ["--version"], {
+    ignoreReturnCode: true,
+  });
+  if (version.exitCode === 0 && /^\d+\.\d+\.\d+/.test(version.stdout)) {
+    return version.stdout.trim();
+  }
+  return undefined;
+}