apteva 0.4.31 → 0.4.41

package/src/routes/api/providers.ts

@@ -1,4 +1,14 @@
+import { existsSync } from "fs";
 import { json, debug } from "./helpers";
+
+// Detect if running inside a Docker container
+async function isRunningInDocker(): Promise<boolean> {
+  try {
+    return existsSync("/.dockerenv") || existsSync("/run/.containerenv");
+  } catch {
+    return false;
+  }
+}
 import { startAgentProcess, setAgentStatus } from "./agent-utils";
 import { AgentDB, UserDB } from "../../db";
 import { ProviderKeys, Onboarding, getProvidersWithStatus, PROVIDERS, type ProviderId } from "../../providers";
@@ -55,6 +65,7 @@ export async function handleProviderRoutes(
   // GET /api/providers/ollama/status - Check if Ollama is running
   if (path === "/api/providers/ollama/status" && method === "GET") {
     const ollamaUrl = ProviderKeys.getDecrypted("ollama") || "http://localhost:11434";
+    const isDocker = await isRunningInDocker();
 
     try {
       const response = await fetch(`${ollamaUrl}/api/tags`, {
@@ -68,11 +79,96 @@ export async function handleProviderRoutes(
           connected: true,
           url: ollamaUrl,
           modelCount: data.models?.length || 0,
+          isDocker,
         });
       }
-      return json({ connected: false, url: ollamaUrl, error: "Ollama not responding" });
+      return json({ connected: false, url: ollamaUrl, error: "Ollama not responding", isDocker });
     } catch {
-      return json({ connected: false, url: ollamaUrl, error: "Ollama not reachable" });
+      return json({ connected: false, url: ollamaUrl, error: "Ollama not reachable", isDocker });
+    }
+  }
+
+  // POST /api/providers/ollama/install - Install Ollama automatically
+  if (path === "/api/providers/ollama/install" && method === "POST") {
+    // Don't allow install inside Docker containers
+    if (await isRunningInDocker()) {
+      return json({ success: false, error: "Cannot install Ollama inside a Docker container. Configure an external Ollama URL instead." }, 400);
+    }
+
+    // Only supported on Linux/macOS
+    const platform = process.platform;
+    if (platform !== "linux" && platform !== "darwin") {
+      return json({ success: false, error: "Auto-install is only supported on Linux and macOS. Please download from https://ollama.com/download" }, 400);
+    }
+
+    // Check if already installed
+    try {
+      const which = Bun.spawnSync(["which", "ollama"]);
+      if (which.exitCode === 0) {
+        // Already installed, just make sure it's running
+        Bun.spawn(["ollama", "serve"], { stdout: "ignore", stderr: "ignore" });
+        // Wait a moment for it to start
+        await new Promise(r => setTimeout(r, 2000));
+        return json({ success: true, message: "Ollama is already installed", alreadyInstalled: true });
+      }
+    } catch { /* not installed */ }
+
+    // Install Ollama using official install script
+    try {
+      const proc = Bun.spawnSync(["bash", "-c", "curl -fsSL https://ollama.com/install.sh | sh"], {
+        timeout: 120_000, // 2 minute timeout
+        stderr: "pipe",
+        stdout: "pipe",
+      });
+
+      if (proc.exitCode !== 0) {
+        const stderr = proc.stderr.toString().trim();
+        return json({ success: false, error: `Installation failed: ${stderr || "Unknown error"}` }, 500);
+      }
+
+      // Start Ollama serve in background
+      Bun.spawn(["ollama", "serve"], { stdout: "ignore", stderr: "ignore" });
+
+      // Wait for it to come up
+      await new Promise(r => setTimeout(r, 3000));
+
+      // Verify it's running
+      try {
+        const check = await fetch("http://localhost:11434/api/tags", { signal: AbortSignal.timeout(3000) });
+        if (check.ok) {
+          return json({ success: true, message: "Ollama installed and running" });
+        }
+      } catch { /* may still be starting */ }
+
+      return json({ success: true, message: "Ollama installed. It may take a moment to start." });
+    } catch (err: any) {
+      return json({ success: false, error: `Installation failed: ${err.message}` }, 500);
+    }
+  }
+
+  // POST /api/providers/ollama/pull - Pull a model
+  if (path === "/api/providers/ollama/pull" && method === "POST") {
+    const body = await req.json() as { model?: string };
+    const model = body.model;
+    if (!model) {
+      return json({ error: "Model name required" }, 400);
+    }
+
+    try {
+      const ollamaUrl = ProviderKeys.getDecrypted("ollama") || "http://localhost:11434";
+      const response = await fetch(`${ollamaUrl}/api/pull`, {
+        method: "POST",
+        headers: { "Content-Type": "application/json" },
+        body: JSON.stringify({ name: model }),
+      });
+
+      if (!response.ok) {
+        return json({ success: false, error: "Failed to start model pull" }, 500);
+      }
+
+      return json({ success: true, message: `Pulling ${model}...` });
+    } catch (err: any) {
+      return json({ success: false, error: `Failed to pull model: ${err.message}` }, 500);
     }
   }
 
@@ -216,38 +312,33 @@ export async function handleProviderRoutes(
         a => a.status === "running" && a.provider === providerId
       );
 
-      const restartResults: Array<{ id: string; name: string; success: boolean; error?: string }> = [];
+      // Stop all agents first
       for (const agent of runningAgents) {
-        try {
-          // Stop the agent
-          const agentProc = agentProcesses.get(agent.id);
-          if (agentProc) {
-            agentProc.proc.kill();
-            agentProcesses.delete(agent.id);
-          }
-          setAgentStatus(agent.id, "stopped", "provider_restart");
-
-          // Wait a moment for port to be released
-          await new Promise(r => setTimeout(r, 500));
-
-          // Restart the agent with new key
-          const startResult = await startAgentProcess(agent, { silent: true });
-          restartResults.push({
-            id: agent.id,
-            name: agent.name,
-            success: startResult.success,
-            error: startResult.error,
-          });
-        } catch (e) {
-          restartResults.push({
-            id: agent.id,
-            name: agent.name,
-            success: false,
-            error: String(e),
-          });
+        const agentProc = agentProcesses.get(agent.id);
+        if (agentProc) {
+          agentProc.proc.kill();
+          agentProcesses.delete(agent.id);
         }
+        setAgentStatus(agent.id, "stopped", "provider_restart");
       }
 
+      // Wait once for ports to be released
+      if (runningAgents.length > 0) {
+        await new Promise(r => setTimeout(r, 500));
+      }
+
+      // Restart all agents in parallel
+      const restartResults = await Promise.all(
+        runningAgents.map(async (agent) => {
+          try {
+            const startResult = await startAgentProcess(agent, { silent: true });
+            return { id: agent.id, name: agent.name, success: startResult.success, error: startResult.error };
+          } catch (e) {
+            return { id: agent.id, name: agent.name, success: false, error: String(e) };
+          }
+        })
+      );
+
       return json({
         success: true,
         message: "API key saved successfully",

package/src/routes/api/skills.ts

@@ -499,13 +499,12 @@ export async function handleSkillRoutes(
       const agentsWithSkill = AgentDB.findBySkill(skillMatch[1]);
       const runningAgents = agentsWithSkill.filter(a => a.status === "running" && a.port);
 
-      for (const agent of runningAgents) {
+      await Promise.allSettled(runningAgents.map(async (agent) => {
         try {
           const providerKey = ProviderKeys.getDecrypted(agent.provider);
           if (providerKey) {
             const config = buildAgentConfig(agent, providerKey);
             await pushConfigToAgent(agent.id, agent.port!, config);
-            // Push skills via /skills endpoint
             if (config.skills?.definitions?.length > 0) {
               await pushSkillsToAgent(agent.id, agent.port!, config.skills.definitions);
             }
@@ -514,7 +513,7 @@ export async function handleSkillRoutes(
         } catch (err) {
           console.error(`Failed to push skill update to agent ${agent.name}:`, err);
         }
-      }
+      }));
 
       return json({ skill: updated, agents_updated: runningAgents.length });
     } catch (err) {

package/src/routes/api/system.ts

@@ -99,21 +99,16 @@ export async function handleSystemRoutes(
       return json({ success: false, error: result.error }, 500);
     }
 
-    // Restart agents that were running
-    const restartResults: { id: string; name: string; success: boolean; error?: string }[] = [];
-    for (const agentId of agentsToRestart) {
-      const agent = AgentDB.findById(agentId);
-      if (agent) {
+    // Restart agents that were running - in parallel
+    const restartResults = await Promise.all(
+      agentsToRestart.map(async (agentId) => {
+        const agent = AgentDB.findById(agentId);
+        if (!agent) return null;
         console.log(`Restarting agent ${agent.name} after update...`);
         const startResult = await startAgentProcess(agent);
-        restartResults.push({
-          id: agent.id,
-          name: agent.name,
-          success: startResult.success,
-          error: startResult.error,
-        });
-      }
-    }
+        return { id: agent.id, name: agent.name, success: startResult.success, error: startResult.error };
+      })
+    ).then(r => r.filter(Boolean));
 
     return json({
       success: true,

package/src/server.ts

@@ -5,7 +5,7 @@ import { serveStatic } from "./routes/static";
 import { join } from "path";
 import { homedir } from "os";
 import { mkdirSync, existsSync } from "fs";
-import { initDatabase, AgentDB, ProviderKeysDB, McpServerDB, ChannelDB, type McpServer, type Agent } from "./db";
+import { initDatabase, AgentDB, ProviderKeysDB, McpServerDB, ChannelDB, TelemetryDB, type McpServer, type Agent } from "./db";
 import { authMiddleware, type AuthContext } from "./auth/middleware";
 import { startMcpProcess } from "./mcp-client";
 import {
@@ -103,6 +103,12 @@ if (await envFile.exists()) {
 // Initialize database (silently)
 initDatabase(DATA_DIR);
 
+// Clean up old telemetry events (keep last 30 days)
+try {
+  const deleted = TelemetryDB.deleteOlderThan(30);
+  if (deleted > 0) console.log(`[db] Cleaned up ${deleted} telemetry events older than 30 days`);
+} catch { /* ignore */ }
+
 // Initialize version tracking
 initVersionTracking(DATA_DIR);
 
@@ -127,37 +133,31 @@ async function cleanupOrphanedProcesses(): Promise<void> {
 
   if (assignedPorts.length === 0) return;
 
-  let cleaned = 0;
-  for (const port of assignedPorts) {
+  // Check all ports in parallel
+  const results = await Promise.allSettled(assignedPorts.map(async (port) => {
     try {
       const res = await fetch(`http://localhost:${port}/health`, { signal: AbortSignal.timeout(200) });
-      if (res.ok) {
-        // Orphaned process on this port - shut it down gracefully first
-        try {
-          await fetch(`http://localhost:${port}/shutdown`, { method: "POST", signal: AbortSignal.timeout(500) });
-          await new Promise(r => setTimeout(r, 500)); // Wait for graceful shutdown
-        } catch {
-          // Graceful shutdown failed
-        }
-
-        // Check if still running and force kill if needed
-        try {
-          const check = await fetch(`http://localhost:${port}/health`, { signal: AbortSignal.timeout(200) });
-          if (check.ok) {
-            // Still running - force kill via lsof
-            const { execSync } = await import("child_process");
-            execSync(`lsof -ti :${port} | xargs -r kill -9 2>/dev/null || true`, { stdio: "ignore" });
-          }
-        } catch {
-          // Not responding anymore - good
+      if (!res.ok) return false;
+      // Orphaned process - shut it down gracefully
+      try {
+        await fetch(`http://localhost:${port}/shutdown`, { method: "POST", signal: AbortSignal.timeout(500) });
+        await new Promise(r => setTimeout(r, 500));
+      } catch {}
+      // Force kill if still running
+      try {
+        const check = await fetch(`http://localhost:${port}/health`, { signal: AbortSignal.timeout(200) });
+        if (check.ok) {
+          const { execSync } = await import("child_process");
+          execSync(`lsof -ti :${port} | xargs -r kill -9 2>/dev/null || true`, { stdio: "ignore" });
         }
-        cleaned++;
-      }
+      } catch {}
+      return true;
     } catch {
-      // Port not in use - good
+      return false;
     }
-  }
+  }));
 
+  const cleaned = results.filter(r => r.status === "fulfilled" && r.value).length;
   if (cleaned > 0) {
     console.log(`  [cleanup] Stopped ${cleaned} orphaned agent process(es)`);
   }
@@ -490,14 +490,13 @@ if (hasRestarts) {
       }
     }
 
-    // Then restart agents
+    // Then restart agents - in parallel
     if (agentsToRestart.length > 0) {
       console.log(`  ${c.darkGray}Agents${c.reset}    ${c.gray}Restarting ${agentsToRestart.length} agent(s)...${c.reset}`);
 
-      for (const agent of agentsToRestart) {
+      await Promise.allSettled(agentsToRestart.map(async (agent) => {
         try {
           const result = await startAgentProcess(agent, { silent: true });
-
           if (result.success) {
             console.log(`  ${c.gray}  ✓ ${agent.name} on :${result.port}${c.reset}`);
           } else {
@@ -506,7 +505,7 @@ if (hasRestarts) {
         } catch (err) {
           console.log(`  ${c.gray}  ✗ ${agent.name}: ${err}${c.reset}`);
         }
-      }
+      }));
     }
 
     // Restart channels (after agents, since channels depend on running agents)
@@ -514,7 +513,7 @@ if (hasRestarts) {
       const { startChannel } = await import("./channels");
       console.log(`  ${c.darkGray}Channels${c.reset}  ${c.gray}Restarting ${channelsToRestart.length} channel(s)...${c.reset}`);
 
-      for (const channel of channelsToRestart) {
+      await Promise.allSettled(channelsToRestart.map(async (channel) => {
         try {
           const result = await startChannel(channel.id);
           if (result.success) {
@@ -525,7 +524,7 @@ if (hasRestarts) {
         } catch (err) {
           console.log(`  ${c.gray}  ✗ ${channel.name}: ${err}${c.reset}`);
         }
-      }
+      }));
     }
   })();
 }

package/src/triggers/agentdojo.ts

@@ -16,13 +16,13 @@ export const AgentDojoTriggerProvider: TriggerProvider = {
   name: "AgentDojo",
 
   async listTriggerTypes(apiKey: string, toolkitSlugs?: string[]): Promise<TriggerType[]> {
-    const params = new URLSearchParams({ is_active: "true", limit: "200" });
+    const params = new URLSearchParams({ is_active: "true", limit: "500" });
     if (toolkitSlugs?.length) {
       // Filter by toolkit name(s) — API supports one at a time, so fetch each
       const allItems: any[] = [];
       for (const slug of toolkitSlugs) {
         const res = await fetch(
-          `${AGENTDOJO_API_BASE}/triggers?${new URLSearchParams({ toolkit_name: slug, is_active: "true", limit: "200" })}`,
+          `${AGENTDOJO_API_BASE}/triggers?${new URLSearchParams({ toolkit_name: slug, is_active: "true", limit: "500" })}`,
           { headers: headers(apiKey) },
         );
         if (res.ok) {

package/src/web/App.tsx

@@ -28,13 +28,14 @@ import { MetaAgentProvider, MetaAgentPanel } from "./components/meta-agent/MetaA
 
 // Lazy-loaded page components (only loaded when navigated to)
 const SettingsPage = lazy(() => import("./components/settings/SettingsPage").then(m => ({ default: m.SettingsPage })));
-const ActivityPage = lazy(() => import("./components/activity/ActivityPage").then(m => ({ default: m.ActivityPage })));
 const TasksPage = lazy(() => import("./components/tasks/TasksPage").then(m => ({ default: m.TasksPage })));
 const McpPage = lazy(() => import("./components/mcp/McpPage").then(m => ({ default: m.McpPage })));
 const SkillsPage = lazy(() => import("./components/skills/SkillsPage").then(m => ({ default: m.SkillsPage })));
 const TestsPage = lazy(() => import("./components/tests/TestsPage").then(m => ({ default: m.TestsPage })));
+const ThreadsPage = lazy(() => import("./components/threads/ThreadsPage").then(m => ({ default: m.ThreadsPage })));
 const TelemetryPage = lazy(() => import("./components/telemetry/TelemetryPage").then(m => ({ default: m.TelemetryPage })));
 const ConnectionsPage = lazy(() => import("./components/connections/ConnectionsPage").then(m => ({ default: m.ConnectionsPage })));
+const ActivityPage = lazy(() => import("./components/activity/ActivityPage").then(m => ({ default: m.ActivityPage })));
 const ApiDocsPage = lazy(() => import("./components/api/ApiDocsPage").then(m => ({ default: m.ApiDocsPage })));
 
 function AppContent() {
@@ -111,7 +112,7 @@ function AppContent() {
     };
 
     fetchTaskCount();
-  }, [shouldFetchData, accessToken, currentProjectId, agents, statusChangeCounter, taskChangeCounter]);
+  }, [shouldFetchData, accessToken, currentProjectId, statusChangeCounter, taskChangeCounter]);
 
   // Form state
   const [newAgent, setNewAgent] = useState<NewAgentForm>({
@@ -260,14 +261,6 @@ function AppContent() {
           <Suspense fallback={<LoadingSpinner />}>
           {route === "settings" && <SettingsPage />}
 
-          {route === "activity" && (
-            <ActivityPage
-              agents={agents}
-              loading={loading}
-              onNavigate={setRoute}
-            />
-          )}
-
           {route === "agents" && (
             <AgentsView
               agents={agents}
@@ -295,6 +288,21 @@ function AppContent() {
             />
           )}
 
+          {route === "threads" && (
+            <ThreadsPage
+              agents={agents}
+              onNavigate={setRoute}
+            />
+          )}
+
+          {route === "activity" && (
+            <ActivityPage
+              agents={agents}
+              loading={loading}
+              onNavigate={handleNavigate}
+            />
+          )}
+
           {route === "tasks" && <TasksPage />}
 
           {route === "connections" && <ConnectionsPage />}