@evanp/activitypub-bot 0.45.3 → 0.45.5

package/CHANGELOG.md

@@ -9,6 +9,19 @@ and this project adheres to
 
 ## [Unreleased]
 
+## [0.45.5] - 2026-04-27
+
+### Fixed
+
+- Clear stale follow requests in followback bot
+- Synchronize followers collection in followback bot
+
+## [0.45.4] - 2026-04-26
+
+### Fixed
+
+- Retry throttled deliveries
+
 ## [0.45.3] - 2026-04-24
 
 ### Fixed

package/lib/botcontext.js

@@ -487,6 +487,10 @@ export class BotContext {
     yield * this.#actorStorage.items(this.#botId, 'following')
   }
 
+  async * pendingFollowing () {
+    yield * this.#actorStorage.items(this.#botId, 'pendingFollowing')
+  }
+
   async addFollowingUnsafe (actor) {
     assert.ok(actor)
     assert.equal(typeof actor, 'object')

package/lib/bots/followback.js

@@ -3,14 +3,30 @@ import Bot from '../bot.js'
 const DEFAULT_NAME = 'FollowBackBot'
 const DEFAULT_DESCRIPTION = 'A bot that follows you back'
 
+// 7-day default timeout
+
+const DEFAULT_STALE_FOLLOW_TIMEOUT = 7 * 24 * 60 * 60 * 1000
+
 export default class FollowBackBot extends Bot {
   #fullname
   #description
+  #staleFollowTimeout
 
   constructor (username, options = {}) {
     super(username, options)
     this.#fullname = options.fullname || DEFAULT_NAME
     this.#description = options.description || DEFAULT_DESCRIPTION
+    this.#staleFollowTimeout = ('staleFollowTimeout' in options)
+      ? options.staleFollowTimeout
+      : DEFAULT_STALE_FOLLOW_TIMEOUT
+  }
+
+  async initialize (context) {
+    await super.initialize(context)
+    await this.#undoStalePendingFollowing()
+    // Drain the queue so undos arrive before re-follows
+    await this._context.onIdle()
+    await this.#synchronizeFollowers()
   }
 
   get fullname () {
@@ -30,4 +46,56 @@ export default class FollowBackBot extends Bot {
     this._context.logger.info({ actorId: actor.id }, 'Unfollowing user back')
     await this._context.unfollowActor(actor)
   }
+
+  async #synchronizeFollowers () {
+    for await (const follower of this._context.followers()) {
+      try {
+        if (!await this._context.isFollowing(follower) &&
+          !await this._context.isPendingFollowing(follower)) {
+          await this._context.followActor(follower)
+          this._context.logger.info(
+            {
+              actorId: follower.id
+            },
+            'Synchronized a follower not yet followed'
+          )
+        }
+      } catch (err) {
+        this._context.logger.error(
+          {
+            err,
+            follower: follower.id
+          },
+          'Error checking for followback; skipping'
+        )
+      }
+    }
+  }
+
+  async #undoStalePendingFollowing () {
+    const now = new Date()
+    for await (const follow of this._context.pendingFollowing()) {
+      try {
+        const activity = await this._context.getObject(follow.id)
+        if (activity.published && (now - activity.published > this.#staleFollowTimeout)) {
+          await this._context.unfollowActor(activity.object.first)
+          this._context.logger.info(
+            {
+              actorId: activity.object.first?.id,
+              published: activity.published
+            },
+            'Unfollowed stale actor'
+          )
+        }
+      } catch (err) {
+        this._context.logger.error(
+          {
+            err,
+            activity: follow.id
+          },
+          'Error checking stale follow; skipping'
+        )
+      }
+    }
+  }
 }

package/lib/distributionworker.js

@@ -2,6 +2,7 @@ import assert from 'node:assert'
 
 import as2 from './activitystreams.js'
 import { Worker, RecoverableError } from './worker.js'
+import { ThrottleError } from './requestthrottler.js'
 
 export class DistributionWorker extends Worker {
   static #MAX_ATTEMPTS = 21 // ~24 days
@@ -21,6 +22,12 @@ export class DistributionWorker extends Worker {
       this._logger.info({ activity: activity.id, inbox }, 'Delivered activity')
     } catch (err) {
       if (!err.status) {
+        if (err instanceof ThrottleError) {
+          this._logger.warn(
+            { err, activity: activity.id, inbox },
+            'Throttled delivery, waiting to retry')
+          throw new RecoverableError(err.message, err.waitTime)
+        }
         this._logger.warn(
           { err, activity: activity.id, inbox },
           'Could not deliver activity and no HTTP status available')

package/lib/requestthrottler.js

@@ -3,6 +3,14 @@ import assert from 'node:assert'
 
 const BETA = 0.75
 
+export class ThrottleError extends Error {
+  constructor (message, waitTime) {
+    super(message)
+    this.name = this.constructor.name
+    this.waitTime = waitTime
+  }
+}
+
 export class RequestThrottler {
   #connection
   #logger
@@ -19,7 +27,10 @@ export class RequestThrottler {
     assert.strictEqual(typeof maxWaitTime, 'number')
     const waitTime = await this.#getWaitTime(host, maxWaitTime)
     if (waitTime > maxWaitTime) {
-      throw new Error(`Wait time is too long; ${waitTime} > ${maxWaitTime}`)
+      throw new ThrottleError(
+        `Wait time is too long; ${waitTime} > ${maxWaitTime}`,
+        waitTime
+      )
     }
     if (waitTime > 0) {
       await this.#decrement(host)

package/lib/worker.js

@@ -2,7 +2,12 @@ import assert from 'node:assert'
 import { nanoid } from 'nanoid'
 
 export class RecoverableError extends Error {
-  delay = 1000
+  delay
+  constructor (message, delay = 1000) {
+    super(message)
+    this.name = this.constructor.name
+    this.delay = delay
+  }
 }
 
 export class Worker {

package/package.json

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