@atproto/ozone 0.0.2

package/src/api/admin/queryModerationStatuses.ts

@@ -0,0 +1,57 @@
+import { Server } from '../../lexicon'
+import AppContext from '../../context'
+import { getReviewState } from '../moderation/util'
+
+export default function (server: Server, ctx: AppContext) {
+  server.com.atproto.admin.queryModerationStatuses({
+    auth: ctx.roleVerifier,
+    handler: async ({ params }) => {
+      const {
+        subject,
+        takendown,
+        appealed,
+        reviewState,
+        reviewedAfter,
+        reviewedBefore,
+        reportedAfter,
+        reportedBefore,
+        ignoreSubjects,
+        lastReviewedBy,
+        sortDirection = 'desc',
+        sortField = 'lastReportedAt',
+        includeMuted = false,
+        limit = 50,
+        cursor,
+      } = params
+      const db = ctx.db
+      const modService = ctx.modService(db)
+      const results = await modService.getSubjectStatuses({
+        reviewState: getReviewState(reviewState),
+        subject,
+        takendown,
+        appealed,
+        reviewedAfter,
+        reviewedBefore,
+        reportedAfter,
+        reportedBefore,
+        includeMuted,
+        ignoreSubjects,
+        sortDirection,
+        lastReviewedBy,
+        sortField,
+        limit,
+        cursor,
+      })
+      const subjectStatuses = results.statuses.map((status) =>
+        modService.views.formatSubjectStatus(status),
+      )
+      return {
+        encoding: 'application/json',
+        body: {
+          cursor: results.cursor,
+          subjectStatuses,
+        },
+      }
+    },
+  })
+}

package/src/api/admin/searchRepos.ts

@@ -0,0 +1,42 @@
+import { Server } from '../../lexicon'
+import AppContext from '../../context'
+import { mapDefined } from '@atproto/common'
+
+export default function (server: Server, ctx: AppContext) {
+  server.com.atproto.admin.searchRepos({
+    auth: ctx.roleVerifier,
+    handler: async ({ params }) => {
+      const modService = ctx.modService(ctx.db)
+
+      // prefer new 'q' query param over deprecated 'term'
+      const query = params.q ?? params.term
+
+      // special case for did searches - do exact match
+      if (query?.startsWith('did:')) {
+        const repos = await modService.views.repos([query])
+        const found = repos.get(query)
+        return {
+          encoding: 'application/json',
+          body: {
+            repos: found ? [found] : [],
+          },
+        }
+      }
+
+      const res = await ctx.appviewAgent.api.app.bsky.actor.searchActors(params)
+      const repoMap = await modService.views.repos(
+        res.data.actors.map((a) => a.did),
+      )
+      const repos = mapDefined(res.data.actors, (actor) =>
+        repoMap.get(actor.did),
+      )
+      return {
+        encoding: 'application/json',
+        body: {
+          cursor: res.data.cursor,
+          repos,
+        },
+      }
+    },
+  })
+}

package/src/api/admin/util.ts

@@ -0,0 +1,54 @@
+import AppContext from '../../context'
+import {
+  RepoView,
+  RepoViewDetail,
+  AccountView,
+} from '../../lexicon/types/com/atproto/admin/defs'
+
+export const getPdsAccountInfo = async (
+  ctx: AppContext,
+  did: string,
+): Promise<AccountView | null> => {
+  const agent = ctx.pdsAgent
+  if (!agent) return null
+  const auth = await ctx.pdsAuth()
+  if (!auth) return null
+  try {
+    const res = await agent.api.com.atproto.admin.getAccountInfo({ did }, auth)
+    return res.data
+  } catch (err) {
+    return null
+  }
+}
+
+export const addAccountInfoToRepoViewDetail = (
+  repoView: RepoViewDetail,
+  accountInfo: AccountView | null,
+  includeEmail = false,
+): RepoViewDetail => {
+  if (!accountInfo) return repoView
+  return {
+    ...repoView,
+    email: includeEmail ? accountInfo.email : undefined,
+    invitedBy: accountInfo.invitedBy,
+    invitesDisabled: accountInfo.invitesDisabled,
+    inviteNote: accountInfo.inviteNote,
+    invites: accountInfo.invites,
+    emailConfirmedAt: accountInfo.emailConfirmedAt,
+  }
+}
+
+export const addAccountInfoToRepoView = (
+  repoView: RepoView,
+  accountInfo: AccountView | null,
+  includeEmail = false,
+): RepoView => {
+  if (!accountInfo) return repoView
+  return {
+    ...repoView,
+    email: includeEmail ? accountInfo.email : undefined,
+    invitedBy: accountInfo.invitedBy,
+    invitesDisabled: accountInfo.invitesDisabled,
+    inviteNote: accountInfo.inviteNote,
+  }
+}

