apteva 0.4.57 → 0.7.0

package/src/routes/api/system.ts

@@ -1,333 +0,0 @@
-import { json } from "./helpers";
-import { META_AGENT_ENABLED, fetchFromAgent, agentFetch, startAgentProcess, setAgentStatus } from "./agent-utils";
-import { AgentDB } from "../../db";
-import { ProviderKeys } from "../../providers";
-import { agentProcesses, getBinaryStatus, BIN_DIR } from "../../server";
-import {
-  checkForUpdates,
-  getInstalledVersion,
-  getAptevaVersion,
-  downloadLatestBinary,
-  installViaNpm,
-} from "../../binary";
-import { openApiSpec } from "../../openapi";
-
-export async function handleSystemRoutes(
-  req: Request,
-  path: string,
-  method: string,
-  authContext?: unknown,
-): Promise<Response | null> {
-  // GET /api/health - Health check endpoint (no auth required)
-  if (path === "/api/health" && method === "GET") {
-    const binaryStatus = getBinaryStatus(BIN_DIR);
-    const installedVersion = getInstalledVersion();
-    return json({
-      status: "ok",
-      version: getAptevaVersion(),
-      timestamp: new Date().toISOString(),
-      agents: {
-        total: AgentDB.count(),
-        running: AgentDB.countRunning(),
-      },
-      binary: {
-        available: binaryStatus.exists,
-        platform: binaryStatus.platform,
-        arch: binaryStatus.arch,
-        version: installedVersion,
-      },
-    });
-  }
-
-  // GET /api/features - Feature flags (no auth required)
-  if (path === "/api/features" && method === "GET") {
-    return json({
-      projects: process.env.PROJECTS_ENABLED === "true",
-      metaAgent: process.env.META_AGENT_ENABLED === "true",
-      costTracking: process.env.COST_TRACKING_ENABLED !== "false",
-    });
-  }
-
-  // GET /api/openapi - OpenAPI spec (no auth required)
-  if (path === "/api/openapi" && method === "GET") {
-    return json(openApiSpec);
-  }
-
-  // GET /api/stats - Get statistics
-  if (path === "/api/stats" && method === "GET") {
-    return json({
-      totalAgents: AgentDB.count(),
-      runningAgents: AgentDB.countRunning(),
-    });
-  }
-
-  // GET /api/binary - Get binary status
-  if (path === "/api/binary" && method === "GET") {
-    return json(getBinaryStatus(BIN_DIR));
-  }
-
-  // GET /api/version - Check agent binary version info
-  if (path === "/api/version" && method === "GET") {
-    const versionInfo = await checkForUpdates();
-    return json(versionInfo);
-  }
-
-  // POST /api/version/update - Download/install latest agent binary
-  if (path === "/api/version/update" && method === "POST") {
-    // Get all running agents to restart later
-    const runningAgents = AgentDB.findAll().filter(a => a.status === "running");
-    const agentsToRestart = runningAgents.map(a => a.id);
-
-    // Stop all running agents
-    for (const agent of runningAgents) {
-      const agentProc = agentProcesses.get(agent.id);
-      if (agentProc) {
-        console.log(`Stopping agent ${agent.name} for update...`);
-        agentProc.proc.kill();
-        agentProcesses.delete(agent.id);
-      }
-      setAgentStatus(agent.id, "stopped", "binary_update");
-    }
-
-    // Try npm install first, fall back to direct download
-    let result = await installViaNpm();
-    if (!result.success) {
-      // Fall back to direct download
-      result = await downloadLatestBinary(BIN_DIR);
-    }
-
-    if (!result.success) {
-      return json({ success: false, error: result.error }, 500);
-    }
-
-    // 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);
-        return { id: agent.id, name: agent.name, success: startResult.success, error: startResult.error };
-      })
-    ).then(r => r.filter(Boolean));
-
-    return json({
-      success: true,
-      version: result.version,
-      restarted: restartResults,
-    });
-  }
-
-  // GET /api/tasks - Get all tasks from all running agents
-  if (path === "/api/tasks" && method === "GET") {
-    const url = new URL(req.url);
-    const status = url.searchParams.get("status") || "all";
-    const projectId = url.searchParams.get("project_id");
-
-    let runningAgents = AgentDB.findAll().filter(a => a.status === "running" && a.port);
-
-    // Filter agents by project if requested
-    if (projectId === "unassigned") {
-      runningAgents = runningAgents.filter(a => !a.project_id);
-    } else if (projectId) {
-      runningAgents = runningAgents.filter(a => a.project_id === projectId);
-    }
-
-    const allTasks: any[] = [];
-
-    // 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 });
-      }
-    }
-
-    // Sort by created_at descending
-    allTasks.sort((a, b) => new Date(b.created_at).getTime() - new Date(a.created_at).getTime());
-
-    return json({ tasks: allTasks, count: allTasks.length });
-  }
-
-  // GET /api/tasks/:agentId/:taskId - Get a single task with full details
-  const singleTaskMatch = path.match(/^\/api\/tasks\/([^/]+)\/([^/]+)$/);
-  if (singleTaskMatch && method === "GET") {
-    const [, agentId, taskId] = singleTaskMatch;
-    const agent = AgentDB.findById(agentId);
-
-    if (!agent) {
-      return json({ error: "Agent not found" }, 404);
-    }
-
-    if (agent.status !== "running" || !agent.port) {
-      return json({ error: "Agent is not running" }, 400);
-    }
-
-    const data = await fetchFromAgent(agent.id, agent.port, `/tasks/${taskId}`);
-    if (!data) {
-      return json({ error: "Failed to fetch task from agent" }, 500);
-    }
-
-    return json({ task: { ...data, agentId: agent.id, agentName: agent.name } });
-  }
-
-  // POST /api/tasks/:agentId/:taskId/execute - Execute a task immediately
-  const executeTaskMatch = path.match(/^\/api\/tasks\/([^/]+)\/([^/]+)\/execute$/);
-  if (executeTaskMatch && method === "POST") {
-    const [, agentId, taskId] = executeTaskMatch;
-    const agent = AgentDB.findById(agentId);
-    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 res = await agentFetch(agentId, agent.port, `/tasks/${taskId}/execute`, {
-        method: "POST",
-        signal: AbortSignal.timeout(5000),
-      });
-      const data = await res.json();
-      if (!res.ok) return json({ error: data.error || `HTTP ${res.status}` }, res.status);
-      return json(data);
-    } catch (err) {
-      return json({ error: `Failed to execute task: ${err}` }, 500);
-    }
-  }
-
-  // POST /api/tasks/:agentId - Create a task on an agent
-  const createTaskMatch = path.match(/^\/api\/tasks\/([^/]+)$/);
-  if (createTaskMatch && method === "POST") {
-    const agentId = createTaskMatch[1];
-    const agent = AgentDB.findById(agentId);
-    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();
-      const res = await agentFetch(agentId, agent.port, "/tasks", {
-        method: "POST",
-        headers: { "Content-Type": "application/json" },
-        body: JSON.stringify(body),
-        signal: AbortSignal.timeout(5000),
-      });
-      const data = await res.json();
-      if (!res.ok) return json({ error: data.error || `HTTP ${res.status}` }, res.status);
-      return json(data, 201);
-    } catch (err) {
-      return json({ error: `Failed to create task: ${err}` }, 500);
-    }
-  }
-
-  // PUT /api/tasks/:agentId/:taskId - Update a task on an agent
-  if (singleTaskMatch && method === "PUT") {
-    const [, agentId, taskId] = singleTaskMatch;
-    const agent = AgentDB.findById(agentId);
-    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();
-      const res = await agentFetch(agentId, agent.port, `/tasks/${taskId}`, {
-        method: "PUT",
-        headers: { "Content-Type": "application/json" },
-        body: JSON.stringify(body),
-        signal: AbortSignal.timeout(5000),
-      });
-      const data = await res.json();
-      if (!res.ok) return json({ error: data.error || `HTTP ${res.status}` }, res.status);
-      return json(data);
-    } catch (err) {
-      return json({ error: `Failed to update task: ${err}` }, 500);
-    }
-  }
-
-  // DELETE /api/tasks/:agentId/:taskId - Delete a task on an agent
-  if (singleTaskMatch && method === "DELETE") {
-    const [, agentId, taskId] = singleTaskMatch;
-    const agent = AgentDB.findById(agentId);
-    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 res = await agentFetch(agentId, agent.port, `/tasks/${taskId}`, {
-        method: "DELETE",
-        signal: AbortSignal.timeout(5000),
-      });
-      const data = await res.json();
-      if (!res.ok) return json({ error: data.error || `HTTP ${res.status}` }, res.status);
-      return json(data);
-    } catch (err) {
-      return json({ error: `Failed to delete task: ${err}` }, 500);
-    }
-  }
-
-  // GET /api/dashboard - Get dashboard statistics
-  if (path === "/api/dashboard" && method === "GET") {
-    const url = new URL(req.url);
-    const projectId = url.searchParams.get("project_id");
-
-    let agents = AgentDB.findAll();
-
-    // Filter agents by project if specified
-    if (projectId === "unassigned") {
-      agents = agents.filter(a => !a.project_id);
-    } else if (projectId) {
-      agents = agents.filter(a => a.project_id === projectId);
-    }
-
-    const runningAgents = agents.filter(a => a.status === "running" && a.port);
-
-    let totalTasks = 0;
-    let pendingTasks = 0;
-    let completedTasks = 0;
-    let runningTasks = 0;
-
-    // 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) {
-          if (task.status === "pending") pendingTasks++;
-          else if (task.status === "completed") completedTasks++;
-          else if (task.status === "running") runningTasks++;
-        }
-      }
-    }
-
-    return json({
-      agents: {
-        total: agents.length,
-        running: runningAgents.length,
-      },
-      tasks: {
-        total: totalTasks,
-        pending: pendingTasks,
-        running: runningTasks,
-        completed: completedTasks,
-      },
-      providers: {
-        configured: ProviderKeys.getConfiguredProviders().length,
-      },
-    });
-  }
-
-  return null;
-}

