domma-cms 0.105.2 → 0.107.0

package/plugins/booking/CLAUDE.md

@@ -20,6 +20,31 @@ service - no import of the Calendar, which is a separate paid Tool).
 Booking Pro (not yet built) is an ADD-ON that registers into this one (`lib/extensions.js`), the Cart / Cart Pro
 pattern - it does not supersede it. Payment is Pro only.
 
+1.6.0 (2026-09-30): "Add people" in an online booking's call (core with `server/services/callInvites.js` and
+`_lib/call/invite.js`; both imported dynamically - lib/call.js by top-level `await import`, plugin.js beside
+`mountCallRoutes` - so an older core simply has no button). The HOST (the person's host link) searches the contacts
+of the person's linked ACTIVE account (`hostUserOf`) and the team, and invites contacts, team members or any name +
+email. With NO linked account the host link may be held by an outsider (it goes to the person's email address and
+the .ics), so resolve answers `inviteOptions: {search: false, typed: false, copyLink: true}` - Copy link only: no
+directory, no contacts, nothing sent (the engine and `send` both refuse people). Links use core's `inviteOrigin`
+(`site.baseUrl` first).
+Each invitee gets their OWN pass `?b=<booking>&g=<nonce>.<hmac>` signed with the session's `callExtraKey` - made on the
+first invite and written to EVERY booking of the session (`changeBooking` patch, online only, never replaced; the
+stored key is re-read after writing, so two sends at once agree), never the customer's token or the host key (a
+customer token carries their name and identity: an invitee would replace them). `whoIsCalling` answers `{host: false,
+name: '', identity: '<session>:inv:<nonce>', invited: true}` for a pass; the page asks their name; they knock. Core
+sends (Join email, a notification + a DM from the person's user for team members). `adminBooking` strips
+`callExtraKey`. Tests: tests/api.test.js "1.6 Add people" (a linked host; a host with no account).
+
+1.5.0 (2026-09-30): the call's chat is saved per SESSION (`sessionOf` - a class's shared call has one chat) in
+`data/call-chat.json` (`options.dataDir` in tests) through core's `_lib/call/chatStore.js` (dynamic import beside
+`mountCallRoutes`; an older core has none and nothing changes), passed as the engine's `chat` - so the call reopened
+shows it. `GET /bookings/:id` adds `callChat` (typed messages) on online bookings; `GET /bookings/:id/call-chat`
+(booking.read; 404 unless online) answers `{messages, items}` without participant ids, the session's host lines
+(`whoOf('<bookingId>:host')` for each booking of the session) marked `mine`. The panel (`openBooking`) shows "Call chat
+(N messages)" when N > 0 and opens `/plugins/_lib/admin/ui/transcript.js` (read-only, domma-reactive). The customer
+has no admin view of it. Kept: 500 items a session, the 1000 most recent sessions. Tests: tests/api.test.js.
+
 1.4.0 (2026-09-30): "Call now" hooks for Booking Pro. Registry `version: 4`: `actions: [{id, icon, title, module}]`
 (module under `/plugins/<owner>/`; ids `[a-z0-9-]`, never a screen's or tab's key, first owner keeps an id) ->
 `registry.actions()` -> bootstrap `actions` -> a banner button each (`booking-x-<id>`) that imports the module and calls
@@ -101,7 +126,8 @@ all off - bookings hold customers' details). Settings: `config/plugins.json` `bo
 A booking: `serviceId`, `serviceName`, `duration`, `bookableId`, `bookableName`, `startAt`, `endAt`, `blockStart`,
 `blockEnd`, `status`, `name`, `email`, `phone`, `notes`, `staffNote`, `contactId`, `source` (public | admin),
 `createdBy`, `token` (the customer's link; never sent to the admin), `reminderSentAt`, `history` [{at, what, by,
-from?, reason?}], `cancelledAt`, `ext` (Pro's); online ones also `online`, `hostKey`, `recordingAllowed`, `callOpenedAt`. Services and bookables carry `ext` too (Pro's fields, kept by the
+from?, reason?}], `cancelledAt`, `ext` (Pro's); online ones also `online`, `hostKey`, `recordingAllowed`, `callOpenedAt`, `callExtraKey` (1.6, the session's key for
+Add people passes; never sent to the admin). Services and bookables carry `ext` too (Pro's fields, kept by the
 free Tool untouched).
 
 ## Extensions (Booking Pro)

package/plugins/booking/admin/lib/kit.js

