@atproto/ozone 0.1.146 → 0.1.147

package/src/daemon/context.ts

@@ -7,11 +7,14 @@ import { BackgroundQueue } from '../background'
 import { OzoneConfig, OzoneSecrets } from '../config'
 import { Database } from '../db'
 import { ModerationService } from '../mod-service'
+import { ScheduledActionService } from '../scheduled-action/service'
+import { SettingService } from '../setting/service'
 import { TeamService } from '../team'
 import { getSigningKeyId } from '../util'
 import { EventPusher } from './event-pusher'
 import { EventReverser } from './event-reverser'
 import { MaterializedViewRefresher } from './materialized-view-refresher'
+import { ScheduledActionProcessor } from './scheduled-action-processor'
 import { TeamProfileSynchronizer } from './team-profile-synchronizer'
 import { VerificationListener } from './verification-listener'
 
@@ -24,6 +27,7 @@ export type DaemonContextOptions = {
   eventReverser: EventReverser
   materializedViewRefresher: MaterializedViewRefresher
   teamProfileSynchronizer: TeamProfileSynchronizer
+  scheduledActionProcessor: ScheduledActionProcessor
   verificationListener?: VerificationListener
 }
 
@@ -72,6 +76,8 @@ export class DaemonContext {
       appviewAgent,
       createAuthHeaders,
     )
+    const settingService = SettingService.creator()
+    const scheduledActionService = ScheduledActionService.creator()
     const teamService = TeamService.creator(
       appviewAgent,
       cfg.appview.did,
@@ -90,6 +96,14 @@ export class DaemonContext {
       cfg.db.materializedViewRefreshIntervalMs,
     )
 
+    const scheduledActionProcessor = new ScheduledActionProcessor(
+      db,
+      cfg.service.did,
+      settingService,
+      modService,
+      scheduledActionService,
+    )
+
     // Only spawn the listener if verifier config exists and a jetstream URL is provided
     const verificationListener =
       cfg.verifier && cfg.jetstreamUrl
@@ -109,6 +123,7 @@ export class DaemonContext {
       eventReverser,
       materializedViewRefresher,
       teamProfileSynchronizer,
+      scheduledActionProcessor,
       verificationListener,
       ...(overrides ?? {}),
     })
@@ -142,6 +157,10 @@ export class DaemonContext {
     return this.opts.teamProfileSynchronizer
   }
 
+  get scheduledActionProcessor(): ScheduledActionProcessor {
+    return this.opts.scheduledActionProcessor
+  }
+
   get verificationListener(): VerificationListener | undefined {
     return this.opts.verificationListener
   }
@@ -151,6 +170,7 @@ export class DaemonContext {
     this.eventReverser.start()
     this.materializedViewRefresher.start()
     this.teamProfileSynchronizer.start()
+    this.scheduledActionProcessor.start()
     this.verificationListener?.start()
   }
 
