neuralos 3.4.0 → 3.4.1

package/bin/gybackend.cjs

@@ -258528,6 +258528,81 @@ var init_HistorySqliteStore = __esm({
           });
         })();
       }
+      /**
+       * v3.4.1: append only the NEW messages for a session instead of rewriting
+       * the whole session. saveUiSessions() deletes every row and re-inserts the
+       * entire message list — on a long session that is a large synchronous
+       * better-sqlite3 transaction on the main event loop, which is the
+       * spinning-wheel freeze. This method appends from a given position in one
+       * small transaction, so a debounced flush costs O(new messages), not
+       * O(all messages).
+       *
+       * Returns the number of rows appended.
+       */
+      appendUiSessionMessages(sessionId, messages, fromPosition, summary) {
+        if (messages.length === 0 || fromPosition >= messages.length) {
+          return 0;
+        }
+        const upsertSession = this.db.prepare(
+          `INSERT INTO ui_sessions (
+         id, title, updated_at, messages_count, last_message_preview
+       ) VALUES (
+         @id, @title, @updatedAt, @messagesCount, @lastMessagePreview
+       )
+       ON CONFLICT(id) DO UPDATE SET
+         title = excluded.title,
+         updated_at = excluded.updated_at,
+         messages_count = excluded.messages_count,
+         last_message_preview = excluded.last_message_preview`
+        );
+        const insertMessage = this.db.prepare(
+          `INSERT INTO ui_session_messages (
+         session_id, position, ui_message_id, backend_message_id, role, message_type, content, metadata_json, timestamp, streaming
+       ) VALUES (?, ?, ?, ?, ?, ?, ?, ?, ?, ?)`
+        );
+        const slice = messages.slice(fromPosition);
+        this.db.transaction(() => {
+          if (summary) {
+            upsertSession.run({
+              id: sessionId,
+              title: summary.title,
+              updatedAt: summary.updatedAt,
+              messagesCount: summary.messagesCount,
+              lastMessagePreview: summary.lastMessagePreview
+            });
+          } else {
+            const existing = this.db.prepare("SELECT title, updated_at FROM ui_sessions WHERE id = ?").get(sessionId);
+            upsertSession.run({
+              id: sessionId,
+              title: existing?.title ?? "New Chat",
+              updatedAt: Date.now(),
+              messagesCount: (existing ? 0 : 0) + fromPosition + slice.length,
+              lastMessagePreview: slice[slice.length - 1]?.content?.slice(0, 200) ?? ""
+            });
+          }
+          for (let i = 0; i < slice.length; i++) {
+            const message = slice[i];
+            insertMessage.run(
+              sessionId,
+              fromPosition + i,
+              message.id,
+              message.backendMessageId ?? null,
+              message.role,
+              message.type,
+              message.content,
+              message.metadata ? JSON.stringify(message.metadata) : null,
+              message.timestamp,
+              message.streaming ? 1 : 0
+            );
+          }
+        })();
+        return slice.length;
+      }
+      /** v3.4.1: how many messages are already persisted for a session. */
+      countUiSessionMessages(sessionId) {
+        const row = this.db.prepare("SELECT COUNT(*) AS n FROM ui_session_messages WHERE session_id = ?").get(sessionId);
+        return row?.n ?? 0;
+      }
       deleteUiSessions(sessionIds) {
         const ids = Array.from(
           new Set(sessionIds.filter((id) => id.trim().length > 0))
@@ -373404,16 +373479,84 @@ function buildUiSessionSummary(session) {
 }
 
 // ../../packages/backend/src/services/UIHistoryService.ts
-var UIHistoryService = class {
+var UIHistoryService = class _UIHistoryService {
   store;
   sessionsCache = {};
   sessionSummaryCache = {};
   dirtySessions = /* @__PURE__ */ new Set();
+  /**
+   * v3.4.1: debounced auto-flush. Previously recordEvent() marked a session
+   * dirty but NEVER flushed — messages reached SQLite only on rename /
+   * rollback / branch or a graceful app close. Kill the process mid-run
+   * (freeze, crash, force-quit) and every message since the last flush was
+   * lost. That is the "work done, no record" bug.
+   *
+   * Now: flush within FLUSH_DEBOUNCE_MS of the last event, plus a synchronous
+   * flush on beforeExit / SIGINT / SIGTERM.
+   */
+  flushTimer = null;
+  shutdownHooksInstalled = false;
+  /** v3.4.1: messages already written to SQLite per session, so flush()
+   *  appends only the new ones instead of rewriting the whole session. */
+  persistedMessageCount = /* @__PURE__ */ new Map();
+  /** Flush debounce window — short enough to survive a crash, long enough
+   *  to batch a streaming burst into one write. */
+  static FLUSH_DEBOUNCE_MS = 1500;
   constructor(options) {
     this.store = options?.store || new HistorySqliteStore();
     this.sessionSummaryCache = this.buildSessionSummaryCache(
       this.store.listUiSessionSummaries()
     );
+    this.installShutdownHooks();
+  }
+  installShutdownHooks() {
+    if (this.shutdownHooksInstalled) return;
+    this.shutdownHooksInstalled = true;
+    const flushNow = () => {
+      try {
+        this.flush();
+      } catch {
+      }
+    };
+    process.once("beforeExit", flushNow);
+    for (const sig of ["SIGINT", "SIGTERM"]) {
+      if (!_UIHistoryService.activeFlushOnSignal.has(sig)) {
+        _UIHistoryService.activeFlushOnSignal.add(sig);
+        const hadListeners = process.listenerCount(sig) > 0;
+        process.once(sig, () => {
+          for (const svc of _UIHistoryService.instances) {
+            try {
+              svc.flush();
+            } catch {
+            }
+          }
+          _UIHistoryService.activeFlushOnSignal.delete(sig);
+          if (!hadListeners) {
+            process.kill(process.pid, sig);
+          }
+        });
+      }
+    }
+    _UIHistoryService.instances.add(this);
+  }
+  /** Live instances — the shared signal handler flushes all of them. */
+  static instances = /* @__PURE__ */ new Set();
+  static activeFlushOnSignal = /* @__PURE__ */ new Set();
+  scheduleFlush() {
+    if (this.flushTimer) {
+      clearTimeout(this.flushTimer);
+    }
+    this.flushTimer = setTimeout(() => {
+      this.flushTimer = null;
+      try {
+        this.flush();
+      } catch (error40) {
+        console.error("[UIHistory] auto-flush failed:", error40);
+      }
+    }, _UIHistoryService.FLUSH_DEBOUNCE_MS);
+    if (typeof this.flushTimer.unref === "function") {
+      this.flushTimer.unref();
+    }
   }
   buildSessionSummaryCache(summaries) {
     const cache2 = {};
@@ -373433,6 +373576,9 @@ var UIHistoryService = class {
     }
     const sanitized = sanitizeUiSession(loaded);
     this.sessionsCache[sessionId] = sanitized;
+    if (!this.persistedMessageCount.has(sessionId)) {
+      this.persistedMessageCount.set(sessionId, sanitized.messages.length);
+    }
     this.syncSessionSummary(sessionId);
     return sanitized;
   }
@@ -373459,6 +373605,7 @@ var UIHistoryService = class {
     const actions = this.processEvent(session, event, sessionId);
     this.syncSessionSummary(sessionId);
     this.dirtySessions.add(sessionId);
+    this.scheduleFlush();
     return actions;
   }
   flush(sessionId) {
@@ -373467,6 +373614,7 @@ var UIHistoryService = class {
       return;
     }
     const entries = [];
+    const appendFrom = {};
     sessionIds.forEach((id) => {
       const session = this.sessionsCache[id];
       if (!session) {
@@ -373478,9 +373626,34 @@ var UIHistoryService = class {
       const summary = buildUiSessionSummary(sanitized);
       this.sessionSummaryCache[id] = summary;
       entries.push({ session: sanitized, summary });
+      const already = this.persistedMessageCount.get(id);
+      appendFrom[id] = typeof already === "number" && already <= sanitized.messages.length ? already : 0;
     });
     if (entries.length > 0) {
-      this.store.saveUiSessions(entries);
+      let usedIncremental = false;
+      try {
+        let appended = 0;
+        for (const { session, summary } of entries) {
+          const from = appendFrom[session.id] ?? 0;
+          const n2 = this.store.appendUiSessionMessages(
+            session.id,
+            session.messages,
+            from,
+            summary
+          );
+          appended += n2;
+          this.persistedMessageCount.set(session.id, session.messages.length);
+        }
+        usedIncremental = true;
+      } catch {
+        usedIncremental = false;
+      }
+      if (!usedIncremental) {
+        this.store.saveUiSessions(entries);
+        entries.forEach(
+          ({ session }) => this.persistedMessageCount.set(session.id, session.messages.length)
+        );
+      }
     }
     sessionIds.forEach((id) => this.dirtySessions.delete(id));
   }
@@ -373993,6 +374166,7 @@ Error: ${event.message}` : ""),
       delete this.sessionsCache[id];
       delete this.sessionSummaryCache[id];
       this.dirtySessions.delete(id);
+      this.persistedMessageCount.delete(id);
     });
     this.store.deleteUiSessions(ids);
   }
@@ -374031,6 +374205,7 @@ Error: ${event.message}` : ""),
     );
     this.syncSessionSummary(sessionId);
     this.dirtySessions.add(sessionId);
+    this.persistedMessageCount.delete(sessionId);
     this.flush(sessionId);
     return removedCount;
   }

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "neuralos",
-  "version": "3.4.0",
+  "version": "3.4.1",
   "description": "AI-native terminal & agentic-AI operations platform for Forward Deployed Engineers & SREs: AIOps closed-loop remediation, AI SRE, self-healing infrastructure, runbook automation, ChatOps; executes over SSH/WinRM/serial under policy with tamper-evident audit.",
   "keywords": [
     "forward-deployed-engineer",