@desplega.ai/agent-swarm 2.4.0 → 2.4.2

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

@@ -1,11 +1,13 @@
 import { afterEach, beforeEach, describe, expect, test } from "bun:test";
 import { unlink } from "node:fs/promises";
-import { closeDb, createUser, initDb } from "../be/db";
+import { closeDb, createUser, getDbClient, initDb, updateUser, upsertSwarmConfig } from "../be/db";
 import { attachRole, detachRole } from "../be/rbac-roles";
+import { loadGlobalConfigsIntoEnv } from "../http/core";
 import {
   _getOrgIdForTests,
   _resetTelemetryStateForTests,
   initTelemetry,
+  setTelemetryFunctionResolver,
   setTelemetryOrgDomain,
   track,
 } from "../telemetry";
@@ -19,12 +21,22 @@ import {
   validOrgDomain,
   validOrgId,
 } from "../telemetry-context";
-import { _resetTelemetryIdentityForTests, computeOrgDomain } from "../telemetry-identity";
+import {
+  _resetTelemetryIdentityForTests,
+  cachedUserFunction,
+  computeOrgDomain,
+  primeUserRole,
+} from "../telemetry-identity";
 
 // initTelemetry no-ops when ANONYMIZED_TELEMETRY=false, and the CI env may set it.
 process.env.ANONYMIZED_TELEMETRY = "true";
 
 const TEST_DB_PATH = "./test-telemetry-context.sqlite";
