@desplega.ai/agent-swarm 1.51.2 → 1.52.1

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/migrations/runner.ts

@@ -129,7 +129,7 @@ export function runMigrations(db: Database): void {
     const initialMigration = migrations.find((m) => m.version === 1);
     if (initialMigration) {
       if (shouldBootstrapInitialMigration(db)) {
-        console.log("[migrations] Existing database detected — bootstrapping migration tracking");
+        console.debug("[migrations] Existing database detected — bootstrapping migration tracking");
         db.run(
           "INSERT INTO _migrations (version, name, applied_at, checksum) VALUES (?, ?, ?, ?)",
           [
@@ -145,7 +145,7 @@ export function runMigrations(db: Database): void {
           checksum: initialMigration.checksum,
         });
       } else {
-        console.log(
+        console.warn(
           "[migrations] Existing database appears incomplete — applying 001_initial migration",
         );
       }
@@ -169,7 +169,7 @@ export function runMigrations(db: Database): void {
     }
 
     // Apply migration in a transaction
-    console.log(`[migrations] Applying: ${migration.name}`);
+    console.debug(`[migrations] Applying: ${migration.name}`);
     const start = performance.now();
 
     db.transaction(() => {
@@ -183,6 +183,6 @@ export function runMigrations(db: Database): void {
     })();
 
     const elapsed = (performance.now() - start).toFixed(1);
-    console.log(`[migrations] Applied: ${migration.name} (${elapsed}ms)`);
+    console.debug(`[migrations] Applied: ${migration.name} (${elapsed}ms)`);
   }
 }

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 };
+}