@desplega.ai/agent-swarm 1.49.0 → 1.52.0

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

@@ -0,0 +1,178 @@
+import { describe, expect, test } from "bun:test";
+import { parseSkillContent } from "../be/skill-parser";
+
+// ─── Valid Parsing ──────────────────────────────────────────────────────────
+
+describe("parseSkillContent — valid inputs", () => {
+  test("parses minimal frontmatter with body", () => {
+    const content = `---
+name: my-skill
+description: A test skill
+---
+
+This is the body.`;
+
+    const result = parseSkillContent(content);
+    expect(result.name).toBe("my-skill");
+    expect(result.description).toBe("A test skill");
+    expect(result.body).toBe("This is the body.");
+  });
+
+  test("parses all optional frontmatter fields", () => {
+    const content = `---
+name: full-skill
+description: Full featured skill
+allowed-tools: Read,Write,Bash
+model: opus
+effort: high
+context: some-context
+agent: worker-123
+disable-model-invocation: true
+user-invocable: true
+---
+
+Body content here.`;
+
+    const result = parseSkillContent(content);
+    expect(result.name).toBe("full-skill");
+    expect(result.description).toBe("Full featured skill");
+    expect(result.allowedTools).toBe("Read,Write,Bash");
+    expect(result.model).toBe("opus");
+    expect(result.effort).toBe("high");
+    expect(result.context).toBe("some-context");
+    expect(result.agent).toBe("worker-123");
+    expect(result.disableModelInvocation).toBe(true);
+    expect(result.userInvocable).toBe(true);
+  });
+
+  test("returns undefined for unset optional fields", () => {
+    const content = `---
+name: minimal
+description: Minimal skill
+---
+
+Body.`;
+
+    const result = parseSkillContent(content);
+    expect(result.allowedTools).toBeUndefined();
+    expect(result.model).toBeUndefined();
+    expect(result.effort).toBeUndefined();
+    expect(result.context).toBeUndefined();
+    expect(result.agent).toBeUndefined();
+    expect(result.disableModelInvocation).toBeUndefined();
+    expect(result.userInvocable).toBeUndefined();
+  });
+
+  test("handles empty body after frontmatter", () => {
+    const content = `---
+name: no-body
+description: Skill with no body
+---`;
+
+    const result = parseSkillContent(content);
+    expect(result.name).toBe("no-body");
+    expect(result.body).toBe("");
+  });
+
+  test("user-invocable defaults to true when present without value", () => {
+    // user-invocable with no value → empty string → not "false" → true
+    // Actually per the parser: if key has empty value, it's skipped (value check)
+    // Let's test explicit true/false
+    const contentTrue = `---
+name: invocable
+description: Test
+user-invocable: true
+---
+Body`;
+
+    const contentFalse = `---
+name: non-invocable
+description: Test
+user-invocable: false
+---
+Body`;
+
+    expect(parseSkillContent(contentTrue).userInvocable).toBe(true);
+    expect(parseSkillContent(contentFalse).userInvocable).toBe(false);
+  });
+
+  test("disable-model-invocation only true for literal 'true'", () => {
+    const contentTrue = `---
+name: disabled
+description: Test
+disable-model-invocation: true
+---
+Body`;
+
+    const contentFalse = `---
+name: enabled
+description: Test
+disable-model-invocation: false
+---
+Body`;
+
+    expect(parseSkillContent(contentTrue).disableModelInvocation).toBe(true);
+    expect(parseSkillContent(contentFalse).disableModelInvocation).toBeUndefined();
+  });
+
+  test("handles extra whitespace in frontmatter", () => {
+    const content = `---
+name:   spaced-skill
+description:   A spaced description
+---
+
+Body.`;
+
+    const result = parseSkillContent(content);
+    expect(result.name).toBe("spaced-skill");
+    expect(result.description).toBe("A spaced description");
+  });
+
+  test("handles colons in frontmatter values", () => {
+    const content = `---
+name: colon-skill
+description: A skill with: colons in description
+---
+
+Body.`;
+
+    const result = parseSkillContent(content);
+    expect(result.description).toBe("A skill with: colons in description");
+  });
+});
+
+// ─── Invalid Inputs ─────────────────────────────────────────────────────────
+
+describe("parseSkillContent — invalid inputs", () => {
+  test("throws if no frontmatter delimiter", () => {
+    expect(() => parseSkillContent("No frontmatter here")).toThrow("No frontmatter found");
+  });
+
+  test("throws if frontmatter is unterminated", () => {
+    expect(() => parseSkillContent("---\nname: test\nno closing")).toThrow("Missing closing ---");
+  });
+
+  test("throws if name is missing", () => {
+    const content = `---
+description: Missing name
+---
+Body`;
+    expect(() => parseSkillContent(content)).toThrow('missing required field: "name"');
+  });
+
+  test("throws if description is missing", () => {
+    const content = `---
+name: no-desc
+---
+Body`;
+    expect(() => parseSkillContent(content)).toThrow('missing required field: "description"');
+  });
+
+  test("throws on empty string", () => {
+    expect(() => parseSkillContent("")).toThrow("No frontmatter found");
+  });
+
+  test("throws on whitespace-only string", () => {
+    expect(() => parseSkillContent("   \n\n  ")).toThrow("No frontmatter found");
+  });
+});

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

