@desplega.ai/agent-swarm 1.20.0 → 1.49.0

package/src/commands/onboard/steps/post-connect.tsx

@@ -0,0 +1,145 @@
+import { Select } from "@inkjs/ui";
+import { Box, Text } from "ink";
+import { useEffect, useRef, useState } from "react";
+import {
+  createDefaultMcpJson,
+  createDefaultSettingsLocal,
+  createHooksConfig,
+  SERVER_NAME,
+} from "../../shared/client-config.ts";
+import type { StepProps } from "../types.ts";
+
+type SubStep = "ask" | "connecting" | "done";
+
+export function PostConnectStep({ state, dryRun, addLog, goToNext, goToStep }: StepProps) {
+  const [subStep, setSubStep] = useState<SubStep>("ask");
+  const executed = useRef(false);
+
+  useEffect(() => {
+    if (subStep !== "connecting") return;
+    if (executed.current) return;
+    executed.current = true;
+
+    const connect = async () => {
+      const cwd = process.cwd();
+      const mcpBaseUrl = `http://localhost:${state.apiPort || 3013}`;
+
+      // Create .claude dir if needed
+      if (!dryRun) {
+        await Bun.$`mkdir -p ${cwd}/.claude`.quiet();
+      }
+
+      // Update .claude/settings.local.json
+      const settingsPath = `${cwd}/.claude/settings.local.json`;
+      const settingsFile = Bun.file(settingsPath);
+      let settings: Record<string, unknown>;
+
+      if (await settingsFile.exists()) {
+        settings = await settingsFile.json();
+      } else {
+        settings = createDefaultSettingsLocal();
+      }
+
+      // Add permissions
+      if (!settings.permissions) settings.permissions = { allow: [] };
+      const perms = settings.permissions as { allow: string[] };
+      if (!perms.allow) perms.allow = [];
+      const permEntry = `mcp__${SERVER_NAME}__*`;
+      if (!perms.allow.includes(permEntry)) {
+        perms.allow.push(permEntry);
+      }
+
+      // Add enabled MCP server
+      if (!settings.enabledMcpjsonServers) settings.enabledMcpjsonServers = [];
+      const enabled = settings.enabledMcpjsonServers as string[];
+      if (!enabled.includes(SERVER_NAME)) {
+        enabled.push(SERVER_NAME);
+      }
+
+      // Add hooks
+      settings.hooks = { ...((settings.hooks as object) || {}), ...createHooksConfig() };
+
+      if (!dryRun) {
+        await Bun.write(settingsPath, JSON.stringify(settings, null, 2));
+      }
+      addLog("Updated .claude/settings.local.json", true);
+
+      // Update .mcp.json
+      const mcpPath = `${cwd}/.mcp.json`;
+      const mcpFile = Bun.file(mcpPath);
+      let mcpConfig: Record<string, unknown>;
+
+      if (await mcpFile.exists()) {
+        mcpConfig = await mcpFile.json();
+      } else {
+        mcpConfig = createDefaultMcpJson();
+      }
+
+      if (!mcpConfig.mcpServers) mcpConfig.mcpServers = {};
+      const servers = mcpConfig.mcpServers as Record<string, unknown>;
+      servers[SERVER_NAME] = {
+        type: "http",
+        url: `${mcpBaseUrl}/mcp`,
+        headers: {
+          Authorization: `Bearer ${state.apiKey}`,
+          "X-Agent-ID": crypto.randomUUID(),
+        },
+      };
+
+      if (!dryRun) {
+        await Bun.write(mcpPath, JSON.stringify(mcpConfig, null, 2));
+      }
+      addLog("Updated .mcp.json", true);
+
+      setSubStep("done");
+    };
+
+    connect().catch((err) => addLog(`Connection error: ${err}`));
+  }, [subStep, state.apiKey, state.apiPort, dryRun, addLog]);
+
+  useEffect(() => {
+    if (subStep === "done") {
+      const timer = setTimeout(() => goToNext(), 500);
+      return () => clearTimeout(timer);
+    }
+  }, [subStep, goToNext]);
+
+  if (subStep === "ask") {
+    return (
+      <Box flexDirection="column" padding={1}>
+        <Text bold>Connect this project to the swarm?</Text>
+        <Text dimColor>This will update .mcp.json and .claude/settings.local.json</Text>
+        <Box marginTop={1}>
+          <Select
+            options={[
+              { label: "Yes — connect now", value: "yes" },
+              { label: "No — skip", value: "no" },
+              { label: "Skip all post-deploy steps", value: "skip_all" },
+            ]}
+            onChange={(value) => {
+              if (value === "yes") {
+                setSubStep("connecting");
+              } else if (value === "skip_all") {
+                goToStep("done");
+              } else {
+                goToNext();
+              }
+            }}
+          />
+        </Box>
+      </Box>
+    );
+  }
+
+  if (subStep === "connecting" || subStep === "done") {
+    return (
+      <Box flexDirection="column" padding={1}>
+        <Text color="green">
+          {"✓"} Connected! Your local Claude Code is now linked to the swarm.
+        </Text>
+      </Box>
+    );
+  }
+
+  return null;
+}

