@johpaz/hive 1.7.2 → 1.7.3

package/packages/core/src/gateway/resolver.ts

@@ -1,108 +0,0 @@
-import { getDb } from "../storage/sqlite"
-
-export interface ResolveContextResult {
-  userId: string
-  agentId: string
-  isNewUser: boolean
-}
-
-export interface ResolveContextOptions {
-  channel: string
-  channelUserId: string
-}
-
-export function resolveContext(options: ResolveContextOptions): ResolveContextResult {
-  const { channel, channelUserId } = options
-  const db = getDb()
-
-  const identity = db
-    .query<any, [string, string]>(
-      "SELECT user_id FROM user_identities WHERE channel = ? AND channel_user_id = ?"
-    )
-    .get(channel, channelUserId)
-
-  let userId: string
-  let isNewUser = false
-
-  if (identity) {
-    userId = identity.user_id
-  } else {
-    // Sistema mono-usuario: reutilizar el usuario del onboarding
-    const existingUser = db
-      .query<any, []>("SELECT id FROM users ORDER BY created_at ASC LIMIT 1")
-      .get() as { id: string } | undefined
-
-    if (!existingUser) {
-      throw new Error("No user found in database. Please run the onboarding process first.")
-    }
-
-    userId = existingUser.id
-
-    // Vincular este canal al usuario existente (auto-link en el primer mensaje)
-    // INSERT OR REPLACE: si ya existe una fila (user_id, channel), actualiza channel_user_id
-    // con el valor real del canal (e.g. chat ID numérico de Telegram).
-    db.query(
-      "INSERT OR REPLACE INTO user_identities (user_id, channel, channel_user_id, linked_at) VALUES (?, ?, ?, ?)"
-    ).run(userId, channel, channelUserId, Math.floor(Date.now() / 1000))
-  }
-
-  const coordinatorAgent = db
-    .query<any, []>("SELECT id FROM agents WHERE role = 'coordinator' LIMIT 1")
-    .get()
-
-  const agentId = coordinatorAgent?.id || "bee"
-
-  return { userId, agentId, isNewUser }
-}
-
-export function getDefaultAgentId(): string {
-  const db = getDb()
-  const coordinatorAgent = db
-    .query<any, []>("SELECT id FROM agents WHERE role = 'coordinator' LIMIT 1")
-    .get()
-
-  return coordinatorAgent?.id || "bee"
-}
-
-export function getUserById(userId: string): any {
-  const db = getDb()
-  return db.query<any, [string]>("SELECT * FROM users WHERE id = ?").get(userId)
-}
-
-export function updateUserProfile(userId: string, updates: {
-  name?: string
-  language?: string
-  timezone?: string
-  occupation?: string
-  notes?: string
-}): void {
-  const db = getDb()
-  const setClauses: string[] = []
-  const values: any[] = []
-
-  if (updates.name !== undefined) {
-    setClauses.push("name = ?")
-    values.push(updates.name)
-  }
-  if (updates.language !== undefined) {
-    setClauses.push("language = ?")
-    values.push(updates.language)
-  }
-  if (updates.timezone !== undefined) {
-    setClauses.push("timezone = ?")
-    values.push(updates.timezone)
-  }
-  if (updates.occupation !== undefined) {
-    setClauses.push("occupation = ?")
-    values.push(updates.occupation)
-  }
-  if (updates.notes !== undefined) {
-    setClauses.push("notes = ?")
-    values.push(updates.notes)
-  }
-
-  if (setClauses.length > 0) {
-    values.push(userId)
-    db.query(`UPDATE users SET ${setClauses.join(", ")} WHERE id = ?`).run(...values)
-  }
-}

package/packages/core/src/gateway/router.ts

