@desplega.ai/agent-swarm 1.90.0 → 1.92.0

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@desplega.ai/agent-swarm",
-  "version": "1.90.0",
+  "version": "1.92.0",
   "description": "Multi-agent orchestration for Claude Code, Codex, Gemini CLI, and other AI coding assistants",
   "license": "MIT",
   "author": "desplega.sh <contact@desplega.sh>",
@@ -60,15 +60,15 @@
     "dev": "bun --hot src/stdio.ts",
     "dev:http": "portless api.swarm bun --hot src/http.ts",
     "start": "bun src/stdio.ts",
-    "start:http": "bun src/http.ts",
-    "start:portless": "portless api.swarm bun src/http.ts",
+    "start:http": "bun --expose-gc src/http.ts",
+    "start:portless": "portless api.swarm bun --expose-gc src/http.ts",
     "inspector": "bunx @modelcontextprotocol/inspector --transport stdio bun src/stdio.ts",
     "inspector:http": "bunx @modelcontextprotocol/inspector --transport http https://api.swarm.localhost:1355/mcp",
     "lint": "biome check src",
     "lint:fix": "biome check --write src",
     "format": "biome format --write src",
-    "build:binary": "bun build ./src/cli.tsx --compile --target=bun-linux-x64 --outfile ./dist/agent-swarm",
-    "build:binary:arm64": "bun build ./src/cli.tsx --compile --target=bun-linux-arm64 --outfile ./dist/agent-swarm",
+    "build:binary": "bun build ./src/cli.tsx --compile --compile-exec-argv='--expose-gc' --target=bun-linux-x64 --outfile ./dist/agent-swarm",
+    "build:binary:arm64": "bun build ./src/cli.tsx --compile --compile-exec-argv='--expose-gc' --target=bun-linux-arm64 --outfile ./dist/agent-swarm",
     "docker:build:worker": "docker build -f Dockerfile.worker -t agent-swarm-worker:latest .",
     "docker:run:worker": "docker run --rm -it --env-file .env.docker -p 3202:3000 -v ./logs:/logs -v ./work/shared:/workspace/shared -v ./work/worker-1:/workspace/personal agent-swarm-worker:latest",
     "docker:run:lead": "docker run --rm -it --env-file .env.docker-lead -e AGENT_ROLE=lead -p 3201:3000 -v ./logs:/logs -v ./work/shared:/workspace/shared -v ./work/lead:/workspace/personal agent-swarm-worker:latest",

package/src/artifact-sdk/server.ts

@@ -1,6 +1,7 @@
 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";
