@jhizzard/termdeck 0.3.1 → 0.3.2

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@jhizzard/termdeck",
-  "version": "0.3.1",
+  "version": "0.3.2",
   "description": "Browser-based terminal multiplexer with metadata overlays, panel flashback memory recall, and AI-aware session management",
   "bin": {
     "termdeck": "./packages/cli/src/index.js"

package/packages/client/public/app.js

@@ -2403,29 +2403,43 @@
       document.getElementById('healthBadgeLabel').textContent = 'Health: offline';
     }
 
+    // Tier 2/3 checks only shown when the user has configured those tiers.
+    // Without DATABASE_URL, mnestra/rumen/database checks are irrelevant noise.
+    const TIER1_CHECKS = new Set(['project_paths', 'shell_sanity']);
+    const TIER23_CHECKS = new Set(['mnestra_reachable', 'mnestra_has_memories', 'rumen_recent', 'database_url']);
+
+    function filterChecksByTier(checks) {
+      const hasDb = checks.some(c => c.name === 'database_url' && c.passed);
+      if (hasDb) return checks; // full stack configured — show everything
+      // No DATABASE_URL: only show Tier 1 checks
+      return checks.filter(c => TIER1_CHECKS.has(c.name));
+    }
+
     function renderHealthBadge(data) {
       const badge = document.getElementById('healthBadge');
       if (!badge) return;
       badge.style.display = '';
 
-      const checks = data.checks || [];
+      const allChecks = data.checks || [];
+      const checks = filterChecksByTier(allChecks);
       const total = checks.length;
-      const passed = checks.filter(c => c.ok).length;
+      const passed = checks.filter(c => c.passed).length;
       const allOk = passed === total && total > 0;
+      const tierLabel = total < allChecks.length ? 'Tier 1' : 'Stack';
 
       if (allOk) {
         badge.className = 'health-badge hb-green';
-        document.getElementById('healthBadgeLabel').textContent = 'Stack: OK';
+        document.getElementById('healthBadgeLabel').textContent = `${tierLabel}: OK`;
       } else if (total === 0) {
         badge.className = 'health-badge hb-amber';
         document.getElementById('healthBadgeLabel').textContent = 'Stack: ?';
       } else {
         badge.className = 'health-badge hb-red';
-        document.getElementById('healthBadgeLabel').textContent = `Stack: ${passed}/${total}`;
+        document.getElementById('healthBadgeLabel').textContent = `${tierLabel}: ${passed}/${total}`;
       }
 
-      // Update dropdown content
-      renderHealthDropdown(data);
+      // Update dropdown content — pass filtered checks
+      renderHealthDropdown({ ...data, checks });
     }
 
     function renderHealthDropdown(data) {
@@ -2439,16 +2453,16 @@
 
       let html = '';
       for (const check of checks) {
-        const icon = check.ok ? '✓' : '✗';
-        const cls = check.ok ? 'hd-ok' : 'hd-fail';
+        const icon = check.passed ? '✓' : '✗';
+        const cls = check.passed ? 'hd-ok' : 'hd-fail';
         const name = check.name || 'Unknown';
         const detail = check.detail || '';
-        const remediation = check.ok ? '' : (check.remediation ? `<div class="hd-remediation">${escapeHtml(check.remediation)}</div>` : '');
+        const remediation = check.passed ? '' : (check.remediation ? `<div class="hd-remediation">${escapeHtml(check.remediation)}</div>` : '');
         html += `<div class="hd-check ${cls}">
           <span class="hd-icon">${icon}</span>
           <span class="hd-name">${escapeHtml(name)}</span>
           <span class="hd-dots"></span>
-          <span class="hd-status">${check.ok ? 'OK' : 'FAIL'}</span>
+          <span class="hd-status">${check.passed ? 'OK' : 'FAIL'}</span>
           <span class="hd-detail">${escapeHtml(detail)}</span>
           ${remediation}
         </div>`;

package/packages/server/src/index.js

@@ -484,14 +484,14 @@ function createServer(config) {
   // GET /api/transcripts/search - FTS across all sessions
   // (Must be registered before :sessionId to avoid route collision)
   app.get('/api/transcripts/search', async (req, res) => {
-    if (!transcriptWriter) return res.json([]);
+    if (!transcriptWriter) return res.json({ results: [] });
     const q = req.query.q;
     if (!q) return res.status(400).json({ error: 'Missing q parameter' });
     const since = req.query.since || null;
     const limit = Math.min(Math.max(parseInt(req.query.limit) || 50, 1), 200);
     try {
       const results = await transcriptWriter.search(q, { since, limit });
-      res.json(results);
+      res.json({ results });
     } catch (err) {
       console.error('[transcript] search endpoint error:', err.message);
       res.status(500).json({ error: 'Transcript search failed' });
@@ -499,13 +499,24 @@ function createServer(config) {
   });
 
   // GET /api/transcripts/recent - time-windowed crash recovery
+  // Returns { sessions: [ { session_id, chunks: [...] }, ... ] }
   app.get('/api/transcripts/recent', async (req, res) => {
-    if (!transcriptWriter) return res.json([]);
+    if (!transcriptWriter) return res.json({ sessions: [] });
     const minutes = Math.min(Math.max(parseInt(req.query.minutes) || 60, 1), 1440);
     const limit = Math.min(Math.max(parseInt(req.query.limit) || 500, 1), 2000);
     try {
-      const results = await transcriptWriter.getRecent(minutes, limit);
-      res.json(results);
+      const rows = await transcriptWriter.getRecent(minutes, limit);
+      // Group by session_id for client consumption
+      const grouped = new Map();
+      for (const row of rows) {
+        if (!grouped.has(row.session_id)) grouped.set(row.session_id, []);
+        grouped.get(row.session_id).push(row);
+      }
+      const sessions = [];
+      for (const [session_id, chunks] of grouped) {
+        sessions.push({ session_id, chunks });
+      }
+      res.json({ sessions });
     } catch (err) {
       console.error('[transcript] recent endpoint error:', err.message);
       res.status(500).json({ error: 'Transcript recent query failed' });
@@ -513,13 +524,16 @@ function createServer(config) {
   });
 
   // GET /api/transcripts/:sessionId - ordered chunks for a session
+  // Returns { content: string } (joined transcript text)
   app.get('/api/transcripts/:sessionId', async (req, res) => {
-    if (!transcriptWriter) return res.json([]);
+    if (!transcriptWriter) return res.json({ content: '', lines: [] });
     const limit = req.query.limit ? Math.min(Math.max(parseInt(req.query.limit), 1), 5000) : undefined;
     const since = req.query.since || undefined;
     try {
       const chunks = await transcriptWriter.getSessionTranscript(req.params.sessionId, { limit, since });
-      res.json(chunks);
+      const lines = chunks.map(c => c.content);
+      const content = lines.join('');
+      res.json({ content, lines, chunks });
     } catch (err) {
       console.error('[transcript] session transcript endpoint error:', err.message);
       res.status(500).json({ error: 'Transcript retrieval failed' });

package/packages/server/src/rag.js

@@ -165,8 +165,8 @@ class RAGIntegration {
       // Success — reset any accumulated 404 count for this table
       this._resetCircuit(table);
     } catch (err) {
-      // Will be retried by sync loop
       console.error('[mnestra] Push failed:', err.message);
+      throw err; // Propagate to caller so sync loop knows this event failed
     }
   }
 

package/packages/server/src/transcripts.js

@@ -28,6 +28,7 @@ class TranscriptWriter {
     this._databaseUrl = databaseUrl;
     this._batchSize = options.batchSize || 50;
     this._flushIntervalMs = options.flushIntervalMs || 2000;
+    this._maxBufferSize = options.maxBufferSize || 10000;
     this._enabled = options.enabled !== false;
 
     // Per-session monotonic chunk counters
@@ -91,6 +92,11 @@ class TranscriptWriter {
     const idx = this._counters.get(sessionId) || 0;
     this._counters.set(sessionId, idx + 1);
 
+    // Cap buffer to prevent unbounded growth during sustained DB failures
+    if (this._buffer.length >= this._maxBufferSize) {
+      this._buffer.splice(0, this._buffer.length - this._maxBufferSize + 1);
+    }
+
     this._buffer.push({
       sessionId,
       content: stripped,