@meith/web 0.16.0

package/src/server/markdown-pipeline.ts

@@ -0,0 +1,31 @@
+import 'server-only'
+
+import type { MarkdownPipeline } from '@meith/markdown'
+
+import { resolveInlineAttachments } from './attachment-embed'
+import { highlightCodeBlocks } from './code-highlighting'
+import { unfurlEmbeds } from './embeds'
+import { filterView } from './plugin-view'
+
+export const boardRendering: MarkdownPipeline = {
+  text: (text, context) =>
+    filterView('markdown.parse.text', text, { ...context.viewer, source: context.source }),
+
+  html: async (html, context) => {
+    const withAttachments = await resolveInlineAttachments(html, {
+      viewerUserId: context.viewer.userId,
+      postId: context.postId ?? null,
+    })
+    const withEmbeds = await unfurlEmbeds(await highlightCodeBlocks(withAttachments))
+    return filterView('markdown.render.html', withEmbeds, {
+      ...context.viewer,
+      source: context.source,
+    })
+  },
+
+  vocabulary: async (source) => ({
+    revision: source.revision,
+    directives: await filterView('markdown.directives', source.directives, {}),
+    smilies: await filterView('smilies.list', source.smilies, {}),
+  }),
+}

package/src/server/marketplace-actions.ts

@@ -0,0 +1,47 @@
+'use server'
+
+import { revalidatePath } from 'next/cache'
+
+import { isAppError, logger } from '@meith/core'
+
+import { recordAdminAction, requireAdmin } from './admin'
+import type { FormState } from './auth-form-state'
+import { tr } from './i18n'
+import { refreshMarketplaceNow } from './marketplace-admin'
+
+/**
+ * The Browse tab's "Refresh" button. Runs the exact same fetch, validate,
+ * cache, notify pass as the daily task (`refreshMarketplaceNow`, shared with
+ * `packages/runtime`'s task worker) — this is the "on demand" half of that
+ * one behaviour, not a second implementation of it.
+ */
+export async function refreshMarketplaceAction(
+  _prev: FormState,
+  _form: FormData,
+): Promise<FormState> {
+  try {
+    await requireAdmin()
+
+    const result = await refreshMarketplaceNow()
+
+    revalidatePath('/admin/plugins/browse')
+    revalidatePath('/admin/themes/browse')
+
+    await recordAdminAction({
+      action: 'marketplace.refresh',
+      detail: { ok: result.ok, listingCount: result.listingCount },
+    })
+
+    if (result.ok) return { notice: 'refreshed' }
+    return {
+      error: result.errorMessage ?? (await tr('notice.app.something-went-wrong-please-try')),
+    }
+  } catch (err) {
+    if (isAppError(err)) return { error: err.message }
+    logger({ module: 'marketplace-admin' }).error(
+      { err },
+      'failed to refresh the marketplace catalog',
+    )
+    return { error: await tr('notice.app.something-went-wrong-please-try') }
+  }
+}

package/src/server/marketplace-admin.ts

