@desplega.ai/agent-swarm 1.173.0 → 2.1.0

package/src/artifact-sdk/index.ts

@@ -1,2 +0,0 @@
-export type { ArtifactServer, ArtifactServerOptions } from "./server";
-export { createArtifactServer } from "./server";

package/src/artifact-sdk/localtunnel.d.ts

@@ -1,20 +0,0 @@
-declare module "@desplega.ai/localtunnel" {
-  interface TunnelOptions {
-    port: number;
-    subdomain?: string;
-    host?: string;
-    auth?: string;
-    username?: string;
-    local_host?: string;
-  }
-
-  interface Tunnel {
-    url: string;
-    close(): void;
-    on(event: "close", listener: () => void): void;
-    on(event: "error", listener: (err: Error) => void): void;
-  }
-
-  function localtunnel(opts: TunnelOptions): Promise<Tunnel>;
-  export default localtunnel;
-}

package/src/artifact-sdk/port.ts

@@ -1,12 +0,0 @@
-import { createServer } from "node:net";
-
-export async function getAvailablePort(): Promise<number> {
-  return new Promise((resolve, reject) => {
-    const server = createServer();
-    server.listen(0, () => {
-      const { port } = server.address() as { port: number };
-      server.close(() => resolve(port));
-    });
-    server.on("error", reject);
-  });
-}

package/src/artifact-sdk/server.ts

@@ -1,183 +0,0 @@
-import { Hono } from "hono";
-import { serveStatic } from "hono/bun";
-import { getApiKey } from "../utils/api-key";
-import { getMcpBaseUrl } from "../utils/constants";
-import { BROWSER_SDK_JS } from "./browser-sdk";
-import { getAvailablePort } from "./port";
-import { createTunnel } from "./tunnel";
-
-export interface ArtifactServerOptions {
-  name: string;
-  static?: string;
-  app?: Hono;
-  port?: number;
-  auth?: boolean;
-  subdomain?: string;
-}
-
-export interface ArtifactServer {
-  start(): Promise<void>;
-  stop(): Promise<void>;
-  url: string;
-  port: number;
-  tunnel: ReturnType<typeof createTunnel> extends Promise<infer T> ? T | null : never;
-}
-
-const NativeResponse = globalThis.Response;
-
-type NativeResponseArgs = ConstructorParameters<typeof Response>;
-
-export function createBunResponse(
-  body?: NativeResponseArgs[0],
-  init?: NativeResponseArgs[1],
-): Response {
-  return new NativeResponse(body, init);
-}
-
-export function createBunHonoFetchHandler(app: Hono): (req: Request) => Promise<Response> {
-  return async (req: Request) => {
-    const response = await app.fetch(req);
-    return createBunResponse(response.body, {
-      status: response.status,
-      statusText: response.statusText,
-      headers: response.headers,
-    });
-  };
-}
-
-export function createArtifactServer(opts: ArtifactServerOptions): ArtifactServer {
-  const agentId = process.env.AGENT_ID || "unknown";
-  const apiKey = getApiKey();
-  const mcpBaseUrl = getMcpBaseUrl();
-
-  const app = new Hono();
-
-  // Inject swarm middleware
-  app.get("/@swarm/sdk.js", (c) => {
-    c.header("Content-Type", "application/javascript");
-    return c.body(BROWSER_SDK_JS);
-  });
-
-  app.get("/@swarm/config", (c) => {
-    return c.json({ agentId, artifactName: opts.name });
-  });
-
-  // API proxy — forwards /@swarm/api/* to MCP server
-  app.all("/@swarm/api/*", async (c) => {
-    const path = c.req.path.replace("/@swarm/api", "/api");
-    const targetUrl = `${mcpBaseUrl}${path}`;
-    const headers: Record<string, string> = {
-      Authorization: `Bearer ${apiKey}`,
-      "X-Agent-ID": agentId,
-    };
-    if (c.req.method !== "GET") {
-      headers["Content-Type"] = "application/json";
-    }
-    try {
-      const res = await fetch(targetUrl, {
-        method: c.req.method,
-        headers,
-        body: c.req.method !== "GET" ? await c.req.text() : undefined,
-      });
-      return new Response(res.body, {
-        status: res.status,
-        headers: {
-          "Access-Control-Allow-Origin": "*",
-          "Access-Control-Allow-Methods": "GET, POST, PUT, DELETE, OPTIONS",
-          "Access-Control-Allow-Headers": "Content-Type",
-        },
-      });
-    } catch (e) {
-      return c.json({ error: "Proxy error", message: String(e) }, 502);
-    }
-  });
-
-  // CORS preflight
-  app.options("/@swarm/api/*", (_c) => {
-    return new Response(null, {
-      status: 204,
-      headers: {
-        "Access-Control-Allow-Origin": "*",
-        "Access-Control-Allow-Methods": "GET, POST, PUT, DELETE, OPTIONS",
-        "Access-Control-Allow-Headers": "Content-Type",
-      },
-    });
-  });
-
-  // User app or static serving
-  if (opts.app) {
-    app.route("/", opts.app);
-  } else if (opts.static) {
-    app.use("/*", serveStatic({ root: opts.static }));
-  }
-
-  let server: ReturnType<typeof Bun.serve> | null = null;
-  // biome-ignore lint/suspicious/noExplicitAny: localtunnel tunnel type
-  let tunnel: any = null;
-  let actualPort = 0;
-
-  const artifact: ArtifactServer = {
-    url: "",
-    port: 0,
-    tunnel: null,
-
-    async start() {
-      actualPort = opts.port || (await getAvailablePort());
-      server = Bun.serve({ port: actualPort, fetch: createBunHonoFetchHandler(app) });
-      artifact.port = actualPort;
-
-      const subdomain = opts.subdomain || `${agentId}-${opts.name}`;
-      const authPassword = opts.auth === false ? undefined : apiKey;
-
-      tunnel = await createTunnel({
-        port: actualPort,
-        subdomain,
-        auth: authPassword,
-      });
-
-      artifact.url = tunnel.url;
-      artifact.tunnel = tunnel;
-
-      // Register in service registry
-      try {
-        await fetch(`${mcpBaseUrl}/api/services`, {
-          method: "POST",
-          headers: {
-            Authorization: `Bearer ${apiKey}`,
-            "X-Agent-ID": agentId,
-            "Content-Type": "application/json",
-          },
-          body: JSON.stringify({
-            script: `artifact-${opts.name}`,
-            metadata: {
-              type: "artifact",
-              artifactName: opts.name,
-              port: actualPort,
-              publicUrl: tunnel.url,
-            },
-          }),
-        });
-      } catch (e) {
-        console.warn("Failed to register artifact in service registry:", e);
-      }
-
-      console.log(`Artifact "${opts.name}" live at ${tunnel.url} (port ${actualPort})`);
-    },
-
-    async stop() {
-      if (tunnel) {
-        tunnel.close();
-        tunnel = null;
-      }
-      if (server) {
-        // Bun >= 1.4 makes stop() wait for in-flight requests and idle
-        // keep-alive connections. Callers stop on SIGINT/SIGTERM and then
-        // exit, so close active connections instead of waiting on a hung client.
-        await server.stop(true);
-        server = null;
-      }
-    },
-  };
-
-  return artifact;
-}