@@ -0,0 +1,171 @@
+import { afterAll, beforeAll, describe, expect, test } from "bun:test";
+import { existsSync, mkdirSync, readFileSync, rmSync } 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 { syncSkillsToFilesystem } from "../be/skill-sync";
+
+const TEST_DB_PATH = `./test-skill-sync-${process.pid}.sqlite`;
+const FAKE_HOME = join(tmpdir(), `skill-sync-test-${process.pid}`);
+
+describe("syncSkillsToFilesystem", () => {
+  let agentId: string;
+
+  beforeAll(() => {
+    initDb(TEST_DB_PATH);
+
+    const agent = createAgent({
+      name: "Skill Sync Test Worker",
+      description: "Test agent for skill sync",
+      role: "worker",
+      isLead: false,
+      status: "idle",
+      maxTasks: 1,
+      capabilities: [],
+    });
+    agentId = agent.id;
+
+    // Create and install a simple skill
+    const skill = createSkill({
+      name: "test-skill",
+      description: "A test skill",
+      content: "---\nname: test-skill\ndescription: A test skill\n---\n\nTest body.",
+      type: "personal",
+      scope: "agent",
+    });
+    installSkill(agentId, skill.id);
+
+    // Create a complex skill (should be skipped)
+    const complexSkill = createSkill({
+      name: "complex-skill",
+      description: "A complex skill",
+      content: "---\nname: complex-skill\ndescription: A complex skill\n---\n\nBody.",
+      type: "remote",
+      scope: "global",
+      isComplex: true,
+    });
+    installSkill(agentId, complexSkill.id);
+
+    mkdirSync(FAKE_HOME, { recursive: true });
+  });
+
+  afterAll(async () => {
+    closeDb();
+    rmSync(FAKE_HOME, { recursive: true, force: true });
+    await unlink(TEST_DB_PATH).catch(() => {});
+    await unlink(`${TEST_DB_PATH}-wal`).catch(() => {});
+    await unlink(`${TEST_DB_PATH}-shm`).catch(() => {});
+  });
+
+  test("syncs simple skills to claude directory", () => {
+    const result = syncSkillsToFilesystem(agentId, "claude", FAKE_HOME);
+
+    expect(result.errors).toHaveLength(0);
+    expect(result.synced).toBeGreaterThanOrEqual(1);
+
+    const skillFile = join(FAKE_HOME, ".claude", "skills", "test-skill", "SKILL.md");
+    expect(existsSync(skillFile)).toBe(true);
+    expect(readFileSync(skillFile, "utf-8")).toContain("Test body.");
+  });
+
+  test("syncs simple skills to pi directory", () => {
+    const result = syncSkillsToFilesystem(agentId, "pi", FAKE_HOME);
+
+    expect(result.errors).toHaveLength(0);
+    expect(result.synced).toBeGreaterThanOrEqual(1);
+
+    const skillFile = join(FAKE_HOME, ".pi", "agent", "skills", "test-skill", "SKILL.md");
+    expect(existsSync(skillFile)).toBe(true);
+    expect(readFileSync(skillFile, "utf-8")).toContain("Test body.");
+  });
+
+  test("syncs to both claude and pi when harnessType is 'both'", () => {
+    // Clean up first to get accurate count
+    rmSync(join(FAKE_HOME, ".claude"), { recursive: true, force: true });
+    rmSync(join(FAKE_HOME, ".pi"), { recursive: true, force: true });
+
+    const result = syncSkillsToFilesystem(agentId, "both", FAKE_HOME);
+
+    expect(result.errors).toHaveLength(0);
+    expect(result.synced).toBe(2); // 1 skill × 2 dirs
+
+    const claudeFile = join(FAKE_HOME, ".claude", "skills", "test-skill", "SKILL.md");
+    const piFile = join(FAKE_HOME, ".pi", "agent", "skills", "test-skill", "SKILL.md");
+    expect(existsSync(claudeFile)).toBe(true);
+    expect(existsSync(piFile)).toBe(true);
+  });
+
+  test("skips complex skills", () => {
+    const result = syncSkillsToFilesystem(agentId, "claude", FAKE_HOME);
+
+    const complexDir = join(FAKE_HOME, ".claude", "skills", "complex-skill");
+    expect(existsSync(complexDir)).toBe(false);
+  });
+
+  test("removes stale skill directories", () => {
+    const staleDir = join(FAKE_HOME, ".claude", "skills", "old-removed-skill");
+    mkdirSync(staleDir, { recursive: true });
+    expect(existsSync(staleDir)).toBe(true);
+
+    const result = syncSkillsToFilesystem(agentId, "claude", FAKE_HOME);
+
+    expect(result.removed).toBeGreaterThanOrEqual(1);
+    expect(existsSync(staleDir)).toBe(false);
+  });
+
+  test("defaults to 'both' when no harnessType provided", () => {
+    // Clean up first
+    rmSync(join(FAKE_HOME, ".claude"), { recursive: true, force: true });
+    rmSync(join(FAKE_HOME, ".pi"), { recursive: true, force: true });
+
+    // Use 'both' explicitly with homeOverride (default harnessType would use real home)
+    const result = syncSkillsToFilesystem(agentId, "both", FAKE_HOME);
+
+    expect(result.errors).toHaveLength(0);
+    expect(result.synced).toBe(2);
+
+    const claudeFile = join(FAKE_HOME, ".claude", "skills", "test-skill", "SKILL.md");
+    const piFile = join(FAKE_HOME, ".pi", "agent", "skills", "test-skill", "SKILL.md");
+    expect(existsSync(claudeFile)).toBe(true);
+    expect(existsSync(piFile)).toBe(true);
+  });
+
+  test("returns empty result for agent with no skills", () => {
+    const otherAgent = createAgent({
+      name: "Empty Agent",
+      description: "Agent with no skills",
+      role: "worker",
+      isLead: false,
+      status: "idle",
+      maxTasks: 1,
+      capabilities: [],
+    });
+
+    const result = syncSkillsToFilesystem(otherAgent.id, "claude", FAKE_HOME);
+
+    expect(result.synced).toBe(0);
+    expect(result.errors).toHaveLength(0);
+  });
+
+  test("sanitizes skill names with special characters", () => {
+    const skill = createSkill({
+      name: "my/dangerous/../skill",
+      description: "Path traversal attempt",
+      content:
+        "---\nname: my/dangerous/../skill\ndescription: Path traversal attempt\n---\n\nSafe.",
+      type: "personal",
+      scope: "agent",
+    });
+    installSkill(agentId, skill.id);
+
+    // Clean up first
+    rmSync(join(FAKE_HOME, ".claude"), { recursive: true, force: true });
+
+    const result = syncSkillsToFilesystem(agentId, "claude", FAKE_HOME);
+
+    expect(result.errors).toHaveLength(0);
+    const sanitizedDir = join(FAKE_HOME, ".claude", "skills", "my_dangerous____skill");
+    expect(existsSync(sanitizedDir)).toBe(true);
+  });
+});

