@desplega.ai/agent-swarm 1.20.0 → 1.51.2

package/src/commands/artifact.ts

@@ -0,0 +1,241 @@
+import { Hono } from "hono";
+import { createArtifactServer } from "../artifact-sdk";
+
+interface ArtifactArgs {
+  additionalArgs: string[];
+  port?: string;
+  key?: string;
+}
+
+export async function runArtifact(subcommand: string, args: ArtifactArgs) {
+  switch (subcommand) {
+    case "serve":
+      return artifactServe(args);
+    case "list":
+      return artifactList();
+    case "stop":
+      return artifactStop(args);
+    default:
+      printHelp();
+  }
+}
+
+function printHelp() {
+  console.log(`Usage: agent-swarm artifact <subcommand>
+
+Subcommands:
+  serve <path> --name <name> [--port <port>] [--no-auth] [--subdomain <sub>]
+    Serve a directory or script as an artifact via localtunnel
+
+  list
+    List active artifacts (from service registry)
+
+  stop <name>
+    Stop an artifact and close its tunnel
+
+Examples:
+  agent-swarm artifact serve ./my-report --name my-report
+  agent-swarm artifact serve ./server.ts --name dashboard
+  agent-swarm artifact list
+  agent-swarm artifact stop my-report`);
+}
+
+async function artifactServe(args: ArtifactArgs) {
+  const additionalArgs = args.additionalArgs || [];
+
+  // Parse artifact-specific args from additionalArgs
+  let path = "";
+  let name = "";
+  let port: number | undefined;
+  let noAuth = false;
+  let subdomain: string | undefined;
+
+  for (let i = 0; i < additionalArgs.length; i++) {
+    const arg = additionalArgs[i] ?? "";
+    if (arg === "--name") {
+      name = additionalArgs[i + 1] ?? "";
+      i++;
+    } else if (arg === "--port") {
+      port = Number.parseInt(additionalArgs[i + 1] ?? "0", 10);
+      i++;
+    } else if (arg === "--no-auth") {
+      noAuth = true;
+    } else if (arg === "--subdomain") {
+      subdomain = additionalArgs[i + 1] ?? "";
+      i++;
+    } else if (!arg.startsWith("-") && !path) {
+      path = arg;
+    }
+  }
+
+  if (!path) {
+    console.error("Error: path is required. Usage: artifact serve <path> --name <name>");
+    process.exit(1);
+  }
+
+  if (!name) {
+    // Derive name from path
+    name = path.split("/").filter(Boolean).pop() || "artifact";
+  }
+
+  // Determine if path is a directory or a script
+  const file = Bun.file(path);
+  const isFile = await file.exists();
+
+  let app: Hono | undefined;
+  let staticDir: string | undefined;
+
+  if (isFile && (path.endsWith(".ts") || path.endsWith(".js"))) {
+    // Script mode — import the module and use its default export as a Hono app
+    try {
+      const mod = await import(path.startsWith("/") ? path : `${process.cwd()}/${path}`);
+      if (mod.default instanceof Hono) {
+        app = mod.default;
+      } else {
+        console.error(`Error: ${path} must export a default Hono app instance`);
+        process.exit(1);
+      }
+    } catch (e) {
+      console.error(`Error loading ${path}:`, e);
+      process.exit(1);
+    }
+  } else {
+    // Static directory mode
+    const { existsSync } = await import("node:fs");
+    if (!existsSync(path)) {
+      console.error(`Error: path "${path}" does not exist`);
+      process.exit(1);
+    }
+    staticDir = path;
+  }
+
+  const server = createArtifactServer({
+    name,
+    app,
+    static: staticDir,
+    port,
+    auth: noAuth ? false : undefined,
+    subdomain,
+  });
+
+  await server.start();
+
+  // Keep the process alive
+  process.on("SIGINT", async () => {
+    console.log(`\nStopping artifact "${name}"...`);
+    await server.stop();
+    process.exit(0);
+  });
+
+  process.on("SIGTERM", async () => {
+    await server.stop();
+    process.exit(0);
+  });
+
+  // Keep alive
+  await new Promise(() => {});
+}
+
+async function artifactList() {
+  const apiKey = process.env.API_KEY || "";
+  const mcpBaseUrl = process.env.MCP_BASE_URL || `http://localhost:${process.env.PORT || "3013"}`;
+  const agentId = process.env.AGENT_ID || "";
+
+  try {
+    const res = await fetch(`${mcpBaseUrl}/api/services`, {
+      headers: {
+        Authorization: `Bearer ${apiKey}`,
+        "X-Agent-ID": agentId,
+      },
+    });
+
+    if (!res.ok) {
+      console.error(`Failed to fetch services: ${res.status} ${res.statusText}`);
+      process.exit(1);
+    }
+
+    const services = (await res.json()) as Array<{
+      name: string;
+      agentId: string;
+      status: string;
+      metadata?: { type?: string; artifactName?: string; port?: number; publicUrl?: string };
+    }>;
+
+    const artifacts = services.filter((s) => s.metadata?.type === "artifact");
+
+    if (artifacts.length === 0) {
+      console.log("No active artifacts");
+      return;
+    }
+
+    // Format as table
+    console.log(
+      `${"NAME".padEnd(20)} ${"AGENT".padEnd(16)} ${"PORT".padEnd(8)} ${"URL".padEnd(50)} STATUS`,
+    );
+    for (const a of artifacts) {
+      const name = (a.metadata?.artifactName || a.name).padEnd(20);
+      const agent = (a.agentId || "").substring(0, 14).padEnd(16);
+      const port = String(a.metadata?.port || "?").padEnd(8);
+      const url = (a.metadata?.publicUrl || "").padEnd(50);
+      console.log(`${name} ${agent} ${port} ${url} ${a.status}`);
+    }
+  } catch (e) {
+    console.error("Failed to list artifacts:", e);
+    process.exit(1);
+  }
+}
+
+async function artifactStop(args: ArtifactArgs) {
+  const name = args.additionalArgs?.[0];
+  if (!name) {
+    console.error("Error: name is required. Usage: artifact stop <name>");
+    process.exit(1);
+  }
+
+  const apiKey = process.env.API_KEY || "";
+  const mcpBaseUrl = process.env.MCP_BASE_URL || `http://localhost:${process.env.PORT || "3013"}`;
+  const agentId = process.env.AGENT_ID || "";
+
+  // 1. Try to stop PM2 process
+  try {
+    await Bun.$`pm2 delete artifact-${name} 2>/dev/null`.quiet();
+    console.log(`Stopped PM2 process: artifact-${name}`);
+  } catch {
+    // Process might not exist in PM2
+  }
+
+  // 2. Unregister from service registry
+  try {
+    const res = await fetch(`${mcpBaseUrl}/api/services`, {
+      headers: {
+        Authorization: `Bearer ${apiKey}`,
+        "X-Agent-ID": agentId,
+      },
+    });
+
+    if (res.ok) {
+      const services = (await res.json()) as Array<{
+        id: string;
+        name: string;
+        metadata?: { type?: string; artifactName?: string };
+      }>;
+      const service = services.find(
+        (s) => s.metadata?.type === "artifact" && s.metadata?.artifactName === name,
+      );
+
+      if (service) {
+        await fetch(`${mcpBaseUrl}/api/services/${service.id}`, {
+          method: "DELETE",
+          headers: {
+            Authorization: `Bearer ${apiKey}`,
+            "X-Agent-ID": agentId,
+          },
+        });
+      }
+    }
+  } catch {
+    // Non-fatal
+  }
+
+  console.log(`Artifact '${name}' stopped.`);
+}

