domma-cms 1.6.37 → 1.6.38

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

@@ -13,7 +13,10 @@
  * Domma brings it straight back. Removing one that never reached Domma cancels it.
  */
 
-import {THREAD, TONE, api, copyText, esc, listOf, openPanel, refreshBadge, rowKeys, stamp, telHref, threadRows, when} from '../lib/kit.js';
+import {
+    FILE_TYPES, THREAD, TONE, api, copyText, esc, fileKeys, filePicker, fileSize, findFile, listOf, openPanel, refreshBadge, rowKeys, stamp, telHref,
+    threadFiles, threadRows, when
+} from '../lib/kit.js';
 
 const ROW = `
 <div class="sp-row" data-id="{{key}}" tabindex="0" role="button" aria-haspopup="menu">
@@ -37,6 +40,21 @@ export async function mount(root, ctx) {
     const {kit, scope, here, meta, id} = ctx;
     const categories = meta.categories || [];
     const priorities = meta.priorities || [];
+    const caps = meta.attachments || {max: 3, maxBytes: 2 * 1024 * 1024};
+    /** The attach button and its hidden input; the picker's list goes in [data-files]. */
+    const attachUi = (pasteHint) => `<div class="sp-files-host" data-files></div>
+  <div class="sp-attach" data-bind-hidden="!room.value">
+    <button type="button" class="btn btn-sm btn-outline" data-on-click="pickFiles"><span data-icon="paperclip" data-icon-size="13"></span> Attach a file</button>
+    <span class="sp-hint">${esc(pasteHint)}</span>
+    <input type="file" class="sp-file-input" accept="${FILE_TYPES}" multiple hidden>
+  </div>`;
+    /** Wire a panel's picker, mirroring its state into the panel's own observables (bound before it existed). */
+    const wirePicker = (p, pasteSel, room, uploading) => {
+        const picker = filePicker({host: p.panel.querySelector('[data-files]'), input: p.panel.querySelector('.sp-file-input'),
+            paste: p.panel.querySelector(pasteSel), caps});
+        const stop = M.effect(() => { room.value = picker.room.value; uploading.value = picker.uploading.value; });
+        return {picker, dispose: () => { stop(); picker.dispose(); }};
+    };
     const iconOf = (c) => categories.find(x => x.key === c)?.icon || 'message-square';
     const labelOf = (c) => categories.find(x => x.key === c)?.short || c;
     const plural = (n, w) => (n ? `${n} ${w}${n === 1 ? '' : 's'}` : '');
@@ -58,7 +76,8 @@ export async function mount(root, ctx) {
             subject: t.subject,
             icon: iconOf(t.category),
             categoryLabel: labelOf(t.category),
-            meta: [when(t.lastAt || t.createdAt), t.userName, plural((t.messages || []).length, 'message')].filter(Boolean).join(' · '),
+            meta: [when(t.lastAt || t.createdAt), t.userName, plural((t.messages || []).length, 'message'),
+                plural((t.messages || []).reduce((n, m) => n + (m.attachments || []).length, 0), 'file')].filter(Boolean).join(' · '),
             statusLabel: t.statusLabel || t.status,
             tone: `is-${TONE[t.status] || 'muted'}`,
             urgent: t.priority === 'urgent' && t.status !== 'closed',
@@ -212,11 +231,13 @@ export async function mount(root, ctx) {
 
     function compose() {
         const f = {category: M.observable('help'), priority: M.observable('normal'), subject: M.observable(''), body: M.observable(''),
-            where: M.observable(''), busy: M.observable(false)};
+            where: M.observable(''), busy: M.observable(false), room: M.observable(true), uploading: M.observable(false)};
         let panel = null;
+        let wired = null;
         openPanel({
             title: 'Ask Domma for help',
             model: f,
+            cleanup: () => wired?.dispose(),
             html: `<div class="sp-form">
   <label class="form-label">What is it about?</label>
   <div class="sp-choices" role="radiogroup" aria-label="Category">
