@magland/mochi 0.3.1 → 0.4.1

package/dist/api/repos.js

@@ -38,7 +38,11 @@ const fs = __importStar(require("fs"));
 const path = __importStar(require("path"));
 const layout_1 = require("../layout");
 const perms_1 = require("../perms");
+const domains_1 = require("../domains");
 const scan_1 = require("../scan");
+const sitesettings_1 = require("../sitesettings");
+const site_1 = require("../site");
+const topics_1 = require("../topics");
 const issues_1 = require("../issues");
 const pulls_1 = require("../pulls");
 const releases_1 = require("../releases");
@@ -50,20 +54,48 @@ function summarize(root, collection, dirName) {
         collection,
         name,
         description: (0, scan_1.repoDescription)(dir) ?? '',
+        topics: (0, topics_1.repoTopics)(dir),
         forkedFrom: (0, scan_1.forkParent)(dir),
-        hasSite: (0, scan_1.siteDir)(root, collection, name) !== null,
+        upstream: (0, scan_1.upstreamOf)(dir)?.url ?? null,
+        // Published, not merely present: files on disk with the site disabled are
+        // not a site, here as everywhere the interface asks.
+        hasSite: (0, sitesettings_1.siteSettings)(dir).enabled && (0, scan_1.siteDir)(root, collection, name) !== null,
         private: (0, perms_1.repoIsPrivate)(dir),
     };
 }
