@atproto/ozone 0.1.126 → 0.1.128

package/src/safelink/service.ts

@@ -0,0 +1,304 @@
+import { Selectable } from 'kysely'
+import { ToolsOzoneSafelinkDefs } from '@atproto/api'
+import { InvalidRequestError } from '@atproto/xrpc-server'
+import {
+  SafelinkActionType,
+  SafelinkPatternType,
+  SafelinkReasonType,
+} from '../api/util'
+import { Database } from '../db'
+import { SafelinkEvent, SafelinkRule } from '../db/schema/safelink'
+
+export type SafelinkRuleServiceCreator = (db: Database) => SafelinkRuleService
+
+export class SafelinkRuleService {
+  constructor(public db: Database) {}
+
+  static creator() {
+    return (db: Database) => new SafelinkRuleService(db)
+  }
+
+  formatEvent(event: Selectable<SafelinkEvent>): ToolsOzoneSafelinkDefs.Event {
+    return {
+      id: event.id,
+      eventType: event.eventType,
+      url: event.url,
+      pattern: event.pattern,
+      action: event.action,
+      reason: event.reason,
+      createdBy: event.createdBy,
+      createdAt: new Date(event.createdAt).toISOString(),
+      comment: event.comment || undefined,
+    }
+  }
+
+  async addRule({
+    url,
+    pattern,
+    action,
+    reason,
+    createdBy,
+    comment,
+  }: {
+    url: string
+    pattern: SafelinkPatternType
+    action: SafelinkActionType
+    reason: SafelinkReasonType
+    createdBy: string
+    comment?: string
+  }): Promise<Selectable<SafelinkEvent>> {
+    const existingRule = await this.getActiveRule(url, pattern)
+    if (existingRule) {
+      throw new InvalidRequestError(
+        'A rule for this URL/domain already exists',
+        'RuleAlreadyExists',
+      )
+    }
+
+    const now = new Date().toISOString()
+    const rule = {
+      url,
+      pattern,
+      action,
+      reason,
+      createdBy,
+      comment: comment || null,
+      createdAt: now,
+    }
+
+    return await this.db.transaction(async (txn) => {
+      const event = await txn.db
+        .insertInto('safelink_event')
+        .values({
+          eventType: 'addRule',
+          ...rule,
+        })
+        .returningAll()
+        .executeTakeFirstOrThrow()
+
+      await txn.db
+        .insertInto('safelink_rule')
+        .values({ ...rule, updatedAt: now })
+        .execute()
+
+      return event
+    })
+  }
+
+  async updateRule({
+    url,
+    pattern,
+    action,
+    reason,
+    createdBy,
+    comment,
+  }: {
+    url: string
+    pattern: SafelinkPatternType
+    action: SafelinkActionType
+    reason: SafelinkReasonType
+    createdBy: string
+    comment?: string
+  }): Promise<Selectable<SafelinkEvent>> {
+    const existingRule = await this.getActiveRule(url, pattern)
+    if (!existingRule) {
+      throw new InvalidRequestError(
+        'No active rule found for this URL/domain',
+        'RuleNotFound',
+      )
+    }
+
+    const now = new Date().toISOString()
+    const rule = {
+      action,
+      reason,
+      createdBy,
+      comment: comment || null,
+    }
+
+    return await this.db.transaction(async (txn) => {
+      const event = await txn.db
+        .insertInto('safelink_event')
+        .values({
+          createdAt: now,
+          url: existingRule.url,
+          pattern: existingRule.pattern,
+          eventType: 'updateRule',
+          ...rule,
+        })
+        .returningAll()
+        .executeTakeFirstOrThrow()
+
+      await txn.db
+        .updateTable('safelink_rule')
+        .set(rule)
+        .where('url', '=', existingRule.url)
+        .where('pattern', '=', existingRule.pattern)
+        .execute()
+
+      return event
+    })
+  }
+
+  async removeRule({
+    url,
+    pattern,
+    createdBy,
+    comment,
+  }: {
+    url: string
+    pattern: SafelinkPatternType
+    createdBy: string
+    comment?: string
+  }): Promise<Selectable<SafelinkEvent>> {
+    const existingRule = await this.getActiveRule(url, pattern)
+    if (!existingRule) {
+      throw new InvalidRequestError(
+        'No active rule found for this URL/domain',
+        'RuleNotFound',
+      )
+    }
+
+    return await this.db.transaction(async (txn) => {
+      const event = await txn.db
+        .insertInto('safelink_event')
+        .values({
+          eventType: 'removeRule',
+          url,
+          pattern,
+          action: existingRule.action,
+          reason: existingRule.reason,
+          createdBy,
+          comment: comment || null,
+          createdAt: new Date().toISOString(),
+        })
+        .returningAll()
+        .executeTakeFirstOrThrow()
+
+      await txn.db
+        .deleteFrom('safelink_rule')
+        .where('url', '=', url)
+        .where('pattern', '=', pattern)
+        .execute()
+
+      return event
+    })
+  }
+
+  async getActiveRule(url: string, pattern: SafelinkPatternType) {
+    const rule = await this.db.db
+      .selectFrom('safelink_rule')
+      .selectAll()
+      .where('url', '=', url)
+      .where('pattern', '=', pattern)
+      .executeTakeFirst()
+
+    if (!rule) {
+      return null
+    }
+
+    return rule
+  }
+
+  async getActiveRules({
+    cursor,
+    limit = 50,
+    urls,
+    patternType,
+    actions,
+    reason,
+    createdBy,
+    direction = 'desc',
+  }: {
+    cursor?: string
+    limit?: number
+    urls?: string[]
+    patternType?: SafelinkPatternType
+    actions?: SafelinkActionType[]
+    reason?: SafelinkReasonType
+    createdBy?: string
+    direction?: 'asc' | 'desc'
+  } = {}): Promise<{
+    rules: Selectable<SafelinkRule>[]
+    cursor?: string
+  }> {
+    let query = this.db.db.selectFrom('safelink_rule').selectAll()
+
+    if (urls && urls.length > 0) {
+      query = query.where('url', 'in', urls)
+    }
+
+    if (patternType) {
+      query = query.where('pattern', '=', patternType)
+    }
+
+    if (actions && actions.length > 0) {
+      query = query.where('action', 'in', actions)
+    }
+
+    if (reason) {
+      query = query.where('reason', '=', reason)
+    }
+
+    if (createdBy) {
+      query = query.where('createdBy', '=', createdBy)
+    }
+
+    if (cursor) {
+      query = query.where(
+        'id',
+        direction === 'asc' ? '>' : '<',
+        parseInt(cursor, 10),
+      )
+    }
+
+    const rules = await query.orderBy('id', direction).limit(limit).execute()
+
+    return {
+      rules,
+      cursor: rules.at(-1)?.id?.toString(),
+    }
+  }
+
+  async queryEvents({
+    cursor,
+    limit = 50,
+    urls,
+    patternType,
+    direction = 'desc',
+  }: {
+    cursor?: string
+    limit?: number
+    urls?: string[]
+    patternType?: SafelinkPatternType
+    direction?: 'asc' | 'desc'
+  } = {}): Promise<{
+    events: Selectable<SafelinkEvent>[]
+    cursor?: string
+  }> {
+    let query = this.db.db.selectFrom('safelink_event').selectAll()
+
+    if (urls && urls.length > 0) {
+      query = query.where('url', 'in', urls)
+    }
+
+    if (patternType) {
+      query = query.where('pattern', '=', patternType)
+    }
+
+    if (cursor) {
+      query = query.where(
+        'id',
+        direction === 'asc' ? '>' : '<',
+        parseInt(cursor, 10),
+      )
+    }
+
+    const events = await query.orderBy('id', direction).limit(limit).execute()
+
+    return {
+      events,
+      cursor: events.at(-1)?.id?.toString(),
+    }
+  }
+}

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