package/src/artifact-sdk/tunnel.ts

@@ -1,19 +0,0 @@
-import localtunnel from "@desplega.ai/localtunnel";
-
-interface TunnelOptions {
-  port: number;
-  subdomain: string;
-  auth?: string;
-  username?: string;
-}
-
-export async function createTunnel(opts: TunnelOptions) {
-  const tunnel = await localtunnel({
-    port: opts.port,
-    subdomain: opts.subdomain,
-    auth: opts.auth,
-    username: opts.username || "hi", // default "hi" for MVP (custom username deferred)
-    // host defaults to lt.desplega.ai in our fork
-  });
-  return tunnel;
-}

package/src/commands/artifact.ts

@@ -1,249 +0,0 @@
-import { Hono } from "hono";
-import { createArtifactServer } from "../artifact-sdk";
-import { getApiKey } from "../utils/api-key";
-import { getMcpBaseUrl } from "../utils/constants";
-
-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 = getApiKey();
-  const mcpBaseUrl = getMcpBaseUrl();
-  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 body = (await res.json()) as {
-      services?: Array<{
-        name: string;
-        agentId: string;
-        status: string;
-        metadata?: { type?: string; artifactName?: string; port?: number; publicUrl?: string };
-      }>;
-    };
-    const services = body.services ?? [];
-
-    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 = getApiKey();
-  const mcpBaseUrl = getMcpBaseUrl();
-  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 body = (await res.json()) as {
-        services?: Array<{
-          id: string;
-          name: string;
-          metadata?: { type?: string; artifactName?: string };
-        }>;
-      };
-      const services = body.services ?? [];
-      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/http/ecosystem.ts