@@ -232,21 +253,24 @@ export async function mount(root, ctx) {
   </div>
   <label class="form-label" for="sp-where">Where <span data-help="The page or admin screen it is about, if there is one - e.g. /contact, or Pages. Optional."></span></label>
   <input id="sp-where" class="form-input" maxlength="300" data-model="where.value" placeholder="Optional">
+  <label class="form-label">Screenshots and files <span data-help="${esc(`Up to ${caps.max} files of ${fileSize(caps.maxBytes)} each: PNG, JPEG, GIF or WebP images, a PDF or a text file. A screenshot of what went wrong helps us most. Only the Domma team sees them.`)}"></span></label>
+  ${attachUi('Or paste a screenshot into the message.')}
   <p class="sp-hint">Sent with your name, email and this site, so we can reply here and by email.</p>
   <div class="sp-actions"><span class="sp-spacer"></span>
     <button type="button" class="btn btn-sm btn-ghost" data-on-click="cancel">Cancel</button>
-    <button type="button" class="btn btn-sm btn-primary" data-on-click="send" data-bind-disabled="busy.value"><span data-icon="send" data-icon-size="13"></span> Send</button>
+    <button type="button" class="btn btn-sm btn-primary" data-on-click="send" data-bind-disabled="busy.value || uploading.value"><span data-icon="send" data-icon-size="13"></span> Send</button>
   </div>
 </div>`,
             methods: {
                 pick: (group, value) => { if (f[group]) f[group].value = value; },
                 cancel: () => panel?.close(),
+                pickFiles: () => panel?.panel.querySelector('.sp-file-input')?.click(),
                 async send() {
-                    if (f.busy.peek()) return;
+                    if (f.busy.peek() || f.uploading.peek()) return;
                     f.busy.value = true;
                     try {
                         const r = await api.open({category: f.category.peek(), priority: f.priority.peek(), subject: f.subject.peek(),
-                            body: f.body.peek(), where: f.where.peek()});
+                            body: f.body.peek(), where: f.where.peek(), attachments: wired?.picker.attachments() || []});
                         E.toast(r.message || 'Sent.', {type: r.state === 'sent' ? 'success' : 'warning'});
                         panel?.close();
                         refreshBadge();
@@ -261,6 +285,7 @@ export async function mount(root, ctx) {
             }
         }).then(p => {
             panel = p;
+            wired = wirePicker(p, '#sp-body', f.room, f.uploading);
             p.panel.querySelector('#sp-subject')?.focus();
         });
     }
@@ -270,7 +295,14 @@ export async function mount(root, ctx) {
         if (!t0) return;
         // The panel follows the list's copy, so a reload or a move from the row menu shows here at once.
         const cur = M.computed(() => tickets.value.find(x => x.ref === ref) || t0);
-        const thread = M.computed(() => threadRows(cur.value.messages || [], 'customer'));
+        // Every file in this site's requests was attached here, so this site's own copy shows them -
+        // even while Domma's copy is still on its way.
+        const shown = threadFiles((a) => api.ownFileUrl(a.id));
+        const thread = M.computed(() => threadRows(cur.value.messages || [], 'customer', {thumbs: shown.thumbs.value}));
+        const room = M.observable(true);
+        const uploading = M.observable(false);
+        let wired = null;
+        let stopFiles = () => {};
         const status = M.computed(() => cur.value.status);
         const statusLabel = M.computed(() => cur.value.statusLabel || cur.value.status);
         const tone = M.computed(() => `is-${TONE[cur.value.status] || 'muted'}`);
@@ -291,8 +323,11 @@ export async function mount(root, ctx) {
         panel = await openPanel({
             title: t0.subject,
             size: 'lg',
-            model: {thread, status, statusLabel, tone, archived, draft, hasDraft, busy},
-            cleanup: () => { stopScroll(); menu?.destroy?.(); [cur, thread, status, statusLabel, tone, archived, hasDraft].forEach(c => c.dispose?.()); },
+            model: {thread, status, statusLabel, tone, archived, draft, hasDraft, busy, room, uploading},
+            cleanup: () => {
+                stopScroll(); stopFiles(); menu?.destroy?.(); wired?.dispose(); shown.dispose();
+                [cur, thread, status, statusLabel, tone, archived, hasDraft].forEach(c => c.dispose?.());
+            },
             html: `<div class="sp-detail">
   <dl class="sp-facts">
     <div><dt>Status</dt><dd><span class="sp-chip" data-bind-class="tone.value" data-bind-text="statusLabel.value"></span>
@@ -306,21 +341,24 @@ export async function mount(root, ctx) {
   ${canWrite ? `<div class="sp-reply">
     <label class="form-label" for="sp-write" data-bind-text="status.value === 'closed' ? 'Write again (this reopens it)' : 'Reply'"></label>
     <textarea id="sp-write" class="form-textarea" rows="4" maxlength="8000" data-model="draft.value" placeholder="Write to Domma Support"></textarea>
+    ${attachUi('Files go with a message - paste a screenshot into it, or attach one.')}
     <div class="sp-actions">
       <button type="button" class="btn btn-sm btn-ghost" data-on-click="resolve" data-bind-hidden="status.value === 'closed'" data-bind-disabled="busy.value"><span data-icon="check-circle" data-icon-size="13"></span> Mark resolved</button>
       <button type="button" class="btn btn-sm btn-ghost" data-on-click="archive" data-bind-disabled="busy.value">
         <span data-icon="archive" data-icon-size="13"></span> <span data-bind-text="archived.value ? 'Back to your requests' : 'Archive'"></span></button>
       <span class="sp-spacer"></span>
-      <button type="button" class="btn btn-sm btn-primary" data-on-click="send" data-bind-disabled="busy.value || !hasDraft.value"><span data-icon="send" data-icon-size="13"></span> Send</button>
+      <button type="button" class="btn btn-sm btn-primary" data-on-click="send" data-bind-disabled="busy.value || uploading.value || !hasDraft.value"><span data-icon="send" data-icon-size="13"></span> Send</button>
     </div>
   </div>` : '<p class="sp-note">You can write again once this request reaches Domma.</p>'}
 </div>`,
             methods: {
+                pickFiles: () => panel?.panel.querySelector('.sp-file-input')?.click(),
                 send: () => run(async () => {
-                    if (!draft.peek().trim()) return;
-                    const r = await api.write(ref, draft.peek());
+                    if (!draft.peek().trim() || uploading.peek()) return;
+                    const r = await api.write(ref, draft.peek(), wired?.picker.attachments() || []);
                     if (r.state !== 'sent') E.toast(r.message, {type: 'warning'});
                     draft.value = '';
+                    wired?.picker.clear();
                     await load();
                 }),
                 resolve: () => run(() => actions.resolve(cur.peek())),
@@ -333,6 +371,11 @@ export async function mount(root, ctx) {
         });
         const box = panel.panel.querySelector('.sp-thread-host');
         stopScroll = M.effect(() => { thread.value; Promise.resolve().then(() => { M.flush?.(); box.scrollTop = box.scrollHeight; }); });
+        if (canWrite) wired = wirePicker(panel, '#sp-write', room, uploading);
+        // Thumbnails for the images in the thread, as messages come; click a file to open it.
+        const fileStop = M.effect(() => { shown.load(cur.value.messages || []); });
+        const keysOff = fileKeys(box, (id) => shown.open(findFile(cur.peek().messages, id)));
+        stopFiles = () => { fileStop(); keysOff(); };
         menu = E.contextMenu(box, {
             cursor: 'glyph', match: '.sp-msg', inherit: false, density: 'compact',
             items: (li) => {

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

@@ -8,7 +8,9 @@
  * still sees the request - and a customer writing again takes it back out.
  */
 
-import {THREAD, TONE, api, copyText, esc, listOf, openPanel, refreshBadge, rowKeys, stamp, store, threadRows, when} from '../lib/kit.js';
+import {
+    THREAD, TONE, api, copyText, esc, fileKeys, findFile, listOf, openPanel, refreshBadge, rowKeys, stamp, store, threadFiles, threadRows, when
+} from '../lib/kit.js';
 
 const ROW = `
 <div class="sp-row" data-id="{{key}}" tabindex="0" role="button" aria-haspopup="menu">
@@ -64,7 +66,9 @@ export async function mount(root, ctx) {
                 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(' · '),
+                meta: [t.siteName, t.userName, `${t.lastFrom === 'domma' ? 'we wrote' : 'they wrote'} ${when(t.lastAt)}`,
+                    (() => { const n = (t.messages || []).reduce((k, m) => k + (m.attachments || []).length, 0); return n ? `${n} file${n === 1 ? '' : 's'}` : ''; })()]
+                    .filter(Boolean).join(' · '),
                 statusLabel: inboxLabel(t.status),
                 tone: `is-${TONE[t.status] || 'muted'}`,
                 urgent: t.priority === 'urgent' && t.status !== 'closed'
@@ -173,7 +177,12 @@ export async function mount(root, ctx) {
 
         // The panel follows the list's copy, so a move from the row menu shows here at once.
         const cur = M.computed(() => tickets.value.find(x => x.id === tid) || t);
-        const thread = M.computed(() => threadRows(cur.value.messages || [], 'domma'));
+        // A file follows its message from the site; until it lands it is listed but cannot open.
+        const arrived = (a) => a.stored !== false;
+        const shown = threadFiles((a) => api.ticketFileUrl(tid, a.id), arrived);
+        const thread = M.computed(() => threadRows(cur.value.messages || [], 'domma',
+            {thumbs: shown.thumbs.value, available: arrived, missing: 'on its way from the site'}));
+        let stopFiles = () => {};
         const status = M.computed(() => cur.value.status);
         const statusLabel = M.computed(() => inboxLabel(cur.value.status));
         const tone = M.computed(() => `is-${TONE[cur.value.status] || 'muted'}`);
@@ -200,7 +209,7 @@ export async function mount(root, ctx) {
             size: 'lg',
             model: {thread, status, statusLabel, tone, urgent, archived, draft, hasDraft, after, notes, busy},
             cleanup: () => {
-                stopScroll(); menu?.destroy?.();
+                stopScroll(); stopFiles(); shown.dispose(); menu?.destroy?.();
                 [cur, thread, status, statusLabel, tone, urgent, archived, hasDraft].forEach(c => c.dispose?.());
                 if (openPanel_?.tid === tid) openPanel_ = null;
             },
@@ -266,6 +275,10 @@ export async function mount(root, ctx) {
         // Keep the newest message in view as the thread grows.
         const box = panel.panel.querySelector('.sp-thread-host');
         stopScroll = M.effect(() => { thread.value; Promise.resolve().then(() => { M.flush?.(); box.scrollTop = box.scrollHeight; }); });
+        // Thumbnails for the images that have arrived; click a file to open it in a new tab.
+        const fileStop = M.effect(() => { shown.load(cur.value.messages || []); });
+        const keysOff = fileKeys(box, (fid) => shown.open(findFile(cur.peek().messages, fid)));
+        stopFiles = () => { fileStop(); keysOff(); };
         // A message: copy it, or quote it into the reply.
         menu = E.contextMenu(box, {
             cursor: 'glyph', match: '.sp-msg', inherit: false, density: 'compact',

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

@@ -12,9 +12,10 @@
  */
 
 import {api, loadKit} from '../lib/kit.js';
+import {addSettingsCog} from '../lib/settings.js';
 
 const ROUTE = /^#\/plugins\/support(\/|$)/;
-const V = '1.1.2';
+const V = '1.1.5';
 let lifetime = null;
 
 export const supportView = {
@@ -50,6 +51,8 @@ export const supportView = {
             return;
         }
         if (!here()) return;
+        // The cog (1.1.5) - this side's settings, for those who may change them. Never blocks the screen.
+        addSettingsCog($container, kit).catch(() => {});
         try {
             const screen = mode.mode === 'receiver' ? 'inbox' : 'desk';
             const mod = await import(`/plugins/support/admin/views/${screen}.js?v=${V}`);

package/plugins/support/docs/guide.md

@@ -20,7 +20,8 @@ Support gets you help from Domma without leaving your admin: our email, phone an
 4. Type a **Subject** (one line) and your **Message**.
 5. Choose **Normal** (we answer in order, usually within a working day) or **Urgent** (your site is down, or you cannot take orders, bookings or payments).
 6. Optional: fill in **Where** - the screen or page it is about, for example "Pages" or `/contact`.
-7. Click **Send**.
+7. Optional: click **Attach a file**, or paste a screenshot straight into the message. Up to 3 files of 2 MB each: PNG, JPEG, GIF or WebP images, a PDF or a text file.
+8. Click **Send**.
 
 For something that is not working, say what you did, what you expected and what happened instead.
 
@@ -37,7 +38,7 @@ Each row shows the subject, when it was last written to, and a status:
 | Resolved | Finished. Writing again reopens it |
 | Waiting to send | Domma could not be reached yet; it goes automatically |
 
-A dot on a row means a new reply. Click a row to read the conversation and **Reply**. Right-click a row (or use the row's menu) to **Archive**, **Resolve** or **Remove** it:
+A dot on a row means a new reply. Click a row to read the conversation and **Reply** - you can attach files to a reply too. Files show under the message they came with; click one to open it. Only the Domma team sees them - they are never put in your Media library or on your website. Right-click a row (or use the row's menu) to **Archive**, **Resolve** or **Remove** it:
 
 - **Archive** tidies a request away under **Archived**. It comes back by itself if Domma writes to it.
 - **Resolve** closes it. You can still write to it, which reopens it.
@@ -49,11 +50,7 @@ If the screen offers the contact card only and says to email us, your site was n
 
 ## Settings
 
-There is no settings screen. Whoever runs the site can change one option in the plugin's configuration file:
-
-| Option | Default | Meaning |
-|---|---|---|
-| `syncMinutes` | 5 | How often the site sends waiting requests and checks for replies |
+Administrators see a **Support settings** cog in the banner. It has one setting, **Check for replies every (minutes)** - how often the site sends anything still waiting and looks for replies in the background (default 5). A change takes effect at once, no restart.
 
 Opening the Support screen also sends anything waiting and checks for replies straight away. The contact card is set by Domma and arrives with the first sync.
 
@@ -77,14 +74,15 @@ Only the **admin** role has them by default. Everyone with **Send** sees every r
 On the Domma server itself (the Manager), the same screen is the **Inbox** of every site's requests, for holders of **Support > Manage**:
 
 - Filter by **Open**, **Answered**, **Resolved**, **Archived** or **All**, urgent first; search subject, text, person and site.
-- Open a request to read the conversation, **Reply** (the site sees it and is notified, and the person is emailed), **Resolve**, change its priority, and keep **Internal notes** (never sent to the site).
+- Open a request to read the conversation (with any files the customer attached - one still on its way says so), **Reply** (the site sees it and is notified, and the person is emailed), **Resolve**, change its priority, and keep **Internal notes** (never sent to the site).
 - Right-click a row to archive, resolve or **Delete** it. Archiving is Domma's own filing: the site does not see it, and a request comes out of the archive when the customer writes again.
 - A new request or a customer's reply is emailed to the Domma support address, with the customer as Reply-To and `[URGENT]` in the subject when it is urgent.
+- The **Support settings** cog sets the contact card every site shows (email, phone, opening hours, how fast you answer), the address new requests are emailed to, and how many messages one site may send in a window. Changes apply at once; each site gets the new card with its next sync.
 
 ## Limitations
 
 - Only sites started by a Domma server can send. A standalone install gets the contact card only.
-- No attachments or screenshots. Describe the problem in words, and use **Where** for the page.
+- Up to 3 files per message, 2 MB each, and only images (PNG, JPEG, GIF, WebP), PDFs and text files. A message with files still needs a few words.
 - Subjects are limited to 140 characters and messages to 8,000.
 - The Domma server accepts up to 20 requests and replies from one site in 10 minutes. Any more show as **Waiting to send** and go later.
 - You cannot edit or withdraw a message once sent. Write a follow-up instead.

package/plugins/support/lib/attachments.js

@@ -0,0 +1,133 @@
+/**
+ * Support - attachments on disk, and reading one out of an upload.
+ *
+ * A site keeps the files it attached under data/attachments/<id>.<ext> (with a
+ * <id>.json beside each saying what it is); the manager keeps a request's files
+ * under data/attachments/<request entry id>/. Files are 0600 in 0700 folders:
+ * they are screenshots of admin screens, nothing a web server should ever list.
+ * Nothing here is served from a public path - a route reads and sends them.
+ *
+ * @module support/lib/attachments
+ */
+import fs from 'node:fs';
+import path from 'node:path';
+import {ATTACHMENTS, ATTACHMENT_TYPES, cleanAttachment, extOf} from './shape.js';
+
+/** A folder name that is safe to join: a collection entry id, or our own staging name. */
+const SUB_RE = /^[A-Za-z0-9_-]{1,80}$/;
+
+/**
+ * Read ONE file out of a multipart request, within the caps. The whole file is
+ * held in memory - it is at most ATTACHMENTS.maxBytes.
+ *
+ * @returns {Promise<{file?: {name: string, type: string, size: number, buffer: Buffer}, error?: string, code?: number}>}
+ */
+export async function readUpload(request) {
+    if (typeof request.isMultipart !== 'function' || !request.isMultipart()) return {error: 'Send the file as a form upload.', code: 400};
+    let part;
+    try { part = await request.file(); } catch (err) { return {error: `That upload could not be read: ${err.message}`, code: 400}; }
+    if (!part) return {error: 'No file was sent.', code: 400};
+    const type = String(part.mimetype || '').toLowerCase().split(';')[0].trim();
+    const drain = async () => { for await (const _ of part.file) { /* a refused part must still be consumed */ } };
+    if (!ATTACHMENT_TYPES[type]) {
+        await drain();
+        return {error: `That kind of file (${type || 'unknown'}) cannot be attached. Attach a PNG, JPEG, GIF or WebP image, a PDF or a text file.`, code: 400};
+    }
+    const chunks = [];
+    let size = 0;
+    let over = false;
+    for await (const chunk of part.file) {
+        size += chunk.length;
+        // Keep reading so the request completes, but keep nothing more.
+        if (size > ATTACHMENTS.maxBytes) { over = true; continue; }
+        chunks.push(chunk);
+    }
+    if (over || part.file.truncated) return {error: `That file is too big - up to ${Math.round(ATTACHMENTS.maxBytes / 1024 / 1024)} MB each.`, code: 413};
+    if (!size) return {error: 'That file is empty.', code: 400};
+    return {file: {name: part.filename, type, size, buffer: Buffer.concat(chunks)}};
+}
+
+/**
+ * Send a stored file: its own type, shown inline, never sniffed into anything else.
+ * Private cache only - it needs the session that fetched it.
+ */
+export function sendFile(reply, a, buffer) {
+    return reply
+        .type(a.type)
+        .header('content-disposition', `inline; filename="${a.name.replace(/["\\]/g, '_')}"`)
+        .header('x-content-type-options', 'nosniff')
+        .header('cache-control', 'private, max-age=300')
+        .send(buffer);
+}
+
+/**
+ * The files under one root. Every path is built from a cleaned attachment and a
+ * checked sub-folder name - nothing from a request reaches `path.join` raw.
+ *
+ * @param {string} root - e.g. <plugin data dir>/attachments
+ */
+export function createStore(root) {
+    const dirOf = (sub) => {
+        if (sub && !SUB_RE.test(sub)) throw new Error('bad attachment folder');
+        return sub ? path.join(root, sub) : root;
+    };
+    const ensure = (sub) => fs.mkdirSync(dirOf(sub), {recursive: true, mode: 0o700});
+    const clean = (a) => { const c = cleanAttachment(a); if (!c) throw new Error('bad attachment'); return c; };
+    const fileOf = (sub, a) => path.join(dirOf(sub), `${a.id}.${extOf(a.type)}`);
+    const metaOf = (sub, id) => path.join(dirOf(sub), `${id}.json`);
+    return {
+        root,
+        /** Keep a file and what it is. */
+        save(att, buffer, sub = '') {
+            const a = clean(att);
+            ensure(sub);
+            fs.writeFileSync(fileOf(sub, a), buffer, {mode: 0o600});
+            fs.writeFileSync(metaOf(sub, a.id), JSON.stringify({id: a.id, name: a.name, type: a.type, size: a.size, at: new Date().toISOString()}), {mode: 0o600});
+            return a;
+        },
+        /** What a kept file is, from its sidecar - null when unknown. */
+        meta(id, sub = '') {
+            if (!/^[A-Za-z0-9-]{8,64}$/.test(String(id))) return null;
+            try { return cleanAttachment(JSON.parse(fs.readFileSync(metaOf(sub, id), 'utf8'))); } catch { return null; }
+        },
+        /** The bytes, or null. */
+        read(att, sub = '') {
+            try { return fs.readFileSync(fileOf(sub, clean(att))); } catch { return null; }
+        },
+        /** Move a file between folders. */
+        move(att, from, to) {
+            const a = clean(att);
+            ensure(to);
+            fs.renameSync(fileOf(from, a), fileOf(to, a));
+            try { fs.unlinkSync(metaOf(from, a.id)); } catch { /* no sidecar */ }
+        },
+        /** A request went: so do its files. */
+        removeAll(sub) {
+            if (!sub) return;
+            try { fs.rmSync(dirOf(sub), {recursive: true, force: true}); } catch { /* already gone */ }
+        },
+        /**
+         * Files picked but never sent (the panel was closed) are dropped once they are older
+         * than `maxAgeMs` and nothing still names them.
+         */
+        prune({maxAgeMs = 24 * 3600_000, keep = new Set(), sub = ''} = {}) {
+            let dir;
+            try { dir = fs.readdirSync(dirOf(sub)); } catch { return 0; }
+            let dropped = 0;
+            const cutoff = Date.now() - maxAgeMs;
+            for (const f of dir) {
+                const m = f.match(/^([A-Za-z0-9-]{8,64})\.json$/);
+                if (!m || keep.has(m[1])) continue;
+                const a = this.meta(m[1], sub);
+                const at = new Date(a?.at || 0).getTime();
+                let stat;
+                try { stat = fs.statSync(metaOf(sub, m[1])); } catch { continue; }
+                if (Math.max(at || 0, stat.mtimeMs) > cutoff) continue;
+                try { if (a) fs.unlinkSync(fileOf(sub, a)); } catch { /* gone */ }
+                try { fs.unlinkSync(metaOf(sub, m[1])); } catch { /* gone */ }
+                dropped++;
+            }
+            return dropped;
+        }
+    };
+}

package/plugins/support/lib/cache.js

@@ -0,0 +1,43 @@
+/**
+ * A short memory for whole-collection reads.
+ *
+ * On the manager, the badge (polled once a minute from every open admin tab
+ * with `manage`), every site's `/fleet/mine` (nudged once a minute by its own
+ * badge) and `byRef()` each read EVERY request. The data changes only when
+ * someone writes, so a read is kept for a little while and every write in
+ * lib/receiver.js throws the memory away (`forget()`, right after the write,
+ * so the writer's next read is fresh). The TTL is the safety net for writes
+ * this plugin never sees (the Collections tool).
+ *
+ * PURE - no I/O of its own; the loader is handed in. Tested in tests/cache.test.js.
+ *
+ * @module support/lib/cache
+ */
+
+export const CACHE_MS = 30_000;
+
+/**
+ * @param {{ttl?: number, clock?: () => number}} [opts]
+ * @returns {{get: (key: string, load: () => Promise<any>) => Promise<any>, forget: () => void, size: number}}
+ */
+export function createCache({ttl = CACHE_MS, clock = Date.now} = {}) {
+    // key -> {at, value: Promise}. The PROMISE is kept, not the result, so
+    // concurrent misses share one read, and a write landing while a read is in
+    // flight clears the map before that read can be stored - nothing stale
+    // survives a forget().
+    const kept = new Map();
+    return {
+        get(key, load) {
+            const hit = kept.get(key);
+            if (hit && clock() - hit.at < ttl) return hit.value;
+            const value = Promise.resolve().then(load);
+            const entry = {at: clock(), value};
+            kept.set(key, entry);
+            // A failed read is not remembered: the next caller tries again.
+            value.catch(() => { if (kept.get(key) === entry) kept.delete(key); });
+            return value;
+        },
+        forget() { kept.clear(); },
+        get size() { return kept.size; }
+    };
+}

package/plugins/support/lib/receiver.js

@@ -15,6 +15,7 @@ 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 {createCache} from './cache.js';
 import {addTurn, receivedTicket} from './shape.js';
 
 export const COLLECTION = 'support-tickets';
@@ -71,10 +72,17 @@ export async function ensureCollection() {
     return true;
 }
 
-/** Every request, newest first. */
-export async function allTickets() {
-    const {entries} = await listEntries(COLLECTION, {limit: 100000, sort: 'createdAt', order: 'desc'});
-    return entries || [];
+// The whole-collection read, kept a short while (lib/cache.js). Every write
+// below calls forget() so the writer's own next read - and the badge - is fresh.
+const remembered = createCache();
+export const forget = () => remembered.forget();
+
+/** Every request, newest first - the SAME array to every caller inside the cache window: filter, never change it. */
+export function allTickets() {
+    return remembered.get('tickets', async () => {
+        const {entries} = await listEntries(COLLECTION, {limit: 100000, sort: 'createdAt', order: 'desc'});
+        return entries || [];
+    });
 }
 
 export const getTicket = (id) => getEntry(COLLECTION, id);
@@ -95,7 +103,9 @@ export async function removeTicket(id) {
         fs.mkdirSync(path.dirname(DELETED), {recursive: true});
         fs.writeFileSync(DELETED, JSON.stringify(gone));
     }
-    return deleteEntry(COLLECTION, id);
+    const r = await deleteEntry(COLLECTION, id);
+    forget();
+    return r;
 }
 
 /** One site's requests - never another's. */
@@ -127,7 +137,9 @@ async function openNow(slug, payload, now, site) {
     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};
+    const entry = await createEntry(COLLECTION, data, {source: 'fleet'});
+    forget();
+    return {entry, created: true};
 }
 
 /**
@@ -148,11 +160,30 @@ async function customerTurnNow(id, payload, now) {
     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)});
+    const {data, added} = addTurn(e.data, {from: 'customer', name, body, id: String(payload.ref || ''), at: now, close: Boolean(payload.close),
+        attachments: payload.attachments});
     if (!added) return {entry: e, added: false};
-    return {entry: await updateEntry(COLLECTION, e.id, data), added: true};
+    const entry = await updateEntry(COLLECTION, e.id, data);
+    forget();
+    return {entry, added: true};
+}
+
+/** A request's file has arrived: mark it stored on its message. No history line - nothing moved. */
+export function markStored(id, attId) {
+    return serial(id, async () => {
+        const e = await getTicket(id);
+        if (!e) return null;
+        const messages = (e.data.messages || []).map(m => (m.attachments?.some(a => a.id === attId)
+            ? {...m, attachments: m.attachments.map(a => (a.id === attId ? {...a, stored: true} : a))} : m));
+        const next = await updateEntry(COLLECTION, id, {...e.data, messages});
+        forget();
+        return next;
+    });
 }
 
+/** That site's request with this ref (a site knows its requests by ref, never by the manager's id). */
+export const ticketByRef = (slug, ref) => byRef(slug, String(ref || ''));
+
 /** Domma replied (and/or moved the status). */
 export function dommaTurn(id, turn, now = new Date().toISOString()) {
     return serial(id, () => dommaTurnNow(id, turn, now));
@@ -162,7 +193,9 @@ 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);
+    const next = await updateEntry(COLLECTION, id, data);
+    forget();
+    return next;
 }
 
 /** Status, priority, notes or the archive, from the inbox - with a line of history for what moved. */
@@ -179,5 +212,7 @@ async function patchNow(id, change, by, now) {
     if (change.priority !== undefined && change.priority !== d.priority) history.push({at: now, by, what: `Priority: ${change.priority}`});
     if (change.archived !== undefined && change.archived !== Boolean(d.archived)) history.push({at: now, by, what: change.archived ? 'Archived' : 'Back from the archive'});
     Object.assign(d, change, {history: history.slice(-200)});
-    return updateEntry(COLLECTION, id, d);
+    const next = await updateEntry(COLLECTION, id, d);
+    forget();
+    return next;
 }