@desplega.ai/agent-swarm 1.70.0 → 1.71.1

package/src/tests/jira-webhook-lifecycle.test.ts

@@ -0,0 +1,234 @@
+import { afterAll, beforeAll, beforeEach, describe, expect, mock, test } from "bun:test";
+import { unlink } from "node:fs/promises";
+import { closeDb, getDb, initDb } from "../be/db";
+import { upsertOAuthApp } from "../be/db-queries/oauth";
+import { getJiraMetadata, updateJiraMetadata } from "../jira/metadata";
+
+const TEST_DB_PATH = "./test-jira-webhook-lifecycle.sqlite";
+
+// Mock the Jira fetch client. Each test installs its own per-call response.
+const jiraFetchMock = mock(
+  () =>
+    Promise.resolve(
+      new Response("{}", { status: 200, headers: { "Content-Type": "application/json" } }),
+    ) as Promise<Response>,
+);
+mock.module("../jira/client", () => ({
+  jiraFetch: jiraFetchMock,
+  getJiraAccessToken: () => Promise.resolve("access-1"),
+  getJiraCloudId: () => "cloud-1",
+}));
+
+beforeAll(() => {
+  initDb(TEST_DB_PATH);
+  process.env.JIRA_WEBHOOK_TOKEN = "test-token-32-chars-deadbeef-cafe-99";
+  process.env.MCP_BASE_URL = "https://test.example.com";
+
+  upsertOAuthApp("jira", {
+    clientId: "client-id",
+    clientSecret: "client-secret",
+    authorizeUrl: "https://auth.atlassian.com/authorize",
+    tokenUrl: "https://auth.atlassian.com/oauth/token",
+    redirectUri: "http://localhost:3013/api/trackers/jira/callback",
+    scopes: "read:jira-work,manage:jira-webhook",
+    metadata: JSON.stringify({ cloudId: "cloud-1", siteUrl: "https://example.atlassian.net" }),
+  });
+});
+
+afterAll(async () => {
+  delete process.env.JIRA_WEBHOOK_TOKEN;
+  delete process.env.MCP_BASE_URL;
+  closeDb();
+  await unlink(TEST_DB_PATH).catch(() => {});
+  await unlink(`${TEST_DB_PATH}-wal`).catch(() => {});
+  await unlink(`${TEST_DB_PATH}-shm`).catch(() => {});
+});
+
+const { refreshJiraWebhooks, registerJiraWebhook } = await import("../jira/webhook-lifecycle");
+
+beforeEach(() => {
+  jiraFetchMock.mockClear();
+  // Reset the webhookIds list each test (and clear metadata writebacks).
+  getDb()
+    .query("UPDATE oauth_apps SET metadata = ? WHERE provider = 'jira'")
+    .run(JSON.stringify({ cloudId: "cloud-1", siteUrl: "https://example.atlassian.net" }));
+});
+
+describe("registerJiraWebhook", () => {
+  test("posts the right body shape and persists webhookId into metadata", async () => {
+    jiraFetchMock.mockImplementationOnce(
+      () =>
+        Promise.resolve(
+          new Response(
+            JSON.stringify({
+              webhookRegistrationResult: [{ createdWebhookId: 42 }],
+            }),
+            { status: 200, headers: { "Content-Type": "application/json" } },
+          ),
+        ) as Promise<Response>,
+    );
+
+    const result = await registerJiraWebhook("project = KAN");
+
+    expect(result.webhookId).toBe(42);
+    expect(result.jql).toBe("project = KAN");
+    expect(result.expiresAt).toMatch(/^\d{4}-\d{2}-\d{2}T/); // ISO
+
+    expect(jiraFetchMock).toHaveBeenCalledTimes(1);
+    const [path, init] = jiraFetchMock.mock.calls[0] as [string, RequestInit];
+    expect(path).toBe("/rest/api/3/webhook");
+    expect(init.method).toBe("POST");
+
+    const parsed = JSON.parse(init.body as string) as {
+      url: string;
+      webhooks: { events: string[]; jqlFilter: string; fieldIdsFilter: string[] }[];
+    };
+    expect(parsed.url).toBe(
+      "https://test.example.com/api/trackers/jira/webhook/test-token-32-chars-deadbeef-cafe-99",
+    );
+    expect(parsed.webhooks[0]?.jqlFilter).toBe("project = KAN");
+    expect(parsed.webhooks[0]?.events).toEqual([
+      "jira:issue_updated",
+      "jira:issue_deleted",
+      "comment_created",
+      "comment_updated",
+    ]);
+    expect(parsed.webhooks[0]?.fieldIdsFilter).toEqual(["assignee"]);
+
+    // Persisted in metadata
+    const meta = getJiraMetadata();
+    expect(meta.webhookIds?.length).toBe(1);
+    expect(meta.webhookIds?.[0]?.id).toBe(42);
+    expect(meta.webhookIds?.[0]?.jql).toBe("project = KAN");
+  });
+
+  test("throws when JIRA_WEBHOOK_TOKEN is unset", async () => {
+    const saved = process.env.JIRA_WEBHOOK_TOKEN;
+    delete process.env.JIRA_WEBHOOK_TOKEN;
+    await expect(registerJiraWebhook("project = X")).rejects.toThrow(
+      /JIRA_WEBHOOK_TOKEN is not set/,
+    );
+    process.env.JIRA_WEBHOOK_TOKEN = saved;
+  });
+
+  test("throws when Atlassian returns no results", async () => {
+    jiraFetchMock.mockImplementationOnce(
+      () =>
+        Promise.resolve(
+          new Response(JSON.stringify({ webhookRegistrationResult: [] }), {
+            status: 200,
+            headers: { "Content-Type": "application/json" },
+          }),
+        ) as Promise<Response>,
+    );
+
+    await expect(registerJiraWebhook("project = X")).rejects.toThrow(/returned no results/);
+  });
+
+  test("throws when entry is malformed (missing createdWebhookId)", async () => {
+    jiraFetchMock.mockImplementationOnce(
+      () =>
+        Promise.resolve(
+          new Response(
+            JSON.stringify({
+              webhookRegistrationResult: [{ errors: ["bad jql"] }],
+            }),
+            { status: 200, headers: { "Content-Type": "application/json" } },
+          ),
+        ) as Promise<Response>,
+    );
+
+    await expect(registerJiraWebhook("project = X")).rejects.toThrow(/malformed/);
+  });
+
+  test("throws when Atlassian responds non-OK", async () => {
+    jiraFetchMock.mockImplementationOnce(
+      () => Promise.resolve(new Response("forbidden", { status: 403 })) as Promise<Response>,
+    );
+    await expect(registerJiraWebhook("project = X")).rejects.toThrow(/registration failed \(403\)/);
+  });
+});
+
+describe("refreshJiraWebhooks", () => {
+  test("no-op when no webhooks are registered", async () => {
+    await refreshJiraWebhooks();
+    expect(jiraFetchMock).not.toHaveBeenCalled();
+  });
+
+  test("handles 200 + expirationDate — applies new expiry to all webhooks", async () => {
+    updateJiraMetadata({
+      webhookIds: [
+        { id: 1, expiresAt: "2026-04-01T00:00:00.000Z", jql: "p=A" },
+        { id: 2, expiresAt: "2026-04-15T00:00:00.000Z", jql: "p=B" },
+      ],
+    });
+
+    jiraFetchMock.mockImplementationOnce(
+      () =>
+        Promise.resolve(
+          new Response(JSON.stringify({ expirationDate: "2026-12-31T00:00:00.000Z" }), {
+            status: 200,
+            headers: { "Content-Type": "application/json" },
+          }),
+        ) as Promise<Response>,
+    );
+
+    await refreshJiraWebhooks();
+
+    expect(jiraFetchMock).toHaveBeenCalledTimes(1);
+    const [path, init] = jiraFetchMock.mock.calls[0] as [string, RequestInit];
+    expect(path).toBe("/rest/api/3/webhook/refresh");
+    expect(init.method).toBe("PUT");
+    const parsed = JSON.parse(init.body as string) as { webhookIds: number[] };
+    expect(parsed.webhookIds.sort()).toEqual([1, 2]);
+
+    const meta = getJiraMetadata();
+    const sorted = [...(meta.webhookIds ?? [])].sort((a, b) => a.id - b.id);
+    expect(sorted[0]?.expiresAt).toBe("2026-12-31T00:00:00.000Z");
+    expect(sorted[1]?.expiresAt).toBe("2026-12-31T00:00:00.000Z");
+  });
+
+  test("handles 204 No Content — leaves local expiries unchanged", async () => {
+    updateJiraMetadata({
+      webhookIds: [{ id: 7, expiresAt: "2026-04-01T00:00:00.000Z", jql: "p=A" }],
+    });
+
+    jiraFetchMock.mockImplementationOnce(
+      () => Promise.resolve(new Response(null, { status: 204 })) as Promise<Response>,
+    );
+
+    await refreshJiraWebhooks();
+
+    const meta = getJiraMetadata();
+    expect(meta.webhookIds?.[0]?.expiresAt).toBe("2026-04-01T00:00:00.000Z");
+  });
+
+  test("throws on Atlassian non-OK response", async () => {
+    updateJiraMetadata({
+      webhookIds: [{ id: 8, expiresAt: "2026-04-01T00:00:00.000Z", jql: "p=A" }],
+    });
+
+    jiraFetchMock.mockImplementationOnce(
+      () => Promise.resolve(new Response("rate limited", { status: 429 })) as Promise<Response>,
+    );
+
+    await expect(refreshJiraWebhooks()).rejects.toThrow(/refresh failed \(429\)/);
+  });
+
+  test("malformed JSON response leaves expiries untouched (no crash)", async () => {
+    updateJiraMetadata({
+      webhookIds: [{ id: 9, expiresAt: "2026-04-01T00:00:00.000Z", jql: "p=A" }],
+    });
+
+    jiraFetchMock.mockImplementationOnce(
+      () =>
+        Promise.resolve(
+          new Response("not-json", { status: 200, headers: { "Content-Type": "text/plain" } }),
+        ) as Promise<Response>,
+    );
+
+    await refreshJiraWebhooks();
+    const meta = getJiraMetadata();
+    expect(meta.webhookIds?.[0]?.expiresAt).toBe("2026-04-01T00:00:00.000Z");
+  });
+});