@@ -1,124 +0,0 @@
-import type { Config, Binding } from "../config/loader.ts";
-
-export interface RoutingContext {
-  channel: string;
-  accountId?: string;
-  peerKind?: "direct" | "group";
-  peerId?: string;
-  guildId?: string;
-  teamId?: string;
-  roles?: string[];
-}
-
-export function matchBinding(binding: Binding, ctx: RoutingContext): number {
-  const match = binding.match;
-  let score = 0;
-
-  if (match.peer?.id && match.peer?.kind) {
-    if (ctx.peerId === match.peer.id && ctx.peerKind === match.peer.kind) {
-      score += 1000;
-    } else {
-      return 0;
-    }
-  } else if (match.peer?.id) {
-    if (ctx.peerId === match.peer.id) {
-      score += 900;
-    } else {
-      return 0;
-    }
-  } else if (match.peer?.kind) {
-    if (ctx.peerKind === match.peer.kind) {
-      score += 50;
-    } else {
-      return 0;
-    }
-  }
-
-  if (match.guildId && match.roles && match.roles.length > 0) {
-    if (ctx.guildId === match.guildId && ctx.roles?.some((r) => match.roles?.includes(r))) {
-      score += 800;
-    } else {
-      return 0;
-    }
-  } else if (match.guildId) {
-    if (ctx.guildId === match.guildId) {
-      score += 200;
-    } else {
-      return 0;
-    }
-  }
-
-  if (match.teamId) {
-    if (ctx.teamId === match.teamId) {
-      score += 300;
-    } else {
-      return 0;
-    }
-  }
-
-  if (match.accountId) {
-    if (ctx.accountId === match.accountId) {
-      score += 400;
-    } else {
-      return 0;
-    }
-  }
-
-  if (match.channel) {
-    if (ctx.channel === match.channel) {
-      score += 100;
-    } else {
-      return 0;
-    }
-  }
-
-  return score || 1;
-}
-
-export function resolveAgent(
-  config: Config,
-  ctx: RoutingContext
-): string {
-  const bindings = config.bindings ?? [];
-  
-  if (bindings.length === 0) {
-    return config.agent?.defaultAgentId ?? "main";
-  }
-
-  let bestMatch: { agentId: string; score: number } | null = null;
-
-  for (const binding of bindings) {
-    const score = matchBinding(binding, ctx);
-    if (score > 0 && (!bestMatch || score > bestMatch.score)) {
-      bestMatch = { agentId: binding.agentId, score };
-    }
-  }
-
-  if (bestMatch) {
-    return bestMatch.agentId;
-  }
-
-  return config.agent?.defaultAgentId ?? "main";
-}
-
-export class Router {
-  constructor(private config: Config) {}
-
-  route(ctx: RoutingContext): string {
-    return resolveAgent(this.config, ctx);
-  }
-
-  getAgentWorkspace(agentId: string): string {
-    const agents = this.config.agents?.list ?? [];
-    const agent = agents.find((a) => a.id === agentId);
-    
-    if (agent?.workspace) {
-      return agent.workspace.replace(/^~/, process.env.HOME ?? "");
-    }
-
-    const baseDir = this.config.agent?.baseDir?.replace(/^~/, process.env.HOME ?? "") 
-      ?? `${process.env.HOME}/.hive/agents`;
-    
-    return `${baseDir}/${agentId}/workspace`;
-  }
-}

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

