@johpaz/hive 1.7.2 → 1.7.3

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

@@ -1,267 +0,0 @@
-import { existsSync } from "node:fs"
-import { randomUUID } from "node:crypto"
-import { getDbPathLazy } from "../../storage/sqlite"
-import {
-  initOnboardingDb,
-  saveUserProfile,
-  saveProviderConfig,
-  activateChannel,
-  saveVoiceConfig,
-  activateEthics,
-} from "../../storage/onboarding"
-import type { Config } from "../../config/loader"
-
-export function isSetupMode(): boolean {
-  return !existsSync(getDbPathLazy())
-}
-
-export async function handleSetupStatus(): Promise<Response> {
-  const setupMode = isSetupMode()
-  return Response.json({
-    configured: !setupMode,
-    setupMode,
-  })
-}
-
-export async function handleVerifyProvider(req: Request): Promise<Response> {
-  const body = await req.json().catch(() => ({}))
-  const { provider, apiKey, model } = body
-
-  if (!provider || !apiKey) {
-    return Response.json({
-      success: false,
-      error: "Provider and API key are required",
-    }, { status: 400 })
-  }
-
-  try {
-    let testUrl: string | null = null
-    let testBody: unknown = null
-    let headers: Record<string, string> = {}
-
-    const testMessages = [{ role: "user" as const, content: "Say 'ok' if you can read this." }]
-
-    if (provider === "ollama") {
-      try {
-        const response = await fetch("http://localhost:11434/api/tags", {
-          signal: AbortSignal.timeout(5000),
-        })
-        return Response.json({
-          success: response.ok,
-          error: response.ok ? null : "Could not connect to Ollama",
-        })
-      } catch {
-        return Response.json({
-          success: false,
-          error: "Could not connect to Ollama at http://localhost:11434",
-        })
-      }
-    }
-
-    if (provider === "anthropic") {
-      testUrl = "https://api.anthropic.com/v1/messages"
-      testBody = {
-        model: model || "claude-sonnet-4-6",
-        max_tokens: 10,
-        messages: testMessages,
-      }
-      headers = {
-        "Content-Type": "application/json",
-        "x-api-key": apiKey,
-        "anthropic-version": "2023-06-01",
-        "anthropic-dangerous-direct-browser-access": "true",
-      }
-    } else if (provider === "openai") {
-      testUrl = "https://api.openai.com/v1/chat/completions"
-      testBody = {
-        model: model || "gpt-4o-mini",
-        max_tokens: 10,
-        messages: testMessages,
-      }
-      headers = {
-        "Content-Type": "application/json",
-        "Authorization": `Bearer ${apiKey}`,
-      }
-    } else if (provider === "gemini") {
-      testUrl = `https://generativelanguage.googleapis.com/v1beta/models/${model || "gemini-2.5-flash"}:generateContent?key=${apiKey}`
-      testBody = {
-        contents: [{ parts: [{ text: "Say ok" }] }],
-      }
-      headers = { "Content-Type": "application/json" }
-    } else if (provider === "groq") {
-      testUrl = "https://api.groq.com/openai/v1/chat/completions"
-      testBody = {
-        model: model || "llama-3.3-70b-versatile",
-        max_tokens: 10,
-        messages: testMessages,
-      }
-      headers = {
-        "Content-Type": "application/json",
-        "Authorization": `Bearer ${apiKey}`,
-      }
-    } else if (provider === "openrouter") {
-      testUrl = "https://openrouter.ai/api/v1/chat/completions"
-      testBody = {
-        model: model || "meta-llama/llama-3.3-70b-instruct",
-        max_tokens: 10,
-        messages: testMessages,
-      }
-      headers = {
-        "Content-Type": "application/json",
-        "Authorization": `Bearer ${apiKey}`,
-      }
-    } else if (provider === "mistral") {
-      testUrl = "https://api.mistral.ai/v1/chat/completions"
-      testBody = {
-        model: model || "mistral-small-latest",
-        max_tokens: 10,
-        messages: testMessages,
-      }
-      headers = {
-        "Content-Type": "application/json",
-        "Authorization": `Bearer ${apiKey}`,
-      }
-    } else if (provider === "deepseek") {
-      testUrl = "https://api.deepseek.com/v1/chat/completions"
-      testBody = {
-        model: model || "deepseek-chat",
-        max_tokens: 10,
-        messages: testMessages,
-      }
-      headers = {
-        "Content-Type": "application/json",
-        "Authorization": `Bearer ${apiKey}`,
-      }
-    } else if (provider === "kimi") {
-      testUrl = "https://api.moonshot.cn/v1/chat/completions"
-      testBody = {
-        model: model || "moonshot-v1-8k",
-        max_tokens: 10,
-        messages: testMessages,
-      }
-      headers = {
-        "Content-Type": "application/json",
-        "Authorization": `Bearer ${apiKey}`,
-      }
-    }
-
-    if (!testUrl) {
-      return Response.json({
-        success: false,
-        error: "Unsupported provider",
-      }, { status: 400 })
-    }
-
-    const response = await fetch(testUrl, {
-      method: "POST",
-      headers,
-      body: JSON.stringify(testBody),
-      signal: AbortSignal.timeout(10000),
-    })
-
-    return Response.json({
-      success: response.ok,
-      error: response.ok ? null : `API error: ${response.status}`,
-    })
-  } catch (error) {
-    return Response.json({
-      success: false,
-      error: `Connection error: ${(error as Error).message}`,
-    })
-  }
-}
-
-export async function handleCompleteSetup(
-  req: Request,
-  config: Config,
-  addCorsHeaders: (response: Response, request: Request) => Response
-): Promise<Response> {
-  if (!isSetupMode()) {
-    return addCorsHeaders(Response.json({
-      success: false,
-      error: "Setup already completed. Use config endpoints to modify settings.",
-    }, { status: 400 }), req)
-  }
-
-  const body = await req.json().catch(() => ({}))
-
-  try {
-    initOnboardingDb()
-
-    const userId = `user_${randomUUID().split("-")[0]}`
-    const agentId = `agent_${randomUUID().split("-")[0]}`
-    const channelUserId = randomUUID()
-
-    saveUserProfile({
-      userId,
-      userName: body.userName || "User",
-      userLanguage: body.userLanguage || "es",
-      userTimezone: body.userTimezone || "UTC",
-      userOccupation: body.userOccupation || "",
-      userNotes: body.userNotes || "",
-      agentName: body.agentName || "Bee",
-      agentId,
-      agentDescription: body.agentDescription || "",
-      agentTone: "friendly",
-      channelUserId,
-    })
-
-    if (body.provider && body.apiKey) {
-      await saveProviderConfig({
-        userId,
-        provider: body.provider,
-        model: body.model,
-        apiKey: body.apiKey,
-      })
-    }
-
-    await activateChannel(userId, {
-      channelId: "webchat",
-      channelUserId,
-      config: {},
-    })
-
-    if (body.channels) {
-      for (const [channelId, channelData] of Object.entries(body.channels as Record<string, unknown>)) {
-        if (channelId !== "webchat" && channelData && typeof channelData === "object" && (channelData as { enabled?: boolean }).enabled) {
-          await activateChannel(userId, {
-            channelId,
-            config: (channelData as { config?: Record<string, unknown> }).config || {},
-          })
-        }
-      }
-    }
-
-    if (body.voiceEnabled) {
-      await saveVoiceConfig({
-        userId,
-        channelId: "webchat",
-        voiceEnabled: true,
-        sttProvider: body.sttProvider || "groq-whisper",
-        ttsProvider: body.ttsProvider || "elevenlabs",
-      })
-    }
-
-    // Activar ethics por defecto
-    activateEthics(userId, "default")
-
-    const authToken = randomUUID().replace(/-/g, "")
-
-    process.env.HIVE_AUTH_TOKEN = authToken
-    // Note: userId and agentId are now resolved from database, not environment variables
-    // These assignments are kept for backward compatibility but are no longer used
-
-    return addCorsHeaders(Response.json({
-      success: true,
-      userId,
-      agentId,
-      authToken,
-      message: "Setup completed successfully",
-    }), req)
-  } catch (error) {
-    return addCorsHeaders(Response.json({
-      success: false,
-      error: (error as Error).message,
-    }, { status: 500 }), req)
-  }
-}

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

