@meith/web 0.30.1 → 0.32.0

package/src/server/search.ts

@@ -3,7 +3,12 @@ import 'server-only'
 
 import type { Actor } from '@meith/authorization'
 import { contentScopeFrom, ForbiddenError } from '@meith/core'
-import { getDb, PostgresSearchRepository } from '@meith/db'
+import {
+  DEFAULT_SEARCH_CONFIG,
+  getDb,
+  PostgresSearchRepository,
+  resolveSearchConfig,
+} from '@meith/db'
 import type { SearchScope } from '@meith/search'
 
 import { getContainer } from './container'
@@ -21,12 +26,20 @@ export async function searchMinWordLength(): Promise<number> {
   return (await getSettings()).get('search.min_word_length')
 }
 
-export function searchProvider(): PostgresSearchRepository | null {
-  return getContainer().dataSource === 'postgres' ? new PostgresSearchRepository(getDb()) : null
+export async function searchLanguage(): Promise<string> {
+  return resolveSearchConfig((await getSettings()).get('search.language'))
 }
 
-export function requireSearch(): PostgresSearchRepository {
-  const provider = searchProvider()
+export function searchProvider(
+  config: string = DEFAULT_SEARCH_CONFIG,
+): PostgresSearchRepository | null {
+  return getContainer().dataSource === 'postgres'
+    ? new PostgresSearchRepository(getDb(), config)
+    : null
+}
+
+export function requireSearch(config: string = DEFAULT_SEARCH_CONFIG): PostgresSearchRepository {
+  const provider = searchProvider(config)
   if (provider === null) {
     throw new ForbiddenError(msg('error.app.board-running-in-memory-sample-data-11'))
   }

package/src/server/subscription-actions.ts

@@ -12,6 +12,8 @@ import {
   type UnsubscribeScope,
 } from '@meith/subscriptions'
 
+import { isEnhancedSubmit } from '@/view/progressive-enhancement'
+
 import type { FormState } from './auth-form-state'
 import { getContainer } from './container'
 import { getActor } from './context'
@@ -72,6 +74,8 @@ export async function subscribeAction(_prev: FormState, form: FormData): Promise
       { userId: actor.userId, target, targetId, subscribed: true },
       { requestId: currentRequestId() ?? null },
     )
+
+    if (isEnhancedSubmit(form)) return { subscribed: true }
   } catch (err) {
     return toFormState(err)
   }
@@ -106,6 +110,8 @@ export async function unsubscribeAction(_prev: FormState, form: FormData): Promi
       { userId: actor.userId, target, targetId, subscribed: false },
       { requestId: currentRequestId() ?? null },
     )
+
+    if (isEnhancedSubmit(form)) return { subscribed: false }
   } catch (err) {
     return toFormState(err)
   }
@@ -144,6 +150,8 @@ export async function unsubscribeByTokenAction(
           ['subscription.digest', false],
         ]),
       )
