@wopr-network/platform-core 1.35.0 → 1.35.1

package/dist/trpc/admin-fleet-update-router.test.js

@@ -0,0 +1,164 @@
+import { beforeEach, describe, expect, it, vi } from "vitest";
+import { createAdminFleetUpdateRouter } from "./admin-fleet-update-router.js";
+import { createCallerFactory, router, setTrpcOrgMemberRepo } from "./init.js";
+vi.mock("../config/logger.js", () => ({
+    logger: {
+        info: vi.fn(),
+        error: vi.fn(),
+        warn: vi.fn(),
+        debug: vi.fn(),
+    },
+}));
+// ---------------------------------------------------------------------------
+// Helpers
+// ---------------------------------------------------------------------------
+function makeMockOrgRepo() {
+    return {
+        listMembers: vi.fn().mockResolvedValue([]),
+        addMember: vi.fn().mockResolvedValue(undefined),
+        updateMemberRole: vi.fn().mockResolvedValue(undefined),
+        removeMember: vi.fn().mockResolvedValue(undefined),
+        findMember: vi.fn().mockResolvedValue(null),
+        countAdminsAndOwners: vi.fn().mockResolvedValue(0),
+        listInvites: vi.fn().mockResolvedValue([]),
+        createInvite: vi.fn().mockResolvedValue(undefined),
+        findInviteById: vi.fn().mockResolvedValue(null),
+        findInviteByToken: vi.fn().mockResolvedValue(null),
+        deleteInvite: vi.fn().mockResolvedValue(undefined),
+        deleteAllMembers: vi.fn().mockResolvedValue(undefined),
+        deleteAllInvites: vi.fn().mockResolvedValue(undefined),
+        listOrgsByUser: vi.fn().mockResolvedValue([]),
+        markInviteAccepted: vi.fn().mockResolvedValue(undefined),
+    };
+}
+function makeOrchestrator(overrides = {}) {
+    return {
+        isRolling: false,
+        rollout: vi.fn().mockResolvedValue({
+            totalBots: 0,
+            succeeded: 0,
+            failed: 0,
+            skipped: 0,
+            aborted: false,
+            alreadyRunning: false,
+            results: [],
+        }),
+        ...overrides,
+    };
+}
+function makeConfigRepo(configs = {}) {
+    return {
+        get: vi.fn().mockImplementation((tenantId) => Promise.resolve(configs[tenantId] ?? null)),
+        upsert: vi.fn().mockResolvedValue(undefined),
+        listAutoEnabled: vi.fn().mockResolvedValue(Object.values(configs)),
+    };
+}
+const adminCtx = {
+    user: { id: "admin-1", roles: ["platform_admin"] },
+    tenantId: undefined,
+};
+// ---------------------------------------------------------------------------
+// Tests
+// ---------------------------------------------------------------------------
+describe("createAdminFleetUpdateRouter", () => {
+    let orchestrator;
+    let configRepo;
+    beforeEach(() => {
+        setTrpcOrgMemberRepo(makeMockOrgRepo());
+        orchestrator = makeOrchestrator();
+        configRepo = makeConfigRepo();
+    });
+    function makeCaller() {
+        const fleetRouter = createAdminFleetUpdateRouter(() => orchestrator, () => configRepo);
+        const appRouter = router({ fleet: fleetRouter });
+        const createCaller = createCallerFactory(appRouter);
+        return createCaller(adminCtx);
+    }
+    describe("rolloutStatus", () => {
+        it("returns isRolling from orchestrator (false)", async () => {
+            const caller = makeCaller();
+            const status = await caller.fleet.rolloutStatus();
+            expect(status).toEqual({ isRolling: false });
+        });
+        it("returns isRolling from orchestrator (true)", async () => {
+            orchestrator = makeOrchestrator({ isRolling: true });
+            const caller = makeCaller();
+            const status = await caller.fleet.rolloutStatus();
+            expect(status).toEqual({ isRolling: true });
+        });
+    });
+    describe("forceRollout", () => {
+        it("calls orchestrator.rollout()", async () => {
+            const caller = makeCaller();
+            const result = await caller.fleet.forceRollout();
+            expect(result).toEqual({ triggered: true });
+            expect(orchestrator.rollout).toHaveBeenCalledOnce();
+        });
+    });
+    describe("listTenantConfigs", () => {
+        it("delegates to repo.listAutoEnabled()", async () => {
+            const configs = [
+                { tenantId: "t1", mode: "auto", preferredHourUtc: 3, updatedAt: Date.now() },
+                { tenantId: "t2", mode: "auto", preferredHourUtc: 12, updatedAt: Date.now() },
+            ];
+            vi.mocked(configRepo.listAutoEnabled).mockResolvedValue(configs);
+            const caller = makeCaller();
+            const result = await caller.fleet.listTenantConfigs();
+            expect(configRepo.listAutoEnabled).toHaveBeenCalledOnce();
+            expect(result).toEqual(configs);
+        });
+    });
+    describe("setTenantConfig", () => {
+        it("preserves existing preferredHourUtc when not provided", async () => {
+            const existing = {
+                tenantId: "t1",
+                mode: "auto",
+                preferredHourUtc: 17,
+                updatedAt: Date.now(),
+            };
+            vi.mocked(configRepo.get).mockResolvedValue(existing);
+            const caller = makeCaller();
+            await caller.fleet.setTenantConfig({ tenantId: "t1", mode: "manual" });
+            expect(configRepo.get).toHaveBeenCalledWith("t1");
+            expect(configRepo.upsert).toHaveBeenCalledWith("t1", {
+                mode: "manual",
+                preferredHourUtc: 17, // preserved from existing
+            });
+        });
+        it("uses provided preferredHourUtc when given", async () => {
+            const existing = {
+                tenantId: "t1",
+                mode: "auto",
+                preferredHourUtc: 17,
+                updatedAt: Date.now(),
+            };
+            vi.mocked(configRepo.get).mockResolvedValue(existing);
+            const caller = makeCaller();
+            await caller.fleet.setTenantConfig({
+                tenantId: "t1",
+                mode: "auto",
+                preferredHourUtc: 9,
+            });
+            expect(configRepo.upsert).toHaveBeenCalledWith("t1", {
+                mode: "auto",
+                preferredHourUtc: 9,
+            });
+        });
+        it("defaults to 3 when no existing config and preferredHourUtc not provided", async () => {
+            vi.mocked(configRepo.get).mockResolvedValue(null);
+            const caller = makeCaller();
+            await caller.fleet.setTenantConfig({ tenantId: "t-new", mode: "auto" });
+            expect(configRepo.upsert).toHaveBeenCalledWith("t-new", {
+                mode: "auto",
+                preferredHourUtc: 3, // default
+            });
+        });
+    });
+    it("rejects non-admin users", async () => {
+        const fleetRouter = createAdminFleetUpdateRouter(() => orchestrator, () => configRepo);
+        const appRouter = router({ fleet: fleetRouter });
+        const createCaller = createCallerFactory(appRouter);
+        const caller = createCaller({ user: { id: "u1", roles: ["user"] }, tenantId: undefined });
+        await expect(caller.fleet.rolloutStatus()).rejects.toThrow("Platform admin role required");
+    });
+});

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@wopr-network/platform-core",
-  "version": "1.35.0",
+  "version": "1.35.1",
   "type": "module",
   "main": "dist/index.js",
   "types": "dist/index.d.ts",

