@magland/mochi 0.3.1

package/dist/ci/runs.js

@@ -0,0 +1,208 @@
+"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.runsDir = runsDir;
+exports.createRun = createRun;
+exports.readRun = readRun;
+exports.writeRun = writeRun;
+exports.isValidJobId = isValidJobId;
+exports.readJob = readJob;
+exports.writeJob = writeJob;
+exports.jobLogPath = jobLogPath;
+exports.appendJobLog = appendJobLog;
+exports.latestRun = latestRun;
+exports.listRuns = listRuns;
+exports.pruneRuns = pruneRuns;
+const fs = __importStar(require("fs"));
+const path = __importStar(require("path"));
+const atomic_1 = require("../atomic");
+const layout_1 = require("../layout");
+const scan_1 = require("../scan");
+function runsDir(root, collection, repoName) {
+    if (!(0, scan_1.isValidName)(collection) || !(0, scan_1.isValidName)(repoName))
+        return null;
+    return (0, layout_1.repoPath)(root, collection, `${(0, scan_1.displayName)(repoName)}.runs`);
+}
+function runDir(root, collection, repoName, n) {
+    return path.join(runsDir(root, collection, repoName), String(n));
+}
+function writeJson(file, value) {
+    (0, atomic_1.writeFileAtomic)(file, JSON.stringify(value, null, 1) + '\n');
+}
+function readJson(file) {
+    try {
+        return JSON.parse(fs.readFileSync(file, 'utf8'));
+    }
+    catch {
+        return null;
+    }
+}
+// Allocate the next run number and create its directory. mkdir is the
+// atomicity: if two creations race, the loser's mkdir fails and it retries.
+function createRun(root, collection, repoName, make) {
+    const base = runsDir(root, collection, repoName);
+    if (!base)
+        throw new Error('invalid repository');
+    fs.mkdirSync(base, { recursive: true });
+    for (let attempt = 0; attempt < 20; attempt++) {
+        const n = nextRunNumber(base);
+        const dir = path.join(base, String(n));
+        try {
+            fs.mkdirSync(dir);
+        }
+        catch {
+            continue;
+        }
+        fs.mkdirSync(path.join(dir, 'jobs'));
+        const { run, jobs } = make(n);
+        for (const j of jobs) {
+            if (!isValidJobId(j.id))
+                throw new Error(`refusing to write a job record under the id ${j.id}`);
+            writeJson(path.join(dir, 'jobs', `${j.id}.json`), j);
+        }
+        writeJson(path.join(dir, 'run.json'), run);
+        return run;
+    }
+    throw new Error('could not allocate a run number');
+}
+function nextRunNumber(base) {
+    let max = 0;
+    for (const e of fs.readdirSync(base)) {
+        const n = parseInt(e, 10);
+        if (Number.isInteger(n) && String(n) === e && n > max)
+            max = n;
+    }
+    return max + 1;
+}
+function readRun(root, collection, repoName, n) {
+    return readJson(path.join(runDir(root, collection, repoName, n), 'run.json'));
+}
+function writeRun(root, collection, repoName, run) {
+    writeJson(path.join(runDir(root, collection, repoName, run.number), 'run.json'), run);
+}
+// Job ids reach the filesystem as a path segment, so every function that
+// builds a path from one checks it, whatever the caller believes about where
+// it came from. Workflow parsing enforces the same shape (workflow.ts), and
+// this is the second lock on the same door.
+function isValidJobId(jobId) {
+    return /^[A-Za-z0-9_][A-Za-z0-9_-]{0,110}$/.test(jobId);
+}
+function readJob(root, collection, repoName, n, jobId) {
+    if (!isValidJobId(jobId))
+        return null;
+    return readJson(path.join(runDir(root, collection, repoName, n), 'jobs', `${jobId}.json`));
+}
+function writeJob(root, collection, repoName, n, job) {
+    if (!isValidJobId(job.id))
+        throw new Error(`refusing to write a job record under the id ${job.id}`);
+    writeJson(path.join(runDir(root, collection, repoName, n), 'jobs', `${job.id}.json`), job);
+}
+function jobLogPath(root, collection, repoName, n, jobId) {
+    if (!isValidJobId(jobId))
+        throw new Error(`invalid job id: ${jobId}`);
+    return path.join(runDir(root, collection, repoName, n), 'jobs', `${jobId}.log`);
+}
+function appendJobLog(root, collection, repoName, n, jobId, ndjson) {
+    fs.appendFileSync(jobLogPath(root, collection, repoName, n, jobId), ndjson);
+}
+/**
+ * The newest run, read without reading the rest. A listing of a whole vault
+ * asks this of every repository, so it finds the highest-numbered directory
+ * and reads that one file rather than parsing the hundred a repository may
+ * have kept.
+ */
+function latestRun(root, collection, repoName) {
+    const base = runsDir(root, collection, repoName);
+    if (!base)
+        return null;
+    let entries;
+    try {
+        entries = fs.readdirSync(base);
+    }
+    catch {
+        return null;
+    }
+    let max = 0;
+    for (const e of entries) {
+        const n = parseInt(e, 10);
+        if (Number.isInteger(n) && String(n) === e && n > max)
+            max = n;
+    }
+    return max === 0 ? null : readJson(path.join(base, String(max), 'run.json'));
+}
+function listRuns(root, collection, repoName) {
+    const base = runsDir(root, collection, repoName);
+    if (!base)
+        return [];
+    let entries;
+    try {
+        entries = fs.readdirSync(base);
+    }
+    catch {
+        return [];
+    }
+    const runs = [];
+    for (const e of entries) {
+        const n = parseInt(e, 10);
+        if (!Number.isInteger(n) || String(n) !== e)
+            continue;
+        const run = readJson(path.join(base, e, 'run.json'));
+        if (run)
+            runs.push(run);
+    }
+    runs.sort((a, b) => b.number - a.number);
+    return runs;
+}
+// Delete completed runs beyond the retention settings. Active runs are never
+// pruned regardless of age.
+function pruneRuns(root, collection, repoName, retain) {
+    const base = runsDir(root, collection, repoName);
+    if (!base)
+        return;
+    const all = listRuns(root, collection, repoName);
+    const completed = all.filter((r) => r.status === 'completed');
+    const doomed = new Set();
+    completed.slice(Math.max(0, retain.runs)).forEach((r) => doomed.add(r.number));
+    if (retain.days > 0) {
+        const cutoff = Date.now() - retain.days * 24 * 60 * 60 * 1000;
+        for (const r of completed) {
+            if (new Date(r.createdAt).getTime() < cutoff)
+                doomed.add(r.number);
+        }
+    }
+    for (const n of doomed) {
+        fs.rmSync(path.join(base, String(n)), { recursive: true, force: true });
+    }
+}

package/dist/ci/trigger.js

@@ -0,0 +1,28 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.firePush = firePush;
+const scan_1 = require("../scan");
+// One place that turns a branch having moved into a workflow event.
+//
+// A commit made in the browser, a commit made over the API, and a merge are all
+// pushes as far as workflows are concerned, and forgetting one would be a silent
+// divergence between the interfaces: the same operation would run CI through one
+// door and not through the other. There were two copies of this before there were
+// two transports, which is one copy too many already.
+const ZERO = '0'.repeat(40);
+/**
+ * Report a branch move to the CI engine, if there is one.
+ *
+ * A failure here is logged and never allowed to affect the operation that caused
+ * it, which by this point has already been committed.
+ */
+function firePush(root, engine, repo, branch, before, after, actor) {
+    if (!engine)
+        return;
+    const gitRepo = (0, scan_1.findRepo)(root, repo.collection, repo.name);
+    if (!gitRepo)
+        return;
+    engine
+        .handlePush(gitRepo, { ref: `refs/heads/${branch}`, before: before ?? ZERO, after, actor })
+        .catch((e) => console.error(`CI trigger failed: ${e instanceof Error ? e.message : e}`));
+}