package/src/tests/jira-webhook.test.ts

@@ -0,0 +1,274 @@
+import {
+  afterAll,
+  afterEach,
+  beforeAll,
+  beforeEach,
+  describe,
+  expect,
+  mock,
+  spyOn,
+  test,
+} from "bun:test";
+import { unlink } from "node:fs/promises";
+import { closeDb, getDb, initDb } from "../be/db";
+import { upsertOAuthApp } from "../be/db-queries/oauth";
+import {
+  createTrackerSync,
+  hasTrackerDelivery,
+  markTrackerDelivery,
+} from "../be/db-queries/tracker";
+import * as syncModule from "../jira/sync";
+
+const TEST_DB_PATH = "./test-jira-webhook.sqlite";
+const TEST_TOKEN = "test-jira-webhook-token-deadbeefcafe1234";
+
+// Spy on the sync handlers — using mock.module here would leak globally
+// because bun's mock.module has no documented restore. spyOn is restored by
+// mock.restore() in afterAll, leaving the real module intact for other test
+// files (notably jira-sync.test.ts which exercises the real handlers).
+const issueHandler = spyOn(syncModule, "handleIssueEvent").mockResolvedValue(undefined);
+const commentHandler = spyOn(syncModule, "handleCommentEvent").mockResolvedValue(undefined);
+const issueDeleteHandler = spyOn(syncModule, "handleIssueDeleteEvent").mockResolvedValue(undefined);
+
+const { handleJiraWebhook, isDuplicateDelivery, synthesizeDeliveryId, verifyJiraWebhookToken } =
+  await import("../jira/webhook");
+
+beforeAll(() => {
+  initDb(TEST_DB_PATH);
+  process.env.JIRA_WEBHOOK_TOKEN = TEST_TOKEN;
+  // Seed an oauth app so any nested calls don't blow up.
+  upsertOAuthApp("jira", {
+    clientId: "client-id",
+    clientSecret: "client-secret",
+    authorizeUrl: "https://auth.atlassian.com/authorize",
+    tokenUrl: "https://auth.atlassian.com/oauth/token",
+    redirectUri: "http://localhost:3013/api/trackers/jira/callback",
+    scopes: "read:jira-work",
+  });
+});
+
+afterAll(async () => {
+  delete process.env.JIRA_WEBHOOK_TOKEN;
+  mock.restore();
+  closeDb();
+  await unlink(TEST_DB_PATH).catch(() => {});
+  await unlink(`${TEST_DB_PATH}-wal`).catch(() => {});
+  await unlink(`${TEST_DB_PATH}-shm`).catch(() => {});
+});
+
+beforeEach(() => {
+  issueHandler.mockClear();
+  commentHandler.mockClear();
+  issueDeleteHandler.mockClear();
+  // Reset tracker_sync rows
+  getDb().query("DELETE FROM tracker_sync").run();
+});
+
+afterEach(() => {
+  // Allow any fire-and-forget dispatch to settle so it doesn't bleed into
+  // the next test.
+});
+
+describe("verifyJiraWebhookToken", () => {
+  test("returns true for matching token", () => {
+    expect(verifyJiraWebhookToken(TEST_TOKEN, TEST_TOKEN)).toBe(true);
+  });
+
+  test("returns false for empty/missing path token", () => {
+    expect(verifyJiraWebhookToken(undefined, TEST_TOKEN)).toBe(false);
+    expect(verifyJiraWebhookToken("", TEST_TOKEN)).toBe(false);
+  });
+
+  test("returns false for empty expected token", () => {
+    expect(verifyJiraWebhookToken(TEST_TOKEN, "")).toBe(false);
+  });
+
+  test("returns false for length mismatch", () => {
+    expect(verifyJiraWebhookToken("short", TEST_TOKEN)).toBe(false);
+    expect(verifyJiraWebhookToken(`${TEST_TOKEN}extra`, TEST_TOKEN)).toBe(false);
+  });
+
+  test("returns false for byte mismatch at same length", () => {
+    const wrong = `${TEST_TOKEN.slice(0, -1)}X`;
+    expect(verifyJiraWebhookToken(wrong, TEST_TOKEN)).toBe(false);
+  });
+});
+
+describe("synthesizeDeliveryId", () => {
+  test("stable across same body+envelope (idempotent retries)", () => {
+    const body = {
+      webhookEvent: "jira:issue_updated",
+      timestamp: 1700000000,
+      issue: { id: "10001" },
+    };
+    const raw = JSON.stringify(body);
+    const id1 = synthesizeDeliveryId(body, raw);
+    const id2 = synthesizeDeliveryId(body, raw);
+    expect(id1).toBe(id2);
+  });
+
+  test("differs across different bodies even at same timestamp/event", () => {
+    const a = { webhookEvent: "comment_created", timestamp: 1700000000, issue: { id: "10001" } };
+    const b = { webhookEvent: "comment_created", timestamp: 1700000000, issue: { id: "10002" } };
+    expect(synthesizeDeliveryId(a, JSON.stringify(a))).not.toBe(
+      synthesizeDeliveryId(b, JSON.stringify(b)),
+    );
+  });
+});
+
+describe("DB-persisted dedup (hasTrackerDelivery + markTrackerDelivery)", () => {
+  test("round-trip: marked delivery is found, unknown delivery is not", () => {
+    createTrackerSync({
+      provider: "jira",
+      entityType: "task",
+      swarmId: "task-1",
+      externalId: "10001",
+      externalIdentifier: "KAN-1",
+    });
+    expect(hasTrackerDelivery("jira", "delivery-abc")).toBe(false);
+    markTrackerDelivery("jira", "task", "10001", "delivery-abc");
+    expect(hasTrackerDelivery("jira", "delivery-abc")).toBe(true);
+  });
+
+  test("hasTrackerDelivery returns false for empty/null deliveryId", () => {
+    expect(hasTrackerDelivery("jira", null)).toBe(false);
+    expect(hasTrackerDelivery("jira", "")).toBe(false);
+    expect(hasTrackerDelivery("jira", undefined)).toBe(false);
+  });
+
+  test("dedup state is durable: marked deliveries survive any number of subsequent reads", () => {
+    // We can't fully simulate a process restart in-process (the test harness
+    // uses a deserialized in-memory template), but the storage is the
+    // tracker_sync table — so as long as the row stays, dedup works. Verify
+    // the data persists across many independent reads (the same property a
+    // restart would test against the underlying store).
+    createTrackerSync({
+      provider: "jira",
+      entityType: "task",
+      swarmId: "task-restart",
+      externalId: "10099",
+      externalIdentifier: "KAN-99",
+    });
+    markTrackerDelivery("jira", "task", "10099", "persistent-id");
+    for (let i = 0; i < 5; i++) {
+      expect(hasTrackerDelivery("jira", "persistent-id")).toBe(true);
+    }
+    // And the row exists in the underlying SQL store (proves it's not just a
+    // process-local Map).
+    const row = getDb()
+      .query("SELECT lastDeliveryId FROM tracker_sync WHERE externalId = '10099'")
+      .get() as { lastDeliveryId: string };
+    expect(row.lastDeliveryId).toBe("persistent-id");
+  });
+});
+
+describe("handleJiraWebhook — auth + status codes", () => {
+  test("returns 503 when JIRA_WEBHOOK_TOKEN is unset", async () => {
+    const saved = process.env.JIRA_WEBHOOK_TOKEN;
+    delete process.env.JIRA_WEBHOOK_TOKEN;
+    const result = await handleJiraWebhook(TEST_TOKEN, "{}");
+    expect(result.status).toBe(503);
+    process.env.JIRA_WEBHOOK_TOKEN = saved;
+  });
+
+  test("returns 401 with empty body for missing path token", async () => {
+    const result = await handleJiraWebhook(undefined, "{}");
+    expect(result.status).toBe(401);
+    expect(result.body).toBe("");
+  });
+
+  test("returns 401 with empty body for wrong path token", async () => {
+    const result = await handleJiraWebhook("wrong-token-32-chars-long-xxxxxx", "{}");
+    expect(result.status).toBe(401);
+    expect(result.body).toBe("");
+  });
+
+  test("returns 200 + 'ignored' for invalid JSON body", async () => {
+    const result = await handleJiraWebhook(TEST_TOKEN, "{not json");
+    expect(result.status).toBe(200);
+    expect(result.body).toEqual({ status: "ignored", reason: "invalid-json" });
+  });
+});
+
+describe("handleJiraWebhook — dispatcher routing", () => {
+  async function letDispatchSettle() {
+    // Dispatch is fire-and-forget; let microtasks drain.
+    await new Promise((r) => setTimeout(r, 20));
+  }
+
+  test("issue_updated routes to handleIssueEvent", async () => {
+    const body = { webhookEvent: "jira:issue_updated", timestamp: 1, issue: { id: "10001" } };
+    const result = await handleJiraWebhook(TEST_TOKEN, JSON.stringify(body));
+    expect(result.status).toBe(200);
+    expect(result.body).toEqual({ status: "accepted" });
+    await letDispatchSettle();
+    expect(issueHandler).toHaveBeenCalledTimes(1);
+    expect(commentHandler).not.toHaveBeenCalled();
+    expect(issueDeleteHandler).not.toHaveBeenCalled();
+  });
+
+  test("comment_created routes to handleCommentEvent", async () => {
+    const body = {
+      webhookEvent: "comment_created",
+      timestamp: 2,
+      issue: { id: "10002" },
+      comment: { id: "c1" },
+    };
+    await handleJiraWebhook(TEST_TOKEN, JSON.stringify(body));
+    await letDispatchSettle();
+    expect(commentHandler).toHaveBeenCalledTimes(1);
+    expect(issueHandler).not.toHaveBeenCalled();
+  });
+
+  test("comment_updated routes to handleCommentEvent", async () => {
+    const body = {
+      webhookEvent: "comment_updated",
+      timestamp: 3,
+      issue: { id: "10003" },
+      comment: { id: "c2" },
+    };
+    await handleJiraWebhook(TEST_TOKEN, JSON.stringify(body));
+    await letDispatchSettle();
+    expect(commentHandler).toHaveBeenCalledTimes(1);
+  });
+
+  test("issue_deleted routes to handleIssueDeleteEvent", async () => {
+    const body = { webhookEvent: "jira:issue_deleted", timestamp: 4, issue: { id: "10004" } };
+    await handleJiraWebhook(TEST_TOKEN, JSON.stringify(body));
+    await letDispatchSettle();
+    expect(issueDeleteHandler).toHaveBeenCalledTimes(1);
+  });
+
+  test("unhandled event is ignored — no handler invoked", async () => {
+    const body = { webhookEvent: "issue_link_created", timestamp: 5, issue: { id: "10005" } };
+    const result = await handleJiraWebhook(TEST_TOKEN, JSON.stringify(body));
+    expect(result.status).toBe(200);
+    await letDispatchSettle();
+    expect(issueHandler).not.toHaveBeenCalled();
+    expect(commentHandler).not.toHaveBeenCalled();
+    expect(issueDeleteHandler).not.toHaveBeenCalled();
+  });
+
+  test("duplicate delivery short-circuits (200 + 'duplicate')", async () => {
+    // Pre-stamp the delivery on a tracker_sync row.
+    createTrackerSync({
+      provider: "jira",
+      entityType: "task",
+      swarmId: "task-dup",
+      externalId: "10006",
+      externalIdentifier: "KAN-6",
+    });
+    const body = { webhookEvent: "jira:issue_updated", timestamp: 6, issue: { id: "10006" } };
+    const raw = JSON.stringify(body);
+    const did = synthesizeDeliveryId(body, raw);
+    markTrackerDelivery("jira", "task", "10006", did);
+
+    expect(isDuplicateDelivery(did)).toBe(true);
+
+    const result = await handleJiraWebhook(TEST_TOKEN, raw);
+    expect(result.status).toBe(200);
+    expect(result.body).toEqual({ status: "duplicate" });
+    await letDispatchSettle();
+    expect(issueHandler).not.toHaveBeenCalled();
+  });
+});

