@johpaz/hive 1.1.4 → 1.1.5

package/packages/core/src/storage/sqlite.js

@@ -0,0 +1,350 @@
+"use strict";
+var __createBinding = (this && this.__createBinding) || (Object.create ? (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    var desc = Object.getOwnPropertyDescriptor(m, k);
+    if (!desc || ("get" in desc ? !m.__esModule : desc.writable || desc.configurable)) {
+      desc = { enumerable: true, get: function() { return m[k]; } };
+    }
+    Object.defineProperty(o, k2, desc);
+}) : (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    o[k2] = m[k];
+}));
+var __setModuleDefault = (this && this.__setModuleDefault) || (Object.create ? (function(o, v) {
+    Object.defineProperty(o, "default", { enumerable: true, value: v });
+}) : function(o, v) {
+    o["default"] = v;
+});
+var __importStar = (this && this.__importStar) || (function () {
+    var ownKeys = function(o) {
+        ownKeys = Object.getOwnPropertyNames || function (o) {
+            var ar = [];
+            for (var k in o) if (Object.prototype.hasOwnProperty.call(o, k)) ar[ar.length] = k;
+            return ar;
+        };
+        return ownKeys(o);
+    };
+    return function (mod) {
+        if (mod && mod.__esModule) return mod;
+        var result = {};
+        if (mod != null) for (var k = ownKeys(mod), i = 0; i < k.length; i++) if (k[i] !== "default") __createBinding(result, mod, k[i]);
+        __setModuleDefault(result, mod);
+        return result;
+    };
+})();
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.dbService = exports.DatabaseService = void 0;
+exports.getDbPathLazy = getDbPathLazy;
+exports.getDb = getDb;
+exports.initializeDatabase = initializeDatabase;
+const bun_sqlite_1 = require("bun:sqlite");
+const logger_ts_1 = require("../utils/logger.ts");
+const path = __importStar(require("node:path"));
+const node_fs_1 = require("node:fs");
+const loader_ts_1 = require("../config/loader.ts");
+const schema_ts_1 = require("./schema.ts");
+function getDbPath() {
+    return path.join((0, loader_ts_1.getHiveDir)(), "data", "hive.db");
+}
+function getDbPathLazy() {
+    return getDbPath();
+}
+let _db = null;
+function getDb() {
+    if (!_db)
+        throw new Error("DB no inicializada. Llama initializeDatabase() primero.");
+    return _db;
+}
+function initializeDatabase() {
+    const hiveDir = (0, loader_ts_1.getHiveDir)();
+    const dir = path.join(hiveDir, "data");
+    if (!(0, node_fs_1.existsSync)(dir)) {
+        (0, node_fs_1.mkdirSync)(dir, { recursive: true });
+    }
+    const dbPath = getDbPath();
+    const dbFileExists = (0, node_fs_1.existsSync)(dbPath);
+    _db = new bun_sqlite_1.Database(dbPath, { create: true });
+    // Use type assertion to avoid deprecated signature with bindings
+    _db.exec(schema_ts_1.SCHEMA);
+    _db.exec(schema_ts_1.PROJECTS_SCHEMA);
+    _db.exec(schema_ts_1.CONTEXT_ENGINE_SCHEMA);
+    ensureSchemaSync();
+    return _db;
+}
+function ensureColumnExists(tableName, columnName, columnDefinition) {
+    if (!_db)
+        return;
+    try {
+        const info = _db.query(`PRAGMA table_info(${tableName})`).all();
+        const exists = info.some((col) => col.name === columnName);
+        if (!exists) {
+            logger_ts_1.logger.info(`🛠️  Añadiendo columna faltante '${columnName}' a la tabla '${tableName}'`);
+            _db.exec(`ALTER TABLE ${tableName} ADD COLUMN ${columnName} ${columnDefinition}`);
+        }
+    }
+    catch (err) {
+        logger_ts_1.logger.warn(`⚠️  No se pudo verificar/añadir la columna '${columnName}' en '${tableName}':`, { error: err.message });
+    }
+}
+function ensureSchemaSync() {
+    if (!_db)
+        return;
+    // Sync mcp_servers
+    ensureColumnExists("mcp_servers", "tools_count", "INTEGER DEFAULT 0");
+    ensureColumnExists("mcp_servers", "status", "TEXT NOT NULL DEFAULT 'disconnected'");
+    ensureColumnExists("mcp_servers", "env_encrypted", "TEXT");
+    ensureColumnExists("mcp_servers", "env_iv", "TEXT");
+    ensureColumnExists("mcp_servers", "headers_encrypted", "TEXT");
+    ensureColumnExists("mcp_servers", "headers_iv", "TEXT");
+    // Sync providers
+    ensureColumnExists("providers", "api_key_encrypted", "TEXT");
+    ensureColumnExists("providers", "api_key_iv", "TEXT");
+    ensureColumnExists("providers", "headers_encrypted", "TEXT");
+    ensureColumnExists("providers", "headers_iv", "TEXT");
+    ensureColumnExists("providers", "num_ctx", "INTEGER");
+    ensureColumnExists("providers", "num_gpu", "INTEGER DEFAULT -1");
+    // Sync agents (new Context Engine columns — safe no-ops if already present)
+    ensureColumnExists("agents", "headers_encrypted", "TEXT");
+    ensureColumnExists("agents", "headers_iv", "TEXT");
+    ensureColumnExists("agents", "system_prompt", "TEXT");
+    ensureColumnExists("agents", "role", "TEXT NOT NULL DEFAULT 'coordinator'");
+    ensureColumnExists("agents", "tools_json", "TEXT");
+    ensureColumnExists("agents", "skills_json", "TEXT");
+    ensureColumnExists("agents", "parent_id", "TEXT");
+    ensureColumnExists("agents", "max_iterations", "INTEGER NOT NULL DEFAULT 10");
+    ensureColumnExists("agents", "updated_at", "INTEGER NOT NULL DEFAULT (unixepoch())");
+    // Sync tasks (new Context Engine columns)
+    ensureColumnExists("tasks", "priority", "INTEGER NOT NULL DEFAULT 0");
+    ensureColumnExists("tasks", "depends_on", "TEXT");
+    ensureColumnExists("tasks", "error", "TEXT");
+    ensureColumnExists("tasks", "completed_at", "INTEGER");
+    // Sync cron_jobs
+    ensureColumnExists("cron_jobs", "max_runs", "INTEGER");
+    ensureColumnExists("cron_jobs", "run_count", "INTEGER NOT NULL DEFAULT 0");
+    ensureColumnExists("cron_jobs", "expires_at", "INTEGER");
+    // hive_capabilities: create if not exists (applied via CONTEXT_ENGINE_SCHEMA IF NOT EXISTS)
+    // No column migrations needed — table is seeded fresh each startup via INSERT OR REPLACE
+}
+class DatabaseService {
+    constructor() {
+        this.log = logger_ts_1.logger.child("sqlite");
+    }
+    get db() {
+        if (!_db) {
+            initializeDatabase();
+        }
+        return _db;
+    }
+    addMessage(sessionId, role, content, metadata) {
+        const stmt = this.db.query(`
+      INSERT INTO messages (id, session_id, thread_id, role, content, metadata) 
+      VALUES ($id, $sessionId, $threadId, $role, $content, $metadata)
+    `);
+        try {
+            const id = crypto.randomUUID();
+            stmt.run({
+                $id: id,
+                $sessionId: sessionId,
+                $threadId: sessionId,
+                $role: role,
+                $content: content,
+                $metadata: metadata ? JSON.stringify(metadata) : null
+            });
+            this.log.debug(`Message added for session ${sessionId}`);
+        }
+        catch (error) {
+            this.log.error(`Failed to add message: ${error.message}`);
+        }
+    }
+    getMessages(sessionId, limit = 100) {
+        const stmt = this.db.query(`
+      SELECT * FROM messages 
+      WHERE session_id = $sessionId 
+      ORDER BY created_at DESC 
+      LIMIT $limit
+    `);
+        try {
+            const rows = stmt.all({
+                $sessionId: sessionId,
+                $limit: limit
+            });
+            return rows.reverse();
+        }
+        catch (error) {
+            this.log.error(`Failed to get messages: ${error.message}`);
+            return [];
+        }
+    }
+    close() {
+        if (_db) {
+            _db.close();
+            _db = null;
+        }
+    }
+    writeNote(title, content) {
+        const stmt = this.db.query(`
+            INSERT INTO notes (id, title, content) 
+            VALUES ($id, $title, $content)
+            ON CONFLICT(title) DO UPDATE SET 
+                content = excluded.content,
+                updatedAt = CURRENT_TIMESTAMP
+            RETURNING *
+        `);
+        return stmt.get({
+            $id: crypto.randomUUID(),
+            $title: title,
+            $content: content
+        });
+    }
+    readNote(title) {
+        const stmt = this.db.query(`SELECT * FROM notes WHERE title = $title`);
+        return stmt.get({ $title: title });
+    }
+    listNotes() {
+        const stmt = this.db.query(`SELECT * FROM notes ORDER BY updatedAt DESC`);
+        return stmt.all();
+    }
+    searchNotes(queryText) {
+        const stmt = this.db.query(`
+            SELECT * FROM notes 
+            WHERE title LIKE $query OR content LIKE $query
+            ORDER BY updatedAt DESC
+        `);
+        return stmt.all({ $query: `%${queryText}%` });
+    }
+    deleteNote(title) {
+        const stmt = this.db.query(`DELETE FROM notes WHERE title = $title`);
+        const result = stmt.run({ $title: title });
+        return result.changes > 0;
+    }
+    updateMCPServer(id, updates) {
+        const fields = [];
+        const values = { $id: id };
+        if (updates.enabled !== undefined) {
+            fields.push("enabled = $enabled");
+            values.$enabled = updates.enabled ? 1 : 0;
+        }
+        if (updates.active !== undefined) {
+            fields.push("active = $active");
+            values.$active = updates.active ? 1 : 0;
+        }
+        if (updates.status !== undefined) {
+            fields.push("status = $status");
+            values.$status = updates.status;
+        }
+        if (updates.tools_count !== undefined) {
+            fields.push("tools_count = $tools_count");
+            values.$tools_count = updates.tools_count;
+        }
+        if (updates.transport !== undefined) {
+            fields.push("transport = $transport");
+            values.$transport = updates.transport;
+        }
+        if (updates.command !== undefined) {
+            fields.push("command = $command");
+            values.$command = updates.command;
+        }
+        if (updates.args !== undefined) {
+            fields.push("args = $args");
+            values.$args = JSON.stringify(updates.args);
+        }
+        if (updates.url !== undefined) {
+            fields.push("url = $url");
+            values.$url = updates.url;
+        }
+        if (updates.env_encrypted !== undefined) {
+            fields.push("env_encrypted = $env_encrypted");
+            values.$env_encrypted = updates.env_encrypted;
+        }
+        if (updates.env_iv !== undefined) {
+            fields.push("env_iv = $env_iv");
+            values.$env_iv = updates.env_iv;
+        }
+        if (updates.headers_encrypted !== undefined) {
+            fields.push("headers_encrypted = $headers_encrypted");
+            values.$headers_encrypted = updates.headers_encrypted;
+        }
+        if (updates.headers_iv !== undefined) {
+            fields.push("headers_iv = $headers_iv");
+            values.$headers_iv = updates.headers_iv;
+        }
+        if (fields.length === 0)
+            return;
+        const query = `UPDATE mcp_servers SET ${fields.join(", ")} WHERE id = $id`;
+        try {
+            this.db.query(query).run(values);
+            this.log.debug(`MCP server ${id} updated in DB`);
+        }
+        catch (error) {
+            this.log.error(`Failed to update MCP server ${id}: ${error.message}`);
+        }
+    }
+    listMCPServers() {
+        try {
+            return this.db.query("SELECT * FROM mcp_servers").all();
+        }
+        catch (error) {
+            this.log.error(`Failed to list MCP servers: ${error.message}`);
+            return [];
+        }
+    }
+    createTask(task) {
+        const result = this.db.query(`
+            INSERT INTO tasks (project_id, agent_id, parent_task_id, name, description)
+            VALUES (?, ?, ?, ?, ?)
+        `).run(task.project_id, task.agent_id ?? null, task.parent_task_id ?? null, task.name, task.description ?? null);
+        return Number(result.lastInsertRowid);
+    }
+    updateTask(taskId, updates) {
+        const fields = ["updated_at = unixepoch()"];
+        const values = [];
+        if (updates.status !== undefined) {
+            fields.push("status = ?");
+            values.push(updates.status);
+        }
+        if (updates.progress !== undefined) {
+            fields.push("progress = ?");
+            values.push(updates.progress);
+        }
+        if (updates.result !== undefined) {
+            fields.push("result = ?");
+            values.push(updates.result);
+        }
+        if (updates.agent_id !== undefined) {
+            fields.push("agent_id = ?");
+            values.push(updates.agent_id);
+        }
+        values.push(taskId);
+        const res = this.db.query(`UPDATE tasks SET ${fields.join(", ")} WHERE id = ?`).run(...values);
+        return res.changes > 0;
+    }
+    getTasksByProject(projectId) {
+        return this.db.query("SELECT * FROM tasks WHERE project_id = ? ORDER BY id ASC").all(projectId);
+    }
+    getProjectWithTasks(projectId) {
+        const project = this.db.query("SELECT * FROM projects WHERE id = ?").get(projectId);
+        if (!project)
+            return null;
+        project.tasks = this.getTasksByProject(projectId);
+        return project;
+    }
+    recalcProjectProgress(projectId) {
+        const row = this.db.query("SELECT AVG(progress) as avg_progress FROM tasks WHERE project_id = ?").get(projectId);
+        const avg = Math.round(row?.avg_progress ?? 0);
+        this.db.query("UPDATE projects SET progress = ?, updated_at = unixepoch() WHERE id = ?").run(avg, projectId);
+        return avg;
+    }
+    saveMCPServer(server) {
+        try {
+            this.db.query(`
+                INSERT OR REPLACE INTO mcp_servers (id, name, transport, command, args, url, env_encrypted, env_iv, headers_encrypted, headers_iv, enabled, active, builtin, tools_count, status)
+                VALUES (?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?)
+            `).run(server.id || server.name, server.name, server.transport, server.command || null, JSON.stringify(server.args || []), server.url || null, server.env_encrypted || null, server.env_iv || null, server.headers_encrypted || null, server.headers_iv || null, server.enabled ? 1 : 0, server.active ? 1 : 0, server.builtin ? 1 : 0, server.tools_count || 0, server.status || "disconnected");
+        }
+        catch (error) {
+            this.log.error(`Failed to save MCP server ${server.name}: ${error.message}`);
+        }
+    }
+}
+exports.DatabaseService = DatabaseService;
+exports.dbService = new DatabaseService();

