domma-cms 0.105.1 → 0.106.0

package/server/routes/api/calls.js

@@ -10,7 +10,8 @@
  *   GET  /api/calls/contacts?q=         contacts the caller may READ (own + shared), to pick     (calls.create)
  *   GET  /api/calls/contact/:id         one contact the caller may read, to fill in             (calls.create)
  *   POST /api/calls                     {name, email?, contactId?, notify} -> 201 {id, hostUrl, joinUrl, emailed, emailLimited?, expiresAt}
- *   GET  /api/calls?contact=<id>        the caller's recent calls with that contact             (calls.read)
+ *   GET  /api/calls?contact=<id>        the caller's recent calls with that contact, with `messages` (calls.read)
+ *   GET  /api/calls/:id/chat            the call's saved chat (read-only transcript) - its HOST or an admin (calls.read)
  *
  * Contacts are read through `readableContactIds` (services/hooks.js): the
  * caller's own, plus whatever a sharing plugin (Contacts Pro) lets them read -
@@ -29,13 +30,14 @@ import {authenticate as defaultAuthenticate, requirePermission as defaultRequire
 import {getEntry, listEntries} from '../../services/collections.js';
 import {readableContactIds} from '../../services/hooks.js';
 import {getPermissionsFor} from '../../services/roles.js';
-import {getEffectiveRoles} from '../../services/userRoles.js';
+import {getEffectiveLevel, getEffectiveRoles} from '../../services/userRoles.js';
 import {isToolEnabled} from '../../services/tools.js';
 import {mountCallRoutes} from '../../../plugins/_lib/call/routes.js';
+import {whoOf} from '../../../plugins/_lib/call/rooms.js';
 import {getBaseUrl} from '../public.js';
 import {
-    EMAIL_RE, callMailReady, callPaths, callsOfContact, createCall, getCall, instantCallsEnabled, isOpen,
-    mayEmailAddress, mayStartCall, sendCallEmail, whoIsCalling
+    EMAIL_RE, callChat, callMailReady, callPaths, callsOfContact, chatCountOf, createCall, getCall, instantCallsEnabled, isOpen,
+    mayEmailAddress, mayStartCall, saveCallChat, sendCallEmail, whoIsCalling
 } from '../../services/instantCalls.js';
 
 const CONTACTS_SLUG = 'contacts-contacts';
@@ -122,13 +124,31 @@ export async function callsRoutes(fastify, opts = {}) {
         if (!contact) return fail(reply, 400, 'contact is required');
         const now = Date.now();
         const list = (await callsOfContact(contact, uidOf(request))).slice(0, 20)
-            .map(c => ({id: c.id, name: c.name, createdAt: c.createdAt, expiresAt: c.expiresAt, open: isOpen(c, now)}));
+            .map(c => ({id: c.id, name: c.name, createdAt: c.createdAt, expiresAt: c.expiresAt, open: isOpen(c, now), messages: chatCountOf(c)}));
         return reply.send(list);
     });
 
+    // The call's chat, saved against it: for the host who made the call, or an admin. Anyone else: 404 (not 403 -
+    // whether a call exists is the host's business). `mine` marks the host's own lines for the bubbles.
+    fastify.get('/:id/chat', can('read'), async (request, reply) => {
+        const rec = await getCall(String(request.params.id));
+        const uid = uidOf(request);
+        let admin = false;
+        try { admin = getEffectiveLevel(request.user || {}) <= 1; } catch { admin = false; }
+        if (!rec || !uid || (rec.hostId !== uid && !admin)) return fail(reply, 404, 'That call could not be found.');
+        const hostWho = whoOf(`${rec.id}:host`, '');
+        const mineToo = rec.hostId === uid;
+        const items = (await callChat(rec.id)).map(({from, ...i}) => ({...i, mine: mineToo && i.kind === 'chat' && i.who === hostWho}));
+        reply.header('Cache-Control', 'no-store');
+        return reply.send({id: rec.id, name: rec.name, hostName: rec.hostName, createdAt: rec.createdAt, expiresAt: rec.expiresAt,
+            messages: chatCountOf(rec), items});
+    });
+
     // The call engine: a room per call, guests knock, the host lets them in, open createdAt..expiresAt.
     mountCallRoutes(fastify, {
         prefix: '/room', ns: 'instant', ...(opts.rooms ? {rooms: opts.rooms} : {}),
-        resolve: async (request, room, body) => whoIsCalling(await getCall(String(room)), {t: body?.t, h: body?.h})
+        resolve: async (request, room, body) => whoIsCalling(await getCall(String(room)), {t: body?.t, h: body?.h}),
+        // The chat is saved against the call record, so a call reopened (or after a restart) shows it again.
+        chat: {load: (room) => callChat(String(room)), save: (room, item) => saveCallChat(String(room), item)}
     });
 }

package/server/services/instantCalls.js