package/src/commands/onboard/compose-generator.ts

@@ -0,0 +1,169 @@
+import { expandServices } from "./service-names.ts";
+import type { OnboardState } from "./types.ts";
+
+// Docker Compose env var references use ${VAR} syntax which triggers biome's
+// noTemplateCurlyInString rule. We collect them via a helper to keep the
+// suppression comments in one place.
+
+// biome-ignore lint/suspicious/noTemplateCurlyInString: Docker Compose env var syntax
+const ENV_API_KEY = "      - API_KEY=${API_KEY}";
+// biome-ignore lint/suspicious/noTemplateCurlyInString: Docker Compose env var syntax
+const ENV_SLACK_BOT_TOKEN = "      - SLACK_BOT_TOKEN=${SLACK_BOT_TOKEN}";
+// biome-ignore lint/suspicious/noTemplateCurlyInString: Docker Compose env var syntax
+const ENV_SLACK_APP_TOKEN = "      - SLACK_APP_TOKEN=${SLACK_APP_TOKEN}";
+// biome-ignore lint/suspicious/noTemplateCurlyInString: Docker Compose env var syntax
+const ENV_CLAUDE_OAUTH = "      - CLAUDE_CODE_OAUTH_TOKEN=${CLAUDE_CODE_OAUTH_TOKEN}";
+// biome-ignore lint/suspicious/noTemplateCurlyInString: Docker Compose env var syntax
+const ENV_ANTHROPIC_KEY = "      - ANTHROPIC_API_KEY=${ANTHROPIC_API_KEY}";
+// biome-ignore lint/suspicious/noTemplateCurlyInString: Docker Compose env var syntax
+const ENV_GITHUB_TOKEN = "      - GITHUB_TOKEN=${GITHUB_TOKEN}";
+// biome-ignore lint/suspicious/noTemplateCurlyInString: Docker Compose env var syntax
+const ENV_GITHUB_EMAIL = "      - GITHUB_EMAIL=${GITHUB_EMAIL}";
+// biome-ignore lint/suspicious/noTemplateCurlyInString: Docker Compose env var syntax
+const ENV_GITHUB_NAME = "      - GITHUB_NAME=${GITHUB_NAME}";
+// biome-ignore lint/suspicious/noTemplateCurlyInString: Docker Compose env var syntax
+const ENV_GITLAB_TOKEN = "      - GITLAB_TOKEN=${GITLAB_TOKEN}";
+// biome-ignore lint/suspicious/noTemplateCurlyInString: Docker Compose env var syntax
+const ENV_GITLAB_EMAIL = "      - GITLAB_EMAIL=${GITLAB_EMAIL}";
+// biome-ignore lint/suspicious/noTemplateCurlyInString: Docker Compose env var syntax
+const ENV_SENTRY_AUTH_TOKEN = "      - SENTRY_AUTH_TOKEN=${SENTRY_AUTH_TOKEN}";
+// biome-ignore lint/suspicious/noTemplateCurlyInString: Docker Compose env var syntax
+const ENV_SENTRY_ORG = "      - SENTRY_ORG=${SENTRY_ORG}";
+
+/**
+ * Generate a docker-compose.yml string from onboard wizard state.
+ * Builds the YAML as plain strings (no YAML library) following the pattern
+ * used in templates-ui/src/lib/compose-generator.ts.
+ */
+export function generateCompose(state: OnboardState): string {
+  const expanded = expandServices(state.services, state.agentIds);
+  const lines: string[] = [];
+
+  // Header
+  lines.push("# Docker Compose for Agent Swarm");
+  lines.push("# Generated by `agent-swarm onboard`");
+  lines.push("#");
+  lines.push("# Usage:");
+  lines.push("#   docker compose --env-file .env up -d");
+  lines.push("");
+  lines.push("services:");
+
+  // ── API service ──
+  lines.push("  swarm-api:");
+  lines.push('    image: "ghcr.io/desplega-ai/agent-swarm:latest"');
+  lines.push("    container_name: swarm-api");
+  lines.push("    pull_policy: always");
+  lines.push("    stop_grace_period: 60s");
+  lines.push("");
+  const port = state.apiPort || 3013;
+
+  lines.push("    environment:");
+  lines.push(ENV_API_KEY);
+  lines.push(`      - MCP_BASE_URL=http://localhost:${port}`);
+  lines.push("      - APP_URL=https://app.agent-swarm.dev");
+
+  if (state.integrations.slack) {
+    lines.push("      - SLACK_DISABLE=false");
+    lines.push(ENV_SLACK_BOT_TOKEN);
+    lines.push(ENV_SLACK_APP_TOKEN);
+  }
+
+  if (state.integrations.github) {
+    lines.push("      - GITHUB_DISABLE=false");
+  }
+
+  lines.push("");
+  lines.push("    ports:");
+  lines.push(`      - "${port}:3013"`);
+  lines.push("");
+  lines.push("    volumes:");
+  lines.push("      - swarm_data:/app/data");
+  lines.push("");
+  lines.push("    healthcheck:");
+  lines.push('      test: ["CMD-SHELL", "curl -f http://localhost:3013/health || exit 1"]');
+  lines.push("      interval: 10s");
+  lines.push("      timeout: 5s");
+  lines.push("      retries: 3");
+  lines.push("      start_period: 15s");
+  lines.push("");
+  lines.push("    restart: unless-stopped");
+
+  // ── Agent services ──
+  let nextPort = 3201;
+
+  for (const svc of expanded) {
+    const port = nextPort++;
+    const agentRole = svc.entry.isLead ? "lead" : "worker";
+    const agentName =
+      svc.entry.count > 1 ? `${svc.entry.displayName} ${svc.index + 1}` : svc.entry.displayName;
+
+    lines.push("");
+    lines.push(`  ${svc.name}:`);
+    lines.push('    image: "ghcr.io/desplega-ai/agent-swarm-worker:latest"');
+    lines.push(`    container_name: ${svc.containerName}`);
+    lines.push("    pull_policy: always");
+    lines.push("    stop_grace_period: 60s");
+    lines.push("");
+    lines.push("    depends_on:");
+    lines.push("      swarm-api:");
+    lines.push("        condition: service_healthy");
+    lines.push("");
+    lines.push("    environment:");
+    if (state.credentialType === "api_key") {
+      lines.push(ENV_ANTHROPIC_KEY);
+    } else {
+      lines.push(ENV_CLAUDE_OAUTH);
+    }
+    lines.push(ENV_API_KEY);
+    lines.push(`      - AGENT_ID=${svc.agentId}`);
+    lines.push(`      - AGENT_NAME=${agentName}`);
+    lines.push(`      - AGENT_ROLE=${agentRole}`);
+    lines.push(`      - TEMPLATE_ID=${svc.entry.template}`);
+    lines.push("      - MCP_BASE_URL=http://swarm-api:3013");
+    lines.push("      - YOLO=true");
+    lines.push("      - SWARM_URL=http://swarm-api:3013");
+
+    if (svc.entry.isLead) {
+      lines.push("      - MAX_CONCURRENT_TASKS=1");
+    }
+
+    if (state.integrations.github) {
+      lines.push(ENV_GITHUB_TOKEN);
+      lines.push(ENV_GITHUB_EMAIL);
+      lines.push(ENV_GITHUB_NAME);
+    }
+
+    if (state.integrations.gitlab) {
+      lines.push(ENV_GITLAB_TOKEN);
+      lines.push(ENV_GITLAB_EMAIL);
+    }
+
+    if (state.integrations.sentry) {
+      lines.push(ENV_SENTRY_AUTH_TOKEN);
+      lines.push(ENV_SENTRY_ORG);
+    }
+
+    lines.push("");
+    lines.push("    ports:");
+    lines.push(`      - "${port}:3000"`);
+    lines.push("");
+    lines.push("    volumes:");
+    lines.push("      - swarm_logs:/app/logs");
+    lines.push("      - swarm_shared:/app/shared");
+    lines.push(`      - swarm_${svc.sanitizedName}:/app/agent`);
+    lines.push("");
+    lines.push("    restart: unless-stopped");
+  }
+
+  // ── Volumes section ──
+  lines.push("");
+  lines.push("volumes:");
+  lines.push("  swarm_data:");
+  lines.push("  swarm_logs:");
+  lines.push("  swarm_shared:");
+  for (const svc of expanded) {
+    lines.push(`  swarm_${svc.sanitizedName}:`);
+  }
+
+  return `${lines.join("\n")}\n`;
+}

