@johpaz/hive 1.7.2 → 1.7.3

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

@@ -1,93 +0,0 @@
-import { getDb } from "../../storage/sqlite.ts"
-import type { Config } from "../../config/loader.ts"
-
-export async function handleGetModels(req: Request, addCorsHeaders: (r: Response, req: Request) => Response): Promise<Response> {
-  const url = new URL(req.url)
-  const providerId = url.searchParams.get("provider_id")
-
-  let models
-  if (providerId) {
-    models = getDb().query("SELECT * FROM models WHERE provider_id = ? ORDER BY name").all(providerId)
-  } else {
-    models = getDb().query("SELECT * FROM models ORDER BY name").all()
-  }
-
-  return addCorsHeaders(Response.json({ models }), req)
-}
-
-export async function handleCreateModel(req: Request, addCorsHeaders: (r: Response, req: Request) => Response): Promise<Response> {
-  const body = await req.json().catch(() => ({}))
-
-  const providerId = body.provider_id || body.providerId
-  const name = body.name
-  const modelType = body.model_type || body.modelType || "llm"
-  const contextWindow = body.context_window || body.contextWindow || 50000
-
-  if (!name || !providerId) {
-    return addCorsHeaders(Response.json({ ok: false, error: "name and provider_id are required" }, { status: 400 }), req)
-  }
-
-  const id = body.id || name
-
-  const existing = getDb().query("SELECT * FROM models WHERE id = ?").get(id) as any
-  if (existing) {
-    return addCorsHeaders(Response.json({ ok: false, error: "Model already exists", id, model: existing }, { status: 409 }), req)
-  }
-
-  getDb().query(`
-    INSERT INTO models(id, name, provider_id, model_type, context_window, enabled, active)
-    VALUES(?, ?, ?, ?, ?, 1, 1)
-  `).run(id, name, providerId, modelType, contextWindow)
-
-  const model = getDb().query("SELECT * FROM models WHERE id = ?").get(id)
-  return addCorsHeaders(Response.json({ ok: true, id, model }, { status: 201 }), req)
-}
-
-export async function handleToggleModel(req: Request, addCorsHeaders: (r: Response, req: Request) => Response): Promise<Response> {
-  const url = new URL(req.url)
-  // URL pattern: /api/models/:id/toggle — extract model id from path
-  const pathMatch = url.pathname.match(/^\/api\/models\/([^/]+)\/toggle$/)
-  const modelId = pathMatch ? decodeURIComponent(pathMatch[1]) : null
-  const body = await req.json().catch(() => ({}))
-  const { active } = body
-
-  if (!modelId || active === undefined) {
-    return addCorsHeaders(Response.json({ success: false, error: "model id and active required" }), req)
-  }
-
-  getDb().query(`UPDATE models SET active = ?, enabled = ? WHERE id = ?`).run(active ? 1 : 0, active ? 1 : 0, modelId)
-
-  return addCorsHeaders(Response.json({ success: true, active }), req)
-}
-
-export async function handleGetModelsConfig(
-  req: Request,
-  addCorsHeaders: (r: Response, req: Request) => Response,
-  config: Config
-): Promise<Response> {
-  return addCorsHeaders(Response.json({
-    config: config.models || {},
-    availableProviders: ["openai", "anthropic", "gemini", "kimi", "ollama", "openrouter", "deepseek"],
-  }), req);
-}
-
-export async function handleUpdateModelsConfig(
-  req: Request,
-  addCorsHeaders: (r: Response, req: Request) => Response,
-  config: Config,
-  agent?: any
-): Promise<Response> {
-  const body = await req.json().catch(() => ({}));
-  const { defaultProvider, defaults, providers } = body;
-
-  config.models = config.models || {};
-  if (defaultProvider) config.models.defaultProvider = defaultProvider;
-  if (defaults) config.models.defaults = { ...(config.models.defaults || {}), ...defaults };
-  if (providers) config.models.providers = { ...(config.models.providers || {}), ...providers };
-
-  if (agent) {
-    await agent.updateConfig(config);
-  }
-
-  return addCorsHeaders(Response.json({ success: true }), req);
-}

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