@@ -0,0 +1,179 @@
+// Jest Snapshot v1, https://goo.gl/fbAQLP
+
+exports[`safelink management addRule allows admins to add rules 1`] = `
+Object {
+  "action": "block",
+  "comment": "Known phishing domain targeting users",
+  "createdAt": "1970-01-01T00:00:00.000Z",
+  "createdBy": "user(0)",
+  "eventType": "addRule",
+  "id": 1,
+  "pattern": "domain",
+  "reason": "phishing",
+  "url": "https://malicious-site.com",
+}
+`;
+
+exports[`safelink management queryEvents allows querying safelink events 1`] = `
+Array [
+  Object {
+    "action": "block",
+    "comment": "Escalated to block",
+    "createdAt": "1970-01-01T00:00:00.000Z",
+    "createdBy": "user(0)",
+    "eventType": "updateRule",
+    "id": 10,
+    "pattern": "domain",
+    "reason": "phishing",
+    "url": "https://events-test.com",
+  },
+  Object {
+    "action": "warn",
+    "comment": "Initial rule creation",
+    "createdAt": "1970-01-01T00:00:00.000Z",
+    "createdBy": "user(0)",
+    "eventType": "addRule",
+    "id": 9,
+    "pattern": "domain",
+    "reason": "spam",
+    "url": "https://events-test.com",
+  },
+  Object {
+    "action": "warn",
+    "createdAt": "1970-01-01T00:00:00.000Z",
+    "createdBy": "user(0)",
+    "eventType": "addRule",
+    "id": 8,
+    "pattern": "url",
+    "reason": "spam",
+    "url": "https://query-test2.com/specific-path",
+  },
+  Object {
+    "action": "block",
+    "createdAt": "1970-01-01T00:00:00.000Z",
+    "createdBy": "user(0)",
+    "eventType": "addRule",
+    "id": 7,
+    "pattern": "domain",
+    "reason": "phishing",
+    "url": "https://query-test1.com",
+  },
+  Object {
+    "action": "block",
+    "createdAt": "1970-01-01T00:00:00.000Z",
+    "createdBy": "user(0)",
+    "eventType": "addRule",
+    "id": 6,
+    "pattern": "domain",
+    "reason": "spam",
+    "url": "https://remove-test2.com",
+  },
+  Object {
+    "action": "block",
+    "comment": "Removing rule - false positive",
+    "createdAt": "1970-01-01T00:00:00.000Z",
+    "createdBy": "user(0)",
+    "eventType": "removeRule",
+    "id": 5,
+    "pattern": "url",
+    "reason": "csam",
+    "url": "https://remove-test.com",
+  },
+  Object {
+    "action": "block",
+    "comment": "Rule to be removed",
+    "createdAt": "1970-01-01T00:00:00.000Z",
+    "createdBy": "user(0)",
+    "eventType": "addRule",
+    "id": 4,
+    "pattern": "url",
+    "reason": "csam",
+    "url": "https://remove-test.com",
+  },
+  Object {
+    "action": "block",
+    "comment": "Updated: confirmed phishing site",
+    "createdAt": "1970-01-01T00:00:00.000Z",
+    "createdBy": "user(0)",
+    "eventType": "updateRule",
+    "id": 3,
+    "pattern": "domain",
+    "reason": "phishing",
+    "url": "https://update-test.com",
+  },
+  Object {
+    "action": "warn",
+    "comment": "Initially marked as spam",
+    "createdAt": "1970-01-01T00:00:00.000Z",
+    "createdBy": "user(0)",
+    "eventType": "addRule",
+    "id": 2,
+    "pattern": "domain",
+    "reason": "spam",
+    "url": "https://update-test.com",
+  },
+  Object {
+    "action": "block",
+    "comment": "Known phishing domain targeting users",
+    "createdAt": "1970-01-01T00:00:00.000Z",
+    "createdBy": "user(0)",
+    "eventType": "addRule",
+    "id": 1,
+    "pattern": "domain",
+    "reason": "phishing",
+    "url": "https://malicious-site.com",
+  },
+]
+`;
+
+exports[`safelink management queryRules allows querying all active rules 1`] = `
+Array [
+  Object {
+    "action": "warn",
+    "createdAt": "1970-01-01T00:00:00.000Z",
+    "createdBy": "user(0)",
+    "pattern": "url",
+    "reason": "spam",
+    "updatedAt": "1970-01-01T00:00:00.000Z",
+    "url": "https://query-test2.com/specific-path",
+  },
+  Object {
+    "action": "block",
+    "createdAt": "1970-01-01T00:00:00.000Z",
+    "createdBy": "user(0)",
+    "pattern": "domain",
+    "reason": "phishing",
+    "updatedAt": "1970-01-01T00:00:00.000Z",
+    "url": "https://query-test1.com",
+  },
+  Object {
+    "action": "block",
+    "createdAt": "1970-01-01T00:00:00.000Z",
+    "createdBy": "user(0)",
+    "pattern": "domain",
+    "reason": "spam",
+    "updatedAt": "1970-01-01T00:00:00.000Z",
+    "url": "https://remove-test2.com",
+  },
+  Object {
+    "action": "block",
+    "comment": "Updated: confirmed phishing site",
+    "createdAt": "1970-01-01T00:00:00.000Z",
+    "createdBy": "user(0)",
+    "pattern": "domain",
+    "reason": "phishing",
+    "updatedAt": "1970-01-01T00:00:00.000Z",
+    "url": "https://update-test.com",
+  },
+  Object {
+    "action": "block",
+    "comment": "Known phishing domain targeting users",
+    "createdAt": "1970-01-01T00:00:00.000Z",
+    "createdBy": "user(0)",
+    "pattern": "domain",
+    "reason": "phishing",
+    "updatedAt": "1970-01-01T00:00:00.000Z",
+    "url": "https://malicious-site.com",
+  },
+]
+`;