package/src/commands/onboard/env-generator.ts

@@ -0,0 +1,79 @@
+import { expandServices } from "./service-names.ts";
+import type { OnboardState } from "./types.ts";
+
+/**
+ * Generate a .env file string from onboard wizard state.
+ * Uses real values from state (not placeholders).
+ */
+export function generateEnv(state: OnboardState): string {
+  const expanded = expandServices(state.services, state.agentIds);
+  const lines: string[] = [];
+
+  // ── Core ──
+  lines.push("# === Core ===");
+  lines.push(`API_KEY=${state.apiKey}`);
+  const port = state.apiPort || 3013;
+  lines.push(`MCP_BASE_URL=http://localhost:${port}`);
+  lines.push("APP_URL=https://app.agent-swarm.dev");
+
+  // ── Authentication ──
+  lines.push("");
+  lines.push("# === Authentication ===");
+  if (state.credentialType === "api_key") {
+    lines.push(`ANTHROPIC_API_KEY=${state.anthropicApiKey}`);
+  } else {
+    lines.push(`CLAUDE_CODE_OAUTH_TOKEN=${state.claudeOAuthToken}`);
+  }
+
+  // ── Integrations ──
+  lines.push("");
+  lines.push("# === Integrations ===");
+
+  // GitHub
+  if (state.integrations.github) {
+    lines.push("");
+    lines.push("# GitHub");
+    lines.push(`GITHUB_TOKEN=${state.githubToken}`);
+    lines.push(`GITHUB_EMAIL=${state.githubEmail}`);
+    lines.push(`GITHUB_NAME=${state.githubName}`);
+    lines.push("GITHUB_DISABLE=false");
+  } else {
+    lines.push("GITHUB_DISABLE=true");
+  }
+
+  // Slack
+  if (state.integrations.slack) {
+    lines.push("");
+    lines.push("# Slack");
+    lines.push(`SLACK_BOT_TOKEN=${state.slackBotToken}`);
+    lines.push(`SLACK_APP_TOKEN=${state.slackAppToken}`);
+    lines.push("SLACK_DISABLE=false");
+  } else {
+    lines.push("SLACK_DISABLE=true");
+  }
+
+  // GitLab
+  if (state.integrations.gitlab) {
+    lines.push("");
+    lines.push("# GitLab");
+    lines.push(`GITLAB_TOKEN=${state.gitlabToken}`);
+    lines.push(`GITLAB_EMAIL=${state.gitlabEmail}`);
+  }
+
+  // Sentry
+  if (state.integrations.sentry) {
+    lines.push("");
+    lines.push("# Sentry");
+    lines.push(`SENTRY_AUTH_TOKEN=${state.sentryToken}`);
+    lines.push(`SENTRY_ORG=${state.sentryOrg}`);
+  }
+
+  // ── Agent IDs ──
+  lines.push("");
+  lines.push("# === Agent IDs (for reference) ===");
+  for (const svc of expanded) {
+    lines.push(`# ${svc.name} = ${svc.agentId}`);
+  }
+
+  return `${lines.join("\n")}\n`;
+}

