@evanp/activitypub-bot 0.45.8 → 0.45.10

package/CHANGELOG.md

@@ -9,6 +9,19 @@ and this project adheres to
 
 ## [Unreleased]
 
+## [0.45.10] - 2026-05-09
+
+### Changed
+
+- Upgraded nock, ipaddr.js, and mysql2.
+- inbox and sharedInbox caches are now persistent and shared across servers.
+
+## [0.45.9] - 2026-04-29
+
+### Fixed
+
+- Don't infinitely retry on 429 status code.
+
 ## [0.45.8] - 2026-04-29
 
 ### Added

package/lib/activitydistributor.js

@@ -1,7 +1,5 @@
 import assert from 'node:assert'
 
-import { LRUCache } from 'lru-cache'
-
 import as2 from './activitystreams.js'
 
 const NS = 'https://www.w3.org/ns/activitystreams#'
@@ -11,11 +9,13 @@ const COLLECTION_TYPES = [
   `${NS}OrderedCollection`
 ]
 
+const INBOX = 'inbox'
+const SHARED_INBOX = 'sharedInbox'
+
 export class ActivityDistributor {
   static #DISTRIBUTION_QUEUE_ID = 'distribution'
   static #DELIVERY_QUEUE_ID = 'delivery'
   static #FANOUT_QUEUE_ID = 'fanout'
-  static #MAX_CACHE_SIZE = 1000000
   static #PUBLIC = [
     'https://www.w3.org/ns/activitystreams#Public',
     'as:Public',
@@ -25,24 +25,23 @@ export class ActivityDistributor {
   #client = null
   #formatter = null
   #actorStorage = null
-  #directInboxCache = null
-  #sharedInboxCache = null
   #logger = null
   #jobQueue = null
+  #cache
 
-  constructor (client, formatter, actorStorage, logger, jobQueue) {
+  constructor (client, formatter, actorStorage, logger, jobQueue, cache) {
     assert.ok(client)
     assert.ok(formatter)
     assert.ok(actorStorage)
     assert.ok(logger)
     assert.ok(jobQueue)
+    assert.ok(cache)
     this.#client = client
     this.#formatter = formatter
     this.#actorStorage = actorStorage
     this.#logger = logger.child({ class: this.constructor.name })
     this.#jobQueue = jobQueue
-    this.#directInboxCache = new LRUCache({ max: ActivityDistributor.#MAX_CACHE_SIZE })
-    this.#sharedInboxCache = new LRUCache({ max: ActivityDistributor.#MAX_CACHE_SIZE })
+    this.#cache = cache
   }
 
   async distribute (activity, username) {
@@ -189,7 +188,7 @@ export class ActivityDistributor {
     assert.ok(username)
     assert.equal(typeof username, 'string')
 
-    let sharedInbox = this.#sharedInboxCache.get(actorId)
+    let sharedInbox = await this.#cache.get(actorId, SHARED_INBOX)
 
     if (sharedInbox) {
       return sharedInbox
@@ -202,20 +201,15 @@ export class ActivityDistributor {
     const endpoints = obj.get('endpoints')
     if (endpoints) {
       const firstEndpoint = Array.from(endpoints)[0]
-      const sharedInboxEndpoint = firstEndpoint.get('sharedInbox')
+      const sharedInboxEndpoint = firstEndpoint.get(SHARED_INBOX)
       if (sharedInboxEndpoint) {
         const firstSharedInbox = Array.from(sharedInboxEndpoint)[0]
         sharedInbox = firstSharedInbox.id
-        this.#sharedInboxCache.set(actorId, sharedInbox)
+        await this.#cache.set(actorId, SHARED_INBOX, sharedInbox)
         return sharedInbox
       }
     }
 
-    let directInbox = this.#directInboxCache.get(actorId)
-    if (directInbox) {
-      return directInbox
-    }
-
     if (!obj.inbox) {
       return null
     }
@@ -223,8 +217,8 @@ export class ActivityDistributor {
     if (inboxes.length === 0) {
       return null
     }
-    directInbox = inboxes[0].id
-    this.#directInboxCache.set(actorId, directInbox)
+    const directInbox = inboxes[0].id
+    await this.#cache.set(actorId, INBOX, directInbox)
     return directInbox
   }
 
@@ -233,7 +227,7 @@ export class ActivityDistributor {
     assert.equal(typeof actorId, 'string')
     assert.ok(username)
     assert.equal(typeof username, 'string')
-    let directInbox = this.#directInboxCache.get(actorId)
+    let directInbox = await this.#cache.get(actorId, INBOX)
     if (directInbox) {
       return directInbox
     }
@@ -248,7 +242,7 @@ export class ActivityDistributor {
       return null
     }
     directInbox = inboxes[0].id
-    this.#directInboxCache.set(actorId, directInbox)
+    await this.#cache.set(actorId, INBOX, directInbox)
     return directInbox
   }
 

package/lib/app.js

@@ -10,6 +10,7 @@ import Logger from 'pino'
 import HTTPLogger from 'pino-http'
 import { RedisStore } from 'rate-limit-redis'
 import { createClient } from 'redis'
+import { rateLimit } from 'express-rate-limit'
 
 import { ActivityDistributor } from './activitydistributor.js'
 import { ActivityPubClient, ActivityPubClientError } from './activitypubclient.js'
@@ -52,7 +53,7 @@ import { RemoteObjectCache } from './remoteobjectcache.js'
 import { HTTPMessageSignature } from './httpmessagesignature.js'
 import { SignaturePolicyStorage } from './signaturepolicystorage.js'
 import { SafeAgent } from './safeagent.js'
-import { rateLimit } from 'express-rate-limit'
+import { EndpointCache } from './endpointcache.js'
 
 const currentDir = dirname(fileURLToPath(import.meta.url))
 const DEFAULT_INDEX_FILENAME = resolve(currentDir, '..', 'web', 'index.html')
@@ -105,12 +106,14 @@ export async function makeApp ({ databaseUrl, origin, bots, logLevel = 'silent',
   const remoteKeyStorage = new RemoteKeyStorage(client, connection, logger)
   const signature = new HTTPSignatureAuthenticator(remoteKeyStorage, signer, messageSigner, digester, logger)
   const jobQueue = new JobQueue(connection, logger)
+  const endpointCache = new EndpointCache(connection, logger)
   const distributor = new ActivityDistributor(
     client,
     formatter,
     actorStorage,
     logger,
-    jobQueue
+    jobQueue,
+    endpointCache
   )
   const authorizer = new Authorizer(actorStorage, formatter, client)
   const cache = new ObjectCache({

package/lib/distributionworker.js

@@ -44,13 +44,21 @@ export class DistributionWorker extends Worker {
           'Could not deliver activity due to client error'
         )
         if ([408, 425, 429].includes(err.status)) {
-          this._logger.debug(
-            { err, activity: activity.id, inbox },
-            'Retrying on recoverable status'
-          )
-          const recoverable = new RecoverableError(err.message)
-          recoverable.delay = this.#retryDelay(err.headers, attempts)
-          throw recoverable
+          if (attempts >= DistributionWorker.#MAX_ATTEMPTS) {
+            this._logger.warn(
+              { err, activity: activity.id, inbox, attempts },
+              'Could not deliver activity due to client error; no more attempts'
+            )
+            throw err
+          } else {
+            this._logger.debug(
+              { err, activity: activity.id, inbox },
+              'Retrying on recoverable status'
+            )
+            const recoverable = new RecoverableError(err.message)
+            recoverable.delay = this.#retryDelay(err.headers, attempts)
+            throw recoverable
+          }
         } else {
           throw err
         }
@@ -87,6 +95,12 @@ export class DistributionWorker extends Worker {
   }
 
   #retryDelay (headers, attempts) {
+    const headerDelay = this.#headerDelay(headers)
+    const attemptsDelay = this.#attemptsDelay(attempts)
+    return Math.max(headerDelay, attemptsDelay)
+  }
+
+  #headerDelay (headers) {
     if (headers?.['retry-after']) {
       this._logger.debug('using retry-after header')
       const retryAfter = headers['retry-after']
@@ -96,7 +110,10 @@ export class DistributionWorker extends Worker {
         return new Date(retryAfter) - Date.now()
       }
     }
-    this._logger.debug('exponential backoff')
+    return 0
+  }
+
+  #attemptsDelay (attempts) {
     return Math.round((2 ** (attempts - 1) * 1000) * (0.5 + Math.random()))
   }
 }

package/lib/endpointcache.js

@@ -0,0 +1,57 @@
+import assert from 'node:assert'
+
+const EXPIRY = 7 * 24 * 60 * 60 * 1000
+
+export class EndpointCache {
+  #connection
+  #logger
+
+  constructor (connection, logger) {
+    assert.ok(connection)
+    assert.equal(typeof connection, 'object')
+    assert.ok(logger)
+    assert.equal(typeof logger, 'object')
+    this.#connection = connection
+    this.#logger = logger
+  }
+
+  async get (actorId, name) {
+    assert.ok(actorId)
+    assert.equal(typeof actorId, 'string')
+    assert.ok(name)
+    assert.equal(typeof name, 'string')
+    const [rows] = await this.#connection.query(
+      `SELECT url, expiry FROM endpoint_cache
+       WHERE actor_id = ? AND name = ?`,
+      { replacements: [actorId, name] }
+    )
+    if (rows && rows.length > 0) {
+      if (new Date(rows[0].expiry) > new Date()) {
+        return rows[0].url
+      } else {
+        return null
+      }
+    }
+    return null
+  }
+
+  async set (actorId, name, url) {
+    assert.ok(actorId)
+    assert.equal(typeof actorId, 'string')
+    assert.ok(name)
+    assert.equal(typeof name, 'string')
+    assert.ok(url)
+    assert.equal(typeof url, 'string')
+    await this.#connection.query(
+    `
+    INSERT INTO endpoint_cache (actor_id, name, url, expiry)
+    VALUES (?, ?, ?, ?)
+    ON CONFLICT (actor_id, name) DO UPDATE SET
+    url = EXCLUDED.url,
+    expiry = EXCLUDED.expiry,
+    updated_at = CURRENT_TIMESTAMP
+    `,
+    { replacements: [actorId, name, url, new Date(Date.now() + EXPIRY)] }
+    )
+  }
+}

package/lib/migrations/010-endpoint-cache.js

@@ -0,0 +1,21 @@
+export const id = '010-endpoint-cache'
+
+export async function up (connection, queryOptions = {}) {
+  await connection.query(`
+    CREATE TABLE endpoint_cache (
+      actor_id varchar(512) NOT NULL,
+      name varchar(64) NOT NULL,
+      url varchar(512) NOT NULL,
+      expiry TIMESTAMP NOT NULL,
+      created_at TIMESTAMP NOT NULL DEFAULT CURRENT_TIMESTAMP,
+      updated_at TIMESTAMP NOT NULL DEFAULT CURRENT_TIMESTAMP,
+      PRIMARY KEY (actor_id, name)
+    );
+  `, queryOptions)
+  await connection.query(`
+    CREATE INDEX endpoint_cache_expiry on endpoint_cache (expiry);
+  `, queryOptions)
+  await connection.query(`
+    CREATE INDEX endpoint_cache_url on endpoint_cache (url);
+  `, queryOptions)
+}

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@evanp/activitypub-bot",
-  "version": "0.45.8",
+  "version": "0.45.10",
   "description": "server-side ActivityPub bot framework",
   "type": "module",
   "main": "lib/index.js",