@consilioweb/payload-support 2.0.0 → 3.0.0

package/src/endpoints/settings.ts

@@ -1,59 +1,21 @@
 import type { Endpoint } from 'payload'
 import type { CollectionSlugs } from '../utils/slugs'
 import { requireAdmin, handleAuthError } from '../utils/auth'
-import { invalidateSupportSettingsCache } from '../utils/readSettings'
-import { dbFind } from '../utils/db'
-
-const PREF_KEY = 'support-settings'
-
-interface SupportSettings {
-  email: {
-    fromAddress: string
-    fromName: string
-    replyToAddress: string
-  }
-  ai: {
-    provider: 'anthropic' | 'openai' | 'gemini' | 'ollama'
-    model: string
-    enableSentiment: boolean
-    enableSynthesis: boolean
-    enableSuggestion: boolean
-    enableRewrite: boolean
-  }
-  sla: {
-    firstResponseMinutes: number
-    resolutionMinutes: number
-    businessHoursOnly: boolean
-    escalationEmail: string
-  }
-  autoClose: {
-    enabled: boolean
-    daysBeforeClose: number
-    reminderDaysBefore: number
-  }
-}
-
-const DEFAULT_SUPPORT_SETTINGS: SupportSettings = {
-  email: { fromAddress: '', fromName: 'Support', replyToAddress: '' },
-  ai: {
-    provider: 'anthropic',
-    model: 'claude-haiku-4-5-20251001',
-    enableSentiment: true,
-    enableSynthesis: true,
-    enableSuggestion: true,
-    enableRewrite: true,
-  },
-  sla: {
-    firstResponseMinutes: 120,
-    resolutionMinutes: 1440,
-    businessHoursOnly: true,
-    escalationEmail: '',
-  },
-  autoClose: { enabled: true, daysBeforeClose: 7, reminderDaysBefore: 2 },
-}
+import {
+  SUPPORT_SETTINGS_PREF_KEY as PREF_KEY,
+  invalidateSupportSettingsCache,
+  mergeSupportSettings,
+  readSupportSettingsState,
+  type SupportSettings,
+} from '../utils/readSettings'
+import { stripProjectedFeatures } from '../utils/features'
 
 /**
  * GET /api/support/settings — Read support settings
+ *
+ * `featuresConfigured` tells the admin UI whether the server has ever had
+ * feature flags saved; a client still holding pre-2.1 `localStorage` flags uses
+ * it to seed the server once instead of losing its configuration.
  */
 export function createSettingsGetEndpoint(slugs: CollectionSlugs): Endpoint {
   return {
@@ -65,25 +27,9 @@ export function createSettingsGetEndpoint(slugs: CollectionSlugs): Endpoint {
 
         requireAdmin(req, slugs)
 
-        const prefs = await dbFind(payload, 'payload-preferences', {
-          where: { key: { equals: PREF_KEY } },
-          limit: 1,
-          depth: 0,
-          overrideAccess: true,
-        })
-
-        let settings = { ...DEFAULT_SUPPORT_SETTINGS }
-        if (prefs.docs.length > 0) {
-          const stored = prefs.docs[0].value as Partial<SupportSettings>
-          settings = {
-            email: { ...DEFAULT_SUPPORT_SETTINGS.email, ...stored.email },
-            ai: { ...DEFAULT_SUPPORT_SETTINGS.ai, ...stored.ai },
-            sla: { ...DEFAULT_SUPPORT_SETTINGS.sla, ...stored.sla },
-            autoClose: { ...DEFAULT_SUPPORT_SETTINGS.autoClose, ...stored.autoClose },
-          }
-        }
+        const { settings, featuresConfigured } = await readSupportSettingsState(payload)
 
-        return Response.json(settings)
+        return Response.json({ ...settings, featuresConfigured })
       } catch (error) {
         const authResponse = handleAuthError(error)
         if (authResponse) return authResponse
@@ -95,7 +41,11 @@ export function createSettingsGetEndpoint(slugs: CollectionSlugs): Endpoint {
 }
 
 /**
- * POST /api/support/settings — Save all support settings (admin-only)
+ * POST /api/support/settings — Save support settings (admin-only)
+ *
+ * The body is merged onto the CURRENT settings, not onto the defaults: the
+ * feature-flag screen posts `{ features }` alone, and that must not reset the
+ * email / AI / SLA blocks.
  */
 export function createSettingsPostEndpoint(slugs: CollectionSlugs): Endpoint {
   return {
@@ -109,19 +59,20 @@ export function createSettingsPostEndpoint(slugs: CollectionSlugs): Endpoint {
 
         const body = (await req.json!()) as Partial<SupportSettings>
 
-        const merged: SupportSettings = {
-          email: { ...DEFAULT_SUPPORT_SETTINGS.email, ...body.email },
-          ai: { ...DEFAULT_SUPPORT_SETTINGS.ai, ...body.ai },
-          sla: { ...DEFAULT_SUPPORT_SETTINGS.sla, ...body.sla },
-          autoClose: { ...DEFAULT_SUPPORT_SETTINGS.autoClose, ...body.autoClose },
-        }
+        const { settings: current } = await readSupportSettingsState(payload)
+        const merged = mergeSupportSettings(body, current)
 
         await payload.db.upsert({
           collection: 'payload-preferences',
           data: {
             key: PREF_KEY,
             user: { relationTo: req.user!.collection, value: req.user!.id },
-            value: merged as unknown as Record<string, unknown>,
+            value: {
+              ...merged,
+              // Persist the flags without the two projected ones, so `features`
+              // and the `autoClose` block can never drift apart.
+              features: stripProjectedFeatures(merged.features),
+            } as unknown as Record<string, unknown>,
           },
           req: { payload, user: req.user } as any,
           where: {
@@ -135,7 +86,7 @@ export function createSettingsPostEndpoint(slugs: CollectionSlugs): Endpoint {
 
         invalidateSupportSettingsCache()
 
-        return Response.json(merged)
+        return Response.json({ ...merged, featuresConfigured: true })
       } catch (error) {
         const authResponse = handleAuthError(error)
         if (authResponse) return authResponse

package/src/index.ts

@@ -21,8 +21,12 @@ export { DEFAULT_FEATURES } from './types'
 // Utils
 export { resolveSlugs, DEFAULT_SLUGS } from './utils/slugs'
 export type { CollectionSlugs } from './utils/slugs'
-export { readSupportSettings, readUserPrefs, DEFAULT_SETTINGS, DEFAULT_USER_PREFS } from './utils/readSettings'
-export type { SupportSettings, UserPrefs } from './utils/readSettings'
+export { readSupportSettings, readSupportSettingsState, readUserPrefs, DEFAULT_SETTINGS, DEFAULT_USER_PREFS } from './utils/readSettings'
+export type { SupportSettings, SupportSettingsState, UserPrefs } from './utils/readSettings'
+// Runtime feature flags (server-authoritative, see utils/features.ts). Distinct
+// from the build-time `SupportFeatures` passed to `supportPlugin()`.
+export { DEFAULT_TICKETING_FEATURES, normalizeFeatures, projectAutoClose, stripProjectedFeatures } from './utils/features'
+export type { TicketingFeatures } from './utils/features'
 export { MemoryRateLimitStore, PayloadRateLimitStore, RateLimiter } from './utils/rateLimiter'
 export type { RateLimitEntry, RateLimitStore } from './utils/rateLimiter'
 export { DEFAULT_INBOUND_EMAIL_LIMITS, validateInboundEmailPayload, verifySecret } from './utils/webhookSecurity'

package/src/portal/LiveChat.tsx

@@ -29,6 +29,13 @@ export function LiveChat() {
   const lastFetchRef = useRef<string | null>(null)
   const inputRef = useRef<HTMLInputElement>(null)
   const pollIntervalRef = useRef<ReturnType<typeof setTimeout> | null>(null)
+  // Mirror of `messages`. The poll decision (and the unread badge) MUST be taken
+  // outside the setMessages updater: React skips the updater on the eager-state
+  // path, so a flag assigned inside it is only ever written on the very first
+  // update — after which `hasNewMessages` stays false, the adaptive backoff climbs
+  // to its 30 s ceiling and never comes back down, mid-conversation. Same pattern
+  // as ChatWidget.tsx.
+  const messagesRef = useRef<ChatMessage[]>([])
 
   // Load session from localStorage on mount
   useEffect(() => {
@@ -42,6 +49,7 @@ export function LiveChat() {
 
   // Auto-scroll to bottom when messages change
   useEffect(() => {
+    messagesRef.current = messages
     messagesEndRef.current?.scrollIntoView({ behavior: 'smooth' })
   }, [messages])
 
@@ -61,31 +69,32 @@ export function LiveChat() {
 
       const data = await res.json()
       if (data.messages?.length > 0) {
-        let hadNewMessages = false
-        setMessages((prev) => {
-          const existingIds = new Set(prev.map((m) => String(m.id)))
-          const newMsgs = data.messages.filter(
-            (m: ChatMessage) => !existingIds.has(String(m.id)),
-          )
-          if (newMsgs.length === 0) return prev
-
-          hadNewMessages = true
-
-          // Count agent messages as unread if chat panel is closed
-          if (screen === 'closed') {
-            const agentNewMsgs = newMsgs.filter(
-              (m: ChatMessage) => m.senderType === 'agent',
-            )
-            if (agentNewMsgs.length > 0) {
-              setUnreadCount((prev) => prev + agentNewMsgs.length)
-            }
+        const existingIds = new Set(messagesRef.current.map((m) => String(m.id)))
+        const newMsgs: ChatMessage[] = data.messages.filter(
+          (m: ChatMessage) => !existingIds.has(String(m.id)),
+        )
+        lastFetchRef.current = data.messages[data.messages.length - 1].createdAt
+        if (newMsgs.length === 0) return false
+
+        // Count agent messages as unread if chat panel is closed. Kept OUT of the
+        // updater: nesting a setState there also double-counted the badge under
+        // StrictMode's double invocation in dev.
+        if (screen === 'closed') {
+          const agentNewMsgs = newMsgs.filter((m) => m.senderType === 'agent')
+          if (agentNewMsgs.length > 0) {
+            setUnreadCount((prev) => prev + agentNewMsgs.length)
           }
+        }
 
-          return [...prev, ...newMsgs]
+        setMessages((prev) => {
+          // Re-dedupe against the authoritative state: the mirror can lag by one
+          // commit if a message was appended optimistically in the meantime.
+          const prevIds = new Set(prev.map((m) => String(m.id)))
+          const trulyNew = newMsgs.filter((m) => !prevIds.has(String(m.id)))
+          if (trulyNew.length === 0) return prev
+          return [...prev, ...trulyNew]
         })
-        lastFetchRef.current =
-          data.messages[data.messages.length - 1].createdAt
-        return hadNewMessages
+        return true
       }
       return false
     } catch {
@@ -127,6 +136,8 @@ export function LiveChat() {
       // If we have a session, fetch messages
       if (session.sessionId) {
         lastFetchRef.current = null
+        // Synchronous too: pollMessages() runs before the mirroring effect commits.
+        messagesRef.current = []
         setMessages([])
         pollMessages()
       }

package/src/portal/auth/tickets/detail/TicketPolling.tsx

@@ -30,8 +30,12 @@ export function TicketPolling({
 
     const interval = setInterval(async () => {
       try {
+        // `/count` returns a single number. The previous limit=0 idiom did NOT return
+        // zero documents — Payload disables pagination for limit=0 and derives
+        // totalDocs from the rows it materialised, so every open portal tab used to
+        // re-download its whole conversation every 30 s to read one counter.
         const res = await fetch(
-          `/api/ticket-messages?where[ticket][equals]=${ticketId}&limit=0&depth=0`,
+          `/api/ticket-messages/count?where[ticket][equals]=${ticketId}`,
           { credentials: 'include' },
         )
         if (res.status === 401 || res.status === 403) {

package/src/types/lucide-react.d.ts

@@ -1,7 +1,15 @@
 /**
  * Ambient stub for 'lucide-react'.
- * lucide-react is an optional peer dependency — the host application installs it.
- * This stub satisfies TypeScript when the plugin is type-checked in isolation.
+ *
+ * lucide-react is a REQUIRED peer dependency — three unconditionally registered
+ * components import it statically, so a host without it fails at build time.
+ * It is deliberately not a devDependency here; this stub is what lets the plugin
+ * type-check in isolation without pulling the icon set into the repo.
+ *
+ * Keep the icon list below in sync with the actual imports:
+ *   src/portal/LiveChat.tsx
+ *   src/views/PendingEmailsView/client.tsx
+ *   src/views/TicketingSettingsView/client.tsx
  */
 declare module 'lucide-react' {
   import type { FC, SVGProps } from 'react'

package/src/utils/aiAgent.ts

@@ -2,6 +2,7 @@ import type { Payload } from 'payload'
 import type { CollectionSlugs } from './slugs'
 import { readSupportSettings, type SupportSettings } from './readSettings'
 import { dbFind, dbFindByID, dbCreate, dbUpdate } from './db'
+import { resolveOllamaBaseUrl } from './aiProvider'
 
 export interface AgentDecision {
   action: 'reply' | 'escalate'
@@ -61,7 +62,7 @@ export async function applyAgentDecision(
 function getClient(aiSettings: SupportSettings['ai']) {
   const Anthropic = require('@anthropic-ai/sdk').default
   if (aiSettings.provider === 'ollama') {
-    return new Anthropic({ apiKey: 'ollama', baseURL: process.env.OLLAMA_API_URL || 'https://ollama.orkelis.app/v1' })
+    return new Anthropic({ apiKey: 'ollama', baseURL: resolveOllamaBaseUrl() })
   }
   return new Anthropic({ apiKey: process.env.ANTHROPIC_API_KEY })
 }

package/src/utils/aiProvider.ts

@@ -0,0 +1,21 @@
+import { APIError } from 'payload'
+
+/**
+ * Resolve the base URL of the OpenAI-compatible gateway used by the `ollama`
+ * provider.
+ *
+ * There is deliberately NO default here. An integrator who selects `ollama` does
+ * so precisely to keep ticket content off third-party infrastructure; a silent
+ * fallback to any hosted endpoint would ship the whole conversation — subject,
+ * message bodies, client name and company — to a server the operator never chose,
+ * and would do so invisibly because the AI answer still comes back normally.
+ *
+ * Fail loudly instead: a missing `OLLAMA_API_URL` is a configuration error.
+ */
+export function resolveOllamaBaseUrl(): string {
+  const baseURL = process.env.OLLAMA_API_URL
+  if (!baseURL) {
+    throw new APIError("provider 'ollama' requires OLLAMA_API_URL", 500)
+  }
+  return baseURL
+}

package/src/utils/features.ts

@@ -0,0 +1,297 @@
+/**
+ * Ticketing feature flags — single source of truth (client + server).
+ *
+ * Flags are stored SERVER-side, in the `support-settings` row of
+ * `payload-preferences` (see `readSettings.ts` and `endpoints/settings.ts`).
+ * A flag toggled on one machine therefore applies to every browser and to
+ * server-side code (hooks, cron endpoints) alike.
+ *
+ * `localStorage` is still used, but demoted to a plain CACHE: it lets admin
+ * views paint synchronously on first render and keeps them usable when the
+ * settings endpoint is unreachable. It is never authoritative.
+ *
+ * Two flags are *projections* of settings that already lived server-side long
+ * before this module, and are deliberately NOT stored twice:
+ *   - `autoClose`     ← `settings.autoClose.enabled`
+ *   - `autoCloseDays` ← `settings.autoClose.daysBeforeClose`
+ * The `autoClose` block stays authoritative; the flags are recomputed on read
+ * and dropped on write. See `projectAutoClose` / `stripProjectedFeatures`.
+ */
+
+/**
+ * Feature flags for the ticketing module.
+ * Each feature can be enabled/disabled by the admin.
+ * When disabled, the corresponding UI section is hidden entirely.
+ */
+export interface TicketingFeatures {
+  /** Time tracking: timer, manual entries, billing */
+  timeTracking: boolean
+  /** AI features: sentiment, synthesis, suggestion, rewrite */
+  ai: boolean
+  /** Satisfaction surveys: CSAT rating after resolution */
+  satisfaction: boolean
+  /** Live chat integration: chat → ticket conversion */
+  chat: boolean
+  /** Email tracking: pixel tracking, open/sent status per message */
+  emailTracking: boolean
+  /** Canned responses: quick reply templates */
+  canned: boolean
+  /** Ticket merge: combine two tickets into one */
+  merge: boolean
+  /** Snooze: temporarily hide a ticket */
+  snooze: boolean
+  /** External messages: add messages received outside the system */
+  externalMessages: boolean
+  /** Client history: past tickets, projects, notes sidebar */
+  clientHistory: boolean
+  /** Activity log: audit trail of actions on the ticket */
+  activityLog: boolean
+  /** Split ticket: extract a message into a new ticket */
+  splitTicket: boolean
+  /** Scheduled replies: send a message at a future date */
+  scheduledReplies: boolean
+  /** Auto-close: automatically resolve inactive tickets (projection of settings.autoClose.enabled) */
+  autoClose: boolean
+  /** Auto-close delay in days (projection of settings.autoClose.daysBeforeClose) */
+  autoCloseDays: number
+  /** Round-robin: distribute new tickets evenly among agents */
+  roundRobin: boolean
+}
+
+/** Default features — all enabled except round-robin */
+export const DEFAULT_TICKETING_FEATURES: TicketingFeatures = {
+  timeTracking: true,
+  ai: true,
+  satisfaction: true,
+  chat: true,
+  emailTracking: true,
+  canned: true,
+  merge: true,
+  snooze: true,
+  externalMessages: true,
+  clientHistory: true,
+  activityLog: true,
+  splitTicket: true,
+  scheduledReplies: true,
+  autoClose: true,
+  autoCloseDays: 7,
+  roundRobin: false,
+}
+
+type BooleanFeatureKey = Exclude<keyof TicketingFeatures, 'autoCloseDays'>
+
+const BOOLEAN_FEATURE_KEYS: readonly BooleanFeatureKey[] = [
+  'timeTracking',
+  'ai',
+  'satisfaction',
+  'chat',
+  'emailTracking',
+  'canned',
+  'merge',
+  'snooze',
+  'externalMessages',
+  'clientHistory',
+  'activityLog',
+  'splitTicket',
+  'scheduledReplies',
+  'autoClose',
+  'roundRobin',
+]
+
+/** Flags derived from another settings block — never persisted inside `features`. */
+const PROJECTED_FEATURE_KEYS = ['autoClose', 'autoCloseDays'] as const
+
+/**
+ * Coerce arbitrary input (stale localStorage, hand-edited preference row, older
+ * plugin version) into a complete, well-typed feature set. Unknown keys are
+ * dropped and wrongly-typed values fall back to their default.
+ */
+export function normalizeFeatures(raw: unknown): TicketingFeatures {
+  const out = { ...DEFAULT_TICKETING_FEATURES }
+  if (!raw || typeof raw !== 'object') return out
+
+  const src = raw as Record<string, unknown>
+  for (const key of BOOLEAN_FEATURE_KEYS) {
+    if (typeof src[key] === 'boolean') out[key] = src[key] as boolean
+  }
+
+  const days = src.autoCloseDays
+  if (typeof days === 'number' && Number.isFinite(days) && days >= 1) {
+    out.autoCloseDays = Math.floor(days)
+  }
+
+  return out
+}
+
+/** Shape of the `autoClose` settings block the two projected flags mirror. */
+export interface AutoCloseProjectionSource {
+  enabled?: boolean
+  daysBeforeClose?: number
+}
+
+/** Recompute the projected flags from the authoritative `autoClose` block. */
+export function projectAutoClose(
+  features: TicketingFeatures,
+  autoClose: AutoCloseProjectionSource | undefined,
+): TicketingFeatures {
+  if (!autoClose) return features
+  return {
+    ...features,
+    autoClose: typeof autoClose.enabled === 'boolean' ? autoClose.enabled : features.autoClose,
+    autoCloseDays:
+      typeof autoClose.daysBeforeClose === 'number' && autoClose.daysBeforeClose >= 1
+        ? Math.floor(autoClose.daysBeforeClose)
+        : features.autoCloseDays,
+  }
+}
+
+/**
+ * Drop the projected flags before persisting, so `features` and the `autoClose`
+ * block can never disagree.
+ */
+export function stripProjectedFeatures(
+  features: TicketingFeatures,
+): Omit<TicketingFeatures, (typeof PROJECTED_FEATURE_KEYS)[number]> {
+  const out = { ...features } as Record<string, unknown>
+  for (const key of PROJECTED_FEATURE_KEYS) delete out[key]
+  return out as Omit<TicketingFeatures, (typeof PROJECTED_FEATURE_KEYS)[number]>
+}
+
+// ─── Client-side cache ───────────────────────────────────
+
+/** localStorage key. Was the source of truth before 2.1 — now only a cache. */
+export const FEATURES_CACHE_KEY = 'ticketing_features'
+/** Set once the pre-2.1 localStorage values have been pushed to the server. */
+export const FEATURES_ADOPTED_KEY = 'ticketing_features_adopted'
+/** Admin-only settings endpoint backing the flags. */
+export const FEATURES_ENDPOINT = '/api/support/settings'
+
+/** localStorage can throw (Safari private mode, disabled storage) — never let it bubble. */
+function storage(): Storage | null {
+  try {
+    if (typeof window === 'undefined' || !window.localStorage) return null
+    return window.localStorage
+  } catch {
+    return null
+  }
+}
+
+/** Read the cached flags, or `null` when nothing usable is cached. */
+export function readFeaturesCache(): TicketingFeatures | null {
+  const store = storage()
+  if (!store) return null
+  try {
+    const stored = store.getItem(FEATURES_CACHE_KEY)
+    if (!stored) return null
+    return normalizeFeatures(JSON.parse(stored))
+  } catch {
+    return null
+  }
+}
+
+/** Refresh the cache with the values the server just confirmed. */
+export function writeFeaturesCache(features: TicketingFeatures): void {
+  const store = storage()
+  if (!store) return
+  try {
+    store.setItem(FEATURES_CACHE_KEY, JSON.stringify(features))
+  } catch {
+    /* quota exceeded / storage disabled — the server copy still stands */
+  }
+}
+
+/**
+ * Synchronous read used for first paint. Returns the cache when present, the
+ * defaults otherwise. Callers must still refresh from the server — see
+ * `useFeatures`.
+ */
+export function getFeatures(): TicketingFeatures {
+  return readFeaturesCache() ?? { ...DEFAULT_TICKETING_FEATURES }
+}
+
+// ─── One-shot migration of pre-2.1 localStorage ──────────
+
+/** True once this browser's legacy flags have been handed over to the server. */
+export function hasAdoptedLegacyFeatures(): boolean {
+  const store = storage()
+  if (!store) return true // nothing to migrate without storage
+  try {
+    return store.getItem(FEATURES_ADOPTED_KEY) === '1'
+  } catch {
+    return true
+  }
+}
+
+export function markLegacyFeaturesAdopted(): void {
+  const store = storage()
+  if (!store) return
+  try {
+    store.setItem(FEATURES_ADOPTED_KEY, '1')
+  } catch {
+    /* ignore */
+  }
+}
+
+/**
+ * Flags this browser configured before the server became authoritative, or
+ * `null` when there is nothing to migrate (no local values, or already done).
+ */
+export function readLegacyFeatures(): TicketingFeatures | null {
+  if (hasAdoptedLegacyFeatures()) return null
+  return readFeaturesCache()
+}
+
+// ─── Server round-trips ──────────────────────────────────
+
+export interface FetchedFeatures {
+  features: TicketingFeatures
+  /** False when the server has never had feature flags saved (fresh install). */
+  configured: boolean
+  /** True when the values come from the cache/defaults because the call failed. */
+  offline: boolean
+}
+
+/**
+ * Read the flags from the server. Falls back to the local cache, then to the
+ * defaults: a failed settings call must never leave a ticket screen unusable.
+ */
+export async function fetchFeatures(signal?: AbortSignal): Promise<FetchedFeatures> {
+  try {
+    const res = await fetch(FEATURES_ENDPOINT, { credentials: 'include', signal })
+    if (res.ok) {
+      const data = (await res.json()) as {
+        features?: unknown
+        featuresConfigured?: boolean
+        autoClose?: AutoCloseProjectionSource
+      }
+      const features = projectAutoClose(normalizeFeatures(data.features), data.autoClose)
+      writeFeaturesCache(features)
+      return { features, configured: data.featuresConfigured === true, offline: false }
+    }
+  } catch {
+    /* network error / aborted — fall through to the cache */
+  }
+  return { features: getFeatures(), configured: false, offline: true }
+}
+
+/**
+ * Persist the flags server-side, then refresh the local cache.
+ *
+ * @returns true when the server accepted the write.
+ */
+export async function saveFeatures(features: TicketingFeatures): Promise<boolean> {
+  const normalized = normalizeFeatures(features)
+  try {
+    const res = await fetch(FEATURES_ENDPOINT, {
+      method: 'POST',
+      headers: { 'Content-Type': 'application/json' },
+      credentials: 'include',
+      body: JSON.stringify({ features: normalized }),
+    })
+    if (!res.ok) return false
+    writeFeaturesCache(normalized)
+    return true
+  } catch {
+    return false
+  }
+}

package/src/utils/fireWebhooks.ts

@@ -6,6 +6,12 @@ import { dbFind, dbUpdate } from './db'
  * Fire all active webhooks matching the given event.
  * Uses fire-and-forget pattern (Promise.allSettled) so hook callers are never blocked.
  * Each webhook request has a 10-second timeout.
+ *
+ * @deprecated Use `dispatchWebhook` instead. This transport sends the endpoint
+ * secret IN CLEAR in the `X-Webhook-Secret` header, which contradicts the
+ * description of the `secret` field (HMAC-SHA256 signature) and defeats the point
+ * of signing. No hook in the plugin calls it any more — it stays exported only
+ * because it is part of the public surface, and will be removed in the next major.
  */
 export async function fireWebhooks(
   payload: Payload,

package/src/utils/generateTicketSynthesis.ts

@@ -2,12 +2,13 @@ import type { Payload } from 'payload'
 import type { CollectionSlugs } from './slugs'
 import { readSupportSettings, type SupportSettings } from './readSettings'
 import { dbFindByID, dbUpdate, dbFind } from './db'
+import { resolveOllamaBaseUrl } from './aiProvider'
 
 function getClient(aiSettings: SupportSettings['ai']) {
   // eslint-disable-next-line @typescript-eslint/no-require-imports
   const Anthropic = require('@anthropic-ai/sdk').default
   if (aiSettings.provider === 'ollama') {
-    const baseURL = process.env.OLLAMA_API_URL || 'https://ollama.orkelis.app/v1'
+    const baseURL = resolveOllamaBaseUrl()
     return new Anthropic({ apiKey: 'ollama', baseURL })
   }
   return new Anthropic({ apiKey: process.env.ANTHROPIC_API_KEY })

package/src/utils/index.ts

@@ -1,5 +1,7 @@
-export { readSupportSettings, DEFAULT_SETTINGS } from './readSettings'
-export type { SupportSettings } from './readSettings'
+export { readSupportSettings, readSupportSettingsState, mergeSupportSettings, invalidateSupportSettingsCache, DEFAULT_SETTINGS } from './readSettings'
+export type { SupportSettings, SupportSettingsState } from './readSettings'
+export { DEFAULT_TICKETING_FEATURES, normalizeFeatures, projectAutoClose, stripProjectedFeatures } from './features'
+export type { TicketingFeatures } from './features'
 export { resolveSlugs, DEFAULT_SLUGS } from './slugs'
 export type { CollectionSlugs } from './slugs'
 export { RateLimiter } from './rateLimiter'