@@ -1,179 +0,0 @@
-import { getDb } from "../../storage/sqlite"
-import { emitCanvas } from "../../canvas/emitter"
-
-export async function handleGetProjects(req: Request, addCorsHeaders: (r: Response, req: Request) => Response): Promise<Response> {
-  const projects = getDb().query(`
-    SELECT p.*, 
-      (SELECT COUNT(*) FROM tasks WHERE project_id = p.id) as task_count,
-      (SELECT COUNT(*) FROM tasks WHERE project_id = p.id AND status = 'done') as done_count
-    FROM projects p
-    ORDER BY p.created_at DESC
-  `).all() as Record<string, unknown>[]
-  
-  return addCorsHeaders(Response.json({
-    projects: projects.map(p => ({
-      id: p.id,
-      name: p.name,
-      description: p.description,
-      status: p.status,
-      createdAt: new Date((p.created_at as number) * 1000).toISOString(),
-      taskCount: p.task_count,
-      doneCount: p.done_count,
-    }))
-  }), req)
-}
-
-export async function handleGetActiveProject(req: Request, addCorsHeaders: (r: Response, req: Request) => Response): Promise<Response> {
-  const project = getDb().query(`
-    SELECT p.*, 
-      (SELECT COUNT(*) FROM tasks WHERE project_id = p.id) as task_count,
-      (SELECT COUNT(*) FROM tasks WHERE project_id = p.id AND status = 'done') as done_count
-    FROM projects p
-    WHERE p.status = 'active'
-    ORDER BY p.created_at DESC
-    LIMIT 1
-  `).get() as Record<string, unknown> | undefined
-  
-  if (!project) {
-    return addCorsHeaders(Response.json({ project: null }), req)
-  }
-  
-  const tasks = getDb().query(`
-    SELECT * FROM tasks WHERE project_id = ? ORDER BY created_at ASC
-  `).all(project.id as string) as Record<string, unknown>[]
-  
-  return addCorsHeaders(Response.json({
-    project: {
-      ...project,
-      tasks,
-      taskCount: project.task_count,
-      doneCount: project.done_count,
-    }
-  }), req)
-}
-
-export async function handleCreateProject(req: Request, addCorsHeaders: (r: Response, req: Request) => Response): Promise<Response> {
-  const body = await req.json().catch(() => ({}))
-  
-  const result = getDb().query(`
-    INSERT INTO projects(name, description, status)
-    VALUES(?, ?, 'active')
-    RETURNING id
-  `).get(body.name || "New Project", body.description || "") as { id: string } | undefined
-  
-  const projectId = result?.id
-  
-  if (projectId) {
-    emitCanvas("canvas:node_add", {
-      node: { id: projectId, name: body.name || "New Project", status: "active", type: "project" }
-    })
-  }
-  
-  return addCorsHeaders(Response.json({ ok: true, projectId }), req)
-}
-
-export async function handleUpdateProject(req: Request, addCorsHeaders: (r: Response, req: Request) => Response): Promise<Response> {
-  const url = new URL(req.url)
-  const projectId = url.pathname.split("/").pop()
-  const body = await req.json().catch(() => ({}))
-
-  if (!projectId) {
-    return addCorsHeaders(new Response("Missing ID", { status: 400 }), req)
-  }
-
-  const updates: string[] = []
-  const params: unknown[] = []
-
-  if (body.name !== undefined) {
-    updates.push("name = ?")
-    params.push(body.name)
-  }
-  if (body.description !== undefined) {
-    updates.push("description = ?")
-    params.push(body.description)
-  }
-  if (body.status !== undefined) {
-    updates.push("status = ?")
-    params.push(body.status)
-  }
-
-  if (updates.length > 0) {
-    params.push(projectId)
-    getDb().query(`UPDATE projects SET ${updates.join(", ")} WHERE id = ?`).run(...params as any[])
-  }
-
-  return addCorsHeaders(Response.json({ ok: true }), req)
-}
-
-export async function handleGetProjectHistory(
-  req: Request,
-  addCorsHeaders: (r: Response, req: Request) => Response
-): Promise<Response> {
-  const url = new URL(req.url);
-  const page = parseInt(url.searchParams.get("page") || "1");
-  const limit = parseInt(url.searchParams.get("limit") || "20");
-  const offset = (page - 1) * limit;
-  const db = getDb();
-
-  const projects = db.query(
-    "SELECT * FROM projects WHERE status IN ('done','failed') ORDER BY completed_at DESC LIMIT ? OFFSET ?"
-  ).all(limit, offset) as Record<string, unknown>[];
-
-  const total = db.query(
-    "SELECT COUNT(*) as count FROM projects WHERE status IN ('done', 'failed')"
-  ).get() as { count: number };
-
-  return addCorsHeaders(Response.json({
-    data: projects.map(p => ({
-      ...p,
-      tasks: db.query("SELECT * FROM tasks WHERE project_id = ? ORDER BY id ASC").all(p.id as string)
-    })),
-    pagination: { page, limit, total: total.count, pages: Math.ceil(total.count / limit) }
-  }), req);
-}
-
-export async function handleGetProjectDetail(
-  req: Request,
-  addCorsHeaders: (r: Response, req: Request) => Response,
-  projectId: string
-): Promise<Response> {
-  const db = getDb();
-  const project = db.query(
-    "SELECT * FROM projects WHERE id = ?"
-  ).get(projectId) as Record<string, unknown> | undefined;
-
-  if (!project) {
-    return new Response("Project not found", { status: 404 });
-  }
-
-  const tasks = db.query(
-    "SELECT * FROM tasks WHERE project_id = ? ORDER BY id ASC"
-  ).all(projectId);
-
-  const subprojects = db.query(
-    "SELECT * FROM projects WHERE parent_id = ?"
-  ).all(projectId);
-
-  return addCorsHeaders(Response.json({ ...project, tasks, subprojects }), req);
-}
-
-export async function handleGetProjectTasks(
-  req: Request,
-  addCorsHeaders: (r: Response, req: Request) => Response,
-  projectId: string
-): Promise<Response> {
-  const db = getDb();
-  const project = db.query(
-    "SELECT id FROM projects WHERE id = ?"
-  ).get(projectId);
-
-  if (!project) {
-    return new Response("Project not found", { status: 404 });
-  }
-
-  const tasks = db.query(
-    "SELECT * FROM tasks WHERE project_id = ? ORDER BY id ASC"
-  ).all(projectId);
-
-  return addCorsHeaders(Response.json(tasks), req);
-}

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