@@ -1,77 +0,0 @@
-import type { IncomingMessage, ServerResponse } from "node:http";
-import { z } from "zod";
-import { getServicesByAgentId } from "../be/db";
-import { route } from "./route-def";
-import { jsonError } from "./utils";
-
-// ─── Route Definitions ───────────────────────────────────────────────────────
-
-const EcosystemAppSchema = z.object({
-  name: z.string(),
-  script: z.string(),
-  cwd: z.string().optional(),
-  interpreter: z.string().optional(),
-  args: z.array(z.string()).optional(),
-  env: z.record(z.string(), z.string()).optional(),
-});
-
-type EcosystemApp = z.infer<typeof EcosystemAppSchema>;
-
-const getEcosystem = route({
-  method: "get",
-  path: "/ecosystem",
-  pattern: ["ecosystem"],
-  summary: "Get PM2 ecosystem config for agent services",
-  tags: ["Ecosystem"],
-  auth: { apiKey: true, agentId: true },
-  responses: {
-    200: {
-      description: "PM2 ecosystem config",
-      schema: z.object({ apps: z.array(EcosystemAppSchema) }),
-    },
-    400: { description: "Missing X-Agent-ID" },
-  },
-});
-
-// ─── Handler ─────────────────────────────────────────────────────────────────
-
-export async function handleEcosystem(
-  req: IncomingMessage,
-  res: ServerResponse,
-  pathSegments: string[],
-  myAgentId: string | undefined,
-): Promise<boolean> {
-  if (getEcosystem.match(req.method, pathSegments)) {
-    if (!myAgentId) {
-      jsonError(res, "Missing X-Agent-ID header", 400);
-      return true;
-    }
-
-    const services = await getServicesByAgentId(myAgentId);
-
-    // Generate PM2 ecosystem format
-    const ecosystem = {
-      apps: services
-        .filter((s) => s.script) // Only include services with script path
-        .map((s) => {
-          const app: EcosystemApp = {
-            name: s.name,
-            script: s.script,
-          };
-
-          if (s.cwd) app.cwd = s.cwd;
-          if (s.interpreter) app.interpreter = s.interpreter;
-          if (s.args && s.args.length > 0) app.args = s.args;
-          if (s.env && Object.keys(s.env).length > 0) app.env = s.env;
-          if (s.port) app.env = { ...(app.env || {}), PORT: String(s.port) };
-
-          return app;
-        }),
-    };
-
-    getEcosystem.respond(res, 200, ecosystem);
-    return true;
-  }
-
-  return false;
-}

package/src/tests/artifact-commands.test.ts

@@ -1,92 +0,0 @@
-/**
- * Regression test for the `/api/services` response-shape bug in
- * `src/commands/artifact.ts` (artifactList / artifactStop).
- *
- * The endpoint returns `{ services: [...] }`, but earlier the code
- * cast the JSON as a bare `Array<...>` and crashed with
- * `services.filter is not a function`.
- */
-
-import { afterAll, afterEach, beforeAll, describe, expect, mock, test } from "bun:test";
-import { runArtifact } from "../commands/artifact";
-
-const originalFetch = globalThis.fetch;
-const originalLog = console.log;
-const originalError = console.error;
-
-let capturedOut: string[] = [];
-let capturedErr: string[] = [];
-
-beforeAll(() => {
-  console.log = (...args: unknown[]) => {
-    capturedOut.push(args.map(String).join(" "));
-  };
-  console.error = (...args: unknown[]) => {
-    capturedErr.push(args.map(String).join(" "));
-  };
-});
-
-afterEach(() => {
-  globalThis.fetch = originalFetch;
-  capturedOut = [];
-  capturedErr = [];
-});
-
-afterAll(() => {
-  globalThis.fetch = originalFetch;
-  console.log = originalLog;
-  console.error = originalError;
-});
-
-function jsonResponse(body: unknown, status = 200): Response {
-  return new Response(JSON.stringify(body), {
-    status,
-    headers: { "Content-Type": "application/json" },
-  });
-}
-
-describe("runArtifact('list')", () => {
-  test("handles wrapped { services: [] } without throwing", async () => {
-    globalThis.fetch = mock(() => Promise.resolve(jsonResponse({ services: [] })));
-
-    await expect(runArtifact("list", { additionalArgs: [] })).resolves.toBeUndefined();
-    expect(capturedOut.join("\n")).toContain("No active artifacts");
-    expect(capturedErr.join("\n")).not.toContain("services.filter");
-  });
-
-  test("renders artifact rows from { services: [...] }", async () => {
-    globalThis.fetch = mock(() =>
-      Promise.resolve(
-        jsonResponse({
-          services: [
-            {
-              name: "artifact-testart",
-              agentId: "agent-xyz",
-              status: "healthy",
-              metadata: {
-                type: "artifact",
-                artifactName: "testart",
-                port: 4242,
-                publicUrl: "https://testart.loca.lt",
-              },
-            },
-          ],
-        }),
-      ),
-    );
-
-    await expect(runArtifact("list", { additionalArgs: [] })).resolves.toBeUndefined();
-    const out = capturedOut.join("\n");
-    expect(out).toContain("testart");
-    expect(out).toContain("4242");
-    expect(out).toContain("https://testart.loca.lt");
-    expect(out).toContain("healthy");
-  });
-
-  test("falls back to [] when response omits services key", async () => {
-    globalThis.fetch = mock(() => Promise.resolve(jsonResponse({})));
-
-    await expect(runArtifact("list", { additionalArgs: [] })).resolves.toBeUndefined();
-    expect(capturedOut.join("\n")).toContain("No active artifacts");
-  });
-});