@desplega.ai/agent-swarm 1.157.0 → 1.158.0

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@desplega.ai/agent-swarm",
-  "version": "1.157.0",
+  "version": "1.158.0",
   "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",
@@ -203,6 +203,7 @@
     "@opencode-ai/sdk": "^1.18.32",
     "@openfort/openfort-node": "^0.9.1",
     "@opentelemetry/api": "^1.9.1",
+    "@opentelemetry/api-logs": "^0.218.0",
     "@opentelemetry/exporter-metrics-otlp-http": "^0.218.0",
     "@opentelemetry/exporter-trace-otlp-http": "^0.218.0",
     "@opentelemetry/resources": "^2.7.1",

package/src/apps/catalog.generated.json

@@ -21,6 +21,9 @@
     "Form",
     "Drawer",
     "DetailList",
+    "Kanban",
+    "Calendar",
+    "ContributionGraph",
     "ElementRef",
     "ElementSlot"
   ],
@@ -842,6 +845,232 @@
         "additionalProperties": false
       }
     },
+    "Kanban": {
+      "description": "Kanban board: one card per row, grouped into `columns` by the row's `columnField`. Bind `data`/`loading` to a named query. `titleField` is the card title; `cardFields` add label/value lines with Table column kinds (badge tones, relative dates). Dragging a card to another column runs `onMove` with `$row` = the moved row, `columnField` already set to the new column — typically `[{ \"action\": \"app.mutate\", \"params\": { \"model\": \"<m>\", \"op\": \"update\", \"rowId\": { \"$row\": \"id\" }, \"values\": { \"<columnField>\": { \"$row\": \"<columnField>\" } } } }]`. Without `onMove` the board is read-only. `onCardClick` runs with `$row` (e.g. an `app.navigate` that opens a Drawer).",
+      "props": {
+        "$schema": "http://json-schema.org/draft-07/schema#",
+        "type": "object",
+        "properties": {
+          "data": {
+            "type": "array",
+            "items": {
+              "type": "object",
+              "propertyNames": {
+                "type": "string"
+              },
+              "additionalProperties": {}
+            }
+          },
+          "loading": {
+            "type": "boolean"
+          },
+          "columnField": {
+            "type": "string"
+          },
+          "columns": {
+            "minItems": 1,
+            "type": "array",
+            "items": {
+              "anyOf": [
+                {
+                  "type": "string"
+                },
+                {
+                  "type": "object",
+                  "properties": {
+                    "id": {
+                      "type": "string"
+                    },
+                    "label": {
+                      "type": "string"
+                    }
+                  },
+                  "required": ["id"],
+                  "additionalProperties": false
+                }
+              ]
+            }
+          },
+          "titleField": {
+            "type": "string"
+          },
+          "cardFields": {
+            "type": "array",
+            "items": {
+              "type": "object",
+              "properties": {
+                "key": {
+                  "type": "string"
+                },
+                "label": {
+                  "type": "string"
+                },
+                "kind": {
+                  "type": "string",
+                  "enum": ["text", "string", "number", "boolean", "date", "badge", "enum", "code"]
+                },
+                "tones": {
+                  "type": "object",
+                  "propertyNames": {
+                    "type": "string"
+                  },
+                  "additionalProperties": {
+                    "type": "string",
+                    "enum": [
+                      "neutral",
+                      "success",
+                      "active",
+                      "error",
+                      "info",
+                      "pending",
+                      "warning",
+                      "paused"
+                    ]
+                  }
+                }
+              },
+              "required": ["key"],
+              "additionalProperties": false
+            }
+          },
+          "idField": {
+            "type": "string"
+          },
+          "onMove": {
+            "type": "array",
+            "items": {
+              "type": "object",
+              "properties": {
+                "action": {
+                  "type": "string"
+                },
+                "params": {
+                  "type": "object",
+                  "propertyNames": {
+                    "type": "string"
+                  },
+                  "additionalProperties": {}
+                }
+              },
+              "required": ["action"],
+              "additionalProperties": false
+            }
+          },
+          "onCardClick": {
+            "type": "array",
+            "items": {
+              "type": "object",
+              "properties": {
+                "action": {
+                  "type": "string"
+                },
+                "params": {
+                  "type": "object",
+                  "propertyNames": {
+                    "type": "string"
+                  },
+                  "additionalProperties": {}
+                }
+              },
+              "required": ["action"],
+              "additionalProperties": false
+            }
+          }
+        },
+        "required": ["columnField", "columns", "titleField"],
+        "additionalProperties": false
+      }
+    },
+    "Calendar": {
+      "description": "Read-only month calendar of rows. `startField` (and optional `endField`) hold dates; an event shows on every day it spans. `titleField` labels it. Has its own prev/next month controls; each Calendar keeps its own month. `onSelect` runs when an event is clicked, with `$row` (e.g. `app.navigate` to open a Drawer).",
+      "props": {
+        "$schema": "http://json-schema.org/draft-07/schema#",
+        "type": "object",
+        "properties": {
+          "data": {
+            "type": "array",
+            "items": {
+              "type": "object",
+              "propertyNames": {
+                "type": "string"
+              },
+              "additionalProperties": {}
+            }
+          },
+          "loading": {
+            "type": "boolean"
+          },
+          "startField": {
+            "type": "string"
+          },
+          "endField": {
+            "type": "string"
+          },
+          "titleField": {
+            "type": "string"
+          },
+          "idField": {
+            "type": "string"
+          },
+          "onSelect": {
+            "type": "array",
+            "items": {
+              "type": "object",
+              "properties": {
+                "action": {
+                  "type": "string"
+                },
+                "params": {
+                  "type": "object",
+                  "propertyNames": {
+                    "type": "string"
+                  },
+                  "additionalProperties": {}
+                }
+              },
+              "required": ["action"],
+              "additionalProperties": false
+            }
+          }
+        },
+        "required": ["startField", "titleField"],
+        "additionalProperties": false
+      }
+    },
+    "ContributionGraph": {
+      "description": "GitHub-style activity heatmap over the trailing `days` (default 365). Buckets rows by the calendar day of `dateField` (default `date`); each row counts 1, or sums `countField` when set. Read-only.",
+      "props": {
+        "$schema": "http://json-schema.org/draft-07/schema#",
+        "type": "object",
+        "properties": {
+          "data": {
+            "type": "array",
+            "items": {
+              "type": "object",
+              "propertyNames": {
+                "type": "string"
+              },
+              "additionalProperties": {}
+            }
+          },
+          "loading": {
+            "type": "boolean"
+          },
+          "dateField": {
+            "type": "string"
+          },
+          "countField": {
+            "type": "string"
+          },
+          "days": {
+            "type": "integer",
+            "minimum": 7,
+            "maximum": 730
+          }
+        },
+        "additionalProperties": false
+      }
+    },
     "ElementRef": {
       "description": "Reference a reusable element from this app or an exported element from another app. Consumer children are inserted at the target's ElementSlot.",
       "slots": ["default"],

package/src/apps/page-validator.ts

@@ -43,6 +43,24 @@ export const ELEMENT_KEYS = new Set([
   "watch",
 ]);
 const UI_STATE_COMPONENTS = new Set(["SearchInput", "Select", "Tabs"]);
+
+/**
+ * Props that hold a plain action chain (an array of `{ action, params }`),
+ * keyed by component type. Table's `rowActions[].actions` is nested one level
+ * deeper and handled separately.
+ */
+const PROP_ACTION_CHAINS: Record<string, readonly string[]> = {
+  Form: ["onSubmit"],
+  Kanban: ["onMove", "onCardClick"],
+  Calendar: ["onSelect"],
+};
+
+/** Props naming a row field of the bound `data` query's model, per type. */
+const DATA_FIELD_PROPS: Record<string, readonly string[]> = {
+  Kanban: ["columnField", "titleField", "idField"],
+  Calendar: ["startField", "endField", "titleField", "idField"],
+  ContributionGraph: ["dateField", "countField"],
+};
 const CONDITION_KEYS = new Set(["eq", "neq", "gt", "gte", "lt", "lte", "not"]);
 
 function isPlainObject(value: unknown): value is Record<string, unknown> {
@@ -705,8 +723,8 @@ function visitPageActionSteps(
         );
       }
     }
