domma-cms 1.6.37 → 1.6.39

package/plugins/support/lib/sender.js

@@ -47,9 +47,10 @@ export function createOutbox(dataDir) {
                 seen: j.seen && typeof j.seen === 'object' ? j.seen : {},
                 tickets: Array.isArray(j.tickets) ? j.tickets : [],
                 contact: j.contact && typeof j.contact === 'object' ? j.contact : null,
-                shelf: j.shelf && typeof j.shelf === 'object' ? j.shelf : {}
+                shelf: j.shelf && typeof j.shelf === 'object' ? j.shelf : {},
+                files: Array.isArray(j.files) ? j.files : []
             };
-        } catch { return {items: [], seen: {}, tickets: [], contact: null, shelf: {}}; }
+        } catch { return {items: [], seen: {}, tickets: [], contact: null, shelf: {}, files: []}; }
     };
     const write = (state) => {
         fs.mkdirSync(dataDir, {recursive: true});
@@ -63,6 +64,26 @@ export function createOutbox(dataDir) {
         tickets: () => read().tickets,
         contact: () => read().contact,
         shelf: () => read().shelf,
+        /**
+         * Every file id this site still needs: named by an item not done with, or already sent (the
+         * thread shows them from this site's copy long after the item itself has gone).
+         */
+        fileIds: () => { const s = read(); return new Set([...s.files, ...s.items.flatMap(i => (i.payload?.attachments || []).map(a => a.id))]); },
+        /** A file reached the manager: keep it (the newest 2000), and note it on its item. */
+        fileSent(ref, id) {
+            update(s => {
+                const item = s.items.find(i => i.ref === ref);
+                if (item) item.filesSent = [...new Set([...(item.filesSent || []), id])];
+                s.files = [...s.files.filter(x => x !== id), id].slice(-2000);
+            });
+        },
+        /** A file the manager will never take (or this site lost): stop trying it. */
+        fileRefused(ref, id) {
+            update(s => {
+                const item = s.items.find(i => i.ref === ref);
+                if (item) item.filesRefused = [...new Set([...(item.filesRefused || []), id])];
+            });
+        },
         /**
          * Archive or remove a request from this site's list (`state` null puts it back). Remembers
          * Domma's latest reply at the time, and marks it read: what is put away is not "new".
@@ -118,11 +139,14 @@ export function createOutbox(dataDir) {
                     const known = latest.has(ref);
                     if ((!known && !local.has(ref)) || (known && (latest.get(ref) || '') !== (entry.dommaAt || ''))) delete s.shelf[ref];
                 }
+                // Files this site keeps to show its own thread: only those the manager still has (a request
+                // deleted there takes its files with it) or an item here still names. The next prune removes the rest.
+                s.files = keepFiles(s.files, remote, s.items);
                 const byRef = new Map(remote.map(t => [t.ref, t]));
                 const have = new Set(remote.flatMap(t => [t.ref, ...(t.messages || []).map(m => m.id)]));
                 s.items = s.items.filter((i) => {
                     if (i.state !== 'sent') return true;
-                    if (have.has(i.ref)) return false;                                  // arrived: done with it
+                    if (have.has(i.ref)) return !filesDone(i);                          // arrived: done with it, once its files have gone
                     const t = byRef.get(i.kind === 'ticket' ? i.ref : i.ticketRef);
                     if (!t) return true;                                                // not in the view yet
                     if (i.kind === 'message' && !i.payload?.body) return false;         // a close: no message to look for
@@ -136,6 +160,24 @@ export function createOutbox(dataDir) {
     };
 }
 
+/**
+ * Of the file ids this site kept after sending them, those still wanted: in a message of a request the
+ * manager still holds (its list for this site is complete), or named by an outbox item. PURE.
+ */
+export function keepFiles(files, remote, items = []) {
+    const live = new Set([
+        ...(remote || []).flatMap(t => (t.messages || []).flatMap(m => (m.attachments || []).map(a => a.id))),
+        ...(items || []).flatMap(i => (i.payload?.attachments || []).map(a => a.id))
+    ]);
+    return (files || []).filter(id => live.has(id));
+}
+
+/** Has every file an item announced been sent, or given up on? */
+const filesDone = (i) => {
+    const done = new Set([...(i.filesSent || []), ...(i.filesRefused || [])]);
+    return (i.payload?.attachments || []).every(a => done.has(a.id));
+};
+
 /**
  * Talk to the manager. `fetchImpl` is swapped in tests; nothing here throws -
  * every call answers `{ok, status?, body?, error?}`.
@@ -157,10 +199,28 @@ export function managerApi(manager, fetchImpl = globalThis.fetch) {
             return {ok: false, error: `Could not reach the Domma server: ${err.message}`};
         }
     };
+    /** One attached file's bytes, after its message: raw, so the JSON routes' 32 KB limit never applies to them. */
+    const attach = async (ticketRef, attId, buffer) => {
+        try {
+            const res = await fetchImpl(`${manager.url}/api/plugins/support/fleet/attach/${encodeURIComponent(ticketRef)}/${encodeURIComponent(attId)}`, {
+                method: 'POST',
+                headers: {authorization: `Bearer ${manager.token}`, 'content-type': 'application/octet-stream'},
+                body: buffer,
+                signal: AbortSignal.timeout(30_000)
+            });
+            let json = null;
+            try { json = await res.json(); } catch { /* not JSON */ }
+            if (res.status >= 200 && res.status < 300) return {ok: true, status: res.status, body: json};
+            return {ok: false, status: res.status, error: json?.error || `The Domma server answered ${res.status}.`};
+        } catch (err) {
+            return {ok: false, error: `Could not reach the Domma server: ${err.message}`};
+        }
+    };
     return {
         open: (payload) => call('POST', 'tickets', payload),
         message: (payload) => call('POST', 'messages', payload),
-        mine: () => call('GET', 'mine')
+        mine: () => call('GET', 'mine'),
+        attach
     };
 }
 
@@ -170,17 +230,40 @@ export function managerApi(manager, fetchImpl = globalThis.fetch) {
  *
  * @returns {Promise<{sent: number, waiting: number, error: string}>}
  */
-export function flush(outbox, api) {
+export function flush(outbox, api, files = null) {
     // One flush at a time per outbox: the timer, the badge's nudge, a screen load and a send can
     // all ask at once, and two flushes would POST the same waiting item twice.
-    if (!outbox.flushing) outbox.flushing = flushOnce(outbox, api).finally(() => { outbox.flushing = null; });
+    if (!outbox.flushing) outbox.flushing = flushOnce(outbox, api, files).finally(() => { outbox.flushing = null; });
     return outbox.flushing;
 }
 
 /** Statuses that mean "try again later"; any other 4xx means the manager will never take it. */
 const RETRY = new Set([401, 408, 429]);
 
-async function flushOnce(outbox, api) {
+/**
+ * The files of messages that have arrived but whose files have not all followed.
+ * A file the manager refuses for good (400/404/413), or one this site no longer
+ * has, is not tried again - the words are there either way.
+ */
+async function sendFiles(outbox, api, files) {
+    let error = '';
+    for (const item of outbox.all().filter(i => i.state === 'sent' && !filesDone(i))) {
+        const done = new Set([...(item.filesSent || []), ...(item.filesRefused || [])]);
+        for (const a of item.payload.attachments.filter(x => !done.has(x.id))) {
+            const buffer = files?.read(a);
+            if (!buffer) { outbox.fileRefused(item.ref, a.id); continue; }
+            const r = await api.attach(item.ticketRef, a.id, buffer);
+            if (r.ok) outbox.fileSent(item.ref, a.id);
+            else {
+                error = r.error || 'A file was not sent.';
+                if (r.status >= 400 && r.status < 500 && !RETRY.has(r.status)) outbox.fileRefused(item.ref, a.id);
+            }
+        }
+    }
+    return error;
+}
+
+async function flushOnce(outbox, api, files) {
     let sent = 0;
     let error = '';
     for (const queued of outbox.all().filter(i => i.state === 'waiting')) {
@@ -204,7 +287,9 @@ async function flushOnce(outbox, api) {
             outbox.mark(item.ref, {lastError: error, triedAt: new Date().toISOString(), ...(permanent && {state: 'refused'})});
         }
     }
-    return {sent, waiting: outbox.all().filter(i => i.state === 'waiting').length, error};
+    // Then the files, each on its own request once its message is on the manager.
+    const fileError = api.attach ? await sendFiles(outbox, api, files) : '';
+    return {sent, waiting: outbox.all().filter(i => i.state === 'waiting').length, error: error || fileError};
 }
 
 /**
@@ -260,7 +345,8 @@ export function mergeTickets(items, remote, seen = {}, cached = []) {
                 id: '', ref: i.ref, category: p.category, priority: p.priority, subject: p.subject, where: p.where || '',
                 userName: p.user?.name || '', status: i.state === 'refused' ? 'refused' : 'waiting',
                 statusLabel: i.state === 'refused' ? 'Not accepted' : 'Waiting to send',
-                messages: [{id: i.ref, from: 'customer', name: p.user?.name || '', body: p.body, at: i.createdAt, pending: true}],
+                messages: [{id: i.ref, from: 'customer', name: p.user?.name || '', body: p.body, at: i.createdAt, pending: true,
+                    ...(p.attachments?.length && {attachments: p.attachments})}],
                 lastFrom: 'customer', lastAt: i.createdAt, createdAt: i.createdAt, updatedAt: i.createdAt,
                 local: true, unread: false, lastError: i.lastError || ''
             });
@@ -269,7 +355,7 @@ export function mergeTickets(items, remote, seen = {}, cached = []) {
             const t = out.get(i.ticketRef);
             if (t && !(t.messages || []).some(m => m.id === i.ref)) {
                 t.messages = [...(t.messages || []), {id: i.ref, from: 'customer', name: p.user?.name || '', body: p.body, at: i.createdAt,
-                    pending: i.state === 'waiting', refused: i.state === 'refused'}];
+                    pending: i.state === 'waiting', refused: i.state === 'refused', ...(p.attachments?.length && {attachments: p.attachments})}];
             }
         }
     }

package/plugins/support/lib/shape.js

@@ -47,6 +47,68 @@ export const LIMITS = {subject: 140, body: 8000, where: 300, notes: 8000, messag
 // would pass here and then be refused by the manager's 32 KB body limit, forever.
 const text = (v, max) => String(v ?? '').replace(/\r\n?/g, '\n').replace(/[\u0000-\u0008\u000B-\u001F\u007F]/g, '').trim().slice(0, max);
 const line = (v, max) => text(v, max).replace(/\s*\n\s*/g, ' ');
+
+// ---------------------------------------------------------------------------------
+// Attachments: a screenshot is what "something is not working" needs most.
+// The same rules as Feedback's (plugins/feedback/lib/shape.js) - each plugin
+// carries its own copy, since either can be installed without the other.
+// ---------------------------------------------------------------------------------
+
+/** How many files one message may carry and how big each may be. The files travel one per request, after their message. */
+export const ATTACHMENTS = {max: 3, maxBytes: 2 * 1024 * 1024};
+
+/** What may be attached: mime -> the extension the file is kept under. No SVG or HTML - they can carry scripts. */
+export const ATTACHMENT_TYPES = {
+    'image/png': 'png', 'image/jpeg': 'jpg', 'image/gif': 'gif', 'image/webp': 'webp', 'application/pdf': 'pdf', 'text/plain': 'txt'
+};
+
+/** Ids are made by the server (randomUUID) and become file names, so nothing else gets through. */
+const ATTACHMENT_ID = /^[A-Za-z0-9-]{8,64}$/;
+
+export const extOf = (type) => ATTACHMENT_TYPES[String(type || '').toLowerCase()] || 'bin';
+
+/** A file name fit to show and to put in a Content-Disposition header: the last path segment, odd characters replaced, never empty. */
+export function safeFileName(name, ext = 'bin') {
+    const base = String(name ?? '').split(/[\\/]/).pop().replace(/[^A-Za-z0-9._ -]/g, '_').replace(/^[. ]+/, '').trim().slice(0, 120);
+    return base || `file.${ext}`;
+}
+
+/**
+ * One attachment's description, cleaned - or null when it is not one we take.
+ * The bytes are checked against `size` when they arrive.
+ *
+ * @returns {{id: string, name: string, type: string, size: number}|null}
+ */
+export function cleanAttachment(a = {}) {
+    if (!a || typeof a !== 'object') return null;
+    const type = String(a.type || '').toLowerCase().split(';')[0].trim();
+    const id = String(a.id || '');
+    const size = Number(a.size);
+    if (!ATTACHMENT_TYPES[type] || !ATTACHMENT_ID.test(id) || !Number.isInteger(size) || size < 1 || size > ATTACHMENTS.maxBytes) return null;
+    return {id, name: safeFileName(a.name, ATTACHMENT_TYPES[type]), type, size};
+}
+
+/** A list of them: the bad ones dropped, duplicates once, at most ATTACHMENTS.max. */
+export function cleanAttachments(list) {
+    if (!Array.isArray(list)) return [];
+    const out = [];
+    const seen = new Set();
+    for (const a of list) {
+        const c = cleanAttachment(a);
+        if (!c || seen.has(c.id)) continue;
+        seen.add(c.id);
+        out.push(c);
+        if (out.length >= ATTACHMENTS.max) break;
+    }
+    return out;
+}
+
+/** The sender-safe view of a stored attachment: what it is and whether the manager has the bytes yet. */
+export const attachmentView = (a) => ({id: a.id, name: a.name, type: a.type, size: a.size, stored: Boolean(a.stored)});
+
+/** Every attachment in a conversation, with the message it came in. */
+export const attachmentsOf = (data = {}) => (data.messages || []).flatMap(m => (m.attachments || []).map(a => ({...a, messageId: m.id})));
+
 const EMAIL_RE = /^[^\s@<>"]+@[^\s@<>"]+\.[^\s@<>"]+$/;
 
 /**
@@ -63,14 +125,15 @@ export function cleanRequest(body = {}) {
     const message = text(body.body, LIMITS.body);
     if (!subject) return {error: 'Give it a short subject.'};
     if (!message) return {error: 'Tell us what you need.'};
-    return {request: {category, priority, subject, body: message, where: line(body.where, LIMITS.where)}};
+    // Descriptions of files, not the files: those follow one per request once the request is in.
+    return {request: {category, priority, subject, body: message, where: line(body.where, LIMITS.where), attachments: cleanAttachments(body.attachments)}};
 }
 
-/** One more message in a conversation. */
+/** One more message in a conversation. Files go with words: a message is never files alone. */
 export function cleanMessage(body = {}) {
     const message = text(body.body, LIMITS.body);
     if (!message) return {error: 'Write a message first.'};
-    return {message: {body: message}};
+    return {message: {body: message, attachments: cleanAttachments(body.attachments)}};
 }
 
 const who = (user = {}) => ({id: text(user.id, 64), name: line(user.name, 120), email: text(user.email, 200)});
@@ -84,8 +147,9 @@ export function buildTicketPayload({request, user = {}, cmsVersion = '', site =
 }
 
 /** What a site sends for another message, or to close a request (`body` empty, `close: true`). */
-export function buildMessagePayload({ticketRef, ref, body = '', close = false, user = {}}) {
-    return {ticketRef: text(ticketRef, 64), ref: text(ref, 64), body: text(body, LIMITS.body), close: Boolean(close), user: who(user)};
+export function buildMessagePayload({ticketRef, ref, body = '', close = false, user = {}, attachments = []}) {
+    return {ticketRef: text(ticketRef, 64), ref: text(ref, 64), body: text(body, LIMITS.body), close: Boolean(close), user: who(user),
+        ...(body && {attachments: cleanAttachments(attachments)})};
 }
 
 /**
@@ -115,7 +179,9 @@ export function receivedTicket(payload = {}, slug, now) {
             userName: u.name || 'A site admin',
             userEmail: EMAIL_RE.test(u.email) ? u.email : '',
             status: 'open',
-            messages: [{id: ref || 'm0', from: 'customer', name: u.name || 'A site admin', body: request.body, at: now}],
+            // Announced with the message; `stored` turns true as each file arrives (/fleet/attach).
+            messages: [{id: ref || 'm0', from: 'customer', name: u.name || 'A site admin', body: request.body, at: now,
+                ...(request.attachments.length && {attachments: request.attachments.map(a => ({...a, stored: false}))})}],
             lastFrom: 'customer',
             lastAt: now,
             notes: '',
@@ -132,14 +198,15 @@ export function receivedTicket(payload = {}, slug, now) {
  * @param {{from: 'customer'|'domma', name: string, body?: string, id: string, at: string, status?: string, close?: boolean}} turn
  * @returns {{data: object, added: boolean}}
  */
-export function addTurn(data, {from, name, body = '', id, at, status, close = false}) {
+export function addTurn(data, {from, name, body = '', id, at, status, close = false, attachments = []}) {
     const messages = Array.isArray(data.messages) ? [...data.messages] : [];
     if (id && messages.some(m => m.id === id)) return {data, added: false};
     const history = Array.isArray(data.history) ? [...data.history] : [];
     const next = {...data};
     let added = false;
     if (body) {
-        messages.push({id, from, name, body, at});
+        const files = cleanAttachments(attachments).map(a => ({...a, stored: false}));
+        messages.push({id, from, name, body, at, ...(files.length && {attachments: files})});
         next.lastFrom = from;
         next.lastAt = at;
         added = true;
@@ -181,7 +248,8 @@ export function senderView(entry) {
         userName: d.userName || '',
         status: d.status,
         statusLabel: statusLabel(d.status),
-        messages: (d.messages || []).map(m => ({id: m.id, from: m.from, name: m.name, body: m.body, at: m.at})),
+        messages: (d.messages || []).map(m => ({id: m.id, from: m.from, name: m.name, body: m.body, at: m.at,
+            ...(m.attachments?.length && {attachments: m.attachments.map(attachmentView)})})),
         lastFrom: d.lastFrom || 'customer',
         lastAt: d.lastAt || '',
         createdAt: entry.meta?.createdAt || '',
@@ -231,6 +299,76 @@ export function contactCard(s = {}) {
     };
 }
 
+/**
+ * The settings each side owns (1.1.5). The site keeps its sync interval; the
+ * manager keeps the contact card every site shows, where new requests are
+ * emailed, and the per-site brake.
+ */
+export const SIDE_SETTINGS = {
+    sender: ['syncMinutes'],
+    receiver: ['email', 'phone', 'hours', 'responseTime', 'notifyEmail', 'perSiteMax', 'perSiteMinutes']
+};
+export const SETTING_RULES = {
+    syncMinutes: {min: 1, max: 1440, fallback: 5},
+    perSiteMax: {min: 1, max: 1000, fallback: 20},
+    perSiteMinutes: {min: 1, max: 1440, fallback: 10}
+};
+const PHONE_RE = /^[+\d][\d\s().-]{4,}$/;
+
+/** What is wrong with a sent settings object, per field - empty when nothing. */
+export function settingsErrors(raw, side = 'sender') {
+    const r = raw && typeof raw === 'object' ? raw : {};
+    const errors = {};
+    const keys = SIDE_SETTINGS[side] || [];
+    for (const k of keys) {
+        if (!(k in r)) continue;
+        const v = r[k];
+        if (SETTING_RULES[k]) {
+            const n = Number(v);
+            const {min, max} = SETTING_RULES[k];
+            if (v === '' || v == null || !Number.isInteger(n) || n < min || n > max) errors[k] = `A whole number from ${min} to ${max}.`;
+        } else if ((k === 'email' || k === 'notifyEmail') && String(v ?? '').trim() && !EMAIL_RE.test(String(v).trim())) {
+            errors[k] = 'One email address, or leave it empty.';
+        } else if (k === 'phone' && String(v ?? '').trim() && !PHONE_RE.test(String(v).trim())) {
+            errors[k] = 'Digits, spaces and + ( ) . - only.';
+        }
+    }
+    return errors;
+}
+
+/**
+ * One side's settings from whatever was saved or sent: only that side's keys,
+ * each checked; a value that does not pass keeps what is current, then the
+ * default. An empty email or phone is allowed - it hides that line of the card
+ * (notifyEmail: emails nobody).
+ *
+ * @param {object} raw
+ * @param {object} [current]
+ * @param {'sender'|'receiver'} [side]
+ */
+export function cleanSettings(raw, current = {}, side = 'sender') {
+    const r = raw && typeof raw === 'object' ? raw : {};
+    const cur = current && typeof current === 'object' ? current : {};
+    const out = {};
+    const okFor = (k, v) => {
+        if (v === undefined) return undefined;
+        if (SETTING_RULES[k]) {
+            const n = Number(v);
+            const {min, max} = SETTING_RULES[k];
+            return v !== '' && v != null && Number.isInteger(n) && n >= min && n <= max ? n : undefined;
+        }
+        if (k === 'email' || k === 'notifyEmail') { const e = text(v, 200); return !e || EMAIL_RE.test(e) ? e : undefined; }
+        if (k === 'phone') { const p = line(v, 40); return !p || PHONE_RE.test(p) ? p : undefined; }
+        if (k === 'hours') return line(v, 200);
+        if (k === 'responseTime') return line(v, 300);
+        return undefined;
+    };
+    for (const k of SIDE_SETTINGS[side] || []) {
+        out[k] = okFor(k, r[k]) ?? okFor(k, cur[k]) ?? SETTING_RULES[k]?.fallback ?? '';
+    }
+    return out;
+}
+
 /** The tel: form of a phone number. */
 export const telHref = (phone) => `tel:${String(phone || '').replace(/[^\d+]/g, '')}`;
 
@@ -241,9 +379,12 @@ export const telHref = (phone) => `tel:${String(phone || '').replace(/[^\d+]/g,
  */
 export function createThrottle({max = 20, windowMs = 10 * 60_000} = {}) {
     const seen = new Map();
-    return (key, now = Date.now()) => {
-        const recent = (seen.get(key) || []).filter(t => now - t < windowMs);
-        if (recent.length >= max) { seen.set(key, recent); return false; }
+    // `limits` per call (1.1.5): the settings cog changes them without a restart.
+    return (key, now = Date.now(), limits = {}) => {
+        const cap = Number(limits.max) > 0 ? Number(limits.max) : max;
+        const window = Number(limits.windowMs) > 0 ? Number(limits.windowMs) : windowMs;
+        const recent = (seen.get(key) || []).filter(t => now - t < window);
+        if (recent.length >= cap) { seen.set(key, recent); return false; }
         recent.push(now);
         seen.set(key, recent);
         return true;