package/src/routes/api/telemetry.ts

@@ -1,203 +0,0 @@
-import { json } from "./helpers";
-import { TelemetryDB, AgentDB } from "../../db";
-import { getModelCost } from "../../providers";
-import { telemetryBroadcaster, type TelemetryEvent } from "../../server";
-
-export async function handleTelemetryRoutes(
-  req: Request,
-  path: string,
-  method: string,
-): Promise<Response | null> {
-  // POST /api/telemetry - Receive telemetry events from agents
-  if (path === "/api/telemetry" && method === "POST") {
-    try {
-      const body = await req.json() as {
-        agent_id: string;
-        sent_at: string;
-        events: Array<{
-          id: string;
-          timestamp: string;
-          category: string;
-          type: string;
-          level: string;
-          trace_id?: string;
-          span_id?: string;
-          thread_id?: string;
-          data?: Record<string, unknown>;
-          metadata?: Record<string, unknown>;
-          duration_ms?: number;
-          error?: string;
-        }>;
-      };
-
-      if (!body.agent_id || !body.events) {
-        return json({ error: "agent_id and events are required" }, 400);
-      }
-
-      // Filter out debug events - too noisy
-      const filteredEvents = body.events.filter(e => e.level !== "debug");
-
-      // Compute cost per LLM event if cost tracking is enabled
-      const costTrackingEnabled = process.env.COST_TRACKING_ENABLED !== "false";
-      if (costTrackingEnabled) {
-        const agent = AgentDB.findById(body.agent_id);
-        if (agent) {
-          const pricing = getModelCost(agent.provider, agent.model);
-          for (const event of filteredEvents) {
-            if (event.category === "LLM" && event.data) {
-              const inputTokens = (event.data.input_tokens as number) || 0;
-              const outputTokens = (event.data.output_tokens as number) || 0;
-              const cacheCreationTokens = (event.data.cache_creation_tokens as number) || 0;
-              const cacheReadTokens = (event.data.cache_read_tokens as number) || 0;
-              const reasoningTokens = (event.data.reasoning_tokens as number) || 0;
-              (event as any).cost = (
-                inputTokens * pricing.input_cost +
-                outputTokens * pricing.output_cost +
-                cacheCreationTokens * pricing.cache_creation_cost +
-                cacheReadTokens * pricing.cache_read_cost +
-                reasoningTokens * pricing.output_cost
-              ) / 1_000_000;
-            }
-          }
-        }
-      }
-
-      const inserted = TelemetryDB.insertBatch(body.agent_id, filteredEvents);
-
-      // Broadcast to SSE clients
-      if (filteredEvents.length > 0) {
-        const broadcastEvents: TelemetryEvent[] = filteredEvents.map(e => ({
-          id: e.id,
-          agent_id: body.agent_id,
-          timestamp: e.timestamp,
-          category: e.category,
-          type: e.type,
-          level: e.level,
-          trace_id: e.trace_id,
-          thread_id: e.thread_id,
-          data: e.data,
-          duration_ms: e.duration_ms,
-          error: e.error,
-          cost: (e as any).cost as number | undefined,
-        }));
-        telemetryBroadcaster.broadcast(broadcastEvents);
-      }
-
-      return json({ received: body.events.length, inserted });
-    } catch (e) {
-      console.error("Telemetry error:", e);
-      return json({ error: "Invalid telemetry payload" }, 400);
-    }
-  }
-
-  // GET /api/telemetry/stream - SSE stream for real-time telemetry
-  if (path === "/api/telemetry/stream" && method === "GET") {
-    let controller: ReadableStreamDefaultController<string>;
-
-    const stream = new ReadableStream<string>({
-      start(c) {
-        controller = c;
-        telemetryBroadcaster.addClient(controller);
-        // Send initial connection message
-        controller.enqueue("data: {\"connected\":true}\n\n");
-      },
-      cancel() {
-        telemetryBroadcaster.removeClient(controller);
-      },
-    });
-
-    return new Response(stream, {
-      headers: {
-        "Content-Type": "text/event-stream",
-        "Cache-Control": "no-cache, no-transform",
-        "Connection": "keep-alive",
-        "X-Accel-Buffering": "no",
-      },
-    });
-  }
-
-  // GET /api/telemetry/events - Query telemetry events
-  if (path === "/api/telemetry/events" && method === "GET") {
-    const url = new URL(req.url);
-    const projectIdParam = url.searchParams.get("project_id");
-    const events = TelemetryDB.query({
-      agent_id: url.searchParams.get("agent_id") || undefined,
-      project_id: projectIdParam === "null" ? null : projectIdParam || undefined,
-      category: url.searchParams.get("category") || undefined,
-      type: url.searchParams.get("type") || undefined,
-      level: url.searchParams.get("level") || undefined,
-      trace_id: url.searchParams.get("trace_id") || undefined,
-      since: url.searchParams.get("since") || undefined,
-      until: url.searchParams.get("until") || undefined,
-      limit: parseInt(url.searchParams.get("limit") || "100"),
-      offset: parseInt(url.searchParams.get("offset") || "0"),
-    });
-    return json({ events });
-  }
-
-  // GET /api/telemetry/usage - Get usage statistics
-  if (path === "/api/telemetry/usage" && method === "GET") {
-    const url = new URL(req.url);
-    const projectIdParam = url.searchParams.get("project_id");
-    const usage = TelemetryDB.getUsage({
-      agent_id: url.searchParams.get("agent_id") || undefined,
-      project_id: projectIdParam === "null" ? null : projectIdParam || undefined,
-      since: url.searchParams.get("since") || undefined,
-      until: url.searchParams.get("until") || undefined,
-      group_by: (url.searchParams.get("group_by") as "agent" | "day" | "project") || undefined,
-    });
-    return json({ usage });
-  }
-
-  // GET /api/telemetry/stats - Get summary statistics
-  if (path === "/api/telemetry/stats" && method === "GET") {
-    const url = new URL(req.url);
-    const agentId = url.searchParams.get("agent_id") || undefined;
-    const projectIdParam = url.searchParams.get("project_id");
-    const stats = TelemetryDB.getStats({
-      agentId,
-      projectId: projectIdParam === "null" ? null : projectIdParam || undefined,
-      since: url.searchParams.get("since") || undefined,
-      until: url.searchParams.get("until") || undefined,
-    });
-    return json({ stats });
-  }
-
-  // POST /api/telemetry/clear - Clear all telemetry data
-  if (path === "/api/telemetry/clear" && method === "POST") {
-    const deleted = TelemetryDB.deleteOlderThan(0); // Delete all
-    return json({ deleted });
-  }
-
-  // --- Notification endpoints (piggyback on telemetry `seen` flag) ---
-
-  // GET /api/notifications - Get notification-worthy events
-  if (path === "/api/notifications" && method === "GET") {
-    const url = new URL(req.url);
-    const limit = parseInt(url.searchParams.get("limit") || "50");
-    const notifications = TelemetryDB.getNotifications(limit);
-    return json({ notifications });
-  }
-
-  // GET /api/notifications/count - Get unseen notification count
-  if (path === "/api/notifications/count" && method === "GET") {
-    const count = TelemetryDB.getUnseenCount();
-    return json({ count });
-  }
-
-  // POST /api/notifications/mark-seen - Mark specific notifications as seen
-  if (path === "/api/notifications/mark-seen" && method === "POST") {
-    const body = await req.json() as { ids?: string[]; all?: boolean };
-    if (body.all) {
-      const updated = TelemetryDB.markAllSeen();
-      return json({ updated });
-    }
-    if (body.ids && body.ids.length > 0) {
-      const updated = TelemetryDB.markSeen(body.ids);
-      return json({ updated });
-    }
-    return json({ error: "Provide ids array or all: true" }, 400);
-  }
-
-  return null;
-}