@@ -1,187 +0,0 @@
-import { getDb } from "../../storage/sqlite"
-import { emitCanvas } from "../../canvas/emitter"
-import { encryptConfig } from "../../storage/crypto"
-
-export async function handleGetAgents(req: Request, addCorsHeaders: (r: Response, req: Request) => Response): Promise<Response> {
-  const rows = getDb().query(`
-    SELECT a.*, u.notes as user_preferences,
-    CASE WHEN a.headers_encrypted IS NOT NULL THEN 1 ELSE 0 END as has_headers
-    FROM agents a
-    LEFT JOIN users u ON a.user_id = u.id
-    ORDER BY a.created_at DESC
-  `).all() as Record<string, unknown>[]
-
-  const agents = rows.map(row => ({
-    // Basic fields
-    id: row.id,
-    userId: row.user_id,
-    name: row.name,
-    description: row.description,
-    systemPrompt: row.system_prompt,
-    tone: row.tone,
-
-    // Role & status
-    role: row.role as 'coordinator' | 'worker',
-    status: row.status,
-    enabled: Boolean(row.enabled),
-
-    // Provider & model
-    providerId: row.provider_id,
-    modelId: row.model_id,
-
-    // Tools & skills
-    toolsJson: row.tools_json,
-    skillsJson: row.skills_json,
-
-    // Hierarchy
-    parentId: row.parent_id,
-    maxIterations: row.max_iterations,
-
-    // Workspace
-    workspace: row.workspace,
-
-    // Headers (encrypted)
-    hasHeaders: row.has_headers === 1,
-
-    // Timestamps
-    createdAt: new Date((row.created_at as number) * 1000).toISOString(),
-    updatedAt: new Date((row.updated_at as number) * 1000).toISOString(),
-
-    // Virtual fields (not from DB)
-    taskCount: 0,
-    successRate: 100,
-  }))
-
-  return addCorsHeaders(Response.json({ agents }), req)
-}
-
-export async function handleCreateAgent(req: Request, addCorsHeaders: (r: Response, req: Request) => Response): Promise<Response> {
-  const body = await req.json().catch(() => ({}))
-  const { encrypted: headersEnc, iv: headersIv } = body.headers
-    ? encryptConfig(body.headers)
-    : { encrypted: null, iv: null }
-
-  let agentId: string
-
-  if (body.id) {
-    agentId = body.id
-    getDb().query(`
-      INSERT INTO agents(id, name, description, provider_id, model_id, tone, enabled, headers_encrypted, headers_iv, workspace)
-      VALUES(?, ?, ?, ?, ?, ?, 1, ?, ?, ?)
-    `).run(
-      agentId,
-      body.name,
-      body.description || "",
-      body.providerId || "openai",
-      body.modelId || "gpt-4o",
-      body.tone || "friendly",
-      headersEnc,
-      headersIv,
-      body.workspace || null
-    )
-  } else {
-    const result = getDb().query(`
-      INSERT INTO agents(name, description, provider_id, model_id, tone, enabled, headers_encrypted, headers_iv, workspace)
-      VALUES(?, ?, ?, ?, ?, 1, ?, ?, ?)
-      RETURNING id
-    `).get(
-      body.name,
-      body.description || "",
-      body.providerId || "openai",
-      body.modelId || "gpt-4o",
-      body.tone || "friendly",
-      headersEnc,
-      headersIv,
-      body.workspace || null
-    ) as { id: string } | undefined
-    agentId = result?.id || ""
-  }
-
-  emitCanvas("canvas:node_add", {
-    node: { id: agentId, name: body.name, status: "idle", type: "agent" }
-  })
-
-  const agent = getDb().query(`
-    SELECT id, name, description, provider_id, model_id, tone, status, enabled, active, created_at, workspace
-    FROM agents WHERE id = ?
-  `).get(agentId) as Record<string, unknown> | undefined
-
-  if (!agent) {
-    return addCorsHeaders(Response.json({ ok: false, error: "Agent not found" }), req)
-  }
-
-  return addCorsHeaders(Response.json({
-    ok: true,
-    agent: {
-      id: agent.id,
-      name: agent.name,
-      description: agent.description,
-      providerId: agent.provider_id,
-      modelId: agent.model_id,
-      tone: agent.tone,
-      status: agent.status,
-      enabled: agent.enabled === 1,
-      active: agent.active === 1,
-      createdAt: new Date((agent.created_at as number) * 1000).toISOString(),
-      workspace: agent.workspace,
-    }
-  }), req)
-}
-
-export async function handleUpdateAgent(req: Request, addCorsHeaders: (r: Response, req: Request) => Response): Promise<Response> {
-  const url = new URL(req.url)
-  const agentId = url.pathname.split("/").pop()
-
-  if (!agentId) {
-    return addCorsHeaders(new Response("Missing ID", { status: 400 }), req)
-  }
-
-  const body = await req.json().catch(() => ({}))
-
-  const updates: string[] = []
-  const params: unknown[] = []
-
-  const possibleFields = [
-    "name", "description", "provider_id", "model_id", "status",
-    "enabled", "tone", "workspace"
-  ]
-
-  for (const field of possibleFields) {
-    const bodyKey = field.replace(/_([a-z])/g, (_g) => field[1]?.toUpperCase() ?? "")
-    let val = body[field] !== undefined ? body[field] : body[bodyKey]
-
-    if (val !== undefined) {
-      updates.push(`${field} = ?`)
-      params.push(typeof val === 'object' ? JSON.stringify(val) : val)
-    }
-  }
-
-  const agentHeaders = body.headers !== undefined ? body.headers : body.config?.headers
-  if (agentHeaders !== undefined) {
-    const { encrypted, iv } = encryptConfig(agentHeaders)
-    updates.push("headers_encrypted = ?")
-    params.push(encrypted)
-    updates.push("headers_iv = ?")
-    params.push(iv)
-  }
-
-  const userPreferences = body.userPreferences !== undefined ? body.userPreferences : body.user_preferences
-  if (userPreferences !== undefined) {
-    const agentRow = getDb().query("SELECT user_id FROM agents WHERE id = ?").get(agentId) as { user_id: string } | undefined
-    if (agentRow?.user_id) {
-      getDb().query(`UPDATE users SET notes = ? WHERE id = ?`).run(userPreferences, agentRow.user_id)
-    }
-  }
-
-  if (updates.length > 0) {
-    params.push(agentId)
-    getDb().query(`UPDATE agents SET ${updates.join(", ")} WHERE id = ?`).run(...params as any[])
-
-    emitCanvas("canvas:node_update", {
-      id: agentId,
-      updates: body
-    })
-  }
-
-  return addCorsHeaders(Response.json({ ok: true }), req)
-}

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

