Basic implementation

Author: kateinoigakukun

.github/workflows/test.yml

@@ -22,4 +22,4 @@ jobs:
     - uses: actions/checkout@v3
     - uses: ./
       with:
-        milliseconds: 1000
+        swift-version: wasm-RELEASE-5.7.1

action.yml

@@ -1,13 +1,10 @@
 name: 'Wait'
 description: 'Wait a designated number of milliseconds'
 inputs:
-  milliseconds:  # id of input
-    description: 'number of milliseconds to wait'
+  swift-version:
+    description: 'Swift version to configure (default: wasm-RELEASE-5.7.1)'
     required: true
-    default: '1000'
-outputs:
-  time: # output will be available to future steps
-    description: 'The current time after waiting'
+    default: 'wasm-RELEASE-5.7.1'
 runs:
   using: 'node16'
   main: 'dist/index.js'

dist/index.js

@@ -1,21 +1,121 @@
-const core = require('@actions/core');
-const wait = require('./wait');
+const fs = require("fs");
+const core = require("@actions/core");
+const tc = require("@actions/tool-cache");
+const os = require("os");
 
-
-// most @actions toolkit packages have async methods
 async function run() {
-  try {
-    const ms = core.getInput('milliseconds');
-    core.info(`Waiting ${ms} milliseconds ...`);
+  const version = resolveVersionInput();
+  validateVersion(version);
+  const platform = resolveHostPlatform();
+  const url = toolchainDownloadUrl(version, platform);
+  core.debug(`Resolved toolchain download URL: ${url}`);
+  const toolchainPath = await installToolchain(url, version, platform);
+  core.addPath(`${toolchainPath}/usr/bin`);
+}
 
-    core.debug((new Date()).toTimeString()); // debug is only output if you set the secret `ACTIONS_RUNNER_DEBUG` to true
-    await wait(parseInt(ms));
-    core.info((new Date()).toTimeString());
+async function installToolchain(url, version, platform) {
+  const cachePath = tc.find("swiftwasm", version, platform.arch);
+  if (cachePath) {
+    core.debug("Toolchain already installed.");
+    return cachePath;
+  }
+  core.debug(`Downloading tool from ${url}`);
+  const downloadPath = await tc.downloadTool(url);
+  core.debug(`Installing toolchain from ${downloadPath}`);
+  let toolchainPath;
+  switch (platform.pkg) {
+    case "tar.gz":
+      toolchainPath = await tc.extractTar(downloadPath);
+      break;
+    case "pkg":
+      toolchainPath = await tc.extractXar(downloadPath);
+      break;
+    default:
+      throw new Error(`Unsupported package type: ${platform.pkg}`);
+  }
+  core.debug(`Installed toolchain to ${toolchainPath}`);
+  const cachedPath = await tc.cacheDir(toolchainPath, "swiftwasm", version, platform.arch);
+  return cachedPath;
+}
 
-    core.setOutput('time', new Date().toTimeString());
-  } catch (error) {
-    core.setFailed(error.message);
+function resolveVersionInput(options = {}) {
+  const version = core.getInput('swift-version') || options.version;
+  if (version) {
+    core.debug(`Using version from input: ${version}`);
+    return version;
+  }
+  if (fs.existsSync(".swift-version")) {
+    const versionFile = fs.readFileSync('.swift-version', 'utf8').trim();
+    if (versionFile !== "") {
+      core.debug(`Using version from .swift-version file: ${versionFile}`);
+      return versionFile;
+    }
   }
+  const message = "No Swift version specified. Please specify a version using the 'swift-version' input or a .swift-version file.";
+  core.error(message);
+  throw new Error(message);
+}
+
+function validateVersion(version) {
+  if (version === "") {
+    throw new Error("Empty version specified.");
+  }
+  if (!version.startsWith("wasm-")) {
+    throw new Error(`Invalid version specified: ${version}. Version must start with 'wasm-'. For example: 'wasm-5.7.1-RELEASE'`);
+  }
+}
+
+function resolveHostPlatform() {
+  function normalizeOS(platform) {
+    switch (platform) {
+      case "linux":
+        return "linux";
+      case "darwin":
+        return "macos";
+      default:
+        throw new Error(`Unsupported platform: ${platform}`);
+    }
+  }
+
+  function normalizeArch(arch) {
+    switch (arch) {
+      case "arm64":
+        return "arm64";
+      case "x64":
+        return "x86_64";
+      default:
+        throw new Error(`Unsupported architecture: ${arch}`);
+    }
+  }
+
+  function parseOSRelease() {
+    const osRelease = fs.readFileSync('/etc/os-release', 'utf8');
+    const lines = osRelease.split(os.EOL);
+    const osReleaseMap = {};
+    for (const line of lines) {
+      const [key, value] = line.split('=');
+      osReleaseMap[key] = value.replace(/["]/g, "");
+    }
+    return osReleaseMap;
+  }
+
+  const platform = normalizeOS(os.platform());
+  if (platform === "linux") {
+    const osRelease = parseOSRelease();
+    if (osRelease.ID === "ubuntu") {
+      const arch = normalizeArch(os.arch());
+      return { suffix: `ubuntu${osRelease.VERSION_ID}_${arch}`, pkg: "tar.gz", arch };
+    }
+  } else if (platform === "macos") {
+    const arch = normalizeArch(os.arch());
+    return { suffix: `macos_${arch}`, pkg: "pkg", arch };
+  } else {
+    throw new Error(`Unsupported platform: ${platform}`);
+  }
+}
+
+function toolchainDownloadUrl(version, platform) {
+  `https://github.com/swiftwasm/swift/releases/download/swift-${version}/swift-${version}-${platform.suffix}.${platform.pkg}`;
 }
 
 run();

dist/index.js.map

@@ -1,24 +1,3 @@
-const wait = require('./wait');
-const process = require('process');
-const cp = require('child_process');
-const path = require('path');
-
-test('throws invalid number', async () => {
-  await expect(wait('foo')).rejects.toThrow('milliseconds not a number');
-});
-
-test('wait 500 ms', async () => {
-  const start = new Date();
-  await wait(500);
-  const end = new Date();
-  var delta = Math.abs(end - start);
-  expect(delta).toBeGreaterThanOrEqual(500);
-});
-
-// shows how the runner will run a javascript action with env / stdout protocol
-test('test runs', () => {
-  process.env['INPUT_MILLISECONDS'] = 100;
-  const ip = path.join(__dirname, 'index.js');
-  const result = cp.execSync(`node ${ip}`, {env: process.env}).toString();
-  console.log(result);
+test('noop', () => {
 })
+