@meith/web 0.33.4 → 0.35.0

package/src/components/admin/backup-forms.tsx

@@ -0,0 +1,87 @@
+'use client'
+
+import { useActionState } from 'react'
+
+import { EMPTY_STATE } from '@/server/auth-form-state'
+import {
+  deleteBackupAction,
+  requestBackupAction,
+  testBackupDestinationAction,
+} from '@/server/backup-admin-actions'
+
+import { FormError, PendingButton, SubmitButton } from '../auth/form-controls'
+import { ConfirmDialog } from '../shell/confirm-dialog'
+import { type Copy, formatFromCopy, fromCopy } from '../shell/copy'
+import { Saved } from './form-bits'
+
+const ROW_BUTTON =
+  'inline-flex h-8 items-center justify-center rounded-md border border-destructive/30 bg-destructive/10 px-2.5 text-xs font-medium text-destructive transition-colors hover:bg-destructive/20 focus-visible:outline-2 focus-visible:outline-offset-2 focus-visible:outline-ring'
+
+export function RequestBackupForm({ disabled, copy }: { disabled: boolean; copy: Copy }) {
+  const [state, action] = useActionState(requestBackupAction, EMPTY_STATE)
+
+  return (
+    <form action={action} className="flex flex-col gap-2">
+      <FormError message={state.error} />
+      {state.notice === 'queued' && <Saved>{fromCopy(copy, 'adminPanel.backup.queued')}</Saved>}
+      {state.notice === 'already' && (
+        <p className="rounded-md border border-border bg-muted px-3 py-2 text-sm">
+          {fromCopy(copy, 'adminPanel.backup.already')}
+        </p>
+      )}
+      <div>
+        {disabled ? (
+          <button
+            type="button"
+            disabled
+            className="inline-flex h-10 cursor-not-allowed items-center rounded-md border border-border px-4 text-sm opacity-60"
+          >
+            {fromCopy(copy, 'adminPanel.backup.now')}
+          </button>
+        ) : (
+          <SubmitButton className="w-auto">{fromCopy(copy, 'adminPanel.backup.now')}</SubmitButton>
+        )}
+      </div>
+    </form>
+  )
+}
+
+export function DeleteBackupForm({ name, copy }: { name: string; copy: Copy }) {
+  const [state, action] = useActionState(deleteBackupAction, EMPTY_STATE)
+
+  return (
+    <form action={action} className="flex flex-wrap items-center gap-2">
+      <input type="hidden" name="name" value={name} />
+      <PendingButton className={ROW_BUTTON}>
+        {fromCopy(copy, 'adminPanel.backup.delete')}
+      </PendingButton>
+      {state.notice === 'deleted' && (
+        <span className="text-xs text-muted-foreground">
+          {formatFromCopy(copy, 'adminPanel.backup.deleted', { name: state.values?.name ?? name })}
+        </span>
+      )}
+      {state.error !== undefined && <span className="text-xs text-destructive">{state.error}</span>}
+      <ConfirmDialog confirm={state.confirm} action={action} />
+    </form>
+  )
+}
+
+export function TestDestinationForm({ copy }: { copy: Copy }) {
+  const [state, action] = useActionState(testBackupDestinationAction, EMPTY_STATE)
+
+  return (
+    <form action={action} className="flex flex-col gap-2">
+      <FormError message={state.error} />
+      {state.notice === 'reachable' && (
+        <Saved>
+          {formatFromCopy(copy, 'adminPanel.backup.reachable', {
+            count: Number(state.values?.count ?? 0),
+          })}
+        </Saved>
+      )}
+      <div>
+        <SubmitButton className="w-auto">{fromCopy(copy, 'adminPanel.backup.test')}</SubmitButton>
+      </div>
+    </form>
+  )
+}

package/src/components/install/restore-form.tsx

