@atproto/dev-env 0.0.0-spaces-alpha-20260818163953

package/src/moderator-client.ts

@@ -0,0 +1,267 @@
+import {
+  type $Typed,
+  type AtpAgent,
+  type ChatBskyConvoDefs,
+  type ComAtprotoAdminDefs,
+  type ComAtprotoRepoStrongRef,
+  type ToolsOzoneModerationDefs,
+  type ToolsOzoneModerationEmitEvent as EmitModerationEvent,
+  ToolsOzoneModerationGetReporterStats as _GetReporterStats, // includes types for getReporterStats()
+  type ToolsOzoneModerationQueryEvents as QueryModerationEvents,
+  type ToolsOzoneModerationQueryStatuses as QueryModerationStatuses,
+  type ToolsOzoneReportQueryReports as QueryModerationReports,
+  type ToolsOzoneSettingRemoveOptions,
+  type ToolsOzoneSettingUpsertOption,
+} from '@atproto/api'
+import type { TestOzone } from './ozone.js'
+
+type TakeActionInput = EmitModerationEvent.InputSchema
+type QueryStatusesParams = QueryModerationStatuses.QueryParams
+type QueryEventsParams = QueryModerationEvents.QueryParams
+type QueryReportsParams = QueryModerationReports.QueryParams
+type ModLevel = 'admin' | 'moderator' | 'triage'
+
+export class ModeratorClient {
+  agent: AtpAgent
+  constructor(public ozone: TestOzone) {
+    this.agent = ozone.getAgent()
+  }
+
+  async getEvent(id: number, role?: ModLevel) {
+    const result = await this.agent.tools.ozone.moderation.getEvent(
+      { id },
+      {
+        headers: await this.ozone.modHeaders(
+          'tools.ozone.moderation.getEvent',
+          role,
+        ),
+      },
+    )
+    return result.data
+  }
+
+  async queryStatuses(input: QueryStatusesParams, role?: ModLevel) {
+    const result = await this.agent.tools.ozone.moderation.queryStatuses(
+      input,
+      {
+        headers: await this.ozone.modHeaders(
+          'tools.ozone.moderation.queryStatuses',
+          role,
+        ),
+      },
+    )
+    return result.data
+  }
+
+  async getReporterStats(dids: string[]) {
+    const result = await this.agent.tools.ozone.moderation.getReporterStats(
+      { dids },
+      {
+        headers: await this.ozone.modHeaders(
+          'tools.ozone.moderation.getReporterStats',
+          'admin',
+        ),
+      },
+    )
+    return result.data
+  }
+
+  async queryEvents(input: QueryEventsParams, role?: ModLevel) {
+    const result = await this.agent.tools.ozone.moderation.queryEvents(input, {
+      headers: await this.ozone.modHeaders(
+        'tools.ozone.moderation.queryEvents',
+        role,
+      ),
+    })
+    return result.data
+  }
+
+  async queryReports(input: QueryReportsParams, role?: ModLevel) {
+    const result = await this.agent.tools.ozone.report.queryReports(input, {
+      headers: await this.ozone.modHeaders(
+        'tools.ozone.report.queryReports',
+        role,
+      ),
+    })
+    return result.data
+  }
+
+  async emitEvent(
+    opts: {
+      event: TakeActionInput['event']
+      subject:
+        | $Typed<ComAtprotoAdminDefs.RepoRef>
+        | $Typed<ComAtprotoRepoStrongRef.Main>
+        | $Typed<ChatBskyConvoDefs.MessageRef>
+        | $Typed<ChatBskyConvoDefs.ConvoRef>
+        | { $type: string }
+      subjectBlobCids?: TakeActionInput['subjectBlobCids']
+      reason?: string
+      createdBy?: string
+      meta?: unknown
+      modTool?: ToolsOzoneModerationDefs.ModTool
+      externalId?: string
+      reportAction?: TakeActionInput['reportAction']
+    },
+    role?: ModLevel,
+  ) {
+    const {
+      event,
+      subject,
+      subjectBlobCids,
+      createdBy = 'did:example:admin',
+      modTool,
+      externalId,
+      reportAction,
+    } = opts
+    const result = await this.agent.tools.ozone.moderation.emitEvent(
+      {
+        event,
+        subject,
+        subjectBlobCids,
+        createdBy,
+        modTool,
+        externalId,
+        reportAction,
+      },
+      {
+        encoding: 'application/json',
+        headers: await this.ozone.modHeaders(
+          'tools.ozone.moderation.emitEvent',
+          role,
+        ),
+      },
+    )
+    return result.data
+  }
+
+  async reverseAction(
+    opts: {
+      id: number
+      subject: TakeActionInput['subject']
+      reason?: string
+      createdBy?: string
+      modTool?: ToolsOzoneModerationDefs.ModTool
+    },
+    role?: ModLevel,
+  ) {
+    const {
+      subject,
+      reason = 'X',
+      createdBy = 'did:example:admin',
+      modTool,
+    } = opts
+    const result = await this.agent.tools.ozone.moderation.emitEvent(
+      {
+        subject,
+        event: {
+          $type: 'tools.ozone.moderation.defs#modEventReverseTakedown',
+          comment: reason,
+        },
+        createdBy,
+        modTool,
+      },
+      {
+        encoding: 'application/json',
+        headers: await this.ozone.modHeaders(
+          'tools.ozone.moderation.emitEvent',
+          role,
+        ),
+      },
+    )
+    return result.data
+  }
+
+  async performTakedown(
+    opts: {
+      subject:
+        | $Typed<ComAtprotoAdminDefs.RepoRef>
+        | $Typed<ComAtprotoRepoStrongRef.Main>
+        | $Typed<ChatBskyConvoDefs.MessageRef>
+        | $Typed<ChatBskyConvoDefs.ConvoRef>
+        | { $type: string }
+      subjectBlobCids?: TakeActionInput['subjectBlobCids']
+      durationInHours?: number
+      acknowledgeAccountSubjects?: boolean
+      reason?: string
+      policies?: string[]
+    },
+    role?: ModLevel,
+  ) {
+    const { durationInHours, acknowledgeAccountSubjects, policies, ...rest } =
+      opts
+    return this.emitEvent(
+      {
+        event: {
+          $type: 'tools.ozone.moderation.defs#modEventTakedown',
+          acknowledgeAccountSubjects,
+          durationInHours,
+          policies,
+        },
+        ...rest,
+      },
+      role,
+    )
+  }
+
+  async performReverseTakedown(
+    opts: {
+      subject: TakeActionInput['subject']
+      subjectBlobCids?: TakeActionInput['subjectBlobCids']
+      reason?: string
+    },
+    role?: ModLevel,
+  ) {
+    return this.emitEvent(
+      {
+        event: {
+          $type: 'tools.ozone.moderation.defs#modEventReverseTakedown',
+        },
+        ...opts,
+      },
+      role,
+    )
+  }
+
+  async upsertSettingOption(
+    setting: ToolsOzoneSettingUpsertOption.InputSchema,
+    callerRole: 'admin' | 'moderator' | 'triage' = 'admin',
+  ) {
+    const { data } = await this.agent.tools.ozone.setting.upsertOption(
+      setting,
+      {
+        encoding: 'application/json',
+        headers: await this.ozone.modHeaders(
+          'tools.ozone.setting.upsertOption',
+          callerRole,
+        ),
+      },
+    )
+
+    return data
+  }
+
+  async removeSettingOptions(
+    params: ToolsOzoneSettingRemoveOptions.InputSchema,
+    callerRole: 'admin' | 'moderator' | 'triage' = 'admin',
+  ) {
+    const { data } = await this.agent.tools.ozone.setting.removeOptions(
+      params,
+      {
+        encoding: 'application/json',
+        headers: await this.ozone.modHeaders(
+          'tools.ozone.setting.removeOptions',
+          callerRole,
+        ),
+      },
+    )
+
+    return data
+  }
+
+  async computeStats() {
+    const db = this.ozone.ctx.db
+    const statsService = this.ozone.ctx.reportStatsService(db)
+    await statsService.materializeAll({ force: true })
+  }
+}