-    if (rawElement.type === "Form") {
-      visitActionChain(rawElement.props.onSubmit, `${elementPath}.props.onSubmit`, visit, false);
+    for (const prop of PROP_ACTION_CHAINS[String(rawElement.type)] ?? []) {
+      visitActionChain(rawElement.props[prop], `${elementPath}.props.${prop}`, visit, false);
     }
   }
 }
@@ -1234,7 +1252,7 @@ export function validatePage(
     if (component) {
       const propsPath = appendPath(elementPath, "props");
       const actionChainPath = (path: string): boolean =>
-        (type === "Form" && path === `${propsPath}.onSubmit`) ||
+        (PROP_ACTION_CHAINS[String(type)] ?? []).some((prop) => path === `${propsPath}.${prop}`) ||
         (type === "Table" && /^.+\.rowActions\.\d+\.actions$/.test(path));
       const propsResult = validateSchema(
         Object.hasOwn(rawElement, "props") ? rawElement.props : {},
@@ -1331,6 +1349,44 @@ export function validatePage(
             if (found) issues.push(found);
           }
         }
+      } else if (typeof type === "string" && Object.hasOwn(DATA_FIELD_PROPS, type)) {
+        // Kanban / Calendar / ContributionGraph name row fields of the bound
+        // query's model (`columnField`, `startField`, ...) — a typo'd name
+        // would silently render an empty board/grid, so cross-check it.
+        const queryModel = queryModelFromDataBinding(definition, rawElement.props.data);
+        if (queryModel) {
+          const props = rawElement.props;
+          const fieldNames: [string, unknown][] = (DATA_FIELD_PROPS[type] ?? []).map((prop) => [
+            `${elementPath}.props.${prop}`,
+            props[prop],
+          ]);
+          if (type === "Kanban" && Array.isArray(props.cardFields)) {
+            for (const [index, field] of props.cardFields.entries()) {
+              if (isPlainObject(field)) {
+                fieldNames.push([`${elementPath}.props.cardFields.${index}.key`, field.key]);
+              }
+            }
+          }
+          for (const [fieldPath, fieldName] of fieldNames) {
+            if (typeof fieldName !== "string") continue;
+            const found = fieldBindingIssue(
+              queryModel.modelName,
+              queryModel.model,
+              fieldName,
+              fieldPath,
+            );
+            if (found) issues.push(found);
+          }
+          for (const prop of PROP_ACTION_CHAINS[type] ?? []) {
+            collectRowFieldIssues(
+              props[prop],
+              `${elementPath}.props.${prop}`,
+              queryModel.modelName,
+              queryModel.model,
+              issues,
+            );
+          }
+        }
       } else if (type === "Form") {
         // `$`-prefixed names are reserved runtime slots under `/forms/<id>/`
         // (`$error` carries the inline mutate failure) — a field stored there
@@ -1440,19 +1496,18 @@ export function validatePage(
         stateRefs.push(...chainResult.stateRefs);
       }
     }
-    if (
-      type === "Form" &&
-      isPlainObject(rawElement.props) &&
-      Object.hasOwn(rawElement.props, "onSubmit")
-    ) {
-      const chainResult = validateActionChain(
-        rawElement.props.onSubmit,
-        `${elementPath}.props.onSubmit`,
-        definition,
-        catalog,
-      );
-      issues.push(...chainResult.issues);
-      stateRefs.push(...chainResult.stateRefs);
+    if (isPlainObject(rawElement.props)) {
+      for (const prop of PROP_ACTION_CHAINS[String(type)] ?? []) {
+        if (!Object.hasOwn(rawElement.props, prop)) continue;
+        const chainResult = validateActionChain(
+          rawElement.props[prop],
+          `${elementPath}.props.${prop}`,
+          definition,
+          catalog,
+        );
+        issues.push(...chainResult.issues);
+        stateRefs.push(...chainResult.stateRefs);
+      }
     }
   }
 

package/src/apps/row-store.ts

@@ -1,4 +1,5 @@
-import { deleteKv, getDbClient, getKv, listKv, upsertKv } from "../be/db";
+import { deleteKv, getDbClient, getKv, kvPrefixUpperBound, listKv, upsertKv } from "../be/db";
+import { isInTransaction } from "../be/db-client";
 import {
   AppDefinitionSchema,
   type AppValidationIssue,
@@ -58,6 +59,15 @@ export class AppRowAppNotFoundError extends Error {
 const mutationChains = new Map<string, Promise<unknown>>();
 let lastCreatedAtMs = 0;
 
+/**
+ * Let queued I/O and other requests run. DB calls are synchronous, so a loop
+ * of awaited statements otherwise only drains microtasks and holds the event
+ * loop until it finishes.
+ */
+export function yieldToEventLoop(): Promise<void> {
+  return new Promise((resolve) => setImmediate(resolve));
+}
+
 export function appsNamespace(appId: string): string {
   return `apps:${appId}`;
 }
@@ -331,11 +341,23 @@ export async function getAppRow(
   return entry.value as AppRow;
 }
 
-export async function listAppRows(appId: string, model: string): Promise<AppRow[]> {
+/**
+ * `equals` pre-filters rows in SQL on top-level fields so a filtered list
+ * does not decode the whole model. The match is looser than `===` (JSON
+ * `true` equals `1`); callers re-check the returned rows.
+ */
+export async function listAppRows(
+  appId: string,
+  model: string,
+  equals: Array<{ column: string; value: string | number | boolean }> = [],
+): Promise<AppRow[]> {
   const entries = await listKv(appsNamespace(appId), {
     prefix: `${model}/row/`,
     limit: 100000,
     offset: 0,
+    jsonFieldEquals: equals
+      .filter((filter) => !/["\\]/.test(filter.column))
+      .map((filter) => ({ field: filter.column, value: filter.value })),
   });
   return entries
     .map((entry) => entry.value)
@@ -355,17 +377,37 @@ export async function listAllAppRowsForMigrationUnlocked(
   const rows: AppRow[] = [];
   const namespace = appsNamespace(appId);
   const prefix = `${model}/row/`;
-  let offset = 0;
+  // Row keys are `<model>/row/<uuid>`, so this bound always exists.
+  const upper = kvPrefixUpperBound(prefix)!;
+  // Keyset paging on the (namespace, key) primary key: OFFSET re-walked every
+  // skipped row on each page. Same rows, order and TTL filter as `listKv`.
+  let afterKey = "";
   while (true) {
-    const entries = await listKv(namespace, { prefix, limit: MIGRATION_KV_BATCH_SIZE, offset });
-    for (const entry of entries) {
-      const value = entry.value;
+    const page = await getDbClient().query<{ key: string; value: string; value_type: string }>(
+      `SELECT key, value, value_type FROM kv_entries
+          WHERE namespace = ? AND key >= ? AND key < ? AND key > ?
+            AND (expires_at IS NULL OR expires_at > ?)
+          ORDER BY key
+          LIMIT ?`,
+      [namespace, prefix, upper, afterKey, Date.now(), MIGRATION_KV_BATCH_SIZE],
+    );
+    for (const entry of page) {
+      if (entry.value_type !== "json") continue;
+      let value: unknown;
+      try {
+        value = JSON.parse(entry.value);
+      } catch {
+        continue;
+      }
       if (typeof value === "object" && value !== null && !Array.isArray(value)) {
         rows.push(value as AppRow);
       }
     }
-    if (entries.length < MIGRATION_KV_BATCH_SIZE) return rows;
-    offset += entries.length;
+    if (page.length < MIGRATION_KV_BATCH_SIZE) return rows;
+    afterKey = page[page.length - 1]!.key;
+    // Schema migrations call this inside an open DbClient transaction, where a
+    // timer would stall every DB caller; only yield outside one.
+    if (!isInTransaction()) await yieldToEventLoop();
   }
 }
 
@@ -502,12 +544,25 @@ export function deleteAppRow(
   });
 }
 
+const PURGE_BATCH_SIZE = 1000;
+
+/**
+ * Batched DELETEs with an event-loop yield between them: one statement per
+ * row blocked every other request for the whole purge, and a single DELETE of
+ * the namespace would block for its full duration too. Expired entries go as
+ * well; a TTL-filtered listing would leave them orphaned.
+ */
 async function purgeNamespace(appId: string): Promise<void> {
   const namespace = appsNamespace(appId);
   while (true) {
-    const entries = await listKv(namespace, { prefix: "", limit: 100000, offset: 0 });
-    if (entries.length === 0) return;
-    for (const entry of entries) await deleteKv(namespace, entry.key);
+    const result = await getDbClient().run(
+      `DELETE FROM kv_entries
+          WHERE namespace = ?
+            AND key IN (SELECT key FROM kv_entries WHERE namespace = ? ORDER BY key LIMIT ?)`,
+      [namespace, namespace, PURGE_BATCH_SIZE],
+    );
+    if (result.changes === 0) return;
+    await yieldToEventLoop();
   }
 }
 

package/src/apps/sync.ts

@@ -1,5 +1,5 @@
 import * as z from "zod";
-import { deleteKv, getAllTasks, getKv, type TaskFilters, upsertKv } from "../be/db";
+import { deleteKv, getAllTasks, getDbClient, getKv, type TaskFilters, upsertKv } from "../be/db";
 import { listScriptConnections } from "../be/script-connections";
 import { getScriptById } from "../be/scripts/db";
 import { runSavedScriptAsAgent } from "../be/scripts/run-saved";
@@ -21,6 +21,7 @@ import {
   listAllAppRowsForMigrationUnlocked,
   patchAppRowUnlocked,
   withMutationLock,
+  yieldToEventLoop,
 } from "./row-store";
 import { appDefinitionNeedsRepair, getApp } from "./store";
 import { resolveSyncRunAs } from "./sync-run-as";
@@ -585,6 +586,45 @@ type ReconcileCounts = {
   staleSweepSkipped?: boolean;
 };
 
+type ReconcileTally = Omit<ReconcileCounts, "staleSweepSkipped">;
+
+/** Rows written per transaction. Big enough to amortize COMMIT, small enough
+ * that one chunk holds the event loop for milliseconds, not seconds. */
+export const RECONCILE_CHUNK_SIZE = 200;
+
+/**
+ * Apply `write` to `items` in transactions of RECONCILE_CHUNK_SIZE, yielding
+ * to the event loop between chunks. A chunk's tally lands in `counts` only
+ * after it commits, so a failing chunk rolls back its writes and its counts
+ * together while earlier chunks stay committed and counted.
+ */
+async function writeInChunks<T>(
+  items: readonly T[],
+  counts: ReconcileCounts,
+  write: (item: T, tally: ReconcileTally) => Promise<void>,
+): Promise<void> {
+  for (let start = 0; start < items.length; start += RECONCILE_CHUNK_SIZE) {
+    const chunk = items.slice(start, start + RECONCILE_CHUNK_SIZE);
+    const tally = await getDbClient().transaction(async () => {
+      const chunkTally: ReconcileTally = {
+        created: 0,
+        updated: 0,
+        refreshed: 0,
+        unchanged: 0,
+        markedStale: 0,
+      };
+      for (const item of chunk) await write(item, chunkTally);
+      return chunkTally;
+    });
+    counts.created += tally.created;
+    counts.updated += tally.updated;
+    counts.refreshed += tally.refreshed;
+    counts.unchanged += tally.unchanged;
+    counts.markedStale += tally.markedStale;
+    await yieldToEventLoop();
+  }
+}
+
 function reconcile(args: {
   appId: string;
   model: string;
@@ -594,13 +634,15 @@ function reconcile(args: {
   pull: PullResult;
   warnings: string[];
   /**
-   * Mutated write-by-write so a mid-pass failure still reports the row churn
-   * that actually committed — the writes are independent KV upserts, not a
-   * transaction, and a thrown error must not zero them out.
+   * Mutated chunk-by-chunk so a mid-pass failure still reports the row churn
+   * that actually committed: writes run in chunked transactions, and a thrown
+   * error must not zero out the chunks that landed before it.
    */
   counts: ReconcileCounts;
 }): Promise<void> {
   const { appId, model, sourceName, joinKey, pull, warnings, counts } = args;
+  // Lock order: the mutation lock is taken here, and every chunk transaction
+  // opens beneath it (see withMutationLock).
   return withMutationLock(appId, model, async () => {
     // Re-read under the lock: the pull ran unlocked, so the definition it was
     // planned against may be gone. Anything that moves the identity or the
@@ -639,7 +681,7 @@ function reconcile(args: {
     const actor = `sync:${sourceName}`;
     const seen = new Set<string>();
 
-    for (const record of pull.records) {
+    await writeInChunks(pull.records, counts, async (record, tally) => {
       if (seen.has(record.key)) {
         warn(warnings, `source returned duplicate key "${record.key}"; the last record wins`);
       }
@@ -655,8 +697,8 @@ function reconcile(args: {
           actor,
         });
         mine.set(record.key, created);
-        counts.created += 1;
-        continue;
+        tally.created += 1;
+        return;
       }
       const differs = Object.entries(values).some(
         ([name, value]) => !sameValue(existing[name], value),
@@ -671,12 +713,12 @@ function reconcile(args: {
       });
       if (!updated) {
         warn(warnings, `row "${existing.id}" vanished before it could be updated`);
-        continue;
+        return;
       }
       mine.set(record.key, updated);
-      if (differs) counts.updated += 1;
-      else counts.refreshed += 1;
-    }
+      if (differs) tally.updated += 1;
+      else tally.refreshed += 1;
+    });
 
     const unseen = [...mine.entries()]
       .filter(([key]) => !seen.has(key))
@@ -688,10 +730,10 @@ function reconcile(args: {
       warn(warnings, "pull reported an incomplete window; stale sweep skipped");
       return;
     }
-    for (const row of unseen) {
+    await writeInChunks(unseen, counts, async (row, tally) => {
       if (row.stale === true) {
-        counts.unchanged += 1;
-        continue;
+        tally.unchanged += 1;
+        return;
       }
       await patchAppRowUnlocked(
         appId,
@@ -710,8 +752,8 @@ function reconcile(args: {
           },
         },
       );
-      counts.markedStale += 1;
-    }
+      tally.markedStale += 1;
+    });
   });
 }
 
@@ -778,7 +820,7 @@ async function executePass(args: {
     return scrubbed;
   };
 
-  // Reconcile mutates this accumulator write-by-write, so the error path below
+  // Reconcile mutates this accumulator chunk-by-chunk, so the error path below
   // reports the churn that actually committed instead of the zero-count base.
   const counts: ReconcileCounts = {
     created: 0,