@@ -19,7 +19,10 @@
  * actions and list stand aside (checked per request), so nobody sees two.
  *
  * A record: {id, name, email, contactId, hostId, hostName, token, hostKey,
- * createdAt, expiresAt}. Kept in memory and in one JSON file with the sign-in
+ * createdAt, expiresAt, chat?}. `chat` is the call's chat, saved against the
+ * call (the engine's items - typed messages plus joined/left lines - the last
+ * CHAT_MAX); the engine seeds a reopened room from it, and the host (or an
+ * admin) reads it afterwards through GET /api/calls/:id/chat. Kept in memory and in one JSON file with the sign-in
  * sessions (content/sessions/ - runtime state, never committed; see
  * siteGitignore.js), so a restart keeps the links working. The call itself (who
  * is in it) is the call engine's, in memory. Records are forgotten KEEP_DAYS
@@ -44,6 +47,8 @@ import {createTransport, escapeHtml, isSmtpConfigured, sendEmail} from './email.
 export const INSTANT_HOURS = 3;
 export const KEEP_DAYS = 30;
 export const MAX_KEPT = 2000;
+/** Chat items kept on one call record (the engine's HISTORY_MAX). */
+export const CHAT_MAX = 500;
 export const CALL_PATH = '/_call';
 export const ROOM_API = '/api/calls/room';
 export const ID_RE = /^[\w-]{16,40}$/;
@@ -141,9 +146,14 @@ function registerActions() {
         async list({id, user}) {
             if (!user?.id || !mayCall(user, 'read')) return [];
             const now = Date.now();
-            return (await callsOfContact(id, String(user.id))).slice(0, 5).map(c => ({
-                id: c.id, title: 'Video call', startAt: c.createdAt, past: !isOpen(c, now), meta: isOpen(c, now) ? 'open now' : ''
-            }));
+            return (await callsOfContact(id, String(user.id))).slice(0, 5).map((c) => {
+                const n = chatCountOf(c);
+                return {
+                    id: c.id, title: 'Video call', startAt: c.createdAt, past: !isOpen(c, now), meta: isOpen(c, now) ? 'open now' : '',
+                    // The admin's Calls list offers "N messages" - a read-only transcript (GET /api/calls/:id/chat).
+                    ...(n ? {transcript: {url: `/calls/${encodeURIComponent(c.id)}/chat`, count: n, title: `Video call with ${c.name || 'a guest'}`}} : {})
+                };
+            });
         }
     });
     // An email in the mail reader: "Call Sam now…" with the sender filled in.
@@ -234,6 +244,46 @@ export async function getCall(id) {
     return (await load()).get(id) || null;
 }
 
+/** The chat item as it is kept on a record; null for junk. System lines other than joined/left are not kept. */
+function chatItem(raw) {
+    if (!raw || typeof raw !== 'object' || typeof raw.text !== 'string' || !raw.id) return null;
+    const kind = raw.kind === 'system' ? 'system' : 'chat';
+    if (kind === 'system' && raw.event !== 'joined' && raw.event !== 'left') return null;
+    const item = {id: String(raw.id).slice(0, 64), seq: Number(raw.seq) || 0, at: String(raw.at || ''), kind,
+        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 (kind === 'system') item.event = raw.event;
+    return item;
+}
+
+/**
+ * Save one chat item against its call (the engine's `chat.save`). Queued with
+ * every other write to the file; the last CHAT_MAX are kept. A call that is no
+ * longer on record (forgotten, or never) keeps nothing.
+ */
+export async function saveCallChat(id, raw) {
+    const item = chatItem(raw);
+    if (!item || typeof id !== 'string' || !ID_RE.test(id)) return;
+    const all = await load();
+    const rec = all.get(id);
+    if (!rec) return;
+    const chat = Array.isArray(rec.chat) ? rec.chat : [];
+    if (chat.some(c => c?.id === item.id)) return;
+    chat.push(item);
+    if (chat.length > CHAT_MAX) chat.splice(0, chat.length - CHAT_MAX);
+    rec.chat = chat;
+    await save(all);
+}
+
+/** A call's saved chat, oldest first ([] for none). */
+export async function callChat(id) {
+    const rec = await getCall(id);
+    return Array.isArray(rec?.chat) ? rec.chat.map(c => ({...c})) : [];
+}
+
+/** How many typed messages a call's chat holds (not the joined/left lines). */
+export const chatCountOf = (rec) => (Array.isArray(rec?.chat) ? rec.chat.filter(c => c?.kind === 'chat').length : 0);
+
 /** One host's calls with one contact, newest first. */
 export async function callsOfContact(contactId, hostId) {
     if (!contactId || !hostId) return [];

package/server/templates/page.html

@@ -154,7 +154,7 @@
     <script src="/public/js/forms.js?v=20260927-submit-btn" type="module"></script>
 
     <!-- Core effects runtime -->
-    <script src="/public/js/effects.js?v=20260930-festive"></script>
+    <script src="/public/js/effects.js?v=20260930-snowman"></script>
 
     <!-- Plugin body-end injection -->
     {{bodyEndInject}}