apteva 0.4.20 → 0.4.29

package/src/routes/api/agents.ts

@@ -110,20 +110,47 @@ export async function handleAgentRoutes(
 
       const updated = AgentDB.update(agentMatch[1], updates);
 
-      // If agent is running, push the new config and skills
+      // If agent is running, handle config update
       if (updated && updated.status === "running" && updated.port) {
-        const providerKey = ProviderKeys.getDecrypted(updated.provider);
-        if (providerKey) {
-          const config = buildAgentConfig(updated, providerKey);
-          const configResult = await pushConfigToAgent(updated.id, updated.port, config);
-          if (!configResult.success) {
-            console.error(`Failed to push config to running agent: ${configResult.error}`);
+        const providerChanged = body.provider !== undefined && body.provider !== agent.provider;
+
+        if (providerChanged) {
+          // Provider changed — must restart to get new API key in env
+          console.log(`Provider changed for ${updated.name} (${agent.provider} -> ${updated.provider}), restarting...`);
+          const agentProc = agentProcesses.get(updated.id);
+          if (agentProc) {
+            // Graceful shutdown
+            try {
+              await fetch(`http://localhost:${updated.port}/shutdown`, {
+                method: "POST",
+                signal: AbortSignal.timeout(2000),
+              });
+              await new Promise(r => setTimeout(r, 500));
+            } catch {}
+            try { agentProc.proc.kill(); } catch {}
+            agentProcesses.delete(updated.id);
           }
-          // Push skills via /skills endpoint
-          if (config.skills?.definitions?.length > 0) {
-            const skillsResult = await pushSkillsToAgent(updated.id, updated.port, config.skills.definitions);
-            if (!skillsResult.success) {
-              console.error(`Failed to push skills to running agent: ${skillsResult.error}`);
+          setAgentStatus(updated.id, "stopped", "provider_changed");
+          // Start with new provider
+          const startResult = await startAgentProcess(updated, { silent: true });
+          if (!startResult.success) {
+            console.error(`Failed to restart agent after provider change: ${startResult.error}`);
+          }
+        } else {
+          // Same provider — just push updated config
+          const providerKey = ProviderKeys.getDecrypted(updated.provider);
+          if (providerKey) {
+            const config = buildAgentConfig(updated, providerKey);
+            const configResult = await pushConfigToAgent(updated.id, updated.port, config);
+            if (!configResult.success) {
+              console.error(`Failed to push config to running agent: ${configResult.error}`);
+            }
+            // Push skills via /skills endpoint
+            if (config.skills?.definitions?.length > 0) {
+              const skillsResult = await pushSkillsToAgent(updated.id, updated.port, config.skills.definitions);
+              if (!skillsResult.success) {
+                console.error(`Failed to push skills to running agent: ${skillsResult.error}`);
+              }
             }
           }
         }
@@ -215,10 +242,11 @@ export async function handleAgentRoutes(
       return json({ error: "No API key found for this agent" }, 404);
     }
 
-    // Return masked key (show only first 8 chars)
+    // Return masked key + full key (full key only shown on demand by frontend)
     const masked = apiKey.substring(0, 8) + "..." + apiKey.substring(apiKey.length - 4);
     return json({
       apiKey: masked,
+      fullKey: apiKey,
       hasKey: true,
     });
   }

package/src/routes/api/integrations.ts

@@ -518,20 +518,29 @@ export async function handleIntegrationRoutes(
     }
 
     try {
+      console.log(`[agentdojo:add] configId=${configId} projectId=${projectId}`);
       const server = await getAgentDojoServer(apiKey, configId);
       if (!server) {
+        console.log(`[agentdojo:add] server not found from AgentDojo API for configId=${configId}`);
         return json({ error: "Config not found" }, 404);
       }
-
-      // Check if already exists
-      const existing = McpServerDB.findAll().find(
-        s => s.source === "agentdojo" && (s.url?.includes(server.slug) || s.url?.includes(configId))
+      console.log(`[agentdojo:add] fetched server: slug=${server.slug} name=${server.name} url=${server.url?.substring(0, 80)}`);
+
+      // Check if already exists — match by slug in URL, scoped to same project
+      const effectiveProjectId = projectId && projectId !== "unassigned" ? projectId : null;
+      const allServers = McpServerDB.findAll();
+      const agentdojoServers = allServers.filter(s => s.source === "agentdojo");
+      console.log(`[agentdojo:add] total servers=${allServers.length} agentdojo servers=${agentdojoServers.length}`);
+      const existing = agentdojoServers.find(
+        s => s.project_id === effectiveProjectId && s.url?.endsWith(`/${server.slug}`)
       );
       if (existing) {
+        console.log(`[agentdojo:add] ALREADY EXISTS: id=${existing.id} project_id=${existing.project_id} slug=${server.slug}`);
         return json({ server: existing, message: "Server already exists" });
       }
 
       // Create the MCP server entry
+      console.log(`[agentdojo:add] creating new server with effectiveProjectId=${effectiveProjectId}`);
       const mcpServer = McpServerDB.create({
         id: generateId(),
         name: server.name,
@@ -544,12 +553,13 @@ export async function handleIntegrationRoutes(
         url: server.url,
         headers: { "X-API-Key": apiKey },
         source: "agentdojo",
-        project_id: projectId && projectId !== "unassigned" ? projectId : null,
+        project_id: effectiveProjectId,
       });
+      console.log(`[agentdojo:add] created server: id=${mcpServer.id} project_id=${mcpServer.project_id}`);
 
       return json({ server: mcpServer, message: "Server added successfully" });
     } catch (e) {
-      console.error("Failed to add AgentDojo config:", e);
+      console.error("[agentdojo:add] Failed to add AgentDojo config:", e);
       return json({ error: "Failed to add AgentDojo config" }, 500);
     }
   }

package/src/routes/api/mcp.ts

@@ -25,16 +25,23 @@ export async function handleMcpRoutes(
     const forAgent = url.searchParams.get("forAgent"); // agent's project ID (shows global + project)
 
     let servers;
+    let queryMode: string;
     if (forAgent !== null) {
       // Get servers available for an agent (global + agent's project)
       servers = McpServerDB.findForAgent(forAgent || null);
+      queryMode = `forAgent=${forAgent}`;
     } else if (projectFilter === "global") {
       servers = McpServerDB.findGlobal();
+      queryMode = "global";
     } else if (projectFilter && projectFilter !== "all") {
       servers = McpServerDB.findByProject(projectFilter);
+      queryMode = `project=${projectFilter}`;
     } else {
       servers = McpServerDB.findAll();
+      queryMode = "all";
     }
+    const agentdojoCount = servers.filter(s => s.source === "agentdojo").length;
+    console.log(`[mcp:GET] mode=${queryMode} total=${servers.length} agentdojo=${agentdojoCount}`);
     return json({ servers });
   }
 

package/src/routes/api/triggers.ts

@@ -266,7 +266,19 @@ export async function handleTriggerRoutes(
 
     try {
       const success = await provider.deleteTrigger(apiKey, triggerId);
-      return json({ success });
+
+      // Also clean up any local subscriptions referencing this trigger instance
+      const localSubs = SubscriptionDB.findByTriggerInstanceId(triggerId);
+      let localDeleted = 0;
+      for (const sub of localSubs) {
+        SubscriptionDB.delete(sub.id);
+        localDeleted++;
+      }
+      if (localDeleted > 0) {
+        console.log(`[triggers] Cleaned up ${localDeleted} local subscription(s) for trigger ${triggerId}`);
+      }
+
+      return json({ success, localSubscriptionsDeleted: localDeleted });
     } catch (e) {
       console.error(`Failed to delete trigger ${triggerId}:`, e);
       return json({ error: "Failed to delete trigger" }, 500);
@@ -446,14 +458,42 @@ export async function handleTriggerRoutes(
     }
   }
 
-  // DELETE /api/subscriptions/:id
+  // DELETE /api/subscriptions/:id?provider=composio&project_id=xxx
   const subDeleteMatch = path.match(/^\/api\/subscriptions\/([^/]+)$/);
   if (subDeleteMatch && method === "DELETE") {
-    const success = SubscriptionDB.delete(subDeleteMatch[1]);
-    if (!success) {
+    const subId = subDeleteMatch[1];
+    const sub = SubscriptionDB.findById(subId);
+    if (!sub) {
       return json({ error: "Subscription not found" }, 404);
     }
-    return json({ success: true });
+
+    // Also delete the remote trigger if it exists
+    let remoteDeleted = false;
+    if (sub.trigger_instance_id) {
+      const url = new URL(req.url);
+      const providerId = url.searchParams.get("provider") || null;
+      const projectId = url.searchParams.get("project_id") || sub.project_id || null;
+
+      // Try to determine provider — check query param, or try all registered providers
+      const providerIds = providerId ? [providerId] : getTriggerProviderIds();
+      for (const pid of providerIds) {
+        const provider = getTriggerProvider(pid);
+        const apiKey = provider ? ProviderKeys.getDecryptedForProject(pid, projectId) : null;
+        if (provider && apiKey) {
+          try {
+            await provider.deleteTrigger(apiKey, sub.trigger_instance_id);
+            remoteDeleted = true;
+            console.log(`[subscriptions] Deleted remote trigger ${sub.trigger_instance_id} via ${pid}`);
+            break;
+          } catch (e) {
+            console.warn(`[subscriptions] Failed to delete remote trigger ${sub.trigger_instance_id} via ${pid}:`, e);
+          }
+        }
+      }
+    }
+
+    const success = SubscriptionDB.delete(subId);
+    return json({ success, remoteDeleted });
   }
 
   // POST /api/subscriptions/:id/enable

package/src/web/App.tsx

@@ -264,6 +264,7 @@ function AppContent() {
             <ActivityPage
               agents={agents}
               loading={loading}
+              onNavigate={setRoute}
             />
           )}