package/src/api/health.ts

@@ -0,0 +1,20 @@
+import express from 'express'
+import { sql } from 'kysely'
+import AppContext from '../context'
+
+export const createRouter = (ctx: AppContext): express.Router => {
+  const router = express.Router()
+
+  router.get('/xrpc/_health', async function (req, res) {
+    const { version } = ctx.cfg.service
+    try {
+      await sql`select 1`.execute(ctx.db.db)
+    } catch (err) {
+      req.log.error(err, 'failed health check')
+      return res.status(503).send({ version, error: 'Service Unavailable' })
+    }
+    res.send({ version })
+  })
+
+  return router
+}

package/src/api/index.ts

@@ -0,0 +1,28 @@
+import { Server } from '../lexicon'
+import AppContext from '../context'
+import createReport from './moderation/createReport'
+import emitModerationEvent from './admin/emitModerationEvent'
+import searchRepos from './admin/searchRepos'
+import adminGetRecord from './admin/getRecord'
+import getRepo from './admin/getRepo'
+import queryModerationStatuses from './admin/queryModerationStatuses'
+import queryModerationEvents from './admin/queryModerationEvents'
+import getModerationEvent from './admin/getModerationEvent'
+import fetchLabels from './temp/fetchLabels'
+
+export * as health from './health'
+
+export * as wellKnown from './well-known'
+
+export default function (server: Server, ctx: AppContext) {
+  createReport(server, ctx)
+  emitModerationEvent(server, ctx)
+  searchRepos(server, ctx)
+  adminGetRecord(server, ctx)
+  getRepo(server, ctx)
+  getModerationEvent(server, ctx)
+  queryModerationEvents(server, ctx)
+  queryModerationStatuses(server, ctx)
+  fetchLabels(server, ctx)
+  return server
+}

package/src/api/moderation/createReport.ts

@@ -0,0 +1,41 @@
+import { Server } from '../../lexicon'
+import AppContext from '../../context'
+import { getReasonType } from './util'
+import { subjectFromInput } from '../../mod-service/subject'
+import { REASONAPPEAL } from '../../lexicon/types/com/atproto/moderation/defs'
+import { ForbiddenError } from '@atproto/xrpc-server'
+
+export default function (server: Server, ctx: AppContext) {
+  server.com.atproto.moderation.createReport({
+    // @TODO anonymous reports w/ optional auth are a temporary measure
+    auth: ctx.authOptionalAccessOrRoleVerifier,
+    handler: async ({ input, auth }) => {
+      const requester =
+        'did' in auth.credentials ? auth.credentials.did : ctx.cfg.service.did
+      const { reasonType, reason } = input.body
+      const subject = subjectFromInput(input.body.subject)
+
+      // If the report is an appeal, the requester must be the author of the subject
+      if (reasonType === REASONAPPEAL && requester !== subject.did) {
+        throw new ForbiddenError('You cannot appeal this report')
+      }
+
+      const db = ctx.db
+      const report = await db.transaction(async (dbTxn) => {
+        const moderationTxn = ctx.modService(dbTxn)
+        return moderationTxn.report({
+          reasonType: getReasonType(reasonType),
+          reason,
+          subject,
+          reportedBy: requester || ctx.cfg.service.did,
+        })
+      })
+
+      const body = ctx.modService(db).views.formatReport(report)
+      return {
+        encoding: 'application/json',
+        body,
+      }
+    },
+  })
+}

