apteva 0.4.15 → 0.4.16

package/src/mcp-handler.ts

@@ -0,0 +1,387 @@
+// Local MCP server handler
+// Handles JSON-RPC requests for servers of type "local"
+// Tools are stored in the database with configurable handler types: mock, http, javascript
+
+import { McpServerDB, McpServerToolDB, type McpServerTool } from "./db";
+
+const PROTOCOL_VERSION = "2024-11-05";
+
+interface JsonRpcRequest {
+  jsonrpc: "2.0";
+  id: number;
+  method: string;
+  params?: any;
+}
+
+interface JsonRpcResponse {
+  jsonrpc: "2.0";
+  id: number;
+  result?: unknown;
+  error?: { code: number; message: string; data?: unknown };
+}
+
+// Template helpers available in mock_response and javascript handlers
+function templateHelpers() {
+  return {
+    uuid: () => crypto.randomUUID(),
+    now: new Date().toISOString(),
+    timestamp: Date.now(),
+    random_int: (min: number, max: number) =>
+      Math.floor(Math.random() * (max - min + 1)) + min,
+    random_float: (min: number, max: number) =>
+      Math.random() * (max - min) + min,
+  };
+}
+
+// Render mock response template with variable substitution
+// Supports: {{args.field}}, {{uuid()}}, {{now}}, {{timestamp}}, {{random_int(min,max)}}
+function renderTemplate(template: any, args: Record<string, any>): any {
+  const helpers = templateHelpers();
+
+  if (typeof template === "string") {
+    // Check if entire string is a single expression
+    const fullMatch = template.match(/^\{\{(.+)\}\}$/);
+    if (fullMatch) {
+      return evaluateExpression(fullMatch[1].trim(), args, helpers);
+    }
+    // Replace embedded expressions
+    return template.replace(/\{\{([^}]+)\}\}/g, (_, expr) => {
+      const result = evaluateExpression(expr.trim(), args, helpers);
+      if (result === null || result === undefined) return "";
+      if (typeof result === "object") return JSON.stringify(result);
+      return String(result);
+    });
+  }
+
+  if (Array.isArray(template)) {
+    return template.map((item) => renderTemplate(item, args));
+  }
+
+  if (template !== null && typeof template === "object") {
+    const result: Record<string, any> = {};
+    for (const [key, val] of Object.entries(template)) {
+      result[key] = renderTemplate(val, args);
+    }
+    return result;
+  }
+
+  return template;
+}
+
+function evaluateExpression(
+  expr: string,
+  args: Record<string, any>,
+  helpers: ReturnType<typeof templateHelpers>,
+): any {
+  // Handle args.* references
+  if (expr.startsWith("args.")) {
+    const key = expr.slice(5);
+    return args[key] ?? null;
+  }
+
+  // Handle helper functions and values
+  try {
+    const fn = new Function(
+      "args",
+      "uuid",
+      "now",
+      "timestamp",
+      "random_int",
+      "random_float",
+      `return ${expr}`,
+    );
+    return fn(
+      args,
+      helpers.uuid,
+      helpers.now,
+      helpers.timestamp,
+      helpers.random_int,
+      helpers.random_float,
+    );
+  } catch {
+    return expr;
+  }
+}
+
+// Execute a mock handler — returns the rendered mock_response
+function executeMock(
+  tool: McpServerTool,
+  args: Record<string, any>,
+): { content: Array<{ type: "text"; text: string }>; isError?: boolean } {
+  const mockResponse = tool.mock_response || {};
+  const rendered = renderTemplate(mockResponse, args);
+  return {
+    content: [{ type: "text", text: JSON.stringify(rendered, null, 2) }],
+  };
+}
+
+// Execute an HTTP handler — makes a real API call
+async function executeHttp(
+  tool: McpServerTool,
+  args: Record<string, any>,
+  credentials: Record<string, string>,
+): Promise<{ content: Array<{ type: "text"; text: string }>; isError?: boolean }> {
+  const config = tool.http_config;
+  if (!config || !config.url) {
+    return {
+      content: [{ type: "text", text: "Error: No HTTP config or URL defined" }],
+      isError: true,
+    };
+  }
+
+  const { method = "GET", url, headers = {}, body } = config;
+
+  // Render templates in URL, headers, and body
+  const renderedUrl = renderTemplate(url, args) as string;
+  const renderedHeaders = renderTemplate(headers, args) as Record<string, string>;
+
+  // Substitute credential references in headers
+  const finalHeaders: Record<string, string> = { "Content-Type": "application/json" };
+  for (const [k, v] of Object.entries(renderedHeaders)) {
+    let val = String(v);
+    // Replace {{credential.*}} references
+    val = val.replace(/\{\{credential\.([^}]+)\}\}/g, (_, key) => credentials[key] || "");
+    finalHeaders[k] = val;
+  }
+
+  const fetchOptions: RequestInit = {
+    method: method.toUpperCase(),
+    headers: finalHeaders,
+  };
+
+  if (["POST", "PUT", "PATCH"].includes(fetchOptions.method!)) {
+    if (body) {
+      const renderedBody = renderTemplate(body, args);
+      fetchOptions.body = JSON.stringify(renderedBody);
+    } else {
+      fetchOptions.body = JSON.stringify(args);
+    }
+  }
+
+  try {
+    const response = await fetch(renderedUrl, fetchOptions);
+    const text = await response.text();
+
+    let data;
+    try {
+      data = JSON.parse(text);
+    } catch {
+      data = text;
+    }
+
+    if (!response.ok) {
+      return {
+        content: [
+          {
+            type: "text",
+            text: `HTTP ${response.status}: ${typeof data === "string" ? data : JSON.stringify(data, null, 2)}`,
+          },
+        ],
+        isError: true,
+      };
+    }
+
+    return {
+      content: [
+        {
+          type: "text",
+          text: typeof data === "string" ? data : JSON.stringify(data, null, 2),
+        },
+      ],
+    };
+  } catch (err) {
+    return {
+      content: [{ type: "text", text: `HTTP error: ${err}` }],
+      isError: true,
+    };
+  }
+}
+
+// Execute a JavaScript handler — runs code string with args + credentials
+function executeJavascript(
+  tool: McpServerTool,
+  args: Record<string, any>,
+  credentials: Record<string, string>,
+): { content: Array<{ type: "text"; text: string }>; isError?: boolean } {
+  if (!tool.code) {
+    return {
+      content: [{ type: "text", text: "Error: No code defined for this tool" }],
+      isError: true,
+    };
+  }
+
+  try {
+    const helpers = templateHelpers();
+    const fn = new Function(
+      "args",
+      "credentials",
+      "uuid",
+      "now",
+      "timestamp",
+      "random_int",
+      "random_float",
+      tool.code,
+    );
+    const result = fn(
+      args,
+      credentials,
+      helpers.uuid,
+      helpers.now,
+      helpers.timestamp,
+      helpers.random_int,
+      helpers.random_float,
+    );
+    const text =
+      typeof result === "string" ? result : JSON.stringify(result, null, 2);
+    return { content: [{ type: "text", text }] };
+  } catch (err) {
+    return {
+      content: [{ type: "text", text: `JavaScript error: ${err}` }],
+      isError: true,
+    };
+  }
+}
+
+// Execute a tool based on its handler_type
+async function executeTool(
+  tool: McpServerTool,
+  args: Record<string, any>,
+  credentials: Record<string, string>,
+): Promise<{ content: Array<{ type: "text"; text: string }>; isError?: boolean }> {
+  switch (tool.handler_type) {
+    case "http":
+      return executeHttp(tool, args, credentials);
+    case "javascript":
+      return executeJavascript(tool, args, credentials);
+    case "mock":
+    default:
+      return executeMock(tool, args);
+  }
+}
+
+// Main JSON-RPC handler for local MCP servers
+export async function handleLocalMcpRequest(
+  req: Request,
+  serverId: string,
+): Promise<Response> {
+  const corsHeaders = {
+    "Access-Control-Allow-Origin": "*",
+    "Access-Control-Allow-Methods": "POST, OPTIONS",
+    "Access-Control-Allow-Headers": "Content-Type, Mcp-Session-Id",
+  };
+
+  if (req.method === "OPTIONS") {
+    return new Response(null, { headers: corsHeaders });
+  }
+
+  const server = McpServerDB.findById(serverId);
+  if (!server || server.type !== "local") {
+    return new Response(
+      JSON.stringify({
+        jsonrpc: "2.0",
+        id: 0,
+        error: { code: -32600, message: "Server not found or not a local server" },
+      }),
+      { headers: { ...corsHeaders, "Content-Type": "application/json" } },
+    );
+  }
+
+  let body: JsonRpcRequest;
+  try {
+    body = (await req.json()) as JsonRpcRequest;
+  } catch {
+    return new Response(
+      JSON.stringify({
+        jsonrpc: "2.0",
+        id: 0,
+        error: { code: -32700, message: "Parse error" },
+      }),
+      { headers: { ...corsHeaders, "Content-Type": "application/json" } },
+    );
+  }
+
+  const { method, params, id } = body;
+  let result: unknown;
+  let error: { code: number; message: string } | undefined;
+
+  // Parse server credentials
+  let credentials: Record<string, string> = {};
+  try {
+    if (server.env && Object.keys(server.env).length > 0) {
+      credentials = server.env;
+    }
+  } catch {
+    // ignore
+  }
+
+  switch (method) {
+    case "initialize": {
+      result = {
+        protocolVersion: PROTOCOL_VERSION,
+        capabilities: {
+          tools: { listChanged: false },
+        },
+        serverInfo: {
+          name: server.name,
+          version: "1.0.0",
+        },
+      };
+      break;
+    }
+
+    case "notifications/initialized": {
+      result = {};
+      break;
+    }
+
+    case "tools/list": {
+      const tools = McpServerToolDB.findByServer(serverId);
+      result = {
+        tools: tools
+          .filter((t) => t.enabled)
+          .map((t) => ({
+            name: t.name,
+            description: t.description,
+            inputSchema: t.input_schema,
+          })),
+      };
+      break;
+    }
+
+    case "tools/call": {
+      const { name, arguments: args } = params as {
+        name: string;
+        arguments: Record<string, any>;
+      };
+      const tool = McpServerToolDB.findByServerAndName(serverId, name);
+      if (!tool) {
+        result = {
+          content: [{ type: "text", text: `Tool '${name}' not found` }],
+          isError: true,
+        };
+      } else if (!tool.enabled) {
+        result = {
+          content: [{ type: "text", text: `Tool '${name}' is disabled` }],
+          isError: true,
+        };
+      } else {
+        result = await executeTool(tool, args || {}, credentials);
+      }
+      break;
+    }
+
+    default: {
+      error = { code: -32601, message: `Method not found: ${method}` };
+    }
+  }
+
+  const response: JsonRpcResponse = {
+    jsonrpc: "2.0",
+    id: id || 0,
+    ...(error ? { error } : { result }),
+  };
+
+  return new Response(JSON.stringify(response), {
+    headers: { ...corsHeaders, "Content-Type": "application/json" },
+  });
+}

