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

@@ -1,11 +1,22 @@
 import { Type, Static } from '@sinclair/typebox'
 import { KeyPairSchema } from './keypair.js'
+import { APActor } from 'activitypub-types'
 
 export const ActorInfoSchema = Type.Object({
   // The actor for the domain inbox
   actorUrl: Type.String(),
   publicKeyId: Type.String(),
-  keypair: KeyPairSchema
+  keypair: KeyPairSchema,
+  announce: Type.Optional(Type.Boolean({ default: false })),
+  manuallyApprovesFollowers: Type.Optional(Type.Boolean({ default: false }))
 })
 
 export type ActorInfo = Static<typeof ActorInfoSchema>
+
+export type APActorNonStandard = APActor & {
+  publicKey: {
+    id: string
+    owner: string
+    publicKeyPem: string
+  }
+}

src/server/announcements.test.ts

@@ -0,0 +1,48 @@
+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()
+
+  sinon.stub(aps, 'mentionToActor').returns(Promise.resolve('http://actor.url'))
+
+  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)
+  await aps.store.forActor(fakeActor).setInfo(actorInfo)
+
+  const outbox = await aps.announcements.getOutbox()
+  t.is(outbox.totalItems, 1, 'something is in outbox')
+})

src/server/announcements.ts

@@ -0,0 +1,141 @@
+import { nanoid } from 'nanoid'
+import ActivityPubSystem, { DEFAULT_PUBLIC_KEY_FIELD } from './apsystem'
+import { generateKeypair } from 'http-signed-fetch'
+import { APOrderedCollection } from 'activitypub-types'
+import { ActorStore } from './store/ActorStore'
+import { APActorNonStandard } from '../schemas'
+
+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}`
+  }
+
+  get store (): ActorStore {
+    return this.apsystem.store.forActor(this.mention)
+  }
+
+  async getActor (): Promise<APActorNonStandard> {
+    const actorInfo = await this.store.getInfo()
+    return {
+      '@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: this.actorUrl,
+      type: 'Person',
+      name: 'Announcements',
+      summary: `Announcements for ${new URL(this.actorUrl).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
+      }
+    }
+  }
+
+  async init (): Promise<void> {
+    const actorUrl = this.actorUrl
+    const actor = this.store
+
+    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,
+        manuallyApprovesFollowers: false
+      })
+    }
+  }
+
+  async announce (actor: string): Promise<void> {
+    const actorUrl = await this.apsystem.mentionToActor(actor)
+    const published = new Date().toUTCString()
+    const to = ['https://www.w3.org/ns/activitystreams#Public']
+    const cc = [`${this.actorUrl}followers`, actorUrl]
+
+    const mentionText = `<span class="h-card"><a href="${actorUrl}" class="u-url mention">${actor}</a></span>`
+
+    const note = {
+      '@context': 'https://www.w3.org/ns/activitystreams',
+      type: 'Note',
+      id: `${this.outboxUrl}/${nanoid()}`,
+      attributedTo: this.actorUrl,
+      published,
+      to,
+      cc,
+      // TODO: add a template in config
+      content: `A wild ${mentionText} appears!`,
+      tag: [{ type: 'Mention', href: actorUrl, name: actor }]
+    }
+    const activity = {
+      '@context': 'https://www.w3.org/ns/activitystreams',
+      type: 'Create',
+      id: `${this.outboxUrl}/${nanoid()}`,
+      actor: this.actorUrl,
+      published,
+      to,
+      cc,
+      object: note
+    }
+    await this.store.outbox.add(activity)
+    await this.store.outbox.add(note)
+    await this.apsystem.notifyFollowers(this.mention, activity)
+  }
+
+  async getOutbox (): Promise<APOrderedCollection> {
+    const actor = this.store
+    const activities = await actor.outbox.list()
+    const orderedItems = activities
+      .filter(a => a.type !== 'Note')
+    // 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,69 @@
+import type { APIConfig, FastifyTypebox } from '.'
+import Store from '../store'
+import type ActivityPubSystem from '../apsystem'
+import type { APActorNonStandard } from '../../schemas'
+import { Type } from '@sinclair/typebox'
+
+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 = await apsystem.announcements.getActor()
+
+    return await reply.send(actor)
+  })
+
+  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 actorUrl = apsystem.announcements.actorUrl
+    const activity = await apsystem.announcements.store.outbox.get(`${actorUrl}outbox/${request.params.id}`)
+    return await reply.send(activity)
+  })
+}

src/server/api/creation.ts

@@ -33,8 +33,22 @@ export const creationRoutes = (cfg: APIConfig, store: Store, apsystem: ActivityP
       return await reply.code(403).send('Not Allowed')
     }
 
+    let existedAlready = false
+    try {
+      const existingActor = await apsystem.store.forActor(actor).getInfo()
+      if (existingActor !== undefined) existedAlready = true
+    } catch (err) {
+      if (!(err as { notFound: boolean }).notFound) {
+        throw err
+      }
+    }
+
     const info = request.body
     await store.forActor(actor).setInfo(info)
+
+    const shouldAnnounce = !existedAlready && info.announce === true
+    if (shouldAnnounce) await apsystem.announcements.announce(actor)
+
     return await reply.send(info)
   })