@johpaz/hive 1.7.2 → 1.7.3

package/packages/core/src/gateway/routes/chat.ts

@@ -1,241 +0,0 @@
-/**
- * Chat API - Endpoint para enviar mensajes al coordinador
- * 
- * POST /api/chat
- * {
- *   "message": "Mensaje para el coordinador",
- *   "thread_id": "ID de sesión (opcional, se genera si no existe)",
- *   "channel": "canal (opcional, default: webchat)"
- * }
- */
-
-import { getDb } from "../../storage/sqlite";
-import { resolveUserId, resolveAgentId } from "../../storage/onboarding";
-import { laneQueue } from "../lane-queue";
-import { getRecentMessages } from "../../agent/conversation-store";
-import { AgentRunner } from "../../agent/providers";
-import { logger } from "../../utils/logger";
-import { getUserDate, getUserTime } from "../../utils/date";
-
-const log = logger.child("api:chat");
-
-export interface ChatRequest {
-  message: string;
-  thread_id?: string;
-  channel?: string;
-  userId?: string;
-  agentId?: string;
-}
-
-export interface ChatResponse {
-  success: boolean;
-  thread_id: string;
-  content?: string;
-  error?: string;
-}
-
-export async function handleChat(
-  req: Request,
-  addCorsHeaders: (res: Response, req: Request) => Response
-): Promise<Response> {
-  try {
-    const body = await req.json();
-    const { message, thread_id, channel = "webchat", userId, agentId }: ChatRequest = body;
-
-    if (!message) {
-      return addCorsHeaders(
-        Response.json({ 
-          success: false, 
-          error: "Message is required" 
-        }, { status: 400 }),
-        req
-      );
-    }
-
-    const db = getDb();
-
-    // Resolve user ID
-    const finalUserId = userId || resolveUserId({ channel }) || "default";
-    
-    // Resolve agent ID (coordinator by default)
-    const finalAgentId = agentId || resolveAgentId(null) || "main";
-
-    // Generate or use provided thread_id
-    const threadId = thread_id || `${finalUserId}-${Date.now()}`;
-
-    log.info(`[chat] Processing message from user=${finalUserId} agent=${finalAgentId} thread=${threadId}`);
-
-    // Get user timezone for timestamp
-    const userRow = db.query<any, [string]>(
-      "SELECT timezone FROM users WHERE id = ?"
-    ).get(finalUserId);
-    const userTimezone = userRow?.timezone || "UTC";
-    const now = new Date();
-    
-    let exactTime: string;
-    try {
-      exactTime = now.toLocaleString("en-US", {
-        timeZone: userTimezone,
-        dateStyle: "full",
-        timeStyle: "long",
-      });
-    } catch (e) {
-      exactTime = now.toISOString();
-    }
-
-    // Format message with timestamp
-    const messageContent = `[Timestamp: ${exactTime} (${userTimezone})]\n${message}`;
-
-    // Get recent conversation history
-    const history = getRecentMessages(threadId, 50);
-    const messages = [
-      ...history.map((row) => ({
-        role: row.role as "user" | "assistant" | "system",
-        content: row.content,
-      })),
-      { role: "user" as const, content: messageContent }
-    ];
-
-    // Get provider config from DB
-    const agent = db.query<any, [string]>(
-      "SELECT provider_id, model_id FROM agents WHERE id = ?"
-    ).get(finalAgentId);
-
-    const provider = agent?.provider_id || "gemini";
-
-    // Create runner
-    const runner = new AgentRunner({} as any);
-
-    let responseContent = "";
-    let responseError: string | null = null;
-
-    // Enqueue in lane queue for processing
-    laneQueue.enqueue(threadId, async (_task, signal) => {
-      if (signal.aborted) return;
-
-      try {
-        log.info(`[chat] Generating response for thread ${threadId}...`);
-
-        const response = await runner.generate({
-          provider: provider as any,
-          messages,
-          rawUserMessage: message,
-          maxTokens: 4096,
-          maxSteps: 15,
-          threadId,
-          userId: finalUserId,
-          channel,
-          onStep: async (step) => {
-            if (step.type === "text" && step.message) {
-              log.debug(`[chat] Step: ${step.message.substring(0, 100)}`);
-            }
-            if (step.type === "tool_result" && step.message) {
-              log.debug(`[chat] Tool result: ${step.message.substring(0, 100)}`);
-            }
-          },
-        });
-
-        responseContent = response.content?.trim() || "Task completed.";
-        log.info(`[chat] Response generated: ${responseContent.substring(0, 100)}...`);
-
-      } catch (error) {
-        log.error(`[chat] Error for thread ${threadId}: ${(error as Error).message}`);
-        responseError = (error as Error).message;
-      }
-    });
-
-    // Wait for processing to complete (with timeout)
-    const startTime = Date.now();
-    const timeout = 120000; // 2 minutes timeout
-
-    while (!responseContent && !responseError) {
-      if (Date.now() - startTime > timeout) {
-        return addCorsHeaders(
-          Response.json({
-            success: false,
-            error: "Request timeout",
-            thread_id: threadId,
-          }, { status: 504 }),
-          req
-        );
-      }
-      await new Promise(resolve => setTimeout(resolve, 100));
-    }
-
-    if (responseError) {
-      return addCorsHeaders(
-        Response.json({
-          success: false,
-          error: responseError,
-          thread_id: threadId,
-        }, { status: 500 }),
-        req
-      );
-    }
-
-    return addCorsHeaders(
-      Response.json({
-        success: true,
-        thread_id: threadId,
-        content: responseContent,
-      }),
-      req
-    );
-
-  } catch (error) {
-    log.error(`[chat] Handler error: ${(error as Error).message}`);
-    return addCorsHeaders(
-      Response.json({
-        success: false,
-        error: (error as Error).message,
-        message: "Internal server error",
-      }, { status: 500 }),
-      req
-    );
-  }
-}
-
-// ── Original Chat API Functions ─────────────────────────────────────────────
-
-export async function handleGetChatHistory(req: Request, addCorsHeaders: (r: Response, req: Request) => Response): Promise<Response> {
-  const url = new URL(req.url)
-  const threadId = url.searchParams.get("sessionId") || url.searchParams.get("threadId") || "default"
-  const limit = parseInt(url.searchParams.get("limit") || "50")
-
-  const messages = getDb().query(`
-    SELECT * FROM conversations
-    WHERE thread_id = ?
-    ORDER BY created_at DESC
-    LIMIT ?
-  `).all(threadId, limit) as Record<string, unknown>[]
-
-  return addCorsHeaders(Response.json({ messages: messages.reverse() }), req)
-}
-
-export async function handleGetCanvas(req: Request, addCorsHeaders: (r: Response, req: Request) => Response): Promise<Response> {
-  return addCorsHeaders(Response.json({ nodes: [], edges: [] }), req)
-}
-
-export async function handleGetNotes(req: Request, addCorsHeaders: (r: Response, req: Request) => Response): Promise<Response> {
-  const notes = getDb().query(`
-    SELECT * FROM scratchpad ORDER BY updated_at DESC LIMIT 50
-  `).all() as Record<string, unknown>[]
-  
-  return addCorsHeaders(Response.json({ notes }), req)
-}
-
-export async function handleUpdateNote(req: Request, addCorsHeaders: (r: Response, req: Request) => Response): Promise<Response> {
-  const body = await req.json().catch(() => ({}))
-  const { threadId, content } = body
-  
-  if (!threadId || !content) {
-    return addCorsHeaders(Response.json({ success: false, error: "threadId and content required" }), req)
-  }
-  
-  getDb().query(`
-    INSERT OR REPLACE INTO scratchpad(thread_id, key, value, updated_at)
-    VALUES(?, 'note', ?, ?)
-  `).run(threadId, content, Math.floor(Date.now() / 1000))
-  
-  return addCorsHeaders(Response.json({ success: true }), req)
-}

