@desplega.ai/agent-swarm 1.49.0 → 1.52.0

package/src/be/migrations/014_prompt_templates.sql

@@ -0,0 +1,33 @@
+-- 013_prompt_templates.sql
+-- Prompt Template Registry: per-event customizable prompt templates with scope resolution,
+-- three-state behavior, wildcard matching, and version history.
+
+CREATE TABLE IF NOT EXISTS prompt_templates (
+    id TEXT PRIMARY KEY,
+    eventType TEXT NOT NULL,
+    scope TEXT NOT NULL CHECK(scope IN ('global', 'agent', 'repo')),
+    scopeId TEXT,
+    state TEXT NOT NULL DEFAULT 'enabled' CHECK(state IN ('enabled', 'default_prompt_fallback', 'skip_event')),
+    body TEXT NOT NULL,
+    isDefault INTEGER NOT NULL DEFAULT 0,
+    version INTEGER NOT NULL DEFAULT 1,
+    createdBy TEXT,
+    createdAt TEXT NOT NULL,
+    updatedAt TEXT NOT NULL,
+    UNIQUE(eventType, scope, scopeId)
+);
+
+CREATE TABLE IF NOT EXISTS prompt_template_history (
+    id TEXT PRIMARY KEY,
+    templateId TEXT NOT NULL,
+    version INTEGER NOT NULL,
+    body TEXT NOT NULL,
+    state TEXT NOT NULL,
+    changedBy TEXT,
+    changedAt TEXT NOT NULL,
+    changeReason TEXT
+);
+
+CREATE INDEX IF NOT EXISTS idx_prompt_templates_event_type ON prompt_templates(eventType);
+CREATE INDEX IF NOT EXISTS idx_prompt_templates_scope ON prompt_templates(scope, scopeId);
+CREATE INDEX IF NOT EXISTS idx_prompt_template_history_template ON prompt_template_history(templateId);

package/src/be/migrations/015_workflow_workspace.sql

@@ -0,0 +1,3 @@
+-- Add optional workspace fields to workflows
+ALTER TABLE workflows ADD COLUMN dir TEXT;
+ALTER TABLE workflows ADD COLUMN vcs_repo TEXT;

package/src/be/migrations/016_active_session_runner_session.sql

@@ -0,0 +1,4 @@
+-- Add runnerSessionId and providerSessionId to active_sessions
+-- for correlating session logs with pool tasks
+ALTER TABLE active_sessions ADD COLUMN runnerSessionId TEXT;
+ALTER TABLE active_sessions ADD COLUMN providerSessionId TEXT;

package/src/be/migrations/017_channel_activity_cursors.sql

@@ -0,0 +1,6 @@
+-- Track last-seen Slack message per channel for channel_activity poll trigger
+CREATE TABLE IF NOT EXISTS channel_activity_cursors (
+  channelId TEXT PRIMARY KEY,
+  lastSeenTs TEXT NOT NULL,
+  updatedAt TEXT NOT NULL DEFAULT (datetime('now'))
+);

package/src/be/migrations/018_fix_seed_double_version.sql

@@ -0,0 +1,30 @@
+-- Fix: template seeding created a spurious version 2 ("Reset to default") for every
+-- seeded template because upsertPromptTemplate hardcoded isDefault=0, requiring
+-- an immediate resetPromptTemplateToDefault call to flip it.
+
+-- Delete spurious "Reset to default" history entries created by the two-step seed.
+-- These are version=2 entries where version=1 for the same template has identical body.
+DELETE FROM prompt_template_history
+WHERE version = 2
+  AND changeReason = 'Reset to default'
+  AND templateId IN (
+    SELECT h2.templateId
+    FROM prompt_template_history h2
+    JOIN prompt_template_history h1
+      ON h1.templateId = h2.templateId
+      AND h1.version = 1
+      AND h1.changeReason = 'Seeded from code registry'
+      AND h1.body = h2.body
+    WHERE h2.version = 2
+      AND h2.changeReason = 'Reset to default'
+  );
+
+-- Reset version back to 1 for templates that are currently at version=2
+-- and only have version=1 history remaining (the spurious v2 was just deleted).
+UPDATE prompt_templates
+SET version = 1
+WHERE version = 2
+  AND isDefault = 1
+  AND id NOT IN (
+    SELECT templateId FROM prompt_template_history WHERE version = 2
+  );

package/src/be/migrations/019_skills.sql

