@atproto/ozone 0.1.176 → 0.2.1

package/src/mod-service/subject.ts

@@ -16,6 +16,9 @@ const isStrongRef = asPredicate(ComAtprotoRepoStrongRef.validateMain)
 type MessageRef = ChatBskyConvoDefs.MessageRef
 const isValidMessageRef = asPredicate(ChatBskyConvoDefs.validateMessageRef)
 
+type ConvoRef = ChatBskyConvoDefs.ConvoRef
+const isValidConvoRef = asPredicate(ChatBskyConvoDefs.validateConvoRef)
+
 const isMessageRefWithoutConvoId = (
   subject: unknown,
 ): subject is $Typed<Omit<MessageRef, 'convoId'> & { convoId?: string }> =>
@@ -41,6 +44,11 @@ export const subjectFromInput = (
   if (isValidMessageRef(subject)) {
     return new MessageSubject(subject.did, subject.convoId, subject.messageId)
   }
+  // @NOTE #convoRef is a new type for reporting entire conversations.
+  // Similar to messageRef, we take advantage of the open union to support this.
+  if (isValidConvoRef(subject)) {
+    return new ConvoSubject(subject.did, subject.convoId)
+  }
   // @TODO we should start to require subject.convoId is a string in order to properly validate
   // the #messageRef. temporarily allowing it to be optional as a stopgap for rollout.
   // The next "if" can be removed once convoId is consistently provided.
@@ -73,6 +81,11 @@ export const subjectFromEventRow = (row: ModerationEventRow): ModSubject => {
     const convoId =
       typeof row.meta?.['convoId'] === 'string' ? row.meta['convoId'] : ''
     return new MessageSubject(row.subjectDid, convoId, row.subjectMessageId)
+  } else if (
+    row.subjectType === 'chat.bsky.convo.defs#convoRef' &&
+    row.subjectConvoId
+  ) {
+    return new ConvoSubject(row.subjectDid, row.subjectConvoId)
   } else {
     return new RepoSubject(row.subjectDid)
   }
@@ -86,6 +99,9 @@ export const subjectFromStatusRow = (
     // which is what the last 2 params of .make() arguments are
     const uri = AtUri.make(row.did, ...row.recordPath.split('/')).toString()
     return new RecordSubject(uri.toString(), row.recordCid, row.blobCids ?? [])
+  } else if (row.convoId) {
+    // Conversation subject - restore from subject status row
+    return new ConvoSubject(row.did, row.convoId)
   } else {
     return new RepoSubject(row.did)
   }
@@ -96,28 +112,37 @@ type SubjectInfo = {
     | 'com.atproto.admin.defs#repoRef'
     | 'com.atproto.repo.strongRef'
     | 'chat.bsky.convo.defs#messageRef'
+    | 'chat.bsky.convo.defs#convoRef'
   subjectDid: string
   subjectUri: string | null
   subjectCid: string | null
   subjectBlobCids: string[] | null
   subjectMessageId: string | null
+  subjectConvoId: string | null
   meta: Record<string, string | undefined> | null
 }
 
 export interface ModSubject {
   did: string
   recordPath: string | undefined
+  convoId: string | undefined
   blobCids?: string[]
   isRepo(): this is RepoSubject
   isRecord(): this is RecordSubject
   isMessage(): this is MessageSubject
+  isConvo(): this is ConvoSubject
   info(): SubjectInfo
-  lex(): $Typed<RepoRef> | $Typed<StrongRef> | $Typed<MessageRef>
+  lex():
+    | $Typed<RepoRef>
+    | $Typed<StrongRef>
+    | $Typed<MessageRef>
+    | $Typed<ConvoRef>
 }
 
 export class RepoSubject implements ModSubject {
   blobCids = undefined
   recordPath = undefined
+  convoId = undefined
   constructor(public did: string) {}
   isRepo(): this is RepoSubject {
     return true
@@ -128,6 +153,9 @@ export class RepoSubject implements ModSubject {
   isMessage(): this is MessageSubject {
     return false
   }
+  isConvo(): this is ConvoSubject {
+    return false
+  }
   info() {
     return {
       subjectType: 'com.atproto.admin.defs#repoRef' as const,
@@ -136,6 +164,7 @@ export class RepoSubject implements ModSubject {
       subjectCid: null,
       subjectBlobCids: null,
       subjectMessageId: null,
+      subjectConvoId: null,
       meta: null,
     }
   }
@@ -151,6 +180,7 @@ export class RecordSubject implements ModSubject {
   parsedUri: AtUri
   did: string
   recordPath: string
+  convoId = undefined
   constructor(
     public uri: string,
     public cid: string,
@@ -169,6 +199,9 @@ export class RecordSubject implements ModSubject {
   isMessage(): this is MessageSubject {
     return false
   }
+  isConvo(): this is ConvoSubject {
+    return false
+  }
   info() {
     return {
       subjectType: 'com.atproto.repo.strongRef' as const,
@@ -177,6 +210,7 @@ export class RecordSubject implements ModSubject {
       subjectCid: this.cid,
       subjectBlobCids: this.blobCids ?? [],
       subjectMessageId: null,
+      subjectConvoId: null,
       meta: null,
     }
   }
@@ -206,6 +240,9 @@ export class MessageSubject implements ModSubject {
   isMessage(): this is MessageSubject {
     return true
   }
+  isConvo(): this is ConvoSubject {
+    return false
+  }
   info() {
     return {
       subjectType: 'chat.bsky.convo.defs#messageRef' as const,
@@ -214,6 +251,7 @@ export class MessageSubject implements ModSubject {
       subjectCid: null,
       subjectBlobCids: null,
       subjectMessageId: this.messageId,
+      subjectConvoId: this.convoId,
       meta: { convoId: this.convoId || undefined },
     }
   }
@@ -226,3 +264,43 @@ export class MessageSubject implements ModSubject {
     }
   }
 }
+
+export class ConvoSubject implements ModSubject {
+  blobCids = undefined
+  recordPath = undefined
+  constructor(
+    public did: string,
+    public convoId: string,
+  ) {}
+  isRepo(): this is RepoSubject {
+    return false
+  }
+  isRecord(): this is RecordSubject {
+    return false
+  }
+  isMessage(): this is MessageSubject {
+    return false
+  }
+  isConvo(): this is ConvoSubject {
+    return true
+  }
+  info() {
+    return {
+      subjectType: 'chat.bsky.convo.defs#convoRef' as const,
+      subjectDid: this.did,
+      subjectUri: null,
+      subjectCid: null,
+      subjectBlobCids: null,
+      subjectMessageId: null,
+      subjectConvoId: this.convoId,
+      meta: { convoId: this.convoId || undefined },
+    }
+  }
+  lex(): $Typed<ConvoRef> {
+    return {
+      $type: 'chat.bsky.convo.defs#convoRef',
+      did: this.did,
+      convoId: this.convoId,
+    }
+  }
+}

package/src/mod-service/views.ts

@@ -51,7 +51,11 @@ import { Un$Typed, asPredicate } from '../lexicon/util.js'
 import { dbLogger, httpLogger } from '../logger.js'
 import { ParsedLabelers } from '../util.js'
 import { moderationSubjectStatusQueryBuilder } from './status.js'
-import { subjectFromEventRow, subjectFromStatusRow } from './subject.js'
+import {
+  ModSubject,
+  subjectFromEventRow,
+  subjectFromStatusRow,
+} from './subject.js'
 import {
   ModerationEventRowWithHandle,
   ModerationSubjectStatusRowWithHandle,
@@ -148,7 +152,9 @@ export class ModerationViews {
       modTool: row.modTool
         ? {
             name: row.modTool.name,
-            meta: row.modTool.meta,
+            meta: sanitizeUnsafeIntegers(row.modTool.meta) as
+              | Record<string, unknown>
+              | undefined,
           }
         : undefined,
     }
@@ -297,14 +303,8 @@ export class ModerationViews {
   async eventDetail(
     result: ModerationEventRowWithHandle,
   ): Promise<ModEventViewDetail> {
-    const subjectId =
-      result.subjectType === 'com.atproto.admin.defs#repoRef'
-        ? result.subjectDid
-        : result.subjectUri
-    if (!subjectId) {
-      throw new Error(`Bad subject: ${result.id}`)
-    }
-    const subject = await this.subject(subjectId)
+    const modSubject = subjectFromEventRow(result)
+    const subject = await this.subject(modSubject)
     const eventView = this.formatEvent(result)
     const allBlobs = 'value' in subject ? findBlobRefs(subject.value) : []
     const subjectBlobs = await this.blob(
@@ -555,10 +555,16 @@ export class ModerationViews {
   }
   // Partial view for subjects
 
-  async subject(subject: string): Promise<SubjectView> {
-    if (subject.startsWith('did:')) {
-      const repos = await this.repos([subject])
-      const repo = repos.get(subject)
+  async subject(subject: ModSubject): Promise<SubjectView> {
+    if (subject.isConvo()) {
+      return {
+        $type: 'tools.ozone.moderation.defs#convoView',
+        did: subject.did,
+        convoId: subject.convoId,
+      }
+    } else if (subject.isRepo()) {
+      const repos = await this.repos([subject.did])
+      const repo = repos.get(subject.did)
       if (repo) {
         return {
           ...repo,
@@ -567,24 +573,24 @@ export class ModerationViews {
       } else {
         return {
           $type: 'tools.ozone.moderation.defs#repoViewNotFound',
-          did: subject,
+          did: subject.did,
         }
       }
-    } else {
-      const records = await this.records([{ uri: subject }])
-      const record = records.get(subject)
+    } else if (subject.isRecord()) {
+      const uri = subject.uri
+      const records = await this.records([{ uri }])
+      const record = records.get(uri)
       if (record) {
         return {
           ...record,
           $type: 'tools.ozone.moderation.defs#recordView',
         }
-      } else {
-        return {
-          $type: 'tools.ozone.moderation.defs#recordViewNotFound',
-          uri: subject,
-        }
       }
     }
+    return {
+      $type: 'tools.ozone.moderation.defs#repoViewNotFound',
+      did: subject.did,
+    }
   }
 
   // Partial view for blobs
@@ -691,7 +697,8 @@ export class ModerationViews {
                 'moderation_subject_status.recordPath',
                 '=',
                 sub.recordPath ?? '',
-              ),
+              )
+              .where('moderation_subject_status.convoId', '=', ''),
           )
         }
         return qb
@@ -882,3 +889,24 @@ export function getSelfLabels(details: {
     return { src, uri, cid, val, cts }
   })
 }
+
+// The atproto data model requires all integers to fit within 53 bits
+// (Number.MAX_SAFE_INTEGER). External tools may write larger numbers into
+// "unknown"-typed fields like modTool.meta, which causes lex-json parse
+// failures on the client side. This helper converts unsafe integers to strings.
+function sanitizeUnsafeIntegers(value: unknown): unknown {
+  if (typeof value === 'number') {
+    return Number.isSafeInteger(value) ? value : String(value)
+  }
+  if (Array.isArray(value)) {
+    return value.map(sanitizeUnsafeIntegers)
+  }
+  if (value !== null && typeof value === 'object') {
+    const out: Record<string, unknown> = {}
+    for (const [k, v] of Object.entries(value)) {
+      out[k] = sanitizeUnsafeIntegers(v)
+    }
+    return out
+  }
+  return value
+}

package/src/queue/service.ts

@@ -13,7 +13,7 @@ import { viewQueueStats } from '../report/views.js'
 const MOD_EVENT_REPORT_ACTION = 'tools.ozone.moderation.defs#modEventReport'
 const REASON_OTHER = 'com.atproto.moderation.defs#reasonOther'
 
-type SubjectType = 'account' | 'record' | 'message'
+type SubjectType = 'account' | 'record' | 'message' | 'conversation'
 
 type ResolvedAssignment = {
   queueId: number
@@ -478,6 +478,7 @@ export class QueueService {
         'subjectDid',
         'subjectUri',
         'subjectMessageId',
+        'subjectConvoId',
         'meta',
         'createdAt',
       ])
@@ -503,9 +504,11 @@ export class QueueService {
     const rows = events.map((event) => {
       const subjectType: SubjectType = event.subjectMessageId
         ? 'message'
-        : event.subjectUri
-          ? 'record'
-          : 'account'
+        : event.subjectConvoId
+          ? 'conversation'
+          : event.subjectUri
+            ? 'record'
+            : 'account'
 
       let collection: string | null = null
       let recordPath = ''
@@ -545,6 +548,7 @@ export class QueueService {
         did: event.subjectDid,
         recordPath,
         subjectMessageId: event.subjectMessageId,
+        subjectConvoId: event.subjectConvoId,
         createdAt: now,
         updatedAt: now,
       }

package/tests/__snapshots__/verification.test.ts.snap

@@ -122,6 +122,8 @@ exports[`verification list returns paginated list of verifications 1`] = `
           "createdAt": "1970-01-01T00:00:00.000Z",
           "isValid": true,
           "issuer": "user(0)",
+          "issuerDisplayName": "ali",
+          "issuerHandle": "alice.test",
           "uri": "record(0)",
         },
       ],

package/tests/expiring-tags.test.ts

@@ -192,6 +192,7 @@ describe('expiring tags', () => {
         eventId: 0,
         did: sc.dids.carol,
         recordPath: '',
+        convoId: '',
         tag: 'skip-tag',
         expiresAt: new Date(Date.now() - 1000).toISOString(),
         createdBy: sc.dids.alice,

package/tests/moderation-events.test.ts

@@ -207,8 +207,25 @@ describe('moderation-events', () => {
         }),
       ])
 
-      expect(misleadingEvents.events.length).toEqual(2)
+      // Verify all spam events have the correct report type
       expect(spamEvents.events.length).toEqual(6)
+      spamEvents.events.forEach((event) => {
+        expect(event.event.$type).toEqual(
+          'tools.ozone.moderation.defs#modEventReport',
+        )
+        expect((event.event as any).reportType).toEqual(REASONSPAM)
+      })
+
+      // Verify all misleading events have one of the correct report types
+      expect(misleadingEvents.events.length).toEqual(2)
+      misleadingEvents.events.forEach((event) => {
+        expect(event.event.$type).toEqual(
+          'tools.ozone.moderation.defs#modEventReport',
+        )
+        expect([REASONMISLEADING, REASONAPPEAL]).toContain(
+          (event.event as any).reportType,
+        )
+      })
     })
 
     it('returns events matching keyword in comment', async () => {
@@ -501,6 +518,96 @@ describe('moderation-events', () => {
         expect(event.createdBy).toEqual(network.ozone.moderatorAccnt.did)
       })
     })
+
+    it('queries events by conversation', async () => {
+      const convoId1 = 'conversation-123'
+      const convoId2 = 'conversation-456'
+
+      // create reports
+      await sc.createReport({
+        reasonType: REASONSPAM,
+        reason: 'spam in convo 1',
+        subject: {
+          $type: 'chat.bsky.convo.defs#convoRef',
+          did: sc.dids.carol,
+          convoId: convoId1,
+        },
+        reportedBy: sc.dids.alice,
+      })
+      await sc.createReport({
+        reasonType: REASONMISLEADING,
+        reason: 'misleading in convo 1',
+        subject: {
+          $type: 'chat.bsky.convo.defs#convoRef',
+          did: sc.dids.carol,
+          convoId: convoId1,
+        },
+        reportedBy: sc.dids.bob,
+      })
+      await sc.createReport({
+        reasonType: REASONSPAM,
+        reason: 'spam in convo 2',
+        subject: {
+          $type: 'chat.bsky.convo.defs#convoRef',
+          did: sc.dids.carol,
+          convoId: convoId2,
+        },
+        reportedBy: sc.dids.alice,
+      })
+
+      // Query events (filter by report type since auto-tagging creates extra events)
+      const convo1Events = await modClient.queryEvents({
+        subject: `at://${sc.dids.carol}/chat.bsky.convo/${convoId1}`,
+        includeAllUserRecords: false,
+        types: ['tools.ozone.moderation.defs#modEventReport'],
+      })
+      const convo2Events = await modClient.queryEvents({
+        subject: `at://${sc.dids.carol}/chat.bsky.convo/${convoId2}`,
+        includeAllUserRecords: false,
+        types: ['tools.ozone.moderation.defs#modEventReport'],
+      })
+
+      // Verify conversation 1 events are correct
+      expect(convo1Events.events.length).toBeGreaterThan(0)
+      convo1Events.events.forEach((e) => {
+        // All events should be conversation refs
+        expect(e.subject.$type).toEqual('chat.bsky.convo.defs#convoRef')
+        // All events should be for conversation 1
+        const subject = e.subject as any
+        expect(subject.convoId).toEqual(convoId1)
+        expect(subject.did).toEqual(sc.dids.carol)
+        // All events should be reports
+        expect(e.event.$type).toEqual(
+          'tools.ozone.moderation.defs#modEventReport',
+        )
+      })
+      // Verify we got both reports we created
+      const convo1Comments = convo1Events.events.map(
+        (e) => (e.event as any).comment,
+      )
+      expect(convo1Comments).toContain('spam in convo 1')
+      expect(convo1Comments).toContain('misleading in convo 1')
+
+      // Verify conversation 2 events are correct
+      expect(convo2Events.events.length).toBeGreaterThan(0)
+      convo2Events.events.forEach((e) => {
+        // All events should be conversation refs
+        expect(e.subject.$type).toEqual('chat.bsky.convo.defs#convoRef')
+        // All events should be for conversation 2
+        const subject = e.subject as any
+        expect(subject.convoId).toEqual(convoId2)
+        expect(subject.did).toEqual(sc.dids.carol)
+        // All events should be reports
+        expect(e.event.$type).toEqual(
+          'tools.ozone.moderation.defs#modEventReport',
+        )
+      })
+      // Verify we got the report we created
+      const convo2Comments = convo2Events.events.map(
+        (e) => (e.event as any).comment,
+      )
+      expect(convo2Comments).toContain('spam in convo 2')
+    })
   })
 
   describe('get event', () => {

package/tests/moderation-status-tags.test.ts

@@ -113,5 +113,28 @@ describe('moderation-status-tags', () => {
       expect(englishOrJapaneseDids).toContain(sc.dids.alice)
       expect(englishOrJapaneseDids).toContain(sc.dids.bob)
     })
+
+    it('adds tag to conversation', async () => {
+      const subject = {
+        $type: 'chat.bsky.convo.defs#convoRef',
+        did: sc.dids.alice,
+        convoId: '123',
+      }
+      await modClient.emitEvent({
+        subject: subject,
+        event: {
+          $type: 'tools.ozone.moderation.defs#modEventTag',
+          add: ['interaction-churn'],
+          remove: [],
+        },
+      })
+      const status = await network.ozone.ctx.db.db
+        .selectFrom('moderation_subject_status')
+        .selectAll()
+        .where('did', '=', subject.did)
+        .where('convoId', '=', subject.convoId)
+        .executeTakeFirstOrThrow()
+      expect(status.tags).toContain('interaction-churn')
+    })
   })
 })

package/tests/moderation-statuses.test.ts

@@ -276,6 +276,88 @@ describe('moderation-statuses', () => {
         "only bob's account statuses are returned, no events have a URI even though the subjectType is record",
       )
     })
+
+    it('returns statuses for conversations', async () => {
+      const convoId1 = 'test-convo-123'
+      const convoId2 = 'test-convo-456'
+
+      // Create reports for conversation 1
+      await sc.createReport({
+        reasonType: REASONSPAM,
+        reason: 'spam in convo 1',
+        subject: {
+          $type: 'chat.bsky.convo.defs#convoRef',
+          did: sc.dids.carol,
+          convoId: convoId1,
+        },
+        reportedBy: sc.dids.alice,
+      })
+
+      // Create another report for conversation 1
+      await sc.createReport({
+        reasonType: REASONMISLEADING,
+        reason: 'misleading in convo 1',
+        subject: {
+          $type: 'chat.bsky.convo.defs#convoRef',
+          did: sc.dids.carol,
+          convoId: convoId1,
+        },
+        reportedBy: sc.dids.bob,
+      })
+
+      // Create report for conversation 2
+      await sc.createReport({
+        reasonType: REASONSPAM,
+        reason: 'spam in convo 2',
+        subject: {
+          $type: 'chat.bsky.convo.defs#convoRef',
+          did: sc.dids.carol,
+          convoId: convoId2,
+        },
+        reportedBy: sc.dids.alice,
+      })
+
+      // Query statuses for conversation 1 using AT URI format
+      const convo1Statuses = await modClient.queryStatuses({
+        subject: `at://${sc.dids.carol}/chat.bsky.convo/${convoId1}`,
+      })
+
+      // Query statuses for conversation 2
+      const convo2Statuses = await modClient.queryStatuses({
+        subject: `at://${sc.dids.carol}/chat.bsky.convo/${convoId2}`,
+      })
+
+      // Query all conversation statuses for carol
+      const allCarolConvoStatuses = await modClient.queryStatuses({
+        subject: sc.dids.carol,
+        includeAllUserRecords: true,
+      })
+
+      // Verify conversation 1 has exactly 1 status (multiple reports create one status)
+      expect(convo1Statuses.subjectStatuses.length).toEqual(1)
+      expect(convo1Statuses.subjectStatuses[0].subject.$type).toEqual(
+        'chat.bsky.convo.defs#convoRef',
+      )
+      expect(convo1Statuses.subjectStatuses[0].reviewState).toEqual(REVIEWOPEN)
+
+      // Verify conversation 2 has exactly 1 status
+      expect(convo2Statuses.subjectStatuses.length).toEqual(1)
+      expect(convo2Statuses.subjectStatuses[0].subject.$type).toEqual(
+        'chat.bsky.convo.defs#convoRef',
+      )
+
+      // Verify statuses are properly isolated by conversation
+      const convo1Subject = convo1Statuses.subjectStatuses[0].subject as any
+      const convo2Subject = convo2Statuses.subjectStatuses[0].subject as any
+      expect(convo1Subject.convoId).toEqual(convoId1)
+      expect(convo2Subject.convoId).toEqual(convoId2)
+
+      // Verify includeAllUserRecords includes conversations
+      const convoStatuses = allCarolConvoStatuses.subjectStatuses.filter(
+        (s) => s.subject.$type === 'chat.bsky.convo.defs#convoRef',
+      )
+      expect(convoStatuses.length).toBeGreaterThanOrEqual(2)
+    })
   })
 
   describe('reviewState changes', () => {