package/packages/core/src/gateway/routes/config.ts

@@ -1,12 +0,0 @@
-import type { Config } from "../../config/loader.ts";
-import { getDb } from "../../storage/sqlite.ts";
-import { decryptConfig } from "../../storage/crypto.ts";
-import { redactConfig } from "../helpers/redact.ts";
-
-export async function handleGetConfig(
-  req: Request,
-  addCorsHeaders: (r: Response, req: Request) => Response,
-  config: Config
-): Promise<Response> {
-  return addCorsHeaders(Response.json(redactConfig(config)), req);
-}

package/packages/core/src/gateway/routes/cron.ts

@@ -1,42 +0,0 @@
-import { getDb } from "../../storage/sqlite"
-
-export async function handleGetCronJobs(req: Request, addCorsHeaders: (r: Response, req: Request) => Response): Promise<Response> {
-  const jobs = getDb().query(`
-    SELECT * FROM cron_jobs ORDER BY id ASC
-  `).all() as Record<string, unknown>[]
-  
-  return addCorsHeaders(Response.json({ cronJobs: jobs }), req)
-}
-
-export async function handleGetCronChannels(req: Request, addCorsHeaders: (r: Response, req: Request) => Response): Promise<Response> {
-  const channels = getDb().query(`
-    SELECT DISTINCT channel FROM user_channels WHERE channel IS NOT NULL
-  `).all() as Record<string, unknown>[]
-  
-  return addCorsHeaders(Response.json({ channels: channels.map(c => c.channel) }), req)
-}
-
-export async function handleUpdateCronJob(req: Request, addCorsHeaders: (r: Response, req: Request) => Response): Promise<Response> {
-  const url = new URL(req.url)
-  const jobId = url.pathname.split("/").pop()
-  const body = await req.json().catch(() => ({}))
-  
-  if (!jobId) {
-    return addCorsHeaders(new Response("Missing ID", { status: 400 }), req)
-  }
-  
-  const updates: string[] = []
-  const params: unknown[] = []
-  
-  if (body.active !== undefined) {
-    updates.push("active = ?")
-    params.push(body.active ? 1 : 0)
-  }
-  
-  if (updates.length > 0) {
-    params.push(jobId)
-    getDb().query(`UPDATE cron_jobs SET ${updates.join(", ")} WHERE id = ?`).run(...params as any[])
-  }
-  
-  return addCorsHeaders(Response.json({ ok: true }), req)
-}