@@ -0,0 +1,65 @@
+-- Skills table: stores skill definitions
+CREATE TABLE IF NOT EXISTS skills (
+  id TEXT PRIMARY KEY,
+  name TEXT NOT NULL,
+  description TEXT NOT NULL,
+  content TEXT NOT NULL DEFAULT '',
+
+  -- Type & ownership
+  type TEXT NOT NULL DEFAULT 'personal'
+    CHECK (type IN ('remote', 'personal')),
+  scope TEXT NOT NULL DEFAULT 'agent'
+    CHECK (scope IN ('global', 'swarm', 'agent')),
+  ownerAgentId TEXT,
+
+  -- Remote skill metadata
+  sourceUrl TEXT,
+  sourceRepo TEXT,
+  sourcePath TEXT,
+  sourceBranch TEXT DEFAULT 'main',
+  sourceHash TEXT,
+  isComplex INTEGER DEFAULT 0,
+
+  -- Parsed frontmatter cache (denormalized)
+  allowedTools TEXT,
+  model TEXT,
+  effort TEXT,
+  context TEXT,
+  agent TEXT,
+  disableModelInvocation INTEGER DEFAULT 0,
+  userInvocable INTEGER DEFAULT 1,
+
+  -- Metadata
+  version INTEGER NOT NULL DEFAULT 1,
+  isEnabled INTEGER NOT NULL DEFAULT 1,
+
+  createdAt TEXT NOT NULL,
+  lastUpdatedAt TEXT NOT NULL,
+  lastFetchedAt TEXT,
+
+  FOREIGN KEY (ownerAgentId) REFERENCES agents(id)
+);
+
+-- Unique constraint: name must be unique within scope+owner combination
+CREATE UNIQUE INDEX IF NOT EXISTS idx_skills_name_scope
+  ON skills(name, scope, COALESCE(ownerAgentId, ''));
+
+CREATE INDEX IF NOT EXISTS idx_skills_type ON skills(type);
+CREATE INDEX IF NOT EXISTS idx_skills_scope ON skills(scope);
+CREATE INDEX IF NOT EXISTS idx_skills_owner ON skills(ownerAgentId);
+
+-- Agent-skill junction table
+CREATE TABLE IF NOT EXISTS agent_skills (
+  id TEXT PRIMARY KEY,
+  agentId TEXT NOT NULL,
+  skillId TEXT NOT NULL,
+  isActive INTEGER NOT NULL DEFAULT 1,
+  installedAt TEXT NOT NULL,
+
+  FOREIGN KEY (agentId) REFERENCES agents(id),
+  FOREIGN KEY (skillId) REFERENCES skills(id) ON DELETE CASCADE,
+  UNIQUE(agentId, skillId)
+);
+
+CREATE INDEX IF NOT EXISTS idx_agent_skills_agent ON agent_skills(agentId);
+CREATE INDEX IF NOT EXISTS idx_agent_skills_skill ON agent_skills(skillId);

package/src/be/migrations/020_approval_requests.sql

@@ -0,0 +1,41 @@
+-- 019_approval_requests.sql
+-- Human-in-the-Loop approval request system for workflow nodes and agent tools
+
+CREATE TABLE IF NOT EXISTS approval_requests (
+  id TEXT PRIMARY KEY,                    -- UUID
+  title TEXT NOT NULL,                    -- Display title for the request
+  questions JSONB NOT NULL,              -- Array of Question objects
+
+  -- Source context (one of these pairs will be set)
+  workflowRunId TEXT,                    -- FK → workflow_runs.id (if from workflow)
+  workflowRunStepId TEXT,               -- FK → workflow_run_steps.id (if from workflow)
+  sourceTaskId TEXT,                     -- FK → agent_tasks.id (if from agent tool)
+
+  -- Approver policy
+  approvers JSONB NOT NULL,             -- { users: [...], roles: [...], policy: "any"|"all"|{min:N} }
+
+  -- State
+  status TEXT NOT NULL DEFAULT 'pending' CHECK (status IN ('pending', 'approved', 'rejected', 'timeout')),
+  responses JSONB,                      -- Keyed by question ID
+  resolvedBy TEXT,                      -- user ID of who responded
+  resolvedAt DATETIME,                  -- when resolved
+
+  -- Timeout
+  timeoutSeconds INTEGER,              -- NULL = no timeout
+  expiresAt DATETIME,                  -- computed: createdAt + timeoutSeconds
+
+  -- Notifications sent
+  notificationChannels JSONB,          -- [{ channel: "slack", target: "...", messageTs: "..." }]
+
+  -- Metadata
+  createdAt DATETIME DEFAULT CURRENT_TIMESTAMP,
+  updatedAt DATETIME DEFAULT CURRENT_TIMESTAMP
+);
+
+-- For the history UI
+CREATE INDEX IF NOT EXISTS idx_approval_requests_status ON approval_requests(status);
+CREATE INDEX IF NOT EXISTS idx_approval_requests_created ON approval_requests(createdAt DESC);
+CREATE INDEX IF NOT EXISTS idx_approval_requests_workflow ON approval_requests(workflowRunId);
+CREATE INDEX IF NOT EXISTS idx_approval_requests_task ON approval_requests(sourceTaskId);
+-- For recovery: find pending requests that may have expired during downtime
+CREATE INDEX IF NOT EXISTS idx_approval_requests_expires ON approval_requests(expiresAt) WHERE status = 'pending';

