@desplega.ai/agent-swarm 1.92.0 → 1.92.2

package/src/http/mcp.ts

@@ -4,10 +4,62 @@ import { StreamableHTTPServerTransport } from "@modelcontextprotocol/sdk/server/
 import { isInitializeRequest } from "@modelcontextprotocol/sdk/types.js";
 import { createServer } from "@/server";
 
+export type McpTransportActivity = Record<string, number>;
+
+export const DEFAULT_MCP_TRANSPORT_IDLE_TIMEOUT_MS = 2 * 60 * 60 * 1000;
+
+export function markMcpTransportActivity(
+  sessionActivity: McpTransportActivity,
+  sessionId: string | undefined,
+  now = Date.now(),
+): void {
+  if (sessionId) {
+    sessionActivity[sessionId] = now;
+  }
+}
+
+export function closeIdleMcpTransports(
+  transports: Record<string, StreamableHTTPServerTransport>,
+  sessionActivity: McpTransportActivity,
+  options: {
+    now?: number;
+    idleTimeoutMs?: number;
+    label?: string;
+    onClose?: (id: string) => void;
+  } = {},
+): number {
+  const now = options.now ?? Date.now();
+  const idleTimeoutMs = options.idleTimeoutMs ?? DEFAULT_MCP_TRANSPORT_IDLE_TIMEOUT_MS;
+  let closed = 0;
+
+  for (const [id, transport] of Object.entries(transports)) {
+    const lastActivity = sessionActivity[id];
+    if (lastActivity === undefined) {
+      sessionActivity[id] = now;
+      continue;
+    }
+    if (now - lastActivity < idleTimeoutMs) continue;
+
+    try {
+      transport.close();
+    } catch (err) {
+      console.warn(`[HTTP] Failed to close idle ${options.label ?? "MCP"} transport ${id}: ${err}`);
+    } finally {
+      delete transports[id];
+      delete sessionActivity[id];
+      options.onClose?.(id);
+      closed++;
+    }
+  }
+
+  return closed;
+}
+
 export async function handleMcp(
   req: IncomingMessage,
   res: ServerResponse,
   transports: Record<string, StreamableHTTPServerTransport>,
+  sessionActivity: McpTransportActivity = {},
 ): Promise<boolean> {
   const sessionId = req.headers["mcp-session-id"] as string | undefined;
 
@@ -26,20 +78,24 @@ export async function handleMcp(
 
     if (sessionId && transports[sessionId]) {
       transport = transports[sessionId];
+      markMcpTransportActivity(sessionActivity, sessionId);
     } else if (!sessionId && isInitializeRequest(body)) {
       transport = new StreamableHTTPServerTransport({
         sessionIdGenerator: () => randomUUID(),
         onsessioninitialized: (id) => {
           transports[id] = transport;
+          markMcpTransportActivity(sessionActivity, id);
         },
         onsessionclosed: (id) => {
           delete transports[id];
+          delete sessionActivity[id];
         },
       });
 
       transport.onclose = () => {
         if (transport.sessionId) {
           delete transports[transport.sessionId];
+          delete sessionActivity[transport.sessionId];
         }
       };
 
@@ -58,11 +114,13 @@ export async function handleMcp(
     }
 
     await transport.handleRequest(req, res, body);
+    markMcpTransportActivity(sessionActivity, transport.sessionId);
     return true;
   }
 
   if (req.method === "GET" || req.method === "DELETE") {
     if (sessionId && transports[sessionId]) {
+      markMcpTransportActivity(sessionActivity, sessionId);
       await transports[sessionId].handleRequest(req, res);
       return true;
     }

package/src/http/memory.ts

@@ -115,6 +115,18 @@ const listMemory = route({
   },
 });
 
+const memoryHealth = route({
+  method: "get",
+  path: "/api/memory/health",
+  pattern: ["api", "memory", "health"],
+  summary: "Report memory vector index health and retrieval mode",
+  tags: ["Memory"],
+  auth: { apiKey: true },
+  responses: {
+    200: { description: "Memory vector index health" },
+  },
+});
+
 const deleteMemoryById = route({
   method: "delete",
   path: "/api/memory/{id}",
@@ -375,6 +387,8 @@ export async function handleMemory(
           name: r.name,
           content: r.content,
           similarity: r.similarity,
+          rawSimilarity: r.rawSimilarity,
+          compositeScore: r.compositeScore,
           source: r.source,
           scope: r.scope,
         })),
@@ -430,6 +444,8 @@ export async function handleMemory(
             scope: r.scope,
             source: r.source,
             similarity: r.similarity,
+            rawSimilarity: r.rawSimilarity,
+            compositeScore: r.compositeScore,
             createdAt: r.createdAt,
             accessedAt: r.accessedAt,
             accessCount: r.accessCount ?? 0,
@@ -498,6 +514,14 @@ export async function handleMemory(
     return true;
   }
 
+  if (memoryHealth.match(req.method, pathSegments)) {
+    const parsed = await memoryHealth.parse(req, res, pathSegments, new URLSearchParams());
+    if (!parsed) return true;
+
+    json(res, getMemoryStore().getHealth());
+    return true;
+  }
+
   if (deleteMemoryById.match(req.method, pathSegments)) {
     const parsed = await deleteMemoryById.parse(req, res, pathSegments, new URLSearchParams());
     if (!parsed) return true;
@@ -663,3 +687,41 @@ export async function handleMemory(
 
   return false;
 }
+
+// ─── Expired Memory GC ──────────────────────────────────────────────────────
+
+const MEMORY_GC_INTERVAL_MS = 60 * 60 * 1000; // 1 hour
+let memoryGcTimer: ReturnType<typeof setInterval> | null = null;
+
+export function startMemoryGc(intervalMs = MEMORY_GC_INTERVAL_MS): void {
+  if (memoryGcTimer) return;
+
+  // Run immediately on startup to clear any backlog
+  try {
+    const purged = getMemoryStore().purgeExpired();
+    if (purged > 0) {
+      console.log(`[memory-gc] Initial purge removed ${purged} expired memory row(s)`);
+    }
+  } catch (err) {
+    console.error("[memory-gc] Initial purge failed:", err);
+  }
+
+  memoryGcTimer = setInterval(() => {
+    try {
+      const purged = getMemoryStore().purgeExpired();
+      if (purged > 0) {
+        console.log(`[memory-gc] Periodic purge removed ${purged} expired memory row(s)`);
+      }
+    } catch (err) {
+      console.error("[memory-gc] Periodic purge failed:", err);
+    }
+  }, intervalMs);
+  if (typeof memoryGcTimer?.unref === "function") memoryGcTimer.unref();
+}
+
+export function stopMemoryGc(): void {
+  if (memoryGcTimer) {
+    clearInterval(memoryGcTimer);
+    memoryGcTimer = null;
+  }
+}

package/src/http/pages.ts

@@ -58,7 +58,7 @@ const createPageRoute = route({
     title: z.string().min(1),
     description: z.string().optional(),
     contentType: PageContentTypeSchema,
-    authMode: PageAuthModeSchema,
+    authMode: PageAuthModeSchema.default("authed"),
     password: z.string().min(1).optional(),
     body: z.string(),
     needsCredentials: z.array(z.string()).optional(),

package/src/http/script-runs.ts

@@ -62,6 +62,7 @@ const journalStepBodySchema = z.object({
   status: z.enum(["completed", "failed"]),
   result: z.unknown().optional(),
   error: z.string().optional(),
+  durationMs: z.number().int().nonnegative().optional(),
 });
 
 const statusBodySchema = z.discriminatedUnion("status", [
@@ -440,6 +441,7 @@ export async function handleScriptRuns(
       status: parsed.body.status,
       result: parsed.body.result,
       error: parsed.body.error,
+      durationMs: parsed.body.durationMs,
     });
     const limit = assertRunWithinLimits(run.id);
     if (!limit.ok) {

package/src/http/scripts.ts

@@ -1,6 +1,6 @@
 import type { IncomingMessage, ServerResponse } from "node:http";
 import { z } from "zod";
-import { getAgentById, upsertKv } from "../be/db";
+import { getAgentById, recordInlineScriptRun, upsertKv } from "../be/db";
 import { createEvent } from "../be/events";
 import { deleteScript, getScript, upsertScriptByName } from "../be/scripts/db";
 import { searchScripts } from "../be/scripts/embeddings";
@@ -14,7 +14,7 @@ import {
   type ScriptScope,
   ScriptScopeSchema,
 } from "../types";
-import { scrubObject } from "../utils/secret-scrubber";
+import { scrubObject, scrubSecrets } from "../utils/secret-scrubber";
 import { route } from "./route-def";
 import { json, jsonError } from "./utils";
 
@@ -283,6 +283,7 @@ export async function handleScripts(
       return true;
     }
 
+    const startedAt = new Date().toISOString();
     const output = await runScript({
       source: source as string,
       args: parsed.body.args,
@@ -331,6 +332,42 @@ export async function handleScripts(
       autoSaved = { slug, reason: "successful_inline_run" };
     }
 
+    // Persist the inline run (no journal) so one-off executions show up alongside
+    // durable workflow runs in the Script Runs dashboard. Best-effort: recording
+    // must never fail the actual execution.
+    const ok = output.exitCode === 0 && !output.error && !output.runtimeError;
+    const runError = ok
+      ? undefined
+      : scrubSecrets(
+          [
+            output.error,
+            output.runtimeError
+              ? `${output.runtimeError.name}: ${output.runtimeError.message}`
+              : undefined,
+          ]
+            .filter(Boolean)
+            .join(" — ") || `Script exited with code ${output.exitCode}`,
+        );
+    try {
+      recordInlineScriptRun({
+        id: crypto.randomUUID(),
+        agentId: agent.id,
+        source: source as string,
+        // Scrub args + result before persisting: the stored row is later served
+        // raw by GET /api/script-runs/{id} to the dashboard, so it needs the same
+        // redaction guarantees as the scrubbed run response below.
+        args: scrubObject(parsed.body.args ?? null),
+        scriptName: parsed.body.name,
+        status: ok ? "completed" : "failed",
+        output: scrubObject(output.result),
+        error: runError,
+        startedAt,
+        finishedAt: new Date().toISOString(),
+      });
+    } catch {
+      // swallow — the run already executed; persistence is observability only.
+    }
+
     json(
       res,
       scrubObject({

package/src/http/skills.ts

@@ -3,13 +3,18 @@ import { z } from "zod";
 import {
   createSkill,
   deleteSkill,
+  deleteSkillFile,
   getAgentSkills,
   getSkillById,
+  getSkillFile,
   installSkill,
+  listSkillFileManifest,
   listSkills,
   searchSkills,
   uninstallSkill,
   updateSkill,
+  upsertSkillFile,
+  upsertSkillFiles,
 } from "../be/db";
 import { parseSkillContent } from "../be/skill-parser";
 import { computeAgentSkillsSignature, syncSkillsToFilesystem } from "../be/skill-sync";
@@ -19,6 +24,24 @@ import { json, jsonError } from "./utils";
 const SYSTEM_DEFAULT_SKILL_LOCKED_MESSAGE =
   "This skill is system-managed and cannot be edited from the UI; it is re-seeded on each start. Fork it under a new name to customize.";
 
+const skillFileBodySchema = z.object({
+  content: z.string(),
+  mimeType: z.string().optional(),
+  isBinary: z.boolean().optional(),
+  size: z.number().int().nonnegative().optional(),
+});
+
+const skillFileWithPathSchema = skillFileBodySchema.extend({
+  path: z.string().min(1),
+});
+
+function decodeSkillFilePath(pathSegments: string[]): string {
+  return pathSegments
+    .slice(4)
+    .map((segment) => decodeURIComponent(segment))
+    .join("/");
+}
+
 // ─── Route Definitions ───────────────────────────────────────────────────────
 
 const listSkillsRoute = route({
@@ -58,6 +81,86 @@ const getSkillRoute = route({
   },
 });
 
+const listSkillFilesRoute = route({
+  method: "get",
+  path: "/api/skills/{id}/files",
+  pattern: ["api", "skills", null, "files"],
+  summary: "List bundled files for a skill",
+  description: "Returns a manifest of bundled skill files without file content.",
+  tags: ["Skills"],
+  auth: { apiKey: true },
+  params: z.object({ id: z.string() }),
+  responses: {
+    200: { description: "Skill file manifest" },
+    404: { description: "Skill not found" },
+  },
+});
+
+const bulkUpsertSkillFilesRoute = route({
+  method: "post",
+  path: "/api/skills/{id}/files",
+  pattern: ["api", "skills", null, "files"],
+  summary: "Bulk upsert bundled files for a skill",
+  tags: ["Skills"],
+  auth: { apiKey: true },
+  params: z.object({ id: z.string() }),
+  body: z.object({
+    files: z.array(skillFileWithPathSchema).max(100),
+  }),
+  responses: {
+    200: { description: "Skill files upserted" },
+    400: { description: "Validation error" },
+    404: { description: "Skill not found" },
+  },
+});
+
+const getSkillFileRoute = route({
+  method: "get",
+  path: "/api/skills/{id}/files/{path}",
+  pattern: ["api", "skills", null, "files", null],
+  exact: false,
+  summary: "Get a bundled skill file",
+  tags: ["Skills"],
+  auth: { apiKey: true },
+  params: z.object({ id: z.string(), path: z.string() }),
+  responses: {
+    200: { description: "Skill file" },
+    404: { description: "Skill or file not found" },
+  },
+});
+
+const upsertSkillFileRoute = route({
+  method: "put",
+  path: "/api/skills/{id}/files/{path}",
+  pattern: ["api", "skills", null, "files", null],
+  exact: false,
+  summary: "Upsert a bundled skill file",
+  tags: ["Skills"],
+  auth: { apiKey: true },
+  params: z.object({ id: z.string(), path: z.string() }),
+  body: skillFileBodySchema,
+  responses: {
+    200: { description: "Skill file upserted" },
+    400: { description: "Validation error" },
+    404: { description: "Skill not found" },
+  },
+});
+
+const deleteSkillFileRoute = route({
+  method: "delete",
+  path: "/api/skills/{id}/files/{path}",
+  pattern: ["api", "skills", null, "files", null],
+  exact: false,
+  summary: "Delete a bundled skill file",
+  tags: ["Skills"],
+  auth: { apiKey: true },
+  params: z.object({ id: z.string(), path: z.string() }),
+  responses: {
+    200: { description: "Skill file deleted" },
+    404: { description: "Skill or file not found" },
+  },
+});
+
 const createSkillRoute = route({
   method: "post",
   path: "/api/skills",
@@ -423,6 +526,128 @@ export async function handleSkills(
     return true;
   }
 
+  // GET /api/skills/:id/files
+  if (listSkillFilesRoute.match(req.method, pathSegments)) {
+    const parsed = await listSkillFilesRoute.parse(req, res, pathSegments, queryParams);
+    if (!parsed) return true;
+
+    const skill = getSkillById(parsed.params.id);
+    if (!skill) {
+      jsonError(res, "Skill not found", 404);
+      return true;
+    }
+
+    const files = listSkillFileManifest(parsed.params.id);
+    json(res, { files, total: files.length });
+    return true;
+  }
+
+  // POST /api/skills/:id/files
+  if (bulkUpsertSkillFilesRoute.match(req.method, pathSegments)) {
+    const parsed = await bulkUpsertSkillFilesRoute.parse(req, res, pathSegments, queryParams);
+    if (!parsed) return true;
+
+    const skill = getSkillById(parsed.params.id);
+    if (!skill) {
+      jsonError(res, "Skill not found", 404);
+      return true;
+    }
+    if (skill.systemDefault) {
+      jsonError(res, SYSTEM_DEFAULT_SKILL_LOCKED_MESSAGE, 403);
+      return true;
+    }
+
+    try {
+      const files = upsertSkillFiles(parsed.params.id, parsed.body.files);
+      const updatedSkill = getSkillById(parsed.params.id);
+      json(res, { files, total: files.length, skill: updatedSkill });
+    } catch (err) {
+      jsonError(res, err instanceof Error ? err.message : "Failed to upsert files", 400);
+    }
+    return true;
+  }
+
+  // GET /api/skills/:id/files/:path
+  if (getSkillFileRoute.match(req.method, pathSegments)) {
+    const parsed = await getSkillFileRoute.parse(req, res, pathSegments, queryParams);
+    if (!parsed) return true;
+
+    const skill = getSkillById(parsed.params.id);
+    if (!skill) {
+      jsonError(res, "Skill not found", 404);
+      return true;
+    }
+
+    try {
+      const file = getSkillFile(parsed.params.id, decodeSkillFilePath(pathSegments));
+      if (!file) {
+        jsonError(res, "Skill file not found", 404);
+        return true;
+      }
+      json(res, { file });
+    } catch (err) {
+      jsonError(res, err instanceof Error ? err.message : "Invalid file path", 400);
+    }
+    return true;
+  }
+
+  // PUT /api/skills/:id/files/:path
+  if (upsertSkillFileRoute.match(req.method, pathSegments)) {
+    const parsed = await upsertSkillFileRoute.parse(req, res, pathSegments, queryParams);
+    if (!parsed) return true;
+
+    const skill = getSkillById(parsed.params.id);
+    if (!skill) {
+      jsonError(res, "Skill not found", 404);
+      return true;
+    }
+    if (skill.systemDefault) {
+      jsonError(res, SYSTEM_DEFAULT_SKILL_LOCKED_MESSAGE, 403);
+      return true;
+    }
+
+    try {
+      const file = upsertSkillFile(parsed.params.id, {
+        path: decodeSkillFilePath(pathSegments),
+        ...parsed.body,
+      });
+      const updatedSkill = getSkillById(parsed.params.id);
+      json(res, { file, skill: updatedSkill });
+    } catch (err) {
+      jsonError(res, err instanceof Error ? err.message : "Failed to upsert file", 400);
+    }
+    return true;
+  }
+
+  // DELETE /api/skills/:id/files/:path
+  if (deleteSkillFileRoute.match(req.method, pathSegments)) {
+    const parsed = await deleteSkillFileRoute.parse(req, res, pathSegments, queryParams);
+    if (!parsed) return true;
+
+    const skill = getSkillById(parsed.params.id);
+    if (!skill) {
+      jsonError(res, "Skill not found", 404);
+      return true;
+    }
+    if (skill.systemDefault) {
+      jsonError(res, SYSTEM_DEFAULT_SKILL_LOCKED_MESSAGE, 403);
+      return true;
+    }
+
+    try {
+      const deleted = deleteSkillFile(parsed.params.id, decodeSkillFilePath(pathSegments));
+      if (!deleted) {
+        jsonError(res, "Skill file not found", 404);
+        return true;
+      }
+      const updatedSkill = getSkillById(parsed.params.id);
+      json(res, { success: true, skill: updatedSkill });
+    } catch (err) {
+      jsonError(res, err instanceof Error ? err.message : "Invalid file path", 400);
+    }
+    return true;
+  }
+
   // GET /api/skills/:id
   if (getSkillRoute.match(req.method, pathSegments)) {
     const parsed = await getSkillRoute.parse(req, res, pathSegments, queryParams);