@magland/mochi 0.3.1

package/dist/runner-cli.js

@@ -0,0 +1,405 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.runnerListCommand = void 0;
+exports.runnerAddCmd = runnerAddCmd;
+exports.runnerWakeCmd = runnerWakeCmd;
+exports.runnerRemoveCmd = runnerRemoveCmd;
+exports.runnerRunCmd = runnerRunCmd;
+const cli_api_1 = require("./cli-api");
+const output_1 = require("./cli/output");
+const target_1 = require("./cli/target");
+const credentials_1 = require("./credentials");
+const job_cli_1 = require("./job-cli");
+const client_1 = require("./runner/client");
+const docker_1 = require("./runner/docker");
+const wake_1 = require("./ci/wake");
+const vault_1 = require("./vault");
+/**
+ * "5m", "30s", "300" -> seconds.
+ *
+ * Written out because the one place this is used is a timeout an operator
+ * chooses in minutes and a program wants in seconds, and "--idle 300" for
+ * five minutes is a needless piece of arithmetic to ask of a reader.
+ */
+function parseDuration(text) {
+    const m = /^(\d+)\s*(s|m|h)?$/i.exec(text.trim());
+    if (!m) {
+        console.error(`--idle takes a duration like 5m, 90s, or 1h, got: ${text}`);
+        process.exit(1);
+    }
+    const n = parseInt(m[1], 10);
+    const unit = (m[2] ?? 's').toLowerCase();
+    return unit === 'h' ? n * 3600 : unit === 'm' ? n * 60 : n;
+}
+function parseArgs(args, usage) {
+    const out = {
+        name: null,
+        host: null,
+        token: null,
+        runnerToken: null,
+        labels: [],
+        allow: [],
+        images: {},
+        workDir: null,
+        network: null,
+        cacheDir: null,
+        actionsUrl: null,
+        actionCache: true,
+        save: false,
+        idleSeconds: null,
+        wakePort: null,
+        wakeSecret: null,
+        wakeUrl: null,
+        clear: false,
+        engine: null,
+    };
+    const list = (v) => v.split(/[\s,]+/).filter((s) => s.length > 0);
+    for (let i = 0; i < args.length; i++) {
+        const a = args[i];
+        if (a === '-h' || a === '--help')
+            usage();
+        else if (a === '--host')
+            out.host = args[++i];
+        else if (a === '--token')
+            out.token = args[++i];
+        else if (a === '--runner-token')
+            out.runnerToken = args[++i];
+        else if (a === '--labels' || a === '--label')
+            out.labels.push(...list(args[++i] ?? ''));
+        else if (a === '--allow')
+            out.allow.push(...list(args[++i] ?? ''));
+        else if (a === '--work-dir')
+            out.workDir = args[++i];
+        else if (a === '--cache-dir')
+            out.cacheDir = args[++i];
+        else if (a === '--actions-url')
+            out.actionsUrl = args[++i];
+        else if (a === '--no-action-cache')
+            out.actionCache = false;
+        else if (a === '--network')
+            out.network = args[++i];
+        else if (a === '--idle')
+            out.idleSeconds = parseDuration(args[++i] ?? '');
+        else if (a === '--wake-port') {
+            const port = parseInt(args[++i] ?? '', 10);
+            if (!Number.isInteger(port) || port < 1 || port > 65535) {
+                console.error('--wake-port takes a port number, e.g. --wake-port 3000');
+                process.exit(1);
+            }
+            out.wakePort = port;
+        }
+        else if (a === '--wake-secret')
+            out.wakeSecret = args[++i];
+        else if (a === '--wake-url')
+            out.wakeUrl = args[++i];
+        else if (a === '--clear')
+            out.clear = true;
+        else if (a === '--save')
+            out.save = true;
+        else if (a === '--engine') {
+            const e = args[++i] ?? '';
+            if (e !== 'docker' && e !== 'podman') {
+                console.error(`--engine takes docker or podman, got: ${e}`);
+                process.exit(1);
+            }
+            out.engine = e;
+        }
+        else if (a === '--image') {
+            // --image ubuntu-latest=my/image:tag
+            const spec = args[++i] ?? '';
+            const eq = spec.indexOf('=');
+            if (eq === -1) {
+                console.error(`--image needs <label>=<image>, got: ${spec}`);
+                process.exit(1);
+            }
+            out.images[spec.slice(0, eq)] = spec.slice(eq + 1);
+        }
+        else if (a.startsWith('-')) {
+            console.error(`Unknown option: ${a}`);
+            process.exit(1);
+        }
+        else if (!out.name)
+            out.name = a;
+        else {
+            console.error(`Unexpected argument: ${a}`);
+            process.exit(1);
+        }
+    }
+    return out;
+}
+// Registration is an ordinary admin operation, so it uses the same login as
+// `mochi user add` rather than any arrangement of its own.
+async function runnerAddCmd(args, usage) {
+    const a = parseArgs(args, usage);
+    if (!a.name) {
+        console.error('A runner name is required: mochi runner add <name> --allow <glob>');
+        process.exit(1);
+    }
+    if (a.allow.length === 0) {
+        console.error('Say which repositories this runner may take jobs for: --allow "mycollection/*".\n' +
+            'A runner executes whatever those repositories\' workflows contain, on the machine you start it on.');
+        process.exit(1);
+    }
+    const target = await (0, cli_api_1.remoteTarget)(a);
+    const labels = a.labels.length ? a.labels : ['ubuntu-latest'];
+    // A wake address is optional, and its secret is generated here when one is
+    // not supplied: it is a credential nobody has to remember, since the vault
+    // sends it and the runner is given it as an environment variable.
+    const wake = a.wakeUrl ? { url: a.wakeUrl, secret: a.wakeSecret ?? (0, wake_1.newWakeSecret)() } : null;
+    const data = await (0, cli_api_1.api)(target, 'POST', '/api/runners', {
+        name: a.name,
+        labels,
+        allow: a.allow,
+        ...(wake ? { wakeUrl: wake.url, wakeSecret: wake.secret } : {}),
+    });
+    console.log(`Registered runner ${data.name}`);
+    console.log(`  labels:  ${data.labels.join(', ')}`);
+    console.log(`  serving: ${data.allow.join(', ')}`);
+    if (wake)
+        console.log(`  wake:    ${wake.url}`);
+    console.log('');
+    console.log('Runner token (shown once; only its hash is stored):');
+    console.log('');
+    console.log(`  ${data.token}`);
+    console.log('');
+    if (a.save) {
+        const config = { host: target.host, token: data.token, labels };
+        if (a.workDir)
+            config.workDir = a.workDir;
+        if (a.network)
+            config.network = a.network;
+        if (Object.keys(a.images).length)
+            config.images = a.images;
+        (0, client_1.saveRunnerConfig)(config);
+        console.log(`Saved to ${(0, client_1.configPath)()}. Start it with:`);
+        console.log('');
+        console.log('  mochi runner run');
+    }
+    else {
+        console.log('On the machine that will run jobs (with Docker installed):');
+        console.log('');
+        console.log(`  mochi runner run --host ${target.host} --runner-token ${data.token}`);
+    }
+    if (wake) {
+        console.log('');
+        console.log('This runner has a wake address, so the vault will start it when a job is');
+        console.log('waiting and nothing is polling. Start it with the matching secret, and with an');
+        console.log('idle timeout, or there will be nothing to wake:');
+        console.log('');
+        console.log(`  MOCHI_WAKE_SECRET=${wake.secret} \\`);
+        console.log(`    mochi runner run --idle 5m --wake-port 3000`);
+    }
+    console.log('');
+}
+/**
+ * `mochi runner wake <name>`: send the wake request, or change where it goes.
+ *
+ * Sending it is the useful default, because the question an operator has is
+ * almost always "does this actually start" rather than "what is stored". The
+ * vault does the sending, since the vault is the only party holding the
+ * secret; what comes back is how long it took to answer, which on a machine
+ * that has to boot is the number worth knowing.
+ */
+async function runnerWakeCmd(args, usage) {
+    const a = parseArgs(args, usage);
+    if (!a.name) {
+        console.error('Which runner? Usage: mochi runner wake <name> [--url <url>] [--clear]');
+        process.exit(1);
+    }
+    if (a.clear && a.wakeUrl) {
+        console.error('--clear removes the wake address and --url sets one. Pass one or the other.');
+        process.exit(1);
+    }
+    const target = await (0, cli_api_1.remoteTarget)(a);
+    const path = `/api/runners/${encodeURIComponent(a.name)}/wake`;
+    if (a.clear) {
+        await (0, cli_api_1.api)(target, 'PUT', path, {});
+        console.log(`Runner ${a.name} has no wake address now, so nothing will start it.`);
+        return;
+    }
+    if (a.wakeUrl) {
+        const secret = a.wakeSecret ?? (0, wake_1.newWakeSecret)();
+        await (0, cli_api_1.api)(target, 'PUT', path, { wakeUrl: a.wakeUrl, wakeSecret: secret });
+        console.log(`Runner ${a.name} will be woken at ${a.wakeUrl}`);
+        if (!a.wakeSecret) {
+            console.log('');
+            console.log('The secret it must present, generated now and shown once here because the');
+            console.log('runner has to be started with the same one:');
+            console.log('');
+            console.log(`  ${secret}`);
+            console.log('');
+            console.log('  MOCHI_WAKE_SECRET=<that> mochi runner run --idle 5m --wake-port 3000');
+        }
+        return;
+    }
+    const data = await (0, cli_api_1.api)(target, 'POST', path, {});
+    console.log(`Woke ${a.name} at ${String(data.wakeUrl)} in ${String(data.seconds)}s.`);
+}
+/** "3s ago", for the one column where a bare ISO timestamp would be unreadable. */
+function ago(iso) {
+    if (!iso)
+        return 'never';
+    const secs = Math.max(0, Math.round((Date.now() - Date.parse(iso)) / 1000));
+    if (secs < 90)
+        return `${secs}s ago`;
+    if (secs < 5400)
+        return `${Math.round(secs / 60)}m ago`;
+    return `${Math.round(secs / 3600)}h ago`;
+}
+function jobLabel(j) {
+    return `${j.collection}/${j.repo} #${j.run} ${j.job}`;
+}
+/**
+ * A queued job that no registered runner can take: its labels match nobody, or
+ * nobody's allow list covers its repository. This is the answer to "the run
+ * never started" that neither the run nor the registry gives on its own, so it
+ * is worth computing here rather than leaving to the reader.
+ */
+function unservedJobs(queued, runners) {
+    return queued.filter((j) => 
+    // A manual job is waiting for a pasted command by design, so no runner
+    // failing to match it is not the problem this list exists to surface.
+    !j.manual &&
+        !runners.some((r) => r.allow.some((g) => (0, vault_1.globMatch)(g, `${j.collection}/${j.repo}`)) &&
+            j.runsOn.some((l) => r.labels.includes(l))));
+}
+exports.runnerListCommand = {
+    path: ['runner', 'list'],
+    summary: 'Show registered runners, whether each is connected, and what is queued',
+    description: `Needs an admin token, as the other runner registration commands do.
+
+Beside the registry it reports liveness: when each runner last spoke to the vault
+(since the vault started; a restart forgets it and every live runner re-announces
+within one poll), the job it is holding now, and the jobs waiting for a runner. A
+queued job that no runner's labels and allow globs match is called out, since that
+is the usual reason a run sits at queued forever.`,
+    options: [output_1.JSON_OPTION, ...target_1.TARGET_OPTIONS],
+    async run(inv) {
+        const target = await (0, target_1.targetFrom)(inv);
+        const data = await (0, cli_api_1.api)(target, 'GET', '/api/runners');
+        const runners = (data.runners ?? []);
+        const queued = (data.queued ?? []);
+        const json = (0, output_1.jsonMode)(inv);
+        if (json.enabled) {
+            (0, output_1.printJson)({ runners: (0, output_1.pickFields)(runners, json.fields), queued });
+            return;
+        }
+        if (runners.length === 0) {
+            console.log('No runners registered. Runs will queue and wait: mochi runner add <name> --allow <glob>');
+        }
+        else {
+            (0, output_1.printTable)(runners.map((r) => [
+                r.name,
+                `labels: ${r.labels.join(', ') || '(none)'}`,
+                `serving: ${r.allow.join(', ') || '(none)'}`,
+                // A vault older than liveness reporting leaves both out, and saying
+                // "seen never" of a runner that may be perfectly healthy would be
+                // worse than saying nothing.
+                r.lastSeen === undefined && !r.running
+                    ? r.createdBy
+                        ? `by ${r.createdBy}`
+                        : ''
+                    : r.running
+                        ? `running ${jobLabel(r.running)}`
+                        : // A runner with a wake address is meant to be absent between
+                            // jobs, so reporting it as idle since an hour ago without that
+                            // context reads as a fault rather than as the arrangement
+                            // working.
+                            `idle, seen ${ago(r.lastSeen ?? null)}${r.wakeUrl ? ', woken on demand' : ''}`,
+            ]));
+        }
+        if (queued.length > 0) {
+            const automatic = queued.filter((j) => !j.manual);
+            const manual = queued.filter((j) => j.manual);
+            console.log('');
+            if (automatic.length > 0) {
+                console.log(`${automatic.length} job${automatic.length === 1 ? '' : 's'} waiting for a runner:`);
+                for (const j of automatic)
+                    console.log(`  ${jobLabel(j)}  (runs-on: ${j.runsOn.join(', ')})`);
+            }
+            if (manual.length > 0) {
+                console.log(`${manual.length} manual job${manual.length === 1 ? '' : 's'} waiting for a pasted command (mochi run exec-command <run>):`);
+                for (const j of manual)
+                    console.log(`  ${jobLabel(j)}  (runs-on: ${j.runsOn.join(', ')})`);
+            }
+            const unserved = unservedJobs(queued, runners);
+            if (unserved.length > 0) {
+                console.log('');
+                console.log(`No registered runner can take ${unserved.length === automatic.length ? 'them' : `${unserved.length} of them`}: check the runs-on labels against each runner's labels, and the repository against its serving globs.`);
+            }
+        }
+    },
+};
+async function runnerRemoveCmd(args, usage) {
+    const a = parseArgs(args, usage);
+    if (!a.name) {
+        console.error('A runner name is required: mochi runner remove <name>');
+        process.exit(1);
+    }
+    const target = await (0, cli_api_1.remoteTarget)(a);
+    await (0, cli_api_1.api)(target, 'DELETE', `/api/runners/${encodeURIComponent(a.name)}`);
+    console.log(`Removed runner ${a.name}`);
+}
+async function runnerRunCmd(args, usage) {
+    const a = parseArgs(args, usage);
+    const saved = (0, client_1.loadRunnerConfig)();
+    // A runner's token is its own, not a user's, so it is not something login
+    // stored; only the vault URL can be borrowed from a login on this machine.
+    const host = (a.host ?? saved?.host ?? (0, credentials_1.loadLogin)()?.host ?? '').replace(/\/+$/, '');
+    const token = a.runnerToken ?? process.env.MOCHI_RUNNER_TOKEN ?? saved?.token ?? '';
+    if (!host || !token) {
+        console.error(`No runner credentials. Register one with:\n\n` +
+            `  mochi runner add <name> --allow 'mycollection/*' --save\n\n` +
+            `or pass --host and --runner-token, or write ${(0, client_1.configPath)()}.`);
+        process.exit(1);
+    }
+    const config = {
+        host,
+        token,
+        labels: a.labels.length ? a.labels : saved?.labels,
+        images: { ...client_1.DEFAULT_IMAGES, ...(saved?.images ?? {}), ...a.images },
+        workDir: a.workDir ?? saved?.workDir,
+        network: a.network ?? saved?.network,
+        cacheDir: a.cacheDir ?? saved?.cacheDir,
+        actionsUrl: a.actionsUrl ?? saved?.actionsUrl,
+        actionCache: a.actionCache && (saved?.actionCache ?? true),
+        idleSeconds: a.idleSeconds ?? saved?.idleSeconds,
+        wakePort: a.wakePort ?? saved?.wakePort,
+        // From the environment by preference, like the runner token above: this is
+        // the credential a wake request must present, and a secret in argv is
+        // readable by every other user on the machine.
+        wakeSecret: a.wakeSecret ?? process.env.MOCHI_WAKE_SECRET ?? saved?.wakeSecret,
+    };
+    if (config.wakePort && !config.wakeSecret) {
+        console.error('A wake port needs a secret to check against: pass --wake-secret, or set MOCHI_WAKE_SECRET.\n' +
+            'Without one, anything that can reach this port could start this runner.');
+        process.exit(1);
+    }
+    if (config.idleSeconds && !config.wakePort) {
+        // Not an error: a runner started by cron, or by hand for one run, is meant
+        // to stop and stay stopped. But the usual reason to pass --idle is the
+        // other arrangement, and a runner that stops with nothing able to start it
+        // looks exactly like a runner that has failed.
+        console.log('Note: this runner will stop when idle, and has no wake port, so nothing can start it.');
+        console.log('      Add --wake-port to let the vault do it: mochi runner wake --help');
+    }
+    if (a.save) {
+        (0, client_1.saveRunnerConfig)(config);
+        console.log(`Saved to ${(0, client_1.configPath)()}`);
+    }
+    // Which container engine carries the jobs: the flag if given, whichever of
+    // docker and podman works if only one does, a question when both do and
+    // there is a terminal to ask on, docker otherwise. Chosen before the runner
+    // starts, because a runner must use one engine for everything or nothing.
+    const engine = await (0, job_cli_1.chooseEngine)(a.engine, process.stdin.isTTY === true && process.stdout.isTTY === true);
+    (0, docker_1.setContainerEngine)(engine);
+    const runner = new client_1.Runner(config);
+    const stop = () => {
+        console.log('\nStopping after the current job. Press Ctrl-C again to quit now.');
+        runner.stop();
+        process.once('SIGINT', () => process.exit(130));
+    };
+    process.once('SIGINT', stop);
+    process.once('SIGTERM', stop);
+    await runner.loop();
+}