+const PROFILE_KEYS = [
+  "SWARM_ORG_TEAM_SIZE",
+  "SWARM_ORG_USE_CASE",
+  "SWARM_ORG_ACQUISITION_SOURCE",
+] as const;
 
 async function removeTestDb(): Promise<void> {
   for (const suffix of ["", "-wal", "-shm"]) {
@@ -116,6 +128,30 @@ describe("telemetry context helpers", () => {
     expect(mapTriggerSurface(null)).toBe("other");
   });
 
+  test("buildContext omits invalid profile values and a function without an actor", () => {
+    const base = {
+      orgId: "org_0123456789abcdef",
+      installationId: "install_test",
+      isCloud: false,
+      isE2b: false,
+      swarmVersion: "1.2.3",
+    };
+    const context = buildContext({
+      ...base,
+      teamSize: "invalid",
+      useCase: "invalid",
+      acquisitionSource: "invalid",
+      userFunction: "founder",
+    });
+    expect(context).not.toHaveProperty("team_size");
+    expect(context).not.toHaveProperty("use_case");
+    expect(context).not.toHaveProperty("user_function");
+    expect(context.acquisition_source).toBeNull();
+    expect(
+      buildContext({ ...base, actor: { userId: "u-1" }, userFunction: "administrator" }),
+    ).not.toHaveProperty("user_function");
+  });
+
   test("normalizeProperties keeps an event alive when one optional value is unsendable", () => {
     const out = normalizeProperties("task.completed", {
       taskId: "t-1",
@@ -248,6 +284,19 @@ describe("telemetry envelope", () => {
     }
   });
 
+  test("track resolves the actor's job function without changing the RBAC role", async () => {
+    const config = memoryConfig({ telemetry_installation_id: "install_function" });
+    await initTelemetry("api-server", config.get, config.set, { generateIfMissing: true });
+    setTelemetryFunctionResolver(() => "founder");
+    track({
+      event: "workflow.deleted",
+      properties: { workflowId: "wf-1" },
+      actor: { userId: "u-1", role: "member" },
+    });
+    await tick();
+    expect(sent[0]?.context).toMatchObject({ user_function: "founder", user_role: "member" });
+  });
+
   test("an org with no ID yet sends nothing instead of a half-identified event", async () => {
     // A worker on an old server: installation ID known, no org ID stored.
     const config = memoryConfig({ telemetry_installation_id: "install_noorg" });
@@ -270,18 +319,95 @@ describe("telemetry envelope", () => {
 });
 
 describe("org email domain", () => {
+  const savedProfile = Object.fromEntries(PROFILE_KEYS.map((key) => [key, process.env[key]]));
+
   beforeEach(async () => {
     closeDb();
     await removeTestDb();
     initDb(TEST_DB_PATH);
     _resetTelemetryIdentityForTests();
+    for (const key of PROFILE_KEYS) delete process.env[key];
   });
 
   afterEach(async () => {
+    for (const key of PROFILE_KEYS) {
+      if (savedProfile[key] === undefined) delete process.env[key];
+      else process.env[key] = savedProfile[key];
+    }
     closeDb();
     await removeTestDb();
   });
 
+  test("stored company profile reaches context after reload and clears without restart", async () => {
+    const values = ["11-50", "features", "hacker_news"];
+    for (const [index, key] of PROFILE_KEYS.entries()) {
+      await upsertSwarmConfig({ scope: "global", key, value: values[index] as string });
+    }
+    await loadGlobalConfigsIntoEnv(true);
+    const originalFetch = globalThis.fetch;
+    const sent: Array<{ context: Record<string, unknown> }> = [];
+    globalThis.fetch = (async (_url: string, init?: { body?: string }) => {
+      if (init?.body) sent.push(JSON.parse(init.body));
+      return new Response(null, { status: 204 });
+    }) as typeof fetch;
+    _resetTelemetryStateForTests();
+    try {
+      const config = memoryConfig({
+        telemetry_installation_id: "install_profile",
+        telemetry_org_id: "org_0123456789abcdef",
+      });
+      await initTelemetry("api-server", config.get, config.set);
+      track({ event: "server.started", properties: { port: 3013 } });
+      expect(sent).toHaveLength(1);
+      expect(sent[0]?.context).toMatchObject({
+        team_size: "11-50",
+        use_case: "features",
+        acquisition_source: "hacker_news",
+      });
+      for (const key of PROFILE_KEYS) {
+        await upsertSwarmConfig({ scope: "global", key, value: "" });
+      }
+      await loadGlobalConfigsIntoEnv(true);
+      track({ event: "server.started", properties: { port: 3013 } });
+      expect(sent).toHaveLength(2);
+      expect(sent[1]?.context).not.toHaveProperty("team_size");
+      expect(sent[1]?.context).not.toHaveProperty("use_case");
+      expect(sent[1]?.context.acquisition_source).toBeNull();
+    } finally {
+      globalThis.fetch = originalFetch;
+      _resetTelemetryStateForTests();
+    }
+  });
+
+  test("job function uses the role cache and invalidates after a committed user update", async () => {
+    const user = await createUser({
+      name: "Founder",
+      role: "admin",
+      metadata: { jobFunction: "founder" },
+    });
+    await primeUserRole(user.id);
+    expect(cachedUserFunction(user.id)).toBe("founder");
+    await getDbClient().transaction(async () => {
+      await updateUser(user.id, { metadata: { jobFunction: "engineer" } });
+      expect(cachedUserFunction(user.id)).toBe("founder");
+    });
+    await primeUserRole(user.id);
+    expect(cachedUserFunction(user.id)).toBe("engineer");
+    await updateUser(user.id, { metadata: { jobFunction: "a free-text legacy role" } });
+    await primeUserRole(user.id);
+    expect(cachedUserFunction(user.id)).toBeUndefined();
+    const context = buildContext({
+      orgId: "org_0123456789abcdef",
+      installationId: "install_profile",
+      isCloud: false,
+      isE2b: false,
+      swarmVersion: "1.2.3",
+      actor: { userId: user.id },
+      userFunction: cachedUserFunction(user.id),
+    });
+    expect(context).not.toHaveProperty("user_function");
+  });
+
   test("is undefined with no users", async () => {
     expect(await computeOrgDomain()).toBeUndefined();
   });

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

@@ -1,4 +1,8 @@
 import { afterEach, beforeEach, describe, expect, test } from "bun:test";
+import { mkdirSync, mkdtempSync, rmSync } from "node:fs";
+import { tmpdir } from "node:os";
+import { join } from "node:path";
+import { pathToFileURL } from "node:url";
 import pkg from "../../package.json";
 import {
   _getInstallationIdForTests,
@@ -14,6 +18,7 @@ import {
   _resolveIntegrationProvider,
   _resolveIntegrationType,
   emitIntegrationConnected,
+  getTelemetryEnvironment,
   initTelemetry,
   telemetry,
   track,
@@ -686,8 +691,11 @@ describe("initTelemetry", () => {
     const originalFetch = globalThis.fetch;
     const originalNodeEnv = process.env.NODE_ENV;
     let captured: Record<string, unknown> | null = null;
+    let packageRoot: URL;
 
     beforeEach(() => {
+      packageRoot = pathToFileURL(`${mkdtempSync(join(tmpdir(), "telemetry-env-"))}/`);
+      process.env.NODE_ENV = "production";
       captured = null;
       globalThis.fetch = (async (_url: string, init?: { body?: string }) => {
         captured = init?.body ? JSON.parse(init.body) : null;
@@ -697,14 +705,59 @@ describe("initTelemetry", () => {
     });
 
     afterEach(() => {
+      rmSync(packageRoot, { recursive: true, force: true });
       globalThis.fetch = originalFetch;
       delete process.env.DESPLEGA_TELEMETRY_ENV;
       if (originalNodeEnv === undefined) delete process.env.NODE_ENV;
       else process.env.NODE_ENV = originalNodeEnv;
     });
 
+    test("track detects the real checkout through the default package root with an unprimed cache", async () => {
+      await initTelemetry(
+        "api-server",
+        async (key) => (key === "telemetry_installation_id" ? "install_checkout_env" : undefined),
+        async () => {},
+        { generateIfMissing: true },
+      );
+
+      track({ event: "test.event", properties: {} });
+      await new Promise((r) => setTimeout(r, 0));
+
+      const metadata = (captured as { metadata: Record<string, unknown> }).metadata;
+      expect(metadata.environment).toBe("development");
+    });
+
+    test("a .git directory marks a checkout as development", () => {
+      mkdirSync(new URL(".git", packageRoot));
+      expect(getTelemetryEnvironment(packageRoot)).toBe("development");
+      rmSync(new URL(".git", packageRoot), { recursive: true });
+      expect(getTelemetryEnvironment(packageRoot)).toBe("development");
+    });
+
+    test("a .git file marks a worktree as development", async () => {
+      await Bun.write(new URL(".git", packageRoot), "gitdir: /some/worktree");
+      expect(getTelemetryEnvironment(packageRoot)).toBe("development");
+    });
+
+    test("caches the checkout check across events", () => {
+      expect(getTelemetryEnvironment(packageRoot)).toBe("production");
+      mkdirSync(new URL(".git", packageRoot));
+      expect(getTelemetryEnvironment(packageRoot)).toBe("production");
+      process.env.DESPLEGA_TELEMETRY_ENV = "staging";
+      expect(getTelemetryEnvironment(packageRoot)).toBe("staging");
+    });
+
+    test("an unusable package root falls back to production without throwing", () => {
+      expect(getTelemetryEnvironment(new URL("data:text/plain,unavailable"))).toBe("production");
+    });
+
+    test("compiled binary paths default to production without throwing", () => {
+      expect(getTelemetryEnvironment(new URL("file:///$bunfs/root/"))).toBe("production");
+    });
+
     test("defaults to production even when NODE_ENV is development", async () => {
       process.env.NODE_ENV = "development";
+      expect(getTelemetryEnvironment(packageRoot)).toBe("production");
       await initTelemetry(
         "api-server",
         async (key) => (key === "telemetry_installation_id" ? "install_default_env" : undefined),
@@ -719,9 +772,11 @@ describe("initTelemetry", () => {
       expect(metadata.environment).toBe("production");
     });
 
-    test("uses DESPLEGA_TELEMETRY_ENV when set", async () => {
-      process.env.NODE_ENV = "production";
-      process.env.DESPLEGA_TELEMETRY_ENV = "development";
+    test("uses DESPLEGA_TELEMETRY_ENV over a git checkout and NODE_ENV=test", async () => {
+      mkdirSync(new URL(".git", packageRoot));
+      process.env.NODE_ENV = "test";
+      process.env.DESPLEGA_TELEMETRY_ENV = "staging";
+      expect(getTelemetryEnvironment(packageRoot)).toBe("staging");
       await initTelemetry(
         "api-server",
         async (key) => (key === "telemetry_installation_id" ? "install_explicit_env" : undefined),
@@ -733,11 +788,13 @@ describe("initTelemetry", () => {
       await new Promise((r) => setTimeout(r, 0));
 
       const metadata = (captured as { metadata: Record<string, unknown> }).metadata;
-      expect(metadata.environment).toBe("development");
+      expect(metadata.environment).toBe("staging");
     });
 
-    test("preserves NODE_ENV=test when telemetry env is unset", async () => {
+    test("preserves NODE_ENV=test over a git checkout when telemetry env is unset", async () => {
+      mkdirSync(new URL(".git", packageRoot));
       process.env.NODE_ENV = "test";
+      expect(getTelemetryEnvironment(packageRoot)).toBe("test");
       await initTelemetry(
         "api-server",
         async (key) => (key === "telemetry_installation_id" ? "install_test_env" : undefined),

package/src/tests/telemetry-ui-route.test.ts

@@ -5,6 +5,7 @@ import { isPublicRoute } from "../http/route-def";
 import { handleTelemetryUi } from "../http/telemetry-ui";
 import { getPathSegments, parseQueryParams } from "../http/utils";
 import { _resetTelemetryStateForTests, initTelemetry } from "../telemetry";
+import catalog from "../telemetry-contract/catalog.json";
 import { UI_EVENT_NAMES, validateUiEvent } from "../telemetry-ui-events";
 import type { HttpRequestAuth } from "../utils/request-auth-context";
 import { setRequestAuth } from "../utils/request-auth-context";
@@ -118,6 +119,128 @@ describe("POST /api/telemetry/ui-event", () => {
     expect(sent).toHaveLength(0);
   });
 
+  test.each([
+    { event: "identity.lookup", properties: { matched: true } },
+    ...["identity_modal", "setup"].map((surface) => ({
+      event: "identity.user_created",
+      properties: { surface, email_kind: "work", has_function: true, has_company: true },
+    })),
+    {
+      event: "fleet_benchmark.unlocked",
+      properties: { fields: ["website", "team_size", "use_case"] },
+    },
+    ...["compose", "docker", "kubernetes"].map((target) => ({
+      event: "setup.worker_command_copied",
+      properties: { target, harness: "codex" },
+    })),
+    ...[
+      "prompt",
+      "setup",
+      "settings",
+      "org_name_popup",
+      "feedback",
+      "fleet_benchmark",
+      "telemetry_banner",
+      "identity_modal",
+    ].map((surface) => ({
+      event: "org.profile_updated",
+      properties: {
+        fields: ["name", "website", "team_size", "use_case", "acquisition_source"],
+        surface,
+      },
+    })),
+    {
+      event: "popup.submitted",
+      properties: {
+        popup: "feedback",
+        has_message: false,
+        has_contact: false,
+        answered: 3,
+        perks: ["used_by", "slack_connect"],
+      },
+    },
+    ...["notification.viewed", "notification.dismissed", "notification.submitted"].flatMap(
+      (event) =>
+        ["task_failed", "first_workflow", "default"].map((moment) => ({
+          event,
+          properties: {
+            key: "slack_connect_invite",
+            moment,
+            ...(event === "notification.submitted" ? { user_function: "engineer" } : {}),
+          },
+        })),
+    ),
+  ])("accepts the company-profile catalog event $event with $properties", async ({
+    event,
+    properties,
+  }) => {
+    const result = await post({ event, properties });
+    await flush();
+    expect(result.statusCode).toBe(204);
+    expect(sent).toHaveLength(1);
+    expect(sent[0]).toMatchObject({ event, source: "ui", properties });
+  });
+
+  test.each([
+    {
+      event: "identity.user_created",
+      properties: {
+        surface: "invalid",
+        email_kind: "work",
+        has_function: true,
+        has_company: false,
+      },
+    },
+    { event: "setup.worker_command_copied", properties: { target: "invalid", harness: "codex" } },
+    { event: "org.profile_updated", properties: { fields: ["team_size"], surface: "invalid" } },
+    { event: "org.profile_updated", properties: { fields: ["invalid"], surface: "settings" } },
+    { event: "fleet_benchmark.unlocked", properties: { fields: ["invalid"] } },
+    {
+      event: "popup.submitted",
+      properties: { popup: "feedback", has_message: false, has_contact: false, perks: ["invalid"] },
+    },
+    {
+      event: "notification.submitted",
+      properties: { key: "slack_connect_invite", moment: "invalid" },
+    },
+    {
+      event: "notification.submitted",
+      properties: { key: "slack_connect_invite", user_function: "invalid" },
+    },
+  ])("rejects a bad enum in $event with $properties", async ({ event, properties }) => {
+    const result = await post({ event, properties });
+    expect(result.statusCode).toBe(400);
+    expect(sent).toHaveLength(0);
+  });
+
+  test("array item references enforce the referenced enum", async () => {
+    const entry = catalog.events.find((entry) => entry.event === "fleet_benchmark.unlocked")!;
+    const fields = entry.properties.fields!;
+    const original = fields.items;
+    // Exercise a referenced item definition without changing the vendored catalog.
+    Object.assign(fields, { items: { ref: "use_case" } });
+    try {
+      expect(
+        (
+          await post({
+            event: "fleet_benchmark.unlocked",
+            properties: { fields: ["features"] },
+          })
+        ).statusCode,
+      ).toBe(204);
+      sent = [];
+      const result = await post({
+        event: "fleet_benchmark.unlocked",
+        properties: { fields: ["invalid"] },
+      });
+      expect(result.statusCode).toBe(400);
+      expect(result.body).toContain("items must be one of");
+      expect(sent).toHaveLength(0);
+    } finally {
+      fields.items = original;
+    }
+  });
+
   test("an unknown event name gets 400 and sends nothing", async () => {
     const result = await post({ event: "task.created", properties: {} });
     await flush();

package/src/tests/tool-annotations.test.ts

@@ -376,9 +376,10 @@ describe("Tool Annotations & Classification", () => {
     // (this suite forces ALL_CAPABILITIES, including default-disabled ones).
     // Includes 11 skill tools, 7 MCP server tools, reusable script tools, and the
     // native Kapso/WhatsApp tools (register/unregister number + send/reply message),
-    // and the six Chat SDK tools (chat-* + register/unregister-chat-channel).
+    // the six Chat SDK tools (chat-* + register/unregister-chat-channel),
+    // and the seven app row tools plus app-action-run.
     expect(count).toBeGreaterThanOrEqual(45);
-    expect(count).toBeLessThanOrEqual(163);
+    expect(count).toBeLessThanOrEqual(169);
   });
 
   test("core tools are fewer than deferred tools", () => {