@stelstone/server 0.30.0 → 0.31.0

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@stelstone/server",
-  "version": "0.30.0",
+  "version": "0.31.0",
   "description": "Runtime-agnostic CMS server built on the Web Fetch API, with pluggable adapters for content, media, auth, and build.",
   "license": "MIT",
   "repository": {

package/src/adapters/basic-auth.mjs

@@ -86,7 +86,15 @@ export function createBasicAuth({
     const p = decoded.slice(colon + 1);
     const entry = findUser(u, p);
     if (!entry) return null;
-    return { login: entry.user, name: entry.name || entry.user, role: entry.role || "editor" };
+    // `email` is optional and deliberately not derived from the username: a
+    // made-up address in a commit looks like a real one, and git history is
+    // read as evidence. Without it the commit falls back to the token owner.
+    return {
+      login: entry.user,
+      name: entry.name || entry.user,
+      email: entry.email || null,
+      role: entry.role || "editor",
+    };
   }
 
   return {

package/src/adapters/github-content.mjs

@@ -52,6 +52,20 @@ import { sanitize, safeFileName, sortPages, buildDuplicateData, listScheduledDue
  * @param {Object} [opts.list]  Listing strategy config (see above)
  * @returns {import('./types.mjs').ContentAdapter}
  */
+/**
+ * The `author` field for a git-data commit, or undefined.
+ *
+ * GitHub attributes a commit to the token owner when this is absent, which is
+ * what made every entry in the CMS's history read as the same person no
+ * matter who published it. A user with no configured email falls back to that
+ * rather than getting an invented address: history is read as evidence, and a
+ * plausible-looking address nobody owns is worse than an honest default.
+ */
+function commitAuthor(actor) {
+  if (!actor?.email) return undefined;
+  return { name: actor.name || actor.login, email: actor.email };
+}
+
 export function createGitHubContent({ token, owner, repo, branch, draftBranch, pagesDir, commitMessage, list = {}, collections = {} }) {
   const listConfig = {
     strategy: "index",
@@ -323,14 +337,19 @@ export function createGitHubContent({ token, owner, repo, branch, draftBranch, p
      *        write time — which is what this did before — discarded that
      *        guarantee and silently overwrote a concurrent edit.
      */
-    async writePage(collection, file, data, { expectedVersion } = {}) {
+    async writePage(collection, file, data, { expectedVersion, actor } = {}) {
       await ensureDraftBranch();
       const path = contentPath(collection, sanitize(file));
       const sha = expectedVersion ?? (await getFileSha(path));
       let result;
       try {
+        // The history screen lists commits on the draft branch, so this write
+        // is the one that answers "who edited this" — attributing it matters
+        // more here than on the publish commit.
+        const author = commitAuthor(actor);
         result = await apiPut(`/contents/${path}`, {
           message: commitMsg(commitMessage),
+          ...(author ? { author } : {}),
           content: encodeContent(data),
           branch: workBranch,
           ...(sha ? { sha } : {}),
@@ -447,7 +466,7 @@ export function createGitHubContent({ token, owner, repo, branch, draftBranch, p
      * @param {string} [message]
      * @param {{ entries?: {collection: string, file: string}[], target?: string }} [opts]
      */
-    async publish(message, { entries, target } = {}) {
+    async publish(message, { entries, target, actor } = {}) {
       const toBranch = target || branch;
       if (!draftMode) {
         // Writes are committed instantly; trigger is external (Netlify webhook on push)
@@ -490,6 +509,7 @@ export function createGitHubContent({ token, owner, repo, branch, draftBranch, p
             message: msg,
             tree: newTree.sha,
             parents: [baseCommitSha],
+            author: commitAuthor(actor),
           });
           await apiPatch(`/git/refs/heads/${toBranch}`, { sha: newCommit.sha });
           const shortSha = newCommit.sha.slice(0, 7);

package/src/adapters/github-oauth.mjs

@@ -116,7 +116,7 @@ export function createGitHubOAuth({
     if (!authHeader.startsWith("Bearer ")) return null;
     const claims = verifyToken(authHeader.slice(7));
     if (!claims || claims.type !== "session") return null;
-    return { login: claims.sub, role: getRole(claims.sub), name: claims.name };
+    return { login: claims.sub, role: getRole(claims.sub), name: claims.name, email: claims.email ?? null };
   }
 
   function issueSessionToken(login, name) {

package/src/core/config-schema.mjs

@@ -156,6 +156,12 @@ function checkAuth(config, report, { getSecret }) {
             `${entry.passEnv} is not set — user "${entry.user}" is DISABLED (check for a typo in the variable name)`,
           );
         }
+        // Optional, and only useful if it is real: it becomes the author of
+        // the commits this user makes. A malformed one would attribute their
+        // work to nobody, so say so rather than write it.
+        if (entry.email !== undefined && !/^[^@\s]+@[^@\s]+\.[^@\s]+$/.test(String(entry.email))) {
+          report.error(`auth.users[${i}].email`, "must be an email address — it becomes the git commit author");
+        }
       });
     } else if (!auth.passEnv && !auth.userEnv) {
       report.warn("auth.users", "no users configured — the CMS will run without authentication");

package/src/routes.mjs

@@ -87,7 +87,12 @@ export const apiRoutes = [
     handler: ({ env, runtime, adminUiVersion }) =>
       ok({
         serverVersion: SERVER_VERSION,
-        adminUiVersion: adminUiVersion ?? null,
+        // The Node server reads this off the package it resolved. A Worker
+        // cannot: the SPA is served by the assets binding and its package.json
+        // is not in the bundle. The deployment composed that directory, so it
+        // can state the version the way it states the commit below — a stated
+        // version beats a null on the About screen.
+        adminUiVersion: adminUiVersion ?? env("CMS_ADMIN_UI_VERSION") ?? null,
         // Declared by whoever constructed the handler, not sniffed: with
         // nodejs_compat enabled a Worker also exposes process.versions.node,
         // so feature detection reported "node" from inside a Worker.
@@ -226,7 +231,7 @@ export const apiRoutes = [
     method: "PUT",
     path: "/api/collections/:collection/:file",
     auth: "any",
-    handler: async ({ adapters, params, body, header }) => {
+    handler: async ({ adapters, params, body, header, user }) => {
       const bodyErr = pageBodyError(body);
       if (bodyErr) return badRequest(bodyErr);
 
@@ -234,7 +239,7 @@ export const apiRoutes = [
       const expectedVersion = ifMatch ? ifMatch.replace(/^W\//, "").replace(/"/g, "") : undefined;
 
       try {
-        await adapters.content.writePage(params.collection, params.file, body, { expectedVersion });
+        await adapters.content.writePage(params.collection, params.file, body, { expectedVersion, actor: user });
       } catch (err) {
         if (err.status === 412) {
           return {
@@ -580,11 +585,11 @@ export const apiRoutes = [
     method: "POST",
     path: "/api/publish",
     auth: "admin",
-    handler: async ({ adapters, config, body }) => {
+    handler: async ({ adapters, config, body, user }) => {
       const target = resolveTarget(config, body?.target);
       if (target.error) return { status: 400, json: { ok: false, message: target.error } };
       try {
-        return ok(await adapters.content.publish(null, { target: target.branch }));
+        return ok(await adapters.content.publish(null, { target: target.branch, actor: user }));
       } catch (err) {
         return { status: 500, json: { ok: false, message: err.message } };
       }
@@ -598,7 +603,7 @@ export const apiRoutes = [
     method: "POST",
     path: "/api/collections/:collection/:file/publish",
     auth: "admin",
-    handler: async ({ adapters, params, config, body }) => {
+    handler: async ({ adapters, params, config, body, user }) => {
       const target = resolveTarget(config, body?.target);
       if (target.error) return { status: 400, json: { ok: false, message: target.error } };
       if (!adapters.content.capabilities?.perEntryPublish) {
@@ -612,6 +617,7 @@ export const apiRoutes = [
           await adapters.content.publish(null, {
             entries: [{ collection: params.collection, file: params.file }],
             target: target.branch,
+            actor: user,
           }),
         );
       } catch (err) {
@@ -643,11 +649,20 @@ export const apiRoutes = [
     method: "GET",
     path: "/api/deploy/status",
     auth: "any",
-    handler: async ({ adapters, query }) => {
+    handler: async ({ adapters, config, query }) => {
       if (!adapters.build.configured) return ok({ configured: false });
+      // Which branch's build to watch. After publishing to a target the new
+      // commit exists only on that target's branch, so without this the run
+      // is looked for on the deploy branch and never found — the pill then
+      // spins until it gives up, for a build that actually succeeded.
+      const target = resolveTarget(config, query.target);
+      if (target.error) return { status: 400, json: { error: target.error } };
       try {
         return ok(
-          await adapters.build.getDeployStatus({ branch: query.branch, sha: query.sha }),
+          await adapters.build.getDeployStatus({
+            branch: target.branch ?? query.branch,
+            sha: query.sha,
+          }),
         );
       } catch (err) {
         if (err.upstreamStatus) {

package/src/version.mjs

@@ -5,4 +5,4 @@
  * require() and no import.meta.url, so reading the manifest at runtime yields
  * "unknown" there.
  */
-export const SERVER_VERSION = "0.30.0";
+export const SERVER_VERSION = "0.31.0";