@@ -0,0 +1,260 @@
+import 'server-only'
+
+import { env, logger, readPluginEnv } from '@meith/core'
+import { getDb, PostgresMarketplaceCacheRepository } from '@meith/db'
+import {
+  type CachedMarketplace,
+  computeListingStatus,
+  EMPTY_CACHE,
+  type InstalledEntry,
+  type ListingKind,
+  type ListingStatus,
+  type MarketplaceListing,
+  MEITH_VERSION,
+  PLUGIN_API_MAJOR,
+  refreshCatalog,
+  THEME_API_MAJOR,
+} from '@meith/marketplace'
+
+import { notificationService } from './notifications'
+import { configuredPlugins } from './plugin-host'
+import { getSettings, getSettingsUncached } from './settings'
+import { themeListing } from './theme-admin'
+
+const BUILD_INFO = {
+  meithVersion: MEITH_VERSION,
+  pluginApiMajor: PLUGIN_API_MAJOR,
+  themeApiMajor: THEME_API_MAJOR,
+}
+
+/**
+ * Whether this process is the stock image rather than a graduated custom
+ * board — both run identical @meith/web code, so an env var set only by
+ * docker/Dockerfile is the only signal available: `BOARD_PLUGINS_MANIFEST`,
+ * baked in for `community board:eject` (see apps/cli/src/board-eject.ts). A
+ * graduated board's own scaffolded Dockerfile never sets it. Read fresh
+ * rather than cached at module load, so it is not fixed by whichever test
+ * happens to import this module first.
+ */
+function onStockImage(): boolean {
+  return readPluginEnv('BOARD_PLUGINS_MANIFEST') !== undefined
+}
+
+/** Caps against untrusted feed content — a self-hosted mirror can serve anything. */
+const MAX_NAME_LENGTH = 120
+const MAX_DESCRIPTION_LENGTH = 500
+const MAX_LICENCE_LENGTH = 100
+const MAX_REASON_LENGTH = 300
+
+function truncate(value: string, max: number): string {
+  return value.length > max ? `${value.slice(0, max - 1)}…` : value
+}
+
+/** https only, and a real URL — never rendered as a link otherwise. */
+function safeHttpsUrl(value: string): string | null {
+  try {
+    const url = new URL(value)
+    return url.protocol === 'https:' ? url.toString() : null
+  } catch {
+    return null
+  }
+}
+
+export function marketplaceCacheRepository(): PostgresMarketplaceCacheRepository | null {
+  return env.DATA_SOURCE === 'postgres' ? new PostgresMarketplaceCacheRepository(getDb()) : null
+}
+
+async function readCache(): Promise<CachedMarketplace> {
+  const repository = marketplaceCacheRepository()
+  if (repository === null) return EMPTY_CACHE
+
+  try {
+    return await repository.read()
+  } catch (error) {
+    logger().warn({ err: String(error) }, 'could not read the cached marketplace feed')
+    return EMPTY_CACHE
+  }
+}
+
+export interface MarketplaceListingRow {
+  readonly key: string
+  readonly kind: ListingKind
+  readonly name: string
+  readonly description: string
+  readonly version: string
+  readonly package: string
+  readonly licence: string
+  readonly repositoryUrl: string | null
+  /** Same-origin URLs — the browser never fetches the feed's own host directly. */
+  readonly screenshotHrefs: readonly string[]
+  readonly status: ListingStatus
+  readonly incompatibleReason: string | null
+  readonly installedVersion: string | null
+  /** Set only for 'not-installed': the exact steps this board would need. Never an affordance that acts. */
+  readonly installSteps: readonly string[] | null
+  /**
+   * True only for 'not-installed' on the stock image, where installSteps'
+   * own `community plugin:add`/`community.config.ts` line cannot actually
+   * run — the image is fixed at build time. Signposts
+   * docs/marketplace.md's "Moving to a custom board" walkthrough; never a
+   * claim this board can graduate itself.
+   */
+  readonly onStockImage: boolean
+}
+
+export interface MarketplaceCatalogView {
+  readonly listings: readonly MarketplaceListingRow[]
+  readonly fetchedAt: Date | null
+  /** True once a fetch has ever succeeded — an empty `listings` before that is "not fetched yet", not "empty catalog". */
+  readonly hasEverFetched: boolean
+  readonly unreachable: boolean
+  readonly errorMessage: string | null
+}
+
+function installSteps(kind: ListingKind, packageName: string): readonly string[] {
+  return kind === 'plugin'
+    ? [
+        `pnpm add ${packageName} --filter @meith/web`,
+        `community plugin:add ${packageName}`,
+        'Rebuild and redeploy for it to take effect.',
+      ]
+    : [
+        `pnpm add ${packageName} --filter @meith/web`,
+        'Register it in community.config.ts (and set it as defaultTheme if it should be the board default).',
+        'Rebuild and redeploy for it to take effect.',
+      ]
+}
+
+async function pluginInstalledEntries(): Promise<ReadonlyMap<string, InstalledEntry>> {
+  const map = new Map<string, InstalledEntry>()
+  for (const plugin of configuredPlugins()) {
+    if (!plugin.hasDefinition || plugin.version === null) continue
+    map.set(plugin.key, { enabled: plugin.enabled, version: plugin.version })
+  }
+  return map
+}
+
+async function themeInstalledEntries(): Promise<ReadonlyMap<string, InstalledEntry>> {
+  const map = new Map<string, InstalledEntry>()
+  for (const theme of await themeListing()) {
+    map.set(theme.key, { enabled: theme.enabled, version: null })
+  }
+  return map
+}
+
+function screenshotHref(listingKey: string, index: number): string {
+  return `/admin/api/marketplace/screenshot?key=${encodeURIComponent(listingKey)}&index=${index}`
+}
+
+function toRow(
+  listing: MarketplaceListing,
+  installed: InstalledEntry | null,
+): MarketplaceListingRow {
+  const { status, incompatibleReason } = computeListingStatus({ ...listing, installed }, BUILD_INFO)
+
+  return {
+    key: listing.key,
+    kind: listing.kind,
+    name: truncate(listing.name, MAX_NAME_LENGTH),
+    description: truncate(listing.description, MAX_DESCRIPTION_LENGTH),
+    version: listing.version,
+    package: listing.package,
+    licence: truncate(listing.licence, MAX_LICENCE_LENGTH),
+    repositoryUrl: safeHttpsUrl(listing.repository),
+    screenshotHrefs: listing.screenshots.map((_, index) => screenshotHref(listing.key, index)),
+    status,
+    incompatibleReason:
+      incompatibleReason === null ? null : truncate(incompatibleReason, MAX_REASON_LENGTH),
+    installedVersion: installed?.version ?? null,
+    installSteps: status === 'not-installed' ? installSteps(listing.kind, listing.package) : null,
+    onStockImage: status === 'not-installed' && onStockImage(),
+  }
+}
+
+/**
+ * The Browse tab's whole read model for one kind — reads the cached feed
+ * only (never the network) and computes status against what this build
+ * actually contains. Renders honestly when the cache is empty: `listings`
+ * is `[]` either way, and `hasEverFetched`/`unreachable` say why.
+ */
+export async function marketplaceCatalog(kind: ListingKind): Promise<MarketplaceCatalogView> {
+  const cache = await readCache()
+  const installed =
+    kind === 'plugin' ? await pluginInstalledEntries() : await themeInstalledEntries()
+
+  const listings = (cache.feed?.listings ?? [])
+    .filter((listing) => listing.kind === kind)
+    .map((listing) => toRow(listing, installed.get(listing.key) ?? null))
+
+  return {
+    listings,
+    fetchedAt: cache.fetchedAt,
+    hasEverFetched: cache.fetchedAt !== null,
+    unreachable: cache.error !== null,
+    errorMessage: cache.error,
+  }
+}
+
+/** One listing's screenshot, resolved against the feed's own host — never a client-supplied URL. */
+export async function marketplaceScreenshotUrl(key: string, index: number): Promise<string | null> {
+  const cache = await readCache()
+  if (cache.feed === null || cache.sourceUrl === null) return null
+
+  const listing = cache.feed.listings.find((entry) => entry.key === key)
+  const path = listing?.screenshots[index]
+  if (path === undefined) return null
+
+  try {
+    return new URL(path, cache.sourceUrl).toString()
+  } catch {
+    return null
+  }
+}
+
+/**
+ * Runs the same fetch, validate, cache, notify pass the daily task does — the
+ * admin panel's "Refresh" button and the task call the exact same function,
+ * per docs/marketplace.md.
+ */
+export async function refreshMarketplaceNow(): Promise<{
+  readonly ok: boolean
+  readonly listingCount: number
+  readonly errorMessage: string | null
+}> {
+  const repository = marketplaceCacheRepository()
+  if (repository === null) {
+    return { ok: false, listingCount: 0, errorMessage: 'This board is running in fixture mode.' }
+  }
+
+  const url = (await getSettingsUncached()).get('marketplace.feed_url')
+  const pluginEntries = await pluginInstalledEntries()
+  const notifications = notificationService()
+
+  const result = await refreshCatalog({
+    url,
+    repository,
+    build: BUILD_INFO,
+    resolveInstalled: (listing) =>
+      listing.kind === 'plugin' ? (pluginEntries.get(listing.key) ?? null) : null,
+    notifyUpdate: async (listing) => {
+      if (notifications === null) return
+      await notifications.raiseForAdministrators({
+        kind: 'marketplace.update_available',
+        data: {
+          key: listing.key,
+          name: listing.name,
+          package: listing.package,
+          version: listing.version,
+        },
+        href: '/admin/plugins/browse',
+        dedupeKey: `marketplace.update_available:${listing.key}:${listing.version}`,
+      })
+    },
+  })
+
+  return { ok: result.ok, listingCount: result.listingCount, errorMessage: result.error }
+}
+
+export async function currentFeedUrl(): Promise<string> {
+  return (await getSettings()).get('marketplace.feed_url')
+}

