@meith/web 0.31.0 → 0.33.0

package/src/server/attachments.ts

@@ -129,6 +129,41 @@ export async function stageAttachments(
   return service.stage(accepted)
 }
 
+export async function resolveEditAttachmentScope(
+  actor: Actor,
+  forumId: number,
+): Promise<AttachmentScope> {
+  const { authorizer, threadWrites } = getContainer()
+  const rules = threadWrites === null ? null : await threadWrites.postingRules(forumId)
+
+  return {
+    forumId,
+    forum: await authorizer.forumMatrix(actor, forumId),
+    allowsAttachments: rules?.allowAttachments === true,
+  }
+}
+
+export async function removeAttachmentsFromPost(
+  ids: readonly number[],
+  post: { readonly postId: number; readonly userId: number },
+): Promise<readonly AttachmentRecord[]> {
+  const service = attachmentService()
+  if (service === null || ids.length === 0) return []
+
+  const removed: AttachmentRecord[] = []
+  for (const id of ids) {
+    const record = await service.removeFromPost(id, post.postId)
+    if (record === null) continue
+    removed.push(record)
+    await emitEvent(
+      'attachment.deleted',
+      { attachmentId: record.id },
+      { userId: post.userId, isGuest: false },
+    )
+  }
+  return removed
+}
+
 export async function attachStaged(
   staged: readonly StagedUpload[],
   post: { readonly postId: number; readonly forumId: number; readonly userId: number },

package/src/server/auth-actions.ts

@@ -20,6 +20,7 @@ import { recordAuthEvent } from './auth-events'
 import type { FormState } from './auth-form-state'
 import { sendPasswordResetEmail, sendVerificationEmail } from './auth-mail'
 import { configuredIdentity, configuredSessions, getContainer } from './container'
+import { revokeFeedToken } from './feed-token'
 import { formStateReporter } from './form-state-reporter'
 import { getTranslator, tr } from './i18n'
 import { termsAcceptance } from './legal'
@@ -477,6 +478,7 @@ export async function confirmResetAction(_prev: FormState, form: FormData): Prom
   const identity = await configuredIdentity()
   try {
     const { userId } = await identity.redeemPasswordReset(token, password)
+    await revokeFeedToken(userId)
     await recordAuthEvent({ userId, kind: 'password_reset' })
   } catch (err) {
     return toFormState(err, { token })

package/src/server/auth-form-state.ts

@@ -3,12 +3,40 @@ export interface UndoState {
   readonly expiresAt: string
 }
 
+export interface ConfirmField {
+  readonly name: string
+  readonly value: string
+}
+
+export interface ConfirmRequest {
+  readonly message: string
+  readonly fields: readonly ConfirmField[]
+}
+
+export interface PollDraftValues {
+  readonly question: string
+  readonly options: readonly string[]
+  readonly closesAt: string
+  readonly maxOptions: string
+  readonly allowRevote: boolean
+  readonly publicVotes: boolean
+}
+
+export interface ThanksResult {
+  readonly thanked: boolean
+  readonly count: number
+}
+
 export interface FormState {
   readonly error?: string | undefined
   readonly notice?: string | undefined
   readonly values?: Record<string, string> | undefined
+  readonly poll?: PollDraftValues | undefined
   readonly preview?: string | undefined
   readonly undo?: UndoState | undefined
+  readonly confirm?: ConfirmRequest | undefined
+  readonly thanks?: ThanksResult | undefined
+  readonly subscribed?: boolean | undefined
 }
 
 export const EMPTY_STATE: FormState = {}

package/src/server/auto-watch.ts

@@ -0,0 +1,31 @@
+import 'server-only'
+
+import type { SubscriptionMode } from '@meith/subscriptions'
+import type { SubscriptionCadence } from '@meith/threads'
+
+import { getContainer } from './container'
+
+export type AutoWatchKind = 'create' | 'reply'
+
+export async function autoWatchPreference(
+  userId: number | null,
+  kind: AutoWatchKind,
+): Promise<SubscriptionMode> {
+  if (userId === null) return 'none'
+
+  const { memberSettings } = getContainer()
+  if (memberSettings === null) return 'none'
+
+  const settings = await memberSettings.read(userId)
+  if (settings === null) return 'none'
+
+  return kind === 'create' ? settings.autoWatchOwnThreads : settings.autoWatchRepliedThreads
+}
+
+export function autoWatchChecksByDefault(preference: SubscriptionMode): boolean {
+  return preference !== 'none'
+}
+
+export function autoWatchCadence(preference: SubscriptionMode): SubscriptionCadence {
+  return preference === 'none' ? 'instant' : preference
+}

package/src/server/ban-filter-admin-actions.ts

@@ -14,9 +14,11 @@ import { msg } from '@meith/i18n'
 import { recordAdminAction, requireAdmin } from './admin'
 import type { FormState } from './auth-form-state'
 import { boardBanFilters } from './ban-filter-admin'
+import { requireConfirmation } from './confirm'
 import { getContainer } from './container'
 import { formStateReporter } from './form-state-reporter'
 import { trimmedText } from './form-values'
+import { tr } from './i18n'
 import { remoteAddress } from './request-fingerprint'
 
 const BAN_FILTER_SCREEN = '/admin/users/ban-filters'
@@ -100,6 +102,9 @@ export async function removeBanFilterAction(_prev: FormState, form: FormData): P
     await requireAdmin()
     const id = filterId(form)
 
+    const confirm = requireConfirmation(form, await tr('adminBanFilter.confirm.remove'))
+    if (confirm !== null) return confirm
+
     await boardBanFilters().remove(id)
 
     refreshBanFilterScreen()

package/src/server/confirm.ts

@@ -0,0 +1,19 @@
+import type { ConfirmField, FormState } from './auth-form-state'
+
+const CONFIRMED = 'confirmed'
+
+export function isConfirmed(form: FormData): boolean {
+  return form.get(CONFIRMED) === '1'
+}
+
+export function requireConfirmation(form: FormData, message: string): FormState | null {
+  if (isConfirmed(form)) return null
+
+  const fields: ConfirmField[] = []
+  form.forEach((value, name) => {
+    if (name === CONFIRMED) return
+    if (typeof value === 'string') fields.push({ name, value })
+  })
+
+  return { confirm: { message, fields } }
+}

package/src/server/content-actions.ts

@@ -11,11 +11,22 @@ import {
   SIGNATURE_FEATURES,
   vocabularyOptions,
 } from '@meith/markdown'
+import { POLL_OPTION_MAX } from '@meith/polls'
 import type { PostEditor } from '@meith/posts'
 
 import { postLink } from '../view/post-link'
-import { attachStaged, claimAttachments, stageAttachments, submittedFiles } from './attachments'
-import type { FormState } from './auth-form-state'
+import {
+  attachmentsForPosts,
+  attachStaged,
+  claimAttachments,
+  removeAttachmentsFromPost,
+  resolveEditAttachmentScope,
+  stageAttachments,
+  submittedFiles,
+} from './attachments'
+import type { FormState, PollDraftValues } from './auth-form-state'
+import { autoWatchCadence, autoWatchPreference } from './auto-watch'
+import { requireConfirmation } from './confirm'
 import { getContainer } from './container'
 import { activeVocabulary } from './content-admin'
 import { getActor } from './context'
@@ -103,6 +114,41 @@ function pollChoiceLimit(form: FormData): number {
   return Number.isSafeInteger(limit) && limit >= 0 ? limit : 1
 }
 
+const POLL_OPTION_ADD_STEP = 4
+
+function pollOptionValues(form: FormData): readonly string[] {
+  return form.getAll('pollOption').filter((value): value is string => typeof value === 'string')
+}
+
+function pollDraftFrom(form: FormData): PollDraftValues {
+  return {
+    question: field(form, 'pollQuestion'),
+    options: pollOptionValues(form),
+    closesAt: field(form, 'pollClosesAt'),
+    maxOptions: field(form, 'pollMaxOptions'),
+    allowRevote: checkbox(form, 'pollAllowRevote'),
+    publicVotes: checkbox(form, 'pollPublicVotes'),
+  }
+}
+
+function grownPollDraft(form: FormData): PollDraftValues {
+  const draft = pollDraftFrom(form)
+  const slots = Math.min(draft.options.length + POLL_OPTION_ADD_STEP, POLL_OPTION_MAX)
+  return {
+    ...draft,
+    options: Array.from({ length: slots }, (_, index) => draft.options[index] ?? ''),
+  }
+}
+
+function pollClosingTime(value: string): Date | null {
+  const trimmed = value.trim()
+  if (trimmed === '') return null
+
+  const at = new Date(`${trimmed}Z`)
+  if (Number.isNaN(at.getTime())) throw new ValidationError(msg('error.app.valid-date'))
+  return at
+}
+
 const toFormState = formStateReporter('content-actions', 'unexpected error writing content')
 
 export interface ComposerAutosaveInput {
@@ -150,22 +196,47 @@ export async function autosaveComposerAction(
   return { savedAt: Date.now() }
 }
 
+export async function deleteDraftAction(_prev: FormState, form: FormData): Promise<FormState> {
+  try {
+    const actor = await getActor()
+    if (actor.userId === null) throw new ForbiddenError(msg('error.app.must-logged-2'))
+
+    const forumId = positiveIntIn(field(form, 'forumId'))
+    if (forumId === null) throw new ValidationError(msg('error.app.forum-exist'))
+    const threadIdRaw = field(form, 'threadId')
+    const threadId = threadIdRaw === '' ? null : positiveIntIn(threadIdRaw)
+
+    const confirm = requireConfirmation(form, await tr('draftsPage.confirm.delete'))
+    if (confirm !== null) return confirm
+
+    const { drafts } = getContainer()
+    if (drafts === null) throw new ValidationError(msg('error.app.drafts-unavailable-board'))
+
+    await drafts.remove(actor.userId, forumId, threadId)
+  } catch (err) {
+    return toFormState(err)
+  }
+
+  redirect('/usercp/drafts')
+}
+
 export async function createThreadAction(_prev: FormState, form: FormData): Promise<FormState> {
   const forumId = positiveIntIn(field(form, 'forumId'))
   const title = field(form, 'title')
   const message = field(form, 'message')
   const prefixId = field(form, 'prefixId') === '' ? null : positiveIntIn(field(form, 'prefixId'))
   const subscribe = checkbox(form, 'subscribe')
-  const pollQuestion = field(form, 'pollQuestion')
-  const pollOptions = form
-    .getAll('pollOption')
-    .filter((value): value is string => typeof value === 'string')
+  const poll = pollDraftFrom(form)
   const values = { title, message, prefixId: field(form, 'prefixId') }
 
-  if (forumId === null) return { error: await tr('notice.app.forum-exist'), values }
+  if (forumId === null) return { error: await tr('notice.app.forum-exist'), values, poll }
 
-  if (field(form, 'intent') === 'preview') {
-    return { notice: 'preview', values, preview: await previewHtml(message) }
+  const intent = field(form, 'intent')
+  if (intent === 'preview') {
+    return { notice: 'preview', values, poll, preview: await previewHtml(message) }
+  }
+  if (intent === 'more_options') {
+    return { values, poll: grownPollDraft(form) }
   }
 
   const actor = await getActor()
@@ -177,28 +248,36 @@ export async function createThreadAction(_prev: FormState, form: FormData): Prom
     resolved = await resolveThreadTarget(actor, forumId)
     const userId = actor.userId!
 
-    if (field(form, 'intent') === 'save_draft') {
+    if (intent === 'save_draft') {
       if (drafts === null) throw new ValidationError(msg('error.app.drafts-unavailable-board'))
       await drafts.save(userId, { forumId, threadId: null, title, message, prefixId })
-      return { notice: 'saved', values }
+      return { notice: 'saved', values, poll }
     }
 
+    const pollClosesAt = pollClosingTime(poll.closesAt)
+
     const staged = await stageAttachments(actor, resolved.scope, await submittedFiles(form))
 
+    const subscribeMode = subscribe
+      ? autoWatchCadence(await autoWatchPreference(userId, 'create'))
+      : undefined
+
     created = await submitThread(actor, resolved, {
       title,
       message,
       prefixId,
       subscribe,
+      ...(subscribeMode === undefined ? {} : { subscribeMode }),
       poll:
-        pollQuestion === '' && pollOptions.every((option) => option.trim() === '')
+        poll.question === '' && poll.options.every((option) => option.trim() === '')
           ? undefined
           : {
-              question: pollQuestion,
-              options: pollOptions,
+              question: poll.question,
+              options: poll.options,
+              closesAt: pollClosesAt,
               maxOptions: pollChoiceLimit(form),
-              allowRevote: checkbox(form, 'pollAllowRevote'),
-              publicVotes: checkbox(form, 'pollPublicVotes'),
+              allowRevote: poll.allowRevote,
+              publicVotes: poll.publicVotes,
             },
     })
 
@@ -211,7 +290,7 @@ export async function createThreadAction(_prev: FormState, form: FormData): Prom
     )
     await drafts?.remove(userId, forumId, null)
   } catch (err) {
-    return toFormState(err, values)
+    return { ...(await toFormState(err, values)), poll }
   }
 
   if (created.visibility === 'unapproved') {
@@ -251,7 +330,16 @@ export async function createReplyAction(_prev: FormState, form: FormData): Promi
 
     const staged = await stageAttachments(actor, scope, await submittedFiles(form))
 
-    created = await submitReply(actor, resolved, { message, subscribe, seenLastPostId })
+    const subscribeMode = subscribe
+      ? autoWatchCadence(await autoWatchPreference(userId, 'reply'))
+      : undefined
+
+    created = await submitReply(actor, resolved, {
+      message,
+      subscribe,
+      ...(subscribeMode === undefined ? {} : { subscribeMode }),
+      seenLastPostId,
+    })
 
     const attached = await attachStaged(staged, { postId: created.postId, forumId, userId })
     await claimAttachments(
@@ -312,6 +400,22 @@ export async function editPostAction(_prev: FormState, form: FormData): Promise<
       throw new ForbiddenError(msg('error.app.must-logged-edit-post'))
     }
 
+    const forumId = scope.target.forum.id
+    const current = await attachmentsForPosts([postId])
+    const removeIds = form
+      .getAll('removeAttachmentIds')
+      .map((value) => (typeof value === 'string' ? positiveIntIn(value) : null))
+      .filter((id): id is number => id !== null)
+    const toRemove = current.filter((record) => removeIds.includes(record.id))
+
+    const attachmentScope = await resolveEditAttachmentScope(actor, forumId)
+    const staged = await stageAttachments(
+      actor,
+      attachmentScope,
+      await submittedFiles(form),
+      current.length - toRemove.length,
+    )
+
     const revised = await filterView(
       'post.edit.before',
       { body: message, reason },
@@ -319,7 +423,7 @@ export async function editPostAction(_prev: FormState, form: FormData): Promise<
         ...viewerRef(actor),
         postId,
         threadId,
-        forumId: scope.target.forum.id,
+        forumId,
       },
     )
 
@@ -329,6 +433,12 @@ export async function editPostAction(_prev: FormState, form: FormData): Promise<
       actor.userId,
       scope.target,
     )
+
+    await attachStaged(staged, { postId, forumId, userId: actor.userId })
+    await removeAttachmentsFromPost(
+      toRemove.map((record) => record.id),
+      { postId, userId: actor.userId },
+    )
   } catch (err) {
     return toFormState(err, values)
   }

package/src/server/content-admin-actions.ts

@@ -17,10 +17,12 @@ import { recordAdminAction, requireAdmin } from './admin'
 import { announcementRepository } from './announcements'
 import { captchaQuestionRepository } from './antispam'
 import type { FormState } from './auth-form-state'
+import { requireConfirmation } from './confirm'
 import { requireAttachmentAdmin, requireContentAdmin } from './content-admin'
 import { getActor } from './context'
 import { formStateReporter } from './form-state-reporter'
 import { trimmedText } from './form-values'
+import { tr } from './i18n'
 import { emitEvent, viewerRef } from './plugin-view'
 
 function id(form: FormData, name = 'id'): number {
@@ -88,6 +90,9 @@ export async function deleteWordFilterAction(_prev: FormState, form: FormData):
     await requireAdmin()
     const filterId = id(form)
 
+    const confirm = requireConfirmation(form, await tr('adminContent.confirm.deleteWordFilter'))
+    if (confirm !== null) return confirm
+
     await requireContentAdmin().deleteWordFilter(filterId)
 
     await invalidateWordFilters()
@@ -131,6 +136,9 @@ export async function deletePrefixAction(_prev: FormState, form: FormData): Prom
     await requireAdmin()
     const prefixId = id(form)
 
+    const confirm = requireConfirmation(form, await tr('adminContent.confirm.deletePrefix'))
+    if (confirm !== null) return confirm
+
     await requireContentAdmin().deletePrefix(prefixId)
 
     await drivers().cache.invalidateTags([CacheTags.prefixes()])
@@ -223,6 +231,10 @@ export async function deleteSmileyAction(_prev: FormState, form: FormData): Prom
     await requireAdmin()
 
     const smileyId = id(form)
+
+    const confirm = requireConfirmation(form, await tr('adminContent.confirm.deleteSmiley'))
+    if (confirm !== null) return confirm
+
     await requireContentAdmin().deleteSmiley(smileyId)
 
     await invalidateVocabulary()
@@ -299,6 +311,10 @@ export async function deleteDirectiveAction(_prev: FormState, form: FormData): P
     await requireAdmin()
 
     const tagId = id(form)
+
+    const confirm = requireConfirmation(form, await tr('adminContent.confirm.deleteDirective'))
+    if (confirm !== null) return confirm
+
     await requireContentAdmin().deleteDirective(tagId)
 
     await invalidateVocabulary()
@@ -315,6 +331,10 @@ export async function deleteAttachmentAction(_prev: FormState, form: FormData):
     await requireAdmin()
 
     const attachmentId = id(form)
+
+    const confirm = requireConfirmation(form, await tr('adminContent.confirm.deleteAttachment'))
+    if (confirm !== null) return confirm
+
     const removed = await requireAttachmentAdmin().delete(attachmentId)
     if (!removed) return { notice: 'deleted' }
 
@@ -404,6 +424,10 @@ export async function deleteAnnouncementAction(
     await requireAdmin()
 
     const announcementId = id(form)
+
+    const confirm = requireConfirmation(form, await tr('adminContent.confirm.deleteAnnouncement'))
+    if (confirm !== null) return confirm
+
     await requireAnnouncements().delete(announcementId)
 
     await recordAdminAction({ action: 'content.announcement_removed', detail: { announcementId } })
@@ -480,6 +504,13 @@ export async function deleteCaptchaQuestionAction(
     await requireAdmin()
 
     const questionId = id(form)
+
+    const confirm = requireConfirmation(
+      form,
+      await tr('adminContent.confirm.deleteCaptchaQuestion'),
+    )
+    if (confirm !== null) return confirm
+
     await requireCaptcha().delete(questionId)
 
     await recordAdminAction({ action: 'content.captcha_removed', detail: { questionId } })

package/src/server/cookies.ts

@@ -11,6 +11,9 @@ export const GUEST_COOKIE_DAYS = 1
 export const ADMIN_COOKIE = 'fs_admin'
 export const ADMIN_COOKIE_PATH = '/admin'
 
+export const ADMIN_SECOND_FACTOR_COOKIE = 'fs_admin_2fa'
+export const ADMIN_SECOND_FACTOR_MINUTES = 10
+
 export const SSO_COOKIE = '__Host-fs_sso'
 export const DEV_SSO_COOKIE = 'fs_sso'
 
@@ -80,6 +83,21 @@ export function clearedAdminCookie(secure: boolean): CookieAttrs {
   }
 }
 
+export function adminSecondFactorCookie(expires: Date, secure: boolean): CookieAttrs {
+  return { httpOnly: true, secure, sameSite: 'strict', path: ADMIN_COOKIE_PATH, expires }
+}
+
+export function clearedAdminSecondFactorCookie(secure: boolean): CookieAttrs {
+  return {
+    httpOnly: true,
+    secure,
+    sameSite: 'strict',
+    path: ADMIN_COOKIE_PATH,
+    expires: new Date(0),
+    maxAge: 0,
+  }
+}
+
 export function clearedCookie(secure: boolean): CookieAttrs {
   return { ...base(secure), expires: new Date(0), maxAge: 0 }
 }

package/src/server/discovery.ts

@@ -14,7 +14,14 @@ import { getContainer } from './container'
 
 export const DISCOVER_PAGE = 20
 
-export const DISCOVERY_VIEWS = ['new', 'today', 'mine', 'participated', 'unanswered'] as const
+export const DISCOVERY_VIEWS = [
+  'new',
+  'today',
+  'unread',
+  'mine',
+  'participated',
+  'unanswered',
+] as const
 export type DiscoveryView = (typeof DISCOVERY_VIEWS)[number]
 
 export function isDiscoveryView(value: string): value is DiscoveryView {
@@ -53,6 +60,9 @@ export async function runDiscovery(input: {
       return repo.activeSince(startOfDay(input.now, input.timeZone), query, scope)
     case 'unanswered':
       return repo.unanswered(query, scope)
+    case 'unread':
+      if (input.actor.userId === null) throw new ForbiddenError(msg('error.app.sign-see-threads'))
+      return repo.unread(input.actor.userId, query, scope)
     case 'mine':
       if (input.actor.userId === null) throw new ForbiddenError(msg('error.app.sign-see-threads'))
       return repo.startedBy(input.actor.userId, query, scope)

package/src/server/feed-routes.ts

@@ -5,12 +5,15 @@ import { type FeedChannel, type FeedEntry, renderAtom, renderRss } from '@/view/
 import { boardOffline } from './board-offline'
 import { activeWordFilter } from './content-admin'
 import { feedFor } from './feed-builder'
+import { feedScopeForRequest } from './feed-token'
 import { filterView } from './plugin-view'
 import { getSettings } from './settings'
-import { FEED_LIMIT, feedRepository, origin, publicScope } from './syndication'
+import { FEED_LIMIT, feedRepository, origin } from './syndication'
 
 const CACHE = 'public, max-age=300, stale-while-revalidate=3600'
 
+const PRIVATE_CACHE = ['private', 'no-store'].join(', ')
+
 export type FeedFormat = 'rss' | 'atom'
 
 export type FeedScope = 'board' | 'forum' | 'thread'
@@ -52,6 +55,7 @@ export async function feedResponse(
   channel: FeedChannel,
   format: FeedFormat,
   feed: FeedScope,
+  options: { readonly private?: boolean } = {},
 ): Promise<Response> {
   const withEntries = { ...channel, entries: await filterEntries(channel.entries, feed) }
   const body = format === 'atom' ? renderAtom(withEntries) : renderRss(withEntries)
@@ -61,7 +65,7 @@ export async function feedResponse(
         format === 'atom'
           ? 'application/atom+xml; charset=utf-8'
           : 'application/rss+xml; charset=utf-8',
-      'cache-control': CACHE,
+      'cache-control': options.private === true ? PRIVATE_CACHE : CACHE,
     },
   })
 }
@@ -82,14 +86,18 @@ export async function offlineFeed(): Promise<Response | null> {
   })
 }
 
-export async function boardFeed(format: FeedFormat, selfPath: string): Promise<Response> {
+export async function boardFeed(
+  format: FeedFormat,
+  selfPath: string,
+  request: Request,
+): Promise<Response> {
   const offline = await offlineFeed()
   if (offline !== null) return offline
 
   const repo = feedRepository()
   if (repo === null) return noFeed()
 
-  const scope = await publicScope()
+  const { scope, tokened } = await feedScopeForRequest(request)
   const threads = await repo.recentThreads(FEED_LIMIT, scope)
   const settings = await getSettings()
 
@@ -106,6 +114,7 @@ export async function boardFeed(format: FeedFormat, selfPath: string): Promise<R
     }),
     format,
     'board',
+    { private: tokened },
   )
 }
 

package/src/server/feed-token-actions.ts

@@ -0,0 +1,61 @@
+'use server'
+
+import { revalidatePath } from 'next/cache'
+
+import { ForbiddenError, isAppError, logger, publicMessageOf } from '@meith/core'
+import { msg } from '@meith/i18n'
+
+import type { FormState } from './auth-form-state'
+import { getActor } from './context'
+import { issueFeedToken, revokeFeedToken } from './feed-token'
+import { getMessageResolver, tr } from './i18n'
+import { origin } from './syndication'
+
+async function currentMemberId(): Promise<number> {
+  const actor = await getActor()
+  if (actor.userId === null) throw new ForbiddenError(msg('error.app.must-logged'))
+  return actor.userId
+}
+
+async function toState(err: unknown): Promise<FormState> {
+  if (isAppError(err)) return { error: publicMessageOf(err, await getMessageResolver()) }
+  logger({ module: 'feed-token-actions' }).error({ err }, 'feed token action failed')
+  return { error: await tr('notice.app.something-went-wrong-please-try') }
+}
+
+export async function regenerateFeedTokenAction(
+  _prev: FormState,
+  _form: FormData,
+): Promise<FormState> {
+  try {
+    const userId = await currentMemberId()
+    const token = await issueFeedToken(userId)
+    const base = await origin()
+
+    revalidatePath('/usercp/security')
+
+    return {
+      notice: 'feed:issued',
+      values: {
+        token,
+        rssUrl: `${base}/feed.xml?token=${token}`,
+        atomUrl: `${base}/atom.xml?token=${token}`,
+      },
+    }
+  } catch (err) {
+    return toState(err)
+  }
+}
+
+export async function revokeFeedTokenAction(_prev: FormState, _form: FormData): Promise<FormState> {
+  try {
+    const userId = await currentMemberId()
+    await revokeFeedToken(userId)
+
+    revalidatePath('/usercp/security')
+
+    return { notice: 'feed:revoked' }
+  } catch (err) {
+    return toState(err)
+  }
+}