@atproto/ozone 0.1.172 → 0.1.174

package/src/lexicon/types/tools/ozone/report/getLatestReport.ts

@@ -0,0 +1,39 @@
+/**
+ * GENERATED CODE - DO NOT MODIFY
+ */
+import { type ValidationResult, BlobRef } from '@atproto/lexicon'
+import { CID } from 'multiformats/cid'
+import { validate as _validate } from '../../../../lexicons'
+import {
+  type $Typed,
+  is$typed as _is$typed,
+  type OmitKey,
+} from '../../../../util'
+import type * as ToolsOzoneReportDefs from './defs.js'
+
+const is$typed = _is$typed,
+  validate = _validate
+const id = 'tools.ozone.report.getLatestReport'
+
+export type QueryParams = {}
+export type InputSchema = undefined
+
+export interface OutputSchema {
+  report: ToolsOzoneReportDefs.ReportView
+}
+
+export type HandlerInput = void
+
+export interface HandlerSuccess {
+  encoding: 'application/json'
+  body: OutputSchema
+  headers?: { [key: string]: string }
+}
+
+export interface HandlerError {
+  status: number
+  message?: string
+  error?: 'NotFound'
+}
+
+export type HandlerOutput = HandlerError | HandlerSuccess

package/src/lexicon/types/tools/ozone/report/getLiveStats.ts

@@ -0,0 +1,45 @@
+/**
+ * GENERATED CODE - DO NOT MODIFY
+ */
+import { type ValidationResult, BlobRef } from '@atproto/lexicon'
+import { CID } from 'multiformats/cid'
+import { validate as _validate } from '../../../../lexicons'
+import {
+  type $Typed,
+  is$typed as _is$typed,
+  type OmitKey,
+} from '../../../../util'
+import type * as ToolsOzoneReportDefs from './defs.js'
+
+const is$typed = _is$typed,
+  validate = _validate
+const id = 'tools.ozone.report.getLiveStats'
+
+export type QueryParams = {
+  /** Filter stats by queue. Use -1 for unqueued reports. */
+  queueId?: number
+  /** Filter stats by moderator DID. */
+  moderatorDid?: string
+  /** Filter stats by report types. */
+  reportTypes?: string[]
+}
+export type InputSchema = undefined
+
+export interface OutputSchema {
+  stats: ToolsOzoneReportDefs.LiveStats
+}
+
+export type HandlerInput = void
+
+export interface HandlerSuccess {
+  encoding: 'application/json'
+  body: OutputSchema
+  headers?: { [key: string]: string }
+}
+
+export interface HandlerError {
+  status: number
+  message?: string
+}
+
+export type HandlerOutput = HandlerError | HandlerSuccess

package/src/lexicon/types/tools/ozone/report/getReport.ts

@@ -0,0 +1,38 @@
+/**
+ * GENERATED CODE - DO NOT MODIFY
+ */
+import { type ValidationResult, BlobRef } from '@atproto/lexicon'
+import { CID } from 'multiformats/cid'
+import { validate as _validate } from '../../../../lexicons'
+import {
+  type $Typed,
+  is$typed as _is$typed,
+  type OmitKey,
+} from '../../../../util'
+import type * as ToolsOzoneReportDefs from './defs.js'
+
+const is$typed = _is$typed,
+  validate = _validate
+const id = 'tools.ozone.report.getReport'
+
+export type QueryParams = {
+  /** The ID of the report to retrieve. */
+  id: number
+}
+export type InputSchema = undefined
+export type OutputSchema = ToolsOzoneReportDefs.ReportView
+export type HandlerInput = void
+
+export interface HandlerSuccess {
+  encoding: 'application/json'
+  body: OutputSchema
+  headers?: { [key: string]: string }
+}
+
+export interface HandlerError {
+  status: number
+  message?: string
+  error?: 'NotFound'
+}
+
+export type HandlerOutput = HandlerError | HandlerSuccess

