@desplega.ai/agent-swarm 1.161.0 → 1.162.0

package/src/tests/comb-status.test.ts

@@ -0,0 +1,152 @@
+import { afterAll, afterEach, beforeAll, beforeEach, describe, expect, test } from "bun:test";
+import { unlink } from "node:fs/promises";
+import { closeDb, initDb } from "../be/db";
+import { resetFileStorageProvider } from "../fs/registry";
+import { buildStatusPayload } from "../http/status";
+
+const TEST_DB_PATH = "./test-comb-status.sqlite";
+
+const ENV_KEYS = [
+  "COMB_ENABLED",
+  "AGENT_FS_API_URL",
+  "AGENT_FS_PUBLIC_URL",
+  "AGENT_FS_LIVE_URL",
+  "AGENT_FS_DEFAULT_ORG_ID",
+  "AGENT_FS_DEFAULT_DRIVE_ID",
+  "API_AGENT_FS_API_KEY",
+  "AGENT_FS_API_KEY",
+];
+const savedEnv = new Map<string, string | undefined>();
+
+async function removeDbFiles(): Promise<void> {
+  for (const suffix of ["", "-wal", "-shm"]) {
+    await unlink(TEST_DB_PATH + suffix).catch(() => {});
+  }
+}
+
+function restoreEnv(): void {
+  for (const key of ENV_KEYS) {
+    const value = savedEnv.get(key);
+    if (value === undefined) delete process.env[key];
+    else process.env[key] = value;
+  }
+}
+
+async function comb() {
+  return (await buildStatusPayload()).agent_fs.comb;
+}
+
+beforeAll(async () => {
+  for (const key of ENV_KEYS) savedEnv.set(key, process.env[key]);
+  await removeDbFiles();
+  initDb(TEST_DB_PATH);
+});
+
+afterAll(async () => {
+  closeDb();
+  await removeDbFiles();
+  restoreEnv();
+});
+
+beforeEach(() => {
+  for (const key of ENV_KEYS) delete process.env[key];
+  resetFileStorageProvider();
+});
+
+afterEach(() => {
+  restoreEnv();
+  resetFileStorageProvider();
+});
+
+describe("/status agent_fs.comb", () => {
+  test("is off by default", async () => {
+    process.env.AGENT_FS_API_URL = "http://agent-fs:7433";
+    const result = await comb();
+    expect(result.enabled).toBe(false);
+    expect(result.api_url).toBe("http://agent-fs:7433");
+  });
+
+  test("stays off with the flag on but no AGENT_FS_API_URL", async () => {
+    process.env.COMB_ENABLED = "true";
+    process.env.AGENT_FS_PUBLIC_URL = "http://localhost:7433";
+    expect((await comb()).enabled).toBe(false);
+  });
+
+  test("turns on with the flag and AGENT_FS_API_URL", async () => {
+    process.env.AGENT_FS_API_URL = "http://agent-fs:7433";
+    for (const value of ["true", " TRUE ", "1"]) {
+      process.env.COMB_ENABLED = value;
+      expect((await comb()).enabled).toBe(true);
+    }
+    for (const value of ["false", "0", "yes", ""]) {
+      process.env.COMB_ENABLED = value;
+      expect((await comb()).enabled).toBe(false);
+    }
+  });
+
+  test("AGENT_FS_PUBLIC_URL wins over AGENT_FS_API_URL, without a trailing slash", async () => {
+    process.env.COMB_ENABLED = "true";
+    process.env.AGENT_FS_API_URL = "http://agent-fs:7433/";
+    expect((await comb()).api_url).toBe("http://agent-fs:7433");
+    process.env.AGENT_FS_PUBLIC_URL = "https://files.example.com/";
+    expect((await comb()).api_url).toBe("https://files.example.com");
+  });
+
+  test("ids come from AGENT_FS_DEFAULT_*, and live_url from AGENT_FS_LIVE_URL", async () => {
+    process.env.COMB_ENABLED = "true";
+    process.env.AGENT_FS_API_URL = "http://agent-fs:7433";
+    let result = await comb();
+    expect(result.org_id).toBeNull();
+    expect(result.drive_id).toBeNull();
+    expect(result.live_url).toBe("https://live.agent-fs.dev");
+
+    process.env.AGENT_FS_DEFAULT_ORG_ID = "org-1";
+    process.env.AGENT_FS_DEFAULT_DRIVE_ID = "drive-1";
+    process.env.AGENT_FS_LIVE_URL = "https://live.example.com/";
+    result = await comb();
+    expect(result).toEqual({
+      enabled: true,
+      api_url: "http://agent-fs:7433",
+      live_url: "https://live.example.com",
+      org_id: "org-1",
+      drive_id: "drive-1",
+      service_user_id: null,
+    });
+  });
+
+  test("service_user_id is the bootstrap key's agent-fs user, asked once", async () => {
+    let meCalls = 0;
+    const agentFs = Bun.serve({
+      port: 0,
+      fetch: (request) => {
+        if (new URL(request.url).pathname !== "/auth/me") return new Response("", { status: 404 });
+        meCalls++;
+        return request.headers.get("authorization") === "Bearer af_boot"
+          ? Response.json({ userId: "svc-user", email: "swarm-admin@agent-fs.local" })
+          : Response.json({ error: "UNAUTHORIZED" }, { status: 401 });
+      },
+    });
+    try {
+      process.env.AGENT_FS_API_URL = `http://localhost:${agentFs.port}`;
+      process.env.API_AGENT_FS_API_KEY = "af_boot";
+      process.env.AGENT_FS_DEFAULT_ORG_ID = "org-1";
+      process.env.AGENT_FS_DEFAULT_DRIVE_ID = "drive-1";
+
+      // Comb off: no lookup.
+      expect((await comb()).service_user_id).toBeNull();
+      expect(meCalls).toBe(0);
+
+      process.env.COMB_ENABLED = "true";
+      expect((await comb()).service_user_id).toBe("svc-user");
+      expect((await comb()).service_user_id).toBe("svc-user");
+      expect(meCalls).toBe(1);
+
+      // A rejected key reports null instead of failing /status.
+      process.env.API_AGENT_FS_API_KEY = "af_other";
+      resetFileStorageProvider();
+      expect((await comb()).service_user_id).toBeNull();
+    } finally {
+      agentFs.stop(true);
+    }
+  });
+});

