@desplega.ai/agent-swarm 1.102.0 → 1.104.0

package/src/tests/task-lifecycle-events.test.ts

@@ -0,0 +1,53 @@
+import { describe, expect, test } from "bun:test";
+import { emitTaskStarted, onTaskStarted } from "../be/task-lifecycle-events";
+import type { AgentTask } from "../types";
+
+function makeTask(overrides: Partial<AgentTask> = {}): AgentTask {
+  return {
+    id: "aaaaaaaa-bbbb-cccc-dddd-eeeeeeeeeeee",
+    agentId: "11111111-2222-3333-4444-555555555555",
+    task: "Test task",
+    status: "in_progress",
+    source: "github",
+    priority: 50,
+    tags: [],
+    dependsOn: [],
+    wasPaused: false,
+    createdAt: new Date().toISOString(),
+    lastUpdatedAt: new Date().toISOString(),
+    ...overrides,
+  } as AgentTask;
+}
+
+describe("task-lifecycle-events", () => {
+  test("emitTaskStarted invokes a registered onTaskStarted handler with the task", () => {
+    const received: AgentTask[] = [];
+    onTaskStarted((task) => {
+      received.push(task);
+    });
+
+    const task = makeTask();
+    emitTaskStarted(task);
+
+    expect(received).toContain(task);
+  });
+
+  test("a throwing handler does not break emit and later handlers still run", () => {
+    let laterRan = false;
+    onTaskStarted(() => {
+      throw new Error("boom");
+    });
+    onTaskStarted(() => {
+      laterRan = true;
+    });
+
+    expect(() => emitTaskStarted(makeTask())).not.toThrow();
+    expect(laterRan).toBe(true);
+  });
+
+  test("a promise-rejecting handler is fire-and-forget and does not throw", () => {
+    onTaskStarted(() => Promise.reject(new Error("async boom")));
+
+    expect(() => emitTaskStarted(makeTask())).not.toThrow();
+  });
+});

package/src/tests/task-lifecycle-telemetry.test.ts

@@ -9,6 +9,7 @@ import {
   failTask,
   getDb,
   initDb,
+  updateTaskClaudeSessionId,
 } from "../be/db";
 import { telemetry } from "../telemetry";
 
@@ -69,7 +70,6 @@ describe("task lifecycle telemetry", () => {
         props: {
           taskId: task.id,
           source: "mcp",
-          tags: ["telemetry"],
           hasParent: false,
           priority: 60,
         },
@@ -150,4 +150,40 @@ describe("task lifecycle telemetry", () => {
     });
     expect(typeof calls[0]?.props.durationMs).toBe("number");
   });
+
+  test("emits structured task provider and harness context instead of tags", async () => {
+    const task = createTaskExtended("complete telemetry with harness context", {
+      agentId: WORKER_ID,
+      source: "mcp",
+      tags: ["telemetry"],
+    });
+    updateTaskClaudeSessionId(
+      task.id,
+      "provider-session-1",
+      "codex",
+      undefined,
+      "gpt-5.5",
+      "stock",
+      { version: "0.40.1" },
+    );
+    await flushMicrotasks();
+    calls = [];
+
+    completeTask(task.id, "done");
+    await flushMicrotasks();
+
+    expect(calls).toHaveLength(1);
+    expect(calls[0]).toMatchObject({
+      event: "completed",
+      props: {
+        taskId: task.id,
+        source: "mcp",
+        agentId: WORKER_ID,
+        provider: "codex",
+        harnessVariant: "stock",
+        harnessVersion: "0.40.1",
+      },
+    });
+    expect(calls[0]?.props.tags).toBeUndefined();
+  });
 });

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

@@ -1,4 +1,5 @@
 import { afterEach, beforeEach, describe, expect, test } from "bun:test";
+import pkg from "../../package.json";
 import {
   _getInstallationIdForTests,
   _isE2bSandbox,
@@ -478,6 +479,37 @@ describe("initTelemetry", () => {
     });
   });
 