package/src/api/moderation/util.ts

@@ -0,0 +1,65 @@
+import { InvalidRequestError } from '@atproto/xrpc-server'
+import { InputSchema as ReportInput } from '../../lexicon/types/com/atproto/moderation/createReport'
+import {
+  REASONOTHER,
+  REASONSPAM,
+  REASONMISLEADING,
+  REASONRUDE,
+  REASONSEXUAL,
+  REASONVIOLATION,
+  REASONAPPEAL,
+} from '../../lexicon/types/com/atproto/moderation/defs'
+import {
+  REVIEWCLOSED,
+  REVIEWESCALATED,
+  REVIEWOPEN,
+} from '../../lexicon/types/com/atproto/admin/defs'
+import { ModerationEvent } from '../../db/schema/moderation_event'
+import { ModerationSubjectStatusRow } from '../../mod-service/types'
+
+export const getReasonType = (reasonType: ReportInput['reasonType']) => {
+  if (reasonTypes.has(reasonType)) {
+    return reasonType as NonNullable<ModerationEvent['meta']>['reportType']
+  }
+  throw new InvalidRequestError('Invalid reason type')
+}
+
+export const getEventType = (type: string) => {
+  if (eventTypes.has(type)) {
+    return type as ModerationEvent['action']
+  }
+  throw new InvalidRequestError('Invalid event type')
+}
+
+export const getReviewState = (reviewState?: string) => {
+  if (!reviewState) return undefined
+  if (reviewStates.has(reviewState)) {
+    return reviewState as ModerationSubjectStatusRow['reviewState']
+  }
+  throw new InvalidRequestError('Invalid review state')
+}
+
+const reviewStates = new Set([REVIEWCLOSED, REVIEWESCALATED, REVIEWOPEN])
+
+const reasonTypes = new Set([
+  REASONOTHER,
+  REASONSPAM,
+  REASONMISLEADING,
+  REASONRUDE,
+  REASONSEXUAL,
+  REASONVIOLATION,
+  REASONAPPEAL,
+])
+
+const eventTypes = new Set([
+  'com.atproto.admin.defs#modEventTakedown',
+  'com.atproto.admin.defs#modEventAcknowledge',
+  'com.atproto.admin.defs#modEventEscalate',
+  'com.atproto.admin.defs#modEventComment',
+  'com.atproto.admin.defs#modEventLabel',
+  'com.atproto.admin.defs#modEventReport',
+  'com.atproto.admin.defs#modEventMute',
+  'com.atproto.admin.defs#modEventUnmute',
+  'com.atproto.admin.defs#modEventReverseTakedown',
+  'com.atproto.admin.defs#modEventEmail',
+])

package/src/api/temp/fetchLabels.ts

@@ -0,0 +1,29 @@
+import { Server } from '../../lexicon'
+import AppContext from '../../context'
+
+export default function (server: Server, ctx: AppContext) {
+  server.com.atproto.temp.fetchLabels(async ({ params }) => {
+    const { limit } = params
+    const since =
+      params.since !== undefined ? new Date(params.since).toISOString() : ''
+    const labelRes = await ctx.db.db
+      .selectFrom('label')
+      .selectAll()
+      .orderBy('label.cts', 'asc')
+      .where('cts', '>', since)
+      .limit(limit)
+      .execute()
+
+    const labels = labelRes.map((l) => ({
+      ...l,
+      cid: l.cid === '' ? undefined : l.cid,
+    }))
+
+    return {
+      encoding: 'application/json',
+      body: {
+        labels,
+      },
+    }
+  })
+}

