@desplega.ai/agent-swarm 1.80.0 → 1.80.2

package/src/be/scripts/db.ts

@@ -0,0 +1,417 @@
+import type { ScriptFsMode, ScriptRecord, ScriptScope, ScriptVersionRecord } from "../../types";
+import { computeContentHash, getDb } from "../db";
+import { embedScript } from "./embeddings";
+
+type ScriptRow = Omit<ScriptRecord, "isScratch" | "typeChecked"> & {
+  isScratch: number;
+  typeChecked: number;
+};
+
+type ScriptVersionRow = ScriptVersionRecord;
+
+type ScriptIdentity = {
+  name: string;
+  scope: ScriptScope;
+  scopeId?: string | null;
+};
+
+type ScriptWriteArgs = ScriptIdentity & {
+  source: string;
+  description: string;
+  intent: string;
+  signatureJson: string;
+  argsJsonSchema?: string | null;
+  isScratch?: boolean;
+  typeChecked?: boolean;
+  fsMode?: ScriptFsMode;
+  agentId?: string | null;
+  changeReason?: string | null;
+};
+
+export type UpsertScriptResult = {
+  script: ScriptRecord;
+  isNew: boolean;
+  contentDeduped: boolean;
+};
+
+function normalizeScopeId(scope: ScriptScope, scopeId?: string | null): string | null {
+  if (scope === "global") return null;
+  if (!scopeId) {
+    throw new Error("scopeId is required for agent-scoped scripts");
+  }
+  return scopeId;
+}
+
+function rowToScript(row: ScriptRow): ScriptRecord {
+  return {
+    ...row,
+    scopeId: row.scopeId ?? null,
+    isScratch: row.isScratch === 1,
+    typeChecked: row.typeChecked === 1,
+    createdByAgentId: row.createdByAgentId ?? null,
+  };
+}
+
+function rowToScriptVersion(row: ScriptVersionRow): ScriptVersionRecord {
+  return {
+    ...row,
+    changedByAgentId: row.changedByAgentId ?? null,
+    changeReason: row.changeReason ?? null,
+  };
+}
+
+function insertScriptVersion(args: {
+  scriptId: string;
+  version: number;
+  source: string;
+  description: string;
+  intent: string;
+  signatureJson: string;
+  contentHash: string;
+  changedByAgentId?: string | null;
+  changeReason?: string | null;
+}): void {
+  getDb()
+    .prepare(
+      `INSERT INTO script_versions (
+        id, scriptId, version, source, description, intent, signatureJson,
+        contentHash, changedByAgentId, changedAt, changeReason
+      )
+      VALUES (?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?)`,
+    )
+    .run(
+      crypto.randomUUID(),
+      args.scriptId,
+      args.version,
+      args.source,
+      args.description,
+      args.intent,
+      args.signatureJson,
+      args.contentHash,
+      args.changedByAgentId ?? null,
+      new Date().toISOString(),
+      args.changeReason ?? null,
+    );
+}
+
+export function insertScript(args: ScriptWriteArgs): ScriptRecord {
+  const now = new Date().toISOString();
+  const id = crypto.randomUUID();
+  const scopeId = normalizeScopeId(args.scope, args.scopeId);
+  const contentHash = computeContentHash(args.source);
+  const fsMode = args.fsMode ?? "none";
+  const isScratch = args.isScratch ? 1 : 0;
+  const typeChecked = args.typeChecked ? 1 : 0;
+
+  const txn = getDb().transaction(() => {
+    const row = getDb()
+      .prepare<
+        ScriptRow,
+        [
+          string,
+          string,
+          ScriptScope,
+          string | null,
+          string,
+          string,
+          string,
+          string,
+          string | null,
+          string,
+          number,
+          number,
+          string,
+          string | null,
+          string,
+          string,
+        ]
+      >(
+        `INSERT INTO scripts (
+          id, name, scope, scopeId, source, description, intent, signatureJson,
+          argsJsonSchema, contentHash, isScratch, typeChecked, fsMode, createdByAgentId, createdAt, updatedAt
+        )
+        VALUES (?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?)
+        RETURNING *`,
+      )
+      .get(
+        id,
+        args.name,
+        args.scope,
+        scopeId,
+        args.source,
+        args.description,
+        args.intent,
+        args.signatureJson,
+        args.argsJsonSchema ?? null,
+        contentHash,
+        isScratch,
+        typeChecked,
+        fsMode,
+        args.agentId ?? null,
+        now,
+        now,
+      );
+
+    if (!row) throw new Error("Failed to insert script");
+
+    insertScriptVersion({
+      scriptId: row.id,
+      version: row.version,
+      source: row.source,
+      description: row.description,
+      intent: row.intent,
+      signatureJson: row.signatureJson,
+      contentHash: row.contentHash,
+      changedByAgentId: args.agentId ?? null,
+      changeReason: args.changeReason ?? "Initial creation",
+    });
+
+    return rowToScript(row);
+  });
+
+  return txn();
+}
+
+/**
+ * Scratch saves skip embedding; they become searchable only after explicit promotion via upsert
+ * OR after a `scripts reembed` pass. Explicit upserts embed synchronously so search is
+ * immediately consistent for authored/promoted scripts.
+ */
+export async function upsertScriptByName(args: ScriptWriteArgs): Promise<UpsertScriptResult> {
+  const existing = getScript(args);
+  if (!existing) {
+    const script = insertScript(args);
+    if (!script.isScratch) {
+      await embedScript(script);
+    }
+    return {
+      script,
+      isNew: true,
+      contentDeduped: false,
+    };
+  }
+
+  const contentHash = computeContentHash(args.source);
+  if (existing.contentHash === contentHash) {
+    const fsMode = args.fsMode ?? existing.fsMode;
+    const isScratch = args.isScratch ?? existing.isScratch;
+    const typeChecked = args.typeChecked ?? existing.typeChecked;
+    const argsJsonSchema =
+      args.argsJsonSchema !== undefined ? args.argsJsonSchema : existing.argsJsonSchema;
+    const trackedMetadataChanged =
+      args.description !== existing.description ||
+      args.intent !== existing.intent ||
+      args.signatureJson !== existing.signatureJson ||
+      argsJsonSchema !== existing.argsJsonSchema;
+    const promotedFromScratch = existing.isScratch && !isScratch;
+    if (
+      fsMode !== existing.fsMode ||
+      isScratch !== existing.isScratch ||
+      typeChecked !== existing.typeChecked ||
+      trackedMetadataChanged
+    ) {
+      const row = getDb()
+        .prepare<
+          ScriptRow,
+          [string, string, string, string | null, number, number, string, string, string]
+        >(
+          `UPDATE scripts
+          SET description = ?, intent = ?, signatureJson = ?, argsJsonSchema = ?,
+            isScratch = ?, typeChecked = ?, fsMode = ?, updatedAt = ?
+          WHERE id = ?
+          RETURNING *`,
+        )
+        .get(
+          args.description,
+          args.intent,
+          args.signatureJson,
+          argsJsonSchema ?? null,
+          isScratch ? 1 : 0,
+          typeChecked ? 1 : 0,
+          fsMode,
+          new Date().toISOString(),
+          existing.id,
+        );
+
+      if (!row) throw new Error("Failed to update script metadata");
+      const script = rowToScript(row);
+      if (!script.isScratch && (trackedMetadataChanged || promotedFromScratch)) {
+        await embedScript(script);
+      }
+      return {
+        script,
+        isNew: false,
+        contentDeduped: true,
+      };
+    }
+
+    return {
+      script: existing,
+      isNew: false,
+      contentDeduped: true,
+    };
+  }
+
+  const now = new Date().toISOString();
+  const newVersion = existing.version + 1;
+  const fsMode = args.fsMode ?? existing.fsMode;
+  const isScratch = args.isScratch ?? existing.isScratch;
+  const typeChecked = args.typeChecked ?? existing.typeChecked;
+  const argsJsonSchema =
+    args.argsJsonSchema !== undefined ? args.argsJsonSchema : existing.argsJsonSchema;
+
+  const txn = getDb().transaction(() => {
+    const row = getDb()
+      .prepare<
+        ScriptRow,
+        [
+          string,
+          string,
+          string,
+          string,
+          string | null,
+          string,
+          number,
+          number,
+          number,
+          string,
+          string,
+          string,
+        ]
+      >(
+        `UPDATE scripts
+        SET source = ?, description = ?, intent = ?, signatureJson = ?, argsJsonSchema = ?,
+          contentHash = ?, version = ?, isScratch = ?, typeChecked = ?, fsMode = ?, updatedAt = ?
+        WHERE id = ?
+        RETURNING *`,
+      )
+      .get(
+        args.source,
+        args.description,
+        args.intent,
+        args.signatureJson,
+        argsJsonSchema ?? null,
+        contentHash,
+        newVersion,
+        isScratch ? 1 : 0,
+        typeChecked ? 1 : 0,
+        fsMode,
+        now,
+        existing.id,
+      );
+
+    if (!row) throw new Error("Failed to update script");
+
+    insertScriptVersion({
+      scriptId: row.id,
+      version: row.version,
+      source: row.source,
+      description: row.description,
+      intent: row.intent,
+      signatureJson: row.signatureJson,
+      contentHash: row.contentHash,
+      changedByAgentId: args.agentId ?? null,
+      changeReason: args.changeReason ?? null,
+    });
+
+    return rowToScript(row);
+  });
+
+  const script = txn();
+  if (!script.isScratch) {
+    await embedScript(script);
+  }
+
+  return {
+    script,
+    isNew: false,
+    contentDeduped: false,
+  };
+}
+
+export function getScript(args: ScriptIdentity): ScriptRecord | null {
+  const scopeId = normalizeScopeId(args.scope, args.scopeId);
+  const row =
+    scopeId === null
+      ? getDb()
+          .prepare<ScriptRow, [string, ScriptScope]>(
+            "SELECT * FROM scripts WHERE name = ? AND scope = ? AND scopeId IS NULL",
+          )
+          .get(args.name, args.scope)
+      : getDb()
+          .prepare<ScriptRow, [string, ScriptScope, string]>(
+            "SELECT * FROM scripts WHERE name = ? AND scope = ? AND scopeId = ?",
+          )
+          .get(args.name, args.scope, scopeId);
+
+  return row ? rowToScript(row) : null;
+}
+
+export function getScriptVersion(args: {
+  scriptId: string;
+  version?: number;
+  contentHash?: string;
+}): ScriptVersionRecord | null {
+  if (args.version === undefined && args.contentHash === undefined) {
+    throw new Error("version or contentHash is required");
+  }
+
+  const row =
+    args.version !== undefined
+      ? getDb()
+          .prepare<ScriptVersionRow, [string, number]>(
+            "SELECT * FROM script_versions WHERE scriptId = ? AND version = ?",
+          )
+          .get(args.scriptId, args.version)
+      : getDb()
+          .prepare<ScriptVersionRow, [string, string]>(
+            "SELECT * FROM script_versions WHERE scriptId = ? AND contentHash = ? ORDER BY version DESC LIMIT 1",
+          )
+          .get(args.scriptId, args.contentHash as string);
+
+  return row ? rowToScriptVersion(row) : null;
+}
+
+export function listScripts(args?: {
+  scope?: ScriptScope;
+  scopeId?: string | null;
+  includeScratch?: boolean;
+}): ScriptRecord[] {
+  const conditions: string[] = [];
+  const params: (string | number | null)[] = [];
+
+  if (args?.scope) {
+    conditions.push("scope = ?");
+    params.push(args.scope);
+
+    if (args.scope === "global") {
+      conditions.push("scopeId IS NULL");
+    } else if (args.scopeId !== undefined) {
+      conditions.push("scopeId = ?");
+      params.push(normalizeScopeId(args.scope, args.scopeId));
+    }
+  } else if (args?.scopeId !== undefined) {
+    conditions.push("scopeId = ?");
+    params.push(args.scopeId ?? "");
+  }
+
+  if (!args?.includeScratch) {
+    conditions.push("isScratch = 0");
+  }
+
+  const whereClause = conditions.length > 0 ? `WHERE ${conditions.join(" AND ")}` : "";
+  return getDb()
+    .prepare<ScriptRow, (string | number | null)[]>(
+      `SELECT * FROM scripts ${whereClause} ORDER BY scope ASC, scopeId ASC, name ASC`,
+    )
+    .all(...params)
+    .map(rowToScript);
+}
+
+export function deleteScript(args: ScriptIdentity): boolean {
+  const existing = getScript(args);
+  if (!existing) return false;
+
+  const result = getDb().run("DELETE FROM scripts WHERE id = ?", [existing.id]);
+  return result.changes > 0;
+}

