@atproto/ozone 0.1.146 → 0.1.148

package/src/api/moderation/cancelScheduledActions.ts

@@ -0,0 +1,72 @@
+import { AuthRequiredError } from '@atproto/xrpc-server'
+import { AppContext } from '../../context'
+import { Server } from '../../lexicon'
+import { subjectFromInput } from '../../mod-service/subject'
+import { ScheduledTakedownTag } from './util'
+
+export default function (server: Server, ctx: AppContext) {
+  server.tools.ozone.moderation.cancelScheduledActions({
+    auth: ctx.authVerifier.modOrAdminToken,
+    handler: async ({ input, auth }) => {
+      const access = auth.credentials
+      const db = ctx.db
+      const { subjects, comment } = input.body
+
+      if (!access.isModerator) {
+        throw new AuthRequiredError(
+          'Must be a moderator to cancel scheduled actions',
+        )
+      }
+
+      const createdBy =
+        access.type === 'admin_token' ? ctx.cfg.service.did : access.iss
+      const now = new Date()
+
+      const result = await db.transaction(async (tx) => {
+        const scheduledActionService = ctx.scheduledActionService(tx)
+        const modService = ctx.modService(tx)
+
+        const cancellations =
+          await scheduledActionService.cancelScheduledActions(subjects)
+
+        for (const subject of cancellations.succeeded) {
+          await modService.logEvent({
+            event: {
+              $type: 'tools.ozone.moderation.defs#cancelScheduledTakedownEvent',
+              comment,
+            },
+            subject: subjectFromInput({
+              did: subject,
+              $type: 'com.atproto.admin.defs#repoRef',
+            }),
+            createdBy,
+            createdAt: now,
+          })
+          await modService.logEvent({
+            event: {
+              $type: 'tools.ozone.moderation.defs#modEventTag',
+              remove: [ScheduledTakedownTag],
+              add: [],
+            },
+            subject: subjectFromInput({
+              did: subject,
+              $type: 'com.atproto.admin.defs#repoRef',
+            }),
+            createdBy,
+            createdAt: now,
+          })
+        }
+
+        return cancellations
+      })
+
+      return {
+        encoding: 'application/json',
+        body: {
+          succeeded: result.succeeded,
+          failed: result.failed,
+        },
+      }
+    },
+  })
+}

package/src/api/moderation/emitEvent.ts

@@ -21,13 +21,12 @@ import {
 } from '../../lexicon/types/tools/ozone/moderation/defs'
 import { HandlerInput } from '../../lexicon/types/tools/ozone/moderation/emitEvent'
 import { subjectFromInput } from '../../mod-service/subject'
-import { ProtectedTagSettingKey } from '../../setting/constants'
 import { SettingService } from '../../setting/service'
-import { ProtectedTagSetting } from '../../setting/types'
 import { TagService } from '../../tag-service'
 import { getTagForReport } from '../../tag-service/util'
 import { retryHttp } from '../../util'
 import { getEventType } from '../util'
+import { assertProtectedTagAction, getProtectedTags } from './util'
 
 const handleModerationEvent = async ({
   ctx,
@@ -140,7 +139,14 @@ const handleModerationEvent = async ({
       )
 
       if (protectedTags) {
-        assertProtectedTagAction(protectedTags, status.tags, createdBy, auth)
+        assertProtectedTagAction({
+          protectedTags,
+          subjectTags: status.tags,
+          actionAuthor: createdBy,
+          isAdmin: auth.credentials.isAdmin,
+          isModerator: auth.credentials.isModerator,
+          isTriage: auth.credentials.isTriage,
+        })
       }
     }
 
@@ -317,68 +323,6 @@ export default function (server: Server, ctx: AppContext) {
   })
 }
 