package/src/commands/onboard/steps/post-dashboard.tsx

@@ -0,0 +1,34 @@
+import { Select } from "@inkjs/ui";
+import { Box, Text } from "ink";
+import type { StepProps } from "../types.ts";
+
+export function PostDashboardStep({ state, addLog, goToNext }: StepProps) {
+  const apiUrl = `http://localhost:${state.apiPort || 3013}`;
+  const dashboardUrl = `https://app.agent-swarm.dev?api_url=${apiUrl}&api_key=${state.apiKey}`;
+
+  return (
+    <Box flexDirection="column" padding={1}>
+      <Text bold>Open the swarm dashboard?</Text>
+      <Text dimColor>{dashboardUrl}</Text>
+      <Box marginTop={1}>
+        <Select
+          options={[
+            { label: "Yes — open in browser", value: "yes" },
+            { label: "No — skip", value: "no" },
+          ]}
+          onChange={async (value) => {
+            if (value === "yes") {
+              try {
+                await Bun.$`open ${dashboardUrl}`.quiet();
+                addLog("Opened dashboard in browser");
+              } catch {
+                addLog(`Open manually: ${dashboardUrl}`);
+              }
+            }
+            goToNext();
+          }}
+        />
+      </Box>
+    </Box>
+  );
+}

package/src/commands/onboard/steps/post-task.tsx

@@ -0,0 +1,103 @@
+import { Select, TextInput } from "@inkjs/ui";
+import { Box, Text } from "ink";
+import { useEffect, useRef, useState } from "react";
+import type { StepProps } from "../types.ts";
+
+type SubStep = "ask" | "input" | "sending" | "sent";
+
+export function PostTaskStep({ state, addLog, goToNext }: StepProps) {
+  const [subStep, setSubStep] = useState<SubStep>("ask");
+  const [sentTask, setSentTask] = useState("");
+
+  const leadService = state.services.find((s) => s.isLead);
+  const leadName = leadService ? "lead" : Object.keys(state.agentIds)[0] || "";
+  const leadAgentId = state.agentIds[leadName] || "";
+
+  if (subStep === "ask") {
+    return (
+      <Box flexDirection="column" padding={1}>
+        <Text bold>Send your first task to the swarm?</Text>
+        <Box marginTop={1}>
+          <Select
+            options={[
+              { label: "Yes — send a task", value: "yes" },
+              { label: "Skip", value: "skip" },
+            ]}
+            onChange={(value) => {
+              if (value === "yes") {
+                setSubStep("input");
+              } else {
+                goToNext();
+              }
+            }}
+          />
+        </Box>
+      </Box>
+    );
+  }
+
+  if (subStep === "input") {
+    return (
+      <Box flexDirection="column" padding={1}>
+        <Text bold>What should the swarm do?</Text>
+        <Box marginTop={1}>
+          <TextInput
+            placeholder="Say hello to the swarm"
+            onSubmit={async (value) => {
+              const task = value.trim() || "Say hello to the swarm";
+              setSubStep("sending");
+              setSentTask(task);
+              try {
+                const res = await fetch(`http://localhost:${state.apiPort || 3013}/api/tasks`, {
+                  method: "POST",
+                  headers: {
+                    "Content-Type": "application/json",
+                    Authorization: `Bearer ${state.apiKey}`,
+                  },
+                  body: JSON.stringify({
+                    task,
+                    agentId: leadAgentId || undefined,
+                  }),
+                });
+                if (!res.ok) {
+                  const text = await res.text();
+                  addLog(`Task API returned ${res.status}: ${text}`);
+                } else {
+                  addLog("Task sent successfully");
+                }
+              } catch (err) {
+                addLog(`Failed to send task: ${err}`);
+              }
+              setSubStep("sent");
+            }}
+          />
+        </Box>
+      </Box>
+    );
+  }
+
+  if (subStep === "sending" || subStep === "sent") {
+    return (
+      <Box flexDirection="column" padding={1}>
+        <Text color="green">
+          {"✓"} Task sent: "{sentTask}"
+        </Text>
+        <Text dimColor>Check the dashboard to see it get picked up.</Text>
+        {subStep === "sent" && <DoneTimer goToNext={goToNext} />}
+      </Box>
+    );
+  }
+
+  return null;
+}
+
+function DoneTimer({ goToNext }: { goToNext: () => void }) {
+  const executed = useRef(false);
+  useEffect(() => {
+    if (executed.current) return;
+    executed.current = true;
+    const timer = setTimeout(() => goToNext(), 1000);
+    return () => clearTimeout(timer);
+  }, [goToNext]);
+  return null;
+}

