@atproto/ozone 0.2.8 → 0.2.11

package/src/setting/validators.ts

@@ -1,333 +0,0 @@
-import { Selectable } from 'kysely'
-import { InvalidRequestError } from '@atproto/xrpc-server'
-import { Setting } from '../db/schema/setting.js'
-import {
-  PolicyListSettingKey,
-  ProtectedTagSettingKey,
-  SeverityLevelSettingKey,
-} from './constants.js'
-
-export const settingValidators = new Map<
-  string,
-  (setting: Partial<Selectable<Setting>>) => Promise<void>
->([
-  [
-    ProtectedTagSettingKey,
-    /*
-     * Example configuration:
-     * {
-     *   "sensitive-tag": {
-     *     "roles": ["tools.ozone.team.defs#roleAdmin", "tools.ozone.team.defs#roleModerator"],
-     *     "moderators": ["did:plc:example1", "did:plc:example2"]
-     *   },
-     *   "high-risk-tag": {
-     *     "roles": ["tools.ozone.team.defs#roleAdmin"]
-     *   },
-     *   "admin-only-tag": {
-     *     "moderators": ["did:plc:admin1"]
-     *   }
-     * }
-     */
-    async (setting: Partial<Selectable<Setting>>) => {
-      if (setting.managerRole !== 'tools.ozone.team.defs#roleAdmin') {
-        throw new InvalidRequestError(
-          'Only admins should be able to configure protected tags',
-        )
-      }
-
-      if (typeof setting.value !== 'object') {
-        throw new InvalidRequestError('Invalid value')
-      }
-      for (const [key, val] of Object.entries(setting.value)) {
-        if (!val || typeof val !== 'object') {
-          throw new InvalidRequestError(`Invalid configuration for tag ${key}`)
-        }
-
-        if (!val['roles'] && !val['moderators']) {
-          throw new InvalidRequestError(
-            `Must define who a list of moderators or a role who can action subjects with ${key} tag`,
-          )
-        }
-
-        if (val['roles']) {
-          if (!Array.isArray(val['roles'])) {
-            throw new InvalidRequestError(
-              `Roles must be an array of moderator roles for tag ${key}`,
-            )
-          }
-          if (!val['roles']?.length) {
-            throw new InvalidRequestError(
-              `Must define at least one role for tag ${key}`,
-            )
-          }
-        }
-
-        if (val['moderators']) {
-          if (!Array.isArray(val['moderators'])) {
-            throw new InvalidRequestError(
-              `Moderators must be an array of moderator DIDs for tag ${key}`,
-            )
-          }
-          if (!val['moderators']?.length) {
-            throw new InvalidRequestError(
-              `Must define at least one moderator DID for tag ${key}`,
-            )
-          }
-        }
-      }
-    },
-  ],
-  [
-    PolicyListSettingKey,
-    /*
-     * Example configuration:
-     * {
-     *   "harassment": {
-     *     "name": "Anti-Harassment",
-     *     "description": "Content that harasses, intimidates, or bullies users",
-     *     "severityLevels": {
-     *       "sev-1": {
-     *         "description": "Minor harassment",
-     *         "isDefault": true
-     *       },
-     *       "sev-2": {
-     *         "description": "Moderate harassment",
-     *         "isDefault": false
-     *       },
-     *       "sev-4": {
-     *         "description": "Severe harassment",
-     *         "isDefault": false
-     *       }
-     *     }
-     *   },
-     *   "death-threats": {
-     *     "name": "Death Threats",
-     *     "description": "Threats of violence or death against individuals",
-     *     "severityLevels": {
-     *       "death-threat": {
-     *         "description": "Death threat violation",
-     *         "isDefault": true
-     *       }
-     *     }
-     *   },
-     *   "spam": {
-     *     "name": "Spam",
-     *     "description": "Unsolicited or repetitive content",
-     *     "severityLevels": {
-     *       "sev-0": {
-     *         "description": "Minor spam",
-     *         "isDefault": false
-     *       },
-     *       "sev-1": {
-     *         "description": "Moderate spam",
-     *         "isDefault": true
-     *       },
-     *       "sev-2": {
-     *         "description": "Severe spam",
-     *         "isDefault": false
-     *       }
-     *     }
-     *   },
-     *   "minimal-policy": {
-     *     "name": "Basic Policy",
-     *     "description": "Simple policy without severity levels"
-     *   }
-     * }
-     */
-    async (setting: Partial<Selectable<Setting>>) => {
-      if (setting.managerRole !== 'tools.ozone.team.defs#roleAdmin') {
-        throw new InvalidRequestError(
-          'Only admins should be able to manage policy list',
-        )
-      }
-
-      if (typeof setting.value !== 'object') {
-        throw new InvalidRequestError('Invalid value')
-      }
-      for (const [key, val] of Object.entries(setting.value)) {
-        if (!val || typeof val !== 'object') {
-          throw new InvalidRequestError(
-            `Invalid configuration for policy ${key}`,
-          )
-        }
-
-        if (!val['name'] || !val['description']) {
-          throw new InvalidRequestError(
-            `Must define a name and description for policy ${key}`,
-          )
-        }
-
-        if (val['severityLevels'] !== undefined) {
-          if (typeof val['severityLevels'] !== 'object') {
-            throw new InvalidRequestError(
-              `Severity levels must be an object for policy ${key}`,
-            )
-          }
-
-          let hasDefault = false
-          for (const [severityKey, severityVal] of Object.entries(
-            val['severityLevels'],
-          )) {
-            if (!severityVal || typeof severityVal !== 'object') {
-              throw new InvalidRequestError(
-                `Invalid configuration for severity level ${severityKey} in policy ${key}`,
-              )
-            }
-
-            if (
-              severityVal['description'] !== undefined &&
-              typeof severityVal['description'] !== 'string'
-            ) {
-              throw new InvalidRequestError(
-                `Description must be a string for severity level ${severityKey} in policy ${key}`,
-              )
-            }
-
-            if (severityVal['isDefault'] !== undefined) {
-              if (typeof severityVal['isDefault'] !== 'boolean') {
-                throw new InvalidRequestError(
-                  `isDefault must be a boolean for severity level ${severityKey} in policy ${key}`,
-                )
-              }
-              if (severityVal['isDefault']) {
-                if (hasDefault) {
-                  throw new InvalidRequestError(
-                    `Only one severity level can be the default for policy ${key}`,
-                  )
-                }
-                hasDefault = true
-              }
-            }
-
-            if (severityVal['targetServices'] !== undefined) {
-              if (!Array.isArray(severityVal['targetServices'])) {
-                throw new InvalidRequestError(
-                  `targetServices must be an array for severity level ${severityKey} in policy ${key}`,
-                )
-              }
-              for (const service of severityVal['targetServices']) {
-                if (typeof service !== 'string') {
-                  throw new InvalidRequestError(
-                    `Each target service must be a string for severity level ${severityKey} in policy ${key}`,
-                  )
-                }
-              }
-            }
-          }
-        }
-      }
-    },
-  ],
-  [
-    SeverityLevelSettingKey,
-    /*
-     * Example configuration:
-     * {
-     *   "sev-0": {
-     *     "strikeCount": 0
-     *   },
-     *   "sev-1": {
-     *     "strikeCount": 1,
-     *     "strikeOnOccurrence": 2
-     *   },
-     *   "sev-2": {
-     *     "strikeCount": 2
-     *   },
-     *   "sev-4": {
-     *     "strikeCount": 4,
-     *     "expiresInDays": 365
-     *   },
-     *   "sev-5": {
-     *     "needsTakedown": true
-     *   },
-     *   "death-threat": {
-     *     "strikeCount": 4,
-     *     "firstOccurrenceStrikeCount": 4,
-     *   },
-     *   "custom-severity": {
-     *     "strikeCount": 3,
-     *     "strikeOnOccurrence": 1,
-     *   },
-     *   "escalating-severity": {
-     *     "firstOccurrenceStrikeCount": 2,
-     *     "repeatOccurrenceStrikeCount": 5
-     *   }
-     * }
-     */
-    async (setting: Partial<Selectable<Setting>>) => {
-      if (setting.managerRole !== 'tools.ozone.team.defs#roleAdmin') {
-        throw new InvalidRequestError(
-          'Only admins should be able to manage severity levels',
-        )
-      }
-
-      if (typeof setting.value !== 'object') {
-        throw new InvalidRequestError('Invalid value')
-      }
-
-      for (const [key, val] of Object.entries(setting.value)) {
-        if (!val || typeof val !== 'object') {
-          throw new InvalidRequestError(
-            `Invalid configuration for severity level ${key}`,
-          )
-        }
-
-        if (val['strikeCount'] !== undefined) {
-          if (
-            typeof val['strikeCount'] !== 'number' ||
-            !Number.isInteger(val['strikeCount']) ||
-            val['strikeCount'] < 0
-          ) {
-            throw new InvalidRequestError(
-              `Strike count must be a non-negative integer for severity level ${key}`,
-            )
-          }
-        }
-
-        if (val['strikeOnOccurrence'] !== undefined) {
-          if (
-            typeof val['strikeOnOccurrence'] !== 'number' ||
-            !Number.isInteger(val['strikeOnOccurrence']) ||
-            val['strikeOnOccurrence'] < 1
-          ) {
-            throw new InvalidRequestError(
-              `Strike on occurrence must be a positive integer for severity level ${key}`,
-            )
-          }
-        }
-
-        if (val['needsTakedown'] !== undefined) {
-          if (typeof val['needsTakedown'] !== 'boolean') {
-            throw new InvalidRequestError(
-              `Needs takedown must be a boolean for severity level ${key}`,
-            )
-          }
-        }
-
-        if (val['expiresInDays'] !== undefined) {
-          if (
-            typeof val['expiresInDays'] !== 'number' ||
-            !Number.isInteger(val['expiresInDays']) ||
-            val['expiresInDays'] < 0
-          ) {
-            throw new InvalidRequestError(
-              `Expires in days must be a non-negative integer for severity level ${key}`,
-            )
-          }
-        }
-
-        if (val['firstOccurrenceStrikeCount'] !== undefined) {
-          if (
-            typeof val['firstOccurrenceStrikeCount'] !== 'number' ||
-            !Number.isInteger(val['firstOccurrenceStrikeCount']) ||
-            val['firstOccurrenceStrikeCount'] < 0
-          ) {
-            throw new InvalidRequestError(
-              `First occurrence strike count must be a non-negative integer for severity level ${key}`,
-            )
-          }
-        }
-      }
-    },
-  ],
-])

