@atproto/ozone 0.1.150 → 0.1.152

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

@@ -157,6 +157,7 @@ export interface SubjectStatusView {
   tags?: string[]
   accountStats?: AccountStats
   recordsStats?: RecordsStats
+  accountStrike?: AccountStrike
   /** Current age assurance state of the subject. */
   ageAssuranceState?:
     | 'pending'
@@ -256,6 +257,29 @@ export function validateRecordsStats<V>(v: V) {
   return validate<RecordsStats & V>(v, id, hashRecordsStats)
 }
 
+/** Strike information for an account */
+export interface AccountStrike {
+  $type?: 'tools.ozone.moderation.defs#accountStrike'
+  /** Current number of active strikes (excluding expired strikes) */
+  activeStrikeCount?: number
+  /** Total number of strikes ever received (including expired strikes) */
+  totalStrikeCount?: number
+  /** Timestamp of the first strike received */
+  firstStrikeAt?: string
+  /** Timestamp of the most recent strike received */
+  lastStrikeAt?: string
+}
+
+const hashAccountStrike = 'accountStrike'
+
+export function isAccountStrike<V>(v: V) {
+  return is$typed(v, id, hashAccountStrike)
+}
+
+export function validateAccountStrike<V>(v: V) {
+  return validate<AccountStrike & V>(v, id, hashAccountStrike)
+}
+
 export type SubjectReviewState =
   | 'lex:tools.ozone.moderation.defs#reviewOpen'
   | 'lex:tools.ozone.moderation.defs#reviewEscalated'
@@ -282,6 +306,12 @@ export interface ModEventTakedown {
   acknowledgeAccountSubjects?: boolean
   /** Names/Keywords of the policies that drove the decision. */
   policies?: string[]
+  /** Severity level of the violation (e.g., 'sev-0', 'sev-1', 'sev-2', etc.). */
+  severityLevel?: string
+  /** Number of strikes to assign to the user for this violation. */
+  strikeCount?: number
+  /** When the strike should expire. If not provided, the strike never expires. */
+  strikeExpiresAt?: string
 }
 
 const hashModEventTakedown = 'modEventTakedown'
@@ -299,6 +329,12 @@ export interface ModEventReverseTakedown {
   $type?: 'tools.ozone.moderation.defs#modEventReverseTakedown'
   /** Describe reasoning behind the reversal. */
   comment?: string
+  /** Names/Keywords of the policy infraction for which takedown is being reversed. */
+  policies?: string[]
+  /** Severity level of the violation. Usually set from the last policy infraction's severity. */
+  severityLevel?: string
+  /** Number of strikes to subtract from the user's strike count. Usually set from the last policy infraction's severity. */
+  strikeCount?: number
 }
 
 const hashModEventReverseTakedown = 'modEventReverseTakedown'
@@ -590,6 +626,14 @@ export interface ModEventEmail {
   content?: string
   /** Additional comment about the outgoing comm. */
   comment?: string
+  /** Names/Keywords of the policies that necessitated the email. */
+  policies?: string[]
+  /** Severity level of the violation. Normally 'sev-1' that adds strike on repeat offense */
+  severityLevel?: string
+  /** Number of strikes to assign to the user for this violation. Normally 0 as an indicator of a warning and only added as a strike on a repeat offense. */
+  strikeCount?: number
+  /** When the strike should expire. If not provided, the strike never expires. */
+  strikeExpiresAt?: string
 }
 
 const hashModEventEmail = 'modEventEmail'

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

@@ -59,6 +59,8 @@ export type QueryParams = {
     | 'reset'
     | 'blocked'
     | (string & {})
+  /** If specified, only events where strikeCount value is set are returned. */
+  withStrike?: boolean
   cursor?: string
 }
 export type InputSchema = undefined

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

@@ -82,6 +82,8 @@ export type QueryParams = {
   minTakendownRecordsCount?: number
   /** If specified, only subjects that have priority score value above the given value will be returned. */
   minPriorityScore?: number
+  /** If specified, only subjects that belong to an account that has at least this many active strikes will be returned. */
+  minStrikeCount?: number
   /** If specified, only subjects with the given age assurance state will be returned. */
   ageAssuranceState?:
     | 'pending'

package/src/mod-service/index.ts

@@ -36,6 +36,7 @@ import {
   isModEventMute,
   isModEventPriorityScore,
   isModEventReport,
+  isModEventReverseTakedown,
   isModEventTag,
   isModEventTakedown,
   isRecordEvent,
@@ -49,6 +50,7 @@ import {
   getStatusIdentifierFromSubject,
   moderationSubjectStatusQueryBuilder,
 } from './status'
+import { StrikeService, StrikeServiceCreator } from './strike'
 import {
   ModSubject,
   RecordSubject,
@@ -89,6 +91,7 @@ export class ModerationService {
       aud: string,
       method: string,
     ) => Promise<AuthHeaders>,
+    public strikeService: StrikeService,
     public imgInvalidator?: ImageInvalidator,
   ) {}
 
@@ -101,10 +104,12 @@ export class ModerationService {
     eventPusher: EventPusher,
     appviewAgent: AtpAgent,
     createAuthHeaders: (aud: string, method: string) => Promise<AuthHeaders>,
+    strikeServiceCreator: StrikeServiceCreator,
     imgInvalidator?: ImageInvalidator,
   ) {
-    return (db: Database) =>
-      new ModerationService(
+    return (db: Database) => {
+      const strikeService = strikeServiceCreator(db)
+      return new ModerationService(
         db,
         signingKey,
         signingKeyId,
@@ -114,8 +119,10 @@ export class ModerationService {
         eventPusher,
         appviewAgent,
         createAuthHeaders,
+        strikeService,
         imgInvalidator,
       )
+    }
   }
 
   views = new ModerationViews(
@@ -190,6 +197,7 @@ export class ModerationService {
     modTool?: string[]
     ageAssuranceState?: string
     batchId?: string
+    withStrike?: boolean
   }): Promise<{ cursor?: string; events: ModerationEventRow[] }> {
     const {
       subject,
@@ -214,6 +222,7 @@ export class ModerationService {
       modTool,
       ageAssuranceState,
       batchId,
+      withStrike,
     } = opts
     const { ref } = this.db.db.dynamic
     let builder = this.db.db.selectFrom('moderation_event').selectAll()
@@ -333,6 +342,10 @@ export class ModerationService {
         .where(sql`meta->>'status'`, '=', ageAssuranceState)
     }
 
+    if (withStrike !== undefined) {
+      builder = builder.where('strikeCount', 'is not', null)
+    }
+
     const keyset = new TimeIdKeyset(
       ref(`moderation_event.createdAt`),
       ref('moderation_event.id'),
@@ -484,6 +497,9 @@ export class ModerationService {
       if (event.content) {
         meta.content = event.content
       }
+      if (event.policies?.length) {
+        meta.policies = event.policies.join(',')
+      }
     }
 
     if (isAccountEvent(event)) {
@@ -566,6 +582,32 @@ export class ModerationService {
 
     const subjectInfo = subject.info()
 
+    // Store severityLevel, strikeCount, and strikeExpiresAt if provided
+    // These values should be calculated by the client based on configuration
+    // processNewEvent will update the account_strike table with the new strike count
+    let severityLevel: string | null = null
+    let strikeCount: number | null = null
+    let strikeExpiresAt: string | null = null
+
+    if (
+      isModEventTakedown(event) ||
+      isModEventEmail(event) ||
+      isModEventReverseTakedown(event)
+    ) {
+      // Store severityLevel if provided (for display/tracking)
+      if (event.severityLevel) {
+        severityLevel = event.severityLevel
+      }
+      // Store explicit strikeCount if provided
+      if (event.strikeCount !== undefined) {
+        strikeCount = event.strikeCount
+      }
+      // Store strikeExpiresAt if provided by client
+      if ('strikeExpiresAt' in event && event.strikeExpiresAt) {
+        strikeExpiresAt = event.strikeExpiresAt
+      }
+    }
+
     const modEvent = await this.db.db
       .insertInto('moderation_event')
       .values({
@@ -599,6 +641,9 @@ export class ModerationService {
         subjectMessageId: subjectInfo.subjectMessageId,
         modTool: modTool ? jsonb(modTool) : null,
         externalId: externalId ?? null,
+        severityLevel,
+        strikeCount,
+        strikeExpiresAt,
       })
       .returningAll()
       .executeTakeFirstOrThrow()
@@ -609,6 +654,19 @@ export class ModerationService {
       subject.blobCids,
     )
 
+    // Updates are only needed if strikeCount is numeric (in some cases even 0)
+    if (modEvent.strikeCount !== null) {
+      try {
+        await this.strikeService.updateSubjectStrikeCount(modEvent.subjectDid)
+      } catch (error) {
+        // Log error but don't fail the entire operation to ensure that events are logged even if updating strike count fails
+        log.error(
+          { err: error, modEventId: modEvent.id },
+          'Error processing strikes for moderation event',
+        )
+      }
+    }
+
     return { event: modEvent, subjectStatus }
   }
 
@@ -959,6 +1017,7 @@ export class ModerationService {
     minReportedRecordsCount,
     minTakendownRecordsCount,
     minPriorityScore,
+    minStrikeCount,
     ageAssuranceState,
   }: QueryStatusParams): Promise<{
     statuses: ModerationSubjectStatusRowWithHandle[]
@@ -1224,6 +1283,14 @@ export class ModerationService {
       )
     }
 
+    if (minStrikeCount != null && minStrikeCount >= 0) {
+      builder = builder.where(
+        'account_strike.activeStrikeCount',
+        '>=',
+        minStrikeCount,
+      )
+    }
+
     if (ageAssuranceState) {
       builder = builder.where(
         'moderation_subject_status.ageAssuranceState',
@@ -1329,7 +1396,6 @@ export class ModerationService {
     )
     const dbVals = signedLabels.map((l) => formatLabelRow(l, this.signingKeyId))
     const { ref } = this.db.db.dynamic
-    await sql`notify ${ref(LabelChannel)}`.execute(this.db.db)
     const excluded = (col: string) => ref(`excluded.${col}`)
     const res = await this.db.db
       .insertInto('label')
@@ -1346,6 +1412,7 @@ export class ModerationService {
       )
       .returningAll()
       .execute()
+    await sql`notify ${ref(LabelChannel)}`.execute(this.db.db)
     return res.map((row) => formatLabel(row))
   }
 

package/src/mod-service/status.ts

@@ -258,6 +258,15 @@ export const moderationSubjectStatusQueryBuilder = (db: DatabaseSchema) => {
       'account_record_status_stats.processedCount',
       'account_record_status_stats.takendownCount',
     ])
+    .leftJoin('account_strike', (join) =>
+      join.onRef('moderation_subject_status.did', '=', 'account_strike.did'),
+    )
+    .select([
+      'account_strike.activeStrikeCount as strikeCount',
+      'account_strike.totalStrikeCount',
+      'account_strike.firstStrikeAt',
+      'account_strike.lastStrikeAt',
+    ])
 }
 
 // Based on a given moderation action event, this function will update the moderation status of the subject

package/src/mod-service/strike.ts

@@ -0,0 +1,96 @@
+import { Database } from '../db'
+
+export type StrikeServiceCreator = (db: Database) => StrikeService
+
+export class StrikeService {
+  constructor(private db: Database) {}
+
+  static creator() {
+    return (db: Database) => {
+      return new StrikeService(db)
+    }
+  }
+
+  /**
+   * Update the strike count in account_strike table
+   */
+  async updateSubjectStrikeCount(subjectDid: string): Promise<void> {
+    const now = new Date().toISOString()
+
+    // This should not incur too many rows since we tend to do permanent takedown on relatively low strike count
+    // and we have a very specific index to support this query
+    const events = await this.db.db
+      .selectFrom('moderation_event')
+      .where('subjectDid', '=', subjectDid)
+      .where('strikeCount', '<>', 0)
+      .select(['strikeCount', 'strikeExpiresAt', 'createdAt'])
+      .orderBy('createdAt', 'asc')
+      .execute()
+
+    if (!events.length) {
+      return
+    }
+
+    let activeStrikeCount = 0
+    let totalStrikeCount = 0
+
+    const firstStrikeAt = events[0].createdAt
+    const lastStrikeAt = events[events.length - 1].createdAt
+
+    for (const event of events) {
+      const strikeCount = event.strikeCount || 0
+      totalStrikeCount += strikeCount
+
+      // Count as active if not expired
+      const isActive =
+        event.strikeExpiresAt === null || event.strikeExpiresAt > now
+      if (isActive) {
+        activeStrikeCount += strikeCount
+      }
+    }
+
+    await this.db.db
+      .insertInto('account_strike')
+      .values({
+        did: subjectDid,
+        activeStrikeCount,
+        totalStrikeCount,
+        firstStrikeAt,
+        lastStrikeAt,
+      })
+      .onConflict((oc) =>
+        oc.column('did').doUpdateSet({
+          activeStrikeCount,
+          totalStrikeCount,
+          firstStrikeAt,
+          lastStrikeAt,
+        }),
+      )
+      .execute()
+  }
+
+  /**
+   * Get distinct subjects with expired strikes since a given timestamp
+   * Used by the strike expiry processor to find accounts that need strike count updates
+   */
+  async getExpiredStrikeSubjects(
+    afterTimestamp?: string,
+  ): Promise<Array<{ subjectDid: string }>> {
+    const now = new Date().toISOString()
+
+    let query = this.db.db
+      .selectFrom('moderation_event')
+      .where('strikeExpiresAt', 'is not', null)
+      .where('strikeExpiresAt', '<=', now)
+      .where('strikeCount', '<>', 0)
+      .select('subjectDid')
+      .distinct()
+
+    // Only process strikes that expired since the last run
+    if (afterTimestamp) {
+      query = query.where('strikeExpiresAt', '>=', afterTimestamp)
+    }
+
+    return await query.execute()
+  }
+}

package/src/mod-service/types.ts

@@ -37,6 +37,12 @@ export type ModerationSubjectStatusRowWithStats = ModerationSubjectStatusRow & {
   pendingCount: number | null
   processedCount: number | null
   takendownCount: number | null
+
+  // account_strike
+  strikeCount: number | null
+  totalStrikeCount: number | null
+  firstStrikeAt: string | null
+  lastStrikeAt: string | null
 }
 
 export type ModerationSubjectStatusRowWithHandle =

package/src/mod-service/views.ts

@@ -41,6 +41,7 @@ import {
   isModEventMuteReporter,
   isModEventPriorityScore,
   isModEventReport,
+  isModEventReverseTakedown,
   isModEventTag,
   isModEventTakedown,
   isRecordEvent,
@@ -178,11 +179,20 @@ export class ModerationViews {
     }
 
     if (
-      isModEventTakedown(event) &&
-      typeof meta.policies === 'string' &&
-      meta.policies.length > 0
+      isModEventTakedown(event) ||
+      isModEventEmail(event) ||
+      isModEventReverseTakedown(event)
     ) {
-      event.policies = meta.policies.split(',')
+      if (typeof meta.policies === 'string' && meta.policies.length > 0) {
+        event.policies = meta.policies.split(',')
+      }
+
+      event.strikeCount = ifNumber(row.strikeCount)
+      event.severityLevel = ifString(row.severityLevel)
+
+      if (isModEventTakedown(event) || isModEventEmail(event)) {
+        event.strikeExpiresAt = ifString(row.strikeExpiresAt)
+      }
     }
 
     if (isModEventLabel(event)) {
@@ -745,6 +755,17 @@ export class ModerationViews {
         processedCount: status.processedCount ?? undefined,
         takendownCount: status.takendownCount ?? undefined,
       },
+
+      accountStrike:
+        status.strikeCount !== null || status.totalStrikeCount !== null
+          ? {
+              $type: 'tools.ozone.moderation.defs#accountStrike',
+              activeStrikeCount: status.strikeCount ?? undefined,
+              totalStrikeCount: status.totalStrikeCount ?? undefined,
+              firstStrikeAt: status.firstStrikeAt ?? undefined,
+              lastStrikeAt: status.lastStrikeAt ?? undefined,
+            }
+          : undefined,
     }
 
     if (status.recordPath !== '') {

package/src/setting/constants.ts

@@ -1,2 +1,3 @@
 export const ProtectedTagSettingKey = 'tools.ozone.setting.protectedTags'
 export const PolicyListSettingKey = 'tools.ozone.setting.policyList'
+export const SeverityLevelSettingKey = 'tools.ozone.setting.severityLevels'