package/src/network-no-appview.ts

@@ -0,0 +1,89 @@
+import getPort from 'get-port'
+import type { SkeletonHandler } from '@atproto/pds'
+import { TestFeedGen } from './feed-gen.js'
+import { TestPds } from './pds.js'
+import { TestPlc } from './plc.js'
+import { SeedClient } from './seed/client.js'
+import { LexiconAuthorityProfile } from './service-profile-lexicon.js'
+import type { TestServerParams } from './types.js'
+import { mockNetworkUtilities } from './util.js'
+
+export class TestNetworkNoAppView {
+  feedGens: TestFeedGen[] = []
+  constructor(
+    public plc: TestPlc,
+    public pds: TestPds,
+    public extraPdses: TestPds[] = [],
+    public lexiconAuthority?: LexiconAuthorityProfile,
+  ) {}
+
+  static async create(
+    params: Partial<TestServerParams> = {},
+  ): Promise<TestNetworkNoAppView> {
+    const plc = await TestPlc.create(params.plc ?? {})
+    const pds = await TestPds.create({
+      didPlcUrl: plc.url,
+      ...params.pds,
+    })
+
+    const extraPdsCount = params.extraPdses ?? 0
+    const extraPdses: TestPds[] = []
+    for (let i = 0; i < extraPdsCount; i++) {
+      // Extra PDSes get their own non-overlapping handle domain (.test2, .test3, ...)
+      // to avoid colliding with the primary PDS's .test.
+      const domain = `.test${i + 2}`
+      const extra = await TestPds.create({
+        didPlcUrl: plc.url,
+        ...params.pds,
+        // Override after spreading so each extra PDS gets a unique port and
+        // its own handle domain (rather than inheriting the primary's).
+        port: await getPort(),
+        serviceHandleDomains: [domain],
+      })
+      extraPdses.push(extra)
+    }
+
+    mockNetworkUtilities([pds, ...extraPdses])
+
+    let lexiconAuthority: LexiconAuthorityProfile | undefined
+    if (params.lexiconAuthority) {
+      // The authority account has to live on a PDS, but a PDS wants the authority
+      // DID in its config — so it's created after boot and the DID assigned here.
+      // The resolver hook reads `cfg.lexicon.didAuthority` per call rather than at
+      // construction (see pds `context.ts`), so assigning it now takes effect.
+      lexiconAuthority = await LexiconAuthorityProfile.create(pds)
+      for (const each of [pds, ...extraPdses]) {
+        each.ctx.cfg.lexicon.didAuthority = lexiconAuthority.did
+      }
+      await lexiconAuthority.createRecords()
+    }
+
+    return new TestNetworkNoAppView(plc, pds, extraPdses, lexiconAuthority)
+  }
+
+  async createFeedGen(
+    feeds: Record<string, SkeletonHandler>,
+  ): Promise<TestFeedGen> {
+    const fg = await TestFeedGen.create(this.plc.url, feeds)
+    this.feedGens.push(fg)
+    return fg
+  }
+
+  getSeedClient(): SeedClient<typeof this> {
+    const agent = this.pds.getAgent()
+    const client = this.pds.getClient()
+    return new SeedClient(this, agent, client)
+  }
+
+  async processAll() {
+    await this.pds.processAll()
+    await Promise.all(this.extraPdses.map((p) => p.processAll()))
+  }
+
+  async close() {
+    await Promise.all(this.feedGens.map((fg) => fg.close()))
+    await this.pds.close()
+    await Promise.all(this.extraPdses.map((p) => p.close()))
+    await this.plc.close()
+  }
+}