package/src/be/scripts/embeddings.ts

@@ -0,0 +1,233 @@
+import type { ScriptRecord, ScriptScope } from "../../types";
+import { scrubSecrets } from "../../utils/secret-scrubber";
+import { getDb } from "../db";
+import { cosineSimilarity, deserializeEmbedding, serializeEmbedding } from "../embedding";
+import { getEmbeddingProvider } from "../memory";
+import type { EmbeddingProvider } from "../memory/types";
+
+type ScriptEmbeddingRow = {
+  scriptId: string;
+  embedding: Buffer;
+  embeddingModel: string;
+  embeddedText: string;
+  embeddedAt: string;
+};
+
+type ScriptEmbeddingCandidateRow = ScriptEmbeddingRow & {
+  id: string;
+  name: string;
+  scope: ScriptScope;
+  scopeId: string | null;
+  source: string;
+  description: string;
+  intent: string;
+  signatureJson: string;
+  argsJsonSchema: string | null;
+  contentHash: string;
+  version: number;
+  isScratch: number;
+  typeChecked: number;
+  fsMode: "none" | "workspace-rw";
+  createdByAgentId: string | null;
+  createdAt: string;
+  updatedAt: string;
+};
+
+export type ScriptSearchResult = {
+  script: ScriptRecord;
+  score: number;
+  semanticScore: number;
+  nameMatchBonus: number;
+};
+
+let providerOverride: EmbeddingProvider | null = null;
+
+function embeddingProvider(): EmbeddingProvider {
+  return providerOverride ?? getEmbeddingProvider();
+}
+
+export function setScriptEmbeddingProviderForTests(provider: EmbeddingProvider | null): void {
+  providerOverride = provider;
+}
+
+export function scriptEmbeddingText(script: ScriptRecord): string {
+  return scrubSecrets([script.description, script.intent, script.signatureJson].join("\n"));
+}
+
+function rowToScript(row: ScriptEmbeddingCandidateRow): ScriptRecord {
+  return {
+    id: row.id,
+    name: row.name,
+    scope: row.scope,
+    scopeId: row.scopeId ?? null,
+    source: row.source,
+    description: row.description,
+    intent: row.intent,
+    signatureJson: row.signatureJson,
+    argsJsonSchema: row.argsJsonSchema ?? null,
+    contentHash: row.contentHash,
+    version: row.version,
+    isScratch: row.isScratch === 1,
+    typeChecked: row.typeChecked === 1,
+    fsMode: row.fsMode,
+    createdByAgentId: row.createdByAgentId ?? null,
+    createdAt: row.createdAt,
+    updatedAt: row.updatedAt,
+  };
+}
+
+export async function embedScript(script: ScriptRecord): Promise<void> {
+  const text = scriptEmbeddingText(script);
+  const provider = embeddingProvider();
+  const embedding = await provider.embed(text);
+  if (!embedding) return;
+
+  getDb()
+    .prepare(
+      `INSERT INTO script_embeddings (
+        scriptId, embedding, embeddingModel, embeddedText, embeddedAt
+      )
+      VALUES (?, ?, ?, ?, ?)
+      ON CONFLICT(scriptId) DO UPDATE SET
+        embedding = excluded.embedding,
+        embeddingModel = excluded.embeddingModel,
+        embeddedText = excluded.embeddedText,
+        embeddedAt = excluded.embeddedAt`,
+    )
+    .run(script.id, serializeEmbedding(embedding), provider.name, text, new Date().toISOString());
+}
+
+function candidateRows(
+  scope?: ScriptScope,
+  scopeId?: string | null,
+): ScriptEmbeddingCandidateRow[] {
+  const params: string[] = [];
+  let where = "s.isScratch = 0";
+
+  if (scope === "global") {
+    where += " AND s.scope = 'global' AND s.scopeId IS NULL";
+  } else if (scope === "agent") {
+    where += " AND s.scope = 'agent' AND s.scopeId = ?";
+    params.push(scopeId ?? "");
+  } else if (scopeId) {
+    where +=
+      " AND ((s.scope = 'agent' AND s.scopeId = ?) OR (s.scope = 'global' AND s.scopeId IS NULL))";
+    params.push(scopeId);
+  } else {
+    where += " AND s.scope = 'global' AND s.scopeId IS NULL";
+  }
+
+  return getDb()
+    .prepare<ScriptEmbeddingCandidateRow, string[]>(
+      `SELECT
+        s.*,
+        e.scriptId,
+        e.embedding,
+        e.embeddingModel,
+        e.embeddedText,
+        e.embeddedAt
+      FROM script_embeddings e
+      JOIN scripts s ON s.id = e.scriptId
+      WHERE ${where}`,
+    )
+    .all(...params);
+}
+
+function scriptRows(scope?: ScriptScope, scopeId?: string | null): ScriptEmbeddingCandidateRow[] {
+  const params: string[] = [];
+  let where = "isScratch = 0";
+
+  if (scope === "global") {
+    where += " AND scope = 'global' AND scopeId IS NULL";
+  } else if (scope === "agent") {
+    where += " AND scope = 'agent' AND scopeId = ?";
+    params.push(scopeId ?? "");
+  } else if (scopeId) {
+    where += " AND ((scope = 'agent' AND scopeId = ?) OR (scope = 'global' AND scopeId IS NULL))";
+    params.push(scopeId);
+  } else {
+    where += " AND scope = 'global' AND scopeId IS NULL";
+  }
+
+  return getDb()
+    .prepare<ScriptEmbeddingCandidateRow, string[]>(
+      `SELECT *, NULL as scriptId, NULL as embedding, NULL as embeddingModel, NULL as embeddedText, NULL as embeddedAt FROM scripts WHERE ${where}`,
+    )
+    .all(...params);
+}
+
+function nameMatchBonus(script: ScriptRecord, query: string): number {
+  const trimmed = query.trim().toLowerCase();
+  if (!trimmed) return 0;
+  return script.name.toLowerCase().includes(trimmed) ? 1 : 0;
+}
+
+function lexicalFallback(args: {
+  query: string;
+  scope?: ScriptScope;
+  scopeId?: string | null;
+  limit?: number;
+}): ScriptSearchResult[] {
+  const query = args.query.trim().toLowerCase();
+  return scriptRows(args.scope, args.scopeId)
+    .map(rowToScript)
+    .filter((script) => {
+      if (!query) return true;
+      return [script.name, script.description, script.intent]
+        .join("\n")
+        .toLowerCase()
+        .includes(query);
+    })
+    .map((script) => {
+      const bonus = nameMatchBonus(script, args.query);
+      return {
+        script,
+        score: bonus || 0.5,
+        semanticScore: 0,
+        nameMatchBonus: bonus,
+      };
+    })
+    .sort((a, b) => b.score - a.score)
+    .slice(0, args.limit ?? 10);
+}
+
+export async function searchScripts(args: {
+  query: string;
+  scope?: ScriptScope;
+  scopeId?: string | null;
+  limit?: number;
+}): Promise<ScriptSearchResult[]> {
+  const provider = embeddingProvider();
+  const queryEmbedding = await provider.embed(args.query);
+  if (!queryEmbedding) return lexicalFallback(args);
+
+  const candidates = candidateRows(args.scope, args.scopeId);
+  if (candidates.length === 0) return lexicalFallback(args);
+
+  return candidates
+    .map((row) => {
+      const script = rowToScript(row);
+      const semanticScore = cosineSimilarity(queryEmbedding, deserializeEmbedding(row.embedding));
+      const bonus = nameMatchBonus(script, args.query);
+      return {
+        script,
+        score: 0.7 * semanticScore + 0.3 * bonus,
+        semanticScore,
+        nameMatchBonus: bonus,
+      };
+    })
+    .sort((a, b) => b.score - a.score)
+    .slice(0, args.limit ?? 10);
+}
+
+export async function reembedAllScripts(): Promise<void> {
+  const rows = getDb()
+    .prepare<ScriptEmbeddingCandidateRow, []>(
+      "SELECT *, NULL as scriptId, NULL as embedding, NULL as embeddingModel, NULL as embeddedText, NULL as embeddedAt FROM scripts WHERE isScratch = 0 ORDER BY updatedAt ASC",
+    )
+    .all();
+
+  for (const row of rows) {
+    await embedScript(rowToScript(row));
+  }
+}

