@atproto/dev-env 0.3.9 → 0.3.11

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@atproto/dev-env",
-  "version": "0.3.9",
+  "version": "0.3.11",
   "license": "MIT",
   "description": "Local development environment helper for atproto development",
   "keywords": [
@@ -24,18 +24,21 @@
     "get-port": "^5.1.1",
     "multiformats": "^9.9.0",
     "uint8arrays": "3.0.0",
-    "@atproto/api": "^0.12.7",
-    "@atproto/bsky": "^0.0.49",
+    "@atproto/api": "^0.12.9",
+    "@atproto/bsky": "^0.0.51",
     "@atproto/bsync": "^0.0.3",
     "@atproto/common-web": "^0.3.0",
     "@atproto/crypto": "^0.4.0",
     "@atproto/identity": "^0.4.0",
     "@atproto/lexicon": "^0.4.0",
-    "@atproto/ozone": "^0.1.11",
-    "@atproto/pds": "^0.4.18",
+    "@atproto/ozone": "^0.1.13",
+    "@atproto/pds": "^0.4.20",
     "@atproto/syntax": "^0.3.0",
     "@atproto/xrpc-server": "^0.5.1"
   },
+  "devDependencies": {
+    "@types/express": "^4.17.13"
+  },
   "scripts": {
     "build": "tsc --build tsconfig.build.json",
     "start": "../dev-infra/with-test-redis-and-db.sh node dist/bin.js"

package/src/bin.ts

@@ -26,10 +26,16 @@ const run = async () => {
       publicUrl: 'http://localhost:2584',
     },
     plc: { port: 2582 },
+    introspect: { port: 2581 },
   })
   mockMailer(network.pds)
   await generateMockSetup(network)
 
+  if (network.introspect) {
+    console.log(
+      `🔍 Dev-env introspection server started http://localhost:${network.introspect.port}`,
+    )
+  }
   console.log(
     `👤 DID Placeholder server started http://localhost:${network.plc.port}`,
   )
@@ -37,6 +43,7 @@ const run = async () => {
     `🌞 Personal Data server started http://localhost:${network.pds.port}`,
   )
   console.log(`🗼 Ozone server started http://localhost:${network.ozone.port}`)
