@consilioweb/payload-support 1.0.0 → 1.1.0

package/README.md

@@ -5,8 +5,8 @@
 
 <div align="center">
 
+[![npm version](https://img.shields.io/npm/v/@consilioweb/payload-support?color=1f8a5b&label=npm)](https://www.npmjs.com/package/@consilioweb/payload-support)
 [![MIT License](https://img.shields.io/badge/license-MIT-1f8a5b)](LICENSE)
-[![Version](https://img.shields.io/badge/version-1.0.0-1f8a5b)](package.json)
 [![Node.js](https://img.shields.io/badge/node-18+-1f8a5b)](https://nodejs.org)
 [![Payload](https://img.shields.io/badge/payload-3.x-1f8a5b)](https://payloadcms.com)
 [![Tests](https://img.shields.io/badge/tests-102%20passing-1f8a5b)](src/__tests__)
@@ -228,6 +228,9 @@ import type { SupportPluginConfig, SupportFeatures } from '@consilioweb/payload-
 | `CRON_SECRET` | for crons | `x-cron-secret` header for the cron endpoints. |
 | `ANTHROPIC_API_KEY` / `OLLAMA_API_URL` | if AI | AI provider keys/URL. |
 | `GOOGLE_OAUTH_CLIENT_ID` / `_SECRET` | if OAuth | Portal Google sign-in. |
+| `VAPID_PUBLIC_KEY` / `VAPID_PRIVATE_KEY` | if push | Web Push keys (`npx web-push generate-vapid-keys`). |
+| `VAPID_SUBJECT` | optional | Push contact (`mailto:` or URL), defaults to `mailto:support@example.com`. |
+| `SUPPORT_TEAM_SCOPING` | optional | `1` to scope agents to their team's tickets. |
 | `SUPPORT_EMAIL` / `SUPPORT_REPLY_TO` | optional | From/reply-to addresses. |
 
 <img src="https://raw.githubusercontent.com/andreasbm/readme/master/assets/lines/rainbow.png" width="100%" alt="" />
@@ -368,6 +371,13 @@ npm run typecheck && npm test && npm run build
 
 See [CHANGELOG.md](CHANGELOG.md) for the full history.
 
+### [1.1.0] — 2026-06-25
+
+- 🎯 **Per-team SLA policies & dashboards** (team policy overrides the default, `?teamId=` scoping).
+- 🔔 **Native push / browser notifications** (Web Push / VAPID, agent pushed on new client messages).
+- 🎭 **End-to-end UI test harness** (browser-driven admin via Playwright, `pnpm test:e2e`).
+- ✅ 109 integration tests (up from 102).
+
 ### [1.0.0] — 2026-06-25
 
 - ✨ Complete ticketing, SLA (+ pause-on-hold), automation & **visual rules engine**.
@@ -405,9 +415,9 @@ See [CHANGELOG.md](CHANGELOG.md) for the full history.
 - [x] Full admin i18n (all views)
 - [x] Social channels (WhatsApp, Messenger)
 - [x] Multi-team / workspaces mode
-- [ ] **Per-team SLA policies & dashboards**
-- [ ] **Native push / browser notifications**
-- [ ] **End-to-end UI test harness** (browser-driven admin)
+- [x] Per-team SLA policies & dashboards
+- [x] Native push / browser notifications
+- [x] End-to-end UI test harness (browser-driven admin)
 
 <img src="https://raw.githubusercontent.com/andreasbm/readme/master/assets/lines/rainbow.png" width="100%" alt="" />
 

package/dist/index.cjs

@@ -3,12 +3,14 @@
 var crypto3 = require('crypto');
 var PDFDocument = require('pdfkit');
 var payload = require('payload');
+var webpush = require('web-push');
 var sanitizeHtml = require('sanitize-html');
 
 function _interopDefault (e) { return e && e.__esModule ? e : { default: e }; }
 
 var crypto3__default = /*#__PURE__*/_interopDefault(crypto3);
 var PDFDocument__default = /*#__PURE__*/_interopDefault(PDFDocument);
+var webpush__default = /*#__PURE__*/_interopDefault(webpush);
 var sanitizeHtml__default = /*#__PURE__*/_interopDefault(sanitizeHtml);
 
 var __require = /* @__PURE__ */ ((x) => typeof require !== "undefined" ? require : typeof Proxy !== "undefined" ? new Proxy(x, {
@@ -72,6 +74,7 @@ var DEFAULT_SLUGS = {
   notificationQueue: "notification-queue",
   automationRules: "automation-rules",
   supportTeams: "support-teams",
+  pushSubscriptions: "push-subscriptions",
   users: "users",
   media: "media"
 };
@@ -3275,11 +3278,13 @@ function createAdminStatsEndpoint(slugs) {
       try {
         const payload = req.payload;
         requireAdmin(req, slugs);
+        const teamId = new URL(req.url).searchParams.get("teamId");
+        const teamAnd = teamId ? [{ team: { equals: Number(teamId) } }] : [];
         const statuses = ["open", "waiting_client", "resolved"];
         const statusCounts = await Promise.all(
           statuses.map(async (status) => {
             const result = await dbCount(payload, slugs.tickets, {
-              where: { status: { equals: status } },
+              where: { and: [{ status: { equals: status } }, ...teamAnd] },
               overrideAccess: true
             });
             return [status, result.totalDocs];
@@ -3291,7 +3296,7 @@ function createAdminStatsEndpoint(slugs) {
         const priorityCounts = await Promise.all(
           priorities.map(async (priority) => {
             const result = await dbCount(payload, slugs.tickets, {
-              where: { priority: { equals: priority } },
+              where: { and: [{ priority: { equals: priority } }, ...teamAnd] },
               overrideAccess: true
             });
             return [priority, result.totalDocs];
@@ -3302,7 +3307,7 @@ function createAdminStatsEndpoint(slugs) {
         const categoryCounts = await Promise.all(
           categories.map(async (category) => {
             const result = await dbCount(payload, slugs.tickets, {
-              where: { category: { equals: category } },
+              where: { and: [{ category: { equals: category } }, ...teamAnd] },
               overrideAccess: true
             });
             return [category, result.totalDocs];
@@ -5881,6 +5886,94 @@ function createChannelsWebhookEndpoint(slugs) {
     }
   };
 }
+var configured = false;
+function ensureVapid() {
+  if (configured) return true;
+  const publicKey = process.env.VAPID_PUBLIC_KEY;
+  const privateKey = process.env.VAPID_PRIVATE_KEY;
+  if (!publicKey || !privateKey) return false;
+  webpush__default.default.setVapidDetails(process.env.VAPID_SUBJECT || "mailto:support@example.com", publicKey, privateKey);
+  configured = true;
+  return true;
+}
+function getVapidPublicKey() {
+  return process.env.VAPID_PUBLIC_KEY || null;
+}
+async function sendPushToUser(payload, slugs, userId, notification) {
+  if (!ensureVapid()) return { sent: 0 };
+  let sent = 0;
+  try {
+    const subs = await dbFind(payload, slugs.pushSubscriptions, { where: { user: { equals: userId } }, limit: 100, depth: 0, overrideAccess: true });
+    for (const s of subs.docs) {
+      const row = s;
+      if (!row.endpoint || !row.p256dh || !row.auth) continue;
+      try {
+        await webpush__default.default.sendNotification(
+          { endpoint: row.endpoint, keys: { p256dh: row.p256dh, auth: row.auth } },
+          JSON.stringify(notification)
+        );
+        sent++;
+      } catch (err) {
+        const code = err?.statusCode;
+        if (code === 404 || code === 410) {
+          try {
+            await dbDelete(payload, slugs.pushSubscriptions, { id: row.id, overrideAccess: true });
+          } catch {
+          }
+        }
+      }
+    }
+  } catch (err) {
+    console.error("[support] Push send failed:", err);
+  }
+  return { sent };
+}
+
+// src/endpoints/push.ts
+function createVapidKeyEndpoint() {
+  return {
+    path: "/support/push/vapid-public-key",
+    method: "get",
+    handler: async () => Response.json({ publicKey: getVapidPublicKey() })
+  };
+}
+function createPushSubscribeEndpoint(slugs) {
+  return {
+    path: "/support/push/subscribe",
+    method: "post",
+    handler: async (req) => {
+      try {
+        requireAdmin(req, slugs);
+        let body;
+        try {
+          body = await req.json();
+        } catch {
+          return Response.json({ error: "Invalid JSON body" }, { status: 400 });
+        }
+        const sub = body?.subscription;
+        const endpoint = sub?.endpoint;
+        const p256dh = sub?.keys?.p256dh;
+        const auth = sub?.keys?.auth;
+        if (!endpoint || !p256dh || !auth) {
+          return Response.json({ error: "subscription invalide (endpoint + keys requis)." }, { status: 400 });
+        }
+        const data = { user: req.user.id, endpoint, p256dh, auth, userAgent: req.headers.get("user-agent") || "" };
+        const existing = await dbFind(req.payload, slugs.pushSubscriptions, { where: { endpoint: { equals: endpoint } }, limit: 1, depth: 0, overrideAccess: true });
+        if (existing.docs.length > 0) {
+          await dbUpdate(req.payload, slugs.pushSubscriptions, { id: existing.docs[0].id, data, overrideAccess: true });
+        } else {
+          await dbCreate(req.payload, slugs.pushSubscriptions, { data, overrideAccess: true });
+        }
+        return Response.json({ ok: true });
+      } catch (error) {
+        const authResponse = handleAuthError(error);
+        if (authResponse) return authResponse;
+        console.error("[push] Error:", error);
+        return Response.json({ error: "Erreur interne" }, { status: 500 });
+      }
+    }
+  };
+}
 
 // src/endpoints/user-prefs.ts
 var PREF_KEY_PREFIX = "support-user-prefs";
@@ -6508,6 +6601,8 @@ function createSupportEndpoints(slugs, options) {
   if (!f || f.snooze !== false) endpoints.push(createProcessSnoozeEndpoint(slugs));
   endpoints.push(createProcessDigestsEndpoint(slugs));
   endpoints.push(createChannelsWebhookEndpoint(slugs));
+  endpoints.push(createVapidKeyEndpoint());
+  endpoints.push(createPushSubscribeEndpoint(slugs));
   return endpoints;
 }
 
@@ -6829,6 +6924,20 @@ async function resolveSlaPolicy(payload, ticket, slugs) {
     }
   }
   const priority = field(ticket, "priority") || "normal";
+  const teamRef = field(ticket, "team");
+  const teamId = typeof teamRef === "object" && teamRef !== null ? teamRef.id : teamRef;
+  if (teamId) {
+    try {
+      const teamPolicies = await dbFind(payload, slugs.slaPolicies, {
+        where: { and: [{ team: { equals: teamId } }, { priority: { equals: priority } }] },
+        limit: 1,
+        depth: 0,
+        overrideAccess: true
+      });
+      if (teamPolicies.docs.length > 0) return teamPolicies.docs[0];
+    } catch {
+    }
+  }
   try {
     const defaults = await dbFind(payload, slugs.slaPolicies, {
       where: {
@@ -8211,6 +8320,15 @@ function createNotifyAdminOnClientMessage(slugs, notificationSlug) {
       }
       const preview = doc.body?.length > 500 ? doc.body.slice(0, 500) + "..." : doc.body;
       const headerTitle = isNewTicket ? `Nouveau ticket ${ticketNumber}` : `Nouveau message \u2014 ${ticketNumber}`;
+      const assignedId = assignedAdmin?.id ?? (ticket.assignedTo && typeof ticket.assignedTo !== "object" ? ticket.assignedTo : void 0);
+      if (assignedId) {
+        void sendPushToUser(payload, slugs, assignedId, {
+          title: headerTitle,
+          body: `${clientName}: ${preview || subject}`,
+          url: `/admin/collections/${slugs.tickets}/${ticketId}`
+        }).catch(() => {
+        });
+      }
       if (primaryEmail) {
         await payload.sendEmail({
           // INTERNAL email (to the support team) — recipients are the contact
@@ -9814,6 +9932,16 @@ function createSlaPoliciesCollection(slugs) {
         admin: {
           description: "Utiliser cette politique pour les tickets sans SLA sp\xE9cifique (par priorit\xE9)"
         }
+      },
+      {
+        name: "team",
+        type: "relationship",
+        relationTo: slugs.supportTeams,
+        index: true,
+        label: "\xC9quipe (optionnel)",
+        admin: {
+          description: "Limiter cette politique \xE0 une \xE9quipe \u2014 prioritaire sur la politique par d\xE9faut"
+        }
       }
     ],
     access: {
@@ -10456,6 +10584,30 @@ function createSupportTeamCollection(slugs) {
   };
 }
 
+// src/collections/PushSubscription.ts
+function createPushSubscriptionCollection(slugs) {
+  return {
+    slug: slugs.pushSubscriptions,
+    labels: { singular: "Abonnement push", plural: "Abonnements push" },
+    admin: { hidden: true, group: "Support", defaultColumns: ["user", "endpoint", "createdAt"] },
+    access: {
+      create: () => false,
+      // written via the subscribe endpoint (overrideAccess)
+      read: ({ req }) => req.user?.collection === slugs.users,
+      update: () => false,
+      delete: ({ req }) => req.user?.collection === slugs.users
+    },
+    fields: [
+      { name: "user", type: "relationship", relationTo: slugs.users, index: true, label: "Agent" },
+      { name: "endpoint", type: "text", required: true, index: true, label: "Endpoint" },
+      { name: "p256dh", type: "text", label: "Cl\xE9 p256dh" },
+      { name: "auth", type: "text", label: "Cl\xE9 auth" },
+      { name: "userAgent", type: "text", label: "User-Agent" }
+    ],
+    timestamps: true
+  };
+}
+
 // src/plugin.ts
 function viewConfig(component, path) {
   return { Component: component, path };
@@ -10494,7 +10646,8 @@ function supportPlugin(config) {
       createTicketCollaboratorsCollection(slugs),
       createNotificationQueueCollection(slugs),
       createAutomationRulesCollection(slugs),
-      createSupportTeamCollection(slugs)
+      createSupportTeamCollection(slugs),
+      createPushSubscriptionCollection(slugs)
     ];
     if (features.authLogs !== false) supportCollections.push(createAuthLogsCollection(slugs));
     if (features.timeTracking !== false) supportCollections.push(createTimeEntriesCollection(slugs));

package/dist/index.d.cts

@@ -240,6 +240,7 @@ interface CollectionSlugs {
     notificationQueue: string;
     automationRules: string;
     supportTeams: string;
+    pushSubscriptions: string;
     users: string;
     media: string;
 }

package/dist/index.d.ts

@@ -240,6 +240,7 @@ interface CollectionSlugs {
     notificationQueue: string;
     automationRules: string;
     supportTeams: string;
+    pushSubscriptions: string;
     users: string;
     media: string;
 }

package/dist/index.js

@@ -1,6 +1,7 @@
 import crypto3, { createHmac, randomBytes } from 'crypto';
 import PDFDocument from 'pdfkit';
 import { APIError, getFieldsToSign, jwtSign } from 'payload';
+import webpush from 'web-push';
 import sanitizeHtml from 'sanitize-html';
 
 var __require = /* @__PURE__ */ ((x) => typeof require !== "undefined" ? require : typeof Proxy !== "undefined" ? new Proxy(x, {
@@ -64,6 +65,7 @@ var DEFAULT_SLUGS = {
   notificationQueue: "notification-queue",
   automationRules: "automation-rules",
   supportTeams: "support-teams",
+  pushSubscriptions: "push-subscriptions",
   users: "users",
   media: "media"
 };
@@ -3267,11 +3269,13 @@ function createAdminStatsEndpoint(slugs) {
       try {
         const payload = req.payload;
         requireAdmin(req, slugs);
+        const teamId = new URL(req.url).searchParams.get("teamId");
+        const teamAnd = teamId ? [{ team: { equals: Number(teamId) } }] : [];
         const statuses = ["open", "waiting_client", "resolved"];
         const statusCounts = await Promise.all(
           statuses.map(async (status) => {
             const result = await dbCount(payload, slugs.tickets, {
-              where: { status: { equals: status } },
+              where: { and: [{ status: { equals: status } }, ...teamAnd] },
               overrideAccess: true
             });
             return [status, result.totalDocs];
@@ -3283,7 +3287,7 @@ function createAdminStatsEndpoint(slugs) {
         const priorityCounts = await Promise.all(
           priorities.map(async (priority) => {
             const result = await dbCount(payload, slugs.tickets, {
-              where: { priority: { equals: priority } },
+              where: { and: [{ priority: { equals: priority } }, ...teamAnd] },
               overrideAccess: true
             });
             return [priority, result.totalDocs];
@@ -3294,7 +3298,7 @@ function createAdminStatsEndpoint(slugs) {
         const categoryCounts = await Promise.all(
           categories.map(async (category) => {
             const result = await dbCount(payload, slugs.tickets, {
-              where: { category: { equals: category } },
+              where: { and: [{ category: { equals: category } }, ...teamAnd] },
               overrideAccess: true
             });
             return [category, result.totalDocs];
@@ -5873,6 +5877,94 @@ function createChannelsWebhookEndpoint(slugs) {
     }
   };
 }
+var configured = false;
+function ensureVapid() {
+  if (configured) return true;
+  const publicKey = process.env.VAPID_PUBLIC_KEY;
+  const privateKey = process.env.VAPID_PRIVATE_KEY;
+  if (!publicKey || !privateKey) return false;
+  webpush.setVapidDetails(process.env.VAPID_SUBJECT || "mailto:support@example.com", publicKey, privateKey);
+  configured = true;
+  return true;
+}
+function getVapidPublicKey() {
+  return process.env.VAPID_PUBLIC_KEY || null;
+}
+async function sendPushToUser(payload, slugs, userId, notification) {
+  if (!ensureVapid()) return { sent: 0 };
+  let sent = 0;
+  try {
+    const subs = await dbFind(payload, slugs.pushSubscriptions, { where: { user: { equals: userId } }, limit: 100, depth: 0, overrideAccess: true });
+    for (const s of subs.docs) {
+      const row = s;
+      if (!row.endpoint || !row.p256dh || !row.auth) continue;
+      try {
+        await webpush.sendNotification(
+          { endpoint: row.endpoint, keys: { p256dh: row.p256dh, auth: row.auth } },
+          JSON.stringify(notification)
+        );
+        sent++;
+      } catch (err) {
+        const code = err?.statusCode;
+        if (code === 404 || code === 410) {
+          try {
+            await dbDelete(payload, slugs.pushSubscriptions, { id: row.id, overrideAccess: true });
+          } catch {
+          }
+        }
+      }
+    }
+  } catch (err) {
+    console.error("[support] Push send failed:", err);
+  }
+  return { sent };
+}
+
+// src/endpoints/push.ts
+function createVapidKeyEndpoint() {
+  return {
+    path: "/support/push/vapid-public-key",
+    method: "get",
+    handler: async () => Response.json({ publicKey: getVapidPublicKey() })
+  };
+}
+function createPushSubscribeEndpoint(slugs) {
+  return {
+    path: "/support/push/subscribe",
+    method: "post",
+    handler: async (req) => {
+      try {
+        requireAdmin(req, slugs);
+        let body;
+        try {
+          body = await req.json();
+        } catch {
+          return Response.json({ error: "Invalid JSON body" }, { status: 400 });
+        }
+        const sub = body?.subscription;
+        const endpoint = sub?.endpoint;
+        const p256dh = sub?.keys?.p256dh;
+        const auth = sub?.keys?.auth;
+        if (!endpoint || !p256dh || !auth) {
+          return Response.json({ error: "subscription invalide (endpoint + keys requis)." }, { status: 400 });
+        }
+        const data = { user: req.user.id, endpoint, p256dh, auth, userAgent: req.headers.get("user-agent") || "" };
+        const existing = await dbFind(req.payload, slugs.pushSubscriptions, { where: { endpoint: { equals: endpoint } }, limit: 1, depth: 0, overrideAccess: true });
+        if (existing.docs.length > 0) {
+          await dbUpdate(req.payload, slugs.pushSubscriptions, { id: existing.docs[0].id, data, overrideAccess: true });
+        } else {
+          await dbCreate(req.payload, slugs.pushSubscriptions, { data, overrideAccess: true });
+        }
+        return Response.json({ ok: true });
+      } catch (error) {
+        const authResponse = handleAuthError(error);
+        if (authResponse) return authResponse;
+        console.error("[push] Error:", error);
+        return Response.json({ error: "Erreur interne" }, { status: 500 });
+      }
+    }
+  };
+}
 
 // src/endpoints/user-prefs.ts
 var PREF_KEY_PREFIX = "support-user-prefs";
@@ -6500,6 +6592,8 @@ function createSupportEndpoints(slugs, options) {
   if (!f || f.snooze !== false) endpoints.push(createProcessSnoozeEndpoint(slugs));
   endpoints.push(createProcessDigestsEndpoint(slugs));
   endpoints.push(createChannelsWebhookEndpoint(slugs));
+  endpoints.push(createVapidKeyEndpoint());
+  endpoints.push(createPushSubscribeEndpoint(slugs));
   return endpoints;
 }
 
@@ -6821,6 +6915,20 @@ async function resolveSlaPolicy(payload, ticket, slugs) {
     }
   }
   const priority = field(ticket, "priority") || "normal";
+  const teamRef = field(ticket, "team");
+  const teamId = typeof teamRef === "object" && teamRef !== null ? teamRef.id : teamRef;
+  if (teamId) {
+    try {
+      const teamPolicies = await dbFind(payload, slugs.slaPolicies, {
+        where: { and: [{ team: { equals: teamId } }, { priority: { equals: priority } }] },
+        limit: 1,
+        depth: 0,
+        overrideAccess: true
+      });
+      if (teamPolicies.docs.length > 0) return teamPolicies.docs[0];
+    } catch {
+    }
+  }
   try {
     const defaults = await dbFind(payload, slugs.slaPolicies, {
       where: {
@@ -8203,6 +8311,15 @@ function createNotifyAdminOnClientMessage(slugs, notificationSlug) {
       }
       const preview = doc.body?.length > 500 ? doc.body.slice(0, 500) + "..." : doc.body;
       const headerTitle = isNewTicket ? `Nouveau ticket ${ticketNumber}` : `Nouveau message \u2014 ${ticketNumber}`;
+      const assignedId = assignedAdmin?.id ?? (ticket.assignedTo && typeof ticket.assignedTo !== "object" ? ticket.assignedTo : void 0);
+      if (assignedId) {
+        void sendPushToUser(payload, slugs, assignedId, {
+          title: headerTitle,
+          body: `${clientName}: ${preview || subject}`,
+          url: `/admin/collections/${slugs.tickets}/${ticketId}`
+        }).catch(() => {
+        });
+      }
       if (primaryEmail) {
         await payload.sendEmail({
           // INTERNAL email (to the support team) — recipients are the contact
@@ -9806,6 +9923,16 @@ function createSlaPoliciesCollection(slugs) {
         admin: {
           description: "Utiliser cette politique pour les tickets sans SLA sp\xE9cifique (par priorit\xE9)"
         }
+      },
+      {
+        name: "team",
+        type: "relationship",
+        relationTo: slugs.supportTeams,
+        index: true,
+        label: "\xC9quipe (optionnel)",
+        admin: {
+          description: "Limiter cette politique \xE0 une \xE9quipe \u2014 prioritaire sur la politique par d\xE9faut"
+        }
       }
     ],
     access: {
@@ -10448,6 +10575,30 @@ function createSupportTeamCollection(slugs) {
   };
 }
 
+// src/collections/PushSubscription.ts
+function createPushSubscriptionCollection(slugs) {
+  return {
+    slug: slugs.pushSubscriptions,
+    labels: { singular: "Abonnement push", plural: "Abonnements push" },
+    admin: { hidden: true, group: "Support", defaultColumns: ["user", "endpoint", "createdAt"] },
+    access: {
+      create: () => false,
+      // written via the subscribe endpoint (overrideAccess)
+      read: ({ req }) => req.user?.collection === slugs.users,
+      update: () => false,
+      delete: ({ req }) => req.user?.collection === slugs.users
+    },
+    fields: [
+      { name: "user", type: "relationship", relationTo: slugs.users, index: true, label: "Agent" },
+      { name: "endpoint", type: "text", required: true, index: true, label: "Endpoint" },
+      { name: "p256dh", type: "text", label: "Cl\xE9 p256dh" },
+      { name: "auth", type: "text", label: "Cl\xE9 auth" },
+      { name: "userAgent", type: "text", label: "User-Agent" }
+    ],
+    timestamps: true
+  };
+}
+
 // src/plugin.ts
 function viewConfig(component, path) {
   return { Component: component, path };
@@ -10486,7 +10637,8 @@ function supportPlugin(config) {
       createTicketCollaboratorsCollection(slugs),
       createNotificationQueueCollection(slugs),
       createAutomationRulesCollection(slugs),
-      createSupportTeamCollection(slugs)
+      createSupportTeamCollection(slugs),
+      createPushSubscriptionCollection(slugs)
     ];
     if (features.authLogs !== false) supportCollections.push(createAuthLogsCollection(slugs));
     if (features.timeTracking !== false) supportCollections.push(createTimeEntriesCollection(slugs));

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@consilioweb/payload-support",
-  "version": "1.0.0",
+  "version": "1.1.0",
   "description": "Payload CMS plugin — professional support & ticketing system with AI, SLA, time tracking, live chat, and more",
   "type": "module",
   "main": "./dist/index.cjs",
@@ -54,7 +54,9 @@
     "typecheck": "tsc --noEmit",
     "prepublishOnly": "npm run build",
     "test": "vitest run",
-    "test:watch": "vitest"
+    "test:watch": "vitest",
+    "test:e2e": "playwright test",
+    "test:e2e:ui": "playwright test --ui"
   },
   "keywords": [
     "payload",
@@ -123,6 +125,7 @@
   },
   "devDependencies": {
     "@payloadcms/db-sqlite": "^3.85.1",
+    "@playwright/test": "^1.49.0",
     "@payloadcms/graphql": "^3.85.1",
     "@payloadcms/next": "^3.85.1",
     "@payloadcms/richtext-lexical": "^3.85.1",
@@ -131,6 +134,7 @@
     "@types/pdfkit": "^0.17.6",
     "@types/react": "^19.0.0",
     "@types/sanitize-html": "^2.16.1",
+    "@types/web-push": "^3.6.4",
     "esbuild-sass-plugin": "^3.7.0",
     "next": "^15.5.14",
     "payload": "^3.85.1",
@@ -142,6 +146,7 @@
   },
   "dependencies": {
     "pdfkit": "^0.19.1",
-    "sanitize-html": "^2.17.5"
+    "sanitize-html": "^2.17.5",
+    "web-push": "^3.6.7"
   }
 }

package/src/__tests__/integration/per-team-sla.test.ts

@@ -0,0 +1,44 @@
+import { describe, it, expect } from 'vitest'
+import { buildTestPayload } from './buildTestPayload'
+import { createAdminStatsEndpoint } from '../../endpoints/admin-stats'
+import { resolveSlugs } from '../../utils/slugs'
+
+const slugs = resolveSlugs({ users: 'users' })
+const PW = 'test-pw-12345'
+
+/** Per-team SLA policies & dashboards (roadmap). */
+describe('per-team SLA & dashboards (roadmap)', () => {
+  it('uses the team-specific SLA policy over the global default', async () => {
+    const payload = await buildTestPayload()
+    const team = await payload.create({ collection: 'support-teams', data: { name: 'Team SLA' }, overrideAccess: true })
+    // Team policy: 2h resolution. Global default: 24h.
+    await payload.create({ collection: 'sla-policies', data: { name: 'Team', priority: 'normal', firstResponseTime: 30, resolutionTime: 120, businessHoursOnly: false, team: team.id }, overrideAccess: true })
+    await payload.create({ collection: 'sla-policies', data: { name: 'Default', priority: 'normal', firstResponseTime: 120, resolutionTime: 1440, businessHoursOnly: false, isDefault: true }, overrideAccess: true })
+
+    const c = await payload.create({ collection: 'support-clients', data: { email: 'pts@example.com', password: PW, firstName: 'P', lastName: 'T', company: 'C' }, overrideAccess: true })
+    const t = await payload.create({ collection: 'tickets', data: { subject: 'team sla', client: c.id, status: 'open', priority: 'normal', team: team.id }, overrideAccess: true })
+
+    const reread = await payload.findByID({ collection: 'tickets', id: t.id, overrideAccess: true })
+    const created = new Date(reread.createdAt as string).getTime()
+    const diffMin = (new Date(reread.slaResolutionDue as string).getTime() - created) / 60000
+    expect(diffMin).toBeGreaterThan(110) // ~120 (team policy), NOT 1440 (default)
+    expect(diffMin).toBeLessThan(130)
+  }, 60_000)
+
+  it('scopes the dashboard counts to a team via ?teamId', async () => {
+    const payload = await buildTestPayload()
+    const teamC = await payload.create({ collection: 'support-teams', data: { name: 'Team C' }, overrideAccess: true })
+    const teamD = await payload.create({ collection: 'support-teams', data: { name: 'Team D' }, overrideAccess: true })
+    const c = await payload.create({ collection: 'support-clients', data: { email: 'ptd@example.com', password: PW, firstName: 'P', lastName: 'D', company: 'C' }, overrideAccess: true })
+    await payload.create({ collection: 'tickets', data: { subject: 'c1', client: c.id, status: 'open', priority: 'normal', team: teamC.id }, overrideAccess: true })
+    await payload.create({ collection: 'tickets', data: { subject: 'c2', client: c.id, status: 'open', priority: 'normal', team: teamC.id }, overrideAccess: true })
+    await payload.create({ collection: 'tickets', data: { subject: 'd1', client: c.id, status: 'open', priority: 'normal', team: teamD.id }, overrideAccess: true })
+
+    const admin = await payload.create({ collection: 'users', data: { email: 'pt-admin@example.com', password: PW } as never, overrideAccess: true })
+    const ep = createAdminStatsEndpoint(slugs)
+    const req = { payload, user: { ...admin, collection: 'users' }, url: `http://localhost/api/support/admin-stats?teamId=${teamC.id}`, headers: new Headers({}) }
+    const res = await (ep.handler as (r: unknown) => Promise<Response>)(req)
+    const json = await res.json()
+    expect(json.total).toBe(2) // only Team C's tickets
+  }, 60_000)
+})

package/src/__tests__/integration/push.test.ts

@@ -0,0 +1,75 @@
+import { describe, it, expect } from 'vitest'
+import { buildTestPayload } from './buildTestPayload'
+import { createVapidKeyEndpoint, createPushSubscribeEndpoint } from '../../endpoints/push'
+import { sendPushToUser } from '../../utils/push'
+import { resolveSlugs } from '../../utils/slugs'
+
+const slugs = resolveSlugs({ users: 'users' })
+const PW = 'test-pw-12345'
+
+/** Native push / browser notifications (roadmap). */
+describe('push notifications (roadmap)', () => {
+  it('subscribe stores a subscription row for the agent', async () => {
+    const payload = await buildTestPayload()
+    const admin = await payload.create({ collection: 'users', data: { email: 'push-admin@example.com', password: PW } as never, overrideAccess: true })
+    const ep = createPushSubscribeEndpoint(slugs)
+    const req = {
+      payload,
+      user: { ...admin, collection: 'users' },
+      headers: new Headers({ 'user-agent': 'vitest' }),
+      json: async () => ({ subscription: { endpoint: 'https://push.example.com/abc', keys: { p256dh: 'pk', auth: 'ak' } } }),
+    }
+    const res = await (ep.handler as (r: unknown) => Promise<Response>)(req)
+    expect(res.status).toBe(200)
+
+    const stored = await payload.find({ collection: 'push-subscriptions', where: { endpoint: { equals: 'https://push.example.com/abc' } }, overrideAccess: true })
+    expect(stored.docs.length).toBe(1)
+    expect((stored.docs[0] as { auth?: string }).auth).toBe('ak')
+  }, 60_000)
+
+  it('subscribe is idempotent on endpoint (upsert, no duplicate)', async () => {
+    const payload = await buildTestPayload()
+    const admin = await payload.create({ collection: 'users', data: { email: 'push-admin2@example.com', password: PW } as never, overrideAccess: true })
+    const ep = createPushSubscribeEndpoint(slugs)
+    const mk = (auth: string) => ({
+      payload,
+      user: { ...admin, collection: 'users' },
+      headers: new Headers({}),
+      json: async () => ({ subscription: { endpoint: 'https://push.example.com/dup', keys: { p256dh: 'pk', auth } } }),
+    })
+    await (ep.handler as (r: unknown) => Promise<Response>)(mk('first'))
+    await (ep.handler as (r: unknown) => Promise<Response>)(mk('second'))
+    const stored = await payload.find({ collection: 'push-subscriptions', where: { endpoint: { equals: 'https://push.example.com/dup' } }, overrideAccess: true })
+    expect(stored.docs.length).toBe(1)
+    expect((stored.docs[0] as { auth?: string }).auth).toBe('second')
+  }, 60_000)
+
+  it('subscribe rejects an anonymous request', async () => {
+    const payload = await buildTestPayload()
+    const ep = createPushSubscribeEndpoint(slugs)
+    const req = {
+      payload,
+      user: null,
+      headers: new Headers({}),
+      json: async () => ({ subscription: { endpoint: 'https://push.example.com/x', keys: { p256dh: 'pk', auth: 'ak' } } }),
+    }
+    const res = await (ep.handler as (r: unknown) => Promise<Response>)(req)
+    expect(res.status).toBe(401)
+  }, 60_000)
+
+  it('vapid-public-key returns null when VAPID is not configured', async () => {
+    delete process.env.VAPID_PUBLIC_KEY
+    const ep = createVapidKeyEndpoint()
+    const res = await (ep.handler as (r: unknown) => Promise<Response>)({})
+    const json = await res.json()
+    expect(json.publicKey).toBeNull()
+  })
+
+  it('sendPushToUser no-ops without VAPID keys', async () => {
+    delete process.env.VAPID_PUBLIC_KEY
+    delete process.env.VAPID_PRIVATE_KEY
+    const payload = await buildTestPayload()
+    const result = await sendPushToUser(payload, slugs, 1, { title: 'Hi', body: 'There' })
+    expect(result.sent).toBe(0)
+  }, 60_000)
+})

package/src/collections/PushSubscription.ts

@@ -0,0 +1,28 @@
+import type { CollectionConfig } from 'payload'
+import type { CollectionSlugs } from '../utils/slugs'
+
+/**
+ * Web Push subscriptions for agents (browser notifications). Written by the
+ * /support/push/subscribe endpoint and drained by `sendPushToUser`.
+ */
+export function createPushSubscriptionCollection(slugs: CollectionSlugs): CollectionConfig {
+  return {
+    slug: slugs.pushSubscriptions,
+    labels: { singular: 'Abonnement push', plural: 'Abonnements push' },
+    admin: { hidden: true, group: 'Support', defaultColumns: ['user', 'endpoint', 'createdAt'] },
+    access: {
+      create: () => false, // written via the subscribe endpoint (overrideAccess)
+      read: ({ req }) => req.user?.collection === slugs.users,
+      update: () => false,
+      delete: ({ req }) => req.user?.collection === slugs.users,
+    },
+    fields: [
+      { name: 'user', type: 'relationship', relationTo: slugs.users, index: true, label: 'Agent' },
+      { name: 'endpoint', type: 'text', required: true, index: true, label: 'Endpoint' },
+      { name: 'p256dh', type: 'text', label: 'Clé p256dh' },
+      { name: 'auth', type: 'text', label: 'Clé auth' },
+      { name: 'userAgent', type: 'text', label: 'User-Agent' },
+    ],
+    timestamps: true,
+  }
+}

package/src/collections/SlaPolicies.ts

@@ -111,6 +111,16 @@ export function createSlaPoliciesCollection(slugs: CollectionSlugs): CollectionC
           description: 'Utiliser cette politique pour les tickets sans SLA spécifique (par priorité)',
         },
       },
+      {
+        name: 'team',
+        type: 'relationship',
+        relationTo: slugs.supportTeams,
+        index: true,
+        label: 'Équipe (optionnel)',
+        admin: {
+          description: "Limiter cette politique à une équipe — prioritaire sur la politique par défaut",
+        },
+      },
     ],
     access: {
       create: ({ req }) => req.user?.collection === slugs.users,

package/src/collections/TicketMessages.ts

@@ -9,6 +9,7 @@ import { createCheckSlaOnReply } from '../hooks/checkSLA'
 import { resolveAccessibleTicketIds } from '../utils/ticketAccess'
 import { sanitizeMessageHtml } from '../utils/sanitizeHtml'
 import { queueClientNotification } from '../utils/notificationQueue'
+import { sendPushToUser } from '../utils/push'
 import { dbFind, dbCreate, dbFindByID } from '../utils/db'
 
 function createAssignAuthor(slugs: CollectionSlugs): CollectionBeforeChangeHook {
@@ -260,6 +261,16 @@ function createNotifyAdminOnClientMessage(slugs: CollectionSlugs, notificationSl
       const preview = doc.body?.length > 500 ? doc.body.slice(0, 500) + '...' : doc.body
       const headerTitle = isNewTicket ? `Nouveau ticket ${ticketNumber}` : `Nouveau message — ${ticketNumber}`
 
+      // Browser push to the assigned agent (RUNTIME no-op without VAPID keys).
+      const assignedId = assignedAdmin?.id ?? (ticket.assignedTo && typeof ticket.assignedTo !== 'object' ? ticket.assignedTo : undefined)
+      if (assignedId) {
+        void sendPushToUser(payload, slugs, assignedId, {
+          title: headerTitle,
+          body: `${clientName}: ${preview || subject}`,
+          url: `/admin/collections/${slugs.tickets}/${ticketId}`,
+        }).catch(() => { /* best-effort */ })
+      }
+
       if (primaryEmail) {
         await payload.sendEmail({
           // INTERNAL email (to the support team) — recipients are the contact

package/src/collections/index.ts

@@ -20,3 +20,4 @@ export { createTicketCollaboratorsCollection } from './TicketCollaborators'
 export { createNotificationQueueCollection } from './NotificationQueue'
 export { createAutomationRulesCollection } from './AutomationRules'
 export { createSupportTeamCollection } from './SupportTeam'
+export { createPushSubscriptionCollection } from './PushSubscription'

package/src/endpoints/admin-stats.ts

@@ -18,12 +18,16 @@ export function createAdminStatsEndpoint(slugs: CollectionSlugs): Endpoint {
 
         requireAdmin(req, slugs)
 
+        // Optional per-team dashboard scoping (?teamId=) — applied to ticket counts.
+        const teamId = new URL(req.url!).searchParams.get('teamId')
+        const teamAnd = teamId ? [{ team: { equals: Number(teamId) } }] : []
+
         // ── Status counts via individual count queries ──
         const statuses = ['open', 'waiting_client', 'resolved'] as const
         const statusCounts = await Promise.all(
           statuses.map(async (status) => {
             const result = await dbCount(payload, slugs.tickets, {
-              where: { status: { equals: status } },
+              where: { and: [{ status: { equals: status } }, ...teamAnd] },
               overrideAccess: true,
             })
             return [status, result.totalDocs] as const
@@ -37,7 +41,7 @@ export function createAdminStatsEndpoint(slugs: CollectionSlugs): Endpoint {
         const priorityCounts = await Promise.all(
           priorities.map(async (priority) => {
             const result = await dbCount(payload, slugs.tickets, {
-              where: { priority: { equals: priority } },
+              where: { and: [{ priority: { equals: priority } }, ...teamAnd] },
               overrideAccess: true,
             })
             return [priority, result.totalDocs] as const
@@ -50,7 +54,7 @@ export function createAdminStatsEndpoint(slugs: CollectionSlugs): Endpoint {
         const categoryCounts = await Promise.all(
           categories.map(async (category) => {
             const result = await dbCount(payload, slugs.tickets, {
-              where: { category: { equals: category } },
+              where: { and: [{ category: { equals: category } }, ...teamAnd] },
               overrideAccess: true,
             })
             return [category, result.totalDocs] as const

package/src/endpoints/index.ts

@@ -48,6 +48,7 @@ import { createProcessScheduledEndpoint } from './process-scheduled'
 import { createProcessSnoozeEndpoint } from './process-snooze'
 import { createProcessDigestsEndpoint } from './process-digests'
 import { createChannelsWebhookEndpoint } from './channels'
+import { createVapidKeyEndpoint, createPushSubscribeEndpoint } from './push'
 import { createUserPrefsGetEndpoint, createUserPrefsPostEndpoint } from './user-prefs'
 import { createEscalateEndpoint } from './escalate'
 import { createTicketFeedbackEndpoint } from './ticket-feedback'
@@ -100,6 +101,7 @@ export { createProcessScheduledEndpoint } from './process-scheduled'
 export { createProcessSnoozeEndpoint } from './process-snooze'
 export { createProcessDigestsEndpoint } from './process-digests'
 export { createChannelsWebhookEndpoint } from './channels'
+export { createVapidKeyEndpoint, createPushSubscribeEndpoint } from './push'
 export { createUserPrefsGetEndpoint, createUserPrefsPostEndpoint } from './user-prefs'
 export type { UserPrefs } from './user-prefs'
 export { createEscalateEndpoint } from './escalate'
@@ -193,6 +195,8 @@ export function createSupportEndpoints(slugs: CollectionSlugs, options?: Support
   if (!f || f.snooze !== false) endpoints.push(createProcessSnoozeEndpoint(slugs))
   endpoints.push(createProcessDigestsEndpoint(slugs))
   endpoints.push(createChannelsWebhookEndpoint(slugs))
+  endpoints.push(createVapidKeyEndpoint())
+  endpoints.push(createPushSubscribeEndpoint(slugs))
 
   return endpoints
 }

package/src/endpoints/push.ts

@@ -0,0 +1,49 @@
+import type { Endpoint } from 'payload'
+import type { CollectionSlugs } from '../utils/slugs'
+import { requireAdmin, handleAuthError } from '../utils/auth'
+import { dbFind, dbCreate, dbUpdate } from '../utils/db'
+import { getVapidPublicKey } from '../utils/push'
+
+/** GET /api/support/push/vapid-public-key — public key the browser uses to subscribe. */
+export function createVapidKeyEndpoint(): Endpoint {
+  return {
+    path: '/support/push/vapid-public-key',
+    method: 'get',
+    handler: async () => Response.json({ publicKey: getVapidPublicKey() }),
+  }
+}
+
+/** POST /api/support/push/subscribe — register the current agent's browser push subscription. */
+export function createPushSubscribeEndpoint(slugs: CollectionSlugs): Endpoint {
+  return {
+    path: '/support/push/subscribe',
+    method: 'post',
+    handler: async (req) => {
+      try {
+        requireAdmin(req, slugs)
+        let body: { subscription?: { endpoint?: string; keys?: { p256dh?: string; auth?: string } } }
+        try { body = (await req.json!()) as typeof body } catch { return Response.json({ error: 'Invalid JSON body' }, { status: 400 }) }
+        const sub = body?.subscription
+        const endpoint = sub?.endpoint
+        const p256dh = sub?.keys?.p256dh
+        const auth = sub?.keys?.auth
+        if (!endpoint || !p256dh || !auth) {
+          return Response.json({ error: 'subscription invalide (endpoint + keys requis).' }, { status: 400 })
+        }
+        const data = { user: req.user!.id, endpoint, p256dh, auth, userAgent: req.headers.get('user-agent') || '' }
+        const existing = await dbFind(req.payload, slugs.pushSubscriptions, { where: { endpoint: { equals: endpoint } }, limit: 1, depth: 0, overrideAccess: true })
+        if (existing.docs.length > 0) {
+          await dbUpdate(req.payload, slugs.pushSubscriptions, { id: (existing.docs[0] as { id: number | string }).id, data, overrideAccess: true })
+        } else {
+          await dbCreate(req.payload, slugs.pushSubscriptions, { data, overrideAccess: true })
+        }
+        return Response.json({ ok: true })
+      } catch (error) {
+        const authResponse = handleAuthError(error)
+        if (authResponse) return authResponse
+        console.error('[push] Error:', error)
+        return Response.json({ error: 'Erreur interne' }, { status: 500 })
+      }
+    },
+  }
+}

package/src/hooks/checkSLA.ts

@@ -157,8 +157,22 @@ async function resolveSlaPolicy(
     }
   }
 
-  // Look for a default policy matching this ticket's priority
   const priority = field(ticket, 'priority') || 'normal'
+
+  // Per-team policy (team + priority) takes precedence over the global default.
+  const teamRef = field(ticket, 'team')
+  const teamId = typeof teamRef === 'object' && teamRef !== null ? (teamRef as AnyDoc).id : teamRef
+  if (teamId) {
+    try {
+      const teamPolicies = await dbFind(payload, slugs.slaPolicies, {
+        where: { and: [{ team: { equals: teamId } }, { priority: { equals: priority } }] },
+        limit: 1, depth: 0, overrideAccess: true,
+      })
+      if (teamPolicies.docs.length > 0) return teamPolicies.docs[0]
+    } catch { /* fall through to default */ }
+  }
+
+  // Look for a default policy matching this ticket's priority
   try {
     const defaults = await dbFind(payload, slugs.slaPolicies, {
       where: {

package/src/plugin.ts

@@ -26,6 +26,7 @@ import {
   createNotificationQueueCollection,
   createAutomationRulesCollection,
   createSupportTeamCollection,
+  createPushSubscriptionCollection,
 } from './collections'
 
 function viewConfig(component: string, path: string): AdminViewConfig {
@@ -96,6 +97,7 @@ export function supportPlugin(config?: SupportPluginConfig): Plugin {
       createNotificationQueueCollection(slugs),
       createAutomationRulesCollection(slugs),
       createSupportTeamCollection(slugs),
+      createPushSubscriptionCollection(slugs),
     ]
 
     // Auth logs (conditional)

package/src/utils/push.ts

@@ -0,0 +1,63 @@
+import type { Payload } from 'payload'
+import type { CollectionSlugs } from './slugs'
+import { dbFind, dbDelete } from './db'
+import webpush from 'web-push'
+
+let configured = false
+function ensureVapid(): boolean {
+  if (configured) return true
+  const publicKey = process.env.VAPID_PUBLIC_KEY
+  const privateKey = process.env.VAPID_PRIVATE_KEY
+  if (!publicKey || !privateKey) return false
+  webpush.setVapidDetails(process.env.VAPID_SUBJECT || 'mailto:support@example.com', publicKey, privateKey)
+  configured = true
+  return true
+}
+
+/** Public VAPID key for the browser to subscribe (null if push isn't configured). */
+export function getVapidPublicKey(): string | null {
+  return process.env.VAPID_PUBLIC_KEY || null
+}
+
+export interface PushNotification {
+  title: string
+  body: string
+  url?: string
+}
+
+/**
+ * Send a Web Push notification to all of an agent's subscriptions. RUNTIME-only:
+ * requires VAPID keys; without them it no-ops (`{ sent: 0 }`). Stale subscriptions
+ * (404/410) are pruned automatically.
+ */
+export async function sendPushToUser(
+  payload: Payload,
+  slugs: CollectionSlugs,
+  userId: number | string,
+  notification: PushNotification,
+): Promise<{ sent: number }> {
+  if (!ensureVapid()) return { sent: 0 }
+  let sent = 0
+  try {
+    const subs = await dbFind(payload, slugs.pushSubscriptions, { where: { user: { equals: userId } }, limit: 100, depth: 0, overrideAccess: true })
+    for (const s of subs.docs) {
+      const row = s as { id: number | string; endpoint?: string; p256dh?: string; auth?: string }
+      if (!row.endpoint || !row.p256dh || !row.auth) continue
+      try {
+        await webpush.sendNotification(
+          { endpoint: row.endpoint, keys: { p256dh: row.p256dh, auth: row.auth } },
+          JSON.stringify(notification),
+        )
+        sent++
+      } catch (err) {
+        const code = (err as { statusCode?: number })?.statusCode
+        if (code === 404 || code === 410) {
+          try { await dbDelete(payload, slugs.pushSubscriptions, { id: row.id, overrideAccess: true }) } catch { /* ignore */ }
+        }
+      }
+    }
+  } catch (err) {
+    console.error('[support] Push send failed:', err)
+  }
+  return { sent }
+}

package/src/utils/slugs.ts

@@ -23,6 +23,7 @@ export interface CollectionSlugs {
   notificationQueue: string
   automationRules: string
   supportTeams: string
+  pushSubscriptions: string
   users: string
   media: string
 }
@@ -48,6 +49,7 @@ export const DEFAULT_SLUGS: CollectionSlugs = {
   notificationQueue: 'notification-queue',
   automationRules: 'automation-rules',
   supportTeams: 'support-teams',
+  pushSubscriptions: 'push-subscriptions',
   users: 'users',
   media: 'media',
 }