package/src/api/well-known.ts

@@ -0,0 +1,35 @@
+import express from 'express'
+import AppContext from '../context'
+
+export const createRouter = (ctx: AppContext): express.Router => {
+  const router = express.Router()
+
+  router.get('/.well-known/did.json', (_req, res) => {
+    const hostname =
+      ctx.cfg.service.publicUrl && new URL(ctx.cfg.service.publicUrl).hostname
+    if (!hostname || ctx.cfg.service.did !== `did:web:${hostname}`) {
+      return res.sendStatus(404)
+    }
+    res.json({
+      '@context': ['https://www.w3.org/ns/did/v1'],
+      id: ctx.cfg.service.did,
+      verificationMethod: [
+        {
+          id: `${ctx.cfg.service.did}#atproto`,
+          type: 'Multikey',
+          controller: ctx.cfg.service.did,
+          publicKeyMultibase: ctx.signingKey.did().replace('did:key:', ''),
+        },
+      ],
+      service: [
+        {
+          id: '#atproto_mod',
+          type: 'AtprotoModerationService',
+          serviceEndpoint: `https://${hostname}`,
+        },
+      ],
+    })
+  })
+
+  return router
+}

package/src/auth.ts

@@ -0,0 +1,147 @@
+import express from 'express'
+import * as uint8arrays from 'uint8arrays'
+import { AuthRequiredError, verifyJwt } from '@atproto/xrpc-server'
+import { IdResolver } from '@atproto/identity'
+import { OzoneSecrets } from './config'
+
+const BASIC = 'Basic '
+const BEARER = 'Bearer '
+
+export const authVerifier = (
+  idResolver: IdResolver,
+  opts: { aud: string | null },
+) => {
+  const getSigningKey = async (
+    did: string,
+    forceRefresh: boolean,
+  ): Promise<string> => {
+    const atprotoData = await idResolver.did.resolveAtprotoData(
+      did,
+      forceRefresh,
+    )
+    return atprotoData.signingKey
+  }
+
+  return async (reqCtx: { req: express.Request; res: express.Response }) => {
+    const jwtStr = getJwtStrFromReq(reqCtx.req)
+    if (!jwtStr) {
+      throw new AuthRequiredError('missing jwt', 'MissingJwt')
+    }
+    const payload = await verifyJwt(jwtStr, opts.aud, getSigningKey)
+    return { credentials: { did: payload.iss }, artifacts: { aud: opts.aud } }
+  }
+}
+
+export const authOptionalVerifier = (
+  idResolver: IdResolver,
+  opts: { aud: string | null },
+) => {
+  const verifyAccess = authVerifier(idResolver, opts)
+  return async (reqCtx: { req: express.Request; res: express.Response }) => {
+    if (!reqCtx.req.headers.authorization) {
+      return { credentials: { did: null } }
+    }
+    return verifyAccess(reqCtx)
+  }
+}
+
+export const authOptionalAccessOrRoleVerifier = (
+  idResolver: IdResolver,
+  secrets: OzoneSecrets,
+  serverDid: string,
+) => {
+  const verifyAccess = authVerifier(idResolver, { aud: serverDid })
+  const verifyRole = roleVerifier(secrets)
+  return async (ctx: { req: express.Request; res: express.Response }) => {
+    const defaultUnAuthorizedCredentials = {
+      credentials: { did: null, type: 'unauthed' as const },
+    }
+    if (!ctx.req.headers.authorization) {
+      return defaultUnAuthorizedCredentials
+    }
+    // For non-admin tokens, we don't want to consider alternative verifiers and let it fail if it fails
+    const isRoleAuthToken = ctx.req.headers.authorization?.startsWith(BASIC)
+    if (isRoleAuthToken) {
+      const result = await verifyRole(ctx)
+      return {
+        ...result,
+        credentials: {
+          type: 'role' as const,
+          ...result.credentials,
+        },
+      }
+    }
+    const result = await verifyAccess(ctx)
+    return {
+      ...result,
+      credentials: {
+        type: 'access' as const,
+        ...result.credentials,
+      },
+    }
+  }
+}
+
+export const roleVerifier =
+  (secrets: OzoneSecrets) =>
+  async (reqCtx: { req: express.Request; res: express.Response }) => {
+    const credentials = getRoleCredentials(secrets, reqCtx.req)
+    if (!credentials.valid) {
+      throw new AuthRequiredError()
+    }
+    return { credentials }
+  }
+
+export const getRoleCredentials = (
+  secrets: OzoneSecrets,
+  req: express.Request,
+) => {
+  const parsed = parseBasicAuth(req.headers.authorization || '')
+  const { username, password } = parsed ?? {}
+  if (username === 'admin' && password === secrets.triagePassword) {
+    return { valid: true, admin: false, moderator: false, triage: true }
+  }
+  if (username === 'admin' && password === secrets.moderatorPassword) {
+    return { valid: true, admin: false, moderator: true, triage: true }
+  }
+  if (username === 'admin' && password === secrets.adminPassword) {
+    return { valid: true, admin: true, moderator: true, triage: true }
+  }
+  return { valid: false, admin: false, moderator: false, triage: false }
+}
+
+export const parseBasicAuth = (
+  token: string,
+): { username: string; password: string } | null => {
+  if (!token.startsWith(BASIC)) return null
+  const b64 = token.slice(BASIC.length)
+  let parsed: string[]
+  try {
+    parsed = uint8arrays
+      .toString(uint8arrays.fromString(b64, 'base64pad'), 'utf8')
+      .split(':')
+  } catch (err) {
+    return null
+  }
+  const [username, password] = parsed
+  if (!username || !password) return null
+  return { username, password }
+}
+
+export const buildBasicAuth = (username: string, password: string): string => {
+  return (
+    BASIC +
+    uint8arrays.toString(
+      uint8arrays.fromString(`${username}:${password}`, 'utf8'),
+      'base64pad',
+    )
+  )
+}
+
+export const getJwtStrFromReq = (req: express.Request): string | null => {
+  const { authorization } = req.headers
+  if (!authorization?.startsWith(BEARER)) {
+    return null
+  }
+  return authorization.slice(BEARER.length).trim()
+}

