@desplega.ai/agent-swarm 1.92.0 → 1.92.2

package/src/tests/skill-get-file-tool.test.ts

@@ -0,0 +1,110 @@
+import { afterAll, beforeAll, describe, expect, test } from "bun:test";
+import { unlink } from "node:fs/promises";
+import { McpServer } from "@modelcontextprotocol/sdk/server/mcp.js";
+import { closeDb, createSkill, initDb, upsertSkillFile } from "../be/db";
+import { registerSkillGetFileTool } from "../tools/skills/skill-get-file";
+
+const TEST_DB_PATH = `./test-skill-get-file-tool-${process.pid}.sqlite`;
+const CALLER_AGENT_ID = "bbbb0000-0000-4000-8000-000000000020";
+
+type StructuredContent = {
+  yourAgentId?: string;
+  success: boolean;
+  message: string;
+  file?: { skillId: string; path: string; content: string };
+};
+
+async function removeDbFiles(path: string): Promise<void> {
+  for (const suffix of ["", "-wal", "-shm"]) {
+    await unlink(path + suffix).catch(() => {});
+  }
+}
+
+async function callSkillGetFile(
+  server: McpServer,
+  args: Record<string, unknown>,
+): Promise<{
+  structuredContent: StructuredContent;
+  content: Array<{ type: string; text: string }>;
+}> {
+  // biome-ignore lint/complexity/noBannedTypes: accessing internal MCP SDK type for test
+  const tools = (server as unknown as { _registeredTools: Record<string, { handler: Function }> })
+    ._registeredTools;
+  const handler = tools["skill-get-file"].handler;
+
+  const result = await handler(args, {
+    sessionId: "test-session",
+    requestInfo: {
+      headers: {
+        "x-agent-id": CALLER_AGENT_ID,
+      },
+    },
+  });
+  return result as {
+    structuredContent: StructuredContent;
+    content: Array<{ type: string; text: string }>;
+  };
+}
+
+describe("skill-get-file tool", () => {
+  let server: McpServer;
+  let skillId: string;
+
+  beforeAll(async () => {
+    await removeDbFiles(TEST_DB_PATH);
+    initDb(TEST_DB_PATH);
+
+    server = new McpServer({ name: "skill-get-file-test", version: "1.0.0" });
+    registerSkillGetFileTool(server);
+
+    const skill = createSkill({
+      name: "tool-file-skill",
+      description: "Tool file skill",
+      content: "---\nname: tool-file-skill\ndescription: Tool file skill\n---\n\nBody.",
+      type: "personal",
+      scope: "agent",
+      isComplex: true,
+    });
+    skillId = skill.id;
+    upsertSkillFile(skill.id, {
+      path: "references/guide.md",
+      content: "# Guide",
+      mimeType: "text/markdown",
+    });
+  });
+
+  afterAll(async () => {
+    closeDb();
+    await removeDbFiles(TEST_DB_PATH);
+  });
+
+  test("fetches a bundled skill file by skillId and path", async () => {
+    const result = await callSkillGetFile(server, {
+      skillId,
+      path: "references/guide.md",
+    });
+
+    expect(result.structuredContent).toMatchObject({
+      yourAgentId: CALLER_AGENT_ID,
+      success: true,
+      file: {
+        skillId,
+        path: "references/guide.md",
+        content: "# Guide",
+      },
+    });
+    expect(result.content[0].text).toContain("# Guide");
+  });
+
+  test("returns structured failure for missing file", async () => {
+    const result = await callSkillGetFile(server, {
+      skillId,
+      path: "references/missing.md",
+    });
+
+    expect(result.structuredContent).toMatchObject({
+      success: false,
+      message: "Skill file not found.",
+    });
+  });
+});

package/src/tests/skill-sync.test.ts

@@ -2,8 +2,8 @@ import { afterAll, beforeAll, describe, expect, test } from "bun:test";
 import { existsSync, mkdirSync, readFileSync, rmSync, writeFileSync } from "node:fs";
 import { unlink } from "node:fs/promises";
 import { tmpdir } from "node:os";
-import { join } from "node:path";
-import { closeDb, createAgent, createSkill, initDb, installSkill } from "../be/db";
+import { dirname, join } from "node:path";
+import { closeDb, createAgent, createSkill, initDb, installSkill, upsertSkillFile } from "../be/db";
 import { syncSkillsToFilesystem } from "../be/skill-sync";
 
 const SWARM_MARKER = ".swarm-managed";