package/src/be/scripts/extract-schema.ts

@@ -0,0 +1,55 @@
+/**
+ * Server-side helper: spawns a subprocess to extract the argsJsonSchema
+ * from a user script's `argsSchema` Zod export. Returns the JSON Schema
+ * serialized as a string, or null if the script has no argsSchema or
+ * if extraction fails.
+ *
+ * Extraction is best-effort and non-blocking — failures return null.
+ */
+
+const TIMEOUT_MS = 5_000;
+
+function extractorPath(): string {
+  return new URL("../../scripts-runtime/extract-args-schema.ts", import.meta.url).pathname;
+}
+
+export async function extractArgsJsonSchema(source: string): Promise<string | null> {
+  const tmpdir = `${process.env.TMPDIR ?? "/tmp"}/schema-extract-${crypto.randomUUID()}`;
+
+  try {
+    await Bun.$`mkdir -p ${tmpdir}`.quiet();
+
+    const sourceFile = `${tmpdir}/source.ts`;
+    const resultFile = `${tmpdir}/result.json`;
+    await Bun.write(sourceFile, source);
+
+    const proc = Bun.spawn(["bun", "run", extractorPath()], {
+      env: {
+        PATH: process.env.PATH ?? "/usr/bin:/bin",
+        HOME: process.env.HOME ?? "/tmp",
+        TMPDIR: tmpdir,
+        SWARM_SCHEMA_SOURCE_FILE: sourceFile,
+        SWARM_SCHEMA_RESULT_FILE: resultFile,
+        SWARM_SCHEMA_TMPDIR: tmpdir,
+      },
+      cwd: tmpdir,
+      stdout: "ignore",
+      stderr: "ignore",
+    });
+
+    const timeout = setTimeout(() => proc.kill(), TIMEOUT_MS);
+    const exitCode = await proc.exited.catch(() => 1);
+    clearTimeout(timeout);
+
+    if (exitCode !== 0) return null;
+
+    const result = await Bun.file(resultFile).text();
+    const parsed: unknown = JSON.parse(result);
+    if (parsed === null) return null;
+    return JSON.stringify(parsed);
+  } catch {
+    return null;
+  } finally {
+    await Bun.$`rm -rf ${tmpdir}`.quiet().nothrow();
+  }
+}

package/src/be/scripts/maintenance.ts

@@ -0,0 +1,9 @@
+import { reembedAllScripts } from "./embeddings";
+
+export async function runScriptsMaintenanceCommand(args: string[]): Promise<void> {
+  const [subcommand] = args;
+  if (subcommand !== "reembed") {
+    throw new Error("Unknown scripts command. Usage: scripts reembed");
+  }
+  await reembedAllScripts();
+}