@mmmbuto/nexuscrew 0.1.0-beta.1 → 0.2.1

package/lib/services/log-watcher.js

@@ -27,10 +27,7 @@ class LogWatcher extends EventEmitter {
 
     const state = {
       offset: 0,
-      engine,
-      conversationId,
-      buffer: '',
-      parser: this._getParser(engine)
+      ...this.createParserState(engine, conversationId)
     };
 
     // Read existing content (in case log already has data)
@@ -98,39 +95,60 @@ class LogWatcher extends EventEmitter {
 
       state.offset = stat.size;
       const chunk = buf.toString('utf8');
-      state.buffer += chunk;
-
-      // Process complete lines
-      this._processBuffer(state);
+      this.processTextChunk(chunk, 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) {
-      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._emitParsedLine(line, state);
+    }
+  }
+
+  _emitParsedLine(line, state) {
+    if (!line.trim()) return;
+    try {
+      const events = state.parser(line, state);
+      for (const event of events) {
         this.emit('data', {
-          type: 'raw',
-          content: line,
+          ...event,
           conversationId: state.conversationId,
           engine: state.engine
         });
       }
+    } catch {
+      this.emit('data', {
+        type: 'raw',
+        content: line,
+        conversationId: state.conversationId,
+        engine: state.engine
+      });
     }
   }
 

package/lib/services/remote-pane-watcher.js

@@ -0,0 +1,155 @@
+const { EventEmitter } = require('events');
+const LogWatcher = require('./log-watcher');
+
+function normalizeSnapshot(text = '') {
+  return String(text).replace(/\r\n/g, '\n').replace(/\r/g, '\n');
+}
+
+function commonPrefixLength(a = '', b = '') {
+  const max = Math.min(a.length, b.length);
+  let index = 0;
+  while (index < max && a[index] === b[index]) {
+    index += 1;
+  }
+  return index;
+}
+
+class RemotePaneWatcher extends EventEmitter {
+  constructor(tmux, options = {}) {
+    super();
+    this.tmux = tmux;
+    this.parserAdapter = new LogWatcher();
+    this.watchers = new Map();
+    this.pollMs = options.pollMs || 400;
+    this.idleMs = options.idleMs || 4500;
+    this.timeoutMs = options.timeoutMs || 120000;
+
+    this.parserAdapter.on('data', (event) => this.emit('data', event));
+  }
+
+  watch({ conversationId, engine, host, windowName, promptText = '', initialSnapshot = '' }) {
+    const key = `${host?.name || host || 'local'}:${windowName}:${conversationId}`;
+    if (this.watchers.has(key)) return key;
+
+    const parserState = this.parserAdapter.createParserState(engine, conversationId);
+    const state = {
+      key,
+      conversationId,
+      engine,
+      host,
+      windowName,
+      parserState,
+      promptText: String(promptText || ''),
+      lastSnapshot: normalizeSnapshot(initialSnapshot),
+      startedAt: Date.now(),
+      lastChangeAt: Date.now(),
+      lastEmitAt: 0,
+      stopped: false,
+      sawAnyOutput: false
+    };
+
+    const intervalId = setInterval(() => this._poll(state), this.pollMs);
+    state.intervalId = intervalId;
+    this.watchers.set(key, state);
+    return key;
+  }
+
+  unwatch(key) {
+    const state = this.watchers.get(key);
+    if (!state) return;
+    clearInterval(state.intervalId);
+    state.stopped = true;
+    this.watchers.delete(key);
+  }
+
+  unwatchByConversation(conversationId) {
+    for (const [key, state] of this.watchers.entries()) {
+      if (state.conversationId === conversationId) {
+        this.unwatch(key);
+      }
+    }
+  }
+
+  unwatchAll() {
+    for (const key of this.watchers.keys()) {
+      this.unwatch(key);
+    }
+  }
+
+  _poll(state) {
+    if (state.stopped) return;
+
+    if (Date.now() - state.startedAt > this.timeoutMs) {
+      this._finish(state, true);
+      return;
+    }
+
+    const snapshot = normalizeSnapshot(
+      this.tmux.capturePane(state.windowName, state.host, 250)
+    );
+
+    if (!snapshot) {
+      if (Date.now() - state.lastChangeAt > this.idleMs) {
+        this._finish(state, true);
+      }
+      return;
+    }
+
+    if (snapshot === state.lastSnapshot) {
+      if (state.sawAnyOutput && Date.now() - state.lastChangeAt > this.idleMs) {
+        this._finish(state, true);
+      }
+      return;
+    }
+
+    const prefixLength = commonPrefixLength(state.lastSnapshot, snapshot);
+    let delta = snapshot.slice(prefixLength);
+    state.lastSnapshot = snapshot;
+    state.lastChangeAt = Date.now();
+
+    if (!delta.trim()) {
+      return;
+    }
+
+    delta = this._stripPromptEcho(delta, state);
+    if (!delta.trim()) {
+      return;
+    }
+
+    state.sawAnyOutput = true;
+    this.parserAdapter.processTextChunk(delta, state.parserState);
+    state.lastEmitAt = Date.now();
+  }
+
+  _stripPromptEcho(delta, state) {
+    if (!state.promptText) return delta;
+
+    const prompt = state.promptText.trim();
+    if (!prompt) return delta;
+
+    if (delta.includes(prompt)) {
+      return delta.replace(prompt, '');
+    }
+
+    const compact = delta.trim();
+    if (prompt.startsWith(compact) && compact.length > 10) {
+      return '';
+    }
+
+    return delta;
+  }
+
+  _finish(state, emitDone = false) {
+    this.parserAdapter.flushState(state.parserState);
+    if (emitDone) {
+      this.emit('data', {
+        type: 'done',
+        conversationId: state.conversationId,
+        engine: state.engine
+      });
+    }
+    this.unwatch(state.key);
+  }
+}
+
+module.exports = RemotePaneWatcher;

package/lib/services/session-store.js

@@ -1,81 +1,49 @@
 /**
- * SessionStore — SQLite persistence for nexuscrew
+ * SessionStore — SQLite persistence for nexuscrew (sql.js version)
  *
  * Schema:
- * - conversations: id, title, engine, model, tmux_window, log_path, workspace, host, status, created_at, updated_at
+ * - conversations: id, title, engine, model, tmux_window, log_path, workspace, host, status, pinned, 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(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 NOT NULL DEFAULT 'claude',
-        model TEXT,
-        tmux_window TEXT,
-        log_path TEXT,
-        workspace TEXT DEFAULT '',
-        host TEXT DEFAULT 'local',
-        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);
-    `);
+  constructor() {
+    // DB is managed by adapter - no direct connection here
+    this.initialized = false;
+  }
+
+  async init() {
+    // Adapter is already initialized by server.js
+    this.initialized = true;
   }
 
   // --- Conversations ---
 
   createConversation({ engine, model, workspace, host, tmuxWindow, logPath } = {}) {
     const id = uuidv4();
-    this.db.prepare(`
+    const stmt = prepare(`
       INSERT INTO conversations (id, engine, model, workspace, host, tmux_window, log_path)
       VALUES (?, ?, ?, ?, ?, ?, ?)
-    `).run(id, engine || 'claude', model || null, workspace || '', host || 'local', tmuxWindow || null, logPath || null);
+    `);
+    stmt.run(id, engine || 'claude', model || null, workspace || '', host || 'local', tmuxWindow || null, logPath || null);
     return this.getConversation(id);
   }
 
   getConversation(id) {
-    return this.db.prepare('SELECT * FROM conversations WHERE id = ?').get(id);
+    const stmt = prepare('SELECT * FROM conversations WHERE id = ?');
+    return stmt.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'].includes(key)) {
+      if (['title', 'engine', 'model', 'tmux_window', 'log_path', 'workspace', 'host', 'status', 'pinned'].includes(key)) {
         fields.push(`${key} = ?`);
         values.push(value);
       }
@@ -83,7 +51,8 @@ class SessionStore {
     if (fields.length === 0) return;
     fields.push('updated_at = unixepoch()');
     values.push(id);
-    this.db.prepare(`UPDATE conversations SET ${fields.join(', ')} WHERE id = ?`).run(...values);
+    const stmt = prepare(`UPDATE conversations SET ${fields.join(', ')} WHERE id = ?`);
+    stmt.run(...values);
   }
 
   listConversations({ workspace, host, status, limit = 50 } = {}) {
@@ -94,22 +63,26 @@ class SessionStore {
     if (status) { sql += ' AND status = ?'; params.push(status); }
     sql += ' ORDER BY updated_at DESC LIMIT ?';
     params.push(limit);
-    return this.db.prepare(sql).all(...params);
+    const stmt = prepare(sql);
+    return stmt.all(...params);
   }
 
   deleteConversation(id) {
-    this.db.prepare('DELETE FROM messages WHERE conversation_id = ?').run(id);
-    this.db.prepare('DELETE FROM conversations WHERE id = ?').run(id);
+    const stmt1 = prepare('DELETE FROM messages WHERE conversation_id = ?');
+    stmt1.run(id);
+    const stmt2 = prepare('DELETE FROM conversations WHERE id = ?');
+    stmt2.run(id);
   }
 
   /** Find conversation by tmux window name */
   findByWindow(windowName) {
-    return this.db.prepare('SELECT * FROM conversations WHERE tmux_window = ?').get(windowName);
+    const stmt = prepare('SELECT * FROM conversations WHERE tmux_window = ?');
+    return stmt.get(windowName);
   }
 
   /** Get conversations grouped by date */
-  listGroupedByDate({ workspace, limit = 100 } = {}) {
-    const convs = this.listConversations({ workspace, limit });
+  listGroupedByDate({ workspace, host, limit = 100 } = {}) {
+    const convs = this.listConversations({ workspace, host, limit });
     const grouped = {};
     for (const c of convs) {
       const date = new Date(c.updated_at * 1000).toISOString().split('T')[0];
@@ -119,17 +92,37 @@ 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();
-    this.db.prepare(`
+    const stmt = prepare(`
       INSERT INTO messages (id, conversation_id, role, content, engine, model, tokens_in, tokens_out)
       VALUES (?, ?, ?, ?, ?, ?, ?, ?)
-    `).run(id, conversationId, role, content || '', engine || null, model || null, tokensIn || 0, tokensOut || 0);
+    `);
+    stmt.run(id, conversationId, role, content || '', engine || null, model || null, tokensIn || 0, tokensOut || 0);
 
     // Update conversation timestamp
-    this.db.prepare('UPDATE conversations SET updated_at = unixepoch() WHERE id = ?').run(conversationId);
+    const updateStmt = prepare('UPDATE conversations SET updated_at = unixepoch() WHERE id = ?');
+    updateStmt.run(conversationId);
     return id;
   }
 
@@ -142,11 +135,13 @@ class SessionStore {
     }
     sql += ' ORDER BY created_at ASC LIMIT ?';
     params.push(limit);
-    return this.db.prepare(sql).all(...params);
+    const stmt = prepare(sql);
+    return stmt.all(...params);
   }
 
   getMessageCount(conversationId) {
-    return this.db.prepare('SELECT COUNT(*) as count FROM messages WHERE conversation_id = ?').get(conversationId).count;
+    const stmt = prepare('SELECT COUNT(*) as count FROM messages WHERE conversation_id = ?');
+    return stmt.get(conversationId).count;
   }
 
   // --- Recovery ---
@@ -156,10 +151,11 @@ class SessionStore {
    * Mark conversations as 'dead' if their tmux window no longer exists
    */
   syncWithTmux(tmuxManager) {
-    const active = this.db.prepare("SELECT * FROM conversations WHERE status = 'active'").all();
+    const stmt = prepare("SELECT * FROM conversations WHERE status = 'active'");
+    const active = stmt.all();
     for (const conv of active) {
       if (conv.tmux_window) {
-        const exists = tmuxManager.hasWindow(conv.tmux_window, conv.host !== 'local' ? conv.host : null);
+        const exists = tmuxManager.hasWindow(conv.tmux_window, conv.host || 'local');
         if (!exists) {
           this.updateConversation(conv.id, { status: 'dead' });
         }
@@ -169,7 +165,7 @@ class SessionStore {
 
   /** Close DB connection */
   close() {
-    this.db.close();
+    saveDb();
   }
 }