@desplega.ai/agent-swarm 1.80.0 → 1.80.2

package/src/commands/setup.tsx

@@ -2,6 +2,7 @@
 import { Spinner, TextInput } from "@inkjs/ui";
 import { Box, Text, useApp } from "ink";
 import { useCallback, useEffect, useRef, useState } from "react";
+import { getApiKey } from "../utils/api-key.ts";
 import {
   createDefaultMcpJson,
   createDefaultSettingsLocal,
@@ -47,7 +48,7 @@ export function Setup({ dryRun = false, restore = false, yes = false }: SetupPro
   const { exit } = useApp();
   const [state, setState] = useState<SetupState>({
     step: restore ? "restoring" : "check_dirs",
-    token: yes ? process.env.API_KEY || "" : "",
+    token: yes ? getApiKey() : "",
     agentId: yes ? process.env.AGENT_ID || "" : "",
     existingToken: "",
     existingAgentId: "",
@@ -258,14 +259,15 @@ export function Setup({ dryRun = false, restore = false, yes = false }: SetupPro
 
       // In non-interactive mode (yes=true), skip prompts and go directly to updating
       if (yes) {
-        const token = process.env.API_KEY;
+        const token = getApiKey();
         const agentId = process.env.AGENT_ID;
 
         if (!token) {
           setState((s) => ({
             ...s,
             step: "error",
-            error: "API_KEY environment variable is required in non-interactive mode (-y/--yes)",
+            error:
+              "AGENT_SWARM_API_KEY (or legacy API_KEY) environment variable is required in non-interactive mode (-y/--yes)",
           }));
           return;
         }

package/src/hooks/hook.ts

@@ -10,6 +10,7 @@ import {
   type RetrievalRow,
 } from "../be/memory/raters/llm";
 import type { Agent } from "../types";
+import { getApiKey } from "../utils/api-key";
 import { summarizeSession as runSummarize } from "../utils/internal-ai";
 import { checkToolLoop, clearToolHistory } from "./tool-loop-detection";
 
@@ -150,7 +151,7 @@ async function fetchTaskDetails(
   taskId: string,
 ): Promise<{ id: string; task: string; progress?: string } | null> {
   const apiUrl = process.env.MCP_BASE_URL || `http://localhost:${process.env.PORT || "3013"}`;
-  const apiKey = process.env.API_KEY || "";
+  const apiKey = getApiKey();
   const headers: Record<string, string> = {};
   if (apiKey) headers.Authorization = `Bearer ${apiKey}`;
 
@@ -301,7 +302,7 @@ export async function runStopHookSessionSummary(
     const { taskContext, taskId } = await resolveStopHookTaskContext(env);
 
     const apiUrl = env.MCP_BASE_URL || `http://localhost:${env.PORT || "3013"}`;
-    const apiKey = env.API_KEY || "";
+    const apiKey = getApiKey(env);
 
     // Memory-rater v1.5 step-4: piggyback per-memory ratings on the
     // existing summary call when MEMORY_RATERS includes `llm`.
@@ -1152,7 +1153,7 @@ ${hasAgentIdHeader() ? `You have a pre-defined agent ID via header: ${mcpConfig?
           try {
             const apiUrl =
               process.env.MCP_BASE_URL || `http://localhost:${process.env.PORT || "3013"}`;
-            const apiKey = process.env.API_KEY || "";
+            const apiKey = getApiKey();
             const fileContent = await Bun.file(editedPath).text();
             const isShared = editedPath.startsWith("/workspace/shared/");
             const fileName = editedPath.split("/").pop() ?? "unnamed";

package/src/http/index.ts

@@ -14,9 +14,10 @@ import { initGitLab } from "../gitlab";
 import { stopHeartbeat } from "../heartbeat";
 import { initJira } from "../jira";
 import { initLinear } from "../linear";
-import { initOtel, startSpan, withRemoteContext } from "../otel";
+import { initOtel, isPollTracingEnabled, startSpan, withRemoteContext } from "../otel";
 import { startSlackApp, stopSlackApp } from "../slack";
 import { initTelemetry, telemetry } from "../telemetry";
+import { getApiKey } from "../utils/api-key";
 import { initWorkflows } from "../workflows";
 import { handleActiveSessions } from "./active-sessions";
 import { handleAgentRegister, handleAgentsRest } from "./agents";
@@ -45,6 +46,7 @@ import { handlePricing } from "./pricing";
 import { handlePromptTemplates } from "./prompt-templates";
 import { handleRepos } from "./repos";
 import { handleSchedules } from "./schedules";
+import { handleScripts } from "./scripts";
 import { handleSessionData } from "./session-data";
 import { handleSessions } from "./sessions";
 import { handleSkills } from "./skills";
@@ -69,7 +71,7 @@ process.on("unhandledRejection", (reason) => {
 });
 
 const port = parseInt(process.env.PORT || process.argv[2] || "3013", 10);
-const apiKey = process.env.API_KEY || "";
+const apiKey = getApiKey();
 
 // Use globalThis to persist state across hot reloads
 const globalState = globalThis as typeof globalThis & {
@@ -116,33 +118,39 @@ const httpServer = createHttpServer(async (req, res) => {
   });
 
   await withRemoteContext(req.headers as Record<string, unknown>, async () => {
-    const span = startSpan("http.server", {
-      "http.request.method": req.method ?? "",
-      "url.path": req.url?.split("?")[0] ?? "",
-      "agent.id": req.headers["x-agent-id"] as string | undefined,
-      "agentswarm.component": "api",
-    });
-
-    res.on("finish", () => {
-      if (spanEnded) return;
-      spanEnded = true;
-      span.setAttributes({
-        "http.response.status_code": statusCode,
-        "agentswarm.http.duration_ms": Math.round((performance.now() - startTime) * 10) / 10,
+    const reqPath = req.url?.split("?")[0] ?? "";
+    const skipSpan = reqPath === "/api/poll" && !isPollTracingEnabled();
+    const span = skipSpan
+      ? null
+      : startSpan("http.server", {
+          "http.request.method": req.method ?? "",
+          "url.path": reqPath,
+          "agent.id": req.headers["x-agent-id"] as string | undefined,
+          "agentswarm.component": "api",
+        });
+
+    if (span) {
+      res.on("finish", () => {
+        if (spanEnded) return;
+        spanEnded = true;
+        span.setAttributes({
+          "http.response.status_code": statusCode,
+          "agentswarm.http.duration_ms": Math.round((performance.now() - startTime) * 10) / 10,
+        });
+        if (statusCode >= 500) {
+          span.setStatus({ code: 2, message: `HTTP ${statusCode}` });
+        }
+        span.end();
       });
-      if (statusCode >= 500) {
-        span.setStatus({ code: 2, message: `HTTP ${statusCode}` });
-      }
-      span.end();
-    });
 
-    res.on("error", (err) => {
-      if (spanEnded) return;
-      spanEnded = true;
-      span.recordException(err);
-      span.setStatus({ code: 2, message: err.message });
-      span.end();
-    });
+      res.on("error", (err) => {
+        if (spanEnded) return;
+        spanEnded = true;
+        span.recordException(err);
+        span.setStatus({ code: 2, message: err.message });
+        span.end();
+      });
+    }
 
     setCorsHeaders(req, res);
 
@@ -180,6 +188,7 @@ const httpServer = createHttpServer(async (req, res) => {
       () => handleDbQuery(req, res, pathSegments, queryParams),
       () => handleRepos(req, res, pathSegments, queryParams),
       () => handleSkills(req, res, pathSegments, queryParams, myAgentId),
+      () => handleScripts(req, res, pathSegments, queryParams, myAgentId),
       () => handleMcpServers(req, res, pathSegments, queryParams),
       () => handleMcpOAuth(req, res, pathSegments, queryParams),
       () => handleMemory(req, res, pathSegments, myAgentId),
@@ -205,8 +214,10 @@ const httpServer = createHttpServer(async (req, res) => {
       res.writeHead(404);
       res.end("Not Found");
     } catch (err) {
-      span.recordException(err);
-      span.setStatus({ code: 2, message: err instanceof Error ? err.message : String(err) });
+      if (span) {
+        span.recordException(err);
+        span.setStatus({ code: 2, message: err instanceof Error ? err.message : String(err) });
+      }
       const message = err instanceof Error ? err.message : String(err);
       console.error(`[HTTP] ❌ ${req.method} ${req.url} → ${message}`);
       if (!res.headersSent) {

package/src/http/memory.ts

@@ -124,6 +124,20 @@ const deleteMemoryById = route({
   },
 });
 
+const getMemoryById = route({
+  method: "get",
+  path: "/api/memory/{id}",
+  pattern: ["api", "memory", null],
+  summary: "Get a single memory by ID",
+  tags: ["Memory"],
+  auth: { apiKey: true, agentId: true },
+  params: z.object({ id: z.string().uuid() }),
+  responses: {
+    200: { description: "Memory details" },
+    404: { description: "Memory not found" },
+  },
+});
+
 // Memory rater v1.5 — worker-facing rating endpoints. Plan:
 // thoughts/taras/plans/2026-05-05-memory-rater-v1.5/step-3.md
 //
@@ -618,5 +632,19 @@ export async function handleMemory(
     return true;
   }
 
+  if (getMemoryById.match(req.method, pathSegments)) {
+    const parsed = await getMemoryById.parse(req, res, pathSegments, new URLSearchParams());
+    if (!parsed) return true;
+
+    const memory = getMemoryStore().get(parsed.params.id);
+    if (!memory) {
+      jsonError(res, "Memory not found", 404);
+      return true;
+    }
+
+    json(res, { memory });
+    return true;
+  }
+
   return false;
 }

package/src/http/openapi.ts

@@ -64,6 +64,7 @@ export function generateOpenApiSpec(opts: OpenApiOptions): string {
     registry.registerPath({
       method: routeDef.method,
       path: routeDef.path,
+      operationId: routeDef.operationId,
       summary: routeDef.summary,
       description: routeDef.description,
       tags: routeDef.tags,

package/src/http/page-proxy.ts

@@ -1,5 +1,6 @@
 import type { IncomingMessage, ServerResponse } from "node:http";
 import { getPage } from "../be/db";
+import { getApiKey } from "../utils/api-key";
 import { extractAndVerifyCookie } from "../utils/page-session";
 import { route } from "./route-def";
 import { jsonError } from "./utils";
@@ -147,7 +148,7 @@ export async function handlePageProxy(req: IncomingMessage, res: ServerResponse)
   const baseUrl = `http://127.0.0.1:${port}`;
   const targetUrl = `${baseUrl}${rewrittenPath}${queryPart}`;
 
-  const apiKey = process.env.API_KEY ?? "";
+  const apiKey = getApiKey();
   // `X-Page-Id` is the trust anchor for page-scoped KV: only the page-proxy
   // ever sets it (any external `X-Page-Id` header is dropped because we don't
   // forward the original headers). The KV handler treats this as the highest-

package/src/http/route-def.ts

@@ -20,6 +20,7 @@ export interface RouteDef<
   path: string; // OpenAPI-style: "/api/tasks/{id}"
   pattern: readonly (string | null)[]; // matchRoute-style: ["api", "tasks", null]
   exact?: boolean; // default true
+  operationId?: string;
   summary: string;
   description?: string;
   tags: string[];

package/src/http/schedules.ts

@@ -8,6 +8,7 @@ import {
   getDb,
   getScheduledTaskById,
   getScheduledTaskByName,
+  getScheduledTasks,
   updateScheduledTask,
 } from "../be/db";
 import { calculateNextRun } from "../scheduler/scheduler";
@@ -64,6 +65,29 @@ const runScheduleNow = route({
   },
 });
 
+const listSchedules = route({
+  method: "get",
+  path: "/api/schedules",
+  pattern: ["api", "schedules"],
+  summary: "List schedules",
+  tags: ["Schedules"],
+  query: z.object({
+    enabled: z
+      .enum(["true", "false"])
+      .optional()
+      .transform((v) => (v === undefined ? undefined : v === "true")),
+    name: z.string().optional(),
+    scheduleType: z.enum(["recurring", "one_time"]).optional(),
+    hideCompleted: z
+      .enum(["true", "false"])
+      .optional()
+      .transform((v) => (v === undefined ? undefined : v === "true")),
+  }),
+  responses: {
+    200: { description: "List of schedules" },
+  },
+});
+
 const getSchedule = route({
   method: "get",
   path: "/api/schedules/{id}",
@@ -129,6 +153,19 @@ export async function handleSchedules(
   queryParams: URLSearchParams,
   _myAgentId: string | undefined,
 ): Promise<boolean> {
+  if (listSchedules.match(req.method, pathSegments)) {
+    const parsed = await listSchedules.parse(req, res, pathSegments, queryParams);
+    if (!parsed) return true;
+    const schedules = getScheduledTasks({
+      enabled: parsed.query.enabled,
+      name: parsed.query.name,
+      scheduleType: parsed.query.scheduleType,
+      hideCompleted: parsed.query.hideCompleted,
+    });
+    json(res, { schedules, count: schedules.length });
+    return true;
+  }
+
   if (createSchedule.match(req.method, pathSegments)) {
     const parsed = await createSchedule.parse(req, res, pathSegments, queryParams);
     if (!parsed) return true;