@atproto/ozone 0.1.149 → 0.1.151

package/src/context.ts

@@ -21,6 +21,7 @@ import {
   ModerationServiceProfile,
   ModerationServiceProfileCreator,
 } from './mod-service/profile'
+import { StrikeService, StrikeServiceCreator } from './mod-service/strike'
 import {
   SafelinkRuleService,
   SafelinkRuleServiceCreator,
@@ -59,6 +60,7 @@ export type AppContextOptions = {
   scheduledActionService: ScheduledActionServiceCreator
   setService: SetServiceCreator
   settingService: SettingServiceCreator
+  strikeService: StrikeServiceCreator
   teamService: TeamServiceCreator
   appviewAgent: AtpAgent
   pdsAgent: AtpAgent | undefined
@@ -132,17 +134,6 @@ export class AppContext {
       appview: cfg.appview.pushEvents ? cfg.appview : undefined,
       pds: cfg.pds ?? undefined,
     })
-    const modService = ModerationService.creator(
-      signingKey,
-      signingKeyId,
-      cfg,
-      backgroundQueue,
-      idResolver,
-      eventPusher,
-      appviewAgent,
-      createAuthHeaders,
-      overrides?.imgInvalidator,
-    )
 
     const communicationTemplateService = CommunicationTemplateService.creator()
     const safelinkRuleService = SafelinkRuleService.creator()
@@ -154,12 +145,25 @@ export class AppContext {
     )
     const setService = SetService.creator()
     const settingService = SettingService.creator()
+    const strikeService = StrikeService.creator()
     const verificationService = VerificationService.creator()
     const verificationIssuer = VerificationIssuer.creator()
     const moderationServiceProfile = ModerationServiceProfile.creator(
       cfg,
       appviewAgent,
     )
+    const modService = ModerationService.creator(
+      signingKey,
+      signingKeyId,
+      cfg,
+      backgroundQueue,
+      idResolver,
+      eventPusher,
+      appviewAgent,
+      createAuthHeaders,
+      strikeService,
+      overrides?.imgInvalidator,
+    )
 
     const sequencer = new Sequencer(modService(db))
 
@@ -181,6 +185,7 @@ export class AppContext {
         teamService,
         setService,
         settingService,
+        strikeService,
         appviewAgent,
         pdsAgent,
         chatAgent,
@@ -248,6 +253,10 @@ export class AppContext {
     return this.opts.settingService
   }
 
+  get strikeService(): StrikeServiceCreator {
+    return this.opts.strikeService
+  }
+
   get verificationService(): VerificationServiceCreator {
     return this.opts.verificationService
   }

package/src/daemon/context.ts

@@ -7,6 +7,7 @@ import { BackgroundQueue } from '../background'
 import { OzoneConfig, OzoneSecrets } from '../config'
 import { Database } from '../db'
 import { ModerationService } from '../mod-service'
+import { StrikeService } from '../mod-service/strike'
 import { ScheduledActionService } from '../scheduled-action/service'
 import { SettingService } from '../setting/service'
 import { TeamService } from '../team'
@@ -15,6 +16,7 @@ import { EventPusher } from './event-pusher'
 import { EventReverser } from './event-reverser'
 import { MaterializedViewRefresher } from './materialized-view-refresher'
 import { ScheduledActionProcessor } from './scheduled-action-processor'
+import { StrikeExpiryProcessor } from './strike-expiry-processor'
 import { TeamProfileSynchronizer } from './team-profile-synchronizer'
 import { VerificationListener } from './verification-listener'
 
@@ -28,6 +30,7 @@ export type DaemonContextOptions = {
   materializedViewRefresher: MaterializedViewRefresher
   teamProfileSynchronizer: TeamProfileSynchronizer
   scheduledActionProcessor: ScheduledActionProcessor
+  strikeExpiryProcessor: StrikeExpiryProcessor
   verificationListener?: VerificationListener
 }
 
@@ -66,6 +69,8 @@ export class DaemonContext {
 
     const backgroundQueue = new BackgroundQueue(db)
 
+    const settingService = SettingService.creator()
+    const strikeService = StrikeService.creator()
     const modService = ModerationService.creator(
       signingKey,
       signingKeyId,
@@ -75,8 +80,8 @@ export class DaemonContext {
       eventPusher,
       appviewAgent,
       createAuthHeaders,
+      strikeService,
     )
-    const settingService = SettingService.creator()
     const scheduledActionService = ScheduledActionService.creator()
     const teamService = TeamService.creator(
       appviewAgent,
@@ -104,6 +109,8 @@ export class DaemonContext {
       scheduledActionService,
     )
 
+    const strikeExpiryProcessor = new StrikeExpiryProcessor(db, strikeService)
+
     // Only spawn the listener if verifier config exists and a jetstream URL is provided
     const verificationListener =
       cfg.verifier && cfg.jetstreamUrl
@@ -124,6 +131,7 @@ export class DaemonContext {
       materializedViewRefresher,
       teamProfileSynchronizer,
       scheduledActionProcessor,
+      strikeExpiryProcessor,
       verificationListener,
       ...(overrides ?? {}),
     })
@@ -161,6 +169,10 @@ export class DaemonContext {
     return this.opts.scheduledActionProcessor
   }
 
+  get strikeExpiryProcessor(): StrikeExpiryProcessor {
+    return this.opts.strikeExpiryProcessor
+  }
+
   get verificationListener(): VerificationListener | undefined {
     return this.opts.verificationListener
   }
@@ -171,6 +183,7 @@ export class DaemonContext {
     this.materializedViewRefresher.start()
     this.teamProfileSynchronizer.start()
     this.scheduledActionProcessor.start()
+    this.strikeExpiryProcessor.start()
     this.verificationListener?.start()
   }
 
@@ -189,6 +202,7 @@ export class DaemonContext {
         this.materializedViewRefresher.destroy(),
         this.teamProfileSynchronizer.destroy(),
         this.scheduledActionProcessor.destroy(),
+        this.strikeExpiryProcessor.destroy(),
         this.verificationListener?.stop(),
       ])
     } finally {

package/src/daemon/index.ts

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

package/src/daemon/strike-expiry-processor.ts

@@ -0,0 +1,111 @@
+import { HOUR } from '@atproto/common'
+import { Database } from '../db'
+import { dbLogger } from '../logger'
+import { StrikeServiceCreator } from '../mod-service/strike'
+
+const JOB_NAME = 'strike_expiry'
+
+export class StrikeExpiryProcessor {
+  destroyed = false
+  processingPromise: Promise<void> = Promise.resolve()
+  timer?: NodeJS.Timeout
+
+  constructor(
+    private db: Database,
+    private strikeServiceCreator: StrikeServiceCreator,
+  ) {}
+
+  start() {
+    this.initializeCursor().then(() => this.poll())
+  }
+
+  poll() {
+    if (this.destroyed) return
+    this.processingPromise = this.processExpiredStrikes()
+      .catch((err) =>
+        dbLogger.error({ err }, 'strike expiry 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 initializeCursor() {
+    await this.db.db
+      .insertInto('job_cursor')
+      .values({
+        job: JOB_NAME,
+        cursor: null,
+      })
+      .onConflict((oc) => oc.doNothing())
+      .execute()
+  }
+
+  async getCursor(): Promise<string | null> {
+    const entry = await this.db.db
+      .selectFrom('job_cursor')
+      .select('cursor')
+      .where('job', '=', JOB_NAME)
+      .executeTakeFirst()
+
+    return entry?.cursor || null
+  }
+
+  async updateCursor(cursor: string): Promise<void> {
+    await this.db.db
+      .updateTable('job_cursor')
+      .set({ cursor })
+      .where('job', '=', JOB_NAME)
+      .execute()
+  }
+
+  async processExpiredStrikes() {
+    const now = new Date()
+    const strikeService = this.strikeServiceCreator(this.db)
+    const lastProcessedAt = await this.getCursor()
+    const affectedSubjects = await strikeService.getExpiredStrikeSubjects(
+      lastProcessedAt || undefined,
+    )
+
+    if (!affectedSubjects.length) {
+      dbLogger.info('no expired strikes to process')
+      await this.updateCursor(now.toISOString())
+      return
+    }
+
+    dbLogger.info(
+      { count: affectedSubjects.length },
+      'processing subjects with expired strikes',
+    )
+
+    await Promise.all(
+      affectedSubjects.map(({ subjectDid }) => {
+        return strikeService.updateSubjectStrikeCount(subjectDid)
+      }),
+    )
+
+    await this.updateCursor(now.toISOString())
+
+    dbLogger.info(
+      { processed: affectedSubjects.length },
+      'strike expiry processing completed',
+    )
+  }
+}
+
+const getInterval = (): number => {
+  // Run every hour, synchronized to the hour boundary
+  const now = Date.now()
+  const intervalMs = HOUR
+  const nextIteration = Math.ceil(now / intervalMs)
+  return nextIteration * intervalMs - now
+}

package/src/db/migrations/20251008T120000000Z-add-strike-system.ts

@@ -0,0 +1,87 @@
+import { Kysely, sql } from 'kysely'
+
+export async function up(db: Kysely<unknown>): Promise<void> {
+  await db.schema
+    .alterTable('moderation_event')
+    .addColumn('severityLevel', 'varchar')
+    .execute()
+  await db.schema
+    .alterTable('moderation_event')
+    .addColumn('strikeCount', 'integer')
+    .execute()
+  await db.schema
+    .alterTable('moderation_event')
+    .addColumn('strikeExpiresAt', 'varchar')
+    .execute()
+
+  await db.schema
+    .createTable('account_strike')
+    .addColumn('did', 'text', (col) => col.primaryKey())
+    .addColumn('firstStrikeAt', 'varchar')
+    .addColumn('lastStrikeAt', 'varchar')
+    .addColumn('activeStrikeCount', 'integer', (col) =>
+      col.notNull().defaultTo(0),
+    )
+    .addColumn('totalStrikeCount', 'integer', (col) =>
+      col.notNull().defaultTo(0),
+    )
+    .execute()
+
+  await db.schema
+    .createTable('job_cursor')
+    .addColumn('job', 'text', (col) => col.primaryKey())
+    .addColumn('cursor', 'text')
+    .addColumn('updatedAt', 'text', (col) =>
+      col.defaultTo(sql`now()`).notNull(),
+    )
+    .execute()
+
+  // This supports fast look up for background job that aggregates strike data per subjectDid
+  await db.schema
+    .createIndex('moderation_event_subject_did_strike_count_idx')
+    .on('moderation_event')
+    .columns(['subjectDid', 'strikeCount'])
+    .execute()
+
+  // This supports fast lookup in the background job that needs to find strikes that have expired
+  await sql`
+    CREATE INDEX moderation_event_strike_expires_at_strike_count_idx
+    ON moderation_event ("strikeExpiresAt", "strikeCount")
+    WHERE "strikeExpiresAt" IS NOT NULL AND "strikeCount" IS NOT NULL
+  `.execute(db)
+
+  // for sorting and filtering by active strike count
+  await db.schema
+    .createIndex('account_strike_active_count_idx')
+    .on('account_strike')
+    .column('activeStrikeCount')
+    .execute()
+}
+
+export async function down(db: Kysely<unknown>): Promise<void> {
+  await db.schema
+    .dropIndex('moderation_event_subject_did_strike_count_idx')
+    .execute()
+  await db.schema
+    .dropIndex('moderation_event_strike_expires_at_strike_count_idx')
+    .execute()
+  await db.schema.dropIndex('account_strike_active_count_idx').execute()
+
+  await db.schema.dropTable('account_strike').execute()
+  await db.schema.dropTable('job_cursor').execute()
+
+  await db.schema
+    .alterTable('moderation_event')
+    .dropColumn('severityLevel')
+    .execute()
+
+  await db.schema
+    .alterTable('moderation_event')
+    .dropColumn('strikeCount')
+    .execute()
+
+  await db.schema
+    .alterTable('moderation_event')
+    .dropColumn('strikeExpiresAt')
+    .execute()
+}

package/src/db/migrations/index.ts

@@ -32,3 +32,4 @@ export * as _20250715T000000000Z from './20250715T000000000Z-add-mod-event-exter
 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'
+export * as _20251008T120000000Z from './20251008T120000000Z-add-strike-system'

package/src/db/schema/account_strike.ts

@@ -0,0 +1,13 @@
+export const accountStrikeTableName = 'account_strike'
+
+export interface AccountStrike {
+  did: string // Primary key
+  firstStrikeAt: string | null
+  lastStrikeAt: string | null
+  activeStrikeCount: number
+  totalStrikeCount: number
+}
+
+export type PartialDB = {
+  [accountStrikeTableName]: AccountStrike
+}

package/src/db/schema/index.ts

@@ -2,9 +2,11 @@ import { Kysely } from 'kysely'
 import * as accountEventsStats from './account_events_stats'
 import * as accountRecordEventsStats from './account_record_events_stats'
 import * as accountRecordStatusStats from './account_record_status_stats'
+import * as accountStrike from './account_strike'
 import * as blobPushEvent from './blob_push_event'
 import * as communicationTemplate from './communication_template'
 import * as firehoseCursor from './firehose_cursor'
+import * as jobCursor from './job_cursor'
 import * as label from './label'
 import * as member from './member'
 import * as modEvent from './moderation_event'
@@ -34,8 +36,10 @@ export type DatabaseSchemaType = modEvent.PartialDB &
   recordEventsStats.PartialDB &
   accountRecordEventsStats.PartialDB &
   accountRecordStatusStats.PartialDB &
+  accountStrike.PartialDB &
   verification.PartialDB &
   firehoseCursor.PartialDB &
+  jobCursor.PartialDB &
   safelink.PartialDB &
   scheduledAction.PartialDB
 

package/src/db/schema/job_cursor.ts

@@ -0,0 +1,13 @@
+import { Generated } from 'kysely'
+
+export const jobCursorTableName = 'job_cursor'
+
+export interface JobCursor {
+  job: string
+  cursor: string | null
+  updatedAt: Generated<string>
+}
+
+export type PartialDB = {
+  [jobCursorTableName]: JobCursor
+}

package/src/db/schema/moderation_event.ts

@@ -48,6 +48,9 @@ export interface ModerationEvent {
   legacyRefId: number | null
   modTool: { name: string; meta?: { [_ in string]: unknown } } | null
   externalId: string | null
+  severityLevel: string | null
+  strikeCount: number | null
+  strikeExpiresAt: string | null
 }
 
 export type PartialDB = {

package/src/lexicon/lexicons.ts

@@ -14630,6 +14630,12 @@ export const schemaDict = {
             type: 'ref',
             ref: 'lex:tools.ozone.moderation.defs#recordsStats',
           },
+          accountStrike: {
+            description:
+              'Strike information for the account (account-level only)',
+            type: 'ref',
+            ref: 'lex:tools.ozone.moderation.defs#accountStrike',
+          },
           ageAssuranceState: {
             type: 'string',
             description: 'Current age assurance state of the subject.',
@@ -14742,6 +14748,32 @@ export const schemaDict = {
           },
         },
       },
+      accountStrike: {
+        description: 'Strike information for an account',
+        type: 'object',
+        properties: {
+          activeStrikeCount: {
+            description:
+              'Current number of active strikes (excluding expired strikes)',
+            type: 'integer',
+          },
+          totalStrikeCount: {
+            description:
+              'Total number of strikes ever received (including expired strikes)',
+            type: 'integer',
+          },
+          firstStrikeAt: {
+            description: 'Timestamp of the first strike received',
+            type: 'string',
+            format: 'datetime',
+          },
+          lastStrikeAt: {
+            description: 'Timestamp of the most recent strike received',
+            type: 'string',
+            format: 'datetime',
+          },
+        },
+      },
       subjectReviewState: {
         type: 'string',
         knownValues: [
@@ -14797,6 +14829,22 @@ export const schemaDict = {
             description:
               'Names/Keywords of the policies that drove the decision.',
           },
+          severityLevel: {
+            type: 'string',
+            description:
+              "Severity level of the violation (e.g., 'sev-0', 'sev-1', 'sev-2', etc.).",
+          },
+          strikeCount: {
+            type: 'integer',
+            description:
+              'Number of strikes to assign to the user for this violation.',
+          },
+          strikeExpiresAt: {
+            type: 'string',
+            format: 'datetime',
+            description:
+              'When the strike should expire. If not provided, the strike never expires.',
+          },
         },
       },
       modEventReverseTakedown: {
@@ -14807,6 +14855,25 @@ export const schemaDict = {
             type: 'string',
             description: 'Describe reasoning behind the reversal.',
           },
+          policies: {
+            type: 'array',
+            maxLength: 5,
+            items: {
+              type: 'string',
+            },
+            description:
+              'Names/Keywords of the policy infraction for which takedown is being reversed.',
+          },
+          severityLevel: {
+            type: 'string',
+            description:
+              "Severity level of the violation. Usually set from the last policy infraction's severity.",
+          },
+          strikeCount: {
+            type: 'integer',
+            description:
+              "Number of strikes to subtract from the user's strike count. Usually set from the last policy infraction's severity.",
+          },
         },
       },
       modEventResolveAppeal: {
@@ -15050,6 +15117,31 @@ export const schemaDict = {
             type: 'string',
             description: 'Additional comment about the outgoing comm.',
           },
+          policies: {
+            type: 'array',
+            maxLength: 5,
+            items: {
+              type: 'string',
+            },
+            description:
+              'Names/Keywords of the policies that necessitated the email.',
+          },
+          severityLevel: {
+            type: 'string',
+            description:
+              "Severity level of the violation. Normally 'sev-1' that adds strike on repeat offense",
+          },
+          strikeCount: {
+            type: 'integer',
+            description:
+              '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.',
+          },
+          strikeExpiresAt: {
+            type: 'string',
+            format: 'datetime',
+            description:
+              'When the strike should expire. If not provided, the strike never expires.',
+          },
         },
       },
       modEventDivert: {
@@ -16448,6 +16540,11 @@ export const schemaDict = {
                 'blocked',
               ],
             },
+            withStrike: {
+              type: 'boolean',
+              description:
+                'If specified, only events where strikeCount value is set are returned.',
+            },
             cursor: {
               type: 'string',
             },
@@ -16678,6 +16775,12 @@ export const schemaDict = {
               description:
                 'If specified, only subjects that have priority score value above the given value will be returned.',
             },
+            minStrikeCount: {
+              type: 'integer',
+              minimum: 1,
+              description:
+                'If specified, only subjects that belong to an account that has at least this many active strikes will be returned.',
+            },
             ageAssuranceState: {
               type: 'string',
               description:

package/src/lexicon/types/app/bsky/actor/profile.ts

@@ -16,7 +16,7 @@ const is$typed = _is$typed,
   validate = _validate
 const id = 'app.bsky.actor.profile'
 
-export interface Record {
+export interface Main {
   $type: 'app.bsky.actor.profile'
   displayName?: string
   /** Free-form profile description text. */
@@ -35,12 +35,18 @@ export interface Record {
   [k: string]: unknown
 }
 
-const hashRecord = 'main'
+const hashMain = 'main'
 
-export function isRecord<V>(v: V) {
-  return is$typed(v, id, hashRecord)
+export function isMain<V>(v: V) {
+  return is$typed(v, id, hashMain)
 }
 
-export function validateRecord<V>(v: V) {
-  return validate<Record & V>(v, id, hashRecord, true)
+export function validateMain<V>(v: V) {
+  return validate<Main & V>(v, id, hashMain, true)
+}
+
+export {
+  type Main as Record,
+  isMain as isRecord,
+  validateMain as validateRecord,
 }

package/src/lexicon/types/app/bsky/actor/status.ts

@@ -15,7 +15,7 @@ const is$typed = _is$typed,
   validate = _validate
 const id = 'app.bsky.actor.status'
 
-export interface Record {
+export interface Main {
   $type: 'app.bsky.actor.status'
   /** The status for the account. */
   status: 'app.bsky.actor.status#live' | (string & {})
@@ -26,14 +26,20 @@ export interface Record {
   [k: string]: unknown
 }
 
-const hashRecord = 'main'
+const hashMain = 'main'
 
-export function isRecord<V>(v: V) {
-  return is$typed(v, id, hashRecord)
+export function isMain<V>(v: V) {
+  return is$typed(v, id, hashMain)
 }
 
-export function validateRecord<V>(v: V) {
-  return validate<Record & V>(v, id, hashRecord, true)
+export function validateMain<V>(v: V) {
+  return validate<Main & V>(v, id, hashMain, true)
+}
+
+export {
+  type Main as Record,
+  isMain as isRecord,
+  validateMain as validateRecord,
 }
 
 /** Advertises an account as currently offering live content. */

package/src/lexicon/types/app/bsky/feed/generator.ts

@@ -16,7 +16,7 @@ const is$typed = _is$typed,
   validate = _validate
 const id = 'app.bsky.feed.generator'
 
-export interface Record {
+export interface Main {
   $type: 'app.bsky.feed.generator'
   did: string
   displayName: string
@@ -34,12 +34,18 @@ export interface Record {
   [k: string]: unknown
 }
 
-const hashRecord = 'main'
+const hashMain = 'main'
 
-export function isRecord<V>(v: V) {
-  return is$typed(v, id, hashRecord)
+export function isMain<V>(v: V) {
+  return is$typed(v, id, hashMain)
 }
 
-export function validateRecord<V>(v: V) {
-  return validate<Record & V>(v, id, hashRecord, true)
+export function validateMain<V>(v: V) {
+  return validate<Main & V>(v, id, hashMain, true)
+}
+
+export {
+  type Main as Record,
+  isMain as isRecord,
+  validateMain as validateRecord,
 }