package/packages/core/src/utils/logger.d.ts

@@ -0,0 +1,84 @@
+export type LogLevel = "debug" | "info" | "warn" | "error";
+export interface LogEntry {
+    timestamp: string;
+    level: LogLevel;
+    source: string;
+    message: string;
+    meta?: Record<string, unknown>;
+}
+export type LogEntryListener = (entry: LogEntry) => void;
+/** Subscribe to real-time log entries */
+export declare function onLogEntry(cb: LogEntryListener): void;
+/** Unsubscribe from real-time log entries */
+export declare function removeLogListener(cb: LogEntryListener): void;
+export interface LoggerConfig {
+    level: LogLevel;
+    dir: string;
+    maxSizeMB: number;
+    maxFiles: number;
+    redactSensitive: boolean;
+    console: boolean;
+}
+export interface LogMeta extends Record<string, unknown> {
+    correlationId?: string;
+    sessionId?: string;
+    userId?: string;
+    agentId?: string;
+    channel?: string;
+    toolName?: string;
+    duration?: number;
+    error?: string;
+    stack?: string;
+}
+export declare class Logger {
+    private config;
+    private logFile;
+    private currentSize;
+    private correlationContext;
+    constructor(config?: Partial<LoggerConfig>);
+    setCorrelationContext(context: Partial<LogMeta>): void;
+    clearCorrelationContext(): void;
+    getCorrelationId(): string | undefined;
+    withCorrelationId(id: string): this;
+    private initLogFile;
+    private shouldLog;
+    private writeToConsole;
+    private mergeMeta;
+    private writeToFile;
+    private rotateLogs;
+    debug(message: string, meta?: unknown): void;
+    info(message: string, meta?: unknown): void;
+    warn(message: string, meta?: unknown): void;
+    error(message: string, meta?: unknown): void;
+    child(context: string): ChildLogger;
+    setLevel(level: LogLevel): void;
+}
+export declare class ChildLogger {
+    private parent;
+    private context;
+    private correlationContext;
+    constructor(parent: Logger, context: string, correlationContext?: LogMeta);
+    private prefix;
+    withCorrelationId(id: string): this;
+    setContext(context: Partial<LogMeta>): void;
+    debug(message: string, meta?: unknown): void;
+    info(message: string, meta?: unknown): void;
+    warn(message: string, meta?: unknown): void;
+    error(message: string, meta?: unknown): void;
+    child(subContext: string): ChildLogger;
+    private mergeMeta;
+}
+export declare function getLogger(): Logger;
+export declare const logger: {
+    child: (opts: any) => ChildLogger;
+    debug: (msg: string, meta?: unknown) => void;
+    info: (msg: string, meta?: unknown) => void;
+    warn: (msg: string, meta?: unknown) => void;
+    error: (msg: string, meta?: unknown) => void;
+    setCorrelationContext: (ctx: any) => void;
+    clearCorrelationContext: () => void;
+    getCorrelationId: () => string;
+    withCorrelationId: (id: string) => Logger;
+    setLevel: (level: any) => void;
+    setHandler: (handler: any) => void;
+};