package/src/routes/api/agent-utils.ts

@@ -126,7 +126,17 @@ export function buildAgentConfig(agent: Agent, providerKey: string) {
     const server = McpServerDB.findById(id);
     if (!server) continue;
 
-    if (server.type === "http" && server.url) {
+    if (server.type === "local" && server.status === "running") {
+      // Local MCP server (in-process, no subprocess)
+      const baseUrl = `http://localhost:${process.env.PORT || 4280}`;
+      mcpServers.push({
+        name: server.name,
+        type: "http",
+        url: `${baseUrl}/api/mcp/servers/${server.id}/mcp`,
+        headers: {},
+        enabled: true,
+      });
+    } else if (server.type === "http" && server.url) {
       // Remote HTTP server (Composio, Smithery, or custom)
       mcpServers.push({
         name: server.name,
@@ -136,7 +146,7 @@ export function buildAgentConfig(agent: Agent, providerKey: string) {
         enabled: true,
       });
     } else if (server.status === "running" && server.port) {
-      // Local MCP server (npm, github, custom)
+      // Subprocess MCP server (npm, github, custom)
       mcpServers.push({
         name: server.name,
         type: "http",

package/src/routes/api/mcp.ts

@@ -1,6 +1,6 @@
 import { spawn } from "bun";
 import { json } from "./helpers";
-import { McpServerDB, generateId, type McpServer } from "../../db";
+import { McpServerDB, McpServerToolDB, generateId, type McpServer } from "../../db";
 import { getNextPort } from "../../server";
 import {
   startMcpProcess,
@@ -11,6 +11,7 @@ import {
   getMcpProcess,
   getHttpMcpClient,
 } from "../../mcp-client";
+import { handleLocalMcpRequest } from "../../mcp-handler";
 
 export async function handleMcpRoutes(
   req: Request,
@@ -121,6 +122,12 @@ export async function handleMcpRoutes(
     }
   }
 
+  // POST /api/mcp/servers/:id/mcp - JSON-RPC endpoint for local MCP servers
+  const mcpJsonRpcMatch = path.match(/^\/api\/mcp\/servers\/([^/]+)\/mcp$/);
+  if (mcpJsonRpcMatch && method === "POST") {
+    return handleLocalMcpRequest(req, mcpJsonRpcMatch[1]);
+  }
+
   // GET /api/mcp/servers/:id - Get a specific MCP server
   const mcpServerMatch = path.match(/^\/api\/mcp\/servers\/([^/]+)$/);
   if (mcpServerMatch && method === "GET") {
@@ -168,8 +175,13 @@ export async function handleMcpRoutes(
     }
 
     // Stop if running
-    if (server.status === "running") {
-      // TODO: Stop the server process
+    if (server.status === "running" && server.type !== "local") {
+      stopMcpProcess(server.id);
+    }
+
+    // Delete tools if local server
+    if (server.type === "local") {
+      McpServerToolDB.deleteByServer(mcpServerMatch[1]);
     }
 
     McpServerDB.delete(mcpServerMatch[1]);
@@ -188,6 +200,19 @@ export async function handleMcpRoutes(
       return json({ error: "MCP server already running" }, 400);
     }
 
+    // Local servers: just flip status and set the MCP endpoint URL
+    if (server.type === "local") {
+      const updated = McpServerDB.update(server.id, {
+        status: "running",
+        url: `/api/mcp/servers/${server.id}/mcp`,
+      });
+      return json({
+        server: updated,
+        message: "Local MCP server started",
+        mcpUrl: `/api/mcp/servers/${server.id}/mcp`,
+      });
+    }
+
     // Determine command to run
     // Helper to substitute $ENV_VAR references with actual values
     const substituteEnvVars = (str: string, env: Record<string, string>): string => {
@@ -276,6 +301,12 @@ export async function handleMcpRoutes(
       return json({ error: "MCP server not found" }, 404);
     }
 
+    // Local servers: just flip status
+    if (server.type === "local") {
+      const updated = McpServerDB.update(server.id, { status: "stopped" });
+      return json({ server: updated, message: "Local MCP server stopped" });
+    }
+
     // Stop the MCP process
     stopMcpProcess(server.id);
 
@@ -291,6 +322,22 @@ export async function handleMcpRoutes(
       return json({ error: "MCP server not found" }, 404);
     }
 
+    // Local servers: read tools from database
+    if (server.type === "local") {
+      const tools = McpServerToolDB.findByServer(server.id);
+      return json({
+        serverInfo: { name: server.name, version: "1.0.0" },
+        tools: tools.map((t) => ({
+          id: t.id,
+          name: t.name,
+          description: t.description,
+          inputSchema: t.input_schema,
+          handler_type: t.handler_type,
+          enabled: t.enabled,
+        })),
+      });
+    }
+
     // HTTP servers use remote HTTP transport
     if (server.type === "http" && server.url) {
       try {
@@ -328,6 +375,101 @@ export async function handleMcpRoutes(
     }
   }
 
+  // POST /api/mcp/servers/:id/tools - Add a tool to a local MCP server
+  if (mcpToolsMatch && method === "POST") {
+    const server = McpServerDB.findById(mcpToolsMatch[1]);
+    if (!server) {
+      return json({ error: "MCP server not found" }, 404);
+    }
+    if (server.type !== "local") {
+      return json({ error: "Tools can only be added to local servers" }, 400);
+    }
+
+    try {
+      const body = await req.json();
+      if (!body.name || !body.description) {
+        return json({ error: "name and description are required" }, 400);
+      }
+
+      // Check for duplicate tool name
+      const existing = McpServerToolDB.findByServerAndName(server.id, body.name);
+      if (existing) {
+        return json({ error: `Tool '${body.name}' already exists on this server` }, 409);
+      }
+
+      const tool = McpServerToolDB.create({
+        id: generateId(),
+        server_id: server.id,
+        name: body.name,
+        description: body.description,
+        input_schema: body.input_schema || { type: "object", properties: {} },
+        handler_type: body.handler_type || "mock",
+        mock_response: body.mock_response || null,
+        http_config: body.http_config || null,
+        code: body.code || null,
+        enabled: body.enabled !== false,
+      });
+
+      return json({ tool }, 201);
+    } catch (e) {
+      console.error("Create tool error:", e);
+      return json({ error: "Invalid request body" }, 400);
+    }
+  }
+
+  // PUT /api/mcp/servers/:id/tools/:toolId - Update a tool on a local MCP server
+  const mcpToolUpdateMatch = path.match(/^\/api\/mcp\/servers\/([^/]+)\/tools\/([^/]+)$/);
+  if (mcpToolUpdateMatch && method === "PUT") {
+    const server = McpServerDB.findById(mcpToolUpdateMatch[1]);
+    if (!server) {
+      return json({ error: "MCP server not found" }, 404);
+    }
+    if (server.type !== "local") {
+      return json({ error: "Tools can only be updated on local servers" }, 400);
+    }
+
+    const tool = McpServerToolDB.findById(mcpToolUpdateMatch[2]);
+    if (!tool || tool.server_id !== server.id) {
+      return json({ error: "Tool not found" }, 404);
+    }
+
+    try {
+      const body = await req.json();
+      const updated = McpServerToolDB.update(tool.id, {
+        ...(body.name !== undefined && { name: body.name }),
+        ...(body.description !== undefined && { description: body.description }),
+        ...(body.input_schema !== undefined && { input_schema: body.input_schema }),
+        ...(body.handler_type !== undefined && { handler_type: body.handler_type }),
+        ...(body.mock_response !== undefined && { mock_response: body.mock_response }),
+        ...(body.http_config !== undefined && { http_config: body.http_config }),
+        ...(body.code !== undefined && { code: body.code }),
+        ...(body.enabled !== undefined && { enabled: body.enabled }),
+      });
+      return json({ tool: updated });
+    } catch (e) {
+      return json({ error: "Invalid request body" }, 400);
+    }
+  }
+
+  // DELETE /api/mcp/servers/:id/tools/:toolId - Delete a tool from a local MCP server
+  if (mcpToolUpdateMatch && method === "DELETE") {
+    const server = McpServerDB.findById(mcpToolUpdateMatch[1]);
+    if (!server) {
+      return json({ error: "MCP server not found" }, 404);
+    }
+    if (server.type !== "local") {
+      return json({ error: "Tools can only be deleted from local servers" }, 400);
+    }
+
+    const tool = McpServerToolDB.findById(mcpToolUpdateMatch[2]);
+    if (!tool || tool.server_id !== server.id) {
+      return json({ error: "Tool not found" }, 404);
+    }
+
+    McpServerToolDB.delete(tool.id);
+    return json({ success: true });
+  }
+
   // POST /api/mcp/servers/:id/tools/:toolName/call - Call a tool on an MCP server
   const mcpToolCallMatch = path.match(/^\/api\/mcp\/servers\/([^/]+)\/tools\/([^/]+)\/call$/);
   if (mcpToolCallMatch && method === "POST") {
@@ -338,6 +480,35 @@ export async function handleMcpRoutes(
 
     const toolName = decodeURIComponent(mcpToolCallMatch[2]);
 
+    // Local servers: execute tool handler directly
+    if (server.type === "local") {
+      const tool = McpServerToolDB.findByServerAndName(server.id, toolName);
+      if (!tool) {
+        return json({ error: `Tool '${toolName}' not found` }, 404);
+      }
+      if (!tool.enabled) {
+        return json({ error: `Tool '${toolName}' is disabled` }, 400);
+      }
+
+      // Forward to JSON-RPC handler via a synthetic request
+      const syntheticReq = new Request(req.url, {
+        method: "POST",
+        headers: { "Content-Type": "application/json" },
+        body: JSON.stringify({
+          jsonrpc: "2.0",
+          id: 1,
+          method: "tools/call",
+          params: {
+            name: toolName,
+            arguments: (await req.json()).arguments || {},
+          },
+        }),
+      });
+      const mcpResponse = await handleLocalMcpRequest(syntheticReq, server.id);
+      const mcpResult = await mcpResponse.json() as any;
+      return json({ result: mcpResult.result });
+    }
+
     // HTTP servers use remote HTTP transport
     if (server.type === "http" && server.url) {
       try {

package/src/server.ts

@@ -357,7 +357,7 @@ const server = Bun.serve({
     const corsHeaders = {
       "Access-Control-Allow-Origin": allowOrigin,
       "Access-Control-Allow-Methods": "GET, POST, PUT, DELETE, OPTIONS",
-      "Access-Control-Allow-Headers": "Content-Type, Authorization",
+      "Access-Control-Allow-Headers": "Content-Type, Authorization, X-API-Key",
       "Access-Control-Allow-Credentials": "true",
     };
 

package/src/web/App.tsx

@@ -23,6 +23,7 @@ import {
   CreateAgentModal,
   AgentsView,
   Dashboard,
+  ActivityPage,
   TasksPage,
   McpPage,
   SkillsPage,
@@ -254,6 +255,13 @@ function AppContent() {
         <main className="flex-1 overflow-hidden flex">
           {route === "settings" && <SettingsPage />}
 
+          {route === "activity" && (
+            <ActivityPage
+              agents={agents}
+              loading={loading}
+            />
+          )}
+
           {route === "agents" && (
             <AgentsView
               agents={agents}