@boringcache/action-core 1.0.0

package/LICENSE

@@ -0,0 +1,21 @@
+MIT License
+
+Copyright (c) 2024 BoringCache
+
+Permission is hereby granted, free of charge, to any person obtaining a copy
+of this software and associated documentation files (the "Software"), to deal
+in the Software without restriction, including without limitation the rights
+to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
+copies of the Software, and to permit persons to whom the Software is
+furnished to do so, subject to the following conditions:
+
+The above copyright notice and this permission notice shall be included in all
+copies or substantial portions of the Software.
+
+THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
+AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
+OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
+SOFTWARE.

package/README.md

@@ -0,0 +1,151 @@
+# @boringcache/action-core
+
+**Cache once. Reuse everywhere.**
+
+Shared core library for BoringCache GitHub Actions. This package provides the common functionality used by all BoringCache actions to download, install, and execute the BoringCache CLI.
+
+## Installation
+
+```bash
+npm install @boringcache/action-core
+```
+
+## Usage
+
+```typescript
+import { ensureBoringCache, execBoringCache } from '@boringcache/action-core';
+
+// Ensure the CLI is installed
+await ensureBoringCache({ version: 'v1.0.0' });
+
+// Execute CLI commands
+const exitCode = await execBoringCache(['restore', 'workspace', 'tag:path']);
+```
+
+## API
+
+### `ensureBoringCache(options: SetupOptions): Promise<void>`
+
+Downloads and installs the BoringCache CLI if not already available.
+
+**Options:**
+- `version` (required): Version to install (e.g., `'v1.0.0'`). Set to `'skip'` to skip installation.
+- `token` (optional): API token (defaults to `BORINGCACHE_API_TOKEN` env var)
+- `cache` (optional): Enable automatic caching across workflow runs (default: `true`)
+
+**Features:**
+- Automatic platform detection (Linux, macOS, Windows)
+- **Automatic caching** - CLI is cached across workflow runs using `@actions/cache`
+- Uses GitHub Actions tool cache for fast subsequent jobs
+- Handles Windows bash fallback
+- Masks API token in logs
+
+### `execBoringCache(args: string[], options?: ExecOptions): Promise<number>`
+
+Executes the BoringCache CLI with the given arguments.
+
+**Parameters:**
+- `args`: Command line arguments to pass to the CLI
+- `options`: Optional exec options (from `@actions/exec`)
+
+**Returns:** Exit code from the command
+
+### `isCliAvailable(): Promise<boolean>`
+
+Checks if the BoringCache CLI is available on the PATH.
+
+### `getToolCacheInfo(version: string): ToolCacheInfo`
+
+Get tool cache information for persisting the CLI across workflow runs.
+
+**Returns:**
+```typescript
+interface ToolCacheInfo {
+  toolName: string;      // 'boringcache'
+  version: string;       // Normalized version (e.g., '1.0.0')
+  cachePath: string | null;  // Path if cached, null otherwise
+  cachePattern: string;  // Glob pattern for actions/cache
+  cacheKey: string;      // Cache key for actions/cache
+}
+```
+
+## Automatic Caching
+
+The CLI is **automatically cached** across workflow runs using `@actions/cache`. No extra configuration needed!
+
+```typescript
+// First workflow run: downloads CLI and saves to cache
+await ensureBoringCache({ version: 'v1.0.0' });
+
+// Subsequent runs: restores from cache instantly
+await ensureBoringCache({ version: 'v1.0.0' });
+```
+
+To disable automatic caching:
+
+```typescript
+await ensureBoringCache({ version: 'v1.0.0', cache: false });
+```
+
+### Manual Cache Control
+
+For advanced use cases, you can use `getToolCacheInfo()` to manage caching yourself:
+
+```typescript
+import * as cache from '@actions/cache';
+import { ensureBoringCache, getToolCacheInfo } from '@boringcache/action-core';
+
+const info = getToolCacheInfo('v1.0.0');
+console.log(info.cacheKey);     // 'boringcache-1.0.0-linux-x64'
+console.log(info.cachePattern); // '/opt/hostedtoolcache/boringcache/1.0.0*'
+console.log(info.cachePath);    // Path if cached, null otherwise
+```
+
+## How Tool Cache Works
+
+```
+┌─────────────────────────────────────────────────────────────────┐
+│ First Run (no cache)                                            │
+├─────────────────────────────────────────────────────────────────┤
+│ 1. tc.find('boringcache', '1.0.0') → null                       │
+│ 2. tc.downloadTool(url) → /tmp/downloaded-binary                │
+│ 3. tc.cacheDir(dir, 'boringcache', '1.0.0')                     │
+│    → $RUNNER_TOOL_CACHE/boringcache/1.0.0/x64/                  │
+│ 4. core.addPath(cachedPath)                                     │
+└─────────────────────────────────────────────────────────────────┘
+
+┌─────────────────────────────────────────────────────────────────┐
+│ Subsequent Run (same job/workflow)                              │
+├─────────────────────────────────────────────────────────────────┤
+│ 1. tc.find('boringcache', '1.0.0')                              │
+│    → $RUNNER_TOOL_CACHE/boringcache/1.0.0/x64/                  │
+│ 2. core.addPath(cachedPath) ✓ (no download needed)              │
+└─────────────────────────────────────────────────────────────────┘
+
+┌─────────────────────────────────────────────────────────────────┐
+│ With actions/cache (persists across workflow runs)              │
+├─────────────────────────────────────────────────────────────────┤
+│ 1. actions/cache restores $RUNNER_TOOL_CACHE/boringcache        │
+│ 2. tc.find('boringcache', '1.0.0') → cached path ✓              │
+│ 3. No download needed on any run!                               │
+└─────────────────────────────────────────────────────────────────┘
+```
+
+## Environment Variables
+
+- `BORINGCACHE_API_TOKEN`: API token for authentication
+- `RUNNER_OS`: GitHub Actions runner OS (auto-detected)
+- `RUNNER_ARCH`: GitHub Actions runner architecture (auto-detected)
+- `RUNNER_TOOL_CACHE`: Tool cache directory (auto-detected)
+
+## Supported Platforms
+
+| OS      | Architecture |
+|---------|-------------|
+| Linux   | x64, ARM64  |
+| macOS   | ARM64       |
+| Windows | x64         |
+
+## License
+
+MIT