@@ -1,70 +0,0 @@
-import { getDb } from "../../storage/sqlite"
-import { emitCanvas } from "../../canvas/emitter"
-
-export async function handleGetSkills(req: Request, addCorsHeaders: (r: Response, req: Request) => Response): Promise<Response> {
-  const skills = getDb().query(`
-    SELECT id, name, category, tools, triggers, body, version, active
-    FROM skills
-    ORDER BY name
-  `).all() as Record<string, unknown>[]
-
-  return addCorsHeaders(Response.json({
-    skills: skills.map(s => ({
-      id: s.id,
-      name: s.name,
-      category: s.category,
-      tools: s.tools,
-      triggers: s.triggers,
-      body: s.body,
-      version: s.version,
-      active: s.active === 1,
-    }))
-  }), req)
-}
-
-export async function handleActivateSkill(req: Request, addCorsHeaders: (r: Response, req: Request) => Response): Promise<Response> {
-  const body = await req.json().catch(() => ({}))
-  const { skillId, active } = body
-
-  if (!skillId) {
-    return addCorsHeaders(Response.json({ success: false, error: "skillId required" }), req)
-  }
-
-  getDb().query(`UPDATE skills SET active = ? WHERE id = ?`).run(active ? 1 : 0, skillId)
-
-  return addCorsHeaders(Response.json({ success: true, skillId, active }), req)
-}
-
-export async function handleDeleteSkill(req: Request, addCorsHeaders: (r: Response, req: Request) => Response): Promise<Response> {
-  const url = new URL(req.url)
-  const skillId = url.pathname.split("/").pop()
-
-  if (!skillId) {
-    return addCorsHeaders(Response.json({ success: false, error: "skillId required" }), req)
-  }
-
-  getDb().query(`DELETE FROM skills WHERE id = ?`).run(skillId)
-
-  return addCorsHeaders(Response.json({ success: true }), req)
-}
-
-export async function handleCreateSkill(
-  req: Request,
-  addCorsHeaders: (r: Response, req: Request) => Response
-): Promise<Response> {
-  const body = await req.json().catch(() => ({}));
-  const { name, category, tools, triggers, body: bodyContent } = body;
-
-  if (!name) {
-    return addCorsHeaders(new Response("Missing name", { status: 400 }), req);
-  }
-
-  const { randomUUID } = await import("crypto");
-  const id = randomUUID();
-
-  getDb().query(
-    `INSERT INTO skills(id, name, category, tools, triggers, body, version, active) VALUES(?, ?, ?, ?, ?, ?, 1, 1)`
-  ).run(id, name, category || "", tools || "", triggers || "", bodyContent || "", 1);
-
-  return addCorsHeaders(Response.json({ success: true, id }), req);
-}

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

