@magland/mochi 0.3.1

package/dist/issueweb.js

@@ -0,0 +1,447 @@
+"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.registerIssues = registerIssues;
+const crypto = __importStar(require("crypto"));
+const avatar_1 = require("./avatar");
+const icons_1 = require("./icons");
+const issues = __importStar(require("./issues"));
+const html_1 = require("./html");
+const markdown_1 = require("./markdown");
+const ops_1 = require("./ops");
+const render_1 = require("./render");
+const session_1 = require("./session");
+const views_1 = require("./views");
+const web_1 = require("./web");
+// The issue pages, over the store in issues.ts.
+//
+// Who may do what follows the vault's model rather than GitHub's: reading is
+// anonymous like every other read, opening an issue and commenting need a
+// session (a vault's users are its users; there is no public sign-up to
+// abuse), and closing, reopening, or editing needs the write role on the
+// repository or being the person who wrote the thing.
+// Issue bodies and comments are the long fields here, and people paste logs
+// into them.
+const form = (0, web_1.urlencodedForm)('3mb');
+function issuesUrl(ctx) {
+    return `${(0, views_1.repoUrl)(ctx)}/issues`;
+}
+/** Issue bodies are markdown, rendered by the same sanitizing pipeline as a
+ * README: this is text one user writes and another reads. Relative links
+ * resolve against the default branch, since an issue has no file of its own. */
+function body(ctx, text) {
+    const base = (0, views_1.repoUrl)(ctx);
+    const ref = (0, views_1.encPath)(ctx.defaultBranch || ctx.ref || 'HEAD');
+    return (0, html_1.raw)((0, markdown_1.renderMarkdown)(text, {
+        rawBase: `${base}/raw/${ref}`,
+        blobBase: `${base}/blob/${ref}`,
+        issueBase: `${base}/issues`,
+        commitBase: `${base}/commit`,
+    }));
+}
+function stateBadge(state) {
+    return state === 'open'
+        ? (0, html_1.html) `<span class="state-badge open">${(0, icons_1.icon)('issue-opened')}<span>Open</span></span>`
+        : (0, html_1.html) `<span class="state-badge closed">${(0, icons_1.icon)('issue-closed')}<span>Closed</span></span>`;
+}
+/** The same filter with one field changed, as a query string. */
+function filterUrl(base, filter, change) {
+    const next = { ...filter, ...change };
+    const params = new URLSearchParams();
+    if (next.state !== 'open')
+        params.set('state', next.state);
+    if (next.label)
+        params.set('label', next.label);
+    if (next.author)
+        params.set('author', next.author);
+    if (next.query)
+        params.set('q', next.query);
+    if (next.sort !== 'newest')
+        params.set('sort', next.sort);
+    const q = params.toString();
+    return q === '' ? base : `${base}?${q}`;
+}
+/**
+ * A label's colour is derived from its name, the way an identicon is: a vault
+ * keeps no label registry, so the set of labels is whatever the issues carry,
+ * and a colour that comes from the name is stable without one being stored.
+ */
+function labelStyle(label) {
+    const hash = crypto.createHash('sha256').update(label.trim().toLowerCase()).digest();
+    return `background: hsl(${Math.round((hash[0] / 256) * 360)} 58% 46%); color: #fff;`;
+}
+function labelChips(labels, base, filter) {
+    return (0, html_1.joinHtml)(labels.map((l) => base && filter
+        ? (0, html_1.html) `<a class="chip label" style="${(0, html_1.raw)(labelStyle(l))}" href="${filterUrl(base, filter, {
+            label: l,
+        })}">${l}</a>`
+        : (0, html_1.html) `<span class="chip label" style="${(0, html_1.raw)(labelStyle(l))}">${l}</span>`));
+}
+function listPage(ctx, list, filter, counts, labels, authors) {
+    const base = issuesUrl(ctx);
+    const tab = (id, label, n, glyph) => (0, html_1.html) `<a class="state-tab${filter.state === id ? ' current' : ''}" href="${filterUrl(base, filter, {
+        state: id,
+    })}">${(0, icons_1.icon)(glyph)}<span>${n} ${label}</span></a>`;
+    const rows = list.map((i) => (0, html_1.html) `<tr>
+<td class="issue-cell">${(0, icons_1.icon)(i.state === 'open' ? 'issue-opened' : 'issue-closed', i.state === 'open' ? 'issue-open' : 'issue-closed')}<span>
+<a class="issue-link" href="${base}/${i.number}">${i.title}</a>${labelChips(i.labels, base, filter)}
+<div class="muted small">#${i.number} opened ${(0, render_1.timeTag)(i.created)} by ${i.author}${i.state === 'closed' && i.closedAt ? (0, html_1.html) ` &middot; closed ${(0, render_1.timeTag)(i.closedAt)}` : ''}</div></span></td>
+<td class="right muted small">${i.comments > 0
+        ? (0, html_1.html) `<a class="issue-comments" href="${base}/${i.number}" title="${i.comments} comment${i.comments === 1 ? '' : 's'}">${(0, icons_1.icon)('comment')}<span>${i.comments}</span></a>`
+        : ''}</td>
+</tr>`);
+    const newBtn = ctx.viewer
+        ? (0, html_1.html) `<a class="btn btn-primary" href="${base}/new">${(0, icons_1.icon)('plus')}<span>New issue</span></a>`
+        : (0, html_1.html) `<a class="btn" href="/login?next=${encodeURIComponent(`${base}/new`)}">${(0, icons_1.icon)('plus')}<span>New issue</span></a>`;
+    // The three menus and the search box. Each menu is a list of links carrying
+    // the rest of the filter, so narrowing never loses what was already chosen
+    // and nothing here needs script.
+    const menu = (label, current, glyph, items) => (0, html_1.html) `<details class="dropdown">
+<summary class="btn">${(0, icons_1.icon)(glyph)}<span>${current || label}</span>${(0, icons_1.icon)('chevron-down', 'caret')}</summary>
+<div class="dropdown-menu"><div class="dd-scroll">${items}</div></div>
+</details>`;
+    const labelMenu = menu('Labels', filter.label, 'tag', [
+        (0, html_1.html) `<a class="dd-item${filter.label === '' ? ' current' : ''}" href="${filterUrl(base, filter, {
+            label: '',
+        })}"><span class="dd-check"></span><span class="dd-label">Any label</span></a>`,
+        ...labels.map((l) => (0, html_1.html) `<a class="dd-item${filter.label === l.label ? ' current' : ''}" href="${filterUrl(base, filter, {
+            label: l.label,
+        })}">${filter.label === l.label ? (0, icons_1.icon)('check', 'dd-check') : (0, html_1.raw)('<span class="dd-check"></span>')}<span class="dd-label">${l.label}</span><span class="muted small">${l.count}</span></a>`),
+    ]);
+    const authorMenu = menu('Author', filter.author, 'person', [
+        (0, html_1.html) `<a class="dd-item${filter.author === '' ? ' current' : ''}" href="${filterUrl(base, filter, {
+            author: '',
+        })}"><span class="dd-check"></span><span class="dd-label">Anyone</span></a>`,
+        ...authors.map((a) => (0, html_1.html) `<a class="dd-item${filter.author === a.author ? ' current' : ''}" href="${filterUrl(base, filter, {
+            author: a.author,
+        })}">${filter.author === a.author ? (0, icons_1.icon)('check', 'dd-check') : (0, html_1.raw)('<span class="dd-check"></span>')}<span class="dd-label">${a.author}</span><span class="muted small">${a.count}</span></a>`),
+    ]);
+    const sortMenu = menu('Sort', issues.ISSUE_SORTS.find((x) => x.key === filter.sort)?.label ?? 'Newest', 'filter', issues.ISSUE_SORTS.map((x) => (0, html_1.html) `<a class="dd-item${filter.sort === x.key ? ' current' : ''}" href="${filterUrl(base, filter, {
+        sort: x.key,
+    })}">${filter.sort === x.key ? (0, icons_1.icon)('check', 'dd-check') : (0, html_1.raw)('<span class="dd-check"></span>')}<span class="dd-label">${x.label}</span></a>`));
+    const hidden = [
+        filter.state === 'open' ? '' : (0, html_1.html) `<input type="hidden" name="state" value="${filter.state}">`,
+        filter.label === '' ? '' : (0, html_1.html) `<input type="hidden" name="label" value="${filter.label}">`,
+        filter.author === '' ? '' : (0, html_1.html) `<input type="hidden" name="author" value="${filter.author}">`,
+        filter.sort === 'newest' ? '' : (0, html_1.html) `<input type="hidden" name="sort" value="${filter.sort}">`,
+    ];
+    const search = (0, html_1.html) `<form class="issue-search" method="get" action="${base}" role="search">${hidden}
+<input class="search-input" type="search" name="q" value="${filter.query}" placeholder="Search issues" aria-label="Search issues">${(0, icons_1.icon)('search', 'search-glyph')}</form>`;
+    const narrowed = filter.label !== '' || filter.author !== '' || filter.query !== '';
+    const clear = narrowed
+        ? (0, html_1.html) `<a class="btn" href="${filterUrl(base, filter, { label: '', author: '', query: '' })}">${(0, icons_1.icon)('x')}<span>Clear</span></a>`
+        : '';
+    const empty = narrowed
+        ? 'No issues match that.'
+        : filter.state === 'closed'
+            ? 'No closed issues.'
+            : filter.state === 'open'
+                ? 'No open issues. Anything that needs doing here can be written down.'
+                : 'No issues yet.';
+    const content = (0, html_1.html) `${(0, views_1.repoHeader)(ctx, 'issues')}
+<div class="page-head">
+  <span class="state-filter">${tab('open', 'Open', counts.open, 'issue-opened')}${tab('closed', 'Closed', counts.closed, 'issue-closed')}</span>
+  ${newBtn}
+</div>
+<div class="issue-filters">${search}<span class="right-group">${labelMenu}${authorMenu}${sortMenu}${clear}</span></div>
+${rows.length
+        ? (0, html_1.html) `<table class="listing issues"><tbody>${rows}</tbody></table>`
+        : (0, html_1.html) `<div class="empty-state">${empty}</div>`}`;
+    return (0, views_1.layout)(`Issues - ${ctx.collection}/${ctx.repo}`, content, (0, views_1.repoOpts)(ctx, filterUrl(base, filter, {})));
+}
+function commentCard(author, when, rendered, note = '') {
+    return (0, html_1.html) `<article class="issue-comment">
+<div class="issue-comment-head">${(0, avatar_1.avatar)(author, 24)}<b>${author}</b><span class="muted small">${note || 'commented'} ${(0, render_1.timeTag)(when)}</span></div>
+<div class="issue-comment-body markdown-body">${rendered}</div>
+</article>`;
+}
+function issuePage(ctx, issue, canWrite) {
+    const base = issuesUrl(ctx);
+    const viewer = ctx.viewer;
+    const mine = viewer !== null && viewer.auth.username === issue.author;
+    const canClose = canWrite || mine;
+    const comments = issue.commentList.map((c) => commentCard(c.author, c.created, body(ctx, c.body)));
+    const closedNote = issue.state === 'closed' && issue.closedAt
+        ? (0, html_1.html) `<div class="issue-event">${(0, icons_1.icon)('issue-closed', 'issue-closed')}<span><b>${issue.closedBy ?? 'someone'}</b> closed this ${(0, render_1.timeTag)(issue.closedAt)}</span></div>`
+        : '';
+    let replyBox;
+    if (viewer) {
+        const toggle = canClose
+            ? (0, html_1.html) `<button class="btn" type="submit" name="state" value="${issue.state === 'open' ? 'closed' : 'open'}" formaction="${base}/${issue.number}/state">${(0, icons_1.icon)(issue.state === 'open' ? 'issue-closed' : 'issue-opened')}<span>${issue.state === 'open' ? 'Close issue' : 'Reopen issue'}</span></button>`
+            : '';
+        replyBox = (0, html_1.html) `<form class="issue-reply" method="post" action="${base}/${issue.number}/comment">${(0, views_1.csrfField)(viewer)}
+<div class="issue-comment-head">${(0, avatar_1.avatar)(viewer.auth.username, 24)}<b>${viewer.auth.username}</b></div>
+<textarea class="code-editor" name="body" rows="6" placeholder="Leave a comment"></textarea>
+<div class="actions">${toggle}<button class="btn btn-primary" type="submit">Comment</button></div>
+</form>`;
+    }
+    else {
+        replyBox = (0, html_1.html) `<p class="muted"><a href="/login?next=${encodeURIComponent(`${base}/${issue.number}`)}">Sign in</a> to comment.</p>`;
+    }
+    const edit = canClose
+        ? (0, html_1.html) `<a class="btn" href="${base}/${issue.number}/edit">${(0, icons_1.icon)('pencil')}<span>Edit</span></a>`
+        : '';
+    const description = body(ctx, issue.body);
+    const content = (0, html_1.html) `${(0, views_1.repoHeader)(ctx, 'issues')}
+<div class="issue-head">
+  <h1 class="issue-title">${issue.title} <span class="muted">#${issue.number}</span></h1>
+  <span class="right-group">${edit}<a class="btn" href="${base}">Back to issues</a></span>
+</div>
+<div class="issue-sub">${stateBadge(issue.state)}<span class="muted"><b>${issue.author}</b> opened this ${(0, render_1.timeTag)(issue.created)} &middot; ${issue.commentList.length} comment${issue.commentList.length === 1 ? '' : 's'}</span>${labelChips(issue.labels)}</div>
+<div class="issue-thread">
+${commentCard(issue.author, issue.created, description.text ? description : (0, html_1.raw)('<p class="muted">No description.</p>'), 'opened this')}
+${comments}
+${closedNote}
+${replyBox}
+</div>`;
+    return (0, views_1.layout)(`${issue.title} · #${issue.number} - ${ctx.collection}/${ctx.repo}`, content, (0, views_1.repoOpts)(ctx, `${base}/${issue.number}`));
+}
+function editPage(ctx, viewer, mode, values, error) {
+    const base = issuesUrl(ctx);
+    const action = mode === 'new' ? `${base}/new` : `${base}/${values.number}/edit`;
+    const content = (0, html_1.html) `${(0, views_1.repoHeader)(ctx, 'issues')}
+<div class="form-box wide">
+<h1>${mode === 'new' ? 'New issue' : `Edit issue #${values.number}`}</h1>
+${error ? (0, html_1.html) `<div class="form-error">${error}</div>` : ''}
+<form method="post" action="${action}">${(0, views_1.csrfField)(viewer)}
+<div class="field"><label for="title">Title</label>
+<input type="text" id="title" name="title" value="${values.title}" maxlength="${issues.MAX_TITLE}" required autofocus></div>
+<div class="field"><label for="body">Description</label>
+<textarea class="code-editor" id="body" name="body" rows="12" placeholder="Markdown is welcome">${values.body}</textarea></div>
+${ctx.canPush
+        ? (0, html_1.html) `<div class="field"><label for="labels">Labels</label>
+<input type="text" id="labels" name="labels" value="${values.labels.join(', ')}" placeholder="bug, ui">
+<p class="muted small">Separated by commas. Labels are for people with push access.</p></div>`
+        : ''}
+<div class="actions"><button class="btn btn-primary" type="submit">${mode === 'new' ? 'Open issue' : 'Save changes'}</button><a class="btn" href="${mode === 'new' ? base : `${base}/${values.number}`}">Cancel</a></div>
+</form>
+</div>`;
+    return (0, views_1.layout)(mode === 'new' ? `New issue - ${ctx.collection}/${ctx.repo}` : `Edit #${values.number}`, content, (0, views_1.repoOpts)(ctx, action));
+}
+function registerIssues(app, root) {
+    /** The repository context plus the issue named in the URL. */
+    async function withIssue(req, res, viewer) {
+        const loaded = await (0, web_1.loadRepo)(root, req, res, viewer);
+        if (!loaded)
+            return null;
+        const ctx = await (0, web_1.makeCtx)(root, req, loaded, loaded.defaultBranch ?? '', viewer);
+        const n = parseInt(req.params.n ?? '', 10);
+        if (!/^[1-9][0-9]*$/.test(req.params.n ?? '')) {
+            (0, web_1.send404)(res, 'No such issue', viewer);
+            return null;
+        }
+        const issue = issues.readIssue(root, ctx.collection, ctx.repo, n);
+        if (!issue) {
+            (0, web_1.send404)(res, `Issue #${n} does not exist in ${ctx.collection}/${ctx.repo}`, viewer);
+            return null;
+        }
+        return { ctx, issue, n };
+    }
+    app.get('/:collection/:repo/issues', (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);
+        const asked = String(req.query.state ?? 'open');
+        const sortAsked = String(req.query.sort ?? 'newest');
+        const filter = {
+            state: asked === 'closed' ? 'closed' : asked === 'all' ? 'all' : 'open',
+            label: String(req.query.label ?? '').slice(0, 60),
+            author: String(req.query.author ?? '').slice(0, 60),
+            // A query is a reader's typing and becomes a substring match, not a
+            // pattern, so its only bound is a sane length.
+            query: String(req.query.q ?? '').slice(0, 200),
+            sort: (issues.ISSUE_SORTS.find((x) => x.key === sortAsked)?.key ?? 'newest'),
+        };
+        // Counts on the state tabs are of the whole repository, as GitHub's are,
+        // so they do not move as the other filters narrow the list.
+        const { all, matched } = issues.listIssuesAndMatches(root, ctx.collection, ctx.repo, filter.query);
+        const counts = {
+            open: all.filter((i) => i.state === 'open').length,
+            closed: all.filter((i) => i.state === 'closed').length,
+        };
+        const list = issues.selectIssues(matched, filter);
+        res
+            .type('html')
+            .send(listPage(ctx, list, filter, counts, issues.labelsInUse(all), issues.authorsInUse(all)));
+    }));
+    app.get('/:collection/:repo/issues/new', (0, web_1.ah)(async (req, res) => {
+        const viewer = (0, web_1.requireViewerPage)(root, req, res);
+        if (!viewer)
+            return;
+        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(editPage(ctx, viewer, 'new', { title: '', body: '', labels: [] }));
+    }));
+    app.post('/:collection/:repo/issues/new', form, (0, web_1.ah)(async (req, res) => {
+        const viewer = (0, web_1.requireViewerPost)(root, req, res);
+        if (!viewer)
+            return;
+        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);
+        const title = (0, web_1.field)(req, 'title');
+        const text = (0, web_1.field)(req, 'body');
+        // Labels are a push-scope decision, so a form that carries them from
+        // someone without it is simply read without them.
+        const labels = ctx.canPush ? (0, web_1.field)(req, 'labels').split(',') : [];
+        try {
+            const created = issues.createIssue(root, ctx.collection, ctx.repo, {
+                title,
+                body: text,
+                author: viewer.auth.username,
+                labels,
+            });
+            res.redirect(`${issuesUrl(ctx)}/${created.number}`);
+        }
+        catch (e) {
+            const message = e instanceof ops_1.OpError ? e.message : 'Could not open the issue.';
+            res
+                .status(400)
+                .type('html')
+                .send(editPage(ctx, viewer, 'new', { title, body: text, labels: labels.map((l) => l.trim()).filter(Boolean) }, message));
+        }
+    }));
+    app.get('/:collection/:repo/issues/:n', (0, web_1.ah)(async (req, res) => {
+        const viewer = (0, session_1.getViewer)(req, root);
+        const found = await withIssue(req, res, viewer);
+        if (!found)
+            return;
+        res.type('html').send(issuePage(found.ctx, found.issue, found.ctx.canPush));
+    }));
+    app.get('/:collection/:repo/issues/:n/edit', (0, web_1.ah)(async (req, res) => {
+        const viewer = (0, web_1.requireViewerPage)(root, req, res);
+        if (!viewer)
+            return;
+        const found = await withIssue(req, res, viewer);
+        if (!found)
+            return;
+        const { ctx, issue } = found;
+        if (!ctx.canPush && viewer.auth.username !== issue.author) {
+            (0, web_1.fail)(res, 403, 'Only the author or someone with push access can edit this issue.', viewer, `${issuesUrl(ctx)}/${issue.number}`);
+            return;
+        }
+        res
+            .type('html')
+            .send(editPage(ctx, viewer, 'edit', { number: issue.number, title: issue.title, body: issue.body, labels: issue.labels }));
+    }));
+    app.post('/:collection/:repo/issues/:n/edit', form, (0, web_1.ah)(async (req, res) => {
+        const viewer = (0, web_1.requireViewerPost)(root, req, res);
+        if (!viewer)
+            return;
+        const found = await withIssue(req, res, viewer);
+        if (!found)
+            return;
+        const { ctx, issue } = found;
+        if (!ctx.canPush && viewer.auth.username !== issue.author) {
+            (0, web_1.fail)(res, 403, 'Only the author or someone with push access can edit this issue.', viewer, `${issuesUrl(ctx)}/${issue.number}`);
+            return;
+        }
+        const title = (0, web_1.field)(req, 'title');
+        const text = (0, web_1.field)(req, 'body');
+        try {
+            issues.editIssue(root, ctx.collection, ctx.repo, issue.number, {
+                title,
+                body: text,
+                labels: ctx.canPush ? (0, web_1.field)(req, 'labels').split(',') : undefined,
+            });
+            res.redirect(`${issuesUrl(ctx)}/${issue.number}`);
+        }
+        catch (e) {
+            const message = e instanceof ops_1.OpError ? e.message : 'Could not save the issue.';
+            res
+                .status(400)
+                .type('html')
+                .send(editPage(ctx, viewer, 'edit', { number: issue.number, title, body: text, labels: issue.labels }, message));
+        }
+    }));
+    app.post('/:collection/:repo/issues/:n/comment', form, (0, web_1.ah)(async (req, res) => {
+        const viewer = (0, web_1.requireViewerPost)(root, req, res);
+        if (!viewer)
+            return;
+        const found = await withIssue(req, res, viewer);
+        if (!found)
+            return;
+        const { ctx, issue } = found;
+        try {
+            issues.addComment(root, ctx.collection, ctx.repo, issue.number, {
+                author: viewer.auth.username,
+                body: (0, web_1.field)(req, 'body'),
+            });
+        }
+        catch (e) {
+            const message = e instanceof ops_1.OpError ? e.message : 'Could not add the comment.';
+            (0, web_1.fail)(res, 400, message, viewer, `${issuesUrl(ctx)}/${issue.number}`);
+            return;
+        }
+        res.redirect(`${issuesUrl(ctx)}/${issue.number}`);
+    }));
+    app.post('/:collection/:repo/issues/:n/state', form, (0, web_1.ah)(async (req, res) => {
+        const viewer = (0, web_1.requireViewerPost)(root, req, res);
+        if (!viewer)
+            return;
+        const found = await withIssue(req, res, viewer);
+        if (!found)
+            return;
+        const { ctx, issue } = found;
+        if (!ctx.canPush && viewer.auth.username !== issue.author) {
+            (0, web_1.fail)(res, 403, 'Only the author or someone with push access can close this issue.', viewer, `${issuesUrl(ctx)}/${issue.number}`);
+            return;
+        }
+        const state = (0, web_1.field)(req, 'state') === 'closed' ? 'closed' : 'open';
+        // A comment posted with the button is kept, so "close with a comment"
+        // is one action rather than two.
+        const text = (0, web_1.field)(req, 'body').trim();
+        if (text !== '') {
+            try {
+                issues.addComment(root, ctx.collection, ctx.repo, issue.number, { author: viewer.auth.username, body: text });
+            }
+            catch (e) {
+                // A comment too long to store must not stop the state change, which
+                // is the reason this is swallowed rather than reported. Only the
+                // validation failures are: a disk that is full or a directory that
+                // cannot be written is not something to close an issue quietly over.
+                if (!(e instanceof ops_1.OpError))
+                    throw e;
+            }
+        }
+        issues.setIssueState(root, ctx.collection, ctx.repo, issue.number, state, viewer.auth.username);
+        res.redirect(`${issuesUrl(ctx)}/${issue.number}`);
+    }));
+}