package/src/tag-service/content-tagger.ts

@@ -1,30 +0,0 @@
-import { ModerationService } from '../mod-service/index.js'
-import { ModSubject } from '../mod-service/subject.js'
-import { ModerationSubjectStatusRow } from '../mod-service/types.js'
-
-export abstract class ContentTagger {
-  constructor(
-    protected subject: ModSubject,
-    protected subjectStatus: ModerationSubjectStatusRow | null,
-    protected moderationService: ModerationService,
-  ) {}
-
-  protected abstract tagPrefix: string
-
-  protected abstract isApplicable(): boolean
-  protected abstract buildTags(): Promise<string[]>
-
-  async getTags(): Promise<string[]> {
-    if (!this.isApplicable()) {
-      return []
-    }
-
-    return this.buildTags()
-  }
-
-  protected tagAlreadyExists(): boolean {
-    return Boolean(
-      this.subjectStatus?.tags?.some((tag) => tag.startsWith(this.tagPrefix)),
-    )
-  }
-}

package/src/tag-service/embed-tagger.ts

@@ -1,70 +0,0 @@
-import {
-  AppBskyEmbedExternal,
-  AppBskyEmbedImages,
-  AppBskyEmbedRecordWithMedia,
-  AppBskyEmbedVideo,
-  AppBskyFeedPost,
-} from '@atproto/api'
-import { ids } from '../lexicon/lexicons.js'
-import { langLogger as log } from '../logger.js'
-import { ContentTagger } from './content-tagger.js'
-
-export class EmbedTagger extends ContentTagger {
-  tagPrefix = 'embed:'
-
-  isApplicable(): boolean {
-    return (
-      !!this.subjectStatus &&
-      !this.tagAlreadyExists() &&
-      this.subject.isRecord() &&
-      this.subject.parsedUri.collection === ids.AppBskyFeedPost
-    )
-  }
-
-  async buildTags(): Promise<string[]> {
-    try {
-      const recordValue = await this.getRecordValue()
-      if (!recordValue) {
-        return []
-      }
-      const tags: string[] = []
-      const result = AppBskyFeedPost.validateRecord(recordValue)
-
-      if (result.success) {
-        const embedContent = AppBskyEmbedRecordWithMedia.isMain(
-          result.value.embed,
-        )
-          ? result.value.embed.media
-          : result.value.embed
-
-        if (AppBskyEmbedImages.isMain(embedContent)) {
-          tags.push(`${this.tagPrefix}image`)
-        }
-
-        if (AppBskyEmbedVideo.isMain(embedContent)) {
-          tags.push(`${this.tagPrefix}video`)
-        }
-
-        if (AppBskyEmbedExternal.isMain(embedContent)) {
-          tags.push(`${this.tagPrefix}external`)
-        }
-      }
-      return tags
-    } catch (err) {
-      log.error({ subject: this.subject, err }, 'Error getting record langs')
-      return []
-    }
-  }
-
-  async getRecordValue(): Promise<Record<string, unknown> | undefined> {
-    if (!this.subject.isRecord()) {
-      return undefined
-    }
-    const recordByUri = await this.moderationService.views.fetchRecords([
-      this.subject,
-    ])
-
-    const record = recordByUri.get(this.subject.uri)
-    return record?.value
-  }
-}