+    } else if (claim.scope === 'board-digest') {
+      await notifications.savePreferences(claim.userId, 'email', new Map([['board.digest', false]]))
     } else {
       await new SubscriptionService({ subscriptions }).unsubscribe({
         userId: claim.userId,
@@ -160,6 +168,7 @@ export async function unsubscribeByTokenAction(
 
 function doneFor(scope: UnsubscribeScope): string {
   if (scope === 'mass-mail') return 'announcements'
+  if (scope === 'board-digest') return 'boardDigest'
   return scope === 'email' ? 'email' : 'one'
 }
 

package/src/server/thread-core.ts

@@ -4,7 +4,12 @@ import type { Actor } from '@meith/authorization'
 import { ForbiddenError, type ForumPermissions, ValidationError } from '@meith/core'
 import { msg } from '@meith/i18n'
 import { restrictsPosting } from '@meith/moderation'
-import { type AuthorRestriction, type ForumPostingTarget, ThreadComposer } from '@meith/threads'
+import {
+  type AuthorRestriction,
+  type ForumPostingTarget,
+  type SubscriptionCadence,
+  ThreadComposer,
+} from '@meith/threads'
 
 import {
   dailyLimitMessage,
@@ -58,10 +63,12 @@ export interface SubmitThreadInput {
   readonly message: string
   readonly prefixId?: number | null
   readonly subscribe?: boolean
+  readonly subscribeMode?: SubscriptionCadence
   readonly poll?:
     | {
         readonly question: string
         readonly options: readonly string[]
+        readonly closesAt?: Date | null
         readonly maxOptions?: number
         readonly allowRevote?: boolean
         readonly publicVotes?: boolean
@@ -126,6 +133,7 @@ export async function submitThread(
       message: draft.body,
       prefixId: draft.prefixId,
       subscribe: input.subscribe ?? false,
+      ...(input.subscribeMode === undefined ? {} : { subscribeMode: input.subscribeMode }),
       heldAsNewMember: await holdsNewMember({
         actor,
         postCount: profile.postCount,
@@ -139,7 +147,7 @@ export async function submitThread(
             poll: {
               question: input.poll.question,
               options: input.poll.options,
-              closesAt: null,
+              closesAt: input.poll.closesAt ?? null,
               ...(input.poll.maxOptions === undefined ? {} : { maxOptions: input.poll.maxOptions }),
               ...(input.poll.allowRevote === undefined
                 ? {}

package/src/server/thread-tool-actions.ts

@@ -8,6 +8,7 @@ import { msg } from '@meith/i18n'
 import { parseThreadTool, type ThreadToolRights, ThreadTools } from '@meith/moderation'
 
 import type { FormState } from './auth-form-state'
+import { requireConfirmation } from './confirm'
 import { getContainer } from './container'
 import { getActor } from './context'
 import { formStateReporter } from './form-state-reporter'
@@ -63,6 +64,11 @@ export async function threadToolAction(_prev: FormState, form: FormData): Promis
         ? await resolveRights(toForumId, threadAuthorId)
         : undefined
 
+    if (tool === 'delete' && rights.delete) {
+      const confirm = requireConfirmation(form, await tr('moderationForm.confirm.deleteThread'))
+      if (confirm !== null) return confirm
+    }
+
     outcome = await new ThreadTools({ threads: threadTools }).apply({
       threadId,
       tool,

package/src/server/unread-goto.ts

@@ -0,0 +1,28 @@
+import 'server-only'
+
+import type { ContentScope } from '@meith/core'
+import type { PostLocation, PostRepository } from '@meith/posts'
+import type { ReadStateRepository } from '@meith/threads'
+
+export interface UnreadGotoThread {
+  readonly id: number
+  readonly forumId: number
+  readonly lastPostId: number | null
+}
+
+export async function resolveUnreadGoto(
+  posts: PostRepository,
+  readState: ReadStateRepository,
+  userId: number,
+  thread: UnreadGotoThread,
+  options: { readonly scope: ContentScope; readonly pageSize: number },
+): Promise<PostLocation | null> {
+  const marker = await readState.markerFor(userId, thread.id, thread.forumId)
+  const located = await posts.locateFirstUnread(
+    thread.id,
+    { postId: marker.lastReadPostId ?? 0, since: marker.forumReadAt },
+    options,
+  )
+  if (located !== null) return located
+  return thread.lastPostId === null ? null : posts.locate(thread.id, thread.lastPostId, options)
+}

package/src/server/upgrade-notice.ts

@@ -16,7 +16,7 @@ import { planUpgrade, type UpgradeState, upgradeNotice } from '@meith/upgrade'
 
 import { activeDefinitions } from './plugin-host'
 
-export const CODE_VERSION = '0.30.1'
+export const CODE_VERSION = '0.32.0'
 
 export interface UpgradeApplied {
   readonly plugins: readonly string[]

package/src/server/usercp-actions.ts

@@ -18,6 +18,7 @@ import { AVATAR_FIELD, canUploadAvatar, requireAvatarService } from './avatars'
 import { configuredSessions, getContainer } from './container'
 import { getActor } from './context'
 import { assertDemoAccountChangeable } from './demo'
+import { revokeFeedToken } from './feed-token'
 import { formStateReporter } from './form-state-reporter'
 import { text } from './form-values'
 import { getTranslator, tr } from './i18n'
@@ -103,11 +104,24 @@ export async function saveOptionsAction(_prev: FormState, form: FormData): Promi
       postsPerPage: text(form, 'postsPerPage'),
       threadsPerPage: text(form, 'threadsPerPage'),
       invisible: form.get('invisible') !== null,
+      autoWatchOwnThreads: text(form, 'autoWatchOwnThreads'),
+      autoWatchRepliedThreads: text(form, 'autoWatchRepliedThreads'),
     })
 
     await emitEvent(
       'user.profile.updated',
-      { userId, fields: ['timezone', 'locale', 'postsPerPage', 'threadsPerPage', 'invisible'] },
+      {
+        userId,
+        fields: [
+          'timezone',
+          'locale',
+          'postsPerPage',
+          'threadsPerPage',
+          'invisible',
+          'autoWatchOwnThreads',
+          'autoWatchRepliedThreads',
+        ],
+      },
       { requestId: currentRequestId() ?? null },
     )
   } catch (err) {
@@ -117,6 +131,20 @@ export async function saveOptionsAction(_prev: FormState, form: FormData): Promi
   redirect('/usercp/options?saved=1')
 }
 
+export async function saveBoardDigestCadenceAction(
+  _prev: FormState,
+  form: FormData,
+): Promise<FormState> {
+  try {
+    const { service, userId } = await requireOwnSettings()
+    await service.saveBoardDigestCadence({ userId, cadence: text(form, 'cadence') })
+  } catch (err) {
+    return toFormState(err)
+  }
+
+  redirect('/notifications/preferences?saved=digest-cadence')
+}
+
 export async function changePasswordAction(_prev: FormState, form: FormData): Promise<FormState> {
   try {
     const { service, userId } = await requireOwnSettings()
@@ -141,6 +169,8 @@ export async function changePasswordAction(_prev: FormState, form: FormData): Pr
     const admin = adminService()
     if (admin !== null) await admin.endAllFor(userId)
 
+    await revokeFeedToken(userId)
+
     await recordAuthEvent({ userId, kind: 'password_changed' })
   } catch (err) {
     return toFormState(err)

package/src/server/viewer-preferences.ts

@@ -3,6 +3,8 @@ import 'server-only'
 import { cookies } from 'next/headers'
 import { cache } from 'react'
 
+import type { SubscriptionMode } from '@meith/subscriptions'
+
 import { resolveTimezone, TIMEZONE_COOKIE } from '@/view/timezone'
 
 import { getContainer } from './container'
@@ -15,6 +17,7 @@ export interface ViewerPreferences {
   readonly locale: string | null
   readonly postsPerPage: number
   readonly threadsPerPage: number
+  readonly autoWatchRepliedThreads: SubscriptionMode
 }
 
 const detectedZone = cache(async (): Promise<string | null> => {
@@ -43,6 +46,7 @@ export const getViewerPreferences = cache(async (): Promise<ViewerPreferences> =
     locale: stored?.locale ?? null,
     postsPerPage: stored?.postsPerPage ?? defaults.postsPerPage,
     threadsPerPage: stored?.threadsPerPage ?? defaults.threadsPerPage,
+    autoWatchRepliedThreads: stored?.autoWatchRepliedThreads ?? 'none',
   }
 })
 
@@ -51,6 +55,7 @@ async function storedSettings(): Promise<{
   readonly locale: string
   readonly postsPerPage: number | null
   readonly threadsPerPage: number | null
+  readonly autoWatchRepliedThreads: SubscriptionMode
 } | null> {
   const actor = await getActor()
   const { memberSettings } = getContainer()

package/src/server/webhook-actions.ts

@@ -0,0 +1,98 @@
+'use server'
+
+import { revalidatePath } from 'next/cache'
+
+import { isAppError, logger, publicMessageOf } from '@meith/core'
+
+import { recordAdminAction, requireAdmin, requireFreshAdmin } from './admin'
+import type { FormState } from './auth-form-state'
+import { getMessageResolver, tr } from './i18n'
+import { createWebhook, webhookStore } from './webhooks-admin'
+
+function field(form: FormData, name: string): string {
+  const value = form.get(name)
+  return typeof value === 'string' ? value.trim() : ''
+}
+
+function refreshWebhookList(): void {
+  revalidatePath('/admin/webhooks')
+}
+
+async function toState(err: unknown): Promise<FormState> {
+  if (isAppError(err)) return { error: publicMessageOf(err, await getMessageResolver()) }
+  logger({ module: 'webhook-actions' }).error({ err }, 'webhook action failed')
+  return { error: await tr('notice.app.something-went-wrong-please-try') }
+}
+
+export async function createWebhookAction(_prev: FormState, form: FormData): Promise<FormState> {
+  try {
+    const admin = await requireFreshAdmin()
+
+    const secret = await createWebhook({
+      url: field(form, 'url'),
+      topics: form.getAll('topics').filter((value): value is string => typeof value === 'string'),
+      format: field(form, 'format'),
+      active: field(form, 'active') !== 'false',
+      createdBy: admin.userId,
+    })
+
+    await recordAdminAction({
+      action: 'system.webhook_created',
+      detail: { url: field(form, 'url') },
+    })
+
+    refreshWebhookList()
+
+    return { notice: 'created', values: { secret } }
+  } catch (err) {
+    return toState(err)
+  }
+}
+
+export async function deleteWebhookAction(_prev: FormState, form: FormData): Promise<FormState> {
+  try {
+    await requireAdmin()
+
+    const id = Number(field(form, 'webhookId'))
+    if (!Number.isSafeInteger(id) || id <= 0) return { error: await tr('notice.app.such-webhook') }
+
+    const store = webhookStore()
+    if (store === null) return { error: await tr('notice.app.board-database-webhooks') }
+
+    const removed = await store.remove(id)
+    if (removed) {
+      await recordAdminAction({ action: 'system.webhook_deleted', detail: { webhookId: id } })
+    }
+
+    refreshWebhookList()
+    return { notice: 'deleted' }
+  } catch (err) {
+    return toState(err)
+  }
+}
+
+export async function toggleWebhookAction(_prev: FormState, form: FormData): Promise<FormState> {
+  try {
+    await requireAdmin()
+
+    const id = Number(field(form, 'webhookId'))
+    if (!Number.isSafeInteger(id) || id <= 0) return { error: await tr('notice.app.such-webhook') }
+
+    const store = webhookStore()
+    if (store === null) return { error: await tr('notice.app.board-database-webhooks') }
+
+    const active = field(form, 'active') === 'true'
+    const changed = await store.setActive(id, active)
+    if (changed) {
+      await recordAdminAction({
+        action: 'system.webhook_updated',
+        detail: { webhookId: id, active },
+      })
+    }
+
+    refreshWebhookList()
+    return { notice: 'updated' }
+  } catch (err) {
+    return toState(err)
+  }
+}

package/src/server/webhooks-admin.ts

@@ -0,0 +1,122 @@
+import { msg } from '@meith/i18n'
+import 'server-only'
+
+import {
+  generateWebhookSecret,
+  isWebhookFormat,
+  isWebhookTopic,
+  WEBHOOK_FORMATS,
+  WEBHOOK_TOPICS,
+  type WebhookFormat,
+  type WebhookTopic,
+} from '@meith/api'
+import { ValidationError } from '@meith/core'
+import { getDb, PostgresWebhookRepository } from '@meith/db'
+
+import { getContainer } from './container'
+
+export function webhookStore(): PostgresWebhookRepository | null {
+  return getContainer().dataSource === 'postgres' ? new PostgresWebhookRepository(getDb()) : null
+}
+
+export interface WebhookDeliveryLogEntry {
+  readonly id: number
+  readonly deliveryId: string
+  readonly topic: string
+  readonly status: string
+  readonly attempts: number
+  readonly lastStatusCode: number | null
+  readonly lastError: string | null
+  readonly createdAt: Date
+  readonly completedAt: Date | null
+}
+
+export interface WebhookRow {
+  readonly id: number
+  readonly url: string
+  readonly topics: readonly WebhookTopic[]
+  readonly active: boolean
+  readonly format: WebhookFormat
+  readonly createdAt: Date
+  readonly delivered: number
+  readonly pending: number
+  readonly dead: number
+  readonly recent: readonly WebhookDeliveryLogEntry[]
+}
+
+export interface WebhookView {
+  readonly subscriptions: readonly WebhookRow[]
+  readonly topics: readonly WebhookTopic[]
+  readonly formats: readonly WebhookFormat[]
+}
+
+export async function buildWebhookView(): Promise<WebhookView | null> {
+  const store = webhookStore()
+  if (store === null) return null
+
+  const summaries = await store.listAll()
+  const subscriptions = await Promise.all(
+    summaries.map(async (summary) => ({
+      id: summary.id,
+      url: summary.url,
+      topics: summary.topics,
+      active: summary.active,
+      format: summary.format,
+      createdAt: summary.createdAt,
+      delivered: summary.delivered,
+      pending: summary.pending,
+      dead: summary.dead,
+      recent: await store.recentDeliveries(summary.id, 10),
+    })),
+  )
+
+  return { subscriptions, topics: WEBHOOK_TOPICS, formats: WEBHOOK_FORMATS }
+}
+
+export interface CreateWebhookInput {
+  readonly url: string
+  readonly topics: readonly string[]
+  readonly format: string
+  readonly active: boolean
+  readonly createdBy: number | null
+}
+
+function validUrl(raw: string): string {
+  const url = raw.trim()
+  let parsed: URL
+  try {
+    parsed = new URL(url)
+  } catch {
+    throw new ValidationError(msg('error.app.webhook-url-https'))
+  }
+  if (parsed.protocol !== 'https:') {
+    throw new ValidationError(msg('error.app.webhook-url-https'))
+  }
+  return url
+}
+
+export async function createWebhook(input: CreateWebhookInput): Promise<string> {
+  const store = webhookStore()
+  if (store === null) throw new ValidationError(msg('error.app.board-database-webhooks'))
+
+  const url = validUrl(input.url)
+
+  const topics = input.topics.filter((topic): topic is WebhookTopic => isWebhookTopic(topic))
+  if (topics.length === 0) {
+    throw new ValidationError(msg('error.app.webhook-needs-at-least-one-topic'))
+  }
+
+  const format: WebhookFormat = isWebhookFormat(input.format) ? input.format : 'json'
+
+  const secret = generateWebhookSecret()
+  await store.create({
+    url,
+    secret,
+    topics,
+    active: input.active,
+    format,
+    createdBy: input.createdBy,
+  })
+
+  return secret
+}

package/src/theme/contract.fixture.ts

@@ -147,10 +147,23 @@ export const SLOT_FIXTURES: { readonly [K in SlotName]?: SlotFixture<K> } = {
       boardTitle: 'The Bike Shed',
       homeHref: '/',
       viewer: VIEWER,
-      navigation: [{ label: 'Unanswered', href: '/discover/unanswered' }],
+      navigation: [
+        { label: 'Unanswered', href: '/discover/unanswered' },
+        {
+          label: 'Community',
+          href: '/community',
+          submenu: [{ label: 'Rules', href: '/community/rules' }],
+        },
+      ],
       children: region('user-panel'),
     },
-    requires: ['The Bike Shed', region('user-panel'), '/discover/unanswered'],
+    requires: [
+      'The Bike Shed',
+      region('user-panel'),
+      '/discover/unanswered',
+      '/community/rules',
+      'Rules',
+    ],
   },
 
   UserPanel: {
@@ -331,8 +344,18 @@ export const SLOT_FIXTURES: { readonly [K in SlotName]?: SlotFixture<K> } = {
   },
 
   ThreadRow: {
-    model: { thread: { ...THREAD, visibility: 'deleted' }, select: null },
-    requires: ['Bikeshedding the bike shed', '/thread/91-bikeshedding', '27', 'data-visibility'],
+    model: {
+      thread: { ...THREAD, visibility: 'deleted' },
+      select: null,
+      regions: { pluginBadges: pluginRegion('threadrow-badges') },
+    },
+    requires: [
+      'Bikeshedding the bike shed',
+      '/thread/91-bikeshedding',
+      '27',
+      'data-visibility',
+      pluginRegion('threadrow-badges'),
+    ],
   },
 
   SubforumList: {
@@ -351,13 +374,19 @@ export const SLOT_FIXTURES: { readonly [K in SlotName]?: SlotFixture<K> } = {
       forum: { label: 'General discussion', href: '/f/3-general' },
       replyHref: '/thread/91-bikeshedding/reply',
       markReadAction: '/thread/91-bikeshedding/mark-read',
+      watch: { subscribed: true, action: '/thread/91-bikeshedding/unwatch' },
       regions: {
         posts: region('posts'),
         pagination: region('pagination'),
         quickReply: region('quick-reply'),
       },
     },
-    requires: ['Bikeshedding the bike shed', region('posts'), region('pagination')],
+    requires: [
+      'Bikeshedding the bike shed',
+      '/thread/91-bikeshedding/unwatch',
+      region('posts'),
+      region('pagination'),
+    ],
   },
 
   PostBit: {
@@ -417,6 +446,7 @@ export const SLOT_FIXTURES: { readonly [K in SlotName]?: SlotFixture<K> } = {
       buttons: [
         {
           tag: 'bold',
+          insertion: null,
           label: 'Bold',
           title: 'Bold (Ctrl+B)',
           keyShortcut: 'Control+b',
@@ -425,6 +455,7 @@ export const SLOT_FIXTURES: { readonly [K in SlotName]?: SlotFixture<K> } = {
         },
         {
           tag: 'link',
+          insertion: null,
           label: 'Link',
           title: 'Link',
           keyShortcut: null,

package/src/view/account-copy.ts

@@ -48,6 +48,10 @@ export function optionsFormCopy(
         'accountForm.options.pageSizeHint',
         'accountForm.options.invisible',
         'accountForm.options.invisibleHint',
+        'accountForm.options.autoWatchOwnThreads',
+        'accountForm.options.autoWatchOwnThreadsHint',
+        'accountForm.options.autoWatchRepliedThreads',
+        'accountForm.options.autoWatchRepliedThreadsHint',
         'accountForm.options.submit',
       ],
       t,
@@ -286,6 +290,36 @@ export function activityDetailLabel(
   return t.t('accountForm.activity.detail', { at, device, address })
 }
 
+export function feedTokenCopy(t: Translator = untranslated()): Readonly<Record<string, string>> {
+  return copyFor(
+    [
+      'accountForm.feed.title',
+      'accountForm.feed.blurb',
+      'accountForm.feed.none',
+      'accountForm.feed.active',
+      'accountForm.feed.generate',
+      'accountForm.feed.regenerate',
+      'accountForm.feed.revoke',
+      'accountForm.feed.copyNow',
+      'accountForm.feed.revealHint',
+      'accountForm.feed.rssLabel',
+      'accountForm.feed.atomLabel',
+      'accountForm.feed.warning',
+      'form.working',
+    ],
+    t,
+  )
+}
+
+export function feedTokenDetailLabel(
+  created: string,
+  lastUsed: string | null,
+  t: Translator = untranslated(),
+): string {
+  const used = lastUsed === null ? t.t('accountForm.feed.neverUsed') : lastUsed
+  return t.t('accountForm.feed.detail', { created, used })
+}
+
 export function notificationFormsCopy(
   t: Translator = untranslated(),
 ): Readonly<Record<string, string>> {
@@ -304,6 +338,11 @@ export function notificationFormsCopy(
       'accountForm.announcements.description',
       'accountForm.announcements.blurb',
       'accountForm.announcements.submit',
+      'accountForm.boardDigest.legend',
+      'accountForm.boardDigest.description',
+      'accountForm.boardDigest.weekly',
+      'accountForm.boardDigest.monthly',
+      'accountForm.boardDigest.submit',
       'accountForm.push.heading',
       'accountForm.push.subscribe',
       'accountForm.push.unsubscribe',

package/src/view/admin-copy.ts

@@ -61,8 +61,10 @@ export function forumAdminCopy(t: Translator = untranslated()): Readonly<Record<
         'adminForum.permGroup.moderation',
         'adminForum.permGroup.attachments',
         'adminForum.permGroup.approvals',
+        'adminForum.permGroup.numeric',
         'adminForum.permGroup.other',
-        'adminForum.inheritsAll',
+        'adminForum.permission',
+        'adminForum.saveMatrix',
         'adminForum.unsavedChanges',
         'adminForum.copied',
         'adminForum.copyNote',
@@ -102,14 +104,7 @@ export function forumAdminCopy(t: Translator = untranslated()): Readonly<Record<
       t,
     ),
     ...patternCopy(
-      [
-        'adminForum.perm.setHere',
-        'adminForum.perm.inheritedDefault',
-        'adminForum.perm.inheritedFrom',
-        'adminForum.saveGroup',
-        'adminForum.copyTo',
-        'adminForum.overridesSet',
-      ],
+      ['adminForum.perm.inheritedDefault', 'adminForum.perm.inheritedFrom', 'adminForum.copyTo'],
       t,
     ),
   }

package/src/view/admin-nav.ts

@@ -104,6 +104,12 @@ export const ADMIN_SECTIONS: PanelNav = [
     icon: 'tokens',
     blurbKey: 'adminNav.admin-api-tokens.blurb',
   },
+  {
+    href: '/admin/webhooks',
+    titleKey: 'adminNav.admin-webhooks.title',
+    icon: 'subscriptions',
+    blurbKey: 'adminNav.admin-webhooks.blurb',
+  },
   {
     href: '/admin/system',
     titleKey: 'adminNav.admin-system.title',