apteva 0.4.56 → 0.7.0

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

@@ -1,890 +0,0 @@
-import { spawn } from "bun";
-import { join } from "path";
-import { homedir } from "os";
-import { mkdirSync, existsSync, rmSync, writeFileSync, readFileSync } from "fs";
-import { agentProcesses, agentsStarting, getBinaryPathForAgent, getBinaryStatus, BIN_DIR, telemetryBroadcaster, isShuttingDown, type TelemetryEvent } from "../../server";
-import { AgentDB, McpServerDB, SkillDB, SubscriptionDB, TelemetryDB, generateId, getMultiAgentConfig, getOperatorConfig, type Agent, type Project } from "../../db";
-import { ProviderKeys, PROVIDERS, type ProviderId } from "../../providers";
-import { binaryExists } from "../../binary";
-
-// Data directory for agent instances (in ~/.apteva/agents/)
-export const AGENTS_DATA_DIR = process.env.DATA_DIR
-  ? join(process.env.DATA_DIR, "agents")
-  : join(homedir(), ".apteva", "agents");
-
-// Meta Agent configuration
-export const META_AGENT_ENABLED = process.env.META_AGENT_ENABLED === "true";
-export const META_AGENT_ID = "apteva-assistant";
-
-// Update agent status + emit telemetry event + broadcast to SSE
-export function setAgentStatus(agentId: string, status: "running" | "stopped", reason?: string): Agent | null {
-  const agent = AgentDB.setStatus(agentId, status);
-  const event: TelemetryEvent = {
-    id: generateId(),
-    agent_id: agentId,
-    timestamp: new Date().toISOString(),
-    category: "system",
-    type: status === "running" ? "agent_started" : "agent_stopped",
-    level: "info",
-    data: { reason: reason || status },
-  };
-  TelemetryDB.insertBatch(agentId, [event]);
-  telemetryBroadcaster.broadcast([event]);
-  return agent;
-}
-
-// Wait for agent to be healthy (with timeout)
-// Note: /health endpoint is whitelisted in agent, no auth needed
-export async function waitForAgentHealth(port: number, maxAttempts = 30, delayMs = 200): Promise<boolean> {
-  for (let i = 0; i < maxAttempts; i++) {
-    try {
-      const res = await fetch(`http://localhost:${port}/health`, {
-        signal: AbortSignal.timeout(1000),
-      });
-      if (res.ok) return true;
-    } catch {
-      // Not ready yet
-    }
-    await new Promise(r => setTimeout(r, delayMs));
-  }
-  return false;
-}
-
-// Check if a port is free by trying to connect
-export async function checkPortFree(port: number): Promise<boolean> {
-  return new Promise((resolve) => {
-    const net = require("net");
-    const server = net.createServer();
-    server.once("error", () => {
-      resolve(false); // Port in use
-    });
-    server.once("listening", () => {
-      server.close();
-      resolve(true); // Port is free
-    });
-    server.listen(port, "127.0.0.1");
-  });
-}
-
-// Make authenticated request to agent
-export async function agentFetch(
-  agentId: string,
-  port: number,
-  endpoint: string,
-  options: RequestInit = {}
-): Promise<Response> {
-  const apiKey = AgentDB.getApiKey(agentId);
-  const headers: Record<string, string> = {
-    ...(options.headers as Record<string, string> || {}),
-  };
-  if (apiKey) {
-    headers["X-API-Key"] = apiKey;
-  }
-  return fetch(`http://localhost:${port}${endpoint}`, {
-    ...options,
-    headers,
-  });
-}
-
-// Build operator config from features, resolving browser provider credentials
-function buildOperatorConfig(features: Agent["features"], projectId: string | null) {
-  const opConfig = getOperatorConfig(features);
-
-  if (!opConfig.enabled) {
-    return {
-      enabled: false,
-      display_width: 1024,
-      display_height: 768,
-      max_actions_per_turn: 5,
-    };
-  }
-
-  const browserProvider = opConfig.browser_provider || "browserengine";
-  const displayWidth = opConfig.display_width || 1024;
-  const displayHeight = opConfig.display_height || 768;
-  const maxActions = opConfig.max_actions_per_turn || 5;
-
-  const operatorResult: Record<string, unknown> = {
-    enabled: true,
-    browser_provider: browserProvider,
-    display_width: displayWidth,
-    display_height: displayHeight,
-    max_actions_per_turn: maxActions,
-  };
-
-  // Only include the active provider's config
-  if (browserProvider === "browserbase") {
-    const raw = ProviderKeys.getDecryptedForProject("browserbase", projectId);
-    if (raw) {
-      try {
-        const parsed = JSON.parse(raw);
-        operatorResult.browserbase = { api_key: parsed.api_key || raw, project_id: parsed.project_id || "" };
-      } catch {
-        operatorResult.browserbase = { api_key: raw, project_id: "" };
-      }
-    }
-  } else if (browserProvider === "steel") {
-    const apiKey = ProviderKeys.getDecryptedForProject("steel", projectId);
-    if (apiKey) {
-      operatorResult.steel = { api_key: apiKey, base_url: "https://api.steel.dev" };
-    }
-  } else if (browserProvider === "cdp") {
-    // CDP uses a URL, not an API key — stored as the provider key value
-    const cdpUrl = ProviderKeys.getDecryptedForProject("cdp", projectId);
-    if (cdpUrl) {
-      operatorResult.cdp = { url: cdpUrl };
-    }
-  } else {
-    // Default: browserengine
-    const apiKey = ProviderKeys.getDecryptedForProject("browserengine", projectId);
-    if (apiKey) {
-      operatorResult.browserengine = { api_key: apiKey, base_url: "https://api.browserengine.co" };
-    }
-  }
-
-  return operatorResult;
-}
-
-function buildRealtimeConfig(features: Agent["features"], projectId: string | null) {
-  // Backwards compatible: handle both boolean and RealtimeConfig
-  const realtimeVal = features.realtime;
-  const isEnabled = typeof realtimeVal === "boolean" ? realtimeVal : (realtimeVal as any)?.enabled ?? false;
-
-  if (!isEnabled) {
-    return { enabled: false, provider: "standard", stt: {}, tts: {} };
-  }
-
-  const rtConfig = typeof realtimeVal === "object" ? realtimeVal as Record<string, unknown> : {};
-  const rtProvider = (rtConfig.provider as string) || "standard";
-
-  // Native OpenAI Realtime mode
-  if (rtProvider === "openai") {
-    return {
-      enabled: true,
-      provider: "openai",
-      model: (rtConfig.model as string) || "gpt-realtime",
-      voice: (rtConfig.voice as string) || "alloy",
-      vad_type: (rtConfig.vadType as string) || "semantic_vad",
-    };
-  }
-
-  // Native Gemini Live mode
-  if (rtProvider === "gemini") {
-    return {
-      enabled: true,
-      provider: "gemini",
-      gemini_model: (rtConfig.geminiModel as string) || "",
-      gemini_voice: (rtConfig.geminiVoice as string) || "Kore",
-      google_search: (rtConfig.googleSearch as boolean) || false,
-    };
-  }
-
-  // Standard mode: STT → Core LLM → TTS pipeline
-  const sttProvider = (rtConfig.sttProvider as string) || "elevenlabs";
-  const sttModel = (rtConfig.sttModel as string) || (sttProvider === "elevenlabs" ? "scribe_v2_realtime" : undefined);
-  const ttsProvider = (rtConfig.ttsProvider as string) || "elevenlabs";
-  const ttsModel = (rtConfig.ttsModel as string) || undefined;
-
-  const sttProviderDef = PROVIDERS[sttProvider as ProviderId];
-  const ttsProviderDef = PROVIDERS[ttsProvider as ProviderId];
-
-  const sttConfig: Record<string, unknown> = { provider: sttProvider };
-  if (sttModel) sttConfig.model = sttModel;
-  // For local providers, include the base URL in the config
-  if (sttProviderDef && "isLocal" in sttProviderDef && sttProviderDef.isLocal) {
-    sttConfig.base_url = ProviderKeys.getDecryptedForProject(sttProvider, projectId) ||
-      ("defaultBaseUrl" in sttProviderDef ? (sttProviderDef as any).defaultBaseUrl : "");
-  }
-
-  const ttsConfig: Record<string, unknown> = { provider: ttsProvider };
-  if (ttsModel) ttsConfig.model = ttsModel;
-  if (ttsProviderDef && "isLocal" in ttsProviderDef && ttsProviderDef.isLocal) {
-    ttsConfig.base_url = ProviderKeys.getDecryptedForProject(ttsProvider, projectId) ||
-      ("defaultBaseUrl" in ttsProviderDef ? (ttsProviderDef as any).defaultBaseUrl : "");
-  }
-
-  return {
-    enabled: true,
-    provider: "standard",
-    stt: sttConfig,
-    tts: ttsConfig,
-  };
-}
-
-// Build agent config from apteva agent data
-// Note: POST /config expects flat structure WITHOUT "agent" wrapper
-export function buildAgentConfig(agent: Agent, providerKey: string) {
-  const features = agent.features;
-
-  // Get MCP server details for the agent's selected servers
-  const mcpServers: Array<{ name: string; type: "http"; url: string; headers: Record<string, string>; enabled: boolean }> = [];
-
-  // Get skill definitions for the agent's selected skills
-  const skillDefinitions: Array<{
-    name: string;
-    description: string;
-    instructions: string;
-    icon: string;
-    category: string;
-    tags: string[];
-    tools: string[];
-    enabled: boolean;
-  }> = [];
-
-  // Batch load skills and MCP servers (2 queries instead of N+M)
-  const skillMap = SkillDB.findByIds(agent.skills || []);
-  const mcpMap = McpServerDB.findByIds(agent.mcp_servers || []);
-
-  for (const skillId of agent.skills || []) {
-    const skill = skillMap.get(skillId);
-    if (!skill || !skill.enabled) continue;
-
-    skillDefinitions.push({
-      name: skill.name,
-      description: skill.description,
-      instructions: skill.content,
-      icon: "",
-      category: "",
-      tags: [],
-      tools: skill.allowed_tools || [],
-      enabled: true,
-    });
-  }
-
-  for (const id of agent.mcp_servers || []) {
-    const server = mcpMap.get(id);
-    if (!server) continue;
-
-    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,
-        type: "http",
-        url: server.url,
-        headers: server.headers || {},
-        enabled: true,
-      });
-    } else if (server.status === "running" && server.port) {
-      // Subprocess MCP server (npm, github, custom)
-      mcpServers.push({
-        name: server.name,
-        type: "http",
-        url: `http://localhost:${server.port}/mcp`,
-        headers: {},
-        enabled: true,
-      });
-    }
-  }
-
-  // Auto-inject built-in platform MCP server for meta agent
-  if (agent.id === META_AGENT_ID) {
-    const baseUrl = `http://localhost:${process.env.PORT || 4280}`;
-    mcpServers.push({
-      name: "Apteva Platform",
-      type: "http",
-      url: `${baseUrl}/api/mcp/platform`,
-      headers: {},
-      enabled: true,
-    });
-  }
-
-  return {
-    id: agent.id,
-    name: agent.name,
-    description: agent.system_prompt,
-    public_url: `http://localhost:${agent.port}`,
-    llm: {
-      provider: agent.provider,
-      model: agent.model,
-      max_tokens: 4000,
-      max_turns: features.maxTurns || 50,
-      temperature: 0.7,
-      system_prompt: agent.system_prompt,
-      vision: {
-        enabled: features.vision,
-        max_images: 20,
-        max_image_size: 5242880,
-        allowed_types: ["jpeg", "png", "gif", "webp"],
-        resize_images: true,
-        max_dimension: 1568,
-        pdf: {
-          enabled: features.vision,
-          max_file_size: 33554432,
-          max_pages: 100,
-          allow_urls: true,
-        },
-      },
-      parallel_tools: {
-        enabled: true,
-        max_concurrent: 10,
-      },
-      tools: [], // Clear any old tool whitelist - agent uses all registered tools
-      builtin_tools: [
-        ...(features.builtinTools?.webSearch ? [{ type: "web_search_20250305", name: "web_search" }] : []),
-        ...(features.builtinTools?.webFetch ? [{ type: "web_fetch_20250910", name: "web_fetch" }] : []),
-      ],
-    },
-    tasks: {
-      enabled: features.tasks,
-      allow_scheduling: true,
-      allow_recurring: true,
-      max_tasks: 100,
-      auto_execute: false,
-    },
-    scheduler: {
-      enabled: features.tasks,
-      interval: "1m",
-      max_tasks: 100,
-    },
-    memory: {
-      enabled: features.memory,
-      embedding_model: "text-embedding-3-small",
-      decision_model: "gpt-4o-mini",
-      max_memories_per_query: 20,
-      min_importance: 0.3,
-      min_similarity: 0.3,
-      auto_prune: true,
-      max_memories: 10000,
-      embedding_provider: "openai",
-      auto_extract_memories: features.memory ? true : null,
-      auto_ingest_files: true,
-    },
-    operator: buildOperatorConfig(features, agent.project_id),
-    mcp: {
-      enabled: features.mcp || agent.id === META_AGENT_ID,
-      base_url: "http://localhost:3000/mcp",
-      timeout: "30s",
-      retry_count: 3,
-      cache_ttl: "15m",
-      servers: mcpServers,
-    },
-    realtime: buildRealtimeConfig(features, agent.project_id),
-    context: {
-      max_messages: 30,
-      max_tokens: 0,
-      keep_images: 5,
-    },
-    filesystem: {
-      enabled: features.files,
-      max_file_size: 10485760,
-      max_total_size: 104857600,
-      auto_extract: true,
-      auto_cleanup: true,
-      retention_days: 7,
-    },
-    telemetry: {
-      enabled: true,
-      endpoint: `http://localhost:${process.env.PORT || 4280}/api/telemetry`,
-      batch_size: 1,
-      flush_interval: 1, // Every 1 second
-      categories: [], // Empty = all categories
-    },
-    skills: {
-      enabled: skillDefinitions.length > 0,
-      definitions: skillDefinitions,
-    },
-    agents: (() => {
-      const multiAgentConfig = getMultiAgentConfig(features, agent.project_id);
-      const baseUrl = process.env.PUBLIC_URL || `http://localhost:${process.env.PORT || 4280}`;
-      return {
-        enabled: multiAgentConfig.enabled,
-        group: multiAgentConfig.group || agent.project_id || undefined,
-        // This agent's reachable URL for peer communication
-        url: `http://localhost:${agent.port}`,
-        // Discovery endpoint to find peer agents in the same group
-        discovery_url: `${baseUrl}/api/discovery/agents`,
-      };
-    })(),
-  };
-}
-
-// Push config to running agent (with authentication)
-export async function pushConfigToAgent(agentId: string, port: number, config: any): Promise<{ success: boolean; error?: string }> {
-  try {
-    const res = await agentFetch(agentId, port, "/config", {
-      method: "POST",
-      headers: { "Content-Type": "application/json" },
-      body: JSON.stringify(config),
-      signal: AbortSignal.timeout(5000),
-    });
-    if (res.ok) {
-      return { success: true };
-    }
-    const data = await res.json().catch(() => ({}));
-    return { success: false, error: data.error || `HTTP ${res.status}` };
-  } catch (err) {
-    return { success: false, error: String(err) };
-  }
-}
-
-// Push skills to running agent via /skills endpoint (not config)
-export async function pushSkillsToAgent(agentId: string, port: number, skills: Array<{
-  name: string;
-  description: string;
-  instructions: string;
-  icon?: string;
-  category?: string;
-  tags?: string[];
-  tools?: string[];
-  enabled: boolean;
-}>): Promise<{ success: boolean; error?: string }> {
-  if (skills.length === 0) {
-    return { success: true };
-  }
-
-  try {
-    // Push all skills in parallel - try PUT first (update), then POST (create) if not found
-    await Promise.allSettled(skills.map(async (skill) => {
-      let res = await agentFetch(agentId, port, "/skills", {
-        method: "PUT",
-        headers: { "Content-Type": "application/json" },
-        body: JSON.stringify(skill),
-        signal: AbortSignal.timeout(5000),
-      });
-
-      if (res.status === 404) {
-        res = await agentFetch(agentId, port, "/skills", {
-          method: "POST",
-          headers: { "Content-Type": "application/json" },
-          body: JSON.stringify(skill),
-          signal: AbortSignal.timeout(5000),
-        });
-      }
-
-      if (!res.ok) {
-        const data = await res.json().catch(() => ({}));
-        console.error(`[pushSkillsToAgent] Failed to push skill ${skill.name}:`, data.error || res.status);
-      }
-    }));
-
-    // Enable skills globally via POST /skills/status
-    const statusRes = await agentFetch(agentId, port, "/skills/status", {
-      method: "POST",
-      headers: { "Content-Type": "application/json" },
-      body: JSON.stringify({ enabled: true }),
-      signal: AbortSignal.timeout(5000),
-    });
-
-    if (!statusRes.ok) {
-      const data = await statusRes.json().catch(() => ({}));
-      return { success: false, error: data.error || `HTTP ${statusRes.status}` };
-    }
-
-    console.log(`[pushSkillsToAgent] Pushed ${skills.length} skill(s) to agent`);
-    return { success: true };
-  } catch (err) {
-    return { success: false, error: String(err) };
-  }
-}
-
-// Exported helper to start an agent process (used by API route and auto-restart)
-export async function startAgentProcess(
-  agent: Agent,
-  options: { silent?: boolean; cleanData?: boolean } = {}
-): Promise<{ success: boolean; port?: number; error?: string }> {
-  const { silent = false, cleanData = false } = options;
-
-  // Check if binary exists
-  if (!binaryExists(BIN_DIR)) {
-    return { success: false, error: "Agent binary not available" };
-  }
-
-  // Check if already running (process map)
-  if (agentProcesses.has(agent.id)) {
-    return { success: false, error: "Agent already running" };
-  }
-
-  // Check if already being started (race condition prevention)
-  if (agentsStarting.has(agent.id)) {
-    return { success: false, error: "Agent is already starting" };
-  }
-
-  // Mark as starting
-  agentsStarting.add(agent.id);
-
-  // Get provider config for env var name
-  const providerConfig = PROVIDERS[agent.provider as ProviderId];
-  if (!providerConfig) {
-    agentsStarting.delete(agent.id);
-    return { success: false, error: `Unknown provider: ${agent.provider}` };
-  }
-
-  // Get the API key for the agent's provider (local providers like Ollama use URL instead)
-  const isLocalProvider = "isLocal" in providerConfig && providerConfig.isLocal;
-  const providerKey = ProviderKeys.getDecrypted(agent.provider);
-  if (!providerKey && !isLocalProvider) {
-    agentsStarting.delete(agent.id);
-    return { success: false, error: `No API key for provider: ${agent.provider}` };
-  }
-
-  // Use agent's permanently assigned port
-  const port = agent.port;
-  if (!port) {
-    agentsStarting.delete(agent.id);
-    return { success: false, error: "Agent has no assigned port" };
-  }
-
-  // Get or create API key for the agent
-  const agentApiKey = AgentDB.ensureApiKey(agent.id);
-  if (!agentApiKey) {
-    agentsStarting.delete(agent.id);
-    return { success: false, error: "Failed to get/create agent API key" };
-  }
-
-  try {
-    // Check if something is already running on this port (orphaned process)
-    try {
-      const res = await fetch(`http://localhost:${port}/health`, { signal: AbortSignal.timeout(500) });
-      if (res.ok) {
-        // Something is running - try to shut it down
-        if (!silent) {
-          console.log(`  Port ${port} in use, stopping orphaned process...`);
-        }
-        try {
-          await fetch(`http://localhost:${port}/shutdown`, { method: "POST", signal: AbortSignal.timeout(1000) });
-        } catch {
-          // Shutdown failed - process might not support it
-        }
-        // Wait longer for port to be released
-        await new Promise(r => setTimeout(r, 1500));
-      }
-    } catch {
-      // No HTTP response - but port might still be bound by zombie process
-    }
-
-    // Double-check port is actually free by trying to connect
-    const isPortFree = await checkPortFree(port);
-    if (!isPortFree) {
-      if (!silent) {
-        console.log(`  Port ${port} still in use, trying to kill process...`);
-      }
-      // Try to kill process using the port (Linux/Mac)
-      try {
-        const { execSync } = await import("child_process");
-        execSync(`lsof -ti:${port} | xargs kill -9 2>/dev/null || true`, { stdio: "ignore" });
-        await new Promise(r => setTimeout(r, 1000));
-      } catch {
-        // Ignore errors
-      }
-
-      // Final check
-      const stillInUse = !(await checkPortFree(port));
-      if (stillInUse) {
-        agentsStarting.delete(agent.id);
-        return { success: false, error: `Port ${port} is still in use` };
-      }
-    }
-
-    // Handle data directory
-    const agentDataDir = join(AGENTS_DATA_DIR, agent.id);
-    if (cleanData && existsSync(agentDataDir)) {
-      // Clean old data if requested
-      rmSync(agentDataDir, { recursive: true, force: true });
-      if (!silent) {
-        console.log(`  Cleaned old data directory`);
-      }
-    }
-    if (!existsSync(agentDataDir)) {
-      mkdirSync(agentDataDir, { recursive: true });
-    }
-
-    if (!silent) {
-      console.log(`Starting agent ${agent.name} on port ${port}...`);
-      console.log(`  Provider: ${agent.provider}`);
-      console.log(`  Data dir: ${agentDataDir}`);
-    }
-
-    // Build environment with provider key and agent API key
-    // CONFIG_PATH ensures each agent has its own config file (prevents sharing)
-    // Remove stale persisted config — platform is source of truth and pushes fresh config after boot
-    const agentConfigPath = join(agentDataDir, "agent-config.json");
-    rmSync(agentConfigPath, { force: true });
-    const env: Record<string, string> = {
-      ...process.env as Record<string, string>,
-      PORT: String(port),
-      DATA_DIR: agentDataDir,
-      CONFIG_PATH: agentConfigPath,
-      AGENT_API_KEY: agentApiKey,
-      [providerConfig.envVar]: providerKey || ("defaultBaseUrl" in providerConfig ? (providerConfig as any).defaultBaseUrl : ""),
-    };
-
-    // If memory is enabled and agent doesn't use OpenAI, also pass OpenAI key for embeddings
-    if (agent.features.memory && agent.provider !== "openai") {
-      const openaiKey = ProviderKeys.getDecrypted("openai");
-      if (openaiKey) {
-        env.OPENAI_API_KEY = openaiKey;
-      }
-    }
-
-    // If realtime voice is enabled, pass voice provider keys/URLs for STT/TTS
-    const rtEnabled = typeof agent.features.realtime === "boolean"
-      ? agent.features.realtime
-      : (agent.features.realtime as any)?.enabled ?? false;
-    if (rtEnabled) {
-      // Cloud voice provider keys (backwards compat — always pass if available)
-      const elevenlabsKey = ProviderKeys.getDecryptedForProject("elevenlabs", agent.project_id);
-      if (elevenlabsKey) env.ELEVENLABS_API_KEY = elevenlabsKey;
-      const deepgramKey = ProviderKeys.getDecryptedForProject("deepgram", agent.project_id);
-      if (deepgramKey) env.DEEPGRAM_API_KEY = deepgramKey;
-
-      // Local voice provider URLs
-      const localVoiceProviders = ["speaches", "whisper_cpp", "kokoro", "piper", "fish_speech"] as const;
-      for (const pvId of localVoiceProviders) {
-        const pv = PROVIDERS[pvId as ProviderId];
-        if (pv) {
-          const url = ProviderKeys.getDecryptedForProject(pvId, agent.project_id);
-          if (url) env[pv.envVar] = url;
-        }
-      }
-
-      // Pass API keys for native realtime providers (OpenAI/Gemini)
-      // Agent may use a different main LLM provider (e.g., Claude) but needs these for voice
-      const rtConfig = typeof agent.features.realtime === "object" ? agent.features.realtime as Record<string, unknown> : {};
-      const rtProvider = rtConfig.provider as string;
-      if (rtProvider === "openai" && agent.provider !== "openai") {
-        const openaiKey = ProviderKeys.getDecryptedForProject("openai", agent.project_id);
-        if (openaiKey) env.OPENAI_API_KEY = openaiKey;
-      }
-      if (rtProvider === "gemini" && agent.provider !== "gemini") {
-        const geminiKey = ProviderKeys.getDecryptedForProject("gemini", agent.project_id);
-        if (geminiKey) env.GEMINI_API_KEY = geminiKey;
-      }
-    }
-
-    // Get binary path dynamically (allows hot-reload of new binary versions)
-    const binaryPath = getBinaryPathForAgent();
-
-    // Write VERSION file so the binary knows its version (ldflags not set in npm builds)
-    try {
-      const { dirname } = await import("path");
-      const pkgJsonPath = require.resolve("@apteva/agent-linux-x64/package.json");
-      const pkg = JSON.parse(readFileSync(pkgJsonPath, "utf-8"));
-      if (pkg.version) {
-        writeFileSync(join(agentDataDir, "VERSION"), pkg.version);
-      }
-    } catch {}
-
-    const proc = spawn({
-      cmd: [binaryPath],
-      cwd: agentDataDir,
-      env,
-      stdout: "ignore",
-      stderr: "ignore",
-    });
-
-    // Store process with port for tracking
-    agentProcesses.set(agent.id, { proc, port });
-
-    // Detect unexpected process exits (crashes) — but not during server shutdown
-    proc.exited.then((code) => {
-      if (isShuttingDown()) return; // Don't update DB during shutdown — keeps status "running" for auto-restart
-      if (agentProcesses.has(agent.id)) {
-        agentProcesses.delete(agent.id);
-        setAgentStatus(agent.id, "stopped", code === 0 ? "exited" : "crashed");
-      }
-    });
-
-    // Wait for agent to be healthy
-    if (!silent) {
-      console.log(`  Waiting for agent to be ready...`);
-    }
-    const isHealthy = await waitForAgentHealth(port);
-    if (!isHealthy) {
-      if (!silent) {
-        console.error(`  Agent failed to start (health check timeout)`);
-      }
-      proc.kill();
-      agentProcesses.delete(agent.id);
-      agentsStarting.delete(agent.id);
-      return { success: false, error: "Health check timeout" };
-    }
-
-    // Push configuration to the agent
-    if (!silent) {
-      console.log(`  Pushing configuration...`);
-    }
-    const config = buildAgentConfig(agent, providerKey);
-    if (agent.features.realtime) {
-      console.log(`[DEBUG] realtime config being pushed:`, JSON.stringify(config.realtime, null, 2));
-    }
-    const configResult = await pushConfigToAgent(agent.id, port, config);
-    if (!configResult.success) {
-      if (!silent) {
-        console.error(`  Failed to configure agent: ${configResult.error}`);
-      }
-      // Agent is running but not configured - still usable but log warning
-    } else if (!silent) {
-      console.log(`  Configuration applied successfully`);
-    }
-
-    // Push skills via /skills endpoint (separate from config)
-    if (config.skills?.definitions?.length > 0) {
-      const skillsResult = await pushSkillsToAgent(agent.id, port, config.skills.definitions);
-      if (!skillsResult.success && !silent) {
-        console.error(`  Failed to push skills: ${skillsResult.error}`);
-      } else if (!silent) {
-        console.log(`  Skills pushed successfully (${config.skills.definitions.length} skills)`);
-      }
-    }
-
-    // Update status in database + emit telemetry event
-    setAgentStatus(agent.id, "running");
-
-    if (!silent) {
-      console.log(`Agent ${agent.name} started on port ${port} (pid: ${proc.pid})`);
-    }
-
-    agentsStarting.delete(agent.id);
-    return { success: true, port };
-  } catch (err) {
-    agentsStarting.delete(agent.id);
-    if (!silent) {
-      console.error(`Failed to start agent: ${err}`);
-    }
-    return { success: false, error: String(err) };
-  }
-}
-
-// Strip legacy "mode" field from multi-agent config
-function cleanFeatures(features: Agent["features"]): Agent["features"] {
-  if (features.agents && typeof features.agents === "object") {
-    const { mode, ...rest } = features.agents as any;
-    return { ...features, agents: rest };
-  }
-  return features;
-}
-
-// Transform DB agent to API response format (camelCase for frontend compatibility)
-// Uses batch queries + light MCP loading (no decryption) for performance
-export function toApiAgent(agent: Agent) {
-  // Batch load MCP servers (light = no decryption) and skills in 2 queries
-  const mcpMap = McpServerDB.findByIdsLight(agent.mcp_servers || []);
-  const skillMap = SkillDB.findByIds(agent.skills || []);
-
-  const mcpServerDetails = (agent.mcp_servers || [])
-    .map(id => mcpMap.get(id))
-    .filter((s): s is NonNullable<typeof s> => !!s)
-    .map(s => ({
-      id: s.id,
-      name: s.name,
-      type: s.type,
-      status: s.status,
-      port: s.port,
-      url: s.url,
-    }));
-
-  const skillDetails = (agent.skills || [])
-    .map(id => skillMap.get(id))
-    .filter((s): s is NonNullable<typeof s> => !!s)
-    .map(s => ({
-      id: s.id,
-      name: s.name,
-      description: s.description,
-      version: s.version,
-      enabled: s.enabled,
-    }));
-
-  // Look up subscriptions
-  const subscriptions = SubscriptionDB.findByAgentId(agent.id).map(s => ({
-    id: s.id, trigger_slug: s.trigger_slug, enabled: s.enabled,
-  }));
-
-  return {
-    id: agent.id,
-    name: agent.name,
-    model: agent.model,
-    provider: agent.provider,
-    systemPrompt: agent.system_prompt,
-    status: agent.status,
-    port: agent.port,
-    features: cleanFeatures(agent.features),
-    mcpServers: agent.mcp_servers,
-    mcpServerDetails,
-    skills: agent.skills,
-    skillDetails,
-    subscriptions,
-    projectId: agent.project_id,
-    createdAt: agent.created_at,
-    updatedAt: agent.updated_at,
-  };
-}
-
-// Batch transform: fetch all MCP servers + skills + subscriptions in 3 queries instead of N per agent
-export function toApiAgentsBatch(agents: Agent[]) {
-  // Collect all unique IDs
-  const allMcpIds = new Set<string>();
-  const allSkillIds = new Set<string>();
-  const allAgentIds: string[] = [];
-  for (const agent of agents) {
-    allAgentIds.push(agent.id);
-    for (const id of agent.mcp_servers || []) allMcpIds.add(id);
-    for (const id of agent.skills || []) allSkillIds.add(id);
-  }
-
-  // Batch load in 3 queries (Light = no decryption for MCP servers)
-  const mcpMap = McpServerDB.findByIdsLight([...allMcpIds]);
-  const skillMap = SkillDB.findByIds([...allSkillIds]);
-  const subsMap = SubscriptionDB.findByAgentIds(allAgentIds);
-
-  return agents.map(agent => {
-    const mcpServerDetails = (agent.mcp_servers || [])
-      .map(id => mcpMap.get(id))
-      .filter((s): s is NonNullable<typeof s> => !!s)
-      .map(s => ({ id: s.id, name: s.name, type: s.type, status: s.status, port: s.port, url: s.url }));
-
-    const skillDetails = (agent.skills || [])
-      .map(id => skillMap.get(id))
-      .filter((s): s is NonNullable<typeof s> => !!s)
-      .map(s => ({ id: s.id, name: s.name, description: s.description, version: s.version, enabled: s.enabled }));
-
-    const subscriptions = (subsMap.get(agent.id) || []).map(s => ({
-      id: s.id, trigger_slug: s.trigger_slug, enabled: s.enabled,
-    }));
-
-    return {
-      id: agent.id, name: agent.name, model: agent.model, provider: agent.provider,
-      systemPrompt: agent.system_prompt, status: agent.status, port: agent.port,
-      features: cleanFeatures(agent.features), mcpServers: agent.mcp_servers, mcpServerDetails,
-      skills: agent.skills, skillDetails, subscriptions, projectId: agent.project_id,
-      createdAt: agent.created_at, updatedAt: agent.updated_at,
-    };
-  });
-}
-
-// Transform DB project to API response format
-export function toApiProject(project: Project) {
-  return {
-    id: project.id,
-    name: project.name,
-    description: project.description,
-    color: project.color,
-    createdAt: project.created_at,
-    updatedAt: project.updated_at,
-  };
-}
-
-// Helper to fetch from a running agent (with authentication + timeout)
-export async function fetchFromAgent(agentId: string, port: number, endpoint: string, timeoutMs = 3000): Promise<any> {
-  try {
-    const response = await agentFetch(agentId, port, endpoint, {
-      headers: { "Accept": "application/json" },
-      signal: AbortSignal.timeout(timeoutMs),
-    });
-    if (response.ok) {
-      return await response.json();
-    }
-    return null;
-  } catch {
-    return null;
-  }
-}