apteva 0.4.3 → 0.4.5

package/src/routes/api/system.ts

@@ -0,0 +1,215 @@
+import { json } from "./helpers";
+import { META_AGENT_ENABLED, fetchFromAgent, 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",
+    });
+  }
+
+  // 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
+    const restartResults: { id: string; name: string; success: boolean; error?: string }[] = [];
+    for (const agentId of agentsToRestart) {
+      const agent = AgentDB.findById(agentId);
+      if (agent) {
+        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 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 runningAgents = AgentDB.findAll().filter(a => a.status === "running" && a.port);
+    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,
+          });
+        }
+      }
+    }
+
+    // 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 } });
+  }
+
+  // GET /api/dashboard - Get dashboard statistics
+  if (path === "/api/dashboard" && method === "GET") {
+    const agents = AgentDB.findAll();
+    const runningAgents = agents.filter(a => a.status === "running" && a.port);
+
+    let totalTasks = 0;
+    let pendingTasks = 0;
+    let completedTasks = 0;
+    let runningTasks = 0;
+
+    for (const agent of runningAgents) {
+      const data = await fetchFromAgent(agent.id, agent.port!, "/tasks?status=all");
+      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

@@ -0,0 +1,142 @@
+import { json } from "./helpers";
+import { TelemetryDB } from "../../db";
+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");
+      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,
+        }));
+        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,
+      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") || 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,
+    });
+    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 });
+  }
+
+  return null;
+}

package/src/routes/api/users.ts

@@ -0,0 +1,148 @@
+import { json } from "./helpers";
+import { UserDB } from "../../db";
+import { createUser, hashPassword, validatePassword } from "../../auth";
+import type { AuthContext } from "../../auth/middleware";
+
+export async function handleUserRoutes(
+  req: Request,
+  path: string,
+  method: string,
+  authContext?: AuthContext,
+): Promise<Response | null> {
+  const user = authContext?.user;
+
+  // GET /api/users - List all users
+  if (path === "/api/users" && method === "GET") {
+    const users = UserDB.findAll().map(u => ({
+      id: u.id,
+      username: u.username,
+      email: u.email,
+      role: u.role,
+      createdAt: u.created_at,
+      lastLoginAt: u.last_login_at,
+    }));
+    return json({ users });
+  }
+
+  // POST /api/users - Create a new user
+  if (path === "/api/users" && method === "POST") {
+    try {
+      const body = await req.json();
+      const { username, password, email, role } = body;
+
+      if (!username || !password) {
+        return json({ error: "Username and password are required" }, 400);
+      }
+
+      const result = await createUser({
+        username,
+        password,
+        email: email || undefined,
+        role: role || "user",
+      });
+
+      if (!result.success) {
+        return json({ error: result.error }, 400);
+      }
+
+      return json({
+        user: {
+          id: result.user!.id,
+          username: result.user!.username,
+          email: result.user!.email,
+          role: result.user!.role,
+          createdAt: result.user!.created_at,
+        },
+      }, 201);
+    } catch (e) {
+      return json({ error: "Invalid request body" }, 400);
+    }
+  }
+
+  // GET /api/users/:id - Get a specific user
+  const userMatch = path.match(/^\/api\/users\/([^/]+)$/);
+  if (userMatch && method === "GET") {
+    const targetUser = UserDB.findById(userMatch[1]);
+    if (!targetUser) {
+      return json({ error: "User not found" }, 404);
+    }
+    return json({
+      user: {
+        id: targetUser.id,
+        username: targetUser.username,
+        email: targetUser.email,
+        role: targetUser.role,
+        createdAt: targetUser.created_at,
+        lastLoginAt: targetUser.last_login_at,
+      },
+    });
+  }
+
+  // PUT /api/users/:id - Update a user
+  if (userMatch && method === "PUT") {
+    const targetUser = UserDB.findById(userMatch[1]);
+    if (!targetUser) {
+      return json({ error: "User not found" }, 404);
+    }
+
+    try {
+      const body = await req.json();
+      const updates: Parameters<typeof UserDB.update>[1] = {};
+
+      if (body.email !== undefined) updates.email = body.email;
+      if (body.role !== undefined) {
+        // Prevent removing last admin
+        if (targetUser.role === "admin" && body.role !== "admin") {
+          if (UserDB.countAdmins() <= 1) {
+            return json({ error: "Cannot remove the last admin" }, 400);
+          }
+        }
+        updates.role = body.role;
+      }
+      if (body.password !== undefined) {
+        const validation = validatePassword(body.password);
+        if (!validation.valid) {
+          return json({ error: validation.errors.join(". ") }, 400);
+        }
+        updates.password_hash = await hashPassword(body.password);
+      }
+
+      const updated = UserDB.update(userMatch[1], updates);
+      return json({
+        user: updated ? {
+          id: updated.id,
+          username: updated.username,
+          email: updated.email,
+          role: updated.role,
+          createdAt: updated.created_at,
+          lastLoginAt: updated.last_login_at,
+        } : null,
+      });
+    } catch (e) {
+      return json({ error: "Invalid request body" }, 400);
+    }
+  }
+
+  // DELETE /api/users/:id - Delete a user
+  if (userMatch && method === "DELETE") {
+    const targetUser = UserDB.findById(userMatch[1]);
+    if (!targetUser) {
+      return json({ error: "User not found" }, 404);
+    }
+
+    // Prevent deleting yourself
+    if (user && targetUser.id === user.id) {
+      return json({ error: "Cannot delete your own account" }, 400);
+    }
+
+    // Prevent deleting last admin
+    if (targetUser.role === "admin" && UserDB.countAdmins() <= 1) {
+      return json({ error: "Cannot delete the last admin" }, 400);
+    }
+
+    UserDB.delete(userMatch[1]);
+    return json({ success: true });
+  }
+
+  return null;
+}