md-semantic-search 1.0.1 → 1.0.2

package/bin/cli.mjs

@@ -1136,9 +1136,29 @@ async function main() {
   }
 }
 
-// Run only when executed directly (`node bin/cli.mjs`, `mdss`), never when
-// imported by tests or library consumers (issue #29).
-if (process.argv[1] && import.meta.url === pathToFileURL(process.argv[1]).href) {
+/**
+ * True only when this module is the process entry script (`node bin/cli.mjs`,
+ * global `mdss`), never when imported by tests or library consumers (issue #29).
+ *
+ * The comparison goes through fs.realpathSync on BOTH sides of the identity:
+ * on Windows a global install is an NTFS junction, so Node resolves this module
+ * to its real path (D:\Repo\...\bin\cli.mjs) while process.argv[1] keeps the
+ * junction path (C:\...\npm\node_modules\md-semantic-search\bin\cli.mjs). A
+ * plain string comparison then never matches and the CLI silently does nothing.
+ */
+function isDirectRun() {
+  const entry = process.argv[1];
+  if (!entry) return false;
+  try {
+    return fs.realpathSync(entry) === fileURLToPath(import.meta.url);
+  } catch {
+    // argv[1] vanished between spawn and here (or is not a real file) —
+    // fall back to lexical resolution so behavior matches the old guard.
+    return pathToFileURL(path.resolve(entry)).href === import.meta.url;
+  }
+}
+
+if (isDirectRun()) {
   main().catch(e => die(e.message));
 }
 

package/dist/core.js

@@ -375,6 +375,9 @@ export function assertSafePath(targetPath, allowedRoots) {
     if (targetPath.startsWith('\\\\') || targetPath.startsWith('//')) {
         throw new Error('Forbidden path: UNC network paths not allowed');
     }
+    if (/^[a-zA-Z]:[\\/]/.test(targetPath) && process.platform !== 'win32') {
+        throw new Error('Forbidden path: Windows drive paths not allowed on non-Windows systems');
+    }
     const resolved = path.resolve(targetPath);
     let canonical = resolved;
     try {

package/dist/serve.js

@@ -40,13 +40,19 @@ export async function createServe(opts) {
         apiKey,
         healthPublic,
     };
+    const sockets = new Set();
     const server = http.createServer((req, res) => {
         handleRequest(req, res, state).catch((e) => {
             json(res, 500, { error: e.message });
         });
     });
+    server.on('connection', (socket) => {
+        sockets.add(socket);
+        socket.on('close', () => sockets.delete(socket));
+    });
     let stopped = false;
     let timer = null;
+    let resolveTimer = null;
     const reload = async () => {
         if (!db)
             return false;
@@ -149,7 +155,13 @@ export async function createServe(opts) {
         let pending = false;
         while (!stopped) {
             await new Promise((r) => {
-                timer = setTimeout(r, watchInterval);
+                resolveTimer = r;
+                timer = setTimeout(() => {
+                    timer = null;
+                    resolveTimer = null;
+                    r();
+                }, watchInterval);
+                timer.unref?.();
             });
             if (stopped)
                 return;
@@ -200,15 +212,24 @@ export async function createServe(opts) {
     }
     const close = async () => {
         stopped = true;
-        if (timer)
+        if (timer) {
             clearTimeout(timer);
+            timer = null;
+        }
+        if (resolveTimer) {
+            resolveTimer();
+            resolveTimer = null;
+        }
         if (nativeWatcher)
             nativeWatcher.close();
-        // closeAllConnections() forcibly closes keep-alive sockets so server.close()
-        // doesn't hang indefinitely waiting for them — critical on Node 18 where the
-        // HTTP server does NOT auto-drain idle connections before calling back.
-        // The method was back-ported to Node 18.2.0 and is always present in CI.
         server.closeAllConnections?.();
+        for (const socket of sockets) {
+            try {
+                socket.destroy();
+            }
+            catch { }
+        }
+        sockets.clear();
         await new Promise((resolve, reject) => server.close((err) => (err ? reject(err) : resolve())));
     };
     return { server, state, close };

package/dist/watcher.js

@@ -8,7 +8,7 @@ import fs from 'node:fs';
 import path from 'node:path';
 import { globToRegExp } from './core.js';
 export function createFileWatcher(dbPath, onChange, options = {}) {
-    const { debounceMs = 250, ignore = [], log = () => { }, fallbackIntervalMs = 1000, } = options;
+    const { debounceMs = 250, ignore = [], log = () => { }, fallbackIntervalMs = 50, } = options;
     let closed = false;
     let debounceTimer = null;
     const ignoreRegexes = [
@@ -47,6 +47,7 @@ export function createFileWatcher(dbPath, onChange, options = {}) {
                 log(`watcher onChange error: ${err.message}`);
             }
         }, debounceMs);
+        debounceTimer.unref?.();
     };
     // Attempt recursive native fs.watch first
     try {
@@ -61,6 +62,11 @@ export function createFileWatcher(dbPath, onChange, options = {}) {
         fsWatcher.on('error', (err) => {
             log(`Native watcher error (${err.message}), continuing.`);
         });
+        // unref() lets the event loop exit even if the watcher is still active.
+        // Without this, on Node 18/Linux the inotify handle keeps the process
+        // alive indefinitely after all tests finish (or after close() is called
+        // but the handle hasn't been fully released by the kernel yet).
+        fsWatcher.unref?.();
         return {
             isNative: true,
             close: () => {
@@ -80,13 +86,14 @@ export function createFileWatcher(dbPath, onChange, options = {}) {
         let lastMtime = 0;
         const getDirMtime = (dir) => {
             try {
-                const stat = fs.statSync(dir);
-                let max = stat.mtimeMs;
+                let max = 0;
                 const entries = fs.readdirSync(dir, { withFileTypes: true });
                 for (const entry of entries) {
                     if (entry.name.startsWith('.') || entry.name === '.mdss')
                         continue;
                     const full = path.join(dir, entry.name);
+                    if (shouldIgnore(entry.name))
+                        continue;
                     if (entry.isDirectory()) {
                         const sub = getDirMtime(full);
                         if (sub > max)
@@ -117,6 +124,7 @@ export function createFileWatcher(dbPath, onChange, options = {}) {
                 scheduleChange();
             }
         }, fallbackIntervalMs);
+        pollInterval.unref?.();
         return {
             isNative: false,
             close: () => {

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "md-semantic-search",
-  "version": "1.0.1",
+  "version": "1.0.2",
   "description": "Local, private semantic (vector) search over any folder of Markdown files. Finds passages by meaning — cross-lingual — using transformers.js. No API keys, no cloud, no vector database.",
   "type": "module",
   "main": "./dist/index.js",

package/src/core.ts

@@ -436,6 +436,9 @@ export function assertSafePath(targetPath: string, allowedRoots?: string[]): str
   if (targetPath.startsWith('\\\\') || targetPath.startsWith('//')) {
     throw new Error('Forbidden path: UNC network paths not allowed');
   }
+  if (/^[a-zA-Z]:[\\/]/.test(targetPath) && process.platform !== 'win32') {
+    throw new Error('Forbidden path: Windows drive paths not allowed on non-Windows systems');
+  }
   const resolved = path.resolve(targetPath);
   let canonical = resolved;
   try {

package/src/serve.ts

@@ -92,14 +92,20 @@ export async function createServe(opts: CreateServeOptions): Promise<{
     healthPublic,
   };
 
+  const sockets = new Set<import('node:net').Socket>();
   const server = http.createServer((req, res) => {
     handleRequest(req, res, state).catch((e) => {
       json(res, 500, { error: e.message });
     });
   });
+  server.on('connection', (socket) => {
+    sockets.add(socket);
+    socket.on('close', () => sockets.delete(socket));
+  });
 
   let stopped = false;
   let timer: NodeJS.Timeout | null = null;
+  let resolveTimer: (() => void) | null = null;
 
   const reload = async () => {
     if (!db) return false;
@@ -199,8 +205,14 @@ export async function createServe(opts: CreateServeOptions): Promise<{
     let lastChangeAt = 0;
     let pending = false;
     while (!stopped) {
-      await new Promise((r) => {
-        timer = setTimeout(r, watchInterval);
+      await new Promise<void>((r) => {
+        resolveTimer = r;
+        timer = setTimeout(() => {
+          timer = null;
+          resolveTimer = null;
+          r();
+        }, watchInterval);
+        timer.unref?.();
       });
       if (stopped) return;
       const tree = scanTree();
@@ -248,13 +260,22 @@ export async function createServe(opts: CreateServeOptions): Promise<{
 
   const close = async (): Promise<void> => {
     stopped = true;
-    if (timer) clearTimeout(timer);
+    if (timer) {
+      clearTimeout(timer);
+      timer = null;
+    }
+    if (resolveTimer) {
+      resolveTimer();
+      resolveTimer = null;
+    }
     if (nativeWatcher) nativeWatcher.close();
-    // closeAllConnections() forcibly closes keep-alive sockets so server.close()
-    // doesn't hang indefinitely waiting for them — critical on Node 18 where the
-    // HTTP server does NOT auto-drain idle connections before calling back.
-    // The method was back-ported to Node 18.2.0 and is always present in CI.
     server.closeAllConnections?.();
+    for (const socket of sockets) {
+      try {
+        socket.destroy();
+      } catch {}
+    }
+    sockets.clear();
     await new Promise<void>((resolve, reject) => server.close((err) => (err ? reject(err) : resolve())));
   };
 

package/src/watcher.ts

@@ -29,7 +29,7 @@ export function createFileWatcher(
     debounceMs = 250,
     ignore = [],
     log = () => {},
-    fallbackIntervalMs = 1000,
+    fallbackIntervalMs = 50,
   } = options;
 
   let closed = false;
@@ -68,6 +68,7 @@ export function createFileWatcher(
         log(`watcher onChange error: ${err.message}`);
       }
     }, debounceMs);
+    debounceTimer.unref?.();
   };
 
   // Attempt recursive native fs.watch first
@@ -88,6 +89,12 @@ export function createFileWatcher(
       log(`Native watcher error (${err.message}), continuing.`);
     });
 
+    // unref() lets the event loop exit even if the watcher is still active.
+    // Without this, on Node 18/Linux the inotify handle keeps the process
+    // alive indefinitely after all tests finish (or after close() is called
+    // but the handle hasn't been fully released by the kernel yet).
+    fsWatcher.unref?.();
+
     return {
       isNative: true,
       close: () => {
@@ -105,12 +112,12 @@ export function createFileWatcher(
     let lastMtime = 0;
     const getDirMtime = (dir: string): number => {
       try {
-        const stat = fs.statSync(dir);
-        let max = stat.mtimeMs;
+        let max = 0;
         const entries = fs.readdirSync(dir, { withFileTypes: true });
         for (const entry of entries) {
           if (entry.name.startsWith('.') || entry.name === '.mdss') continue;
           const full = path.join(dir, entry.name);
+          if (shouldIgnore(entry.name)) continue;
           if (entry.isDirectory()) {
             const sub = getDirMtime(full);
             if (sub > max) max = sub;
@@ -136,6 +143,7 @@ export function createFileWatcher(
         scheduleChange();
       }
     }, fallbackIntervalMs);
+    pollInterval.unref?.();
 
     return {
       isNative: false,