@zuvia-software-solutions/code-mapper 1.4.0 → 2.0.1

package/dist/mcp/core/lbug-adapter.js

@@ -1,330 +0,0 @@
-// code-mapper/src/mcp/core/lbug-adapter.ts
-/** @file lbug-adapter.ts
- *  @description LadybugDB connection pool adapter keyed by repoId
- *  Provides checkout/return pool so each concurrent query gets its own Connection
- *  from the same Database (Connections are NOT thread-safe)
- *  @see https://docs.ladybugdb.com/concurrency */
-import fs from 'fs/promises';
-import lbug from '@ladybugdb/core';
-const pool = new Map();
-const dbCache = new Map();
-/** Max repos in the pool (LRU eviction) */
-const MAX_POOL_SIZE = 5;
-/** Idle timeout before closing a repo's connections */
-const IDLE_TIMEOUT_MS = 5 * 60 * 1000; // 5 minutes
-/** Max connections per repo (caps concurrent queries per repo) */
-const MAX_CONNS_PER_REPO = 8;
-/** Connections created eagerly on init */
-const INITIAL_CONNS_PER_REPO = 2;
-let idleTimer = null;
-/** Start the idle cleanup timer (runs every 60s) */
-function ensureIdleTimer() {
-    if (idleTimer)
-        return;
-    idleTimer = setInterval(() => {
-        const now = Date.now();
-        for (const [repoId, entry] of pool) {
-            if (now - entry.lastUsed > IDLE_TIMEOUT_MS && entry.checkedOut === 0) {
-                closeOne(repoId);
-            }
-        }
-    }, 60_000);
-    if (idleTimer && typeof idleTimer === 'object' && 'unref' in idleTimer) {
-        idleTimer.unref();
-    }
-}
-/** Evict the least-recently-used repo if pool is at capacity */
-function evictLRU() {
-    if (pool.size < MAX_POOL_SIZE)
-        return;
-    let oldestId = null;
-    let oldestTime = Infinity;
-    for (const [id, entry] of pool) {
-        if (entry.checkedOut === 0 && entry.lastUsed < oldestTime) {
-            oldestTime = entry.lastUsed;
-            oldestId = id;
-        }
-    }
-    if (oldestId) {
-        closeOne(oldestId);
-    }
-}
-/**
- * Remove a repo from the pool and release its shared Database ref
- * Skips .closeSync() which triggers N-API segfaults on Linux/macOS;
- * pools are read-only so GC reclamation is safe
- */
-function closeOne(repoId) {
-    const entry = pool.get(repoId);
-    if (entry) {
-        const shared = dbCache.get(entry.dbPath);
-        if (shared && shared.refCount > 0) {
-            shared.refCount--;
-        }
-    }
-    pool.delete(repoId);
-}
-function createConnection(db) {
-    return new lbug.Connection(db);
-}
-/** Query timeout in milliseconds */
-const QUERY_TIMEOUT_MS = 30_000;
-/** Waiter queue timeout in milliseconds */
-const WAITER_TIMEOUT_MS = 15_000;
-const LOCK_RETRY_ATTEMPTS = 3;
-const LOCK_RETRY_DELAY_MS = 2000;
-/**
- * Initialize (or reuse) a Database + connection pool for a specific repo
- * Retries on lock errors (e.g., when `code-mapper analyze` is running)
- */
-export const initLbug = async (repoId, dbPath) => {
-    const existing = pool.get(repoId);
-    if (existing) {
-        existing.lastUsed = Date.now();
-        return;
-    }
-    // Check if database exists
-    try {
-        await fs.stat(dbPath);
-    }
-    catch {
-        throw new Error(`LadybugDB not found at ${dbPath}. Run: code-mapper analyze`);
-    }
-    evictLRU();
-    // Reuse an existing native Database if another repoId already opened this path
-    // Prevents buffer manager exhaustion from multiple mmap regions on the same file
-    let shared = dbCache.get(dbPath);
-    if (!shared) {
-        // Open read-write so incremental refresh can write through the same handle.
-        // Lock conflicts with `code-mapper analyze` are handled by retry logic.
-        let lastError = null;
-        for (let attempt = 1; attempt <= LOCK_RETRY_ATTEMPTS; attempt++) {
-            try {
-                const db = new lbug.Database(dbPath, 0, // bufferManagerSize (default)
-                false, // enableCompression (default)
-                false);
-                shared = { db, refCount: 0, ftsLoaded: false };
-                dbCache.set(dbPath, shared);
-                break;
-            }
-            catch (err) {
-                lastError = err instanceof Error ? err : new Error(String(err));
-                const isLockError = lastError.message.includes('Could not set lock')
-                    || lastError.message.includes('lock');
-                if (!isLockError || attempt === LOCK_RETRY_ATTEMPTS)
-                    break;
-                await new Promise(resolve => setTimeout(resolve, LOCK_RETRY_DELAY_MS * attempt));
-            }
-        }
-        if (!shared) {
-            throw new Error(`LadybugDB unavailable for ${repoId}. Another process may be rebuilding the index. ` +
-                `Retry later. (${lastError?.message || 'unknown error'})`);
-        }
-    }
-    shared.refCount++;
-    const db = shared.db;
-    // Pre-create a small pool of connections
-    const available = [];
-    for (let i = 0; i < INITIAL_CONNS_PER_REPO; i++) {
-        available.push(createConnection(db));
-    }
-    pool.set(repoId, { db, available, checkedOut: 0, waiters: [], lastUsed: Date.now(), dbPath });
-    ensureIdleTimer();
-    // Load FTS + VECTOR extensions once per shared Database
-    if (!shared.ftsLoaded) {
-        try {
-            await available[0].query('LOAD EXTENSION fts');
-            shared.ftsLoaded = true;
-        }
-        catch {
-            // Extension may not be installed — FTS queries will fail gracefully
-        }
-    }
-    // Load VECTOR extension for semantic search (HNSW index queries)
-    try {
-        await available[0].query('LOAD EXTENSION vector');
-    }
-    catch {
-        // Extension may not be installed — vector queries will fall back to BM25-only
-    }
-};
-/**
- * Checkout a connection from the pool
- * Returns an available connection, creates a new one if under cap,
- * or queues the caller until one is returned
- */
-function checkout(entry) {
-    // Fast path: grab an available connection
-    if (entry.available.length > 0) {
-        entry.checkedOut++;
-        return Promise.resolve(entry.available.pop());
-    }
-    // Grow the pool if under the cap
-    const totalConns = entry.available.length + entry.checkedOut;
-    if (totalConns < MAX_CONNS_PER_REPO) {
-        entry.checkedOut++;
-        return Promise.resolve(createConnection(entry.db));
-    }
-    // At capacity — queue the caller with a timeout.
-    return new Promise((resolve, reject) => {
-        const waiter = (conn) => {
-            clearTimeout(timer);
-            resolve(conn);
-        };
-        const timer = setTimeout(() => {
-            const idx = entry.waiters.indexOf(waiter);
-            if (idx !== -1)
-                entry.waiters.splice(idx, 1);
-            reject(new Error(`Connection pool exhausted: timed out after ${WAITER_TIMEOUT_MS}ms waiting for a free connection`));
-        }, WAITER_TIMEOUT_MS);
-        entry.waiters.push(waiter);
-    });
-}
-/**
- * Return a connection to the pool after use
- * Hands directly to queued waiters to avoid race conditions
- */
-function checkin(entry, conn) {
-    if (entry.waiters.length > 0) {
-        // Hand directly to the next waiter (no intermediate available state)
-        const waiter = entry.waiters.shift();
-        waiter(conn);
-    }
-    else {
-        entry.checkedOut--;
-        entry.available.push(conn);
-    }
-}
-/** Race a promise against a timeout */
-function withTimeout(promise, ms, label) {
-    let timer;
-    const timeout = new Promise((_, reject) => {
-        timer = setTimeout(() => reject(new Error(`${label} timed out after ${ms}ms`)), ms);
-    });
-    return Promise.race([promise, timeout]).finally(() => clearTimeout(timer));
-}
-export const executeQuery = async (repoId, cypher) => {
-    const entry = pool.get(repoId);
-    if (!entry) {
-        throw new Error(`LadybugDB not initialized for repo "${repoId}". Call initLbug first.`);
-    }
-    entry.lastUsed = Date.now();
-    const conn = await checkout(entry);
-    try {
-        const queryResult = await withTimeout(conn.query(cypher), QUERY_TIMEOUT_MS, 'Query');
-        const result = Array.isArray(queryResult) ? queryResult[0] : queryResult;
-        const rows = await result.getAll();
-        return rows;
-    }
-    finally {
-        checkin(entry, conn);
-    }
-};
-/** Execute a parameterized query using prepare/execute to prevent Cypher injection */
-export const executeParameterized = async (repoId, cypher, params) => {
-    const entry = pool.get(repoId);
-    if (!entry) {
-        throw new Error(`LadybugDB not initialized for repo "${repoId}". Call initLbug first.`);
-    }
-    entry.lastUsed = Date.now();
-    const conn = await checkout(entry);
-    try {
-        const stmt = await withTimeout(conn.prepare(cypher), QUERY_TIMEOUT_MS, 'Prepare');
-        if (!stmt.isSuccess()) {
-            const errMsg = await stmt.getErrorMessage();
-            throw new Error(`Prepare failed: ${errMsg}`);
-        }
-        const queryResult = await withTimeout(conn.execute(stmt, params), QUERY_TIMEOUT_MS, 'Execute');
-        const result = Array.isArray(queryResult) ? queryResult[0] : queryResult;
-        const rows = await result.getAll();
-        return rows;
-    }
-    finally {
-        checkin(entry, conn);
-    }
-};
-/** Close one or all repo pools (provide repoId for single, omit for all) */
-export const closeLbug = async (repoId) => {
-    if (repoId) {
-        closeOne(repoId);
-        return;
-    }
-    for (const id of [...pool.keys()]) {
-        closeOne(id);
-    }
-    if (idleTimer) {
-        clearInterval(idleTimer);
-        idleTimer = null;
-    }
-};
-/** Invalidate a repo's pool and shared DB cache, forcing fresh connections on next init.
- *  Closes the native Database handle to release the file lock so a child process
- *  can open the DB in read-write mode for incremental refresh.
- *  Used before AND after the incremental refresh child process writes to the DB. */
-export const invalidateAndReopen = async (repoId) => {
-    const entry = pool.get(repoId);
-    if (!entry)
-        return;
-    const entryDbPath = entry.dbPath;
-    closeOne(repoId);
-    // Close and remove the native Database handle to release the file lock.
-    // Without this, the child process cannot acquire a write lock on the DB file.
-    const shared = dbCache.get(entryDbPath);
-    if (shared && shared.refCount <= 0) {
-        try {
-            await shared.db.close();
-            console.error('Code Mapper: Native DB handle closed successfully');
-        }
-        catch (err) {
-            console.error(`Code Mapper: DB close failed (may still release lock on GC): ${err instanceof Error ? err.message : err}`);
-        }
-        dbCache.delete(entryDbPath);
-    }
-    else if (shared) {
-        console.error(`Code Mapper: Cannot close DB — ${shared.refCount} other refs still active`);
-    }
-};
-/** Check if a specific repo's pool is active */
-export const isLbugReady = (repoId) => pool.has(repoId);
-/** Write-connection retry config */
-const WRITE_RETRY_ATTEMPTS = 3;
-const WRITE_RETRY_DELAY_MS = 1500;
-/**
- * Open a short-lived read-write connection, execute the callback, then close.
- * The read-only pool must be invalidated BEFORE calling this to avoid lock
- * conflicts. Retries on lock errors (e.g., concurrent `code-mapper analyze`).
- */
-export const withWriteConnection = async (dbPath, fn) => {
-    let lastError = null;
-    for (let attempt = 1; attempt <= WRITE_RETRY_ATTEMPTS; attempt++) {
-        let db = null;
-        let conn = null;
-        try {
-            db = new lbug.Database(dbPath);
-            conn = new lbug.Connection(db);
-            const result = await fn(conn);
-            return result;
-        }
-        catch (err) {
-            lastError = err instanceof Error ? err : new Error(String(err));
-            const isLockError = lastError.message.includes('Could not set lock') ||
-                lastError.message.includes('lock');
-            if (!isLockError || attempt === WRITE_RETRY_ATTEMPTS)
-                break;
-            await new Promise((resolve) => setTimeout(resolve, WRITE_RETRY_DELAY_MS * attempt));
-        }
-        finally {
-            try {
-                if (conn)
-                    await conn.close();
-            }
-            catch { }
-            try {
-                if (db)
-                    await db.close();
-            }
-            catch { }
-        }
-    }
-    throw lastError ?? new Error('withWriteConnection failed');
-};

