@secureci/cli 0.2.0 → 0.3.0

package/dist/cli.js

@@ -45,6 +45,7 @@ const pipeline_contract_validator_1 = require("./parser/pipeline-contract-valida
 const report_1 = require("./report");
 const init_1 = require("./init");
 const inventory_1 = require("./inventory");
+const github_lockfile_1 = require("./github-lockfile");
 const logger_1 = require("./utils/logger");
 const key_value_1 = require("./utils/key-value");
 const config_1 = require("./config");
@@ -195,7 +196,7 @@ program
     .option('--dry-run', `Print the resolved inventory as JSON without writing or checking ${LOCKFILE_NAME}`)
     .option('--update-lock', `Write/update ./${LOCKFILE_NAME} with the current commit SHAs (commit it to your repo)`)
     .option('--update-lockfile', `Alias of --update-lock`)
-    .option('--check', `Compare the current commit SHAs against ./${LOCKFILE_NAME} and fail on drift`)
+    .option('--check', `Compare the current commit SHAs against ./${LOCKFILE_NAME} (or GitHub's ${github_lockfile_1.GITHUB_LOCKFILE} when that is the only lockfile) and fail on drift`)
     .option('--compare', `Alias of --check`)
     .action(async (files, options) => {
     await runInventory(files, options);
@@ -283,38 +284,58 @@ async function runInventory(files, options) {
         return;
     }
     const lockPath = path.join(process.cwd(), LOCKFILE_NAME);
-    const lockExists = fs.existsSync(lockPath);
+    // secureci.lock is first-class; GitHub's actions.lock is used only when
+    // it is the lockfile the repository provides.
+    const source = (0, github_lockfile_1.findLockfile)(process.cwd());
     const writeLock = () => {
         const updated = { version: 1, actions: current };
         fs.writeFileSync(lockPath, JSON.stringify(updated, null, 2) + '\n');
         logger_1.logger.success(`Wrote ${Object.keys(current).length} action(s) to ${LOCKFILE_NAME}. Commit it to track supply-chain drift.`);
     };
     // `--update-lock`, or bare `inventory` when no lockfile exists yet: write it.
-    if (update || (!check && !lockExists)) {
+    if (update || (!check && !source)) {
         writeLock();
         return;
     }
     // Otherwise compare (explicit `--check`, or bare `inventory` with a lockfile).
-    if (!lockExists) {
-        logger_1.logger.error(`No ${LOCKFILE_NAME} found. Create one with: secureci inventory --update-lock`);
+    if (!source) {
+        logger_1.logger.error(`No ${LOCKFILE_NAME} found (or GitHub's ${github_lockfile_1.GITHUB_LOCKFILE}). Create one with: secureci inventory --update-lock`);
         process.exit(1);
     }
-    const lock = JSON.parse(fs.readFileSync(lockPath, 'utf-8'));
+    const github = source.kind === 'github';
+    const lockName = github ? 'actions.lock' : LOCKFILE_NAME;
+    const fixHint = github
+        ? 'run `gh actions-lock` to update actions.lock'
+        : 'run with --update-lock to accept it';
+    let lock;
+    try {
+        const text = fs.readFileSync(source.file, 'utf-8');
+        lock = github ? (0, github_lockfile_1.parseGitHubLockfile)(text) : JSON.parse(text);
+    }
+    catch (error) {
+        logger_1.logger.error(`Could not read ${lockName}: ${error instanceof Error ? error.message : 'Unknown error'}`);
+        process.exit(1);
+    }
+    logger_1.logger.info(`Checking against ${github ? github_lockfile_1.GITHUB_LOCKFILE : LOCKFILE_NAME}`);
     const diff = (0, inventory_1.diffLock)(current, lock);
     for (const d of diff.drifted) {
         logger_1.logger.error(`Drift: ${d.uses} now resolves to ${d.to.slice(0, 12)} (was ${d.from.slice(0, 12)})`);
     }
-    diff.added.forEach((u) => logger_1.logger.warn(`New action not in ${LOCKFILE_NAME}: ${u}`));
-    diff.removed.forEach((u) => logger_1.logger.info(`In ${LOCKFILE_NAME} but no longer used: ${u}`));
+    diff.added.forEach((u) => logger_1.logger.warn(`New action not in ${lockName}: ${u}`));
+    // actions.lock also records transitive dependencies, which SecureCI
+    // doesn't scan, so "no longer used" only means something for secureci.lock.
+    if (!github) {
+        diff.removed.forEach((u) => logger_1.logger.info(`In ${lockName} but no longer used: ${u}`));
+    }
     if (diff.drifted.length > 0) {
-        logger_1.logger.error(`Action commits drifted from ${LOCKFILE_NAME}. Review the change, then run with --update-lock to accept it.`);
+        logger_1.logger.error(`Action commits drifted from ${lockName}. Review the change, then ${fixHint}.`);
         process.exit(1);
     }
     if (diff.added.length > 0) {
-        logger_1.logger.warn(`New actions are not yet in ${LOCKFILE_NAME} (run --update-lock).`);
+        logger_1.logger.warn(`New actions are not yet in ${lockName} (${fixHint}).`);
         process.exit(1);
     }
-    logger_1.logger.success(`No action drift against ${LOCKFILE_NAME}.`);
+    logger_1.logger.success(`No action drift against ${lockName}.`);
 }
 async function validateOneFile(filePath, contractFile, recurse, say) {
     const parsed = (0, workflow_parser_1.parseFile)(filePath);

package/dist/github-lockfile.js

@@ -0,0 +1,90 @@
+"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.GITHUB_LOCKFILE = exports.SECURECI_LOCKFILE = void 0;
+exports.findLockfile = findLockfile;
+exports.parseGitHubLockfile = parseGitHubLockfile;
+const fs = __importStar(require("fs"));
+const path = __importStar(require("path"));
+const YAML = __importStar(require("yaml"));
+/** SecureCI's own lockfile, at the repository root. */
+exports.SECURECI_LOCKFILE = 'secureci.lock';
+/**
+ * GitHub's workflow dependency lockfile, written by `gh actions-lock`
+ * (public preview). See
+ * https://docs.github.com/actions/concepts/security/workflow-dependency-lockfiles
+ */
+exports.GITHUB_LOCKFILE = path.join('.github', 'workflows', 'actions.lock');
+/**
+ * Versions of GitHub's format this release reads. The format is pre-1.0 and
+ * may change, so an unknown version is an error rather than a guess.
+ */
+const SUPPORTED_GITHUB_VERSIONS = ['v0.0.2', 'v0.0.3'];
+const SHA1_COMMIT = /^sha1-([0-9a-f]{40})$/;
+/**
+ * The lockfile to check against: `secureci.lock` when present (it stays
+ * first-class), otherwise GitHub's `actions.lock`, otherwise none.
+ */
+function findLockfile(repoRoot) {
+    const secureci = path.join(repoRoot, exports.SECURECI_LOCKFILE);
+    if (fs.existsSync(secureci))
+        return { kind: 'secureci', file: secureci };
+    const github = path.join(repoRoot, exports.GITHUB_LOCKFILE);
+    if (fs.existsSync(github))
+        return { kind: 'github', file: github };
+    return undefined;
+}
+/**
+ * Read GitHub's `actions.lock` as a `uses -> commit` map, the same shape as
+ * `secureci.lock`. It includes transitive dependencies (actions that your
+ * actions use), which SecureCI doesn't scan.
+ */
+function parseGitHubLockfile(text) {
+    const doc = YAML.parse(text);
+    const version = String(doc?.version ?? '');
+    if (!SUPPORTED_GITHUB_VERSIONS.includes(version)) {
+        throw new Error(`Unsupported actions.lock version "${version}" (this release reads ${SUPPORTED_GITHUB_VERSIONS.join(', ')}). Update @secureci/cli, or use ${exports.SECURECI_LOCKFILE}.`);
+    }
+    const actions = {};
+    for (const [uses, dep] of Object.entries(doc?.dependencies ?? {})) {
+        const match = SHA1_COMMIT.exec(String(dep?.commit ?? ''));
+        if (!match) {
+            throw new Error(`actions.lock entry ${uses} has no sha1 commit (got "${String(dep?.commit)}").`);
+        }
+        actions[uses] = match[1];
+    }
+    return { version: 1, actions };
+}
+//# sourceMappingURL=github-lockfile.js.map

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@secureci/cli",
-  "version": "0.2.0",
+  "version": "0.3.0",
   "description": "SecureCI: validate, check against pipeline standards, and run GitHub Actions workflows locally",
   "main": "dist/index.js",
   "bin": {