package/src/commands/onboard/steps/prereq-check.tsx

@@ -0,0 +1,178 @@
+import { Select, Spinner } from "@inkjs/ui";
+import { Box, Text } from "ink";
+import { useEffect, useRef, useState } from "react";
+import type { StepProps } from "../types.ts";
+
+type CheckStatus = "checking" | "passed" | "failed";
+
+interface CheckResult {
+  docker: { ok: boolean; version?: string; error?: string };
+  compose: { ok: boolean; version?: string; error?: string };
+  ports: { ok: boolean; conflicts?: string[] };
+}
+
+export function PrereqCheckStep({ state, addLog, goToNext, goToStep, goToError }: StepProps) {
+  const [status, setStatus] = useState<CheckStatus>("checking");
+  const [result, setResult] = useState<CheckResult | null>(null);
+  const executed = useRef(false);
+
+  useEffect(() => {
+    if (executed.current) return;
+    executed.current = true;
+
+    const run = async () => {
+      const res: CheckResult = {
+        docker: { ok: false },
+        compose: { ok: false },
+        ports: { ok: true },
+      };
+
+      // Check Docker
+      try {
+        const out = await Bun.$`docker --version`.quiet();
+        if (out.exitCode === 0) {
+          res.docker = { ok: true, version: out.text().trim() };
+        } else {
+          res.docker = { ok: false, error: "Docker exited with non-zero status" };
+        }
+      } catch {
+        res.docker = { ok: false, error: "Docker not found" };
+      }
+
+      // Check Docker Compose
+      try {
+        const out = await Bun.$`docker compose version`.quiet();
+        if (out.exitCode === 0) {
+          res.compose = { ok: true, version: out.text().trim() };
+        } else {
+          res.compose = { ok: false, error: "Docker Compose not found" };
+        }
+      } catch {
+        res.compose = { ok: false, error: "Docker Compose v2 not found" };
+      }
+
+      // Check ports
+      const portsToCheck = [3013];
+      const agentCount = state.services.reduce((sum, s) => sum + s.count, 0);
+      for (let i = 0; i < agentCount; i++) {
+        portsToCheck.push(3201 + i);
+      }
+
+      const conflicts: string[] = [];
+      for (const port of portsToCheck) {
+        try {
+          const out = await Bun.$`lsof -i :${port} -t`.quiet();
+          if (out.exitCode === 0 && out.text().trim()) {
+            conflicts.push(`Port ${port} is in use (PID: ${out.text().trim().split("\n")[0]})`);
+          }
+        } catch {
+          // Port is free
+        }
+      }
+      if (conflicts.length > 0) {
+        res.ports = { ok: false, conflicts };
+      }
+
+      setResult(res);
+
+      if (res.docker.ok && res.compose.ok && res.ports.ok) {
+        addLog("All prerequisites met");
+        setStatus("passed");
+      } else {
+        setStatus("failed");
+      }
+    };
+
+    run().catch((err) => goToError(err.message));
+  }, [state.services, addLog, goToError]);
+
+  // Auto-advance on pass
+  useEffect(() => {
+    if (status === "passed") {
+      const timer = setTimeout(() => goToNext(), 500);
+      return () => clearTimeout(timer);
+    }
+  }, [status, goToNext]);
+
+  if (status === "checking") {
+    return (
+      <Box padding={1}>
+        <Spinner label="Checking prerequisites..." />
+      </Box>
+    );
+  }
+
+  if (status === "passed" && result) {
+    return (
+      <Box flexDirection="column" padding={1}>
+        <Text color="green">
+          {"✓"} {result.docker.version}
+        </Text>
+        <Text color="green">
+          {"✓"} {result.compose.version}
+        </Text>
+        <Text color="green">{"✓"} All ports available</Text>
+      </Box>
+    );
+  }
+
+  // Failed
+  return (
+    <Box flexDirection="column" padding={1}>
+      {result?.docker.ok ? (
+        <Text color="green">
+          {"✓"} {result.docker.version}
+        </Text>
+      ) : (
+        <Box flexDirection="column">
+          <Text color="red">
+            {"✗"} Docker: {result?.docker.error}
+          </Text>
+          <Text dimColor>
+            {" "}
+            Install: brew install --cask docker (macOS) or https://docs.docker.com/get-docker/
+          </Text>
+        </Box>
+      )}
+      {result?.compose.ok ? (
+        <Text color="green">
+          {"✓"} {result.compose.version}
+        </Text>
+      ) : (
+        <Text color="red">
+          {"✗"} Docker Compose v2: {result?.compose.error}
+        </Text>
+      )}
+      {result?.ports.ok ? (
+        <Text color="green">{"✓"} All ports available</Text>
+      ) : (
+        <Box flexDirection="column">
+          <Text color="red">{"✗"} Port conflicts:</Text>
+          {result?.ports.conflicts?.map((c) => (
+            <Text key={c} dimColor>
+              {" "}
+              {c}
+            </Text>
+          ))}
+        </Box>
+      )}
+      <Box marginTop={1}>
+        <Select
+          options={[
+            { label: "Retry checks", value: "retry" },
+            { label: "Skip — just keep the generated files", value: "skip" },
+          ]}
+          onChange={(value) => {
+            if (value === "retry") {
+              executed.current = false;
+              setStatus("checking");
+              setResult(null);
+            } else {
+              goToStep("done");
+            }
+          }}
+        />
+      </Box>
+    </Box>
+  );
+}