@@ -1,165 +0,0 @@
-import { getDb } from "../../storage/sqlite.ts"
-import { loadConfig } from "../../config/loader.ts"
-import { cpus } from "node:os"
-
-export function getSystemStats(startTime: number) {
-  const mem = process.memoryUsage()
-  const uptimeSeconds = Math.floor((Date.now() - startTime) / 1000)
-  const uptimeStr = new Date(uptimeSeconds * 1000).toISOString().substr(11, 8)
-  
-  return {
-    cpu: 0, // Placeholder - Node.js doesn't provide per-process CPU
-    memory: {
-      rss: Math.round(mem.rss / 1024 / 1024), // MB
-      heapUsed: Math.round(mem.heapUsed / 1024 / 1024), // MB
-      heapTotal: Math.round(mem.heapTotal / 1024 / 1024), // MB
-      heapPercent: Math.round((mem.heapUsed / mem.heapTotal) * 100 * 100) / 100,
-      external: Math.round((mem.external || 0) / 1024 / 1024), // MB
-    },
-    uptime: uptimeStr,
-    connections: 0, // Placeholder
-    cores: cpus().length,
-    recentMessages: 0, // Placeholder
-  }
-}
-
-export async function handleGetActivityStats(req: Request, addCorsHeaders: (r: Response, req: Request) => Response): Promise<Response> {
-  const db = getDb()
-  const url = new URL(req.url)
-  const hours = parseInt(url.searchParams.get("hours") || "12", 10)
-  
-  // Get message counts per hour from conversations table
-  const now = Date.now()
-  const startTime = now - (hours * 60 * 60 * 1000)
-  
-  const rows = db.query(`
-    SELECT 
-      strftime('%Y-%m-%d %H:00', datetime(created_at, 'unixepoch')) as hour,
-      COUNT(*) as count
-    FROM conversations
-    WHERE created_at >= ?
-    GROUP BY hour
-    ORDER BY hour
-  `).all(startTime / 1000) as { hour: string; count: number }[]
-  
-  // Format as array expected by frontend
-  const activityData = rows.map(r => ({
-    time: r.hour,
-    count: r.count,
-  }))
-  
-  return addCorsHeaders(Response.json(activityData), req)
-}
-
-export async function handleGetSystemStats(req: Request, addCorsHeaders: (r: Response, req: Request) => Response, startTime: number): Promise<Response> {
-  return addCorsHeaders(Response.json(getSystemStats(startTime)), req)
-}
-
-export async function handleGetUsageStats(req: Request, addCorsHeaders: (r: Response, req: Request) => Response): Promise<Response> {
-  const db = getDb()
-  
-  // Get totals from usage_records table
-  const totals = db.query(`
-    SELECT 
-      COALESCE(SUM(input_tokens), 0) as inputTokens,
-      COALESCE(SUM(output_tokens), 0) as outputTokens,
-      COALESCE(SUM(cost_usd), 0) as costUsd
-    FROM usage_records
-  `).get() as { inputTokens: number; outputTokens: number; costUsd: number }
-  
-  // Get by provider
-  const byProviderRows = db.query(`
-    SELECT 
-      provider,
-      COALESCE(SUM(input_tokens), 0) as inputTokens,
-      COALESCE(SUM(output_tokens), 0) as outputTokens,
-      COALESCE(SUM(cost_usd), 0) as costUsd
-    FROM usage_records
-    GROUP BY provider
-  `).all() as { provider: string; inputTokens: number; outputTokens: number; costUsd: number }[]
-  
-  // Get by model
-  const byModelRows = db.query(`
-    SELECT 
-      model,
-      COALESCE(SUM(input_tokens), 0) as inputTokens,
-      COALESCE(SUM(output_tokens), 0) as outputTokens,
-      COALESCE(SUM(cost_usd), 0) as costUsd
-    FROM usage_records
-    GROUP BY model
-  `).all() as { model: string; inputTokens: number; outputTokens: number; costUsd: number }[]
-  
-  const totalTokens = (totals.inputTokens || 0) + (totals.outputTokens || 0)
-  const totalCostUsd = totals.costUsd || 0
-  
-  // TOON savings (placeholder - actual calculation depends on implementation)
-  const toonSavedTokens = 0
-  const toonSavedCost = 0
-  const toonSavingsPercent = 0
-  
-  const stats: UsageStats = {
-    totalTokens,
-    totalInputTokens: totals.inputTokens || 0,
-    totalOutputTokens: totals.outputTokens || 0,
-    totalCostUsd,
-    toonSavedTokens,
-    toonSavedCost,
-    toonSavingsPercent,
-    byProvider: Object.fromEntries(
-      byProviderRows.map(r => [r.provider, {
-        tokens: (r.inputTokens || 0) + (r.outputTokens || 0),
-        costUsd: r.costUsd || 0,
-        inputTokens: r.inputTokens || 0,
-        outputTokens: r.outputTokens || 0,
-      }])
-    ),
-    byModel: Object.fromEntries(
-      byModelRows.map(r => [r.model, {
-        tokens: (r.inputTokens || 0) + (r.outputTokens || 0),
-        costUsd: r.costUsd || 0,
-        provider: "unknown",
-        inputTokens: r.inputTokens || 0,
-        outputTokens: r.outputTokens || 0,
-      }])
-    ),
-  }
-  
-  return addCorsHeaders(Response.json(stats), req)
-}
-
-// Add UsageStats interface for backend
-interface UsageStats {
-  totalTokens: number;
-  totalInputTokens: number;
-  totalOutputTokens: number;
-  totalCostUsd: number;
-  toonSavedTokens: number;
-  toonSavedCost: number;
-  toonSavingsPercent: number;
-  byProvider: Record<string, { tokens: number; costUsd: number; inputTokens: number; outputTokens: number }>;
-  byModel: Record<string, { tokens: number; costUsd: number; provider: string; inputTokens: number; outputTokens: number }>;
-}
-
-export async function handleSystemReload(req: Request, addCorsHeaders: (r: Response, req: Request) => Response): Promise<Response> {
-  return addCorsHeaders(Response.json({ success: true, message: "Reload triggered" }), req)
-}
-
-export async function handleApiReload(
-  req: Request,
-  addCorsHeaders: (r: Response, req: Request) => Response,
-  agent?: any
-): Promise<Response> {
-  try {
-    const newConfig = await loadConfig()
-    if (agent) {
-      await agent.updateConfig(newConfig)
-      await agent.reload()
-    }
-    return addCorsHeaders(Response.json({ success: true, message: "Configuration reloaded" }), req)
-  } catch (error) {
-    return addCorsHeaders(Response.json(
-      { success: false, error: (error as Error).message },
-      { status: 500 }
-    ), req)
-  }
-}

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

