@evanp/activitypub-bot 0.9.0 → 0.11.0

package/.github/workflows/main.yml

@@ -0,0 +1,34 @@
+name: Run tests on main
+
+on:
+  workflow_dispatch:
+  push:
+    branches:
+      - main
+
+permissions:
+  contents: read
+  packages: write
+
+jobs:
+
+  runTests:
+    runs-on: ubuntu-latest
+    strategy:
+      matrix:
+        node-version: [20, 22, 24, 25]
+    steps:
+
+    - uses: actions/checkout@v4
+
+    - uses: actions/setup-node@v4
+      with:
+        node-version: ${{ matrix.node-version }}
+        cache: npm
+        cache-dependency-path: package-lock.json
+
+    - name: Install dependencies
+      run: npm ci
+
+    - name: Run tests
+      run: npm run test

package/.github/workflows/{tag-docker.yml → tag.yml}

@@ -5,8 +5,58 @@ on:
     tags:
       - 'v[0-9]+.[0-9]+.[0-9]+'
 
+permissions:
+  contents: read
+  packages: write
+
 jobs:
+
+  runTests:
+    runs-on: ubuntu-latest
+    strategy:
+      matrix:
+        node-version: [20, 22, 24, 25]
+    steps:
+
+    - uses: actions/checkout@v4
+
+    - uses: actions/setup-node@v4
+      with:
+        node-version: ${{ matrix.node-version }}
+        cache: npm
+        cache-dependency-path: package-lock.json
+
+    - name: Install dependencies
+      run: npm ci
+
+    - name: Run tests
+      run: npm run test
+
+  publish-npm:
+    needs: runTests
+    runs-on: ubuntu-latest
+
+    permissions:
+      contents: read
+      id-token: write
+
+    steps:
+      - name: Checkout code
+        uses: actions/checkout@v4
+
+      - name: Set up Node.js
+        uses: actions/setup-node@v4
+        with:
+          node-version: 25
+          registry-url: https://registry.npmjs.org
+          cache: npm
+          cache-dependency-path: package-lock.json
+
+      - name: Publish to NPM
+        run: npm publish --access public --provenance
+
   build-and-push:
+    needs: publish-npm
     runs-on: ubuntu-latest
 
     permissions:
@@ -15,10 +65,10 @@ jobs:
 
     steps:
       - name: Checkout code
-        uses: actions/checkout@v3
+        uses: actions/checkout@v4
 
       - name: Set up Docker Buildx
-        uses: docker/setup-buildx-action@v2
+        uses: docker/setup-buildx-action@v3
 
       - name: Extract version components from tag
         id: get_version
@@ -33,22 +83,24 @@ jobs:
           echo "MAJOR_MINOR_VERSION=$MAJOR.$MINOR" >> $GITHUB_OUTPUT
 
       - name: Login to GitHub Container Registry
-        uses: docker/login-action@v2
+        uses: docker/login-action@v3
         with:
           registry: ghcr.io
           username: ${{ github.actor }}
           password: ${{ secrets.GITHUB_TOKEN }}
 
       - name: Build and push Docker image
-        uses: docker/build-push-action@v4
+        uses: docker/build-push-action@v5
         with:
           context: .
           push: true
           platforms: linux/amd64,linux/arm64
+          build-args: |
+            PACKAGE_VERSION=${{ steps.get_version.outputs.FULL_VERSION }}
           tags: |
             ghcr.io/${{ github.repository }}:${{ steps.get_version.outputs.FULL_VERSION }}
             ghcr.io/${{ github.repository }}:${{ steps.get_version.outputs.MAJOR_MINOR_VERSION }}
             ghcr.io/${{ github.repository }}:${{ steps.get_version.outputs.MAJOR_VERSION }}
             ghcr.io/${{ github.repository }}:${{ github.sha }}
           cache-from: type=gha
-          cache-to: type=gha,mode=max
+          cache-to: type=gha,mode=max

package/.nvmrc

@@ -0,0 +1 @@
+24

package/Dockerfile

@@ -1,23 +1,18 @@
-FROM node:20-alpine AS builder
+FROM node:24-alpine
 
 WORKDIR /app
 
-RUN apk add --no-cache python3 make g++ py3-setuptools
-
-COPY package.json package-lock.json ./
-RUN npm ci
-
-COPY index.js .
-COPY lib lib
-COPY bots bots
-COPY README.md .
-
-FROM node:20-alpine
+RUN apk add --no-cache libstdc++ sqlite sqlite-libs
 
