context-vault 3.1.6 → 3.1.8

package/src/{server.js → server.ts}

@@ -1,69 +1,58 @@
 #!/usr/bin/env node
 
-import { McpServer } from "@modelcontextprotocol/sdk/server/mcp.js";
-import { StdioServerTransport } from "@modelcontextprotocol/sdk/server/stdio.js";
-import {
-  existsSync,
-  mkdirSync,
-  writeFileSync,
-  readFileSync,
-  unlinkSync,
-} from "node:fs";
-import { join, dirname } from "node:path";
-import { homedir } from "node:os";
-import { fileURLToPath } from "node:url";
+import { McpServer } from '@modelcontextprotocol/sdk/server/mcp.js';
+import { StdioServerTransport } from '@modelcontextprotocol/sdk/server/stdio.js';
+import { existsSync, mkdirSync, writeFileSync, readFileSync, unlinkSync } from 'node:fs';
+import { join, dirname } from 'node:path';
+import { homedir } from 'node:os';
+import { fileURLToPath } from 'node:url';
 
 const __dirname = dirname(fileURLToPath(import.meta.url));
-const pkg = JSON.parse(
-  readFileSync(join(__dirname, "..", "package.json"), "utf-8"),
-);
+const pkg = JSON.parse(readFileSync(join(__dirname, '..', 'package.json'), 'utf-8'));
 
-import { resolveConfig } from "@context-vault/core/config";
-import { appendErrorLog } from "./error-log.js";
-import { sendTelemetryEvent, maybeShowTelemetryNotice } from "./telemetry.js";
-import { embed } from "@context-vault/core/embed";
+import { resolveConfig } from '@context-vault/core/config';
+import type { LocalCtx } from './types.js';
+import { appendErrorLog } from './error-log.js';
+import { sendTelemetryEvent, maybeShowTelemetryNotice } from './telemetry.js';
+import { embed } from '@context-vault/core/embed';
 import {
   initDatabase,
   NativeModuleError,
   prepareStatements,
   insertVec,
   deleteVec,
-} from "@context-vault/core/db";
-import { registerTools } from "./register-tools.js";
-import { pruneExpired } from "@context-vault/core/index";
+} from '@context-vault/core/db';
+import { registerTools } from './register-tools.js';
+import { pruneExpired } from '@context-vault/core/index';
 
-async function main() {
-  let phase = "CONFIG";
-  let db;
-  let config;
+async function main(): Promise<void> {
+  let phase = 'CONFIG';
+  let db: import('node:sqlite').DatabaseSync | undefined;
+  let config: import('@context-vault/core/types').VaultConfig | undefined;
 
   try {
     config = resolveConfig();
 
-    phase = "DIRS";
+    phase = 'DIRS';
     mkdirSync(config.dataDir, { recursive: true });
     mkdirSync(config.vaultDir, { recursive: true });
     maybeShowTelemetryNotice(config.dataDir);
 
     try {
-      const probe = join(config.vaultDir, ".write-probe");
-      writeFileSync(probe, "");
+      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}"`,
-      );
+      console.error(`[context-vault] FATAL: Vault directory is not writable: ${config.vaultDir}`);
+      console.error(`[context-vault] ${(writeErr as Error).message}`);
+      console.error(`[context-vault] Fix permissions: chmod u+w "${config.vaultDir}"`);
       process.exit(1);
     }
 
     try {
-      const markerPath = join(config.vaultDir, ".context-mcp");
+      const markerPath = join(config.vaultDir, '.context-mcp');
       const markerData = existsSync(markerPath)
-        ? JSON.parse(readFileSync(markerPath, "utf-8"))
+        ? JSON.parse(readFileSync(markerPath, 'utf-8'))
         : {};
       writeFileSync(
         markerPath,
@@ -73,12 +62,12 @@ async function main() {
             version: pkg.version,
           },
           null,
-          2,
-        ) + "\n",
+          2
+        ) + '\n'
       );
     } catch (markerErr) {
       console.error(
-        `[context-vault] Warning: could not write marker file: ${markerErr.message}`,
+        `[context-vault] Warning: could not write marker file: ${(markerErr as Error).message}`
       );
     }
 
@@ -91,17 +80,17 @@ async function main() {
       console.error(`[context-vault] WARNING: Vault directory not found!`);
     }
 
-    phase = "DB";
+    phase = 'DB';
     db = await initDatabase(config.dbPath);
     const stmts = prepareStatements(db);
 
