apteva 0.4.16 → 0.4.18

package/src/db.ts

@@ -194,6 +194,29 @@ export interface SkillRow {
   updated_at: string;
 }
 
+// Subscription: maps trigger events to agents for routing
+export interface Subscription {
+  id: string;
+  trigger_slug: string;
+  trigger_instance_id: string | null;
+  agent_id: string;
+  enabled: boolean;
+  project_id: string | null;
+  created_at: string;
+  updated_at: string;
+}
+
+export interface SubscriptionRow {
+  id: string;
+  trigger_slug: string;
+  trigger_instance_id: string | null;
+  agent_id: string;
+  enabled: number;
+  project_id: string | null;
+  created_at: string;
+  updated_at: string;
+}
+
 export interface McpServerRow {
   id: string;
   name: string;
@@ -256,11 +279,21 @@ export function initDatabase(dataDir: string): Database {
 
   // Enable WAL mode for better concurrent access
   db.run("PRAGMA journal_mode = WAL");
+  db.run("PRAGMA busy_timeout = 5000");
   db.run("PRAGMA foreign_keys = ON");
 
   // Run migrations
   runMigrations();
 
+  // Auto-set instance_url from env if not already configured
+  const envInstanceUrl = process.env.INSTANCE_URL || process.env.PUBLIC_URL;
+  if (envInstanceUrl) {
+    const current = SettingsDB.get("instance_url");
+    if (!current) {
+      SettingsDB.set("instance_url", envInstanceUrl.replace(/\/+$/, ""));
+    }
+  }
+
   // Database initialized silently
   return db;
 }
@@ -685,6 +718,25 @@ function runMigrations() {
         CREATE INDEX IF NOT EXISTS idx_mcp_server_tools_server ON mcp_server_tools(server_id);
       `,
     },
+    {
+      name: "031_create_subscriptions",
+      sql: `
+        CREATE TABLE IF NOT EXISTS subscriptions (
+          id TEXT PRIMARY KEY,
+          trigger_slug TEXT NOT NULL,
+          trigger_instance_id TEXT,
+          agent_id TEXT NOT NULL,
+          enabled INTEGER NOT NULL DEFAULT 1,
+          project_id TEXT,
+          created_at TEXT DEFAULT CURRENT_TIMESTAMP,
+          updated_at TEXT DEFAULT CURRENT_TIMESTAMP,
+          FOREIGN KEY (agent_id) REFERENCES agents(id) ON DELETE CASCADE
+        );
+        CREATE INDEX IF NOT EXISTS idx_subscriptions_agent ON subscriptions(agent_id);
+        CREATE INDEX IF NOT EXISTS idx_subscriptions_trigger_slug ON subscriptions(trigger_slug);
+        CREATE INDEX IF NOT EXISTS idx_subscriptions_trigger_instance ON subscriptions(trigger_instance_id);
+      `,
+    },
     {
       name: "029_fix_provider_keys_unique_constraint",
       sql: `
@@ -723,8 +775,8 @@ function runMigrations() {
   for (const migration of migrations) {
     if (!applied.has(migration.name)) {
       try {
-        // Migration runs silently
-        db.run(migration.sql);
+        // Migration runs silently (exec supports multi-statement SQL)
+        db.exec(migration.sql);
         db.run("INSERT INTO migrations (name) VALUES (?)", [migration.name]);
       } catch (err) {
         // Log error but continue - some migrations may fail if partially applied
@@ -853,12 +905,13 @@ export const AgentDB = {
     return rows.map(rowToAgent);
   },
 
-  // Get running agents (for auto-restart)
+  // Get running agents
   findRunning(): Agent[] {
     const rows = db.query("SELECT * FROM agents WHERE status = 'running'").all() as AgentRow[];
     return rows.map(rowToAgent);
   },
 
+
   // Update agent
   update(id: string, updates: Partial<Omit<Agent, "id" | "created_at">>): Agent | null {
     const agent = this.findById(id);
@@ -907,7 +960,6 @@ export const AgentDB = {
       fields.push("project_id = ?");
       values.push(updates.project_id);
     }
-
     if (fields.length > 0) {
       fields.push("updated_at = ?");
       values.push(new Date().toISOString());
@@ -1076,8 +1128,12 @@ export const ProjectDB = {
     return this.findById(id);
   },
 
-  // Delete project (agents will have project_id set to NULL)
+  // Delete project with full cleanup
+  // FK constraints handle: agents, mcp_servers, skills (SET NULL), provider_keys (CASCADE)
+  // Manual cleanup: subscriptions, test_cases (no FK on project_id)
   delete(id: string): boolean {
+    db.run("UPDATE subscriptions SET project_id = NULL WHERE project_id = ?", [id]);
+    db.run("UPDATE test_cases SET project_id = NULL WHERE project_id = ?", [id]);
     const result = db.run("DELETE FROM projects WHERE id = ?", [id]);
     return result.changes > 0;
   },
@@ -1386,6 +1442,15 @@ export const McpServerDB = {
     return row ? rowToMcpServer(row) : null;
   },
 
+  findByIds(ids: string[]): Map<string, McpServer> {
+    if (ids.length === 0) return new Map();
+    const placeholders = ids.map(() => "?").join(",");
+    const rows = db.query(`SELECT * FROM mcp_servers WHERE id IN (${placeholders})`).all(...ids) as McpServerRow[];
+    const map = new Map<string, McpServer>();
+    for (const row of rows) map.set(row.id, rowToMcpServer(row));
+    return map;
+  },
+
   findAll(): McpServer[] {
     const rows = db.query("SELECT * FROM mcp_servers ORDER BY created_at DESC").all() as McpServerRow[];
     return rows.map(rowToMcpServer);
@@ -2388,6 +2453,15 @@ export const SkillDB = {
     return row ? rowToSkill(row) : null;
   },
 
+  findByIds(ids: string[]): Map<string, Skill> {
+    if (ids.length === 0) return new Map();
+    const placeholders = ids.map(() => "?").join(",");
+    const rows = db.query(`SELECT * FROM skills WHERE id IN (${placeholders})`).all(...ids) as SkillRow[];
+    const map = new Map<string, Skill>();
+    for (const row of rows) map.set(row.id, rowToSkill(row));
+    return map;
+  },
+
   // Find skill by name
   findByName(name: string): Skill | null {
     const row = db.query("SELECT * FROM skills WHERE name = ?").get(name) as SkillRow | null;
@@ -2503,12 +2577,6 @@ export const SkillDB = {
     return row.count;
   },
 
-  // Check if skill with name exists
-  exists(name: string): boolean {
-    const row = db.query("SELECT COUNT(*) as count FROM skills WHERE name = ?").get(name) as { count: number };
-    return row.count > 0;
-  },
-
   // Find skills by project (null = global only)
   findByProject(projectId: string | null): Skill[] {
     if (projectId === null) {
@@ -2575,6 +2643,89 @@ function rowToSkill(row: SkillRow): Skill {
   };
 }
 
+// Subscription row → Subscription
+function rowToSubscription(row: SubscriptionRow): Subscription {
+  return {
+    id: row.id,
+    trigger_slug: row.trigger_slug,
+    trigger_instance_id: row.trigger_instance_id,
+    agent_id: row.agent_id,
+    enabled: row.enabled === 1,
+    project_id: row.project_id,
+    created_at: row.created_at,
+    updated_at: row.updated_at,
+  };
+}
+
+export const SubscriptionDB = {
+  create(sub: Omit<Subscription, "id" | "created_at" | "updated_at">): Subscription {
+    const id = generateId();
+    const now = new Date().toISOString();
+    db.run(
+      `INSERT INTO subscriptions (id, trigger_slug, trigger_instance_id, agent_id, enabled, project_id, created_at, updated_at)
+       VALUES (?, ?, ?, ?, ?, ?, ?, ?)`,
+      [id, sub.trigger_slug, sub.trigger_instance_id || null, sub.agent_id, sub.enabled ? 1 : 0, sub.project_id || null, now, now]
+    );
+    return this.findById(id)!;
+  },
+
+  findById(id: string): Subscription | null {
+    const row = db.query("SELECT * FROM subscriptions WHERE id = ?").get(id) as SubscriptionRow | null;
+    return row ? rowToSubscription(row) : null;
+  },
+
+  findByTriggerInstanceId(instanceId: string): Subscription[] {
+    const rows = db.query("SELECT * FROM subscriptions WHERE trigger_instance_id = ?").all(instanceId) as SubscriptionRow[];
+    return rows.map(rowToSubscription);
+  },
+
+  findByTriggerSlug(slug: string): Subscription[] {
+    const rows = db.query("SELECT * FROM subscriptions WHERE trigger_slug = ?").all(slug) as SubscriptionRow[];
+    return rows.map(rowToSubscription);
+  },
+
+  findByAgentId(agentId: string): Subscription[] {
+    const rows = db.query("SELECT * FROM subscriptions WHERE agent_id = ?").all(agentId) as SubscriptionRow[];
+    return rows.map(rowToSubscription);
+  },
+
+  findAll(projectId?: string | null): Subscription[] {
+    if (projectId) {
+      const rows = db.query("SELECT * FROM subscriptions WHERE project_id = ? ORDER BY created_at DESC").all(projectId) as SubscriptionRow[];
+      return rows.map(rowToSubscription);
+    }
+    const rows = db.query("SELECT * FROM subscriptions ORDER BY created_at DESC").all() as SubscriptionRow[];
+    return rows.map(rowToSubscription);
+  },
+
+  update(id: string, updates: Partial<Pick<Subscription, "trigger_slug" | "trigger_instance_id" | "agent_id" | "enabled">>): Subscription | null {
+    const sub = this.findById(id);
+    if (!sub) return null;
+
+    const fields: string[] = [];
+    const values: (string | number | null)[] = [];
+
+    if (updates.trigger_slug !== undefined) { fields.push("trigger_slug = ?"); values.push(updates.trigger_slug); }
+    if (updates.trigger_instance_id !== undefined) { fields.push("trigger_instance_id = ?"); values.push(updates.trigger_instance_id || null); }
+    if (updates.agent_id !== undefined) { fields.push("agent_id = ?"); values.push(updates.agent_id); }
+    if (updates.enabled !== undefined) { fields.push("enabled = ?"); values.push(updates.enabled ? 1 : 0); }
+
+    if (fields.length === 0) return sub;
+
+    fields.push("updated_at = ?");
+    values.push(new Date().toISOString());
+    values.push(id);
+
+    db.run(`UPDATE subscriptions SET ${fields.join(", ")} WHERE id = ?`, values);
+    return this.findById(id);
+  },
+
+  delete(id: string): boolean {
+    const result = db.run("DELETE FROM subscriptions WHERE id = ?", [id]);
+    return result.changes > 0;
+  },
+};
+
 // Generate unique ID
 export function generateId(): string {
   return Math.random().toString(36).substring(2, 15);

package/src/mcp-platform.ts

@@ -346,6 +346,25 @@ After creating, assign to agents with assign_mcp_server_to_agent. HTTP servers w
       required: ["agent_id", "skill_id"],
     },
   },
+  {
+    name: "create_skill",
+    description: "Create a new skill. Skills are reusable instruction sets (markdown content) that give agents specialized capabilities. Provide a name, description, and the full instructions content (markdown). Optionally specify allowed MCP tools. If the user is working within a project, set project_id to scope the skill to that project.",
+    inputSchema: {
+      type: "object",
+      properties: {
+        name: { type: "string", description: "The skill name" },
+        description: { type: "string", description: "Short description of what the skill does" },
+        content: { type: "string", description: "Full skill instructions in markdown format" },
+        allowed_tools: {
+          type: "array",
+          items: { type: "string" },
+          description: "Optional list of MCP tool names this skill is allowed to use",
+        },
+        project_id: { type: "string", description: "Project ID to scope the skill to. Use the current project ID from context when the user is working within a project. Omit for a global skill." },
+      },
+      required: ["name", "description", "content"],
+    },
+  },
   {
     name: "delete_skill",
     description: "Delete a skill. It will be unassigned from all agents.",
@@ -824,6 +843,27 @@ async function executeTool(name: string, args: Record<string, any>): Promise<{ c
         return { content: [{ type: "text", text: `Removed skill from agent "${agent.name}". Restart the agent for changes to take effect.` }] };
       }
 
+      case "create_skill": {
+        if (!args.name || !args.description || !args.content) {
+          return { content: [{ type: "text", text: "name, description, and content are required" }], isError: true };
+        }
+        const newSkill = SkillDB.create({
+          name: args.name,
+          description: args.description,
+          content: args.content,
+          version: "1.0.0",
+          license: null,
+          compatibility: null,
+          metadata: {},
+          allowed_tools: args.allowed_tools || [],
+          source: "local",
+          source_url: null,
+          enabled: true,
+          project_id: args.project_id || null,
+        });
+        return { content: [{ type: "text", text: `Skill "${newSkill.name}" created (ID: ${newSkill.id}). You can now assign it to an agent with assign_skill_to_agent.` }] };
+      }
+
       case "delete_skill": {
         const skill = SkillDB.findById(args.skill_id);
         if (!skill) {
@@ -977,7 +1017,7 @@ You can manage:
 - AGENTS: Create, configure, start, stop, and delete AI agents. Each agent has a provider (LLM), model, system prompt, and optional features (memory, tasks, vision, MCP tools, files).
 - PROJECTS: Organize agents into projects for grouping.
 - MCP SERVERS: Tool integrations that give agents capabilities (web search, file access, APIs). Assign servers to agents.
-- SKILLS: Reusable instruction sets that specialize agent behavior. Assign skills to agents.
+- SKILLS: Reusable instruction sets that specialize agent behavior. Use create_skill to create new skills (pass project_id from context to scope to the current project), then assign them to agents. Use list_skills, get_skill, create_skill, toggle_skill, assign_skill_to_agent, unassign_skill_from_agent, delete_skill.
 - PROVIDERS: View which LLM providers have API keys configured.
 - TESTS: Create and run automated tests for agent workflows. Tests send a message to an agent, then an LLM judge evaluates the response against success criteria. Use list_tests, create_test, run_test, run_all_tests, get_test_results, delete_test.
 

package/src/routes/api/agent-utils.ts

@@ -2,7 +2,7 @@ import { spawn } from "bun";
 import { join } from "path";
 import { homedir } from "os";
 import { mkdirSync, existsSync, rmSync } from "fs";
-import { agentProcesses, agentsStarting, getBinaryPathForAgent, getBinaryStatus, BIN_DIR, telemetryBroadcaster, type TelemetryEvent } from "../../server";
+import { agentProcesses, agentsStarting, getBinaryPathForAgent, getBinaryStatus, BIN_DIR, telemetryBroadcaster, isShuttingDown, type TelemetryEvent } from "../../server";
 import { AgentDB, McpServerDB, SkillDB, TelemetryDB, generateId, getMultiAgentConfig, type Agent, type Project } from "../../db";
 import { ProviderKeys, PROVIDERS, type ProviderId } from "../../providers";
 import { binaryExists } from "../../binary";
@@ -520,8 +520,9 @@ export async function startAgentProcess(
     // Store process with port for tracking
     agentProcesses.set(agent.id, { proc, port });
 
-    // Detect unexpected process exits (crashes)
+    // Detect unexpected process exits (crashes) — but not during server shutdown
     proc.exited.then((code) => {
+      if (isShuttingDown()) return; // Don't update DB during shutdown — keeps status "running" for auto-restart
       if (agentProcesses.has(agent.id)) {
         agentProcesses.delete(agent.id);
         setAgentStatus(agent.id, "stopped", code === 0 ? "exited" : "crashed");
@@ -632,6 +633,41 @@ export function toApiAgent(agent: Agent) {
   };
 }
 
+// Batch transform: fetch all MCP servers + skills in 2 queries instead of N per agent
+export function toApiAgentsBatch(agents: Agent[]) {
+  // Collect all unique IDs
+  const allMcpIds = new Set<string>();
+  const allSkillIds = new Set<string>();
+  for (const agent of agents) {
+    for (const id of agent.mcp_servers || []) allMcpIds.add(id);
+    for (const id of agent.skills || []) allSkillIds.add(id);
+  }
+
+  // Batch load in 2 queries
+  const mcpMap = McpServerDB.findByIds([...allMcpIds]);
+  const skillMap = SkillDB.findByIds([...allSkillIds]);
+
+  return agents.map(agent => {
+    const mcpServerDetails = (agent.mcp_servers || [])
+      .map(id => mcpMap.get(id))
+      .filter((s): s is NonNullable<typeof s> => !!s)
+      .map(s => ({ id: s.id, name: s.name, type: s.type, status: s.status, port: s.port, url: s.url }));
+
+    const skillDetails = (agent.skills || [])
+      .map(id => skillMap.get(id))
+      .filter((s): s is NonNullable<typeof s> => !!s)
+      .map(s => ({ id: s.id, name: s.name, description: s.description, version: s.version, enabled: s.enabled }));
+
+    return {
+      id: agent.id, name: agent.name, model: agent.model, provider: agent.provider,
+      systemPrompt: agent.system_prompt, status: agent.status, port: agent.port,
+      features: agent.features, mcpServers: agent.mcp_servers, mcpServerDetails,
+      skills: agent.skills, skillDetails, projectId: agent.project_id,
+      createdAt: agent.created_at, updatedAt: agent.updated_at,
+    };
+  });
+}
+
 // Transform DB project to API response format
 export function toApiProject(project: Project) {
   return {

package/src/routes/api/agents.ts

@@ -3,7 +3,7 @@ import { join } from "path";
 import { json, isDev } from "./helpers";
 import {
   agentFetch,
-  toApiAgent,
+  toApiAgent, toApiAgentsBatch,
   checkPortFree,
   startAgentProcess,
   buildAgentConfig,
@@ -30,7 +30,7 @@ export async function handleAgentRoutes(
   // GET /api/agents - List all agents (excludes meta agent)
   if (path === "/api/agents" && method === "GET") {
     const agents = AgentDB.findAll().filter(a => a.id !== META_AGENT_ID);
-    return json({ agents: agents.map(toApiAgent) });
+    return json({ agents: toApiAgentsBatch(agents) });
   }
 
   // POST /api/agents - Create a new agent
@@ -345,6 +345,69 @@ export async function handleAgentRoutes(
     }
   }
 
+  // ==================== WEBHOOK ENDPOINT ====================
+
+  // POST /api/agents/:id/webhook - Receive external trigger events and forward to agent chat
+  const webhookMatch = path.match(/^\/api\/agents\/([^/]+)\/webhook$/);
+  if (webhookMatch && method === "POST") {
+    const agent = AgentDB.findById(webhookMatch[1]);
+    if (!agent) {
+      return json({ error: "Agent not found" }, 404);
+    }
+
+    if (agent.status !== "running" || !agent.port) {
+      return json({ error: "Agent is not running" }, 400);
+    }
+
+    try {
+      const body = await req.json();
+
+      // Format the webhook payload as a chat message
+      const triggerSlug = body.trigger_name || body.type || "unknown_trigger";
+      const eventPayload = body.payload || body.data || body;
+
+      const triggerName = String(triggerSlug).replace(/_/g, " ");
+      const message = [
+        `[Trigger: ${triggerName}]`,
+        "",
+        "```json",
+        JSON.stringify(eventPayload, null, 2),
+        "```",
+        "",
+        "Process this event and take appropriate action.",
+      ].join("\n");
+
+      // Forward to agent's /chat endpoint
+      const response = await agentFetch(agent.id, agent.port, "/chat", {
+        method: "POST",
+        headers: { "Content-Type": "application/json" },
+        body: JSON.stringify({ message }),
+      });
+
+      // Consume the streaming response (we don't need the agent's reply)
+      if (response.body) {
+        try {
+          const reader = response.body.getReader();
+          while (true) {
+            const { done } = await reader.read();
+            if (done) break;
+          }
+        } catch {
+          // Ignore read errors
+        }
+      }
+
+      if (!response.ok) {
+        return json({ error: "Agent failed to process webhook" }, 502);
+      }
+
+      return json({ received: true, agent_id: agent.id, trigger: triggerSlug });
+    } catch (err) {
+      console.error(`Webhook proxy error for agent ${webhookMatch[1]}:`, err);
+      return json({ error: `Failed to process webhook: ${err}` }, 500);
+    }
+  }
+
   // ==================== THREAD & MESSAGE PROXY ====================
 
   // GET/POST /api/agents/:id/threads

package/src/routes/api/projects.ts

@@ -1,6 +1,7 @@
 import { json } from "./helpers";
 import { AgentDB, ProjectDB, type Project } from "../../db";
-import { toApiAgent, toApiProject } from "./agent-utils";
+import { toApiAgent, toApiAgentsBatch, toApiProject, setAgentStatus } from "./agent-utils";
+import { agentProcesses } from "../../server";
 
 export async function handleProjectRoutes(
   req: Request,
@@ -54,7 +55,7 @@ export async function handleProjectRoutes(
     const agents = AgentDB.findByProject(project.id);
     return json({
       project: toApiProject(project),
-      agents: agents.map(toApiAgent),
+      agents: toApiAgentsBatch(agents),
     });
   }
 
@@ -87,6 +88,22 @@ export async function handleProjectRoutes(
       return json({ error: "Project not found" }, 404);
     }
 
+    // Stop any running agents in this project first
+    const projectAgents = AgentDB.findByProject(projectMatch[1]);
+    for (const agent of projectAgents) {
+      if (agent.status === "running") {
+        const entry = agentProcesses.get(agent.id);
+        if (entry) {
+          try {
+            await fetch(`http://localhost:${entry.port}/shutdown`, { method: "POST", signal: AbortSignal.timeout(1000) }).catch(() => {});
+            entry.proc.kill();
+          } catch {}
+          agentProcesses.delete(agent.id);
+        }
+        setAgentStatus(agent.id, "stopped", "project_deleted");
+      }
+    }
+
     ProjectDB.delete(projectMatch[1]);
     return json({ success: true });
   }

package/src/routes/api/system.ts

@@ -139,17 +139,21 @@ export async function handleSystemRoutes(
 
     const allTasks: any[] = [];
 
-    for (const agent of runningAgents) {
-      const data = await fetchFromAgent(agent.id, agent.port!, `/tasks?status=${status}`);
-      if (data?.tasks) {
-        // Add agent info to each task
-        for (const task of data.tasks) {
-          allTasks.push({
-            ...task,
-            agentId: agent.id,
-            agentName: agent.name,
-          });
+    // Fetch tasks from all agents in parallel
+    const results = await Promise.all(
+      runningAgents.map(async (agent) => {
+        try {
+          const data = await fetchFromAgent(agent.id, agent.port!, `/tasks?status=${status}`);
+          return { agent, tasks: data?.tasks || [] };
+        } catch {
+          return { agent, tasks: [] };
         }
+      })
+    );
+
+    for (const { agent, tasks } of results) {
+      for (const task of tasks) {
+        allTasks.push({ ...task, agentId: agent.id, agentName: agent.name });
       }
     }
 
@@ -191,8 +195,18 @@ export async function handleSystemRoutes(
     let completedTasks = 0;
     let runningTasks = 0;
 
-    for (const agent of runningAgents) {
-      const data = await fetchFromAgent(agent.id, agent.port!, "/tasks?status=all");
+    // Fetch task stats from all agents in parallel
+    const taskResults = await Promise.all(
+      runningAgents.map(async (agent) => {
+        try {
+          return await fetchFromAgent(agent.id, agent.port!, "/tasks?status=all");
+        } catch {
+          return null;
+        }
+      })
+    );
+
+    for (const data of taskResults) {
       if (data?.tasks) {
         totalTasks += data.tasks.length;
         for (const task of data.tasks) {