@desplega.ai/agent-swarm 2.4.4 → 2.5.0

package/src/tasks/task-terminal-effects.ts

@@ -16,7 +16,7 @@
  */
 
 import { getSessionLogsByTaskId } from "@/be/db";
-import { getEmbeddingProvider, getMemoryStore } from "@/be/memory";
+import { indexMemoryContent, taskCompletionMemoryKey } from "@/be/memory/index-content";
 import { getRetrievalsForTask } from "@/be/memory/raters/retrieval";
 import { runServerRaters } from "@/be/memory/raters/run-server-raters";
 import { shouldPersistTaskCompletionMemory } from "@/memory/automatic-task-gate";
@@ -55,21 +55,22 @@ export async function runTaskTerminalEffects(args: {
         // Skip indexing if there's truly no content
         if (taskContent.length < 30) return;
 
-        const store = getMemoryStore();
-        const provider = getEmbeddingProvider();
-
-        const memory = await store.store({
+        // Same path as memory-store: chunk, store, and embed each chunk, so a
+        // long output never meets the embedding model's input cap. The per-task
+        // key makes the chunks one document, like a keyed manual memory, and a
+        // repeat write for the task replaces that document atomically.
+        const key = taskCompletionMemoryKey(taskId);
+        await indexMemoryContent({
           agentId: agentId ?? null,
           content: taskContent,
           name: `Task: ${safeTask.slice(0, 80)}`,
           scope: "agent",
           source: "task_completion",
           sourceTaskId: taskId,
+          key,
+          intent: "task completion memory",
+          replaceExisting: true,
         });
-        const embedding = await provider.embed(taskContent);
-        if (embedding) {
-          await store.updateEmbedding(memory.id, embedding, provider.name);
-        }
 
         // Auto-promote high-value completions to swarm memory (P3)
         const shouldShareWithSwarm =
@@ -80,24 +81,27 @@ export async function runTaskTerminalEffects(args: {
 
         if (shouldShareWithSwarm) {
           try {
-            const swarmMemory = await store.store({
+            await indexMemoryContent({
               agentId: agentId ?? null,
-              scope: "swarm",
-              name: `Shared: ${safeTask.slice(0, 80)}`,
               content: `Task completed by agent ${agentId}:\n\n${taskContent}`,
+              name: `Shared: ${safeTask.slice(0, 80)}`,
+              scope: "swarm",
               source: "task_completion",
               sourceTaskId: taskId,
+              key,
+              intent: "task completion memory",
+              replaceExisting: true,
             });
-            const swarmEmbedding = await provider.embed(taskContent);
-            if (swarmEmbedding) {
-              await store.updateEmbedding(swarmMemory.id, swarmEmbedding, provider.name);
-            }
           } catch {
             // Non-blocking — swarm memory promotion failure is not critical
           }
         }
-      } catch {
+      } catch (err) {
         // Non-blocking — task completion memory failure should not affect task status
+        console.error(
+          "[task-terminal-effects] task completion memory write failed:",
+          scrubSecrets(err instanceof Error ? err.message : String(err)),
+        );
       }
     })().catch((err) =>
       console.error(

package/src/tests/apps-card-grid.test.ts

@@ -0,0 +1,197 @@
+import { describe, expect, test } from "bun:test";
+import { parseAppDefinition } from "../apps/definition";
+
+/**
+ * Validator coverage for `CardGrid` and the Table column `format` template.
+ * Pure `parseAppDefinition` calls — no DB, no HTTP — mirroring
+ * `apps-catalog-additions.test.ts`.
+ */
+
+type Element = { type: string; props?: Record<string, unknown>; children?: string[] };
+
+function appWith(elements: Record<string, Element>) {
+  return {
+    models: {
+      doc: {
+        columns: {
+          title: { kind: "string", required: true },
+          author: { kind: "string" },
+          cover: { kind: "string" },
+          status: { kind: "enum", enum: ["draft", "published"], default: "draft" },
+        },
+      },
+    },
+    queries: {
+      docs: { model: "doc" },
+      docById: { model: "doc", filter: { id: { $param: "doc" } } },
+    },
+    pages: {
+      main: { title: "Main", root: "root", elements },
+      detail: {
+        title: "Detail",
+        params: { doc: { kind: "string" }, position: { kind: "number" } },
+        root: "detailRoot",
+        elements: { detailRoot: { type: "Text", props: { content: "Detail" } } },
+      },
+    },
+    defaultPage: "main",
+  };
+}
+
+async function issuesFor(input: unknown) {
+  const parsed = await parseAppDefinition(input);
+  return parsed.success ? [] : parsed.issues;
+}
+
+const el = (id: string) => `pages.main.elements.${id}`;
+
+function cardGrid(props: Record<string, unknown>) {
+  return appWith({
+    root: { type: "Stack", props: {}, children: ["cards"] },
+    cards: {
+      type: "CardGrid",
+      props: {
+        data: { $state: "/queries/docs/data" },
+        loading: { $state: "/queries/docs/loading" },
+        error: { $state: "/queries/docs/error" },
+        titleKey: "title",
+        ...props,
+      },
+    },
+  });
+}
+
+const navigateToDetail = [
+  { action: "app.navigate", params: { page: "detail", params: { doc: { $row: "id" } } } },
+];
+
+describe("CardGrid", () => {
+  test("onClick running app.navigate to a declared page with $row params passes", async () => {
+    const issues = await issuesFor(
+      cardGrid({
+        imageKey: "cover",
+        fields: [
+          { key: "author" },
+          { key: "createdAt", kind: "date" },
+          { key: "status", kind: "badge", tones: { published: "success" } },
+        ],
+        columns: { base: 1, md: 2, lg: 4 },
+        emptyMessage: "No documents yet",
+        onClick: navigateToDetail,
+      }),
+    );
+    if (issues.length > 0) console.error(issues);
+    expect(issues).toEqual([]);
+  });
+
+  test("$row and $rowIndex are accepted inside the onClick chain", async () => {
+    const issues = await issuesFor(
+      cardGrid({
+        onClick: [
+          { action: "app.refresh", params: { query: "docs" } },
+          {
+            action: "app.navigate",
+            params: {
+              page: "detail",
+              params: { doc: { $row: "id" }, position: { $rowIndex: true } },
+            },
+          },
+        ],
+      }),
+    );
+    if (issues.length > 0) console.error(issues);
+    expect(issues).toEqual([]);
+  });
+
+  test("$row outside the onClick chain is rejected", async () => {
+    const issues = await issuesFor(cardGrid({ emptyMessage: { $row: "title" } }));
+    expect(issues).toContainEqual({
+      path: `${el("cards")}.props.emptyMessage`,
+      message: "$row, $rowIndex, $form, and $chain bindings are only allowed in action params",
+    });
+  });
+
+  test("onClick naming an unknown action fails", async () => {
+    const issues = await issuesFor(cardGrid({ onClick: [{ action: "app.nope", params: {} }] }));
+    expect(issues).toContainEqual({
+      path: `${el("cards")}.props.onClick.0.action`,
+      message: 'unknown action type "app.nope"',
+    });
+  });
+
+  test("onClick navigating to an undeclared page fails", async () => {
+    const issues = await issuesFor(
+      cardGrid({ onClick: [{ action: "app.navigate", params: { page: "nope" } }] }),
+    );
+    expect(issues).toContainEqual({
+      path: `${el("cards")}.props.onClick.0.params.page`,
+      message: 'unknown page "nope"',
+    });
+  });
+
+  test("titleKey is required", async () => {
+    const copy = cardGrid({});
+    delete copy.pages.main.elements.cards!.props!.titleKey;
+    const issues = await issuesFor(copy);
+    expect(issues.some((i) => i.path.startsWith(`${el("cards")}.props`))).toBe(true);
+  });
+
+  test("data bound to a $state path passes", async () => {
+    const issues = await issuesFor(
+      appWith({
+        root: { type: "Stack", props: {}, children: ["cards"] },
+        cards: {
+          type: "CardGrid",
+          props: { data: { $state: "/queries/docs/data" }, titleKey: "title" },
+        },
+      }),
+    );
+    if (issues.length > 0) console.error(issues);
+    expect(issues).toEqual([]);
+  });
+
+  test("an unknown field kind is rejected", async () => {
+    const issues = await issuesFor(cardGrid({ fields: [{ key: "author", kind: "status" }] }));
+    expect(issues.some((i) => i.path.startsWith(`${el("cards")}.props.fields.0.kind`))).toBe(true);
+  });
+});
+
+describe("Table column format", () => {
+  test("a column with a {{field}} format template passes", async () => {
+    const issues = await issuesFor(
+      appWith({
+        root: { type: "Stack", props: {}, children: ["table"] },
+        table: {
+          type: "Table",
+          props: {
+            data: { $state: "/queries/docs/data" },
+            columns: [
+              { key: "title", label: "Document", format: "{{title}} ({{status}})" },
+              { key: "author" },
+            ],
+          },
+        },
+      }),
+    );
+    if (issues.length > 0) console.error(issues);
+    expect(issues).toEqual([]);
+  });
+
+  test("format must be a string", async () => {
+    const issues = await issuesFor(
+      appWith({
+        root: { type: "Stack", props: {}, children: ["table"] },
+        table: {
+          type: "Table",
+          props: {
+            data: { $state: "/queries/docs/data" },
+            columns: [{ key: "title", format: 42 }],
+          },
+        },
+      }),
+    );
+    expect(issues.some((i) => i.path.startsWith(`${el("table")}.props.columns.0.format`))).toBe(
+      true,
+    );
+  });
+});

package/src/tests/apps-catalog-additions.test.ts

@@ -0,0 +1,120 @@
+import { describe, expect, test } from "bun:test";
+import { parseAppDefinition } from "../apps/definition";
+
+/**
+ * Validator coverage for the small catalog additions: `NumberInput`, Select
+ * `defaultValue`, and `fill` on Stack / Split. Pure `parseAppDefinition`
+ * calls — no DB, no HTTP — mirroring `apps-catalog-inputs.test.ts`.
+ */
+
+type Element = { type: string; props?: Record<string, unknown>; children?: string[] };
+
+function appWith(elements: Record<string, Element>) {
+  return {
+    models: {},
+    pages: { main: { title: "Main", root: "root", elements } },
+    defaultPage: "main",
+  };
+}
+
+async function issuesFor(input: unknown) {
+  const parsed = await parseAppDefinition(input);
+  return parsed.success ? [] : parsed.issues;
+}
+
+const el = (id: string) => `pages.main.elements.${id}`;
+
+describe("NumberInput", () => {
+  test("a NumberInput's /ui/<id>/value read by a bound Text validates", async () => {
+    const issues = await issuesFor(
+      appWith({
+        root: { type: "Stack", props: {}, children: ["width", "echo"] },
+        width: {
+          type: "NumberInput",
+          props: { id: "x", label: "Width", placeholder: "px", min: 1, max: 4096 },
+        },
+        echo: { type: "Text", props: { content: { $state: "/ui/x/value" } } },
+      }),
+    );
+    if (issues.length > 0) console.error(issues);
+    expect(issues).toEqual([]);
+  });
+
+  test("a /ui/<id>/value read with no UI control of that id is rejected", async () => {
+    const issues = await issuesFor(
+      appWith({
+        root: { type: "Stack", props: {}, children: ["echo"] },
+        echo: { type: "Text", props: { content: { $state: "/ui/x/value" } } },
+      }),
+    );
+    expect(issues).toContainEqual({
+      path: `${el("echo")}.props.content`,
+      message: 'state reference targets unknown UI control "x"',
+    });
+  });
+
+  test("id is required and min/max must be numbers", async () => {
+    const missingId = await issuesFor(
+      appWith({
+        root: { type: "Stack", props: {}, children: ["width"] },
+        width: { type: "NumberInput", props: { label: "Width" } },
+      }),
+    );
+    expect(missingId.map((issue) => issue.path)).toContain(`${el("width")}.props.id`);
+
+    const badBounds = await issuesFor(
+      appWith({
+        root: { type: "Stack", props: {}, children: ["width"] },
+        width: { type: "NumberInput", props: { id: "x", min: "1", max: "10" } },
+      }),
+    );
+    const paths = badBounds.map((issue) => issue.path);
+    expect(paths).toContain(`${el("width")}.props.min`);
+    expect(paths).toContain(`${el("width")}.props.max`);
+  });
+});
+
+describe("Select defaultValue", () => {
+  const select = (props: Record<string, unknown>) =>
+    appWith({
+      root: { type: "Stack", props: {}, children: ["device", "echo"] },
+      device: {
+        type: "Select",
+        props: { id: "device", options: ["phone", "tablet", "desktop"], ...props },
+      },
+      echo: { type: "Text", props: { content: { $state: "/ui/device/value" } } },
+    });
+
+  test("a Select with defaultValue validates", async () => {
+    const issues = await issuesFor(select({ defaultValue: "tablet" }));
+    if (issues.length > 0) console.error(issues);
+    expect(issues).toEqual([]);
+  });
+
+  test("defaultValue must be a string", async () => {
+    const paths = (await issuesFor(select({ defaultValue: 2 }))).map((issue) => issue.path);
+    expect(paths).toContain(`${el("device")}.props.defaultValue`);
+  });
+});
+
+describe("Stack and Split fill", () => {
+  const layout = (stackFill: unknown, splitFill: unknown) =>
+    appWith({
+      root: { type: "Stack", props: { fill: stackFill }, children: ["split"] },
+      split: { type: "Split", props: { fill: splitFill, ratio: "1-1" }, children: ["a", "b"] },
+      a: { type: "Text", props: { content: "left" } },
+      b: { type: "Text", props: { content: "right" } },
+    });
+
+  test("fill: true validates on both", async () => {
+    const issues = await issuesFor(layout(true, true));
+    if (issues.length > 0) console.error(issues);
+    expect(issues).toEqual([]);
+  });
+
+  test("fill must be a boolean", async () => {
+    const paths = (await issuesFor(layout("yes", 1))).map((issue) => issue.path);
+    expect(paths).toContain(`${el("root")}.props.fill`);
+    expect(paths).toContain(`${el("split")}.props.fill`);
+  });
+});

package/src/tests/apps-tree.test.ts

@@ -0,0 +1,129 @@
+import { describe, expect, test } from "bun:test";
+import { parseAppDefinition } from "../apps/definition";
+
+/**
+ * Validator coverage for the `Tree` component: its `/ui/<id>/value` state slot,
+ * the type-less `nodes` prop (a bare `z.unknown()` in the catalog), and the
+ * generated schema's enforcement. Pure `parseAppDefinition` calls — no DB, no
+ * HTTP — mirroring `apps-catalog-additions.test.ts`.
+ */
+
+type Element = { type: string; props?: Record<string, unknown>; children?: string[] };
+
+const el = (id: string) => `pages.main.elements.${id}`;
+
+/**
+ * A `document` model with a json `doc` column, a `documentById` query over it,
+ * a `Tree` bound to that query's doc, and a `Text` reading the tree's
+ * selection slot. `tree` props are overridable per case.
+ */
+function treeDefinition(
+  treeProps: Record<string, unknown> = {},
+  elements: Record<string, Element> = {},
+) {
+  return {
+    models: {
+      document: { columns: { doc: { kind: "json" } } },
+    },
+    queries: { documentById: { model: "document" } },
+    pages: {
+      main: {
+        title: "Main",
+        root: "root",
+        elements: {
+          root: { type: "Stack", props: {}, children: ["tree", "selected"] },
+          tree: {
+            type: "Tree",
+            props: {
+              id: "nodes",
+              nodes: { $state: "/queries/documentById/data/0/doc" },
+              ...treeProps,
+            },
+          },
+          selected: { type: "Text", props: { content: { $state: "/ui/nodes/value" } } },
+          ...elements,
+        },
+      },
+    },
+    defaultPage: "main",
+  };
+}
+
+async function issuesFor(input: unknown) {
+  const parsed = await parseAppDefinition(input);
+  return parsed.success ? [] : parsed.issues;
+}
+
+describe("Tree validation", () => {
+  test("a Tree whose /ui/<id>/value slot is read by a bound Text validates", async () => {
+    const issues = await issuesFor(treeDefinition());
+    if (issues.length > 0) console.error(issues);
+    expect(issues).toEqual([]);
+  });
+
+  test("a /ui/<id>/value read with no Tree of that id is rejected", async () => {
+    const issues = await issuesFor(
+      treeDefinition(
+        {},
+        { selected: { type: "Text", props: { content: { $state: "/ui/phantom/value" } } } },
+      ),
+    );
+    expect(issues).toContainEqual({
+      path: `${el("selected")}.props.content`,
+      message: 'state reference targets unknown UI control "phantom"',
+    });
+  });
+
+  test("nodes accepts an inline doc-shaped literal as well as a $state binding", async () => {
+    const issues = await issuesFor(
+      treeDefinition({ nodes: { root: "a", elements: { a: { type: "Stack" } } } }),
+    );
+    if (issues.length > 0) console.error(issues);
+    expect(issues).toEqual([]);
+  });
+
+  test("label, maxHeight and fill validate together", async () => {
+    const issues = await issuesFor(
+      treeDefinition({ label: "Outline", maxHeight: "320px", fill: true }),
+    );
+    if (issues.length > 0) console.error(issues);
+    expect(issues).toEqual([]);
+  });
+
+  test("an unknown prop is rejected", async () => {
+    const issues = await issuesFor(treeDefinition({ foo: 1 }));
+    expect(issues).toContainEqual({
+      path: `${el("tree")}.props.foo`,
+      message: "unknown property",
+    });
+  });
+
+  test("id is required", async () => {
+    // No `selected` reader here: without an id there is no slot for it to target.
+    const issues = await issuesFor({
+      ...treeDefinition(),
+      pages: {
+        main: {
+          title: "Main",
+          root: "root",
+          elements: {
+            root: { type: "Stack", props: {}, children: ["tree"] },
+            tree: {
+              type: "Tree",
+              props: { nodes: { $state: "/queries/documentById/data/0/doc" } },
+            },
+          },
+        },
+      },
+    });
+    expect(issues.map((issue) => issue.path)).toContain(`${el("tree")}.props.id`);
+  });
+
+  test("maxHeight must be a string and fill a boolean", async () => {
+    const paths = (await issuesFor(treeDefinition({ maxHeight: 320, fill: "yes" }))).map(
+      (issue) => issue.path,
+    );
+    expect(paths).toContain(`${el("tree")}.props.maxHeight`);
+    expect(paths).toContain(`${el("tree")}.props.fill`);
+  });
+});

package/src/tests/bitbucket-auth.test.ts

@@ -0,0 +1,156 @@
+import { afterEach, describe, expect, test } from "bun:test";
+import { createHmac } from "node:crypto";
+import { resetBitbucketBotCache, resolveBitbucketBotAccountId } from "../bitbucket/api";
+import {
+  getBitbucketToken,
+  initBitbucket,
+  isBitbucketEnabled,
+  resetBitbucket,
+  verifyBitbucketWebhook,
+} from "../bitbucket/auth";
+
+const ENV_KEYS = [
+  "BITBUCKET_WEBHOOK_SECRET",
+  "BITBUCKET_TOKEN",
+  "BITBUCKET_DISABLE",
+  "BITBUCKET_BOT_ACCOUNT_ID",
+] as const;
+
+function sign(secret: string, body: string): string {
+  return `sha256=${createHmac("sha256", secret).update(body).digest("hex")}`;
+}
+
+afterEach(() => {
+  for (const key of ENV_KEYS) delete process.env[key];
+  resetBitbucket();
+  resetBitbucketBotCache();
+});
+
+describe("isBitbucketEnabled", () => {
+  test("disabled without a webhook secret", () => {
+    expect(isBitbucketEnabled()).toBe(false);
+  });
+
+  test("enabled with a webhook secret", () => {
+    process.env.BITBUCKET_WEBHOOK_SECRET = "example-secret";
+    expect(isBitbucketEnabled()).toBe(true);
+  });
+
+  test("BITBUCKET_DISABLE wins over the secret", () => {
+    process.env.BITBUCKET_WEBHOOK_SECRET = "example-secret";
+    process.env.BITBUCKET_DISABLE = "true";
+    expect(isBitbucketEnabled()).toBe(false);
+  });
+});
+
+describe("verifyBitbucketWebhook", () => {
+  test("matches Atlassian's documented test vector", () => {
+    process.env.BITBUCKET_WEBHOOK_SECRET = "It's a Secret to Everybody";
+    initBitbucket();
+    expect(
+      verifyBitbucketWebhook(
+        "Hello World!",
+        "sha256=a4771c39fbe90f317c7824e83ddef3caae9cb3d976c214ace1f2937e133263c9",
+      ),
+    ).toBe(true);
+  });
+
+  test("rejects a signature made with the wrong secret", () => {
+    process.env.BITBUCKET_WEBHOOK_SECRET = "example-secret";
+    initBitbucket();
+    expect(verifyBitbucketWebhook("{}", sign("other-secret", "{}"))).toBe(false);
+    expect(verifyBitbucketWebhook("{}", sign("example-secret", "{}"))).toBe(true);
+  });
+
+  test("rejects a tampered body", () => {
+    process.env.BITBUCKET_WEBHOOK_SECRET = "example-secret";
+    initBitbucket();
+    expect(verifyBitbucketWebhook('{"a":2}', sign("example-secret", '{"a":1}'))).toBe(false);
+  });
+
+  test("rejects a missing header", () => {
+    process.env.BITBUCKET_WEBHOOK_SECRET = "example-secret";
+    initBitbucket();
+    expect(verifyBitbucketWebhook("{}", undefined)).toBe(false);
+  });
+
+  test("rejects a bare hex digest without the sha256= prefix", () => {
+    process.env.BITBUCKET_WEBHOOK_SECRET = "example-secret";
+    initBitbucket();
+    const bare = sign("example-secret", "{}").slice("sha256=".length);
+    expect(verifyBitbucketWebhook("{}", bare)).toBe(false);
+  });
+
+  test("rejects everything before init and after reset", () => {
+    process.env.BITBUCKET_WEBHOOK_SECRET = "example-secret";
+    const sig = sign("example-secret", "{}");
+    expect(verifyBitbucketWebhook("{}", sig)).toBe(false);
+    initBitbucket();
+    expect(verifyBitbucketWebhook("{}", sig)).toBe(true);
+    resetBitbucket();
+    expect(verifyBitbucketWebhook("{}", sig)).toBe(false);
+  });
+});
+
+describe("initBitbucket", () => {
+  test("does not initialize when disabled", () => {
+    process.env.BITBUCKET_WEBHOOK_SECRET = "example-secret";
+    process.env.BITBUCKET_TOKEN = "example-token";
+    process.env.BITBUCKET_DISABLE = "true";
+    initBitbucket();
+    expect(getBitbucketToken()).toBeNull();
+  });
+
+  test("loads the API token", () => {
+    process.env.BITBUCKET_WEBHOOK_SECRET = "example-secret";
+    process.env.BITBUCKET_TOKEN = "example-token";
+    initBitbucket();
+    expect(getBitbucketToken()).toBe("example-token");
+  });
+});
+
+describe("resolveBitbucketBotAccountId", () => {
+  test("prefers BITBUCKET_BOT_ACCOUNT_ID", async () => {
+    process.env.BITBUCKET_BOT_ACCOUNT_ID = "557058:env-bot";
+    expect(await resolveBitbucketBotAccountId()).toBe("557058:env-bot");
+  });
+
+  test("returns null without a token", async () => {
+    expect(await resolveBitbucketBotAccountId()).toBeNull();
+  });
+
+  test("resolves GET /user with a Bearer token and caches it", async () => {
+    process.env.BITBUCKET_WEBHOOK_SECRET = "example-secret";
+    process.env.BITBUCKET_TOKEN = "example-token";
+    initBitbucket();
+    const calls: Array<{ url: string; auth?: string }> = [];
+    const realFetch = globalThis.fetch;
+    globalThis.fetch = (async (input: string | URL | Request, init?: RequestInit) => {
+      const headers = (init?.headers ?? {}) as Record<string, string>;
+      calls.push({ url: String(input), auth: headers.Authorization });
+      return new Response(JSON.stringify({ account_id: "557058:api-bot" }), { status: 200 });
+    }) as typeof fetch;
+    try {
+      expect(await resolveBitbucketBotAccountId()).toBe("557058:api-bot");
+      expect(await resolveBitbucketBotAccountId()).toBe("557058:api-bot");
+    } finally {
+      globalThis.fetch = realFetch;
+    }
+    expect(calls).toEqual([
+      { url: "https://api.bitbucket.org/2.0/user", auth: "Bearer example-token" },
+    ]);
+  });
+
+  test("returns null on a failed lookup", async () => {
+    process.env.BITBUCKET_WEBHOOK_SECRET = "example-secret";
+    process.env.BITBUCKET_TOKEN = "example-token";
+    initBitbucket();
+    const realFetch = globalThis.fetch;
+    globalThis.fetch = (async () => new Response("nope", { status: 401 })) as typeof fetch;
+    try {
+      expect(await resolveBitbucketBotAccountId()).toBeNull();
+    } finally {
+      globalThis.fetch = realFetch;
+    }
+  });
+});