+/**
+ * The site block a repository's API responses carry: the settings, and the URL
+ * the site is (or would be) served at, which only the vault knows.
+ */
+function siteInfo(root, req, repo) {
+    const settings = (0, sitesettings_1.siteSettings)(repo.dir);
+    const origin = (0, site_1.siteHostUrl)(root, req, repo.collection, repo.name);
+    return {
+        enabled: settings.enabled,
+        source: settings.source,
+        path: settings.path,
+        label: settings.label === '' ? null : settings.label,
+        domain: (0, domains_1.repoDomain)(root, repo.collection, repo.name),
+        url: origin
+            ? `${origin}/`
+            : `/${encodeURIComponent(repo.collection)}/${encodeURIComponent(repo.name)}/site/`,
+    };
+}
 function registerRepoApi(app, root, limiter) {
     // Every repository in the vault, flat. A vault's collections are small and
     // this is read off disk per request, so there is no pagination: --limit and
     // the server-side caps are enough, and a cursor protocol would be machinery
-    // with nothing to carry.
+    // with nothing to carry. ?topic= narrows the list to repositories carrying
+    // that topic, which is the one cross-repository query topics exist for.
     app.get('/api/repos', (req, res) => {
         const auth = (0, auth_1.requireApiAuth)(root, limiter, req, res);
         if (!auth)
             return;
+        const topic = typeof req.query.topic === 'string' ? req.query.topic : '';
+        if (topic !== '' && !(0, topics_1.isValidTopic)(topic)) {
+            (0, auth_1.apiError)(res, 400, 'a topic is lowercase letters, digits, and hyphens, starting with a letter or digit');
+            return;
+        }
         const repos = [];
         for (const c of (0, scan_1.listCollections)(root)) {
             for (const dirName of (0, scan_1.listRepoDirs)(root, c.name)) {
@@ -72,11 +104,30 @@ function registerRepoApi(app, root, limiter) {
                 // same way its page 404s.
                 if ((0, perms_1.repoRole)(root, auth, { collection: c.name, name: (0, scan_1.displayName)(dirName), dir }) === null)
                     continue;
+                if (topic !== '' && !(0, topics_1.repoTopics)(dir).includes(topic))
+                    continue;
                 repos.push(summarize(root, c.name, dirName));
             }
         }
         res.json({ repos });
     });
+    // Every topic in use, with how many repositories carry each: only what the
+    // caller could see listed anyway, counted rather than repeated.
+    app.get('/api/topics', (req, res) => {
+        const auth = (0, auth_1.requireApiAuth)(root, limiter, req, res);
+        if (!auth)
+            return;
+        const lists = [];
+        for (const c of (0, scan_1.listCollections)(root)) {
+            for (const dirName of (0, scan_1.listRepoDirs)(root, c.name)) {
+                const dir = (0, layout_1.repoPath)(root, c.name, dirName);
+                if ((0, perms_1.repoRole)(root, auth, { collection: c.name, name: (0, scan_1.displayName)(dirName), dir }) === null)
+                    continue;
+                lists.push((0, topics_1.repoTopics)(dir));
+            }
+        }
+        res.json({ topics: (0, topics_1.countTopics)(lists) });
+    });
     app.get('/api/repos/:collection/:repo', async (req, res) => {
         const found = (0, auth_1.requireRepo)(root, limiter, req, res);
         if (!found)
@@ -98,6 +149,7 @@ function registerRepoApi(app, root, limiter) {
             closedIssues: issues.closed,
             openPulls: pulls.open,
             closedPulls: pulls.closed,
+            site: siteInfo(root, req, repo),
             // What this token may do here, so that a caller need not discover it by
             // being refused.
             role,
@@ -124,9 +176,13 @@ function registerRepoApi(app, root, limiter) {
         const found = (0, auth_1.requireRepo)(root, limiter, req, res);
         if (!found)
             return;
+        const info = siteInfo(root, req, found.repo);
         const dir = (0, scan_1.siteDir)(root, found.repo.collection, found.repo.name);
+        // `exists` says whether the site is being served, which takes both the
+        // switch and the files; the settings are reported either way, and so is
+        // what is on disk, since a disabled site keeps its directory.
         if (!dir) {
-            res.json({ exists: false });
+            res.json({ ...info, exists: false });
             return;
         }
         let entries = 0;
@@ -146,7 +202,7 @@ function registerRepoApi(app, root, limiter) {
         catch {
             // An unreadable site directory reports what it can rather than failing.
         }
-        res.json({ exists: true, entries, updated });
+        res.json({ ...info, exists: info.enabled, entries, updated });
     });
     // A repository name that is not two path segments is a caller's mistake rather
     // than a missing repository, and saying so is cheaper than letting it 404.

package/dist/api/write.js

@@ -5,7 +5,12 @@ const trigger_1 = require("../ci/trigger");
 const git_1 = require("../git");
 const ops_1 = require("../ops");
 const perms_1 = require("../perms");
+const domains_1 = require("../domains");
 const scan_1 = require("../scan");
+const sitesettings_1 = require("../sitesettings");
+const sitepublish_1 = require("../sitepublish");
+const siteshost_1 = require("../siteshost");
+const topics_1 = require("../topics");
 const vault_1 = require("../vault");
 const auth_1 = require("./auth");
 function writeBody(body, fallbackMessage) {
@@ -13,7 +18,7 @@ function writeBody(body, fallbackMessage) {
     if (branch === null || !(0, git_1.isValidRefName)(branch))
         return '"branch" is required and must be a usable branch name';
     const newBranch = (0, auth_1.stringField)(body, 'newBranch');
-    if (newBranch !== null && !(0, git_1.isValidRefName)(newBranch))
+    if (newBranch !== null && !(0, git_1.isValidNewRefName)(newBranch))
         return '"newBranch" is not a usable branch name';
     const expectedSha = (0, auth_1.stringField)(body, 'expectedSha');
     return {
@@ -381,35 +386,131 @@ function registerWriteApi(app, root, limiter, lfs = null, engine) {
         const body = (0, auth_1.bodyOf)(req);
         const description = (0, auth_1.stringField)(body, 'description');
         const defaultBranch = (0, auth_1.stringField)(body, 'defaultBranch');
+        const upstream = (0, auth_1.stringField)(body, 'upstream');
+        const topics = (0, auth_1.stringsField)(body, 'topics');
+        if (topics === null) {
+            (0, auth_1.apiError)(res, 400, '"topics" must be a list of strings');
+            return;
+        }
         const priv = body.private;
         if (priv !== undefined && typeof priv !== 'boolean') {
             (0, auth_1.apiError)(res, 400, '"private" must be a boolean');
             return;
         }
-        if (description === null && defaultBranch === null && priv === undefined) {
-            (0, auth_1.apiError)(res, 400, 'nothing to change; provide "description", "defaultBranch", and/or "private"');
+        const siteEnabled = body.siteEnabled;
+        if (siteEnabled !== undefined && typeof siteEnabled !== 'boolean') {
+            (0, auth_1.apiError)(res, 400, '"siteEnabled" must be a boolean');
+            return;
+        }
+        const siteSource = body.siteSource;
+        if (siteSource !== undefined && !(0, sitesettings_1.isSiteSource)(siteSource)) {
+            (0, auth_1.apiError)(res, 400, '"siteSource" must be "copy", "actions", or "repository"');
+            return;
+        }
+        const sitePathRaw = (0, auth_1.stringField)(body, 'sitePath');
+        const sitePath = sitePathRaw === null ? null : (0, sitesettings_1.normalizeSitePath)(sitePathRaw);
+        if (sitePath !== null && !(0, sitesettings_1.isUsableSitePath)(sitePath)) {
+            (0, auth_1.apiError)(res, 400, '"sitePath" must be a relative directory within the tree, such as "docs", or "" for the root');
+            return;
+        }
+        const siteLabel = (0, auth_1.stringField)(body, 'siteLabel');
+        if (siteLabel !== null && siteLabel !== '' && (0, siteshost_1.isReservedSiteLabel)(siteLabel)) {
+            (0, auth_1.apiError)(res, 409, `the label ${siteLabel} is reserved for the operator of this vault`);
+            return;
+        }
+        if (siteLabel !== null && siteLabel !== '' && !(0, sitesettings_1.isUsableSiteLabel)(siteLabel)) {
+            (0, auth_1.apiError)(res, 400, 'a site label is lowercase letters, digits, and single interior hyphens, at most 63 characters');
+            return;
+        }
+        const siteDomain = (0, auth_1.stringField)(body, 'siteDomain');
+        const changingSite = siteEnabled !== undefined || siteSource !== undefined || siteLabel !== null || sitePath !== null;
+        if (description === null &&
+            defaultBranch === null &&
+            upstream === null &&
+            topics === undefined &&
+            priv === undefined &&
+            !changingSite &&
+            siteDomain === null) {
+            (0, auth_1.apiError)(res, 400, 'nothing to change; provide "description", "defaultBranch", "upstream", "topics", "private", "siteEnabled", "siteSource", "sitePath", "siteLabel", and/or "siteDomain"');
+            return;
+        }
+        // Visibility takes the admin role rather than write: publishing a
+        // repository, or withdrawing one from everybody who could see it, is the
+        // repository's own business the way deleting it is. The site settings are
+        // on the same footing, since enabling a site publishes what the directory
+        // holds to everyone.
+        if ((priv !== undefined || changingSite) && !(0, perms_1.canAdminRepo)(root, ctx.auth, ctx.repo)) {
+            (0, auth_1.apiError)(res, 403, `changing visibility or site settings needs the admin role on ${ctx.repo.collection}/${ctx.repo.name}`);
             return;
         }
-        // Visibility is the one setting here that takes the admin role rather than
-        // write: publishing a repository, or withdrawing one from everybody who
-        // could see it, is the repository's own business the way deleting it is.
-        if (priv !== undefined && !(0, perms_1.canAdminRepo)(root, ctx.auth, ctx.repo)) {
-            (0, auth_1.apiError)(res, 403, `changing visibility needs the admin role on ${ctx.repo.collection}/${ctx.repo.name}`);
+        // A custom domain is the operator's act: the operator points DNS at the
+        // vault and covers the name with a certificate, so attaching one takes a
+        // site admin, not merely the repository's.
+        if (siteDomain !== null && !(0, perms_1.isSiteAdmin)(ctx.auth)) {
+            (0, auth_1.apiError)(res, 403, 'attaching a custom domain takes a site admin');
             return;
         }
+        if (siteLabel !== null && siteLabel !== '') {
+            const holder = (0, sitesettings_1.siteLabelConflict)(root, siteLabel, ctx.repo.collection, ctx.repo.name);
+            if (holder) {
+                (0, auth_1.apiError)(res, 409, `the label ${siteLabel} is already used by ${holder}`);
+                return;
+            }
+        }
+        if (siteDomain !== null && siteDomain !== '') {
+            const problem = (0, domains_1.setRepoDomain)(root, ctx.repo.collection, ctx.repo.name, siteDomain);
+            if (problem) {
+                (0, auth_1.apiError)(res, problem.kind === 'conflict' ? 409 : 400, problem.message);
+                return;
+            }
+        }
+        if (siteDomain === '')
+            (0, domains_1.clearRepoDomain)(root, ctx.repo.collection, ctx.repo.name);
         try {
             if (description !== null)
                 (0, ops_1.setDescription)(ctx.repo.dir, description);
             if (defaultBranch !== null)
                 await (0, ops_1.setDefaultBranch)(ctx.repo.dir, defaultBranch);
+            if (upstream !== null)
+                await (0, ops_1.setUpstream)(ctx.repo.dir, upstream);
+            if (topics !== undefined)
+                (0, topics_1.setTopics)(ctx.repo.dir, topics);
             if (priv !== undefined)
                 (0, perms_1.setRepoPrivate)(ctx.repo.dir, priv);
+            if (changingSite) {
+                (0, sitesettings_1.editSiteSettings)(ctx.repo.dir, (s) => {
+                    if (siteEnabled !== undefined)
+                        s.enabled = siteEnabled;
+                    if (siteSource !== undefined)
+                        s.source = siteSource;
+                    if (siteLabel !== null)
+                        s.label = siteLabel;
+                    if (sitePath !== null)
+                        s.path = sitePath;
+                });
+            }
             const branches = await ctx.repo.listRefs('heads');
+            const settings = (0, sitesettings_1.siteSettings)(ctx.repo.dir);
+            // A site published from the repository is rewritten whenever what it
+            // should hold may have changed: the site settings, or the branch it
+            // follows. The publish's outcome rides in the response rather than
+            // failing it, since the settings themselves were saved.
+            const sitePublish = changingSite || defaultBranch !== null ? await (0, sitepublish_1.publishSiteForSettings)(root, ctx.repo) : null;
             res.json({
                 collection: ctx.repo.collection,
                 name: ctx.repo.name,
                 defaultBranch: await ctx.repo.defaultBranch(branches),
+                upstream: (0, scan_1.upstreamOf)(ctx.repo.dir)?.url ?? null,
+                topics: (0, topics_1.repoTopics)(ctx.repo.dir),
                 private: (0, perms_1.repoIsPrivate)(ctx.repo.dir),
+                site: {
+                    enabled: settings.enabled,
+                    source: settings.source,
+                    path: settings.path,
+                    label: settings.label === '' ? null : settings.label,
+                    domain: (0, domains_1.repoDomain)(root, ctx.repo.collection, ctx.repo.name),
+                },
+                sitePublish,
                 changed: true,
             });
         }
@@ -446,6 +547,35 @@ function registerWriteApi(app, root, limiter, lfs = null, engine) {
             (0, auth_1.sendOpError)(res, e, 'could not rename the repository');
         }
     });
+    // Collecting a repository now, rather than waiting for the sweep in
+    // src/maintenance.ts to reach it. It takes the admin role and the same typed
+    // confirmation deletion takes, because what it removes is unrecoverable:
+    // everything no ref can reach, which is exactly what a person who has just
+    // rewritten a history away is asking for, and exactly what someone who
+    // mistook this for a repack is not.
+    app.post('/api/repos/:collection/:repo/gc', async (req, res) => {
+        const ctx = (0, auth_1.requireRepoAdmin)(root, limiter, req, res);
+        if (!ctx)
+            return;
+        const full = `${ctx.repo.collection}/${ctx.repo.name}`;
+        if (String(req.query.confirm ?? '') !== full) {
+            (0, auth_1.apiError)(res, 400, `to drop every unreachable object in this repository, send ?confirm=${full}`);
+            return;
+        }
+        try {
+            const { before, after } = await (0, ops_1.collectRepo)(ctx.repo.dir);
+            res.json({
+                repo: full,
+                before,
+                after,
+                removed: Math.max(0, before.objects - after.objects),
+                kilobytesFreed: Math.max(0, before.kilobytes - after.kilobytes),
+            });
+        }
+        catch (e) {
+            (0, auth_1.sendOpError)(res, e, 'could not collect the repository');
+        }
+    });
     // ?confirm= is the API's equivalent of the web's typed confirmation. It costs
     // nothing and it makes an accidental DELETE from a loop over a listing
     // impossible.

package/dist/api.js

@@ -46,12 +46,15 @@ const perms_1 = require("./perms");
 const scan_1 = require("./scan");
 const vault_1 = require("./vault");
 const auth_1 = require("./api/auth");
+const logincodes_1 = require("./logincodes");
 const contents_1 = require("./api/contents");
 const issues_1 = require("./api/issues");
 const pulls_1 = require("./api/pulls");
 const repos_1 = require("./api/repos");
 const admin_1 = require("./api/admin");
 const backup_1 = require("./api/backup");
+const sitesettings_1 = require("./sitesettings");
+const config_1 = require("./config");
 const ci_1 = require("./api/ci");
 const releases_1 = require("./api/releases");
 const write_1 = require("./api/write");
@@ -99,6 +102,24 @@ function registerApi(app, root, authLimiter, gates, lfs = null, engine, egress)
         name: (0, scan_1.displayName)(dirName),
         dir: (0, layout_1.repoPath)(root, collection, dirName),
     }) !== null);
+    // A one-time sign-in URL for the browser, which is how `mochi web` opens
+    // the vault already signed in: the CLI proves the token over the API, and
+    // the session the link starts is bound to that same token, so revoking it
+    // ends both. The link lands on a page that names the account and asks for a
+    // click; see /login/code/:code in src/webops.ts.
+    app.post('/api/login-url', (req, res) => {
+        const auth = requireApiAuth(req, res);
+        if (!auth)
+            return;
+        const body = (req.body ?? {});
+        const next = typeof body.next === 'string' ? body.next : '/';
+        const code = (0, logincodes_1.mintLoginLink)(root, auth.username, auth.token.hash, next);
+        res.json({
+            url: `${req.protocol}://${req.get('host')}/login/code/${code}`,
+            username: auth.username,
+            expiresInSeconds: Math.round(logincodes_1.LOGIN_LINK_TTL_MS / 1000),
+        });
+    });
     app.get('/api/whoami', (req, res) => {
         const auth = requireApiAuth(req, res);
         if (!auth)
@@ -140,7 +161,18 @@ function registerApi(app, root, authLimiter, gates, lfs = null, engine, egress)
             (0, auth_1.apiError)(res, 404, `no collection ${name} in this vault`);
             return;
         }
-        res.json({ name, owners: (0, perms_1.collectionOwners)(root, name), repos: visibleRepos(auth, name).map(scan_1.displayName) });
+        // siteAlias is what is stored and siteHostAlias what is in effect, the two
+        // differing wherever a tier below the stored one is answering; see the
+        // tiers in src/sitesettings.ts. Both are null on a vault with no sites
+        // host, where a derived hostname would mean nothing.
+        const sitesHost = (0, config_1.loadConfig)(root).sites.host;
+        res.json({
+            name,
+            owners: (0, perms_1.collectionOwners)(root, name),
+            repos: visibleRepos(auth, name).map(scan_1.displayName),
+            siteAlias: sitesHost ? (0, sitesettings_1.storedCollectionAlias)(root, name) : null,
+            siteHostAlias: sitesHost ? (0, sitesettings_1.collectionSiteAlias)(root, name) : null,
+        });
     });
     app.post('/api/collections', (req, res) => {
         const auth = requireApiAuth(req, res);
@@ -287,6 +319,7 @@ function registerApi(app, root, authLimiter, gates, lfs = null, engine, egress)
         const result = (0, vault_1.addUserToken)(root, username, {
             siteAdmin: body.siteAdmin === true,
             tokenScope: tokenScope ?? undefined,
+            by: auth.username,
         });
         res.json({
             username,