-WORKDIR /app
+ARG PACKAGE_VERSION
 
-RUN apk add --no-cache libstdc++ sqlite sqlite-libs
+ENV DATABASE_URL \
+    ORIGIN \
+    PORT \
+    BOTS_CONFIG_FILE \
+    LOG_LEVEL
 
-COPY --from=builder /app/ ./
+RUN npm init -y \
+  && npm install --omit=dev @evanp/activitypub-bot@${PACKAGE_VERSION:-latest}
 
-CMD ["npm", "start"]
+CMD ["npx", "activitypub-bot"]

package/README.md

@@ -43,11 +43,25 @@ It's also an [npm](https://npmjs.org/) package, [@evanp/activitypub-bot](https:/
 
 The server works as an ActivityPub server; bots appear as ActivityPub "actors".
 
-### Environment variables
+You can run it using `npx activitypub-bot`.
 
-The package can be configured with the following environment variables.
+### Command-line arguments
 
-#### DATABASE_URL
+The program can be configured with command-line arguments.
+
+```sh
+Usage: activitypub-bot [options]
+
+Options:
+  --database-url <url>       Database connection URL
+  --origin <url>             Public origin URL for the server
+  --port <number>            Port to listen on
+  --bots-config-file <path>  Path to bots config module
+  --log-level <level>        Log level (e.g., info, debug)
+  -h, --help                 Show this help
+```
+
+#### --database-url
 
 A [sequelize](https://sequelize.org) database URI for storing the server data. The default is 'sqlite::memory', which will store data in memory and lose the data when the process shuts down; you probably don't want that. The server comes with Postgres, MySQL, and SQLite libraries; you might need to install libraries if you're using some other dialect.
 
@@ -55,33 +69,39 @@ The URI format varies by database backend; see [Postgres](https://www.postgresql
 
 The server creates and alters tables at runtime; whatever user you use to connect should have rights to do those things.
 
-#### ORIGIN
+If unspecified, the server uses the environment variable `DATABASE_URL`.
+
+#### --origin
 
 The [origin](https://developer.mozilla.org/en-US/docs/Web/API/URL/origin) (protocol + hostname) for the server. This will only be used for formatting IDs, not for running the server. Use this if you're running the server
 behind a load balancer or inside a Kubernetes cluster.
 
-The default is 'https://activitypubbot.test', which doesn't work and probably isn't what you want.
+Falls back to the `ORIGIN` environment variable. The default is 'https://activitypubbot.test', which doesn't work and probably isn't what you want.
 
-#### PORT
+#### --port
 
-The [port](https://en.wikipedia.org/wiki/Port_(computer_networking)) number to listen on. This is only used for connection; URLs are created using [ORIGIN](#origin). Must be an integer number between 1 and 65535; the default is 9000.
+The [port](https://en.wikipedia.org/wiki/Port_(computer_networking)) number to listen on. This is only used for connection; URLs are created using [--origin](#--origin). Must be an integer number between 1 and 65535; the default is 9000.
 
-#### LOG_LEVEL
+Falls back to the `PORT` environment variable.
+
+#### --log-level
 
 The minimum [pino](https://getpino.io) [log level](https://getpino.io/#/docs/api?id=logger-level) to output. This can be `trace`, `debug`, `info`, `warn`, `error`, `fatal`, or `silent`. Whatever the log level is, messages with
 lower log levels won't appear in the logs. For example, if the log level is `info`, debug and trace log messages will be silently dropped. `silent` turns off logging altogether.
 
-The default is `info` (or `silent` when running unit tests).
+Falls back to `LOG_LEVEL` environment variable. The default is `info` (or `silent` when running unit tests).
+
+#### --bots-config-file
 
-#### BOTS_CONFIG_FILE
+The path to the [config file](#config-file) for this server, which defines the usernames and code for the bots for this server.
 
-The path to the [config file](#config_file) for this server, which defines the usernames and code for the bots for this server. The default is to use the shipped default bot config file, which defines an [OKBot](#okbot) named `ok` and a [DoNothingBot](#donothingbot) named `null`.
+Falls back to `BOTS_CONFIG_FILE` environment variable. The default is to use the shipped default bot config file, which defines an [OKBot](#okbot) named `ok` and a [DoNothingBot](#donothingbot) named `null`.
 
 ### Config file
 
 The config file defines the bots provided by this server.
 
-The config file is implemented as a JavaScript module. It should export a single object mapping a string name for the bot to an instance of a classes that implements the [Bot](#bot) interface.
+The config file is implemented as a JavaScript module. It should export a single object mapping a string name for the bot to an instance of a class that implements the [Bot](#bot) or [BotFactory](#botfactory) interface.
 
 For example, the default config file declares two bot accounts: an [OKBot](#okbot) named `ok` and a [DoNothingBot](#donothingbot) named `null`.
 
@@ -95,6 +115,18 @@ export default {
 }
 ```
 
+For another example, the `ProvinceBotFactory` defines bots for all the Canadian provinces and territories ('ab' for Alberta, 'bc' for British Columbia, and so on). The special `*` value is used for identifying a bot factory (only one allowed per server). Named bots will be identified first, and the bot factory will be used as a fallback.
+
+```js
+import ProvinceBotFactory from './provincebotfactory.js'
+import DoNothingBot from '../../lib/bots/donothing.js'
+
+export default {
+  'other', new DoNothingBot('other')
+  '*', new ProvinceBotFactory()
+}
+```
+
 ### Pre-installed bot classes
 
 The following bot classes are pre-installed with the server.
@@ -109,7 +141,11 @@ A *DoNothingBot* instance will only do default stuff, like accepting follows.
 
 ## API
 
-New bot classes must implement the [Bot](#bot) interface, which is easiest if you inherit from the `Bot` class. Bots will receive a [BotContext](#botcontext) object at initialization. The BotContext is the main way to access data or execute activities.
+Custom bots can implement the [Bot](#bot) interface, which is easiest if you inherit from the `Bot` class.
+
+Alternatively, you can implement a whole class of bots with the [BotFactory](#botfactory) interface, inheriting from the `BotFactory` class.
+
+Bots will receive a [BotContext](#botcontext) object at initialization. The BotContext is the main way to access data or execute activities.
 
 ### Bot
 
@@ -144,6 +180,40 @@ getter is needed to retrieve it.)
 
 Called when the bot is mentioned in an incoming object. Can be used to implement conversational interfaces. `object` is the object of a `Create` activity, like a `Note`, that mentions the bot; it's represented in [activitystrea.ms](#activitystreams) format. `activity` is the activity itself.
 
+#### async onFollow (actor, activity)
+
+Called when the bot is followed by another actor. The first argument is the actor, and the second is the `Follow` activity itself. This method is called after the acceptance has been sent and the new
+follower has been added to the `followers` collection.
+
+#### async onLike (object, activity)
+
+Called when one of the bot's objects is liked by another actor. The first argument is the object, and the second is the `Like` activity itself. This method is called after the like has been added to the
+`likes` collection.
+
+#### async onPublic (activity)
+
+Called when the server receives a public activity to its shared inbox. This can be used to skim through ActivityPub network content.
+
+#### async onAnnounce (object, activity)
+
+Called when one of the bot's objects is shared by another actor. The first argument is the object, and the second is the `Announce` activity itself. This method is called after the activity has been added to the `shares` collection.
+
+### BotFactory
+
+The BotFactory interface lets you have a lot of bots that act in a similar way without declaring them explicitly in the bots config file.
+
+#### async canCreate (username)
+
+Can this factory create a bot with this username? Boolean response. For example, the `ProvinceBotFactory` checks that there is a matching 2-letter province code for the username.
+
+#### async create (username)
+
+Create a bot with this username and return it. The bot must implement the [Bot](#bot) interface.
+
+#### async onPublic (activity)
+
+When a public activity is received at the shared inbox of the server, this method is called for the bot factory.
+
 ### BotContext
 
 This is the bot's control panel for working with the rest of the server.
@@ -202,6 +272,10 @@ Sends a `Like` activity for the passed-in object in [activitystrea.ms](#activity
 
 Sends an `Undo`/`Like` activity for the passed-in object in [activitystrea.ms](#activitystreams) form which was previously liked.
 
+#### async announceObject (obj)
+
+Sends an `Announce` activity for the passed-in object in [activitystrea.ms](#activitystreams) form to followers.
+
 #### async followActor (actor)
 
 Sends a `Follow` activity for the passed-in actor in [activitystrea.ms](#activitystreams) form.

package/activitypub-bot.js

@@ -0,0 +1,68 @@
+#!/usr/bin/env node
+
+import { parseArgs } from 'node:util'
+import { fileURLToPath } from 'node:url'
+import { dirname, resolve } from 'node:path'
+import { makeApp } from './lib/app.js'
+
+const { values } = parseArgs({
+  options: {
+    'database-url': { type: 'string' },
+    origin: { type: 'string' },
+    port: { type: 'string' },
+    'bots-config-file': { type: 'string' },
+    'log-level': { type: 'string' },
+    help: { type: 'boolean', short: 'h' }
+  },
+  allowPositionals: false
+})
+
+if (values.help) {
+  console.log(`Usage: activitypub-bot [options]
+
+Options:
+  --database-url <url>       Database connection URL
+  --origin <url>             Public origin URL for the server
+  --port <number>            Port to listen on
+  --bots-config-file <path>  Path to bots config module
+  --log-level <level>        Log level (e.g., info, debug)
+  -h, --help                 Show this help
+`)
+  process.exit(0)
+}
+
+const normalize = (value) => (value === '' ? undefined : value)
+const parsePort = (value) => {
+  if (!value) return undefined
+  const parsed = Number.parseInt(value, 10)
+  return Number.isNaN(parsed) ? undefined : parsed
+}
+
+const baseDir = dirname(fileURLToPath(import.meta.url))
+const DEFAULT_BOTS_CONFIG_FILE = resolve(baseDir, 'bots', 'index.js')
+
+const DATABASE_URL = normalize(values['database-url']) || process.env.DATABASE_URL || 'sqlite::memory:'
+const ORIGIN = normalize(values.origin) || process.env.ORIGIN || 'https://activitypubbot.test'
+const PORT = parsePort(normalize(values.port)) || parsePort(process.env.PORT) || 9000 // HAL
+const BOTS_CONFIG_FILE =
+  normalize(values['bots-config-file']) || process.env.BOTS_CONFIG_FILE || DEFAULT_BOTS_CONFIG_FILE
+const LOG_LEVEL =
+  normalize(values['log-level']) ||
+  process.env.LOG_LEVEL ||
+  (process.env.NODE_ENV === 'test' ? 'silent' : 'info')
+
+const bots = (await import(BOTS_CONFIG_FILE)).default
+
+const app = await makeApp(DATABASE_URL, ORIGIN, bots, LOG_LEVEL)
+
+const server = app.listen(parseInt(PORT), () => {
+  app.locals.logger.info(`Listening on port ${PORT}`)
+})
+
+process.on('SIGTERM', () => {
+  console.log('Received SIGTERM')
+  server.close(async () => {
+    await app.cleanup()
+    process.exit(0)
+  })
+})

package/lib/activitydeliverer.js

@@ -0,0 +1,260 @@
+import BotMaker from './botmaker.js'
+import assert from 'node:assert'
+import as2 from './activitystreams.js'
+
+const NS = 'https://www.w3.org/ns/activitystreams#'
+
+const PUBLIC = [
+  `${NS}Public`,
+  'as:Public',
+  'Public'
+]
+
+const COLLECTION_TYPES = [
+  `${NS}Collection`,
+  `${NS}OrderedCollection`
+]
+
+export class ActivityDeliverer {
+  #actorStorage
+  #activityHandler
+  #formatter
+  #logger
+  #client
+
+  constructor (actorStorage, activityHandler, formatter, logger, client) {
+    this.#actorStorage = actorStorage
+    this.#activityHandler = activityHandler
+    this.#formatter = formatter
+    this.#client = client
+    this.#logger = logger.child({ class: this.constructor.name })
+  }
+
+  isActivity (object) {
+    return true
+  }
+
+  getActor (activity) {
+    return activity.actor?.first
+  }
+
+  getRecipients (obj) {
+    let r = []
+    for (const prop of ['to', 'cc', 'audience']) {
+      const val = obj.get(prop)
+      if (val) {
+        r = r.concat(Array.from(val))
+      }
+    }
+    return r
+  }
+
+  async deliverTo (activity, bot) {
+    try {
+      await this.#activityHandler.handleActivity(bot, activity)
+    } catch (err) {
+      this.#logger.warn(err)
+    }
+    this.#logger.debug(`Adding ${activity.id} to ${bot.username} inbox`)
+    await this.#actorStorage.addToCollection(bot.username, 'inbox', activity)
+  }
+
+  async deliverToAll (activity, bots) {
+    const deliveredTo = new Set()
+    const actor = this.getActor(activity)
+    const recipients = this.getRecipients(activity)
+
+    for (const recipient of recipients) {
+      if (this.#isPublic(recipient)) {
+        await this.#deliverPublic(activity, bots)
+      } else if (this.#isLocal(recipient)) {
+        const parts = this.#formatter.unformat(recipient.id)
+        if (this.#isLocalActor(parts)) {
+          await this.#deliverLocalActor(activity, recipient, bots, deliveredTo)
+        } else if (this.#isLocalFollowersCollection(parts)) {
+          await this.#deliverLocalFollowersCollection(activity, parts.username, bots, deliveredTo)
+        } else if (this.#isLocalFollowingCollection(parts)) {
+          await this.#deliverLocalFollowingCollection(activity, parts.username, bots, deliveredTo)
+        } else {
+          this.#logger.warn(
+            `Unrecognized recipient for remote delivery: ${recipient.id}`
+          )
+        }
+      } else {
+        const fullActor = await this.#client.get(actor.id)
+        const fullRecipient = await this.#client.get(recipient.id)
+        if (await this.#isRemoteActor(fullRecipient)) {
+          this.#logger.warn(`Skipping remote actor ${recipient.id}`)
+        } else if (await this.#isRemoteFollowersCollection(fullActor, fullRecipient)) {
+          await this.#deliverRemoteFollowersCollection(activity, fullRecipient, fullActor, deliveredTo, bots)
+        } else if (await this.#isRemoteFollowingCollection(fullActor, fullRecipient)) {
+          await this.#deliverRemoteFollowingCollection(activity, fullRecipient, fullActor, deliveredTo, bots)
+        } else if (await this.#isRemoteCollection(fullRecipient)) {
+          await this.#deliverRemoteCollection(activity, fullRecipient, deliveredTo, bots)
+        } else {
+          this.#logger.warn(`Unrecognized recipient: ${recipient.id}`)
+        }
+      }
+    }
+  }
+
+  async #isRemoteFollowersCollection (actor, object) {
+    assert.strictEqual(typeof actor, 'object')
+    assert.strictEqual(typeof actor.id, 'string')
+    assert.strictEqual(typeof object, 'object')
+    assert.strictEqual(typeof object.id, 'string')
+
+    return (actor.followers?.first?.id === object.id)
+  }
+
+  async #isRemoteFollowingCollection (actor, object) {
+    assert.strictEqual(typeof actor, 'object')
+    assert.strictEqual(typeof actor.id, 'string')
+    assert.strictEqual(typeof object, 'object')
+    assert.strictEqual(typeof object.id, 'string')
+
+    return (actor.following?.first?.id === object.id)
+  }
+
+  async #getLocalFollowers (actor) {
+    return await this.#actorStorage.getUsernamesWith('following', actor)
+  }
+
+  async #getLocalFollowing (actor) {
+    return await this.#actorStorage.getUsernamesWith('followers', actor)
+  }
+
+  async #deliverLocalActor (activity, recipient, bots, deliveredTo) {
+    const { username } = this.#formatter.unformat(recipient.id)
+    if (!deliveredTo.has(username)) {
+      const bot = await BotMaker.makeBot(bots, username)
+      if (!bot) {
+        this.#logger.warn(`sharedInbox direct delivery for unknown bot ${username}`)
+      }
+      await this.deliverTo(activity, bot)
+      deliveredTo.add(username)
+    }
+  }
+
+  async #deliverRemoteFollowersCollection (activity, recipient, actor, deliveredTo, bots) {
+    const followers = await this.#getLocalFollowers(actor)
+    for (const username of followers) {
+      if (!deliveredTo.has(username)) {
+        const bot = await BotMaker.makeBot(bots, username)
+        if (!bot) {
+          this.#logger.warn(`sharedInbox direct delivery for unknown bot ${username}`)
+          continue
+        }
+        await this.deliverTo(activity, bot)
+        deliveredTo.add(username)
+      }
+    }
+  }
+
+  async #deliverRemoteFollowingCollection (activity, recipient, actor, deliveredTo, bots) {
+    const following = await this.#getLocalFollowing(actor)
+    for (const username of following) {
+      if (!deliveredTo.has(username)) {
+        const bot = await BotMaker.makeBot(bots, username)
+        if (!bot) {
+          this.#logger.warn(`sharedInbox direct delivery for unknown bot ${username}`)
+          continue
+        }
+        await this.deliverTo(activity, bot)
+        deliveredTo.add(username)
+      }
+    }
+  }
+
+  #isPublic (recipient) {
+    return PUBLIC.includes(recipient.id)
+  }
+
+  #isLocal (recipient) {
+    return this.#formatter.isLocal(recipient.id)
+  }
+
+  #isLocalActor (parts) {
+    return parts.username && !parts.collection && !parts.type
+  }
+
+  #isLocalFollowersCollection (parts) {
+    return parts.username && (parts.collection === 'followers')
+  }
+
+  #isLocalFollowingCollection (parts) {
+    return parts.username && (parts.collection === 'following')
+  }
+
+  async #isRemoteCollection (recipient) {
+    assert.strictEqual(typeof recipient, 'object')
+    assert.strictEqual(typeof recipient.id, 'string')
+
+    return (Array.isArray(recipient.type))
+      ? recipient.type.some(item => COLLECTION_TYPES.includes(item))
+      : COLLECTION_TYPES.includes(recipient.type)
+  }
+
+  async #isRemoteActor (recipient) {
+    assert.strictEqual(typeof recipient, 'object')
+    assert.strictEqual(typeof recipient.id, 'string')
+
+    return !!recipient.inbox?.first?.id
+  }
+
+  async #deliverPublic (activity, bots) {
+    await Promise.all(Object.values(bots).map(bot => bot.onPublic(activity)))
+  }
+
+  async #deliverLocalFollowersCollection (activity, username, bots, deliveredTo) {
+    const id = this.#formatter.format({ username })
+    const followed = await as2.import({ id })
+    const followers = await this.#actorStorage.getUsernamesWith('following', followed)
+    for (const follower of followers) {
+      if (!deliveredTo.has(follower)) {
+        const bot = await BotMaker.makeBot(bots, follower)
+        if (!bot) {
+          this.#logger.warn(`sharedInbox delivery for unknown bot ${follower}`)
+          continue
+        }
+        await this.deliverTo(activity, bot)
+        deliveredTo.add(follower)
+      }
+    }
+  }
+
+  async #deliverLocalFollowingCollection (activity, username, bots, deliveredTo) {
+    const id = this.#formatter.format({ username })
+    const following = await as2.import({ id })
+    const followeds = await this.#actorStorage.getUsernamesWith('followers', following)
+    for (const followed of followeds) {
+      if (!deliveredTo.has(followed)) {
+        const bot = await BotMaker.makeBot(bots, followed)
+        if (!bot) {
+          this.#logger.warn(`sharedInbox delivery for unknown bot ${followed}`)
+          continue
+        }
+        await this.deliverTo(activity, bot)
+        deliveredTo.add(followed)
+      }
+    }
+  }
+
+  async #deliverRemoteCollection (activity, recipient, deliveredTo, bots) {
+    for await (const item of this.#client.items(recipient.id)) {
+      this.#logger.debug(`item: ${JSON.stringify(item)}`)
+      if (this.#isLocal(item)) {
+        const parts = this.#formatter.unformat(item.id)
+        if (this.#isLocalActor(parts)) {
+          const bot = await BotMaker.makeBot(bots, parts.username)
+          if (!bot) {
+            this.#logger.warn(`sharedInbox delivery for unknown bot ${parts.username}`)
+            continue
+          }
+          await this.deliverTo(activity, bot)
+          deliveredTo.add(parts.username)
+        }
+      }
+    }
+  }
+}

package/lib/activityhandler.js

@@ -314,6 +314,11 @@ export class ActivityHandler {
       object: activity,
       to: actor
     }))
+    this.#logger.debug({
+      msg: 'Notifying bot of new follow',
+      actor: actor.id
+    })
+    await bot.onFollow(actor, activity)
   }
 
   async #handleAccept (bot, activity) {
@@ -516,6 +521,7 @@ export class ActivityHandler {
       }),
       ...recipients
     }))
+    await bot.onLike(object, activity)
   }
 
   async #handleAnnounce (bot, activity) {
@@ -592,6 +598,14 @@ export class ActivityHandler {
       }),
       ...recipients
     }))
+    try {
+      await bot.onAnnounce(object, activity)
+    } catch (err) {
+      this.#logger.warn(
+        `Error notifying bot of announce: ${err.message}`,
+        { err, username: bot.username, activity: activity.id }
+      )
+    }
   }
 
   async #handleBlock (bot, activity) {