@desplega.ai/agent-swarm 1.20.0 → 1.51.2

package/src/commands/onboard/steps/core-credentials.tsx

@@ -0,0 +1,111 @@
+import { randomBytes, randomUUID } from "node:crypto";
+import { createServer } from "node:net";
+import { Spinner } from "@inkjs/ui";
+import { Box, Text } from "ink";
+import { useEffect, useRef, useState } from "react";
+import type { StepProps } from "../types.ts";
+
+/** Find an available port, starting from the preferred one. */
+async function findAvailablePort(preferred: number): Promise<number> {
+  return new Promise((resolve) => {
+    const server = createServer();
+    server.listen(preferred, () => {
+      server.close(() => resolve(preferred));
+    });
+    server.on("error", () => {
+      // Port is in use, try a random one
+      const server2 = createServer();
+      server2.listen(0, () => {
+        const addr = server2.address();
+        const port = typeof addr === "object" && addr ? addr.port : 0;
+        server2.close(() => resolve(port));
+      });
+    });
+  });
+}
+
+export function CoreCredentialsStep({ state, goToNext, addLog }: StepProps) {
+  const [apiKey, setApiKey] = useState("");
+  const [agentIds, setAgentIds] = useState<Record<string, string>>({});
+  const [apiPort, setApiPort] = useState(0);
+  const [ready, setReady] = useState(false);
+  const generatedRef = useRef(false);
+
+  useEffect(() => {
+    if (generatedRef.current) return;
+    generatedRef.current = true;
+
+    const generate = async () => {
+      const key = randomBytes(32).toString("hex").slice(0, 24);
+      setApiKey(key);
+
+      const ids: Record<string, string> = {};
+      for (const service of state.services) {
+        for (let i = 0; i < service.count; i++) {
+          const suffix = service.count > 1 ? `-${i + 1}` : "";
+          const name = service.isLead ? "lead" : `worker-${service.role}${suffix}`;
+          ids[name] = randomUUID();
+        }
+      }
+      setAgentIds(ids);
+
+      // Find available port (prefer 3013)
+      const port = await findAvailablePort(3013);
+      setApiPort(port);
+
+      const masked = `${key.slice(0, 4)}...${key.slice(-4)}`;
+      addLog(`Generated API key: ${masked}`);
+      addLog(`Generated ${Object.keys(ids).length} agent ID(s)`);
+      addLog(`API port: ${port}${port !== 3013 ? " (3013 was in use)" : ""}`);
+
+      setTimeout(() => setReady(true), 1000);
+    };
+
+    generate();
+  }, [state.services, addLog]);
+
+  useEffect(() => {
+    if (!ready) return;
+    goToNext({ apiKey, agentIds, apiPort });
+  }, [ready, apiKey, agentIds, apiPort, goToNext]);
+
+  const idEntries = Object.entries(agentIds);
+
+  return (
+    <Box flexDirection="column" padding={1}>
+      <Text bold>Generating credentials...</Text>
+      {apiKey && (
+        <Box marginTop={1} flexDirection="column">
+          <Text>
+            API Key:{" "}
+            <Text color="green">
+              {apiKey.slice(0, 4)}...{apiKey.slice(-4)}
+            </Text>
+          </Text>
+          {apiPort > 0 && (
+            <Text>
+              API Port: <Text color="green">{apiPort}</Text>
+              {apiPort !== 3013 && <Text dimColor> (3013 was in use)</Text>}
+            </Text>
+          )}
+          {idEntries.length > 0 && (
+            <Box flexDirection="column" marginTop={1}>
+              <Text>Agent IDs:</Text>
+              {idEntries.map(([label, id]) => (
+                <Text key={id}>
+                  {"  "}
+                  {label}: <Text dimColor>{id}</Text>
+                </Text>
+              ))}
+            </Box>
+          )}
+        </Box>
+      )}
+      {!ready && (
+        <Box marginTop={1}>
+          <Spinner label="Preparing next step..." />
+        </Box>
+      )}
+    </Box>
+  );
+}

package/src/commands/onboard/steps/custom-templates.tsx

