@mmmbuto/nexuscrew 0.2.1 → 0.2.2

package/lib/services/log-watcher.js

@@ -27,7 +27,10 @@ class LogWatcher extends EventEmitter {
 
     const state = {
       offset: 0,
-      ...this.createParserState(engine, conversationId)
+      engine,
+      conversationId,
+      buffer: '',
+      parser: this._getParser(engine)
     };
 
     // Read existing content (in case log already has data)
@@ -95,60 +98,39 @@ class LogWatcher extends EventEmitter {
 
       state.offset = stat.size;
       const chunk = buf.toString('utf8');
-      this.processTextChunk(chunk, state);
+      state.buffer += chunk;
+
+      // Process complete lines
+      this._processBuffer(state);
     } catch (err) {
       // File might be temporarily unavailable
     }
   }
 
-  createParserState(engine, conversationId) {
-    return {
-      engine,
-      conversationId,
-      buffer: '',
-      parser: this._getParser(engine)
-    };
-  }
-
-  processTextChunk(chunk, state) {
-    state.buffer += chunk;
-    this._processBuffer(state);
-  }
-
-  flushState(state) {
-    if (!state.buffer?.trim()) return;
-    const line = state.buffer;
-    state.buffer = '';
-    this._emitParsedLine(line, state);
-  }
-
   _processBuffer(state) {
     const lines = state.buffer.split('\n');
     state.buffer = lines.pop() || ''; // Keep incomplete line in buffer
 
     for (const line of lines) {
-      this._emitParsedLine(line, state);
-    }
-  }
-
-  _emitParsedLine(line, state) {
-    if (!line.trim()) return;
-    try {
-      const events = state.parser(line, state);
-      for (const event of events) {
+      if (!line.trim()) continue;
+      try {
+        const events = state.parser(line, state);
+        for (const event of events) {
+          this.emit('data', {
+            ...event,
+            conversationId: state.conversationId,
+            engine: state.engine
+          });
+        }
+      } catch {
+        // Emit raw text if parser fails
         this.emit('data', {
-          ...event,
+          type: 'raw',
+          content: line,
           conversationId: state.conversationId,
           engine: state.engine
         });
       }
-    } catch {
-      this.emit('data', {
-        type: 'raw',
-        content: line,
-        conversationId: state.conversationId,
-        engine: state.engine
-      });
     }
   }
 

package/lib/services/session-store.js

@@ -1,49 +1,94 @@
 /**
- * SessionStore — SQLite persistence for nexuscrew (sql.js version)
+ * SessionStore — SQLite persistence for nexuscrew
  *
  * Schema:
- * - conversations: id, title, engine, model, tmux_window, log_path, workspace, host, status, pinned, created_at, updated_at
+ * - conversations: id, title, engine, model, tmux_session, log_path, workspace, host, status, launcher_id, created_at, updated_at
  * - messages: id, conversation_id, role, content, engine, model, tokens_in, tokens_out, created_at
  */
 
+const Database = require('better-sqlite3');
 const path = require('path');
 const fs = require('fs');
 const { v4: uuidv4 } = require('uuid');
-const { prepare, saveDb } = require('../server/db/adapter');
 
 class SessionStore {
-  constructor() {
-    // DB is managed by adapter - no direct connection here
-    this.initialized = false;
+  constructor(dbPath) {
+    const dir = path.dirname(dbPath);
+    if (!fs.existsSync(dir)) fs.mkdirSync(dir, { recursive: true });
+
+    this.db = new Database(dbPath);
+    this.db.pragma('journal_mode = WAL');
+    this.db.pragma('foreign_keys = ON');
+    this._migrate();
+  }
+
+  _migrate() {
+    this.db.exec(`
+      CREATE TABLE IF NOT EXISTS conversations (
+        id TEXT PRIMARY KEY,
+        title TEXT DEFAULT 'New Chat',
+        engine TEXT,
+        model TEXT,
+        tmux_window TEXT,
+        tmux_session TEXT,
+        log_path TEXT,
+        workspace TEXT DEFAULT '',
+        host TEXT DEFAULT 'local',
+        launcher_id TEXT,
+        status TEXT DEFAULT 'active',
+        created_at INTEGER DEFAULT (unixepoch()),
+        updated_at INTEGER DEFAULT (unixepoch())
+      );
+
+      CREATE TABLE IF NOT EXISTS messages (
+        id TEXT PRIMARY KEY,
+        conversation_id TEXT NOT NULL,
+        role TEXT NOT NULL,
+        content TEXT DEFAULT '',
+        engine TEXT,
+        model TEXT,
+        tokens_in INTEGER DEFAULT 0,
+        tokens_out INTEGER DEFAULT 0,
+        created_at INTEGER DEFAULT (unixepoch()),
+        FOREIGN KEY (conversation_id) REFERENCES conversations(id)
+      );
+
+      CREATE INDEX IF NOT EXISTS idx_messages_conv ON messages(conversation_id, created_at);
+      CREATE INDEX IF NOT EXISTS idx_conversations_status ON conversations(status, updated_at);
+    `);
+
+    this._ensureColumn('conversations', 'tmux_session', 'TEXT');
+    this._ensureColumn('conversations', 'launcher_id', 'TEXT');
+    this.db.exec('CREATE INDEX IF NOT EXISTS idx_conversations_tmux_session ON conversations(tmux_session)');
   }
 
-  async init() {
-    // Adapter is already initialized by server.js
-    this.initialized = true;
+  _ensureColumn(tableName, columnName, definition) {
+    const columns = this.db.prepare(`PRAGMA table_info(${tableName})`).all();
+    if (!columns.find((column) => column.name === columnName)) {
+      this.db.exec(`ALTER TABLE ${tableName} ADD COLUMN ${columnName} ${definition}`);
+    }
   }
 
   // --- Conversations ---
 
-  createConversation({ engine, model, workspace, host, tmuxWindow, logPath } = {}) {
+  createConversation({ engine, model, workspace, host, tmuxWindow, tmuxSession, logPath, launcherId } = {}) {
     const id = uuidv4();
-    const stmt = prepare(`
-      INSERT INTO conversations (id, engine, model, workspace, host, tmux_window, log_path)
-      VALUES (?, ?, ?, ?, ?, ?, ?)
-    `);
-    stmt.run(id, engine || 'claude', model || null, workspace || '', host || 'local', tmuxWindow || null, logPath || null);
+    this.db.prepare(`
+      INSERT INTO conversations (id, engine, model, workspace, host, tmux_window, tmux_session, log_path, launcher_id)
+      VALUES (?, ?, ?, ?, ?, ?, ?, ?, ?)
+    `).run(id, engine || null, model || null, workspace || '', host || 'local', tmuxWindow || null, tmuxSession || null, logPath || null, launcherId || null);
     return this.getConversation(id);
   }
 
   getConversation(id) {
-    const stmt = prepare('SELECT * FROM conversations WHERE id = ?');
-    return stmt.get(id);
+    return this.db.prepare('SELECT * FROM conversations WHERE id = ?').get(id);
   }
 
   updateConversation(id, updates) {
     const fields = [];
     const values = [];
     for (const [key, value] of Object.entries(updates)) {
-      if (['title', 'engine', 'model', 'tmux_window', 'log_path', 'workspace', 'host', 'status', 'pinned'].includes(key)) {
+      if (['title', 'engine', 'model', 'tmux_window', 'tmux_session', 'log_path', 'workspace', 'host', 'status', 'launcher_id'].includes(key)) {
         fields.push(`${key} = ?`);
         values.push(value);
       }
@@ -51,8 +96,7 @@ class SessionStore {
     if (fields.length === 0) return;
     fields.push('updated_at = unixepoch()');
     values.push(id);
-    const stmt = prepare(`UPDATE conversations SET ${fields.join(', ')} WHERE id = ?`);
-    stmt.run(...values);
+    this.db.prepare(`UPDATE conversations SET ${fields.join(', ')} WHERE id = ?`).run(...values);
   }
 
   listConversations({ workspace, host, status, limit = 50 } = {}) {
@@ -63,26 +107,26 @@ class SessionStore {
     if (status) { sql += ' AND status = ?'; params.push(status); }
     sql += ' ORDER BY updated_at DESC LIMIT ?';
     params.push(limit);
-    const stmt = prepare(sql);
-    return stmt.all(...params);
+    return this.db.prepare(sql).all(...params);
   }
 
   deleteConversation(id) {
-    const stmt1 = prepare('DELETE FROM messages WHERE conversation_id = ?');
-    stmt1.run(id);
-    const stmt2 = prepare('DELETE FROM conversations WHERE id = ?');
-    stmt2.run(id);
+    this.db.prepare('DELETE FROM messages WHERE conversation_id = ?').run(id);
+    this.db.prepare('DELETE FROM conversations WHERE id = ?').run(id);
   }
 
   /** Find conversation by tmux window name */
   findByWindow(windowName) {
-    const stmt = prepare('SELECT * FROM conversations WHERE tmux_window = ?');
-    return stmt.get(windowName);
+    return this.db.prepare('SELECT * FROM conversations WHERE tmux_window = ?').get(windowName);
+  }
+
+  findByTmuxSession(sessionName) {
+    return this.db.prepare('SELECT * FROM conversations WHERE tmux_session = ?').get(sessionName);
   }
 
   /** Get conversations grouped by date */
-  listGroupedByDate({ workspace, host, limit = 100 } = {}) {
-    const convs = this.listConversations({ workspace, host, limit });
+  listGroupedByDate({ workspace, limit = 100 } = {}) {
+    const convs = this.listConversations({ workspace, limit });
     const grouped = {};
     for (const c of convs) {
       const date = new Date(c.updated_at * 1000).toISOString().split('T')[0];
@@ -92,37 +136,17 @@ class SessionStore {
     return grouped;
   }
 
-  /** Toggle conversation pinned status */
-  pinConversation(id) {
-    const stmt = prepare('SELECT pinned FROM conversations WHERE id = ?');
-    const conv = stmt.get(id);
-    if (!conv) return;
-
-    const newPinned = conv.pinned ? 0 : 1;
-    const updateStmt = prepare('UPDATE conversations SET pinned = ? WHERE id = ?');
-    updateStmt.run(newPinned, id);
-    return newPinned === 1;
-  }
-
-  /** Search conversations by title */
-  searchConversations(query) {
-    const stmt = prepare('SELECT * FROM conversations WHERE title LIKE ? ORDER BY updated_at DESC LIMIT 50');
-    return stmt.all(`%${query}%`);
-  }
-
   // --- Messages ---
 
   addMessage({ conversationId, role, content, engine, model, tokensIn, tokensOut } = {}) {
     const id = uuidv4();
-    const stmt = prepare(`
+    this.db.prepare(`
       INSERT INTO messages (id, conversation_id, role, content, engine, model, tokens_in, tokens_out)
       VALUES (?, ?, ?, ?, ?, ?, ?, ?)
-    `);
-    stmt.run(id, conversationId, role, content || '', engine || null, model || null, tokensIn || 0, tokensOut || 0);
+    `).run(id, conversationId, role, content || '', engine || null, model || null, tokensIn || 0, tokensOut || 0);
 
     // Update conversation timestamp
-    const updateStmt = prepare('UPDATE conversations SET updated_at = unixepoch() WHERE id = ?');
-    updateStmt.run(conversationId);
+    this.db.prepare('UPDATE conversations SET updated_at = unixepoch() WHERE id = ?').run(conversationId);
     return id;
   }
 
@@ -135,13 +159,11 @@ class SessionStore {
     }
     sql += ' ORDER BY created_at ASC LIMIT ?';
     params.push(limit);
-    const stmt = prepare(sql);
-    return stmt.all(...params);
+    return this.db.prepare(sql).all(...params);
   }
 
   getMessageCount(conversationId) {
-    const stmt = prepare('SELECT COUNT(*) as count FROM messages WHERE conversation_id = ?');
-    return stmt.get(conversationId).count;
+    return this.db.prepare('SELECT COUNT(*) as count FROM messages WHERE conversation_id = ?').get(conversationId).count;
   }
 
   // --- Recovery ---
@@ -151,11 +173,15 @@ class SessionStore {
    * Mark conversations as 'dead' if their tmux window no longer exists
    */
   syncWithTmux(tmuxManager) {
-    const stmt = prepare("SELECT * FROM conversations WHERE status = 'active'");
-    const active = stmt.all();
+    const active = this.db.prepare("SELECT * FROM conversations WHERE status = 'active'").all();
     for (const conv of active) {
-      if (conv.tmux_window) {
-        const exists = tmuxManager.hasWindow(conv.tmux_window, conv.host || 'local');
+      if (conv.tmux_session) {
+        const exists = tmuxManager.hasSession(conv.tmux_session, conv.host !== 'local' ? conv.host : null);
+        if (!exists) {
+          this.updateConversation(conv.id, { status: 'dead' });
+        }
+      } else if (conv.tmux_window) {
+        const exists = tmuxManager.hasSession(conv.tmux_window, conv.host !== 'local' ? conv.host : null);
         if (!exists) {
           this.updateConversation(conv.id, { status: 'dead' });
         }
@@ -165,7 +191,7 @@ class SessionStore {
 
   /** Close DB connection */
   close() {
-    saveDb();
+    this.db.close();
   }
 }