package/packages/core/src/gateway/routes/ethics.ts

@@ -1,46 +0,0 @@
-import { getDb } from "../../storage/sqlite"
-
-export async function handleGetEthics(req: Request, addCorsHeaders: (r: Response, req: Request) => Response): Promise<Response> {
-  const ethics = getDb().query(`
-    SELECT id, name, description, content, active, enabled
-    FROM ethics
-    ORDER BY name
-  `).all() as Record<string, unknown>[]
-  
-  return addCorsHeaders(Response.json({
-    ethics: ethics.map(e => ({
-      id: e.id,
-      name: e.name,
-      description: e.description,
-      content: e.content,
-      active: e.active === 1,
-      enabled: e.enabled === 1,
-    }))
-  }), req)
-}
-
-export async function handleActivateEthics(req: Request, addCorsHeaders: (r: Response, req: Request) => Response): Promise<Response> {
-  const body = await req.json().catch(() => ({}))
-  const { ethicsId, active } = body
-  
-  if (!ethicsId) {
-    return addCorsHeaders(Response.json({ success: false, error: "ethicsId required" }), req)
-  }
-  
-  getDb().query(`UPDATE ethics SET active = ?, enabled = ? WHERE id = ?`).run(active ? 1 : 0, active ? 1 : 0, ethicsId)
-  
-  return addCorsHeaders(Response.json({ success: true, ethicsId, active }), req)
-}
-
-export async function handleDeleteEthics(req: Request, addCorsHeaders: (r: Response, req: Request) => Response): Promise<Response> {
-  const url = new URL(req.url)
-  const id = url.pathname.split("/").pop()
-  
-  if (!id) {
-    return addCorsHeaders(Response.json({ success: false, error: "id required" }), req)
-  }
-  
-  getDb().query("DELETE FROM ethics WHERE id = ?").run(id)
-  
-  return addCorsHeaders(Response.json({ success: true }), req)
-}

package/packages/core/src/gateway/routes/mcp.ts

