@jhizzard/termdeck 0.2.5 → 0.3.1

package/packages/server/src/index.js

@@ -10,15 +10,45 @@ const fs = require('fs');
 const { v4: uuidv4 } = require('uuid');
 
 // Conditional imports (graceful fallback if not installed yet)
-let pty, Database;
+let pty, Database, pg;
 try { pty = require('@homebridge/node-pty-prebuilt-multiarch'); } catch { pty = null; }
 try { Database = require('better-sqlite3'); } catch { Database = null; }
+try { pg = require('pg'); } catch { pg = null; }
+
+// Module-level singleton Postgres pool for rumen_insights (petvetbid DB).
+// Lazy-initialized on first rumen endpoint hit so startup stays fast and
+// servers without DATABASE_URL never pay the connection cost.
+let _rumenPool = null;
+let _rumenPoolFailed = false;
+const UUID_RE = /^[0-9a-f]{8}-[0-9a-f]{4}-[0-9a-f]{4}-[0-9a-f]{4}-[0-9a-f]{12}$/i;
+function getRumenPool() {
+  if (_rumenPool || _rumenPoolFailed) return _rumenPool;
+  if (!pg || !process.env.DATABASE_URL) return null;
+  try {
+    _rumenPool = new pg.Pool({
+      connectionString: process.env.DATABASE_URL,
+      max: 4,
+      idleTimeoutMillis: 30000,
+      connectionTimeoutMillis: 5000
+    });
+    _rumenPool.on('error', (err) => {
+      console.warn('[rumen] pg pool error:', err.message);
+    });
+    return _rumenPool;
+  } catch (err) {
+    console.warn('[rumen] failed to create pg pool:', err.message);
+    _rumenPoolFailed = true;
+    return null;
+  }
+}
 
 const { SessionManager } = require('./session');
 const { initDatabase, logCommand, getSessionHistory, getProjectSessions } = require('./database');
 const { RAGIntegration } = require('./rag');
 const { createBridge } = require('./mnestra-bridge');
 const { writeSessionLog } = require('./session-logger');
+const { TranscriptWriter } = require('./transcripts');
+const { createHealthHandler } = require('./preflight');
 const { themes, statusColors } = require('./themes');
 const { loadConfig, addProject } = require('./config');
 
