@atproto/ozone 0.1.145 → 0.1.147

package/src/lexicon/types/tools/ozone/moderation/defs.ts

@@ -46,6 +46,8 @@ export interface ModEventView {
     | $Typed<AgeAssuranceEvent>
     | $Typed<AgeAssuranceOverrideEvent>
     | $Typed<RevokeAccountCredentialsEvent>
+    | $Typed<ScheduleTakedownEvent>
+    | $Typed<CancelScheduledTakedownEvent>
     | { $type: string }
   subject:
     | $Typed<ComAtprotoAdminDefs.RepoRef>
@@ -96,6 +98,8 @@ export interface ModEventViewDetail {
     | $Typed<AgeAssuranceEvent>
     | $Typed<AgeAssuranceOverrideEvent>
     | $Typed<RevokeAccountCredentialsEvent>
+    | $Typed<ScheduleTakedownEvent>
+    | $Typed<CancelScheduledTakedownEvent>
     | { $type: string }
   subject:
     | $Typed<RepoView>
@@ -701,6 +705,45 @@ export function validateRecordEvent<V>(v: V) {
   return validate<RecordEvent & V>(v, id, hashRecordEvent)
 }
 
+/** Logs a scheduled takedown action for an account. */
+export interface ScheduleTakedownEvent {
+  $type?: 'tools.ozone.moderation.defs#scheduleTakedownEvent'
+  comment?: string
+  executeAt?: string
+  executeAfter?: string
+  executeUntil?: string
+}
+
+const hashScheduleTakedownEvent = 'scheduleTakedownEvent'
+
+export function isScheduleTakedownEvent<V>(v: V) {
+  return is$typed(v, id, hashScheduleTakedownEvent)
+}
+
+export function validateScheduleTakedownEvent<V>(v: V) {
+  return validate<ScheduleTakedownEvent & V>(v, id, hashScheduleTakedownEvent)
+}
+
+/** Logs cancellation of a scheduled takedown action for an account. */
+export interface CancelScheduledTakedownEvent {
+  $type?: 'tools.ozone.moderation.defs#cancelScheduledTakedownEvent'
+  comment?: string
+}
+
+const hashCancelScheduledTakedownEvent = 'cancelScheduledTakedownEvent'
+
+export function isCancelScheduledTakedownEvent<V>(v: V) {
+  return is$typed(v, id, hashCancelScheduledTakedownEvent)
+}
+
+export function validateCancelScheduledTakedownEvent<V>(v: V) {
+  return validate<CancelScheduledTakedownEvent & V>(
+    v,
+    id,
+    hashCancelScheduledTakedownEvent,
+  )
+}
+
 export interface RepoView {
   $type?: 'tools.ozone.moderation.defs#repoView'
   did: string
@@ -1010,3 +1053,48 @@ export const TIMELINEEVENTPLCCREATE = `${id}#timelineEventPlcCreate`
 export const TIMELINEEVENTPLCOPERATION = `${id}#timelineEventPlcOperation`
 /** Moderation event timeline event for a PLC tombstone operation */
 export const TIMELINEEVENTPLCTOMBSTONE = `${id}#timelineEventPlcTombstone`
+
+/** View of a scheduled moderation action */
+export interface ScheduledActionView {
+  $type?: 'tools.ozone.moderation.defs#scheduledActionView'
+  /** Auto-incrementing row ID */
+  id: number
+  /** Type of action to be executed */
+  action: 'takedown' | (string & {})
+  /** Serialized event object that will be propagated to the event when performed */
+  eventData?: { [_ in string]: unknown }
+  /** Subject DID for the action */
+  did: string
+  /** Exact time to execute the action */
+  executeAt?: string
+  /** Earliest time to execute the action (for randomized scheduling) */
+  executeAfter?: string
+  /** Latest time to execute the action (for randomized scheduling) */
+  executeUntil?: string
+  /** Whether execution time should be randomized within the specified range */
+  randomizeExecution?: boolean
+  /** DID of the user who created this scheduled action */
+  createdBy: string
+  /** When the scheduled action was created */
+  createdAt: string
+  /** When the scheduled action was last updated */
+  updatedAt?: string
+  /** Current status of the scheduled action */
+  status: 'pending' | 'executed' | 'cancelled' | 'failed' | (string & {})
+  /** When the action was last attempted to be executed */
+  lastExecutedAt?: string
+  /** Reason for the last execution failure */
+  lastFailureReason?: string
+  /** ID of the moderation event created when action was successfully executed */
+  executionEventId?: number
+}
+
+const hashScheduledActionView = 'scheduledActionView'
+
+export function isScheduledActionView<V>(v: V) {
+  return is$typed(v, id, hashScheduledActionView)
+}
+
+export function validateScheduledActionView<V>(v: V) {
+  return validate<ScheduledActionView & V>(v, id, hashScheduledActionView)
+}

package/src/lexicon/types/tools/ozone/moderation/emitEvent.ts

@@ -43,6 +43,8 @@ export interface InputSchema {
     | $Typed<ToolsOzoneModerationDefs.AgeAssuranceEvent>
     | $Typed<ToolsOzoneModerationDefs.AgeAssuranceOverrideEvent>
     | $Typed<ToolsOzoneModerationDefs.RevokeAccountCredentialsEvent>
+    | $Typed<ToolsOzoneModerationDefs.ScheduleTakedownEvent>
+    | $Typed<ToolsOzoneModerationDefs.CancelScheduledTakedownEvent>
     | { $type: string }
   subject:
     | $Typed<ComAtprotoAdminDefs.RepoRef>

package/src/lexicon/types/tools/ozone/moderation/getAccountTimeline.ts

@@ -88,6 +88,8 @@ export interface TimelineItemSummary {
     | 'tools.ozone.hosting.getAccountHistory#emailConfirmed'
     | 'tools.ozone.hosting.getAccountHistory#passwordUpdated'
     | 'tools.ozone.hosting.getAccountHistory#handleUpdated'
+    | 'tools.ozone.moderation.defs#scheduleTakedownEvent'
+    | 'tools.ozone.moderation.defs#cancelScheduledTakedownEvent'
     | (string & {})
   count: number
 }

package/src/lexicon/types/tools/ozone/moderation/listScheduledActions.ts

@@ -0,0 +1,57 @@
+/**
+ * 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 ToolsOzoneModerationDefs from './defs.js'
+
+const is$typed = _is$typed,
+  validate = _validate
+const id = 'tools.ozone.moderation.listScheduledActions'
+
+export type QueryParams = {}
+
+export interface InputSchema {
+  /** Filter actions scheduled to execute after this time */
+  startsAfter?: string
+  /** Filter actions scheduled to execute before this time */
+  endsBefore?: string
+  /** Filter actions for specific DID subjects */
+  subjects?: string[]
+  /** Filter actions by status */
+  statuses: ('pending' | 'executed' | 'cancelled' | 'failed' | (string & {}))[]
+  /** Maximum number of results to return */
+  limit: number
+  /** Cursor for pagination */
+  cursor?: string
+}
+
+export interface OutputSchema {
+  actions: ToolsOzoneModerationDefs.ScheduledActionView[]
+  /** Cursor for next page of results */
+  cursor?: string
+}
+
+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/moderation/scheduleAction.ts

@@ -0,0 +1,123 @@
+/**
+ * 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 ToolsOzoneModerationDefs from './defs.js'
+
+const is$typed = _is$typed,
+  validate = _validate
+const id = 'tools.ozone.moderation.scheduleAction'
+
+export type QueryParams = {}
+
+export interface InputSchema {
+  action: $Typed<Takedown> | { $type: string }
+  /** Array of DID subjects to schedule the action for */
+  subjects: string[]
+  createdBy: string
+  scheduling: SchedulingConfig
+  modTool?: ToolsOzoneModerationDefs.ModTool
+}
+
+export type OutputSchema = ScheduledActionResults
+
+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
+
+/** Schedule a takedown action */
+export interface Takedown {
+  $type?: 'tools.ozone.moderation.scheduleAction#takedown'
+  comment?: string
+  /** Indicates how long the takedown should be in effect before automatically expiring. */
+  durationInHours?: number
+  /** If true, all other reports on content authored by this account will be resolved (acknowledged). */
+  acknowledgeAccountSubjects?: boolean
+  /** Names/Keywords of the policies that drove the decision. */
+  policies?: string[]
+}
+
+const hashTakedown = 'takedown'
+
+export function isTakedown<V>(v: V) {
+  return is$typed(v, id, hashTakedown)
+}
+
+export function validateTakedown<V>(v: V) {
+  return validate<Takedown & V>(v, id, hashTakedown)
+}
+
+/** Configuration for when the action should be executed */
+export interface SchedulingConfig {
+  $type?: 'tools.ozone.moderation.scheduleAction#schedulingConfig'
+  /** Exact time to execute the action */
+  executeAt?: string
+  /** Earliest time to execute the action (for randomized scheduling) */
+  executeAfter?: string
+  /** Latest time to execute the action (for randomized scheduling) */
+  executeUntil?: string
+}
+
+const hashSchedulingConfig = 'schedulingConfig'
+
+export function isSchedulingConfig<V>(v: V) {
+  return is$typed(v, id, hashSchedulingConfig)
+}
+
+export function validateSchedulingConfig<V>(v: V) {
+  return validate<SchedulingConfig & V>(v, id, hashSchedulingConfig)
+}
+
+export interface ScheduledActionResults {
+  $type?: 'tools.ozone.moderation.scheduleAction#scheduledActionResults'
+  succeeded: string[]
+  failed: FailedScheduling[]
+}
+
+const hashScheduledActionResults = 'scheduledActionResults'
+
+export function isScheduledActionResults<V>(v: V) {
+  return is$typed(v, id, hashScheduledActionResults)
+}
+
+export function validateScheduledActionResults<V>(v: V) {
+  return validate<ScheduledActionResults & V>(v, id, hashScheduledActionResults)
+}
+
+export interface FailedScheduling {
+  $type?: 'tools.ozone.moderation.scheduleAction#failedScheduling'
+  subject: string
+  error: string
+  errorCode?: string
+}
+
+const hashFailedScheduling = 'failedScheduling'
+
+export function isFailedScheduling<V>(v: V) {
+  return is$typed(v, id, hashFailedScheduling)
+}
+
+export function validateFailedScheduling<V>(v: V) {
+  return validate<FailedScheduling & V>(v, id, hashFailedScheduling)
+}

package/src/mod-service/index.ts

@@ -39,6 +39,7 @@ import {
   isModEventTag,
   isModEventTakedown,
   isRecordEvent,
+  isScheduleTakedownEvent,
 } from '../lexicon/types/tools/ozone/moderation/defs'
 import { QueryParams as QueryStatusParams } from '../lexicon/types/tools/ozone/moderation/queryStatuses'
 import { httpLogger as log } from '../logger'
@@ -532,6 +533,18 @@ export class ModerationService {
       meta.status = event.status
     }
 
+    if (isScheduleTakedownEvent(event)) {
+      if (event.executeAfter) {
+        meta.executeAfter = event.executeAfter
+      }
+      if (event.executeAt) {
+        meta.executeAt = event.executeAt
+      }
+      if (event.executeUntil) {
+        meta.executeUntil = event.executeUntil
+      }
+    }
+
     if (
       (isModEventTakedown(event) || isModEventAcknowledge(event)) &&
       event.acknowledgeAccountSubjects

package/src/mod-service/views.ts

@@ -44,6 +44,7 @@ import {
   isModEventTag,
   isModEventTakedown,
   isRecordEvent,
+  isScheduleTakedownEvent,
 } from '../lexicon/types/tools/ozone/moderation/defs'
 import { Un$Typed, asPredicate } from '../lexicon/util'
 import { dbLogger, httpLogger } from '../logger'
@@ -262,6 +263,12 @@ export class ModerationViews {
       event.status = ifString(meta.status)!
     }
 
+    if (isScheduleTakedownEvent(event)) {
+      event.executeAt = ifString(meta.executeAt)
+      event.executeAfter = ifString(meta.executeAfter)
+      event.executeUntil = ifString(meta.executeUntil)
+    }
+
     return eventView
   }
 

package/src/scheduled-action/service.ts

@@ -0,0 +1,279 @@
+import { Selectable } from 'kysely'
+import { InvalidRequestError } from '@atproto/xrpc-server'
+import { ScheduledActionStatus, ScheduledActionType } from '../api/util'
+import { Database } from '../db'
+import { ScheduledAction } from '../db/schema/scheduled-action'
+import { ScheduledActionView } from '../lexicon/types/tools/ozone/moderation/defs'
+import { dbLogger } from '../logger'
+import { SchedulingParams } from './types'
+
+export type ScheduledActionServiceCreator = (
+  db: Database,
+) => ScheduledActionService
+
+export class ScheduledActionService {
+  constructor(public db: Database) {}
+
+  static creator() {
+    return (db: Database) => new ScheduledActionService(db)
+  }
+
+  formatScheduledAction(
+    action: Selectable<ScheduledAction>,
+  ): ScheduledActionView {
+    return {
+      id: action.id,
+      action: action.action,
+      eventData: action.eventData as { [x: string]: unknown } | undefined,
+      did: action.did,
+      executeAt: action.executeAt
+        ? new Date(action.executeAt).toISOString()
+        : undefined,
+      executeAfter: action.executeAfter
+        ? new Date(action.executeAfter).toISOString()
+        : undefined,
+      executeUntil: action.executeUntil
+        ? new Date(action.executeUntil).toISOString()
+        : undefined,
+      randomizeExecution: action.randomizeExecution,
+      createdBy: action.createdBy,
+      createdAt: new Date(action.createdAt).toISOString(),
+      updatedAt: new Date(action.updatedAt).toISOString(),
+      status: action.status,
+      lastExecutedAt: action.lastExecutedAt
+        ? new Date(action.lastExecutedAt).toISOString()
+        : undefined,
+      lastFailureReason: action.lastFailureReason || undefined,
+      executionEventId: action.executionEventId || undefined,
+    }
+  }
+
+  async scheduleAction(
+    schedulingParams: SchedulingParams,
+  ): Promise<Selectable<ScheduledAction>> {
+    const { action, eventData, did, createdBy } = schedulingParams
+
+    // Only allow one pending action at a time for a given subject and action type
+    const existingAction = await this.getPendingActionForSubject(did, action)
+    if (existingAction) {
+      throw new InvalidRequestError(
+        'A pending scheduled action already exists for this subject',
+        'ActionAlreadyExists',
+      )
+    }
+
+    // When a time-range for action is specified, ensure that the range is valid
+    if (
+      'executeAfter' in schedulingParams &&
+      schedulingParams.executeAfter &&
+      schedulingParams.executeUntil &&
+      schedulingParams.executeAfter >= schedulingParams.executeUntil
+    ) {
+      throw new InvalidRequestError(
+        'executeAfter must be before executeUntil',
+        'InvalidScheduling',
+      )
+    }
+
+    const now = new Date().toISOString()
+    const randomizeExecution =
+      !('executeAt' in schedulingParams) && 'executeAfter' in schedulingParams
+
+    const scheduledAction = await this.db.db
+      .insertInto('scheduled_action')
+      .values({
+        action,
+        eventData: JSON.stringify(eventData),
+        did,
+        executeAt: randomizeExecution
+          ? null
+          : schedulingParams.executeAt?.toISOString(),
+        executeAfter: randomizeExecution
+          ? schedulingParams.executeAfter?.toISOString()
+          : null,
+        executeUntil: randomizeExecution
+          ? schedulingParams.executeUntil?.toISOString()
+          : null,
+        randomizeExecution,
+        createdBy,
+        createdAt: now,
+        updatedAt: now,
+        status: 'pending',
+      })
+      .returningAll()
+      .executeTakeFirstOrThrow()
+
+    return scheduledAction
+  }
+
+  async getPendingActionForSubject(
+    did: string,
+    action: ScheduledActionType,
+  ): Promise<Selectable<ScheduledAction> | null> {
+    const scheduledAction = await this.db.db
+      .selectFrom('scheduled_action')
+      .selectAll()
+      .where('did', '=', did)
+      .where('action', '=', action)
+      .where('status', '=', 'pending')
+      .executeTakeFirst()
+
+    return scheduledAction || null
+  }
+
+  async listScheduledActions({
+    cursor,
+    limit = 50,
+    startTime,
+    endTime,
+    subjects,
+    statuses = [],
+    direction = 'desc',
+  }: {
+    cursor?: string
+    limit?: number
+    startTime?: Date
+    endTime?: Date
+    subjects?: string[]
+    statuses: ScheduledActionStatus[]
+    direction?: 'asc' | 'desc'
+  }): Promise<{
+    actions: Selectable<ScheduledAction>[]
+    cursor?: string
+  }> {
+    let query = this.db.db
+      .selectFrom('scheduled_action')
+      .where('status', 'in', statuses)
+      .selectAll()
+
+    if (subjects && subjects.length > 0) {
+      query = query.where('did', 'in', subjects)
+    }
+
+    if (startTime) {
+      query = query.where((qb) => {
+        return qb
+          .orWhere('executeAt', '>=', startTime.toISOString())
+          .orWhere('executeAfter', '>=', startTime.toISOString())
+      })
+    }
+
+    if (endTime) {
+      query = query.where((qb) => {
+        return qb
+          .orWhere('executeAt', '<=', endTime.toISOString())
+          .orWhere('executeUntil', '<=', endTime.toISOString())
+          .orWhere((sqb) => {
+            return sqb
+              .where('executeUntil', 'is', null)
+              .where('executeAfter', '<=', endTime.toISOString())
+          })
+      })
+    }
+
+    if (cursor) {
+      query = query.where(
+        'id',
+        direction === 'asc' ? '>' : '<',
+        parseInt(cursor, 10),
+      )
+    }
+
+    const actions = await query.orderBy('id', direction).limit(limit).execute()
+
+    return {
+      actions,
+      cursor: actions.at(-1)?.id?.toString(),
+    }
+  }
+
+  async cancelScheduledActions(subjects: string[]): Promise<{
+    succeeded: string[]
+    failed: { did: string; error: string; errorCode?: string }[]
+  }> {
+    const succeeded: string[] = []
+    const failed: { did: string; error: string; errorCode?: string }[] = []
+
+    for (const did of subjects) {
+      try {
+        const result = await this.db.db
+          .updateTable('scheduled_action')
+          .set({
+            status: 'cancelled',
+            updatedAt: new Date().toISOString(),
+          })
+          .where('did', '=', did)
+          .where('status', '=', 'pending')
+          .executeTakeFirst()
+
+        if (result.numUpdatedRows && result.numUpdatedRows > 0) {
+          succeeded.push(did)
+        } else {
+          failed.push({
+            did,
+            error: 'No pending scheduled actions found for subject',
+            errorCode: 'NoPendingActions',
+          })
+        }
+      } catch (err) {
+        dbLogger.error({ err, subjects }, 'Error cancelling scheduled action')
+        failed.push({
+          did,
+          error: 'Unknown error',
+          errorCode: 'DatabaseError',
+        })
+      }
+    }
+
+    return { succeeded, failed }
+  }
+
+  async getPendingActionsToExecute(
+    now: Date,
+  ): Promise<Selectable<ScheduledAction>[]> {
+    return await this.db.db
+      .selectFrom('scheduled_action')
+      .selectAll()
+      .where('status', '=', 'pending')
+      .where((qb) => {
+        return qb
+          .orWhere('executeAfter', '<=', now.toISOString())
+          .orWhere('executeAt', '<=', now.toISOString())
+      })
+      .execute()
+  }
+
+  async markActionAsExecuted(
+    actionId: number,
+    executionEventId: number,
+  ): Promise<void> {
+    const now = new Date().toISOString()
+    await this.db.db
+      .updateTable('scheduled_action')
+      .set({
+        status: 'executed',
+        lastExecutedAt: now,
+        executionEventId,
+        updatedAt: now,
+      })
+      .where('id', '=', actionId)
+      .execute()
+  }
+
+  async markActionAsFailed(
+    actionId: number,
+    failureReason: string,
+  ): Promise<void> {
+    const now = new Date().toISOString()
+    await this.db.db
+      .updateTable('scheduled_action')
+      .set({
+        status: 'failed',
+        lastExecutedAt: now,
+        lastFailureReason: failureReason,
+        updatedAt: now,
+      })
+      .where('id', '=', actionId)
+      .execute()
+  }
+}

package/src/scheduled-action/types.ts

@@ -0,0 +1,17 @@
+import { ScheduledActionType } from '../api/util'
+
+export type ExecutionSchedule =
+  | {
+      executeAt: Date
+    }
+  | {
+      executeAfter: Date
+      executeUntil?: Date
+    }
+
+export type SchedulingParams = {
+  action: ScheduledActionType
+  eventData: unknown
+  did: string
+  createdBy: string
+} & ExecutionSchedule