@@ -1,346 +0,0 @@
-import { getDb } from "../../storage/sqlite.ts"
-import { encryptConfig, decryptConfig } from "../../storage/crypto.ts"
-import { logger } from "../../utils/logger.ts"
-
-const mcpLog = logger.child("mcp:api")
-
-export async function handleGetMcpServers(
-  req: Request,
-  addCorsHeaders: (r: Response, req: Request) => Response,
-  mcpManager?: any
-): Promise<Response> {
-  const db = getDb()
-
-  // Get real-time server status from MCP manager
-  const mcpServers = new Map<string, { status: string; tools: any[] }>()
-  if (mcpManager) {
-    try {
-      const servers = mcpManager.listServers?.() || []
-      mcpLog.info(`[GET] MCP Manager returned ${servers.length} servers:`, servers.map((s: any) => `${s.name}:${s.status}`))
-      for (const s of servers) {
-        mcpServers.set(s.name, {
-          status: s.status,
-          tools: s.tools || [],
-        })
-      }
-    } catch (e) {
-      mcpLog.warn(`Failed to get MCP servers: ${(e as Error).message}`)
-    }
-  } else {
-    mcpLog.warn(`[GET] No MCP Manager provided`)
-  }
-
-  // Get all servers from database
-  const dbServers = db.query(`
-    SELECT * FROM mcp_servers ORDER BY name
-  `).all() as Record<string, unknown>[]
-
-  // Combine DB info with real-time status from MCP manager
-  const allServers = dbServers.map(s => {
-    // Try to find matching server in MCP Manager (by name or normalized name)
-    const normalizedName = (s.name as string).toLowerCase().replace(/[^a-z0-9-]/g, '-')
-    const mcpServer = mcpServers.get(s.name as string) || mcpServers.get(normalizedName)
-    const isEnabled = s.enabled === 1
-
-    // Redact headers for safe UI display
-    let headers = undefined
-    if (s.headers_encrypted && s.headers_iv) {
-      try {
-        const decryptedHeaders = decryptConfig(s.headers_encrypted as string, s.headers_iv as string)
-        headers = Object.fromEntries(
-          Object.entries(decryptedHeaders).map(([k, v]) => [
-            k,
-            k.toLowerCase().includes("auth") ||
-              k.toLowerCase().includes("token") ||
-              k.toLowerCase().includes("key")
-              ? `${(v as string).slice(0, 4)}••••••••`
-              : v,
-          ])
-        )
-      } catch (e) {
-        mcpLog.error(`Failed to decrypt headers for ${s.name}: ${(e as Error).message}`)
-      }
-    }
-
-    return {
-      name: s.name,
-      enabled: isEnabled,
-      status: mcpServer?.status || (isEnabled ? "disconnected" : "disconnected"),
-      config: {
-        transport: s.transport,
-        command: s.command,
-        args: s.args ? JSON.parse(s.args as string) : [],
-        url: s.url,
-        headers,
-        enabled: isEnabled
-      },
-      tools_count: mcpServer?.tools.length || s.tools_count || 0,
-      tools: mcpServer?.tools || [],
-    }
-  })
-
-  return addCorsHeaders(Response.json(allServers), req)
-}
-
-export async function handleCreateMcpServer(req: Request, addCorsHeaders: (r: Response, req: Request) => Response): Promise<Response> {
-  const body = await req.json().catch(() => ({}))
-  const db = getDb()
-
-  if (!body.name || !body.config) {
-    return addCorsHeaders(new Response("Missing name or config", { status: 400 }), req)
-  }
-
-  mcpLog.info(`Creating MCP server: ${body.name}`)
-
-  // Generate unique ID (name-based for consistency)
-  const serverId = body.name.toLowerCase().replace(/[^a-z0-9-]/g, '-')
-
-  // Encrypt headers if present
-  let headersEncrypted: string | undefined
-  let headersIv: string | undefined
-  if (body.config.headers) {
-    const encrypted = encryptConfig(body.config.headers)
-    headersEncrypted = encrypted.encrypted
-    headersIv = encrypted.iv
-  }
-
-  // Save to database
-  db.query(`
-    INSERT INTO mcp_servers(id, name, transport, command, args, url, headers_encrypted, headers_iv, enabled, builtin, status)
-    VALUES(?, ?, ?, ?, ?, ?, ?, ?, ?, 0, 'disconnected')
-  `).run(
-    serverId,
-    body.name,
-    body.config.transport || "stdio",
-    body.config.command || null,
-    body.config.args ? JSON.stringify(body.config.args) : null,
-    body.config.url || null,
-    headersEncrypted,
-    headersIv,
-    body.config.enabled !== false ? 1 : 0
-  )
-
-  return addCorsHeaders(Response.json({ success: true, id: serverId }), req)
-}
-
-export async function handleDeleteMcpServer(req: Request, addCorsHeaders: (r: Response, req: Request) => Response): Promise<Response> {
-  const url = new URL(req.url)
-  // Extract server name from path: /api/mcp/servers/{name}
-  const parts = url.pathname.split("/").filter(Boolean)
-  const serverName = parts[parts.length - 1]
-
-  if (!serverName || serverName === "servers") {
-    return addCorsHeaders(Response.json({ success: false, error: "server name required" }), req)
-  }
-
-  getDb().query(`DELETE FROM mcp_servers WHERE id = ?`).run(serverName)
-
-  return addCorsHeaders(Response.json({ success: true }), req)
-}
-
-export async function handleUpdateMcpServer(req: Request, addCorsHeaders: (r: Response, req: Request) => Response): Promise<Response> {
-  const url = new URL(req.url)
-  // Extract server name from path: /api/mcp/servers/{name}
-  const parts = url.pathname.split("/").filter(Boolean)
-  const serverName = parts[parts.length - 1]
-  const body = await req.json().catch(() => ({}))
-  const db = getDb()
-
-  if (!serverName || serverName === "servers") {
-    return addCorsHeaders(new Response("Missing server name", { status: 400 }), req)
-  }
-
-  mcpLog.info(`Updating MCP server: ${serverName}`)
-
-  const updates: string[] = []
-  const params: unknown[] = []
-
-  if (body.name !== undefined) {
-    updates.push("name = ?")
-    params.push(body.name)
-  }
-  if (body.command !== undefined) {
-    updates.push("command = ?")
-    params.push(body.command)
-  }
-  if (body.args !== undefined) {
-    updates.push("args = ?")
-    params.push(JSON.stringify(body.args))
-  }
-  if (body.url !== undefined) {
-    updates.push("url = ?")
-    params.push(body.url)
-  }
-  if (body.enabled !== undefined) {
-    updates.push("enabled = ?")
-    params.push(body.enabled ? 1 : 0)
-  }
-  if (body.headers) {
-    const { encrypted, iv } = encryptConfig(body.headers)
-    updates.push("headers_encrypted = ?")
-    params.push(encrypted)
-    updates.push("headers_iv = ?")
-    params.push(iv)
-  }
-
-  if (updates.length > 0) {
-    params.push(serverName)
-    db.query(`UPDATE mcp_servers SET ${updates.join(", ")} WHERE id = ?`).run(...params as any[])
-  }
-
-  return addCorsHeaders(Response.json({ success: true }), req)
-}
-
-export async function handleStartMcpServer(req: Request, addCorsHeaders: (r: Response, req: Request) => Response): Promise<Response> {
-  const url = new URL(req.url)
-  const serverId = url.pathname.split("/").pop()
-
-  if (!serverId) {
-    return addCorsHeaders(Response.json({ success: false, error: "serverId required" }), req)
-  }
-
-  getDb().query(`UPDATE mcp_servers SET enabled = 1 WHERE id = ?`).run(serverId)
-
-  return addCorsHeaders(Response.json({ success: true, serverId, enabled: true }), req)
-}
-
-export async function handleGetMcpServerTools(
-  req: Request,
-  addCorsHeaders: (r: Response, req: Request) => Response,
-  serverName: string,
-  mcpManager?: any
-): Promise<Response> {
-  if (!mcpManager) {
-    return addCorsHeaders(Response.json([]), req)
-  }
-
-  const tools = mcpManager.getServerTools(serverName)
-  return addCorsHeaders(Response.json(tools), req)
-}
-
-export async function handleGetMcpServerDetail(
-  req: Request,
-  addCorsHeaders: (r: Response, req: Request) => Response,
-  serverName: string,
-  mcpManager?: any
-): Promise<Response> {
-  if (!mcpManager) {
-    return addCorsHeaders(new Response("MCP is disabled", { status: 404 }), req)
-  }
-
-  const details = mcpManager.getServerDetails(serverName)
-  if (!details) {
-    return new Response("Server not found", { status: 404 })
-  }
-
-  return addCorsHeaders(Response.json(details), req)
-}
-
-export async function handleToggleMcpServer(
-  req: Request,
-  addCorsHeaders: (r: Response, req: Request) => Response,
-  mcpId: string
-): Promise<Response> {
-  const body = await req.json().catch(() => ({}))
-  const { active } = body
-
-  if (active === undefined) {
-    return addCorsHeaders(Response.json({ success: false, error: "Missing active field", message: "Falta el campo 'active'" }, { status: 400 }), req)
-  }
-
-  getDb().query(`UPDATE mcp_servers SET active = ?, enabled = ? WHERE id = ?`).run(active ? 1 : 0, active ? 1 : 0, mcpId)
-
-  return addCorsHeaders(Response.json({ success: true, active, message: active ? "Servidor MCP activado" : "Servidor MCP desactivado" }), req)
-}
-
-export async function handleMcpServerAction(
-  req: Request,
-  addCorsHeaders: (r: Response, req: Request) => Response,
-  serverName: string,
-  action: "connect" | "disconnect",
-  mcpManager?: any
-): Promise<Response> {
-  if (!mcpManager) {
-    return addCorsHeaders(new Response("MCP is disabled", { status: 404 }), req)
-  }
-
-  const db = getDb()
-
-  if (action === "connect") {
-    // Check if server exists and is enabled in DB
-    const dbServer = db.query(`SELECT * FROM mcp_servers WHERE name = ? AND enabled = 1`).get(serverName)
-    if (!dbServer) {
-      return new Response("Server not found or disabled", { status: 400 })
-    }
-
-    await mcpManager.connectServer(serverName)
-
-    // Update tools count after connection
-    const tools = mcpManager.getServerTools(serverName) || []
-    db.query(`UPDATE mcp_servers SET status = ?, tools_count = ? WHERE name = ?`).run("connected", tools.length, serverName)
-
-    return addCorsHeaders(Response.json({ success: true, tools_count: tools.length }), req)
-  }
-
-  if (action === "disconnect") {
-    await mcpManager.disconnectServer(serverName)
-    return addCorsHeaders(Response.json({ success: true }), req)
-  }
-
-  return addCorsHeaders(new Response("Invalid action", { status: 400 }), req)
-}
-
-/**
- * Get tools for a specific MCP server
- */
-export async function handleGetMCPServerTools(
-  req: Request,
-  addCorsHeaders: (r: Response, req: Request) => Response,
-  serverId: string
-): Promise<Response> {
-  const db = getDb();
-  
-  const tools = db.query(`
-    SELECT id, name, description, input_schema as inputSchema, enabled, active, created_at, updated_at
-    FROM tools_mcp
-    WHERE server_id = ?
-    ORDER BY name
-  `).all(serverId) as Record<string, unknown>[];
-  
-  return addCorsHeaders(Response.json({ tools }), req);
-}
-
-/**
- * Toggle MCP tool active state
- */
-export async function handleToggleMCPTool(
-  req: Request,
-  addCorsHeaders: (r: Response, req: Request) => Response,
-  toolId: string
-): Promise<Response> {
-  const body = await req.json().catch(() => ({}));
-  const { active } = body;
-  
-  if (active === undefined) {
-    return addCorsHeaders(Response.json({ success: false, error: "Missing active field" }, { status: 400 }), req);
-  }
-  
-  const db = getDb();
-  db.query(`UPDATE tools_mcp SET active = ?, updated_at = unixepoch() WHERE id = ?`).run(active ? 1 : 0, toolId);
-  
-  return addCorsHeaders(Response.json({ success: true, active, message: active ? "Herramienta MCP activada" : "Herramienta MCP desactivada" }), req);
-}
-
-/**
- * Delete MCP tool
- */
-export async function handleDeleteMCPTool(
-  req: Request,
-  addCorsHeaders: (r: Response, req: Request) => Response,
-  toolId: string
-): Promise<Response> {
-  const db = getDb();
-  db.query(`DELETE FROM tools_mcp WHERE id = ?`).run(toolId);
-  
-  return addCorsHeaders(Response.json({ success: true, message: "Herramienta MCP eliminada" }), req);
-}