@@ -0,0 +1,154 @@
+'use client'
+
+import { useActionState } from 'react'
+
+import {
+  Alert,
+  AlertDescription,
+  AlertTitle,
+  Card,
+  CardContent,
+  CardDescription,
+  CardHeader,
+  CardTitle,
+} from '@meith/ui'
+import { Button } from '@meith/ui/button'
+
+import { useFocusOnFail } from '@/components/auth/form-controls'
+import { type Copy, formatFromCopy, fromCopy } from '@/components/shell/copy'
+import { type InstallRestoreState, installRestoreAction } from '@/server/install-restore-actions'
+
+const EMPTY: InstallRestoreState = {}
+
+export interface RestoreCandidateView {
+  readonly name: string
+  readonly label: string
+  readonly size: string
+  readonly location: string
+}
+
+export function InstallRestoreForm({
+  candidates,
+  destination,
+  problem,
+  copy,
+}: {
+  candidates: readonly RestoreCandidateView[]
+  destination: string | null
+  problem: string | null
+  copy: Copy
+}) {
+  const [state, submit, pending] = useActionState(installRestoreAction, EMPTY)
+  const errorRef = useFocusOnFail<HTMLDivElement>(state.error !== undefined)
+
+  if (state.outcome !== undefined) {
+    const { outcome } = state
+    return (
+      <Card>
+        <CardHeader>
+          <CardTitle>{fromCopy(copy, 'install.restore.doneTitle')}</CardTitle>
+          <CardDescription>
+            {formatFromCopy(copy, 'install.restore.doneDetail', {
+              bundle: outcome.bundle,
+              version: outcome.version,
+              posts: outcome.posts,
+            })}
+          </CardDescription>
+        </CardHeader>
+        <CardContent className="flex flex-col gap-3 text-sm">
+          {outcome.migrationsApplied > 0 && (
+            <p>
+              {formatFromCopy(copy, 'install.restore.migrated', {
+                count: outcome.migrationsApplied,
+              })}
+            </p>
+          )}
+          {outcome.uploads === 'none' && <p>{fromCopy(copy, 'install.restore.noUploads')}</p>}
+          {outcome.skippedKeys > 0 && (
+            <p className="text-destructive">
+              {formatFromCopy(copy, 'install.restore.skipped', { count: outcome.skippedKeys })}
+            </p>
+          )}
+          <p>{fromCopy(copy, 'install.restore.next')}</p>
+          <p>
+            <a href="/login" className="underline">
+              {fromCopy(copy, 'install.restore.signIn')}
+            </a>
+          </p>
+        </CardContent>
+      </Card>
+    )
+  }
+
+  return (
+    <Card aria-labelledby="install-restore">
+      <CardHeader>
+        <CardTitle id="install-restore">{fromCopy(copy, 'install.restore.title')}</CardTitle>
+        <CardDescription>{fromCopy(copy, 'install.restore.hint')}</CardDescription>
+      </CardHeader>
+      <CardContent className="flex flex-col gap-4">
+        {problem !== null && (
+          <Alert tone="warning">
+            <AlertDescription>{problem}</AlertDescription>
+          </Alert>
+        )}
+        {candidates.length === 0 ? (
+          <p className="text-sm text-muted-foreground">
+            {destination === null
+              ? fromCopy(copy, 'install.restore.noneLocal')
+              : formatFromCopy(copy, 'install.restore.noneAnywhere', { destination })}
+          </p>
+        ) : (
+          <form action={submit} className="flex flex-col gap-4">
+            {state.error !== undefined && (
+              <Alert tone="error" ref={errorRef} tabIndex={-1}>
+                <AlertDescription>
+                  <AlertTitle>{fromCopy(copy, 'install.restore.notRestored')}</AlertTitle>{' '}
+                  {state.error}
+                </AlertDescription>
+              </Alert>
+            )}
+            <fieldset className="flex flex-col gap-2">
+              <legend className="text-sm font-medium">
+                {fromCopy(copy, 'install.restore.pick')}
+              </legend>
+              {candidates.map((candidate, index) => (
+                <label key={candidate.name} className="flex items-start gap-2 text-sm">
+                  <input
+                    type="radio"
+                    name="bundle"
+                    value={candidate.name}
+                    defaultChecked={index === 0}
+                    className="mt-1 size-4"
+                  />
+                  <span className="flex min-w-0 flex-col">
+                    <span className="font-medium">{candidate.label}</span>
+                    <span className="truncate text-xs text-muted-foreground">
+                      <code>{candidate.name}</code> · {candidate.size} · {candidate.location}
+                    </span>
+                  </span>
+                </label>
+              ))}
+            </fieldset>
+            <label className="flex items-start gap-2 text-sm">
+              <input type="checkbox" name="confirm" value="1" className="mt-1 size-4" />
+              <span>{fromCopy(copy, 'install.restore.confirm')}</span>
+            </label>
+            <div className="flex flex-wrap items-center gap-3">
+              <Button type="submit" variant="secondary" size="lg" disabled={pending}>
+                {pending
+                  ? fromCopy(copy, 'install.restore.restoring')
+                  : fromCopy(copy, 'install.restore.submit')}
+              </Button>
+              <p className="text-xs text-muted-foreground">
+                {pending
+                  ? fromCopy(copy, 'install.restore.pendingNote')
+                  : fromCopy(copy, 'install.restore.idleNote')}
+              </p>
+            </div>
+          </form>
+        )}
+      </CardContent>
+    </Card>
+  )
+}