package/dist/index.d.ts

@@ -0,0 +1 @@
+export { ensureBoringCache, execBoringCache, isCliAvailable, getToolCacheInfo, SetupOptions, ToolCacheInfo, } from './setup';

package/dist/index.js

@@ -0,0 +1,9 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.getToolCacheInfo = exports.isCliAvailable = exports.execBoringCache = exports.ensureBoringCache = void 0;
+var setup_1 = require("./setup");
+Object.defineProperty(exports, "ensureBoringCache", { enumerable: true, get: function () { return setup_1.ensureBoringCache; } });
+Object.defineProperty(exports, "execBoringCache", { enumerable: true, get: function () { return setup_1.execBoringCache; } });
+Object.defineProperty(exports, "isCliAvailable", { enumerable: true, get: function () { return setup_1.isCliAvailable; } });
+Object.defineProperty(exports, "getToolCacheInfo", { enumerable: true, get: function () { return setup_1.getToolCacheInfo; } });
+//# sourceMappingURL=data:application/json;base64,eyJ2ZXJzaW9uIjozLCJmaWxlIjoiaW5kZXguanMiLCJzb3VyY2VSb290IjoiIiwic291cmNlcyI6WyIuLi9saWIvaW5kZXgudHMiXSwibmFtZXMiOltdLCJtYXBwaW5ncyI6Ijs7O0FBQUEsaUNBT2lCO0FBTmYsMEdBQUEsaUJBQWlCLE9BQUE7QUFDakIsd0dBQUEsZUFBZSxPQUFBO0FBQ2YsdUdBQUEsY0FBYyxPQUFBO0FBQ2QseUdBQUEsZ0JBQWdCLE9BQUEifQ==

package/dist/setup.d.ts