-const assertProtectedTagAction = (
-  protectedTags: ProtectedTagSetting,
-  subjectTags: string[],
-  actionAuthor: string,
-  auth: ModeratorOutput | AdminTokenOutput,
-) => {
-  subjectTags.forEach((tag) => {
-    if (!Object.hasOwn(protectedTags, tag)) return
-    if (
-      protectedTags[tag]['moderators'] &&
-      !protectedTags[tag]['moderators'].includes(actionAuthor)
-    ) {
-      throw new InvalidRequestError(
-        `Not allowed to action on protected tag: ${tag}`,
-      )
-    }
-
-    if (protectedTags[tag]['roles']) {
-      if (auth.credentials.isAdmin) {
-        if (
-          protectedTags[tag]['roles'].includes(
-            'tools.ozone.team.defs#roleAdmin',
-          )
-        ) {
-          return
-        }
-        throw new InvalidRequestError(
-          `Not allowed to action on protected tag: ${tag}`,
-        )
-      }
-
-      if (auth.credentials.isModerator) {
-        if (
-          protectedTags[tag]['roles'].includes(
-            'tools.ozone.team.defs#roleModerator',
-          )
-        ) {
-          return
-        }
-
-        throw new InvalidRequestError(
-          `Not allowed to action on protected tag: ${tag}`,
-        )
-      }
-
-      if (auth.credentials.isTriage) {
-        if (
-          protectedTags[tag]['roles'].includes(
-            'tools.ozone.team.defs#roleTriage',
-          )
-        ) {
-          return
-        }
-
-        throw new InvalidRequestError(
-          `Not allowed to action on protected tag: ${tag}`,
-        )
-      }
-    }
-  })
-}
-
 const assertTagAuth = async (
   settingService: SettingService,
   serviceDid: string,
@@ -429,25 +373,6 @@ const assertTagAuth = async (
   }
 }
 