package/src/background.ts

@@ -0,0 +1,35 @@
+import PQueue from 'p-queue'
+import { Database } from './db'
+import { dbLogger } from './logger'
+
+// A simple queue for in-process, out-of-band/backgrounded work
+
+export class BackgroundQueue {
+  queue = new PQueue({ concurrency: 20 })
+  destroyed = false
+  constructor(public db: Database) {}
+
+  add(task: Task) {
+    if (this.destroyed) {
+      return
+    }
+    this.queue
+      .add(() => task(this.db))
+      .catch((err) => {
+        dbLogger.error(err, 'background queue task failed')
+      })
+  }
+
+  async processAll() {
+    await this.queue.onIdle()
+  }
+
+  // On destroy we stop accepting new tasks, but complete all pending/in-progress tasks.
+  // The application calls this only once http connections have drained (tasks no longer being added).
+  async destroy() {
+    this.destroyed = true
+    await this.queue.onIdle()
+  }
+}
+
+type Task = (db: Database) => Promise<void>

package/src/config/config.ts

@@ -0,0 +1,84 @@
+import assert from 'node:assert'
+import { OzoneEnvironment } from './env'
+
+// off-config but still from env:
+// logging: LOG_LEVEL, LOG_SYSTEMS, LOG_ENABLED, LOG_DESTINATION
+
+export const envToCfg = (env: OzoneEnvironment): OzoneConfig => {
+  const port = env.port ?? 3000
+  assert(env.publicUrl)
+  assert(env.serverDid)
+  const serviceCfg: OzoneConfig['service'] = {
+    port,
+    publicUrl: env.publicUrl,
+    did: env.serverDid,
+    version: env.version,
+  }
+
+  assert(env.dbPostgresUrl)
+  const dbCfg: OzoneConfig['db'] = {
+    postgresUrl: env.dbPostgresUrl,
+    postgresSchema: env.dbPostgresSchema,
+  }
+
+  assert(env.appviewUrl)
+  assert(env.appviewDid)
+  const appviewCfg: OzoneConfig['appview'] = {
+    url: env.appviewUrl,
+    did: env.appviewDid,
+  }
+
+  assert(env.pdsUrl)
+  assert(env.pdsDid)
+  const pdsCfg: OzoneConfig['pds'] = {
+    url: env.pdsUrl,
+    did: env.pdsDid,
+  }
+
+  assert(env.didPlcUrl)
+  const identityCfg: OzoneConfig['identity'] = {
+    plcUrl: env.didPlcUrl,
+  }
+
+  return {
+    service: serviceCfg,
+    db: dbCfg,
+    appview: appviewCfg,
+    pds: pdsCfg,
+    identity: identityCfg,
+  }
+}
+
+export type OzoneConfig = {
+  service: ServiceConfig
+  db: DatabaseConfig
+  appview: AppviewConfig
+  pds: PdsConfig | null
+  identity: IdentityConfig
+}
+
+export type ServiceConfig = {
+  port: number
+  publicUrl: string
+  did: string
+  version?: string
+}
+
+export type DatabaseConfig = {
+  postgresUrl: string
+  postgresSchema?: string
+}
+
+export type AppviewConfig = {
+  url: string
+  did: string
+}
+
+export type PdsConfig = {
+  url: string
+  did: string
+}
+
+export type IdentityConfig = {
+  plcUrl: string
+}

