@threadbase-sh/scanner 0.9.0 → 0.9.2

package/dist/index.cjs

@@ -1361,7 +1361,7 @@ var import_fs7 = require("fs");
 var import_path6 = require("path");
 
 // src/persistent/schema.ts
-var SCHEMA_VERSION = 3;
+var SCHEMA_VERSION = 4;
 var SCHEMA_SQL = `
 CREATE TABLE IF NOT EXISTS conversation_files (
   id INTEGER PRIMARY KEY AUTOINCREMENT,
@@ -2528,10 +2528,21 @@ var ConversationScanner = class {
   dbPath;
   sidecarEnabled;
   engineInstance = null;
+  // The most recent scan()'s promise while it is still running, or null when
+  // idle. close() awaits it before closing the SQLite handle so a fire-and-
+  // forget scan can't have its DB shut mid-indexAll ("database connection is
+  // not open"). Tracks the latest scan only — concurrent scans on one instance
+  // aren't a supported pattern (a single writer DB), and the latest resolving
+  // implies earlier ones already settled in practice.
+  inFlightScan = null;
   emitter = new import_events.EventEmitter();
   watcher = null;
   queue = null;
   periodicTimer = null;
+  // The in-flight periodicReconcile() job, if one is mid-run. unwatch() awaits
+  // it before dropping the queue/engine so its post-await engine.files access
+  // can't hit a closed DB (the watch-mode half of Bug #4).
+  inFlightReconcile = null;
   constructor(options) {
     this.conversationLRU = new LRUCache(options?.conversationCacheSize ?? 5);
     if (options?.persistent === false) {
@@ -2554,14 +2565,31 @@ var ConversationScanner = class {
     return this.engineInstance;
   }
   // Release the SQLite connection. No-op in legacy mode. Safe to call
-  // repeatedly. Stops the watcher first if one is running; call unwatch()
-  // explicitly beforehand if you need to await watcher teardown.
-  close() {
-    if (this.watcher || this.queue || this.periodicTimer) void this.unwatch();
+  // repeatedly. Awaits watcher teardown AND any in-flight scan before closing
+  // the DB handle, so a fire-and-forget scan() can never have its connection
+  // shut mid-indexAll() ("database connection is not open"). This is why close()
+  // is async — callers should await it during shutdown. (Scanner review Bug #4.)
+  async close() {
+    if (this.watcher || this.queue || this.periodicTimer) await this.unwatch();
+    if (this.inFlightScan) {
+      try {
+        await this.inFlightScan;
+      } catch {
+      }
+    }
     this.engineInstance?.close();
     this.engineInstance = null;
   }
   async scan(options = {}) {
+    const promise = this.runScan(options);
+    this.inFlightScan = promise;
+    try {
+      return await promise;
+    } finally {
+      if (this.inFlightScan === promise) this.inFlightScan = null;
+    }
+  }
+  async runScan(options) {
     const profiles = await this.resolveProfiles(options.profiles);
     const activeProfiles = profiles.filter((p) => p.enabled && p.scanHistory !== false);
     this.lastTier = resolveTier(options.tier ?? "standard", options.tiers);
@@ -2997,7 +3025,10 @@ var ConversationScanner = class {
     const periodicMs = options.periodicMs ?? 6e4;
     if (periodicMs > 0) {
       this.periodicTimer = setInterval(() => {
-        void this.periodicReconcile(activeProfiles);
+        const job = this.periodicReconcile(activeProfiles).finally(() => {
+          if (this.inFlightReconcile === job) this.inFlightReconcile = null;
+        });
+        this.inFlightReconcile = job;
       }, periodicMs);
       this.periodicTimer.unref?.();
     }
@@ -3041,6 +3072,9 @@ var ConversationScanner = class {
       clearInterval(this.periodicTimer);
       this.periodicTimer = null;
     }
+    if (this.inFlightReconcile) {
+      await this.inFlightReconcile;
+    }
     if (this.watcher) {
       await this.watcher.stop();
       this.watcher = null;