package/src/components/install/unlock-form.tsx

@@ -0,0 +1,65 @@
+'use client'
+
+import { useActionState } from 'react'
+
+import {
+  Alert,
+  AlertDescription,
+  Card,
+  CardContent,
+  CardDescription,
+  CardHeader,
+  CardTitle,
+} from '@meith/ui'
+import { Button } from '@meith/ui/button'
+
+import { useFocusOnFail } from '@/components/auth/form-controls'
+import { type InstallUnlockState, installUnlockAction } from '@/server/install-actions'
+
+const EMPTY: InstallUnlockState = {}
+
+export interface InstallUnlockCopy {
+  readonly title: string
+  readonly lede: string
+  readonly label: string
+  readonly button: string
+  readonly pending: string
+}
+
+export function InstallUnlockForm({ copy }: { copy: InstallUnlockCopy }) {
+  const [state, submit, pending] = useActionState(installUnlockAction, EMPTY)
+  const errorRef = useFocusOnFail<HTMLDivElement>(state.error !== undefined)
+
+  return (
+    <Card aria-labelledby="install-unlock">
+      <CardHeader>
+        <CardTitle id="install-unlock">{copy.title}</CardTitle>
+        <CardDescription>{copy.lede}</CardDescription>
+      </CardHeader>
+      <CardContent>
+        <form action={submit} className="flex flex-col gap-4">
+          {state.error !== undefined && (
+            <Alert tone="error" ref={errorRef} tabIndex={-1}>
+              <AlertDescription>{state.error}</AlertDescription>
+            </Alert>
+          )}
+          <label className="flex flex-col gap-1 text-sm font-medium">
+            {copy.label}
+            <input
+              type="password"
+              name="secret"
+              required
+              autoComplete="off"
+              className="rounded-md border border-border bg-background px-3 py-2 font-mono text-sm"
+            />
+          </label>
+          <div>
+            <Button type="submit" size="lg" disabled={pending}>
+              {pending ? copy.pending : copy.button}
+            </Button>
+          </div>
+        </form>
+      </CardContent>
+    </Card>
+  )
+}

package/src/server/antispam.ts

@@ -125,6 +125,8 @@ export function dailyLimitMessage(
     : `You have used your allowance of ${noun} for today. It resets in ${hours} hours.`
 }
 
+const CREDENTIAL_PROOF_PER_HOUR = 10
+
 type AuthLimitSetting =
   | 'antispam.register_ip_per_hour'
   | 'antispam.reset_per_hour'
@@ -173,6 +175,22 @@ export async function spendResetLimits(
   ]
 }
 
+export async function spendCredentialProofLimit(userId: number): Promise<RateLimitOutcome | null> {
+  const store = rateLimitStore()
+  if (store === null) return null
+
+  try {
+    return await new RateLimiter(store).consume({
+      scope: 'credential_proof',
+      subject: `u:${userId}`,
+      rule: { max: CREDENTIAL_PROOF_PER_HOUR, windowSeconds: HOUR },
+    })
+  } catch (error) {
+    logger().warn({ err: String(error) }, 'credential-proof rate limit unavailable')
+    return null
+  }
+}
+
 export async function spendRegisterLimit(): Promise<RateLimitOutcome | null> {
   const prefix = await countingPrefix()
 

package/src/server/api/content.ts

@@ -52,8 +52,11 @@ async function threadScope(actor: Actor, threadId: number): Promise<ThreadScope
     return null
   }
 