@@ -1,44 +0,0 @@
-import { getDb } from "../../storage/sqlite"
-
-export async function handleGetTasks(req: Request, addCorsHeaders: (r: Response, req: Request) => Response): Promise<Response> {
-  const url = new URL(req.url)
-  const agentId = url.searchParams.get("agentId")
-  
-  let tasks
-  if (agentId) {
-    tasks = getDb().query("SELECT * FROM tasks WHERE agent_id = ? ORDER BY id ASC").all(agentId)
-  } else {
-    tasks = getDb().query("SELECT * FROM tasks ORDER BY id ASC").all()
-  }
-  
-  return addCorsHeaders(Response.json({ tasks }), req)
-}
-
-export async function handleUpdateTask(req: Request, addCorsHeaders: (r: Response, req: Request) => Response): Promise<Response> {
-  const url = new URL(req.url)
-  const taskId = url.pathname.split("/").pop()
-  const body = await req.json().catch(() => ({}))
-  
-  if (!taskId) {
-    return addCorsHeaders(new Response("Missing ID", { status: 400 }), req)
-  }
-  
-  const updates: string[] = []
-  const params: unknown[] = []
-  
-  if (body.status !== undefined) {
-    updates.push("status = ?")
-    params.push(body.status)
-  }
-  if (body.result !== undefined) {
-    updates.push("result = ?")
-    params.push(body.result)
-  }
-  
-  if (updates.length > 0) {
-    params.push(taskId)
-    getDb().query(`UPDATE tasks SET ${updates.join(", ")} WHERE id = ?`).run(...params as any[])
-  }
-  
-  return addCorsHeaders(Response.json({ ok: true }), req)
-}

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

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

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

