@magland/mochi 0.3.1

package/dist/api/ci.js

@@ -0,0 +1,336 @@
+"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.registerCiRunApi = registerCiRunApi;
+const fs = __importStar(require("fs"));
+const path = __importStar(require("path"));
+const artifacts_1 = require("../ci/artifacts");
+const dispatch_1 = require("../ci/dispatch");
+const engine_1 = require("../ci/engine");
+const manual_1 = require("../ci/manual");
+const runs_1 = require("../ci/runs");
+const git_1 = require("../git");
+const version_1 = require("../version");
+const web_1 = require("../web");
+const auth_1 = require("./auth");
+// Workflows and their runs.
+//
+// The one thing here that is not a thin transport is the log: a job log can be
+// large and is capped by the server, and an agent diagnosing a failure wants the
+// end of it. Handing it the whole thing wastes its context, so ?tail= defaults to
+// the last two hundred lines and the response says when it truncated something.
+const MAX_LISTED_RUNS = 200;
+const DEFAULT_TAIL = 200;
+function runNumber(raw) {
+    return /^[1-9][0-9]*$/.test(raw ?? '') ? parseInt(raw, 10) : null;
+}
+/**
+ * A job log, as lines. It is stored as NDJSON, one object per line, which is what
+ * the runner posts and what the tailer reads; a caller asking for text gets the
+ * text out of it.
+ */
+function readLog(file) {
+    let content = '';
+    try {
+        content = fs.readFileSync(file, 'utf8');
+    }
+    catch {
+        return { lines: [], raw: [] };
+    }
+    const raw = content.split('\n').filter((l) => l !== '');
+    const lines = [];
+    for (const line of raw) {
+        try {
+            const parsed = JSON.parse(line);
+            lines.push(typeof parsed.text === 'string' ? parsed.text : line);
+        }
+        catch {
+            lines.push(line);
+        }
+    }
+    return { lines, raw };
+}
+function registerCiRunApi(app, root, limiter, engine) {
+    // The workflows at a ref, with the inputs each dispatch takes. A caller that
+    // means to run one needs both.
+    app.get('/api/repos/:collection/:repo/workflows', async (req, res) => {
+        const found = (0, auth_1.requireRepo)(root, limiter, req, res);
+        if (!found)
+            return;
+        const asked = String(req.query.ref ?? '');
+        if (asked !== '' && !(0, git_1.isValidRefName)(asked)) {
+            (0, auth_1.apiError)(res, 400, 'ref is not a usable ref name');
+            return;
+        }
+        const branches = await found.repo.listRefs('heads');
+        const ref = asked || (await found.repo.defaultBranch(branches)) || '';
+        const sha = ref === '' ? null : await found.repo.resolve(ref);
+        if (!sha) {
+            res.json({ ref, workflows: [] });
+            return;
+        }
+        res.json({ ref, sha, workflows: await (0, engine_1.listWorkflowsAt)(found.repo, sha) });
+    });
+    app.get('/api/repos/:collection/:repo/runs', (req, res) => {
+        const found = (0, auth_1.requireRepo)(root, limiter, req, res);
+        if (!found)
+            return;
+        const status = String(req.query.status ?? '');
+        if (status !== '' && !['queued', 'running', 'completed'].includes(status)) {
+            (0, auth_1.apiError)(res, 400, 'status must be queued, running, or completed');
+            return;
+        }
+        const all = (0, runs_1.listRuns)(root, found.repo.collection, found.repo.name);
+        const selected = status === '' ? all : all.filter((r) => r.status === status);
+        const limit = (0, auth_1.limitParam)(req.query.limit, 30, MAX_LISTED_RUNS);
+        res.json({ runs: selected.slice(0, limit), total: selected.length });
+    });
+    app.get('/api/repos/:collection/:repo/runs/:n', (req, res) => {
+        const found = (0, auth_1.requireRepo)(root, limiter, req, res);
+        if (!found)
+            return;
+        const n = runNumber(req.params.n);
+        const run = n === null ? null : (0, runs_1.readRun)(root, found.repo.collection, found.repo.name, n);
+        if (!run) {
+            (0, auth_1.apiError)(res, 404, `no run #${req.params.n} in ${found.repo.collection}/${found.repo.name}`);
+            return;
+        }
+        // The jobs with their step states, because "which step failed" is the next
+        // question after "did it fail" and a second request per job to answer it
+        // would be a poor trade.
+        const jobs = run.jobs
+            .map((id) => (0, runs_1.readJob)(root, found.repo.collection, found.repo.name, n, id))
+            .filter((j) => j !== null);
+        res.json({ ...run, jobs });
+    });
+    app.get('/api/repos/:collection/:repo/runs/:n/jobs/:job', (req, res) => {
+        const found = (0, auth_1.requireRepo)(root, limiter, req, res);
+        if (!found)
+            return;
+        const n = runNumber(req.params.n);
+        if (n === null || !(0, runs_1.isValidJobId)(req.params.job)) {
+            (0, auth_1.apiError)(res, 404, 'no such job');
+            return;
+        }
+        const job = (0, runs_1.readJob)(root, found.repo.collection, found.repo.name, n, req.params.job);
+        if (!job) {
+            (0, auth_1.apiError)(res, 404, `no job ${req.params.job} in run #${n}`);
+            return;
+        }
+        res.json(job);
+    });
+    // ?tail=<n> for the last n lines, ?tail=0 for all of it, ?format=ndjson for
+    // the records as the runner posted them.
+    app.get('/api/repos/:collection/:repo/runs/:n/jobs/:job/log', (req, res) => {
+        const found = (0, auth_1.requireRepo)(root, limiter, req, res);
+        if (!found)
+            return;
+        const n = runNumber(req.params.n);
+        if (n === null || !(0, runs_1.isValidJobId)(req.params.job)) {
+            (0, auth_1.apiError)(res, 404, 'no such job');
+            return;
+        }
+        const job = (0, runs_1.readJob)(root, found.repo.collection, found.repo.name, n, req.params.job);
+        if (!job) {
+            (0, auth_1.apiError)(res, 404, `no job ${req.params.job} in run #${n}`);
+            return;
+        }
+        const format = String(req.query.format ?? 'text');
+        if (format !== 'text' && format !== 'ndjson') {
+            (0, auth_1.apiError)(res, 400, 'format must be text or ndjson');
+            return;
+        }
+        const asked = req.query.tail;
+        const tail = asked === undefined ? DEFAULT_TAIL : Number(asked);
+        if (!Number.isInteger(tail) || tail < 0) {
+            (0, auth_1.apiError)(res, 400, 'tail must be a whole number; 0 means the whole log');
+            return;
+        }
+        const { lines, raw } = readLog((0, runs_1.jobLogPath)(root, found.repo.collection, found.repo.name, n, req.params.job));
+        const source = format === 'ndjson' ? raw : lines;
+        const kept = tail === 0 ? source : source.slice(-tail);
+        res.json({
+            job: job.id,
+            status: job.status,
+            conclusion: job.conclusion ?? null,
+            // Two kinds of truncation, and they are not the same thing: the server
+            // caps a log as it is written, and tail keeps only the end of what is
+            // there. A caller diagnosing a failure should be told which happened.
+            lines: kept,
+            truncated: kept.length < source.length,
+            capped: job.logCapped === true,
+            total: source.length,
+            // A job that failed in the planner has no log at all, only a reason.
+            error: job.error ?? null,
+        });
+    });
+    app.get('/api/repos/:collection/:repo/runs/:n/artifacts', (req, res) => {
+        const found = (0, auth_1.requireRepo)(root, limiter, req, res);
+        if (!found)
+            return;
+        const n = runNumber(req.params.n);
+        if (n === null) {
+            (0, auth_1.apiError)(res, 404, 'no such run');
+            return;
+        }
+        res.json({ artifacts: (0, artifacts_1.listArtifacts)(root, found.repo.collection, found.repo.name, n) });
+    });
+    app.get('/api/repos/:collection/:repo/runs/:n/artifacts/:name', (req, res) => {
+        const found = (0, auth_1.requireRepo)(root, limiter, req, res);
+        if (!found)
+            return;
+        const n = runNumber(req.params.n);
+        if (n === null || !(0, artifacts_1.isValidArtifactName)(req.params.name)) {
+            (0, auth_1.apiError)(res, 404, 'no such artifact');
+            return;
+        }
+        const file = (0, artifacts_1.artifactPath)(root, found.repo.collection, found.repo.name, n, req.params.name);
+        if (!file || !fs.existsSync(file)) {
+            (0, auth_1.apiError)(res, 404, `no artifact named ${req.params.name} in run #${n}`);
+            return;
+        }
+        res
+            .type('application/x-tar')
+            .set('Content-Disposition', `attachment; filename="${req.params.name}.tar"`)
+            .sendFile(path.resolve(file));
+    });
+    // Cancelling, re-running, and dispatching write, so they take the write role on
+    // the repository, which is what the web requires of them too.
+    app.post('/api/repos/:collection/:repo/runs/:n/cancel', (req, res) => {
+        const ctx = (0, auth_1.requirePush)(root, limiter, req, res);
+        if (!ctx)
+            return;
+        const n = runNumber(req.params.n);
+        if (n === null || !(0, runs_1.readRun)(root, ctx.repo.collection, ctx.repo.name, n)) {
+            (0, auth_1.apiError)(res, 404, `no run #${req.params.n}`);
+            return;
+        }
+        // A run that is already over is not cancellable, which is a state refusal
+        // rather than a missing run.
+        const cancelled = engine.cancelRun(ctx.repo.collection, ctx.repo.name, n);
+        if (!cancelled) {
+            (0, auth_1.apiError)(res, 409, `run #${n} is not in progress`);
+            return;
+        }
+        res.json({ cancelled: n });
+    });
+    app.post('/api/repos/:collection/:repo/runs/:n/rerun', async (req, res) => {
+        const ctx = (0, auth_1.requirePush)(root, limiter, req, res);
+        if (!ctx)
+            return;
+        const n = runNumber(req.params.n);
+        if (n === null) {
+            (0, auth_1.apiError)(res, 404, 'no such run');
+            return;
+        }
+        try {
+            const fresh = await engine.rerun(ctx.repo.collection, ctx.repo.name, n);
+            if (!fresh) {
+                (0, auth_1.apiError)(res, 404, `no run #${n}`);
+                return;
+            }
+            res.json({ number: fresh.number, workflowName: fresh.workflowName, status: fresh.status });
+        }
+        catch (e) {
+            (0, auth_1.apiError)(res, 400, e instanceof Error ? e.message : String(e));
+        }
+    });
+    /**
+     * Mint the command that runs this run's manual jobs on a machine of the
+     * caller's. Takes the write role, the same standing that dispatches and
+     * re-runs workflows: minting decides that repository code will execute
+     * somewhere, which is exactly what those decide.
+     *
+     * The token is in the response once and only its hash is kept, as with
+     * every credential a vault issues. It must be redeemed within fifteen
+     * minutes and is spent by redemption; the npx version is pinned to this
+     * vault's own, so the pasted command runs the client this server was
+     * released with.
+     */
+    app.post('/api/repos/:collection/:repo/runs/:n/exec-command', (req, res) => {
+        const ctx = (0, auth_1.requirePush)(root, limiter, req, res);
+        if (!ctx)
+            return;
+        const n = runNumber(req.params.n);
+        if (n === null || !(0, runs_1.readRun)(root, ctx.repo.collection, ctx.repo.name, n)) {
+            (0, auth_1.apiError)(res, 404, `no run #${req.params.n}`);
+            return;
+        }
+        const minted = engine.mintManual(ctx.repo.collection, ctx.repo.name, n, ctx.actor.username);
+        if ('error' in minted) {
+            if (minted.error === 'finished')
+                (0, auth_1.apiError)(res, 409, `run #${n} has finished; there is nothing left to run`);
+            else
+                (0, auth_1.apiError)(res, 400, `run #${n} has no manual jobs (none of its jobs has 'manual' in runs-on)`);
+            return;
+        }
+        const url = (0, web_1.baseUrlOf)(req);
+        res.status(201).json({
+            run: n,
+            token: minted.token,
+            expiresAt: minted.grant.expiresAt,
+            expiresInMinutes: Math.round(manual_1.MINT_TTL_MS / 60000),
+            command: `npx @magland/mochi@${(0, version_1.packageVersion)()} job run ${url} ${minted.token}`,
+        });
+    });
+    app.post('/api/repos/:collection/:repo/dispatches', async (req, res) => {
+        const ctx = (0, auth_1.requirePush)(root, limiter, req, res);
+        if (!ctx)
+            return;
+        const body = (0, auth_1.bodyOf)(req);
+        const workflow = (0, auth_1.stringField)(body, 'workflow');
+        if (workflow === null) {
+            (0, auth_1.apiError)(res, 400, 'a "workflow" is required; list them at /workflows');
+            return;
+        }
+        const rawInputs = body.inputs;
+        if (rawInputs !== undefined && (typeof rawInputs !== 'object' || rawInputs === null || Array.isArray(rawInputs))) {
+            (0, auth_1.apiError)(res, 400, '"inputs" must be an object');
+            return;
+        }
+        const branches = await ctx.repo.listRefs('heads');
+        try {
+            const run = await (0, dispatch_1.dispatchWorkflow)(engine, ctx.repo, branches, await ctx.repo.defaultBranch(branches), ctx.actor.username, {
+                workflow,
+                ref: (0, auth_1.stringField)(body, 'ref') ?? '',
+                inputs: (rawInputs ?? {}),
+            });
+            res.status(201).json({ number: run.number, workflowName: run.workflowName, status: run.status, sha: run.sha });
+        }
+        catch (e) {
+            (0, auth_1.sendOpError)(res, e, 'could not dispatch the workflow');
+        }
+    });
+}

