@loghead/core 0.1.32 → 0.1.34

package/dist/api/server.js

@@ -1,33 +1,29 @@
-"use strict";
-var __importDefault = (this && this.__importDefault) || function (mod) {
-    return (mod && mod.__esModule) ? mod : { "default": mod };
-};
-Object.defineProperty(exports, "__esModule", { value: true });
-exports.startApiServer = startApiServer;
-const express_1 = __importDefault(require("express"));
-const cors_1 = __importDefault(require("cors"));
-const path_1 = __importDefault(require("path"));
-const auth_1 = require("../services/auth");
-const chalk_1 = __importDefault(require("chalk"));
-const auth = new auth_1.AuthService();
-async function startApiServer(db) {
-    const app = (0, express_1.default)();
+import express from "express";
+import cors from "cors";
+import path from "path";
+import fs from "fs";
+import { fileURLToPath } from "url";
+import chalk from "chalk";
+const __filename = fileURLToPath(import.meta.url);
+const __dirname = path.dirname(__filename);
+export async function startApiServer(db, auth) {
+    const app = express();
     const port = process.env.PORT || 4567;
-    app.use((0, cors_1.default)());
-    app.use(express_1.default.json());
+    app.use(cors());
+    app.use(express.json());
     // Serve static frontend files
     // Determine path based on whether we are running in src (dev) or dist (prod)
-    let publicPath = path_1.default.join(__dirname, "../public");
-    if (!require("fs").existsSync(publicPath)) {
+    let publicPath = path.join(__dirname, "../public");
+    if (!fs.existsSync(publicPath)) {
         // Try looking in dist/public if we are in src
-        publicPath = path_1.default.join(__dirname, "../../dist/public");
+        publicPath = path.join(__dirname, "../../dist/public");
     }
-    if (require("fs").existsSync(publicPath)) {
-        console.log(chalk_1.default.blue(`Serving frontend from: ${publicPath}`));
-        app.use(express_1.default.static(publicPath));
+    if (fs.existsSync(publicPath)) {
+        console.log(chalk.blue(`Serving frontend from: ${publicPath}`));
+        app.use(express.static(publicPath));
     }
     else {
-        console.warn(chalk_1.default.yellow("Frontend build not found. Run 'npm run build' in packages/core/frontend to build the UI."));
+        console.warn(chalk.yellow("Frontend build not found. Run 'npm run build' in packages/core/frontend to build the UI."));
     }
     await auth.initialize();
     // console.log(chalk.bold.green(`\n💻 API server running on:`));
@@ -195,37 +191,55 @@ async function startApiServer(db) {
             res.status(500).json({ error: String(e) });
         }
     });
-    app.get("/api/projects", (req, res) => {
-        const projects = db.listProjects();
+    app.get("/api/projects", async (req, res) => {
+        const projects = await db.listProjects();
         res.json(projects);
     });
-    app.post("/api/projects", (req, res) => {
+    app.post("/api/projects", async (req, res) => {
         const { name } = req.body;
         if (!name)
             return res.status(400).json({ error: "Name required" });
-        const project = db.createProject(name);
+        const project = await db.createProject(name);
         res.json(project);
     });
-    app.delete("/api/projects/:id", (req, res) => {
+    app.delete("/api/projects/:id", async (req, res) => {
         const { id } = req.params;
-        db.deleteProject(id);
+        await db.deleteProject(id);
         res.json({ success: true });
     });
-    app.get("/api/streams", (req, res) => {
+    app.patch("/api/projects/:id", async (req, res) => {
+        const { id } = req.params;
+        const { name } = req.body;
+        if (!name || !name.trim()) {
+            return res.status(400).send("Name required");
+        }
+        const project = await db.renameProject(id, name.trim());
+        res.json(project);
+    });
+    app.get("/api/streams", async (req, res) => {
         const projectId = req.query.projectId;
         if (projectId) {
-            const streams = db.listStreams(projectId);
+            const streams = await db.listStreams(projectId);
             res.json(streams);
         }
         else {
             res.status(400).send("Missing projectId");
         }
     });
-    app.delete("/api/streams/:id", (req, res) => {
+    app.delete("/api/streams/:id", async (req, res) => {
         const { id } = req.params;
-        db.deleteStream(id);
+        await db.deleteStream(id);
         res.json({ success: true });
     });
+    app.patch("/api/streams/:id", async (req, res) => {
+        const { id } = req.params;
+        const { name } = req.body;
+        if (!name || !name.trim()) {
+            return res.status(400).send("Name required");
+        }
+        const stream = await db.renameStream(id, name.trim());
+        res.json(stream);
+    });
     app.get("/api/streams/:id/token", async (req, res) => {
         const { id } = req.params;
         try {
@@ -236,19 +250,24 @@ async function startApiServer(db) {
             res.status(500).json({ error: String(e) });
         }
     });
-    app.post("/api/streams", (req, res) => {
-        // Deprecated or just listing? The previous code had this returning listStreams for POST?
-        // I'll remove it or keep it if CLI uses it?
-        // CLI uses db directly.
-        // MCP uses GET /api/streams
-        // I'll replace this with the actual CREATE logic to be RESTful, or keep /create
-        const projectId = req.body.projectId;
-        if (projectId) {
-            const streams = db.listStreams(projectId);
-            res.json(streams);
+    app.post("/api/streams", async (req, res) => {
+        try {
+            const { projectId, name, type, config } = req.body || {};
+            if (!projectId) {
+                return res.status(400).send("Missing projectId");
+            }
+            if (!name || typeof name !== "string" || !name.trim()) {
+                return res.status(400).send("Missing name");
+            }
+            if (!type || typeof type !== "string") {
+                return res.status(400).send("Missing type");
+            }
+            const stream = await db.createStream(projectId, type, name.trim(), config || {});
+            res.json(stream);
         }
-        else {
-            res.status(400).send("Missing projectId");
+        catch (e) {
+            console.error("Create stream error:", e);
+            res.status(500).json({ error: String(e) });
         }
     });
     app.post("/api/streams/create", async (req, res) => {
@@ -256,6 +275,23 @@ async function startApiServer(db) {
         const stream = await db.createStream(body.projectId, body.type, body.name, body.config || {});
         res.json(stream);
     });
+    app.get("/api/search", async (req, res) => {
+        const query = req.query.query || req.query.q;
+        const streamId = req.query.streamId;
+        const limitStr = req.query.limit;
+        const limit = limitStr ? parseInt(limitStr) : 50;
+        if (!query) {
+            return res.json([]);
+        }
+        try {
+            const results = await db.searchLogs(query, streamId, limit);
+            res.json(results);
+        }
+        catch (e) {
+            console.error("Error searching logs:", e);
+            res.status(500).send(String(e));
+        }
+    });
     app.get("/api/logs", async (req, res) => {
         const streamId = req.query.streamId;
         if (!streamId) {
@@ -275,20 +311,64 @@ async function startApiServer(db) {
         const query = req.query.q;
         let logs;
         if (query) {
-            logs = await db.searchLogs(streamId, query, limit);
+            logs = await db.searchLogs(query, streamId, limit);
         }
         else {
-            logs = db.getRecentLogs(streamId, limit, offset);
+            logs = await db.getRecentLogs(streamId, limit, offset);
         }
         res.json(logs);
     });
+    app.get("/api/issues", async (req, res) => {
+        const projectId = req.query.projectId;
+        const status = req.query.status;
+        const limit = parseInt(req.query.limit || "50");
+        if (!projectId) {
+            return res.status(400).send("Missing projectId");
+        }
+        try {
+            const issues = await db.getIssues(projectId, status, limit);
+            res.json(issues);
+        }
+        catch (e) {
+            console.error("Error fetching issues:", e);
+            res.status(500).send(String(e));
+        }
+    });
+    app.get("/api/issues/:id", async (req, res) => {
+        const { id } = req.params;
+        try {
+            const data = await db.getIssue(id);
+            if (!data)
+                return res.status(404).send("Issue not found");
+            res.json(data);
+        }
+        catch (e) {
+            console.error("Error fetching issue details:", e);
+            res.status(500).send(String(e));
+        }
+    });
+    app.patch("/api/issues/:id", async (req, res) => {
+        const { id } = req.params;
+        const { status } = req.body;
+        if (status !== "open" && status !== "resolved") {
+            return res.status(400).send("Invalid status");
+        }
+        try {
+            await db.updateIssueStatus(id, status);
+            res.json({ success: true });
+        }
+        catch (e) {
+            console.error("Error updating issue:", e);
+            res.status(500).send(String(e));
+        }
+    });
     // SPA fallback
     app.get("*", (req, res) => {
         if (req.path.startsWith("/api")) {
             return res.status(404).json({ error: "Not Found" });
         }
-        if (require("fs").existsSync(path_1.default.join(publicPath, "index.html"))) {
-            res.sendFile(path_1.default.join(publicPath, "index.html"));
+        if (fs.existsSync(path.join(publicPath, "index.html"))) {
+            res.sendFile(path.join(publicPath, "index.html"));
         }
         else {
             res.status(404).send("Dashboard not found. Please build the frontend.");

package/dist/cli_main.js

@@ -1,59 +1,64 @@
 #!/usr/bin/env node
-"use strict";
-var __importDefault = (this && this.__importDefault) || function (mod) {
-    return (mod && mod.__esModule) ? mod : { "default": mod };
-};
-Object.defineProperty(exports, "__esModule", { value: true });
-const yargs_1 = __importDefault(require("yargs"));
-const helpers_1 = require("yargs/helpers");
-const db_1 = require("./services/db");
-const server_1 = require("./api/server");
-const migrate_1 = require("./db/migrate");
-// import { ensureInfrastructure } from "./utils/startup"; // Might need adjustment
-const auth_1 = require("./services/auth");
-const chalk_1 = __importDefault(require("chalk"));
-const db = new db_1.DbService();
-const auth = new auth_1.AuthService();
+import yargs from "yargs";
+import { hideBin } from "yargs/helpers";
+import { dbService, authService, dbAdapter } from "./db/client.js";
+import { startApiServer } from "./api/server.js";
+import { migrate } from "@loghead/db";
+import chalk from "chalk";
+function isUnsupportedVectorIndexError(error) {
+    const msg = error instanceof Error ? error.message : String(error);
+    return msg.includes("invalid expression in CREATE INDEX") && msg.includes("libsql_vector_idx");
+}
 async function main() {
-    const argv = await (0, yargs_1.default)((0, helpers_1.hideBin)(process.argv))
+    const argv = await yargs(hideBin(process.argv))
         .command(["start", "$0"], "Start API Server", {}, async (argv) => {
         // console.log("Ensuring database is initialized...");
-        await (0, migrate_1.migrate)(false); // Run migrations silently
-        const token = await auth.getOrCreateMcpToken();
+        try {
+            await migrate(dbAdapter, false); // Run migrations silently
+        }
+        catch (e) {
+            if (isUnsupportedVectorIndexError(e)) {
+                console.warn("[Vector] Embedded DB does not support vector index expressions yet; continuing without vec_logs_idx.");
+            }
+            else {
+                throw e;
+            }
+        }
+        const token = await authService.getOrCreateMcpToken();
         // Start API Server (this sets up express listen)
-        await (0, server_1.startApiServer)(db);
+        await startApiServer(dbService, authService);
         // console.clear();
-        console.log(chalk_1.default.bold.green(`
+        console.log(chalk.bold.green(`
 ▌        ▌          ▌
 ▌  ▞▀▖▞▀▌▛▀▖▞▀▖▝▀▖▞▀▌
 ▌  ▌ ▌▚▄▌▌ ▌▛▀ ▞▀▌▌ ▌
 ▀▀▘▝▀ ▗▄▘▘ ▘▝▀▘▝▀▘▝▀▘                                
 `));
-        console.log(chalk_1.default.gray("--------------------------------------------------"));
-        console.log(chalk_1.default.bold(" 🟢 Loghead is running"));
-        console.log(chalk_1.default.gray("--------------------------------------------------"));
+        console.log(chalk.gray("--------------------------------------------------"));
+        console.log(chalk.bold(" 🟢 Loghead is running"));
+        console.log(chalk.gray("--------------------------------------------------"));
         console.log("");
-        console.log(chalk_1.default.bold(" 🖥️  Dashboard : ") + chalk_1.default.cyan("http://localhost:4567"));
-        console.log(chalk_1.default.bold(" 🔌 MCP Server: ") + chalk_1.default.cyan("http://localhost:4567/sse"));
+        console.log(chalk.bold(" 🖥️  Dashboard : ") + chalk.cyan("http://localhost:4567"));
+        console.log(chalk.bold(" 🔌 MCP Server: ") + chalk.cyan("http://localhost:4567/sse"));
         console.log("");
-        console.log(chalk_1.default.bold(" 🔑 MCP Token : "));
-        console.log(chalk_1.default.yellow(token));
+        console.log(chalk.bold(" 🔑 MCP Token : "));
+        console.log(chalk.yellow(token));
         console.log("");
-        console.log(chalk_1.default.gray("--------------------------------------------------"));
-        console.log(chalk_1.default.gray(" Press Ctrl+C to stop"));
+        console.log(chalk.gray("--------------------------------------------------"));
+        console.log(chalk.gray(" Press Ctrl+C to stop"));
     })
         .command("projects <cmd> [name]", "Manage projects", (yargs) => {
         yargs
-            .command("list", "List projects", {}, () => {
-            const projects = db.listProjects();
+            .command("list", "List projects", {}, async () => {
+            const projects = await dbService.listProjects();
             console.table(projects);
         })
-            .command("add <name>", "Add project", {}, (argv) => {
-            const p = db.createProject(argv.name);
+            .command("add <name>", "Add project", {}, async (argv) => {
+            const p = await dbService.createProject(argv.name);
             console.log(`Project created: ${p.id}`);
         })
-            .command("delete <id>", "Delete project", {}, (argv) => {
-            db.deleteProject(argv.id);
+            .command("delete <id>", "Delete project", {}, async (argv) => {
+            await dbService.deleteProject(argv.id);
             console.log(`Project deleted: ${argv.id}`);
         });
     })
@@ -61,8 +66,8 @@ async function main() {
         yargs
             .command("list", "List streams", {
             project: { type: "string", demandOption: true },
-        }, (argv) => {
-            const streams = db.listStreams(argv.project);
+        }, async (argv) => {
+            const streams = await dbService.listStreams(argv.project);
             console.table(streams);
         })
             .command("add <type> <name>", "Add stream", {
@@ -73,16 +78,16 @@ async function main() {
             if (argv.type === "docker" && argv.container) {
                 config.container = argv.container;
             }
-            const s = await db.createStream(argv.project, argv.type, argv.name, config);
+            const s = await dbService.createStream(argv.project, argv.type, argv.name, config);
             console.log(`Stream created: ${s.id}`);
             console.log(`Token: ${s.token}`);
         })
             .command("token <streamId>", "Get token for stream", {}, async (argv) => {
-            const token = await auth.createStreamToken(argv.streamId);
+            const token = await authService.createStreamToken(argv.streamId);
             console.log(`Token: ${token}`);
         })
-            .command("delete <id>", "Delete stream", {}, (argv) => {
-            db.deleteStream(argv.id);
+            .command("delete <id>", "Delete stream", {}, async (argv) => {
+            await dbService.deleteStream(argv.id);
             console.log(`Stream deleted: ${argv.id}`);
         });
     })

package/dist/db/client.js

@@ -1,55 +1,39 @@
-"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;
-    };
-})();
-var __importDefault = (this && this.__importDefault) || function (mod) {
-    return (mod && mod.__esModule) ? mod : { "default": mod };
-};
-Object.defineProperty(exports, "__esModule", { value: true });
-exports.db = void 0;
-const better_sqlite3_1 = __importDefault(require("better-sqlite3"));
-const sqliteVec = __importStar(require("sqlite-vec"));
-const path_1 = __importDefault(require("path"));
-const dotenv_1 = __importDefault(require("dotenv"));
-dotenv_1.default.config();
+import { connect } from "@tursodatabase/database";
+import { rm } from "fs/promises";
+import path from "path";
+import dotenv from "dotenv";
+import { LocalLibSqlAdapter, DbService, AuthService, OllamaService } from "@loghead/db";
+dotenv.config();
 const dbPath = process.env.LOGHEAD_DB_PATH || "loghead.db";
-console.log(`[DB] Using database at: ${path_1.default.resolve(dbPath)}`);
-const db = new better_sqlite3_1.default(dbPath);
-exports.db = db;
-// Load sqlite-vec extension
-try {
-    sqliteVec.load(db);
-}
-catch (e) {
-    console.error("Failed to load sqlite-vec extension:", e);
+const resolvedDbPath = path.resolve(dbPath);
+console.log(`[DB] Using database at: ${resolvedDbPath}`);
+async function openLocalDb() {
+    let db = await connect(resolvedDbPath);
+    try {
+        const legacyRows = (await db
+            .prepare("SELECT sql FROM sqlite_master WHERE type='table' AND name='vec_logs'")
+            .all());
+        const hasLegacyVec0 = legacyRows.some((r) => (r.sql || "").toLowerCase().includes("vec0"));
+        if (hasLegacyVec0) {
+            console.warn("[DB] Legacy sqlite-vec schema detected. Resetting local DB file.");
+            db.close();
+            await Promise.allSettled([
+                rm(resolvedDbPath, { force: true }),
+                rm(`${resolvedDbPath}-wal`, { force: true }),
+                rm(`${resolvedDbPath}-shm`, { force: true }),
+                rm(`${resolvedDbPath}-journal`, { force: true }),
+            ]);
+            db = await connect(resolvedDbPath);
+        }
+    }
+    catch {
+        // If sqlite_master inspection fails, continue and let migrations handle setup.
+    }
+    return db;
 }
+const db = await openLocalDb();
+const dbAdapter = new LocalLibSqlAdapter(db);
+const authService = new AuthService(dbAdapter);
+const ollamaService = new OllamaService();
+const dbService = new DbService(dbAdapter, authService, ollamaService);
+export { dbAdapter, authService, ollamaService, dbService };

package/dist/db/migrate.js

@@ -60,19 +60,6 @@ function migrate(verbose = true) {
     catch (e) {
         console.warn("Failed to create virtual vector table. Is sqlite-vec loaded?", e);
     }
-    // Trigger to clean up vec_logs when logs are deleted
-    try {
-        client_1.db.exec(`
-      CREATE TRIGGER IF NOT EXISTS delete_vec_log
-      AFTER DELETE ON logs
-      BEGIN
-        DELETE FROM vec_logs WHERE rowid = old.rowid;
-      END;
-    `);
-    }
-    catch (e) {
-        console.warn("Failed to create trigger delete_vec_log", e);
-    }
     if (verbose)
         console.log("Migrations complete.");
 }