@@ -0,0 +1,168 @@
+import { Select } from "@inkjs/ui";
+import { Box, Text } from "ink";
+import { useEffect, useRef, useState } from "react";
+import type { TemplateConfig } from "../../../../templates/schema.ts";
+import { fetchTemplateList } from "../templates.ts";
+import type { ServiceEntry, StepProps } from "../types.ts";
+
+type SubStep = "loading" | "picking" | "confirming";
+
+export function CustomTemplatesStep({
+  state: _state,
+  dryRun,
+  addLog,
+  goToNext,
+  goToError,
+}: StepProps) {
+  const [subStep, setSubStep] = useState<SubStep>("loading");
+  const [templates, setTemplates] = useState<TemplateConfig[]>([]);
+  const [services, setServices] = useState<ServiceEntry[]>([]);
+  const fetchedRef = useRef(false);
+
+  // Fetch templates on mount
+  useEffect(() => {
+    if (fetchedRef.current) return;
+    fetchedRef.current = true;
+
+    const load = async () => {
+      addLog("Fetching templates from registry...");
+      try {
+        const list = await fetchTemplateList();
+        if (list.length === 0) {
+          goToError("No templates found in the registry.");
+          return;
+        }
+        setTemplates(list);
+        setSubStep("picking");
+        addLog(`Found ${list.length} templates`);
+      } catch (err) {
+        goToError(err instanceof Error ? err.message : String(err));
+      }
+    };
+
+    load();
+  }, [addLog, goToError]);
+
+  if (subStep === "loading") {
+    return (
+      <Box flexDirection="column" padding={1}>
+        <Text dimColor>Loading templates from registry...</Text>
+      </Box>
+    );
+  }
+
+  if (subStep === "picking") {
+    const leadTemplates = templates.filter((t) => t.agentDefaults.isLead);
+    const workerTemplates = templates.filter((t) => !t.agentDefaults.isLead);
+
+    const options = [
+      ...leadTemplates.map((t) => ({
+        label: `[Lead] ${t.displayName} — ${t.description}`,
+        value: t.name,
+      })),
+      ...workerTemplates.map((t) => ({
+        label: `${t.displayName} — ${t.description}`,
+        value: t.name,
+      })),
+    ];
+
+    return (
+      <Box flexDirection="column" padding={1}>
+        {services.length > 0 && (
+          <Box flexDirection="column" marginBottom={1}>
+            <Text bold>Selected services:</Text>
+            {services.map((s) => (
+              <Text key={s.template}>
+                {"  "}- {s.displayName} ({s.template}){s.isLead ? " [lead]" : ""}
+              </Text>
+            ))}
+          </Box>
+        )}
+        <Text bold>Add a service template{services.length > 0 ? " (or select Done)" : ""}:</Text>
+        <Box marginTop={1}>
+          <Select
+            options={[
+              ...(services.length > 0
+                ? [{ label: "Done — finish selecting", value: "__done__" }]
+                : []),
+              ...options,
+            ]}
+            onChange={(value) => {
+              if (value === "__done__") {
+                setSubStep("confirming");
+                return;
+              }
+
+              const tpl = templates.find((t) => t.name === value);
+              if (!tpl) return;
+
+              // Avoid adding the same template twice
+              if (services.some((s) => s.template === tpl.name)) {
+                addLog(`Template "${tpl.displayName}" is already selected.`);
+                return;
+              }
+
+              const entry: ServiceEntry = {
+                template: tpl.name,
+                displayName: tpl.displayName,
+                count: 1,
+                role: tpl.agentDefaults.role,
+                isLead: tpl.agentDefaults.isLead ?? false,
+              };
+
+              setServices((prev) => [...prev, entry]);
+              addLog(`Added: ${tpl.displayName}`);
+            }}
+          />
+        </Box>
+      </Box>
+    );
+  }
+
+  if (subStep === "confirming") {
+    const hasLead = services.some((s) => s.isLead);
+
+    return (
+      <Box flexDirection="column" padding={1}>
+        <Box flexDirection="column" marginBottom={1}>
+          <Text bold>Selected services:</Text>
+          {services.map((s) => (
+            <Text key={s.template}>
+              {"  "}- {s.displayName} ({s.template}){s.isLead ? " [lead]" : ""}
+            </Text>
+          ))}
+        </Box>
+        {!hasLead && (
+          <Box marginBottom={1}>
+            <Text color="yellow">
+              Warning: No lead agent selected. A lead coordinates task delegation.
+            </Text>
+          </Box>
+        )}
+        <Text bold>Confirm selection?</Text>
+        <Box marginTop={1}>
+          <Select
+            options={[
+              { label: "Confirm and continue", value: "confirm" },
+              { label: "Go back and add more", value: "back" },
+            ]}
+            onChange={(value) => {
+              if (value === "back") {
+                setSubStep("picking");
+                return;
+              }
+              addLog(
+                dryRun
+                  ? `[DRY-RUN] Would use ${services.length} custom templates`
+                  : `Using ${services.length} custom templates`,
+              );
+              goToNext({ services });
+            }}
+          />
+        </Box>
+      </Box>
+    );
+  }
+
+  return null;
+}

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