+  console.log(`🗼 Ozone service DID ${network.ozone.ctx.cfg.service.did}`)
   console.log(`🌅 Bsky Appview started http://localhost:${network.bsky.port}`)
   for (const fg of network.feedGens) {
     console.log(`🤖 Feed Generator started http://localhost:${fg.port}`)

package/src/bsky.ts

@@ -58,6 +58,7 @@ export class TestBsky {
       didPlcUrl: cfg.plcUrl,
       publicUrl: 'https://bsky.public.url',
       serverDid,
+      alternateAudienceDids: [],
       dataplaneUrls: [`http://localhost:${dataplanePort}`],
       dataplaneHttpVersion: '1.1',
       bsyncUrl: `http://localhost:${bsyncPort}`,

package/src/introspect.ts

@@ -0,0 +1,54 @@
+import http from 'node:http'
+import events from 'node:events'
+import express from 'express'
+import { TestPlc } from './plc'
+import { TestPds } from './pds'
+import { TestBsky } from './bsky'
+import { TestOzone } from './ozone'
+
+export class IntrospectServer {
+  constructor(
+    public port: number,
+    public server: http.Server,
+  ) {}
+
+  static async start(
+    port: number,
+    plc: TestPlc,
+    pds: TestPds,
+    bsky: TestBsky,
+    ozone: TestOzone,
+  ) {
+    const app = express()
+    app.get('/', (_req, res) => {
+      res.status(200).send({
+        plc: {
+          url: plc.url,
+        },
+        pds: {
+          url: pds.url,
+          did: pds.ctx.cfg.service.did,
+        },
+        bsky: {
+          url: bsky.url,
+          did: bsky.ctx.cfg.serverDid,
+        },
+        ozone: {
+          url: ozone.url,
+          did: ozone.ctx.cfg.service.did,
+        },
+        db: {
+          url: ozone.ctx.cfg.db.postgresUrl,
+        },
+      })
+    })
+    const server = app.listen(port)
+    await events.once(server, 'listening')
+    return new IntrospectServer(port, server)
+  }
+
+  async close() {
+    this.server.close()
+    await events.once(this.server, 'close')
+  }
+}

package/src/mock/index.ts

@@ -350,328 +350,6 @@ export async function generateMockSetup(env: TestNetwork) {
     },
   )
 
-  // create the dev-env moderator
-  {
-    const res = await clients.loggedout.api.com.atproto.server.createAccount({
-      email: 'mod-authority@test.com',
-      handle: 'mod-authority.test',
-      password: 'hunter2',
-    })
-    const agent = env.pds.getClient()
-    agent.api.setHeader('Authorization', `Bearer ${res.data.accessJwt}`)
-    await agent.api.app.bsky.actor.profile.create(
-      { repo: res.data.did },
-      {
-        displayName: 'Dev-env Moderation',
-        description: `The pretend version of mod.bsky.app`,
-      },
-    )
-
-    await agent.api.app.bsky.labeler.service.create(
-      { repo: res.data.did, rkey: 'self' },
-      {
-        policies: {
-          labelValues: [
-            '!hide',
-            '!warn',
-            'porn',
-            'sexual',
-            'nudity',
-            'sexual-figurative',
-            'graphic-media',
-            'self-harm',
-            'sensitive',
-            'extremist',
-            'intolerant',
-            'threat',
-            'rude',
-            'illicit',
-            'security',
-            'unsafe-link',
-            'impersonation',
-            'misinformation',
-            'scam',
-            'engagement-farming',
-            'spam',
-            'rumor',
-            'misleading',
-            'inauthentic',
-          ],
-          labelValueDefinitions: [
-            {
-              identifier: 'spam',
-              blurs: 'content',
-              severity: 'inform',
-              defaultSetting: 'hide',
-              adultOnly: false,
-              locales: [
-                {
-                  lang: 'en',
-                  name: 'Spam',
-                  description:
-                    'Unwanted, repeated, or unrelated actions that bother users.',
-                },
-              ],
-            },
-            {
-              identifier: 'impersonation',
-              blurs: 'none',
-              severity: 'inform',
-              defaultSetting: 'hide',
-              adultOnly: false,
-              locales: [
-                {
-                  lang: 'en',
-                  name: 'Impersonation',
-                  description:
-                    'Pretending to be someone else without permission.',
-                },
-              ],
-            },
-            {
-              identifier: 'scam',
-              blurs: 'content',
-              severity: 'alert',
-              defaultSetting: 'hide',
-              adultOnly: false,
-              locales: [
-                {
-                  lang: 'en',
-                  name: 'Scam',
-                  description: 'Scams, phishing & fraud.',
-                },
-              ],
-            },
-            {
-              identifier: 'intolerant',
-              blurs: 'content',
-              severity: 'alert',
-              defaultSetting: 'warn',
-              adultOnly: false,
-              locales: [
-                {
-                  lang: 'en',
-                  name: 'Intolerance',
-                  description: 'Discrimination against protected groups.',
-                },
-              ],
-            },
-            {
-              identifier: 'self-harm',
-              blurs: 'content',
-              severity: 'alert',
-              defaultSetting: 'warn',
-              adultOnly: false,
-              locales: [
-                {
-                  lang: 'en',
-                  name: 'Self-Harm',
-                  description:
-                    'Promotes self-harm, including graphic images, glorifying discussions, or triggering stories.',
-                },
-              ],
-            },
-            {
-              identifier: 'security',
-              blurs: 'content',
-              severity: 'alert',
-              defaultSetting: 'hide',
-              adultOnly: false,
-              locales: [
-                {
-                  lang: 'en',
-                  name: 'Security Concerns',
-                  description:
-                    'May be unsafe and could harm your device, steal your info, or get your account hacked.',
-                },
-              ],
-            },
-            {
-              identifier: 'misleading',
-              blurs: 'content',
-              severity: 'alert',
-              defaultSetting: 'warn',
-              adultOnly: false,
-              locales: [
-                {
-                  lang: 'en',
-                  name: 'Misleading',
-                  description:
-                    'Altered images/videos, deceptive links, or false statements.',
-                },
-              ],
-            },
-            {
-              identifier: 'threat',
-              blurs: 'content',
-              severity: 'inform',
-              defaultSetting: 'hide',
-              adultOnly: false,
-              locales: [
-                {
-                  lang: 'en',
-                  name: 'Threats',
-                  description:
-                    'Promotes violence or harm towards others, including threats, incitement, or advocacy of harm.',
-                },
-              ],
-            },
-            {
-              identifier: 'unsafe-link',
-              blurs: 'content',
-              severity: 'alert',
-              defaultSetting: 'hide',
-              adultOnly: false,
-              locales: [
-                {
-                  lang: 'en',
-                  name: 'Unsafe link',
-                  description:
-                    'Links to harmful sites with malware, phishing, or violating content that risk security and privacy.',
-                },
-              ],
-            },
-            {
-              identifier: 'illicit',
-              blurs: 'content',
-              severity: 'alert',
-              defaultSetting: 'hide',
-              adultOnly: false,
-              locales: [
-                {
-                  lang: 'en',
-                  name: 'Illicit',
-                  description:
-                    'Promoting or selling potentially illicit goods, services, or activities.',
-                },
-              ],
-            },
-            {
-              identifier: 'misinformation',
-              blurs: 'content',
-              severity: 'inform',
-              defaultSetting: 'warn',
-              adultOnly: false,
-              locales: [
-                {
-                  lang: 'en',
-                  name: 'Misinformation',
-                  description:
-                    'Spreading false or misleading info, including unverified claims and harmful conspiracy theories.',
-                },
-              ],
-            },
-            {
-              identifier: 'rumor',
-              blurs: 'content',
-              severity: 'inform',
-              defaultSetting: 'warn',
-              adultOnly: false,
-              locales: [
-                {
-                  lang: 'en',
-                  name: 'Rumor',
-                  description:
-                    'Approach with caution, as these claims lack evidence from credible sources.',
-                },
-              ],
-            },
-            {
-              identifier: 'rude',
-              blurs: 'content',
-              severity: 'inform',
-              defaultSetting: 'hide',
-              adultOnly: false,
-              locales: [
-                {
-                  lang: 'en',
-                  name: 'Rude',
-                  description:
-                    'Rude or impolite, including crude language and disrespectful comments, without constructive purpose.',
-                },
-              ],
-            },
-            {
-              identifier: 'extremist',
-              blurs: 'content',
-              severity: 'alert',
-              defaultSetting: 'hide',
-              adultOnly: false,
-              locales: [
-                {
-                  lang: 'en',
-                  name: 'Extremist',
-                  description:
-                    'Radical views advocating violence, hate, or discrimination against individuals or groups.',
-                },
-              ],
-            },
-            {
-              identifier: 'sensitive',
-              blurs: 'content',
-              severity: 'alert',
-              defaultSetting: 'warn',
-              adultOnly: false,
-              locales: [
-                {
-                  lang: 'en',
-                  name: 'Sensitive',
-                  description:
-                    'May be upsetting, covering topics like substance abuse or mental health issues, cautioning sensitive viewers.',
-                },
-              ],
-            },
-            {
-              identifier: 'engagement-farming',
-              blurs: 'content',
-              severity: 'alert',
-              defaultSetting: 'hide',
-              adultOnly: false,
-              locales: [
-                {
-                  lang: 'en',
-                  name: 'Engagement Farming',
-                  description:
-                    'Insincere content or bulk actions aimed at gaining followers, including frequent follows, posts, and likes.',
-                },
-              ],
-            },
-            {
-              identifier: 'inauthentic',
-              blurs: 'content',
-              severity: 'alert',
-              defaultSetting: 'hide',
-              adultOnly: false,
-              locales: [
-                {
-                  lang: 'en',
-                  name: 'Inauthentic Account',
-                  description: 'Bot or a person pretending to be someone else.',
-                },
-              ],
-            },
-            {
-              identifier: 'sexual-figurative',
-              blurs: 'media',
-              severity: 'none',
-              defaultSetting: 'show',
-              adultOnly: true,
-              locales: [
-                {
-                  lang: 'en',
-                  name: 'Sexually Suggestive (Cartoon)',
-                  description:
-                    'Art with explicit or suggestive sexual themes, including provocative imagery or partial nudity.',
-                },
-              ],
-            },
-          ],
-        },
-        createdAt: date.next().value,
-      },
-    )
-  }
-
   // create a labeler account
   {
     const res = await clients.loggedout.api.com.atproto.server.createAccount({

package/src/network.ts

@@ -7,11 +7,12 @@ import { TestServerParams } from './types'
 import { TestPlc } from './plc'
 import { TestPds } from './pds'
 import { TestBsky } from './bsky'
-import { TestOzone, createOzoneDid } from './ozone'
+import { TestOzone } from './ozone'
+import { OzoneServiceProfile } from './ozone-service-profile'
 import { mockNetworkUtilities } from './util'
 import { TestNetworkNoAppView } from './network-no-appview'
-import { Secp256k1Keypair } from '@atproto/crypto'
 import { EXAMPLE_LABELER } from './const'
+import { IntrospectServer } from './introspect'
 
 const ADMIN_USERNAME = 'admin'
 const ADMIN_PASSWORD = 'admin-pass'
@@ -22,6 +23,7 @@ export class TestNetwork extends TestNetworkNoAppView {
     public pds: TestPds,
     public bsky: TestBsky,
     public ozone: TestOzone,
+    public introspect?: IntrospectServer,
   ) {
     super(plc, pds)
   }
@@ -42,8 +44,16 @@ export class TestNetwork extends TestNetworkNoAppView {
     const pdsPort = params.pds?.port ?? (await getPort())
     const ozonePort = params.ozone?.port ?? (await getPort())
 
-    const ozoneKey = await Secp256k1Keypair.create({ exportable: true })
-    const ozoneDid = await createOzoneDid(plc.url, ozoneKey)
+    const thirdPartyPdsProps = {
+      didPlcUrl: plc.url,
+      ...params.pds,
+      inviteRequired: false,
+      port: await getPort(),
+    }
+    const thirdPartyPds = await TestPds.create(thirdPartyPdsProps)
+    const ozoneServiceProfile = new OzoneServiceProfile(thirdPartyPds)
+    const { did: ozoneDid, key: ozoneKey } =
+      await ozoneServiceProfile.createDidAndKey()
 
     const bsky = await TestBsky.create({
       port: bskyPort,
@@ -58,22 +68,25 @@ export class TestNetwork extends TestNetworkNoAppView {
       ...params.bsky,
     })
 
-    const pds = await TestPds.create({
+    const modServiceUrl = `http://localhost:${ozonePort}`
+    const pdsProps = {
       port: pdsPort,
       didPlcUrl: plc.url,
       bskyAppViewUrl: bsky.url,
       bskyAppViewDid: bsky.ctx.cfg.serverDid,
-      modServiceUrl: `http://localhost:${ozonePort}`,
+      modServiceUrl,
       modServiceDid: ozoneDid,
       ...params.pds,
-    })
+    }
+
+    const pds = await TestPds.create(pdsProps)
 
     const ozone = await TestOzone.create({
       port: ozonePort,
       plcUrl: plc.url,
       signingKey: ozoneKey,
       serverDid: ozoneDid,
-      dbPostgresSchema: `ozone_${dbPostgresSchema}`,
+      dbPostgresSchema: `ozone_${dbPostgresSchema || 'db'}`,
       dbPostgresUrl,
       appviewUrl: bsky.url,
       appviewDid: bsky.ctx.cfg.serverDid,
@@ -83,9 +96,42 @@ export class TestNetwork extends TestNetworkNoAppView {
       ...params.ozone,
     })
 
+    let inviteCode: string | undefined
+    if (pdsProps.inviteRequired) {
+      const { data: invite } = await pds
+        .getClient()
+        .api.com.atproto.server.createInviteCode(
+          { useCount: 1 },
+          {
+            encoding: 'application/json',
+            headers: pds.adminAuthHeaders(),
+          },
+        )
+      inviteCode = invite.code
+    }
+    await ozoneServiceProfile.createServiceDetails(pds, modServiceUrl, {
+      inviteCode,
+    })
+
+    ozone.addAdminDid(ozoneDid)
+
     mockNetworkUtilities(pds, bsky)
+    await pds.processAll()
+    await bsky.sub.background.processAll()
+    await thirdPartyPds.close()
+
+    let introspect: IntrospectServer | undefined = undefined
+    if (params.introspect?.port) {
+      introspect = await IntrospectServer.start(
+        params.introspect.port,
+        plc,
+        pds,
+        bsky,
+        ozone,
+      )
+    }
 
-    return new TestNetwork(plc, pds, bsky, ozone)
+    return new TestNetwork(plc, pds, bsky, ozone, introspect)
   }
 
   async processFullSubscription(timeout = 5000) {
@@ -144,5 +190,6 @@ export class TestNetwork extends TestNetworkNoAppView {
     await this.bsky.close()
     await this.pds.close()
     await this.plc.close()
+    await this.introspect?.close()
   }
 }