@@ -61,6 +61,7 @@ export const api = {
     bookings: {
         list: (q = {}) => request('GET', `${P}/bookings?${qs(q)}`),
         get: (id) => request('GET', `${P}/bookings/${seg(id)}`),
+        callChat: (id) => request('GET', `${P}/bookings/${seg(id)}/call-chat`),
         create: (d) => request('POST', `${P}/bookings`, d),
         update: (id, d) => request('PUT', `${P}/bookings/${seg(id)}`, d),
         move: (id, d) => request('PUT', `${P}/bookings/${seg(id)}/move`, d),

package/plugins/booking/admin/views/panels.js

@@ -478,6 +478,9 @@ export async function openBooking(ctx, id) {
   ${b.hostUrl && live ? `<div class="bk-actions bk-actions-start bk-call-row">
     <a class="btn btn-sm btn-primary" href="${esc(b.hostUrl)}" target="_blank" rel="noopener"><span data-icon="video" data-icon-size="13"></span> Start the call</a>
     <span class="bk-muted">You are the host: let ${esc(b.name || 'them')} in when they arrive. ${Date.parse(b.callOpenedAt || '') > Date.now() - 2 * 3600000 ? 'It was opened early, so it is open now.' : 'It opens 10 minutes before the start.'}</span></div>` : ''}
+  ${b.online && Number(b.callChat) > 0 ? `<div class="bk-actions bk-actions-start bk-call-chat">
+    <button type="button" class="btn btn-sm btn-outline" data-on-click="callChat"><span data-icon="message-circle" data-icon-size="13"></span> Call chat (${Number(b.callChat)} message${Number(b.callChat) === 1 ? '' : 's'})</button>
+    <span class="bk-muted">What was typed in the call's chat, read-only.</span></div>` : ''}
   <div class="bk-actions bk-actions-start">
     <button type="button" class="btn btn-sm btn-outline" data-on-click="move" ${live ? '' : 'disabled'}><span data-icon="move" data-icon-size="13"></span> Move</button>
     <button type="button" class="btn btn-sm btn-outline" data-on-click="done" ${live && b.status !== 'completed' ? '' : 'disabled'}><span data-icon="check" data-icon-size="13"></span> Done</button>
@@ -505,6 +508,13 @@ export async function openBooking(ctx, id) {
                     E.toast(`Not saved: ${errText(err)}`, {type: 'error'});
                 }
             },
+            async callChat() {
+                // The call's chat, read-only (1.5) - one per session, so a class's shared call has one.
+                try {
+                    const [r, ui] = await Promise.all([api.bookings.callChat(b.id), import('/plugins/_lib/admin/ui/transcript.js')]);
+                    await ui.openTranscript({title: `Call chat: ${b.serviceName}`, subtitle: timeRange(b, ctx.tz), items: r?.items || []});
+                } catch (err) { E.toast(`The chat could not be opened: ${errText(err)}`, {type: 'error'}); }
+            },
             move: act(() => moveBooking(ctx, b)),
             done: act(() => setStatus(ctx, b, 'completed')),
             noshow: act(() => setStatus(ctx, b, 'no-show')),

package/plugins/booking/docs/guide.md

@@ -57,7 +57,8 @@ Booking has its own permission, **Booking**, which admins have by default. **See
 ## Booking Pro
 
 Booking Pro adds the following to the free Tool:
-- Online appointments, held as a video call on your site.
+- Online appointments, held as a video call on your site. What is typed in the call's chat is kept: open the booking and click **Call chat** to read it afterwards (a class shares one chat).
+- **Add people** during an online call: the person being booked clicks **Add people** in the call, searches their contacts and the team (or types a name and email), and sends each person their own Join link - by email, and for team members also as a notification and a message in Messages. They knock and you let them in. **Copy link** gives you a link to pass on yourself. This needs the person to be linked to their account on the site (**People & rooms**); without one, their call offers **Copy link** only.
 - **Call now**: open an online booking's call early, or start a video call with anyone straight away - from Booking, a contact or an email.
 - Services that need more than one person or room at once.
 - Classes and group sessions with places and a waiting list.

package/plugins/booking/lib/call.js

@@ -6,7 +6,10 @@
  * same service, start and person - so everyone booked into an online class
  * shares one call, and a one-to-one appointment is a session of one. Links
  * name the session and the booking: `?b=<booking>&t=<customer token>` for the
- * customer, `&h=<host key>` for the person they booked. Booking (free) serves
+ * customer, `&h=<host key>` for the person they booked, `&g=<invite pass>` for
+ * someone the host added while the call runs ("Add people", 1.6: a pass under
+ * the session's `callExtraKey` - never the customer's token or the host key -
+ * who names themselves and knocks). Booking (free) serves
  * these for any booking that is already online, so a lapsed Pro licence
  * strands nobody; only Pro can make a service online in the first place.
  *
@@ -15,6 +18,12 @@
 
 import {createHash, timingSafeEqual} from 'crypto';
 
+// Add people (1.6) needs a core with _lib/call/invite.js; an older one has no invite passes.
+let invite = null;
+try { invite = await import('../../_lib/call/invite.js'); } catch { invite = null; }
+/** Does this core have "Add people"? */
+export const invitesAvailable = () => Boolean(invite);
+
 export const OPENS_BEFORE_MIN = 10;
 export const CLOSES_AFTER_MIN = 60;
 const HOLDING = new Set(['pending', 'confirmed', 'completed', 'no-show']);
@@ -33,6 +42,10 @@ export const joinPath = (settings, b) => `${settings.bookingPath}/call/${session
 /** The host's (the person booked) - never shown to the customer. */
 export const hostPath = (settings, b) => `${settings.bookingPath}/call/${sessionOf(b)}?b=${encodeURIComponent(b.id)}&h=${encodeURIComponent(b.hostKey)}`;
 
+/** A Join link for someone added to the call (1.6): a new pass under the session's extra key. */
+export const invitePath = (settings, b, key) => (invite && key
+    ? `${settings.bookingPath}/call/${sessionOf(b)}?b=${encodeURIComponent(b.id)}&g=${encodeURIComponent(invite.invitePass(key, sessionOf(b)))}` : '');
+
 /** How long a call opened early ("Call now", Booking 1.4) stays open at least. */
 export const OPENED_EARLY_HOURS = 2;
 
@@ -60,7 +73,7 @@ export function callWindow(b, now = Date.now()) {
  *
  * @param {object|null} b - the booking named by `cred.b`
  * @param {string} room - the room in the address
- * @param {{t?: string, h?: string}} cred
+ * @param {{t?: string, h?: string, g?: string}} cred
  */
 export function whoIsCalling(b, room, cred = {}, now = Date.now()) {
     if (!b || b.online !== true || !HOLDING.has(b.status) || sessionOf(b) !== room) return null;
@@ -68,5 +81,8 @@ export function whoIsCalling(b, room, cred = {}, now = Date.now()) {
     // identity: a link the host turns away cannot knock again (the engine remembers it per room).
     if (cred.h && same(cred.h, b.hostKey)) return {...base, host: true, name: b.bookableName || 'Host', identity: `${b.id}:host`};
     if (cred.t && same(cred.t, b.token)) return {...base, host: false, name: b.name || 'Guest', identity: `${b.id}:guest`};
+    // Someone the host added (1.6): their own pass, their own name, and they knock.
+    const nonce = cred.g && b.callExtraKey && invite ? invite.checkInvitePass(b.callExtraKey, room, cred.g) : null;
+    if (nonce) return {...base, host: false, name: '', identity: `${room}:inv:${nonce}`, invited: true};
     return null;
 }

package/plugins/booking/lib/store.js

@@ -313,6 +313,8 @@ export function changeBooking(id, patch, by = '') {
             data.callOpenedAt = String(patch.callOpenedAt || '');
             if (data.callOpenedAt) data.history = [...(data.history || []), {at: data.callOpenedAt, what: 'call-opened', by}].slice(-50);
         }
+        // "Add people" (1.6): the session's key for invite passes - set once, never replaced.
+        if (patch.callExtraKey !== undefined && data.online === true && !data.callExtraKey) data.callExtraKey = String(patch.callExtraKey || '').slice(0, 64);
         if (patch.ext && typeof patch.ext === 'object') data.ext = {...(data.ext || {}), ...patch.ext};
         return {booking: flat(await updateEntry(BOOKINGS, id, data)), from};
     });

package/plugins/booking/plugin.js

@@ -6,6 +6,8 @@
  *   GET  /count                   sidebar badge: bookings still to come today
  *   GET  /bookings?from=&to=      bookings starting in a range (ISO instants)
  *   GET  /bookings/:id · POST /bookings · PUT /bookings/:id · PUT /bookings/:id/move · DELETE /bookings/:id
+ *   GET  /bookings/:id/call-chat  an online booking's call chat, read-only (booking.read; 1.5) - saved per
+ *                                 session (a class's shared call has one) in data/call-chat.json
  *   GET  /slots?service=&from=&to=&with=&ignore=   free times (dates in the business zone)
  *   GET/POST /services · PUT/DELETE /services/:id
  *   GET/POST /bookables · PUT/DELETE /bookables/:id
@@ -24,17 +26,19 @@
  * The booking page itself is plugin.public.js.
  */
 
+import path from 'node:path';
+import {fileURLToPath} from 'node:url';
 import {getConfig} from '../../server/config.js';
 import {getPluginStates} from '../../server/services/plugins.js';
 import {getPermissionsFor} from '../../server/services/roles.js';
 import {getEffectiveRoles} from '../../server/services/userRoles.js';
-import {listUsers} from '../../server/services/users.js';
+import {getUserById, listUsers} from '../../server/services/users.js';
 import {isToolEnabled} from '../../server/services/tools.js';
 import {cleanBookable, cleanCustomer, cleanService, whenLabel} from './public/lib/clean.js';
 import {bookingRange, HOLDING, slotsFor} from './public/lib/slots.js';
 import {addDays, atWallClock, isDate, wallClock} from './public/lib/time.js';
 import {bookingRegistry} from './lib/extensions.js';
-import {hostPath, joinPath, sessionOf, whoIsCalling} from './lib/call.js';
+import {callWindow, hostPath, invitePath, joinPath, sessionOf, whoIsCalling} from './lib/call.js';
 import {compose, icsFor, mailReady, send, siteAddress, siteTitle} from './lib/mail.js';
 import {
     BOOKABLES, BOOKINGS, NAME, SERVICES, SlotTaken, allBookables, allBookings, allServices, calendarBusy, changeBooking,
@@ -83,7 +87,7 @@ const publicFields = (list) => list.map(f => ({
  */
 const adminBooking = (b) => {
     if (!b) return b;
-    const {token, hostKey, ...rest} = b;
+    const {token, hostKey, callExtraKey, ...rest} = b;
     return b.online === true && hostKey ? {...rest, hostUrl: hostPath(settingsNow(), b)} : rest;
 };
 
@@ -119,7 +123,9 @@ function registerShortcodes(hooks) {
     });
 }
 
-export const ASSET_V = '1.4.0';
+export const ASSET_V = '1.6.0';
+
+const HERE = path.dirname(fileURLToPath(import.meta.url));
 
 export default async function booking(fastify, options) {
     const {authenticate, requirePermission} = options.auth;
@@ -135,6 +141,10 @@ export default async function booking(fastify, options) {
     // The online call's rooms (set once the engine is mounted, at the end). A booking cancelled or moved away
     // ends the call it was in, unless someone else is still booked into that session (a class).
     let calls = null;
+    // The call's chat (1.5), saved per session - set with the engine, at the end; null on an older core.
+    let chatStore = null;
+    let whoOf = null;
+    const dataDir = options.dataDir || path.join(HERE, 'data');
     async function endCall(old) {
         if (!calls || old?.online !== true) return;
         const room = sessionOf(old);
@@ -432,7 +442,24 @@ export default async function booking(fastify, options) {
 
     fastify.get('/bookings/:id', can('read'), async (request, reply) => {
         const b = await getBooking(request.params.id);
-        return b ? adminBooking(b) : fail(reply, 404, 'No such booking.');
+        if (!b) return fail(reply, 404, 'No such booking.');
+        // An online booking says how many messages its call's chat holds (the panel offers "Call chat").
+        const callChat = b.online === true && chatStore ? (await chatStore.load(sessionOf(b))).filter(i => i.kind === 'chat').length : undefined;
+        return reply.send({...adminBooking(b), ...(callChat !== undefined ? {callChat} : {})});
+    });
+
+    // The call's chat, read-only (1.5): the session's transcript - a class's shared call has one. Staff with
+    // booking read only; the customer saw it in the call. Staff (host) lines are marked `mine`.
+    fastify.get('/bookings/:id/call-chat', can('read'), async (request, reply) => {
+        const b = await getBooking(request.params.id);
+        if (!b || b.online !== true) return fail(reply, 404, 'No such online booking.');
+        const room = sessionOf(b);
+        const items = chatStore ? await chatStore.load(room) : [];
+        const hosts = new Set(whoOf ? (await allBookings()).filter(x => x.online === true && sessionOf(x) === room)
+            .map(x => whoOf(`${x.id}:host`, '')) : []);
+        reply.header('Cache-Control', 'no-store');
+        return reply.send({messages: items.filter(i => i.kind === 'chat').length,
+            items: items.map(({from, ...i}) => ({...i, mine: i.kind === 'chat' && hosts.has(i.who)}))});
     });
 
     /** Service + the bookables that may take a booking of it (`with` narrows to one). */
@@ -536,6 +563,11 @@ export default async function booking(fastify, options) {
         const b = await getBooking(request.params.id);
         if (!b) return fail(reply, 404, 'No such booking.');
         await removeBooking(b.id);
+        // Its call's chat goes with it - unless someone else is still booked into that session (a class).
+        if (b.online === true && chatStore) {
+            const room = sessionOf(b);
+            if (!(await allBookings()).some(x => x.online === true && sessionOf(x) === room)) await chatStore.remove(room)?.catch?.(() => {});
+        }
         return {ok: true};
     });
 
@@ -788,7 +820,63 @@ export default async function booking(fastify, options) {
     // The engine is core's (_lib/call); an older core without it simply has no calls.
     try {
         const {mountCallRoutes} = await import('../_lib/call/routes.js');
-        calls = mountCallRoutes(fastify, {prefix: '/call', ns: 'booking', resolve: async (request, room, body) => {
+        // The chat is saved per session (1.5; a core with the chat store) so a call reopened later shows it.
+        try {
+            const {createChatStore} = await import('../_lib/call/chatStore.js');
+            chatStore = createChatStore(path.join(dataDir, 'call-chat.json'));
+            whoOf = (await import('../_lib/call/rooms.js')).whoOf || null;
+        } catch { chatStore = null; }
+        // Add people (1.6; a core with services/callInvites.js): the host searches their contacts and the team, and
+        // each person gets their own `&g=` pass under the session's callExtraKey (never the customer's token or the
+        // host key). They knock like the customer. Without that core the button stays hidden.
+        let invites = null;
+        try { invites = await import('../../server/services/callInvites.js'); } catch { invites = null; }
+        /** The host's booking of this session (their identity is `<booking>:host`), or null. */
+        const hostBooking = async (room, identity) => {
+            const id = String(identity || '').endsWith(':host') ? String(identity).slice(0, -5) : '';
+            const b = id ? await getBooking(id).catch(() => null) : null;
+            return b && b.online === true && HOLDING.has(b.status) && sessionOf(b) === room ? b : null;
+        };
+        /** The session's extra key: the one a booking of it already has, else a new one - on every booking of it. */
+        const extraKeyOf = async (b, room) => {
+            const session = (await allBookings()).filter(x => x.online === true && HOLDING.has(x.status) && sessionOf(x) === room);
+            const key = session.map(x => x.callExtraKey).find(Boolean) || (await import('../_lib/call/invite.js')).newInviteKey();
+            for (const x of session) if (!x.callExtraKey) await changeBooking(x.id, {callExtraKey: key}, 'call');
+            // Two sends at once: the first key written stays (changeBooking never replaces one) - use what is stored.
+            return (await getBooking(b.id).catch(() => null))?.callExtraKey || key;
+        };
+        /**
+         * The host's user on the site: the person's linked, active account - else '' (the host link then may be held
+         * by someone from outside - it is emailed to the person's address and sits in the .ics - so they get no team
+         * directory, no contacts and nothing sent in the site's name: Copy link only).
+         */
+        const hostUserOf = async (b) => {
+            const bk = b?.bookableId ? await getBookable(b.bookableId).catch(() => null) : null;
+            const u = bk?.userId ? await getUserById(bk.userId).catch(() => null) : null;
+            return u && u.disabled !== true && u.active !== false && u.isActive !== false ? u.id : '';
+        };
+        const invite = invites ? {
+            search: async (room, q, {identity}) => {
+                const b = await hostBooking(room, identity);
+                const owner = b ? await hostUserOf(b) : '';
+                return owner ? invites.searchInvitees({hostUserId: owner, q}) : [];
+            },
+            send: async (room, people, {identity, name, via, request}) => {
+                const b = await hostBooking(room, identity);
+                if (!b) return {error: 'This booking has no call now.'};
+                const owner = await hostUserOf(b);
+                if (!owner && people.length) return {error: 'Copy the link and pass it on yourself.'};
+                const key = await extraKeyOf(b, room);
+                const s = await liveSettings();
+                const base = invites.inviteOrigin ? invites.inviteOrigin(request) : siteBase(request);
+                const newLink = () => `${base}${invitePath(s, b, key)}`;
+                const targets = await invites.resolveInvitees(people, {hostUserId: owner});
+                const results = await invites.deliverInvites(targets, {linkFor: newLink, hostName: name || b.bookableName || 'Your host',
+                    hostUserId: owner, title: b.serviceName, via, key: `booking:${room}`, expiresAt: callWindow(b).closesAt, log});
+                return {link: newLink(), results};
+            }
+        } : null;
+        calls = mountCallRoutes(fastify, {prefix: '/call', ns: 'booking', ...(chatStore ? {chat: chatStore} : {}), ...(invite ? {invite} : {}), resolve: async (request, room, body) => {
             const b = await getBooking(String(body?.b || '')).catch(() => null);
             // A class opened early ("Call now") is open for everyone in the session - someone who booked in
             // after the click too: take the session's latest opening when this booking has none of its own.
@@ -798,7 +886,10 @@ export default async function booking(fastify, options) {
                     .map(x => x.callOpenedAt).sort().at(-1);
                 if (opened) b.callOpenedAt = opened;
             }
-            return whoIsCalling(b, room, {t: body?.t, h: body?.h});
+            const who = whoIsCalling(b, room, {t: body?.t, h: body?.h, g: body?.g});
+            // Add people for a host with no account here: Copy link only (see hostUserOf).
+            if (who?.host && invite && !(await hostUserOf(b))) return {...who, inviteOptions: {search: false, typed: false, copyLink: true}};
+            return who;
         }});
     } catch (err) {
         log.warn?.(`[booking] online calls unavailable on this CMS: ${err?.message || err}`);

package/plugins/booking/plugin.json

@@ -1,7 +1,7 @@
 {
   "name": "booking",
   "displayName": "Booking",
-  "version": "1.4.1",
+  "version": "1.6.0",
   "tier": "free",
   "description": "Let people book appointments with you or your team, and rooms or equipment, from a booking page on your site. Opening hours, days off and buffers; confirmation and reminder emails with a link to change or cancel; a diary in the admin. Book straight from a contact or an email.",
   "author": "Domma CMS",

package/plugins/booking/plugin.public.js

@@ -20,7 +20,7 @@ import {callWindow, whoIsCalling} from './lib/call.js';
 import {dayLabel, lengthLabel} from './public/lib/page-format.js';
 
 const TEMPLATE = path.join(fileURLToPath(new URL('.', import.meta.url)), 'templates', 'booking.html');
-export const ASSET_V = '1.3.1';
+export const ASSET_V = '1.6.0';
 
 /** Which page a path is, under the booking page's base. */
 export function matchBookingPath(pathname, base) {
@@ -128,7 +128,7 @@ export default async function bookingPublic(fastify) {
      */
     pages.call = async function call(request, reply, s, {room}) {
         const q = request.query || {};
-        const cred = {b: String(q.b || '').slice(0, 64), ...(q.h ? {h: String(q.h).slice(0, 128)} : {t: String(q.t || '').slice(0, 128)})};
+        const cred = {b: String(q.b || '').slice(0, 64), ...(q.h ? {h: String(q.h).slice(0, 128)} : q.g ? {g: String(q.g).slice(0, 128)} : {t: String(q.t || '').slice(0, 128)})};
         const b = await getBooking(cred.b).catch(() => null);
         const who = whoIsCalling(b, room, cred);
         const head = `<header class="bk-hero"><p class="bk-crumbs"><a href="${esc(s.bookingPath)}">${esc(s.pageTitle || 'Book')}</a></p>`;
@@ -136,11 +136,11 @@ export default async function bookingPublic(fastify) {
             return send(reply, request, s, {page: 'call', title: `Call - ${s.pageTitle || 'Book'}`, urlPath: `${s.bookingPath}/call/${room}`, noindex: true,
                 body: `${head}<h1>This call link is not valid</h1></header><p class="bk-note">The booking may have been cancelled or moved. Check the latest email we sent you.</p>`
                     // A reload of the bare address (the call screen took the link out of the address bar): back to it.
-                    + (cred.t || cred.h ? '' : RECOVER_CALL)});
+                    + (cred.t || cred.h || cred.g ? '' : RECOVER_CALL)});
         }
         const {closesAt} = callWindow(b);
         const cfg = {api: '/api/plugins/booking/call', room, cred, title: `${b.serviceName}${who.host ? `: ${b.name}` : b.bookableName ? ` with ${b.bookableName}` : ''}`,
-            askName: false, recordingAllowed: who.recordingAllowed, closesAt};
+            askName: who.invited === true, recordingAllowed: who.recordingAllowed, closesAt};
         return send(reply, request, s, {page: 'call', title: `${b.serviceName} - online`, urlPath: `${s.bookingPath}/call/${room}`, noindex: true,
             body: `<link rel="stylesheet" href="/plugins/_lib/public/call/call.css?v=${ASSET_V}">`
                 + `<div data-dm-call='${esc(JSON.stringify(cfg))}'><noscript><p class="bk-note">The call needs JavaScript switched on.</p></noscript></div>`

package/plugins/booking/tests/api.test.js

@@ -6,6 +6,7 @@
 import {after, before, test} from 'node:test';
 import assert from 'node:assert/strict';
 import fs from 'node:fs/promises';
+import os from 'node:os';
 import path from 'node:path';
 import Fastify from 'fastify';
 import booking from '../plugin.js';
@@ -20,6 +21,7 @@ const DIRS = ['booking-bookables', 'booking-services', 'booking-bookings'].map(c
 const TZ = 'Europe/London';
 let savedPlugins;
 let app;
+let dataDir;
 const sent = [];
 const notices = [];
 const related = {};
@@ -30,11 +32,14 @@ before(async () => {
     for (const d of DIRS) await fs.rm(d, {recursive: true, force: true});
     setMailer(async (msg) => { sent.push(msg); });
     app = Fastify();
+    dataDir = await fs.mkdtemp(path.join(os.tmpdir(), 'booking-data-'));
     const authenticate = async (req) => { req.user = {id: 'u1', name: 'Sam', role: 'admin'}; };
     await app.register(booking, {
         prefix: '',
-        auth: {authenticate, requirePermission: () => async () => {}},
+        // `x-deny` stands for a role without the permission.
+        auth: {authenticate, requirePermission: () => async (req, reply) => { if (req.headers['x-deny']) return reply.code(403).send({error: 'Forbidden'}); }},
         settings: {},
+        dataDir,
         hooks: {
             notify: (n) => notices.push(n), registerShortcode() {},
             registerRelatedItems: (kind, p) => { related[kind] = p; return true; }
@@ -49,6 +54,7 @@ after(async () => {
     if (savedPlugins === null) await fs.rm(PLUGINS, {force: true});
     else await fs.writeFile(PLUGINS, savedPlugins);
     if (savedContacts !== null) await fs.writeFile(CONTACTS, savedContacts);
+    if (dataDir) await fs.rm(dataDir, {recursive: true, force: true});
 });
 
 const call = async (method, url, body) => {
@@ -355,6 +361,63 @@ test('online: a service an extension makes online gives a call - the customer an
     }
 });
 
+test('online: the call\'s chat is saved per session - counted on the booking, read by staff, seeds the reopened call', async () => {
+    const reg = bookingRegistry();
+    reg.register('test-online', {rules: (s) => (s?.slug === 'chat-call' ? {online: true} : {})});
+    try {
+        const all = Object.fromEntries(['mon', 'tue', 'wed', 'thu', 'fri', 'sat', 'sun'].map(d => [d, [{from: '00:00', to: '24:00'}]]));
+        let r = await call('POST', '/bookables', {name: 'Cara', kind: 'person', hours: all});
+        const cara = r.body;
+        r = await call('POST', '/services', {name: 'Chat call', duration: 30, minNoticeMinutes: 0, bookables: [cara.id]});
+        const svc = r.body;
+        const start = new Date(Math.ceil((Date.now() + 5 * 60000) / 60000) * 60000).toISOString();
+        r = await call('POST', '/bookings', {serviceId: svc.id, startAt: start, customer: {name: 'Gus Guest', email: 'gus@example.com'}, force: true});
+        assert.equal(r.status, 201, JSON.stringify(r.body));
+        const b = r.body;
+        const raw = JSON.parse(await fs.readFile(path.resolve('content/collections/booking-bookings/data.json'), 'utf8'))
+            .map(e => e.data ? {id: e.id, ...e.data} : e).find(x => x.id === b.id);
+        const room = b.hostUrl.split('/call/')[1].split('?')[0];
+        const hostKey = new URL(`http://x${b.hostUrl}`).searchParams.get('h');
+        const as = (p) => ({'x-call-id': p.id, 'x-call-secret': p.secret});
+        const post = (u, payload, headers = {}) => app.inject({method: 'POST', url: u, payload, headers});
+
+        assert.equal((await call('GET', `/bookings/${b.id}`)).body.callChat, 0, 'no chat yet');
+        const host = (await post(`/call/${room}/join`, {b: b.id, h: hostKey})).json();
+        const guest = (await post(`/call/${room}/join`, {b: b.id, t: raw.token})).json();
+        assert.equal(guest.state, 'waiting');
+        await post(`/call/${room}/answer`, {who: guest.id, yes: true}, as(host));
+        assert.equal((await post(`/call/${room}/chat`, {text: 'Hello Gus'}, as(host))).statusCode, 200);
+        assert.equal((await post(`/call/${room}/chat`, {text: 'Hi <Cara>'}, as(guest))).statusCode, 200);
+        await post(`/call/${room}/leave`, {}, as(guest));
+        await post(`/call/${room}/leave`, {}, as(host));
+        await new Promise(res => setTimeout(res, 30));
+
+        // Saved in the plugin's data folder, keyed by the session.
+        const file = JSON.parse(await fs.readFile(path.join(dataDir, 'call-chat.json'), 'utf8'));
+        assert.equal(file.rooms[room].items.filter(i => i.kind === 'chat').length, 2);
+        assert.equal((await call('GET', `/bookings/${b.id}`)).body.callChat, 2);
+        r = await call('GET', `/bookings/${b.id}/call-chat`);
+        assert.equal(r.status, 200);
+        assert.equal(r.body.messages, 2);
+        assert.deepEqual(r.body.items.filter(i => i.kind === 'chat').map(i => [i.name, i.text, i.mine]), [['Cara', 'Hello Gus', true], ['Gus Guest', 'Hi <Cara>', false]]);
+        assert.ok(r.body.items.every(i => !('from' in i)));
+        assert.ok(r.body.items.some(i => i.kind === 'system' && i.text === 'Gus Guest left'));
+        // Staff without booking read: refused. Not online / missing: 404.
+        assert.equal((await app.inject({method: 'GET', url: `/bookings/${b.id}/call-chat`, headers: {'x-deny': '1'}})).statusCode, 403);
+        assert.equal((await call('GET', '/bookings/nope/call-chat')).status, 404);
+
+        // Everyone left, the room is gone: rejoining shows the earlier chat.
+        const again = (await post(`/call/${room}/join`, {b: b.id, h: hostKey})).json();
+        const polled = (await app.inject({method: 'GET', url: `/call/${room}/poll?since=0`, headers: as(again)})).json();
+        const admitted = polled.events.find(e => e.type === 'admitted');
+        assert.ok(admitted.chat.some(i => i.text === 'Hello Gus') && admitted.chat.some(i => i.text === 'Hi <Cara>'));
+        await post(`/call/${room}/leave`, {}, as(again));
+        await call('DELETE', `/bookings/${b.id}`);
+    } finally {
+        reg.unregister('test-online');
+    }
+});
+
 test('extensions: banner actions reach the bootstrap, only under their owner, one per id', async () => {
     const reg = bookingRegistry();
     assert.ok(reg.version >= 4);
@@ -443,3 +506,117 @@ test('an early-opened call lasts two hours from the click, not all the way to a
     const soon = {...b, callOpenedAt: '2031-01-10T09:00:00.000Z'};
     assert.deepEqual(callWindow(soon, at('2031-01-10T09:05:00.000Z')), {opensAt: '2031-01-10T09:00:00.000Z', closesAt: '2031-01-10T12:00:00.000Z'}, 'joined up when they meet');
 });
+
+test('1.6 Add people: the host adds a team member and an address; each gets their own &g= pass (never the customer token or host key); they knock', async () => {
+    const reg = bookingRegistry();
+    reg.register('test-online', {rules: (s) => (s?.slug === 'team-call' ? {online: true} : {})});
+    const {createUser, deleteUser} = await import('../../../server/services/users.js');
+    await (await import('../../../server/services/roles.js')).load();
+    const {setInviteMailer, resetInviteLimits} = await import('../../../server/services/callInvites.js');
+    const {whoIsCalling} = await import('../lib/call.js');
+    const tag = Math.random().toString(36).slice(2, 7);
+    const tess = await createUser({name: `Tess Host ${tag}`, email: `tess-${tag}@example.test`, password: 'password123', role: 'user'});
+    const mate = await createUser({name: `Milo Mate ${tag}`, email: `milo-${tag}@example.test`, password: 'password123', role: 'user'});
+    const mails = [];
+    setInviteMailer(async (m) => { mails.push(m); });
+    resetInviteLimits();
+    try {
+        const all = Object.fromEntries(['mon', 'tue', 'wed', 'thu', 'fri', 'sat', 'sun'].map(d => [d, [{from: '00:00', to: '24:00'}]]));
+        let r = await call('POST', '/bookables', {name: 'Tess', kind: 'person', hours: all, userId: tess.id});
+        const bk = r.body;
+        assert.equal(bk.userId, tess.id, 'the person is a user of the site');
+        const svc = (await call('POST', '/services', {name: 'Team call', duration: 30, minNoticeMinutes: 0, bookables: [bk.id]})).body;
+        const start = new Date(Math.ceil((Date.now() + 5 * 60000) / 60000) * 60000).toISOString();
+        r = await call('POST', '/bookings', {serviceId: svc.id, startAt: start, customer: {name: 'Gus Guest', email: 'gus@example.com'}, force: true, notify: false});
+        assert.equal(r.status, 201, JSON.stringify(r.body));
+        const b = r.body;
+        const raw = await reg.services.getBooking(b.id);
+        const room = b.hostUrl.split('/call/')[1].split('?')[0];
+        const as = (p) => ({'x-call-id': p.id, 'x-call-secret': p.secret});
+        const post = (u, payload, headers = {}) => app.inject({method: 'POST', url: u, payload, headers});
+        const host = (await post(`/call/${room}/join`, {b: b.id, h: raw.hostKey})).json();
+        const guest = (await post(`/call/${room}/join`, {b: b.id, t: raw.token})).json();
+        assert.equal(host.canInvite, true);
+        assert.equal(guest.canInvite, false);
+
+        let s = await app.inject({method: 'GET', url: `/call/${room}/people?q=Milo`, headers: as(host)});
+        assert.equal(s.statusCode, 200);
+        assert.ok(s.json().people.some(p => p.kind === 'user' && p.id === mate.id));
+        assert.ok(!(await app.inject({method: 'GET', url: `/call/${room}/people?q=Tess`, headers: as(host)})).json().people.some(p => p.id === tess.id), 'not the host');
+        assert.equal((await app.inject({method: 'GET', url: `/call/${room}/people?q=Milo`, headers: as(guest)})).statusCode, 403, 'the customer cannot');
+
+        r = await post(`/call/${room}/invite`, {people: [{kind: 'user', id: mate.id}, {name: 'Ext Person', email: 'ext@example.com'}], via: {email: true}}, {...as(host), host: 'site.test'});
+        assert.equal(r.statusCode, 200, r.body);
+        assert.deepEqual(r.json().results.map(x => [x.name, x.emailed]), [[`Milo Mate ${tag}`, true], ['Ext Person', true]]);
+        const linkTo = (to) => new URL(mails.find(m => m.to === to).text.match(/https?:\/\/\S+/)[0]);
+        const milo = linkTo(mate.email);
+        const ext = linkTo('ext@example.com');
+        assert.equal(milo.pathname, `/booking/call/${room}`);
+        assert.equal(milo.searchParams.get('b'), b.id);
+        assert.ok(milo.searchParams.get('g') && !milo.searchParams.get('t') && !milo.searchParams.get('h'));
+        assert.notEqual(milo.searchParams.get('g'), ext.searchParams.get('g'));
+        for (const u of [milo, ext]) assert.ok(!u.href.includes(raw.token) && !u.href.includes(raw.hostKey), 'no token or host key reused');
+
+        const kept = await reg.services.getBooking(b.id);
+        assert.ok(kept.callExtraKey && kept.callExtraKey !== raw.token && kept.callExtraKey !== raw.hostKey);
+        assert.equal((await call('GET', `/bookings/${b.id}`)).body.callExtraKey, undefined, 'never shown in the admin');
+
+        // They knock with their own name; the customer keeps their place.
+        const m1 = (await post(`/call/${room}/join`, {b: b.id, g: milo.searchParams.get('g'), name: 'Milo'})).json();
+        const e1 = (await post(`/call/${room}/join`, {b: b.id, g: ext.searchParams.get('g'), name: 'Ext'})).json();
+        assert.equal(m1.state, 'waiting');
+        assert.equal(e1.state, 'waiting');
+        assert.equal(m1.canInvite, false);
+        assert.deepEqual((await app.inject({method: 'GET', url: `/call/${room}/poll?since=0`, headers: as(host)})).json().events
+            .filter(e => e.type === 'waiting').at(-1).waiting.map(w => w.name), ['Gus Guest', 'Milo', 'Ext']);
+        assert.equal((await post(`/call/${room}/join`, {b: b.id, g: 'abcdefgh.AAAAAAAAAAAAAAAAAAAAAAAA', name: 'X'})).statusCode, 404, 'forged');
+        const who = whoIsCalling(kept, room, {g: milo.searchParams.get('g')});
+        assert.equal(who.invited, true);
+        assert.equal(who.host, false);
+
+        // Copy link: a new pass each time.
+        const copy = (await post(`/call/${room}/invite`, {people: []}, {...as(host), host: 'site.test'})).json();
+        assert.match(copy.link, new RegExp(`/booking/call/${room}\\?b=${b.id}&g=`));
+        for (const p of [host, guest, m1, e1]) await post(`/call/${room}/leave`, {}, as(p));
+        await call('DELETE', `/bookings/${b.id}`);
+    } finally {
+        setInviteMailer(null);
+        reg.unregister('test-online');
+        for (const u of [tess, mate]) await deleteUser(u.id).catch(() => {});
+    }
+});
+
+test('1.6 Add people: a person with no account on the site (the host link may be anyone\'s) gets Copy link only - no directory, nothing sent', async () => {
+    const reg = bookingRegistry();
+    reg.register('test-online', {rules: (s) => (s?.slug === 'outside-call' ? {online: true} : {})});
+    const {setInviteMailer} = await import('../../../server/services/callInvites.js');
+    const mails = [];
+    setInviteMailer(async (m) => { mails.push(m); });
+    try {
+        const all = Object.fromEntries(['mon', 'tue', 'wed', 'thu', 'fri', 'sat', 'sun'].map(d => [d, [{from: '00:00', to: '24:00'}]]));
+        const olga = (await call('POST', '/bookables', {name: 'Olga Outside', kind: 'person', hours: all, email: 'olga@elsewhere.example'})).body;
+        const svc = (await call('POST', '/services', {name: 'Outside call', duration: 30, minNoticeMinutes: 0, bookables: [olga.id]})).body;
+        const start = new Date(Math.ceil((Date.now() + 5 * 60000) / 60000) * 60000).toISOString();
+        const b = (await call('POST', '/bookings', {serviceId: svc.id, startAt: start, customer: {name: 'Gus', email: 'gus2@example.com'}, force: true, notify: false})).body;
+        const raw = await reg.services.getBooking(b.id);
+        const room = b.hostUrl.split('/call/')[1].split('?')[0];
+        const post = (u, payload, headers = {}) => app.inject({method: 'POST', url: u, payload, headers});
+        const host = (await post(`/call/${room}/join`, {b: b.id, h: raw.hostKey})).json();
+        assert.equal(host.canInvite, true);
+        assert.deepEqual(host.inviteOptions, {search: false, typed: false, copyLink: true, external: true});
+        const as = {'x-call-id': host.id, 'x-call-secret': host.secret};
+        assert.deepEqual((await app.inject({method: 'GET', url: `/call/${room}/people?q=a`, headers: as})).json(), {people: []}, 'no team directory, no contacts');
+        for (const person of [{name: 'Spam', email: 'victim@example.com'}, {kind: 'user', id: 'someone'}, {kind: 'contact', id: 'c1'}]) {
+            assert.equal((await post(`/call/${room}/invite`, {people: [person], via: {email: true}}, as)).statusCode, 400);
+        }
+        assert.equal(mails.length, 0, 'nothing sent in the site\'s name');
+        const copy = (await post(`/call/${room}/invite`, {people: []}, as)).json();
+        assert.match(copy.link, new RegExp(`/booking/call/${room}\\?b=${b.id}&g=`), 'Copy link: their own pass');
+        const knock = (await post(`/call/${room}/join`, {b: b.id, g: new URL(copy.link).searchParams.get('g'), name: 'Friend'})).json();
+        assert.equal(knock.state, 'waiting');
+        await call('DELETE', `/bookings/${b.id}`);
+    } finally {
+        setInviteMailer(null);
+        reg.unregister('test-online');
+    }
+});