@@ -0,0 +1,154 @@
+import { Spinner } from "@inkjs/ui";
+import { Box, Text } from "ink";
+import { useEffect, useRef, useState } from "react";
+import { generateCompose } from "../compose-generator.ts";
+import { generateEnv } from "../env-generator.ts";
+import type { StepProps } from "../types.ts";
+
+interface ManifestConfig {
+  presetId: string | null;
+  deployType: string;
+  harness: string;
+  services: { template: string; displayName: string; count: number; role: string }[];
+  integrations: Record<string, boolean>;
+  agentIds: Record<string, string>;
+  createdAt: string;
+}
+
+function generateManifest(state: {
+  presetId: string | null;
+  deployType: string;
+  harness: string;
+  services: { template: string; displayName: string; count: number; role: string }[];
+  integrations: Record<string, boolean>;
+  agentIds: Record<string, string>;
+}): ManifestConfig {
+  return {
+    presetId: state.presetId,
+    deployType: state.deployType,
+    harness: state.harness,
+    services: state.services.map((s) => ({
+      template: s.template,
+      displayName: s.displayName,
+      count: s.count,
+      role: s.role,
+    })),
+    integrations: { ...state.integrations },
+    agentIds: { ...state.agentIds },
+    createdAt: new Date().toISOString(),
+  };
+}
+
+export function GenerateStep({ state, dryRun, addLog, goToNext, goToStep, goToError }: StepProps) {
+  const executedRef = useRef(false);
+  const [composePreview, setComposePreview] = useState<string | null>(null);
+  const [envPreview, setEnvPreview] = useState<string | null>(null);
+  const [done, setDone] = useState(false);
+
+  useEffect(() => {
+    if (executedRef.current) return;
+    executedRef.current = true;
+
+    const run = async () => {
+      const composeContent = generateCompose(state);
+      const envContent = generateEnv(state);
+      const manifest = generateManifest(state);
+
+      if (dryRun) {
+        const composeLines = composeContent.split("\n").slice(0, 30).join("\n");
+        const envLines = envContent.split("\n").slice(0, 20).join("\n");
+        setComposePreview(composeLines);
+        setEnvPreview(envLines);
+
+        addLog("Write docker-compose.yml", true);
+        addLog("Write .env", true);
+        addLog("Write .agent-swarm/config.json", true);
+        // In dry-run, skip prereq/start/health — go straight to done
+        goToStep("done");
+        return;
+      }
+
+      // Write docker-compose.yml
+      const composePath = `${state.outputDir}/docker-compose.yml`;
+      await Bun.write(composePath, composeContent);
+      addLog(`Wrote ${composePath}`);
+
+      // Write .env
+      const envPath = `${state.outputDir}/.env`;
+      await Bun.write(envPath, envContent);
+      addLog(`Wrote ${envPath}`);
+
+      // Create .agent-swarm/ dir and write config.json
+      await Bun.$`mkdir -p ${state.outputDir}/.agent-swarm`;
+      const manifestPath = `${state.outputDir}/.agent-swarm/config.json`;
+      await Bun.write(manifestPath, JSON.stringify(manifest, null, 2));
+      addLog(`Wrote ${manifestPath}`);
+
+      // Add to .gitignore if in a git repo
+      try {
+        const result = await Bun.$`git -C ${state.outputDir} rev-parse --show-toplevel`.quiet();
+        if (result.exitCode === 0) {
+          const gitRoot = result.text().trim();
+          const gitignorePath = `${gitRoot}/.gitignore`;
+          const gitignoreFile = Bun.file(gitignorePath);
+
+          let content = "";
+          if (await gitignoreFile.exists()) {
+            content = await gitignoreFile.text();
+          }
+
+          const entriesToAdd: string[] = [];
+          if (!content.includes(".env")) {
+            entriesToAdd.push(".env");
+          }
+          if (!content.includes(".agent-swarm/")) {
+            entriesToAdd.push(".agent-swarm/");
+          }
+
+          if (entriesToAdd.length > 0) {
+            const block = `\n# Added by agent-swarm onboard\n${entriesToAdd.join("\n")}\n`;
+            await Bun.write(gitignorePath, content + block);
+            addLog(`Added to .gitignore: ${entriesToAdd.join(", ")}`);
+          }
+        }
+      } catch {
+        // Not a git repo — skip
+      }
+
+      setDone(true);
+    };
+
+    run().catch((err) => goToError(String(err)));
+  }, [state, dryRun, addLog, goToStep, goToError]);
+
+  useEffect(() => {
+    if (!done) return;
+    goToNext();
+  }, [done, goToNext]);
+
+  if (dryRun && composePreview != null && envPreview != null) {
+    return (
+      <Box flexDirection="column" padding={1}>
+        <Text bold color="yellow">
+          DRY-RUN — File previews:
+        </Text>
+
+        <Box marginTop={1} flexDirection="column">
+          <Text bold>docker-compose.yml (first 30 lines):</Text>
+          <Text dimColor>{composePreview}</Text>
+        </Box>
+
+        <Box marginTop={1} flexDirection="column">
+          <Text bold>.env (first 20 lines):</Text>
+          <Text dimColor>{envPreview}</Text>
+        </Box>
+      </Box>
+    );
+  }
+
+  return (
+    <Box flexDirection="column" padding={1}>
+      <Spinner label="Generating files..." />
+    </Box>
+  );
+}