package/dist/scan.js

@@ -0,0 +1,231 @@
+"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.repoSiblingSuffixes = void 0;
+exports.isValidName = isValidName;
+exports.isDotName = isDotName;
+exports.isValidUserName = isValidUserName;
+exports.reservedRepoSuffix = reservedRepoSuffix;
+exports.isBareRepo = isBareRepo;
+exports.displayName = displayName;
+exports.listRepoDirs = listRepoDirs;
+exports.listCollections = listCollections;
+exports.findRepo = findRepo;
+exports.siteDir = siteDir;
+exports.forkParent = forkParent;
+exports.repoDescription = repoDescription;
+const fs = __importStar(require("fs"));
+const path = __importStar(require("path"));
+const git_1 = require("./git");
+const layout_1 = require("./layout");
+// Names the UI owns as top-level path segments. None of these may ever be a
+// collection or repo name, since a collection is reached at /<collection> and
+// a repository at /<collection>/<repo>. The vault's own files are not among
+// them: they sit beside `collections/` rather than in it, so no file of the
+// vault's can collide with a name a user chose.
+const RESERVED_NAMES = new Set([
+    'about',
+    'api',
+    'assets',
+    'favicon.ico',
+    'favicon.svg',
+    'login',
+    'logout',
+    'new',
+    'import',
+    'admin',
+    'settings',
+]);
+function isValidName(name) {
+    if (RESERVED_NAMES.has(name))
+        return false;
+    return /^\.?[A-Za-z0-9][A-Za-z0-9._-]*$/.test(name) && !name.includes('..');
+}
+/**
+ * Whether a name is dot-prefixed. A single leading dot is allowed so that a
+ * repository can carry a name the interface reads rather than a name a project
+ * chose: `.mochi` holds a collection's profile README (see
+ * src/profile.ts), and the shape is left open for whatever else the forge
+ * later wants to read out of a collection.
+ *
+ * Only a repository may carry such a name. A collection or a user named with a
+ * leading dot would be a hidden directory in the vault and a hidden address in
+ * the interface, with nothing gained, so both are refused where they are
+ * created. Reading stays permissive: isValidName above accepts the dot for
+ * every kind of name, since a route that is asked for one only has to resolve
+ * it, and a vault that somehow holds one should still serve what it holds.
+ */
+function isDotName(name) {
+    return name.startsWith('.');
+}
+/**
+ * A username. A name being looked up is checked with isValidName, which
+ * accepts a leading dot; this is the stricter rule applied where a user is
+ * created, since only a repository may carry one.
+ */
+function isValidUserName(name) {
+    return isValidName(name) && !isDotName(name);
+}
+// The directories a repository accumulates beside its bare repository, by the
+// suffix each one carries. Every feature has its own helper for the directory
+// it owns (siteDir, runsDir, issuesDir, pullsDir, releasesDir), but rename and
+// delete are the two places that need the whole set, and a set spelled out in
+// two places is a set one of them falls behind on. The list therefore lives
+// here, beside the rest of what may and may not be a name, so a sibling added
+// later is added once and is refused as a new repository's name for free.
+//
+// LFS objects are not in the list. Without a bucket they do sit in a sibling
+// <repo>.lfs, but with one they do not sit on disk at all, so the store is
+// asked to move or drop them rather than having its path assumed.
+exports.repoSiblingSuffixes = ['.site', '.runs', '.issues', '.pulls', '.releases'];
+// Suffixes a repository may not be created under. A repository named
+// webapp.site would land on exactly the path the repository webapp keeps its
+// site in, so without this a user with the write role could shadow another
+// repository's site, or have their own issues served as that repository's.
+// The list is the siblings plus two the siblings do not name: .lfs, which is
+// where LFS objects sit when no bucket is configured, and .git, the ordinary
+// on-disk spelling of a bare repository, since displayName would resolve a
+// new webapp.git back to webapp. Compared case-insensitively, because a
+// case-insensitive filesystem would collide where a case-sensitive one would
+// not, and the refusal should not depend on which one is underneath.
+const reservedRepoSuffixes = [...exports.repoSiblingSuffixes, '.lfs', '.git'];
+/**
+ * The reserved suffix a proposed repository name ends in, or null if it ends
+ * in none. Callers report the suffix, since a name is much easier to fix when
+ * the refusal says which part of it is the problem. Asked only where a
+ * repository comes into being: reading stays more permissive, so a repository
+ * created before this check existed keeps working.
+ */
+function reservedRepoSuffix(name) {
+    const lower = name.toLowerCase();
+    return reservedRepoSuffixes.find((s) => lower.endsWith(s)) ?? null;
+}
+function isBareRepo(dir) {
+    try {
+        return (fs.statSync(path.join(dir, 'HEAD')).isFile() &&
+            fs.statSync(path.join(dir, 'objects')).isDirectory() &&
+            fs.statSync(path.join(dir, 'refs')).isDirectory());
+    }
+    catch {
+        return false;
+    }
+}
+function displayName(dirName) {
+    return dirName.replace(/\.git$/, '');
+}
+function listRepoDirs(root, collection) {
+    const dir = (0, layout_1.reposDir)(root, collection);
+    let entries;
+    try {
+        entries = fs.readdirSync(dir, { withFileTypes: true });
+    }
+    catch {
+        return [];
+    }
+    return entries
+        .filter((e) => e.isDirectory() && isValidName(e.name) && isBareRepo(path.join(dir, e.name)))
+        .map((e) => e.name)
+        .sort();
+}
+function listCollections(root) {
+    let entries;
+    try {
+        entries = fs.readdirSync((0, layout_1.collectionsDir)(root), { withFileTypes: true });
+    }
+    catch {
+        return [];
+    }
+    return entries
+        .filter((e) => e.isDirectory() && isValidName(e.name) && !isDotName(e.name))
+        .map((e) => ({ name: e.name, repoCount: listRepoDirs(root, e.name).length }))
+        .sort((a, b) => a.name.localeCompare(b.name));
+}
+function findRepo(root, collection, repoName) {
+    if (!isValidName(collection) || !isValidName(repoName))
+        return null;
+    const base = displayName(repoName);
+    for (const cand of [base, base + '.git']) {
+        const dir = (0, layout_1.repoPath)(root, collection, cand);
+        if (isBareRepo(dir))
+            return new git_1.GitRepo(dir, collection, base);
+    }
+    return null;
+}
+// A repository's static site lives in a sibling directory, `<repo>.site`.
+function siteDir(root, collection, repoName) {
+    if (!isValidName(collection) || !isValidName(repoName))
+        return null;
+    const dir = (0, layout_1.repoPath)(root, collection, `${displayName(repoName)}.site`);
+    try {
+        if (fs.statSync(dir).isDirectory())
+            return dir;
+    }
+    catch {
+        // no site directory
+    }
+    return null;
+}
+/**
+ * The repository this one was forked from, as `<collection>/<repo>`, or null
+ * if it was not. Read out of the bare repository's own config file rather
+ * than through git, since this is asked on page renders.
+ */
+function forkParent(dir) {
+    let text;
+    try {
+        text = fs.readFileSync(path.join(dir, 'config'), 'utf8');
+    }
+    catch {
+        return null;
+    }
+    const m = text.match(/^\s*forkedFrom\s*=\s*(\S+)\s*$/m);
+    if (!m)
+        return null;
+    const [collection, repo] = m[1].split('/');
+    if (!collection || !repo || !isValidName(collection) || !isValidName(repo))
+        return null;
+    return { collection, repo };
+}
+function repoDescription(dir) {
+    try {
+        const t = fs.readFileSync(path.join(dir, 'description'), 'utf8').trim();
+        if (!t || t.startsWith('Unnamed repository'))
+            return null;
+        return t;
+    }
+    catch {
+        return null;
+    }
+}