package/src/lexicon/types/tools/ozone/report/listActivities.ts

@@ -0,0 +1,44 @@
+/**
+ * GENERATED CODE - DO NOT MODIFY
+ */
+import { type ValidationResult, BlobRef } from '@atproto/lexicon'
+import { CID } from 'multiformats/cid'
+import { validate as _validate } from '../../../../lexicons'
+import {
+  type $Typed,
+  is$typed as _is$typed,
+  type OmitKey,
+} from '../../../../util'
+import type * as ToolsOzoneReportDefs from './defs.js'
+
+const is$typed = _is$typed,
+  validate = _validate
+const id = 'tools.ozone.report.listActivities'
+
+export type QueryParams = {
+  /** ID of the report whose activities to list */
+  reportId: number
+  limit: number
+  cursor?: string
+}
+export type InputSchema = undefined
+
+export interface OutputSchema {
+  activities: ToolsOzoneReportDefs.ReportActivityView[]
+  cursor?: string
+}
+
+export type HandlerInput = void
+
+export interface HandlerSuccess {
+  encoding: 'application/json'
+  body: OutputSchema
+  headers?: { [key: string]: string }
+}
+
+export interface HandlerError {
+  status: number
+  message?: string
+}
+
+export type HandlerOutput = HandlerError | HandlerSuccess

package/src/lexicon/types/tools/ozone/report/queryReports.ts

@@ -0,0 +1,72 @@
+/**
+ * GENERATED CODE - DO NOT MODIFY
+ */
+import { type ValidationResult, BlobRef } from '@atproto/lexicon'
+import { CID } from 'multiformats/cid'
+import { validate as _validate } from '../../../../lexicons'
+import {
+  type $Typed,
+  is$typed as _is$typed,
+  type OmitKey,
+} from '../../../../util'
+import type * as ToolsOzoneReportDefs from './defs.js'
+
+const is$typed = _is$typed,
+  validate = _validate
+const id = 'tools.ozone.report.queryReports'
+
+export type QueryParams = {
+  /** Filter by queue ID. Use -1 for unassigned reports. */
+  queueId?: number
+  /** Filter by report types (fully qualified string in the format of com.atproto.moderation.defs#reason<name>). */
+  reportTypes?: string[]
+  /** Filter by report status. */
+  status:
+    | 'open'
+    | 'closed'
+    | 'escalated'
+    | 'queued'
+    | 'assigned'
+    | (string & {})
+  /** Filter by subject DID or AT-URI. */
+  subject?: string
+  /** Filter to reports where the subject is this DID or any record owned by this DID. Unlike `subject` (which scopes to a specific account or record), this returns all reports tied to the DID across both account-level and record-level subjects. */
+  did?: string
+  /** If specified, reports of the given type (account or record) will be returned. */
+  subjectType?: 'account' | 'record' | (string & {})
+  /** If specified, reports where the subject belongs to the given collections will be returned. When subjectType is set to 'account', this will be ignored. */
+  collections?: string[]
+  /** Retrieve reports created after a given timestamp */
+  reportedAfter?: string
+  /** Retrieve reports created before a given timestamp */
+  reportedBefore?: string
+  /** Filter by muted status. true returns only muted reports, false returns only unmuted reports. Defaults to false. */
+  isMuted: boolean
+  /** Filter by the DID of the moderator permanently assigned to the report. */
+  assignedTo?: string
+  sortField: 'createdAt' | 'updatedAt'
+  sortDirection: 'asc' | 'desc'
+  limit: number
+  cursor?: string
+}
+export type InputSchema = undefined
+
+export interface OutputSchema {
+  cursor?: string
+  reports: ToolsOzoneReportDefs.ReportView[]
+}
+
+export type HandlerInput = void
+
+export interface HandlerSuccess {
+  encoding: 'application/json'
+  body: OutputSchema
+  headers?: { [key: string]: string }
+}
+
+export interface HandlerError {
+  status: number
+  message?: string
+}
+
+export type HandlerOutput = HandlerError | HandlerSuccess