@@ -59,12 +89,33 @@ function createServer(config) {
   const mnestraBridge = createBridge(config);
   console.log(`[mnestra-bridge] mode=${mnestraBridge.mode}`);
 
+  // Initialize transcript writer (Session Transcripts — Sprint 6)
+  const transcriptConfig = config.transcripts || {};
+  const transcriptEnabled = transcriptConfig.enabled !== undefined
+    ? transcriptConfig.enabled
+    : !!process.env.DATABASE_URL;
+  let transcriptWriter = null;
+  if (transcriptEnabled && process.env.DATABASE_URL) {
+    transcriptWriter = new TranscriptWriter(process.env.DATABASE_URL, {
+      batchSize: transcriptConfig.batchSize || 50,
+      flushIntervalMs: transcriptConfig.flushIntervalMs || 2000,
+      enabled: true
+    });
+    console.log('[transcript] Writer initialized (flush every %dms, batch %d)',
+      transcriptConfig.flushIntervalMs || 2000, transcriptConfig.batchSize || 50);
+  } else {
+    console.log('[transcript] Writer disabled (no DATABASE_URL or transcripts.enabled=false)');
+  }
+
   // Wire RAG to session events
   sessions.on('session:created', (s) => rag.onSessionCreated(s));
   sessions.on('session:removed', (s) => rag.onSessionEnded(s));
 
   // ==================== REST API ====================
 
+  // GET /api/health - preflight health checks (Sprint 6 T1, wired by T3)
+  app.get('/api/health', createHealthHandler(config));
+
   // GET /api/sessions - list all active sessions
   app.get('/api/sessions', (req, res) => {
     res.json(sessions.getAll());
@@ -129,7 +180,7 @@ function createServer(config) {
         session.pid = term.pid;
         session.meta.status = 'active';
 
-        // PTY output → analyze + broadcast to WebSocket
+        // PTY output → analyze + broadcast to WebSocket + transcript archive
         term.onData((data) => {
           session.analyzeOutput(data);
 
@@ -137,6 +188,15 @@ function createServer(config) {
           if (session.ws && session.ws.readyState === 1) {
             session.ws.send(JSON.stringify({ type: 'output', data }));
           }
+
+          // Archive to transcript writer (non-blocking, failure-safe)
+          if (transcriptWriter) {
+            try {
+              transcriptWriter.append(session.id, data, Buffer.byteLength(data, 'utf8'));
+            } catch (err) {
+              // Never let transcript failures disrupt the PTY data path
+            }
+          }
         });
 
         term.onExit(({ exitCode, signal }) => {
@@ -171,9 +231,13 @@ function createServer(config) {
           rag.onStatusChanged(sess, oldStatus, newStatus);
         };
 
-        // Proactive Mnestra queries on error — fire-and-forget, respects rag.enabled
+        // Proactive Mnestra queries on error — fire-and-forget.
+        // Independent of rag.enabled — the push loop (rag.js) and the Flashback
+        // bridge (mnestra-bridge) are separate systems. rag.enabled gates only
+        // the telemetry push loop. Flashback has its own error handling via
+        // the catch below and should fire whenever the Mnestra bridge is
+        // configured, regardless of the push-loop flag.
         session.onErrorDetected = (sess, ctx) => {
-          if (!rag.enabled) return;
           const question = `${sess.meta.type} error ${ctx.lastCommand || ''} ${ctx.tail || ''}`.trim();
           mnestraBridge.queryMnestra({
             question,
@@ -415,6 +479,193 @@ function createServer(config) {
     });
   });
 
+  // ==================== Transcript endpoints (Sprint 6 T3) ====================
+
+  // 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([]);
+    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);
+    } catch (err) {
+      console.error('[transcript] search endpoint error:', err.message);
+      res.status(500).json({ error: 'Transcript search failed' });
+    }
+  });
+
+  // GET /api/transcripts/recent - time-windowed crash recovery
+  app.get('/api/transcripts/recent', async (req, res) => {
+    if (!transcriptWriter) return res.json([]);
+    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);
+    } catch (err) {
+      console.error('[transcript] recent endpoint error:', err.message);
+      res.status(500).json({ error: 'Transcript recent query failed' });
+    }
+  });
+
+  // GET /api/transcripts/:sessionId - ordered chunks for a session
+  app.get('/api/transcripts/:sessionId', async (req, res) => {
+    if (!transcriptWriter) return res.json([]);
+    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);
+    } catch (err) {
+      console.error('[transcript] session transcript endpoint error:', err.message);
+      res.status(500).json({ error: 'Transcript retrieval failed' });
+    }
+  });
+
+  // ==================== Rumen insights (Sprint 4 T2) ====================
+  // Read-only access to rumen_insights + rumen_jobs in the petvetbid Postgres
+  // instance. Contract frozen in docs/sprint-4-rumen-integration/API-CONTRACT.md.
+
+  function rumenUnreachable(res) {
+    return res.status(503).json({ error: 'rumen database unreachable' });
+  }
+
+  // GET /api/rumen/insights
+  app.get('/api/rumen/insights', async (req, res) => {
+    const pool = getRumenPool();
+    if (!pool) {
+      return res.json({ insights: [], total: 0, enabled: false });
+    }
+
+    let limit = parseInt(req.query.limit, 10);
+    if (!Number.isFinite(limit)) limit = 20;
+    limit = Math.max(1, Math.min(100, limit));
+
+    const project = typeof req.query.project === 'string' && req.query.project.trim()
+      ? req.query.project.trim() : null;
+    const since = typeof req.query.since === 'string' && !Number.isNaN(Date.parse(req.query.since))
+      ? new Date(req.query.since).toISOString() : null;
+    const unseen = typeof req.query.unseen === 'string' &&
+      /^(1|true|yes)$/i.test(req.query.unseen);
+
+    const where = [];
+    const params = [];
+    if (project) { params.push(project); where.push(`$${params.length} = ANY(projects)`); }
+    if (since)   { params.push(since);   where.push(`created_at >= $${params.length}`); }
+    if (unseen)  { where.push(`acted_upon = FALSE`); }
+    const whereSql = where.length ? `WHERE ${where.join(' AND ')}` : '';
+
+    try {
+      const countSql = `SELECT COUNT(*)::int AS n FROM rumen_insights ${whereSql}`;
+      const listParams = params.slice();
+      listParams.push(limit);
+      const listSql =
+        `SELECT id, insight_text, confidence, projects, source_memory_ids, created_at, acted_upon
+           FROM rumen_insights
+           ${whereSql}
+           ORDER BY created_at DESC
+           LIMIT $${listParams.length}`;
+
+      const [countRes, listRes] = await Promise.all([
+        pool.query(countSql, params),
+        pool.query(listSql, listParams)
+      ]);
+
+      const insights = listRes.rows.map((r) => ({
+        id: r.id,
+        insight_text: r.insight_text,
+        confidence: r.confidence == null ? 0 : Number(r.confidence),
+        projects: r.projects || [],
+        source_memory_ids: r.source_memory_ids || [],
+        created_at: r.created_at instanceof Date ? r.created_at.toISOString() : r.created_at,
+        acted_upon: !!r.acted_upon
+      }));
+
+      res.json({ insights, total: countRes.rows[0]?.n || 0 });
+    } catch (err) {
+      console.warn('[rumen] GET /insights failed:', err.message);
+      return rumenUnreachable(res);
+    }
+  });
+
+  // GET /api/rumen/status
+  app.get('/api/rumen/status', async (req, res) => {
+    const pool = getRumenPool();
+    if (!pool) return res.json({ enabled: false });
+
+    try {
+      const jobSql =
+        `SELECT id, status, completed_at, sessions_processed, insights_generated
+           FROM rumen_jobs
+           ORDER BY started_at DESC
+           LIMIT 1`;
+      const insightSql =
+        `SELECT
+            COUNT(*)::int AS total,
+            COUNT(*) FILTER (WHERE acted_upon = FALSE)::int AS unseen,
+            MAX(created_at) AS latest
+           FROM rumen_insights`;
+
+      const [jobRes, insightRes] = await Promise.all([
+        pool.query(jobSql),
+        pool.query(insightSql)
+      ]);
+
+      const job = jobRes.rows[0] || null;
+      const stat = insightRes.rows[0] || { total: 0, unseen: 0, latest: null };
+
+      res.json({
+        enabled: true,
+        last_job_id: job ? job.id : null,
+        last_job_status: job ? job.status : null,
+        last_job_completed_at: job && job.completed_at
+          ? (job.completed_at instanceof Date ? job.completed_at.toISOString() : job.completed_at)
+          : null,
+        last_job_sessions_processed: job ? (job.sessions_processed || 0) : 0,
+        last_job_insights_generated: job ? (job.insights_generated || 0) : 0,
+        total_insights: stat.total || 0,
+        unseen_insights: stat.unseen || 0,
+        latest_insight_at: stat.latest
+          ? (stat.latest instanceof Date ? stat.latest.toISOString() : stat.latest)
+          : null
+      });
+    } catch (err) {
+      console.warn('[rumen] GET /status failed:', err.message);
+      return rumenUnreachable(res);
+    }
+  });
+
+  // POST /api/rumen/insights/:id/seen
+  app.post('/api/rumen/insights/:id/seen', async (req, res) => {
+    const pool = getRumenPool();
+    if (!pool) return res.status(503).json({ error: 'rumen not configured' });
+
+    const id = req.params.id;
+    if (!UUID_RE.test(id)) {
+      return res.status(400).json({ error: 'invalid insight id' });
+    }
+
+    try {
+      const result = await pool.query(
+        `UPDATE rumen_insights SET acted_upon = TRUE WHERE id = $1
+         RETURNING id, acted_upon`,
+        [id]
+      );
+      if (result.rowCount === 0) {
+        return res.status(404).json({ error: 'insight not found' });
+      }
+      const row = result.rows[0];
+      res.json({ id: row.id, acted_upon: !!row.acted_upon });
+    } catch (err) {
+      console.warn('[rumen] POST /insights/:id/seen failed:', err.message);
+      return rumenUnreachable(res);
+    }
+  });
+
   // POST /api/ai/query - query Mnestra memory via the bridge (direct|webhook|mcp)
   app.post('/api/ai/query', async (req, res) => {
     let { question, sessionId, project } = req.body;
@@ -545,7 +796,7 @@ function createServer(config) {
     res.sendFile(path.join(clientDir, 'index.html'));
   });
 
-  return { app, server, wss, sessions, rag, db };
+  return { app, server, wss, sessions, rag, db, transcriptWriter };
 }
 
 // Start server