@@ -47,7 +48,7 @@ export function createBunHonoFetchHandler(app: Hono): (req: Request) => Promise<
 export function createArtifactServer(opts: ArtifactServerOptions): ArtifactServer {
   const agentId = process.env.AGENT_ID || "unknown";
   const apiKey = getApiKey();
-  const mcpBaseUrl = process.env.MCP_BASE_URL || `http://localhost:${process.env.PORT || "3013"}`;
+  const mcpBaseUrl = getMcpBaseUrl();
 
   const app = new Hono();
 

package/src/be/db.ts

@@ -62,6 +62,9 @@ import type {
   RepoGuidelines,
   ScheduledTask,
   ScheduledTaskSummary,
+  ScriptRun,
+  ScriptRunJournalEntry,
+  ScriptRunStatus,
   Service,
   ServiceStatus,
   SessionCost,
@@ -1887,6 +1890,19 @@ export function getInProgressTasksByContextKey(
     .map(rowToAgentTask);
 }
 
+export function getLatestTaskByContextKey(contextKey: string): AgentTask | null {
+  if (!contextKey) return null;
+  const row = getDb()
+    .prepare<AgentTaskRow, [string]>(
+      `SELECT * FROM agent_tasks
+       WHERE contextKey = ?
+       ORDER BY createdAt DESC
+       LIMIT 1`,
+    )
+    .get(contextKey);
+  return row ? rowToAgentTask(row) : null;
+}
+
 /**
  * Find the most recent agent associated with a specific Slack thread.
  * No status filter — returns the last agent that touched this thread regardless of task state.
@@ -8991,7 +9007,7 @@ export function getAgentSkills(agentId: string, activeOnly = true): SkillWithIns
     SELECT s.*, 1 as isActive, s.createdAt as installedAt, 1 as sourceRank,
       CASE WHEN s.type = 'personal' THEN 0 ELSE 1 END as typeRank
     FROM skills s
-    WHERE s.systemDefault = 1
+    WHERE (s.systemDefault = 1 OR s.scope = 'swarm')
       AND s.isEnabled = 1
     ORDER BY
       sourceRank,
@@ -11206,3 +11222,323 @@ export function countKv(namespace: string, opts: { prefix?: string }): number {
     .get(namespace, now);
   return row?.n ?? 0;
 }
+
+// ─── Script Runs ────────────────────────────────────────────────────────────
+
+type ScriptRunRow = {
+  id: string;
+  agentId: string;
+  scriptName: string | null;
+  source: string;
+  args: string;
+  status: string;
+  pid: number | null;
+  startedAt: string;
+  finishedAt: string | null;
+  output: string | null;
+  error: string | null;
+  last_heartbeat_at: string | null;
+  idempotencyKey: string | null;
+  requestedByUserId: string | null;
+  created_by: string | null;
+  updated_by: string | null;
+};
+
+function parseJsonColumn(value: string | null): unknown | undefined {
+  if (value === null) return undefined;
+  return JSON.parse(value);
+}
+
+function rowToScriptRun(row: ScriptRunRow): ScriptRun {
+  return {
+    id: row.id,
+    agentId: row.agentId,
+    scriptName: row.scriptName ?? undefined,
+    source: row.source,
+    args: JSON.parse(row.args),
+    status: row.status as ScriptRunStatus,
+    pid: row.pid ?? undefined,
+    startedAt: row.startedAt,
+    finishedAt: row.finishedAt ?? undefined,
+    output: parseJsonColumn(row.output),
+    error: row.error ?? undefined,
+    lastHeartbeatAt: row.last_heartbeat_at ?? undefined,
+    idempotencyKey: row.idempotencyKey ?? undefined,
+    requestedByUserId: row.requestedByUserId ?? undefined,
+  };
+}
+
+export function createScriptRun(data: {
+  id: string;
+  agentId: string;
+  source: string;
+  args: unknown;
+  scriptName?: string;
+  idempotencyKey?: string;
+  requestedByUserId?: string;
+  createdBy?: string;
+  updatedBy?: string;
+}): { run: ScriptRun; existing: boolean } {
+  const db = getDb();
+  if (data.idempotencyKey) {
+    const existing = db
+      .prepare<ScriptRunRow, [string]>("SELECT * FROM script_runs WHERE idempotencyKey = ?")
+      .get(data.idempotencyKey);
+    if (existing) return { run: rowToScriptRun(existing), existing: true };
+  }
+
+  const row = db
+    .prepare<
+      ScriptRunRow,
+      [
+        string,
+        string,
+        string | null,
+        string,
+        string,
+        string | null,
+        string | null,
+        string | null,
+        string | null,
+      ]
+    >(
+      `INSERT INTO script_runs
+        (id, agentId, scriptName, source, args, idempotencyKey, requestedByUserId, created_by, updated_by)
+       VALUES (?, ?, ?, ?, ?, ?, ?, ?, ?)
+       RETURNING *`,
+    )
+    .get(
+      data.id,
+      data.agentId,
+      data.scriptName ?? null,
+      data.source,
+      JSON.stringify(data.args ?? null),
+      data.idempotencyKey ?? null,
+      data.requestedByUserId ?? null,
+      data.createdBy ?? null,
+      data.updatedBy ?? data.createdBy ?? null,
+    );
+  if (!row) throw new Error("Failed to create script run");
+  return { run: rowToScriptRun(row), existing: false };
+}
+
+export function getScriptRun(id: string): ScriptRun | null {
+  const row = getDb()
+    .prepare<ScriptRunRow, [string]>("SELECT * FROM script_runs WHERE id = ?")
+    .get(id);
+  return row ? rowToScriptRun(row) : null;
+}
+
+export function getScriptRunByIdempotencyKey(idempotencyKey: string): ScriptRun | null {
+  const row = getDb()
+    .prepare<ScriptRunRow, [string]>("SELECT * FROM script_runs WHERE idempotencyKey = ?")
+    .get(idempotencyKey);
+  return row ? rowToScriptRun(row) : null;
+}
+
+export function listScriptRuns(opts?: {
+  status?: ScriptRunStatus;
+  agentId?: string;
+  limit?: number;
+  offset?: number;
+}): ScriptRun[] {
+  const conditions: string[] = [];
+  const params: Array<string | number> = [];
+  if (opts?.status) {
+    conditions.push("status = ?");
+    params.push(opts.status);
+  }
+  if (opts?.agentId) {
+    conditions.push("agentId = ?");
+    params.push(opts.agentId);
+  }
+
+  const limit = opts?.limit ?? 50;
+  const offset = opts?.offset ?? 0;
+  params.push(limit, offset);
+  const where = conditions.length > 0 ? `WHERE ${conditions.join(" AND ")}` : "";
+  const rows = getDb()
+    .prepare<ScriptRunRow, Array<string | number>>(
+      `SELECT * FROM script_runs ${where} ORDER BY startedAt DESC LIMIT ? OFFSET ?`,
+    )
+    .all(...params);
+  return rows.map(rowToScriptRun);
+}
+
+export function countScriptRuns(opts?: { status?: ScriptRunStatus; agentId?: string }): number {
+  const conditions: string[] = [];
+  const params: string[] = [];
+  if (opts?.status) {
+    conditions.push("status = ?");
+    params.push(opts.status);
+  }
+  if (opts?.agentId) {
+    conditions.push("agentId = ?");
+    params.push(opts.agentId);
+  }
+  const where = conditions.length > 0 ? `WHERE ${conditions.join(" AND ")}` : "";
+  const row = getDb()
+    .prepare<{ count: number }, string[]>(`SELECT COUNT(*) AS count FROM script_runs ${where}`)
+    .get(...params);
+  return row?.count ?? 0;
+}
+
+export function countActiveScriptRuns(): number {
+  const row = getDb()
+    .prepare<{ count: number }, []>(
+      "SELECT COUNT(*) AS count FROM script_runs WHERE status IN ('running', 'paused')",
+    )
+    .get();
+  return row?.count ?? 0;
+}
+
+export function updateScriptRun(
+  id: string,
+  patch: Partial<{
+    status: ScriptRunStatus;
+    pid: number | null;
+    finishedAt: string | null;
+    output: unknown;
+    error: string | null;
+    lastHeartbeatAt: string | null;
+    updatedBy: string | null;
+  }>,
+): void {
+  const sets: string[] = [];
+  const vals: Array<string | number | null> = [];
+  if (patch.status !== undefined) {
+    sets.push("status = ?");
+    vals.push(patch.status);
+  }
+  if (patch.pid !== undefined) {
+    sets.push("pid = ?");
+    vals.push(patch.pid);
+  }
+  if (patch.finishedAt !== undefined) {
+    sets.push("finishedAt = ?");
+    vals.push(patch.finishedAt);
+  }
+  if ("output" in patch) {
+    sets.push("output = ?");
+    vals.push(patch.output === undefined ? null : JSON.stringify(patch.output));
+  }
+  if (patch.error !== undefined) {
+    sets.push("error = ?");
+    vals.push(patch.error);
+  }
+  if (patch.lastHeartbeatAt !== undefined) {
+    sets.push("last_heartbeat_at = ?");
+    vals.push(patch.lastHeartbeatAt);
+  }
+  if (patch.updatedBy !== undefined) {
+    sets.push("updated_by = ?");
+    vals.push(patch.updatedBy);
+  }
+  if (sets.length === 0) return;
+  vals.push(id);
+  getDb().run(`UPDATE script_runs SET ${sets.join(", ")} WHERE id = ?`, vals);
+}
+
+export function getRunningScriptRuns(): ScriptRun[] {
+  const rows = getDb()
+    .prepare<ScriptRunRow, []>("SELECT * FROM script_runs WHERE status IN ('running', 'paused')")
+    .all();
+  return rows.map(rowToScriptRun);
+}
+
+// ─── Script Run Journal ─────────────────────────────────────────────────────
+
+type ScriptRunJournalRow = {
+  id: string;
+  runId: string;
+  stepKey: string;
+  stepType: string;
+  config: string;
+  status: string;
+  result: string | null;
+  error: string | null;
+  startedAt: string;
+  completedAt: string | null;
+  created_by: string | null;
+  updated_by: string | null;
+};
+
+function rowToScriptRunJournalEntry(row: ScriptRunJournalRow): ScriptRunJournalEntry {
+  return {
+    id: row.id,
+    runId: row.runId,
+    stepKey: row.stepKey,
+    stepType: row.stepType,
+    config: JSON.parse(row.config),
+    status: row.status as "completed" | "failed",
+    result: parseJsonColumn(row.result),
+    error: row.error ?? undefined,
+    startedAt: row.startedAt,
+    completedAt: row.completedAt ?? undefined,
+  };
+}
+
+export function getScriptRunJournalStep(
+  runId: string,
+  stepKey: string,
+): ScriptRunJournalEntry | null {
+  const row = getDb()
+    .prepare<ScriptRunJournalRow, [string, string]>(
+      "SELECT * FROM script_run_journal WHERE runId = ? AND stepKey = ?",
+    )
+    .get(runId, stepKey);
+  return row ? rowToScriptRunJournalEntry(row) : null;
+}
+
+export function upsertScriptRunJournalStep(data: {
+  runId: string;
+  stepKey: string;
+  stepType: string;
+  config: unknown;
+  status: "completed" | "failed";
+  result?: unknown;
+  error?: string;
+}): void {
+  getDb().run(
+    `INSERT OR IGNORE INTO script_run_journal
+      (id, runId, stepKey, stepType, config, status, result, error, completedAt)
+     VALUES (?, ?, ?, ?, ?, ?, ?, ?, datetime('now'))`,
+    [
+      crypto.randomUUID(),
+      data.runId,
+      data.stepKey,
+      data.stepType,
+      JSON.stringify(data.config ?? {}),
+      data.status,
+      data.result !== undefined ? JSON.stringify(data.result) : null,
+      data.error ?? null,
+    ],
+  );
+}
+
+export function listScriptRunJournalSteps(runId: string): ScriptRunJournalEntry[] {
+  const rows = getDb()
+    .prepare<ScriptRunJournalRow, [string]>(
+      "SELECT * FROM script_run_journal WHERE runId = ? ORDER BY startedAt ASC",
+    )
+    .all(runId);
+  return rows.map(rowToScriptRunJournalEntry);
+}
+
+export function countScriptRunJournalSteps(runId: string): number {
+  const row = getDb()
+    .prepare<{ count: number }, [string]>(
+      "SELECT COUNT(*) AS count FROM script_run_journal WHERE runId = ?",
+    )
+    .get(runId);
+  return row?.count ?? 0;
+}
+
+export function countScriptRunJournalAgentTaskSteps(runId: string): number {
+  const row = getDb()
+    .prepare<{ count: number }, [string]>(
+      "SELECT COUNT(*) AS count FROM script_run_journal WHERE runId = ? AND stepType = 'agent-task'",
+    )
+    .get(runId);
+  return row?.count ?? 0;
+}

package/src/be/memory/providers/sqlite-store.ts

@@ -383,7 +383,7 @@ export class SqliteMemoryStore implements MemoryStore {
   }
 
   list(agentId: string, options: MemoryListOptions = {}): AgentMemory[] {
-    const { scope = "all", limit = 20, offset = 0, isLead = false } = options;
+    const { scope = "all", limit = 20, offset = 0, isLead = false, source } = options;
     const db = getDb();
 
     const conditions: string[] = [];
@@ -407,6 +407,11 @@ export class SqliteMemoryStore implements MemoryStore {
       }
     }
 
+    if (source) {
+      conditions.push("source = ?");
+      params.push(source);
+    }
+
     const whereClause = conditions.length > 0 ? `WHERE ${conditions.join(" AND ")}` : "";
     params.push(limit, offset);
 

package/src/be/memory/types.ts

@@ -70,6 +70,7 @@ export interface MemoryListOptions {
   limit?: number;
   offset?: number;
   isLead?: boolean;
+  source?: AgentMemorySource;
 }
 
 export interface MemoryStats {

package/src/be/migrations/083_script_workflows.sql

@@ -0,0 +1,51 @@
+-- Script Workflows v1: durable background TypeScript scripts.
+
+CREATE TABLE IF NOT EXISTS script_runs (
+  id                TEXT PRIMARY KEY,
+  agentId           TEXT NOT NULL,
+  scriptName        TEXT,
+  source            TEXT NOT NULL,
+  args              TEXT NOT NULL DEFAULT 'null',
+  status            TEXT NOT NULL DEFAULT 'running'
+    CHECK(status IN (
+      'running',
+      'paused',
+      'completed',
+      'failed',
+      'cancelled',
+      'aborted_limit'
+    )),
+  pid               INTEGER,
+  startedAt         TEXT NOT NULL DEFAULT (datetime('now')),
+  finishedAt        TEXT,
+  output            TEXT,
+  error             TEXT,
+  last_heartbeat_at TEXT,
+  idempotencyKey    TEXT UNIQUE,
+  requestedByUserId TEXT REFERENCES users(id),
+  created_by        TEXT REFERENCES users(id),
+  updated_by        TEXT REFERENCES users(id)
+);
+
+CREATE INDEX IF NOT EXISTS idx_script_runs_status ON script_runs(status);
+CREATE INDEX IF NOT EXISTS idx_script_runs_agentId ON script_runs(agentId);
+CREATE INDEX IF NOT EXISTS idx_script_runs_idempotencyKey ON script_runs(idempotencyKey)
+  WHERE idempotencyKey IS NOT NULL;
+
+CREATE TABLE IF NOT EXISTS script_run_journal (
+  id          TEXT PRIMARY KEY,
+  runId       TEXT NOT NULL REFERENCES script_runs(id) ON DELETE CASCADE,
+  stepKey     TEXT NOT NULL,
+  stepType    TEXT NOT NULL,
+  config      TEXT NOT NULL DEFAULT '{}',
+  status      TEXT NOT NULL CHECK(status IN ('completed','failed')),
+  result      TEXT,
+  error       TEXT,
+  startedAt   TEXT NOT NULL DEFAULT (datetime('now')),
+  completedAt TEXT,
+  created_by  TEXT REFERENCES users(id),
+  updated_by  TEXT REFERENCES users(id),
+  UNIQUE(runId, stepKey)
+);
+
+CREATE INDEX IF NOT EXISTS idx_srj_runId ON script_run_journal(runId);