@mmmbuto/nexuscrew 0.1.0-beta.1

package/lib/services/log-watcher.js

@@ -0,0 +1,279 @@
+/**
+ * LogWatcher — Monitor tmux tee log files for structured output
+ *
+ * Watches log files created by `tee` in tmux windows.
+ * Parses output per-engine and emits events.
+ */
+
+const fs = require('fs');
+const path = require('path');
+const { EventEmitter } = require('events');
+
+class LogWatcher extends EventEmitter {
+  constructor() {
+    super();
+    this.watchers = new Map(); // logPath → { watcher, offset, parser }
+    this.pollIntervals = new Map(); // logPath → intervalId
+  }
+
+  /**
+   * Start watching a log file
+   * @param {string} logPath - Path to the tee log file
+   * @param {string} engine - Engine type (claude, codex, gemini, qwen)
+   * @param {string} conversationId - Associated conversation
+   */
+  watch(logPath, engine, conversationId) {
+    if (this.watchers.has(logPath)) return;
+
+    const state = {
+      offset: 0,
+      engine,
+      conversationId,
+      buffer: '',
+      parser: this._getParser(engine)
+    };
+
+    // Read existing content (in case log already has data)
+    if (fs.existsSync(logPath)) {
+      state.offset = fs.statSync(logPath).size;
+    }
+
+    // Poll-based watching (more reliable than fs.watch for log files)
+    const intervalId = setInterval(() => this._poll(logPath, state), 200);
+    this.pollIntervals.set(logPath, intervalId);
+
+    // Also use fs.watch for immediate responsiveness
+    try {
+      const watcher = fs.watch(path.dirname(logPath), (eventType, filename) => {
+        if (filename === path.basename(logPath)) {
+          this._poll(logPath, state);
+        }
+      });
+      this.watchers.set(logPath, { ...state, watcher });
+    } catch {
+      // fs.watch may fail in some environments, polling still works
+      this.watchers.set(logPath, state);
+    }
+
+    this.emit('watching', { logPath, engine, conversationId });
+  }
+
+  /**
+   * Stop watching a log file
+   */
+  unwatch(logPath) {
+    const state = this.watchers.get(logPath);
+    if (state?.watcher) state.watcher.close();
+    this.watchers.delete(logPath);
+
+    const intervalId = this.pollIntervals.get(logPath);
+    if (intervalId) {
+      clearInterval(intervalId);
+      this.pollIntervals.delete(logPath);
+    }
+  }
+
+  /**
+   * Stop all watchers
+   */
+  unwatchAll() {
+    for (const logPath of this.watchers.keys()) {
+      this.unwatch(logPath);
+    }
+  }
+
+  // --- Polling ---
+
+  _poll(logPath, state) {
+    try {
+      if (!fs.existsSync(logPath)) return;
+
+      const stat = fs.statSync(logPath);
+      if (stat.size <= state.offset) return;
+
+      const fd = fs.openSync(logPath, 'r');
+      const buf = Buffer.alloc(stat.size - state.offset);
+      fs.readSync(fd, buf, 0, buf.length, state.offset);
+      fs.closeSync(fd);
+
+      state.offset = stat.size;
+      const chunk = buf.toString('utf8');
+      state.buffer += chunk;
+
+      // Process complete lines
+      this._processBuffer(state);
+    } catch (err) {
+      // File might be temporarily unavailable
+    }
+  }
+
+  _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.emit('data', {
+          type: 'raw',
+          content: line,
+          conversationId: state.conversationId,
+          engine: state.engine
+        });
+      }
+    }
+  }
+
+  // --- Parsers ---
+
+  _getParser(engine) {
+    switch (engine) {
+      case 'claude': return this._parseClaude.bind(this);
+      case 'codex': return this._parseCodex.bind(this);
+      case 'gemini': return this._parseGemini.bind(this);
+      case 'qwen': return this._parseQwen.bind(this);
+      default: return this._parseGeneric.bind(this);
+    }
+  }
+
+  /**
+   * Claude Code JSON output parser
+   * Claude emits JSON objects per-line when --output-format json is used
+   */
+  _parseClaude(line, state) {
+    const events = [];
+
+    // Try JSON parse (Claude --output-format json)
+    try {
+      const obj = JSON.parse(line);
+
+      if (obj.type === 'assistant') {
+        events.push({ type: 'status', content: 'thinking...' });
+      } else if (obj.type === 'content_block_delta') {
+        events.push({ type: 'chunk', content: obj.delta?.text || '' });
+      } else if (obj.type === 'message_stop') {
+        events.push({ type: 'done' });
+      } else if (obj.type === 'tool_use') {
+        events.push({ type: 'status', content: `tool: ${obj.name || 'unknown'}` });
+      } else if (obj.result !== undefined) {
+        // Final result
+        events.push({
+          type: 'message_done',
+          content: typeof obj.result === 'string' ? obj.result : JSON.stringify(obj.result),
+          usage: obj.usage
+        });
+      }
+      return events;
+    } catch {}
+
+    // Fallback: plain text parsing
+    if (line.includes('thinking...') || line.includes('Thinking...')) {
+      events.push({ type: 'status', content: 'thinking...' });
+    } else if (line.includes('tool:')) {
+      events.push({ type: 'status', content: line.trim() });
+    } else if (line.trim()) {
+      events.push({ type: 'chunk', content: line });
+    }
+
+    return events;
+  }
+
+  /**
+   * Codex exec --json output parser (JSONL)
+   */
+  _parseCodex(line) {
+    const events = [];
+
+    try {
+      const obj = JSON.parse(line);
+      if (obj.type === 'status') {
+        events.push({ type: 'status', content: obj.message || obj.status });
+      } else if (obj.type === 'response' || obj.type === 'result') {
+        events.push({
+          type: 'message_done',
+          content: obj.content || obj.result || obj.text || '',
+          usage: obj.usage
+        });
+      } else if (obj.type === 'tool_use' || obj.type === 'patch') {
+        events.push({ type: 'status', content: `${obj.type}: ${obj.name || obj.path || ''}` });
+      } else if (obj.delta) {
+        events.push({ type: 'chunk', content: obj.delta });
+      } else if (obj.content) {
+        events.push({ type: 'chunk', content: typeof obj.content === 'string' ? obj.content : JSON.stringify(obj.content) });
+      }
+    } catch {
+      if (line.trim()) {
+        events.push({ type: 'chunk', content: line });
+      }
+    }
+
+    return events;
+  }
+
+  /**
+   * Gemini output parser
+   */
+  _parseGemini(line) {
+    const events = [];
+
+    try {
+      const obj = JSON.parse(line);
+      if (obj.type === 'status') {
+        events.push({ type: 'status', content: obj.message });
+      } else if (obj.content) {
+        events.push({ type: 'chunk', content: obj.content });
+      }
+    } catch {
+      // Detect Gemini status markers
+      if (line.match(/^(⠋|⠙|⠹|⠸|⠼|⠴|⠦|⠧|⠇|⠏)/)) {
+        events.push({ type: 'status', content: line.trim() });
+      } else if (line.trim()) {
+        events.push({ type: 'chunk', content: line });
+      }
+    }
+
+    return events;
+  }
+
+  /**
+   * Qwen output parser
+   */
+  _parseQwen(line) {
+    const events = [];
+
+    try {
+      const obj = JSON.parse(line);
+      if (obj.type === 'status') {
+        events.push({ type: 'status', content: obj.message });
+      } else if (obj.content) {
+        events.push({ type: 'chunk', content: obj.content });
+      }
+    } catch {
+      if (line.trim()) {
+        events.push({ type: 'chunk', content: line });
+      }
+    }
+
+    return events;
+  }
+
+  /**
+   * Generic fallback parser
+   */
+  _parseGeneric(line) {
+    if (!line.trim()) return [];
+    return [{ type: 'chunk', content: line }];
+  }
+}
+
+module.exports = LogWatcher;

