context-vault 2.4.1 → 2.4.2

package/scripts/local-server.js

@@ -0,0 +1,386 @@
+#!/usr/bin/env node
+/**
+ * local-server.js — Local mode: serves app + vault API with no auth.
+ *
+ * Uses local SQLite vault. No authentication required.
+ * Usage: node local-server.js [--port 3141]
+ */
+
+import { createServer } from "node:http";
+import { createReadStream, existsSync, statSync, unlinkSync } from "node:fs";
+import { join, resolve, dirname, extname } from "node:path";
+import { fileURLToPath } from "node:url";
+import { homedir, platform } from "node:os";
+import { execSync } from "node:child_process";
+import { resolveConfig } from "@context-vault/core/core/config";
+import { initDatabase, prepareStatements, insertVec, deleteVec } from "@context-vault/core/index/db";
+import { embed } from "@context-vault/core/index/embed";
+import { captureAndIndex, updateEntryFile } from "@context-vault/core/capture";
+import { indexEntry } from "@context-vault/core/index";
+import { hybridSearch } from "@context-vault/core/retrieve";
+import { gatherVaultStatus } from "@context-vault/core/core/status";
+import { normalizeKind } from "@context-vault/core/core/files";
+import { categoryFor } from "@context-vault/core/core/categories";
+
+const __dirname = dirname(fileURLToPath(import.meta.url));
+const LOCAL_ROOT = resolve(__dirname, "..");
+const APP_DIST = resolve(LOCAL_ROOT, "..", "app", "dist");
+
+const MIME = {
+  ".html": "text/html",
+  ".js": "application/javascript",
+  ".css": "text/css",
+  ".json": "application/json",
+  ".ico": "image/x-icon",
+  ".svg": "image/svg+xml",
+};
+
+function formatEntry(row) {
+  return {
+    id: row.id,
+    kind: row.kind,
+    category: row.category,
+    title: row.title || null,
+    body: row.body || null,
+    tags: row.tags ? JSON.parse(row.tags) : [],
+    meta: row.meta ? (typeof row.meta === "string" ? JSON.parse(row.meta) : row.meta) : {},
+    source: row.source || null,
+    identity_key: row.identity_key || null,
+    expires_at: row.expires_at || null,
+    created_at: row.created_at,
+  };
+}
+
+function validateEntry(data, { requireKind = true, requireBody = true } = {}) {
+  if (requireKind && !data.kind) return { error: "kind is required", status: 400 };
+  if (data.kind && !/^[a-z0-9-]+$/.test(data.kind)) return { error: "kind must be lowercase alphanumeric/hyphens", status: 400 };
+  if (requireBody && !data.body) return { error: "body is required", status: 400 };
+  if (data.body && data.body.length > 100 * 1024) return { error: "body max 100KB", status: 400 };
+  if (categoryFor(data.kind) === "entity" && !data.identity_key) return { error: `Entity kind "${data.kind}" requires identity_key`, status: 400 };
+  return null;
+}
+
+async function main() {
+  const portArg = process.argv.find((a) => a.startsWith("--port="));
+  const portVal = portArg ? portArg.split("=")[1] : process.argv[process.argv.indexOf("--port") + 1];
+  const port = parseInt(portVal || "3141", 10);
+
+  const config = resolveConfig();
+  config.vaultDirExists = existsSync(config.vaultDir);
+  let db = await initDatabase(config.dbPath);
+  let stmts = prepareStatements(db);
+
+  const state = {
+    db,
+    config,
+    stmts,
+    embed,
+    get ctx() {
+      return {
+        db: state.db,
+        config: state.config,
+        stmts: state.stmts,
+        embed: state.embed,
+        insertVec: (r, e) => insertVec(state.stmts, r, e),
+        deleteVec: (r) => deleteVec(state.stmts, r),
+        userId: null,
+      };
+    },
+  };
+
+  const server = createServer(async (req, res) => {
+    const url = req.url?.replace(/\?.*$/, "") || "/";
+
+    const json = (data, status = 200) => {
+      res.writeHead(status, { "Content-Type": "application/json", "Access-Control-Allow-Origin": "*" });
+      res.end(JSON.stringify(data));
+    };
+
+    const readBody = () =>
+      new Promise((resolve) => {
+        let body = "";
+        req.on("data", (c) => (body += c));
+        req.on("end", () => {
+          try {
+            resolve(body ? JSON.parse(body) : null);
+          } catch {
+            resolve(null);
+          }
+        });
+      });
+
+    const ctx = state.ctx;
+
+    // ─── API: POST /api/local/browse — native folder picker dialog ────────────
+    if (url === "/api/local/browse" && req.method === "POST") {
+      const os = platform();
+      try {
+        let selected;
+        if (os === "darwin") {
+          selected = execSync(
+            `osascript -e 'POSIX path of (choose folder with prompt "Select vault folder")'`,
+            { encoding: "utf-8", timeout: 30000 }
+          ).trim();
+        } else if (os === "linux") {
+          selected = execSync(
+            `zenity --file-selection --directory --title="Select vault folder" 2>/dev/null`,
+            { encoding: "utf-8", timeout: 30000 }
+          ).trim();
+        } else {
+          return json({ error: "Folder picker not supported on this platform" }, 501);
+        }
+
+        if (selected) {
+          return json({ path: selected });
+        }
+        return json({ path: null, cancelled: true });
+      } catch {
+        // User cancelled the dialog or command failed
+        return json({ path: null, cancelled: true });
+      }
+    }
+
+    // ─── API: POST /api/local/connect — switch to a local vault folder ───────
+    if (url === "/api/local/connect" && req.method === "POST") {
+      const data = await readBody();
+      if (!data?.vaultDir?.trim()) return json({ error: "vaultDir is required", code: "INVALID_INPUT" }, 400);
+      let vaultPath = data.vaultDir.trim().replace(/^~/, homedir());
+      vaultPath = resolve(vaultPath);
+      if (!existsSync(vaultPath)) return json({ error: "Vault folder not found", code: "NOT_FOUND" }, 404);
+      if (!statSync(vaultPath).isDirectory()) return json({ error: "Path is not a directory", code: "INVALID_INPUT" }, 400);
+      try {
+        try { state.db.close(); } catch {}
+        const newConfig = { ...state.config, vaultDir: vaultPath, dbPath: join(vaultPath, ".context-vault.db"), vaultDirExists: true };
+        state.config = newConfig;
+        state.db = await initDatabase(newConfig.dbPath);
+        state.stmts = prepareStatements(state.db);
+        console.log(`[context-vault] Switched to vault: ${vaultPath}`);
+        return json({
+          userId: "local",
+          email: "local@localhost",
+          name: "Local",
+          tier: "free",
+          createdAt: new Date().toISOString(),
+        });
+      } catch (e) {
+        console.error(`[local-server] Connect error: ${e.message}`);
+        return json({ error: `Failed to connect: ${e.message}`, code: "CONNECT_FAILED" }, 500);
+      }
+    }
+
+    // ─── API: /api/me (local mode — no auth) ─────────────────────────────────
+    if (url === "/api/me" && req.method === "GET") {
+      return json({
+        userId: "local",
+        email: "local@localhost",
+        name: "Local",
+        tier: "free",
+        createdAt: new Date().toISOString(),
+      });
+    }
+
+    // ─── API: /api/billing/usage (local — unlimited) ─────────────────────────
+    if (url === "/api/billing/usage" && req.method === "GET") {
+      const status = gatherVaultStatus(ctx, {});
+      const total = status.kindCounts.reduce((s, k) => s + k.c, 0);
+      const storageMb = Math.round((status.dbSizeBytes / (1024 * 1024)) * 100) / 100;
+      return json({
+        tier: "free",
+        limits: { maxEntries: "unlimited", requestsPerDay: "unlimited", storageMb: 1024, exportEnabled: true },
+        usage: { requestsToday: 0, entriesUsed: total, storageMb },
+      });
+    }
+
+    // ─── API: /api/keys (local — empty) ──────────────────────────────────────
+    if (url === "/api/keys" && req.method === "GET") {
+      return json({ keys: [] });
+    }
+
+    // ─── API: /api/vault/status ─────────────────────────────────────────────
+    if (url === "/api/vault/status" && req.method === "GET") {
+      const status = gatherVaultStatus(ctx, {});
+      return json({
+        entries: {
+          total: status.kindCounts.reduce((s, k) => s + k.c, 0),
+          by_kind: Object.fromEntries(status.kindCounts.map((k) => [k.kind, k.c])),
+          by_category: Object.fromEntries(status.categoryCounts.map((k) => [k.category, k.c])),
+        },
+        files: { total: status.fileCount, directories: status.subdirs },
+        database: { size: status.dbSize, size_bytes: status.dbSizeBytes, stale_paths: status.staleCount, expired: status.expiredCount },
+        embeddings: status.embeddingStatus,
+        embed_model_available: status.embedModelAvailable,
+        health: status.errors.length === 0 && !status.stalePaths ? "ok" : "degraded",
+        errors: status.errors,
+      });
+    }
+
+    // ─── API: GET /api/vault/entries ────────────────────────────────────────
+    if (url.startsWith("/api/vault/entries") && req.method === "GET") {
+      const idMatch = url.match(/\/api\/vault\/entries\/([^/]+)$/);
+      if (idMatch) {
+        const entry = stmts.getEntryById.get(idMatch[1]);
+        if (!entry) return json({ error: "Entry not found", code: "NOT_FOUND" }, 404);
+        return json(formatEntry(entry));
+      }
+      const u = new URL(req.url || "", "http://localhost");
+      const kind = u.searchParams.get("kind") || null;
+      const category = u.searchParams.get("category") || null;
+      const limit = Math.min(parseInt(u.searchParams.get("limit") || "20", 10) || 20, 100);
+      const offset = parseInt(u.searchParams.get("offset") || "0", 10) || 0;
+      const clauses = ["(expires_at IS NULL OR expires_at > datetime('now'))"];
+      const params = [];
+      if (kind) {
+        clauses.push("kind = ?");
+        params.push(normalizeKind(kind));
+      }
+      if (category) {
+        clauses.push("category = ?");
+        params.push(category);
+      }
+      const where = clauses.length ? `WHERE ${clauses.join(" AND ")}` : "";
+      const total = ctx.db.prepare(`SELECT COUNT(*) as c FROM vault ${where}`).get(...params).c;
+      const rows = ctx.db.prepare(`SELECT * FROM vault ${where} ORDER BY created_at DESC LIMIT ? OFFSET ?`).all(...params, limit, offset);
+      return json({ entries: rows.map(formatEntry), total, limit, offset });
+    }
+
+    // ─── API: POST /api/vault/entries ────────────────────────────────────────
+    if (url === "/api/vault/entries" && req.method === "POST") {
+      const data = await readBody();
+      if (!data) return json({ error: "Invalid JSON body", code: "INVALID_INPUT" }, 400);
+      const err = validateEntry(data);
+      if (err) return json({ error: err.error, code: "INVALID_INPUT" }, err.status);
+      try {
+        const entry = await captureAndIndex(
+          ctx,
+          {
+            kind: data.kind,
+            title: data.title,
+            body: data.body,
+            meta: data.meta,
+            tags: data.tags,
+            source: data.source || "rest-api",
+            identity_key: data.identity_key,
+            expires_at: data.expires_at,
+            userId: null,
+          },
+          indexEntry
+        );
+        return json(formatEntry(stmts.getEntryById.get(entry.id)), 201);
+      } catch (e) {
+        console.error(`[local-server] Create error: ${e.message}`);
+        return json({ error: "Failed to create entry", code: "CREATE_FAILED" }, 500);
+      }
+    }
+
+    // ─── API: PUT /api/vault/entries/:id ─────────────────────────────────────
+    if (url.match(/^\/api\/vault\/entries\/[^/]+$/) && req.method === "PUT") {
+      const id = url.split("/").pop();
+      const data = await readBody();
+      if (!data) return json({ error: "Invalid JSON body", code: "INVALID_INPUT" }, 400);
+      const err = validateEntry(data, { requireKind: false, requireBody: false });
+      if (err) return json({ error: err.error, code: "INVALID_INPUT" }, err.status);
+      const existing = stmts.getEntryById.get(id);
+      if (!existing) return json({ error: "Entry not found", code: "NOT_FOUND" }, 404);
+      try {
+        const entry = updateEntryFile(ctx, existing, {
+          title: data.title,
+          body: data.body,
+          tags: data.tags,
+          meta: data.meta,
+          source: data.source,
+          expires_at: data.expires_at,
+        });
+        await indexEntry(ctx, entry);
+        return json(formatEntry(stmts.getEntryById.get(id)));
+      } catch (e) {
+        console.error(`[local-server] Update error: ${e.message}`);
+        return json({ error: "Failed to update entry", code: "UPDATE_FAILED" }, 500);
+      }
+    }
+
+    // ─── API: DELETE /api/vault/entries/:id ──────────────────────────────────
+    if (url.match(/^\/api\/vault\/entries\/[^/]+$/) && req.method === "DELETE") {
+      const id = url.split("/").pop();
+      const entry = stmts.getEntryById.get(id);
+      if (!entry) return json({ error: "Entry not found", code: "NOT_FOUND" }, 404);
+      if (entry.file_path) {
+        try {
+          unlinkSync(entry.file_path);
+        } catch {}
+      }
+      const rowidResult = stmts.getRowid.get(id);
+      if (rowidResult?.rowid) {
+        try {
+          deleteVec(stmts, Number(rowidResult.rowid));
+        } catch {}
+      }
+      stmts.deleteEntry.run(id);
+      return json({ deleted: true, id, kind: entry.kind, title: entry.title || null });
+    }
+
+    // ─── API: POST /api/vault/search ─────────────────────────────────────────
+    if (url === "/api/vault/search" && req.method === "POST") {
+      const data = await readBody();
+      if (!data || !data.query?.trim()) return json({ error: "query is required", code: "INVALID_INPUT" }, 400);
+      const limit = Math.min(parseInt(data.limit || 20, 10) || 20, 100);
+      const offset = parseInt(data.offset || 0, 10) || 0;
+      try {
+        const results = await hybridSearch(ctx, data.query, {
+          kindFilter: data.kind ? normalizeKind(data.kind) : null,
+          categoryFilter: data.category || null,
+          limit,
+          offset,
+          decayDays: ctx.config.eventDecayDays || 30,
+          userIdFilter: undefined,
+        });
+        const formatted = results.map((row) => ({ ...formatEntry(row), score: Math.round(row.score * 1000) / 1000 }));
+        return json({ results: formatted, count: formatted.length, query: data.query });
+      } catch (e) {
+        console.error(`[local-server] Search error: ${e.message}`);
+        return json({ error: "Search failed", code: "SEARCH_FAILED" }, 500);
+      }
+    }
+
+    // ─── Static files ───────────────────────────────────────────────────────
+    const filePath = join(APP_DIST, url === "/" ? "index.html" : url.replace(/^\//, ""));
+    if (!filePath.startsWith(APP_DIST)) {
+      res.writeHead(403);
+      res.end();
+      return;
+    }
+    if (!existsSync(filePath) || !statSync(filePath).isFile()) {
+      const fallback = join(APP_DIST, "index.html");
+      if (existsSync(fallback)) {
+        res.writeHead(200, { "Content-Type": "text/html" });
+        createReadStream(fallback).pipe(res);
+        return;
+      }
+      res.writeHead(404);
+      res.end();
+      return;
+    }
+    const type = MIME[extname(filePath)] || "application/octet-stream";
+    res.writeHead(200, { "Content-Type": type });
+    createReadStream(filePath).pipe(res);
+  });
+
+  server.listen(port, () => {
+    console.log(`[context-vault] Local mode: http://localhost:${port}`);
+    console.log(`[context-vault] Vault: ${config.vaultDir}`);
+    console.log(`[context-vault] No authentication required`);
+  });
+
+  process.on("SIGINT", () => {
+    try { state.db.close(); } catch {}
+    process.exit(0);
+  });
+  process.on("SIGTERM", () => {
+    try { state.db.close(); } catch {}
+    process.exit(0);
+  });
+}
+
+main().catch((e) => {
+  console.error(`[local-server] Fatal: ${e.message}`);
+  process.exit(1);
+});

package/scripts/postinstall.js

@@ -1,14 +1,25 @@
 #!/usr/bin/env node
 
 /**
- * postinstall.js — Auto-rebuild native modules on install
+ * postinstall.js — Post-install setup for context-vault
  *
- * Detects NODE_MODULE_VERSION mismatches and attempts a rebuild.
+ * 1. Detects NODE_MODULE_VERSION mismatches for native modules and rebuilds.
+ * 2. Installs @huggingface/transformers with --ignore-scripts to avoid sharp's
+ *    broken install lifecycle in global contexts.  Semantic search degrades
+ *    gracefully if this step fails.
  */
 
 import { execSync } from "node:child_process";
+import { existsSync } from "node:fs";
+import { join, dirname } from "node:path";
+import { fileURLToPath } from "node:url";
+
+const __dirname = dirname(fileURLToPath(import.meta.url));
+const PKG_ROOT = join(__dirname, "..");
+const NODE_MODULES = join(PKG_ROOT, "node_modules");
 
 async function main() {
+  // ── 1. Native-module rebuild ──────────────────────────────────────────
   let needsRebuild = false;
 
   try {
@@ -40,6 +51,28 @@ async function main() {
       console.error("[context-vault] Try manually: npm rebuild better-sqlite3 sqlite-vec");
     }
   }
+
+  // ── 2. Install @huggingface/transformers (optional) ───────────────────
+  // The transformers package depends on `sharp`, whose install script fails
+  // in global npm contexts.  We install with --ignore-scripts to skip it —
+  // context-vault only uses text embeddings, not image processing.
+  // Check the package's own node_modules (not general import resolution,
+  // which may find it in the workspace during `npm install -g ./tarball`).
+  const transformersDir = join(NODE_MODULES, "@huggingface", "transformers");
+  if (!existsSync(transformersDir)) {
+    console.log("[context-vault] Installing embedding support (@huggingface/transformers)...");
+    try {
+      execSync("npm install --no-save --ignore-scripts @huggingface/transformers@^3.0.0", {
+        stdio: "inherit",
+        timeout: 120000,
+        cwd: PKG_ROOT,
+      });
+      console.log("[context-vault] Embedding support installed.");
+    } catch {
+      console.error("[context-vault] Warning: could not install @huggingface/transformers.");
+      console.error("[context-vault] Semantic search will be unavailable; full-text search still works.");
+    }
+  }
 }
 
 main().catch(() => {});

package/scripts/prepack.js

@@ -7,20 +7,22 @@
  * Replaces the Unix shell script in package.json "prepack".
  */
 
-import { cpSync, rmSync, mkdirSync } from "node:fs";
+import { cpSync, rmSync, mkdirSync, readFileSync, writeFileSync } from "node:fs";
 import { join, dirname } from "node:path";
 import { fileURLToPath } from "node:url";
 
 const __dirname = dirname(fileURLToPath(import.meta.url));
 const LOCAL_ROOT = join(__dirname, "..");
+const NODE_MODULES = join(LOCAL_ROOT, "node_modules");
 const CORE_SRC = join(LOCAL_ROOT, "..", "core");
-const CORE_DEST = join(LOCAL_ROOT, "node_modules", "@context-vault", "core");
+const CORE_DEST = join(NODE_MODULES, "@context-vault", "core");
 
-// Ensure target directory exists
-mkdirSync(join(LOCAL_ROOT, "node_modules", "@context-vault"), { recursive: true });
+// Clean node_modules to prevent workspace deps from leaking into the tarball.
+// Only @context-vault/core should be bundled.
+rmSync(NODE_MODULES, { recursive: true, force: true });
 
-// Remove old copy if present
-rmSync(CORE_DEST, { recursive: true, force: true });
+// Ensure target directory exists
+mkdirSync(join(NODE_MODULES, "@context-vault"), { recursive: true });
 
 // Copy core package (dereference symlinks)
 cpSync(CORE_SRC, CORE_DEST, { recursive: true, dereference: true });
@@ -28,4 +30,15 @@ cpSync(CORE_SRC, CORE_DEST, { recursive: true, dereference: true });
 // Remove nested node_modules from the copy
 rmSync(join(CORE_DEST, "node_modules"), { recursive: true, force: true });
 
+// Strip all dependencies from the bundled core's package.json.
+// Core's deps (better-sqlite3, sqlite-vec, MCP SDK) are hoisted to
+// context-vault's own dependencies.  @huggingface/transformers is
+// dynamically imported and installed via postinstall.  Leaving them
+// in the bundled core causes duplicate resolution that breaks native
+// module install scripts in global npm contexts.
+const corePkgPath = join(CORE_DEST, "package.json");
+const corePkg = JSON.parse(readFileSync(corePkgPath, "utf8"));
+delete corePkg.dependencies;
+writeFileSync(corePkgPath, JSON.stringify(corePkg, null, 2) + "\n");
+
 console.log("[prepack] Bundled @context-vault/core into node_modules");

package/src/server/index.js

@@ -2,7 +2,7 @@
 
 import { McpServer } from "@modelcontextprotocol/sdk/server/mcp.js";
 import { StdioServerTransport } from "@modelcontextprotocol/sdk/server/stdio.js";
-import { existsSync, mkdirSync, writeFileSync, readFileSync } from "node:fs";
+import { existsSync, mkdirSync, writeFileSync, readFileSync, unlinkSync } from "node:fs";
 import { join, dirname } from "node:path";
 import { fileURLToPath } from "node:url";
 
@@ -19,33 +19,46 @@ import { registerTools } from "@context-vault/core/server/tools";
 async function main() {
   let phase = "CONFIG";
   let db;
+  let config;
 
   try {
     // ── Phase: CONFIG ────────────────────────────────────────────────────────
-    const config = resolveConfig();
+    config = resolveConfig();
 
     // ── Phase: DIRS ──────────────────────────────────────────────────────────
     phase = "DIRS";
     mkdirSync(config.dataDir, { recursive: true });
     mkdirSync(config.vaultDir, { recursive: true });
 
+    // Verify vault directory is writable (catch permission issues early)
+    try {
+      const probe = join(config.vaultDir, ".write-probe");
+      writeFileSync(probe, "");
+      unlinkSync(probe);
+    } catch (writeErr) {
+      console.error(`[context-vault] FATAL: Vault directory is not writable: ${config.vaultDir}`);
+      console.error(`[context-vault] ${writeErr.message}`);
+      console.error(`[context-vault] Fix permissions: chmod u+w "${config.vaultDir}"`);
+      process.exit(1);
+    }
+
     // Write .context-mcp marker (non-fatal)
     try {
       const markerPath = join(config.vaultDir, ".context-mcp");
       const markerData = existsSync(markerPath) ? JSON.parse(readFileSync(markerPath, "utf-8")) : {};
       writeFileSync(markerPath, JSON.stringify({ created: markerData.created || new Date().toISOString(), version: pkg.version }, null, 2) + "\n");
     } catch (markerErr) {
-      console.error(`[context-mcp] Warning: could not write marker file: ${markerErr.message}`);
+      console.error(`[context-vault] Warning: could not write marker file: ${markerErr.message}`);
     }
 
     config.vaultDirExists = existsSync(config.vaultDir);
 
     // Startup diagnostics
-    console.error(`[context-mcp] Vault: ${config.vaultDir}`);
-    console.error(`[context-mcp] Database: ${config.dbPath}`);
-    console.error(`[context-mcp] Dev dir: ${config.devDir}`);
+    console.error(`[context-vault] Vault: ${config.vaultDir}`);
+    console.error(`[context-vault] Database: ${config.dbPath}`);
+    console.error(`[context-vault] Dev dir: ${config.devDir}`);
     if (!config.vaultDirExists) {
-      console.error(`[context-mcp] WARNING: Vault directory not found!`);
+      console.error(`[context-vault] WARNING: Vault directory not found!`);
     }
 
     // ── Phase: DB ────────────────────────────────────────────────────────────
@@ -60,33 +73,55 @@ async function main() {
       embed,
       insertVec: (rowid, embedding) => insertVec(stmts, rowid, embedding),
       deleteVec: (rowid) => deleteVec(stmts, rowid),
+      activeOps: { count: 0 },
     };
 
     // ── Phase: SERVER ────────────────────────────────────────────────────────
     phase = "SERVER";
     const server = new McpServer(
-      { name: "context-mcp", version: pkg.version },
+      { name: "context-vault", version: pkg.version },
       { capabilities: { tools: {} } }
     );
 
     registerTools(server, ctx);
 
     // ── Graceful Shutdown ────────────────────────────────────────────────────
-    function shutdown(signal) {
-      console.error(`[context-mcp] Received ${signal}, shutting down...`);
+    function closeDb() {
       try {
         if (db.inTransaction) {
-          console.error("[context-mcp] Rolling back active transaction...");
+          console.error("[context-vault] Rolling back active transaction...");
           db.exec("ROLLBACK");
         }
         db.pragma("wal_checkpoint(TRUNCATE)");
         db.close();
-        console.error("[context-mcp] Database closed cleanly.");
+        console.error("[context-vault] Database closed cleanly.");
       } catch (shutdownErr) {
-        console.error(`[context-mcp] Shutdown error: ${shutdownErr.message}`);
+        console.error(`[context-vault] Shutdown error: ${shutdownErr.message}`);
       }
       process.exit(0);
     }
+
+    function shutdown(signal) {
+      console.error(`[context-vault] Received ${signal}, shutting down...`);
+
+      if (ctx.activeOps.count > 0) {
+        console.error(`[context-vault] Waiting for ${ctx.activeOps.count} in-flight operation(s)...`);
+        const check = setInterval(() => {
+          if (ctx.activeOps.count === 0) {
+            clearInterval(check);
+            closeDb();
+          }
+        }, 100);
+        // Force shutdown after 5 seconds even if ops are still running
+        setTimeout(() => {
+          clearInterval(check);
+          console.error(`[context-vault] Force shutdown — ${ctx.activeOps.count} operation(s) still running`);
+          closeDb();
+        }, 5000);
+      } else {
+        closeDb();
+      }
+    }
     process.on("SIGINT", () => shutdown("SIGINT"));
     process.on("SIGTERM", () => shutdown("SIGTERM"));
 
@@ -105,7 +140,7 @@ async function main() {
             stdio: ["pipe", "pipe", "pipe"],
           }).trim();
           if (latest && latest !== pkg.version) {
-            console.error(`[context-mcp] Update available: v${pkg.version} → v${latest}. Run: context-mcp update`);
+            console.error(`[context-vault] Update available: v${pkg.version} → v${latest}. Run: context-vault update`);
           }
         } catch {}
       }).catch(() => {});
@@ -116,7 +151,7 @@ async function main() {
       // Boxed diagnostic for native module mismatch
       console.error("");
       console.error("╔══════════════════════════════════════════════════════════════╗");
-      console.error("║  context-mcp: Native Module Error                           ║");
+      console.error("║  context-vault: Native Module Error                         ║");
       console.error("╚══════════════════════════════════════════════════════════════╝");
       console.error("");
       console.error(err.message);
@@ -127,15 +162,15 @@ async function main() {
       process.exit(78); // EX_CONFIG
     }
 
-    console.error(`[context-mcp] Fatal error during ${phase} phase: ${err.message}`);
+    console.error(`[context-vault] Fatal error during ${phase} phase: ${err.message}`);
     if (phase === "DB") {
-      console.error(`[context-mcp] Try deleting the DB file and restarting: rm "${err.dbPath || "vault.db"}"`);
+      console.error(`[context-vault] Try deleting the DB file and restarting: rm "${config?.dbPath || "vault.db"}"`);
     }
     process.exit(1);
   }
 }
 
 main().catch((err) => {
-  console.error(`[context-mcp] Unexpected fatal error: ${err.message}`);
+  console.error(`[context-vault] Unexpected fatal error: ${err.message}`);
   process.exit(1);
 });