@@ -1,118 +0,0 @@
-import { getDb } from "../../storage/sqlite"
-
-export async function handleGetUsers(req: Request, addCorsHeaders: (r: Response, req: Request) => Response): Promise<Response> {
-  const users = getDb().query(`
-    SELECT u.*, COUNT(DISTINCT a.id) as agent_count
-    FROM users u
-    LEFT JOIN agents a ON u.id = a.user_id
-    GROUP BY u.id
-    ORDER BY u.created_at DESC
-  `).all() as Record<string, unknown>[]
-  
-  return addCorsHeaders(Response.json({
-    users: users.map(u => ({
-      id: u.id,
-      name: u.name,
-      language: u.language,
-      timezone: u.timezone,
-      occupation: u.occupation,
-      notes: u.notes,
-      createdAt: new Date((u.created_at as number) * 1000).toISOString(),
-      agentCount: u.agent_count,
-    }))
-  }), req)
-}
-
-export async function handleCreateUser(req: Request, addCorsHeaders: (r: Response, req: Request) => Response): Promise<Response> {
-  const body = await req.json().catch(() => ({}))
-  
-  const result = getDb().query(`
-    INSERT INTO users(name, language, timezone, occupation, notes)
-    VALUES(?, ?, ?, ?, ?)
-    RETURNING id
-  `).get(
-    body.name || "User",
-    body.language || "es",
-    body.timezone || "UTC",
-    body.occupation || "",
-    body.notes || ""
-  ) as { id: string } | undefined
-  
-  return addCorsHeaders(Response.json({
-    ok: true,
-    userId: result?.id
-  }), req)
-}
-
-export async function handleUpdateUserSettings(req: Request, addCorsHeaders: (r: Response, req: Request) => Response): Promise<Response> {
-  const url = new URL(req.url)
-  const userId = url.searchParams.get("userId") || "default"
-  const body = await req.json().catch(() => ({}))
-
-  const updates: string[] = []
-  const params: unknown[] = []
-
-  if (body.name !== undefined) {
-    updates.push("name = ?")
-    params.push(body.name)
-  }
-  if (body.language !== undefined) {
-    updates.push("language = ?")
-    params.push(body.language)
-  }
-  if (body.timezone !== undefined) {
-    updates.push("timezone = ?")
-    params.push(body.timezone)
-  }
-  if (body.occupation !== undefined) {
-    updates.push("occupation = ?")
-    params.push(body.occupation)
-  }
-  if (body.notes !== undefined) {
-    updates.push("notes = ?")
-    params.push(body.notes)
-  }
-
-  if (updates.length > 0) {
-    params.push(userId)
-    getDb().query(`UPDATE users SET ${updates.join(", ")} WHERE id = ?`).run(...params as any[])
-  }
-
-  return addCorsHeaders(Response.json({ ok: true }), req)
-}
-
-export async function handleGetUserChannels(
-  req: Request,
-  addCorsHeaders: (r: Response, req: Request) => Response,
-  config?: any
-): Promise<Response> {
-  return addCorsHeaders(Response.json({
-    user: config?.user || { id: "", name: "User", channels: {} },
-  }), req);
-}
-
-export async function handleLinkUserChannel(
-  req: Request,
-  addCorsHeaders: (r: Response, req: Request) => Response,
-  config?: any,
-  logger?: any
-): Promise<Response> {
-  const body = await req.json().catch(() => ({}));
-  const { channel, channelUserId } = body;
-
-  if (!channel || !channelUserId) {
-    return addCorsHeaders(Response.json({ success: false, error: "Missing channel or channelUserId" }, { status: 400 }), req);
-  }
-
-  if (config) {
-    config.user = config.user || { id: "", name: "User" };
-    config.user.channels = config.user.channels || {};
-    config.user.channels[channel] = channelUserId;
-
-    if (logger) {
-      logger.info(`Linked channel ${channel} to user ID ${channelUserId}`);
-    }
-  }
-
-  return addCorsHeaders(Response.json({ success: true, channels: config?.user?.channels }), req);
-}