@frockbot/plugin-flock 0.3.11 → 0.3.13

package/src/user.test.ts

@@ -287,6 +287,110 @@ describe("Flock User contribution", () => {
     ).toMatchObject({ status: "applied", lifecycle: { status: "archived" } });
   });
 
+  test("removes a deleted Bot from the directory and queues its sweep", async () => {
+    const storage = new MemoryStorage();
+    let botStatus: "active" | "deleted" = "active";
+    const contribution = createFlockUserBackendContribution({
+      storage,
+      commandBotLifecycle: (_userId, lifecycleCommand) => {
+        botStatus = "deleted";
+        return Promise.resolve({
+          schemaVersion: 1,
+          commandId: lifecycleCommand.commandId,
+          botId: lifecycleCommand.botId,
+          status: "applied",
+          lifecycle: {
+            schemaVersion: 1,
+            botId: lifecycleCommand.botId,
+            status: "deleted",
+            revision: 1,
+          },
+        });
+      },
+      readBotLifecycle: (_userId, botId) =>
+        Promise.resolve({
+          schemaVersion: 1,
+          botId,
+          status: botStatus,
+          revision: 1,
+        }),
+    });
+    await contribution.createBot("user-1", command());
+    const remove = {
+      schemaVersion: 1 as const,
+      type: "bot/delete" as const,
+      commandId: "delete-1",
+      botId: "alpha",
+    };
+    const applied = await contribution.executeLifecycle("user-1", remove);
+    expect(applied).toMatchObject({
+      status: "applied",
+      lifecycle: { status: "deleted" },
+    });
+    // Gone from every read the sidebar, the fan-outs and the debug surface do.
+    expect(await contribution.listBots()).toMatchObject({
+      revision: 2,
+      bots: [],
+    });
+    expect(await contribution.listBotLifecycles()).toEqual({
+      schemaVersion: 1,
+      lifecycles: [],
+    });
+    expect(storage.values.has("flock:lifecycle:alpha")).toBe(false);
+    // The User-scoped projections are somebody else's to sweep, so the
+    // removal leaves the to-do entry that says so.
+    expect(await contribution.listDeletedBotIds()).toEqual(["alpha"]);
+    await contribution.forgetDeletedBot("alpha");
+    expect(await contribution.listDeletedBotIds()).toEqual([]);
+    // Replaying the command settles from the stored receipt rather than
+    // reporting a Bot that is no longer registered.
+    expect(await contribution.executeLifecycle("user-1", remove)).toEqual(
+      applied,
+    );
+    // A fresh delete of a Bot that is already gone is a plain 404.
+    await expect(
+      contribution.executeLifecycle("user-1", {
+        ...remove,
+        commandId: "delete-2",
+      }),
+    ).rejects.toThrow('Bot "alpha" is not registered');
+  });
+
+  test("finishes a half-done delete from the User alarm", async () => {
+    const storage = new MemoryStorage();
+    // The Bot tore itself down but the reply never arrived, so the saga is the
+    // only thing that knows the registration still has to go.
+    const contribution = createFlockUserBackendContribution({
+      storage,
+      commandBotLifecycle: () => Promise.reject(new Error("response lost")),
+      readBotLifecycle: (_userId, botId) =>
+        Promise.resolve({
+          schemaVersion: 1,
+          botId,
+          status: "deleted",
+          revision: 1,
+        }),
+    });
+    await contribution.createBot("user-1", command());
+    const failing = createFlockUserBackendContribution({
+      storage,
+      commandBotLifecycle: () => Promise.reject(new Error("response lost")),
+      readBotLifecycle: () => Promise.reject(new Error("Bot unavailable")),
+    });
+    expect(
+      await failing.executeLifecycle("user-1", {
+        schemaVersion: 1,
+        type: "bot/delete",
+        commandId: "delete-alarm",
+        botId: "alpha",
+      }),
+    ).toMatchObject({ status: "pending" });
+    expect((await contribution.listBots()).bots).toHaveLength(1);
+    await contribution.alarm();
+    expect((await contribution.listBots()).bots).toEqual([]);
+    expect(await contribution.listDeletedBotIds()).toEqual(["alpha"]);
+  });
+
   test("reconciles uncorrelated, pending, and wrong-target Bot replies", async () => {
     for (const variant of [
       "wrong-command",

package/src/user.ts

@@ -11,6 +11,7 @@ import {
   decodeStoredBotLifecycleReceiptV1,
   decodeStoredFlockReceiptV1,
   flockCommandFingerprint,
+  lifecycleTargetStatusV1,
   migrateStoredBotDirectoryV1,
   randomSheepRecipeV1,
   type BotDirectoryViewV1,
@@ -30,6 +31,18 @@ const LIFECYCLE_PREFIX = "flock:lifecycle:";
 const LIFECYCLE_RECEIPT_PREFIX = "flock:lifecycle-receipt:";
 const LIFECYCLE_SAGA_PREFIX = "flock:lifecycle-saga:";
 const LIFECYCLE_OPERATION_PREFIX = "flock:lifecycle-operation:";
+/**
+ * One key per Bot whose registration this object has removed, and whose
+ * User-scoped projections — the transcript index and the audit table — have
+ * not yet been swept.
+ *
+ * The saga can settle a delete on its alarm rather than on the command that
+ * started it, and the projections live outside this Package. Without a durable
+ * to-do list the sweep would be lost with the call that missed it, so the
+ * removal writes one and the application clears it once the projections are
+ * gone.
+ */
+const DELETED_PREFIX = "flock:deleted:";
 export interface FlockUserTransaction {
   get<T>(key: string): Promise<T | undefined>;
   put<T>(key: string, value: T): Promise<void>;
@@ -207,6 +220,53 @@ export class FlockUserBackendContribution {
     });
   }
 
+  /**
+   * Drops one Bot out of the directory and out of the lifecycle projection,
+   * and records that its User-scoped projections still need sweeping.
+   *
+   * Idempotent by construction: a directory that no longer holds the Bot is
+   * left at its current revision, and both deletes and the tombstone write are
+   * safe to repeat.
+   */
+  private async removeRegistration(
+    storage: FlockUserTransaction,
+    botId: string,
+  ): Promise<void> {
+    const currentValue = await storage.get<unknown>(DIRECTORY_KEY);
+    const current =
+      currentValue === undefined
+        ? initialDirectory()
+        : decodeDirectoryViewV1(migrateStoredBotDirectoryV1(currentValue));
+    if (current.bots.some((bot) => bot.botId === botId)) {
+      await storage.put(DIRECTORY_KEY, {
+        ...current,
+        revision: current.revision + 1,
+        bots: current.bots.filter((bot) => bot.botId !== botId),
+      } satisfies BotDirectoryViewV1);
+    }
+    await storage.delete(`${LIFECYCLE_PREFIX}${botId}`);
+    await storage.put(`${DELETED_PREFIX}${botId}`, {
+      schemaVersion: 1,
+      botId,
+    });
+  }
+
+  /**
+   * Bots whose registration is gone but whose User-scoped projections have not
+   * been swept yet. The application sweeps and then calls `forgetDeletedBot`.
+   */
+  async listDeletedBotIds(): Promise<string[]> {
+    const entries = await this.host.storage.list<unknown>({
+      prefix: DELETED_PREFIX,
+    });
+    return [...entries.keys()].map((key) => key.slice(DELETED_PREFIX.length));
+  }
+
+  /** The sweep is done; drop the to-do entry. */
+  async forgetDeletedBot(botId: string): Promise<void> {
+    await this.host.storage.delete(`${DELETED_PREFIX}${botId}`);
+  }
+
   async listBotLifecycles(): Promise<BotLifecycleDirectoryViewV1> {
     const directory = await this.listBots();
     const lifecycles = await Promise.all(
@@ -317,7 +377,7 @@ export class FlockUserBackendContribution {
       return decodeStoredBotLifecycleReceiptV1(receipt).receipt;
     }
     const saga = decodeStoredLifecycleSagaV1(sagaValue);
-    const target = saga.command.type === "bot/archive" ? "archived" : "active";
+    const target = lifecycleTargetStatusV1(saga.command.type);
     let outcome: BotLifecycleReceiptV1 | undefined;
     let reconcileMarker = false;
     try {
@@ -383,12 +443,21 @@ export class FlockUserBackendContribution {
       const currentSaga = decodeStoredLifecycleSagaV1(currentSagaValue);
       if (currentSaga.fingerprint !== saga.fingerprint)
         throw new FlockDecodeError(`command ID collision: ${commandId}`);
-      await storage.put({
-        [`${LIFECYCLE_PREFIX}${saga.command.botId}`]: outcome!.lifecycle,
-        [`${LIFECYCLE_RECEIPT_PREFIX}${commandId}`]: {
-          fingerprint: saga.fingerprint,
-          receipt: outcome,
-        },
+      if (outcome!.lifecycle.status === "deleted") {
+        // The Bot has torn itself down, so the registration leaves the
+        // directory in the same transaction that settles the receipt: the
+        // sidebar, every fan-out and the debug surface all read the directory,
+        // and none of them may see a Bot whose history is already gone.
+        await this.removeRegistration(storage, saga.command.botId);
+      } else {
+        await storage.put(
+          `${LIFECYCLE_PREFIX}${saga.command.botId}`,
+          outcome!.lifecycle,
+        );
+      }
+      await storage.put(`${LIFECYCLE_RECEIPT_PREFIX}${commandId}`, {
+        fingerprint: saga.fingerprint,
+        receipt: outcome,
       });
       await storage.delete(`${LIFECYCLE_SAGA_PREFIX}${commandId}`);
       await storage.delete(