package/src/server/mention-actions.ts

@@ -0,0 +1,21 @@
+'use server'
+
+import type { MemberSuggestion } from '@meith/accounts'
+
+import { getContainer } from './container'
+import { getActor } from './context'
+import { searchMentionCandidates } from './mention-search'
+import { relationService } from './relations'
+
+export async function searchMentionCandidatesAction(
+  query: string,
+): Promise<readonly MemberSuggestion[]> {
+  const actor = await getActor()
+  const { authorizer, memberProfiles } = getContainer()
+
+  return searchMentionCandidates(actor, typeof query === 'string' ? query : '', {
+    authorizer,
+    memberProfiles,
+    relations: relationService(),
+  })
+}

package/src/server/mention-search.ts

@@ -0,0 +1,35 @@
+import type { MemberProfileRepository, MemberSuggestion } from '@meith/accounts'
+import type { Actor, Authorizer } from '@meith/authorization'
+import type { RelationService } from '@meith/relations'
+
+const MIN_QUERY_LENGTH = 1
+const MAX_QUERY_LENGTH = 32
+const SUGGESTION_LIMIT = 8
+
+export interface MentionSearchDeps {
+  readonly authorizer: Authorizer
+  readonly memberProfiles: MemberProfileRepository
+  readonly relations: RelationService | null
+}
+
+export async function searchMentionCandidates(
+  actor: Actor,
+  rawQuery: string,
+  deps: MentionSearchDeps,
+): Promise<readonly MemberSuggestion[]> {
+  const query = rawQuery.trim()
+  if (query.length < MIN_QUERY_LENGTH || query.length > MAX_QUERY_LENGTH) return []
+  if (!deps.authorizer.can(actor, 'profile.view')) return []
+
+  const [matches, ignored] = await Promise.all([
+    deps.memberProfiles.searchByUsernamePrefix(query, SUGGESTION_LIMIT * 2),
+    actor.userId === null || deps.relations === null
+      ? Promise.resolve<readonly number[]>([])
+      : deps.relations.ignoredIds(actor.userId),
+  ])
+
+  if (ignored.length === 0) return matches.slice(0, SUGGESTION_LIMIT)
+
+  const ignoredIds = new Set(ignored)
+  return matches.filter((candidate) => !ignoredIds.has(candidate.id)).slice(0, SUGGESTION_LIMIT)
+}