package/src/be/seed.ts

@@ -0,0 +1,62 @@
+/**
+ * Seed default prompt templates into the DB from the in-memory code registry.
+ *
+ * Called from initDb() after migrations run. Ensures every registered
+ * EventTemplateDefinition has a corresponding global default in the
+ * prompt_templates table.
+ */
+
+import { getAllTemplateDefinitions } from "../prompts/registry";
+import { getPromptTemplates, resetPromptTemplateToDefault, upsertPromptTemplate } from "./db";
+
+// Side-effect imports: register ALL template definitions so they're seeded on API startup.
+// Webhook handler templates (github, gitlab, etc.) are loaded transitively by the API server's
+// handler imports, but runner/session templates are only loaded by the worker. Importing them
+// here ensures all templates are available for the render endpoint and seeded to the DB.
+import "../prompts/session-templates";
+import "../commands/templates";
+import "../tools/templates";
+
+/**
+ * Seed default templates into the DB.
+ *
+ * For each registered EventTemplateDefinition:
+ * - If no global record exists at all, insert one as default (isDefault=true, state=enabled)
+ * - If a global default (isDefault=true) exists and its body differs from code, update it
+ * - Never touch records where isDefault=false (user customizations)
+ */
+export function seedDefaultTemplates(): void {
+  const definitions = getAllTemplateDefinitions();
+
+  if (definitions.length === 0) {
+    return; // No templates registered yet — expected during early phases
+  }
+
+  for (const def of definitions) {
+    // Look for ALL existing global records for this eventType (both default and customized)
+    const allGlobal = getPromptTemplates({
+      eventType: def.eventType,
+      scope: "global",
+    });
+
+    const globalRecord = allGlobal.find((t) => t.scopeId === null);
+
+    if (!globalRecord) {
+      // No global record at all — seed one with isDefault=true directly.
+      upsertPromptTemplate({
+        eventType: def.eventType,
+        scope: "global",
+        body: def.defaultBody,
+        createdBy: "system",
+        changeReason: "Seeded from code registry",
+        isDefault: true,
+      });
+    } else if (globalRecord.isDefault && globalRecord.body !== def.defaultBody) {
+      // Global default exists but body has drifted from code — update it.
+      // Only update if the record is still marked as default (not user-customized).
+      resetPromptTemplateToDefault(globalRecord.id, def.defaultBody);
+    }
+    // If record exists with isDefault=false (user customization): leave it alone
+    // If record exists with isDefault=true and body matches: leave it alone
+  }
+}

package/src/be/skill-parser.ts

@@ -0,0 +1,70 @@
+/**
+ * Parses SKILL.md content (YAML frontmatter + markdown body).
+ */
+
+export interface ParsedSkill {
+  name: string;
+  description: string;
+  allowedTools?: string;
+  model?: string;
+  effort?: string;
+  context?: string;
+  agent?: string;
+  disableModelInvocation?: boolean;
+  userInvocable?: boolean;
+  body: string;
+}
+
+/**
+ * Parse SKILL.md content into structured metadata + body.
+ * Frontmatter is delimited by `---` lines at the start.
+ */
+export function parseSkillContent(content: string): ParsedSkill {
+  const trimmed = content.trim();
+
+  if (!trimmed.startsWith("---")) {
+    throw new Error("Skill content must start with YAML frontmatter (---). No frontmatter found.");
+  }
+
+  const secondDelimiter = trimmed.indexOf("---", 3);
+  if (secondDelimiter === -1) {
+    throw new Error("Skill content has unterminated frontmatter. Missing closing ---.");
+  }
+
+  const frontmatterRaw = trimmed.slice(3, secondDelimiter).trim();
+  const body = trimmed.slice(secondDelimiter + 3).trim();
+
+  // Parse simple YAML key-value pairs
+  const metadata: Record<string, string> = {};
+  for (const line of frontmatterRaw.split("\n")) {
+    const colonIdx = line.indexOf(":");
+    if (colonIdx === -1) continue;
+    const key = line.slice(0, colonIdx).trim();
+    const value = line.slice(colonIdx + 1).trim();
+    if (key && value) {
+      metadata[key] = value;
+    }
+  }
+
+  // Validate required fields
+  if (!metadata.name) {
+    throw new Error('Skill frontmatter is missing required field: "name"');
+  }
+  if (!metadata.description) {
+    throw new Error('Skill frontmatter is missing required field: "description"');
+  }
+
+  return {
+    name: metadata.name,
+    description: metadata.description,
+    allowedTools: metadata["allowed-tools"] || undefined,
+    model: metadata.model || undefined,
+    effort: metadata.effort || undefined,
+    context: metadata.context || undefined,
+    agent: metadata.agent || undefined,
+    disableModelInvocation: metadata["disable-model-invocation"] === "true" ? true : undefined,
+    userInvocable:
+      metadata["user-invocable"] !== undefined ? metadata["user-invocable"] !== "false" : undefined,
+    body,
+  };
+}