package/src/commands/onboard/steps/harness-credentials.tsx

@@ -0,0 +1,195 @@
+import { Select, TextInput } from "@inkjs/ui";
+import { Box, Text } from "ink";
+import { useEffect, useState } from "react";
+import type { StepProps } from "../types.ts";
+
+type SubStep =
+  | "choose_method"
+  | "running_cli"
+  | "confirm_token"
+  | "manual_oauth"
+  | "manual_api_key";
+
+const TOKEN_REGEX = /sk-ant-oat[^\s]+/;
+
+export function HarnessCredentialsStep({ goToNext, addLog }: StepProps) {
+  const [subStep, setSubStep] = useState<SubStep>("choose_method");
+  const [cliOutput, setCliOutput] = useState("");
+  const [parsedToken, setParsedToken] = useState("");
+  const [cliError, setCliError] = useState("");
+
+  // Run CLI when entering running_cli
+  useEffect(() => {
+    if (subStep !== "running_cli") return;
+
+    let cancelled = false;
+
+    (async () => {
+      try {
+        const result = await Bun.$`claude setup-token`.quiet();
+        if (cancelled) return;
+
+        const output = result.text().trim();
+        setCliOutput(output);
+
+        if (result.exitCode !== 0) {
+          addLog("claude setup-token exited with a non-zero code");
+          setCliError("Command exited with a non-zero code. Is Claude CLI installed?");
+          setSubStep("manual_oauth");
+          return;
+        }
+
+        const match = output.match(TOKEN_REGEX);
+        if (match) {
+          addLog("Token detected from claude setup-token output");
+          setParsedToken(match[0]);
+          setSubStep("confirm_token");
+        } else {
+          addLog("claude setup-token completed but no token found in output");
+          setSubStep("manual_oauth");
+        }
+      } catch (err) {
+        if (cancelled) return;
+        const msg = err instanceof Error ? err.message : String(err);
+        addLog(`Failed to run claude setup-token: ${msg}`);
+        setCliError(msg);
+        setSubStep("manual_oauth");
+      }
+    })();
+
+    return () => {
+      cancelled = true;
+    };
+  }, [subStep, addLog]);
+
+  if (subStep === "choose_method") {
+    return (
+      <Box flexDirection="column" padding={1}>
+        <Text bold>How would you like to provide credentials?</Text>
+        <Box marginTop={1}>
+          <Select
+            options={[
+              {
+                label: "Run `claude setup-token` (recommended)",
+                value: "setup_token",
+              },
+              { label: "Paste OAuth token manually", value: "manual_oauth" },
+              { label: "Provide ANTHROPIC_API_KEY", value: "manual_api_key" },
+            ]}
+            onChange={(value) => {
+              if (value === "setup_token") {
+                setSubStep("running_cli");
+              } else if (value === "manual_oauth") {
+                setSubStep("manual_oauth");
+              } else if (value === "manual_api_key") {
+                setSubStep("manual_api_key");
+              }
+            }}
+          />
+        </Box>
+      </Box>
+    );
+  }
+
+  if (subStep === "running_cli") {
+    return (
+      <Box flexDirection="column" padding={1}>
+        <Text>
+          Running <Text color="cyan">claude setup-token</Text>...
+        </Text>
+        <Text dimColor>This may take a moment.</Text>
+      </Box>
+    );
+  }
+
+  if (subStep === "confirm_token") {
+    const masked = `${parsedToken.slice(0, 14)}...${parsedToken.slice(-4)}`;
+    return (
+      <Box flexDirection="column" padding={1}>
+        <Text bold>Token detected from CLI output:</Text>
+        <Text color="green">{masked}</Text>
+        {cliOutput ? (
+          <Box marginTop={1}>
+            <Text dimColor>CLI output: {cliOutput.slice(0, 200)}</Text>
+          </Box>
+        ) : null}
+        <Box marginTop={1}>
+          <Select
+            options={[
+              { label: "Use this token", value: "use" },
+              { label: "Paste manually instead", value: "manual" },
+            ]}
+            onChange={(value) => {
+              if (value === "use") {
+                addLog("Claude OAuth token collected via CLI");
+                goToNext({
+                  claudeOAuthToken: parsedToken,
+                  anthropicApiKey: "",
+                  credentialType: "oauth",
+                });
+              } else {
+                setSubStep("manual_oauth");
+              }
+            }}
+          />
+        </Box>
+      </Box>
+    );
+  }
+
+  if (subStep === "manual_oauth") {
+    return (
+      <Box flexDirection="column" padding={1}>
+        {cliError ? (
+          <Box marginBottom={1} flexDirection="column">
+            <Text color="red">Could not run claude setup-token: {cliError}</Text>
+            <Text dimColor>Falling back to manual token entry.</Text>
+          </Box>
+        ) : null}
+        <Text bold>Paste your CLAUDE_CODE_OAUTH_TOKEN:</Text>
+        <TextInput
+          placeholder="sk-ant-oat..."
+          onSubmit={(value) => {
+            const trimmed = value.trim();
+            if (!trimmed) {
+              addLog("Token cannot be empty.");
+              return;
+            }
+            addLog("Claude OAuth token collected");
+            goToNext({
+              claudeOAuthToken: trimmed,
+              anthropicApiKey: "",
+              credentialType: "oauth",
+            });
+          }}
+        />
+      </Box>
+    );
+  }
+
+  if (subStep === "manual_api_key") {
+    return (
+      <Box flexDirection="column" padding={1}>
+        <Text bold>Paste your ANTHROPIC_API_KEY:</Text>
+        <TextInput
+          placeholder="sk-ant-api..."
+          onSubmit={(value) => {
+            const trimmed = value.trim();
+            if (!trimmed) {
+              addLog("API key cannot be empty.");
+              return;
+            }
+            addLog("Anthropic API key collected");
+            goToNext({
+              claudeOAuthToken: "",
+              anthropicApiKey: trimmed,
+              credentialType: "api_key",
+            });
+          }}
+        />
+      </Box>
+    );
+  }
+
+  return null;
+}

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

@@ -0,0 +1,21 @@
+import { Select } from "@inkjs/ui";
+import { Box, Text } from "ink";
+import type { StepProps } from "../types.ts";
+
+export function HarnessStep({ goToNext, addLog }: StepProps) {
+  return (
+    <Box flexDirection="column" padding={1}>
+      <Text bold>Which harness should run your agents?</Text>
+      <Box marginTop={1}>
+        <Select
+          options={[{ label: "Claude Code (Recommended)", value: "claude" }]}
+          onChange={() => {
+            addLog("Harness: Claude Code");
+            goToNext({ harness: "claude" });
+          }}
+        />
+      </Box>
+      <Text dimColor>Pi-mono — Coming soon</Text>
+    </Box>
+  );
+}