package/src/commands/onboard/steps/review.tsx

@@ -0,0 +1,82 @@
+import { Select } from "@inkjs/ui";
+import { Box, Text } from "ink";
+import { getPresetById } from "../presets.ts";
+import type { StepProps } from "../types.ts";
+
+export function ReviewStep({ state, dryRun, goToNext, goToStep }: StepProps) {
+  const preset = state.presetId ? getPresetById(state.presetId) : null;
+  const totalAgents = state.services.reduce((sum, s) => sum + s.count, 0);
+
+  const enabledIntegrations = Object.entries(state.integrations)
+    .filter(([, v]) => v)
+    .map(([k]) => k);
+
+  const maskedKey = state.apiKey ? `${state.apiKey.slice(0, 8)}...` : "(not set)";
+
+  return (
+    <Box flexDirection="column" padding={1}>
+      <Text bold>Review Configuration</Text>
+      <Text dimColor>Confirm before generating files.</Text>
+
+      {dryRun && (
+        <Box marginTop={1}>
+          <Text color="yellow" bold>
+            DRY-RUN MODE — files will NOT be written
+          </Text>
+        </Box>
+      )}
+
+      <Box marginTop={1} flexDirection="column">
+        <Text>
+          Deploy type: <Text color="cyan">{state.deployType}</Text>
+        </Text>
+        <Text>
+          Preset: <Text color="cyan">{preset ? preset.name : (state.presetId ?? "custom")}</Text>
+        </Text>
+        <Text>
+          Services: <Text color="cyan">{totalAgents}</Text>
+        </Text>
+        {state.services.map((svc) => (
+          <Text key={svc.template} dimColor>
+            {"  "}- {svc.displayName} x{svc.count} ({svc.template})
+          </Text>
+        ))}
+        <Text>
+          Harness: <Text color="cyan">{state.harness}</Text>
+        </Text>
+        <Text>
+          Integrations:{" "}
+          <Text color="cyan">
+            {enabledIntegrations.length > 0 ? enabledIntegrations.join(", ") : "none"}
+          </Text>
+        </Text>
+        <Text>
+          Output directory: <Text color="cyan">{state.outputDir}</Text>
+        </Text>
+        <Text>
+          API key: <Text color="cyan">{maskedKey}</Text>
+        </Text>
+      </Box>
+
+      <Box marginTop={1} flexDirection="column">
+        <Text bold>What would you like to do?</Text>
+        <Select
+          options={[
+            { label: "Generate files and start", value: "generate" },
+            { label: "Go back to integrations", value: "back" },
+            { label: "Cancel", value: "cancel" },
+          ]}
+          onChange={(value) => {
+            if (value === "generate") {
+              goToNext();
+            } else if (value === "back") {
+              goToStep("integration_menu");
+            } else {
+              goToStep("done");
+            }
+          }}
+        />
+      </Box>
+    </Box>
+  );
+}