package/src/network.ts

@@ -0,0 +1,243 @@
+import assert from 'node:assert'
+import getPort from 'get-port'
+import * as uint8arrays from 'uint8arrays'
+import { allFulfilled, wait } from '@atproto/common-web'
+import { createServiceJwt } from '@atproto/xrpc-server'
+import { TestBsky } from './bsky.js'
+import { TestBsync } from './bsync.js'
+import { EXAMPLE_LABELER } from './const.js'
+import { IntrospectServer } from './introspect.js'
+import { TestNetworkNoAppView } from './network-no-appview.js'
+import { TestOzone } from './ozone.js'
+import { TestPds } from './pds.js'
+import { TestPlc } from './plc.js'
+import { LexiconAuthorityProfile } from './service-profile-lexicon.js'
+import { OzoneServiceProfile } from './service-profile-ozone.js'
+import type { TestServerParams } from './types.js'
+import { mockNetworkUtilities } from './util.js'
+
+const ADMIN_USERNAME = 'admin'
+const ADMIN_PASSWORD = 'admin-pass'
+
+export class TestNetwork extends TestNetworkNoAppView {
+  constructor(
+    public plc: TestPlc,
+    public pds: TestPds,
+    public bsync: TestBsync,
+    public bsky: TestBsky,
+    public ozone: TestOzone,
+    public introspect?: IntrospectServer,
+  ) {
+    super(plc, pds)
+  }
+
+  static async create(
+    params: Partial<TestServerParams> = {},
+  ): Promise<TestNetwork> {
+    const redisHost = process.env.REDIS_HOST
+    const dbPostgresUrl = params.dbPostgresUrl || process.env.DB_POSTGRES_URL
+    assert(dbPostgresUrl, 'Missing postgres url for tests')
+    assert(redisHost, 'Missing redis host for tests')
+    const dbPostgresSchema =
+      params.dbPostgresSchema || process.env.DB_POSTGRES_SCHEMA
+
+    const plc = await TestPlc.create(params.plc ?? {})
+
+    const bskyPort = params.bsky?.port ?? (await getPort())
+    const pdsPort = params.pds?.port ?? (await getPort())
+    const ozonePort = params.ozone?.port ?? (await getPort())
+
+    const thirdPartyPds = await TestPds.create({
+      didPlcUrl: plc.url,
+      ...params.pds,
+      inviteRequired: false,
+      port: await getPort(),
+    })
+
+    const ozoneUrl = `http://localhost:${ozonePort}`
+
+    // @TODO (?) rework the ServiceProfile to live on a separate PDS instead of
+    // requiring to migrate to the main PDS
+    const ozoneServiceProfile = await OzoneServiceProfile.create(
+      thirdPartyPds,
+      ozoneUrl,
+    )
+    const lexiconAuthorityProfile =
+      await LexiconAuthorityProfile.create(thirdPartyPds)
+
+    const bsyncApiKey = 'bsync-api-key'
+    const bsync = await TestBsync.create({
+      apiKeys: [bsyncApiKey],
+      dbUrl: dbPostgresUrl,
+    })
+
+    const bsky = await TestBsky.create({
+      port: bskyPort,
+      plcUrl: plc.url,
+      pdsPort,
+      bsyncApiKey,
+      bsyncUrl: bsync.url,
+      rolodexUrl: process.env.BSKY_ROLODEX_URL,
+      rolodexIgnoreBadTls: true,
+      repoProvider: `ws://localhost:${pdsPort}`,
+      dbPostgresSchema: `appview_${dbPostgresSchema}`,
+      dbPostgresUrl,
+      redisHost,
+      modServiceDid: ozoneServiceProfile.did,
+      labelsFromIssuerDids: [ozoneServiceProfile.did, EXAMPLE_LABELER],
+      // Using a static private key results in a static DID, which is useful for e2e tests with the social-app repo.
+      privateKey:
+        '3f916c70dc69e4c5e83877f013325b11ecac31742e6a42f5c4fb240d0703d9d5=',
+      ...params.bsky,
+    })
+
+    const pds = await TestPds.create({
+      port: pdsPort,
+      didPlcUrl: plc.url,
+      bskyAppViewUrl: bsky.url,
+      bskyAppViewDid: bsky.ctx.cfg.serverDid,
+      modServiceUrl: ozoneUrl,
+      modServiceDid: ozoneServiceProfile.did,
+      lexiconDidAuthority: lexiconAuthorityProfile.did,
+      ...params.pds,
+    })
+
+    // mock before any events start flowing from pds so that we don't miss e.g. any handle resolutions.
+    mockNetworkUtilities(pds, bsky)
+
+    const ozone = await TestOzone.create({
+      port: ozonePort,
+      plcUrl: plc.url,
+      signingKey: ozoneServiceProfile.key,
+      serverDid: ozoneServiceProfile.did,
+      dbPostgresSchema: `ozone_${dbPostgresSchema || 'db'}`,
+      dbPostgresUrl,
+      appviewUrl: bsky.url,
+      appviewDid: bsky.ctx.cfg.serverDid,
+      appviewPushEvents: true,
+      pdsUrl: pds.url,
+      pdsDid: pds.ctx.cfg.service.did,
+      verifierDid: ozoneServiceProfile.did,
+      verifierUrl: pds.url,
+      verifierPassword: 'temp',
+      ...params.ozone,
+    })
+
+    await ozoneServiceProfile.migrateTo(pds)
+    await ozoneServiceProfile.createRecords()
+
+    await lexiconAuthorityProfile.migrateTo(pds)
+    await lexiconAuthorityProfile.createRecords()
+
+    await ozone.addAdminDid(ozoneServiceProfile.did)
+    await ozone.createPolicies()
+
+    await thirdPartyPds.processAll()
+    await pds.processAll()
+    await ozone.processAll()
+    await bsky.sub.processAll()
+    await bsky.bsyncSub.processAll(await bsync.getStreamHeads())
+    await thirdPartyPds.close()
+
+    // Weird but if we do this before pds.processAll() somehow appview loses this user and tests in different parts fail because appview doesn't return this user in various contexts anymore
+    const ozoneVerifierPassword =
+      await ozoneServiceProfile.createAppPasswordForVerification()
+    if (ozone.daemon.ctx.cfg.verifier) {
+      ozone.daemon.ctx.cfg.verifier.password = ozoneVerifierPassword
+    }
+
+    let introspect: IntrospectServer | undefined = undefined
+    if (params.introspect?.port) {
+      introspect = await IntrospectServer.start(
+        params.introspect.port,
+        plc,
+        pds,
+        bsync,
+        bsky,
+        ozone,
+      )
+    }
+
+    return new TestNetwork(plc, pds, bsync, bsky, ozone, introspect)
+  }
+
+  async processFullSubscription(timeout = 5000) {
+    const sub = this.bsky.sub
+    // If the subscription is not running, there is no point in
+    // waiting for it to process events
+    if (!sub.running) return
+    const start = Date.now()
+    const lastSeq = await this.pds.ctx.sequencer.curr()
+    if (!lastSeq) return
+    while (Date.now() - start < timeout) {
+      await sub.processAll()
+      const runnerCursor = await sub.getCursor()
+      // if subscription claims to be done, ensure we are at the most recent cursor from PDS, else wait to process again
+      // (the subscription may claim to be finished before the PDS has even emitted it's event)
+      if (runnerCursor && runnerCursor >= lastSeq) {
+        return
+      }
+      await wait(5)
+    }
+    throw new Error(`Sequence was not processed within ${timeout}ms`)
+  }
+
+  async processAll(timeout?: number) {
+    await this.pds.processAll()
+    await this.ozone.processAll()
+    await this.bsky.sub.processAll()
+    await this.bsky.bsyncSub.processAll(
+      await this.bsync.getStreamHeads(),
+      timeout,
+    )
+    await this.processFullSubscription(timeout)
+  }
+
+  async serviceHeaders(did: string, lxm: string, aud?: string) {
+    const keypair = await this.pds.ctx.actorStore.keypair(did)
+    const jwt = await createServiceJwt({
+      iss: did,
+      aud: aud ?? this.bsky.ctx.cfg.serverDid,
+      lxm,
+      keypair,
+    })
+    return { authorization: `Bearer ${jwt}` }
+  }
+
+  async adminHeaders({
+    username = ADMIN_USERNAME,
+    password = ADMIN_PASSWORD,
+  }: {
+    username?: string
+    password?: string
+  }) {
+    return {
+      authorization:
+        'Basic ' +
+        uint8arrays.toString(
+          uint8arrays.fromString(`${username}:${password}`, 'utf8'),
+          'base64pad',
+        ),
+    }
+  }
+
+  async close() {
+    try {
+      await this.processAll()
+    } finally {
+      await allFulfilled([
+        ...this.feedGens.map(async (fg) => fg.close()),
+        this.ozone.close(),
+        this.bsky.close(),
+        this.bsync.close(),
+        this.pds.close(),
+        this.plc.close(),
+        this.introspect?.close(),
+      ])
+    }
+  }
+
+  async [Symbol.asyncDispose]() {
+    await this.close()
+  }
+}