domma-cms 0.113.0 → 0.114.1

package/plugins/support/admin/views/inbox.js

@@ -0,0 +1,211 @@
+/**
+ * Support on the manager: every site's requests. Waiting on Domma comes first,
+ * urgent at the top; a request opens in a panel with the conversation, a reply
+ * box (the customer is emailed), status, priority and internal notes.
+ */
+
+import {TONE, api, esc, listOf, openPanel, refreshBadge, stamp, store, threadHtml, when} from '../lib/kit.js';
+
+const ROW = `
+<div class="sp-row" data-id="{{key}}" tabindex="0" role="button">
+  <span class="sp-cat" data-bind-title="categoryLabel"><span data-icon="{{icon}}" data-icon-size="16"></span></span>
+  <span class="sp-main"><strong data-bind-text="subject"></strong><small data-bind-text="meta"></small></span>
+  <span class="sp-urgent" data-bind-hidden="!urgent">Urgent</span>
+  <span class="sp-chip" data-bind-class="tone" data-bind-text="statusLabel"></span>
+</div>`;
+
+const FILTERS = [
+    {key: 'open', label: 'Waiting on Domma'},
+    {key: 'answered', label: 'Answered'},
+    {key: 'closed', label: 'Resolved'},
+    {key: 'all', label: 'All'}
+];
+
+export async function mount(root, ctx) {
+    const {kit, scope, here, meta, id, mode} = ctx;
+    const categories = meta.categories || [];
+    const statuses = meta.statuses || [];
+    const iconOf = (c) => categories.find(x => x.key === c)?.icon || 'message-square';
+    const labelOf = (c) => categories.find(x => x.key === c)?.short || c;
+    const inboxLabel = (s) => statuses.find(x => x.key === s)?.inboxLabel || s;
+
+    const tickets = M.observable([]);
+    const loading = M.observable(true);
+    const error = M.observable('');
+    const filter = M.observable(store.get('support.filter') || 'open');
+    const query = M.observable('');
+    const rows = M.observable([]);
+    const counts = M.observable({});
+    scope(M.effect(() => {
+        const all = tickets.value;
+        counts.value = Object.fromEntries(FILTERS.map(f => [f.key, f.key === 'all' ? all.length : all.filter(t => t.status === f.key).length]));
+        const q = query.value.trim().toLowerCase();
+        rows.value = all
+            .filter(t => filter.value === 'all' || t.status === filter.value)
+            .filter(t => !q || [t.subject, t.siteName, t.userName, t.userEmail, ...(t.messages || []).map(m => m.body)]
+                .some(v => String(v || '').toLowerCase().includes(q)))
+            // Urgent first, then whoever has waited longest for us (newest first elsewhere).
+            .sort((a, b) => (b.priority === 'urgent') - (a.priority === 'urgent')
+                || (filter.value === 'open' ? String(a.lastAt).localeCompare(String(b.lastAt)) : String(b.lastAt).localeCompare(String(a.lastAt))))
+            .map(t => ({
+                key: t.id,
+                subject: t.subject,
+                icon: iconOf(t.category),
+                categoryLabel: labelOf(t.category),
+                meta: [t.siteName, t.userName, `${t.lastFrom === 'domma' ? 'we wrote' : 'they wrote'} ${when(t.lastAt)}`].filter(Boolean).join(' · '),
+                statusLabel: inboxLabel(t.status),
+                tone: `is-${TONE[t.status] || 'muted'}`,
+                urgent: t.priority === 'urgent' && t.status !== 'closed'
+            }));
+    }));
+
+    const card = mode.contact || {};
+    root.innerHTML = '';
+    const view = document.createElement('div');
+    view.className = 'sp-card';
+    view.innerHTML = `
+<div class="sp-bar">
+  <div class="sp-seg" role="tablist" aria-label="Filter">
+    ${FILTERS.map(f => `<button type="button" role="tab" data-filter="${f.key}" data-bind-class="filter.value === '${f.key}' && 'is-on'">${esc(f.label)} <b data-bind-text="counts.value['${f.key}'] || 0"></b></button>`).join('')}
+  </div>
+  <span class="sp-spacer"></span>
+  <input class="form-input sp-search" type="search" placeholder="Search requests" data-model="query.value" aria-label="Search requests">
+  <span data-help-title="Support inbox" data-help="Every site's support requests. Replying emails the customer a link back to the conversation in their own admin, and moves it to Answered (or Resolved, if you choose). A customer writing again moves it back to Waiting on Domma. Urgent requests sort first and turn the sidebar badge red. Internal notes never reach the site."></span>
+</div>
+<p class="sp-note sp-small">Customers see: ${esc([card.email, card.phone, card.hours].filter(Boolean).join(' · ') || 'no contact details set')}${mode.notifyEmail ? ` · New requests are emailed to ${esc(mode.notifyEmail)}` : ' · New requests are not emailed (no notifyEmail set)'}.</p>
+<div class="sp-loading dm-loading-slot" data-bind-hidden="!loading.value">Loading...</div>
+<p class="sp-note is-bad" data-bind-hidden="!error.value" data-bind-text="error.value"></p>
+<p class="sp-note" data-bind-hidden="loading.value || rows.value.length">Nothing here.</p>
+<div class="sp-list" data-each="rows.value key=key"></div>`;
+    root.appendChild(view);
+    scope(kit.helpPopovers(view, {position: 'bottom'}));
+    const listEl = view.querySelector('.sp-list');
+    listEl.innerHTML = ROW;
+    scope(M.effect(() => { rows.value; Promise.resolve().then(() => { M.flush?.(); I.scan(listEl); }); }));
+
+    async function load() {
+        loading.value = true;
+        try {
+            const res = await api.tickets();
+            if (!here()) return;
+            tickets.value = listOf(res, 'tickets');
+            error.value = '';
+        } catch (err) {
+            error.value = `Could not load requests: ${err.message || err}`;
+        } finally {
+            loading.value = false;
+        }
+    }
+
+    const byId = (tid) => tickets.peek().find(t => t.id === tid);
+    const replace = (t) => { tickets.value = tickets.peek().map(x => (x.id === t.id ? {...x, ...t} : x)); refreshBadge(); };
+
+    async function open(tid) {
+        let t = byId(tid);
+        if (!t) {
+            try { t = await api.ticket(tid); } catch { E.toast('That request is no longer here.', {type: 'warning'}); return; }
+        }
+        const draft = M.observable('');
+        const after = M.observable('answered');
+        const notes = M.observable(t.notes || '');
+        const priority = M.observable(t.priority || 'normal');
+        const status = M.observable(t.status);
+        const busy = M.observable(false);
+        let panel = null;
+        const render = () => {
+            const cur = byId(tid) || t;
+            status.value = cur.status;
+            priority.value = cur.priority;
+            const box = panel?.panel.querySelector('.sp-thread-host');
+            if (box) { box.innerHTML = threadHtml(cur.messages, 'domma'); box.scrollTop = box.scrollHeight; }
+            const urgent = panel?.panel.querySelector('[data-ref="urgent"]');
+            if (urgent) urgent.checked = cur.priority === 'urgent';
+            const chip = panel?.panel.querySelector('[data-ref="status"]');
+            if (chip) { chip.textContent = inboxLabel(cur.status); chip.className = `sp-chip is-${TONE[cur.status] || 'muted'}`; }
+        };
+        const siteUrl = t.siteHost ? `https://${t.siteHost}/admin/` : '';
+        const run = async (fn) => {
+            if (busy.peek()) return;
+            busy.value = true;
+            try { await fn(); render(); } catch (err) { E.toast(err.message || String(err), {type: 'error'}); } finally { busy.value = false; }
+        };
+        panel = await openPanel({
+            title: t.subject,
+            size: 'lg',
+            model: {draft, after, notes, priority, status, busy},
+            html: `<div class="sp-detail">
+  <dl class="sp-facts">
+    <div><dt>Status</dt><dd><span data-ref="status" class="sp-chip"></span></dd></div>
+    <div><dt>Site</dt><dd>${siteUrl ? `<a href="${esc(siteUrl)}" target="_blank" rel="noopener">${esc(t.siteName)}</a>` : esc(t.siteName)}</dd></div>
+    <div><dt>From</dt><dd>${esc(t.userName)}${t.userEmail ? ` · <a href="mailto:${esc(t.userEmail)}">${esc(t.userEmail)}</a>` : ''}</dd></div>
+    <div><dt>About</dt><dd>${esc(labelOf(t.category))}</dd></div>
+    <div><dt>Opened</dt><dd>${esc(stamp(t.createdAt))}</dd></div>
+    ${t.where ? `<div><dt>Where</dt><dd>${esc(t.where)}</dd></div>` : ''}
+    ${t.cmsVersion ? `<div><dt>CMS</dt><dd>${esc(t.cmsVersion)}</dd></div>` : ''}
+  </dl>
+  <div class="sp-thread-host"></div>
+  <div class="sp-reply">
+    <label class="form-label" for="sp-answer">Reply <span data-help="The customer sees it in their admin and gets it by email${t.userEmail ? '' : ' (this one has no email on record, so only in their admin)'}."></span></label>
+    <textarea id="sp-answer" class="form-textarea" rows="5" maxlength="8000" data-model="draft.value" placeholder="Write to ${esc(t.userName || 'the customer')}"></textarea>
+    <div class="sp-actions">
+      <label class="sp-inline">Then <select class="form-select" data-model="after.value"><option value="answered">wait for them</option><option value="closed">mark resolved</option></select></label>
+      <span class="sp-spacer"></span>
+      <button type="button" class="btn btn-sm btn-ghost" data-on-click="resolve" data-bind-hidden="status.value === 'closed'" data-bind-disabled="busy.value">Resolve without reply</button>
+      <button type="button" class="btn btn-sm btn-ghost" data-on-click="reopen" data-bind-hidden="status.value !== 'closed'" data-bind-disabled="busy.value">Reopen</button>
+      <button type="button" class="btn btn-sm btn-primary" data-on-click="send" data-bind-disabled="busy.value || !draft.value.trim()"><span data-icon="send" data-icon-size="13"></span> Send reply</button>
+    </div>
+  </div>
+  <div class="sp-side">
+    <label class="sp-inline"><input type="checkbox" data-ref="urgent"> Urgent</label>
+    <label class="form-label" for="sp-notes">Internal notes <span data-help="For the Domma team only - never sent to the site."></span></label>
+    <textarea id="sp-notes" class="form-textarea" rows="3" data-model="notes.value"></textarea>
+    <div class="sp-actions">
+      <button type="button" class="btn btn-sm btn-ghost sp-danger" data-on-click="remove" data-bind-disabled="busy.value"><span data-icon="trash" data-icon-size="13"></span> Delete</button>
+      <span class="sp-spacer"></span>
+      <button type="button" class="btn btn-sm btn-ghost" data-on-click="saveNotes" data-bind-disabled="busy.value">Save notes</button>
+    </div>
+  </div>
+</div>`,
+            methods: {
+                send: () => run(async () => {
+                    const next = await api.reply(tid, {body: draft.peek(), status: after.peek()});
+                    replace(next);
+                    draft.value = '';
+                    E.toast(t.userEmail ? `Sent - ${t.userName || 'the customer'} has been emailed.` : 'Sent - it shows in their admin.', {type: 'success'});
+                }),
+                resolve: () => run(async () => { replace(await api.reply(tid, {status: 'closed'})); E.toast('Resolved.', {type: 'success'}); }),
+                reopen: () => run(async () => { replace(await api.update(tid, {status: 'open'})); }),
+                saveNotes: () => run(async () => { replace(await api.update(tid, {notes: notes.peek()})); E.toast('Notes saved.', {type: 'success'}); }),
+                remove: async () => {
+                    if (!await E.confirm(`Delete "${esc(t.subject)}"? It goes from ${esc(t.siteName)}'s admin too.`)) return;
+                    await run(async () => {
+                        await api.remove(tid);
+                        tickets.value = tickets.peek().filter(x => x.id !== tid);
+                        refreshBadge();
+                        panel?.close();
+                    });
+                }
+            }
+        });
+        panel.panel.querySelector('[data-ref="urgent"]').addEventListener('change', (e) => run(async () => {
+            replace(await api.update(tid, {priority: e.target.checked ? 'urgent' : 'normal'}));
+        }));
+        render();
+    }
+
+    const bindings = M.applyBindings({tickets, loading, error, filter, query, rows, counts}, view, {methods: {}});
+    scope(() => bindings.dispose());
+
+    const seg = view.querySelector('.sp-seg');
+    const onFilter = (e) => { const b = e.target.closest('[data-filter]'); if (b) { filter.value = b.dataset.filter; store.set('support.filter', filter.value); } };
+    seg.addEventListener('click', onFilter);
+    const onClick = (e) => { const row = e.target.closest('.sp-row'); if (row) open(row.dataset.id); };
+    const onKey = (e) => { const row = e.target.closest('.sp-row'); if (row && (e.key === 'Enter' || e.key === ' ')) { e.preventDefault(); open(row.dataset.id); } };
+    listEl.addEventListener('click', onClick);
+    listEl.addEventListener('keydown', onKey);
+    scope(() => { seg.removeEventListener('click', onFilter); listEl.removeEventListener('click', onClick); listEl.removeEventListener('keydown', onKey); });
+
+    I.scan(view);
+    await load();
+    if (id && here()) open(id);
+}

