instar 0.23.9 → 0.23.11

package/dist/commands/server.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"server.d.ts","sourceRoot":"","sources":["../../src/commands/server.ts"],"names":[],"mappings":"AAAA;;;;;;;;GAQG;AAwPH,UAAU,YAAY;IACpB,UAAU,CAAC,EAAE,OAAO,CAAC;IACrB,GAAG,CAAC,EAAE,MAAM,CAAC;IACb;2DACuD;IACvD,QAAQ,CAAC,EAAE,OAAO,CAAC;CACpB;AA8gCD,wBAAsB,WAAW,CAAC,OAAO,EAAE,YAAY,GAAG,OAAO,CAAC,IAAI,CAAC,CAy1EtE;AAED,wBAAsB,UAAU,CAAC,OAAO,EAAE;IAAE,GAAG,CAAC,EAAE,MAAM,CAAA;CAAE,GAAG,OAAO,CAAC,IAAI,CAAC,CAsDzE;AAED;;;;;;;;;;;GAWG;AACH,wBAAsB,aAAa,CAAC,OAAO,EAAE;IAAE,GAAG,CAAC,EAAE,MAAM,CAAA;CAAE,GAAG,OAAO,CAAC,IAAI,CAAC,CAuD5E"}
+{"version":3,"file":"server.d.ts","sourceRoot":"","sources":["../../src/commands/server.ts"],"names":[],"mappings":"AAAA;;;;;;;;GAQG;AAwPH,UAAU,YAAY;IACpB,UAAU,CAAC,EAAE,OAAO,CAAC;IACrB,GAAG,CAAC,EAAE,MAAM,CAAC;IACb;2DACuD;IACvD,QAAQ,CAAC,EAAE,OAAO,CAAC;CACpB;AAiiCD,wBAAsB,WAAW,CAAC,OAAO,EAAE,YAAY,GAAG,OAAO,CAAC,IAAI,CAAC,CAk3EtE;AAED,wBAAsB,UAAU,CAAC,OAAO,EAAE;IAAE,GAAG,CAAC,EAAE,MAAM,CAAA;CAAE,GAAG,OAAO,CAAC,IAAI,CAAC,CAsDzE;AAED;;;;;;;;;;;GAWG;AACH,wBAAsB,aAAa,CAAC,OAAO,EAAE;IAAE,GAAG,CAAC,EAAE,MAAM,CAAA;CAAE,GAAG,OAAO,CAAC,IAAI,CAAC,CAuD5E"}

package/dist/commands/server.js