@@ -561,10 +812,29 @@ if (require.main === module) {
     config.sessionLogs = { ...(config.sessionLogs || {}), enabled: true };
   }
 
-  const { server } = createServer(config);
+  const { server, transcriptWriter } = createServer(config);
   const port = config.port || 3000;
   const host = config.host || '127.0.0.1';
 
+  // Graceful shutdown — flush transcript buffer before exit
+  let shutdownInProgress = false;
+  async function handleShutdown(signal) {
+    if (shutdownInProgress) return;
+    shutdownInProgress = true;
+    console.log(`\n[server] ${signal} received, shutting down...`);
+    if (transcriptWriter) {
+      console.log('[transcript] Flushing buffer before exit...');
+      try { await transcriptWriter.close(); } catch (err) {
+        console.error('[transcript] Shutdown flush failed:', err.message);
+      }
+    }
+    server.close(() => process.exit(0));
+    // Force exit after 5s if server.close hangs
+    setTimeout(() => process.exit(1), 5000).unref();
+  }
+  process.on('SIGINT', () => handleShutdown('SIGINT'));
+  process.on('SIGTERM', () => handleShutdown('SIGTERM'));
+
   server.listen(port, host, () => {
     console.log(`\n  TermDeck running at http://${host}:${port}\n`);
     console.log(`  Terminals:  0 active`);
@@ -572,6 +842,7 @@ if (require.main === module) {
     console.log(`  PTY:        ${pty ? 'node-pty OK' : 'unavailable (install node-pty)'}`);
     console.log(`  RAG:        ${config.rag?.supabaseUrl ? 'configured' : 'not configured'}`);
     console.log(`  Session logs: ${config.sessionLogs?.enabled ? '~/.termdeck/sessions/ (on exit)' : 'off'}`);
+    console.log(`  Transcripts:  ${transcriptWriter ? 'streaming to Supabase' : 'off (no DATABASE_URL)'}`);
     console.log(`\n  WARNING: TermDeck binds to ${host} only.`);
     console.log(`  Do NOT expose this to the network without authentication.`);
     console.log(`  Terminal sessions have full shell access.\n`);

package/packages/server/src/mnestra-bridge/index.js

@@ -207,7 +207,7 @@ function createBridge(config) {
     } catch (err) {
       // Kill child so it respawns next call
       if (state.mcpChild) {
-        try { state.mcpChild.kill(); } catch {}
+        try { state.mcpChild.kill(); } catch (err) { /* process may already be dead */ }
         state.mcpChild = null;
       }
       throw err;