@@ -38,7 +38,7 @@ describe("syncSkillsToFilesystem", () => {
     });
     installSkill(agentId, skill.id);
 
-    // Create a complex skill (should be skipped)
+    // Create a legacy complex skill with no stored files (should be skipped)
     const complexSkill = createSkill({
       name: "complex-skill",
       description: "A complex skill",
@@ -49,6 +49,28 @@ describe("syncSkillsToFilesystem", () => {
     });
     installSkill(agentId, complexSkill.id);
 
+    const dbBackedComplexSkill = createSkill({
+      name: "complex-db-skill",
+      description: "A DB-backed complex skill",
+      content: "---\nname: complex-db-skill\ndescription: A DB-backed complex skill\n---\n\nBody.",
+      type: "remote",
+      scope: "global",
+      isComplex: true,
+    });
+    installSkill(agentId, dbBackedComplexSkill.id);
+    upsertSkillFile(dbBackedComplexSkill.id, {
+      path: "references/guide.md",
+      content: "# Guide\n\nBundled reference.",
+      mimeType: "text/markdown",
+    });
+    upsertSkillFile(dbBackedComplexSkill.id, {
+      path: "assets/logo.png",
+      content: "[binary file - not synced]",
+      mimeType: "image/png",
+      isBinary: true,
+      size: 2048,
+    });
+
     mkdirSync(FAKE_HOME, { recursive: true });
   });
 