package/src/email/handlebars-renderer.test.ts

@@ -0,0 +1,209 @@
+import { describe, expect, it, vi } from "vitest";
+import { HandlebarsRenderer } from "./handlebars-renderer.js";
+import type { INotificationTemplateRepository, NotificationTemplateRow } from "./notification-repository-types.js";
+
+// ---------------------------------------------------------------------------
+// Helpers
+// ---------------------------------------------------------------------------
+
+function makeTemplate(overrides: Partial<NotificationTemplateRow> = {}): NotificationTemplateRow {
+  return {
+    id: "tpl-1",
+    name: "test-template",
+    description: "A test template",
+    subject: "Hello {{name}}",
+    htmlBody: "<h1>Hello {{name}}</h1>",
+    textBody: "Hello {{name}}",
+    active: true,
+    createdAt: Date.now(),
+    updatedAt: Date.now(),
+    ...overrides,
+  };
+}
+
+function makeRepo(templates: Record<string, NotificationTemplateRow | null> = {}): INotificationTemplateRepository {
+  return {
+    getByName: vi.fn().mockImplementation((name: string) => Promise.resolve(templates[name] ?? null)),
+    list: vi.fn().mockResolvedValue(Object.values(templates).filter(Boolean)),
+    upsert: vi.fn().mockResolvedValue(undefined),
+  } as unknown as INotificationTemplateRepository;
+}
+
+// ---------------------------------------------------------------------------
+// Tests
+// ---------------------------------------------------------------------------
+
+describe("HandlebarsRenderer", () => {
+  it("returns null for unknown template", async () => {
+    const repo = makeRepo({});
+    const renderer = new HandlebarsRenderer(repo);
+
+    const result = await renderer.render("nonexistent", { name: "World" });
+
+    expect(result).toBeNull();
+    expect(repo.getByName).toHaveBeenCalledWith("nonexistent");
+  });
+
+  it("returns null for inactive template", async () => {
+    const repo = makeRepo({
+      "inactive-tpl": makeTemplate({ name: "inactive-tpl", active: false }),
+    });
+    const renderer = new HandlebarsRenderer(repo);
+
+    const result = await renderer.render("inactive-tpl", { name: "World" });
+
+    expect(result).toBeNull();
+  });
+
+  it("compiles Handlebars and returns subject/html/text", async () => {
+    const repo = makeRepo({
+      greeting: makeTemplate({
+        name: "greeting",
+        subject: "Hi {{name}}!",
+        htmlBody: "<p>Welcome, {{name}}!</p>",
+        textBody: "Welcome, {{name}}!",
+      }),
+    });
+    const renderer = new HandlebarsRenderer(repo);
+
+    const result = await renderer.render("greeting", { name: "Alice" });
+
+    expect(result).not.toBeNull();
+    expect(result?.subject).toBe("Hi Alice!");
+    expect(result?.html).toBe("<p>Welcome, Alice!</p>");
+    expect(result?.text).toBe("Welcome, Alice!");
+  });
+
+  it("injects currentYear automatically", async () => {
+    const repo = makeRepo({
+      footer: makeTemplate({
+        name: "footer",
+        subject: "Year: {{currentYear}}",
+        htmlBody: "<p>&copy; {{currentYear}}</p>",
+        textBody: "(c) {{currentYear}}",
+      }),
+    });
+    const renderer = new HandlebarsRenderer(repo);
+
+    const result = await renderer.render("footer", {});
+
+    const year = new Date().getFullYear();
+    expect(result?.subject).toBe(`Year: ${year}`);
+    expect(result?.html).toBe(`<p>&copy; ${year}</p>`);
+    expect(result?.text).toBe(`(c) ${year}`);
+  });
+
+  it("does not override explicit currentYear from data", async () => {
+    const repo = makeRepo({
+      footer: makeTemplate({
+        name: "footer",
+        subject: "Year: {{currentYear}}",
+        htmlBody: "<p>{{currentYear}}</p>",
+        textBody: "{{currentYear}}",
+      }),
+    });
+    const renderer = new HandlebarsRenderer(repo);
+
+    const result = await renderer.render("footer", { currentYear: 2099 });
+
+    expect(result?.subject).toBe("Year: 2099");
+  });
+
+  describe("helpers", () => {
+    it("eq helper returns true for equal values", async () => {
+      const repo = makeRepo({
+        cond: makeTemplate({
+          name: "cond",
+          subject: '{{#if (eq status "active")}}Active{{else}}Inactive{{/if}}',
+          htmlBody: "ok",
+          textBody: "ok",
+        }),
+      });
+      const renderer = new HandlebarsRenderer(repo);
+
+      const active = await renderer.render("cond", { status: "active" });
+      expect(active?.subject).toBe("Active");
+
+      const inactive = await renderer.render("cond", { status: "disabled" });
+      expect(inactive?.subject).toBe("Inactive");
+    });
+
+    it("gt helper compares numbers", async () => {
+      const repo = makeRepo({
+        gt: makeTemplate({
+          name: "gt",
+          subject: "{{#if (gt count 5)}}Many{{else}}Few{{/if}}",
+          htmlBody: "ok",
+          textBody: "ok",
+        }),
+      });
+      const renderer = new HandlebarsRenderer(repo);
+
+      const many = await renderer.render("gt", { count: 10 });
+      expect(many?.subject).toBe("Many");
+
+      const few = await renderer.render("gt", { count: 3 });
+      expect(few?.subject).toBe("Few");
+    });
+
+    it("formatDate helper formats timestamps", async () => {
+      const repo = makeRepo({
+        dated: makeTemplate({
+          name: "dated",
+          subject: "Date: {{formatDate ts}}",
+          htmlBody: "ok",
+          textBody: "ok",
+        }),
+      });
+      const renderer = new HandlebarsRenderer(repo);
+
+      // Use noon UTC to avoid timezone date-boundary shifts
+      const ts = new Date("2025-01-15T12:00:00Z").getTime();
+      const result = await renderer.render("dated", { ts });
+
+      // The formatted string uses en-US locale with year/month/day
+      const expected = new Date(ts).toLocaleDateString("en-US", {
+        year: "numeric",
+        month: "long",
+        day: "numeric",
+      });
+      expect(result?.subject).toBe(`Date: ${expected}`);
+    });
+
+    it("formatDate helper passes through non-numeric values", async () => {
+      const repo = makeRepo({
+        dated: makeTemplate({
+          name: "dated",
+          subject: "Date: {{formatDate ts}}",
+          htmlBody: "ok",
+          textBody: "ok",
+        }),
+      });
+      const renderer = new HandlebarsRenderer(repo);
+
+      const result = await renderer.render("dated", { ts: "not-a-number" });
+
+      expect(result?.subject).toBe("Date: not-a-number");
+    });
+
+    it("escapeHtml helper escapes special characters", async () => {
+      const repo = makeRepo({
+        esc: makeTemplate({
+          name: "esc",
+          subject: "Safe: {{escapeHtml input}}",
+          htmlBody: "ok",
+          textBody: "ok",
+        }),
+      });
+      const renderer = new HandlebarsRenderer(repo);
+
+      const result = await renderer.render("esc", {
+        input: '<script>alert("xss")</script>',
+      });
+
+      expect(result?.subject).toContain("&lt;script&gt;");
+      expect(result?.subject).toContain("&quot;xss&quot;");
+      expect(result?.subject).not.toContain("<script>");
+    });
+  });
+});