package/dist/api/contents.js

@@ -0,0 +1,339 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.registerContentsApi = registerContentsApi;
+const git_1 = require("../git");
+const languages_1 = require("../languages");
+const limit_1 = require("../limit");
+const pointer_1 = require("../pointer");
+const render_1 = require("../render");
+const auth_1 = require("./auth");
+// Reading a repository: the tree, a file, history, a diff, blame, search.
+//
+// These are the routes that make an agent able to work without a clone. They are
+// deliberately not the HTML routes answering JSON: the HTML routes carry
+// UI-shaped parameters and costs (a tree listing with the last commit per entry
+// is one `git log` per entry) that an API caller usually does not want, and
+// sometimes wants more than.
+/** The wildcard tail of a route path, as express leaves it. */
+function tail(req) {
+    return req.params['0'] ?? '';
+}
+/** A ref from ?ref=, falling back to the default branch. Never an arbitrary revision expression. */
+async function refOf(req, repo) {
+    const asked = String(req.query.ref ?? '');
+    if (asked === '')
+        return await repo.defaultBranch(await repo.listRefs('heads'));
+    return (0, git_1.isValidRefName)(asked) ? asked : null;
+}
+// How a gated route refuses. 503 rather than 429: this is server capacity rather
+// than a client quota, and nothing about the request was wrong.
+function sendBusy(res) {
+    res.setHeader('Retry-After', String(limit_1.BUSY_RETRY_SECONDS));
+    (0, auth_1.apiError)(res, 503, 'the server is busy with other git work; try again in a moment');
+}
+const MAX_COMMITS = 250;
+const MAX_LISTED_PATHS = 20000;
+/** The same ceiling the editor applies, so that the two interfaces agree on what is too big. */
+const MAX_FILE_BYTES = 1024 * 1024;
+function registerContentsApi(app, root, limiter, gates) {
+    // A directory listing. ?commits=1 adds the last commit per entry, which costs
+    // one git log per entry; it is off by default because an API caller asking for
+    // a listing usually wants names.
+    const treeHandler = async (req, res) => {
+        const found = (0, auth_1.requireRepo)(root, limiter, req, res);
+        if (!found)
+            return;
+        const ref = await refOf(req, found.repo);
+        if (!ref) {
+            (0, auth_1.apiError)(res, 400, 'ref is not a usable ref name');
+            return;
+        }
+        const dir = tail(req);
+        if (!(0, git_1.isValidRepoPath)(dir)) {
+            (0, auth_1.apiError)(res, 400, 'that is not a usable path');
+            return;
+        }
+        let entries;
+        try {
+            entries = await found.repo.listTree(ref, dir);
+        }
+        catch {
+            (0, auth_1.apiError)(res, 404, `nothing at ${dir || '/'} in ${ref}`);
+            return;
+        }
+        if (String(req.query.commits ?? '') === '1') {
+            const paths = entries.map((e) => (dir ? `${dir}/${e.name}` : e.name));
+            const last = await found.repo.lastCommits(ref, paths);
+            res.json({
+                ref,
+                path: dir,
+                entries: entries.map((e, i) => ({ ...e, lastCommit: last.get(paths[i]) ?? null })),
+            });
+            return;
+        }
+        res.json({ ref, path: dir, entries });
+    };
+    app.get('/api/repos/:collection/:repo/tree/*', treeHandler);
+    app.get('/api/repos/:collection/:repo/tree', treeHandler);
+    // One file, with its content. Text comes back as text; anything binary comes
+    // back base64, and an LFS pointer is reported as one rather than handed over as
+    // if it were the file, since the bytes are somewhere else.
+    app.get('/api/repos/:collection/:repo/contents/*', async (req, res) => {
+        const found = (0, auth_1.requireRepo)(root, limiter, req, res);
+        if (!found)
+            return;
+        const ref = await refOf(req, found.repo);
+        if (!ref) {
+            (0, auth_1.apiError)(res, 400, 'ref is not a usable ref name');
+            return;
+        }
+        const filePath = tail(req);
+        if (filePath === '' || !(0, git_1.isValidRepoPath)(filePath)) {
+            (0, auth_1.apiError)(res, 400, 'that is not a usable path');
+            return;
+        }
+        let buf;
+        try {
+            if ((await found.repo.entryType(ref, filePath)) !== 'blob') {
+                (0, auth_1.apiError)(res, 404, `no file at ${filePath} in ${ref}`);
+                return;
+            }
+            buf = await found.repo.catBlob(ref, filePath);
+        }
+        catch {
+            (0, auth_1.apiError)(res, 404, `no file at ${filePath} in ${ref}`);
+            return;
+        }
+        const pointer = (0, pointer_1.parsePointer)(buf);
+        // The commit the ref is at, so that a caller which reads, thinks, and then
+        // writes can hand it back as expectedSha and be told if the branch moved
+        // underneath it.
+        const base = { ref, path: filePath, size: buf.length, commit: await found.repo.resolve(ref) };
+        if (pointer) {
+            res.json({
+                ...base,
+                encoding: 'lfs-pointer',
+                lfs: { oid: pointer.oid, size: pointer.size },
+                content: null,
+                note: 'this path is a Git LFS pointer; fetch the object through the LFS endpoints or a clone with git-lfs',
+            });
+            return;
+        }
+        if (buf.length > MAX_FILE_BYTES) {
+            (0, auth_1.apiError)(res, 413, `${filePath} is larger than ${MAX_FILE_BYTES} bytes; fetch it from the raw route or a clone`);
+            return;
+        }
+        if ((0, render_1.isBinary)(buf)) {
+            res.json({ ...base, encoding: 'base64', content: buf.toString('base64') });
+            return;
+        }
+        res.json({ ...base, encoding: 'utf-8', content: buf.toString('utf8') });
+    });
+    // The bytes, with no envelope. The sandbox headers are the same ones the web
+    // raw route sets, because repository content must never be able to inject HTML
+    // into this origin whichever door it came out of.
+    app.get('/api/repos/:collection/:repo/raw/*', async (req, res) => {
+        const found = (0, auth_1.requireRepo)(root, limiter, req, res);
+        if (!found)
+            return;
+        const ref = await refOf(req, found.repo);
+        const filePath = tail(req);
+        if (!ref || filePath === '' || !(0, git_1.isValidRepoPath)(filePath)) {
+            (0, auth_1.apiError)(res, 400, 'ask for a file as /raw/<path>?ref=<ref>');
+            return;
+        }
+        let buf;
+        try {
+            if ((await found.repo.entryType(ref, filePath)) !== 'blob') {
+                (0, auth_1.apiError)(res, 404, `no file at ${filePath} in ${ref}`);
+                return;
+            }
+            buf = await found.repo.catBlob(ref, filePath);
+        }
+        catch {
+            (0, auth_1.apiError)(res, 404, `no file at ${filePath} in ${ref}`);
+            return;
+        }
+        res.setHeader('Content-Security-Policy', 'sandbox');
+        res.setHeader('X-Content-Type-Options', 'nosniff');
+        res.type((0, render_1.isBinary)(buf) ? 'application/octet-stream' : 'text/plain; charset=utf-8');
+        res.send(buf);
+    });
+    app.get('/api/repos/:collection/:repo/commits', async (req, res) => {
+        const found = (0, auth_1.requireRepo)(root, limiter, req, res);
+        if (!found)
+            return;
+        const ref = await refOf(req, found.repo);
+        if (!ref) {
+            (0, auth_1.apiError)(res, 400, 'ref is not a usable ref name');
+            return;
+        }
+        const filePath = String(req.query.path ?? '');
+        if (filePath !== '' && !(0, git_1.isValidRepoPath)(filePath)) {
+            (0, auth_1.apiError)(res, 400, 'that is not a usable path');
+            return;
+        }
+        const limit = (0, auth_1.limitParam)(req.query.limit, 30, MAX_COMMITS);
+        try {
+            const commits = await found.repo.log(ref, 0, limit, filePath || undefined);
+            res.json({ ref, commits });
+        }
+        catch {
+            (0, auth_1.apiError)(res, 404, `ref ${ref} not found`);
+        }
+    });
+    app.get('/api/repos/:collection/:repo/commits/:sha', async (req, res) => {
+        const found = (0, auth_1.requireRepo)(root, limiter, req, res);
+        if (!found)
+            return;
+        const detail = await found.repo.commit(req.params.sha);
+        if (!detail) {
+            (0, auth_1.apiError)(res, 404, `no commit ${req.params.sha}`);
+            return;
+        }
+        res.json(detail);
+    });
+    app.get('/api/repos/:collection/:repo/commits/:sha/patch', async (req, res) => {
+        const found = (0, auth_1.requireRepo)(root, limiter, req, res);
+        if (!found)
+            return;
+        if (!(await found.repo.commit(req.params.sha))) {
+            (0, auth_1.apiError)(res, 404, `no commit ${req.params.sha}`);
+            return;
+        }
+        res.type('text/plain').send(await found.repo.commitPatch(req.params.sha));
+    });
+    // base...head, spelled as the web route spells it. A wildcard rather than one
+    // segment, because a branch name may contain slashes.
+    app.get('/api/repos/:collection/:repo/compare/*', async (req, res) => {
+        const found = (0, auth_1.requireRepo)(root, limiter, req, res);
+        if (!found)
+            return;
+        const parts = tail(req).split('...');
+        if (parts.length !== 2 || !(0, git_1.isValidRefName)(parts[0]) || !(0, git_1.isValidRefName)(parts[1])) {
+            (0, auth_1.apiError)(res, 400, 'ask for a comparison as <base>...<head>');
+            return;
+        }
+        try {
+            const cmp = await found.repo.compare(parts[0], parts[1]);
+            res.json({ base: parts[0], head: parts[1], ...cmp });
+        }
+        catch {
+            (0, auth_1.apiError)(res, 404, `could not compare ${parts[0]} with ${parts[1]}`);
+        }
+    });
+    app.get('/api/repos/:collection/:repo/blame/*', async (req, res) => {
+        const found = (0, auth_1.requireRepo)(root, limiter, req, res);
+        if (!found)
+            return;
+        const ref = await refOf(req, found.repo);
+        const filePath = tail(req);
+        if (!ref || filePath === '' || !(0, git_1.isValidRepoPath)(filePath)) {
+            (0, auth_1.apiError)(res, 400, 'ask for blame as /blame/<path>?ref=<ref>');
+            return;
+        }
+        try {
+            res.json({ ref, path: filePath, lines: await found.repo.blame(ref, filePath) });
+        }
+        catch {
+            (0, auth_1.apiError)(res, 404, `no file at ${filePath} in ${ref}`);
+        }
+    });
+    // Literal search, gated like the web route: git grep over a whole tree is the
+    // most expensive thing a reader can ask for.
+    app.get('/api/repos/:collection/:repo/search', async (req, res) => {
+        const found = (0, auth_1.requireRepo)(root, limiter, req, res);
+        if (!found)
+            return;
+        const ref = await refOf(req, found.repo);
+        const query = String(req.query.q ?? '').slice(0, 256);
+        if (!ref) {
+            (0, auth_1.apiError)(res, 400, 'ref is not a usable ref name');
+            return;
+        }
+        if (query.trim() === '') {
+            res.json({ ref, query, hits: [], truncated: false });
+            return;
+        }
+        const release = await gates.search.enter();
+        if (!release) {
+            sendBusy(res);
+            return;
+        }
+        try {
+            const { hits, truncated } = await found.repo.search(ref, query);
+            res.json({ ref, query, hits, truncated });
+        }
+        finally {
+            release();
+        }
+    });
+    // The file list the finder uses, which is what an agent wants before it asks
+    // for any one file.
+    app.get('/api/repos/:collection/:repo/paths', async (req, res) => {
+        const found = (0, auth_1.requireRepo)(root, limiter, req, res);
+        if (!found)
+            return;
+        const ref = await refOf(req, found.repo);
+        if (!ref) {
+            (0, auth_1.apiError)(res, 400, 'ref is not a usable ref name');
+            return;
+        }
+        const limit = (0, auth_1.limitParam)(req.query.limit, MAX_LISTED_PATHS, MAX_LISTED_PATHS);
+        const release = await gates.tree.enter();
+        if (!release) {
+            sendBusy(res);
+            return;
+        }
+        try {
+            const { paths, truncated } = await found.repo.listPaths(ref, limit);
+            res.json({ ref, paths, truncated });
+        }
+        catch {
+            (0, auth_1.apiError)(res, 404, `ref ${ref} not found`);
+        }
+        finally {
+            release();
+        }
+    });
+    app.get('/api/repos/:collection/:repo/contributors', async (req, res) => {
+        const found = (0, auth_1.requireRepo)(root, limiter, req, res);
+        if (!found)
+            return;
+        const ref = await refOf(req, found.repo);
+        if (!ref) {
+            (0, auth_1.apiError)(res, 400, 'ref is not a usable ref name');
+            return;
+        }
+        try {
+            res.json({ ref, contributors: await found.repo.contributors(ref) });
+        }
+        catch {
+            (0, auth_1.apiError)(res, 404, `ref ${ref} not found`);
+        }
+    });
+    app.get('/api/repos/:collection/:repo/languages', async (req, res) => {
+        const found = (0, auth_1.requireRepo)(root, limiter, req, res);
+        if (!found)
+            return;
+        const ref = await refOf(req, found.repo);
+        if (!ref) {
+            (0, auth_1.apiError)(res, 400, 'ref is not a usable ref name');
+            return;
+        }
+        const release = await gates.tree.enter();
+        if (!release) {
+            sendBusy(res);
+            return;
+        }
+        try {
+            res.json({ ref, languages: await (0, languages_1.languageBreakdown)(found.repo.dir, ref) });
+        }
+        catch {
+            (0, auth_1.apiError)(res, 404, `ref ${ref} not found`);
+        }
+        finally {
+            release();
+        }
+    });
+}