package/lib/services/session-store.js

@@ -0,0 +1,176 @@
+/**
+ * SessionStore — SQLite persistence for nexuscrew
+ *
+ * Schema:
+ * - conversations: id, title, engine, model, tmux_window, log_path, workspace, host, status, 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');
+
+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);
+    `);
+  }
+
+  // --- Conversations ---
+
+  createConversation({ engine, model, workspace, host, tmuxWindow, logPath } = {}) {
+    const id = uuidv4();
+    this.db.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);
+    return this.getConversation(id);
+  }
+
+  getConversation(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'].includes(key)) {
+        fields.push(`${key} = ?`);
+        values.push(value);
+      }
+    }
+    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);
+  }
+
+  listConversations({ workspace, host, status, limit = 50 } = {}) {
+    let sql = 'SELECT * FROM conversations WHERE 1=1';
+    const params = [];
+    if (workspace) { sql += ' AND workspace = ?'; params.push(workspace); }
+    if (host) { sql += ' AND host = ?'; params.push(host); }
+    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);
+  }
+
+  deleteConversation(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) {
+    return this.db.prepare('SELECT * FROM conversations WHERE tmux_window = ?').get(windowName);
+  }
+
+  /** Get conversations grouped by date */
+  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];
+      if (!grouped[date]) grouped[date] = [];
+      grouped[date].push(c);
+    }
+    return grouped;
+  }
+
+  // --- Messages ---
+
+  addMessage({ conversationId, role, content, engine, model, tokensIn, tokensOut } = {}) {
+    const id = uuidv4();
+    this.db.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);
+
+    // Update conversation timestamp
+    this.db.prepare('UPDATE conversations SET updated_at = unixepoch() WHERE id = ?').run(conversationId);
+    return id;
+  }
+
+  getMessages(conversationId, { limit = 50, before } = {}) {
+    let sql = 'SELECT * FROM messages WHERE conversation_id = ?';
+    const params = [conversationId];
+    if (before) {
+      sql += ' AND created_at < ?';
+      params.push(before);
+    }
+    sql += ' ORDER BY created_at ASC LIMIT ?';
+    params.push(limit);
+    return this.db.prepare(sql).all(...params);
+  }
+
+  getMessageCount(conversationId) {
+    return this.db.prepare('SELECT COUNT(*) as count FROM messages WHERE conversation_id = ?').get(conversationId).count;
+  }
+
+  // --- Recovery ---
+
+  /**
+   * Sync DB with actual tmux state
+   * 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();
+    for (const conv of active) {
+      if (conv.tmux_window) {
+        const exists = tmuxManager.hasWindow(conv.tmux_window, conv.host !== 'local' ? conv.host : null);
+        if (!exists) {
+          this.updateConversation(conv.id, { status: 'dead' });
+        }
+      }
+    }
+  }
+
+  /** Close DB connection */
+  close() {
+    this.db.close();
+  }
+}
+
+module.exports = SessionStore;