package/src/routes/api/tests.ts

@@ -1,148 +0,0 @@
-import { json } from "./helpers";
-import { TestCaseDB, TestRunDB } from "../../db-tests";
-import { AgentDB } from "../../db";
-import { runTest, runAll } from "../../test-runner";
-
-export async function handleTestRoutes(
-  req: Request,
-  path: string,
-  method: string,
-): Promise<Response | null> {
-  // GET /api/tests - List test cases
-  if (path === "/api/tests" && method === "GET") {
-    const url = new URL(req.url);
-    const projectId = url.searchParams.get("project_id") || undefined;
-    const tests = TestCaseDB.findAll(projectId);
-
-    // Enrich with agent name and latest run
-    const enriched = tests.map(tc => {
-      const agent = tc.agent_id ? AgentDB.findById(tc.agent_id) : null;
-      const lastRun = TestRunDB.getLatestByTestCase(tc.id);
-      return {
-        ...tc,
-        agent_name: agent?.name || null,
-        agent_status: agent?.status || null,
-        last_run: lastRun ? {
-          id: lastRun.id,
-          status: lastRun.status,
-          score: lastRun.score,
-          duration_ms: lastRun.duration_ms,
-          judge_reasoning: lastRun.judge_reasoning,
-          generated_message: lastRun.generated_message,
-          selected_agent_id: lastRun.selected_agent_id,
-          selected_agent_name: lastRun.selected_agent_name,
-          planner_reasoning: lastRun.planner_reasoning,
-          created_at: lastRun.created_at,
-        } : null,
-      };
-    });
-
-    return json(enriched);
-  }
-
-  // POST /api/tests - Create test case
-  if (path === "/api/tests" && method === "POST") {
-    const body = await req.json() as any;
-
-    // Behavior-driven: only name + behavior required
-    // Legacy: name + agent_id + input_message + eval_criteria required
-    if (!body.name) {
-      return json({ error: "Missing required field: name" }, 400);
-    }
-
-    if (!body.behavior && (!body.agent_id || !body.input_message)) {
-      return json({ error: "Either 'behavior' or both 'agent_id' and 'input_message' are required" }, 400);
-    }
-
-    // Validate agent if explicitly specified
-    if (body.agent_id) {
-      const agent = AgentDB.findById(body.agent_id);
-      if (!agent) {
-        return json({ error: "Agent not found" }, 404);
-      }
-    }
-
-    const testCase = TestCaseDB.create({
-      name: body.name,
-      description: body.description,
-      behavior: body.behavior,
-      agent_id: body.agent_id || null,
-      input_message: body.input_message || null,
-      eval_criteria: body.eval_criteria,
-      project_id: body.project_id,
-    });
-
-    return json(testCase, 201);
-  }
-
-  // PUT /api/tests/:id - Update test case
-  const updateMatch = path.match(/^\/api\/tests\/([^/]+)$/);
-  if (updateMatch && method === "PUT") {
-    const body = await req.json() as any;
-    const updated = TestCaseDB.update(updateMatch[1], body);
-    if (!updated) {
-      return json({ error: "Test case not found" }, 404);
-    }
-    return json(updated);
-  }
-
-  // DELETE /api/tests/:id - Delete test case
-  if (updateMatch && method === "DELETE") {
-    const deleted = TestCaseDB.delete(updateMatch[1]);
-    if (!deleted) {
-      return json({ error: "Test case not found" }, 404);
-    }
-    return json({ success: true });
-  }
-
-  // POST /api/tests/:id/run - Run single test
-  const runSingleMatch = path.match(/^\/api\/tests\/([^/]+)\/run$/);
-  if (runSingleMatch && method === "POST") {
-    const testCase = TestCaseDB.findById(runSingleMatch[1]);
-    if (!testCase) {
-      return json({ error: "Test case not found" }, 404);
-    }
-
-    const result = await runTest(testCase);
-    return json(result);
-  }
-
-  // POST /api/tests/run - Run all (or filtered) tests
-  if (path === "/api/tests/run" && method === "POST") {
-    const body = await req.json().catch(() => ({})) as any;
-    const testCaseIds = body.test_case_ids as string[] | undefined;
-
-    const results = await runAll(testCaseIds);
-    const passed = results.filter(r => r.status === "passed").length;
-    const failed = results.filter(r => r.status === "failed").length;
-    const errors = results.filter(r => r.status === "error").length;
-
-    return json({
-      summary: { total: results.length, passed, failed, errors },
-      results,
-    });
-  }
-
-  // GET /api/tests/:id/runs - Get run history for a test
-  const runsMatch = path.match(/^\/api\/tests\/([^/]+)\/runs$/);
-  if (runsMatch && method === "GET") {
-    const testCase = TestCaseDB.findById(runsMatch[1]);
-    if (!testCase) {
-      return json({ error: "Test case not found" }, 404);
-    }
-    const runs = TestRunDB.findByTestCase(runsMatch[1]);
-    return json(runs);
-  }
-
-  // GET /api/tests/runs/:runId - Get single run details
-  const runDetailMatch = path.match(/^\/api\/tests\/runs\/([^/]+)$/);
-  if (runDetailMatch && method === "GET") {
-    const run = TestRunDB.findById(runDetailMatch[1]);
-    if (!run) {
-      return json({ error: "Test run not found" }, 404);
-    }
-    return json(run);
-  }
-
-  return null;
-}