@@ -0,0 +1,27 @@
+import * as exec from '@actions/exec';
+export interface SetupOptions {
+    version: string;
+    token?: string;
+    /** Enable automatic caching across workflow runs (default: true) */
+    cache?: boolean;
+}
+export interface ToolCacheInfo {
+    /** Tool name used in cache */
+    toolName: string;
+    /** Normalized version (without 'v' prefix) */
+    version: string;
+    /** Full path to tool cache directory (or null if not cached) */
+    cachePath: string | null;
+    /** Path pattern for use with actions/cache */
+    cachePattern: string;
+    /** Cache key for use with actions/cache */
+    cacheKey: string;
+}
+/**
+ * Get tool cache information for a specific version.
+ * Use this to persist the tool cache across workflow runs with actions/cache.
+ */
+export declare function getToolCacheInfo(version: string): ToolCacheInfo;
+export declare function isCliAvailable(): Promise<boolean>;
+export declare function ensureBoringCache(options: SetupOptions): Promise<void>;
+export declare function execBoringCache(args: string[], options?: exec.ExecOptions): Promise<number>;

package/dist/setup.js

@@ -0,0 +1,222 @@
+"use strict";
+var __createBinding = (this && this.__createBinding) || (Object.create ? (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    var desc = Object.getOwnPropertyDescriptor(m, k);
+    if (!desc || ("get" in desc ? !m.__esModule : desc.writable || desc.configurable)) {
+      desc = { enumerable: true, get: function() { return m[k]; } };
+    }
+    Object.defineProperty(o, k2, desc);
+}) : (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    o[k2] = m[k];
+}));
+var __setModuleDefault = (this && this.__setModuleDefault) || (Object.create ? (function(o, v) {
+    Object.defineProperty(o, "default", { enumerable: true, value: v });
+}) : function(o, v) {
+    o["default"] = v;
+});
+var __importStar = (this && this.__importStar) || (function () {
+    var ownKeys = function(o) {
+        ownKeys = Object.getOwnPropertyNames || function (o) {
+            var ar = [];
+            for (var k in o) if (Object.prototype.hasOwnProperty.call(o, k)) ar[ar.length] = k;
+            return ar;
+        };
+        return ownKeys(o);
+    };
+    return function (mod) {
+        if (mod && mod.__esModule) return mod;
+        var result = {};
+        if (mod != null) for (var k = ownKeys(mod), i = 0; i < k.length; i++) if (k[i] !== "default") __createBinding(result, mod, k[i]);
+        __setModuleDefault(result, mod);
+        return result;
+    };
+})();
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.getToolCacheInfo = getToolCacheInfo;
+exports.isCliAvailable = isCliAvailable;
+exports.ensureBoringCache = ensureBoringCache;
+exports.execBoringCache = execBoringCache;
+const core = __importStar(require("@actions/core"));
+const exec = __importStar(require("@actions/exec"));
+const tc = __importStar(require("@actions/tool-cache"));
+const cache = __importStar(require("@actions/cache"));
+const fs = __importStar(require("fs"));
+const os = __importStar(require("os"));
+const path = __importStar(require("path"));
+const TOOL_NAME = 'boringcache';
+const GITHUB_RELEASES_BASE = 'https://github.com/boringcache/cli/releases/download';
+/**
+ * Get tool cache information for a specific version.
+ * Use this to persist the tool cache across workflow runs with actions/cache.
+ */
+function getToolCacheInfo(version) {
+    const normalizedVersion = version.replace(/^v/, '');
+    const platform = getPlatformInfo();
+    const cachePath = tc.find(TOOL_NAME, normalizedVersion);
+    const toolCacheRoot = process.env.RUNNER_TOOL_CACHE || '/opt/hostedtoolcache';
+    return {
+        toolName: TOOL_NAME,
+        version: normalizedVersion,
+        cachePath: cachePath || null,
+        cachePattern: `${toolCacheRoot}/${TOOL_NAME}/${normalizedVersion}*`,
+        cacheKey: `${TOOL_NAME}-${normalizedVersion}-${platform.os}-${platform.arch}`,
+    };
+}
+function getPlatformInfo() {
+    const runnerOS = process.env.RUNNER_OS || os.platform();
+    const runnerArch = process.env.RUNNER_ARCH || os.arch();
+    let normalizedOS = runnerOS;
+    let normalizedArch = runnerArch;
+    if (runnerOS === 'darwin' || runnerOS === 'Darwin') {
+        normalizedOS = 'macOS';
+    }
+    else if (runnerOS === 'win32' || runnerOS === 'Windows') {
+        normalizedOS = 'Windows';
+    }
+    else if (runnerOS === 'linux' || runnerOS === 'Linux') {
+        normalizedOS = 'Linux';
+    }
+    if (runnerArch === 'x64' || runnerArch === 'X64' || runnerArch === 'amd64') {
+        normalizedArch = 'X64';
+    }
+    else if (runnerArch === 'arm64' || runnerArch === 'ARM64' || runnerArch === 'aarch64') {
+        normalizedArch = 'ARM64';
+    }
+    const isWindows = normalizedOS === 'Windows';
+    let assetName;
+    switch (normalizedOS) {
+        case 'Linux':
+            assetName = normalizedArch === 'ARM64' ? 'boringcache-linux-arm64' : 'boringcache-linux-amd64';
+            break;
+        case 'macOS':
+            assetName = 'boringcache-macos-14-arm64';
+            break;
+        case 'Windows':
+            assetName = 'boringcache-windows-2022-amd64.exe';
+            break;
+        default:
+            throw new Error(`Unsupported platform: OS=${runnerOS}, ARCH=${runnerArch}`);
+    }
+    return {
+        os: normalizedOS.toLowerCase(),
+        arch: normalizedArch.toLowerCase(),
+        assetName,
+        isWindows,
+    };
+}
+function getDownloadUrl(version, assetName) {
+    return `${GITHUB_RELEASES_BASE}/${version}/${assetName}`;
+}
+async function downloadAndInstall(version, platform) {
+    const downloadUrl = getDownloadUrl(version, platform.assetName);
+    core.info(`Downloading BoringCache CLI from: ${downloadUrl}`);
+    const downloadedPath = await tc.downloadTool(downloadUrl);
+    const binaryName = platform.isWindows ? 'boringcache.exe' : 'boringcache';
+    const installDir = path.join(os.tmpdir(), 'boringcache-install', version);
+    await fs.promises.mkdir(installDir, { recursive: true });
+    const binaryPath = path.join(installDir, binaryName);
+    await fs.promises.copyFile(downloadedPath, binaryPath);
+    if (!platform.isWindows) {
+        await fs.promises.chmod(binaryPath, 0o755);
+    }
+    const cachedPath = await tc.cacheDir(installDir, TOOL_NAME, version.replace(/^v/, ''));
+    return cachedPath;
+}
+async function isCliAvailable() {
+    try {
+        let output = '';
+        const result = await exec.exec('boringcache', ['--version'], {
+            ignoreReturnCode: true,
+            silent: true,
+            listeners: {
+                stdout: (data) => { output += data.toString(); },
+                stderr: (data) => { output += data.toString(); }
+            }
+        });
+        return result === 0 && output.includes('boringcache');
+    }
+    catch {
+        return false;
+    }
+}
+async function ensureBoringCache(options) {
+    const token = options.token || process.env.BORINGCACHE_API_TOKEN;
+    if (token) {
+        core.setSecret(token);
+    }
+    if (options.version === 'skip') {
+        core.debug('CLI setup skipped (version: skip)');
+        if (await isCliAvailable()) {
+            return;
+        }
+        throw new Error('BoringCache CLI not found and cli-version is set to "skip"');
+    }
+    if (await isCliAvailable()) {
+        core.debug('BoringCache CLI already available');
+        return;
+    }
+    const version = options.version;
+    const normalizedVersion = version.startsWith('v') ? version : `v${version}`;
+    const platform = getPlatformInfo();
+    const enableCache = options.cache !== false;
+    core.info(`Installing BoringCache CLI ${normalizedVersion}...`);
+    // Get cache info for this version
+    const cacheInfo = getToolCacheInfo(normalizedVersion);
+    const toolCacheRoot = process.env.RUNNER_TOOL_CACHE || '/opt/hostedtoolcache';
+    const cachePaths = [`${toolCacheRoot}/${TOOL_NAME}`];
+    // Try to restore from actions/cache first
+    let restoredFromCache = false;
+    if (enableCache) {
+        try {
+            const cacheKey = await cache.restoreCache(cachePaths, cacheInfo.cacheKey);
+            if (cacheKey) {
+                core.info(`Restored CLI from cache (key: ${cacheKey})`);
+                restoredFromCache = true;
+            }
+        }
+        catch (error) {
+            core.debug(`Cache restore failed: ${error instanceof Error ? error.message : error}`);
+        }
+    }
+    let toolPath;
+    const cachedPath = tc.find(TOOL_NAME, normalizedVersion.replace(/^v/, ''));
+    if (cachedPath) {
+        core.info(`Using cached BoringCache CLI`);
+        toolPath = cachedPath;
+    }
+    else {
+        toolPath = await downloadAndInstall(normalizedVersion, platform);
+        // Save to actions/cache for future workflow runs
+        if (enableCache && !restoredFromCache) {
+            try {
+                await cache.saveCache(cachePaths, cacheInfo.cacheKey);
+                core.info(`Saved CLI to cache (key: ${cacheInfo.cacheKey})`);
+            }
+            catch (error) {
+                // Cache save can fail if key already exists (race condition) - that's ok
+                core.debug(`Cache save failed: ${error instanceof Error ? error.message : error}`);
+            }
+        }
+    }
+    core.addPath(toolPath);
+    core.info(`BoringCache CLI ${normalizedVersion} ready`);
+}
+async function execBoringCache(args, options = {}) {
+    const isWindows = os.platform() === 'win32';
+    try {
+        return await exec.exec('boringcache', args, options);
+    }
+    catch (error) {
+        const msg = error instanceof Error ? error.message : String(error);
+        if (isWindows && msg.includes('Unable to locate executable file')) {
+            const quoted = ['boringcache', ...args.map(a => {
+                    const escaped = a.replace(/"/g, '\\"');
+                    return /\s/.test(escaped) ? `"${escaped}"` : escaped;
+                })].join(' ');
+            return await exec.exec('bash', ['-lc', quoted], options);
+        }
+        throw error;
+    }
+}
+//# sourceMappingURL=data:application/json;base64,{"version":3,"file":"setup.js","sourceRoot":"","sources":["../lib/setup.ts"],"names":[],"mappings":"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"}

package/package.json

@@ -0,0 +1,58 @@
+{
+  "name": "@boringcache/action-core",
+  "version": "1.0.0",
+  "description": "Shared core library for BoringCache GitHub Actions",
+  "main": "dist/index.js",
+  "types": "dist/index.d.ts",
+  "scripts": {
+    "build": "tsc",
+    "test": "jest",
+    "test:coverage": "jest --coverage",
+    "lint": "eslint lib/**/*.ts",
+    "clean": "rm -rf dist coverage",
+    "prepublishOnly": "npm run build"
+  },
+  "repository": {
+    "type": "git",
+    "url": "git+https://github.com/boringcache/actions.git",
+    "directory": "action-core"
+  },
+  "homepage": "https://github.com/boringcache/actions/tree/main/action-core#readme",
+  "bugs": {
+    "url": "https://github.com/boringcache/actions/issues"
+  },
+  "keywords": [
+    "boringcache",
+    "github-actions",
+    "cache",
+    "ci",
+    "cd"
+  ],
+  "author": "BoringCache",
+  "license": "MIT",
+  "publishConfig": {
+    "access": "public",
+    "registry": "https://registry.npmjs.org/"
+  },
+  "engines": {
+    "node": ">=20"
+  },
+  "dependencies": {
+    "@actions/cache": "^5.0.3",
+    "@actions/core": "^1.10.1",
+    "@actions/exec": "^1.1.1",
+    "@actions/tool-cache": "^2.0.1"
+  },
+  "devDependencies": {
+    "@types/jest": "^29.5.14",
+    "@types/node": "^20.19.10",
+    "jest": "^29.7.0",
+    "ts-jest": "^29.2.6",
+    "typescript": "^5.0.0"
+  },
+  "files": [
+    "dist",
+    "README.md",
+    "LICENSE"
+  ]
+}