package/src/server/message-actions.ts

@@ -0,0 +1,110 @@
+'use server'
+
+import { redirect } from 'next/navigation'
+
+import { ValidationError } from '@meith/core'
+import { msg } from '@meith/i18n'
+import { parseFolder } from '@meith/messages'
+
+import { folderHref } from '../view/messages'
+import { dailyLimitMessage, limitMessage, spendDailyLimit, spendLimit } from './antispam'
+import type { FormState } from './auth-form-state'
+import { getActor } from './context'
+import { formStateReporter } from './form-state-reporter'
+import { text } from './form-values'
+import { requireMessaging } from './messages'
+
+const toFormState = formStateReporter('message-actions', 'unexpected error in a message action')
+
+export async function sendMessageAction(_prev: FormState, form: FormData): Promise<FormState> {
+  const values = {
+    to: text(form, 'to'),
+    bcc: text(form, 'bcc'),
+    subject: text(form, 'subject'),
+    message: text(form, 'message'),
+  }
+
+  try {
+    const actor = await getActor()
+    const { service, userId, username } = await requireMessaging(actor)
+
+    const limited = await spendLimit({ scope: 'message', actor })
+    if (limited !== null && !limited.allowed) {
+      return { error: limitMessage(limited), values }
+    }
+
+    const daily = await spendDailyLimit({ scope: 'message_day', actor })
+    if (daily !== null && !daily.allowed) {
+      return { error: dailyLimitMessage('message_day', daily), values }
+    }
+
+    const replyTo = Number(text(form, 'replyTo'))
+    await service.send({
+      authorUserId: userId,
+      authorUsername: username,
+      to: values.to,
+      bcc: values.bcc,
+      subject: values.subject,
+      message: values.message,
+      receiptRequested: form.get('receipt') === 'on',
+      replyToId: Number.isInteger(replyTo) && replyTo > 0 ? replyTo : null,
+    })
+  } catch (err) {
+    return toFormState(err, values)
+  }
+
+  redirect('/messages?folder=sent&sent=1')
+}
+
+export async function messageBulkAction(_prev: FormState, form: FormData): Promise<FormState> {
+  const folder = parseFolder(text(form, 'folder')) ?? 'inbox'
+  const command = text(form, 'command')
+
+  let query: string
+  try {
+    const { service, userId } = await requireMessaging(await getActor())
+
+    if (command === 'empty') {
+      query = `emptied=${await service.emptyTrash(userId)}`
+    } else {
+      const copyIds = selectedIds(form)
+      if (copyIds.length === 0)
+        throw new ValidationError(msg('error.app.select-at-least-one-message'))
+
+      switch (command) {
+        case 'read':
+          query = `marked=${await service.markRead(userId, copyIds)}`
+          break
+        case 'unread':
+          query = `marked=${await service.markUnread(userId, copyIds)}`
+          break
+        case 'trash':
+          query = `moved=${await service.move(userId, copyIds, 'trash')}`
+          break
+        case 'restore':
+          query = `moved=${await service.move(userId, copyIds, 'inbox')}`
+          break
+        case 'delete':
+          query = `deleted=${await service.remove(userId, copyIds)}`
+          break
+        default:
+          throw new ValidationError(msg('error.app.something-message'))
+      }
+    }
+  } catch (err) {
+    return toFormState(err)
+  }
+
+  const base = folderHref(folder)
+  redirect(`${base}${base.includes('?') ? '&' : '?'}${query}`)
+}
+
+function selectedIds(form: FormData): readonly number[] {
+  const ids: number[] = []
+  for (const value of form.getAll('copyId')) {
+    if (typeof value !== 'string') continue
+    const id = Number(value)
+    if (Number.isInteger(id) && id > 0) ids.push(id)
+  }
+  return ids
+}