package/src/tests/telemetry-init.test.ts

@@ -0,0 +1,108 @@
+import { beforeEach, describe, expect, test } from "bun:test";
+import {
+  _getInstallationIdForTests,
+  _resetTelemetryStateForTests,
+  initTelemetry,
+} from "../telemetry";
+
+// initTelemetry no-ops when ANONYMIZED_TELEMETRY=false. The CI env or local
+// setup may set this, so force-enable for the duration of this file.
+process.env.ANONYMIZED_TELEMETRY = "true";
+
+describe("initTelemetry", () => {
+  beforeEach(() => {
+    _resetTelemetryStateForTests();
+  });
+
+  test("without generateIfMissing + missing config → installationId stays null (track no-ops)", async () => {
+    const writes: Array<{ key: string; value: string }> = [];
+    await initTelemetry(
+      "worker",
+      async () => undefined,
+      async (key, value) => {
+        writes.push({ key, value });
+      },
+    );
+    expect(_getInstallationIdForTests()).toBeNull();
+    expect(writes).toEqual([]);
+  });
+
+  test("without generateIfMissing + getConfig throws → installationId stays null", async () => {
+    const writes: Array<{ key: string; value: string }> = [];
+    await initTelemetry(
+      "worker",
+      async () => {
+        throw new Error("network blip");
+      },
+      async (key, value) => {
+        writes.push({ key, value });
+      },
+    );
+    expect(_getInstallationIdForTests()).toBeNull();
+    expect(writes).toEqual([]);
+  });
+
+  test("with generateIfMissing + missing config → mints install_<hex> and persists", async () => {
+    const writes: Array<{ key: string; value: string }> = [];
+    await initTelemetry(
+      "api-server",
+      async () => undefined,
+      async (key, value) => {
+        writes.push({ key, value });
+      },
+      { generateIfMissing: true },
+    );
+    const id = _getInstallationIdForTests();
+    expect(id).not.toBeNull();
+    expect(id).toMatch(/^install_[0-9a-f]{16}$/);
+    expect(writes).toEqual([{ key: "telemetry_installation_id", value: id as string }]);
+  });
+
+  test("with generateIfMissing + getConfig throws → mints ephemeral_<hex>, no persist", async () => {
+    const writes: Array<{ key: string; value: string }> = [];
+    await initTelemetry(
+      "api-server",
+      async () => {
+        throw new Error("db unavailable");
+      },
+      async (key, value) => {
+        writes.push({ key, value });
+      },
+      { generateIfMissing: true },
+    );
+    const id = _getInstallationIdForTests();
+    expect(id).not.toBeNull();
+    expect(id).toMatch(/^ephemeral_[0-9a-f]{16}$/);
+    expect(writes).toEqual([]);
+  });
+
+  test("existing config → reuses regardless of generateIfMissing flag", async () => {
+    const existing = "install_deadbeefcafebabe";
+
+    // Without flag.
+    const writesA: Array<{ key: string; value: string }> = [];
+    await initTelemetry(
+      "worker",
+      async () => existing,
+      async (key, value) => {
+        writesA.push({ key, value });
+      },
+    );
+    expect(_getInstallationIdForTests()).toBe(existing);
+    expect(writesA).toEqual([]);
+
+    // With flag.
+    _resetTelemetryStateForTests();
+    const writesB: Array<{ key: string; value: string }> = [];
+    await initTelemetry(
+      "api-server",
+      async () => existing,
+      async (key, value) => {
+        writesB.push({ key, value });
+      },
+      { generateIfMissing: true },
+    );
+    expect(_getInstallationIdForTests()).toBe(existing);
+    expect(writesB).toEqual([]);
+  });
+});