package/plugins/support/admin/views/support.js

@@ -0,0 +1,63 @@
+/**
+ * Support - one sidebar entry, two screens, decided by the server:
+ *
+ *   on a site       the contact card and this site's conversations with Domma (desk.js)
+ *   on the manager  the inbox of every site's requests (inbox.js)
+ *
+ *   #/plugins/support        the screen
+ *   #/plugins/support/<id>   the same, with that request open (a notification's or email's link):
+ *                            on a site the id is the request's ref, on the manager its entry id
+ *
+ * Path segments, not ?query: the admin router 404s a query on a fresh load.
+ */
+
+import {api, loadKit} from '../lib/kit.js';
+
+const ROUTE = /^#\/plugins\/support(\/|$)/;
+const V = '1.0.0';
+let lifetime = null;
+
+export const supportView = {
+    templateUrl: '/plugins/support/admin/templates/support.html',
+
+    async onMount($container) {
+        const kit = await loadKit();
+        lifetime ??= kit.viewLifetime(ROUTE);
+        if (!ROUTE.test(location.hash)) return;
+        lifetime.reset();
+        const scope = (fn) => { lifetime.add(fn); return fn; };
+        const container = $container.get(0);
+        const root = container.querySelector('[data-support-admin]') || container;
+        const mountedFor = location.hash;
+        const here = () => location.hash === mountedFor && root.isConnected;
+        const m = location.hash.match(/^#\/plugins\/support\/([^/?#]+)/);
+        const id = m ? decodeURIComponent(m[1]) : '';
+
+        const fail = (text) => {
+            root.innerHTML = '';
+            const p = document.createElement('p');
+            p.className = 'sp-note is-bad';
+            p.textContent = text;
+            root.appendChild(p);
+        };
+
+        let mode;
+        let meta;
+        try {
+            [mode, meta] = await Promise.all([api.mode(), api.meta()]);
+        } catch (err) {
+            fail(`Support could not load: ${err.message || err}. You can always email support@dommajs.org.`);
+            return;
+        }
+        if (!here()) return;
+        try {
+            const screen = mode.mode === 'receiver' ? 'inbox' : 'desk';
+            const mod = await import(`/plugins/support/admin/views/${screen}.js?v=${V}`);
+            if (!here()) return;
+            const cleanup = await mod.mount(root, {kit, scope, here, meta, mode, id});
+            if (typeof cleanup === 'function') scope(cleanup);
+        } catch (err) {
+            fail(`This screen could not load: ${err.message || err}`);
+        }
+    }
+};

package/plugins/support/collections/support-tickets.json

@@ -0,0 +1,30 @@
+{
+  "slug": "support-tickets",
+  "title": "Support requests",
+  "description": "Support requests from every site the manager runs. Read and answer them in Support, never here: the sites see only what the Support inbox lets them.",
+  "plugin": "support",
+  "fields": [
+    {"name": "subject", "label": "Subject", "type": "text", "required": true},
+    {"name": "category", "label": "Category", "type": "text"},
+    {"name": "priority", "label": "Priority", "type": "text"},
+    {"name": "status", "label": "Status", "type": "text"},
+    {"name": "site", "label": "Site", "type": "text"},
+    {"name": "ref", "label": "Reference", "type": "text"},
+    {"name": "where", "label": "Where", "type": "text"},
+    {"name": "cmsVersion", "label": "CMS version", "type": "text"},
+    {"name": "userId", "label": "User id", "type": "text"},
+    {"name": "userName", "label": "From", "type": "text"},
+    {"name": "userEmail", "label": "Email", "type": "text"},
+    {"name": "messages", "label": "Messages", "type": "array", "items": "object"},
+    {"name": "lastFrom", "label": "Last from", "type": "text"},
+    {"name": "lastAt", "label": "Last message", "type": "text"},
+    {"name": "notes", "label": "Internal notes", "type": "textarea"},
+    {"name": "history", "label": "History", "type": "array", "items": "object"}
+  ],
+  "api": {
+    "create": {"enabled": false, "access": "admin"},
+    "read": {"enabled": false, "access": "admin"},
+    "update": {"enabled": false, "access": "admin"},
+    "delete": {"enabled": false, "access": "admin"}
+  }
+}

package/plugins/support/config.js

@@ -0,0 +1,28 @@
+/**
+ * Support - default settings (config/plugins.json `support.settings` overrides).
+ *
+ * The contact card (every site):
+ *   email, phone, hours, responseTime
+ *     On the MANAGER these are the source: each managed site gets them with its
+ *     next sync, so a change of hours is made once, on dcm. A site's own values
+ *     are used only until it has heard from the manager, and on a standalone
+ *     install (which never does).
+ *
+ * Site side:
+ *   syncMinutes    how often a site sends what is waiting and looks for replies
+ *
+ * Manager side:
+ *   notifyEmail    where new requests and customer replies are emailed ('' = none)
+ *   perSiteMax     messages one site may send in perSiteMinutes; more answer 429
+ *   perSiteMinutes the window for perSiteMax
+ */
+export default {
+    email: 'support@dommajs.org',
+    phone: '',
+    hours: 'Monday to Friday, 9am to 5pm (UK time)',
+    responseTime: 'We answer within one working day, and urgent requests first.',
+    syncMinutes: 5,
+    notifyEmail: 'support@dommajs.org',
+    perSiteMax: 20,
+    perSiteMinutes: 10
+};

package/plugins/support/lib/mail.js

@@ -0,0 +1,58 @@
+/**
+ * Support mail: one way out, and never a pretend one.
+ *
+ * Without an SMTP host the CMS falls back to Ethereal and "succeeds" while
+ * delivering nothing, so with no SMTP these are simply not sent - the in-admin
+ * inbox and notices still carry everything. Tests swap the sender with
+ * `setMailer()`.
+ *
+ * @module support/lib/mail
+ */
+import {createTransport, isSmtpConfigured, sendEmail} from '../../../server/services/email.js';
+import {getConfig} from '../../../server/config.js';
+
+let override = null;
+let transport = null;
+let transportFor = '';
+
+/** Tests only: `fn(msg)` receives every message instead. Pass null to restore. */
+export function setMailer(fn) { override = fn; }
+
+const site = () => { try { return getConfig('site') || {}; } catch { return {}; } };
+
+/** This server's own address, as links in emails need it. */
+export function siteUrl() {
+    const s = site();
+    return String(s.url || s.baseUrl || '').replace(/\/+$/, '');
+}
+
+/**
+ * Send one message. Returns false (and logs) rather than throwing: a lost email
+ * must never fail the request that caused it, and callers do not await it - an
+ * unhandled rejection stops the whole server.
+ *
+ * @param {{to: string, subject: string, html: string, text: string, replyTo?: string}} msg
+ * @returns {Promise<boolean>}
+ */
+export async function send(msg, {log} = {}) {
+    try {
+        if (!msg?.to) return false;
+        if (override) { await override(msg); return true; }
+        const s = site();
+        const smtp = s.smtp || {};
+        if (!isSmtpConfigured(smtp)) return false;
+        const key = JSON.stringify([smtp.host, smtp.port, smtp.user, smtp.secure]);
+        if (!transport || transportFor !== key) { transport = await createTransport(smtp); transportFor = key; }
+        await sendEmail(transport, {
+            from: smtp.fromAddress || 'noreply@example.com',
+            fromName: 'Domma Support',
+            to: msg.to, subject: msg.subject, html: msg.html, text: msg.text,
+            ...(msg.replyTo && {replyTo: msg.replyTo})
+        });
+        return true;
+    } catch (err) {
+        const line = `[support] Email to ${msg?.to} not sent: ${err?.message || err}`;
+        try { if (typeof log?.error === 'function') log.error(line); else console.error(line); } catch { /* never */ }
+        return false;
+    }
+}

package/plugins/support/lib/receiver.js

@@ -0,0 +1,182 @@
+/**
+ * Support - the RECEIVING side, on the manager (dcm).
+ *
+ * Requests live in the `support-tickets` collection. Its API is off on all four
+ * verbs - a collection's default is a public read, and these carry customers'
+ * names, emails and words.
+ *
+ * A site is who its fleet token says it is (site-manager/services/fleetTokens.js,
+ * memory only, minted when the manager forked it). That module only exists where
+ * Site Manager does, which is also how this plugin knows it is on the manager.
+ *
+ * @module support/lib/receiver
+ */
+import fs from 'node:fs';
+import path from 'node:path';
+import {fileURLToPath} from 'node:url';
+import {createCollection, createEntry, deleteEntry, getCollection, getEntry, listEntries, updateEntry} from '../../../server/services/collections.js';
+import {addTurn, receivedTicket} from './shape.js';
+
+export const COLLECTION = 'support-tickets';
+
+/**
+ * One write at a time per key. Each turn reads a request, changes it and writes the whole
+ * record back, so two at once (a customer message while Domma's reply saves) would lose one.
+ */
+const queues = new Map();
+function serial(key, fn) {
+    const prev = queues.get(key) || Promise.resolve();
+    const next = prev.catch(() => {}).then(fn);
+    const tail = next.catch(() => {});
+    queues.set(key, tail);
+    tail.then(() => { if (queues.get(key) === tail) queues.delete(key); });
+    return next;
+}
+
+const HERE = path.dirname(fileURLToPath(import.meta.url));
+const SITE_MANAGER = path.resolve(HERE, '..', '..', 'site-manager');
+const TOKENS = path.join(SITE_MANAGER, 'services', 'fleetTokens.js');
+
+/** Is Site Manager here - so this is the manager, and requests come TO it? */
+export const isManager = () => fs.existsSync(TOKENS);
+
+/** The site a bearer token speaks for, or null. */
+export async function slugFromToken(authorization) {
+    const token = String(authorization || '').replace(/^Bearer\s+/i, '').trim();
+    if (!token) return null;
+    try {
+        const tokens = await import(TOKENS);
+        return tokens.resolve(token) || null;
+    } catch { return null; }
+}
+
+/** slug -> {name, host}, from Site Manager's registry. Empty when there is none. */
+export function siteDirectory() {
+    try {
+        const j = JSON.parse(fs.readFileSync(path.join(SITE_MANAGER, 'data', 'sites.json'), 'utf8'));
+        const list = Array.isArray(j) ? j : (j.sites || Object.values(j));
+        return Object.fromEntries(list.filter(s => s?.slug).map(s => [s.slug, {
+            name: s.displayName || s.name || s.slug,
+            host: s.primaryDomain || s.fallbackDomain || (Array.isArray(s.domains) ? s.domains[0] : '') || '',
+            cmsVersion: s.cmsVersion || ''
+        }]));
+    } catch { return {}; }
+}
+
+/** Make the collection when it is missing. Every boot: a plugin switched on by copy never runs onEnable. */
+export async function ensureCollection() {
+    if (await getCollection(COLLECTION)) return false;
+    const schema = JSON.parse(fs.readFileSync(path.join(HERE, '..', 'collections', `${COLLECTION}.json`), 'utf8'));
+    await createCollection(schema);
+    return true;
+}
+
+/** Every request, newest first. */
+export async function allTickets() {
+    const {entries} = await listEntries(COLLECTION, {limit: 100000, sort: 'createdAt', order: 'desc'});
+    return entries || [];
+}
+
+export const getTicket = (id) => getEntry(COLLECTION, id);
+/**
+ * Deleted requests, as `slug:ref`, so a site retrying one (it never heard the first answer)
+ * is told 404 - which it takes as final - instead of the request coming back.
+ */
+let DELETED = path.join(HERE, '..', 'data', 'deleted.json');
+/** Where this plugin keeps its own state (tests pass a temp dir). */
+export function setDataDir(dir) { DELETED = path.join(dir, 'deleted.json'); }
+const readDeleted = () => { try { return new Set(JSON.parse(fs.readFileSync(DELETED, 'utf8'))); } catch { return new Set(); } };
+export const wasDeleted = (slug, ref) => readDeleted().has(`${slug}:${ref}`);
+
+export async function removeTicket(id) {
+    const e = await getTicket(id);
+    if (e?.data?.ref) {
+        const gone = [...readDeleted(), `${e.data.site}:${e.data.ref}`].slice(-5000);
+        fs.mkdirSync(path.dirname(DELETED), {recursive: true});
+        fs.writeFileSync(DELETED, JSON.stringify(gone));
+    }
+    return deleteEntry(COLLECTION, id);
+}
+
+/** One site's requests - never another's. */
+export async function ticketsOf(slug) {
+    return (await allTickets()).filter(e => e.data?.site === slug);
+}
+
+async function byRef(slug, ref) {
+    if (!ref) return null;
+    return (await ticketsOf(slug)).find(e => e.data?.ref === ref) || null;
+}
+
+/**
+ * A site opened a request. The same site sending the same `ref` again (a retry
+ * after an answer that never reached it) gets the request it already made.
+ *
+ * @returns {Promise<{entry?: object, created?: boolean, error?: string}>}
+ */
+export function open(slug, payload, now = new Date().toISOString(), site = {}) {
+    return serial(`open:${slug}:${payload?.ref}`, () => openNow(slug, payload, now, site));
+}
+
+async function openNow(slug, payload, now, site) {
+    const {data, error} = receivedTicket(payload, slug, now);
+    if (error) return {error};
+    if (wasDeleted(slug, data.ref)) return {missing: true, error: 'That request was deleted by Domma.'};
+    // A site cannot always tell its own engine version (its package.json is the site's); the registry can.
+    if (site.cmsVersion) data.cmsVersion = String(site.cmsVersion).slice(0, 20);
+    if (!data.ref) return {error: 'A request needs a reference.'};
+    const same = await byRef(slug, data.ref);
+    if (same) return {entry: same, created: false};
+    return {entry: await createEntry(COLLECTION, data, {source: 'fleet'}), created: true};
+}
+
+/**
+ * The customer wrote again, or closed the request. Found by the site's ref, in
+ * that site's requests only.
+ *
+ * @returns {Promise<{entry?: object, added?: boolean, error?: string, missing?: boolean}>}
+ */
+export async function customerTurn(slug, payload = {}, now = new Date().toISOString()) {
+    const found = await byRef(slug, String(payload.ticketRef || ''));
+    if (!found) return {missing: true, error: 'No such request.'};
+    return serial(found.id, () => customerTurnNow(found.id, payload, now));
+}
+
+async function customerTurnNow(id, payload, now) {
+    const e = await getTicket(id);
+    if (!e) return {missing: true, error: 'No such request.'};
+    const body = String(payload.body || '').trim();
+    if (!body && !payload.close) return {error: 'Write a message first.'};
+    const name = String(payload.user?.name || '').trim() || e.data.userName;
+    const {data, added} = addTurn(e.data, {from: 'customer', name, body, id: String(payload.ref || ''), at: now, close: Boolean(payload.close)});
+    if (!added) return {entry: e, added: false};
+    return {entry: await updateEntry(COLLECTION, e.id, data), added: true};
+}
+
+/** Domma replied (and/or moved the status). */
+export function dommaTurn(id, turn, now = new Date().toISOString()) {
+    return serial(id, () => dommaTurnNow(id, turn, now));
+}
+
+async function dommaTurnNow(id, {body = '', status, by, msgId}, now) {
+    const e = await getTicket(id);
+    if (!e) return null;
+    const {data} = addTurn(e.data, {from: 'domma', name: by, body, id: msgId, at: now, status});
+    return updateEntry(COLLECTION, id, data);
+}
+
+/** Status, priority or notes, from the inbox - with a line of history for what moved. */
+export function patch(id, change, by, now = new Date().toISOString()) {
+    return serial(id, () => patchNow(id, change, by, now));
+}
+
+async function patchNow(id, change, by, now) {
+    const e = await getTicket(id);
+    if (!e) return null;
+    const d = {...e.data};
+    const history = Array.isArray(d.history) ? [...d.history] : [];
+    if (change.status !== undefined && change.status !== d.status) history.push({at: now, by, what: `Status: ${change.status}`});
+    if (change.priority !== undefined && change.priority !== d.priority) history.push({at: now, by, what: `Priority: ${change.priority}`});
+    Object.assign(d, change, {history: history.slice(-200)});
+    return updateEntry(COLLECTION, id, d);
+}