domma-cms 0.105.2 → 0.106.0

package/admin/js/lib/related.js

@@ -1 +1 @@
-import{apiRequest as w}from"../api.js";import{fmtDate as b,fmtDateTime as y}from"./dates.js";const f=new Map;export function relatedProviders(e){return f.has(e)||f.set(e,w(`/related/providers?kind=${encodeURIComponent(e)}`,{method:"GET"}).then(t=>Array.isArray(t)?t:[]).catch(()=>[])),f.get(e)}export function relatedMenuItems(e,t,i=n=>n.label){return e.flatMap(n=>n.actions||[]).map(n=>({label:i(n),icon:n.icon||"arrow-right",action:()=>{location.hash=n.url.replace(/\{id\}/g,encodeURIComponent(t)).replace(/^#/,"")}}))}export function relatedWhen(e){if(e?.when)return String(e.when);if(!e?.startAt)return"";const t=new Date(e.startAt);return Number.isNaN(t.getTime())?"":e.allDay?b(t.toISOString().slice(0,10)):y(t)}const a=(e,t,i)=>{const n=document.createElement(e);return t&&(n.className=t),i!=null&&(n.textContent=i),n};export async function mountRelated(e,t,i,{onOpen:n,name:v=""}={}){e.hidden=!0;const h=await relatedProviders(t);if(!h.length||!e.isConnected)return;e.hidden=!1,e.replaceChildren(a("p","related-loading","Loading\u2026"));let g;try{g=await w(`/related?kind=${encodeURIComponent(t)}&id=${encodeURIComponent(i)}`,{method:"GET"})}catch{e.replaceChildren(a("p","related-note","Could not be loaded just now."));return}const I=(g?.providers||[]).map(r=>{const d=a("section","related-section"),s=a("div","related-head"),c=a("span");c.dataset.icon=r.icon||"link",c.dataset.iconSize="14",s.append(c,a("strong","",r.label));const p=(h.find(o=>o.id===r.id)?.actions||[])[0];if(p){const o=a("button","btn btn-sm btn-ghost related-add",p.label.replace(/\{name\}/g,v||"them"));o.type="button",o.addEventListener("click",()=>{n?.(),location.hash=p.url.replace(/\{id\}/g,encodeURIComponent(i)).replace(/^#/,"")}),s.append(o)}if(d.append(s),r.error)d.append(a("p","related-note",r.error));else if(!r.items?.length)d.append(a("p","related-note",`No ${r.label.toLowerCase()} yet.`));else{const o=a("ul","related-list");for(const l of r.items){const m=a("li",l.past?"is-past":""),u=a(l.url?"a":"span","related-title",l.title||"Untitled");l.url&&(u.href=l.url,u.addEventListener("click",()=>n?.())),m.append(u);const C=[relatedWhen(l),l.meta].filter(Boolean).join(" \xB7 ");C&&m.append(a("small","related-meta",C)),o.append(m)}d.append(o)}return d});e.replaceChildren(...I),window.I?.scan?.(e)}
+import{apiRequest as f}from"../api.js";import{fmtDate as E,fmtDateTime as I}from"./dates.js";const b=new Map;export function relatedProviders(e){return b.has(e)||b.set(e,f(`/related/providers?kind=${encodeURIComponent(e)}`,{method:"GET"}).then(t=>Array.isArray(t)?t:[]).catch(()=>[])),b.get(e)}export function relatedMenuItems(e,t,a=n=>n.label){return e.flatMap(n=>n.actions||[]).map(n=>({label:a(n),icon:n.icon||"arrow-right",action:()=>{location.hash=n.url.replace(/\{id\}/g,encodeURIComponent(t)).replace(/^#/,"")}}))}export function relatedWhen(e){if(e?.when)return String(e.when);if(!e?.startAt)return"";const t=new Date(e.startAt);return Number.isNaN(t.getTime())?"":e.allDay?E(t.toISOString().slice(0,10)):I(t)}const r=(e,t,a)=>{const n=document.createElement(e);return t&&(n.className=t),a!=null&&(n.textContent=a),n};export function transcriptOf(e){const t=e?.transcript;if(!t||typeof t.url!="string"||!/^\/[\w\-/%.]+$/.test(t.url)||t.url.includes(".."))return null;const a=Math.max(0,Number(t.count)|0);return a?{url:t.url,count:a,title:String(t.title||"Call chat").slice(0,160)}:null}function R(e,t){const a=r("button","btn btn-sm btn-ghost related-chat",`${e.count} message${e.count===1?"":"s"}`);return a.type="button",a.title="Read the chat from this call",a.addEventListener("click",async()=>{a.disabled=!0;try{const[n,d]=await Promise.all([f(e.url,{method:"GET"}),import("/plugins/_lib/admin/ui/transcript.js")]);await d.openTranscript({title:e.title,subtitle:t?`Call started ${t}`:"",items:n?.items||[]})}catch(n){window.E?.toast?.(n?.status===404?"That chat is not available.":"The chat could not be loaded just now.",{type:"warning"})}finally{a.disabled=!1}}),a}export async function mountRelated(e,t,a,{onOpen:n,name:d=""}={}){e.hidden=!0;const g=await relatedProviders(t);if(!g.length||!e.isConnected)return;e.hidden=!1,e.replaceChildren(r("p","related-loading","Loading\u2026"));let w;try{w=await f(`/related?kind=${encodeURIComponent(t)}&id=${encodeURIComponent(a)}`,{method:"GET"})}catch{e.replaceChildren(r("p","related-note","Could not be loaded just now."));return}const v=(w?.providers||[]).map(l=>{const s=r("section","related-section"),p=r("div","related-head"),u=r("span");u.dataset.icon=l.icon||"link",u.dataset.iconSize="14",p.append(u,r("strong","",l.label));const m=(g.find(i=>i.id===l.id)?.actions||[])[0];if(m){const i=r("button","btn btn-sm btn-ghost related-add",m.label.replace(/\{name\}/g,d||"them"));i.type="button",i.addEventListener("click",()=>{n?.(),location.hash=m.url.replace(/\{id\}/g,encodeURIComponent(a)).replace(/^#/,"")}),p.append(i)}if(s.append(p),l.error)s.append(r("p","related-note",l.error));else if(!l.items?.length)s.append(r("p","related-note",`No ${l.label.toLowerCase()} yet.`));else{const i=r("ul","related-list");for(const o of l.items){const c=r("li",o.past?"is-past":""),h=r(o.url?"a":"span","related-title",o.title||"Untitled");o.url&&(h.href=o.url,h.addEventListener("click",()=>n?.())),c.append(h);const C=[relatedWhen(o),o.meta].filter(Boolean).join(" \xB7 ");C&&c.append(r("small","related-meta",C));const y=transcriptOf(o);y&&c.append(R(y,relatedWhen(o))),i.append(c)}s.append(i)}return s});e.replaceChildren(...v),window.I?.scan?.(e)}

package/admin/js/templates/docs/usage-tools.html

@@ -37,6 +37,10 @@
                       screen shows their link to copy or send. They need no account or app, and wait until you let
                       them in. The link works for 3 hours. The contact's <strong>Calls</strong> list shows your
                       recent calls with them.</p>
+                  <p>What is typed in the call's chat is kept with the call. A call on the contact's
+                      <strong>Calls</strong> list shows how many messages it has - click that to read them (only
+                      you, as the one who made the call, or an admin). If you open the call again while it lasts,
+                      the earlier messages are still there.</p>
                   <p>Who may start a call is the <strong>Calls</strong> permission under <strong>System &gt;
                       Roles</strong>; Admin is given it once, the first time a Tool with calls runs. A site without
                       any of those Tools has no instant calls at all.</p>

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "domma-cms",
-  "version": "0.105.2",
+  "version": "0.106.0",
   "description": "File-based CMS powered by Domma and Fastify. Run npx domma-cms my-site to create a new project.",
   "type": "module",
   "main": "server/server.js",

package/plugins/_lib/admin/ui/transcript.js

@@ -0,0 +1,154 @@
+/**
+ * A call's chat, read-only, in a slideover - WhatsApp-style bubbles, day
+ * dividers, system lines ("Jo joined") centred. Shared by the CMS's instant
+ * calls (a contact's Calls list), Booking (a booking's panel) and Calendar (an
+ * online event's editor). Import it over HTTP: `/plugins/_lib/admin/ui/transcript.js`.
+ *
+ * Items are the call engine's (`_lib/call/CLAUDE.md` "Chat history"). The rows
+ * are built in JS (`transcriptRows`, pure) and every string reaches the page
+ * through a domma-reactive text binding - chat is never HTML. The stylesheet is
+ * this module's own (`--dm-*` tokens only), added to the page once.
+ *
+ * @module _lib/admin/ui/transcript
+ */
+import {fmtDate} from './dates.js';
+
+const GROUP_MS = 5 * 60000;
+const HUES = 8;
+
+const dayKey = (d) => `${d.getFullYear()}-${d.getMonth()}-${d.getDate()}`;
+
+/** "Today", "Yesterday" or dd/mm/yyyy - in the reader's zone. */
+export function dayLabel(d, now = new Date()) {
+    if (dayKey(d) === dayKey(now)) return 'Today';
+    const y = new Date(now);
+    y.setDate(y.getDate() - 1);
+    if (dayKey(d) === dayKey(y)) return 'Yesterday';
+    return fmtDate(d);
+}
+
+/** A stable colour (1..8) for a sender. */
+export function hueOf(s) {
+    let h = 0;
+    for (const c of String(s || '')) h = (h * 31 + c.charCodeAt(0)) >>> 0;
+    return String((h % HUES) + 1);
+}
+
+/**
+ * The rows for a transcript: one per item (oldest first), with its day divider,
+ * grouping (same sender within 5 minutes, no system line or new day between),
+ * side and time. PURE.
+ *
+ * @param {object[]} items - the engine's chat items
+ * @param {{mine?: (item: object) => boolean, now?: Date}} [opts]
+ * @returns {{id: string, cls: string, hue: string, day: string, sys: boolean, name: string, showName: boolean, text: string, time: string}[]}
+ */
+export function transcriptRows(items, {mine = (i) => i?.mine === true, now = new Date()} = {}) {
+    const rows = [];
+    let last = null;
+    const seen = new Set();
+    for (const raw of Array.isArray(items) ? items : []) {
+        if (!raw || typeof raw.text !== 'string' || !raw.id || seen.has(raw.id)) continue;
+        seen.add(raw.id);
+        const at = new Date(raw.at || 0);
+        const when = Number.isNaN(at.getTime()) ? new Date(0) : at;
+        const sys = raw.kind === 'system';
+        const sender = String(raw.who || raw.from || raw.name || '');
+        const isMine = !sys && mine(raw) === true;
+        const day = !last || dayKey(last.when) !== dayKey(when) ? dayLabel(when, now) : '';
+        const first = sys || Boolean(day) || !last || last.sys || last.sender !== sender || when - last.when > GROUP_MS;
+        rows.push({
+            id: String(raw.id), sys, day, text: raw.text, name: String(raw.name || 'Someone'), showName: first && !sys && !isMine,
+            hue: hueOf(sender),
+            time: when.toLocaleTimeString([], {hour: '2-digit', minute: '2-digit', hourCycle: 'h23'}),
+            cls: ['dmt-msg', sys ? 'is-sys' : isMine ? 'is-mine' : 'is-other', first ? 'is-first' : 'is-cont', day ? 'has-day' : ''].join(' ').trim()
+        });
+        last = {when, sys, sender};
+    }
+    return rows;
+}
+
+/** How many typed messages (not system lines). */
+export const messageCount = (items) => (Array.isArray(items) ? items.filter(i => i?.kind === 'chat').length : 0);
+
+/** "3 messages" / "1 message". */
+export const messagesLabel = (n) => `${n} message${n === 1 ? '' : 's'}`;
+
+const CSS = `
+.dmt-panel { display: flex; flex-direction: column; gap: .5rem; min-height: 100%; }
+.dmt-sub { margin: 0; color: var(--dm-text-muted); font-size: .85rem; }
+.dmt-list { list-style: none; margin: 0; padding: .6rem .7rem 1rem; border-radius: .6rem; background: var(--dm-background-alt, var(--dm-surface)); border: 1px solid var(--dm-border); flex: 1; }
+.dmt-empty { color: var(--dm-text-muted); font-size: .9rem; text-align: center; padding: 1.5rem .5rem; }
+.dmt-msg { display: flex; flex-direction: column; margin-top: 2px; }
+.dmt-msg.is-first { margin-top: .6rem; }
+.dmt-msg.is-mine { align-items: flex-end; }
+.dmt-msg.is-other { align-items: flex-start; }
+.dmt-msg.is-sys { align-items: center; margin-top: .5rem; }
+.dmt-day { align-self: center; margin: .5rem 0 .3rem; }
+.dmt-day span, .dmt-sys span { display: inline-block; padding: .22rem .6rem; border-radius: .45rem; background: var(--dm-surface-raised, var(--dm-surface)); color: var(--dm-text-muted);
+  font-size: .75rem; border: 1px solid var(--dm-border); }
+.dmt-day span { text-transform: uppercase; letter-spacing: .03em; font-size: .68rem; }
+.dmt-bubble { position: relative; max-width: 85%; padding: .36rem .55rem .3rem .6rem; border-radius: .55rem; background: var(--dm-surface-raised, var(--dm-surface));
+  color: var(--dm-text); border: 1px solid var(--dm-border); white-space: pre-wrap; overflow-wrap: anywhere; line-height: 1.35; }
+.is-mine .dmt-bubble { background: var(--dm-success-light, var(--dm-surface-raised)); }
+.is-first.is-mine .dmt-bubble { border-top-right-radius: 0; }
+.is-first.is-other .dmt-bubble { border-top-left-radius: 0; }
+.dmt-from { display: block; font-size: .78rem; font-weight: 600; margin-bottom: .1rem; color: var(--dm-primary); }
+.dmt-time { float: right; position: relative; top: .3rem; margin-left: .6rem; font-size: .68rem; line-height: 1; color: var(--dm-text-muted); font-variant-numeric: tabular-nums; }
+.dmt-msg[data-hue="2"] .dmt-from, .dmt-msg[data-hue="7"] .dmt-from { color: var(--dm-success); }
+.dmt-msg[data-hue="3"] .dmt-from, .dmt-msg[data-hue="8"] .dmt-from { color: var(--dm-info); }
+.dmt-msg[data-hue="4"] .dmt-from { color: var(--dm-danger); }
+.dmt-msg[data-hue="5"] .dmt-from { color: var(--dm-warning); }
+.dmt-panel [hidden] { display: none !important; }
+`;
+
+function addStyles() {
+    if (document.getElementById('dm-transcript-css')) return;
+    const style = document.createElement('style');
+    style.id = 'dm-transcript-css';
+    style.textContent = CSS;
+    document.head.appendChild(style);
+}
+
+const ROW = `<li data-bind-class="cls" data-bind-data-hue="hue">
+  <div class="dmt-day" data-bind-hidden="!day"><span data-bind-text="day"></span></div>
+  <div class="dmt-sys" data-bind-hidden="!sys"><span data-bind-text="text"></span></div>
+  <div class="dmt-bubble" data-bind-hidden="sys"><span class="dmt-from" data-bind-hidden="!showName" data-bind-text="name"></span><span class="dmt-text" data-bind-text="text"></span><span class="dmt-time" data-bind-text="time"></span></div>
+</li>`;
+
+/**
+ * Open the transcript in a right-hand slideover. `title` and `subtitle` are
+ * plain text. Returns the slideover (null when the admin has no Domma).
+ *
+ * @param {{title?: string, subtitle?: string, items: object[], mine?: (item: object) => boolean, empty?: string}} opts
+ */
+export async function openTranscript({title = 'Call chat', subtitle = '', items = [], mine, empty = 'Nothing was typed in the chat.'} = {}) {
+    if (!window.E?.slideover || !window.M?.applyBindings) return null;
+    addStyles();
+    const rows = M.observable(transcriptRows(items, mine ? {mine} : {}));
+    const sub = M.observable(String(subtitle || ''));
+    const emptyText = M.observable(String(empty || ''));
+    // The title goes in as text: Domma's slideover title takes HTML.
+    const so = E.slideover({title: String(title).replace(/[&<>"']/g, c => `&#${c.charCodeAt(0)};`), size: 'md', position: 'right'});
+    const panel = document.createElement('div');
+    panel.className = 'dmt-panel';
+    panel.innerHTML = `<p class="dmt-sub" data-bind-hidden="!sub.value" data-bind-text="sub.value"></p>
+<p class="dmt-empty" data-bind-hidden="rows.value.length" data-bind-text="emptyText.value"></p>
+<div class="dmt-wrap" data-bind-hidden="!rows.value.length"><ol class="dmt-list" aria-label="Chat from the call" data-each="rows.value key=id"></ol></div>`;
+    // The row template goes in before binding (a templateUrl would eat {{...}}; this has none, but keep the order).
+    panel.querySelector('.dmt-list').innerHTML = ROW;
+    so.element.appendChild(panel);
+    const bindings = M.applyBindings({rows, sub, emptyText}, panel);
+    let onceClosed = null;
+    try { onceClosed = (await import('/admin/js/lib/tool-kit.js')).onceClosed; } catch { /* older admin */ }
+    const dispose = () => { try { bindings?.dispose?.(); } catch { /* gone */ } };
+    if (typeof onceClosed === 'function') onceClosed(so, dispose);
+    else {
+        const close = so.close.bind(so);
+        so.close = (...a) => { const r = close(...a); dispose(); setTimeout(() => { try { so.destroy?.(); } catch { /* gone */ } so.element?.remove(); }, 400); return r; };
+    }
+    so.open();
+    // Newest at the bottom, in view.
+    setTimeout(() => { const list = panel.querySelector('.dmt-list'); list?.lastElementChild?.scrollIntoView?.({block: 'end'}); }, 60);
+    return so;
+}

package/plugins/_lib/call/chatStore.js

@@ -0,0 +1,103 @@
+/**
+ * A call chat store for a Tool: one JSON file holding every room's transcript,
+ * made to be handed to `mountCallRoutes(..., {chat: store})` (its `load` and
+ * `save`), plus what an admin screen needs to show a transcript afterwards.
+ *
+ * File shape: `{rooms: {<room>: {updatedAt, items: [...]}}}`. Growth is capped
+ * twice: the last `maxItems` items per room (the engine's HISTORY_MAX), and the
+ * `maxRooms` most recently used rooms (older transcripts go first). Writes are
+ * one after another (a promise chain) through `_lib/dataStore.js` (atomic
+ * .tmp + rename); the file is read once and then kept in memory - one process.
+ *
+ * @module _lib/call/chatStore
+ */
+
+import {createStore} from '../dataStore.js';
+import {HISTORY_MAX} from './rooms.js';
+
+/** The fields an item keeps; anything else a caller passes is dropped. */
+export function storedItem(raw) {
+    if (!raw || typeof raw !== 'object' || typeof raw.text !== 'string' || !raw.id) return null;
+    const item = {id: String(raw.id).slice(0, 64), seq: Number(raw.seq) || 0, at: String(raw.at || ''),
+        kind: raw.kind === 'system' ? 'system' : 'chat', from: String(raw.from || '').slice(0, 64),
+        who: String(raw.who || '').slice(0, 64), name: String(raw.name || '').slice(0, 60), text: raw.text.slice(0, 1000)};
+    if (raw.event) item.event = String(raw.event).slice(0, 40);
+    return item;
+}
+
+/** How many typed messages (not system lines) a transcript holds. */
+export const chatCount = (items) => (Array.isArray(items) ? items.filter(i => i?.kind === 'chat').length : 0);
+
+/**
+ * @param {string} file - absolute path of the JSON file (a Tool's data/ folder)
+ * @param {{maxItems?: number, maxRooms?: number, now?: () => number}} [opts]
+ */
+export function createChatStore(file, {maxItems = HISTORY_MAX, maxRooms = 1000, now = Date.now} = {}) {
+    const disk = createStore(file);
+    let data = null;              // {rooms: {}} once read
+    let reading = null;           // the ONE first read: two callers never each replace `data`
+    let chain = Promise.resolve();
+
+    function read() {
+        if (data) return Promise.resolve(data);
+        reading ??= Promise.resolve(disk.read()).then((raw) => {
+            data = {rooms: raw && typeof raw.rooms === 'object' && raw.rooms && !Array.isArray(raw.rooms) ? raw.rooms : {}};
+            return data;
+        }).finally(() => { reading = null; });
+        return reading;
+    }
+    /** Run `fn` after every earlier change; a failure is passed on to its caller, never to the next change. */
+    function queue(fn) {
+        const run = chain.then(fn);
+        chain = run.catch(() => {});
+        return run;
+    }
+    const key = (room) => String(room || '').slice(0, 160);
+
+    return {
+        /** The room's items, oldest first ([] when there are none). */
+        async load(room) {
+            await chain;
+            const r = (await read()).rooms[key(room)];
+            return Array.isArray(r?.items) ? r.items.map(i => ({...i})) : [];
+        },
+
+        /** Add one item (the engine's save). Kept: the last maxItems; the maxRooms most recently used rooms. */
+        save(room, item) {
+            const clean = storedItem(item);
+            if (!clean || !key(room)) return Promise.resolve();
+            return queue(async () => {
+                const d = await read();
+                const k = key(room);
+                const r = d.rooms[k] || (d.rooms[k] = {updatedAt: '', items: []});
+                if (!r.items.some(i => i.id === clean.id)) r.items.push(clean);
+                if (r.items.length > maxItems) r.items.splice(0, r.items.length - maxItems);
+                r.updatedAt = new Date(now()).toISOString();
+                const names = Object.keys(d.rooms);
+                if (names.length > maxRooms) {
+                    names.sort((a, b) => String(d.rooms[a].updatedAt).localeCompare(String(d.rooms[b].updatedAt)))
+                        .slice(0, names.length - maxRooms).forEach(n => { delete d.rooms[n]; });
+                }
+                await disk.write(d);
+            });
+        },
+
+        /** The rooms whose name starts with `prefix`: [{room, count, updatedAt}] (count = typed messages). */
+        async rooms(prefix = '') {
+            await chain;
+            const d = await read();
+            return Object.entries(d.rooms).filter(([k]) => k.startsWith(prefix))
+                .map(([k, r]) => ({room: k, count: chatCount(r.items), updatedAt: r.updatedAt}));
+        },
+
+        /** Forget a room's transcript. */
+        remove(room) {
+            return queue(async () => {
+                const d = await read();
+                if (!(key(room) in d.rooms)) return;
+                delete d.rooms[key(room)];
+                await disk.write(d);
+            });
+        }
+    };
+}

package/plugins/_lib/call/rooms.js

@@ -9,16 +9,23 @@
  * what is waiting for them. Every request after joining carries the
  * participant's id and secret.
  *
+ * Each room also keeps its chat history (the last HISTORY_MAX items): what
+ * people typed, plus system lines (joined, left, recording started/stopped),
+ * so someone arriving late sees what was said. It lives as long as the room;
+ * a Tool that wants it kept longer listens with `onItem` (routes.js does, for
+ * its `chat.save`) and seeds a new room from storage with `join(..., {history})`.
+ *
  * @module _lib/call/rooms
  */
 
-import {randomBytes, timingSafeEqual} from 'node:crypto';
+import {createHash, randomBytes, timingSafeEqual} from 'node:crypto';
 
 export const MAX_PEOPLE = 6;
 const SILENT_MS = 35000;          // no poll for this long: gone
 const POLL_MS = 25000;            // a poll waits this long for something to happen
 const QUEUE_MAX = 500;            // events kept per participant (a stuck browser cannot grow it forever)
-const CHAT_MAX = 1000;
+const CHAT_MAX = 1000;             // characters in one message
+export const HISTORY_MAX = 500;   // chat items a room keeps (and hands a late joiner)
 const EMPTY_KEEP_MS = 2 * 3600e3;  // an empty room remembering who was turned away
 
 export class CallError extends Error {
@@ -28,6 +35,21 @@ export class CallError extends Error {
     }
 }
 
+/**
+ * A stable, non-reversible tag for one person across reloads: the same link (identity) always gives the same
+ * `who`, so "mine" and a sender's colour survive a reload or a restart. No identity: the participant id.
+ */
+export const whoOf = (identity, id) => (identity ? createHash('sha256').update(`dm-call:${identity}`).digest('base64url').slice(0, 16) : id);
+
+/** A chat item as it is kept and handed out; anything else a store gave back is dropped. */
+function cleanItem(raw) {
+    if (!raw || typeof raw !== 'object' || typeof raw.text !== 'string' || !raw.id) return null;
+    const item = {id: String(raw.id).slice(0, 64), seq: Number(raw.seq) || 0, at: String(raw.at || ''), kind: raw.kind === 'system' ? 'system' : 'chat',
+        from: String(raw.from || ''), who: String(raw.who || raw.from || ''), name: String(raw.name || '').slice(0, 60), text: raw.text.slice(0, CHAT_MAX)};
+    if (raw.event) item.event = String(raw.event).slice(0, 40);
+    return item;
+}
+
 const secretOk = (a, b) => {
     const x = Buffer.from(String(a || ''));
     const y = Buffer.from(String(b || ''));
@@ -35,11 +57,13 @@ const secretOk = (a, b) => {
 };
 
 /**
- * @param {{now?: () => number, pollMs?: number, silentMs?: number}} [opts]
+ * @param {{now?: () => number, pollMs?: number, silentMs?: number, onItem?: (key: string, item: object) => void}} [opts]
  */
-export function createRooms({now = Date.now, pollMs = POLL_MS, silentMs = SILENT_MS} = {}) {
-    /** key -> {key, title, max, recordingAllowed, recording, people: Map<pid, person>} */
+export function createRooms({now = Date.now, pollMs = POLL_MS, silentMs = SILENT_MS, onItem} = {}) {
+    /** key -> {key, title, max, recordingAllowed, recording, people: Map<pid, person>, chat: item[], chatSeq} */
     const rooms = new Map();
+    /** Told about every new chat item (user and system) - never about history a room was seeded with. */
+    const listeners = new Set(onItem ? [onItem] : []);
 
     const newId = (n) => randomBytes(n).toString('base64url');
     const admitted = (room) => [...room.people.values()].filter(p => p.state === 'in');
@@ -55,6 +79,23 @@ export function createRooms({now = Date.now, pollMs = POLL_MS, silentMs = SILENT
     }
     const tell = (people, event) => people.forEach(p => push(p, event));
 
+    /**
+     * Add one item to a room's history (capped) and hand it to the listeners. Returns the item. The listeners
+     * also get `{identity}` of the person it is about ('' for none) - for the server only, never in the item.
+     */
+    function record(room, fields, person) {
+        room.chatSeq += 1;
+        const item = {id: newId(9), seq: room.chatSeq, at: new Date(now()).toISOString(), kind: 'chat', from: '', who: '', name: '', text: '', ...fields};
+        room.chat.push(item);
+        if (room.chat.length > HISTORY_MAX) room.chat.splice(0, room.chat.length - HISTORY_MAX);
+        for (const fn of listeners) {
+            try { fn(room.key, {...item}, {identity: person?.identity || ''}); } catch { /* a listener never breaks a call */ }
+        }
+        return item;
+    }
+    const system = (room, person, event, text) => record(room, {kind: 'system', event, text,
+        from: person?.id || '', who: person?.who || '', name: person?.name || ''}, person);
+
     function me(key, pid, secret) {
         const room = rooms.get(key);
         const person = room?.people.get(String(pid || ''));
@@ -66,12 +107,15 @@ export function createRooms({now = Date.now, pollMs = POLL_MS, silentMs = SILENT
     function remove(room, person, why) {
         if (!room.people.delete(person.id)) return;
         for (const w of person.waiters.splice(0)) w();
-        if (person.state === 'in') tell(admitted(room), {type: 'left', id: person.id, name: person.name, why});
-        else tell(hosts(room), {type: 'waiting', waiting: waitingList(room)});
+        if (person.state === 'in') {
+            // A reload is not news: no "left" line (and the join that follows adds no "joined" line either).
+            const item = why === 'rejoined' ? undefined : system(room, person, 'left', `${person.name} left`);
+            tell(admitted(room), {type: 'left', id: person.id, name: person.name, why, ...(item && {item})});
+        } else tell(hosts(room), {type: 'waiting', waiting: waitingList(room)});
         // The last host leaving stops a recording; nobody else can.
         if (room.recording && !hosts(room).length) {
             room.recording = false;
-            tell(admitted(room), {type: 'recording', on: false});
+            tell(admitted(room), {type: 'recording', on: false, item: system(room, null, 'recording-off', 'Recording stopped')});
         }
         // An empty room goes - or, while it remembers who was turned away, two hours after it emptied (sweep).
         if (!room.people.size) {
@@ -82,11 +126,14 @@ export function createRooms({now = Date.now, pollMs = POLL_MS, silentMs = SILENT
 
     const waitingList = (room) => [...room.people.values()].filter(p => p.state === 'waiting').map(p => ({id: p.id, name: p.name}));
 
-    function admit(room, person) {
+    function admit(room, person, quiet = false) {
         if (admitted(room).length >= room.max) throw new CallError('full', `This call is full (${room.max} people).`);
         person.state = 'in';
-        tell(admitted(room).filter(p => p !== person), {type: 'joined', peer: pub(person)});
-        push(person, {type: 'admitted', peers: admitted(room).filter(p => p !== person).map(pub), recording: room.recording});
+        const item = quiet ? undefined : system(room, person, 'joined', `${person.name} joined`);
+        tell(admitted(room).filter(p => p !== person), {type: 'joined', peer: pub(person), ...(item && {item})});
+        // `chat` is the history so far (their own "joined" line included), so a late joiner sees what was said.
+        push(person, {type: 'admitted', peers: admitted(room).filter(p => p !== person).map(pub), recording: room.recording,
+            chat: room.chat.map(c => ({...c}))});
         tell(hosts(room), {type: 'waiting', waiting: waitingList(room)});
     }
 
@@ -96,12 +143,16 @@ export function createRooms({now = Date.now, pollMs = POLL_MS, silentMs = SILENT
          * for a host unless the room lets everyone straight in.
          *
          * @param {string} key - the room, as the Tool names it ("booking:<id>")
-         * @param {{name: string, host?: boolean, title?: string, max?: number, recordingAllowed?: boolean, autoAdmit?: boolean}} who
+         * @param {{name: string, host?: boolean, title?: string, max?: number, recordingAllowed?: boolean, autoAdmit?: boolean,
+         *   identity?: string, history?: object[]}} who - `history` seeds the chat of a room this join CREATES (earlier
+         *   items from storage); it is ignored when the room already exists, and never handed to the listeners.
          */
-        join(key, {name, host = false, title = '', max = MAX_PEOPLE, recordingAllowed = false, autoAdmit = false, identity = ''}) {
+        join(key, {name, host = false, title = '', max = MAX_PEOPLE, recordingAllowed = false, autoAdmit = false, identity = '', history}) {
             let room = rooms.get(key);
             if (!room) {
-                room = {key, title, max: Math.max(2, Math.min(MAX_PEOPLE, max | 0 || MAX_PEOPLE)), recordingAllowed, recording: false, people: new Map(), away: new Set()};
+                const seeded = (Array.isArray(history) ? history : []).map(cleanItem).filter(Boolean).slice(-HISTORY_MAX);
+                room = {key, title, max: Math.max(2, Math.min(MAX_PEOPLE, max | 0 || MAX_PEOPLE)), recordingAllowed, recording: false, people: new Map(), away: new Set(),
+                    chat: seeded, chatSeq: seeded.reduce((m, c) => Math.max(m, c.seq), 0)};
                 rooms.set(key, room);
             }
             room.emptySince = 0;
@@ -109,21 +160,29 @@ export function createRooms({now = Date.now, pollMs = POLL_MS, silentMs = SILENT
             if (!host && identity && room.away.has(identity)) throw new CallError('away', 'The host did not let you in to this call.');
             // The same link joining again (a reload, a second tab) replaces its old place at once, rather than
             // leaving a frozen copy of them in the call until the sweep notices.
-            if (identity) for (const p of [...room.people.values()]) if (p.identity === identity) remove(room, p, 'rejoined');
+            let rejoin = false;
+            if (identity) {
+                for (const p of [...room.people.values()]) {
+                    if (p.identity !== identity) continue;
+                    rejoin = rejoin || p.state === 'in';
+                    remove(room, p, 'rejoined');
+                }
+            }
             // remove() deletes a room it leaves empty - this one is about to have someone in it again.
             rooms.set(key, room);
             if (admitted(room).length >= room.max && (host || autoAdmit)) throw new CallError('full', `This call is full (${room.max} people).`);
-            const person = {id: newId(9), secret: newId(24), identity: String(identity || ''), name: String(name || '').trim().slice(0, 60) || (host ? 'Host' : 'Guest'),
+            const id = newId(9);
+            const person = {id, secret: newId(24), identity: String(identity || ''), who: whoOf(identity, id), name: String(name || '').trim().slice(0, 60) || (host ? 'Host' : 'Guest'),
                 host: Boolean(host), state: 'waiting', seq: 0, queue: [], waiters: [], seen: now()};
             room.people.set(person.id, person);
             if (host || autoAdmit) {
                 // admit() also tells every host - this one included - who is already waiting.
-                admit(room, person);
+                admit(room, person, rejoin);
             } else {
                 push(person, {type: 'knocking'});
                 tell(hosts(room), {type: 'waiting', waiting: waitingList(room)});
             }
-            return {id: person.id, secret: person.secret, name: person.name, host: person.host, state: person.state, title: room.title,
+            return {id: person.id, secret: person.secret, who: person.who, name: person.name, host: person.host, state: person.state, title: room.title,
                 max: room.max, recordingAllowed: room.recordingAllowed};
         },
 
@@ -166,8 +225,10 @@ export function createRooms({now = Date.now, pollMs = POLL_MS, silentMs = SILENT
             if (person.state !== 'in') throw new CallError('waiting', 'Wait to be let in first.');
             const clean = String(text || '').trim().slice(0, CHAT_MAX);
             if (!clean) return false;
-            tell(admitted(room), {type: 'chat', from: person.id, name: person.name, text: clean});
-            return true;
+            const item = record(room, {kind: 'chat', from: person.id, who: person.who, name: person.name, text: clean}, person);
+            // from/name/text stay at the top level for older pages; `item` is the whole history entry.
+            tell(admitted(room), {type: 'chat', from: person.id, name: person.name, text: clean, item});
+            return item;
         },
 
         /** A host lets someone in (yes) or turns them away (no). */
@@ -192,8 +253,11 @@ export function createRooms({now = Date.now, pollMs = POLL_MS, silentMs = SILENT
             const {room, person} = me(key, pid, secret);
             if (!person.host || person.state !== 'in') throw new CallError('not-host', 'Only the host can record.');
             if (!room.recordingAllowed && on) throw new CallError('no-recording', 'Recording is switched off for this call.');
+            const was = room.recording;
             room.recording = Boolean(on);
-            tell(admitted(room), {type: 'recording', on: room.recording, by: person.name});
+            const item = was === room.recording ? undefined
+                : system(room, person, room.recording ? 'recording-on' : 'recording-off', `${person.name} ${room.recording ? 'started' : 'stopped'} recording`);
+            tell(admitted(room), {type: 'recording', on: room.recording, by: person.name, ...(item && {item})});
             return room.recording;
         },
 
@@ -212,6 +276,25 @@ export function createRooms({now = Date.now, pollMs = POLL_MS, silentMs = SILENT
             }
         },
 
+        /** Is there a room under this key right now (someone in it, waiting, or remembered)? */
+        has: (key) => rooms.has(key),
+
+        /** A copy of a room's chat history, oldest first ([] when there is no room). */
+        history(key) {
+            const room = rooms.get(key);
+            return room ? room.chat.map(c => ({...c})) : [];
+        },
+
+        /**
+         * Hear about every new chat item: `fn(key, item, {identity})`, for user messages and system lines alike -
+         * `identity` is the join's identity of the person concerned ('' when none), for server-side use only (it
+         * is never put in an item). Returns a function that stops listening. A listener that throws is ignored.
+         */
+        onItem(fn) {
+            listeners.add(fn);
+            return () => listeners.delete(fn);
+        },
+
         /** For the admin: how many are in a room and waiting (0 when there is no call). */
         count(key) {
             const room = rooms.get(key);

package/plugins/_lib/call/routes.js

@@ -15,6 +15,10 @@
  * After joining, every request carries `X-Call-Id` and `X-Call-Secret`
  * (headers, so the secret never lands in an access log).
  *
+ * Chat history: each room keeps its own (see rooms.js). A Tool that passes
+ * `chat: {load, save}` makes it outlive the room - `load(room)` seeds a room
+ * as it is created, `save(room, item)` gets every new item. See CLAUDE.md.
+ *
  * @module _lib/call/routes
  */
 
@@ -34,11 +38,45 @@ const BUSY = {config: {rateLimit: {max: 1200, timeWindow: '1 minute'}}};
  *   who the caller is in this room, or null when they may not join. Throw nothing: null answers 404.
  * @param {ReturnType<typeof createRooms>} [opts.rooms] - for tests
  * @param {() => {stun: string[], turn: object|null}} [opts.config]
+ * @param {{load?: (room: string) => Promise<object[]>, save?: (room: string, item: object, meta: {identity: string}) => Promise<void>}} [opts.chat]
+ *   optional storage for the chat: `load(room)` gives the earlier items of a room being created (oldest first),
+ *   `save(room, item, {identity})` is handed every new item, user and system. `room` is the Tool's own room id (no
+ *   namespace); `identity` is what the Tool's resolve() gave the person concerned ('' for none) - server side only.
+ *   Failures (and a load slower than 5 s) are logged and otherwise ignored: a chat never breaks a call.
  * @returns {ReturnType<typeof createRooms>} the rooms, so the Tool can close() one or count() it
  */
-export function mountCallRoutes(fastify, {prefix = '/call', ns, resolve, rooms = createRooms(), config = () => readCallConfig()}) {
+export function mountCallRoutes(fastify, {prefix = '/call', ns, resolve, rooms = createRooms(), config = () => readCallConfig(), chat = null}) {
     if (!ns) throw new Error('mountCallRoutes needs a namespace');
     const keyOf = (room) => `${ns}:${String(room || '').slice(0, 120)}`;
+    const roomOf = (key) => key.slice(ns.length + 1);
+    const log = fastify.log || console;
+
+    // ---- Chat storage (optional) --------------------------------------------------------
+    // Saves for one room run one after another, so the store sees items in order.
+    const saving = new Map();   // key -> promise of the last save
+    const save = (key, item, meta) => {
+        const next = (saving.get(key) || Promise.resolve())
+            .then(() => chat.save(roomOf(key), item, {identity: String(meta?.identity || '')}))
+            .catch(err => log.warn?.({err: err?.message || String(err), room: roomOf(key)}, '[call] chat save failed'));
+        saving.set(key, next);
+        next.then(() => { if (saving.get(key) === next) saving.delete(key); });
+        return next;
+    };
+    const stopListening = typeof chat?.save === 'function'
+        ? rooms.onItem((key, item, meta) => { if (key.startsWith(`${ns}:`)) save(key, item, meta); })
+        : null;
+    const load = async (room) => {
+        if (typeof chat?.load !== 'function') return undefined;
+        let timer;
+        try {
+            const items = await Promise.race([chat.load(room),
+                new Promise((_, no) => { timer = setTimeout(() => no(new Error('timed out after 5 s')), 5000); })]);
+            return Array.isArray(items) ? items : [];
+        } catch (err) {
+            log.warn?.({err: err?.message || String(err), room}, '[call] chat load failed');
+            return [];
+        } finally { clearTimeout(timer); }
+    };
     const who = (request) => [request.headers['x-call-id'], request.headers['x-call-secret']];
     const fail = (reply, err) => {
         if (err instanceof CallError) return reply.code(STATUS[err.code] || 400).send({error: err.message, code: err.code});
@@ -47,7 +85,7 @@ export function mountCallRoutes(fastify, {prefix = '/call', ns, resolve, rooms =
 
     const sweeper = setInterval(() => rooms.sweep(), 5000);
     sweeper.unref?.();
-    fastify.addHook('onClose', async () => clearInterval(sweeper));
+    fastify.addHook('onClose', async () => { clearInterval(sweeper); stopListening?.(); });
 
     fastify.post(`${prefix}/:room/join`, {config: {rateLimit: {max: 30, timeWindow: '1 minute'}}}, async (request, reply) => {
         const body = request.body || {};
@@ -56,9 +94,12 @@ export function mountCallRoutes(fastify, {prefix = '/call', ns, resolve, rooms =
         const t = Date.now();
         if (r.opensAt && t < Date.parse(r.opensAt)) return reply.code(425).send({error: 'This call has not opened yet.', code: 'early', opensAt: r.opensAt});
         if (r.closesAt && t > Date.parse(r.closesAt)) return reply.code(410).send({error: 'This call has ended.', code: 'closed'});
+        const key = keyOf(request.params.room);
+        // A room being created starts from its stored chat (a room reopened later, or after a restart).
+        const history = rooms.has(key) ? undefined : await load(roomOf(key));
         try {
-            const joined = rooms.join(keyOf(request.params.room), {name: r.name || body.name, host: r.host, title: r.title, max: r.max,
-                recordingAllowed: r.recordingAllowed === true, autoAdmit: r.autoAdmit === true, identity: r.identity || ''});
+            const joined = rooms.join(key, {name: r.name || body.name, host: r.host, title: r.title, max: r.max,
+                recordingAllowed: r.recordingAllowed === true, autoAdmit: r.autoAdmit === true, identity: r.identity || '', history});
             return reply.send({...joined, iceServers: iceServers(config(), request.hostname), closesAt: r.closesAt || null});
         } catch (err) { return fail(reply, err); }
     });
@@ -79,11 +120,20 @@ export function mountCallRoutes(fastify, {prefix = '/call', ns, resolve, rooms =
         } catch (err) { return fail(reply, err); }
     });
     action('signal', (k, id, s, b) => rooms.signal(k, id, s, b.to, b.data));
-    action('chat', (k, id, s, b) => rooms.chat(k, id, s, b.text));
+    fastify.post(`${prefix}/:room/chat`, BUSY, async (request, reply) => {
+        const [id, secret] = who(request);
+        const key = keyOf(request.params.room);
+        let item;
+        try { item = rooms.chat(key, id, secret, (request.body || {}).text); } catch (err) { return fail(reply, err); }
+        // Answered once the store has had it (a failed save is only logged).
+        if (item && saving.has(key)) await saving.get(key);
+        return reply.send({ok: true, result: item || false});
+    });
     action('answer', (k, id, s, b) => rooms.answer(k, id, s, b.who, b.yes === true));
     action('recording', (k, id, s, b) => rooms.recording(k, id, s, b.on === true));
     action('leave', (k, id, s) => rooms.leave(k, id, s));
 
     return {...rooms, closeRoom: (room) => rooms.close(keyOf(room)), countRoom: (room) => rooms.count(keyOf(room)),
+        historyOfRoom: (room) => rooms.history(keyOf(room)),
         kickFromRoom: (room, identity) => rooms.kick(keyOf(room), identity)};
 }