-    const ctx = {
+    const ctx: LocalCtx = {
       db,
       config,
       stmts,
       embed,
-      insertVec: (rowid, embedding) => insertVec(stmts, rowid, embedding),
-      deleteVec: (rowid) => deleteVec(stmts, rowid),
+      insertVec: (rowid: number, embedding: Float32Array) => insertVec(stmts, rowid, embedding),
+      deleteVec: (rowid: number) => deleteVec(stmts, rowid),
       activeOps: { count: 0 },
       toolStats: { ok: 0, errors: 0, lastError: null },
     };
@@ -110,29 +99,27 @@ async function main() {
       const pruned = await pruneExpired(ctx);
       if (pruned > 0) {
         console.error(
-          `[context-vault] Pruned ${pruned} expired ${pruned === 1 ? "entry" : "entries"}`,
+          `[context-vault] Pruned ${pruned} expired ${pruned === 1 ? 'entry' : 'entries'}`
         );
       }
     } catch (pruneErr) {
       console.error(
-        `[context-vault] Warning: startup prune failed: ${pruneErr.message}`,
+        `[context-vault] Warning: startup prune failed: ${(pruneErr as Error).message}`
       );
     }
 
-    phase = "SERVER";
+    phase = 'SERVER';
     const server = new McpServer(
-      { name: "context-vault", version: pkg.version },
-      { capabilities: { tools: {} } },
+      { name: 'context-vault', version: pkg.version },
+      { capabilities: { tools: {} } }
     );
 
     let lastVaultDir = config.vaultDir;
-    Object.defineProperty(ctx, "config", {
+    Object.defineProperty(ctx as object, 'config', {
       get() {
         const fresh = resolveConfig();
         if (fresh.vaultDir !== lastVaultDir) {
-          console.error(
-            `[context-vault] Config reloaded: vaultDir changed to ${fresh.vaultDir}`,
-          );
+          console.error(`[context-vault] Config reloaded: vaultDir changed to ${fresh.vaultDir}`);
           lastVaultDir = fresh.vaultDir;
           fresh.vaultDirExists = existsSync(fresh.vaultDir);
         }
@@ -143,27 +130,27 @@ async function main() {
 
     registerTools(server, ctx);
 
-    function closeDb() {
+    function closeDb(): void {
       try {
-        if (db.inTransaction) {
-          console.error("[context-vault] Rolling back active transaction...");
-          db.exec("ROLLBACK");
+        if ((db as any).inTransaction) {
+          console.error('[context-vault] Rolling back active transaction...');
+          db!.exec('ROLLBACK');
         }
-        db.pragma("wal_checkpoint(TRUNCATE)");
-        db.close();
-        console.error("[context-vault] Database closed cleanly.");
+        (db as any).pragma('wal_checkpoint(TRUNCATE)');
+        db!.close();
+        console.error('[context-vault] Database closed cleanly.');
       } catch (shutdownErr) {
-        console.error(`[context-vault] Shutdown error: ${shutdownErr.message}`);
+        console.error(`[context-vault] Shutdown error: ${(shutdownErr as Error).message}`);
       }
       process.exit(0);
     }
 
-    function shutdown(signal) {
+    function shutdown(signal: string): void {
       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)...`,
+          `[context-vault] Waiting for ${ctx.activeOps.count} in-flight operation(s)...`
         );
         const check = setInterval(() => {
           if (ctx.activeOps.count === 0) {
@@ -174,7 +161,7 @@ async function main() {
         setTimeout(() => {
           clearInterval(check);
           console.error(
-            `[context-vault] Force shutdown — ${ctx.activeOps.count} operation(s) still running`,
+            `[context-vault] Force shutdown — ${ctx.activeOps.count} operation(s) still running`
           );
           closeDb();
         }, 5000);
@@ -182,37 +169,38 @@ async function main() {
         closeDb();
       }
     }
-    process.on("SIGINT", () => shutdown("SIGINT"));
-    process.on("SIGTERM", () => shutdown("SIGTERM"));
+    process.on('SIGINT', () => shutdown('SIGINT'));
+    process.on('SIGTERM', () => shutdown('SIGTERM'));
 
-    phase = "CONNECTED";
+    phase = 'CONNECTED';
     const transport = new StdioServerTransport();
     await server.connect(transport);
 
     setTimeout(() => {
-      import("node:child_process")
+      import('node:child_process')
         .then(({ execSync }) => {
           try {
-            const latest = execSync("npm view context-vault version", {
-              encoding: "utf-8",
+            const latest = execSync('npm view context-vault version', {
+              encoding: 'utf-8',
               timeout: 5000,
-              stdio: ["pipe", "pipe", "pipe"],
+              stdio: ['pipe', 'pipe', 'pipe'],
             }).trim();
             if (latest && latest !== pkg.version) {
               console.error(
-                `[context-vault] Update available: v${pkg.version} → v${latest}. Run: context-vault update`,
+                `[context-vault] Update available: v${pkg.version} → v${latest}. Run: context-vault update`
               );
             }
           } catch {}
         })
         .catch(() => {});
     }, 3000);
-  } catch (err) {
-    const dataDir = config?.dataDir || join(homedir(), ".context-mcp");
+  } catch (rawErr) {
+    const err = rawErr as Error;
+    const dataDir = config?.dataDir || join(homedir(), '.context-mcp');
 
     const logEntry = {
       timestamp: new Date().toISOString(),
-      error_type: err.constructor?.name || "Error",
+      error_type: (err as any).constructor?.name || 'Error',
       message: err.message,
       node_version: process.version,
       platform: process.platform,
@@ -224,59 +212,51 @@ async function main() {
     try {
       mkdirSync(dataDir, { recursive: true });
       writeFileSync(
-        join(dataDir, ".last-error"),
-        `${logEntry.timestamp} [${phase}] ${err.message}`,
+        join(dataDir, '.last-error'),
+        `${logEntry.timestamp} [${phase}] ${err.message}`
       );
     } catch {}
 
     sendTelemetryEvent(config, {
-      event: "startup_error",
+      event: 'startup_error',
       code: phase,
       tool: null,
       cv_version: pkg.version,
     });
 
-    if (err instanceof NativeModuleError) {
-      console.error("");
-      console.error(
-        "╔══════════════════════════════════════════════════════════════╗",
-      );
-      console.error(
-        "║  context-vault: Native Module Error                         ║",
-      );
-      console.error(
-        "╚══════════════════════════════════════════════════════════════╝",
-      );
-      console.error("");
+    if (rawErr instanceof NativeModuleError) {
+      console.error('');
+      console.error('╔══════════════════════════════════════════════════════════════╗');
+      console.error('║  context-vault: Native Module Error                         ║');
+      console.error('╚══════════════════════════════════════════════════════════════╝');
+      console.error('');
       console.error(err.message);
-      console.error("");
+      console.error('');
       console.error(`  Node.js path:    ${process.execPath}`);
       console.error(`  Node.js version: ${process.version}`);
-      console.error(`  Error log:       ${join(dataDir, "error.log")}`);
-      console.error("");
+      console.error(`  Error log:       ${join(dataDir, 'error.log')}`);
+      console.error('');
       process.exit(78);
     }
 
-    console.error(
-      `[context-vault] Fatal error during ${phase} phase: ${err.message}`,
-    );
-    console.error(`[context-vault] Error log: ${join(dataDir, "error.log")}`);
-    if (phase === "DB") {
+    console.error(`[context-vault] Fatal error during ${phase} phase: ${err.message}`);
+    console.error(`[context-vault] Error log: ${join(dataDir, 'error.log')}`);
+    if (phase === 'DB') {
       console.error(
-        `[context-vault] Try deleting the DB file and restarting: rm "${config?.dbPath || "vault.db"}"`,
+        `[context-vault] Try deleting the DB file and restarting: rm "${config?.dbPath || 'vault.db'}"`
       );
     }
     process.exit(1);
   }
 }
 
-process.on("uncaughtException", (err) => {
-  const dataDir = join(homedir(), ".context-mcp");
+process.on('uncaughtException', (err) => {
+  const dataDir = join(homedir(), '.context-mcp');
   const logEntry = {
     timestamp: new Date().toISOString(),
-    error_type: "uncaughtException",
+    error_type: 'uncaughtException',
     message: err.message,
-    stack: err.stack?.split("\n").slice(0, 5).join(" | "),
+    stack: err.stack?.split('\n').slice(0, 5).join(' | '),
     node_version: process.version,
     platform: process.platform,
     arch: process.arch,
@@ -284,17 +264,17 @@ process.on("uncaughtException", (err) => {
   };
   appendErrorLog(dataDir, logEntry);
   console.error(`[context-vault] Uncaught exception: ${err.message}`);
-  console.error(`[context-vault] Error log: ${join(dataDir, "error.log")}`);
+  console.error(`[context-vault] Error log: ${join(dataDir, 'error.log')}`);
   console.error(`[context-vault] Run: context-vault doctor`);
   process.exit(1);
 });
 
-process.on("unhandledRejection", (reason) => {
-  const dataDir = join(homedir(), ".context-mcp");
+process.on('unhandledRejection', (reason) => {
+  const dataDir = join(homedir(), '.context-mcp');
   const message = reason instanceof Error ? reason.message : String(reason);
   const logEntry = {
     timestamp: new Date().toISOString(),
-    error_type: "unhandledRejection",
+    error_type: 'unhandledRejection',
     message,
     node_version: process.version,
     platform: process.platform,
@@ -303,7 +283,7 @@ process.on("unhandledRejection", (reason) => {
   };
   appendErrorLog(dataDir, logEntry);
   console.error(`[context-vault] Unhandled rejection: ${message}`);
-  console.error(`[context-vault] Error log: ${join(dataDir, "error.log")}`);
+  console.error(`[context-vault] Error log: ${join(dataDir, 'error.log')}`);
   console.error(`[context-vault] Run: context-vault doctor`);
   process.exit(1);
 });