-const getProtectedTags = async (
-  settingService: SettingService,
-  serviceDid: string,
-) => {
-  const protectedTagSetting = await settingService.query({
-    keys: [ProtectedTagSettingKey],
-    scope: 'instance',
-    did: serviceDid,
-    limit: 1,
-  })
-
-  // if no protected tags are configured, then no need to do further check
-  if (!protectedTagSetting.options.length) {
-    return
-  }
-
-  return protectedTagSetting.options[0].value as ProtectedTagSetting
-}
-
 const validateLabels = (labels: string[]) => {
   for (const label of labels) {
     for (const char of badChars) {

package/src/api/moderation/listScheduledActions.ts

@@ -0,0 +1,45 @@
+import { AppContext } from '../../context'
+import { Server } from '../../lexicon'
+import { getScheduledActionStatus } from '../util'
+
+export default function (server: Server, ctx: AppContext) {
+  server.tools.ozone.moderation.listScheduledActions({
+    auth: ctx.authVerifier.modOrAdminToken,
+    handler: async ({ input }) => {
+      const db = ctx.db
+      const {
+        startsAfter,
+        endsBefore,
+        subjects,
+        statuses,
+        limit = 50,
+        cursor,
+      } = input.body
+
+      const scheduledActionService = ctx.scheduledActionService(db)
+
+      const parsedStatuses = statuses.map((status) =>
+        getScheduledActionStatus(status),
+      )
+
+      const result = await scheduledActionService.listScheduledActions({
+        cursor,
+        limit,
+        startTime: startsAfter ? new Date(startsAfter) : undefined,
+        endTime: endsBefore ? new Date(endsBefore) : undefined,
+        subjects,
+        statuses: parsedStatuses,
+      })
+
+      return {
+        encoding: 'application/json',
+        body: {
+          actions: result.actions.map((action) =>
+            scheduledActionService.formatScheduledAction(action),
+          ),
+          cursor: result.cursor,
+        },
+      }
+    },
+  })
+}

package/src/api/moderation/scheduleAction.ts

@@ -0,0 +1,129 @@
+import { ToolsOzoneModerationScheduleAction } from '@atproto/api'
+import { AuthRequiredError, InvalidRequestError } from '@atproto/xrpc-server'
+import { AppContext } from '../../context'
+import { Server } from '../../lexicon'
+import { subjectFromInput } from '../../mod-service/subject'
+import { ExecutionSchedule } from '../../scheduled-action/types'
+import { getScheduledActionType } from '../util'
+import { ScheduledTakedownTag } from './util'
+
+export default function (server: Server, ctx: AppContext) {
+  server.tools.ozone.moderation.scheduleAction({
+    auth: ctx.authVerifier.modOrAdminToken,
+    handler: async ({ input, auth }) => {
+      const access = auth.credentials
+      const db = ctx.db
+      const { action, subjects, createdBy, scheduling, modTool } = input.body
+
+      if (!access.isModerator) {
+        throw new AuthRequiredError('Must be a moderator to schedule actions')
+      }
+
+      if (access.type === 'admin_token' && !createdBy) {
+        throw new AuthRequiredError(
+          'Must specify createdBy when using admin auth',
+        )
+      }
+
+      const actionType = getScheduledActionType(
+        action.$type?.split('#')[1] || '',
+      )
+
+      const succeeded: string[] = []
+      const failed: ToolsOzoneModerationScheduleAction.FailedScheduling[] = []
+
+      // Defining alternatively required fields is not supported by lexicons so we need to manually validate here
+      if (!scheduling.executeAt && !scheduling.executeAfter) {
+        throw new InvalidRequestError('Must specify an execution schedule')
+      }
+
+      const executionSchedule: ExecutionSchedule = scheduling.executeAt
+        ? { executeAt: new Date(scheduling.executeAt) }
+        : {
+            executeAfter: new Date(scheduling.executeAfter!),
+            executeUntil: scheduling.executeUntil
+              ? new Date(scheduling.executeUntil)
+              : undefined,
+          }
+
+      const eventData = { ...action, modTool }
+      const actualCreatedBy =
+        access.type === 'admin_token' ? createdBy : access.iss
+
+      const now = new Date()
+      for (const subject of subjects) {
+        try {
+          await db.transaction(async (tx) => {
+            const modService = ctx.modService(tx)
+            const scheduledActionService = ctx.scheduledActionService(tx)
+            // register the action in database
+            await scheduledActionService.scheduleAction({
+              action: actionType,
+              eventData,
+              did: subject,
+              createdBy: actualCreatedBy,
+              ...executionSchedule,
+            })
+            // log an event in the mod event stream
+            if (ToolsOzoneModerationScheduleAction.isTakedown(action)) {
+              await modService.logEvent({
+                event: {
+                  $type: 'tools.ozone.moderation.defs#scheduleTakedownEvent',
+                  executeAfter: scheduling.executeAfter,
+                  executeUntil: scheduling.executeUntil,
+                  executeAt: scheduling.executeAt,
+                  comment: action.comment,
+                },
+                subject: subjectFromInput({
+                  did: subject,
+                  $type: 'com.atproto.admin.defs#repoRef',
+                }),
+                createdBy: actualCreatedBy,
+                createdAt: now,
+                modTool,
+              })
+              await modService.logEvent({
+                event: {
+                  $type: 'tools.ozone.moderation.defs#modEventTag',
+                  add: [ScheduledTakedownTag],
+                  remove: [],
+                },
+                subject: subjectFromInput({
+                  did: subject,
+                  $type: 'com.atproto.admin.defs#repoRef',
+                }),
+                createdBy,
+                createdAt: now,
+              })
+            }
+            succeeded.push(subject)
+          })
+        } catch (error) {
+          let errorMessage = 'Unknown error'
+          let errorCode: string | undefined
+
+          if (error instanceof InvalidRequestError) {
+            errorMessage = error.message
+            errorCode = 'InvalidRequest'
+          } else if (error instanceof Error) {
+            errorMessage = error.message
+          }
+
+          failed.push({
+            subject,
+            error: errorMessage,
+            errorCode,
+          })
+        }
+      }
+
+      return {
+        encoding: 'application/json',
+        body: {
+          succeeded,
+          failed,
+        },
+      }
+    },
+  })
+}

package/src/api/moderation/util.ts

@@ -0,0 +1,96 @@
+import { InvalidRequestError } from '@atproto/xrpc-server'
+import { ProtectedTagSettingKey } from '../../setting/constants'
+import { SettingService } from '../../setting/service'
+import { ProtectedTagSetting } from '../../setting/types'
+
+export const getProtectedTags = async (
+  settingService: SettingService,
+  serviceDid: string,
+) => {
+  const protectedTagSetting = await settingService.query({
+    keys: [ProtectedTagSettingKey],
+    scope: 'instance',
+    did: serviceDid,
+    limit: 1,
+  })
+
+  // if no protected tags are configured, then no need to do further check
+  if (!protectedTagSetting.options.length) {
+    return
+  }
+
+  return protectedTagSetting.options[0].value as ProtectedTagSetting
+}
+
+export const assertProtectedTagAction = ({
+  protectedTags,
+  subjectTags,
+  actionAuthor,
+  isModerator,
+  isAdmin,
+  isTriage,
+}: {
+  protectedTags: ProtectedTagSetting
+  subjectTags: string[]
+  actionAuthor: string
+  isModerator: boolean
+  isAdmin: boolean
+  isTriage: boolean
+}) => {
+  subjectTags.forEach((tag) => {
+    if (!Object.hasOwn(protectedTags, tag)) return
+    if (
+      protectedTags[tag]['moderators'] &&
+      !protectedTags[tag]['moderators'].includes(actionAuthor)
+    ) {
+      throw new InvalidRequestError(
+        `Not allowed to action on protected tag: ${tag}`,
+      )
+    }
+
+    if (protectedTags[tag]['roles']) {
+      if (isAdmin) {
+        if (
+          protectedTags[tag]['roles'].includes(
+            'tools.ozone.team.defs#roleAdmin',
+          )
+        ) {
+          return
+        }
+        throw new InvalidRequestError(
+          `Not allowed to action on protected tag: ${tag}`,
+        )
+      }
+
+      if (isModerator) {
+        if (
+          protectedTags[tag]['roles'].includes(
+            'tools.ozone.team.defs#roleModerator',
+          )
+        ) {
+          return
+        }
+
+        throw new InvalidRequestError(
+          `Not allowed to action on protected tag: ${tag}`,
+        )
+      }
+
+      if (isTriage) {
+        if (
+          protectedTags[tag]['roles'].includes(
+            'tools.ozone.team.defs#roleTriage',
+          )
+        ) {
+          return
+        }
+
+        throw new InvalidRequestError(
+          `Not allowed to action on protected tag: ${tag}`,
+        )
+      }
+    }
+  })
+}
+
+export const ScheduledTakedownTag = 'scheduled-takedown'

package/src/api/util.ts

@@ -152,6 +152,8 @@ const eventTypes = new Set([
   'tools.ozone.moderation.defs#ageAssuranceEvent',
   'tools.ozone.moderation.defs#ageAssuranceOverrideEvent',
   'tools.ozone.moderation.defs#revokeAccountCredentialsEvent',
+  'tools.ozone.moderation.defs#scheduleTakedownEvent',
+  'tools.ozone.moderation.defs#cancelScheduledTakedownEvent',
 ])
 
 export const getMemberRole = (role: string) => {
@@ -211,3 +213,34 @@ const safelinkPatterns = new Set(['domain', 'url'])
 const safelinkActions = new Set(['block', 'warn', 'whitelist'])
 const safelinkReasons = new Set(['csam', 'spam', 'phishing', 'none'])
 const safelinkEventTypes = new Set(['addRule', 'updateRule', 'removeRule'])
+
+export const getScheduledActionType = (action: string): ScheduledActionType => {
+  if (scheduledActionTypes.has(action)) {
+    return action as ScheduledActionType
+  }
+  throw new InvalidRequestError('Invalid scheduled action type')
+}
+
+export const getScheduledActionStatus = (
+  status: string,
+): ScheduledActionStatus => {
+  if (scheduledActionStatuses.has(status)) {
+    return status as ScheduledActionStatus
+  }
+  throw new InvalidRequestError('Invalid scheduled action status')
+}
+
+export type ScheduledActionType = 'takedown'
+export type ScheduledActionStatus =
+  | 'pending'
+  | 'executed'
+  | 'cancelled'
+  | 'failed'
+
+const scheduledActionTypes = new Set(['takedown'])
+const scheduledActionStatuses = new Set([
+  'pending',
+  'executed',
+  'cancelled',
+  'failed',
+])

package/src/context.ts

@@ -25,6 +25,10 @@ import {
   SafelinkRuleService,
   SafelinkRuleServiceCreator,
 } from './safelink/service'
+import {
+  ScheduledActionService,
+  ScheduledActionServiceCreator,
+} from './scheduled-action/service'
 import { Sequencer } from './sequencer/sequencer'
 import { SetService, SetServiceCreator } from './set/service'
 import { SettingService, SettingServiceCreator } from './setting/service'
@@ -52,6 +56,7 @@ export type AppContextOptions = {
   moderationServiceProfile: ModerationServiceProfileCreator
   communicationTemplateService: CommunicationTemplateServiceCreator
   safelinkRuleService: SafelinkRuleServiceCreator
+  scheduledActionService: ScheduledActionServiceCreator
   setService: SetServiceCreator
   settingService: SettingServiceCreator
   teamService: TeamServiceCreator
@@ -141,6 +146,7 @@ export class AppContext {
 
     const communicationTemplateService = CommunicationTemplateService.creator()
     const safelinkRuleService = SafelinkRuleService.creator()
+    const scheduledActionService = ScheduledActionService.creator()
     const teamService = TeamService.creator(
       appviewAgent,
       cfg.appview.did,
@@ -171,6 +177,7 @@ export class AppContext {
         moderationServiceProfile,
         communicationTemplateService,
         safelinkRuleService,
+        scheduledActionService,
         teamService,
         setService,
         settingService,
@@ -225,6 +232,10 @@ export class AppContext {
     return this.opts.safelinkRuleService
   }
 
+  get scheduledActionService(): ScheduledActionServiceCreator {
+    return this.opts.scheduledActionService
+  }
+
   get teamService(): TeamServiceCreator {
     return this.opts.teamService
   }

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) {}