@desplega.ai/agent-swarm 1.76.1 → 1.76.2

package/openapi.json

@@ -2,7 +2,7 @@
   "openapi": "3.1.0",
   "info": {
     "title": "Agent Swarm API",
-    "version": "1.76.1",
+    "version": "1.76.2",
     "description": "Multi-agent orchestration API for Claude Code, Codex, and Gemini CLI. Enables task distribution, agent communication, and service discovery.\n\nMCP tools are documented separately in [MCP.md](./MCP.md)."
   },
   "servers": [
@@ -1781,7 +1781,7 @@
         }
       },
       "delete": {
-        "summary": "Delete a config entry by ID (including legacy reserved rows for cleanup)",
+        "summary": "Delete a config entry by ID (including legacy reserved rows for cleanup). Global-scope deletes auto-trigger an integrations reload.",
         "tags": [
           "Config"
         ],
@@ -1858,7 +1858,7 @@
         }
       },
       "put": {
-        "summary": "Create or update a config entry (reserved env-only keys are rejected)",
+        "summary": "Create or update a config entry (reserved env-only keys are rejected). Global-scope writes auto-trigger an integrations reload (debounced ~250ms) so Slack/GitHub/Linear/Jira/AgentMail pick up new credentials without an explicit /api/config/reload call.",
         "tags": [
           "Config"
         ],

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@desplega.ai/agent-swarm",
-  "version": "1.76.1",
+  "version": "1.76.2",
   "description": "Multi-agent orchestration for Claude Code, Codex, Gemini CLI, and other AI coding assistants",
   "license": "MIT",
   "author": "desplega.sh <contact@desplega.sh>",

package/src/http/config.ts

@@ -14,7 +14,7 @@ import {
   reservedKeyError,
   validateConfigValue,
 } from "../be/swarm-config-guard";
-import { reloadGlobalConfigsAndIntegrations } from "./core";
+import { reloadGlobalConfigsAndIntegrations, scheduleIntegrationsReload } from "./core";
 import { route } from "./route-def";
 import { json, jsonError } from "./utils";
 
@@ -104,7 +104,8 @@ const upsertConfig = route({
   method: "put",
   path: "/api/config",
   pattern: ["api", "config"],
-  summary: "Create or update a config entry (reserved env-only keys are rejected)",
+  summary:
+    "Create or update a config entry (reserved env-only keys are rejected). Global-scope writes auto-trigger an integrations reload (debounced ~250ms) so Slack/GitHub/Linear/Jira/AgentMail pick up new credentials without an explicit /api/config/reload call.",
   tags: ["Config"],
   body: z.object({
     scope: z.enum(["global", "agent", "repo"]),
@@ -125,7 +126,8 @@ const deleteConfig = route({
   method: "delete",
   path: "/api/config/{id}",
   pattern: ["api", "config", null],
-  summary: "Delete a config entry by ID (including legacy reserved rows for cleanup)",
+  summary:
+    "Delete a config entry by ID (including legacy reserved rows for cleanup). Global-scope deletes auto-trigger an integrations reload.",
   tags: ["Config"],
   params: z.object({ id: z.string() }),
   responses: {
@@ -251,6 +253,13 @@ export async function handleConfig(
         envPath: envPath || null,
         description: description || null,
       });
+      // Auto-reload integrations when a global-scoped config changes so callers
+      // (CLI, automation, dashboard) don't have to remember to hit /reload.
+      // Debounced to coalesce sequential single-key upserts from the dashboard
+      // batch save (no bulk endpoint exists).
+      if (scope === "global") {
+        scheduleIntegrationsReload();
+      }
       const result = includeSecrets || !config.isSecret ? config : maskSecrets([config])[0];
       json(res, result);
     } catch (_error) {
@@ -272,6 +281,9 @@ export async function handleConfig(
       jsonError(res, "Config not found", 404);
       return true;
     }
+    if (existing.scope === "global") {
+      scheduleIntegrationsReload();
+    }
     json(res, { success: true });
     return true;
   }

package/src/http/core.ts

@@ -84,6 +84,114 @@ export async function reloadGlobalConfigsAndIntegrations(): Promise<ReloadConfig
   };
 }
 
+// ─── Auto-reload debouncer ────────────────────────────────────────────────────
+// Why this exists: the integrations dashboard saves a row at a time (no bulk
+// endpoint — see ui/src/api/hooks/use-config-api.ts useUpsertConfigsBatch),
+// so a "save" of N keys produces N upsert calls in tight succession. Reloading
+// after each one would tear Slack's socket down N times. Coalesce instead.
+let pendingReloadTimer: ReturnType<typeof setTimeout> | null = null;
+let inFlightReload: Promise<ReloadConfigResult> | null = null;
+let reloadRerunRequested = false;
+let autoReloadInvocations = 0;
+const AUTO_RELOAD_DEBOUNCE_MS = 250;
+
+/**
+ * Schedule a coalesced integrations reload. Repeated calls within the debounce
+ * window collapse into a single reload. If a reload is currently running, the
+ * scheduler defers the next one until it finishes (so a save during a reload
+ * still re-runs once afterwards).
+ *
+ * Fire-and-forget — failures are logged and swallowed so callers (HTTP handlers)
+ * don't have to await the reload before responding.
+ */
+export function scheduleIntegrationsReload(delayMs = AUTO_RELOAD_DEBOUNCE_MS): void {
+  if (inFlightReload) {
+    reloadRerunRequested = true;
+    return;
+  }
+  if (pendingReloadTimer) {
+    clearTimeout(pendingReloadTimer);
+  }
+  pendingReloadTimer = setTimeout(() => {
+    pendingReloadTimer = null;
+    autoReloadInvocations += 1;
+    inFlightReload = reloadGlobalConfigsAndIntegrations()
+      .then((r) => {
+        console.log(
+          `[auto-reload] Loaded ${r.configsLoaded} config(s), re-initialized: ${r.integrationsReinitialized.join(", ") || "none"}`,
+        );
+        return r;
+      })
+      .catch((err) => {
+        const message = err instanceof Error ? err.message : String(err);
+        console.error("[auto-reload] Failed:", message);
+        throw err;
+      })
+      .finally(() => {
+        inFlightReload = null;
+        if (reloadRerunRequested) {
+          reloadRerunRequested = false;
+          scheduleIntegrationsReload(delayMs);
+        }
+      });
+  }, delayMs);
+}
+
+/**
+ * For tests + shutdown: cancel any pending timer and await any in-flight
+ * reload. Returns once the queue is fully drained.
+ */
+export async function flushPendingIntegrationsReload(): Promise<void> {
+  if (pendingReloadTimer) {
+    clearTimeout(pendingReloadTimer);
+    pendingReloadTimer = null;
+    autoReloadInvocations += 1;
+    inFlightReload = reloadGlobalConfigsAndIntegrations()
+      .catch((err) => {
+        const message = err instanceof Error ? err.message : String(err);
+        console.error("[auto-reload] flush failed:", message);
+        throw err;
+      })
+      .finally(() => {
+        inFlightReload = null;
+      }) as Promise<ReloadConfigResult>;
+  }
+  if (inFlightReload) {
+    try {
+      await inFlightReload;
+    } catch {
+      // Already logged; flush should not throw on caller's path.
+    }
+  }
+  // Drain any reruns queued while we were awaiting.
+  while (reloadRerunRequested) {
+    reloadRerunRequested = false;
+    autoReloadInvocations += 1;
+    inFlightReload = reloadGlobalConfigsAndIntegrations()
+      .catch(() => null)
+      .finally(() => {
+        inFlightReload = null;
+      }) as Promise<ReloadConfigResult>;
+    await inFlightReload;
+  }
+}
+
+// ─── Test helpers (stable surface for src/tests/) ─────────────────────────────
+// Module state is intentionally process-global; tests need to reset it between
+// cases to avoid cross-contamination. Not part of the public HTTP API.
+export function _autoReloadStatsForTests(): { invocations: number; pending: boolean } {
+  return { invocations: autoReloadInvocations, pending: pendingReloadTimer !== null };
+}
+export function _resetAutoReloadForTests(): void {
+  if (pendingReloadTimer) {
+    clearTimeout(pendingReloadTimer);
+    pendingReloadTimer = null;
+  }
+  inFlightReload = null;
+  reloadRerunRequested = false;
+  autoReloadInvocations = 0;
+}
+
 export async function handleCore(
   req: IncomingMessage,
   res: ServerResponse,

package/src/tests/reload-config.test.ts

@@ -1,10 +1,16 @@
-import { afterAll, beforeAll, describe, expect, test } from "bun:test";
+import { afterAll, beforeAll, beforeEach, describe, expect, test } from "bun:test";
 import { unlink } from "node:fs/promises";
 import { createServer as createHttpServer, type Server } from "node:http";
 import { initAgentMail, resetAgentMail } from "../agentmail";
-import { closeDb, getDb, initDb, upsertSwarmConfig } from "../be/db";
+import { closeDb, deleteSwarmConfig, getDb, initDb, upsertSwarmConfig } from "../be/db";
 import { initGitHub, resetGitHub } from "../github";
-import { loadGlobalConfigsIntoEnv } from "../http/core";
+import {
+  _autoReloadStatsForTests,
+  _resetAutoReloadForTests,
+  flushPendingIntegrationsReload,
+  loadGlobalConfigsIntoEnv,
+  scheduleIntegrationsReload,
+} from "../http/core";
 
 const TEST_DB_PATH = "./test-reload-config.sqlite";
 const TEST_PORT = 13023;
@@ -199,3 +205,137 @@ describe("reload-config", () => {
     expect(res.status).toBe(404);
   });
 });
+
+describe("auto-reload debouncer", () => {
+  // The reload calls into stopSlackApp/startSlackApp + GH/Linear/Jira/AgentMail
+  // init. They are no-ops without credentials, so we explicitly disable Slack
+  // (it has its own DISABLE switch) and rely on the others being unconfigured.
+  let originalSlackDisable: string | undefined;
+
+  beforeAll(() => {
+    originalSlackDisable = process.env.SLACK_DISABLE;
+    process.env.SLACK_DISABLE = "true";
+  });
+
+  afterAll(() => {
+    if (originalSlackDisable === undefined) {
+      delete process.env.SLACK_DISABLE;
+    } else {
+      process.env.SLACK_DISABLE = originalSlackDisable;
+    }
+  });
+
+  beforeEach(() => {
+    _resetAutoReloadForTests();
+  });
+
+  test("scheduleIntegrationsReload runs reload after the debounce window", async () => {
+    const testKey = `__TEST_AUTO_RELOAD_RUNS_${Date.now()}`;
+    upsertSwarmConfig({ scope: "global", key: testKey, value: "fresh" });
+    delete process.env[testKey];
+
+    scheduleIntegrationsReload(50);
+    expect(_autoReloadStatsForTests().pending).toBe(true);
+
+    await flushPendingIntegrationsReload();
+
+    expect(_autoReloadStatsForTests().invocations).toBe(1);
+    expect(process.env[testKey]).toBe("fresh");
+
+    delete process.env[testKey];
+  });
+
+  test("rapid scheduleIntegrationsReload calls coalesce into one reload", async () => {
+    const testKey = `__TEST_COALESCE_${Date.now()}`;
+    upsertSwarmConfig({ scope: "global", key: testKey, value: "v1" });
+
+    scheduleIntegrationsReload(100);
+    scheduleIntegrationsReload(100);
+    scheduleIntegrationsReload(100);
+    scheduleIntegrationsReload(100);
+
+    expect(_autoReloadStatsForTests().invocations).toBe(0);
+
+    await flushPendingIntegrationsReload();
+
+    expect(_autoReloadStatsForTests().invocations).toBe(1);
+
+    delete process.env[testKey];
+  });
+
+  test("schedule during in-flight reload triggers exactly one rerun", async () => {
+    const testKey = `__TEST_RERUN_${Date.now()}`;
+    upsertSwarmConfig({ scope: "global", key: testKey, value: "first" });
+
+    scheduleIntegrationsReload(20);
+    // Wait just past the debounce so the first reload is in-flight, then
+    // schedule again. The second call should defer to a rerun, not a parallel
+    // reload.
+    await new Promise((r) => setTimeout(r, 25));
+    scheduleIntegrationsReload(20);
+    scheduleIntegrationsReload(20); // collapses with the rerun-pending flag
+
+    await flushPendingIntegrationsReload();
+
+    // First run + one rerun = 2 invocations total.
+    expect(_autoReloadStatsForTests().invocations).toBe(2);
+
+    delete process.env[testKey];
+  });
+
+  test("flushPendingIntegrationsReload is a no-op when nothing is queued", async () => {
+    expect(_autoReloadStatsForTests().pending).toBe(false);
+    await flushPendingIntegrationsReload();
+    expect(_autoReloadStatsForTests().invocations).toBe(0);
+  });
+
+  test("auto-reload picks up a brand-new config row at runtime", async () => {
+    const testKey = `__TEST_NEW_ROW_${Date.now()}`;
+    delete process.env[testKey];
+
+    // Simulate the upsert path's behavior: write the row, then schedule.
+    upsertSwarmConfig({ scope: "global", key: testKey, value: "live-update" });
+    scheduleIntegrationsReload(20);
+
+    await flushPendingIntegrationsReload();
+
+    expect(process.env[testKey]).toBe("live-update");
+    delete process.env[testKey];
+  });
+
+  test("auto-reload reflects an updated value (override semantics)", async () => {
+    const testKey = `__TEST_OVERRIDE_LIVE_${Date.now()}`;
+    process.env[testKey] = "shipped-by-deploy";
+
+    // Pre-existing env should win at startup, but reload uses override=true.
+    upsertSwarmConfig({ scope: "global", key: testKey, value: "from-config" });
+    scheduleIntegrationsReload(20);
+
+    await flushPendingIntegrationsReload();
+
+    expect(process.env[testKey]).toBe("from-config");
+    delete process.env[testKey];
+  });
+
+  test("delete + reload removes value from active env (well, doesn't re-inject it)", async () => {
+    const testKey = `__TEST_DELETE_${Date.now()}`;
+    delete process.env[testKey];
+
+    const config = upsertSwarmConfig({ scope: "global", key: testKey, value: "to-be-deleted" });
+    scheduleIntegrationsReload(20);
+    await flushPendingIntegrationsReload();
+    expect(process.env[testKey]).toBe("to-be-deleted");
+
+    deleteSwarmConfig(config.id);
+    // Mimic the delete handler in src/http/config.ts.
+    scheduleIntegrationsReload(20);
+    await flushPendingIntegrationsReload();
+
+    // Caveat: process.env keeps the previously-injected value. Reload only
+    // overwrites keys that still exist in DB. This test pins that behavior so
+    // anyone changing the loader has to make a deliberate decision about
+    // whether to also unset removed keys.
+    expect(process.env[testKey]).toBe("to-be-deleted");
+    delete process.env[testKey];
+  });
+});