package/src/tools/tracker/tracker-link-task.ts

@@ -12,7 +12,7 @@ export const registerTrackerLinkTaskTool = (server: McpServer) => {
       annotations: { destructiveHint: false },
 
       inputSchema: z.object({
-        provider: z.string().describe("Tracker provider (e.g. 'linear')"),
+        provider: z.string().describe("Tracker provider (e.g. 'linear', 'jira')"),
         swarmTaskId: z.string().describe("The swarm task ID to link"),
         externalId: z.string().describe("The external issue ID in the tracker"),
         externalIdentifier: z

package/src/tools/tracker/tracker-map-agent.ts

@@ -12,7 +12,7 @@ export const registerTrackerMapAgentTool = (server: McpServer) => {
       annotations: { destructiveHint: false },
 
       inputSchema: z.object({
-        provider: z.string().describe("Tracker provider (e.g. 'linear')"),
+        provider: z.string().describe("Tracker provider (e.g. 'linear', 'jira')"),
         agentId: z.string().describe("The swarm agent ID"),
         externalUserId: z.string().describe("The external user ID in the tracker"),
         agentName: z.string().describe("Display name for the agent mapping"),

package/src/tools/tracker/tracker-status.ts

@@ -26,7 +26,7 @@ export const registerTrackerStatusTool = (server: McpServer) => {
       }),
     },
     async (_requestInfo, _meta) => {
-      const providers = ["linear"] as const;
+      const providers = ["linear", "jira"] as const;
       const trackers = providers.map((provider) => {
         const app = getOAuthApp(provider);
         const tokens = getOAuthTokens(provider);

package/src/tools/tracker/tracker-sync-status.ts

@@ -12,7 +12,7 @@ export const registerTrackerSyncStatusTool = (server: McpServer) => {
       annotations: { readOnlyHint: true },
 
       inputSchema: z.object({
-        provider: z.string().optional().describe("Filter by provider (e.g. 'linear')"),
+        provider: z.string().optional().describe("Filter by provider (e.g. 'linear', 'jira')"),
         entityType: z.enum(["task"]).optional().describe("Filter by entity type"),
       }),
       outputSchema: z.object({

package/src/tracker/types.ts

@@ -1,4 +1,4 @@
-export type TrackerProvider = "linear"; // extend as providers are added
+export type TrackerProvider = "linear" | "jira"; // extend as providers are added
 
 export interface OAuthApp {
   id: string;

package/src/types.ts

@@ -64,6 +64,7 @@ export const AgentTaskSourceSchema = z.enum([
   "schedule",
   "workflow",
   "linear",
+  "jira",
 ]);
 export type AgentTaskSource = z.infer<typeof AgentTaskSourceSchema>;