package/dist/server/api.d.ts

@@ -1,5 +0,0 @@
-/** @file api.ts
- *  @description REST API server for browser clients to query local .code-mapper/ indexes
- *  Also hosts MCP server over StreamableHTTP for remote AI tool access
- *  Binds to 127.0.0.1 by default with CORS restricted to localhost */
-export declare const createServer: (port: number, host?: string) => Promise<void>;

package/dist/server/api.js

@@ -1,340 +0,0 @@
-// code-mapper/src/server/api.ts
-/** @file api.ts
- *  @description REST API server for browser clients to query local .code-mapper/ indexes
- *  Also hosts MCP server over StreamableHTTP for remote AI tool access
- *  Binds to 127.0.0.1 by default with CORS restricted to localhost */
-import express from 'express';
-import cors from 'cors';
-import path from 'path';
-import fs from 'fs/promises';
-import { loadMeta, listRegisteredRepos } from '../storage/repo-manager.js';
-import { executeQuery, closeLbug, withLbugDb } from '../core/lbug/lbug-adapter.js';
-import { NODE_TABLES } from '../core/lbug/schema.js';
-import { searchFTSFromLbug } from '../core/search/bm25-index.js';
-import { hybridSearch } from '../core/search/hybrid-search.js';
-// Embedding imports are lazy (dynamic import) to avoid loading onnxruntime-node
-// at server startup — crashes on unsupported Node ABI versions (#89)
-import { LocalBackend } from '../mcp/local/local-backend.js';
-import { mountMCPEndpoints } from './mcp-http.js';
-const buildGraph = async () => {
-    const nodes = [];
-    for (const table of NODE_TABLES) {
-        try {
-            let query = '';
-            if (table === 'File') {
-                query = `MATCH (n:File) RETURN n.id AS id, n.name AS name, n.filePath AS filePath, n.content AS content`;
-            }
-            else if (table === 'Folder') {
-                query = `MATCH (n:Folder) RETURN n.id AS id, n.name AS name, n.filePath AS filePath`;
-            }
-            else if (table === 'Community') {
-                query = `MATCH (n:Community) RETURN n.id AS id, n.label AS label, n.heuristicLabel AS heuristicLabel, n.cohesion AS cohesion, n.symbolCount AS symbolCount`;
-            }
-            else if (table === 'Process') {
-                query = `MATCH (n:Process) RETURN n.id AS id, n.label AS label, n.heuristicLabel AS heuristicLabel, n.processType AS processType, n.stepCount AS stepCount, n.communities AS communities, n.entryPointId AS entryPointId, n.terminalId AS terminalId`;
-            }
-            else {
-                query = `MATCH (n:${table}) RETURN n.id AS id, n.name AS name, n.filePath AS filePath, n.startLine AS startLine, n.endLine AS endLine, n.content AS content`;
-            }
-            const rows = await executeQuery(query);
-            for (const row of rows) {
-                nodes.push({
-                    id: row.id ?? row[0],
-                    label: table,
-                    properties: {
-                        name: row.name ?? row.label ?? row[1],
-                        filePath: row.filePath ?? row[2],
-                        startLine: row.startLine,
-                        endLine: row.endLine,
-                        content: row.content,
-                        heuristicLabel: row.heuristicLabel,
-                        cohesion: row.cohesion,
-                        symbolCount: row.symbolCount,
-                        processType: row.processType,
-                        stepCount: row.stepCount,
-                        communities: row.communities,
-                        entryPointId: row.entryPointId,
-                        terminalId: row.terminalId,
-                    },
-                });
-            }
-        }
-        catch {
-            // ignore empty tables
-        }
-    }
-    const relationships = [];
-    const relRows = await executeQuery(`MATCH (a)-[r:CodeRelation]->(b) RETURN a.id AS sourceId, b.id AS targetId, r.type AS type, r.confidence AS confidence, r.reason AS reason, r.step AS step`);
-    for (const row of relRows) {
-        relationships.push({
-            id: `${row.sourceId}_${row.type}_${row.targetId}`,
-            type: row.type,
-            sourceId: row.sourceId,
-            targetId: row.targetId,
-            confidence: row.confidence,
-            reason: row.reason,
-            step: row.step,
-        });
-    }
-    return { nodes, relationships };
-};
-const statusFromError = (err) => {
-    const msg = String(err?.message ?? '');
-    if (msg.includes('No indexed repositories') || msg.includes('not found'))
-        return 404;
-    if (msg.includes('Multiple repositories'))
-        return 400;
-    return 500;
-};
-const requestedRepo = (req) => {
-    const fromQuery = typeof req.query.repo === 'string' ? req.query.repo : undefined;
-    if (fromQuery)
-        return fromQuery;
-    if (req.body && typeof req.body === 'object' && typeof req.body.repo === 'string') {
-        return req.body.repo;
-    }
-    return undefined;
-};
-export const createServer = async (port, host = '127.0.0.1') => {
-    const app = express();
-    // CORS: localhost origins + deployed site only
-    // Non-browser requests (curl, server-to-server) have no origin and are allowed
-    app.use(cors({
-        origin: (origin, callback) => {
-            if (!origin
-                || origin.startsWith('http://localhost:')
-                || origin.startsWith('http://127.0.0.1:')
-                || origin === 'https://code-mapper.vercel.app') {
-                callback(null, true);
-            }
-            else {
-                callback(new Error('Not allowed by CORS'));
-            }
-        }
-    }));
-    app.use(express.json({ limit: '10mb' }));
-    // Initialize MCP backend (multi-repo, shared across all MCP sessions)
-    const backend = new LocalBackend();
-    await backend.init();
-    const cleanupMcp = mountMCPEndpoints(app, backend);
-    // Resolve a repo by name from the global registry, or default to first
-    const resolveRepo = async (repoName) => {
-        const repos = await listRegisteredRepos();
-        if (repos.length === 0)
-            return null;
-        if (repoName)
-            return repos.find(r => r.name === repoName) || null;
-        return repos[0]; // default to first
-    };
-    // List all registered repos
-    app.get('/api/repos', async (_req, res) => {
-        try {
-            const repos = await listRegisteredRepos();
-            res.json(repos.map(r => ({
-                name: r.name, path: r.path, indexedAt: r.indexedAt,
-                lastCommit: r.lastCommit, stats: r.stats,
-            })));
-        }
-        catch (err) {
-            res.status(500).json({ error: err.message || 'Failed to list repos' });
-        }
-    });
-    // Get repo info
-    app.get('/api/repo', async (req, res) => {
-        try {
-            const entry = await resolveRepo(requestedRepo(req));
-            if (!entry) {
-                res.status(404).json({ error: 'Repository not found. Run: code-mapper analyze' });
-                return;
-            }
-            const meta = await loadMeta(entry.storagePath);
-            res.json({
-                name: entry.name,
-                repoPath: entry.path,
-                indexedAt: meta?.indexedAt ?? entry.indexedAt,
-                stats: meta?.stats ?? entry.stats ?? {},
-            });
-        }
-        catch (err) {
-            res.status(500).json({ error: err.message || 'Failed to get repo info' });
-        }
-    });
-    // Get full graph
-    app.get('/api/graph', async (req, res) => {
-        try {
-            const entry = await resolveRepo(requestedRepo(req));
-            if (!entry) {
-                res.status(404).json({ error: 'Repository not found' });
-                return;
-            }
-            const lbugPath = path.join(entry.storagePath, 'lbug');
-            const graph = await withLbugDb(lbugPath, async () => buildGraph());
-            res.json(graph);
-        }
-        catch (err) {
-            res.status(500).json({ error: err.message || 'Failed to build graph' });
-        }
-    });
-    // Execute Cypher query
-    app.post('/api/query', async (req, res) => {
-        try {
-            const cypher = req.body.cypher;
-            if (!cypher) {
-                res.status(400).json({ error: 'Missing "cypher" in request body' });
-                return;
-            }
-            const entry = await resolveRepo(requestedRepo(req));
-            if (!entry) {
-                res.status(404).json({ error: 'Repository not found' });
-                return;
-            }
-            const lbugPath = path.join(entry.storagePath, 'lbug');
-            const result = await withLbugDb(lbugPath, () => executeQuery(cypher));
-            res.json({ result });
-        }
-        catch (err) {
-            res.status(500).json({ error: err.message || 'Query failed' });
-        }
-    });
-    // Search
-    app.post('/api/search', async (req, res) => {
-        try {
-            const query = (req.body.query ?? '').trim();
-            if (!query) {
-                res.status(400).json({ error: 'Missing "query" in request body' });
-                return;
-            }
-            const entry = await resolveRepo(requestedRepo(req));
-            if (!entry) {
-                res.status(404).json({ error: 'Repository not found' });
-                return;
-            }
-            const lbugPath = path.join(entry.storagePath, 'lbug');
-            const parsedLimit = Number(req.body.limit ?? 10);
-            const limit = Number.isFinite(parsedLimit)
-                ? Math.max(1, Math.min(100, Math.trunc(parsedLimit)))
-                : 10;
-            const results = await withLbugDb(lbugPath, async () => {
-                const { isEmbedderReady } = await import('../core/embeddings/embedder.js');
-                if (isEmbedderReady()) {
-                    const { semanticSearch } = await import('../core/embeddings/embedding-pipeline.js');
-                    return hybridSearch(query, limit, executeQuery, semanticSearch);
-                }
-                // FTS-only fallback when embeddings aren't loaded
-                return searchFTSFromLbug(query, limit);
-            });
-            res.json({ results });
-        }
-        catch (err) {
-            res.status(500).json({ error: err.message || 'Search failed' });
-        }
-    });
-    // Read file (with path traversal guard)
-    app.get('/api/file', async (req, res) => {
-        try {
-            const entry = await resolveRepo(requestedRepo(req));
-            if (!entry) {
-                res.status(404).json({ error: 'Repository not found' });
-                return;
-            }
-            const filePath = req.query.path;
-            if (!filePath) {
-                res.status(400).json({ error: 'Missing path' });
-                return;
-            }
-            // Prevent path traversal: resolve and verify path stays within repo root
-            const repoRoot = path.resolve(entry.path);
-            const fullPath = path.resolve(repoRoot, filePath);
-            if (!fullPath.startsWith(repoRoot + path.sep) && fullPath !== repoRoot) {
-                res.status(403).json({ error: 'Path traversal denied' });
-                return;
-            }
-            const content = await fs.readFile(fullPath, 'utf-8');
-            res.json({ content });
-        }
-        catch (err) {
-            if (err.code === 'ENOENT') {
-                res.status(404).json({ error: 'File not found' });
-            }
-            else {
-                res.status(500).json({ error: err.message || 'Failed to read file' });
-            }
-        }
-    });
-    // List all processes
-    app.get('/api/processes', async (req, res) => {
-        try {
-            const result = await backend.queryProcesses(requestedRepo(req));
-            res.json(result);
-        }
-        catch (err) {
-            res.status(statusFromError(err)).json({ error: err.message || 'Failed to query processes' });
-        }
-    });
-    // Process detail
-    app.get('/api/process', async (req, res) => {
-        try {
-            const name = String(req.query.name ?? '').trim();
-            if (!name) {
-                res.status(400).json({ error: 'Missing "name" query parameter' });
-                return;
-            }
-            const result = await backend.queryProcessDetail(name, requestedRepo(req));
-            if (result?.error) {
-                res.status(404).json({ error: result.error });
-                return;
-            }
-            res.json(result);
-        }
-        catch (err) {
-            res.status(statusFromError(err)).json({ error: err.message || 'Failed to query process detail' });
-        }
-    });
-    // List all clusters
-    app.get('/api/clusters', async (req, res) => {
-        try {
-            const result = await backend.queryClusters(requestedRepo(req));
-            res.json(result);
-        }
-        catch (err) {
-            res.status(statusFromError(err)).json({ error: err.message || 'Failed to query clusters' });
-        }
-    });
-    // Cluster detail
-    app.get('/api/cluster', async (req, res) => {
-        try {
-            const name = String(req.query.name ?? '').trim();
-            if (!name) {
-                res.status(400).json({ error: 'Missing "name" query parameter' });
-                return;
-            }
-            const result = await backend.queryClusterDetail(name, requestedRepo(req));
-            if (result?.error) {
-                res.status(404).json({ error: result.error });
-                return;
-            }
-            res.json(result);
-        }
-        catch (err) {
-            res.status(statusFromError(err)).json({ error: err.message || 'Failed to query cluster detail' });
-        }
-    });
-    // Global error handler
-    app.use((err, _req, res, _next) => {
-        console.error('Unhandled error:', err);
-        res.status(500).json({ error: 'Internal server error' });
-    });
-    const server = app.listen(port, host, () => {
-        console.log(`Code Mapper server running on http://${host}:${port}`);
-    });
-    // Graceful shutdown
-    const shutdown = async () => {
-        server.close();
-        await cleanupMcp();
-        await closeLbug();
-        await backend.disconnect();
-        process.exit(0);
-    };
-    process.once('SIGINT', shutdown);
-    process.once('SIGTERM', shutdown);
-};

package/dist/server/mcp-http.d.ts

@@ -1,7 +0,0 @@
-/** @file mcp-http.ts
- *  @description Mounts Code Mapper MCP server on Express using StreamableHTTP transport
- *  Each client gets a stateful session; LocalBackend is shared (thread-safe)
- *  Sessions are evicted on close or after idle timeout */
-import type { Express } from 'express';
-import type { LocalBackend } from '../mcp/local/local-backend.js';
-export declare function mountMCPEndpoints(app: Express, backend: LocalBackend): () => Promise<void>;