package/src/tests/db-task-read-contract.test.ts

@@ -441,6 +441,7 @@ value:installSkill
 value:installSystemDefaultSkillsForAgent
 value:isAgentEligibleForTask
 value:isExtensionAgent
+value:isLinearTrackerContextKey
 value:isPendingSlackMessage
 value:isPoolAffinityEnforcementEnabled
 value:isSettledSlackMessage
@@ -621,6 +622,7 @@ value:getTasksByStatus
 value:getTasksCount
 value:hasNonTerminalRerouteDecisionChild
 value:hasNonTerminalResumeChild
+value:isLinearTrackerContextKey
 value:markFinalizedSlackRelaysDelivered
 value:markSlackRelayAttempted
 value:markSlackRelayDelivered

package/src/tests/db-task-write-contract.test.ts

@@ -464,6 +464,7 @@ value:installSkill
 value:installSystemDefaultSkillsForAgent
 value:isAgentEligibleForTask
 value:isExtensionAgent
+value:isLinearTrackerContextKey
 value:isPendingSlackMessage
 value:isPoolAffinityEnforcementEnabled
 value:isSettledSlackMessage

package/src/tests/docs-index-footprint.test.js

@@ -78,7 +78,7 @@ describe("docs API index footprint", () => {
     expect(tasks).toContain('"path":"/api/task-templates","method":"get"');
   });
 