@@ -168,6 +188,7 @@ export class DaemonContext {
         this.eventPusher.destroy(),
         this.materializedViewRefresher.destroy(),
         this.teamProfileSynchronizer.destroy(),
+        this.scheduledActionProcessor.destroy(),
         this.verificationListener?.stop(),
       ])
     } finally {

package/src/daemon/index.ts

@@ -5,6 +5,7 @@ import { DaemonContext } from './context'
 export { EventPusher } from './event-pusher'
 export { BlobDiverter } from './blob-diverter'
 export { EventReverser } from './event-reverser'
+export { ScheduledActionProcessor } from './scheduled-action-processor'
 
 export class OzoneDaemon {
   constructor(public ctx: DaemonContext) {}

package/src/daemon/scheduled-action-processor.ts

@@ -0,0 +1,243 @@
+import { Selectable } from 'kysely'
+import { MINUTE, SECOND } from '@atproto/common'
+import {
+  assertProtectedTagAction,
+  getProtectedTags,
+} from '../api/moderation/util'
+import { Database } from '../db'
+import { ScheduledAction } from '../db/schema/scheduled-action'
+import {
+  ModEventTakedown,
+  ModTool,
+} from '../lexicon/types/tools/ozone/moderation/defs'
+import { dbLogger } from '../logger'
+import { ModerationService, ModerationServiceCreator } from '../mod-service'
+import { RepoSubject } from '../mod-service/subject'
+import { ModEventType } from '../mod-service/types'
+import { ScheduledActionServiceCreator } from '../scheduled-action/service'
+import { SettingService, SettingServiceCreator } from '../setting/service'
+
+export class ScheduledActionProcessor {
+  destroyed = false
+  processingPromise: Promise<void> = Promise.resolve()
+  timer?: NodeJS.Timeout
+
+  constructor(
+    private db: Database,
+    private serviceDid: string,
+    private settingService: SettingServiceCreator,
+    private modService: ModerationServiceCreator,
+    private scheduledActionService: ScheduledActionServiceCreator,
+  ) {}
+
+  start() {
+    this.poll()
+  }
+
+  poll() {
+    if (this.destroyed) return
+    this.processingPromise = this.findAndExecuteScheduledActions()
+      .catch((err) =>
+        dbLogger.error({ err }, 'scheduled action processing errored'),
+      )
+      .finally(() => {
+        this.timer = setTimeout(() => this.poll(), getInterval())
+      })
+  }
+
+  async destroy() {
+    this.destroyed = true
+    if (this.timer) {
+      clearTimeout(this.timer)
+      this.timer = undefined
+    }
+    await this.processingPromise
+  }
+
+  async executeScheduledAction(actionId: number) {
+    await this.db.transaction(async (dbTxn) => {
+      const settingService = this.settingService(dbTxn)
+      const moderationTxn = this.modService(dbTxn)
+      const scheduledActionTxn = this.scheduledActionService(dbTxn)
+
+      try {
+        // maybe overfetching here to get the action again within the transaction to ensure it's still pending
+        const action = await dbTxn.db
+          .selectFrom('scheduled_action')
+          .selectAll()
+          .where('id', '=', actionId)
+          .where('status', '=', 'pending')
+          .executeTakeFirst()
+
+        if (!action) {
+          // already processed or cancelled
+          return
+        }
+
+        let event: ModEventType
+        let modTool: ModTool | undefined
+
+        // Create the appropriate moderation action based on the scheduled action type
+        switch (action.action) {
+          case 'takedown':
+            {
+              const eventData = action.eventData as ModEventTakedown & {
+                modTool?: ModTool
+              }
+              modTool = eventData.modTool
+              event = {
+                $type: 'tools.ozone.moderation.defs#modEventTakedown',
+                comment: `[SCHEDULED_ACTION] ${eventData.comment || 'Scheduled takedown executed'}`,
+                durationInHours: eventData.durationInHours,
+                acknowledgeAccountSubjects:
+                  eventData.acknowledgeAccountSubjects,
+                policies: eventData.policies,
+              }
+            }
+            break
+          default:
+            throw new Error(
+              `Unsupported scheduled action type: ${action.action}`,
+            )
+        }
+
+        const moderationEvent = await this.performTakedown({
+          action,
+          event,
+          modTool,
+          moderationTxn,
+          settingService,
+        })
+
+        // Mark the scheduled action as executed
+        await scheduledActionTxn.markActionAsExecuted(
+          actionId,
+          moderationEvent.event.id,
+        )
+
+        dbLogger.info(
+          {
+            did: action.did,
+            scheduledActionId: actionId,
+            moderationEventId: moderationEvent.event.id,
+          },
+          'executed scheduled action',
+        )
+      } catch (error) {
+        const errorMessage =
+          error instanceof Error ? error.message : 'Unknown error'
+
+        // mark as failed
+        await scheduledActionTxn.markActionAsFailed(actionId, errorMessage)
+
+        dbLogger.error(
+          {
+            scheduledActionId: actionId,
+            error: errorMessage,
+          },
+          'failed to execute scheduled action',
+        )
+      }
+    })
+  }
+
+  async performTakedown({
+    action,
+    event,
+    modTool,
+    moderationTxn,
+    settingService,
+  }: {
+    action: Selectable<ScheduledAction>
+    event: ModEventType
+    modTool: ModTool | undefined
+
+    moderationTxn: ModerationService
+    settingService: SettingService
+  }) {
+    const subject = new RepoSubject(action.did)
+
+    const status = await moderationTxn.getStatus(subject)
+
+    if (status?.takendown) {
+      throw new Error(`Account is already taken down`)
+    }
+
+    if (status?.tags?.length) {
+      const protectedTags = await getProtectedTags(
+        settingService,
+        this.serviceDid,
+      )
+
+      if (protectedTags) {
+        assertProtectedTagAction({
+          protectedTags,
+          subjectTags: status.tags,
+          actionAuthor: action.createdBy,
+          isAdmin: true,
+          isModerator: false,
+          isTriage: false,
+        })
+      }
+    }
+
+    // log the event which also applies the necessary state changes to moderation subject
+    const moderationEvent = await moderationTxn.logEvent({
+      event,
+      subject,
+      modTool,
+      createdBy: action.createdBy,
+    })
+
+    // register the takedown in event pusher
+    await moderationTxn.takedownRepo(subject, moderationEvent.event.id)
+
+    return moderationEvent
+  }
+
+  async findAndExecuteScheduledActions() {
+    const scheduledActionService = this.scheduledActionService(this.db)
+    const now = new Date()
+
+    const actionsToExecute =
+      await scheduledActionService.getPendingActionsToExecute(now)
+
+    for (const action of actionsToExecute) {
+      // For randomized execution, check if we should execute now or wait
+      if (action.randomizeExecution && action.executeAfter) {
+        const executeAfter = new Date(action.executeAfter)
+        // Default to a 30 second window for execution
+        const executeUntil = action.executeUntil
+          ? new Date(action.executeUntil)
+          : new Date(executeAfter.getTime() + 30 * SECOND)
+
+        // Only execute if we're past the earliest time
+        if (now < executeAfter) {
+          continue
+        }
+
+        // For randomized scheduling, randomly decide whether to execute now
+        // The probability increases as we get closer to the deadline
+        const timeRange = executeUntil.getTime() - executeAfter.getTime()
+        const timeElapsed = now.getTime() - executeAfter.getTime()
+        const executeProb = Math.min(timeElapsed / timeRange, 1)
+
+        // Execute with increasing probability as we approach the deadline
+        // Always execute if we're at or past the deadline
+        if (now < executeUntil && Math.random() > executeProb * 0.1) {
+          continue
+        }
+      }
+
+      await this.executeScheduledAction(action.id)
+    }
+  }
+}
+
+const getInterval = (): number => {
+  // Process scheduled actions every minute
+  const now = Date.now()
+  const intervalMs = MINUTE
+  const nextIteration = Math.ceil(now / intervalMs)
+  return nextIteration * intervalMs - now
+}

package/src/db/migrations/20250923T000000000Z-scheduled-actions.ts

@@ -0,0 +1,56 @@
+import { Kysely, sql } from 'kysely'
+
+export async function up(db: Kysely<unknown>): Promise<void> {
+  await db.schema
+    .createTable('scheduled_action')
+    .addColumn('id', 'bigserial', (col) => col.primaryKey())
+    .addColumn('action', 'varchar', (col) => col.notNull())
+    .addColumn('eventData', 'jsonb')
+    .addColumn('did', 'varchar', (col) => col.notNull())
+    .addColumn('executeAt', 'varchar')
+    .addColumn('executeAfter', 'varchar')
+    .addColumn('executeUntil', 'varchar')
+    .addColumn('randomizeExecution', 'boolean', (col) =>
+      col.notNull().defaultTo(false),
+    )
+    .addColumn('createdBy', 'varchar', (col) => col.notNull())
+    .addColumn('createdAt', 'varchar', (col) => col.notNull())
+    .addColumn('updatedAt', 'varchar', (col) => col.notNull())
+    .addColumn('status', 'varchar', (col) => col.notNull().defaultTo('pending'))
+    .addColumn('lastExecutedAt', 'varchar')
+    .addColumn('lastFailureReason', 'text')
+    .addColumn('executionEventId', 'bigint')
+    .execute()
+
+  // Unique constraint to prevent multiple pending actions for the same subject
+  await sql`
+    CREATE UNIQUE INDEX scheduled_action_unique_pending_subject
+    ON scheduled_action (did, action)
+    WHERE status = 'pending'
+  `.execute(db)
+
+  // for task runner to query pending actions efficiently
+  await db.schema
+    .createIndex('scheduled_action_execute_time_idx')
+    .on('scheduled_action')
+    .columns(['executeAt', 'executeAfter', 'status'])
+    .execute()
+
+  // for querying actions by subject
+  await db.schema
+    .createIndex('scheduled_action_did_idx')
+    .on('scheduled_action')
+    .column('did')
+    .execute()
+
+  // we require status to be always passed when listing scheduled actions and use createdAt for pagination
+  await db.schema
+    .createIndex('scheduled_action_status_created_at_idx')
+    .on('scheduled_action')
+    .columns(['status', 'createdAt'])
+    .execute()
+}
+
+export async function down(db: Kysely<unknown>): Promise<void> {
+  await db.schema.dropTable('scheduled_action').execute()
+}

package/src/db/migrations/index.ts

@@ -30,3 +30,5 @@ export * as _20250618T180246000Z from './20250618T180246000Z-add-mod-tool-to-mod
 export * as _20250701T000000000Z from './20250701T000000000Z-add-age-assurance-state'
 export * as _20250715T000000000Z from './20250715T000000000Z-add-mod-event-external-id'
 export * as _20250718T150931000Z from './20250718T150931000Z-update-appeal-reason-stats'
+export * as _20250813T000000000Z from './20250813T000000000Z-mod-tool-batch-id-index'
+export * as _20250923T000000000Z from './20250923T000000000Z-scheduled-actions'

package/src/db/schema/index.ts

@@ -14,6 +14,7 @@ import * as recordEventsStats from './record_events_stats'
 import * as recordPushEvent from './record_push_event'
 import * as repoPushEvent from './repo_push_event'
 import * as safelink from './safelink'
+import * as scheduledAction from './scheduled-action'
 import * as setting from './setting'
 import * as signingKey from './signing_key'
 import * as verification from './verification'
@@ -35,7 +36,8 @@ export type DatabaseSchemaType = modEvent.PartialDB &
   accountRecordStatusStats.PartialDB &
   verification.PartialDB &
   firehoseCursor.PartialDB &
-  safelink.PartialDB
+  safelink.PartialDB &
+  scheduledAction.PartialDB
 
 export type DatabaseSchema = Kysely<DatabaseSchemaType>
 

package/src/db/schema/scheduled-action.ts

@@ -0,0 +1,25 @@
+import { GeneratedAlways } from 'kysely'
+
+export const scheduledActionTableName = 'scheduled_action'
+
+export interface ScheduledAction {
+  id: GeneratedAlways<number>
+  action: string
+  eventData: unknown | null
+  did: string
+  executeAt: string | null
+  executeAfter: string | null
+  executeUntil: string | null
+  randomizeExecution: boolean
+  createdBy: string
+  createdAt: string
+  updatedAt: string
+  status: string
+  lastExecutedAt: string | null
+  lastFailureReason: string | null
+  executionEventId: number | null
+}
+
+export type PartialDB = {
+  [scheduledActionTableName]: ScheduledAction
+}

package/src/lexicon/index.ts

@@ -209,6 +209,7 @@ import * as ToolsOzoneCommunicationDeleteTemplate from './types/tools/ozone/comm
 import * as ToolsOzoneCommunicationListTemplates from './types/tools/ozone/communication/listTemplates.js'
 import * as ToolsOzoneCommunicationUpdateTemplate from './types/tools/ozone/communication/updateTemplate.js'
 import * as ToolsOzoneHostingGetAccountHistory from './types/tools/ozone/hosting/getAccountHistory.js'
+import * as ToolsOzoneModerationCancelScheduledActions from './types/tools/ozone/moderation/cancelScheduledActions.js'
 import * as ToolsOzoneModerationEmitEvent from './types/tools/ozone/moderation/emitEvent.js'
 import * as ToolsOzoneModerationGetAccountTimeline from './types/tools/ozone/moderation/getAccountTimeline.js'
 import * as ToolsOzoneModerationGetEvent from './types/tools/ozone/moderation/getEvent.js'
@@ -218,8 +219,10 @@ import * as ToolsOzoneModerationGetRepo from './types/tools/ozone/moderation/get
 import * as ToolsOzoneModerationGetReporterStats from './types/tools/ozone/moderation/getReporterStats.js'
 import * as ToolsOzoneModerationGetRepos from './types/tools/ozone/moderation/getRepos.js'
 import * as ToolsOzoneModerationGetSubjects from './types/tools/ozone/moderation/getSubjects.js'
+import * as ToolsOzoneModerationListScheduledActions from './types/tools/ozone/moderation/listScheduledActions.js'
 import * as ToolsOzoneModerationQueryEvents from './types/tools/ozone/moderation/queryEvents.js'
 import * as ToolsOzoneModerationQueryStatuses from './types/tools/ozone/moderation/queryStatuses.js'
+import * as ToolsOzoneModerationScheduleAction from './types/tools/ozone/moderation/scheduleAction.js'
 import * as ToolsOzoneModerationSearchRepos from './types/tools/ozone/moderation/searchRepos.js'
 import * as ToolsOzoneSafelinkAddRule from './types/tools/ozone/safelink/addRule.js'
 import * as ToolsOzoneSafelinkQueryEvents from './types/tools/ozone/safelink/queryEvents.js'
@@ -3109,6 +3112,18 @@ export class ToolsOzoneModerationNS {
     this._server = server
   }
 
+  cancelScheduledActions<A extends Auth = void>(
+    cfg: MethodConfigOrHandler<
+      A,
+      ToolsOzoneModerationCancelScheduledActions.QueryParams,
+      ToolsOzoneModerationCancelScheduledActions.HandlerInput,
+      ToolsOzoneModerationCancelScheduledActions.HandlerOutput
+    >,
+  ) {
+    const nsid = 'tools.ozone.moderation.cancelScheduledActions' // @ts-ignore
+    return this._server.xrpc.method(nsid, cfg)
+  }
+
   emitEvent<A extends Auth = void>(
     cfg: MethodConfigOrHandler<
       A,
@@ -3217,6 +3232,18 @@ export class ToolsOzoneModerationNS {
     return this._server.xrpc.method(nsid, cfg)
   }
 
+  listScheduledActions<A extends Auth = void>(
+    cfg: MethodConfigOrHandler<
+      A,
+      ToolsOzoneModerationListScheduledActions.QueryParams,
+      ToolsOzoneModerationListScheduledActions.HandlerInput,
+      ToolsOzoneModerationListScheduledActions.HandlerOutput
+    >,
+  ) {
+    const nsid = 'tools.ozone.moderation.listScheduledActions' // @ts-ignore
+    return this._server.xrpc.method(nsid, cfg)
+  }
+
   queryEvents<A extends Auth = void>(
     cfg: MethodConfigOrHandler<
       A,
@@ -3241,6 +3268,18 @@ export class ToolsOzoneModerationNS {
     return this._server.xrpc.method(nsid, cfg)
   }
 
+  scheduleAction<A extends Auth = void>(
+    cfg: MethodConfigOrHandler<
+      A,
+      ToolsOzoneModerationScheduleAction.QueryParams,
+      ToolsOzoneModerationScheduleAction.HandlerInput,
+      ToolsOzoneModerationScheduleAction.HandlerOutput
+    >,
+  ) {
+    const nsid = 'tools.ozone.moderation.scheduleAction' // @ts-ignore
+    return this._server.xrpc.method(nsid, cfg)
+  }
+
   searchRepos<A extends Auth = void>(
     cfg: MethodConfigOrHandler<
       A,