apteva 0.4.26 → 0.4.30

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/web/components/activity/ActivityPage.tsx

@@ -216,7 +216,7 @@ function AgentRow({ agent, selected, onSelect }: {
   selected: boolean;
   onSelect: () => void;
 }) {
-  const { isActive, type } = useAgentActivity(agent.id);
+  const { isActive, label } = useAgentActivity(agent.id);
   const isRunning = agent.status === "running";
 
   return (
@@ -244,8 +244,8 @@ function AgentRow({ agent, selected, onSelect }: {
           </span>
           <span className="text-[10px] text-[#555] shrink-0">{agent.provider}</span>
         </div>
-        {isActive && type ? (
-          <p className="text-[11px] text-green-400 truncate">{type}</p>
+        {isActive && label ? (
+          <p className="text-[11px] text-green-400 truncate">{label}</p>
         ) : (
           <p className={`text-[11px] ${isRunning ? "text-[#555]" : "text-[#444]"}`}>
             {isRunning ? "idle" : "stopped"}

package/src/web/components/agents/AgentCard.tsx

@@ -26,7 +26,7 @@ export function AgentCard({ agent, selected, onSelect, onToggle, showProject }:
   const enabledFeatures = FEATURE_ICONS.filter(f => agent.features?.[f.key]);
   const mcpServers = agent.mcpServerDetails || [];
   const skills = agent.skillDetails || [];
-  const { isActive, type } = useAgentActivity(agent.id);
+  const { isActive, label: activityLabel } = useAgentActivity(agent.id);
   const { projects } = useProjects();
   const { authFetch } = useAuth();
   const project = agent.projectId ? projects.find(p => p.id === agent.projectId) : null;
@@ -62,7 +62,7 @@ export function AgentCard({ agent, selected, onSelect, onToggle, showProject }:
             </p>
           )}
         </div>
-        <StatusBadge status={agent.status} isActive={isActive && agent.status === "running"} activityType={type} />
+        <StatusBadge status={agent.status} isActive={isActive && agent.status === "running"} activityLabel={activityLabel} />
       </div>
 
       {enabledFeatures.length > 0 && (
@@ -165,11 +165,11 @@ export function AgentCard({ agent, selected, onSelect, onToggle, showProject }:
   );
 }
 
-function StatusBadge({ status, isActive, activityType }: { status: Agent["status"]; isActive?: boolean; activityType?: string }) {
-  if (status === "running" && isActive && activityType) {
+function StatusBadge({ status, isActive, activityLabel }: { status: Agent["status"]; isActive?: boolean; activityLabel?: string }) {
+  if (status === "running" && isActive && activityLabel) {
     return (
       <span className="px-2 py-1 rounded text-xs font-medium bg-green-500/20 text-green-400 animate-pulse">
-        {activityType}
+        {activityLabel}
       </span>
     );
   }

package/src/web/components/agents/AgentPanel.tsx

@@ -6,8 +6,8 @@ import { Select } from "../common/Select";
 import { useConfirm } from "../common/Modal";
 import { useTelemetry } from "../../context";
 import { useAuth } from "../../context";
-import type { Agent, Provider, AgentFeatures, McpServer, SkillSummary, AgentMode, MultiAgentConfig, Task } from "../../types";
-import { getMultiAgentConfig } from "../../types";
+import type { Agent, Provider, AgentFeatures, McpServer, SkillSummary, AgentMode, MultiAgentConfig, OperatorConfig, Task } from "../../types";
+import { getMultiAgentConfig, getOperatorConfig } from "../../types";
 
 type Tab = "chat" | "threads" | "tasks" | "memory" | "files" | "settings";
 
@@ -1123,6 +1123,7 @@ function SettingsTab({ agent, providers, onUpdateAgent, onDeleteAgent }: {
   const [availableMcpServers, setAvailableMcpServers] = useState<McpServer[]>([]);
   const [availableSkills, setAvailableSkills] = useState<AvailableSkill[]>([]);
   const [apiKey, setApiKey] = useState<string | null>(null);
+  const [apiKeyFull, setApiKeyFull] = useState<string | null>(null);
   const [showApiKey, setShowApiKey] = useState(false);
   const [subscriptions, setSubscriptions] = useState<{ id: string; trigger_slug: string; enabled: boolean }[]>([]);
 
@@ -1148,22 +1149,22 @@ function SettingsTab({ agent, providers, onUpdateAgent, onDeleteAgent }: {
     fetchMcpServers();
   }, [authFetch]);
 
-  // Fetch API key (dev mode only)
+  // Fetch API key
   useEffect(() => {
-    if (!isDev) return;
     const fetchApiKey = async () => {
       try {
         const res = await authFetch(`/api/agents/${agent.id}/api-key`);
         if (res.ok) {
           const data = await res.json();
           setApiKey(data.apiKey);
+          setApiKeyFull(data.fullKey || null);
         }
       } catch (e) {
         // Ignore - not critical
       }
     };
     fetchApiKey();
-  }, [agent.id, isDev, authFetch]);
+  }, [agent.id, authFetch]);
 
   // Fetch available skills
   useEffect(() => {
@@ -1217,19 +1218,13 @@ function SettingsTab({ agent, providers, onUpdateAgent, onDeleteAgent }: {
   const toggleFeature = (key: keyof AgentFeatures) => {
     if (key === "agents") {
       // Special handling for agents feature - convert to MultiAgentConfig
-      const current = prev => {
-        const agentConfig = getMultiAgentConfig(prev.features, agent.projectId);
-        return agentConfig.enabled;
-      };
       setForm(prev => {
         const isEnabled = typeof prev.features.agents === "boolean"
           ? prev.features.agents
           : (prev.features.agents as MultiAgentConfig)?.enabled ?? false;
         if (isEnabled) {
-          // Turning off - set to false
           return { ...prev, features: { ...prev.features, agents: false } };
         } else {
-          // Turning on - set to config with defaults
           return {
             ...prev,
             features: {
@@ -1239,6 +1234,22 @@ function SettingsTab({ agent, providers, onUpdateAgent, onDeleteAgent }: {
           };
         }
       });
+    } else if (key === "operator") {
+      // Special handling for operator feature - convert to OperatorConfig
+      setForm(prev => {
+        const opConfig = getOperatorConfig(prev.features);
+        if (opConfig.enabled) {
+          return { ...prev, features: { ...prev.features, operator: false } };
+        } else {
+          return {
+            ...prev,
+            features: {
+              ...prev.features,
+              operator: { enabled: true },
+            },
+          };
+        }
+      });
     } else {
       setForm(prev => ({
         ...prev,
@@ -1274,6 +1285,33 @@ function SettingsTab({ agent, providers, onUpdateAgent, onDeleteAgent }: {
     return config.mode || "worker";
   };
 
+  // Helper to check if operator feature is enabled
+  const isOperatorEnabled = () => {
+    return getOperatorConfig(form.features).enabled;
+  };
+
+  // Get current operator config
+  const getOperatorCfg = (): OperatorConfig => {
+    return getOperatorConfig(form.features);
+  };
+
+  // Get browser providers from the providers list
+  const browserProviders = providers.filter(p => p.type === "browser" && p.hasKey);
+
+  // Set operator browser provider
+  const setOperatorBrowserProvider = (browserProvider: string) => {
+    setForm(prev => {
+      const current = getOperatorConfig(prev.features);
+      return {
+        ...prev,
+        features: {
+          ...prev.features,
+          operator: { ...current, enabled: true, browser_provider: browserProvider },
+        },
+      };
+    });
+  };
+
   const toggleMcpServer = (serverId: string) => {
     setForm(prev => ({
       ...prev,
@@ -1353,8 +1391,10 @@ function SettingsTab({ agent, providers, onUpdateAgent, onDeleteAgent }: {
         <FormField label="Features">
           <div className="grid grid-cols-1 sm:grid-cols-2 gap-2">
             {FEATURE_CONFIG.map(({ key, label, description, icon: Icon }) => {
-              // For agents feature, check the enabled property of the config
-              const isEnabled = key === "agents" ? isAgentsEnabled() : !!form.features[key];
+              // For agents/operator features, check the enabled property of the config
+              const isEnabled = key === "agents" ? isAgentsEnabled()
+                : key === "operator" ? isOperatorEnabled()
+                : !!form.features[key];
               return (
                 <button
                   key={key}
@@ -1420,6 +1460,29 @@ function SettingsTab({ agent, providers, onUpdateAgent, onDeleteAgent }: {
           </FormField>
         )}
 
+        {/* Operator Browser Provider - shown when operator is enabled */}
+        {isOperatorEnabled() && (
+          <FormField label="Browser Provider">
+            {browserProviders.length > 0 ? (
+              <Select
+                value={getOperatorCfg().browser_provider || ""}
+                options={[
+                  { value: "", label: "Auto (first available)" },
+                  ...browserProviders.map(p => ({
+                    value: p.id,
+                    label: p.name,
+                  })),
+                ]}
+                onChange={(value) => setOperatorBrowserProvider(value)}
+              />
+            ) : (
+              <p className="text-sm text-[#666] p-3 border border-[#222] rounded bg-[#0a0a0a]">
+                No browser providers configured. Go to Settings &rarr; Providers to add one.
+              </p>
+            )}
+          </FormField>
+        )}
+
         {/* Agent Built-in Tools - Anthropic only */}
         {form.provider === "anthropic" && (
         <FormField label="Agent Built-in Tools">
@@ -1628,7 +1691,7 @@ function SettingsTab({ agent, providers, onUpdateAgent, onDeleteAgent }: {
         </div>
 
         {/* Developer Info (dev mode only) */}
-        {isDev && apiKey && (
+        {apiKey && (
           <div className="mt-8 pt-6 border-t border-[#222]">
             <p className="text-sm text-[#666] mb-3">Developer Info</p>
             <div className="space-y-2">
@@ -1650,17 +1713,15 @@ function SettingsTab({ agent, providers, onUpdateAgent, onDeleteAgent }: {
                     {showApiKey ? "Hide" : "Show"}
                   </button>
                 </div>
-                {showApiKey && (
-                  <code className="text-xs bg-[#1a1a1a] px-2 py-1 rounded text-[#888] break-all">
-                    {apiKey}
-                  </code>
-                )}
+                <code className="text-xs bg-[#1a1a1a] px-2 py-1 rounded text-[#888] break-all">
+                  {showApiKey ? (apiKeyFull || apiKey) : apiKey}
+                </code>
               </div>
               {agent.status === "running" && agent.port && (
                 <div className="flex flex-col gap-1 mt-2">
                   <span className="text-xs text-[#666]">Test with curl</span>
                   <code className="text-xs bg-[#1a1a1a] px-2 py-1.5 rounded text-[#666] break-all">
-                    curl -H "X-API-Key: {showApiKey ? apiKey : "***"}" http://localhost:{agent.port}/config
+                    curl -H "X-API-Key: {showApiKey ? (apiKeyFull || apiKey) : "***"}" http://localhost:{agent.port}/config
                   </code>
                 </div>
               )}

package/src/web/components/mcp/McpPage.tsx

@@ -1366,6 +1366,7 @@ function AgentDojoContent({
       const serversUrl = projectId && projectId !== "unassigned"
         ? `/api/mcp/servers?project=${encodeURIComponent(projectId)}`
         : "/api/mcp/servers";
+      console.log(`[AgentDojo:fetchConfigs] projectId=${projectId} serversUrl=${serversUrl}`);
       const [configsRes, serversRes] = await Promise.all([
         authFetch(`/api/integrations/agentdojo/configs${projectParam}`),
         authFetch(serversUrl),
@@ -1373,18 +1374,24 @@ function AgentDojoContent({
       const configsData = await configsRes.json();
       const serversData = await serversRes.json();
 
+      console.log(`[AgentDojo:fetchConfigs] configs=${(configsData.configs || []).length} servers=${(serversData.servers || []).length}`);
       setConfigs(configsData.configs || []);
 
       // Track which configs are already added as local servers
+      const agentdojoServers = (serversData.servers || []).filter((s: any) => s.source === "agentdojo");
+      console.log(`[AgentDojo:fetchConfigs] agentdojo servers found: ${agentdojoServers.length}`);
+      for (const s of agentdojoServers) {
+        const match = s.url?.match(/\/mcp\/([^/?]+)/);
+        console.log(`[AgentDojo:fetchConfigs]   server: id=${s.id} name=${s.name} project_id=${s.project_id} url=${s.url?.substring(0, 80)} extracted=${match ? match[1] : s.name}`);
+      }
       const agentdojoServerIds = new Set(
-        (serversData.servers || [])
-          .filter((s: any) => s.source === "agentdojo")
-          .map((s: any) => {
+        agentdojoServers.map((s: any) => {
             // Extract config ID from URL or match by name
             const match = s.url?.match(/\/mcp\/([^/?]+)/);
             return match ? match[1] : s.name;
           })
       );
+      console.log(`[AgentDojo:fetchConfigs] addedServers set:`, [...agentdojoServerIds]);
       setAddedServers(agentdojoServerIds);
     } catch (e) {
       console.error("Failed to fetch AgentDojo configs:", e);
@@ -1396,15 +1403,19 @@ function AgentDojoContent({
     setAddingConfig(configId);
     try {
       const projectParam = projectId && projectId !== "unassigned" ? `?project_id=${projectId}` : "";
+      console.log(`[AgentDojo:addConfig] configId=${configId} projectParam=${projectParam}`);
       const res = await authFetch(`/api/integrations/agentdojo/configs/${configId}/add${projectParam}`, {
         method: "POST",
       });
+      const data = await res.json();
+      console.log(`[AgentDojo:addConfig] response status=${res.status} ok=${res.ok} message=${data.message} server.id=${data.server?.id} server.project_id=${data.server?.project_id}`);
       if (res.ok) {
         const config = configs.find(c => c.id === configId);
-        setAddedServers(prev => new Set([...prev, config?.slug || configId]));
+        const addKey = config?.slug || configId;
+        console.log(`[AgentDojo:addConfig] marking as added: key=${addKey} config.slug=${config?.slug} config.id=${config?.id} config.name=${config?.name}`);
+        setAddedServers(prev => new Set([...prev, addKey]));
         onServerAdded?.();
       } else {
-        const data = await res.json();
         await alert(data.error || "Failed to add config", { title: "Error", variant: "error" });
       }
     } catch (e) {