package/src/config/env.ts

@@ -0,0 +1,41 @@
+import { envInt, envStr } from '@atproto/common'
+
+export const readEnv = (): OzoneEnvironment => {
+  return {
+    nodeEnv: envStr('NODE_ENV'),
+    version: envStr('OZONE_VERSION'),
+    port: envInt('OZONE_PORT'),
+    publicUrl: envStr('OZONE_PUBLIC_URL'),
+    serverDid: envStr('OZONE_SERVER_DID'),
+    appviewUrl: envStr('OZONE_APPVIEW_URL'),
+    appviewDid: envStr('OZONE_APPVIEW_DID'),
+    pdsUrl: envStr('OZONE_PDS_URL'),
+    pdsDid: envStr('OZONE_PDS_DID'),
+    dbPostgresUrl: envStr('OZONE_DB_POSTGRES_URL'),
+    dbPostgresSchema: envStr('OZONE_DB_POSTGRES_SCHEMA'),
+    didPlcUrl: envStr('OZONE_DID_PLC_URL'),
+    adminPassword: envStr('OZONE_ADMIN_PASSWORD'),
+    moderatorPassword: envStr('OZONE_MODERATOR_PASSWORD'),
+    triagePassword: envStr('OZONE_TRIAGE_PASSWORD'),
+    signingKeyHex: envStr('OZONE_SIGNING_KEY_HEX'),
+  }
+}
+
+export type OzoneEnvironment = {
+  nodeEnv?: string
+  version?: string
+  port?: number
+  publicUrl?: string
+  serverDid?: string
+  appviewUrl?: string
+  appviewDid?: string
+  pdsUrl?: string
+  pdsDid?: string
+  dbPostgresUrl?: string
+  dbPostgresSchema?: string
+  didPlcUrl?: string
+  adminPassword?: string
+  moderatorPassword?: string
+  triagePassword?: string
+  signingKeyHex?: string
+}

package/src/config/index.ts

@@ -0,0 +1,3 @@
+export * from './config'
+export * from './env'
+export * from './secrets'