package/src/tests/slack-metadata-inheritance.test.ts

@@ -1,6 +1,6 @@
 import { afterAll, beforeAll, describe, expect, test } from "bun:test";
 import { unlinkSync } from "node:fs";
-import { closeDb, createAgent, createTaskExtended, getDb, getTaskById, initDb } from "../be/db";
+import { closeDb, createAgent, createTaskExtended, getDb, initDb } from "../be/db";
 
 const TEST_DB_PATH = "./test-slack-metadata-inheritance.sqlite";
 

package/src/tests/slack-thread-followups.test.ts

@@ -256,7 +256,7 @@ describe("watcher query scope — getCompletedSlackTasks / getInProgressSlackTas
     });
 
     // Worker task with no source but has Slack metadata (inherited via parentTaskId)
-    const workerTask = createTaskExtended("worker completed", {
+    const _workerTask = createTaskExtended("worker completed", {
       agentId: agent.id,
       slackChannelId: "C_WATCHER_NULL",
       slackThreadTs: "7100.0001",

package/src/tests/structured-output.test.ts

@@ -1,17 +1,13 @@
 import { afterAll, beforeAll, describe, expect, test } from "bun:test";
 import { unlink } from "node:fs/promises";
-import { z } from "zod";
 import {
   closeDb,
-  completeTask,
   createTaskExtended,
   createWorkflow,
   createWorkflowRun,
   createWorkflowRunStep,
   getTaskById,
   initDb,
-  updateWorkflowRun,
-  updateWorkflowRunStep,
 } from "../be/db";
 import { validateJsonSchema } from "../workflows/json-schema-validator";
 

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

@@ -338,8 +338,9 @@ describe("Tool Annotations & Classification", () => {
   test("registered tool count matches expected total", () => {
     const count = Object.keys(tools).length;
     // We expect all tools to be registered when all capabilities are enabled (default)
+    // Includes 11 skill tools added in the skill system feature
     expect(count).toBeGreaterThanOrEqual(45);
-    expect(count).toBeLessThanOrEqual(65);
+    expect(count).toBeLessThanOrEqual(85);
   });
 
   test("core tools are fewer than deferred tools", () => {

package/src/tests/update-profile-agentid.test.ts

@@ -0,0 +1,248 @@
+import { afterAll, beforeAll, describe, expect, test } from "bun:test";
+import { unlink } from "node:fs/promises";
+import {
+  closeDb,
+  createAgent,
+  getAgentById,
+  getLatestContextVersion,
+  initDb,
+  updateAgentName,
+  updateAgentProfile,
+} from "../be/db";
+
+const TEST_DB_PATH = "./test-update-profile-agentid.sqlite";
+
+describe("update-profile agentId authorization", () => {
+  const leadId = "aaaa0000-0000-4000-8000-000000000001";
+  const workerId = "bbbb0000-0000-4000-8000-000000000002";
+  const otherWorkerId = "cccc0000-0000-4000-8000-000000000003";
+  const nonExistentId = "dddd0000-0000-4000-8000-000000000099";
+
+  beforeAll(async () => {
+    for (const suffix of ["", "-wal", "-shm"]) {
+      try {
+        await unlink(TEST_DB_PATH + suffix);
+      } catch {
+        // File doesn't exist
+      }
+    }
+
+    closeDb();
+    initDb(TEST_DB_PATH);
+
+    createAgent({ id: leadId, name: "Test Lead", isLead: true, status: "idle" });
+    createAgent({ id: workerId, name: "Test Worker", isLead: false, status: "idle" });
+    createAgent({ id: otherWorkerId, name: "Other Worker", isLead: false, status: "idle" });
+  });
+
+  afterAll(async () => {
+    closeDb();
+    for (const suffix of ["", "-wal", "-shm"]) {
+      try {
+        await unlink(TEST_DB_PATH + suffix);
+      } catch {
+        // File doesn't exist
+      }
+    }
+  });
+
+  // ==========================================================================
+  // Authorization logic (simulates update-profile tool handler checks)
+  // ==========================================================================
+
+  describe("lead agent can update another agent's profile", () => {
+    test("lead updates worker description", () => {
+      const callingAgent = getAgentById(leadId);
+      expect(callingAgent).not.toBeNull();
+      expect(callingAgent!.isLead).toBe(true);
+
+      // Lead updating another agent — this is the happy path
+      const updated = updateAgentProfile(
+        workerId,
+        { description: "Updated by lead" },
+        { changeSource: "lead_coaching", changedByAgentId: leadId },
+      );
+      expect(updated).not.toBeNull();
+      expect(updated!.description).toBe("Updated by lead");
+    });
+
+    test("lead updates worker soulMd with lead_coaching changeSource", () => {
+      const updated = updateAgentProfile(
+        workerId,
+        { soulMd: "# Soul updated by lead" },
+        { changeSource: "lead_coaching", changedByAgentId: leadId },
+      );
+      expect(updated).not.toBeNull();
+      expect(updated!.soulMd).toBe("# Soul updated by lead");
+
+      // Verify the context version records lead_coaching as changeSource
+      const version = getLatestContextVersion(workerId, "soulMd");
+      expect(version).not.toBeNull();
+      expect(version!.changeSource).toBe("lead_coaching");
+      expect(version!.changedByAgentId).toBe(leadId);
+    });
+
+    test("lead updates worker name", () => {
+      const updated = updateAgentName(workerId, "Renamed Worker");
+      expect(updated).not.toBeNull();
+      expect(updated!.name).toBe("Renamed Worker");
+
+      // Rename back for other tests
+      updateAgentName(workerId, "Test Worker");
+    });
+  });
+
+  describe("non-lead is rejected when providing agentId", () => {
+    test("non-lead agent cannot update another agent's profile", () => {
+      const callingAgent = getAgentById(workerId);
+      expect(callingAgent).not.toBeNull();
+      expect(callingAgent!.isLead).toBe(false);
+
+      // The tool handler checks isLead before calling DB functions.
+      // Simulate the authorization check the tool performs:
+      const isUpdatingSelf = otherWorkerId === workerId; // false — different agent
+      expect(isUpdatingSelf).toBe(false);
+
+      // Non-lead should be rejected
+      const canUpdate = callingAgent!.isLead;
+      expect(canUpdate).toBe(false);
+    });
+
+    test("non-lead agent cannot update lead's profile", () => {
+      const callingAgent = getAgentById(workerId);
+      expect(callingAgent!.isLead).toBe(false);
+
+      const isUpdatingSelf = leadId === workerId; // false
+      expect(isUpdatingSelf).toBe(false);
+
+      // Authorization would reject this
+      expect(callingAgent!.isLead).toBe(false);
+    });
+  });
+
+  describe("self-update via explicit agentId works without lead check", () => {
+    test("agent providing own agentId is treated as self-update", () => {
+      // Simulate: agentId param = caller's own ID
+      const requestAgentId = workerId;
+      const paramAgentId = workerId;
+      const isUpdatingSelf = !paramAgentId || paramAgentId === requestAgentId;
+      expect(isUpdatingSelf).toBe(true);
+
+      // Self-update should succeed regardless of isLead status
+      const updated = updateAgentProfile(
+        workerId,
+        { description: "Self-updated via explicit agentId" },
+        { changeSource: "self_edit", changedByAgentId: workerId },
+      );
+      expect(updated).not.toBeNull();
+      expect(updated!.description).toBe("Self-updated via explicit agentId");
+    });
+
+    test("self-update with omitted agentId also works", () => {
+      // When agentId is undefined, isUpdatingSelf = true
+      const agentId = undefined;
+      const isUpdatingSelf = !agentId || agentId === workerId;
+      expect(isUpdatingSelf).toBe(true);
+
+      const updated = updateAgentProfile(
+        workerId,
+        { role: "updated-role" },
+        { changeSource: "self_edit", changedByAgentId: workerId },
+      );
+      expect(updated).not.toBeNull();
+      expect(updated!.role).toBe("updated-role");
+    });
+  });
+
+  describe("invalid agentId returns appropriate error", () => {
+    test("updateAgentProfile returns null for non-existent target agent", () => {
+      const result = updateAgentProfile(
+        nonExistentId,
+        { description: "Should fail" },
+        { changeSource: "lead_coaching", changedByAgentId: leadId },
+      );
+      expect(result).toBeNull();
+    });
+
+    test("updateAgentName returns null for non-existent target agent", () => {
+      const result = updateAgentName(nonExistentId, "Ghost Agent");
+      expect(result).toBeNull();
+    });
+
+    test("getAgentById returns null for non-existent agent", () => {
+      const agent = getAgentById(nonExistentId);
+      expect(agent).toBeNull();
+    });
+  });
+
+  describe("changeSource is correct for remote vs self updates", () => {
+    test("lead_coaching changeSource for lead updating worker identityMd", () => {
+      updateAgentProfile(
+        otherWorkerId,
+        { identityMd: "# Identity set by lead" },
+        { changeSource: "lead_coaching", changedByAgentId: leadId },
+      );
+
+      const version = getLatestContextVersion(otherWorkerId, "identityMd");
+      expect(version).not.toBeNull();
+      expect(version!.changeSource).toBe("lead_coaching");
+      expect(version!.changedByAgentId).toBe(leadId);
+    });
+
+    test("self_edit changeSource for agent updating own claudeMd", () => {
+      updateAgentProfile(
+        workerId,
+        { claudeMd: "# My notes" },
+        { changeSource: "self_edit", changedByAgentId: workerId },
+      );
+
+      const version = getLatestContextVersion(workerId, "claudeMd");
+      expect(version).not.toBeNull();
+      expect(version!.changeSource).toBe("self_edit");
+      expect(version!.changedByAgentId).toBe(workerId);
+    });
+
+    test("lead_coaching changeSource for lead updating worker toolsMd", () => {
+      updateAgentProfile(
+        workerId,
+        { toolsMd: "# Tools set by lead" },
+        { changeSource: "lead_coaching", changedByAgentId: leadId },
+      );
+
+      const version = getLatestContextVersion(workerId, "toolsMd");
+      expect(version).not.toBeNull();
+      expect(version!.changeSource).toBe("lead_coaching");
+      expect(version!.changedByAgentId).toBe(leadId);
+    });
+
+    test("self_edit changeSource for agent updating own setupScript", () => {
+      updateAgentProfile(
+        otherWorkerId,
+        { setupScript: "echo hello" },
+        { changeSource: "self_edit", changedByAgentId: otherWorkerId },
+      );
+
+      const version = getLatestContextVersion(otherWorkerId, "setupScript");
+      expect(version).not.toBeNull();
+      expect(version!.changeSource).toBe("self_edit");
+      expect(version!.changedByAgentId).toBe(otherWorkerId);
+    });
+  });
+
+  // ==========================================================================
+  // Target agent existence validation (non-blocking suggestion)
+  // ==========================================================================
+
+  describe("target agent existence validation", () => {
+    test("getAgentById can validate target exists before update", () => {
+      // The tool should validate the target agent exists before attempting updates
+      const targetAgent = getAgentById(nonExistentId);
+      expect(targetAgent).toBeNull();
+
+      // Valid target should be found
+      const validTarget = getAgentById(workerId);
+      expect(validTarget).not.toBeNull();
+      expect(validTarget!.id).toBe(workerId);
+    });
+  });
+});