package/src/commands/onboard/manifest.ts

@@ -0,0 +1,37 @@
+import { expandServices } from "./service-names.ts";
+import type { OnboardState } from "./types.ts";
+
+/**
+ * Generate a JSON-serializable manifest object from onboard wizard state.
+ * This manifest captures the full configuration for later reference,
+ * upgrades, or re-generation.
+ */
+export function generateManifest(state: OnboardState): object {
+  const expanded = expandServices(state.services, state.agentIds);
+
+  return {
+    version: 1,
+    createdAt: new Date().toISOString(),
+    deployType: state.deployType,
+    preset: state.presetId,
+    harness: state.harness,
+    services: expanded.map((svc) => ({
+      name: svc.name,
+      templateId: svc.entry.template,
+      agentId: svc.agentId,
+      role: svc.entry.isLead ? "lead" : "worker",
+      displayName:
+        svc.entry.count > 1 ? `${svc.entry.displayName} ${svc.index + 1}` : svc.entry.displayName,
+    })),
+    integrations: {
+      github: state.integrations.github,
+      slack: state.integrations.slack,
+      gitlab: state.integrations.gitlab,
+      sentry: state.integrations.sentry,
+    },
+    composePath: "./docker-compose.yml",
+    envPath: "./.env",
+    apiUrl: `http://localhost:${state.apiPort || 3013}`,
+    dashboardUrl: "https://app.agent-swarm.dev",
+  };
+}

