instar 0.24.5 → 0.24.7

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;AAskCD,wBAAsB,WAAW,CAAC,OAAO,EAAE,YAAY,GAAG,OAAO,CAAC,IAAI,CAAC,CA2qFtE;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;AAyPH,UAAU,YAAY;IACpB,UAAU,CAAC,EAAE,OAAO,CAAC;IACrB,GAAG,CAAC,EAAE,MAAM,CAAC;IACb;2DACuD;IACvD,QAAQ,CAAC,EAAE,OAAO,CAAC;CACpB;AAskCD,wBAAsB,WAAW,CAAC,OAAO,EAAE,YAAY,GAAG,OAAO,CAAC,IAAI,CAAC,CAqvFtE;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

@@ -48,6 +48,7 @@ import { SessionWatchdog } from '../monitoring/SessionWatchdog.js';
 import { StallTriageNurse } from '../monitoring/StallTriageNurse.js';
 import { TriageOrchestrator } from '../monitoring/TriageOrchestrator.js';
 import { SessionMonitor } from '../monitoring/SessionMonitor.js';
+import { SessionRecovery } from '../monitoring/SessionRecovery.js';
 import { MultiMachineCoordinator } from '../core/MultiMachineCoordinator.js';
 import { GitSyncManager } from '../core/GitSync.js';
 import { ProjectMapper } from '../core/ProjectMapper.js';
@@ -1719,6 +1720,29 @@ export async function startServer(options) {
                             return { interventionsTotal: 0, interventionsByLevel: {}, recoveries: 0, sessionDeaths: 0, llmGateOverrides: 0 };
                         return watchdog.getStats(sinceMs);
                     },
+                    // Session recovery stats — lazy getter (declared later in scope via `let`)
+                    getRecoveryStats: (_sinceMs) => {
+                        return { attempts: { stall: 0, crash: 0, errorLoop: 0 }, successes: { stall: 0, crash: 0, errorLoop: 0 } };
+                    },
+                    // Triage orchestrator stats — lazy getter (declared later in scope via `let`)
+                    getTriageStats: (_sinceMs) => {
+                        return { activations: 0, heuristicResolutions: 0, llmResolutions: 0, failures: 0, actionCounts: {} };
+                    },
+                    // Notification batcher stats — lazy getter
+                    getNotificationStats: () => {
+                        if (!notificationBatcher)
+                            return { flushed: 0, suppressed: 0, summaryQueueSize: 0, digestQueueSize: 0 };
+                        const s = notificationBatcher.getStats();
+                        return { flushed: s.totalFlushed, suppressed: s.totalSuppressed, summaryQueueSize: s.summaryQueueSize, digestQueueSize: s.digestQueueSize };
+                    },
+                    // Process staleness stats — lazy getter
+                    getStalenessStats: () => {
+                        const pi = ProcessIntegrity.getInstance();
+                        if (!pi)
+                            return { versionMismatch: false, driftCount: 0 };
+                        const drifts = staleGuard.checkAll();
+                        return { versionMismatch: pi.versionMismatch, driftCount: drifts.length };
+                    },
                 });
                 telemetryHeartbeat.setCollector(collector);
                 console.log(pc.green('  Baseline telemetry collector wired'));
@@ -2450,6 +2474,42 @@ export async function startServer(options) {
             };
             console.log(pc.green('  Triage Orchestrator enabled (replaces Stall Triage Nurse for stall detection)'));
         }
+        // SessionRecovery — fast mechanical recovery (JSONL analysis, no LLM)
+        let sessionRecovery;
+        if (telegram) {
+            sessionRecovery = new SessionRecovery({ enabled: true, projectDir: config.projectDir }, {
+                isSessionAlive: (name) => sessionManager.isSessionAlive(name),
+                getPanePid: (name) => {
+                    try {
+                        const tmux = detectTmuxPath();
+                        if (!tmux)
+                            return null;
+                        const pid = execFileSync(tmux, ['list-panes', '-t', `=${name}:`, '-F', '#{pane_pid}'], { encoding: 'utf-8', timeout: 5000 }).trim();
+                        return /^\d+$/.test(pid) ? parseInt(pid, 10) : null;
+                    }
+                    catch {
+                        return null;
+                    }
+                },
+                killSession: (name) => {
+                    try {
+                        const tmux = detectTmuxPath();
+                        if (!tmux)
+                            return;
+                        execFileSync(tmux, ['kill-session', '-t', `=${name}`], { encoding: 'utf-8' });
+                    }
+                    catch { /* may already be dead */ }
+                },
+                respawnSession: async (topicId, _sessionName, recoveryPrompt) => {
+                    const targetSession = telegram.getSessionForTopic(topicId);
+                    if (!targetSession)
+                        return;
+                    await respawnSessionForTopic(sessionManager, telegram, targetSession, topicId, undefined, topicMemory, undefined, recoveryPrompt, { silent: true });
+                },
+                sendToTopic: async (topicId, message) => { await telegram.sendToTopic(topicId, message); },
+            });
+            console.log(pc.green('  Session Recovery enabled (mechanical fast-path)'));
+        }
         // SessionMonitor — proactive session health monitoring
         let sessionMonitor;
         if (telegram) {
@@ -2478,6 +2538,7 @@ export async function startServer(options) {
                             return { resolved: result.resolved };
                         }
                         : undefined,
+                sessionRecovery,
             }, config.monitoring.sessionMonitor);
             sessionMonitor.start();
             console.log(pc.green('  Session Monitor enabled'));
@@ -2799,14 +2860,16 @@ export async function startServer(options) {
             catch {
                 console.warn('[SleepWake] tmux check failed after wake');
             }
-            // 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.
+            // Restart tunnel if configured — disable auto-reconnect first to prevent
+            // a cascade of competing reconnection attempts, then forceStop to handle
+            // zombie cloudflared processes that may be hung after sleep.
             if (tunnel) {
                 try {
                     await Promise.race([
                         (async () => {
+                            tunnel.disableAutoReconnect();
                             await tunnel.forceStop(5000);
+                            tunnel.enableAutoReconnect();
                             const tunnelUrl = await tunnel.start();
                             console.log(`[SleepWake] Tunnel restarted: ${tunnelUrl}`);
                             // Re-broadcast dashboard URL after tunnel restart (quick tunnels get new URL)
@@ -2820,6 +2883,8 @@ export async function startServer(options) {
                 }
                 catch (err) {
                     console.error(`[SleepWake] Tunnel restart failed:`, err);
+                    // Re-enable auto-reconnect even on failure so it can self-heal
+                    tunnel.enableAutoReconnect();
                 }
             }
             // Notify via batcher — wake events are informational, not urgent
@@ -3698,6 +3763,20 @@ export async function startServer(options) {
         // 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) => {
+            // Non-fatal HTTP errors — log and continue, don't crash the server.
+            // "Cannot set headers" is a double-response race condition (common during
+            // tunnel reconnect storms). The affected request is already handled; the
+            // server can keep serving new requests.
+            const nonFatalPatterns = [
+                'Cannot set headers after they are sent',
+                'write after end',
+                'ERR_HTTP_HEADERS_SENT',
+                'ERR_STREAM_WRITE_AFTER_END',
+            ];
+            if (nonFatalPatterns.some(p => err.message?.includes(p))) {
+                console.warn(`[WARN] Non-fatal uncaught exception (suppressed): ${err.message}`);
+                return; // Don't crash — the server is fine
+            }
             console.error('[FATAL] Uncaught exception — closing databases before crash:', err.message);
             try {
                 topicMemory?.close();