package/src/fleet/fleet-notification-listener.test.ts

@@ -0,0 +1,322 @@
+import { afterEach, beforeEach, describe, expect, it, vi } from "vitest";
+import type { INotificationPreferencesRepository, NotificationPrefs } from "../email/notification-repository-types.js";
+import type { NotificationService } from "../email/notification-service.js";
+import type { BotFleetEvent } from "./fleet-event-emitter.js";
+import { FleetEventEmitter } from "./fleet-event-emitter.js";
+import { initFleetNotificationListener } from "./fleet-notification-listener.js";
+
+vi.mock("../config/logger.js", () => ({
+  logger: {
+    info: vi.fn(),
+    error: vi.fn(),
+    warn: vi.fn(),
+    debug: vi.fn(),
+  },
+}));
+
+// ---------------------------------------------------------------------------
+// Helpers
+// ---------------------------------------------------------------------------
+
+const DEBOUNCE_MS = 100;
+
+function makePrefs(overrides: Partial<NotificationPrefs> = {}): NotificationPrefs {
+  return {
+    billing_low_balance: true,
+    billing_receipts: true,
+    billing_auto_topup: true,
+    agent_channel_disconnect: true,
+    agent_status_changes: false,
+    account_role_changes: true,
+    account_team_invites: true,
+    fleet_updates: true,
+    ...overrides,
+  };
+}
+
+function makePrefsRepo(prefs: NotificationPrefs = makePrefs()): INotificationPreferencesRepository {
+  return {
+    get: vi.fn().mockResolvedValue(prefs),
+    update: vi.fn().mockResolvedValue(undefined),
+  } as unknown as INotificationPreferencesRepository;
+}
+
+function makeNotificationService(): NotificationService {
+  return {
+    notifyFleetUpdateComplete: vi.fn(),
+    notifyFleetUpdateAvailable: vi.fn(),
+    notifyLowBalance: vi.fn(),
+  } as unknown as NotificationService;
+}
+
+function botUpdated(tenantId: string, version = "v1.2.0"): BotFleetEvent {
+  return {
+    type: "bot.updated",
+    botId: `bot-${Math.random().toString(36).slice(2, 6)}`,
+    tenantId,
+    timestamp: new Date().toISOString(),
+    version,
+  };
+}
+
+function botUpdateFailed(tenantId: string, version = "v1.2.0"): BotFleetEvent {
+  return {
+    type: "bot.update_failed",
+    botId: `bot-${Math.random().toString(36).slice(2, 6)}`,
+    tenantId,
+    timestamp: new Date().toISOString(),
+    version,
+  };
+}
+
+// ---------------------------------------------------------------------------
+// Tests
+// ---------------------------------------------------------------------------
+
+describe("initFleetNotificationListener", () => {
+  let emitter: FleetEventEmitter;
+
+  beforeEach(() => {
+    vi.useFakeTimers();
+    emitter = new FleetEventEmitter();
+  });
+
+  afterEach(() => {
+    vi.useRealTimers();
+  });
+
+  it("ignores non-bot events (node events)", async () => {
+    const notificationService = makeNotificationService();
+    const preferences = makePrefsRepo();
+
+    initFleetNotificationListener({
+      eventEmitter: emitter,
+      notificationService,
+      preferences,
+      resolveEmail: vi.fn().mockResolvedValue("user@example.com"),
+      debounceMs: DEBOUNCE_MS,
+    });
+
+    emitter.emit({
+      type: "node.provisioned",
+      nodeId: "node-1",
+      timestamp: new Date().toISOString(),
+    });
+
+    await vi.advanceTimersByTimeAsync(DEBOUNCE_MS + 50);
+
+    expect(notificationService.notifyFleetUpdateComplete).not.toHaveBeenCalled();
+  });
+
+  it("ignores non-update bot events (bot.started, bot.stopped)", async () => {
+    const notificationService = makeNotificationService();
+    const preferences = makePrefsRepo();
+
+    initFleetNotificationListener({
+      eventEmitter: emitter,
+      notificationService,
+      preferences,
+      resolveEmail: vi.fn().mockResolvedValue("user@example.com"),
+      debounceMs: DEBOUNCE_MS,
+    });
+
+    emitter.emit({
+      type: "bot.started",
+      botId: "bot-1",
+      tenantId: "t1",
+      timestamp: new Date().toISOString(),
+    });
+
+    emitter.emit({
+      type: "bot.stopped",
+      botId: "bot-2",
+      tenantId: "t1",
+      timestamp: new Date().toISOString(),
+    });
+
+    await vi.advanceTimersByTimeAsync(DEBOUNCE_MS + 50);
+
+    expect(notificationService.notifyFleetUpdateComplete).not.toHaveBeenCalled();
+  });
+
+  it("aggregates multiple bot.updated events per tenant into one notification", async () => {
+    const notificationService = makeNotificationService();
+    const preferences = makePrefsRepo();
+    const resolveEmail = vi.fn().mockResolvedValue("owner@example.com");
+
+    initFleetNotificationListener({
+      eventEmitter: emitter,
+      notificationService,
+      preferences,
+      resolveEmail,
+      debounceMs: DEBOUNCE_MS,
+    });
+
+    // Emit 3 successful updates for the same tenant
+    emitter.emit(botUpdated("t1", "v2.0.0"));
+    emitter.emit(botUpdated("t1", "v2.0.0"));
+    emitter.emit(botUpdated("t1", "v2.0.0"));
+
+    // No notification yet — debounce hasn't fired
+    expect(notificationService.notifyFleetUpdateComplete).not.toHaveBeenCalled();
+
+    await vi.advanceTimersByTimeAsync(DEBOUNCE_MS + 50);
+
+    expect(notificationService.notifyFleetUpdateComplete).toHaveBeenCalledOnce();
+    expect(notificationService.notifyFleetUpdateComplete).toHaveBeenCalledWith(
+      "t1",
+      "owner@example.com",
+      "v2.0.0",
+      3, // succeeded
+      0, // failed
+    );
+  });
+
+  it("sends summary with correct succeeded/failed counts after debounce", async () => {
+    const notificationService = makeNotificationService();
+    const preferences = makePrefsRepo();
+    const resolveEmail = vi.fn().mockResolvedValue("owner@example.com");
+
+    initFleetNotificationListener({
+      eventEmitter: emitter,
+      notificationService,
+      preferences,
+      resolveEmail,
+      debounceMs: DEBOUNCE_MS,
+    });
+
+    emitter.emit(botUpdated("t1", "v3.0.0"));
+    emitter.emit(botUpdated("t1", "v3.0.0"));
+    emitter.emit(botUpdateFailed("t1", "v3.0.0"));
+
+    await vi.advanceTimersByTimeAsync(DEBOUNCE_MS + 50);
+
+    expect(notificationService.notifyFleetUpdateComplete).toHaveBeenCalledWith(
+      "t1",
+      "owner@example.com",
+      "v3.0.0",
+      2, // succeeded
+      1, // failed
+    );
+  });
+
+  it("updates version from subsequent events", async () => {
+    const notificationService = makeNotificationService();
+    const preferences = makePrefsRepo();
+    const resolveEmail = vi.fn().mockResolvedValue("owner@example.com");
+
+    initFleetNotificationListener({
+      eventEmitter: emitter,
+      notificationService,
+      preferences,
+      resolveEmail,
+      debounceMs: DEBOUNCE_MS,
+    });
+
+    // First event has v1.0.0, subsequent event changes to v1.1.0
+    emitter.emit(botUpdated("t1", "v1.0.0"));
+    emitter.emit(botUpdated("t1", "v1.1.0"));
+
+    await vi.advanceTimersByTimeAsync(DEBOUNCE_MS + 50);
+
+    expect(notificationService.notifyFleetUpdateComplete).toHaveBeenCalledWith(
+      "t1",
+      "owner@example.com",
+      "v1.1.0", // updated to latest version
+      2,
+      0,
+    );
+  });
+
+  it("checks fleet_updates preference — skips if disabled", async () => {
+    const notificationService = makeNotificationService();
+    const preferences = makePrefsRepo(makePrefs({ fleet_updates: false }));
+    const resolveEmail = vi.fn().mockResolvedValue("owner@example.com");
+
+    initFleetNotificationListener({
+      eventEmitter: emitter,
+      notificationService,
+      preferences,
+      resolveEmail,
+      debounceMs: DEBOUNCE_MS,
+    });
+
+    emitter.emit(botUpdated("t1"));
+
+    await vi.advanceTimersByTimeAsync(DEBOUNCE_MS + 50);
+
+    expect(preferences.get).toHaveBeenCalledWith("t1");
+    expect(notificationService.notifyFleetUpdateComplete).not.toHaveBeenCalled();
+  });
+
+  it("skips if email resolver returns null", async () => {
+    const notificationService = makeNotificationService();
+    const preferences = makePrefsRepo();
+    const resolveEmail = vi.fn().mockResolvedValue(null);
+
+    initFleetNotificationListener({
+      eventEmitter: emitter,
+      notificationService,
+      preferences,
+      resolveEmail,
+      debounceMs: DEBOUNCE_MS,
+    });
+
+    emitter.emit(botUpdated("t1"));
+
+    await vi.advanceTimersByTimeAsync(DEBOUNCE_MS + 50);
+
+    expect(resolveEmail).toHaveBeenCalledWith("t1");
+    expect(notificationService.notifyFleetUpdateComplete).not.toHaveBeenCalled();
+  });
+
+  it("async shutdown flushes pending notifications", async () => {
+    const notificationService = makeNotificationService();
+    const preferences = makePrefsRepo();
+    const resolveEmail = vi.fn().mockResolvedValue("owner@example.com");
+
+    const shutdown = initFleetNotificationListener({
+      eventEmitter: emitter,
+      notificationService,
+      preferences,
+      resolveEmail,
+      debounceMs: DEBOUNCE_MS,
+    });
+
+    emitter.emit(botUpdated("t1", "v5.0.0"));
+    emitter.emit(botUpdated("t2", "v5.0.0"));
+
+    // Don't advance timers — flush via shutdown instead
+    await shutdown();
+
+    // Both tenants should have been flushed
+    expect(notificationService.notifyFleetUpdateComplete).toHaveBeenCalledTimes(2);
+
+    const calls = vi.mocked(notificationService.notifyFleetUpdateComplete).mock.calls;
+    const tenantIds = calls.map((c) => c[0]);
+    expect(tenantIds).toContain("t1");
+    expect(tenantIds).toContain("t2");
+  });
+
+  it("no further events after shutdown", async () => {
+    const notificationService = makeNotificationService();
+    const preferences = makePrefsRepo();
+    const resolveEmail = vi.fn().mockResolvedValue("owner@example.com");
+
+    const shutdown = initFleetNotificationListener({
+      eventEmitter: emitter,
+      notificationService,
+      preferences,
+      resolveEmail,
+      debounceMs: DEBOUNCE_MS,
+    });
+
+    await shutdown();
+
+    // Events after shutdown should not trigger anything
+    emitter.emit(botUpdated("t1"));
+    await vi.advanceTimersByTimeAsync(DEBOUNCE_MS + 50);
+
+    expect(notificationService.notifyFleetUpdateComplete).not.toHaveBeenCalled();
+  });
+});