@@ -108,7 +130,7 @@ describe("syncSkillsToFilesystem", () => {
     const result = syncSkillsToFilesystem(agentId, "all", FAKE_HOME);
 
     expect(result.errors).toHaveLength(0);
-    expect(result.synced).toBe(3); // 1 skill × 3 dirs
+    expect(result.synced).toBe(6); // 2 DB-backed skills × 3 dirs
 
     const claudeFile = join(FAKE_HOME, ".claude", "skills", "test-skill", "SKILL.md");
     const piFile = join(FAKE_HOME, ".pi", "agent", "skills", "test-skill", "SKILL.md");
@@ -118,13 +140,110 @@ describe("syncSkillsToFilesystem", () => {
     expect(existsSync(codexFile)).toBe(true);
   });
 
-  test("skips complex skills", () => {
+  test("syncs DB-backed complex skill files and skips binary placeholders", () => {
+    rmSync(join(FAKE_HOME, ".claude"), { recursive: true, force: true });
+
+    const result = syncSkillsToFilesystem(agentId, "claude", FAKE_HOME);
+
+    expect(result.errors).toHaveLength(0);
+
+    const skillFile = join(FAKE_HOME, ".claude", "skills", "complex-db-skill", "SKILL.md");
+    const bundledFile = join(
+      FAKE_HOME,
+      ".claude",
+      "skills",
+      "complex-db-skill",
+      "references",
+      "guide.md",
+    );
+    const binaryFile = join(
+      FAKE_HOME,
+      ".claude",
+      "skills",
+      "complex-db-skill",
+      "assets",
+      "logo.png",
+    );
+    expect(existsSync(skillFile)).toBe(true);
+    expect(readFileSync(bundledFile, "utf-8")).toContain("Bundled reference.");
+    expect(existsSync(binaryFile)).toBe(false);
+  });
+
+  test("removes stale bundled files from swarm-managed skill directories", () => {
+    rmSync(join(FAKE_HOME, ".claude"), { recursive: true, force: true });
+
+    const result = syncSkillsToFilesystem(agentId, "claude", FAKE_HOME);
+    expect(result.errors).toHaveLength(0);
+
+    const skillDir = join(FAKE_HOME, ".claude", "skills", "complex-db-skill");
+    const staleFile = join(skillDir, "references", "old-guide.md");
+    const currentFile = join(skillDir, "references", "guide.md");
+    const staleBinary = join(skillDir, "assets", "logo.png");
+    mkdirSync(dirname(staleFile), { recursive: true });
+    mkdirSync(dirname(staleBinary), { recursive: true });
+    writeFileSync(staleFile, "stale");
+    writeFileSync(staleBinary, "previous binary payload");
+
+    const nextResult = syncSkillsToFilesystem(agentId, "claude", FAKE_HOME);
+
+    expect(nextResult.errors).toHaveLength(0);
+    expect(nextResult.removed).toBeGreaterThanOrEqual(2);
+    expect(existsSync(staleFile)).toBe(false);
+    expect(existsSync(staleBinary)).toBe(false);
+    expect(readFileSync(currentFile, "utf-8")).toContain("Bundled reference.");
+  });
+
+  test("skips legacy complex skills without stored files", () => {
     const _result = syncSkillsToFilesystem(agentId, "claude", FAKE_HOME);
 
     const complexDir = join(FAKE_HOME, ".claude", "skills", "complex-skill");
     expect(existsSync(complexDir)).toBe(false);
   });
 
+  test("continues syncing bundled files after one file write fails", () => {
+    const failSkill = createSkill({
+      name: "complex-fail-safe",
+      description: "Complex skill with one blocked file",
+      content:
+        "---\nname: complex-fail-safe\ndescription: Complex skill with one blocked file\n---\n\nBody.",
+      type: "remote",
+      scope: "global",
+      isComplex: true,
+    });
+    installSkill(agentId, failSkill.id);
+    upsertSkillFile(failSkill.id, {
+      path: "references/blocked.md",
+      content: "blocked",
+    });
+    upsertSkillFile(failSkill.id, {
+      path: "references/ok.md",
+      content: "ok",
+    });
+
+    rmSync(join(FAKE_HOME, ".claude"), { recursive: true, force: true });
+    const blockedTarget = join(
+      FAKE_HOME,
+      ".claude",
+      "skills",
+      "complex-fail-safe",
+      "references",
+      "blocked.md",
+    );
+    mkdirSync(blockedTarget, { recursive: true });
+
+    const result = syncSkillsToFilesystem(agentId, "claude", FAKE_HOME);
+
+    expect(result.errors.some((error) => error.includes("references/blocked.md"))).toBe(true);
+    expect(
+      readFileSync(
+        join(FAKE_HOME, ".claude", "skills", "complex-fail-safe", "references", "ok.md"),
+        "utf-8",
+      ),
+    ).toBe("ok");
+
+    rmSync(join(FAKE_HOME, ".claude"), { recursive: true, force: true });
+  });
+
   test("removes stale swarm-managed skill directories", () => {
     // Mark this stale dir as swarm-managed (mirrors what an earlier sync would have done)
     const staleDir = join(FAKE_HOME, ".claude", "skills", "old-removed-skill");
@@ -185,7 +304,7 @@ describe("syncSkillsToFilesystem", () => {
     const result = syncSkillsToFilesystem(agentId, "all", FAKE_HOME);
 
     expect(result.errors).toHaveLength(0);
-    expect(result.synced).toBe(3);
+    expect(result.synced).toBeGreaterThanOrEqual(6);
 
     const claudeFile = join(FAKE_HOME, ".claude", "skills", "test-skill", "SKILL.md");
     const piFile = join(FAKE_HOME, ".pi", "agent", "skills", "test-skill", "SKILL.md");

package/src/tests/task-cascade-fail.test.ts

@@ -0,0 +1,304 @@
+import { afterAll, beforeAll, describe, expect, test } from "bun:test";
+import { unlinkSync } from "node:fs";
+import {
+  cancelTask,
+  cascadeFailDependents,
+  closeDb,
+  completeTask,
+  createAgent,
+  createTaskExtended,
+  failTask,
+  getDb,
+  getDependentTasks,
+  getTaskById,
+  initDb,
+  startTask,
+  supersedeTask,
+} from "../be/db";
+
+const TEST_DB_PATH = "./test-task-cascade-fail.sqlite";
+
+beforeAll(() => {
+  initDb(TEST_DB_PATH);
+});
+
+afterAll(() => {
+  closeDb();
+  try {
+    unlinkSync(TEST_DB_PATH);
+    unlinkSync(`${TEST_DB_PATH}-wal`);
+    unlinkSync(`${TEST_DB_PATH}-shm`);
+  } catch {
+    // ignore
+  }
+});
+
+describe("getDependentTasks", () => {
+  test("finds tasks that depend on a given parent", () => {
+    const agent = createAgent({
+      name: "dep-lookup-worker-1",
+      isLead: false,
+      status: "idle",
+      capabilities: [],
+    });
+
+    const parent = createTaskExtended("Parent task", { agentId: agent.id });
+    const child = createTaskExtended("Child task", {
+      agentId: agent.id,
+      dependsOn: [parent.id],
+    });
+
+    const deps = getDependentTasks(parent.id, { includeTerminal: true });
+    expect(deps.length).toBeGreaterThanOrEqual(1);
+    expect(deps.some((d) => d.id === child.id)).toBe(true);
+  });
+
+  test("filters out terminal tasks by default", () => {
+    const agent = createAgent({
+      name: "dep-lookup-worker-2",
+      isLead: false,
+      status: "idle",
+      capabilities: [],
+    });
+
+    const parent = createTaskExtended("Parent task 2", { agentId: agent.id });
+    const child1 = createTaskExtended("Child completed", {
+      agentId: agent.id,
+      dependsOn: [parent.id],
+    });
+    const child2 = createTaskExtended("Child pending", {
+      agentId: agent.id,
+      dependsOn: [parent.id],
+    });
+
+    startTask(child1.id, agent.id);
+    completeTask(child1.id, "done");
+
+    const nonTerminalDeps = getDependentTasks(parent.id);
+    expect(nonTerminalDeps.some((d) => d.id === child1.id)).toBe(false);
+    expect(nonTerminalDeps.some((d) => d.id === child2.id)).toBe(true);
+
+    const allDeps = getDependentTasks(parent.id, { includeTerminal: true });
+    expect(allDeps.some((d) => d.id === child1.id)).toBe(true);
+    expect(allDeps.some((d) => d.id === child2.id)).toBe(true);
+  });
+
+  test("returns empty array when no dependents exist", () => {
+    const agent = createAgent({
+      name: "dep-lookup-worker-3",
+      isLead: false,
+      status: "idle",
+      capabilities: [],
+    });
+
+    const task = createTaskExtended("Lonely task", { agentId: agent.id });
+    const deps = getDependentTasks(task.id);
+    expect(deps).toEqual([]);
+  });
+});
+
+describe("cascadeFailDependents", () => {
+  test("single-level cascade: failing parent fails its dependent", () => {
+    const agent = createAgent({
+      name: "cascade-worker-1",
+      isLead: false,
+      status: "idle",
+      capabilities: [],
+    });
+
+    const parent = createTaskExtended("Parent A", { agentId: agent.id });
+    const child = createTaskExtended("Child of A", {
+      agentId: agent.id,
+      dependsOn: [parent.id],
+    });
+
+    startTask(parent.id, agent.id);
+    failTask(parent.id, "parent failed");
+
+    const childAfter = getTaskById(child.id);
+    expect(childAfter!.status).toBe("failed");
+    expect(childAfter!.failureReason).toContain("Blocked dependency");
+    expect(childAfter!.failureReason).toContain("was failed");
+  });
+
+  test("multi-level recursive cascade: A→B→C all fail", () => {
+    const agent = createAgent({
+      name: "cascade-worker-2",
+      isLead: false,
+      status: "idle",
+      capabilities: [],
+    });
+
+    const taskA = createTaskExtended("Task A (root)", { agentId: agent.id });
+    const taskB = createTaskExtended("Task B (depends on A)", {
+      agentId: agent.id,
+      dependsOn: [taskA.id],
+    });
+    const taskC = createTaskExtended("Task C (depends on B)", {
+      agentId: agent.id,
+      dependsOn: [taskB.id],
+    });
+
+    startTask(taskA.id, agent.id);
+    failTask(taskA.id, "root failure");
+
+    const bAfter = getTaskById(taskB.id);
+    expect(bAfter!.status).toBe("failed");
+    expect(bAfter!.failureReason).toContain("Blocked dependency");
+
+    const cAfter = getTaskById(taskC.id);
+    expect(cAfter!.status).toBe("failed");
+    expect(cAfter!.failureReason).toContain("Blocked dependency");
+  });
+
+  test("cycle-safety: A↔B does not infinite-loop", () => {
+    const agent = createAgent({
+      name: "cascade-worker-3",
+      isLead: false,
+      status: "idle",
+      capabilities: [],
+    });
+
+    // Create tasks with a dependency cycle: A depends on B, B depends on A
+    const taskA = createTaskExtended("Cycle A", { agentId: agent.id });
+    const taskB = createTaskExtended("Cycle B", {
+      agentId: agent.id,
+      dependsOn: [taskA.id],
+    });
+    // Manually update taskA to depend on taskB (creating a cycle)
+    getDb().run("UPDATE agent_tasks SET dependsOn = ? WHERE id = ?", [
+      JSON.stringify([taskB.id]),
+      taskA.id,
+    ]);
+
+    // This should not infinite-loop — the visited set protects us
+    startTask(taskA.id, agent.id);
+    const results = cascadeFailDependents(taskA.id, "failed");
+
+    // taskB should be cascade-failed
+    const bAfter = getTaskById(taskB.id);
+    expect(bAfter!.status).toBe("failed");
+
+    // results should include taskB but NOT loop infinitely
+    expect(results.length).toBeGreaterThanOrEqual(1);
+    expect(results.some((r) => r.taskId === taskB.id)).toBe(true);
+  });
+
+  test("already-completed dependent is left untouched", () => {
+    const agent = createAgent({
+      name: "cascade-worker-4",
+      isLead: false,
+      status: "idle",
+      capabilities: [],
+    });
+
+    const parent = createTaskExtended("Parent D", { agentId: agent.id });
+    const child = createTaskExtended("Child D (completed)", {
+      agentId: agent.id,
+      dependsOn: [parent.id],
+    });
+
+    startTask(child.id, agent.id);
+    completeTask(child.id, "finished before parent failed");
+
+    startTask(parent.id, agent.id);
+    failTask(parent.id, "parent failed late");
+
+    const childAfter = getTaskById(child.id);
+    expect(childAfter!.status).toBe("completed");
+    expect(childAfter!.output).toBe("finished before parent failed");
+  });
+
+  test("cancelTask cascades to dependents", () => {
+    const agent = createAgent({
+      name: "cascade-worker-5",
+      isLead: false,
+      status: "idle",
+      capabilities: [],
+    });
+
+    const parent = createTaskExtended("Parent cancel", { agentId: agent.id });
+    const child = createTaskExtended("Child of cancelled", {
+      agentId: agent.id,
+      dependsOn: [parent.id],
+    });
+
+    cancelTask(parent.id, "no longer needed");
+
+    const childAfter = getTaskById(child.id);
+    expect(childAfter!.status).toBe("failed");
+    expect(childAfter!.failureReason).toContain("was cancelled");
+  });
+
+  test("supersedeTask cascades to dependents", () => {
+    const agent = createAgent({
+      name: "cascade-worker-6",
+      isLead: false,
+      status: "idle",
+      capabilities: [],
+    });
+
+    const parent = createTaskExtended("Parent supersede", { agentId: agent.id });
+    const child = createTaskExtended("Child of superseded", {
+      agentId: agent.id,
+      dependsOn: [parent.id],
+    });
+
+    startTask(parent.id, agent.id);
+    supersedeTask(parent.id, { reason: "context limit", resumeTaskId: null });
+
+    const childAfter = getTaskById(child.id);
+    expect(childAfter!.status).toBe("failed");
+    expect(childAfter!.failureReason).toContain("was superseded");
+  });
+
+  test("wide fan-out: multiple dependents all cascade-failed", () => {
+    const agent = createAgent({
+      name: "cascade-worker-7",
+      isLead: false,
+      status: "idle",
+      capabilities: [],
+    });
+
+    const parent = createTaskExtended("Parent wide", { agentId: agent.id });
+    const children = Array.from({ length: 5 }, (_, i) =>
+      createTaskExtended(`Child ${i}`, {
+        agentId: agent.id,
+        dependsOn: [parent.id],
+      }),
+    );
+
+    startTask(parent.id, agent.id);
+    failTask(parent.id, "parent gone");
+
+    for (const child of children) {
+      const after = getTaskById(child.id);
+      expect(after!.status).toBe("failed");
+      expect(after!.failureReason).toContain("Blocked dependency");
+    }
+  });
+
+  test("diamond dependency: C depends on both A and B, only A fails", () => {
+    const agent = createAgent({
+      name: "cascade-worker-8",
+      isLead: false,
+      status: "idle",
+      capabilities: [],
+    });
+
+    const taskA = createTaskExtended("Diamond A", { agentId: agent.id });
+    const taskB = createTaskExtended("Diamond B", { agentId: agent.id });
+    const taskC = createTaskExtended("Diamond C (depends on A and B)", {
+      agentId: agent.id,
+      dependsOn: [taskA.id, taskB.id],
+    });
+
+    startTask(taskA.id, agent.id);
+    failTask(taskA.id, "A failed");
+
+    // C should be cascade-failed because one of its dependencies failed
+    const cAfter = getTaskById(taskC.id);
+    expect(cAfter!.status).toBe("failed");
+    expect(cAfter!.failureReason).toContain("Blocked dependency");
+  });
+});

package/src/tools/create-page.ts

@@ -82,8 +82,8 @@ export const registerCreatePageTool = (server: McpServer) => {
         contentType: PageContentTypeSchema.describe(
           "'text/html' renders directly at /p/:id; 'application/json' is rendered by the SPA.",
         ),
-        authMode: PageAuthModeSchema.default("public").describe(
-          "'public' — no gate; 'authed' — requires page-session cookie; 'password' — requires key.",
+        authMode: PageAuthModeSchema.default("authed").describe(
+          "'authed' — requires page-session cookie (default); 'public' — no gate and must be explicit; 'password' — requires key.",
         ),
         password: z
           .string()

package/src/tools/skills/index.ts

@@ -1,6 +1,7 @@
 export { registerSkillCreateTool } from "./skill-create";
 export { registerSkillDeleteTool } from "./skill-delete";
 export { registerSkillGetTool } from "./skill-get";
+export { registerSkillGetFileTool } from "./skill-get-file";
 export { registerSkillInstallTool } from "./skill-install";
 export { registerSkillInstallRemoteTool } from "./skill-install-remote";
 export { registerSkillListTool } from "./skill-list";

package/src/tools/skills/skill-get-file.ts

@@ -0,0 +1,80 @@
+import type { McpServer } from "@modelcontextprotocol/sdk/server/mcp.js";
+import * as z from "zod";
+import { getSkillById, getSkillFile } from "@/be/db";
+import { createToolRegistrar } from "@/tools/utils";
+
+export const registerSkillGetFileTool = (server: McpServer) => {
+  createToolRegistrar(server)(
+    "skill-get-file",
+    {
+      title: "Get Skill File",
+      annotations: { destructiveHint: false },
+      description:
+        "Fetch a bundled reference file from a complex skill by skillId and relative path. Use this when the file is not available on disk.",
+      inputSchema: z.object({
+        skillId: z.string().describe("Skill ID"),
+        path: z.string().describe("Relative path, e.g. references/animations.md"),
+      }),
+      outputSchema: z.object({
+        yourAgentId: z.string().uuid().optional(),
+        success: z.boolean(),
+        message: z.string(),
+        file: z.any().optional(),
+      }),
+    },
+    async (args, requestInfo, _meta) => {
+      const skill = getSkillById(args.skillId);
+      if (!skill) {
+        return {
+          content: [{ type: "text", text: "Skill not found." }],
+          structuredContent: {
+            yourAgentId: requestInfo.agentId,
+            success: false,
+            message: "Skill not found.",
+          },
+        };
+      }
+
+      let file = null;
+      try {
+        file = getSkillFile(args.skillId, args.path);
+      } catch (err) {
+        const message = err instanceof Error ? err.message : "Invalid file path.";
+        return {
+          content: [{ type: "text", text: message }],
+          structuredContent: {
+            yourAgentId: requestInfo.agentId,
+            success: false,
+            message,
+          },
+        };
+      }
+
+      if (!file) {
+        return {
+          content: [{ type: "text", text: "Skill file not found." }],
+          structuredContent: {
+            yourAgentId: requestInfo.agentId,
+            success: false,
+            message: "Skill file not found.",
+          },
+        };
+      }
+
+      return {
+        content: [
+          {
+            type: "text",
+            text: `Skill file "${skill.name}/${file.path}" (${file.mimeType}):\n\n${file.content}`,
+          },
+        ],
+        structuredContent: {
+          yourAgentId: requestInfo.agentId,
+          success: true,
+          message: `Found skill file "${file.path}".`,
+          file,
+        },
+      };
+    },
+  );
+};