domma-cms 1.6.33 → 1.6.34

package/server/services/markdown.js

@@ -21,6 +21,7 @@ import {buildTextStyle} from '../../public/js/text-style.mjs';
 import {buildScribeStyle} from '../../public/js/scribe-style.mjs';
 import {CHARACTERS, resolveCharacterSize} from '../../public/js/celebrations/character-catalog.mjs';
 import {publicButtonSettings} from '../../public/js/form-submit.mjs';
+import {applyShortcodeExpiry} from './shortcodeExpiry.js';
 
 const __dirname_md = path.dirname(fileURLToPath(import.meta.url));
 const BLOCKS_DIR = path.resolve(__dirname_md, '../../content/blocks');
@@ -4553,10 +4554,14 @@ export async function parseMarkdown(raw, opts = {}) {
   const uncommented = comments.restore(comments.scrubbed
       .replace(/<!--[\s\S]*?(?:-->|$)/g, '')
       .replace(/^[ ]{0,3}\/\/[^\r\n]*/gm, ''));
-  const preprocessed = applyTransforms('markdown:beforeParse', uncommented);
+  const expirySafe = scrubCodeRegions(uncommented, true);
+  const expiry = await applyShortcodeExpiry(expirySafe.scrubbed, {
+    ...(opts.expiry || {}), urlPath: opts.urlPath || '/', parseAttrs: parseShortcodeAttrs
+  });
+  const preprocessed = applyTransforms('markdown:beforeParse', expirySafe.restore(expiry.markdown));
   const {output: withComponents, used: usedComponents} = collectAndRewriteComponents(preprocessed);
   const tagSet = new Set();
-  const flags = {perViewer: false};
+  const flags = {perViewer: false, hasExpiry:expiry.hasExpiry};
   const withCollection = await processCollectionBlocks(withComponents, tagSet);
   const withView = await processViewBlocks(withCollection, tagSet, opts.user || null, flags);
   const withStaticBlock = await processStaticBlocks(withView, tagSet);
@@ -4670,7 +4675,7 @@ export async function parseMarkdown(raw, opts = {}) {
   const allowed = new Set(_dmTagAllowlist.map(t => t.replace(/^dm-/, '')));
   const filteredUsed = [...usedComponents].filter(name => allowed.has(name));
 
-  return {data, content, html, usedComponents: filteredUsed, tags: [...tagSet], perViewer: flags.perViewer};
+  return {data, content, html, usedComponents: filteredUsed, tags: [...tagSet], perViewer: flags.perViewer, hasExpiry:flags.hasExpiry};
 }
 
 /**

package/server/services/shortcodeExpiry.js

@@ -0,0 +1,146 @@
+/** Shared per-shortcode expiry state for public page renders. */
+import {createHmac, randomBytes, timingSafeEqual} from 'node:crypto';
+import fs from 'node:fs/promises';
+import path from 'node:path';
+import net from 'node:net';
+import {SHORTCODE_EXPIRY_FIELDS} from '../../public/js/shortcode-expiry.mjs';
+
+const STATE_FILE = path.resolve('content/shortcode-expiry.json');
+const EXPIRY_KEYS = new Set(['expires-at', 'expire-after', 'expire-views', 'expire-scope', 'expire-ip', 'expire-session', 'expiry-id']);
+let stateQueue = Promise.resolve();
+
+export function hasShortcodeExpiry(attrs) {
+  return Object.keys(attrs || {}).some(key => EXPIRY_KEYS.has(key));
+}
+
+export function validSessionCookie(value, secret) {
+  if (!value || !secret) return '';
+  const [id, signature, extra] = String(value).split('.');
+  if (!id || !signature || extra || !/^[a-f0-9]{32}$/.test(id)) return '';
+  const expected = createHmac('sha256', secret).update(id).digest('hex');
+  const a = Buffer.from(signature), b = Buffer.from(expected);
+  return a.length === b.length && timingSafeEqual(a, b) ? id : '';
+}
+
+export function newSessionCookie(secret) {
+  const id = randomBytes(16).toString('hex');
+  const signature = createHmac('sha256', secret).update(id).digest('hex');
+  return {id, value:`${id}.${signature}`};
+}
+
+function stateKey(page, identity, scope, secret) {
+  return createHmac('sha256', secret).update(`${page}\0${identity}\0${scope}`).digest('hex');
+}
+
+function ipAllowed(ruleText, ip) {
+  const rules = String(ruleText || '').split(/[\s,;]+/).filter(Boolean);
+  if (!rules.length) return true;
+  return rules.some(rule => {
+    if (rule === ip) return true;
+    const [network, prefix] = rule.split('/');
+    if (!prefix || net.isIP(network) !== net.isIP(ip)) return false;
+    try {
+      const block = new net.BlockList();
+      block.addSubnet(network, Number(prefix), net.isIP(network) === 4 ? 'ipv4' : 'ipv6');
+      return block.check(ip, net.isIP(ip) === 4 ? 'ipv4' : 'ipv6');
+    } catch { return false; }
+  });
+}
+
+/** Replace expired shortcode ranges, counting each actual public page render once. */
+async function applyShortcodeExpiryUnlocked(markdown, {urlPath = '/', ip = '', sessionId = '', preview = false, secret = '', parseAttrs} = {}) {
+  const tokenRe = /\[(\/)?([a-z][\w-]*)(?:\s+((?:[^\]"']|"[^"]*"|'[^']*')*?))?\s*(\/)?\]/gi;
+  const tokens = [...markdown.matchAll(tokenRe)].map(match => ({
+    start: match.index, end: match.index + match[0].length, raw:match[0], close:!!match[1],
+    name:match[2].toLowerCase(), attrsText:match[3] || '', self:!!match[4], attrs:parseAttrs(match[3] || '')
+  }));
+  const ranges = [];
+  const stack = [];
+  for (let i = 0; i < tokens.length; i++) {
+    const t = tokens[i];
+    if (t.close) {
+      for (let j = stack.length - 1; j >= 0; j--) {
+        if (stack[j].name === t.name) {
+          const open = stack.splice(j, 1)[0];
+          if (open.expiring) ranges.push({start:open.start, end:t.end, token:open});
+          break;
+        }
+      }
+    } else {
+      t.expiring = hasShortcodeExpiry(t.attrs);
+      if (t.self || /\/\s*$/.test(t.attrsText)) {
+        if (t.expiring) ranges.push({start:t.start, end:t.end, token:t});
+      } else stack.push(t);
+    }
+  }
+  // Treat malformed/unclosed expiry tags as extending to the end of the source.
+  for (const open of stack) if (open.expiring) ranges.push({start:open.start, end:markdown.length, token:open});
+  if (!ranges.length) return {markdown, hasExpiry:false};
+
+  const now = Date.now();
+  let state = {};
+  if (!preview && secret) {
+    try { state = JSON.parse(await fs.readFile(STATE_FILE, 'utf8')); } catch {}
+  }
+  const removals = [];
+  const cleanOpeners = [];
+  for (const range of ranges.sort((a,b)=>a.start-b.start)) {
+    if (removals.some(parent => parent.start <= range.start && parent.end >= range.end)) continue;
+    const {token} = range, a = token.attrs;
+    const scope = String(a['expire-scope'] || 'ip').toLowerCase() === 'session' ? 'session' : 'ip';
+    const visitor = scope === 'session' ? sessionId : ip;
+    const identity = String(a['expiry-id'] || a.id || `${token.name}:${token.start}`).trim();
+    const date = String(a['expires-at'] || '').trim();
+    const expiresAt = date ? Date.parse(date) : NaN;
+    const afterMinutes = Number(a['expire-after']);
+    const maxViews = Math.floor(Number(a['expire-views']));
+    const oncePerSession = a['expire-session'] === true || String(a['expire-session']).toLowerCase() === 'true';
+    const keyScope = oncePerSession ? `session:${sessionId}` : `${scope}:${visitor || 'anonymous'}`;
+    const key = stateKey(urlPath, `${token.name}:${identity}`, keyScope, secret);
+    let record = state[key] || {};
+    const blocked = !preview && ((Number.isFinite(expiresAt) && now >= expiresAt)
+      || (Number.isFinite(afterMinutes) && afterMinutes > 0 && record.firstSeen && now >= record.firstSeen + afterMinutes * 60000)
+      || (Number.isInteger(maxViews) && maxViews > 0 && record.views >= maxViews)
+      || (oncePerSession && record.views >= 1)
+      || (a['expire-ip'] && !ipAllowed(a['expire-ip'], ip)));
+    if (blocked) { removals.push(range); continue; }
+    cleanOpeners.push(token);
+    const counterVisitor = (scope === 'session' || oncePerSession) ? sessionId : ip;
+    if (!preview && secret && counterVisitor && (afterMinutes > 0 || maxViews > 0 || oncePerSession)) {
+      record.firstSeen ||= now;
+      record.views = (record.views || 0) + 1;
+      record.updated = now;
+      state[key] = record;
+    }
+  }
+  // Nested expired ranges collapse to one removal so offsets remain valid.
+  const collapsed = [];
+  for (const range of removals.sort((a,b)=>a.start-b.start)) {
+    const parent = collapsed.at(-1);
+    if (parent && range.start < parent.end) parent.end = Math.max(parent.end, range.end);
+    else collapsed.push({...range});
+  }
+  if (!preview && Object.keys(state).length) {
+    // Bound state growth while preserving current visitor records.
+    for (const [key, record] of Object.entries(state)) if (record.updated && record.updated < now - 180 * 86400000) delete state[key];
+    await fs.mkdir(path.dirname(STATE_FILE), {recursive:true});
+    const temp = `${STATE_FILE}.${process.pid}.${randomBytes(4).toString('hex')}.tmp`;
+    await fs.writeFile(temp, JSON.stringify(state));
+    await fs.rename(temp, STATE_FILE);
+  }
+  const edits = collapsed.map(range => ({start:range.start, end:range.end, value:''}));
+  for (const token of cleanOpeners) {
+    if (collapsed.some(range => range.start <= token.start && range.end >= token.end)) continue;
+    const cleaned = token.raw.replace(/\s+(?:expires-at|expire-after|expire-views|expire-scope|expire-ip|expire-session|expiry-id)(?:\s*=\s*(?:"[^"]*"|'[^']*'|[^\s\]]+))?/gi, '');
+    if (cleaned !== token.raw) edits.push({start:token.start, end:token.end, value:cleaned});
+  }
+  let output = markdown;
+  for (const edit of edits.sort((a,b)=>b.start-a.start)) output = output.slice(0,edit.start) + edit.value + output.slice(edit.end);
+  return {markdown:output, hasExpiry:true};
+}
+
+export function applyShortcodeExpiry(markdown, options = {}) {
+  const operation = stateQueue.then(() => applyShortcodeExpiryUnlocked(markdown, options));
+  stateQueue = operation.then(() => {}, () => {});
+  return operation;
+}

package/server/templates/page.html

@@ -25,7 +25,7 @@
     <link rel="stylesheet" href="/dist/domma/themes/domma-themes.css">
 
     <!-- Site CSS -->
-    <link rel="stylesheet" href="/public/css/site.css?v=20261012-card-icon">
+    <link rel="stylesheet" href="/public/css/site.css?v=20261012-carousel-centre">
     <link rel="stylesheet" href="/public/css/forms.css?v=20260927-submit-btn-css">
     <!-- Menu item hover / current-page effects. Loaded after site.css so a
          menu's own highlight wins over the blanket link styling there. -->