package/tests/communication-templates.test.ts

@@ -28,7 +28,7 @@ describe('communication-templates', () => {
   }
 
   const listTemplates = async () => {
-    const { data } = await agent.api.tools.ozone.communication.listTemplates(
+    const { data } = await agent.tools.ozone.communication.listTemplates(
       {},
       {
         headers: await network.ozone.modHeaders(
@@ -42,7 +42,7 @@ describe('communication-templates', () => {
 
   describe('create templates', () => {
     it('only allows admins to create new templates', async () => {
-      const moderatorReq = agent.api.tools.ozone.communication.createTemplate(
+      const moderatorReq = agent.tools.ozone.communication.createTemplate(
         { ...templateOne, createdBy: sc.dids.bob },
         {
           encoding: 'application/json',
@@ -55,7 +55,7 @@ describe('communication-templates', () => {
       await expect(moderatorReq).rejects.toThrow(
         'Must be a moderator to create a communication template',
       )
-      const modReq = await agent.api.tools.ozone.communication.createTemplate(
+      const modReq = await agent.tools.ozone.communication.createTemplate(
         { ...templateOne, createdBy: sc.dids.bob },
         {
           encoding: 'application/json',
@@ -82,7 +82,7 @@ describe('communication-templates', () => {
         ...templateOne,
         name: 'Test template 2',
       }
-      await agent.api.tools.ozone.communication.createTemplate(
+      await agent.tools.ozone.communication.createTemplate(
         { ...templateTwo, createdBy: sc.dids.bob },
         {
           encoding: 'application/json',
@@ -100,7 +100,7 @@ describe('communication-templates', () => {
   })
   describe('update template', () => {
     it('allows moderators to update a template by id', async () => {
-      const { data } = await agent.api.tools.ozone.communication.updateTemplate(
+      const { data } = await agent.tools.ozone.communication.updateTemplate(
         { id: '1', updatedBy: sc.dids.bob, name: '1 Test template' },
         {
           encoding: 'application/json',
@@ -117,7 +117,7 @@ describe('communication-templates', () => {
   })
   describe('delete template', () => {
     it('allows admins to remove a template by id', async () => {
-      const modReq = agent.api.tools.ozone.communication.deleteTemplate(
+      const modReq = agent.tools.ozone.communication.deleteTemplate(
         { id: '1' },
         {
           encoding: 'application/json',
@@ -132,7 +132,7 @@ describe('communication-templates', () => {
         'Must be a moderator to delete a communication template',
       )
 
-      await agent.api.tools.ozone.communication.deleteTemplate(
+      await agent.tools.ozone.communication.deleteTemplate(
         { id: '1' },
         {
           encoding: 'application/json',

package/tests/mod-tool.test.ts

@@ -0,0 +1,128 @@
+import {
+  ModeratorClient,
+  SeedClient,
+  TestNetwork,
+  basicSeed,
+} from '@atproto/dev-env'
+
+describe('mod-tool tracking', () => {
+  let network: TestNetwork
+  let sc: SeedClient
+  let modClient: ModeratorClient
+
+  beforeAll(async () => {
+    network = await TestNetwork.create({
+      dbPostgresSchema: 'ozone_mod_tool_test',
+    })
+    sc = network.getSeedClient()
+    modClient = network.ozone.getModClient()
+    await basicSeed(sc)
+    await network.processAll()
+  })
+
+  afterAll(async () => {
+    await network.close()
+  })
+
+  it('stores and returns modTool with name and meta metadata', async () => {
+    const subject = {
+      $type: 'com.atproto.repo.strongRef' as const,
+      uri: sc.posts[sc.dids.bob][0].ref.uriStr,
+      cid: sc.posts[sc.dids.bob][0].ref.cidStr,
+    }
+
+    const modTool = {
+      name: 'automod/1.1.3',
+      meta: {
+        confidence: 85,
+        rules: ['high_risk_country', 'spam_detection'],
+        version: '1.1.3',
+        environment: 'production',
+      },
+    }
+
+    const emittedEvent = await modClient.emitEvent({
+      event: {
+        $type: 'tools.ozone.moderation.defs#modEventLabel',
+        createLabelVals: ['spam'],
+        negateLabelVals: [],
+      },
+      subject,
+      modTool,
+    })
+
+    expect(emittedEvent.modTool).toEqual(modTool)
+    expect(emittedEvent.modTool?.name).toBe('automod/1.1.3')
+    expect(emittedEvent.modTool?.meta).toEqual({
+      confidence: 85,
+      rules: ['high_risk_country', 'spam_detection'],
+      version: '1.1.3',
+      environment: 'production',
+    })
+
+    const queryResult = await modClient.queryEvents({
+      subject: subject.uri,
+    })
+
+    const foundEvent = queryResult.events.find((e) => e.id === emittedEvent.id)
+    expect(foundEvent?.modTool).toEqual(modTool)
+  })
+
+  it('filters events by modTool name', async () => {
+    const subject = {
+      $type: 'com.atproto.repo.strongRef' as const,
+      uri: sc.posts[sc.dids.alice][0].ref.uriStr,
+      cid: sc.posts[sc.dids.alice][0].ref.cidStr,
+    }
+
+    const event1 = await modClient.emitEvent({
+      event: {
+        $type: 'tools.ozone.moderation.defs#modEventLabel',
+        createLabelVals: ['test1'],
+        negateLabelVals: [],
+      },
+      subject,
+      modTool: { name: 'automod/1.1.3' },
+    })
+
+    const event2 = await modClient.emitEvent({
+      event: {
+        $type: 'tools.ozone.moderation.defs#modEventLabel',
+        createLabelVals: ['test2'],
+        negateLabelVals: [],
+      },
+      subject,
+      modTool: { name: 'ozone-web/1.0.0' },
+    })
+
+    const event3 = await modClient.emitEvent({
+      event: {
+        $type: 'tools.ozone.moderation.defs#modEventLabel',
+        createLabelVals: ['test3'],
+        negateLabelVals: [],
+      },
+      subject,
+      modTool: { name: 'mobile-app/2.1.0' },
+    })
+
+    const automodResults = await modClient.queryEvents({
+      subject: subject.uri,
+      modTool: ['automod/1.1.3'],
+    })
+
+    expect(automodResults.events).toHaveLength(1)
+    expect(automodResults.events[0].id).toBe(event1.id)
+    expect(automodResults.events[0].modTool?.name).toBe('automod/1.1.3')
+
+    const multipleResults = await modClient.queryEvents({
+      subject: subject.uri,
+      modTool: ['automod/1.1.3', 'ozone-web/1.0.0'],
+    })
+
+    expect(multipleResults.events).toHaveLength(2)
+    const eventIds = multipleResults.events.map((e) => e.id)
+    expect(eventIds).toContain(event1.id)
+    expect(eventIds).toContain(event2.id)
+    expect(eventIds).not.toContain(event3.id)
+  })
+})