@desplega.ai/agent-swarm 2.3.0 → 2.4.1

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@desplega.ai/agent-swarm",
-  "version": "2.3.0",
+  "version": "2.4.1",
   "description": "agent-swarm.dev — an open-source operating system for AI work: a lead agent breaks goals into tasks, routes them to specialized workers such as Claude Code or Codex, runs each worker in an isolated container, and preserves shared memory, tools, schedules, and review gates so delegated work compounds across sessions.",
   "keywords": [
     "agent-swarm.dev",
@@ -200,7 +200,7 @@
   "dependencies": {
     "@agentclientprotocol/sdk": "1.9.0",
     "@ai-sdk/openai": "^3.0.41",
-    "@anthropic-ai/claude-agent-sdk": "0.3.302",
+    "@anthropic-ai/claude-agent-sdk": "0.3.303",
     "@anthropic-ai/sdk": "^0.135.0",
     "@asteasolutions/zod-to-openapi": "^8.0.0",
     "@aws-sdk/client-bedrock": "3.1048.0",

package/src/apps/action-caller.ts

@@ -0,0 +1,6 @@
+export type AppActionCaller = {
+  kind: "user" | "agent" | "operator" | "guest";
+  id: string | null;
+  name?: string;
+  pageId?: string;
+};

package/src/apps/action-runner.ts

@@ -0,0 +1,146 @@
+import { normalizeAssetKey } from "../assets/key";
+import { getLeadAgent } from "../be/db";
+import { getScriptById } from "../be/scripts/db";
+import { getSavedScriptOwnerAgentId, runSavedScriptAsAgent } from "../be/scripts/run-saved";
+import { resolveTemplate } from "../prompts/resolver";
+import { createTaskWithSiblingAwareness } from "../tasks/sibling-awareness";
+import { scrubObject } from "../utils/secret-scrubber";
+import type { AppActionCaller } from "./action-caller";
+import type { AppRecord } from "./store";
+import { runAppSync } from "./sync";
+
+/**
+ * One `error` string for a sync result, or undefined when every pass succeeded.
+ * Each failed pair is named so a multi-pair sync says which one broke; the pass
+ * list in `result.passes` carries the rest.
+ */
+function syncPassError(sync: Awaited<ReturnType<typeof runAppSync>>): string | undefined {
+  const failed = sync.passes.filter((pass) => pass.error !== undefined);
+  if (failed.length === 0) return undefined;
+  return failed.map((pass) => `${pass.model}.${pass.source}: ${pass.error}`).join("; ");
+}
+
+export async function runAppAction({
+  app,
+  name,
+  input = {},
+  caller,
+  actor,
+}: {
+  app: AppRecord;
+  name: string;
+  input?: Record<string, unknown>;
+  caller: AppActionCaller;
+  actor: string;
+}) {
+  const actions = app.definition.actions;
+  if (!actions || !Object.hasOwn(actions, name)) {
+    return { status: 404 as const, body: { error: "app action not found" } };
+  }
+
+  const action = actions[name]!;
+
+  if (action.kind === "script") {
+    const script = await getScriptById(action.scriptId);
+    if (!script) {
+      return {
+        status: 400 as const,
+        body: {
+          error: "invalid app action",
+          issues: [
+            {
+              path: `actions.${name}.scriptId`,
+              message: `script "${action.scriptId}" no longer exists`,
+            },
+          ],
+        },
+      };
+    }
+
+    // Script actions use the owner's bindings. Definition validation checks
+    // which scripts an agent can wire into an app.
+    const runAsAgentId = getSavedScriptOwnerAgentId(script);
+    if (!runAsAgentId) {
+      return {
+        status: 400 as const,
+        body: { error: "agentId is required: this script has no owning agent to run as" },
+      };
+    }
+
+    const output = await runSavedScriptAsAgent({
+      script,
+      input: { ...action.args, ...input, app: { id: app.id }, caller },
+      agentId: runAsAgentId,
+    });
+    const ok = output.exitCode === 0 && !output.error && !output.runtimeError;
+    const error = ok
+      ? undefined
+      : output.runtimeError
+        ? `${output.runtimeError.name}: ${output.runtimeError.message}`
+        : (output.error ?? `Script exited with code ${output.exitCode}`);
+    return {
+      status: 200 as const,
+      body: scrubObject({
+        ok,
+        result: output.result,
+        stdout: output.stdout,
+        ...(error === undefined ? {} : { error }),
+        durationMs: output.durationMs,
+      }),
+    };
+  }
+
+  if (action.kind === "sync") {
+    const startedAt = Date.now();
+    const sync = await runAppSync({
+      appId: app.id,
+      ...(action.model === undefined ? {} : { model: action.model }),
+      ...(action.source === undefined ? {} : { source: action.source }),
+      invokedBy: actor,
+    });
+    const durationMs = Date.now() - startedAt;
+    if (sync.issues && sync.issues.length > 0) {
+      return { status: 400 as const, body: { error: "invalid sync action", issues: sync.issues } };
+    }
+    // Deliberately the SCRIPT-action response shape, minus `taskId`:
+    // app-surface.tsx branches on `taskId` first, so omitting it gives the
+    // dashboard running -> ok/error + refetchAll() with zero UI changes.
+    const error = syncPassError(sync);
+    return {
+      status: 200 as const,
+      body: scrubObject({
+        ok: sync.ok,
+        result: { passes: sync.passes },
+        ...(error === undefined ? {} : { error }),
+        durationMs,
+      }),
+    };
+  }
+
+  const lead = action.agentId ? null : await getLeadAgent();
+  const taskPrompt = resolveTemplate("task.app.action", {
+    prompt: action.prompt,
+    app_id: app.id,
+    action_name: name,
+    input_json: JSON.stringify(input),
+    caller_json: JSON.stringify(caller),
+  });
+  const task = await createTaskWithSiblingAwareness(
+    taskPrompt.text,
+    {
+      source: "api",
+      agentId: action.agentId ?? lead?.id,
+      routingReason: action.agentId ? "human_pinned" : lead ? "skill" : undefined,
+      routingSource: action.agentId || lead ? "engine_default" : undefined,
+      // App-spawned tasks group under the app's asset namespace so a
+      // swarm-tasks source can pull them back via config.assetKey.
+      key: normalizeAssetKey(`shared/app:${app.id}/action:${name}/`),
+      ...(actor.startsWith("user:") ? { requestedByUserId: actor.slice("user:".length) } : {}),
+    },
+    { origin: "app" },
+  );
+  return {
+    status: 200 as const,
+    body: { ok: true as const, taskId: task.id, status: task.status },
+  };
+}

package/src/apps/row-store.ts

@@ -109,7 +109,7 @@ function indexKeys(model: string, definition: ModelDef, row: AppRow): string[] {
   return keys;
 }
 
-function validValue(column: ColumnDef, value: unknown): boolean {
+export function validValue(column: ColumnDef, value: unknown): boolean {
   if (value === null) return column.required !== true;
   if (column.kind === "string") return typeof value === "string";
   if (column.kind === "number") return typeof value === "number" && Number.isFinite(value);
@@ -526,18 +526,20 @@ export async function rebuildAppColumnIndexUnlocked(
   }
 }
 
+/** `matches` re-checks the row under the lock; a row that no longer matches is kept. */
 export function deleteAppRow(
   appId: string,
   model: string,
   _definition: ModelDef,
   rowId: string,
+  matches?: (row: AppRow) => boolean,
 ): Promise<boolean> {
   return withMutationLock(appId, model, async () => {
     const currentDefinition = await currentModelDefinition(appId, model);
     if (!currentDefinition) return false;
     const namespace = appsNamespace(appId);
     const row = await getAppRow(appId, model, rowId);
-    if (!row) return false;
+    if (!row || (matches && !matches(row))) return false;
     for (const key of indexKeys(model, currentDefinition, row)) await deleteKv(namespace, key);
     await deleteKv(namespace, rowKey(model, rowId));
     return true;

package/src/apps/script-types.ts

@@ -8,6 +8,13 @@ const APP_TYPES_PREAMBLE = `// ── Swarm Apps: generated per-app types (sourc
 // Rows are the app's declared columns plus the 5 system columns. Query
 // overloads narrow only when appId AND query are string literals.
 
+export type AppActionCaller = {
+  kind: "user" | "agent" | "operator" | "guest";
+  id: string | null;
+  name?: string;
+  pageId?: string;
+};
+
 export interface SwarmAppQueryResult<Row> {
   success: boolean;
   status: number;
@@ -175,9 +182,8 @@ function renderQuery(
 }
 
 function renderApp(app: AppRecord, namespace: string): string {
-  // Reserve the generated alias so a model named `actionName` dedupes to
-  // `ActionName_2` instead of colliding with `type ActionName`.
-  const modelNames = new Set<string>(["ActionName"]);
+  // Reserve action types so model names cannot collide with them.
+  const modelNames = new Set<string>(["ActionName", "ActionArgs", "AppActionCaller"]);
   const renderedModels = Object.entries(app.definition.models).map(([modelName, model]) =>
     renderModel(modelName, model, modelNames),
   );
@@ -200,8 +206,15 @@ function renderApp(app: AppRecord, namespace: string): string {
 export namespace ${namespace} {
 ${renderedModels.map((model) => model.source).join("\n\n")}
 
-  /** Declared actions. Invocation is REST-only: POST /api/apps/<id>/actions/<name>. */
+  /** Scripts can write rows. Declared actions are callable through REST or MCP only. */
   export type ActionName = ${actionType};
+
+  /** Script action arguments include server-stamped app and caller context. */
+  export interface ActionArgs {
+    app: { id: ${JSON.stringify(app.id)} };
+    caller: AppActionCaller;
+    [key: string]: unknown;
+  }
 }
 
 export interface SwarmSdk {

package/src/be/db/active-sessions.ts

@@ -1,3 +1,4 @@
+import type { ActiveSession } from "../../types";
 import { getDbClient } from "./runtime";
 
 /**
@@ -28,3 +29,7 @@ export async function refreshActiveSessionOnActivity(
   );
   return result.changes > 0;
 }
+
+export async function getActiveSessionById(id: string): Promise<ActiveSession | null> {
+  return getDbClient().get<ActiveSession>("SELECT * FROM active_sessions WHERE id = ?", [id]);
+}

package/src/be/db/session-visibility.ts

@@ -0,0 +1,29 @@
+/**
+ * Session-list visibility for session sharing. `all`: sessions the viewer
+ * owns, ownerless sessions, and sessions shared with the viewer or everyone.
+ * `mine`: owned by the viewer. `shared`: owned by someone else and shared with
+ * the viewer or everyone. A null `userId` (a guest page session) owns nothing.
+ */
+export type SessionViewer = { userId: string | null; scope: "all" | "mine" | "shared" };
+
+/** SQL condition + params restricting root tasks (alias `r`) to what `viewer` may open. */
+export function sessionViewerCondition(viewer: SessionViewer): {
+  sql: string;
+  params: (string | null)[];
+} {
+  const shared = `EXISTS (SELECT 1 FROM session_shares s
+      WHERE s.rootTaskId = r.id AND s.revokedAt IS NULL AND (s.userId IS NULL OR s.userId = ?))`;
+  if (viewer.scope === "mine") {
+    return { sql: "r.requestedByUserId = ?", params: [viewer.userId] };
+  }
+  if (viewer.scope === "shared") {
+    return {
+      sql: `(r.requestedByUserId IS NOT NULL AND r.requestedByUserId IS NOT ? AND ${shared})`,
+      params: [viewer.userId, viewer.userId],
+    };
+  }
+  return {
+    sql: `(r.requestedByUserId IS NULL OR r.requestedByUserId = ? OR ${shared})`,
+    params: [viewer.userId, viewer.userId],
+  };
+}

package/src/be/db/tasks/read.ts

@@ -556,10 +556,14 @@ export async function hasNonTerminalRerouteDecisionChild(parentId: string): Prom
   return row !== undefined && row !== null;
 }
 
-export async function getTasksByAgentId(agentId: string): Promise<AgentTask[]> {
+export async function getTasksByAgentId(
+  agentId: string,
+  readableBy?: { userId: string | null },
+): Promise<AgentTask[]> {
+  const readable = readableBy ? readableSessionCondition(readableBy.userId) : undefined;
   const rows = await getDbClient().query<AgentTaskRow>(
-    "SELECT * FROM agent_tasks WHERE agentId = ? ORDER BY createdAt DESC",
-    [agentId],
+    `SELECT * FROM agent_tasks WHERE agentId = ?${readable ? ` AND ${readable.sql}` : ""} ORDER BY createdAt DESC`,
+    [agentId, ...(readable?.params ?? [])],
   );
   return rows.map(rowToAgentTask);
 }
@@ -642,6 +646,48 @@ export interface TaskFilters {
   limit?: number;
   offset?: number;
   includeHeartbeat?: boolean;
+  /** Only tasks of sessions this user may read; `userId: null` is a guest. */
+  readableBy?: { userId: string | null };
+}
+
+/**
+ * The SQL twin of `sessionAccessForRoot` (../../session-shares). A session's
+ * root is its topmost existing task; the session is hidden when the root has
+ * an owner other than the user and no active share names the user or
+ * everyone. Descending from hidden roots is linear in their tasks at any chain
+ * depth, and as a WHERE term it keeps paging and `COUNT(*)` on the same rows.
+ * `parentTaskId` is fixed at insert to an existing task, so no parent cycle
+ * (which would have no root) can form.
+ *
+ * `taskIdColumn` applies the same filter to any table keyed by task id. A
+ * nullable column keeps its task-less rows: they belong to no session.
+ */
+export function readableSessionCondition(
+  userId: string | null,
+  taskIdColumn = "agent_tasks.id",
+  opts: { nullable?: boolean } = {},
+): { sql: string; params: string[] } {
+  const otherOwner = userId
+    ? "r.requestedByUserId IS NOT NULL AND r.requestedByUserId != ?"
+    : "r.requestedByUserId IS NOT NULL";
+  const shareMatch = userId ? "(s.userId IS NULL OR s.userId = ?)" : "s.userId IS NULL";
+  const notHidden = `${taskIdColumn} NOT IN (
+      WITH RECURSIVE hidden(id) AS (
+        SELECT r.id FROM agent_tasks r
+        WHERE (r.parentTaskId IS NULL
+            OR NOT EXISTS (SELECT 1 FROM agent_tasks p WHERE p.id = r.parentTaskId))
+          AND ${otherOwner}
+          AND NOT EXISTS (SELECT 1 FROM session_shares s
+            WHERE s.rootTaskId = r.id AND s.revokedAt IS NULL AND ${shareMatch})
+        UNION ALL
+        SELECT c.id FROM agent_tasks c JOIN hidden ON c.parentTaskId = hidden.id
+      )
+      SELECT id FROM hidden
+    )`;
+  return {
+    sql: opts.nullable ? `(${taskIdColumn} IS NULL OR ${notHidden})` : notHidden,
+    params: userId ? [userId, userId] : [],
+  };
 }
 
 export function getAllTasks(filters?: TaskFilters): Promise<AgentTask[]>;
@@ -756,6 +802,12 @@ export async function getAllTasks(
     );
   }
 
+  if (filters?.readableBy) {
+    const readable = readableSessionCondition(filters.readableBy.userId);
+    conditions.push(readable.sql);
+    params.push(...readable.params);
+  }
+
   const whereClause = conditions.length > 0 ? `WHERE ${conditions.join(" AND ")}` : "";
   const limit = filters?.limit ?? 25;
   const offset = filters?.offset ?? 0;
@@ -916,6 +968,12 @@ export async function getTasksCount(
     );
   }
 
+  if (filters?.readableBy) {
+    const readable = readableSessionCondition(filters.readableBy.userId);
+    conditions.push(readable.sql);
+    params.push(...readable.params);
+  }
+
   const whereClause = conditions.length > 0 ? `WHERE ${conditions.join(" AND ")}` : "";
   const query = `SELECT COUNT(*) as count FROM agent_tasks ${whereClause}`;
 

package/src/be/db/tasks/write.ts

@@ -27,6 +27,7 @@ import {
   type AgentTaskRow,
   getTaskById,
   NEVER_STARTED_TASK_STATUSES,
+  readableSessionCondition,
   rowToAgentTask,
 } from "./read";
 
@@ -1019,12 +1020,16 @@ export async function resumeTask(taskId: string): Promise<AgentTask | null> {
  * Used on startup to resume tasks that were interrupted by deployment.
  * Returns tasks ordered by creation time (oldest first for FIFO).
  */
-export async function getPausedTasksForAgent(agentId: string): Promise<AgentTask[]> {
+export async function getPausedTasksForAgent(
+  agentId: string,
+  readableBy?: { userId: string | null },
+): Promise<AgentTask[]> {
+  const readable = readableBy ? readableSessionCondition(readableBy.userId) : undefined;
   const rows = await getDbClient().query<AgentTaskRow>(
     `SELECT * FROM agent_tasks
-       WHERE agentId = ? AND status = 'paused'
+       WHERE agentId = ? AND status = 'paused'${readable ? ` AND ${readable.sql}` : ""}
        ORDER BY createdAt ASC, rowid ASC`,
-    [agentId],
+    [agentId, ...(readable?.params ?? [])],
   );
   return rows.map(rowToAgentTask);
 }
@@ -1093,15 +1098,19 @@ export async function resetOrphanedInProgressTasksForAgent(
  * Used by hooks to detect task cancellation and stop the worker loop.
  * Returns tasks cancelled within the last 5 minutes.
  */
-export async function getRecentlyCancelledTasksForAgent(agentId: string): Promise<AgentTask[]> {
+export async function getRecentlyCancelledTasksForAgent(
+  agentId: string,
+  readableBy?: { userId: string | null },
+): Promise<AgentTask[]> {
   const fiveMinutesAgo = new Date(Date.now() - 5 * 60 * 1000).toISOString();
+  const readable = readableBy ? readableSessionCondition(readableBy.userId) : undefined;
   const rows = await getDbClient().query<AgentTaskRow>(
     `SELECT * FROM agent_tasks
        WHERE agentId = ?
        AND status = 'cancelled'
-       AND finishedAt > ?
+       AND finishedAt > ?${readable ? ` AND ${readable.sql}` : ""}
        ORDER BY finishedAt DESC`,
-    [agentId, fiveMinutesAgo],
+    [agentId, fiveMinutesAgo, ...(readable?.params ?? [])],
   );
   return rows.map(rowToAgentTask);
 }