package/src/commands/onboard/presets.ts

@@ -0,0 +1,85 @@
+import type { ServiceEntry } from "./types.ts";
+
+export interface Preset {
+  id: string;
+  name: string;
+  description: string;
+  services: ServiceEntry[];
+}
+
+export const PRESETS: Preset[] = [
+  {
+    id: "dev",
+    name: "Development Team",
+    description: "Build software with a lead coordinator and two coding agents.",
+    services: [
+      { template: "official/lead", displayName: "Lead", count: 1, role: "lead", isLead: true },
+      { template: "official/coder", displayName: "Coder", count: 2, role: "coder" },
+    ],
+  },
+  {
+    id: "content",
+    name: "Content Team",
+    description: "Content creation pipeline with writing, review, and strategy.",
+    services: [
+      { template: "official/lead", displayName: "Lead", count: 1, role: "lead", isLead: true },
+      {
+        template: "official/content-writer",
+        displayName: "Content Writer",
+        count: 1,
+        role: "content-writer",
+      },
+      {
+        template: "official/content-reviewer",
+        displayName: "Content Reviewer",
+        count: 1,
+        role: "content-reviewer",
+      },
+      {
+        template: "official/content-strategist",
+        displayName: "Content Strategist",
+        count: 1,
+        role: "content-strategist",
+      },
+    ],
+  },
+  {
+    id: "research",
+    name: "Research Team",
+    description: "Research and analysis with peer review.",
+    services: [
+      { template: "official/lead", displayName: "Lead", count: 1, role: "lead", isLead: true },
+      {
+        template: "official/researcher",
+        displayName: "Researcher",
+        count: 1,
+        role: "researcher",
+      },
+      { template: "official/reviewer", displayName: "Reviewer", count: 1, role: "reviewer" },
+    ],
+  },
+  {
+    id: "solo",
+    name: "Solo Agent",
+    description: "Single agent, simplest setup.",
+    services: [{ template: "official/coder", displayName: "Coder", count: 1, role: "coder" }],
+  },
+  {
+    id: "custom",
+    name: "Custom",
+    description: "Choose your own templates.",
+    services: [],
+  },
+];
+
+export function getPresetById(id: string): Preset | undefined {
+  return PRESETS.find((p) => p.id === id);
+}
+
+export function getAgentCount(services: ServiceEntry[]): number {
+  return services.reduce((sum, s) => sum + s.count, 0);
+}
+
+export function getAgentSummary(services: ServiceEntry[]): string {
+  return services.map((s) => `${s.count} ${s.displayName.toLowerCase()}`).join(" + ");
+}