package/src/tag-service/index.ts

@@ -1,70 +0,0 @@
-import { langLogger as log } from '../logger.js'
-import { ModerationService } from '../mod-service/index.js'
-import { ModSubject } from '../mod-service/subject.js'
-import { ModerationSubjectStatusRow } from '../mod-service/types.js'
-import { ContentTagger } from './content-tagger.js'
-import { EmbedTagger } from './embed-tagger.js'
-import { LanguageTagger } from './language-tagger.js'
-
-export class TagService {
-  private taggers: ContentTagger[]
-
-  constructor(
-    private subject: ModSubject,
-    protected subjectStatus: ModerationSubjectStatusRow | null,
-    private taggerDid: string,
-    private moderationService: ModerationService,
-  ) {
-    this.taggers = [
-      new LanguageTagger(subject, subjectStatus, moderationService),
-      new EmbedTagger(subject, subjectStatus, moderationService),
-      // Add more taggers as needed
-    ]
-  }
-
-  // Allow the caller to seed the initial tags
-  async evaluateForSubject(initialTags?: Iterable<string>) {
-    try {
-      const tags = new Set(initialTags)
-
-      await Promise.all(
-        this.taggers.map(async (tagger) => {
-          try {
-            const newTags = await tagger.getTags()
-            for (const newTag of newTags) {
-              tags.add(newTag)
-            }
-          } catch (e) {
-            // Don't let one tagger error stop the rest from running
-            log.error(
-              { subject: this.subject, err: e },
-              'Error applying tagger',
-            )
-          }
-        }),
-      )
-
-      // Ensure that before inserting new tags, we discard any tag that may
-      // have been evaluated to be added but is already present in the subject
-      if (this.subjectStatus?.tags?.length) {
-        for (const tag of this.subjectStatus.tags) {
-          tags.delete(tag)
-        }
-      }
-
-      if (tags.size) {
-        await this.moderationService.logEvent({
-          event: {
-            $type: 'tools.ozone.moderation.defs#modEventTag',
-            add: [...tags],
-            remove: [],
-          },
-          subject: this.subject,
-          createdBy: this.taggerDid,
-        })
-      }
-    } catch (err) {
-      log.error({ subject: this.subject, err }, 'Error tagging subject')
-    }
-  }
-}