@@ -1,203 +0,0 @@
-import { getDb } from "../../storage/sqlite"
-
-export async function handleGetChannels(req: Request, addCorsHeaders: (r: Response, req: Request) => Response): Promise<Response> {
-  const channels = getDb().query(`
-    SELECT channel, COUNT(*) as count FROM user_channels GROUP BY channel
-  `).all() as Record<string, unknown>[]
-  
-  return addCorsHeaders(Response.json({ channels }), req)
-}
-
-export async function handleGetChannelConfig(req: Request, addCorsHeaders: (r: Response, req: Request) => Response): Promise<Response> {
-  const url = new URL(req.url)
-  const channelIdMatch = url.pathname.match(/^\/api\/channels\/([^/]+)$/)
-  
-  if (!channelIdMatch) {
-    return addCorsHeaders(Response.json({ error: "Invalid path" }), req)
-  }
-  
-  const channelId = channelIdMatch[1]
-  const config = getDb().query(`
-    SELECT * FROM user_channels WHERE channel = ?
-  `).all(channelId) as Record<string, unknown>[]
-  
-  return addCorsHeaders(Response.json({ config }), req)
-}
-
-export async function handleActivateChannel(req: Request, addCorsHeaders: (r: Response, req: Request) => Response): Promise<Response> {
-  const body = await req.json().catch(() => ({}))
-  const { channel, config, accountId } = body
-  
-  if (!channel) {
-    return addCorsHeaders(Response.json({ success: false, error: "channel required" }), req)
-  }
-  
-  const userId = "default"
-  getDb().query(`
-    INSERT OR REPLACE INTO user_channels(user_id, channel, account_id, config, active)
-    VALUES(?, ?, ?, ?, 1)
-  `).run(userId, channel, accountId || null, JSON.stringify(config || {}))
-  
-  return addCorsHeaders(Response.json({ success: true, channel }), req)
-}
-
-export async function handleDeactivateChannel(req: Request, addCorsHeaders: (r: Response, req: Request) => Response): Promise<Response> {
-  const url = new URL(req.url)
-  const parts = url.pathname.split("/")
-  const channel = parts[3]
-  const accountId = parts[4]
-
-  if (!channel) {
-    return addCorsHeaders(Response.json({ success: false, error: "channel required" }), req)
-  }
-
-  const userId = "default"
-  if (accountId) {
-    getDb().query(`DELETE FROM user_channels WHERE user_id = ? AND channel = ? AND account_id = ?`).run(userId, channel, accountId)
-  } else {
-    getDb().query(`DELETE FROM user_channels WHERE user_id = ? AND channel = ?`).run(userId, channel)
-  }
-
-  return addCorsHeaders(Response.json({ success: true }), req)
-}
-
-export async function handleCreateChannel(
-  req: Request,
-  addCorsHeaders: (r: Response, req: Request) => Response,
-  channelManager?: any
-): Promise<Response> {
-  const body = await req.json().catch(() => ({}));
-  const { name, accountId, config: channelConfigData } = body;
-
-  if (!name || !accountId || !channelConfigData) {
-    return addCorsHeaders(new Response("Missing name, accountId or config", { status: 400 }), req);
-  }
-
-  // Note: Channel config persistence should be handled by the caller
-  // The channelManager is passed to start the channel after config is saved
-  if (channelManager) {
-    await channelManager.removeChannel(name, accountId);
-    await channelManager.startChannel(name, accountId);
-  }
-
-  return addCorsHeaders(Response.json({ success: true }), req);
-}
-
-export async function handleGetChannelAccount(
-  req: Request,
-  addCorsHeaders: (r: Response, req: Request) => Response,
-  name: string,
-  accountId: string
-): Promise<Response> {
-  // This should read from the config file or database
-  // For now, return a placeholder - the actual implementation depends on config storage
-  return addCorsHeaders(Response.json({ name, accountId, config: {} }), req);
-}
-
-export async function handleUpdateChannelAccount(
-  req: Request,
-  addCorsHeaders: (r: Response, req: Request) => Response,
-  name: string,
-  accountId: string,
-  channelManager?: any
-): Promise<Response> {
-  const body = await req.json().catch(() => ({}));
-  if (!body.config) {
-    return new Response("Missing config", { status: 400 });
-  }
-
-  // Note: Channel config persistence should be handled by the caller
-  if (channelManager) {
-    await channelManager.removeChannel(name, accountId);
-    await channelManager.startChannel(name, accountId);
-  }
-
-  return addCorsHeaders(Response.json({ success: true }), req);
-}
-
-export async function handleDeleteChannelAccount(
-  req: Request,
-  addCorsHeaders: (r: Response, req: Request) => Response,
-  name: string,
-  accountId: string,
-  config?: any,
-  channelManager?: any
-): Promise<Response> {
-  // Note: Config update should be handled by the caller
-  if (channelManager) {
-    await channelManager.removeChannel(name, accountId);
-  }
-
-  return addCorsHeaders(Response.json({ success: true }), req);
-}
-
-export async function handleChannelAction(
-  req: Request,
-  addCorsHeaders: (r: Response, req: Request) => Response,
-  name: string,
-  accountId: string,
-  action: "start" | "stop",
-  channelManager?: any
-): Promise<Response> {
-  try {
-    if (!channelManager) {
-      return addCorsHeaders(new Response("Channel manager not available", { status: 500 }), req);
-    }
-
-    if (action === "start") {
-      await channelManager.startChannel(name, accountId);
-    } else {
-      await channelManager.stopChannel(name, accountId);
-    }
-    return addCorsHeaders(Response.json({ success: true }), req);
-  } catch (error) {
-    return addCorsHeaders(Response.json(
-      { success: false, error: (error as Error).message },
-      { status: 500 }
-    ), req);
-  }
-}
-
-export async function handleUpdateChannelSettings(
-  req: Request,
-  addCorsHeaders: (r: Response, req: Request) => Response,
-  channelId: string
-): Promise<Response> {
-  const body = await req.json().catch(() => ({})) as Record<string, unknown>;
-  const allowed = ["voice_enabled", "tts_enabled", "stt_provider", "tts_provider", "tts_voice_id", "step_delivery_mode"] as const;
-  const updates: string[] = [];
-  const params: unknown[] = [];
-
-  for (const key of allowed) {
-    if (key in body) {
-      updates.push(`${key} = ?`);
-      params.push(typeof body[key] === "boolean" ? (body[key] ? 1 : 0) : body[key]);
-    }
-  }
-
-  if (updates.length === 0) {
-    return addCorsHeaders(Response.json({ error: "No valid fields to update" }, { status: 400 }), req);
-  }
-
-  params.push(channelId);
-  getDb().query(`UPDATE channels SET ${updates.join(", ")} WHERE id = ?`).run(...params as any[]);
-
-  return addCorsHeaders(Response.json({ success: true }), req);
-}
-
-export async function handleToggleChannel(
-  req: Request,
-  addCorsHeaders: (r: Response, req: Request) => Response,
-  channelId: 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 channels SET active = ?, enabled = ? WHERE id = ?`).run(active ? 1 : 0, active ? 1 : 0, channelId);
-
-  return addCorsHeaders(Response.json({ success: true, active, message: active ? `Canal "${channelId}" activado` : `Canal "${channelId}" desactivado` }), req);
-}