package/src/server/messages.ts

@@ -0,0 +1,141 @@
+import 'server-only'
+
+import { cache } from 'react'
+
+import type { Actor } from '@meith/authorization'
+import { ForbiddenError } from '@meith/core'
+import { currentRequestId } from '@meith/core/logger'
+import { msg } from '@meith/i18n'
+import { EMPTY_VOCABULARY } from '@meith/markdown'
+import {
+  type MessageAudit,
+  type MessageNotifierPort,
+  type MessagePolicy,
+  MessageService,
+} from '@meith/messages'
+
+import { getContainer } from './container'
+import { activeVocabulary } from './content-admin'
+import { boardRendering } from './markdown-pipeline'
+import { notificationService } from './notifications'
+import { emitEvent, filterView } from './plugin-view'
+import { relationService } from './relations'
+
+const PLUGIN_AUDIT: MessageAudit = {
+  before: (input) => filterView('pm.send.before', input, { requestId: currentRequestId() ?? null }),
+
+  sent: (input) => emitEvent('pm.sent', input, { requestId: currentRequestId() ?? null }),
+}
+
+export function messageService(): MessageService | null {
+  const { messages } = getContainer()
+  if (messages === null) return null
+
+  return new MessageService({
+    messages,
+    policy: messagePolicy(),
+    notifier: messageNotifier(),
+    vocabulary: async () => (await activeVocabulary()) ?? EMPTY_VOCABULARY,
+    rendering: boardRendering,
+    audit: PLUGIN_AUDIT,
+  })
+}
+
+export interface Messaging {
+  readonly service: MessageService
+  readonly userId: number
+  readonly username: string
+}
+
+export async function requireMessaging(actor: Actor): Promise<Messaging> {
+  const { authorizer, accountStore } = getContainer()
+
+  if (actor.userId === null) throw new ForbiddenError(msg('error.app.must-logged'))
+  if (!authorizer.can(actor, 'pm.use')) {
+    throw new ForbiddenError(msg('error.app.use-private-messages'))
+  }
+
+  const service = messageService()
+  if (service === null) {
+    throw new ForbiddenError(msg('error.app.board-running-in-memory-sample-data-21'))
+  }
+
+  const account = await accountStore.accounts.findById(actor.userId)
+  if (account === null) throw new ForbiddenError(msg('error.app.must-logged'))
+
+  return { service, userId: actor.userId, username: account.username }
+}
+
+export function messagePolicy(): MessagePolicy {
+  const { accountStore, actorSource, authorizer } = getContainer()
+
+  return {
+    async lookup(username) {
+      const { foldIdentifier } = await import('@meith/accounts')
+      const account = await accountStore.accounts.findByUsernameLower(foldIdentifier(username))
+      if (account === null) return null
+      return { id: account.id, username: account.username }
+    },
+
+    async limitsFor(userId) {
+      const actor = await actorSource.buildForUser(userId)
+      if (actor === null) return { quota: 0, canReceive: false }
+
+      return {
+        canReceive: authorizer.can(actor, 'pm.use'),
+        quota: authorizer.globalLimit(actor, 'privateMessageQuota'),
+      }
+    },
+
+    async blocks(ownerUserId, senderUserId) {
+      const service = relationService()
+      if (service === null) return false
+
+      try {
+        return await service.ignores(ownerUserId, senderUserId)
+      } catch {
+        return true
+      }
+    },
+  }
+}
+
+export function messageNotifier(): MessageNotifierPort | null {
+  const service = notificationService()
+  if (service === null) return null
+
+  return {
+    async messageReceived(input) {
+      await service.raise({
+        userId: input.userId,
+        kind: 'pm.received',
+        data: { fromUsername: input.fromUsername, subject: input.subject },
+        href: `/messages/${input.messageId}`,
+      })
+    },
+
+    async receiptRead(input) {
+      await service.raise({
+        userId: input.userId,
+        kind: 'pm.receipt',
+        data: { byUsername: input.byUsername, subject: input.subject },
+        dedupeKey: `pm.receipt:${input.messageId}`,
+        href: `/messages/${input.messageId}`,
+      })
+    },
+  }
+}
+
+export const unreadMessageCount = cache(async function unreadMessageCount(
+  userId: number | null,
+): Promise<number> {
+  if (userId === null) return 0
+  const service = messageService()
+  if (service === null) return 0
+
+  try {
+    return (await service.counts(userId)).unread
+  } catch {
+    return 0
+  }
+})