@atproto/api 0.11.0-next → 0.11.0

package/src/agent.ts

@@ -17,9 +17,12 @@ import {
   AtpAgentGlobalOpts,
   AtpPersistSessionHandler,
   AtpAgentOpts,
+  AtprotoServiceType,
 } from './types'
-import { BSKY_MODSERVICE_DID } from './const'
+import { BSKY_LABELER_DID } from './const'
 
+const MAX_MOD_AUTHORITIES = 3
+const MAX_LABELERS = 10
 const REFRESH_SESSION = 'com.atproto.server.refreshSession'
 
 /**
@@ -30,16 +33,13 @@ export class AtpAgent {
   service: URL
   api: AtpServiceClient
   session?: AtpSessionData
-  labelersHeader: string[] = [BSKY_MODSERVICE_DID]
+  labelersHeader: string[] = []
+  proxyHeader: string | undefined
+  pdsUrl: URL | undefined // The PDS URL, driven by the did doc. May be undefined.
 
-  /**
-   * The PDS URL, driven by the did doc. May be undefined.
-   */
-  pdsUrl: URL | undefined
-
-  private _baseClient: AtpBaseClient
-  private _persistSession?: AtpPersistSessionHandler
-  private _refreshSessionPromise: Promise<void> | undefined
+  protected _baseClient: AtpBaseClient
+  protected _persistSession?: AtpPersistSessionHandler
+  protected _refreshSessionPromise: Promise<void> | undefined
 
   get com() {
     return this.api.com
@@ -50,11 +50,21 @@ export class AtpAgent {
    */
   static fetch: AtpAgentFetchHandler | undefined = defaultFetchHandler
 
+  /**
+   * The labelers to be used across all requests with the takedown capability
+   */
+  static appLabelers: string[] = [BSKY_LABELER_DID]
+
   /**
    * Configures the API globally.
    */
   static configure(opts: AtpAgentGlobalOpts) {
-    AtpAgent.fetch = opts.fetch
+    if (opts.fetch) {
+      AtpAgent.fetch = opts.fetch
+    }
+    if (opts.appLabelers) {
+      AtpAgent.appLabelers = opts.appLabelers
+    }
   }
 
   constructor(opts: AtpAgentOpts) {
@@ -68,6 +78,27 @@ export class AtpAgent {
     this.api = this._baseClient.service(opts.service)
   }
 
+  clone() {
+    const inst = new AtpAgent({
+      service: this.service,
+    })
+    this.copyInto(inst)
+    return inst
+  }
+
+  copyInto(inst: AtpAgent) {
+    inst.session = this.session
+    inst.labelersHeader = this.labelersHeader
+    inst.proxyHeader = this.proxyHeader
+    inst.pdsUrl = this.pdsUrl
+  }
+
+  withProxy(serviceType: AtprotoServiceType, did: string) {
+    const inst = this.clone()
+    inst.configureProxyHeader(serviceType, did)
+    return inst
+  }
+
   /**
    * Is there any active session?
    */
@@ -92,6 +123,15 @@ export class AtpAgent {
     this.labelersHeader = labelerDids
   }
 
+  /**
+   * Configures the atproto-proxy header to be applied on requests
+   */
+  configureProxyHeader(serviceType: AtprotoServiceType, did: string) {
+    if (did.startsWith('did:')) {
+      this.proxyHeader = `${did}#${serviceType}`
+    }
+  }
+
   /**
    * Create a new account and hydrate its session in this agent.
    */
@@ -212,15 +252,20 @@ export class AtpAgent {
         authorization: `Bearer ${this.session.accessJwt}`,
       }
     }
-    if (this.labelersHeader.length) {
+    if (this.proxyHeader) {
       reqHeaders = {
         ...reqHeaders,
-        'atproto-labelers': this.labelersHeader
-          .filter((str) => str.startsWith('did:'))
-          .slice(0, 10)
-          .join(','),
+        'atproto-proxy': this.proxyHeader,
       }
     }
+    reqHeaders = {
+      ...reqHeaders,
+      'atproto-accept-labelers': AtpAgent.appLabelers
+        .map((str) => `${str};redact`)
+        .concat(this.labelersHeader.filter((str) => str.startsWith('did:')))
+        .slice(0, MAX_LABELERS)
+        .join(', '),
+    }
     return reqHeaders
   }
 

package/src/bsky-agent.ts

@@ -4,6 +4,7 @@ import {
   AppBskyFeedPost,
   AppBskyActorProfile,
   AppBskyActorDefs,
+  AppBskyLabelerDefs,
   ComAtprotoRepoPutRecord,
 } from './client'
 import {
@@ -12,10 +13,14 @@ import {
   BskyThreadViewPreference,
   BskyInterestsPreference,
 } from './types'
-import { LabelPreference } from './moderation/types'
-import { BSKY_MODSERVICE_DID } from './const'
+import {
+  InterpretedLabelValueDefinition,
+  LabelPreference,
+  ModerationPrefs,
+} from './moderation/types'
 import { DEFAULT_LABEL_SETTINGS } from './moderation/const/labels'
 import { sanitizeMutedWordValue } from './util'
+import { interpretLabelValueDefinitions } from './moderation'
 
 const FEED_VIEW_PREF_DEFAULTS = {
   hideReplies: false,
@@ -39,6 +44,14 @@ declare global {
 }
 
 export class BskyAgent extends AtpAgent {
+  clone() {
+    const inst = new BskyAgent({
+      service: this.service,
+    })
+    this.copyInto(inst)
+    return inst
+  }
+
   get app() {
     return this.api.app
   }
@@ -103,6 +116,37 @@ export class BskyAgent extends AtpAgent {
   getLabelers: typeof this.api.app.bsky.labeler.getServices = (params, opts) =>
     this.api.app.bsky.labeler.getServices(params, opts)
 
+  async getLabelDefinitions(
+    prefs: BskyPreferences | ModerationPrefs | string[],
+  ): Promise<Record<string, InterpretedLabelValueDefinition[]>> {
+    // collect the labeler dids
+    let dids: string[] = BskyAgent.appLabelers
+    if (isBskyPrefs(prefs)) {
+      dids = dids.concat(prefs.moderationPrefs.labelers.map((l) => l.did))
+    } else if (isModPrefs(prefs)) {
+      dids = dids.concat(prefs.labelers.map((l) => l.did))
+    } else {
+      dids = dids.concat(prefs)
+    }
+
+    // fetch their definitions
+    const labelers = await this.getLabelers({
+      dids,
+      detailed: true,
+    })
+
+    // assemble a map of labeler dids to the interpretted label value definitions
+    const labelDefs = {}
+    if (labelers.data) {
+      for (const labeler of labelers.data
+        .views as AppBskyLabelerDefs.LabelerViewDetailed[]) {
+        labelDefs[labeler.creator.did] = interpretLabelValueDefinitions(labeler)
+      }
+    }
+
+    return labelDefs
+  }
+
   async post(
     record: Partial<AppBskyFeedPost.Record> &
       Omit<AppBskyFeedPost.Record, 'createdAt'>,
@@ -330,14 +374,14 @@ export class BskyAgent extends AtpAgent {
       moderationPrefs: {
         adultContentEnabled: false,
         labels: { ...DEFAULT_LABEL_SETTINGS },
-        mods: [],
+        labelers: BskyAgent.appLabelers.map((did) => ({ did, labels: {} })),
+        mutedWords: [],
+        hiddenPosts: [],
       },
       birthDate: undefined,
       interests: {
         tags: [],
       },
-      mutedWords: [],
-      hiddenPosts: [],
     }
     const res = await this.app.bsky.actor.getPreferences({})
     const labelPrefs: AppBskyActorDefs.ContentLabelPref[] = []
@@ -356,14 +400,18 @@ export class BskyAgent extends AtpAgent {
         const adjustedPref = adjustLegacyContentLabelPref(pref)
         labelPrefs.push(adjustedPref)
       } else if (
-        AppBskyActorDefs.isModsPref(pref) &&
-        AppBskyActorDefs.validateModsPref(pref).success
+        AppBskyActorDefs.isLabelersPref(pref) &&
+        AppBskyActorDefs.validateLabelersPref(pref).success
       ) {
-        // mods preferences
-        prefs.moderationPrefs.mods = pref.mods.map((mod) => ({
-          ...mod,
-          labels: {},
-        }))
+        // labelers preferences
+        prefs.moderationPrefs.labelers = BskyAgent.appLabelers
+          .map((did) => ({ did, labels: {} }))
+          .concat(
+            pref.labelers.map((labeler) => ({
+              ...labeler,
+              labels: {},
+            })),
+          )
       } else if (
         AppBskyActorDefs.isSavedFeedsPref(pref) &&
         AppBskyActorDefs.validateSavedFeedsPref(pref).success
@@ -408,42 +456,35 @@ export class BskyAgent extends AtpAgent {
       ) {
         // eslint-disable-next-line @typescript-eslint/no-unused-vars
         const { $type, ...v } = pref
-        prefs.mutedWords = v.items
+        prefs.moderationPrefs.mutedWords = v.items
       } else if (
         AppBskyActorDefs.isHiddenPostsPref(pref) &&
         AppBskyActorDefs.validateHiddenPostsPref(pref).success
       ) {
         // eslint-disable-next-line @typescript-eslint/no-unused-vars
         const { $type, ...v } = pref
-        prefs.hiddenPosts = v.items
+        prefs.moderationPrefs.hiddenPosts = v.items
       }
     }
 
-    // ensure the bluesky moderation is configured
-    const bskyModeration = prefs.moderationPrefs.mods.find(
-      (modPref) => modPref.did === BSKY_MODSERVICE_DID,
-    )
-    if (!bskyModeration) {
-      prefs.moderationPrefs.mods.unshift({
-        did: BSKY_MODSERVICE_DID,
-        labels: {},
-      })
-    }
-
     // apply the label prefs
     for (const pref of labelPrefs) {
       if (pref.labelerDid) {
-        const mod = prefs.moderationPrefs.mods.find(
-          (mod) => mod.did === pref.labelerDid,
+        const labeler = prefs.moderationPrefs.labelers.find(
+          (labeler) => labeler.did === pref.labelerDid,
         )
-        if (!mod) continue
-        mod.labels[pref.label] = pref.visibility as LabelPreference
+        if (!labeler) continue
+        labeler.labels[pref.label] = pref.visibility as LabelPreference
       } else {
         prefs.moderationPrefs.labels[pref.label] =
           pref.visibility as LabelPreference
       }
     }
 
+    prefs.moderationPrefs.labels = remapLegacyLabels(
+      prefs.moderationPrefs.labels,
+    )
+
     // automatically configure the client
     this.configureLabelersHeader(prefsArrayToLabelerDids(res.data.preferences))
 
@@ -522,6 +563,8 @@ export class BskyAgent extends AtpAgent {
           pref.label === key &&
           pref.labelerDid === labelerDid,
       )
+      let legacyLabelPref: AppBskyActorDefs.ContentLabelPref | undefined
+
       if (labelPref) {
         labelPref.visibility = value
       } else {
@@ -532,6 +575,40 @@ export class BskyAgent extends AtpAgent {
           visibility: value,
         }
       }
+
+      if (AppBskyActorDefs.isContentLabelPref(labelPref)) {
+        // is global
+        if (!labelPref.labelerDid) {
+          const legacyLabelValue = {
+            'graphic-media': 'gore',
+            porn: 'nsfw',
+            sexual: 'suggestive',
+          }[labelPref.label]
+
+          // if it's a legacy label, double-write the legacy label
+          if (legacyLabelValue) {
+            legacyLabelPref = prefs.findLast(
+              (pref) =>
+                AppBskyActorDefs.isContentLabelPref(pref) &&
+                AppBskyActorDefs.validateContentLabelPref(pref).success &&
+                pref.label === legacyLabelValue &&
+                pref.labelerDid === undefined,
+            ) as AppBskyActorDefs.ContentLabelPref | undefined
+
+            if (legacyLabelPref) {
+              legacyLabelPref.visibility = value
+            } else {
+              legacyLabelPref = {
+                $type: 'app.bsky.actor.defs#contentLabelPref',
+                label: legacyLabelValue,
+                labelerDid: undefined,
+                visibility: value,
+              }
+            }
+          }
+        }
+      }
+
       return prefs
         .filter(
           (pref) =>
@@ -539,63 +616,78 @@ export class BskyAgent extends AtpAgent {
             !(pref.label === key && pref.labelerDid === labelerDid),
         )
         .concat([labelPref])
+        .filter((pref) => {
+          if (!legacyLabelPref) return true
+          return (
+            !AppBskyActorDefs.isContentLabelPref(pref) ||
+            !(
+              pref.label === legacyLabelPref.label &&
+              pref.labelerDid === undefined
+            )
+          )
+        })
+        .concat(legacyLabelPref ? [legacyLabelPref] : [])
     })
   }
 
-  async addModService(did: string) {
+  async addLabeler(did: string) {
     const prefs = await updatePreferences(
       this,
       (prefs: AppBskyActorDefs.Preferences) => {
-        let modsPref = prefs.findLast(
+        let labelersPref = prefs.findLast(
           (pref) =>
-            AppBskyActorDefs.isModsPref(pref) &&
-            AppBskyActorDefs.validateModsPref(pref).success,
+            AppBskyActorDefs.isLabelersPref(pref) &&
+            AppBskyActorDefs.validateLabelersPref(pref).success,
         )
-        if (!modsPref) {
-          modsPref = {
-            $type: 'app.bsky.actor.defs#modsPref',
-            mods: [],
+        if (!labelersPref) {
+          labelersPref = {
+            $type: 'app.bsky.actor.defs#labelersPref',
+            labelers: [],
           }
         }
-        if (AppBskyActorDefs.isModsPref(modsPref)) {
-          let modPrefItem = modsPref.mods.find((mod) => mod.did === did)
-          if (!modPrefItem) {
-            modPrefItem = {
+        if (AppBskyActorDefs.isLabelersPref(labelersPref)) {
+          let labelerPrefItem = labelersPref.labelers.find(
+            (labeler) => labeler.did === did,
+          )
+          if (!labelerPrefItem) {
+            labelerPrefItem = {
               did,
             }
-            modsPref.mods.push(modPrefItem)
+            labelersPref.labelers.push(labelerPrefItem)
           }
         }
         return prefs
-          .filter((pref) => !AppBskyActorDefs.isModsPref(pref))
-          .concat([modsPref])
+          .filter((pref) => !AppBskyActorDefs.isLabelersPref(pref))
+          .concat([labelersPref])
       },
     )
     // automatically configure the client
     this.configureLabelersHeader(prefsArrayToLabelerDids(prefs))
   }
 
-  async removeModService(did: string) {
+  async removeLabeler(did: string) {
     const prefs = await updatePreferences(
       this,
       (prefs: AppBskyActorDefs.Preferences) => {
-        let modsPref = prefs.findLast(
+        let labelersPref = prefs.findLast(
           (pref) =>
-            AppBskyActorDefs.isModsPref(pref) &&
-            AppBskyActorDefs.validateModsPref(pref).success,
+            AppBskyActorDefs.isLabelersPref(pref) &&
+            AppBskyActorDefs.validateLabelersPref(pref).success,
         )
-        if (!modsPref) {
-          modsPref = {
-            $type: 'app.bsky.actor.defs#modsPref',
-            mods: [],
+        if (!labelersPref) {
+          labelersPref = {
+            $type: 'app.bsky.actor.defs#labelersPref',
+            labelers: [],
           }
         }
-        if (AppBskyActorDefs.isModsPref(modsPref)) {
-          modsPref.mods = modsPref.mods.filter((mod) => mod.did !== did)
+        if (AppBskyActorDefs.isLabelersPref(labelersPref)) {
+          labelersPref.labelers = labelersPref.labelers.filter(
+            (labeler) => labeler.did !== did,
+          )
         }
         return prefs
-          .filter((pref) => !AppBskyActorDefs.isModsPref(pref))
-          .concat([modsPref])
+          .filter((pref) => !AppBskyActorDefs.isLabelersPref(pref))
+          .concat([labelersPref])
       },
     )
     // automatically configure the client
@@ -859,7 +951,6 @@ async function updateFeedPreferences(
 function adjustLegacyContentLabelPref(
   pref: AppBskyActorDefs.ContentLabelPref,
 ): AppBskyActorDefs.ContentLabelPref {
-  let label = pref.label
   let visibility = pref.visibility
 
   // adjust legacy values
@@ -867,15 +958,31 @@ function adjustLegacyContentLabelPref(
     visibility = 'ignore'
   }
 
-  // adjust legacy labels
-  if (label === 'nsfw') {
-    label = 'porn'
+  return { ...pref, visibility }
+}
+
+/**
+ * Re-maps legacy labels to new labels on READ. Does not save these changes to
+ * the user's preferences.
+ */
+function remapLegacyLabels(
+  labels: BskyPreferences['moderationPrefs']['labels'],
+) {
+  const _labels = { ...labels }
+  const legacyToNewMap: Record<string, string | undefined> = {
+    gore: 'graphic-media',
+    nsfw: 'porn',
+    suggestive: 'sexual',
   }
-  if (label === 'suggestive') {
-    label = 'sexual'
+
+  for (const labelName in _labels) {
+    const newLabelName = legacyToNewMap[labelName]!
+    if (newLabelName) {
+      _labels[newLabelName] = _labels[labelName]
+    }
   }
 
-  return { ...pref, label, visibility }
+  return _labels
 }
 
 /**
@@ -884,17 +991,16 @@ function adjustLegacyContentLabelPref(
 function prefsArrayToLabelerDids(
   prefs: AppBskyActorDefs.Preferences,
 ): string[] {
-  const modsPref = prefs.findLast(
+  const labelersPref = prefs.findLast(
     (pref) =>
-      AppBskyActorDefs.isModsPref(pref) &&
-      AppBskyActorDefs.validateModsPref(pref).success,
+      AppBskyActorDefs.isLabelersPref(pref) &&
+      AppBskyActorDefs.validateLabelersPref(pref).success,
   )
   let dids: string[] = []
-  if (modsPref) {
-    dids = (modsPref as AppBskyActorDefs.ModsPref).mods.map((mod) => mod.did)
-  }
-  if (!dids.includes(BSKY_MODSERVICE_DID)) {
-    dids.unshift(BSKY_MODSERVICE_DID)
+  if (labelersPref) {
+    dids = (labelersPref as AppBskyActorDefs.LabelersPref).labelers.map(
+      (labeler) => labeler.did,
+    )
   }
   return dids
 }
@@ -928,3 +1034,16 @@ async function updateHiddenPost(
       .concat([{ ...pref, $type: 'app.bsky.actor.defs#hiddenPostsPref' }])
   })
 }
+
+function isBskyPrefs(v: any): v is BskyPreferences {
+  return (
+    v &&
+    typeof v === 'object' &&
+    'moderationPrefs' in v &&
+    isModPrefs(v.moderationPrefs)
+  )
+}
+
+function isModPrefs(v: any): v is ModerationPrefs {
+  return v && typeof v === 'object' && 'labelers' in v
+}

package/src/client/lexicons.ts

@@ -855,6 +855,17 @@ export const schemaDict = {
               "What should this label hide in the UI, if applied? 'content' hides all of the target; 'media' hides the images/video/audio; 'none' hides nothing.",
             knownValues: ['content', 'media', 'none'],
           },
+          defaultSetting: {
+            type: 'string',
+            description: 'The default setting for this label.',
+            knownValues: ['ignore', 'warn', 'hide'],
+            default: 'warn',
+          },
+          adultOnly: {
+            type: 'boolean',
+            description:
+              'Does the user need to have adult content enabled in order to configure this label?',
+          },
           locales: {
             type: 'array',
             items: {
@@ -3958,20 +3969,20 @@ export const schemaDict = {
           },
         },
       },
-      modsPref: {
+      labelersPref: {
         type: 'object',
-        required: ['mods'],
+        required: ['labelers'],
         properties: {
-          mods: {
+          labelers: {
             type: 'array',
             items: {
               type: 'ref',
-              ref: 'lex:app.bsky.actor.defs#modPrefItem',
+              ref: 'lex:app.bsky.actor.defs#labelerPrefItem',
             },
           },
         },
       },
-      modPrefItem: {
+      labelerPrefItem: {
         type: 'object',
         required: ['did'],
         properties: {
@@ -4859,6 +4870,13 @@ export const schemaDict = {
             type: 'integer',
             minimum: 0,
           },
+          labels: {
+            type: 'array',
+            items: {
+              type: 'ref',
+              ref: 'lex:com.atproto.label.defs#label',
+            },
+          },
           viewer: {
             type: 'ref',
             ref: 'lex:app.bsky.feed.defs#generatorViewerState',
@@ -6163,6 +6181,13 @@ export const schemaDict = {
           avatar: {
             type: 'string',
           },
+          labels: {
+            type: 'array',
+            items: {
+              type: 'ref',
+              ref: 'lex:com.atproto.label.defs#label',
+            },
+          },
           viewer: {
             type: 'ref',
             ref: 'lex:app.bsky.graph.defs#listViewerState',
@@ -6213,6 +6238,13 @@ export const schemaDict = {
           avatar: {
             type: 'string',
           },
+          labels: {
+            type: 'array',
+            items: {
+              type: 'ref',
+              ref: 'lex:com.atproto.label.defs#label',
+            },
+          },
           viewer: {
             type: 'ref',
             ref: 'lex:app.bsky.graph.defs#listViewerState',

package/src/client/types/app/bsky/actor/defs.ts

@@ -338,36 +338,36 @@ export function validateHiddenPostsPref(v: unknown): ValidationResult {
   return lexicons.validate('app.bsky.actor.defs#hiddenPostsPref', v)
 }
 
-export interface ModsPref {
-  mods: ModPrefItem[]
+export interface LabelersPref {
+  labelers: LabelerPrefItem[]
   [k: string]: unknown
 }
 
-export function isModsPref(v: unknown): v is ModsPref {
+export function isLabelersPref(v: unknown): v is LabelersPref {
   return (
     isObj(v) &&
     hasProp(v, '$type') &&
-    v.$type === 'app.bsky.actor.defs#modsPref'
+    v.$type === 'app.bsky.actor.defs#labelersPref'
   )
 }
 
-export function validateModsPref(v: unknown): ValidationResult {
-  return lexicons.validate('app.bsky.actor.defs#modsPref', v)
+export function validateLabelersPref(v: unknown): ValidationResult {
+  return lexicons.validate('app.bsky.actor.defs#labelersPref', v)
 }
 
-export interface ModPrefItem {
+export interface LabelerPrefItem {
   did: string
   [k: string]: unknown
 }
 
-export function isModPrefItem(v: unknown): v is ModPrefItem {
+export function isLabelerPrefItem(v: unknown): v is LabelerPrefItem {
   return (
     isObj(v) &&
     hasProp(v, '$type') &&
-    v.$type === 'app.bsky.actor.defs#modPrefItem'
+    v.$type === 'app.bsky.actor.defs#labelerPrefItem'
   )
 }
 
-export function validateModPrefItem(v: unknown): ValidationResult {
-  return lexicons.validate('app.bsky.actor.defs#modPrefItem', v)
+export function validateLabelerPrefItem(v: unknown): ValidationResult {
+  return lexicons.validate('app.bsky.actor.defs#labelerPrefItem', v)
 }

package/src/client/types/app/bsky/feed/defs.ts

@@ -219,6 +219,7 @@ export interface GeneratorView {
   descriptionFacets?: AppBskyRichtextFacet.Main[]
   avatar?: string
   likeCount?: number
+  labels?: ComAtprotoLabelDefs.Label[]
   viewer?: GeneratorViewerState
   indexedAt: string
   [k: string]: unknown