@johpaz/hive 1.1.0

package/packages/core/src/storage/onboarding.ts

@@ -0,0 +1,1087 @@
+import { logger } from "../utils/logger.ts";
+import { getDb, initializeDatabase } from "./sqlite";
+import { encryptApiKey, encryptConfig, decryptApiKey, decryptConfig } from "./crypto";
+import { seedAllData } from "./seed";
+
+export interface OnboardingSection {
+  step: "user" | "skills" | "ethics" | "tools" | "provider" | "model" | "channel" | "codebridge" | "mcp" | "agent" | "complete";
+  userId: string;
+  data: Record<string, unknown>;
+  completedAt?: number;
+}
+
+const log = logger.child("onboarding");
+
+export function initOnboardingDb(): void {
+  try {
+    initializeDatabase();
+    
+    // Verificar si la DB ya tiene datos antes de hacer seed
+    const db = getDb();
+    const userCount = db.query("SELECT COUNT(*) as count FROM users").get() as { count: number };
+    
+    if (userCount.count > 0) {
+      log.info("✅ DB ya inicializada con " + userCount.count + " usuario(s). Saltando seed.");
+      return;
+    }
+    
+    log.info("🌱 Ejecutando seed de datos...");
+    seedAllData();
+    log.info("✅ Seed completado correctamente.");
+  } catch (e) {
+    log.error("⚠️ Fallo al inicializar/poblar la DB:", { error: (e as Error).message });
+  }
+}
+
+export function saveUserProfile(data: {
+  userId?: string;
+  userName?: string;
+  userLanguage?: string;
+  userTimezone?: string;
+  userOccupation?: string;
+  userNotes?: string;
+  agentName?: string;
+  agentId?: string;
+  agentDescription?: string;
+  agentTone?: string;
+  channelUserId?: string;
+}): string {
+  try {
+    const db = getDb();
+    let finalUserId = data.userId;
+
+    if (!finalUserId) {
+      // 1️⃣ Dejar que SQLite genere el ID automáticamente con randomblob(16)
+      const result = db.query(`
+        INSERT INTO users (name, language, timezone, occupation, notes)
+        VALUES (?, ?, ?, ?, ?) RETURNING id
+      `).get(
+        data.userName || null,
+        data.userLanguage || null,
+        data.userTimezone || null,
+        data.userOccupation || null,
+        data.userNotes || null
+      ) as { id: string };
+      finalUserId = result.id;
+      log.info("✅ User created with auto-generated ID", { userId: finalUserId });
+    } else {
+      // 1️⃣ Upsert con ID explícito (flujo web o actualización)
+      db.query(`
+        INSERT INTO users (id, name, language, timezone, occupation, notes)
+        VALUES (?, ?, ?, ?, ?, ?)
+        ON CONFLICT(id) DO UPDATE SET
+          name = COALESCE(excluded.name, name),
+          language = COALESCE(excluded.language, language),
+          timezone = COALESCE(excluded.timezone, timezone),
+          occupation = COALESCE(excluded.occupation, occupation),
+          notes = COALESCE(excluded.notes, notes)
+      `).run(
+        finalUserId,
+        data.userName || null,
+        data.userLanguage || null,
+        data.userTimezone || null,
+        data.userOccupation || null,
+        data.userNotes || null
+      );
+    }
+
+    // 2️⃣ Crear identidad base para webchat (sesión única)
+    if (data.channelUserId) {
+      db.query(`
+        INSERT OR REPLACE INTO user_identities (user_id, channel, channel_user_id)
+        VALUES (?, 'webchat', ?)
+      `).run(finalUserId, data.channelUserId);
+      log.info("✅ User identity created for webchat", { userId: finalUserId });
+    }
+
+    // 3️⃣ Crear o actualizar agente
+    if (data.agentId && data.agentName) {
+      const systemPrompt = buildAgentSystemPrompt(data.agentName, data.agentDescription, data.agentTone || "friendly")
+      db.query(`
+        INSERT INTO agents
+          (id, user_id, name, description, tone, system_prompt, status, is_coordinator)
+        VALUES (?, ?, ?, ?, ?, ?, 'idle', 1)
+        ON CONFLICT(id) DO UPDATE SET
+          user_id = COALESCE(excluded.user_id, user_id),
+          name = COALESCE(excluded.name, name),
+          description = COALESCE(excluded.description, description),
+          tone = COALESCE(excluded.tone, tone),
+          system_prompt = excluded.system_prompt
+      `).run(
+        data.agentId,
+        finalUserId,
+        data.agentName,
+        data.agentDescription || null,
+        data.agentTone || null,
+        systemPrompt
+      );
+    }
+
+    return finalUserId;
+  } catch (e) {
+    log.error("⚠️ Error saving user profile:", { error: (e as Error).message });
+    throw e;
+  }
+}
+
+export function activateSkills(userId: string, skillIds: string[]): void {
+  try {
+    const db = getDb();
+    // Activar skills seleccionadas
+    for (const skillId of skillIds) {
+      db.query(`UPDATE skills SET active = 1, enabled = 1 WHERE id = ?`).run(skillId);
+    }
+    log.info("✅ Skills activadas:", { skillIds: skillIds.join(", ") });
+  } catch (e) {
+    log.error("⚠️ Error activating skills:", { error: (e as Error).message });
+  }
+}
+
+export function activateEthics(userId: string, ethicsId: string): void {
+  try {
+    const db = getDb();
+    // Activar el ethics seleccionado
+    db.query(`UPDATE ethics SET active = 1 WHERE id = ?`).run(ethicsId);
+    // Desactivar los demás
+    db.query(`UPDATE ethics SET active = 0 WHERE id != ?`).run(ethicsId);
+    log.info("✅ Ethics activado:", { ethicsId });
+  } catch (e) {
+    log.error("⚠️ Error activating ethics:", { error: (e as Error).message });
+  }
+}
+
+export function activateTools(userId: string, toolIds: string[]): void {
+  try {
+    const db = getDb();
+    // Activar tools seleccionadas
+    for (const toolId of toolIds) {
+      db.query(`UPDATE tools SET active = 1, enabled = 1 WHERE id = ?`).run(toolId);
+    }
+    log.info("✅ Tools activadas:", { toolIds: toolIds.join(", ") });
+  } catch (e) {
+    log.error("⚠️ Error activating tools:", { error: (e as Error).message });
+  }
+}
+
+export async function saveProviderConfig(data: {
+  userId: string;
+  provider: string;
+  model: string;
+  apiKey?: string;
+  baseUrl?: string;
+}): Promise<void> {
+  try {
+    const db = getDb();
+
+    let apiKeyEncrypted = null;
+    let apiKeyIv = null;
+
+    if (data.apiKey) {
+      const encrypted = await encryptApiKey(data.apiKey);
+      apiKeyEncrypted = encrypted.encrypted;
+      apiKeyIv = encrypted.iv;
+    }
+
+    // 1️⃣ Primero: Actualizar provider global con API key del usuario
+    db.query(`
+      UPDATE providers SET 
+        api_key_encrypted = ?, 
+        api_key_iv = ?, 
+        base_url = ?,
+        enabled = 1,
+        active = 1
+      WHERE id = ?
+    `).run(apiKeyEncrypted, apiKeyIv, data.baseUrl || null, data.provider);
+
+    log.info("✅ Provider actualizado:", { provider: data.provider });
+
+    // 2️⃣ Segundo: Activar el modelo seleccionado
+    db.query(`
+      UPDATE models SET enabled = 1, active = 1
+      WHERE id = ?
+    `).run(data.model);
+
+    log.info("✅ Model activado:", { model: data.model });
+  } catch (e) {
+    log.error("⚠️ Error saving provider:", { error: (e as Error).message });
+    throw e;
+  }
+}
+
+export function activateCodeBridge(userId: string, codeBridgeConfig: { id: string; enabled: boolean; port?: number }[]): void {
+  try {
+    const db = getDb();
+    // 7️⃣ Séptimo: Configurar Code Bridge CLIs seleccionados
+    for (const cb of codeBridgeConfig) {
+      db.query(`
+        UPDATE code_bridge SET enabled = ?, active = ?, port = ?, user_id = ?
+        WHERE id = ?
+      `).run(cb.enabled ? 1 : 0, cb.enabled ? 1 : 0, cb.port || 18791, userId, cb.id);
+    }
+    log.info("✅ Code Bridge configurado:", { codeBridgeIds: codeBridgeConfig.map(c => c.id).join(", ") });
+  } catch (e) {
+    log.error("⚠️ Error configuring code bridge:", { error: (e as Error).message });
+  }
+}
+
+export function activateMcpServers(userId: string, mcpIds: string[]): void {
+  try {
+    const db = getDb();
+    // Activar MCP servers seleccionados
+    for (const mcpId of mcpIds) {
+      db.query(`UPDATE mcp_servers SET active = 1, enabled = 1 WHERE id = ?`).run(mcpId);
+    }
+    log.info("✅ MCP servers activados:", { mcpIds: mcpIds.join(", ") });
+  } catch (e) {
+    log.error("⚠️ Error activating MCP servers:", { error: (e as Error).message });
+  }
+}
+
+function buildAgentSystemPrompt(name: string, description: string | undefined, tone: string): string {
+  const toneGuide: Record<string, string> = {
+    friendly:     "Sos cálido, cercano y empático. Usás un lenguaje natural y amigable, como si hablaras con un amigo de confianza.",
+    professional: "Sos preciso, claro y formal. Priorizás la exactitud técnica y el lenguaje estructurado.",
+    direct:       "Sos conciso y al punto. Sin rodeos ni relleno — respondés exactamente lo que se pregunta.",
+    casual:       "Sos relajado e informal. Podés usar humor moderado y un tono conversacional descontracturado.",
+  }
+
+  const toneText = toneGuide[tone] || toneGuide.friendly
+
+  const lines = [
+    `Sos ${name}${description ? `, ${description}` : ""}.`,
+    "",
+    `TONO Y ESTILO:`,
+    toneText,
+    "",
+    `PRINCIPIOS:`,
+    `- Siempre usá las herramientas disponibles antes de pedir información al usuario.`,
+    `- Confirmá acciones irreversibles (borrar archivos, cancelar tareas) antes de ejecutarlas.`,
+    `- Cuando no puedas completar algo, explicá brevemente por qué y qué alternativas hay.`,
+    `- Adaptá tu nivel técnico al contexto del usuario.`,
+  ]
+
+  return lines.join("\n")
+}
+
+export function saveAgentConfig(data: {
+  userId: string;
+  agentId?: string;
+  agentName: string;
+  providerId: string;
+  modelId: string;
+  tone: string;
+  description?: string;
+}): string {
+  try {
+    const db = getDb();
+    let finalAgentId = data.agentId;
+
+    const systemPrompt = buildAgentSystemPrompt(data.agentName, data.description, data.tone)
+
+    // Si no se pasa agentId, dejar que SQLite lo genere automáticamente
+    if (!finalAgentId) {
+      const result = db.query(`
+        INSERT INTO agents
+          (user_id, name, description, tone, system_prompt, provider_id, model_id, status, is_coordinator, enabled)
+        VALUES (?, ?, ?, ?, ?, ?, ?, 'idle', 1, 1)
+        RETURNING id
+      `).get(
+        data.userId,
+        data.agentName,
+        data.description || null,
+        data.tone,
+        systemPrompt,
+        data.providerId || null,
+        data.modelId || null
+      ) as { id: string };
+      finalAgentId = result.id;
+      log.info("✅ Agent created with auto-generated ID", { agentId: finalAgentId });
+    } else {
+      // INSERT or UPDATE agent (crea nuevo o actualiza existente)
+      db.query(`
+        INSERT INTO agents
+          (id, user_id, name, description, tone, system_prompt, provider_id, model_id, status, is_coordinator, enabled)
+        VALUES (?, ?, ?, ?, ?, ?, ?, ?, 'idle', 1, 1)
+        ON CONFLICT(id) DO UPDATE SET
+          user_id = COALESCE(excluded.user_id, user_id),
+          name = COALESCE(excluded.name, name),
+          description = COALESCE(excluded.description, description),
+          tone = COALESCE(excluded.tone, tone),
+          system_prompt = excluded.system_prompt,
+          provider_id = COALESCE(excluded.provider_id, provider_id),
+          model_id = COALESCE(excluded.model_id, model_id),
+          status = 'idle',
+          enabled = 1,
+          is_coordinator = 1
+      `).run(
+        data.agentId,
+        data.userId,
+        data.agentName,
+        data.description || null,
+        data.tone,
+        systemPrompt,
+        data.providerId || null,
+        data.modelId || null
+      );
+    }
+
+    return finalAgentId;
+  } catch (e) {
+    log.error("⚠️ Error saving agent:", { error: (e as Error).message });
+    throw e;
+  }
+}
+
+export async function activateChannel(userId: string, data: {
+  channelId: string;
+  channelUserId?: string; // For creating user_identity
+  config?: Record<string, unknown>;
+}): Promise<void> {
+  try {
+    const db = getDb();
+
+    if (data.config && Object.keys(data.config).length > 0) {
+      const encrypted = await encryptConfig(data.config);
+      db.query(`
+        UPDATE channels 
+        SET user_id = ?, active = 1, enabled = 1, status = 'connected',
+            config_encrypted = ?, config_iv = ?
+        WHERE id = ?
+      `).run(userId, encrypted.encrypted, encrypted.iv, data.channelId);
+    } else {
+      db.query(`
+        UPDATE channels 
+        SET user_id = ?, active = 1, enabled = 1, status = 'connected'
+        WHERE id = ?
+      `).run(userId, data.channelId);
+    }
+
+    // Create user_identity for the channel if channelUserId provided
+    if (data.channelUserId) {
+      const channelType = data.channelId; // webchat, telegram, discord, etc.
+      db.query(`
+        INSERT OR REPLACE INTO user_identities (user_id, channel, channel_user_id)
+        VALUES (?, ?, ?)
+      `).run(userId, channelType, data.channelUserId);
+      log.info("✅ User identity created", { userId, channel: channelType });
+    }
+
+    log.info("✅ Channel activated:", { channelId: data.channelId, userId });
+  } catch (e) {
+    log.error("⚠️ Error activating channel:", { error: (e as Error).message });
+  }
+}
+
+export async function saveVoiceConfig(data: {
+  userId: string;
+  channelId: string;
+  voiceEnabled: boolean;
+  sttProvider: string;
+  ttsProvider: string;
+  sttApiKey?: string;
+  ttsApiKey?: string;
+}): Promise<void> {
+  try {
+    const db = getDb();
+
+    // Activate STT and TTS models
+    db.query(`UPDATE models SET active = 1, enabled = 1 WHERE id = ?`).run(data.sttProvider);
+    db.query(`UPDATE models SET active = 1, enabled = 1 WHERE id = ?`).run(data.ttsProvider);
+
+    // Determine provider IDs based on model IDs
+    let sttProviderId = "";
+    let ttsProviderId = "";
+
+    if (data.sttProvider.startsWith("whisper") || data.sttProvider === "distil-whisper-large-v3-en") {
+      sttProviderId = "groq";
+    } else if (data.sttProvider === "whisper-1") {
+      sttProviderId = "openai";
+    }
+
+    if (data.ttsProvider.startsWith("eleven")) {
+      ttsProviderId = "elevenlabs";
+    } else if (data.ttsProvider.startsWith("tts-") || data.ttsProvider.startsWith("gpt-")) {
+      ttsProviderId = "openai";
+    } else if (data.ttsProvider.startsWith("gemini")) {
+      ttsProviderId = "gemini";
+    } else if (data.ttsProvider.startsWith("qwen")) {
+      ttsProviderId = "qwen";
+    }
+
+    // Save STT API key to provider if provided
+    if (data.sttApiKey && sttProviderId) {
+      const encrypted = await encryptApiKey(data.sttApiKey);
+      db.query(`
+        UPDATE providers SET 
+          api_key_encrypted = ?, 
+          api_key_iv = ?, 
+          enabled = 1,
+          active = 1
+        WHERE id = ?
+      `).run(encrypted.encrypted, encrypted.iv, sttProviderId);
+      log.info("✅ STT API key guardada en BD (encriptada)", { provider: sttProviderId });
+    }
+
+    // Save TTS API key to provider if provided
+    if (data.ttsApiKey && ttsProviderId) {
+      const encrypted = await encryptApiKey(data.ttsApiKey);
+      db.query(`
+        UPDATE providers SET 
+          api_key_encrypted = ?, 
+          api_key_iv = ?, 
+          enabled = 1,
+          active = 1
+        WHERE id = ?
+      `).run(encrypted.encrypted, encrypted.iv, ttsProviderId);
+      log.info("✅ TTS API key guardada en BD (encriptada)", { provider: ttsProviderId });
+    }
+
+    // Update channel with voice config
+    db.query(`
+      UPDATE channels 
+      SET user_id = ?, voice_enabled = ?, stt_provider = ?, tts_provider = ?
+      WHERE id = ?
+    `).run(data.userId, data.voiceEnabled ? 1 : 0, data.sttProvider, data.ttsProvider, data.channelId);
+
+    log.info("✅ Voice config saved:", {
+      channelId: data.channelId,
+      userId: data.userId,
+      sttProvider: data.sttProvider,
+      ttsProvider: data.ttsProvider,
+      sttProviderId,
+      ttsProviderId
+    });
+  } catch (e) {
+    log.error("⚠️ Error saving voice config:", { error: (e as Error).message });
+  }
+}
+
+export async function saveMcpServer(data: {
+  userId: string;
+  name: string;
+  transport: string;
+  command?: string;
+  args?: string[];
+  env?: Record<string, string>;
+  url?: string;
+  enabled?: boolean;
+}): Promise<void> {
+  try {
+    const db = getDb();
+
+    const mcpId = `${data.userId}:${data.name}`;
+
+    let envEncrypted = null;
+    let envIv = null;
+
+    if (data.env && Object.keys(data.env).length > 0) {
+      const encrypted = await encryptConfig(data.env as Record<string, unknown>);
+      envEncrypted = encrypted.encrypted;
+      envIv = encrypted.iv;
+    }
+
+    db.query(`
+      INSERT OR REPLACE INTO mcp_servers
+        (id, user_id, name, transport, command, args, env_encrypted, env_iv, url, enabled, builtin)
+      VALUES (?, ?, ?, ?, ?, ?, ?, ?, ?, ?, 0)
+    `).run(
+      mcpId,
+      data.userId,
+      data.name,
+      data.transport,
+      data.command || null,
+      JSON.stringify(data.args || []),
+      envEncrypted,
+      envIv,
+      data.url || null,
+      data.enabled ? 1 : 0
+    );
+
+    log.info("✅ MCP server saved:", { name: data.name });
+  } catch (e) {
+    log.error("⚠️ Error saving MCP server:", { error: (e as Error).message });
+  }
+}
+
+export function saveToolSelection(userId: string, tools: string[]): void {
+  try {
+    const db = getDb();
+
+    for (const tool of tools) {
+      // Activar la herramienta (ya existe del seed)
+      db.query(`
+        UPDATE tools SET active = 1, enabled = 1
+        WHERE id = ?
+      `).run(tool);
+    }
+
+    log.info("✅ Tools activadas:", { tools: tools.join(", ") });
+  } catch (e) {
+    log.error("⚠️ Error saving tools:", { error: (e as Error).message });
+  }
+}
+
+export function activateProvider(providerId: string): void {
+  try {
+    const db = getDb();
+    db.query(`
+      UPDATE providers SET active = 1, enabled = 1
+      WHERE id = ?
+    `).run(providerId);
+    log.info("✅ Provider activado:", { providerId });
+  } catch (e) {
+    log.error("⚠️ Error activating provider:", { error: (e as Error).message });
+  }
+}
+
+export function activateModel(modelId: string): void {
+  try {
+    const db = getDb();
+    db.query(`
+      UPDATE models SET active = 1, enabled = 1
+      WHERE id = ?
+    `).run(modelId);
+    log.info("✅ Model activado:", { modelId });
+  } catch (e) {
+    log.error("⚠️ Error activating model:", { error: (e as Error).message });
+  }
+}
+
+
+
+export function activateMcpServer(mcpName: string): void {
+  try {
+    const db = getDb();
+    db.query(`
+      UPDATE mcp_servers SET active = 1, enabled = 1
+      WHERE id = ?
+    `).run(mcpName);
+    log.info("✅ MCP server activado:", { mcpName });
+  } catch (e) {
+    log.error("⚠️ Error activating MCP server:", { error: (e as Error).message });
+  }
+}
+
+export function deactivateProvider(providerId: string): void {
+  try {
+    const db = getDb();
+    db.query(`
+      UPDATE providers SET active = 0, enabled = 0
+      WHERE id = ?
+    `).run(providerId);
+    log.warn("⚠️ Provider desactivado:", { providerId });
+  } catch (e) {
+    log.error("⚠️ Error deactivating provider:", { error: (e as Error).message });
+  }
+}
+
+export function deactivateModel(modelId: string): void {
+  try {
+    const db = getDb();
+    db.query(`
+      UPDATE models SET active = 0, enabled = 0
+      WHERE id = ?
+    `).run(modelId);
+    log.warn("⚠️ Model desactivado:", { modelId });
+  } catch (e) {
+    log.error("⚠️ Error deactivating model:", { error: (e as Error).message });
+  }
+}
+
+export function deactivateChannel(channelType: string): void {
+  try {
+    const db = getDb();
+    db.query(`
+      UPDATE channels SET active = 0, enabled = 0
+      WHERE id = ?
+    `).run(channelType);
+    log.warn("⚠️ Channel desactivado:", { channelType });
+  } catch (e) {
+    log.error("⚠️ Error deactivating channel:", { error: (e as Error).message });
+  }
+}
+
+export function deactivateMcpServer(mcpName: string): void {
+  try {
+    const db = getDb();
+    db.query(`
+      UPDATE mcp_servers SET active = 0, enabled = 0
+      WHERE id = ?
+    `).run(mcpName);
+    log.warn("⚠️ MCP server desactivado:", { mcpName });
+  } catch (e) {
+    log.error("⚠️ Error deactivating MCP server:", { error: (e as Error).message });
+  }
+}
+
+export function getAllProviders(): Array<{
+  id: string;
+  name: string;
+  baseUrl: string | null;
+  enabled: boolean;
+  active: boolean;
+}> {
+  try {
+    const db = getDb();
+    const results = db.query(`
+      SELECT id, name, base_url, enabled, active
+      FROM providers
+    `).all() as Array<{
+      id: string;
+      name: string;
+      base_url: string | null;
+      enabled: number;
+      active: number;
+    }>;
+
+    return results.map(r => ({
+      id: r.id,
+      name: r.name,
+      baseUrl: r.base_url,
+      enabled: r.enabled === 1,
+      active: r.active === 1,
+    }));
+  } catch (e) {
+    log.warn("[onboarding] ⚠️ Error getting providers:", (e as Error).message);
+    return [];
+  }
+}
+
+export function getAllModels(): Array<{
+  id: string;
+  name: string;
+  providerId: string;
+  contextWindow: number | null;
+  capabilities: string | null;
+  enabled: boolean;
+  active: boolean;
+}> {
+  try {
+    const db = getDb();
+    const results = db.query(`
+      SELECT id, name, provider_id, context_window, capabilities, enabled, active
+      FROM models
+    `).all() as Array<{
+      id: string;
+      name: string;
+      provider_id: string;
+      context_window: number | null;
+      capabilities: string | null;
+      enabled: number;
+      active: number;
+    }>;
+
+    return results.map(r => ({
+      id: r.id,
+      name: r.name,
+      providerId: r.provider_id,
+      contextWindow: r.context_window,
+      capabilities: r.capabilities,
+      enabled: r.enabled === 1,
+      active: r.active === 1,
+    }));
+  } catch (e) {
+    log.error("⚠️ Error getting models:", { error: (e as Error).message });
+    return [];
+  }
+}
+
+export function getAllEthics(): Array<{
+  id: string;
+  name: string;
+  description: string | null;
+  content: string;
+  isDefault: boolean;
+  active: boolean;
+}> {
+  try {
+    const db = getDb();
+    const results = db.query(`
+      SELECT id, name, description, content, is_default, active
+      FROM ethics
+    `).all() as Array<{
+      id: string;
+      name: string;
+      description: string | null;
+      content: string;
+      is_default: number;
+      active: number;
+    }>;
+
+    return results.map(r => ({
+      id: r.id,
+      name: r.name,
+      description: r.description,
+      content: r.content,
+      isDefault: r.is_default === 1,
+      active: r.active === 1,
+    }));
+  } catch (e) {
+    log.error("⚠️ Error getting ethics:", { error: (e as Error).message });
+    return [];
+  }
+}
+
+export function getAllCodeBridge(): Array<{
+  id: string;
+  name: string;
+  cliCommand: string;
+  port: number;
+  enabled: boolean;
+  active: boolean;
+}> {
+  try {
+    const db = getDb();
+    const results = db.query(`
+      SELECT id, name, cli_command, port, enabled, active
+      FROM code_bridge
+    `).all() as Array<{
+      id: string;
+      name: string;
+      cli_command: string;
+      port: number;
+      enabled: number;
+      active: number;
+    }>;
+
+    return results.map(r => ({
+      id: r.id,
+      name: r.name,
+      cliCommand: r.cli_command,
+      port: r.port,
+      enabled: r.enabled === 1,
+      active: r.active === 1,
+    }));
+  } catch (e) {
+    log.error("⚠️ Error getting code bridge:", { error: (e as Error).message });
+    return [];
+  }
+}
+
+export function getAllSkills(): Array<{
+  id: string;
+  name: string;
+  description: string | null;
+  source: string;
+  isGlobal: boolean;
+  enabled: boolean;
+  active: boolean;
+}> {
+  try {
+    const db = getDb();
+    const results = db.query(`
+      SELECT id, name, api_key_encrypted, api_key_iv, base_url, enabled
+      FROM providers
+    `).all() as Array<{
+      id: string;
+      name: string;
+      description: string | null;
+      source: string;
+      enabled: number;
+      active: number;
+    }>;
+
+    return results.map(r => ({
+      id: r.id,
+      name: r.name,
+      description: r.description,
+      source: r.source,
+      isGlobal: false,
+      enabled: r.enabled === 1,
+      active: r.active === 1,
+    }));
+  } catch (e) {
+    log.error("⚠️ Error getting skills:", { error: (e as Error).message });
+    return [];
+  }
+}
+
+export function getAllTools(): Array<{
+  id: string;
+  name: string;
+  description: string | null;
+  category: string | null;
+  enabled: boolean;
+  active: boolean;
+}> {
+  try {
+    const db = getDb();
+    const results = db.query(`
+      SELECT id, name, description, category, enabled, active
+      FROM tools
+    `).all() as Array<{
+      id: string;
+      name: string;
+      description: string | null;
+      category: string | null;
+      enabled: number;
+      active: number;
+    }>;
+
+    return results.map(r => ({
+      id: r.id,
+      name: r.name,
+      description: r.description,
+      category: r.category,
+      enabled: r.enabled === 1,
+      active: r.active === 1,
+    }));
+  } catch (e) {
+    log.error("⚠️ Error getting tools:", { error: (e as Error).message });
+    return [];
+  }
+}
+
+export function getAllMcpServers(): Array<{
+  id: string;
+  name: string;
+  transport: string;
+  command: string | null;
+  args: string | null;
+  url: string | null;
+  builtin: boolean;
+  enabled: boolean;
+  active: boolean;
+}> {
+  try {
+    const db = getDb();
+    const results = db.query(`
+      SELECT id, name, transport, command, args, url, builtin, enabled, active
+      FROM mcp_servers
+    `).all() as Array<{
+      id: string;
+      name: string;
+      transport: string;
+      command: string | null;
+      args: string | null;
+      url: string | null;
+      builtin: number;
+      enabled: number;
+      active: number;
+    }>;
+
+    return results.map(r => ({
+      id: r.id,
+      name: r.name,
+      transport: r.transport,
+      command: r.command,
+      args: r.args,
+      url: r.url,
+      builtin: r.builtin === 1,
+      enabled: r.enabled === 1,
+      active: r.active === 1,
+    }));
+  } catch (e) {
+    log.error("⚠️ Error getting MCP servers:", { error: (e as Error).message });
+    return [];
+  }
+}
+
+export function getAllChannels(): Array<{
+  id: string;
+  type: string;
+  accountId: string;
+  status: string;
+  enabled: boolean;
+  active: boolean;
+}> {
+  try {
+    const db = getDb();
+    const results = db.query(`
+      SELECT id, type, id as account_id, status, enabled, active
+      FROM channels
+    `).all() as Array<{
+      id: string;
+      type: string;
+      account_id: string;
+      status: string;
+      enabled: number;
+      active: number;
+    }>;
+
+    return results.map(r => ({
+      id: r.id,
+      type: r.type,
+      accountId: r.id,
+      status: r.status,
+      enabled: r.enabled === 1,
+      active: r.active === 1,
+    }));
+  } catch (e) {
+    log.warn("[onboarding] ⚠️ Error getting channels:", (e as Error).message);
+    return [];
+  }
+}
+
+export function getActiveTools(): Array<{
+  id: string;
+  name: string;
+  description: string | null;
+  category: string | null;
+}> {
+  try {
+    const db = getDb();
+    const results = db.query(`
+      SELECT id, name, description, category
+      FROM tools WHERE active = 1
+    `).all() as Array<{
+      id: string;
+      name: string;
+      description: string | null;
+      category: string | null;
+    }>;
+
+    return results.map(r => ({
+      id: r.id,
+      name: r.name,
+      description: r.description,
+      category: r.category,
+    }));
+  } catch (e) {
+    log.error("⚠️ Error getting active tools:", { error: (e as Error).message });
+    return [];
+  }
+}
+
+export function getOnboardingProgress(userId: string): OnboardingSection | null {
+  try {
+    const db = getDb();
+    const result = db.query<{ step: string; data: string }, [string]>(
+      "SELECT step, data FROM onboarding_progress WHERE user_id = ? LIMIT 1"
+    ).get(userId);
+
+    if (result) {
+      return {
+        step: result.step as OnboardingSection["step"],
+        userId,
+        data: JSON.parse(result.data),
+        completedAt: Date.now(),
+      };
+    }
+    return null;
+  } catch {
+    return null;
+  }
+}
+
+export function saveOnboardingProgress(section: OnboardingSection): void {
+  try {
+    const db = getDb();
+    db.query(`
+      INSERT OR REPLACE INTO onboarding_progress (id, user_id, step, data)
+      VALUES (?, ?, ?, ?)
+    `).run(section.userId, section.userId, section.step, JSON.stringify(section.data));
+  } catch (e) {
+    log.error("⚠️ Error saving progress:", { error: (e as Error).message });
+  }
+}
+
+export async function getUserProviders(userId: string): Promise<Array<{
+  id: string;
+  name: string;
+  apiKey: string | null;
+  baseUrl: string | null;
+  enabled: boolean;
+}>> {
+  try {
+    const db = getDb();
+    const results = db.query(`
+      SELECT id, name, api_key_encrypted, api_key_iv, base_url, enabled
+      FROM providers
+    `).all() as Array<{
+      id: string;
+      name: string;
+      api_key_encrypted: string | null;
+      api_key_iv: string | null;
+      base_url: string | null;
+      enabled: number;
+    }>;
+
+    return Promise.all(results.map(async r => ({
+      id: r.name,
+      name: r.name,
+      apiKey: r.api_key_encrypted && r.api_key_iv
+        ? await decryptApiKey(r.api_key_encrypted, r.api_key_iv)
+        : null,
+      baseUrl: r.base_url,
+      enabled: r.enabled === 1,
+    })));
+  } catch (e) {
+    log.warn("[onboarding] ⚠️ Error getting providers:", (e as Error).message);
+    return [];
+  }
+}
+
+export async function getUserChannels(userId: string): Promise<Array<{
+  id: string;
+  type: string;
+  accountId: string;
+  config: Record<string, unknown>;
+  enabled: boolean;
+}>> {
+  try {
+    const db = getDb();
+    const results = db.query<{
+      id: string;
+      type: string;
+      account_id: string;
+      config_encrypted: string | null;
+      config_iv: string | null;
+      enabled: number;
+    }, [string]>(`
+      SELECT id, type, id as account_id, config_encrypted, config_iv, enabled
+      FROM channels WHERE user_id = ?
+    `).all(userId);
+
+    return Promise.all(results.map(async r => ({
+      id: r.type,
+      type: r.type,
+      accountId: r.id,
+      config: r.config_encrypted && r.config_iv
+        ? await decryptConfig(r.config_encrypted, r.config_iv)
+        : {},
+      enabled: r.enabled === 1,
+    })));
+  } catch (e) {
+    log.warn("[onboarding] ⚠️ Error getting channels:", (e as Error).message);
+    return [];
+  }
+}
+
+export function getUserAgents(userId: string): Array<{
+  id: string;
+  name: string;
+  providerId: string | null;
+  modelId: string | null;
+  tone: string;
+}> {
+  try {
+    const db = getDb();
+    const results = db.query<{
+      id: string;
+      name: string;
+      provider_id: string | null;
+      model_id: string | null;
+      tone: string;
+    }, [string]>(`
+      SELECT id, name, provider_id, model_id, tone
+      FROM agents WHERE user_id = ?
+    `).all(userId);
+
+    return results.map(r => ({
+      id: r.id,
+      name: r.name,
+      providerId: r.provider_id,
+      modelId: r.model_id,
+      tone: r.tone || "friendly",
+    }));
+  } catch (e) {
+    log.error("⚠️ Error getting agents:", { error: (e as Error).message });
+    return [];
+  }
+}
+
+export function maskApiKey(apiKey: string): string {
+  if (!apiKey || apiKey.length < 8) return "••••••••";
+  return apiKey.slice(0, 4) + "••••••••" + apiKey.slice(-4);
+}