@@ -1,192 +0,0 @@
-import { getDb } from "../../storage/sqlite"
-import { decryptApiKey, maskApiKey, encryptApiKey, encryptConfig } from "../../storage/crypto"
-
-export async function handleGetProviders(req: Request, addCorsHeaders: (r: Response, req: Request) => Response): Promise<Response> {
-  const rawProviders = getDb().query(`
-    SELECT id, name, base_url, enabled, active, num_ctx,
-      api_key_encrypted, api_key_iv,
-      CASE WHEN api_key_encrypted IS NOT NULL THEN 1 ELSE 0 END as has_api_key,
-      CASE WHEN headers_encrypted IS NOT NULL THEN 1 ELSE 0 END as has_headers
-    FROM providers
-  `).all() as Record<string, unknown>[]
-
-  const modelsRows = getDb().query(`
-    SELECT id, name, provider_id, enabled, active FROM models
-  `).all() as Record<string, unknown>[]
-
-  const modelsByProvider: Record<string, Record<string, unknown>[]> = {}
-  for (const m of modelsRows) {
-    const pid = m.provider_id as string
-    if (!modelsByProvider[pid]) modelsByProvider[pid] = []
-    modelsByProvider[pid].push({ id: m.id, name: m.name, provider_id: m.provider_id, enabled: !!m.enabled, active: !!m.active })
-  }
-
-  const providers = rawProviders.map((p) => {
-    let masked_api_key: string | null = null
-    if (p.api_key_encrypted && p.api_key_iv) {
-      try {
-        const plain = decryptApiKey(p.api_key_encrypted as string, p.api_key_iv as string)
-        masked_api_key = maskApiKey(plain)
-      } catch { /* silently ignore */ }
-    }
-    return {
-      id: p.id,
-      name: p.name,
-      base_url: p.base_url,
-      enabled: p.enabled,
-      active: p.active,
-      num_ctx: p.num_ctx ?? null,
-      has_api_key: p.has_api_key,
-      has_headers: p.has_headers,
-      masked_api_key,
-      models: modelsByProvider[p.id as string] || [],
-    }
-  })
-
-  return addCorsHeaders(Response.json({ providers }), req)
-}
-
-export async function handleCreateProvider(req: Request, addCorsHeaders: (r: Response, req: Request) => Response): Promise<Response> {
-  const body = await req.json().catch(() => ({}))
-  getDb().query(`
-    INSERT OR REPLACE INTO providers(id, name, base_url, enabled, active)
-    VALUES(?, ?, ?, ?, 1)
-  `).run(body.id, body.name, body.base_url || null, body.enabled !== undefined ? body.enabled : 1)
-  return addCorsHeaders(Response.json({ ok: true }), req)
-}
-
-export async function handleToggleProvider(req: Request, addCorsHeaders: (r: Response, req: Request) => Response): Promise<Response> {
-  const url = new URL(req.url)
-  const providerId = url.pathname.split("/")[3]
-  const body = await req.json().catch(() => ({}))
-  const { active } = body
-  
-  if (active === undefined) {
-    return addCorsHeaders(new Response("Missing active field", { status: 400 }), req)
-  }
-  
-  getDb().query(`UPDATE providers SET active = ?, enabled = ? WHERE id = ?`).run(active ? 1 : 0, active ? 1 : 0, providerId)
-  return addCorsHeaders(Response.json({ success: true, active }), req)
-}
-
-export async function handleUpdateProvider(req: Request, addCorsHeaders: (r: Response, req: Request) => Response): Promise<Response> {
-  const url = new URL(req.url)
-  const providerIdMatch = url.pathname.match(/^\/api\/providers\/([^/]+)$/)
-  
-  if (!providerIdMatch) {
-    return addCorsHeaders(new Response("Invalid path", { status: 400 }), req)
-  }
-  
-  const id = providerIdMatch[1]
-  const body = await req.json().catch(() => ({}))
-  const updates: string[] = []
-  const params: unknown[] = []
-
-  if (body.name) {
-    updates.push("name = ?")
-    params.push(body.name)
-  }
-  const baseUrl = body.base_url !== undefined ? body.base_url : body.baseUrl
-  if (baseUrl !== undefined) {
-    updates.push("base_url = ?")
-    params.push(baseUrl || null)
-  }
-  if (body.enabled !== undefined) {
-    updates.push("enabled = ?")
-    params.push(body.enabled ? 1 : 0)
-  }
-  if (body.active !== undefined) {
-    updates.push("active = ?")
-    params.push(body.active ? 1 : 0)
-  }
-  if (body.config?.apiKey || body.apiKey) {
-    const apiKey = body.config?.apiKey || body.apiKey
-    const { encrypted, iv } = encryptApiKey(apiKey)
-    updates.push("api_key_encrypted = ?")
-    params.push(encrypted)
-    updates.push("api_key_iv = ?")
-    params.push(iv)
-  }
-  if (body.headers) {
-    const { encrypted, iv } = encryptConfig(body.headers)
-    updates.push("headers_encrypted = ?")
-    params.push(encrypted)
-    updates.push("headers_iv = ?")
-    params.push(iv)
-  }
-  const numCtx = body.num_ctx !== undefined ? body.num_ctx : body.numCtx
-  if (numCtx !== undefined) {
-    updates.push("num_ctx = ?")
-    params.push(numCtx ? Number(numCtx) : null)
-  }
-
-  if (updates.length > 0) {
-    params.push(id)
-    getDb().query(`UPDATE providers SET ${updates.join(", ")} WHERE id = ?`).run(...params as any[])
-  }
-
-  return addCorsHeaders(Response.json({ ok: true }), req)
-}
-
-export async function handleSyncProviderModels(
-  req: Request,
-  addCorsHeaders: (r: Response, req: Request) => Response,
-  providerId: string
-): Promise<Response> {
-  const db = getDb()
-  const providerRow = db.query<Record<string, unknown>, [string]>(
-    "SELECT * FROM providers WHERE id = ?"
-  ).get(providerId)
-
-  if (!providerRow) {
-    return addCorsHeaders(new Response("Provider not found", { status: 404 }), req)
-  }
-
-  const baseUrl = ((providerRow.base_url as string) || "http://localhost:11434").replace(/\/(v1|api)\/?$/, "")
-
-  try {
-    const res = await fetch(`${baseUrl}/api/tags`)
-    if (!res.ok) {
-      return addCorsHeaders(Response.json({ error: `Ollama responded ${res.status}` }, { status: 502 }), req)
-    }
-
-    const data = await res.json() as { models: Array<{ name: string }> }
-    const ollamaModels = data.models || []
-
-    const upsert = db.query(
-      `INSERT INTO models (id, provider_id, name, model_type, enabled, active) 
-       VALUES (?, ?, ?, 'llm', 1, 1) 
-       ON CONFLICT(id) DO UPDATE SET name = excluded.name, enabled = 1`
-    )
-
-    for (const m of ollamaModels) {
-      upsert.run(m.name, providerId, m.name)
-    }
-
-    const installedIds = ollamaModels.map(m => m.name)
-    const existingModels = db.query<Record<string, unknown>, [string]>(
-      "SELECT id FROM models WHERE provider_id = ?"
-    ).all(providerId) as Record<string, unknown>[]
-
-    const disable = db.query("UPDATE models SET active = 0, enabled = 0 WHERE id = ?")
-    for (const row of existingModels) {
-      if (!installedIds.includes(row.id as string)) {
-        disable.run(row.id as string)
-      }
-    }
-
-    const models = db.query<Record<string, unknown>, [string]>(
-      "SELECT id, name, provider_id, enabled, active FROM models WHERE provider_id = ?"
-    ).all(providerId)
-
-    return addCorsHeaders(Response.json({ 
-      success: true, 
-      synced: ollamaModels.length, 
-      models 
-    }), req)
-  } catch (err: unknown) {
-    return addCorsHeaders(Response.json({ 
-      error: `No se pudo conectar a Ollama: ${(err as Error).message}` 
-    }, { status: 502 }), req)
-  }
-}