package/src/be/skill-sync.ts

@@ -0,0 +1,106 @@
+/**
+ * Filesystem sync for skills.
+ *
+ * Writes installed skills to ~/.claude/skills/<name>/SKILL.md (and optionally
+ * ~/.pi/agent/skills/<name>/SKILL.md) so Claude Code and Pi discover them
+ * natively.
+ *
+ * This runs on the API side — workers call it via POST /api/skills/sync-filesystem.
+ */
+
+import { existsSync, mkdirSync, readdirSync, rmSync, writeFileSync } from "node:fs";
+import { homedir } from "node:os";
+import { join } from "node:path";
+import { getAgentSkills } from "./db";
+
+export interface SkillSyncResult {
+  synced: number;
+  removed: number;
+  errors: string[];
+}
+
+/**
+ * Sync agent's installed skills to the filesystem.
+ *
+ * For simple skills (content in DB): writes SKILL.md to ~/.claude/skills/<name>/
+ * For complex skills (isComplex=true): skipped here (handled by npx in entrypoint)
+ */
+export function syncSkillsToFilesystem(
+  agentId: string,
+  harnessType: "claude" | "pi" | "both" = "both",
+  homeOverride?: string,
+): SkillSyncResult {
+  const skills = getAgentSkills(agentId);
+  const home = homeOverride ?? homedir();
+  const errors: string[] = [];
+  let synced = 0;
+
+  // Directories to write to
+  const skillDirs: string[] = [];
+  if (harnessType === "claude" || harnessType === "both") {
+    skillDirs.push(join(home, ".claude", "skills"));
+  }
+  if (harnessType === "pi" || harnessType === "both") {
+    skillDirs.push(join(home, ".pi", "agent", "skills"));
+  }
+
+  // Ensure base dirs exist
+  for (const dir of skillDirs) {
+    mkdirSync(dir, { recursive: true });
+  }
+
+  // Track which skill names we write (for cleanup)
+  const writtenNames = new Set<string>();
+
+  for (const skill of skills) {
+    if (!skill.isActive || !skill.isEnabled) continue;
+    if (skill.isComplex) continue; // Complex skills handled by npx
+    if (!skill.content) continue;
+
+    // Sanitize skill name to prevent path traversal (strip /, .., and non-safe chars)
+    const safeName = skill.name.replace(/[^a-zA-Z0-9_-]/g, "_");
+    if (!safeName) continue;
+
+    writtenNames.add(safeName);
+
+    for (const baseDir of skillDirs) {
+      const skillDir = join(baseDir, safeName);
+      const skillFile = join(skillDir, "SKILL.md");
+
+      try {
+        mkdirSync(skillDir, { recursive: true });
+        writeFileSync(skillFile, skill.content, "utf-8");
+        synced++;
+      } catch (err) {
+        errors.push(
+          `${skill.name} -> ${skillDir}: ${err instanceof Error ? err.message : "Unknown error"}`,
+        );
+      }
+    }
+  }
+
+  // Cleanup: remove skill directories that are no longer installed
+  let removed = 0;
+  for (const baseDir of skillDirs) {
+    if (!existsSync(baseDir)) continue;
+
+    try {
+      const existing = readdirSync(baseDir, { withFileTypes: true });
+      for (const entry of existing) {
+        if (entry.isDirectory() && !writtenNames.has(entry.name)) {
+          const skillDir = join(baseDir, entry.name);
+          try {
+            rmSync(skillDir, { recursive: true, force: true });
+            removed++;
+          } catch {
+            // Non-fatal — skip cleanup errors
+          }
+        }
+      }
+    } catch {
+      // Non-fatal — skip if we can't read the directory
+    }
+  }
+
+  return { synced, removed, errors };
+}