package/dist/job-cli.js

@@ -0,0 +1,197 @@
+"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.chooseEngine = chooseEngine;
+exports.jobRunCmd = jobRunCmd;
+const readline = __importStar(require("readline"));
+const docker_1 = require("./runner/docker");
+const manual_run_1 = require("./runner/manual-run");
+function parseArgs(args, usage) {
+    const out = {
+        url: null,
+        token: null,
+        job: null,
+        yes: false,
+        engine: null,
+        images: {},
+        workDir: null,
+        network: null,
+        cacheDir: null,
+        actionsUrl: null,
+        actionCache: true,
+    };
+    for (let i = 0; i < args.length; i++) {
+        const a = args[i];
+        if (a === '-h' || a === '--help')
+            usage();
+        else if (a === '--job')
+            out.job = args[++i] ?? null;
+        else if (a === '--yes' || a === '-y')
+            out.yes = 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') {
+            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 === '--work-dir')
+            out.workDir = args[++i] ?? null;
+        else if (a === '--network')
+            out.network = args[++i] ?? null;
+        else if (a === '--cache-dir')
+            out.cacheDir = args[++i] ?? null;
+        else if (a === '--actions-url')
+            out.actionsUrl = args[++i] ?? null;
+        else if (a === '--no-action-cache')
+            out.actionCache = false;
+        else if (a.startsWith('-')) {
+            console.error(`Unknown option: ${a}`);
+            process.exit(1);
+        }
+        else if (!out.url)
+            out.url = a;
+        else if (!out.token)
+            out.token = a;
+        else {
+            console.error(`Unexpected argument: ${a}`);
+            process.exit(1);
+        }
+    }
+    return out;
+}
+function ask(question) {
+    return new Promise((resolve) => {
+        const rl = readline.createInterface({ input: process.stdin, output: process.stdout });
+        // A closed stdin (Ctrl-D, or the terminal going away) answers nothing,
+        // and nothing must never read as consent. The flag matters: rl.close()
+        // below emits 'close' synchronously, and without it the empty answer
+        // would win the race against the real one.
+        let answered = false;
+        rl.on('close', () => {
+            if (!answered)
+                resolve('');
+        });
+        rl.question(question, (answer) => {
+            answered = true;
+            rl.close();
+            resolve(answer);
+        });
+    });
+}
+/**
+ * Which container engine to use: the flag if given, whatever is present if
+ * only one is, and a question with docker as the default when both are. The
+ * probe demands a working daemon, not just a binary on the path, since a
+ * docker command with nothing behind it runs nothing.
+ */
+async function chooseEngine(flag, interactive) {
+    if (flag) {
+        const v = await (0, docker_1.probeEngine)(flag);
+        if (!v) {
+            console.error(`--engine ${flag}: ${flag} is not available here, or its daemon is not running.`);
+            process.exit(1);
+        }
+        return flag;
+    }
+    const [docker, podman] = await Promise.all([(0, docker_1.probeEngine)('docker'), (0, docker_1.probeEngine)('podman')]);
+    if (docker && !podman)
+        return 'docker';
+    if (podman && !docker) {
+        console.log(`Using podman ${podman} (no working docker here).`);
+        return 'podman';
+    }
+    if (!docker && !podman) {
+        console.error('Neither docker nor podman works here. Jobs run in containers, so one of the two is needed.');
+        process.exit(1);
+    }
+    if (!interactive)
+        return 'docker';
+    const answer = (await ask(`Both docker (${docker}) and podman (${podman}) work here. Use which? [docker] `)).trim().toLowerCase();
+    if (answer === '' || answer === 'docker' || answer === 'd')
+        return 'docker';
+    if (answer === 'podman' || answer === 'p')
+        return 'podman';
+    console.error(`That is neither; pass --engine docker or --engine podman.`);
+    process.exit(1);
+}
+async function jobRunCmd(args, usage) {
+    const a = parseArgs(args, usage);
+    if (!a.url || !a.token) {
+        console.error('Usage: mochi job run <vault-url> <token>   (both come from the run page, minted together)');
+        process.exit(1);
+    }
+    const interactive = process.stdin.isTTY === true && process.stdout.isTTY === true;
+    if (!a.yes && !interactive) {
+        console.error('There is no terminal to confirm the steps on. Pass --yes to run without confirmation, knowing that this executes whatever the workflow contains.');
+        process.exit(1);
+    }
+    const engine = await chooseEngine(a.engine, interactive);
+    (0, docker_1.setContainerEngine)(engine);
+    const session = new manual_run_1.ManualSession({
+        host: a.url.replace(/\/+$/, ''),
+        token: a.token,
+        jobFilter: a.job,
+        yes: a.yes,
+        images: a.images,
+        workDir: a.workDir ?? undefined,
+        network: a.network ?? undefined,
+        cacheDir: a.cacheDir ?? undefined,
+        actionsUrl: a.actionsUrl ?? undefined,
+        actionCache: a.actionCache,
+        confirm: async (q) => {
+            const answer = (await ask(q)).trim().toLowerCase();
+            return answer === 'y' || answer === 'yes';
+        },
+    });
+    const stop = () => {
+        console.log('\nStopping after the current job. Press Ctrl-C again to quit now, which fails a job in progress.');
+        session.stop();
+        process.once('SIGINT', () => process.exit(130));
+    };
+    process.once('SIGINT', stop);
+    process.once('SIGTERM', stop);
+    process.exit(await session.run());
+}