@atproto/ozone 0.1.173 → 0.1.174

package/src/api/moderation/emitEvent.ts

@@ -26,6 +26,7 @@ import {
 } from '../../lexicon/types/tools/ozone/moderation/defs'
 import { HandlerInput } from '../../lexicon/types/tools/ozone/moderation/emitEvent'
 import { httpLogger } from '../../logger'
+import { processReportAction } from '../../mod-service/report'
 import { subjectFromInput } from '../../mod-service/subject'
 import { SettingService } from '../../setting/service'
 import { TagService } from '../../tag-service'
@@ -240,6 +241,21 @@ const handleModerationEvent = async ({
       }
     }
 
+    // Validate reportAction if provided (actual processing happens after event is logged)
+    if (input.body.reportAction) {
+      // Validate that at least one targeting criteria is provided
+      const { reportAction } = input.body
+      if (
+        !reportAction.ids?.length &&
+        !reportAction.types?.length &&
+        !reportAction.all
+      ) {
+        throw new InvalidRequestError(
+          'reportAction must specify ids, types, or all',
+        )
+      }
+    }
+
     const result = await moderationTxn.logEvent({
       event,
       subject,
@@ -248,6 +264,28 @@ const handleModerationEvent = async ({
       externalId,
     })
 
+    // Update reports if reportAction was provided
+    if (input.body.reportAction) {
+      const subjectUri = subject.isRecord() ? subject.uri : null
+      try {
+        await processReportAction({
+          db: dbTxn,
+          reportAction: input.body.reportAction,
+          subjectDid: subject.did,
+          subjectUri,
+          eventId: result.event.id,
+          eventType: event.$type,
+          createdBy,
+        })
+      } catch (err) {
+        throw new InvalidRequestError(
+          err instanceof Error
+            ? err.message
+            : 'Failed to process report action',
+        )
+      }
+    }
+
     const tagService = new TagService(
       subject,
       result.subjectStatus,

package/src/api/queue/assignModerator.ts

@@ -0,0 +1,31 @@
+import { ForbiddenError } from '@atproto/xrpc-server'
+import { AppContext } from '../../context'
+import { Server } from '../../lexicon'
+import { getAuthDid } from '../util'
+
+export default function (server: Server, ctx: AppContext) {
+  server.tools.ozone.queue.assignModerator({
+    auth: ctx.authVerifier.modOrAdminToken,
+    handler: async ({ input, auth }) => {
+      const { queueId, did } = input.body
+      const authDid = getAuthDid(auth, ctx.cfg.service.did)
+
+      // RBAC
+      if (!auth.credentials.isModerator) {
+        throw new ForbiddenError('Unauthorized')
+      }
+
+      // RuBAC
+      if (did !== authDid && !auth.credentials.isAdmin) {
+        throw new ForbiddenError('Unauthorized')
+      }
+
+      const result = await ctx.assignmentService.assignQueue({ did, queueId })
+
+      return {
+        encoding: 'application/json',
+        body: result,
+      }
+    },
+  })
+}

package/src/api/queue/createQueue.ts

@@ -0,0 +1,62 @@
+import { AuthRequiredError, InvalidRequestError } from '@atproto/xrpc-server'
+import { AppContext } from '../../context'
+import { Server } from '../../lexicon'
+
+const VALID_SUBJECT_TYPES = ['account', 'record', 'message']
+
+export default function (server: Server, ctx: AppContext) {
+  server.tools.ozone.queue.createQueue({
+    auth: ctx.authVerifier.modOrAdminToken,
+    handler: async ({ input, auth }) => {
+      const access = auth.credentials
+
+      if (!access.isModerator) {
+        throw new AuthRequiredError('Must be a moderator to create a queue')
+      }
+
+      const { name, subjectTypes, collection, reportTypes, description } =
+        input.body
+      const createdBy =
+        access.type === 'admin_token' ? 'admin_token' : access.iss
+
+      const invalidTypes = subjectTypes.filter(
+        (t) => !VALID_SUBJECT_TYPES.includes(t),
+      )
+      if (invalidTypes.length > 0) {
+        throw new InvalidRequestError(
+          `Invalid subject types: ${invalidTypes.join(', ')}. Allowed values: ${VALID_SUBJECT_TYPES.join(', ')}`,
+          'InvalidSubjectType',
+        )
+      }
+
+      if (collection && !subjectTypes.includes('record')) {
+        throw new InvalidRequestError(
+          'collection can only be specified when subjectTypes includes "record"',
+          'InvalidCollection',
+        )
+      }
+
+      const queueService = ctx.queueService(ctx.db)
+
+      await queueService.checkConflict({
+        subjectTypes,
+        collection,
+        reportTypes,
+      })
+
+      const queue = await queueService.create({
+        name,
+        subjectTypes,
+        collection,
+        reportTypes,
+        description,
+        createdBy,
+      })
+
+      return {
+        encoding: 'application/json',
+        body: { queue: queueService.view(queue) },
+      }
+    },
+  })
+}

package/src/api/queue/deleteQueue.ts

@@ -0,0 +1,56 @@
+import { AuthRequiredError, InvalidRequestError } from '@atproto/xrpc-server'
+import { AppContext } from '../../context'
+import { Server } from '../../lexicon'
+
+export default function (server: Server, ctx: AppContext) {
+  server.tools.ozone.queue.deleteQueue({
+    auth: ctx.authVerifier.modOrAdminToken,
+    handler: async ({ input, auth }) => {
+      const access = auth.credentials
+
+      if (!access.isModerator) {
+        throw new AuthRequiredError('Must be a moderator to delete a queue')
+      }
+
+      const { queueId, migrateToQueueId } = input.body
+
+      const queueService = ctx.queueService(ctx.db)
+
+      const existing = await queueService.getById(queueId)
+      if (!existing) {
+        throw new InvalidRequestError(
+          `Queue with id ${queueId} does not exist`,
+          'QueueNotFound',
+        )
+      }
+
+      if (migrateToQueueId !== undefined) {
+        const targetQueue = await queueService.getById(migrateToQueueId)
+        if (!targetQueue) {
+          throw new InvalidRequestError(
+            `Target queue with id ${migrateToQueueId} does not exist`,
+            'QueueNotFound',
+          )
+        }
+      }
+
+      // Migrate non-closed reports before soft-deleting the queue.
+      // Closed reports are left assigned to the deleted queue — their history is preserved.
+      // Non-closed reports go to migrateToQueueId if specified, otherwise to -1 (unmatched).
+      const reportsMigrated = await queueService.migrateReports(
+        queueId,
+        migrateToQueueId,
+      )
+
+      await queueService.delete(queueId)
+
+      return {
+        encoding: 'application/json',
+        body: {
+          deleted: true,
+          reportsMigrated,
+        },
+      }
+    },
+  })
+}

package/src/api/queue/getAssignments.ts

@@ -0,0 +1,19 @@
+import { AppContext } from '../../context'
+import { Server } from '../../lexicon'
+
+export default function (server: Server, ctx: AppContext) {
+  server.tools.ozone.queue.getAssignments({
+    auth: ctx.authVerifier.modOrAdminToken,
+    handler: async ({ params }) => {
+      const result = await ctx.assignmentService.getQueueAssignments(params)
+
+      return {
+        encoding: 'application/json',
+        body: {
+          assignments: result.assignments,
+          cursor: result.cursor,
+        },
+      }
+    },
+  })
+}

package/src/api/queue/listQueues.ts

@@ -0,0 +1,39 @@
+import { AppContext } from '../../context'
+import { Server } from '../../lexicon'
+
+export default function (server: Server, ctx: AppContext) {
+  server.tools.ozone.queue.listQueues({
+    auth: ctx.authVerifier.modOrAdminToken,
+    handler: async ({ params }) => {
+      const {
+        limit = 50,
+        cursor,
+        enabled,
+        subjectType,
+        collection,
+        reportTypes,
+      } = params
+
+      const queueService = ctx.queueService(ctx.db)
+
+      const result = await queueService.list({
+        limit,
+        cursor,
+        enabled,
+        subjectType,
+        collection,
+        reportTypes,
+      })
+
+      const queues = await queueService.viewsWithStats(result.queues)
+
+      return {
+        encoding: 'application/json',
+        body: {
+          queues,
+          cursor: result.cursor,
+        },
+      }
+    },
+  })
+}

package/src/api/queue/routeReports.ts

@@ -0,0 +1,44 @@
+import { AuthRequiredError, InvalidRequestError } from '@atproto/xrpc-server'
+import { AppContext } from '../../context'
+import { Server } from '../../lexicon'
+
+const MAX_REPORTS = 5000
+
+export default function (server: Server, ctx: AppContext) {
+  server.tools.ozone.queue.routeReports({
+    auth: ctx.authVerifier.modOrAdminToken,
+    handler: async ({ input, auth }) => {
+      const access = auth.credentials
+      const { startReportId, endReportId } = input.body
+
+      if (!access.isModerator) {
+        throw new AuthRequiredError('Must be an admin to re-route reports')
+      }
+      if (startReportId > endReportId) {
+        throw new InvalidRequestError(
+          'startReportId must be less than or equal to endReportId',
+        )
+      }
+      if (endReportId - startReportId + 1 > MAX_REPORTS) {
+        throw new InvalidRequestError(
+          `Cannot route more than ${MAX_REPORTS} reports at a time`,
+          'OutOfRange',
+        )
+      }
+
+      const queueService = ctx.queueService(ctx.db)
+      const { assigned, unmatched } = await queueService.assignReportBatch(
+        { start: startReportId, end: endReportId, limit: MAX_REPORTS },
+        { includeUnmatched: true },
+      )
+
+      return {
+        encoding: 'application/json',
+        body: {
+          assigned,
+          unmatched,
+        },
+      }
+    },
+  })
+}

package/src/api/queue/unassignModerator.ts

@@ -0,0 +1,26 @@
+import { ForbiddenError } from '@atproto/xrpc-server'
+import { AppContext } from '../../context'
+import { Server } from '../../lexicon'
+import { getAuthDid } from '../util'
+
+export default function (server: Server, ctx: AppContext) {
+  server.tools.ozone.queue.unassignModerator({
+    auth: ctx.authVerifier.modOrAdminToken,
+    handler: async ({ input, auth }) => {
+      const { queueId, did } = input.body
+      const authDid = getAuthDid(auth, ctx.cfg.service.did)
+
+      // RBAC
+      if (!auth.credentials.isModerator) {
+        throw new ForbiddenError('Unauthorized')
+      }
+
+      // RuBAC
+      if (did !== authDid && !auth.credentials.isAdmin) {
+        throw new ForbiddenError('Unauthorized')
+      }
+
+      await ctx.assignmentService.unassignQueue({ did, queueId })
+    },
+  })
+}

package/src/api/queue/updateQueue.ts

@@ -0,0 +1,54 @@
+import { AuthRequiredError, InvalidRequestError } from '@atproto/xrpc-server'
+import { AppContext } from '../../context'
+import { Server } from '../../lexicon'
+
+export default function (server: Server, ctx: AppContext) {
+  server.tools.ozone.queue.updateQueue({
+    auth: ctx.authVerifier.modOrAdminToken,
+    handler: async ({ input, auth }) => {
+      const access = auth.credentials
+
+      if (!access.isModerator) {
+        throw new AuthRequiredError('Must be a moderator to update a queue')
+      }
+
+      const { queueId, name, enabled, description } = input.body
+
+      if (
+        name === undefined &&
+        enabled === undefined &&
+        description === undefined
+      ) {
+        throw new InvalidRequestError(
+          'At least one of name, enabled, or description must be provided',
+        )
+      }
+
+      const queueService = ctx.queueService(ctx.db)
+
+      const existing = await queueService.getById(queueId)
+      if (!existing) {
+        throw new InvalidRequestError(
+          `Queue with id ${queueId} does not exist`,
+          'QueueNotFound',
+        )
+      }
+
+      const updates: {
+        name?: string
+        enabled?: boolean
+        description?: string
+      } = {}
+      if (name !== undefined) updates.name = name
+      if (enabled !== undefined) updates.enabled = enabled
+      if (description !== undefined) updates.description = description
+
+      const queue = await queueService.update(queueId, updates)
+
+      return {
+        encoding: 'application/json',
+        body: { queue: queueService.view(queue) },
+      }
+    },
+  })
+}

package/src/api/report/assignModerator.ts

@@ -0,0 +1,36 @@
+import { ForbiddenError } from '@atproto/xrpc-server'
+import { AppContext } from '../../context'
+import { Server } from '../../lexicon'
+import { getAuthDid } from '../util'
+
+export default function (server: Server, ctx: AppContext) {
+  server.tools.ozone.report.assignModerator({
+    auth: ctx.authVerifier.modOrAdminToken,
+    handler: async ({ input, auth }) => {
+      const authDid = getAuthDid(auth, ctx.cfg.service.did)
+      const did = input.body.did ?? authDid
+
+      if (!did) {
+        throw new ForbiddenError('No one to assign report to')
+      }
+
+      // RuBAC: only admins can assign to a different user
+      if (did !== authDid && !auth.credentials.isAdmin) {
+        throw new ForbiddenError('Unauthorized')
+      }
+
+      const result = await ctx.assignmentService.assignReport({
+        did,
+        createdBy: authDid,
+        reportId: input.body.reportId,
+        queueId: input.body.queueId,
+        isPermanent: input.body.isPermanent,
+      })
+
+      return {
+        encoding: 'application/json',
+        body: result,
+      }
+    },
+  })
+}

package/src/api/report/createActivity.ts

@@ -0,0 +1,57 @@
+import { InvalidRequestError } from '@atproto/xrpc-server'
+import { AppContext } from '../../context'
+import { Server } from '../../lexicon'
+import {
+  ActivityType,
+  createReportActivity,
+  formatActivityView,
+} from '../../report/activity'
+import { getAuthDid } from '../util'
+
+const VALID_ACTIVITY_TYPES = new Set<ActivityType>([
+  'queueActivity',
+  'assignmentActivity',
+  'escalationActivity',
+  'closeActivity',
+  'reopenActivity',
+  'noteActivity',
+])
+
+const DEFS_PREFIX = 'tools.ozone.report.defs#'
+
+export default function (server: Server, ctx: AppContext) {
+  server.tools.ozone.report.createActivity({
+    auth: ctx.authVerifier.modOrAdminToken,
+    handler: async ({ input, auth }) => {
+      const createdBy = getAuthDid(auth, ctx.cfg.service.did)
+      const { reportId, activity, internalNote, publicNote, isAutomated } =
+        input.body
+
+      const rawType = activity.$type ?? ''
+      const activityType = rawType.startsWith(DEFS_PREFIX)
+        ? rawType.slice(DEFS_PREFIX.length)
+        : rawType
+
+      if (!VALID_ACTIVITY_TYPES.has(activityType as ActivityType)) {
+        throw new InvalidRequestError(
+          `Unknown activity type: ${rawType}`,
+          'InvalidActivityType',
+        )
+      }
+
+      const row = await createReportActivity(ctx.db, {
+        reportId,
+        activityType: activityType as ActivityType,
+        internalNote: internalNote ?? undefined,
+        publicNote: publicNote ?? undefined,
+        isAutomated: isAutomated ?? false,
+        createdBy: createdBy ?? ctx.cfg.service.did,
+      })
+
+      return {
+        encoding: 'application/json',
+        body: { activity: formatActivityView(row) },
+      }
+    },
+  })
+}

package/src/api/report/getAssignments.ts

@@ -0,0 +1,20 @@
+import { AppContext } from '../../context'
+import { Server } from '../../lexicon'
+
+export default function (server: Server, ctx: AppContext) {
+  server.tools.ozone.report.getAssignments({
+    auth: ctx.authVerifier.modOrAdminToken,
+    handler: async ({ params }) => {
+      const { assignments, cursor } =
+        await ctx.assignmentService.getReportAssignments(params)
+
+      return {
+        encoding: 'application/json',
+        body: {
+          assignments,
+          cursor,
+        },
+      }
+    },
+  })
+}

package/src/api/report/getHistoricalStats.ts

@@ -0,0 +1,41 @@
+import { AppContext } from '../../context'
+import { Server } from '../../lexicon'
+import { viewHistoricalStats } from '../../report/views'
+
+export default function (server: Server, ctx: AppContext) {
+  server.tools.ozone.report.getHistoricalStats({
+    auth: ctx.authVerifier.modOrAdminToken,
+    handler: async ({ params }) => {
+      const {
+        queueId,
+        moderatorDid,
+        reportTypes,
+        startDate,
+        endDate,
+        limit,
+        cursor,
+      } = params
+
+      const reportStatsService = ctx.reportStatsService(ctx.db)
+      const result = await reportStatsService.getHistoricalStats({
+        group: {
+          queueId: queueId ?? null,
+          moderatorDid: moderatorDid ?? null,
+          reportTypes: reportTypes?.length ? reportTypes : null,
+        },
+        startDate,
+        endDate,
+        limit: limit ?? 30,
+        cursor,
+      })
+
+      return {
+        encoding: 'application/json',
+        body: {
+          stats: result.stats.map(viewHistoricalStats),
+          cursor: result.cursor,
+        },
+      }
+    },
+  })
+}

package/src/api/report/getLatestReport.ts

@@ -0,0 +1,44 @@
+import { InvalidRequestError } from '@atproto/xrpc-server'
+import { AppContext } from '../../context'
+import { Server } from '../../lexicon'
+import { getLatestReport } from '../../mod-service/report'
+import { buildReportView, hydrateReportInfo } from '../../report/views'
+import { getPdsAccountInfos } from '../util'
+
+export default function (server: Server, ctx: AppContext) {
+  server.tools.ozone.report.getLatestReport({
+    auth: ctx.authVerifier.modOrAdminToken,
+    handler: async ({ auth, req }) => {
+      const db = ctx.db
+      const modService = ctx.modService(db)
+      const labelers = ctx.reqLabelers(req)
+
+      const report = await getLatestReport(db)
+      if (!report) {
+        throw new InvalidRequestError('No report found', 'NotFound')
+      }
+
+      const queueService = ctx.queueService(db)
+      const teamService = ctx.teamService(db)
+      const hydrated = await hydrateReportInfo(
+        [report],
+        modService.views,
+        (dids) => getPdsAccountInfos(ctx, dids),
+        (queueIds) => queueService.getViewsByIds(queueIds),
+        (dids) => teamService.viewByDids(dids),
+        labelers,
+      )
+
+      return {
+        encoding: 'application/json',
+        body: {
+          report: buildReportView(
+            report,
+            hydrated,
+            auth.credentials.isModerator,
+          ),
+        },
+      }
+    },
+  })
+}

package/src/api/report/getLiveStats.ts

@@ -0,0 +1,26 @@
+import { AppContext } from '../../context'
+import { Server } from '../../lexicon'
+import { viewLiveStats } from '../../report/views'
+
+export default function (server: Server, ctx: AppContext) {
+  server.tools.ozone.report.getLiveStats({
+    auth: ctx.authVerifier.modOrAdminToken,
+    handler: async ({ params }) => {
+      const { queueId, moderatorDid, reportTypes } = params
+
+      const reportStatsService = ctx.reportStatsService(ctx.db)
+      const row = await reportStatsService.getLiveStats({
+        queueId: queueId ?? null,
+        moderatorDid: moderatorDid ?? null,
+        reportTypes: reportTypes?.length ? reportTypes : null,
+      })
+
+      return {
+        encoding: 'application/json',
+        body: {
+          stats: viewLiveStats(row),
+        },
+      }
+    },
+  })
+}

package/src/api/report/getReport.ts

@@ -0,0 +1,55 @@
+import { InvalidRequestError } from '@atproto/xrpc-server'
+import { AppContext } from '../../context'
+import { Server } from '../../lexicon'
+import { getReportById } from '../../mod-service/report'
+import { buildReportView, hydrateReportInfo } from '../../report/views'
+import { getPdsAccountInfos } from '../util'
+
+export default function (server: Server, ctx: AppContext) {
+  server.tools.ozone.report.getReport({
+    auth: ctx.authVerifier.modOrAdminToken,
+    handler: async ({ params, auth, req }) => {
+      const db = ctx.db
+      const modService = ctx.modService(db)
+      const labelers = ctx.reqLabelers(req)
+
+      const report = await getReportById(db, params.id)
+      if (!report) {
+        throw new InvalidRequestError(
+          `Report not found: ${params.id}`,
+          'NotFound',
+        )
+      }
+
+      const queueService = ctx.queueService(db)
+      const teamService = ctx.teamService(db)
+      const [hydrated, actionEvents] = await Promise.all([
+        hydrateReportInfo(
+          [report],
+          modService.views,
+          (dids) => getPdsAccountInfos(ctx, dids),
+          (queueIds) => queueService.getViewsByIds(queueIds),
+          (dids) => teamService.viewByDids(dids),
+          labelers,
+        ),
+        Array.isArray(report.actionEventIds) && report.actionEventIds.length
+          ? modService.getEventsByIds(report.actionEventIds as number[])
+          : Promise.resolve([]),
+      ])
+
+      const actions = actionEvents.map((evt) =>
+        modService.views.formatEvent(evt),
+      )
+
+      return {
+        encoding: 'application/json',
+        body: buildReportView(
+          report,
+          hydrated,
+          auth.credentials.isModerator,
+          actions,
+        ),
+      }
+    },
+  })
+}