package/lib/services/tmux-manager.js

@@ -0,0 +1,256 @@
+/**
+ * TmuxManager — Core tmux operations for nexuscrew
+ *
+ * Manages tmux sessions locally and remotely via SSH.
+ * Every AI session = one tmux window inside the master session.
+ */
+
+const { execSync, exec } = require('child_process');
+const path = require('path');
+const fs = require('fs');
+
+const TMUX_SESSION = 'nexuscrew';
+
+class TmuxManager {
+  constructor(config = {}) {
+    this.sessionName = config.tmuxSession || TMUX_SESSION;
+    this.logDir = config.logDir || path.join(process.env.HOME, '.nexuscrew', 'logs');
+    this.hosts = config.hosts || [{ name: 'local', type: 'local' }];
+
+    // Ensure log dir
+    if (!fs.existsSync(this.logDir)) {
+      fs.mkdirSync(this.logDir, { recursive: true });
+    }
+  }
+
+  // --- Session management ---
+
+  /** Ensure master tmux session exists */
+  ensureSession(host = null) {
+    const cmd = this._cmd('tmux new-session -d -s ${SESSION} -x 200 -y 50 2>/dev/null || true', host);
+    this._exec(cmd);
+  }
+
+  /** Check if master session exists */
+  hasSession(host = null) {
+    try {
+      this._exec(this._cmd('tmux has-session -t ${SESSION} 2>/dev/null', host));
+      return true;
+    } catch {
+      return false;
+    }
+  }
+
+  // --- Window management ---
+
+  /**
+   * Create a new tmux window running a CLI command
+   * @param {Object} opts
+   * @param {string} opts.windowName - Unique window name (e.g. "claude-abc123")
+   * @param {string} opts.command - Full command to run
+   * @param {string} opts.cwd - Working directory
+   * @param {string} opts.host - Host name or null for local
+   * @returns {{ windowName, logPath }}
+   */
+  createWindow({ windowName, command, cwd, host = null }) {
+    this.ensureSession(host);
+
+    const logPath = path.join(this.logDir, `${windowName}.log`);
+    const logDir = path.dirname(logPath);
+
+    // For remote hosts, logs go to a local path
+    const fullCommand = cwd
+      ? `cd ${cwd} && ${command} 2>&1 | tee ${logPath}`
+      : `${command} 2>&1 | tee ${logPath}`;
+
+    const cmd = this._cmd(
+      `tmux new-window -t \${SESSION} -n ${windowName} -c '${cwd || process.env.HOME}' "${fullCommand.replace(/"/g, '\\"')}"`,
+      host
+    );
+
+    this._exec(cmd);
+
+    return { windowName, logPath };
+  }
+
+  /**
+   * Send text to a tmux window (like typing)
+   * @param {string} windowName
+   * @param {string} text - Text to send
+   * @param {Object} opts
+   * @param {boolean} opts.enter - Press Enter after text
+   * @param {string} opts.host - Host name or null
+   */
+  sendKeys(windowName, text, opts = {}) {
+    const enterSuffix = opts.enter ? ' Enter' : '';
+    const escapedText = text.replace(/'/g, "'\\''");
+    const cmd = this._cmd(
+      `tmux send-keys -t \${SESSION}:${windowName} '${escapedText}'${enterSuffix}`,
+      opts.host
+    );
+    this._exec(cmd);
+  }
+
+  /**
+   * Send a special key (C-c, Escape, etc.)
+   */
+  sendSpecialKey(windowName, key, host = null) {
+    const cmd = this._cmd(
+      `tmux send-keys -t \${SESSION}:${windowName} ${key}`,
+      host
+    );
+    this._exec(cmd);
+  }
+
+  /** Interrupt: Escape then C-c (works for Claude/Codex/Gemini/Qwen) */
+  interrupt(windowName, host = null) {
+    this.sendSpecialKey(windowName, 'Escape', host);
+    setTimeout(() => {
+      this.sendSpecialKey(windowName, 'C-c', host);
+    }, 100);
+  }
+
+  /**
+   * Capture current pane content
+   * @returns {string} visible text in the pane
+   */
+  capturePane(windowName, host = null) {
+    try {
+      const cmd = this._cmd(
+        `tmux capture-pane -t \${SESSION}:${windowName} -p -S -100`,
+        host
+      );
+      return this._exec(cmd);
+    } catch {
+      return '';
+    }
+  }
+
+  /**
+   * Check if a window exists
+   */
+  hasWindow(windowName, host = null) {
+    try {
+      const cmd = this._cmd(
+        `tmux list-windows -t \${SESSION} -F '#{{window_name}}' 2>/dev/null | grep -qx '${windowName}'`,
+        host
+      );
+      this._exec(cmd);
+      return true;
+    } catch {
+      return false;
+    }
+  }
+
+  /**
+   * Kill a window
+   */
+  killWindow(windowName, host = null) {
+    try {
+      const cmd = this._cmd(
+        `tmux kill-window -t \${SESSION}:${windowName} 2>/dev/null`,
+        host
+      );
+      this._exec(cmd);
+    } catch {}
+  }
+
+  /**
+   * List all windows in the master session
+   * @returns {Array<{index, name, active, size}>}
+   */
+  listWindows(host = null) {
+    try {
+      const cmd = this._cmd(
+        `tmux list-windows -t \${SESSION} -F '#{{window_index}}:#{{window_name}} #{{window_width}}x#{{window_height}} #{{?window_active,1,0}}' 2>/dev/null`,
+        host
+      );
+      const output = this._exec(cmd);
+      return output.trim().split('\n').filter(Boolean).map(line => {
+        const [idxName, size, active] = line.split(' ');
+        const [index, ...nameParts] = idxName.split(':');
+        return {
+          index: parseInt(index),
+          name: nameParts.join(':'),
+          size,
+          active: active === '1'
+        };
+      });
+    } catch {
+      return [];
+    }
+  }
+
+  /**
+   * Get process PID running in a window
+   */
+  getWindowPid(windowName, host = null) {
+    try {
+      const cmd = this._cmd(
+        `tmux list-panes -t \${SESSION}:${windowName} -F '#{{pane_pid}}' 2>/dev/null`,
+        host
+      );
+      return this._exec(cmd).trim();
+    } catch {
+      return null;
+    }
+  }
+
+  // --- Host resolution ---
+
+  /** Get host config by name */
+  getHost(name) {
+    if (!name || name === 'local') return null;
+    return this.hosts.find(h => h.name === name) || null;
+  }
+
+  /** Get all configured hosts */
+  getAllHosts() {
+    return this.hosts;
+  }
+
+  /** Test SSH connectivity */
+  testHost(host) {
+    if (!host || host.type === 'local') return true;
+    try {
+      const sshCmd = this._sshCmd(host, 'echo ok');
+      this._exec(sshCmd, 5000);
+      return true;
+    } catch {
+      return false;
+    }
+  }
+
+  // --- Internal ---
+
+  /**
+   * Build command with SESSION variable substitution
+   * @param {string} tmpl - Command template with ${SESSION}
+   * @param {Object|null} host - Host config
+   * @returns {string} final command
+   */
+  _cmd(tmpl, host) {
+    const cmd = tmpl.replace(/\$\{SESSION\}/g, this.sessionName);
+    if (!host || host.type === 'local') return cmd;
+    return this._sshCmd(host, cmd);
+  }
+
+  _sshCmd(host, cmd) {
+    const parts = ['ssh', '-o', 'ConnectTimeout=5', '-o', 'BatchMode=yes'];
+    if (host.port && host.port !== '22') parts.push('-p', host.port);
+    if (host.key) parts.push('-i', host.key);
+    parts.push(`${host.user}@${host.host}`);
+    parts.push(cmd);
+    return parts.join(' ');
+  }
+
+  _exec(cmd, timeout = 10000) {
+    return execSync(cmd, {
+      encoding: 'utf8',
+      timeout,
+      stdio: ['pipe', 'pipe', 'pipe']
+    });
+  }
+}
+
+module.exports = TmuxManager;