package/src/lexicon/types/tools/ozone/report/reassignQueue.ts

@@ -0,0 +1,55 @@
+/**
+ * GENERATED CODE - DO NOT MODIFY
+ */
+import { type ValidationResult, BlobRef } from '@atproto/lexicon'
+import { CID } from 'multiformats/cid'
+import { validate as _validate } from '../../../../lexicons'
+import {
+  type $Typed,
+  is$typed as _is$typed,
+  type OmitKey,
+} from '../../../../util'
+import type * as ToolsOzoneReportDefs from './defs.js'
+
+const is$typed = _is$typed,
+  validate = _validate
+const id = 'tools.ozone.report.reassignQueue'
+
+export type QueryParams = {}
+
+export interface InputSchema {
+  /** ID of the report to reassign */
+  reportId: number
+  /** Target queue ID. Use -1 to unassign from any queue. */
+  queueId: number
+  /** Optional moderator-only note recorded on the resulting queueActivity as internalNote. */
+  comment?: string
+}
+
+export interface OutputSchema {
+  report: ToolsOzoneReportDefs.ReportView
+}
+
+export interface HandlerInput {
+  encoding: 'application/json'
+  body: InputSchema
+}
+
+export interface HandlerSuccess {
+  encoding: 'application/json'
+  body: OutputSchema
+  headers?: { [key: string]: string }
+}
+
+export interface HandlerError {
+  status: number
+  message?: string
+  error?:
+    | 'ReportNotFound'
+    | 'ReportClosed'
+    | 'AlreadyInTargetQueue'
+    | 'QueueNotFound'
+    | 'QueueDisabled'
+}
+
+export type HandlerOutput = HandlerError | HandlerSuccess

package/src/lexicon/types/tools/ozone/report/refreshStats.ts

@@ -0,0 +1,46 @@
+/**
+ * GENERATED CODE - DO NOT MODIFY
+ */
+import { type ValidationResult, BlobRef } from '@atproto/lexicon'
+import { CID } from 'multiformats/cid'
+import { validate as _validate } from '../../../../lexicons'
+import {
+  type $Typed,
+  is$typed as _is$typed,
+  type OmitKey,
+} from '../../../../util'
+
+const is$typed = _is$typed,
+  validate = _validate
+const id = 'tools.ozone.report.refreshStats'
+
+export type QueryParams = {}
+
+export interface InputSchema {
+  /** Start date for recomputation, inclusive (YYYY-MM-DD). */
+  startDate: string
+  /** End date for recomputation, inclusive (YYYY-MM-DD). */
+  endDate: string
+  /** Optional list of queue IDs to recompute. Omit to recompute all groups. */
+  queueIds?: number[]
+}
+
+export interface OutputSchema {}
+
+export interface HandlerInput {
+  encoding: 'application/json'
+  body: InputSchema
+}
+
+export interface HandlerSuccess {
+  encoding: 'application/json'
+  body: OutputSchema
+  headers?: { [key: string]: string }
+}
+
+export interface HandlerError {
+  status: number
+  message?: string
+}
+
+export type HandlerOutput = HandlerError | HandlerSuccess

package/src/lexicon/types/tools/ozone/report/unassignModerator.ts