+  const scope = authorizer.contentScope(actor, target)
+  if (!scope.states.includes(located.visibility)) return null
+
   return {
-    scope: authorizer.contentScope(actor, target),
+    scope,
     authors: authorizer.authorFilter(actor, target),
   }
 }

package/src/server/api/subscriptions.ts

@@ -49,8 +49,8 @@ export const SUBSCRIPTION_HANDLERS: ApiRoutes = [
     '/subscriptions',
     async ({ actor }): Promise<ApiResult> => {
       const userId = requireUserId(actor)
-      const visibleForumIds = await getContainer().authorizer.visibleForumIds(actor)
-      const rows = await requireSubscriptions().list(userId, visibleForumIds)
+      const audience = await getContainer().authorizer.threadAudience(actor)
+      const rows = await requireSubscriptions().list(userId, audience)
       const wordFilter = await activeWordFilter()
 
       return {

package/src/server/attachment-upload-actions.ts

@@ -4,6 +4,7 @@ import { ForbiddenError, ValidationError } from '@meith/core'
 import { msg } from '@meith/i18n'
 
 import { attachmentHref, attachmentModel } from '../view/attachments'
+import { limitMessage, spendLimit } from './antispam'
 import { acceptSingleFile, attachmentLimits, attachmentService, canAttach } from './attachments'
 import { getContainer } from './container'
 import { getActor } from './context'
@@ -42,6 +43,9 @@ export async function uploadInlineAttachmentAction(
 
     if (!canAttach(actor, scope)) throw new ForbiddenError(msg('error.app.attach-files-forum'))
 
+    const limited = await spendLimit({ scope: 'upload', actor })
+    if (limited !== null && !limited.allowed) throw new ValidationError(limitMessage(limited))
+
     const accepted = await acceptSingleFile(form, attachmentLimits(scope))
 
     const objections = await filterView('attachment.upload.validate', [], {

package/src/server/auth-actions.ts

@@ -24,6 +24,7 @@ import { revokeFeedToken } from './feed-token'
 import { formStateReporter } from './form-state-reporter'
 import { getTranslator, tr } from './i18n'
 import { termsAcceptance } from './legal'
+import { notificationService } from './notifications'
 import { emitEvent, filterView } from './plugin-view'
 import { profileFieldService, registrationFieldContext, submittedFields } from './profile-fields'
 import {
@@ -297,7 +298,7 @@ async function completeSignIn(
 
   if (remember) {
     const sessions = await configuredSessions()
-    const remembered = await sessions.startRemembered(login.account.id, await deviceContext())
+    const remembered = await sessions.issueRemember(login.account.id)
     await setRememberCookie(remembered.rememberToken, remembered.rememberExpiresAt)
   }
 
@@ -479,6 +480,7 @@ export async function confirmResetAction(_prev: FormState, form: FormData): Prom
   try {
     const { userId } = await identity.redeemPasswordReset(token, password)
     await revokeFeedToken(userId)
+    await notificationService()?.unsubscribeAllFromPush(userId)
     await recordAuthEvent({ userId, kind: 'password_reset' })
   } catch (err) {
     return toFormState(err, { token })

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

@@ -0,0 +1,115 @@
+'use server'
+
+import { rm } from 'node:fs/promises'
+
+import { revalidatePath } from 'next/cache'
+
+import { isBundleName } from '@meith/backup'
+import { ValidationError } from '@meith/core'
+import { msg } from '@meith/i18n'
+
+import { recordAdminAction, requireAdmin, requireFreshAdmin } from './admin'
+import type { FormState } from './auth-form-state'
+import {
+  backupsAvailable,
+  currentBackupSettings,
+  destinationFor,
+  localBundlePath,
+  requireBackupRuns,
+} from './backup-admin'
+import { requireConfirmation } from './confirm'
+import { formStateReporter } from './form-state-reporter'
+import { tr } from './i18n'
+
+const toFormState = formStateReporter('backup-admin', 'backup action failed')
+
+const BACKUPS_PATH = '/admin/system/backups'
+
+function refreshBackupsScreen(): void {
+  revalidatePath(BACKUPS_PATH)
+}
+
+export async function requestBackupAction(): Promise<FormState> {
+  try {
+    const admin = await requireAdmin()
+    if (backupsAvailable() !== 'available') {
+      throw new ValidationError(msg('error.app.backups-not-on-this-deployment'))
+    }
+
+    const { queued } = await requireBackupRuns().enqueue({
+      trigger: 'manual',
+      requestedByUserId: admin.session.userId,
+      now: new Date(),
+    })
+
+    refreshBackupsScreen()
+    if (queued) await recordAdminAction({ action: 'backup.requested' })
+    return { notice: queued ? 'queued' : 'already' }
+  } catch (err) {
+    return toFormState(err)
+  }
+}
+
+function bundleNameFrom(form: FormData): string {
+  const raw = form.get('name')
+  const name = typeof raw === 'string' ? raw.trim() : ''
+  if (!isBundleName(name)) throw new ValidationError(msg('error.app.not-a-backup-bundle-name'))
+  return name
+}
+
+export async function deleteBackupAction(_prev: FormState, form: FormData): Promise<FormState> {
+  try {
+    await requireFreshAdmin()
+    const name = bundleNameFrom(form)
+
+    const confirm = requireConfirmation(form, await tr('adminBackups.confirm.delete'))
+    if (confirm !== null) return confirm
+
+    const local = await localBundlePath(name)
+    if (local !== null) await rm(local, { force: true })
+
+    let remote = false
+    const destination = destinationFor(await currentBackupSettings())
+    if (destination !== undefined) {
+      const listed = await destination.list()
+      if (listed.some((bundle) => bundle.name === name)) {
+        await destination.delete(name)
+        remote = true
+      }
+    }
+
+    if (local === null && !remote) throw new ValidationError(msg('error.app.no-such-bundle'))
+
+    refreshBackupsScreen()
+    await recordAdminAction({
+      action: 'backup.deleted',
+      detail: { name, local: local !== null, remote },
+    })
+    return { notice: 'deleted', values: { name } }
+  } catch (err) {
+    return toFormState(err)
+  }
+}
+
+export async function testBackupDestinationAction(): Promise<FormState> {
+  try {
+    await requireAdmin()
+    const settings = await currentBackupSettings()
+    if (settings.destination.problem !== null) {
+      throw new ValidationError(settings.destination.problem)
+    }
+    const destination = destinationFor(settings)
+    if (destination === undefined) {
+      throw new ValidationError(msg('error.app.no-off-site-destination'))
+    }
+
+    const bundles = await destination.list()
+    await recordAdminAction({
+      action: 'backup.destination_tested',
+      detail: { count: bundles.length },
+    })
+    return { notice: 'reachable', values: { count: String(bundles.length) } }
+  } catch (err) {
+    return toFormState(err)
+  }
+}

package/src/server/backup-admin.ts

@@ -0,0 +1,157 @@
+import 'server-only'
+
+import { stat } from 'node:fs/promises'
+import path from 'node:path'
+
+import {
+  type BackupCapability,
+  type BackupDestination,
+  type BackupRunRecord,
+  backupCapability,
+  backupDestinationFromEnv,
+  bundleTakenAt,
+  isBundleName,
+  localBundles,
+  nextSlotAfter,
+} from '@meith/backup'
+import { env, ForbiddenError, logger } from '@meith/core'
+import { getDb, PostgresBackupRunRepository } from '@meith/db'
+import { msg } from '@meith/i18n'
+import {
+  BACKUP_STALE_MS,
+  type BackupSettingsView,
+  backupDestinationFor,
+  backupRingDirectory,
+  loadBackupSettings,
+} from '@meith/runtime'
+
+import { getContainer } from './container'
+
+export interface BackupBundleRow {
+  readonly name: string
+  readonly takenAt: Date | null
+  readonly localSize: number | null
+  readonly remoteSize: number | null
+}
+
+export interface BackupDestinationView {
+  readonly source: 'environment' | 'board' | 'none'
+  readonly description: string | null
+  readonly problem: string | null
+  readonly listError: string | null
+}
+
+export interface BackupAdminView {
+  readonly capability: BackupCapability
+  readonly ring: string
+  readonly destination: BackupDestinationView
+  readonly bundles: readonly BackupBundleRow[]
+  readonly runs: readonly BackupRunRecord[]
+  readonly active: BackupRunRecord | null
+  readonly settings: BackupSettingsView
+  readonly nextScheduled: Date | null
+}
+
+const RECENT_RUNS = 10
+
+export function backupRuns(): PostgresBackupRunRepository | null {
+  return getContainer().dataSource === 'postgres' ? new PostgresBackupRunRepository(getDb()) : null
+}
+
+export function requireBackupRuns(): PostgresBackupRunRepository {
+  const runs = backupRuns()
+  if (runs === null) {
+    throw new ForbiddenError(msg('error.app.board-running-in-memory-sample-data-6'))
+  }
+  return runs
+}
+
+export function backupRing(): string {
+  return backupRingDirectory(env)
+}
+
+export function backupsAvailable(): BackupCapability {
+  return backupCapability(env)
+}
+
+export function destinationIsFromEnvironment(): boolean {
+  try {
+    return backupDestinationFromEnv(env) !== undefined
+  } catch {
+    return true
+  }
+}
+
+export async function currentBackupSettings(): Promise<BackupSettingsView> {
+  return loadBackupSettings(getDb(), env)
+}
+
+export function destinationFor(settings: BackupSettingsView): BackupDestination | undefined {
+  return backupDestinationFor(settings.destination)
+}
+
+export async function localBundlePath(name: string): Promise<string | null> {
+  if (!isBundleName(name)) return null
+  const file = path.join(backupRing(), name)
+  const info = await stat(file).catch(() => null)
+  return info?.isFile() ? file : null
+}
+
+async function mergedBundles(
+  ring: string,
+  destination: BackupDestination | undefined,
+): Promise<{ readonly bundles: readonly BackupBundleRow[]; readonly listError: string | null }> {
+  const local = await localBundles(ring)
+  const rows = new Map<string, { localSize: number | null; remoteSize: number | null }>()
+  for (const bundle of local) rows.set(bundle.name, { localSize: bundle.size, remoteSize: null })
+
+  let listError: string | null = null
+  if (destination !== undefined) {
+    try {
+      for (const bundle of await destination.list()) {
+        const row = rows.get(bundle.name)
+        if (row === undefined) rows.set(bundle.name, { localSize: null, remoteSize: bundle.size })
+        else rows.set(bundle.name, { ...row, remoteSize: bundle.size })
+      }
+    } catch (error) {
+      listError = error instanceof Error ? error.message : String(error)
+      logger({ module: 'backup' }).warn({ err: listError }, 'could not list the off-site backups')
+    }
+  }
+
+  const bundles = [...rows]
+    .map(([name, sizes]) => ({ name, takenAt: bundleTakenAt(name), ...sizes }))
+    .sort((a, b) => b.name.localeCompare(a.name))
+  return { bundles, listError }
+}
+
+export async function buildBackupAdminView(now: Date): Promise<BackupAdminView | null> {
+  const runs = backupRuns()
+  if (runs === null) return null
+
+  const settings = await currentBackupSettings()
+  const destination = destinationFor(settings)
+  const ring = backupRing()
+
+  const [{ bundles, listError }, recent, active] = await Promise.all([
+    mergedBundles(ring, destination),
+    runs.recent(RECENT_RUNS),
+    runs.active(now, new Date(now.getTime() - BACKUP_STALE_MS)),
+  ])
+
+  return {
+    capability: backupsAvailable(),
+    ring,
+    destination: {
+      source: settings.destination.source,
+      description: destination?.description ?? null,
+      problem: settings.destination.problem,
+      listError,
+    },
+    bundles,
+    runs: recent,
+    active,
+    settings,
+    nextScheduled: nextSlotAfter(settings.schedule, now),
+  }
+}