+  describe("track() ships swarmVersion in properties", () => {
+    const originalFetch = globalThis.fetch;
+    let captured: Record<string, unknown> | null = null;
+
+    beforeEach(() => {
+      captured = null;
+      globalThis.fetch = (async (_url: string, init?: { body?: string }) => {
+        captured = init?.body ? JSON.parse(init.body) : null;
+        return new Response(null, { status: 204 });
+      }) as typeof fetch;
+    });
+
+    afterEach(() => {
+      globalThis.fetch = originalFetch;
+    });
+
+    test("includes the package version on every event and ignores caller overrides", async () => {
+      await initTelemetry(
+        "worker",
+        async () => "install_version_test",
+        async () => {},
+      );
+
+      track({ event: "test.event", properties: { swarmVersion: "spoofed" } });
+      await new Promise((r) => setTimeout(r, 0));
+
+      const properties = (captured as { properties: Record<string, unknown> }).properties;
+      expect(properties.swarmVersion).toBe(pkg.version);
+    });
+  });
+
   describe("track() metadata.environment", () => {
     const originalFetch = globalThis.fetch;
     const originalNodeEnv = process.env.NODE_ENV;

package/src/tests/update-schedule-mcp-tool.test.ts

@@ -11,7 +11,15 @@ import { afterAll, beforeAll, describe, expect, test } from "bun:test";
 import { unlink } from "node:fs/promises";
 import { McpServer } from "@modelcontextprotocol/sdk/server/mcp.js";
 import type { CallToolResult } from "@modelcontextprotocol/sdk/types.js";
-import { closeDb, createAgent, createScheduledTask, getScheduledTaskById, initDb } from "../be/db";
+import {
+  closeDb,
+  createAgent,
+  createScheduledTask,
+  getDb,
+  getScheduledTaskById,
+  initDb,
+} from "../be/db";
+import { registerDeleteScheduleTool } from "../tools/schedules/delete-schedule";
 import { registerUpdateScheduleTool } from "../tools/schedules/update-schedule";
 
 const TEST_DB_PATH = "./test-update-schedule-mcp-tool.sqlite";
@@ -23,24 +31,34 @@ type RegisteredTool = {
 function buildServer(): McpServer {
   const server = new McpServer({ name: "update-schedule-mcp-test", version: "1.0.0" });
   registerUpdateScheduleTool(server);
+  registerDeleteScheduleTool(server);
   return server;
 }
 
-function callUpdateSchedule(
+function callTool(
   server: McpServer,
+  toolName: string,
   args: Record<string, unknown>,
   callerAgentId: string,
 ): Promise<CallToolResult> {
   const tools = (server as unknown as { _registeredTools: Record<string, RegisteredTool> })
     ._registeredTools;
-  const tool = tools["update-schedule"];
-  if (!tool) throw new Error("update-schedule not registered");
+  const tool = tools[toolName];
+  if (!tool) throw new Error(`${toolName} not registered`);
   return tool.handler(args, {
     sessionId: "test-session",
     requestInfo: { headers: { "x-agent-id": callerAgentId } },
   });
 }
 
+function callUpdateSchedule(
+  server: McpServer,
+  args: Record<string, unknown>,
+  callerAgentId: string,
+): Promise<CallToolResult> {
+  return callTool(server, "update-schedule", args, callerAgentId);
+}
+
 type ScheduleOutput = {
   success: boolean;
   message: string;
@@ -57,6 +75,7 @@ function structured(result: CallToolResult): ScheduleOutput {
 }
 
 let creatorId: string;
+let otherAgentId: string;
 
 beforeAll(async () => {
   for (const suffix of ["", "-wal", "-shm"]) {
@@ -70,7 +89,13 @@ beforeAll(async () => {
     isLead: false,
     status: "idle",
   });
+  const otherAgent = createAgent({
+    name: "update-schedule-mcp-other",
+    isLead: false,
+    status: "idle",
+  });
   creatorId = creator.id;
+  otherAgentId = otherAgent.id;
 });
 
 afterAll(async () => {
@@ -83,6 +108,60 @@ afterAll(async () => {
 });
 
 describe("update-schedule MCP tool", () => {
+  test("non-lead, non-creator agent can update a schedule", async () => {
+    const server = buildServer();
+    const schedule = createScheduledTask({
+      name: `mcp-noncreator-update-${Date.now()}`,
+      intervalMs: 60000,
+      taskTemplate: "owned by creator",
+      createdByAgentId: creatorId,
+      timezone: "UTC",
+    });
+
+    const result = await callUpdateSchedule(
+      server,
+      { scheduleId: schedule.id, intervalMs: 120000 },
+      otherAgentId,
+    );
+    const sc = structured(result);
+
+    expect(sc.success).toBe(true);
+    expect(sc.schedule?.intervalMs).toBe(120000);
+    expect(getScheduledTaskById(schedule.id)?.intervalMs).toBe(120000);
+  });
+
+  test("non-lead, non-creator agent can delete a schedule and writes an audit event", async () => {
+    const server = buildServer();
+    const schedule = createScheduledTask({
+      name: `mcp-noncreator-delete-${Date.now()}`,
+      intervalMs: 60000,
+      taskTemplate: "owned by creator",
+      createdByAgentId: creatorId,
+      timezone: "UTC",
+    });
+
+    const result = await callTool(
+      server,
+      "delete-schedule",
+      { scheduleId: schedule.id },
+      otherAgentId,
+    );
+    const sc = result.structuredContent as { success: boolean };
+
+    expect(sc.success).toBe(true);
+    expect(getScheduledTaskById(schedule.id)).toBeNull();
+    const event = getDb()
+      .prepare<{ data: string }, []>(
+        "SELECT data FROM events WHERE event = 'schedule.deleted' ORDER BY createdAt DESC LIMIT 1",
+      )
+      .get();
+    expect(JSON.parse(event!.data)).toMatchObject({
+      scheduleId: schedule.id,
+      deletedByAgentId: otherAgentId,
+      createdByAgentId: creatorId,
+    });
+  });
+
   test("regression: { cronExpression: null, intervalMs: null, enabled: false } returns success:false and leaves DB row unchanged", async () => {
     const server = buildServer();
     const schedule = createScheduledTask({

package/src/tools/credential-bindings/index.ts

@@ -0,0 +1 @@
+export { registerCredentialBindingsTool } from "./tool";

package/src/tools/credential-bindings/tool.ts

@@ -0,0 +1,238 @@
+import type { McpServer } from "@modelcontextprotocol/sdk/server/mcp.js";
+import * as z from "zod";
+import { getAgentById } from "@/be/db";
+import {
+  disableCredentialBinding,
+  importLegacyCredentialBindings,
+  listRelationalCredentialBindings,
+  upsertCredentialBinding,
+} from "@/be/script-connections";
+import {
+  CredentialBindingSchema,
+  placeholderForConfigKey,
+} from "@/scripts-runtime/credential-broker";
+import { createToolRegistrar } from "@/tools/utils";
+
+const credentialBindingsOutputSchema = z.object({
+  yourAgentId: z.string().uuid().optional(),
+  success: z.boolean(),
+  message: z.string(),
+  bindings: z.array(CredentialBindingSchema),
+});
+
+const credentialBindingsInputSchema = z.object({
+  action: z
+    .enum(["list", "upsert", "disable", "import-legacy"])
+    .describe("List, add/update, disable, or import legacy JSON bindings."),
+  id: z.string().uuid().optional(),
+  configKey: z.string().min(1).max(255).optional(),
+  allowedHosts: z.array(z.string().min(1)).min(1).optional(),
+  headerTemplate: z.string().min(1).optional(),
+  queryTemplate: z.string().min(1).optional(),
+  scope: z.enum(["global", "agent", "repo"]).default("global").optional(),
+  scopeId: z.string().uuid().nullable().optional(),
+});
+
+export const registerCredentialBindingsTool = (server: McpServer) => {
+  createToolRegistrar(server)(
+    "credential-bindings",
+    {
+      title: "Credential Bindings",
+      description:
+        "Lead-only management for scripts-runtime credential broker bindings. Bindings map config keys to allowed egress hosts; scripts consume them only through fetch-layer placeholder substitution.",
+      annotations: { idempotentHint: true },
+      inputSchema: credentialBindingsInputSchema,
+      outputSchema: credentialBindingsOutputSchema,
+    },
+    async (args, requestInfo) => {
+      if (!requestInfo.agentId) {
+        return {
+          content: [{ type: "text", text: 'Agent ID not found. Set the "X-Agent-ID" header.' }],
+          structuredContent: {
+            success: false,
+            message: 'Agent ID not found. Set the "X-Agent-ID" header.',
+            bindings: [],
+          },
+        };
+      }
+
+      const agent = getAgentById(requestInfo.agentId);
+      if (!agent?.isLead) {
+        return {
+          content: [{ type: "text", text: "Only the lead can manage credential bindings." }],
+          structuredContent: {
+            yourAgentId: requestInfo.agentId,
+            success: false,
+            message: "Only the lead can manage credential bindings.",
+            bindings: [],
+          },
+        };
+      }
+
+      const bindings = listRelationalCredentialBindings({ includeInactive: true });
+
+      if (args.action === "list") {
+        return {
+          content: [
+            {
+              type: "text",
+              text:
+                bindings.length === 0
+                  ? "No configured credential bindings."
+                  : `Found ${bindings.length} credential binding(s).`,
+            },
+          ],
+          structuredContent: {
+            yourAgentId: requestInfo.agentId,
+            success: true,
+            message:
+              bindings.length === 0
+                ? "No configured credential bindings."
+                : `Found ${bindings.length} credential binding(s).`,
+            bindings,
+          },
+        };
+      }
+
+      if (args.action === "import-legacy") {
+        const imported = importLegacyCredentialBindings();
+        const nextBindings = listRelationalCredentialBindings({ includeInactive: true });
+        return {
+          content: [{ type: "text", text: `Imported ${imported} legacy credential binding(s).` }],
+          structuredContent: {
+            yourAgentId: requestInfo.agentId,
+            success: true,
+            message: `Imported ${imported} legacy credential binding(s).`,
+            bindings: nextBindings,
+          },
+        };
+      }
+
+      if (args.action === "disable") {
+        const disabled = args.id ? disableCredentialBinding(args.id) : null;
+        if (!disabled) {
+          return {
+            content: [{ type: "text", text: "Credential binding id not found." }],
+            structuredContent: {
+              yourAgentId: requestInfo.agentId,
+              success: false,
+              message: "Credential binding id not found.",
+              bindings,
+            },
+          };
+        }
+
+        const nextBindings = listRelationalCredentialBindings({ includeInactive: true });
+        return {
+          content: [{ type: "text", text: `Credential binding ${disabled.configKey} disabled.` }],
+          structuredContent: {
+            yourAgentId: requestInfo.agentId,
+            success: true,
+            message: `Credential binding ${disabled.configKey} disabled.`,
+            bindings: nextBindings,
+          },
+        };
+      }
+
+      if (!args.configKey) {
+        return {
+          content: [{ type: "text", text: "configKey is required for upsert." }],
+          structuredContent: {
+            yourAgentId: requestInfo.agentId,
+            success: false,
+            message: "configKey is required for upsert.",
+            bindings,
+          },
+        };
+      }
+
+      const scope = args.scope ?? "global";
+      const scopeId = scope === "global" ? null : (args.scopeId ?? null);
+      if (scope !== "global" && !scopeId) {
+        return {
+          content: [{ type: "text", text: `scopeId is required for ${scope} bindings.` }],
+          structuredContent: {
+            yourAgentId: requestInfo.agentId,
+            success: false,
+            message: `scopeId is required for ${scope} bindings.`,
+            bindings,
+          },
+        };
+      }
+
+      if (!args.allowedHosts || (!args.headerTemplate && !args.queryTemplate)) {
+        return {
+          content: [
+            {
+              type: "text",
+              text: "allowedHosts and at least one of headerTemplate or queryTemplate are required for upsert.",
+            },
+          ],
+          structuredContent: {
+            yourAgentId: requestInfo.agentId,
+            success: false,
+            message:
+              "allowedHosts and at least one of headerTemplate or queryTemplate are required for upsert.",
+            bindings,
+          },
+        };
+      }
+
+      const placeholder = placeholderForConfigKey(args.configKey);
+      if (args.headerTemplate && !args.headerTemplate.includes(placeholder)) {
+        return {
+          content: [{ type: "text", text: `headerTemplate must include ${placeholder}.` }],
+          structuredContent: {
+            yourAgentId: requestInfo.agentId,
+            success: false,
+            message: `headerTemplate must include ${placeholder}.`,
+            bindings,
+          },
+        };
+      }
+      if (args.queryTemplate && !args.queryTemplate.includes(placeholder)) {
+        return {
+          content: [{ type: "text", text: `queryTemplate must include ${placeholder}.` }],
+          structuredContent: {
+            yourAgentId: requestInfo.agentId,
+            success: false,
+            message: `queryTemplate must include ${placeholder}.`,
+            bindings,
+          },
+        };
+      }
+
+      const nextBinding = CredentialBindingSchema.parse({
+        configKey: args.configKey,
+        allowedHosts: args.allowedHosts,
+        headerTemplate: args.headerTemplate,
+        queryTemplate: args.queryTemplate,
+        scope,
+        scopeId,
+        active: true,
+      });
+
+      upsertCredentialBinding({
+        id: args.id,
+        configKey: nextBinding.configKey,
+        allowedHosts: nextBinding.allowedHosts,
+        headerTemplate: nextBinding.headerTemplate,
+        queryTemplate: nextBinding.queryTemplate,
+        scope: nextBinding.scope,
+        scopeId: nextBinding.scopeId ?? null,
+        active: true,
+      });
+      const nextBindings = listRelationalCredentialBindings({ includeInactive: true });
+
+      return {
+        content: [{ type: "text", text: `Credential binding ${args.configKey} saved.` }],
+        structuredContent: {
+          yourAgentId: requestInfo.agentId,
+          success: true,
+          message: `Credential binding ${args.configKey} saved.`,
+          bindings: nextBindings,
+        },
+      };
+    },
+  );
+};

package/src/tools/memory-edit.ts

@@ -0,0 +1,148 @@
+import type { McpServer } from "@modelcontextprotocol/sdk/server/mcp.js";
+import * as z from "zod";
+import { getEmbeddingProvider, getMemoryStore } from "@/be/memory";
+import { storeLinks } from "@/be/memory/link-resolver";
+import { createToolRegistrar } from "@/tools/utils";
+import { AgentMemorySchema, AgentMemoryScopeSchema } from "@/types";
+
+export const registerMemoryEditTool = (server: McpServer) => {
+  createToolRegistrar(server)(
+    "memory-edit",
+    {
+      title: "Edit a memory",
+      description:
+        "Edit a single memory in place while preserving its ID, usefulness posterior, and audit history. Two modes: 'replace' overwrites the entire content (requires `content`); 'exact' performs a surgical find-and-replace of `oldString` with `newString` within the existing content (fails if `oldString` is missing or ambiguous). Use 'replace' for full rewrites, 'exact' for targeted edits.",
+      annotations: { destructiveHint: true },
+
+      inputSchema: z.object({
+        memoryId: z.uuid().optional().describe("The memory ID to edit."),
+        key: z.string().min(1).optional().describe("Structured key alternative to memoryId."),
+        scope: AgentMemoryScopeSchema.optional().describe("Required when editing by key."),
+        mode: z
+          .enum(["replace", "exact"])
+          .default("replace")
+          .describe(
+            "'replace' overwrites the entire memory content; 'exact' finds a unique substring (oldString) and replaces it with newString.",
+          ),
+        content: z
+          .string()
+          .min(1)
+          .optional()
+          .describe("Full replacement content. Required for 'replace' mode, ignored in 'exact'."),
+        oldString: z
+          .string()
+          .min(1)
+          .optional()
+          .describe(
+            "Substring to find in existing content. Required for 'exact' mode. Must appear exactly once.",
+          ),
+        newString: z
+          .string()
+          .optional()
+          .describe(
+            "Replacement for oldString. Required for 'exact' mode. Can be empty to delete.",
+          ),
+        intent: z.string().min(1).describe("Why you are editing this memory."),
+        expectedVersion: z.number().int().min(1).optional(),
+      }),
+      outputSchema: z.object({
+        yourAgentId: z.string().uuid().optional(),
+        success: z.boolean(),
+        message: z.string(),
+        memory: AgentMemorySchema.optional(),
+        changed: z.boolean().optional(),
+        previousVersion: z.number().int().optional(),
+        version: z.number().int().optional(),
+      }),
+    },
+    async (
+      { memoryId, key, scope, mode, content, oldString, newString, intent, expectedVersion },
+      requestInfo,
+      _meta,
+    ) => {
+      if (!requestInfo.agentId) {
+        return {
+          content: [{ type: "text", text: "Agent ID required to edit memories." }],
+          structuredContent: {
+            yourAgentId: undefined,
+            success: false,
+            message: "Agent ID required. Are you registered in the swarm?",
+          },
+        };
+      }
+
+      if (!memoryId && !(key && scope)) {
+        return {
+          content: [{ type: "text", text: "memoryId or key+scope required." }],
+          structuredContent: {
+            yourAgentId: requestInfo.agentId,
+            success: false,
+            message: "memoryId or key+scope required.",
+          },
+        };
+      }
+
+      try {
+        const store = getMemoryStore();
+        const result = store.edit({
+          id: memoryId,
+          key,
+          scope,
+          agentId: requestInfo.agentId,
+          mode,
+          content,
+          oldString,
+          newString,
+          intent,
+          expectedVersion,
+          changedByAgentId: requestInfo.agentId,
+        });
+
+        if (result.changed) {
+          const provider = getEmbeddingProvider();
+          const embedding = await provider.embed(result.memory.content);
+          if (embedding) store.updateEmbedding(result.memory.id, embedding, provider.name);
+          try {
+            storeLinks(result.memory.id, requestInfo.agentId, result.memory.content);
+          } catch (err) {
+            console.error(
+              `[memory-edit] Link resolution failed for ${result.memory.id}:`,
+              (err as Error).message,
+            );
+          }
+        }
+
+        return {
+          content: [
+            {
+              type: "text",
+              text: result.changed
+                ? `Memory "${result.memory.id}" edited to version ${result.version}.`
+                : `Memory "${result.memory.id}" unchanged.`,
+            },
+          ],
+          structuredContent: {
+            yourAgentId: requestInfo.agentId,
+            success: true,
+            message: result.changed
+              ? `Memory edited to version ${result.version}.`
+              : "Memory unchanged.",
+            memory: result.memory,
+            changed: result.changed,
+            previousVersion: result.previousVersion,
+            version: result.version,
+          },
+        };
+      } catch (err) {
+        return {
+          content: [{ type: "text", text: `Memory edit failed: ${(err as Error).message}` }],
+          structuredContent: {
+            yourAgentId: requestInfo.agentId,
+            success: false,
+            message: `Memory edit failed: ${(err as Error).message}`,
+          },
+        };
+      }
+    },
+  );
+};