@stelstone/server 0.30.1 → 0.32.0

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@stelstone/server",
-  "version": "0.30.1",
+  "version": "0.32.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/fs-json-content.mjs

@@ -49,8 +49,9 @@ export function createFsJsonContent({
     }
   }
 
-  function git(cmd) {
-    return execSync(`git ${cmd}`, { cwd: rootDir, encoding: "utf-8" }).trim();
+  function git(cmd, { trim = true } = {}) {
+    const out = execSync(`git ${cmd}`, { cwd: rootDir, encoding: "utf-8" });
+    return trim ? out.trim() : out;
   }
 
   function pagePath(collection, file) {
@@ -206,7 +207,11 @@ export function createFsJsonContent({
     capabilities: { deferredPublish: true, perEntryPublish: true },
 
     async pendingChanges() {
-      const status = git(`status --porcelain ${PATHS_ARG}`);
+      // Untrimmed: a modified file's line starts with a space (" M path") and
+      // trimming ate it on the first line, which then lost the first letter
+      // of its path and was never attributed to its collection — so the
+      // first pending entry in a list never got its badge.
+      const status = git(`status --porcelain ${PATHS_ARG}`, { trim: false });
       const lines = status.split("\n").filter(Boolean);
       // Porcelain line: "XY path" (rename: "XY old -> new"). Only entries under
       // pagesDir are attributed to a collection/file; other publishPaths (e.g.

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

@@ -231,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);
 
@@ -239,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 {
@@ -311,9 +311,20 @@ export const apiRoutes = [
       if (!data) return notFound();
 
       let url = null;
+      // Which publish target the preview shows, when the site can say: a
+      // draft previews on the staging site, a published entry on the live
+      // one. The admin needs this to tell whether the framed page is current
+      // or behind the saved draft.
+      let target = null;
       if (typeof config.previewUrl === "function") {
         try {
-          url = config.previewUrl({ collection: params.collection, data });
+          const out = config.previewUrl({ collection: params.collection, data });
+          if (out && typeof out === "object") {
+            url = out.url ?? null;
+            target = out.target ?? null;
+          } else {
+            url = out;
+          }
         } catch (err) {
           return { status: 500, json: { error: `previewUrl(): ${err.message}` } };
         }
@@ -323,7 +334,7 @@ export const apiRoutes = [
           .replace("{slug}", data.slug || "")
           .replace("{lang}", data.lang || "");
       }
-      return ok({ url });
+      return ok({ url, target });
     },
   },
 
@@ -585,11 +596,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 } };
       }
@@ -603,7 +614,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) {
@@ -617,6 +628,7 @@ export const apiRoutes = [
           await adapters.content.publish(null, {
             entries: [{ collection: params.collection, file: params.file }],
             target: target.branch,
+            actor: user,
           }),
         );
       } catch (err) {

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.1";
+export const SERVER_VERSION = "0.32.0";