domma-cms 0.92.1 → 0.94.0

package/plugins/feedback/admin/views/feedback.js

@@ -2,18 +2,25 @@
  * Feedback - one sidebar entry, two screens, decided by the server:
  *
  *   on a site     Send feedback, and what this site has sent (send.js)
- *   on the manager  the inbox of every site's feedback (inbox.js)
+ *   on the manager  the inbox of every site's feedback (inbox.js); the level-0 role
+ *                   also gets a "My feedback" tab - send.js again, filing straight
+ *                   into that inbox as "Manager (this server)"
  *
  *   #/plugins/feedback        the screen
  *   #/plugins/feedback/<id>   the same, with that report open (a notification's link)
+ *   #/plugins/feedback/mine   the manager, on the My feedback tab
  *
  * Path segments, not ?query: the admin router 404s a query on a fresh load.
  */
 
-import {api, loadKit} from '../lib/kit.js';
+import {api, loadKit, store} from '../lib/kit.js';
 
 const ROUTE = /^#\/plugins\/feedback(\/|$)/;
-const V = '1.0.0';
+const V = '1.1.0';
+const TABS = [
+    {key: 'inbox', label: 'Inbox', icon: 'inbox'},
+    {key: 'mine', label: 'My feedback', icon: 'send'}
+];
 let lifetime = null;
 
 export const feedbackView = {
@@ -50,14 +57,76 @@ export const feedbackView = {
         }
         if (!here()) return;
 
-        const screen = mode.mode === 'receiver' ? 'inbox' : 'send';
-        try {
+        const load = async (screen, into, ctx) => {
             const mod = await import(`/plugins/feedback/admin/views/${screen}.js?v=${V}`);
-            if (!here()) return;
-            const cleanup = await mod.mount(root, {kit, scope, here, container, $container, mode, meta, id});
-            if (typeof cleanup === 'function') scope(cleanup);
-        } catch (err) {
-            fail(`This screen could not load: ${err.message || err}`);
+            if (!here()) return null;
+            return mod.mount(into, {kit, container, $container, meta, here, ...ctx});
+        };
+
+        // A site, or a manager user below level 0: one screen, as before.
+        if (mode.mode !== 'receiver' || !mode.canSend) {
+            try {
+                const cleanup = await load(mode.mode === 'receiver' ? 'inbox' : 'send', root, {scope, mode, id});
+                if (typeof cleanup === 'function') scope(cleanup);
+            } catch (err) {
+                fail(`This screen could not load: ${err.message || err}`);
+            }
+            return;
         }
+
+        // The manager's level-0 role: the inbox, and its own feedback. One tab mounted at a time,
+        // each with its own cleanups, so switching back always shows fresh data.
+        root.innerHTML = `
+<div class="fb-bar fb-tabs">
+  <div class="fb-seg" role="tablist" aria-label="Feedback">
+    ${TABS.map(t => `<button type="button" role="tab" data-tab="${t.key}"><span data-icon="${t.icon}" data-icon-size="14"></span> ${t.label}</button>`).join('')}
+  </div>
+  <span data-help-title="Your own feedback" data-help="Inbox is every report, from every site and from this server. My feedback is where you file your own - a bug, a request or a note to self about the CMS or the Manager. It goes straight into the Inbox, marked Manager (this server), and then works like any site's report: status, reply and a Waypoint issue. Only the most senior role sees this tab."></span>
+</div>
+<div data-feedback-pane></div>`;
+        scope(kit.helpPopovers(root, {position: 'bottom'}));
+        I.scan(root);
+        const pane = root.querySelector('[data-feedback-pane]');
+        const tabs = root.querySelector('.fb-seg');
+        let paneCleanups = [];
+        const disposePane = () => { for (const fn of paneCleanups.splice(0)) { try { fn(); } catch { /* already gone */ } } };
+        scope(disposePane);
+
+        let current = '';
+        const show = async (key, openId = '') => {
+            if (key === current) return;
+            current = key;
+            store.set('feedback.tab', key);
+            for (const b of tabs.querySelectorAll('[data-tab]')) {
+                const on = b.dataset.tab === key;
+                b.classList.toggle('is-on', on);
+                b.setAttribute('aria-selected', String(on));
+            }
+            disposePane();
+            pane.innerHTML = '';
+            const mine = () => current === key && here();
+            const paneScope = (fn) => { paneCleanups.push(fn); return fn; };
+            try {
+                const cleanup = await load(key === 'mine' ? 'send' : 'inbox', pane, {
+                    scope: paneScope, here: mine, id: openId,
+                    mode: key === 'mine' ? {mode: 'sender', connected: true, local: true} : mode
+                });
+                if (typeof cleanup === 'function') paneScope(cleanup);
+            } catch (err) {
+                pane.innerHTML = '';
+                const p = document.createElement('p');
+                p.className = 'fb-note is-bad';
+                p.textContent = `This screen could not load: ${err.message || err}`;
+                pane.appendChild(p);
+            }
+        };
+        const onTab = (e) => { const b = e.target.closest('[data-tab]'); if (b) show(b.dataset.tab); };
+        tabs.addEventListener('click', onTab);
+        scope(() => tabs.removeEventListener('click', onTab));
+
+        // A report id in the path opens the inbox on it; /mine, or the last tab used, otherwise.
+        if (id === 'mine') await show('mine');
+        else if (id) await show('inbox', id);
+        else await show(store.get('feedback.tab') === 'mine' ? 'mine' : 'inbox');
     }
 };

