@magland/mochi 0.3.1

package/dist/browse.js

@@ -0,0 +1,630 @@
+"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.IMAGE_TYPES = void 0;
+exports.registerBrowse = registerBrowse;
+const crypto = __importStar(require("crypto"));
+const fs = __importStar(require("fs"));
+const git_1 = require("./git");
+const languages_1 = require("./languages");
+const markdown_1 = require("./markdown");
+const pointer_1 = require("./pointer");
+const profile_1 = require("./profile");
+const render_1 = require("./render");
+const atom_1 = require("./atom");
+const runs_1 = require("./ci/runs");
+const diff_1 = require("./diff");
+const layout_1 = require("./layout");
+const perms_1 = require("./perms");
+const scan_1 = require("./scan");
+const session_1 = require("./session");
+const site_1 = require("./site");
+const vault_1 = require("./vault");
+const views = __importStar(require("./views"));
+const views_1 = require("./views");
+const web_1 = require("./web");
+const COMMITS_PER_PAGE = 35;
+const MAX_RENDER_SIZE = 1024 * 1024;
+const MAX_LISTED_COMMITS = 250;
+const ARCHIVE_FORMATS = {
+    'tar.gz': { format: 'tar.gz', type: 'application/gzip' },
+    tgz: { format: 'tar.gz', type: 'application/gzip' },
+    zip: { format: 'zip', type: 'application/zip' },
+};
+exports.IMAGE_TYPES = {
+    png: 'image/png',
+    jpg: 'image/jpeg',
+    jpeg: 'image/jpeg',
+    gif: 'image/gif',
+    webp: 'image/webp',
+    ico: 'image/x-icon',
+    svg: 'image/svg+xml',
+};
+function registerBrowse(app, root, gates, lfs = null) {
+    /**
+     * What a listing says about one repository. The facts beyond the name come
+     * from different places, so they are gathered once here and used by both
+     * the front page and a collection's own. A private repository the viewer
+     * has no role on is not listed at all, matching the 404 its page gives.
+     */
+    async function repoCards(req, collection, viewer) {
+        const visible = (0, scan_1.listRepoDirs)(root, collection).filter((d) => (0, perms_1.repoRole)(root, viewer?.auth ?? null, {
+            collection,
+            name: (0, scan_1.displayName)(d),
+            dir: (0, layout_1.repoPath)(root, collection, d),
+        }) !== null);
+        return Promise.all(visible.map(async (d) => {
+            const name = (0, scan_1.displayName)(d);
+            const repo = new git_1.GitRepo((0, layout_1.repoPath)(root, collection, d), collection, name);
+            // A repository with a site is linked straight to it from the listing,
+            // at its own origin where it has one, so a visitor scanning a
+            // collection reaches the published page without stopping at the
+            // repository first.
+            const hasSite = (0, scan_1.siteDir)(root, collection, name) !== null;
+            const origin = hasSite ? (0, site_1.siteHostUrl)(root, req, collection, name) : null;
+            const run = (0, runs_1.latestRun)(root, collection, name);
+            return {
+                collection,
+                name,
+                description: (0, scan_1.repoDescription)(repo.dir),
+                isPrivate: (0, perms_1.repoIsPrivate)(repo.dir),
+                updated: await repo.lastUpdated(),
+                siteUrl: !hasSite
+                    ? null
+                    : origin
+                        ? `${origin}/`
+                        : `/${encodeURIComponent(collection)}/${encodeURIComponent(name)}/site/`,
+                ci: run
+                    ? {
+                        conclusion: run.conclusion ?? null,
+                        running: run.status !== 'completed',
+                        url: `/${encodeURIComponent(collection)}/${encodeURIComponent(name)}/actions/runs/${run.number}`,
+                    }
+                    : null,
+            };
+        }));
+    }
+    // Newest first is the default: a listing is read to see what has been
+    // happening, and only sometimes to find a name already known.
+    function sortParam(req) {
+        return req.query.sort === 'name' ? 'name' : 'recent';
+    }
+    app.get('/', (0, web_1.ah)(async (req, res) => {
+        const viewer = (0, session_1.getViewer)(req, root);
+        const cardsPer = await Promise.all((0, scan_1.listCollections)(root).map((c) => repoCards(req, c.name, viewer)));
+        // The counts beside collection names count what this viewer can see,
+        // for the same reason the cards do.
+        const collections = (0, scan_1.listCollections)(root).map((c, i) => ({ name: c.name, repoCount: cardsPer[i].length }));
+        res.type('html').send(views.homePage(root, collections, cardsPer.flat(), sortParam(req), viewer));
+    }));
+    app.get('/about', (req, res) => {
+        res.type('html').send(views.aboutPage((0, web_1.baseUrlOf)(req), (0, session_1.getViewer)(req, root)));
+    });
+    app.get('/:collection', (0, web_1.ah)(async (req, res) => {
+        const collection = req.params.collection;
+        const viewer = (0, session_1.getViewer)(req, root);
+        let collectionIsDir = false;
+        try {
+            collectionIsDir = fs.statSync((0, layout_1.collectionDir)(root, collection)).isDirectory();
+        }
+        catch {
+            collectionIsDir = false;
+        }
+        if (!(0, scan_1.isValidName)(collection) || !collectionIsDir) {
+            (0, web_1.send404)(res, `Collection ${collection} not found`, viewer);
+            return;
+        }
+        // The profile lives in the .mochi repository, so a private one
+        // introduces the collection only to viewers who could read it.
+        const profileRepo = (0, scan_1.findRepo)(root, collection, '.mochi');
+        const profileVisible = profileRepo === null || (0, perms_1.repoRole)(root, viewer?.auth ?? null, profileRepo) !== null;
+        const [cards, profile] = await Promise.all([
+            repoCards(req, collection, viewer),
+            profileVisible
+                ? (0, profile_1.collectionProfile)(root, collection)
+                : Promise.resolve({ readme: null, addUrl: `/new?collection=${encodeURIComponent(collection)}` }),
+        ]);
+        const canSettings = viewer !== null && (0, perms_1.canAdminCollection)(root, viewer.auth, collection);
+        res
+            .type('html')
+            .send(views.collectionPage(collection, cards, sortParam(req), viewer, canSettings, profile));
+    }));
+    async function renderTree(req, res, loaded, ref, treePath) {
+        const viewer = (0, session_1.getViewer)(req, root);
+        const ctx = await (0, web_1.makeCtx)(root, req, loaded, ref, viewer);
+        let entries;
+        try {
+            entries = await loaded.repo.listTree(ref, treePath);
+        }
+        catch {
+            (0, web_1.send404)(res, `Path ${treePath || '/'} not found at ${ref}`, viewer);
+            return;
+        }
+        // The listing wants a commit per entry, which is a git log per entry: cheap
+        // for the directory sizes people browse, and capped so that an unusually
+        // wide one degrades into a listing without the message and age columns
+        // rather than into a page that takes a second to build.
+        const entryPaths = entries
+            .slice(0, MAX_LISTED_COMMITS)
+            .map((e) => (treePath === '' ? e.name : `${treePath}/${e.name}`));
+        // The language breakdown reads the whole tree, so it is measured only at
+        // the root, which is the only place the About panel that shows it appears.
+        const [latest, entryCommits, commitCount, languages, contributors] = await Promise.all([
+            loaded.repo.log(ref, 0, 1, treePath || undefined).then((cs) => cs[0] ?? null),
+            loaded.repo.lastCommits(ref, entryPaths),
+            loaded.repo.commitCount(ref).catch(() => 0),
+            treePath === '' ? (0, languages_1.languageBreakdown)(loaded.repo.dir, ref) : Promise.resolve([]),
+            treePath === ''
+                ? loaded.repo.contributors(ref).then((people) => {
+                    // One person, one face: a user's web edits carry a synthetic
+                    // author, and their listed emails are theirs too.
+                    const state = (0, vault_1.loadVault)(root);
+                    return (0, vault_1.mergeContributors)(state.status === 'ok' ? state.vault : null, people);
+                })
+                : Promise.resolve([]),
+        ]);
+        let readmeHtml = null;
+        let readmeName = null;
+        const readme = entries.find((e) => e.type === 'blob' && /^readme(\.(md|markdown|txt))?$/i.test(e.name));
+        if (readme && (readme.size ?? 0) <= MAX_RENDER_SIZE) {
+            const readmePath = treePath === '' ? readme.name : `${treePath}/${readme.name}`;
+            const buf = await loaded.repo.catBlob(ref, readmePath);
+            if (!(0, render_1.isBinary)(buf)) {
+                const text = buf.toString('utf8');
+                readmeName = readme.name;
+                const base = (0, views_1.repoUrl)(ctx);
+                const dirSuffix = treePath === '' ? '' : `/${(0, views_1.encPath)(treePath)}`;
+                if (/\.(md|markdown)$/i.test(readme.name) || !readme.name.includes('.')) {
+                    readmeHtml = (0, markdown_1.renderMarkdown)(text, {
+                        rawBase: `${base}/raw/${(0, views_1.encPath)(ref)}${dirSuffix}`,
+                        blobBase: `${base}/blob/${(0, views_1.encPath)(ref)}${dirSuffix}`,
+                        issueBase: `${base}/issues`,
+                        commitBase: `${base}/commit`,
+                    });
+                }
+                else {
+                    readmeHtml = `<pre>${(0, render_1.esc)(text)}</pre>`;
+                }
+            }
+        }
+        res.type('html').send(views.treePage(ctx, {
+            path: treePath,
+            entries,
+            entryCommits,
+            latest,
+            commitCount,
+            description: (0, scan_1.repoDescription)(loaded.repo.dir),
+            contributors,
+            readmeHtml,
+            readmeName,
+            languages,
+        }));
+    }
+    app.get('/:collection/:repo', (0, web_1.ah)(async (req, res) => {
+        const viewer = (0, session_1.getViewer)(req, root);
+        const loaded = await (0, web_1.loadRepo)(root, req, res, viewer);
+        if (!loaded)
+            return;
+        if (!loaded.defaultBranch) {
+            res.type('html').send(views.emptyRepoPage(await (0, web_1.makeCtx)(root, req, loaded, '', viewer)));
+            return;
+        }
+        await renderTree(req, res, loaded, loaded.defaultBranch, '');
+    }));
+    app.get('/:collection/:repo/tree/*', (0, web_1.ah)(async (req, res) => {
+        const viewer = (0, session_1.getViewer)(req, root);
+        const loaded = await (0, web_1.loadRepo)(root, req, res, viewer);
+        if (!loaded)
+            return;
+        const { ref, path: treePath } = loaded.repo.resolveRefAndPath((0, web_1.wildcard)(req), loaded.refNames);
+        if (!(0, git_1.isValidRefName)(ref) || !(0, git_1.isValidRepoPath)(treePath)) {
+            (0, web_1.send404)(res, 'Not found', viewer);
+            return;
+        }
+        if (treePath !== '') {
+            const type = await loaded.repo.entryType(ref, treePath);
+            if (type === 'blob') {
+                res.redirect(`${(0, views_1.repoUrl)(await (0, web_1.makeCtx)(root, req, loaded, ref, viewer))}/blob/${(0, views_1.encPath)(ref)}/${(0, views_1.encPath)(treePath)}`);
+                return;
+            }
+        }
+        await renderTree(req, res, loaded, ref, treePath);
+    }));
+    app.get('/:collection/:repo/blob/*', (0, web_1.ah)(async (req, res) => {
+        const viewer = (0, session_1.getViewer)(req, root);
+        const loaded = await (0, web_1.loadRepo)(root, req, res, viewer);
+        if (!loaded)
+            return;
+        const { ref, path: filePath } = loaded.repo.resolveRefAndPath((0, web_1.wildcard)(req), loaded.refNames);
+        if (!(0, git_1.isValidRefName)(ref) || !(0, git_1.isValidRepoPath)(filePath) || filePath === '') {
+            (0, web_1.send404)(res, 'Not found', viewer);
+            return;
+        }
+        const ctx = await (0, web_1.makeCtx)(root, req, loaded, ref, viewer);
+        const type = await loaded.repo.entryType(ref, filePath);
+        if (type === 'tree') {
+            res.redirect(`${(0, views_1.repoUrl)(ctx)}/tree/${(0, views_1.encPath)(ref)}/${(0, views_1.encPath)(filePath)}`);
+            return;
+        }
+        if (type !== 'blob') {
+            (0, web_1.send404)(res, `File ${filePath} not found at ${ref}`, viewer);
+            return;
+        }
+        const buf = await loaded.repo.catBlob(ref, filePath);
+        const ext = (filePath.split('.').pop() ?? '').toLowerCase();
+        const rawUrl = `${(0, views_1.repoUrl)(ctx)}/raw/${(0, views_1.encPath)(ref)}/${(0, views_1.encPath)(filePath)}`;
+        // LFS pointer detection precedes every content branch: an LFS-tracked
+        // .md or .png must render as a download card, not as its pointer text.
+        // ?plain=1 falls through to the source view, as on GitHub, keeping the
+        // underlying pointer inspectable.
+        const pointer = (0, pointer_1.parsePointer)(buf);
+        if (pointer) {
+            if (req.query.plain !== '1') {
+                res
+                    .type('html')
+                    .send(views.blobPage(ctx, filePath, { kind: 'lfs', rawUrl, size: pointer.size, oid: pointer.oid }, true));
+                return;
+            }
+            // ?plain=1 shows the pointer itself, whatever the file is named: an
+            // LFS-tracked .png must not be rendered from its pointer text as an
+            // image, or the source view would be unreachable for it. Pointers are
+            // never editable, so no edit controls here.
+            const src = buf.toString('utf8');
+            res.type('html').send(views.blobPage(ctx, filePath, {
+                kind: 'code',
+                html: (0, render_1.esc)(src),
+                lineCount: src.replace(/\n$/, '').split('\n').length,
+                size: buf.length,
+                editable: false,
+            }, true));
+            return;
+        }
+        if (exports.IMAGE_TYPES[ext]) {
+            res.type('html').send(views.blobPage(ctx, filePath, { kind: 'image', rawUrl, size: buf.length }));
+            return;
+        }
+        if ((0, render_1.isBinary)(buf)) {
+            res.type('html').send(views.blobPage(ctx, filePath, { kind: 'binary', rawUrl, size: buf.length }));
+            return;
+        }
+        if (buf.length > MAX_RENDER_SIZE) {
+            res.type('html').send(views.blobPage(ctx, filePath, { kind: 'too-large', rawUrl, size: buf.length }));
+            return;
+        }
+        const text = buf.toString('utf8');
+        const editable = ctx.canPush && ctx.refIsBranch;
+        const markdown = (0, markdown_1.isMarkdownFile)(filePath);
+        // Markdown renders by default; ?plain=1 asks for the source, as on GitHub.
+        if (markdown && req.query.plain !== '1') {
+            const dir = filePath.includes('/') ? `/${(0, views_1.encPath)(filePath.slice(0, filePath.lastIndexOf('/')))}` : '';
+            const html = (0, markdown_1.renderMarkdown)(text, {
+                rawBase: `${(0, views_1.repoUrl)(ctx)}/raw/${(0, views_1.encPath)(ref)}${dir}`,
+                blobBase: `${(0, views_1.repoUrl)(ctx)}/blob/${(0, views_1.encPath)(ref)}${dir}`,
+                issueBase: `${(0, views_1.repoUrl)(ctx)}/issues`,
+                commitBase: `${(0, views_1.repoUrl)(ctx)}/commit`,
+            });
+            res
+                .type('html')
+                .send(views.blobPage(ctx, filePath, { kind: 'markdown', html, size: buf.length, editable }, true));
+            return;
+        }
+        const html = (0, render_1.highlightCode)(text, filePath);
+        const lineCount = text === '' ? 1 : text.replace(/\n$/, '').split('\n').length;
+        res
+            .type('html')
+            .send(views.blobPage(ctx, filePath, { kind: 'code', html, lineCount, size: buf.length, editable }, markdown));
+    }));
+    // Blame: who last changed each line, and the way back to the revision
+    // before that change. Only for a file we would show as text anyway; the
+    // rest redirect to the blob page, which explains what they are.
+    app.get('/:collection/:repo/blame/*', (0, web_1.ah)(async (req, res) => {
+        const viewer = (0, session_1.getViewer)(req, root);
+        const loaded = await (0, web_1.loadRepo)(root, req, res, viewer);
+        if (!loaded)
+            return;
+        const { ref, path: filePath } = loaded.repo.resolveRefAndPath((0, web_1.wildcard)(req), loaded.refNames);
+        if (!(0, git_1.isValidRefName)(ref) || !(0, git_1.isValidRepoPath)(filePath) || filePath === '') {
+            (0, web_1.send404)(res, 'Not found', viewer);
+            return;
+        }
+        const ctx = await (0, web_1.makeCtx)(root, req, loaded, ref, viewer);
+        const blobUrl = `${(0, views_1.repoUrl)(ctx)}/blob/${(0, views_1.encPath)(ref)}/${(0, views_1.encPath)(filePath)}`;
+        if ((await loaded.repo.entryType(ref, filePath)) !== 'blob') {
+            (0, web_1.send404)(res, `File ${filePath} not found at ${ref}`, viewer);
+            return;
+        }
+        const buf = await loaded.repo.catBlob(ref, filePath);
+        if ((0, render_1.isBinary)(buf) || buf.length > MAX_RENDER_SIZE) {
+            res.redirect(blobUrl);
+            return;
+        }
+        const lines = await loaded.repo.blame(ref, filePath);
+        const text = lines.map((l) => l.text).join('\n');
+        res.type('html').send(views.blamePage(ctx, filePath, (0, render_1.highlightCode)(text, filePath), lines, buf.length));
+    }));
+    app.get('/:collection/:repo/raw/*', (0, web_1.ah)(async (req, res) => {
+        const loaded = await (0, web_1.loadRepo)(root, req, res, (0, session_1.getViewer)(req, root));
+        if (!loaded)
+            return;
+        const { ref, path: filePath } = loaded.repo.resolveRefAndPath((0, web_1.wildcard)(req), loaded.refNames);
+        if (!(0, git_1.isValidRefName)(ref) || !(0, git_1.isValidRepoPath)(filePath) || filePath === '') {
+            (0, web_1.send404)(res);
+            return;
+        }
+        const type = await loaded.repo.entryType(ref, filePath);
+        if (type !== 'blob') {
+            res.status(404).type('text/plain').send('not found');
+            return;
+        }
+        const buf = await loaded.repo.catBlob(ref, filePath);
+        // A pointer blob redirects to the stored object; the filename gives the
+        // browser something better to save than a 64-character object id.
+        const pointer = (0, pointer_1.parsePointer)(buf);
+        if (pointer && lfs) {
+            const info = await lfs.store.head(loaded.repo.collection, loaded.repo.name, pointer.oid);
+            if (!info) {
+                res
+                    .status(404)
+                    .type('text/plain')
+                    .send('This file is stored with Git LFS, but its object is missing from storage (the commits were pushed without pushing the LFS objects).\n');
+                return;
+            }
+            const dl = await lfs.store.signDownload(loaded.repo.collection, loaded.repo.name, pointer.oid, {
+                filename: filePath.split('/').pop(),
+            });
+            res.redirect(302, dl.href);
+            return;
+        }
+        // Reading a public repository is anonymous, so its raw files may be
+        // cached publicly; the question is only for how long. A full commit id
+        // can never come to name different bytes, so under one the answer is
+        // forever. Under a branch or tag it is "until it changes", which HTTP
+        // spells as revalidate every time: the ETag is a hash of the bytes
+        // themselves, so an unchanged file costs a 304 and no body, whichever
+        // commit now holds it. The pointer redirect above returns before this
+        // on purpose: a redirect to a presigned URL expires and must not be
+        // cached. A private repository's bytes were served to one reader and
+        // must never come out of a shared cache for another.
+        const cacheScope = (0, perms_1.repoIsPrivate)(loaded.repo.dir) ? 'private' : 'public';
+        if (/^[0-9a-f]{40}$/.test(ref)) {
+            res.setHeader('Cache-Control', `${cacheScope}, max-age=31536000, immutable`);
+        }
+        else {
+            res.setHeader('Cache-Control', `${cacheScope}, no-cache`);
+            res.setHeader('ETag', `"${crypto.createHash('sha256').update(buf).digest('hex').slice(0, 32)}"`);
+            if (req.fresh) {
+                res.status(304).end();
+                return;
+            }
+        }
+        const ext = (filePath.split('.').pop() ?? '').toLowerCase();
+        // Repository content must never be able to inject HTML into this
+        // origin: non-image types are served as text/plain in a sandbox.
+        res.setHeader('Content-Security-Policy', 'sandbox');
+        res.setHeader('X-Content-Type-Options', 'nosniff');
+        if (exports.IMAGE_TYPES[ext]) {
+            res.type(exports.IMAGE_TYPES[ext]);
+        }
+        else if ((0, render_1.isBinary)(buf)) {
+            res.type('application/octet-stream');
+        }
+        else {
+            res.type('text/plain; charset=utf-8');
+        }
+        res.send(buf);
+    }));
+    // Source downloads, as GitHub's Code button offers them: the extension on
+    // the URL picks the format and the rest of it is the ref.
+    app.get('/:collection/:repo/archive/*', (0, web_1.ah)(async (req, res) => {
+        const viewer = (0, session_1.getViewer)(req, root);
+        const loaded = await (0, web_1.loadRepo)(root, req, res, viewer);
+        if (!loaded)
+            return;
+        const m = (0, web_1.wildcard)(req).match(/^(.+)\.(tar\.gz|tgz|zip)$/);
+        if (!m) {
+            (0, web_1.send404)(res, 'Ask for an archive as <ref>.tar.gz or <ref>.zip', viewer);
+            return;
+        }
+        const [, ref, ext] = m;
+        const spec = ARCHIVE_FORMATS[ext];
+        // A ref this repository has, or a commit id: never an arbitrary
+        // revision expression out of a URL.
+        const known = loaded.refNames.includes(ref) || /^[0-9a-f]{7,40}$/.test(ref);
+        const sha = (0, git_1.isValidRefName)(ref) && known ? await loaded.repo.resolve(ref) : null;
+        if (!sha) {
+            (0, web_1.send404)(res, `Ref ${ref} not found`, viewer);
+            return;
+        }
+        // An archive is a subprocess and a stream, which is exactly what a 304
+        // saves: the commit the ref resolves to determines every byte of the
+        // archive, so it is the validator, checked before a slot is taken or
+        // git is spawned. An archive of a full commit id is immutable outright.
+        const cacheScope = (0, perms_1.repoIsPrivate)(loaded.repo.dir) ? 'private' : 'public';
+        if (ref === sha) {
+            res.setHeader('Cache-Control', `${cacheScope}, max-age=31536000, immutable`);
+        }
+        else {
+            res.setHeader('Cache-Control', `${cacheScope}, no-cache`);
+            res.setHeader('ETag', `"${sha}"`);
+            if (req.fresh) {
+                res.status(304).end();
+                return;
+            }
+        }
+        // The slot is held until the stream ends, which is what the gate is for: an
+        // archive holds a subprocess and a socket for as long as the client cares
+        // to read.
+        const release = await gates.tree.enter();
+        if (!release) {
+            (0, web_1.sendBusy)(res, viewer);
+            return;
+        }
+        res.on('close', release);
+        const stem = `${loaded.repo.name}-${ref.replace(/\//g, '-')}`;
+        res.type(spec.type);
+        res.setHeader('Content-Disposition', `attachment; filename="${stem}.${ext}"`);
+        try {
+            await loaded.repo.archiveTo(ref, spec.format, `${stem}/`, res);
+            res.end();
+        }
+        catch {
+            // The response is already streaming, so there is no status left to
+            // send: break the connection rather than finish a truncated archive.
+            res.destroy();
+        }
+        finally {
+            release();
+        }
+    }));
+    app.get('/:collection/:repo/commits', (req, res) => {
+        res.redirect(`/${encodeURIComponent(req.params.collection)}/${encodeURIComponent(req.params.repo)}`);
+    });
+    app.get('/:collection/:repo/commits/*', (0, web_1.ah)(async (req, res) => {
+        const viewer = (0, session_1.getViewer)(req, root);
+        const loaded = await (0, web_1.loadRepo)(root, req, res, viewer);
+        if (!loaded)
+            return;
+        // A path after the ref narrows the history to that file or directory,
+        // which is what the History button on a blob or tree page asks for.
+        // A .atom suffix asks for the same history as a feed, as on GitHub.
+        const asked = (0, web_1.wildcard)(req);
+        const wantsFeed = asked.endsWith('.atom');
+        const { ref, path: histPath } = loaded.repo.resolveRefAndPath(wantsFeed ? asked.slice(0, -'.atom'.length) : asked, loaded.refNames);
+        if (!(0, git_1.isValidRefName)(ref) || !(0, git_1.isValidRepoPath)(histPath)) {
+            (0, web_1.send404)(res, 'Not found', viewer);
+            return;
+        }
+        const page = Math.max(1, parseInt(String(req.query.page ?? '1'), 10) || 1);
+        // An author narrows it further: this is where a contributor in the
+        // About panel leads, and it is a literal string rather than a pattern.
+        const author = String(req.query.author ?? '').slice(0, 200) || undefined;
+        let total;
+        try {
+            total = await loaded.repo.commitCount(ref, histPath || undefined, author);
+        }
+        catch {
+            (0, web_1.send404)(res, `Ref ${ref} not found`, viewer);
+            return;
+        }
+        const totalPages = Math.max(1, Math.ceil(total / COMMITS_PER_PAGE));
+        const commits = await loaded.repo.log(ref, (page - 1) * COMMITS_PER_PAGE, COMMITS_PER_PAGE, histPath || undefined, author);
+        if (wantsFeed) {
+            const site = `${(0, web_1.baseUrlOf)(req)}/${encodeURIComponent(loaded.repo.collection)}/${encodeURIComponent(loaded.repo.name)}`;
+            const where = `${(0, views_1.encPath)(ref)}${histPath ? `/${(0, views_1.encPath)(histPath)}` : ''}`;
+            res.type('application/atom+xml; charset=utf-8').send((0, atom_1.atomFeed)({
+                id: `${site}/commits/${where}`,
+                title: `${loaded.repo.collection}/${loaded.repo.name}${histPath ? `: ${histPath}` : ''} at ${ref}`,
+                selfLink: `${site}/commits/${where}.atom`,
+                htmlLink: `${site}/commits/${where}`,
+                entries: commits.map((c) => ({
+                    id: `${site}/commit/${c.sha}`,
+                    title: c.subject,
+                    updated: c.date,
+                    link: `${site}/commit/${c.sha}`,
+                    author: c.author,
+                })),
+            }));
+            return;
+        }
+        res
+            .type('html')
+            .send(views.commitsPage(await (0, web_1.makeCtx)(root, req, loaded, ref, viewer), histPath, commits, page, totalPages, total, author));
+    }));
+    app.get('/:collection/:repo/commit/:sha', (0, web_1.ah)(async (req, res) => {
+        const viewer = (0, session_1.getViewer)(req, root);
+        const loaded = await (0, web_1.loadRepo)(root, req, res, viewer);
+        if (!loaded)
+            return;
+        const sha = req.params.sha;
+        if (!/^[0-9a-f]{4,40}$/i.test(sha)) {
+            (0, web_1.send404)(res, 'Not found', viewer);
+            return;
+        }
+        const detail = await loaded.repo.commit(sha);
+        if (!detail) {
+            (0, web_1.send404)(res, `Commit ${sha} not found`, viewer);
+            return;
+        }
+        const patch = await loaded.repo.commitPatch(detail.sha);
+        const ctx = await (0, web_1.makeCtx)(root, req, loaded, loaded.defaultBranch ?? detail.sha, viewer);
+        res
+            .type('html')
+            .send(views.commitPage(ctx, detail, (0, diff_1.renderDiff)(patch, { blobBase: `${(0, views_1.repoUrl)(ctx)}/blob/${detail.sha}` })));
+    }));
+    app.get('/:collection/:repo/branches', (0, web_1.ah)(async (req, res) => {
+        const viewer = (0, session_1.getViewer)(req, root);
+        const loaded = await (0, web_1.loadRepo)(root, req, res, viewer);
+        if (!loaded)
+            return;
+        const ctx = await (0, web_1.makeCtx)(root, req, loaded, loaded.defaultBranch ?? '', viewer);
+        res.type('html').send(views.refListPage(ctx, 'branches'));
+    }));
+    app.get('/:collection/:repo/tags', (0, web_1.ah)(async (req, res) => {
+        const viewer = (0, session_1.getViewer)(req, root);
+        const loaded = await (0, web_1.loadRepo)(root, req, res, viewer);
+        if (!loaded)
+            return;
+        const ctx = await (0, web_1.makeCtx)(root, req, loaded, loaded.defaultBranch ?? '', viewer);
+        res.type('html').send(views.refListPage(ctx, 'tags'));
+    }));
+    // Sites are served through src/site.ts, which both this route and the
+    // per-site hostname share. The mode is what differs: on the forge's own
+    // origin a site is sandboxed, because its script would otherwise run as the
+    // visitor.
+    //
+    // When the vault has a sites host and this repository is eligible for one,
+    // the site lives at its own origin and this path only points there. 302 and
+    // not 301: a permanent redirect would be cached hard, and removing
+    // sites.host from config.json must take effect on the next request.
+    app.get('/:collection/:repo/site/*', (req, res) => {
+        const origin = (0, site_1.siteHostUrl)(root, req, req.params.collection, (0, scan_1.displayName)(req.params.repo));
+        if (origin) {
+            const query = req.originalUrl.includes('?') ? req.originalUrl.slice(req.originalUrl.indexOf('?')) : '';
+            res.redirect(302, `${origin}/${(0, web_1.wildcard)(req)}${query}`);
+            return;
+        }
+        (0, site_1.serveSite)(root, req.params.collection, req.params.repo, req, res, 'sandbox');
+    });
+    // The missing-slash redirect lands on the site origin in one hop rather than
+    // two when there is one.
+    app.get('/:collection/:repo/site', (req, res) => {
+        const origin = (0, site_1.siteHostUrl)(root, req, req.params.collection, (0, scan_1.displayName)(req.params.repo));
+        if (origin) {
+            res.redirect(302, `${origin}/`);
+            return;
+        }
+        res.redirect(`/${encodeURIComponent(req.params.collection)}/${encodeURIComponent((0, scan_1.displayName)(req.params.repo))}/site/`);
+    });
+}

package/dist/build-info.json

@@ -0,0 +1,4 @@
+{
+  "commit": "7b95ca5-dirty",
+  "builtAt": "2026-08-21T14:34:24.115Z"
+}