package/src/commands/onboard/service-names.ts

@@ -0,0 +1,47 @@
+import type { ServiceEntry } from "./types.ts";
+
+export interface ExpandedService {
+  name: string; // e.g., "lead", "worker-coder-1"
+  sanitizedName: string; // e.g., "lead", "worker_coder_1"
+  containerName: string; // e.g., "swarm-lead", "swarm-worker-coder-1"
+  entry: ServiceEntry;
+  index: number; // 0-based within the entry's count
+  agentId: string; // from state.agentIds[name]
+}
+
+/**
+ * Expand ServiceEntry[] (which have a `count` field) into individual named services.
+ * Naming rules:
+ *  - lead (count=1) -> "lead"
+ *  - lead (count>1) -> "lead-1", "lead-2"
+ *  - worker role "coder" (count=1) -> "worker-coder"
+ *  - worker role "coder" (count=2) -> "worker-coder-1", "worker-coder-2"
+ */
+export function expandServices(
+  services: ServiceEntry[],
+  agentIds: Record<string, string>,
+): ExpandedService[] {
+  const result: ExpandedService[] = [];
+
+  for (const entry of services) {
+    for (let i = 0; i < entry.count; i++) {
+      const suffix = entry.count > 1 ? `-${i + 1}` : "";
+      const baseName = entry.isLead ? "lead" : `worker-${entry.role}`;
+      const name = `${baseName}${suffix}`;
+      const sanitizedName = name.replace(/-/g, "_");
+      const containerName = `swarm-${name}`;
+      const agentId = agentIds[name] ?? "";
+
+      result.push({
+        name,
+        sanitizedName,
+        containerName,
+        entry,
+        index: i,
+        agentId,
+      });
+    }
+  }
+
+  return result;
+}