@@ -0,0 +1,44 @@
+/**
+ * GENERATED CODE - DO NOT MODIFY
+ */
+import { type ValidationResult, BlobRef } from '@atproto/lexicon'
+import { CID } from 'multiformats/cid'
+import { validate as _validate } from '../../../../lexicons'
+import {
+  type $Typed,
+  is$typed as _is$typed,
+  type OmitKey,
+} from '../../../../util'
+import type * as ToolsOzoneReportDefs from './defs.js'
+
+const is$typed = _is$typed,
+  validate = _validate
+const id = 'tools.ozone.report.unassignModerator'
+
+export type QueryParams = {}
+
+export interface InputSchema {
+  /** The ID of the report to unassign. */
+  reportId: number
+}
+
+export type OutputSchema = ToolsOzoneReportDefs.AssignmentView
+
+export interface HandlerInput {
+  encoding: 'application/json'
+  body: InputSchema
+}
+
+export interface HandlerSuccess {
+  encoding: 'application/json'
+  body: OutputSchema
+  headers?: { [key: string]: string }
+}
+
+export interface HandlerError {
+  status: number
+  message?: string
+  error?: 'InvalidAssignment'
+}
+
+export type HandlerOutput = HandlerError | HandlerSuccess

package/src/mod-service/expiring-tags.ts

@@ -0,0 +1,98 @@
+import { Selectable } from 'kysely'
+import { Database } from '../db'
+import { ExpiringTag } from '../db/schema/expiring_tag'
+
+export type ExpiringTagRow = Selectable<ExpiringTag>
+
+export type ExpiringTagGroup = {
+  did: string
+  recordPath: string
+  createdBy: string
+  tags: string[]
+  ids: number[]
+}
+
+export async function insertExpiringTags(
+  db: Database,
+  params: {
+    eventId: number
+    did: string
+    recordPath: string
+    tags: string[]
+    expiresAt: string
+    createdBy: string
+  },
+): Promise<void> {
+  await db.db
+    .insertInto('expiring_tag')
+    .values(
+      params.tags.map((tag) => ({
+        eventId: params.eventId,
+        did: params.did,
+        recordPath: params.recordPath,
+        tag,
+        expiresAt: params.expiresAt,
+        createdBy: params.createdBy,
+      })),
+    )
+    .execute()
+}
+
+export async function removeExpiringTags(
+  db: Database,
+  params: {
+    did: string
+    recordPath: string
+    tags: string[]
+  },
+): Promise<void> {
+  await db.db
+    .deleteFrom('expiring_tag')
+    .where('did', '=', params.did)
+    .where('recordPath', '=', params.recordPath)
+    .where('tag', 'in', params.tags)
+    .execute()
+}
+
+export async function deleteExpiringTagsByIds(
+  db: Database,
+  ids: number[],
+): Promise<void> {
+  await db.db.deleteFrom('expiring_tag').where('id', 'in', ids).execute()
+}
+
+export async function getExpiredTags(
+  db: Database,
+): Promise<ExpiringTagGroup[]> {
+  const now = new Date().toISOString()
+  const rows = await db.db
+    .selectFrom('expiring_tag')
+    .where('expiresAt', '<', now)
+    .selectAll()
+    .execute()
+
+  if (!rows.length) return []
+
+  // Group by (did, recordPath, createdBy) so each reversal event has the correct author
+  const grouped = new Map<string, ExpiringTagGroup>()
+  for (const row of rows) {
+    const key = `${row.did}|${row.recordPath}|${row.createdBy}`
+    let group = grouped.get(key)
+    if (!group) {
+      group = {
+        did: row.did,
+        recordPath: row.recordPath,
+        createdBy: row.createdBy,
+        tags: [],
+        ids: [],
+      }
+      grouped.set(key, group)
+    }
+    if (!group.tags.includes(row.tag)) {
+      group.tags.push(row.tag)
+    }
+    group.ids.push(row.id)
+  }
+
+  return [...grouped.values()]
+}

package/src/mod-service/index.ts