package/src/commands/onboard/steps/start.tsx

@@ -0,0 +1,97 @@
+import { Select, Spinner } from "@inkjs/ui";
+import { Box, Text } from "ink";
+import { useEffect, useRef, useState } from "react";
+import type { StepProps } from "../types.ts";
+
+type StartStatus = "starting" | "success" | "failed";
+
+export function StartStep({ state, addLog, goToNext }: StepProps) {
+  const [status, setStatus] = useState<StartStatus>("starting");
+  const [errorMsg, setErrorMsg] = useState("");
+  const executed = useRef(false);
+
+  useEffect(() => {
+    if (executed.current) return;
+    executed.current = true;
+
+    const run = async () => {
+      addLog("Running docker compose up -d...");
+      try {
+        const result = await Bun.$`docker compose --env-file .env up -d`
+          .cwd(state.outputDir)
+          .quiet();
+
+        if (result.exitCode === 0) {
+          addLog("Docker stack started successfully");
+          setStatus("success");
+        } else {
+          const stderr = result.stderr.toString().trim();
+          setErrorMsg(stderr || "docker compose up failed");
+          setStatus("failed");
+        }
+      } catch (err) {
+        setErrorMsg(err instanceof Error ? err.message : String(err));
+        setStatus("failed");
+      }
+    };
+
+    run();
+  }, [state.outputDir, addLog]);
+
+  useEffect(() => {
+    if (status === "success") {
+      const timer = setTimeout(() => goToNext(), 500);
+      return () => clearTimeout(timer);
+    }
+  }, [status, goToNext]);
+
+  if (status === "starting") {
+    return (
+      <Box padding={1}>
+        <Spinner label="Starting Docker stack..." />
+      </Box>
+    );
+  }
+
+  if (status === "success") {
+    return (
+      <Box padding={1}>
+        <Text color="green">{"✓"} Docker stack started</Text>
+      </Box>
+    );
+  }
+
+  return (
+    <Box flexDirection="column" padding={1}>
+      <Text color="red">{"✗"} Failed to start Docker stack</Text>
+      <Text dimColor>{errorMsg}</Text>
+      <Box marginTop={1}>
+        <Select
+          options={[
+            { label: "Retry", value: "retry" },
+            { label: "View logs (docker compose logs)", value: "logs" },
+            { label: "Skip", value: "skip" },
+          ]}
+          onChange={async (value) => {
+            if (value === "retry") {
+              executed.current = false;
+              setStatus("starting");
+              setErrorMsg("");
+            } else if (value === "logs") {
+              try {
+                const logs = await Bun.$`docker compose logs --tail 30`
+                  .cwd(state.outputDir)
+                  .quiet();
+                addLog(logs.text());
+              } catch {
+                addLog("Failed to fetch logs");
+              }
+            } else {
+              goToNext();
+            }
+          }}
+        />
+      </Box>
+    </Box>
+  );
+}

package/src/commands/onboard/templates.ts

@@ -0,0 +1,34 @@
+import type { TemplateConfig } from "../../../templates/schema.ts";
+
+const DEFAULT_REGISTRY_URL = "https://templates.agent-swarm.dev";
+
+export async function fetchTemplateList(
+  registryUrl: string = DEFAULT_REGISTRY_URL,
+): Promise<TemplateConfig[]> {
+  const url = `${registryUrl.replace(/\/+$/, "")}/api/templates`;
+
+  let res: Response;
+  try {
+    res = await fetch(url);
+  } catch (err) {
+    throw new Error(
+      `Failed to reach template registry at ${url}: ${err instanceof Error ? err.message : String(err)}`,
+    );
+  }
+
+  if (!res.ok) {
+    throw new Error(`Template registry returned HTTP ${res.status}: ${res.statusText}`);
+  }
+
+  const data = (await res.json()) as { templates?: TemplateConfig[] } | TemplateConfig[];
+
+  // The API may return { templates: [...] } or a raw array
+  if (Array.isArray(data)) {
+    return data;
+  }
+  if (data.templates && Array.isArray(data.templates)) {
+    return data.templates;
+  }
+
+  throw new Error("Unexpected response format from template registry");
+}