package/plugins/feedback/admin/views/send.js

@@ -5,6 +5,9 @@
  * A report is kept on this site before it is sent, so a Domma server that is
  * restarting only delays it ("Waiting to send"); opening this screen tries
  * again. A site the manager did not start has nowhere to send to, and says so.
+ *
+ * On the manager itself (ctx.mode.local - the level-0 role's "My feedback" tab)
+ * the same screen files straight into the inbox: nothing waits, nothing travels.
  */
 
 import {api, esc, openPanel, refreshBadge, stamp, when} from '../lib/kit.js';
@@ -22,6 +25,24 @@ const TONE = {new: 'info', acknowledged: 'muted', planned: 'info', 'in-progress'
 
 export async function mount(root, ctx) {
     const {kit, scope, here, meta, id} = ctx;
+    const local = Boolean(ctx.mode.local);
+    const COPY = local ? {
+        lead: 'File your own feedback on the CMS or the Manager.',
+        sub: 'It goes straight into the Inbox as Manager (this server) - status, reply and Waypoint work as for any site.',
+        help: 'For you and the other holders of the most senior role on this server. A report lands in the Inbox tab at once, marked Manager (this server), so it sits beside the sites\' reports and can be answered or made a Waypoint issue there. This list is everything this server has filed, whoever filed it, with its status and any reply.',
+        title: 'Send feedback',
+        hint: 'Filed with your name and this server\'s CMS version.',
+        replied: 'Reply',
+        noReply: 'No reply yet. Answer it, or file it in Waypoint, from the Inbox tab.'
+    } : {
+        lead: 'Tell Domma what is broken, missing or good.',
+        sub: 'Every report is read. You will see its progress here, and any reply.',
+        help: 'Reports go to the Domma team, with your name and this site attached so we can come back to you. You see everything this site has sent, whoever sent it. A report shows as Seen, Planned, In progress, Done or Not planned as it moves, and a reply from Domma appears in it - the sidebar badge counts replies you have not opened.',
+        title: 'Send feedback to Domma',
+        hint: 'Sent with your name, this site and its CMS version, so Domma can reply.',
+        replied: 'Domma replied',
+        noReply: 'No reply yet. The status above moves as Domma works on it.'
+    };
     const types = meta.types || [];
     const iconOf = (t) => types.find(x => x.key === t)?.icon || 'message-square';
     const labelOf = (t) => types.find(x => x.key === t)?.short || t;
@@ -58,10 +79,10 @@ export async function mount(root, ctx) {
 <div data-bind-hidden="!connected.value">
   <div class="fb-bar">
     <div class="fb-intro">
-      <strong>Tell Domma what is broken, missing or good.</strong>
-      <span>Every report is read. You will see its progress here, and any reply.</span>
+      <strong>${esc(COPY.lead)}</strong>
+      <span>${esc(COPY.sub)}</span>
     </div>
-    <span data-help-title="Feedback" data-help="Reports go to the Domma team, with your name and this site attached so we can come back to you. You see everything this site has sent, whoever sent it. A report shows as Seen, Planned, In progress, Done or Not planned as it moves, and a reply from Domma appears in it - the sidebar badge counts replies you have not opened."></span>
+    <span data-help-title="Feedback" data-help="${esc(COPY.help)}"></span>
     <span class="fb-spacer"></span>
     <button type="button" class="btn btn-primary btn-sm" data-on-click="compose"><span data-icon="send" data-icon-size="14"></span> Send feedback</button>
   </div>
@@ -116,7 +137,7 @@ export async function mount(root, ctx) {
         const isBug = M.computed(() => f.type.value === 'bug');
         let panel = null;
         openPanel({
-            title: 'Send feedback to Domma',
+            title: COPY.title,
             size: 'md',
             model: {...f, isBug},
             html: `<div class="fb-form">
@@ -136,7 +157,7 @@ export async function mount(root, ctx) {
   </div>
   <label class="form-label" for="fb-where">Where <span data-help="The screen or page it is about, if there is one - e.g. Pages, the Blog editor, /contact. Optional."></span></label>
   <input id="fb-where" class="form-input" maxlength="300" data-model="where.value" placeholder="Optional">
-  <p class="fb-hint">Sent with your name, this site and its CMS version, so Domma can reply.</p>
+  <p class="fb-hint">${esc(COPY.hint)}</p>
   <div class="fb-actions"><span class="fb-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>
@@ -152,6 +173,7 @@ export async function mount(root, ctx) {
                             where: f.where.peek(), severity: f.type.peek() === 'bug' ? f.severity.peek() : ''});
                         E.toast(r.message || 'Sent.', {type: r.state === 'sent' ? 'success' : 'warning'});
                         panel?.close();
+                        refreshBadge();
                         await load();
                     } catch (err) {
                         E.toast(err.message || String(err), {type: 'error'});
@@ -189,7 +211,7 @@ export async function mount(root, ctx) {
   <dl class="fb-facts">${lines.map(([a, b]) => `<div><dt>${esc(a)}</dt><dd>${esc(b)}</dd></div>`).join('')}</dl>
   <h4>What was sent</h4>
   <div class="fb-text">${esc(r.description)}</div>
-  ${r.reply ? `<h4><span data-icon="corner-up-left" data-icon-size="14"></span> Domma replied <small>${esc(stamp(r.replyAt))}</small></h4><div class="fb-text fb-reply">${esc(r.reply)}</div>` : '<p class="fb-note">No reply yet. The status above moves as Domma works on it.</p>'}
+  ${r.reply ? `<h4><span data-icon="corner-up-left" data-icon-size="14"></span> ${esc(COPY.replied)} <small>${esc(stamp(r.replyAt))}</small></h4><div class="fb-text fb-reply">${esc(r.reply)}</div>` : `<p class="fb-note">${esc(COPY.noReply)}</p>`}
 </div>`
         });
         if (r.unread && r.id) {

package/plugins/feedback/docs/guide.md

@@ -0,0 +1,95 @@
+---
+title: Guide
+order: 1
+---
+
+Feedback lets you tell Domma what is broken, missing or good, straight from your admin, and follow what happens to it. It is free.
+
+## What it does
+
+- Sends a report to the Domma team with your name, your site and its CMS version attached, so Domma can reply.
+- Lists every report this site has sent, whoever sent it, with its status.
+- Shows Domma's reply inside the report, and tells you when one arrives.
+- Keeps a report safe if Domma cannot be reached, and sends it as soon as it can.
+
+## Getting started
+
+1. Open [Feedback](#/plugins/feedback) from the admin sidebar.
+2. Click **Send feedback**.
+3. Under **What is it?** pick one: Something is broken, An idea or request, A question, Something we got right, or Something else.
+4. Type a **Title** (one line) and a **Description**.
+5. For something broken, choose **How bad is it?**: Minor - a nuisance, Major - gets in the way, or Blocker - cannot carry on.
+6. Optional: fill in **Where** - the screen or page it is about, for example "Pages" or `/contact`.
+7. Click **Send**.
+
+A good bug report says what you did, what you expected and what happened instead. For a request, say what you are trying to get done.
+
+## Screens
+
+### Your reports
+
+Each row shows the type, title, when it was sent and by whom, and a status:
+
+| Status | Meaning |
+|---|---|
+| New | Domma has it and has not looked yet |
+| Seen | Domma has read it |
+| Planned | It is on the list |
+| In progress | Being worked on |
+| Done | Finished |
+| Not planned | Domma does not intend to do it |
+| Waiting to send | Domma could not be reached yet; it goes automatically |
+| Not accepted | Domma's server turned the report down |
+
+A dot on a row means a new reply. Click a row to open it: you see the details, **What was sent**, and **Domma replied** with the reply, or "No reply yet".
+
+If "Tracked as" appears, Domma has filed the report in its own issue tracker, and the status follows that issue.
+
+When reports are waiting to send, a note says so, with **Try now**.
+
+### Not connected
+
+If the screen says "This site is not connected to Domma", your site was not started by a Domma server, so there is nowhere to send to. Ask whoever set the site up.
+
+## Settings
+
+There is no settings screen. Whoever runs the site can change one option in the plugin's configuration file:
+
+| Option | Default | Meaning |
+|---|---|---|
+| `syncMinutes` | 60 | How often the site sends waiting reports and checks for replies |
+
+Opening the Feedback screen also sends anything waiting and checks for replies straight away.
+
+## Notifications
+
+When Domma replies, you get an admin notification "Domma replied:" followed by the report's title. The sidebar badge counts replies you have not opened; opening the report clears it.
+
+## Permissions and roles
+
+In System > Roles, Feedback appears in the **Plugins** group:
+
+| Action | Label | Allows |
+|---|---|---|
+| `feedback.send` | Send | Send feedback to Domma and see what this site has sent |
+| `feedback.manage` | Manage | Only used on the Domma server (see below) |
+
+Only the **admin** role has them by default. Everyone with **Send** sees every report the site has sent, not just their own.
+
+## On the Domma server
+
+On the Domma server itself (the Manager), the same screen is the **Inbox** of every site's reports, for holders of **Feedback > Manage**:
+
+- Filter by **Open**, each status, or **All**; by site and type; and search title, text, person and site.
+- Open a report to set its **Status**, write a **Reply to the site** (the site sees it and is notified) and keep **Internal notes** (never sent to the site). Click **Save**.
+- With Waypoint Pro installed, **Make a Waypoint issue** files the report in a project with a type and priority. The report then follows the issue: planned, in progress, done. "Not planned" set by hand stays until you change it.
+- Right-click a row to open it, change its status quickly, or **Delete** it. Deleting removes it for the site too.
+- Holders of the most senior role also get **My feedback**, to file their own reports. These appear in the Inbox as "Manager (this server)".
+
+## Limitations
+
+- Only sites started by a Domma server can send. A standalone install cannot.
+- No attachments or screenshots. Describe the problem in words, and use **Where** for the page.
+- Titles are limited to 140 characters and descriptions to 8,000.
+- The Domma server accepts up to 10 reports from one site in 10 minutes. Any more show as **Waiting to send** and go later.
+- You cannot edit or withdraw a report once sent. Send a follow-up instead.

package/plugins/feedback/lib/receiver.js

@@ -21,6 +21,10 @@ import {receivedReport, statusFromIssue, statusLabel} from './shape.js';
 
 export const COLLECTION = 'feedback-reports';
 
+/** The site slug the manager's OWN reports carry. Site slugs start [a-z0-9], so no site can be this. */
+export const MANAGER_SITE = '_manager';
+export const MANAGER_NAME = 'Manager (this server)';
+
 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');
@@ -68,9 +72,12 @@ export const removeReport = (id) => deleteEntry(COLLECTION, id);
  * A site's report arrived. The same site sending the same `ref` again (a retry
  * after a reply that never reached it) gets the report it already made.
  *
+ * @param   {string} slug
+ * @param   {object} payload
+ * @param   {string} [source] - entry meta source: 'fleet' from a site, 'manager' for its own
  * @returns {Promise<{entry?: object, created?: boolean, error?: string}>}
  */
-export async function receive(slug, payload) {
+export async function receive(slug, payload, source = 'fleet') {
     const {data, error} = receivedReport(payload, slug);
     if (error) return {error};
     if (data.ref) {
@@ -78,7 +85,7 @@ export async function receive(slug, payload) {
         if (same) return {entry: same, created: false};
     }
     data.history = [{at: new Date().toISOString(), by: data.userName, what: 'Sent'}];
-    const entry = await createEntry(COLLECTION, data, {source: 'fleet'});
+    const entry = await createEntry(COLLECTION, data, {source});
     return {entry, created: true};
 }
 

package/plugins/feedback/lib/sender.js

@@ -31,10 +31,11 @@ export function managerOf(env = process.env) {
  * The outbox: this site's copy of everything it sent, in data/outbox.json.
  *
  * @param   {string} dataDir
+ * @param   {string} [name] - the manager keeps only `seen` for its own reports, in own.json
  * @returns {object}
  */
-export function createOutbox(dataDir) {
-    const file = path.join(dataDir, 'outbox.json');
+export function createOutbox(dataDir, name = 'outbox.json') {
+    const file = path.join(dataDir, name);
     const read = () => {
         try {
             const j = JSON.parse(fs.readFileSync(file, 'utf8'));

package/plugins/feedback/plugin.js

@@ -15,6 +15,9 @@
  *     POST /fleet/submit          a site's report (Bearer fleet token)
  *     GET  /fleet/mine            that site's reports, sender-safe fields only
  *     GET  /mode · GET /count     'new' reports
+ *     POST /send · GET /sent · PUT /sent/:id/seen
+ *                                 the manager's OWN feedback (level-0 role only):
+ *                                 written straight into the inbox as site `_manager`
  *     GET  /reports · GET /reports/:id · PUT /reports/:id · DELETE /reports/:id
  *     GET  /waypoint              is Waypoint Pro here, and its projects
  *     POST /reports/:id/promote   make a Waypoint issue from a report
@@ -30,6 +33,7 @@ import {
     SEVERITIES, STATUSES, TYPES, buildPayload, cleanSubmission, cleanUpdate, createThrottle, issueDescription, senderView
 } from './lib/shape.js';
 import {createOutbox, flush, managerApi, managerOf, mergeReports, newRef} from './lib/sender.js';
+import {getEffectiveLevel} from '../../server/services/userRoles.js';
 
 const HERE = path.dirname(fileURLToPath(import.meta.url));
 const NAME = 'feedback';
@@ -67,7 +71,7 @@ export default async function feedbackPlugin(fastify, options) {
 
     fastify.get('/meta', can('send'), async () => ({types: TYPES, statuses: STATUSES, severities: SEVERITIES}));
 
-    if (mode === 'receiver') await receiverRoutes(fastify, {can, hooks, notifyOk, receiverMod, settings, options});
+    if (mode === 'receiver') await receiverRoutes(fastify, {can, authenticate, requirePermission, hooks, notifyOk, receiverMod, settings, options});
     else await senderRoutes(fastify, {can, hooks, notifyOk, settings, options});
 }
 
@@ -152,10 +156,21 @@ async function senderRoutes(fastify, {can, hooks, notifyOk, settings, options})
 // Receiver (the manager)
 // ---------------------------------------------------------------------------------
 
-async function receiverRoutes(fastify, {can, hooks, notifyOk, receiverMod, settings, options}) {
+/** Level 0 - the most senior role, whatever it is called. Roles are data, never names in code. */
+const isTopLevel = (user) => { try { return getEffectiveLevel(user) === 0; } catch { return false; } };
+
+async function receiverRoutes(fastify, {can, authenticate, requirePermission, hooks, notifyOk, receiverMod, settings, options}) {
     const rx = receiverMod;
     const slugOf = options.slugFromToken || rx.slugFromToken;
-    const names = options.siteNames || rx.siteNames;
+    const siteNames = options.siteNames || rx.siteNames;
+    // The manager's own reports are filed as `_manager` - a slug no site can have (theirs start [a-z0-9]).
+    const names = () => ({...siteNames(), [rx.MANAGER_SITE]: rx.MANAGER_NAME});
+    // Its own feedback: the level-0 role only, on top of the `feedback` send permission.
+    const topOnly = async (request, reply) => {
+        if (!isTopLevel(request.user)) return reply.code(403).send({error: 'Only the most senior role on this server can send feedback from here.'});
+    };
+    const own = {preHandler: [authenticate, requirePermission('feedback', 'send'), topOnly]};
+    const ownSeen = createOutbox(options.dataDir || path.join(HERE, 'data'), 'own.json');
     const allowed = createThrottle({max: Number(settings.perSiteMax) || 10, windowMs: (Number(settings.perSiteMinutes) || 10) * 60_000});
     try { await rx.ensureCollection(); } catch (err) { fastify.log.error(`[feedback] collection: ${err.message}`); }
 
@@ -195,20 +210,49 @@ async function receiverRoutes(fastify, {can, hooks, notifyOk, receiverMod, setti
 
     // ---- The inbox ----
 
-    fastify.get('/mode', can('manage'), async () => ({mode: 'receiver', waypoint: Boolean(waypoint())}));
+    fastify.get('/mode', can('manage'), async (request) => ({mode: 'receiver', waypoint: Boolean(waypoint()), canSend: isTopLevel(request.user)}));
 
-    fastify.get('/count', can('manage'), async () => {
-        const fresh = (await rx.allReports()).filter(e => e.data?.status === 'new');
+    fastify.get('/count', can('manage'), async (request) => {
+        const all = await rx.allReports();
+        const fresh = all.filter(e => e.data?.status === 'new');
         const n = names();
+        const seen = ownSeen.seen();
+        const replies = isTopLevel(request.user)
+            ? all.filter(e => e.data?.site === rx.MANAGER_SITE && e.data.reply && e.data.replyAt && seen[e.id] !== e.data.replyAt).length : 0;
         return {
             count: fresh.length,
             label: fresh.length ? `${fresh.length} new` : '',
             tone: fresh.some(e => e.data?.severity === 'blocker') ? 'danger' : 'info',
             details: {title: 'New feedback', items: fresh.slice(0, 6).map(e => ({text: e.data.title, meta: n[e.data.site] || e.data.site})),
+                ...(replies && {rows: [{label: 'New', value: String(fresh.length)}, {label: 'Replies to your own feedback', value: String(replies)}]}),
                 empty: 'Nothing new.'}
         };
     });
 
+    // ---- The manager's own feedback: straight into the inbox, no HTTP round trip ----
+
+    fastify.post('/send', own, async (request, reply) => {
+        const {report, error} = cleanSubmission(request.body || {});
+        if (error) return reply.code(400).send({error});
+        if (!allowed(rx.MANAGER_SITE)) return reply.code(429).send({error: 'That is a lot of feedback at once - try again in a few minutes.'});
+        const payload = buildPayload({report, user: request.user, cmsVersion: cmsVersion(), site: rx.MANAGER_SITE, ref: newRef()});
+        const r = await rx.receive(rx.MANAGER_SITE, payload, 'manager');
+        if (r.error) return reply.code(400).send({error: r.error});
+        return reply.code(201).send({id: r.entry.id, ref: payload.ref, state: 'sent', message: 'Filed in the inbox.'});
+    });
+
+    fastify.get('/sent', own, async () => {
+        const seen = ownSeen.seen();
+        const reports = (await rx.reportsOf(rx.MANAGER_SITE)).map(senderView)
+            .map(r => ({...r, local: false, unread: Boolean(r.reply && r.replyAt && seen[r.id] !== r.replyAt)}));
+        return {connected: true, reachable: true, error: '', local: true, reports};
+    });
+
+    fastify.put('/sent/:id/seen', own, async (request) => {
+        ownSeen.markSeen(String(request.params.id), String(request.body?.replyAt || ''));
+        return {ok: true};
+    });
+
     fastify.get('/reports', can('manage'), async () => {
         const n = names();
         return {sites: n, reports: (await rx.allReports()).map(e => ({id: e.id, ...e.data, siteName: n[e.data.site] || e.data.site,
@@ -235,6 +279,10 @@ async function receiverRoutes(fastify, {can, hooks, notifyOk, receiverMod, setti
         const {patch, error} = cleanUpdate(request.body || {}, e.data);
         if (error) return reply.code(400).send({error});
         const next = await rx.applyPatch(e.id, patch, request.user?.name || 'Domma');
+        // Answering your own report is not news to you.
+        if (next.data.site === rx.MANAGER_SITE && next.data.replyAt && next.data.userId && next.data.userId === String(request.user?.id || '')) {
+            ownSeen.markSeen(next.id, next.data.replyAt);
+        }
         return {id: next.id, ...next.data, createdAt: next.meta?.createdAt, updatedAt: next.meta?.updatedAt};
     });
 

package/plugins/feedback/plugin.json

@@ -1,7 +1,7 @@
 {
   "name": "feedback",
   "displayName": "Feedback",
-  "version": "1.0.0",
+  "version": "1.1.2",
   "tier": "free",
   "description": "Tell Domma what is broken, missing or good - straight from your admin - and see what became of it: seen, planned, in progress, done, with Domma's reply.",
   "author": "Domma CMS",
@@ -13,9 +13,9 @@
       "label": "Feedback",
       "group": "Plugins",
       "icon": "message-square",
-      "description": "Send feedback to Domma and read the replies (send). On the Domma server itself: read, answer and file everything the sites sent (manage).",
+      "description": "Send feedback to Domma and read the replies (send). On the Domma server itself: read, answer and file everything the sites sent (manage); the level-0 role can also file its own there.",
       "actions": [
-        {"key": "send", "label": "Send", "description": "Send feedback to Domma and see what this site has sent"},
+        {"key": "send", "label": "Send", "description": "Send feedback to Domma and see what this site has sent (on the Domma server: the level-0 role only)"},
         {"key": "manage", "label": "Manage", "description": "On the Domma server: the inbox of every site's feedback"}
       ],
       "grant": ["admin"]
@@ -40,7 +40,7 @@
     ],
     "views": {
       "plugin-feedback": {
-        "entry": "feedback/admin/views/feedback.js?v=1.0.0",
+        "entry": "feedback/admin/views/feedback.js?v=1.1.1",
         "exportName": "feedbackView"
       }
     }

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

@@ -11,6 +11,7 @@ import os from 'node:os';
 import path from 'node:path';
 import Fastify from 'fastify';
 import feedback from '../plugin.js';
+import {getRoleHierarchy, getRoleLevel, load as loadRoles} from '../../../server/services/roles.js';
 
 const PLUGINS = path.resolve('config/plugins.json');
 const COLL = path.resolve('content/collections/feedback-reports');
@@ -21,6 +22,9 @@ let dataDir;
 let managerUp = true;
 const notices = [];
 const siteNotices = [];
+// Roles are data: the level-0 role and one below it, whatever this checkout calls them.
+let TOP;
+let BELOW;
 
 /** A site's fetch: into the manager app, or a connection failure while it is "restarting". */
 const fetchInto = (app) => async (url, init = {}) => {
@@ -53,10 +57,15 @@ before(async () => {
     savedPlugins = await fs.readFile(PLUGINS, 'utf8').catch(() => null);
     await fs.rm(COLL, {recursive: true, force: true});
     dataDir = await fs.mkdtemp(path.join(os.tmpdir(), 'feedback-test-'));
+    await loadRoles();
+    TOP = getRoleHierarchy().find(r => getRoleLevel(r) === 0);
+    BELOW = getRoleHierarchy().find(r => getRoleLevel(r) > 0);
     manager = Fastify();
     await manager.register(feedback, {
-        auth: {authenticate: async (req) => { req.user = {id: 'v1', name: 'Vendor', role: 'super-admin'}; }, requirePermission: () => async () => {}},
-        prefix: '/api/plugins/feedback',
+        // x-test-user swaps the signed-in user for one request; otherwise the vendor at level 0.
+        auth: {authenticate: async (req) => { req.user = req.headers['x-test-user'] ? JSON.parse(req.headers['x-test-user']) : {id: 'v1', name: 'Vendor', role: TOP}; },
+            requirePermission: () => async () => {}},
+        prefix: '/api/plugins/feedback', dataDir: await fs.mkdtemp(path.join(dataDir, 'manager-')),
         settings: {perSiteMax: 6, perSiteMinutes: 10}, mode: 'receiver',
         slugFromToken: async (h) => TOKENS[String(h || '').replace(/^Bearer\s+/i, '')] || null,
         siteNames: () => ({acme: 'Acme Ltd', beta: 'Beta Co'}),
@@ -217,3 +226,66 @@ test('a site the manager did not start cannot send, and says so', async () => {
     assert.equal((await call(app, 'POST', '/send', {title: 't', description: 'd'})).status, 409);
     await app.close();
 });
+
+test('the manager\'s level-0 role files its own feedback straight into the inbox', async () => {
+    assert.ok(TOP && BELOW, 'this checkout has a level-0 role and one below it');
+    const P = '/api/plugins/feedback';
+    const me = {id: 'v1', name: 'Vendor', email: 'v@domma.test', role: TOP};
+    const as = (u) => ({'x-test-user': JSON.stringify(u)});
+    assert.equal((await call(manager, 'GET', `${P}/mode`, null, as(me))).body.canSend, true);
+
+    let r = await call(manager, 'POST', `${P}/send`, {type: 'bug', title: 'Manager hiccup', description: 'The fleet list flickers.', severity: 'minor',
+        user: {name: 'Mallory'}, site: 'acme'}, as(me));
+    assert.equal(r.status, 201, JSON.stringify(r.body));
+    assert.equal(r.body.state, 'sent');
+
+    const inbox = (await call(manager, 'GET', `${P}/reports`)).body;
+    const got = inbox.reports.find(x => x.title === 'Manager hiccup');
+    assert.equal(got.site, '_manager', 'marked as the manager, whatever the body says');
+    assert.equal(got.siteName, 'Manager (this server)');
+    assert.equal(got.userName, 'Vendor', 'the session names the sender');
+    assert.equal(got.status, 'new');
+    assert.equal(inbox.sites._manager, 'Manager (this server)', 'the site filter offers it');
+    assert.ok(!notices.some(n => n.title.includes('Manager hiccup')), 'no notice to yourself');
+
+    // Below level 0: refused, and not offered.
+    const admin = {id: 'a1', name: 'Ada', role: BELOW};
+    assert.equal((await call(manager, 'GET', `${P}/mode`, null, as(admin))).body.canSend, false);
+    assert.equal((await call(manager, 'POST', `${P}/send`, {title: 't', description: 'd'}, as(admin))).status, 403);
+    assert.equal((await call(manager, 'GET', `${P}/sent`, null, as(admin))).status, 403);
+    assert.equal((await call(manager, 'PUT', `${P}/sent/${got.id}/seen`, {replyAt: 'x'}, as(admin))).status, 403);
+    assert.equal((await call(manager, 'POST', `${P}/send`, {title: 't'}, as(me))).status, 400);
+
+    // Its own list: only the manager's reports, sender-safe fields, same as a site sees.
+    let mine = (await call(manager, 'GET', `${P}/sent`, null, as(me))).body;
+    assert.equal(mine.connected, true);
+    assert.deepEqual(mine.reports.map(x => x.title), ['Manager hiccup']);
+    for (const k of ['notes', 'userEmail', 'site', 'history']) assert.equal(mine.reports[0][k], undefined, `${k} stays in the inbox`);
+
+    // The same reply flow: another level-0 holder answers; it shows unread until opened.
+    r = await call(manager, 'PUT', `${P}/reports/${got.id}`, {status: 'planned', reply: 'Next release.', notes: 'css'},
+        as({id: 'v2', name: 'Other', role: TOP}));
+    assert.equal(r.status, 200);
+    mine = (await call(manager, 'GET', `${P}/sent`, null, as(me))).body.reports[0];
+    assert.equal(mine.statusLabel, 'Planned');
+    assert.equal(mine.reply, 'Next release.');
+    assert.equal(mine.unread, true);
+    assert.equal((await call(manager, 'GET', `${P}/count`, null, as(me))).body.details.rows[1].value, '1');
+    await call(manager, 'PUT', `${P}/sent/${mine.id}/seen`, {replyAt: mine.replyAt}, as(me));
+    assert.equal((await call(manager, 'GET', `${P}/sent`, null, as(me))).body.reports[0].unread, false);
+
+    // Replying to your own report is not news to you.
+    await call(manager, 'PUT', `${P}/reports/${got.id}`, {reply: 'Done it myself.'}, as(me));
+    assert.equal((await call(manager, 'GET', `${P}/sent`, null, as(me))).body.reports[0].unread, false);
+
+    // And Waypoint: the same promote path.
+    globalThis.dommaWaypoint = {version: 1, listProjects: async () => [], getIssue: async () => null,
+        createIssue: async (input) => ({id: 'i9', key: 'CMS-99', made: input})};
+    r = await call(manager, 'POST', `${P}/reports/${got.id}/promote`, {projectId: 'p1', type: 'bug'});
+    delete globalThis.dommaWaypoint;
+    assert.equal(r.status, 200, JSON.stringify(r.body));
+    assert.equal(r.body.issueKey, 'CMS-99');
+
+    // No site token can speak as the manager.
+    assert.equal((await call(manager, 'GET', `${P}/fleet/mine`, null, {authorization: 'Bearer _manager'})).status, 401);
+});