-  test("OpenAPI and generated pages keep all 392 operations", async () => {
+  test("OpenAPI and generated pages keep all 394 operations", async () => {
     const spec = await Bun.file(resolve(repoRoot, "openapi.json")).json();
     const operationKeys = [];
     const tags = new Set();
@@ -103,8 +103,8 @@ describe("docs API index footprint", () => {
     expect(spec.paths["/api/agents/{id}/runtime"]?.get).toBeDefined();
 
     const generatedKeys = await generatedOperationKeys();
-    expect(operationKeys).toHaveLength(392);
-    expect(generatedKeys).toHaveLength(392);
+    expect(operationKeys).toHaveLength(394);
+    expect(generatedKeys).toHaveLength(394);
     expect(new Set(generatedKeys)).toEqual(new Set(operationKeys));
   });
 

package/src/tests/dsh-adapter.test.ts

@@ -354,7 +354,7 @@ describe("dsh harness", () => {
     await rename(join(config.cwd, "dsh"), join(config.cwd, "npx"));
     config.env = { ...config.env, DSH_BINARY: "", PATH: config.cwd };
     await expect(new DshAdapter().createSession(config)).rejects.toThrow(
-      "dsh CLI not found. Install @deepseek-ai/dsh@0.2.0-rc.2",
+      "dsh CLI not found. Install @deepseek-ai/dsh@0.2.1-alpha.1",
     );
     expect(await Bun.file(join(config.cwd, "invocation.json")).exists()).toBe(false);
   });

package/src/tests/favorites-agent-fs-path.test.ts

@@ -0,0 +1,226 @@
+import { Database } from "bun:sqlite";
+import { afterAll, beforeAll, describe, expect, test } from "bun:test";
+import { unlink } from "node:fs/promises";
+import { join } from "node:path";
+import { Readable } from "node:stream";
+import { closeDb, getDb, initDb } from "../be/db";
+import { runMigrations } from "../be/migrations/runner";
+import { handleFavorites } from "../http/favorites";
+import { getPathSegments, parseQueryParams } from "../http/utils";
+import { setRequestAuth } from "../utils/request-auth-context";
+
+// Migration 192 adds the Comb pin item type `agent-fs-path` to user_favorites.
+
+const TEST_DB_PATH = "./test-favorites-agent-fs-path.sqlite";
+const MIGRATIONS_DIR = join(import.meta.dir, "../be/migrations");
+
+async function removeDb(path: string): Promise<void> {
+  for (const suffix of ["", "-wal", "-shm"]) {
+    try {
+      await unlink(`${path}${suffix}`);
+    } catch {}
+  }
+}
+
+function jsonReq(method: string, url: string, body?: unknown) {
+  const raw = body === undefined ? "" : JSON.stringify(body);
+  const req = Readable.from(raw ? [Buffer.from(raw)] : []) as Readable & {
+    method: string;
+    url: string;
+    headers: Record<string, string>;
+  };
+  req.method = method;
+  req.url = url;
+  req.headers = { "content-type": "application/json" };
+  setRequestAuth(req, { kind: "operator", fingerprint: "op:test-comb-pins" });
+  return req;
+}
+
+async function call(method: string, url: string, body?: unknown) {
+  const req = jsonReq(method, url, body);
+  let statusCode = 200;
+  const chunks: string[] = [];
+  const res = {
+    setHeader: () => {},
+    writeHead: (code: number) => {
+      statusCode = code;
+    },
+    end: (chunk?: string) => {
+      if (chunk) chunks.push(chunk);
+    },
+  };
+  await handleFavorites(
+    req,
+    res as never,
+    getPathSegments(req.url),
+    parseQueryParams(req.url),
+    undefined,
+  );
+  return { statusCode, body: chunks.length > 0 ? JSON.parse(chunks.join("")) : null };
+}
+
+describe("favorites: agent-fs-path item type (fresh DB)", () => {
+  beforeAll(async () => {
+    await removeDb(TEST_DB_PATH);
+    initDb(TEST_DB_PATH);
+  });
+
+  afterAll(async () => {
+    closeDb();
+    await removeDb(TEST_DB_PATH);
+  });
+
+  test("PUT pins a folder and a file, GET lists them back", async () => {
+    for (const itemId of ["org/drive/comb-qa/", "org/drive/comb-qa/my notes 100%.md"]) {
+      const put = await call("PUT", "/api/favorites", {
+        itemType: "agent-fs-path",
+        itemId,
+        favorite: true,
+      });
+      expect(put).toMatchObject({
+        statusCode: 200,
+        body: { favorite: true, itemType: "agent-fs-path", itemId },
+      });
+    }
+
+    const list = await call("GET", "/api/favorites?itemType=agent-fs-path");
+    expect(list.statusCode).toBe(200);
+    expect([...list.body.favoriteIds].sort()).toEqual([
+      "org/drive/comb-qa/",
+      "org/drive/comb-qa/my notes 100%.md",
+    ]);
+    for (const row of list.body.favorites) expect(row.itemType).toBe("agent-fs-path");
+
+    // Other item types do not see the pins.
+    expect((await call("GET", "/api/favorites?itemType=page")).body.favoriteIds).toEqual([]);
+  });
+
+  test("PUT with favorite=false unpins", async () => {
+    await call("PUT", "/api/favorites", {
+      itemType: "agent-fs-path",
+      itemId: "org/drive/comb-qa/",
+      favorite: false,
+    });
+    const list = await call("GET", "/api/favorites?itemType=agent-fs-path");
+    expect(list.body.favoriteIds).toEqual(["org/drive/comb-qa/my notes 100%.md"]);
+  });
+
+  test("GET lists pins newest first", async () => {
+    const db = getDb();
+    const ids = ["org/drive/order/a.md", "org/drive/order/b.md", "org/drive/order/c.md"];
+    for (const [i, itemId] of ids.entries()) {
+      await call("PUT", "/api/favorites", { itemType: "agent-fs-path", itemId, favorite: true });
+      db.run(
+        "UPDATE user_favorites SET lastUpdatedAt = ? WHERE itemType = 'agent-fs-path' AND itemId = ?",
+        [`2030-01-0${i + 1}T00:00:00.000Z`, itemId],
+      );
+    }
+    const list = await call("GET", "/api/favorites?itemType=agent-fs-path");
+    const listed = list.body.favoriteIds.filter((id: string) => id.startsWith("org/drive/order/"));
+    expect(listed).toEqual([...ids].reverse());
+  });
+
+  test("an unknown item type is still rejected", async () => {
+    const put = await call("PUT", "/api/favorites", {
+      itemType: "agent-fs-file",
+      itemId: "org/drive/a.md",
+      favorite: true,
+    });
+    expect(put.statusCode).toBe(400);
+    const list = await call("GET", "/api/favorites?itemType=agent-fs-file");
+    expect(list.statusCode).toBe(400);
+  });
+});
+
+describe("migration 192 (existing DB)", () => {
+  // In memory: the full migration chain on a file DB passed the 10 s test timeout on a loaded CI shard.
+  test("keeps every favorite row and the indexes, and widens the CHECK", async () => {
+    const db = new Database(":memory:");
+    try {
+      runMigrations(db);
+
+      // Roll back to the pre-192 shape: re-run 116 on the empty table (it
+      // rebuilds user_favorites with the old CHECK and the same indexes).
+      db.exec(await Bun.file(join(MIGRATIONS_DIR, "116_favorite_principal_scope.sql")).text());
+      db.run("DELETE FROM _migrations WHERE version = 192");
+      expect(() =>
+        db.run(
+          "INSERT INTO user_favorites (favoriteScope, itemType, itemId) VALUES ('operator:x', 'agent-fs-path', 'o/d/a.md')",
+        ),
+      ).toThrow(/CHECK constraint failed/);
+
+      db.run("INSERT INTO users (id, name) VALUES ('user-1', 'Pin User')");
+      const insert = db.prepare(
+        `INSERT INTO user_favorites
+           (id, favoriteScope, userId, itemType, itemId, createdAt, lastUpdatedAt, created_by, updated_by)
+         VALUES (?, ?, ?, ?, ?, ?, ?, ?, ?)`,
+      );
+      // Page, workflow, and schedule favorites for a user scope and the
+      // operator scope, with distinct timestamps and audit values per row.
+      let n = 0;
+      for (const [scope, userId] of [
+        ["user:user-1", "user-1"],
+        ["operator", null],
+      ] as const) {
+        for (const itemType of ["page", "workflow", "schedule"]) {
+          n++;
+          insert.run(
+            `fav-${n}`,
+            scope,
+            userId,
+            itemType,
+            `${itemType}-${n}`,
+            `2026-09-0${n}T00:00:00.000Z`,
+            `2026-09-1${n}T00:00:00.000Z`,
+            n % 2 ? "op:abc" : null,
+            n % 3 ? userId : null,
+          );
+        }
+      }
+      const before = db.query("SELECT * FROM user_favorites ORDER BY id").all();
+      expect(before).toHaveLength(6);
+
+      runMigrations(db);
+
+      expect(db.query("SELECT version FROM _migrations WHERE version = 192").get()).not.toBeNull();
+      expect(db.query("SELECT * FROM user_favorites ORDER BY id").all()).toEqual(before);
+
+      const indexes = db
+        .query<{ name: string; unique: number }, []>("PRAGMA index_list(user_favorites)")
+        .all();
+      expect(indexes.map((index) => index.name)).toEqual(
+        expect.arrayContaining([
+          "idx_user_favorites_scope_type",
+          "idx_user_favorites_user_type",
+          "idx_user_favorites_item",
+        ]),
+      );
+      // The UNIQUE (favoriteScope, itemType, itemId) constraint survives.
+      const unique = indexes
+        .filter((index) => index.unique === 1)
+        .map((index) =>
+          db
+            .query<{ name: string }, []>(`PRAGMA index_info("${index.name}")`)
+            .all()
+            .map((column) => column.name),
+        );
+      expect(unique).toContainEqual(["favoriteScope", "itemType", "itemId"]);
+
+      // The new type is accepted, an unknown type is still rejected.
+      db.run(
+        "INSERT INTO user_favorites (favoriteScope, itemType, itemId) VALUES ('operator', 'agent-fs-path', 'o/d/comb-qa/')",
+      );
+      expect(() =>
+        db.run(
+          "INSERT INTO user_favorites (favoriteScope, itemType, itemId) VALUES ('operator', 'bogus', 'x')",
+        ),
+      ).toThrow(/CHECK constraint failed/);
+
+      // The user FK still cascades.
+      db.run("DELETE FROM users WHERE id = 'user-1'");
+      expect(db.query("SELECT id FROM user_favorites WHERE userId = 'user-1'").all()).toEqual([]);
+    } finally {
+      db.close();
+    }
+  });
+});

package/src/tests/memory-link-resolver.test.ts

@@ -61,6 +61,40 @@ describe("resolveLinks", () => {
     expect(fsLinks[0]!.resolver).toBe("agent-fs-path");
   });
 
+  test("a dashboard (Comb) file link resolves to the same target as the live URL", () => {
+    const route =
+      "/file/~/648a5f3c-35c8-4f11-8673-b89de52cd6bd/2faf73ba-4eee-4472-8b3b-359c4ed6bfbb/thoughts/final%20plan.md";
+    const savedAppUrl = process.env.APP_URL;
+    const savedDashboardUrl = process.env.DASHBOARD_URL;
+    process.env.APP_URL = "https://swarm.example.com/dash/";
+    delete process.env.DASHBOARD_URL;
+    try {
+      const fsTargets = (content: string) =>
+        resolveLinks(content)
+          .filter((l) => l.linkType === "agent-fs-file")
+          .map((l) => ({ targetId: l.targetId, metadata: l.metadata }));
+      const live = fsTargets(`Plan at https://live.agent-fs.dev${route}`);
+      expect(live).toHaveLength(1);
+      expect(fsTargets(`Plan at https://swarm.example.com/dash${route}`)).toEqual(live);
+      expect(fsTargets(`Plan at http://localhost:5274${route}`)).toEqual(live);
+      // Another host, or the app host without its path prefix, is not a file link.
+      expect(fsTargets(`Plan at https://other.example.com${route}`)).toEqual([]);
+      expect(fsTargets(`Plan at https://swarm.example.com${route}`)).toEqual([]);
+      // A known host must start the host name.
+      expect(fsTargets(`Plan at https://evil-swarm.example.com/dash${route}`)).toEqual([]);
+      expect(fsTargets(`Plan at https://notlocalhost:9${route}`)).toEqual([]);
+      expect(fsTargets(`Plan at https://myagent-fs${route}`)).toEqual([]);
+      // Hosts are case-insensitive.
+      expect(fsTargets(`Plan at https://SWARM.Example.com/dash${route}`)).toEqual(live);
+      expect(fsTargets(`Plan at https://LIVE.AGENT-FS.DEV${route}`)).toEqual(live);
+    } finally {
+      if (savedAppUrl === undefined) delete process.env.APP_URL;
+      else process.env.APP_URL = savedAppUrl;
+      if (savedDashboardUrl === undefined) delete process.env.DASHBOARD_URL;
+      else process.env.DASHBOARD_URL = savedDashboardUrl;
+    }
+  });
+
   test("extracts agent-ui page links", () => {
     const links = resolveLinks(
       "See app.agent-swarm.dev/pages/abc12345-1234-1234-1234-123456789abc",

package/src/tests/onboarding.test.ts

@@ -613,6 +613,114 @@ describe("onboarding memory probe", () => {
     });
   });
 
+  test("splits a 404 into a missing path and a missing model or deployment", async () => {
+    const cases = [
+      {
+        // Azure without `/openai/v1`.
+        body: { error: { code: "404", message: "Resource not found" } },
+        errorClass: "endpoint",
+        error: "The endpoint path was not found (404). Check the base URL.",
+      },
+      {
+        // A proxy or server page with no JSON body.
+        body: "404 page not found",
+        errorClass: "endpoint",
+        error: "The endpoint path was not found (404). Check the base URL.",
+      },
+      {
+        body: {
+          error: {
+            message: "The model `nope` does not exist or you do not have access to it.",
+            type: "invalid_request_error",
+            code: "model_not_found",
+          },
+        },
+        errorClass: "model",
+        error: "The endpoint could not find the embedding model or deployment (404).",
+      },
+      {
+        body: {
+          error: {
+            code: "DeploymentNotFound",
+            message: "The API deployment for this resource does not exist.",
+          },
+        },
+        errorClass: "model",
+        error: "The endpoint could not find the embedding model or deployment (404).",
+      },
+    ] as const;
+
+    for (const testCase of cases) {
+      const fake = startEmbeddingServer(() =>
+        typeof testCase.body === "string"
+          ? new Response(testCase.body, { status: 404 })
+          : Response.json(testCase.body, { status: 404 }),
+      );
+      try {
+        const response = await request("/api/onboarding/memory", {
+          method: "POST",
+          body: {
+            preset: "azure",
+            baseUrl: fake.baseUrl,
+            model: "my-embedding-deployment",
+            apiKey: "azure-resource-key",
+          },
+        });
+        expect(response.status).toBe(200);
+        expect(await response.json()).toMatchObject({
+          ok: false,
+          errorClass: testCase.errorClass,
+          error: testCase.error,
+        });
+      } finally {
+        fake.server.stop(true);
+      }
+    }
+    // A failed step keeps its first error class.
+    expect((await getState()).steps.memory).toMatchObject({
+      status: "failed",
+      errorClass: "endpoint",
+    });
+  });
+
+  test("the azure preset saves its base URL and deployment name", async () => {
+    let path = "";
+    let model = "";
+    const fake = Bun.serve({
+      hostname: "127.0.0.1",
+      port: 0,
+      async fetch(req) {
+        path = new URL(req.url).pathname;
+        model = ((await req.json()) as { model: string }).model;
+        return embeddingResponse(512);
+      },
+    });
+    try {
+      const baseUrl = `http://127.0.0.1:${fake.port}/openai/v1`;
+      const response = await request("/api/onboarding/memory", {
+        method: "POST",
+        body: {
+          preset: "azure",
+          baseUrl,
+          model: "my-embedding-deployment",
+          apiKey: "azure-resource-key",
+        },
+      });
+      expect(await response.json()).toMatchObject({ ok: true, dimensions: 512 });
+      expect(path).toBe("/openai/v1/embeddings");
+      expect(model).toBe("my-embedding-deployment");
+      const configs = await getSwarmConfigs({ scope: "global" });
+      const saved = Object.fromEntries(configs.map((config) => [config.key, config.value]));
+      expect(saved).toMatchObject({
+        EMBEDDING_API_BASE_URL: baseUrl,
+        EMBEDDING_MODEL: "my-embedding-deployment",
+      });
+      expect((await getState()).steps.memory).toMatchObject({ status: "done", method: "azure" });
+    } finally {
+      fake.stop(true);
+    }
+  });
+
   test("a wrong dimension keeps memory done after a successful probe", async () => {
     let dimensions = 512;
     const fake = startEmbeddingServer(() => embeddingResponse(dimensions));