@@ -46,6 +46,7 @@ import {
 import { QueryParams as QueryStatusParams } from '../lexicon/types/tools/ozone/moderation/queryStatuses'
 import { httpLogger as log } from '../logger'
 import { LABELER_HEADER_NAME, ParsedLabelers } from '../util'
+import { insertExpiringTags, removeExpiringTags } from './expiring-tags'
 import {
   adjustModerationSubjectStatus,
   getStatusIdentifierFromSubject,
@@ -61,6 +62,7 @@ import {
 import {
   ModEventType,
   ModerationEventRow,
+  ModerationEventRowWithHandle,
   ModerationSubjectStatusRow,
   ModerationSubjectStatusRowWithHandle,
   ReporterStats,
@@ -375,6 +377,29 @@ export class ModerationService {
     return { cursor: keyset.packFromResult(result), events: resultWithHandles }
   }
 
+  async getEventsByIds(ids: number[]): Promise<ModerationEventRowWithHandle[]> {
+    if (!ids.length) return []
+
+    const result = await this.db.db
+      .selectFrom('moderation_event')
+      .selectAll()
+      .where('id', 'in', ids)
+      .execute()
+
+    if (!result.length) return []
+
+    const infos = await this.views.getAccoutInfosByDid([
+      ...result.map((row) => row.subjectDid),
+      ...result.map((row) => row.createdBy),
+    ])
+
+    return result.map((r) => ({
+      ...r,
+      creatorHandle: infos.get(r.createdBy)?.handle,
+      subjectHandle: infos.get(r.subjectDid)?.handle,
+    }))
+  }
+
   async getReport(id: number): Promise<ModerationEventRow | undefined> {
     return await this.db.db
       .selectFrom('moderation_event')
@@ -590,6 +615,13 @@ export class ModerationService {
       if (isReportingMuted) {
         meta.isReporterMuted = true
       }
+      // Also capture whether the subject was muted at event-creation time, so
+      // the queue-router daemon can populate report.isMuted later without
+      // racing against subsequent mute/unmute changes.
+      const isSubjectMuted = await this.isSubjectMuted(subject.did)
+      if (isSubjectMuted) {
+        meta.isSubjectMuted = true
+      }
     }
 
     const subjectInfo = subject.info()
@@ -666,6 +698,31 @@ export class ModerationService {
       subject.blobCids,
     )
 
+    // Manage expiring tag rows for temporary tags
+    if (isModEventTag(event)) {
+      if (event.durationInHours && event.add.length > 0) {
+        const expiresAt = addHoursToDate(
+          event.durationInHours,
+          createdAt,
+        ).toISOString()
+        await insertExpiringTags(this.db, {
+          eventId: modEvent.id,
+          did: subjectInfo.subjectDid,
+          recordPath: subjectInfo.subjectUri ?? '',
+          tags: event.add,
+          expiresAt,
+          createdBy,
+        })
+      }
+      if (event.remove.length > 0) {
+        await removeExpiringTags(this.db, {
+          did: subjectInfo.subjectDid,
+          recordPath: subjectInfo.subjectUri ?? '',
+          tags: event.remove,
+        })
+      }
+    }
+
     if (isAgeAssurancePurgeEvent(event)) {
       await this.purgeAgeAssuranceEvents(subjectInfo.subjectDid)
     }
@@ -1009,7 +1066,7 @@ export class ModerationService {
       modTool,
     } = info
 
-    const result = await this.logEvent({
+    return await this.logEvent({
       event: {
         $type: 'tools.ozone.moderation.defs#modEventReport',
         reportType: reasonType,
@@ -1020,8 +1077,6 @@ export class ModerationService {
       createdAt,
       modTool,
     })
-
-    return result
   }
 
   async getSubjectStatuses({
@@ -1399,6 +1454,19 @@ export class ModerationService {
     return !!result
   }
 
+  // Check if a subject (the account being reported) has an active mute
+  async isSubjectMuted(did: string) {
+    const result = await this.db.db
+      .selectFrom('moderation_subject_status')
+      .where('did', '=', did)
+      .where('recordPath', '=', '')
+      .where('muteUntil', '>', new Date().toISOString())
+      .select(sql`true`.as('status'))
+      .executeTakeFirst()
+
+    return !!result
+  }
+
   async formatAndCreateLabels(
     uri: string,
     cid: string | null,