@@ -1006,15 +1006,22 @@ async function ensureAgentUpdatesTopic(telegram, state) {
  */
 async function ensureSqliteBindings() {
     try {
-        await import('better-sqlite3');
-        // Bindings loaded OK — nothing to do.
+        const BetterSqlite3 = (await import('better-sqlite3')).default;
+        // Import alone doesn't catch all mismatches — some NODE_MODULE_VERSION
+        // conflicts cause runtime crashes (C++ mutex errors) rather than import errors.
+        // Actually opening an in-memory DB exercises the native bindings fully.
+        const testDb = new BetterSqlite3(':memory:');
+        testDb.pragma('journal_mode = WAL');
+        testDb.close();
         return false;
     }
     catch (err) {
         const reason = err instanceof Error ? err.message : String(err);
         const isBindingError = reason.includes('Could not locate the bindings file') ||
             reason.includes('better-sqlite3') ||
-            reason.includes('was compiled against a different Node.js version');
+            reason.includes('was compiled against a different Node.js version') ||
+            reason.includes('NODE_MODULE_VERSION') ||
+            reason.includes('mutex lock failed');
         if (!isBindingError)
             return false; // Not a binding issue — let subsystems handle it.
         console.log(pc.yellow('  better-sqlite3: native binding mismatch detected — auto-rebuilding for current Node.js version...'));
@@ -1026,14 +1033,27 @@ async function ensureSqliteBindings() {
                 execFileSync(process.execPath, [fixScript], { encoding: 'utf-8', timeout: 60000, stdio: 'pipe' });
             }
             else {
-                // Fallback: npm rebuild (may fail in pnpm/asdf environments)
-                const globalInstarDir = execSync('npm root -g', { encoding: 'utf-8', timeout: 10000 }).trim() + '/instar';
-                execSync('npm rebuild better-sqlite3', {
-                    cwd: globalInstarDir,
-                    encoding: 'utf-8',
-                    timeout: 60000,
-                    stdio: 'pipe',
-                });
+                // Fallback: npm rebuild in the directory containing better-sqlite3.
+                // Shadow installs have their own node_modules — try that first, then global.
+                const instarDir = new URL('../../..', import.meta.url).pathname;
+                const shadowBs3 = path.join(instarDir, 'node_modules', 'better-sqlite3');
+                if (fs.existsSync(shadowBs3)) {
+                    execSync('npm rebuild better-sqlite3', {
+                        cwd: instarDir,
+                        encoding: 'utf-8',
+                        timeout: 60000,
+                        stdio: 'pipe',
+                    });
+                }
+                else {
+                    const globalInstarDir = execSync('npm root -g', { encoding: 'utf-8', timeout: 10000 }).trim() + '/instar';
+                    execSync('npm rebuild better-sqlite3', {
+                        cwd: globalInstarDir,
+                        encoding: 'utf-8',
+                        timeout: 60000,
+                        stdio: 'pipe',
+                    });
+                }
             }
             console.log(pc.green('  better-sqlite3: rebuilt successfully — restarting to apply (ESM module cache must be cleared).'));
             return true; // Restart needed — ESM cache holds the stale failure
@@ -2511,6 +2531,15 @@ export async function startServer(options) {
         const sleepWakeDetector = new SleepWakeDetector();
         sleepWakeDetector.on('wake', async (event) => {
             console.log(`[SleepWake] Wake detected after ~${event.sleepDurationSeconds}s sleep`);
+            // Checkpoint SQLite WAL files to flush stale locks from pre-sleep connections
+            try {
+                topicMemory?.checkpoint();
+            }
+            catch { /* non-critical */ }
+            try {
+                semanticMemory?.checkpoint();
+            }
+            catch { /* non-critical */ }
             // Re-validate tmux sessions
             try {
                 const tmuxPath = detectTmuxPath();
@@ -2523,17 +2552,24 @@ export async function startServer(options) {
             catch {
                 console.warn('[SleepWake] tmux check failed after wake');
             }
-            // Restart tunnel if configured
+            // Restart tunnel if configured — use forceStop to handle zombie cloudflared
+            // processes that may be hung after sleep. Race with a 15s overall timeout
+            // to prevent the wake handler itself from blocking indefinitely.
             if (tunnel) {
                 try {
-                    await tunnel.stop();
-                    const tunnelUrl = await tunnel.start();
-                    console.log(`[SleepWake] Tunnel restarted: ${tunnelUrl}`);
-                    // Re-broadcast dashboard URL after tunnel restart (quick tunnels get new URL)
-                    if (telegram && tunnelUrl) {
-                        const tunnelType = config.tunnel?.type || 'quick';
-                        await telegram.broadcastDashboardUrl(tunnelUrl, tunnelType).catch(() => { });
-                    }
+                    await Promise.race([
+                        (async () => {
+                            await tunnel.forceStop(5000);
+                            const tunnelUrl = await tunnel.start();
+                            console.log(`[SleepWake] Tunnel restarted: ${tunnelUrl}`);
+                            // Re-broadcast dashboard URL after tunnel restart (quick tunnels get new URL)
+                            if (telegram && tunnelUrl) {
+                                const tunnelType = config.tunnel?.type || 'quick';
+                                await telegram.broadcastDashboardUrl(tunnelUrl, tunnelType).catch(() => { });
+                            }
+                        })(),
+                        new Promise((_, reject) => setTimeout(() => reject(new Error('Tunnel restart timed out after 15s')), 15_000)),
+                    ]);
                 }
                 catch (err) {
                     console.error(`[SleepWake] Tunnel restart failed:`, err);
@@ -3109,6 +3145,7 @@ export async function startServer(options) {
         }
         // Start tunnel AFTER server is listening (with retry on failure)
         if (tunnel) {
+            tunnel.enableAutoReconnect();
             const maxRetries = 5;
             let tunnelStarted = false;
             for (let attempt = 1; attempt <= maxRetries; attempt++) {
@@ -3319,6 +3356,22 @@ export async function startServer(options) {
         };
         process.on('SIGINT', shutdown);
         process.on('SIGTERM', shutdown);
+        // Last-resort SQLite cleanup — if the process crashes from an uncaught exception
+        // (e.g., cloudflared crash cascade during sleep/wake), close databases to prevent
+        // the "mutex lock failed" error on next start. This doesn't prevent the crash,
+        // but ensures the next boot is clean.
+        process.on('uncaughtException', (err) => {
+            console.error('[FATAL] Uncaught exception — closing databases before crash:', err.message);
+            try {
+                topicMemory?.close();
+            }
+            catch { /* best effort */ }
+            try {
+                semanticMemory?.close();
+            }
+            catch { /* best effort */ }
+            process.exit(1);
+        });
         // Wire the ForegroundRestartWatcher to the graceful shutdown function.
         // This ensures auto-update restarts close all resources (especially SQLite
         // databases) before exiting, preventing the "mutex lock failed" crash.