setup announcement actor, add endpoint for actor

.vscode/settings.json

@@ -1,6 +1,7 @@
 {
   "standard.enable": true,
   "standard.autoFixOnSave": true,
+  "standard.engine": "ts-standard",
   "[typescript]": {
     "editor.defaultFormatter": ""
   }

@types/http-signed-fetch.d.ts

@@ -4,6 +4,5 @@ declare module 'http-signed-fetch' {
   export function generateKeypair (): {
     publicKeyPem: string
     privateKeyPem: string
-    publicKeyId: string
   }
 }

package.json

@@ -14,6 +14,7 @@
     "generate-identity": "ts-node-esm src/scripts/generate-identity.ts",
     "import-blocklist": "ts-node-esm src/scripts/import-blocklist.ts",
     "import-admins": "ts-node-esm src/scripts/import-admins.ts",
+    "client-cli": "ts-node-esm src/client/cli.ts",
     "lint": "ts-standard --fix && tsc --noEmit",
     "dev": "ts-node-esm src/bin.ts run | pino-pretty -c -t",
     "start": "node dist/bin.js run | pino-pretty -c -t",

src/client/index.test.ts

@@ -33,7 +33,7 @@ test('Local Server Communication', async t => {
   const client = new SocialInboxClient({
     instance: `http://localhost:${port}`,
     account: 'testAccount',
-    keypair: generateKeypair(),
+    keypair: { ...generateKeypair(), publicKeyId: 'testAccount#main-key' },
     fetch: globalThis.fetch
   })
 

src/client/index.ts

@@ -9,10 +9,14 @@ export type SignedFetchLike = (
   init?: RequestInit & { publicKeyId: string, keypair: KeyPair }
 ) => Promise<Response>
 
+type Keypair = ReturnType<typeof generateKeypair> & {
+  publicKeyId: string
+}
+
 export interface SocialInboxOptions {
   instance: string
   account: string
-  keypair: ReturnType<typeof generateKeypair>
+  keypair: Keypair
   fetch?: SignedFetchLike
 }
 
@@ -40,7 +44,7 @@ type VALID_TYPES = typeof TYPE_TEXT | typeof TYPE_JSON | typeof TYPE_LDJSON | un
 export class SocialInboxClient {
   instance: string
   account: string
-  keypair: ReturnType<typeof generateKeypair>
+  keypair: Keypair
   fetch: SignedFetchLike
 
   constructor (options: SocialInboxOptions) {
@@ -83,7 +87,7 @@ export class SocialInboxClient {
 
   // Actorinfo
   async setActorInfo (info: ActorInfo, actor: string = this.account): Promise<void> {
-    await this.sendRequest(POST, `/${actor}/`, TYPE_JSON, info)
+    await this.sendRequest(POST, `/${actor}`, TYPE_JSON, info)
   }
 
   async getActorInfo (actor: string = this.account): Promise<ActorInfo> {

src/schemas.ts

@@ -5,7 +5,8 @@ export const ActorInfoSchema = Type.Object({
   // The actor for the domain inbox
   actorUrl: Type.String(),
   publicKeyId: Type.String(),
-  keypair: KeyPairSchema
+  keypair: KeyPairSchema,
+  announce: Type.Boolean({ default: false })
 })
 
 export type ActorInfo = Static<typeof ActorInfoSchema>

src/server/announcements.test.ts

@@ -0,0 +1,46 @@
+import test from 'ava'
+import sinon from 'sinon'
+import ActivityPubSystem, { FetchLike } from './apsystem'
+import Store from './store/index.js'
+import { ModerationChecker } from './moderation.js'
+import HookSystem from './hooksystem'
+import { MemoryLevel } from 'memory-level'
+
+// Create some mock dependencies
+const mockStore = new Store(new MemoryLevel())
+
+const mockModCheck = new ModerationChecker(mockStore)
+const mockFetch: FetchLike = async (input: RequestInfo | URL, init?: RequestInit): Promise<Response> => {
+  return new Response(JSON.stringify({}), { status: 200 })
+}
+const mockHooks = new HookSystem(mockStore, mockFetch)
+
+const aps = new ActivityPubSystem('http://localhost', mockStore, mockModCheck, mockHooks)
+
+test.beforeEach(async () => {
+  // Restore stubs before setting them up again
+  sinon.restore()
+
+  await aps.announcements.init()
+})
+
+const keypair = {
+  publicKeyPem: 'mockPublicKey',
+  privateKeyPem: 'mockPrivateKey',
+  publicKeyId: 'mockPublicKeyId'
+}
+
+test('actor gets announced on .announce', async t => {
+  const fakeActor = '@test@url'
+  const actorInfo = {
+    actorUrl: 'https://url/@test',
+    announce: true,
+    keypair,
+    publicKeyId: keypair.publicKeyId
+  }
+  await aps.announcements.announce(fakeActor, actorInfo)
+  await aps.store.forActor(fakeActor).setInfo(actorInfo)
+
+  const outbox = await aps.store.forActor('@announcements@localhost').outbox.list()
+  t.is(outbox.length, 1, 'something is in outbox')
+})

src/server/announcements.ts

@@ -0,0 +1,107 @@
+import { nanoid } from 'nanoid'
+import { ActorInfo } from '../schemas'
+import ActivityPubSystem, { DEFAULT_PUBLIC_KEY_FIELD } from './apsystem'
+import { generateKeypair } from 'http-signed-fetch'
+import { APOrderedCollection } from 'activitypub-types'
+import { ActorStore } from './store/ActorStore'
+
+export class Announcements {
+  apsystem: ActivityPubSystem
+  publicURL: string
+
+  constructor (apsystem: ActivityPubSystem, publicURL: string) {
+    this.apsystem = apsystem
+    this.publicURL = publicURL
+  }
+
+  get actorUrl (): string {
+    return `${this.publicURL}/v1/${this.mention}/`
+  }
+
+  get outboxUrl (): string {
+    return `${this.actorUrl}outbox`
+  }
+
+  get mention (): string {
+    const url = new URL(this.publicURL)
+    return `@announcements@${url.hostname}`
+  }
+
+  getActor (): ActorStore {
+    return this.apsystem.store.forActor(this.mention)
+  }
+
+  async init (): Promise<void> {
+    const actorUrl = this.actorUrl
+    const actor = this.getActor()
+
+    try {
+      const prev = await actor.getInfo()
+      if (prev.actorUrl !== actorUrl) {
+        await actor.setInfo({
+          ...prev,
+          actorUrl
+        })
+      }
+    } catch {
+      const { privateKeyPem, publicKeyPem } = generateKeypair()
+      await actor.setInfo({
+        actorUrl,
+        publicKeyId: `${actorUrl}#${DEFAULT_PUBLIC_KEY_FIELD}`,
+        keypair: {
+          privateKeyPem,
+          publicKeyPem
+        },
+        announce: false
+      })
+    }
+  }
+
+  async announce (actor: string, info: ActorInfo): Promise<void> {
+    let existedAlready = false
+    try {
+      const existingActor = await this.apsystem.store.forActor(actor).getInfo()
+      if (existingActor !== undefined) existedAlready = true
+    } catch (err) {
+      if (!(err as { notFound: boolean }).notFound) {
+        throw err
+      }
+    }
+
+    if (!existedAlready && info.announce) {
+      const activity = {
+        '@context': 'https://www.w3.org/ns/activitystreams',
+        type: 'Note',
+        id: `${this.outboxUrl}/${nanoid()}`,
+        actor: this.actorUrl,
+        attributedTo: info.actorUrl,
+        published: new Date().toUTCString(),
+        to: ['https://www.w3.org/ns/activitystreams#Public'],
+        cc: [`${this.actorUrl}followers`],
+        // TODO: add a template in config
+        content: `a wild site appears! ${actor}`
+      }
+      await this.getActor().outbox.add(activity)
+      await this.apsystem.notifyFollowers(this.mention, activity)
+    }
+  }
+
+  async getOutbox (): Promise<APOrderedCollection> {
+    const actor = this.getActor()
+    const activities = await actor.outbox.list()
+    const orderedItems = activities
+      // XXX: maybe `new Date()` doesn't correctly parse possible dates?
+      .map(a => ({ ...a, published: typeof a.published === 'string' ? new Date(a.published) : a.published }))
+      .sort((a, b) => +(b.published ?? 0) - +(a.published ?? 0))
+      .map(a => a.id)
+      .filter((id): id is string => id !== undefined)
+
+    return {
+      '@context': 'https://www.w3.org/ns/activitystreams',
+      id: `${this.actorUrl}outbox`,
+      type: 'OrderedCollection',
+      totalItems: orderedItems.length,
+      orderedItems
+    }
+  }
+}

src/server/api/announcements.ts

@@ -0,0 +1,102 @@
+import { APActor } from 'activitypub-types'
+
+import type { APIConfig, FastifyTypebox } from '.'
+import Store from '../store'
+import type ActivityPubSystem from '../apsystem'
+import { Type } from '@sinclair/typebox'
+
+type APActorNonStandard = APActor & {
+  publicKey: {
+    id: string
+    owner: string
+    publicKeyPem: string
+  }
+}
+
+export const announcementsRoutes = (cfg: APIConfig, store: Store, apsystem: ActivityPubSystem) => async (server: FastifyTypebox): Promise<void> => {
+  server.get<{
+    Reply: APActorNonStandard
+  }>(`/${apsystem.announcements.mention}/`, {
+    schema: {
+      params: {},
+      // XXX: even with Type.Any(), the endpoint returns `{}` :/
+      // response: {
+      //   // TODO: typebox APActor
+      //   200: Type.Any()
+      // },
+      description: 'Announcements ActivityPub actor',
+      tags: ['ActivityPub']
+    }
+  }, async (request, reply) => {
+    const actor = apsystem.announcements.getActor()
+    const actorInfo = await actor.getInfo()
+
+    return await reply.send({
+      '@context': [
+        // TODO: I copied this from Mastodon, is this correct?
+        'https://www.w3.org/ns/activitystreams',
+        'https://w3id.org/security/v1'
+      ],
+      // https://www.w3.org/TR/activitystreams-vocabulary/#actor-types
+      id: apsystem.announcements.actorUrl,
+      type: 'Person',
+      name: 'Announcements',
+      summary: `Announcements for ${new URL(cfg.publicURL).hostname}`,
+      preferredUsername: 'Announcements',
+      following: `${actorInfo.actorUrl}following`,
+      followers: `${actorInfo.actorUrl}followers`,
+      inbox: `${actorInfo.actorUrl}inbox`,
+      outbox: `${actorInfo.actorUrl}outbox`,
+      publicKey: {
+        id: `${actorInfo.actorUrl}#main-key`,
+
+        owner: actorInfo.actorUrl,
+        publicKeyPem: actorInfo.keypair.publicKeyPem
+      }
+    })
+  })
+
+  server.get<{
+    // TODO: typebox APOrderedCollection
+    Reply: any
+  }>(`/${apsystem.announcements.mention}/outbox`, {
+    schema: {
+      params: {},
+      // XXX: even with Type.Any(), the endpoint returns `{}` :/
+      // response: {
+      //   // TODO: typebox APOrderedCollection
+      //   200: Type.Any()
+      // },
+      description: 'Announcements ActivityPub outbox',
+      tags: ['ActivityPub']
+    }
+  }, async (request, reply) => {
+    return await reply.send(await apsystem.announcements.getOutbox())
+  })
+
+  server.get<{
+    Params: {
+      id: string
+    }
+    // TODO: typebox APOrderedCollection
+    Reply: any
+  }>(`/${apsystem.announcements.mention}/outbox/:id`, {
+    schema: {
+      params: Type.Object({
+        id: Type.String()
+      }),
+      // XXX: even with Type.Any(), the endpoint returns `{}` :/
+      // response: {
+      //   // TODO: typebox APOrderedCollection
+      //   200: Type.Any()
+      // },
+      description: 'Announcements ActivityPub get activity',
+      tags: ['ActivityPub']
+    }
+  }, async (request, reply) => {
+    const actor = apsystem.announcements.getActor()
+    const actorInfo = await actor.getInfo()
+    const activity = await actor.outbox.get(`${actorInfo.actorUrl}outbox/${request.params.id}`)
+    return await reply.send(activity)
+  })
+}

src/server/api/creation.ts

@@ -34,7 +34,9 @@ export const creationRoutes = (cfg: APIConfig, store: Store, apsystem: ActivityP
     }
 
     const info = request.body
+    await apsystem.announcements.announce(actor, info)
     await store.forActor(actor).setInfo(info)
+
     return await reply.send(info)
   })
 

src/server/api/index.ts

@@ -27,6 +27,8 @@ import { blockAllowListRoutes } from './blockallowlist.js'
 import { adminRoutes } from './admins.js'
 import { followerRoutes } from './followers.js'
 import { hookRoutes } from './hooks.js'
+import { announcementsRoutes } from './announcements.js'
+import { wellKnownRoutes } from './wellKnown.js'
 
 export const paths = envPaths('distributed-press')
 
@@ -94,7 +96,10 @@ async function apiBuilder (cfg: APIConfig): Promise<FastifyTypebox> {
     return 'ok\n'
   })
 
+  await apsystem.announcements.init()
+
   await server.register(v1Routes(cfg, store, apsystem, hookSystem), { prefix: '/v1' })
+  await server.register(wellKnownRoutes(cfg, store, apsystem))
 
   await server.ready()
 
@@ -123,6 +128,7 @@ const v1Routes = (cfg: APIConfig, store: Store, apsystem: ActivityPubSystem, hoo
     })
   }
 
+  await server.register(announcementsRoutes(cfg, store, apsystem))
   await server.register(creationRoutes(cfg, store, apsystem))
   await server.register(inboxRoutes(cfg, store, apsystem))
   await server.register(outboxRoutes(cfg, store, apsystem))