@mmmbuto/nexuscrew 0.2.5 → 0.4.1

package/lib/services/session-store.js

@@ -1,198 +0,0 @@
-/**
- * SessionStore — SQLite persistence for nexuscrew
- *
- * Schema:
- * - 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');
-
-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,
-        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)');
-  }
-
-  _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, tmuxSession, logPath, launcherId } = {}) {
-    const id = uuidv4();
-    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) {
-    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', 'tmux_session', 'log_path', 'workspace', 'host', 'status', 'launcher_id'].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);
-  }
-
-  findByTmuxSession(sessionName) {
-    return this.db.prepare('SELECT * FROM conversations WHERE tmux_session = ?').get(sessionName);
-  }
-
-  /** 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_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' });
-        }
-      }
-    }
-  }
-
-  /** Close DB connection */
-  close() {
-    this.db.close();
-  }
-}
-
-module.exports = SessionStore;

package/lib/services/tmux-manager.js

@@ -1,288 +0,0 @@
-/**
- * TmuxManager — Core tmux operations for nexuscrew
- *
- * The primary unit is a standalone tmux session. nexuscrew never creates
- * implicit "master" sessions and never assumes ownership of all tmux state.
- */
-
-const { execSync } = require('child_process');
-const path = require('path');
-const fs = require('fs');
-const os = require('os');
-
-class TmuxManager {
-  constructor(config = {}) {
-    this.logDir = config.logDir || path.join(os.homedir(), '.nexuscrew', 'logs');
-    this.configDir = config.configDir || path.dirname(this.logDir);
-    this.hosts = config.hosts || [{ name: 'local', type: 'local' }];
-    this.shell = config.preferredShell || process.env.SHELL || '/bin/sh';
-
-    if (!fs.existsSync(this.logDir)) {
-      fs.mkdirSync(this.logDir, { recursive: true });
-    }
-  }
-
-  listSessions(host = null) {
-    try {
-      const cmd = this._cmd(
-        "tmux list-sessions -F '#{session_name}\t#{session_attached}\t#{session_windows}\t#{session_created}' 2>/dev/null",
-        host
-      );
-      const output = this._exec(cmd);
-      return output.trim().split('\n').filter(Boolean).map((line) => {
-        const [sessionName, attached, windows, created] = line.split('\t');
-        return {
-          sessionName,
-          attached: attached === '1',
-          windows: Number(windows || 0),
-          createdAt: created ? Number(created) : null
-        };
-      });
-    } catch {
-      return [];
-    }
-  }
-
-  hasSession(sessionName, host = null) {
-    try {
-      const cmd = this._cmd(`tmux has-session -t ${this._quote(sessionName)} 2>/dev/null`, host);
-      this._exec(cmd);
-      return true;
-    } catch {
-      return false;
-    }
-  }
-
-  createSession({ sessionName, cwd, host = null, launcherCommand = '', shell = null }) {
-    const effectiveHost = this._resolveHost(host);
-    const runtime = this.getRuntimeInfo(effectiveHost);
-    const effectiveShell = shell || runtime.shell || this.shell;
-    const workingDir = cwd || runtime.homeDir || os.homedir();
-
-    if (this.hasSession(sessionName, effectiveHost)) {
-      throw new Error(`tmux session "${sessionName}" already exists`);
-    }
-
-    const shellCmd = this._interactiveShellCommand(effectiveShell);
-    const createCmd = this._cmd(
-      `tmux new-session -d -s ${this._quote(sessionName)} -c ${this._quote(workingDir)} ${this._quote(shellCmd)}`,
-      effectiveHost
-    );
-    this._exec(createCmd);
-
-    const logPath = this.ensureSessionLogging(sessionName, effectiveHost);
-    if (launcherCommand && launcherCommand.trim()) {
-      this.sendKeys(sessionName, launcherCommand.trim(), { enter: true, host: effectiveHost });
-    }
-
-    return { sessionName, logPath };
-  }
-
-  ensureSessionLogging(sessionName, host = null) {
-    const effectiveHost = this._resolveHost(host);
-    if (effectiveHost && effectiveHost.type !== 'local') {
-      return null;
-    }
-    const logPath = path.join(this.logDir, `${sessionName}.log`);
-    const pipeCmd = this._cmd(
-      `tmux pipe-pane -o -t ${this._quote(sessionName)} ${this._quote(`cat >> ${logPath}`)}`,
-      effectiveHost
-    );
-    this._exec(pipeCmd);
-    return logPath;
-  }
-
-  sendKeys(sessionName, text, opts = {}) {
-    const effectiveHost = this._resolveHost(opts.host);
-    const enterSuffix = opts.enter ? ' Enter' : '';
-    const escapedText = text.replace(/'/g, "'\\''");
-    const cmd = this._cmd(
-      `tmux send-keys -t ${this._quote(sessionName)} '${escapedText}'${enterSuffix}`,
-      effectiveHost
-    );
-    this._exec(cmd);
-  }
-
-  sendSpecialKey(sessionName, key, host = null) {
-    const effectiveHost = this._resolveHost(host);
-    const cmd = this._cmd(
-      `tmux send-keys -t ${this._quote(sessionName)} ${key}`,
-      effectiveHost
-    );
-    this._exec(cmd);
-  }
-
-  interrupt(sessionName, host = null) {
-    const effectiveHost = this._resolveHost(host);
-    this.sendSpecialKey(sessionName, 'Escape', effectiveHost);
-    setTimeout(() => {
-      this.sendSpecialKey(sessionName, 'C-c', effectiveHost);
-    }, 100);
-  }
-
-  capturePane(sessionName, host = null) {
-    try {
-      const cmd = this._cmd(
-        `tmux capture-pane -t ${this._quote(sessionName)} -p -S -100`,
-        this._resolveHost(host)
-      );
-      return this._exec(cmd);
-    } catch {
-      return '';
-    }
-  }
-
-  killSession(sessionName, host = null) {
-    try {
-      const cmd = this._cmd(
-        `tmux kill-session -t ${this._quote(sessionName)} 2>/dev/null`,
-        this._resolveHost(host)
-      );
-      this._exec(cmd);
-    } catch {}
-  }
-
-  getHost(name) {
-    if (!name || name === 'local') return null;
-    return this.hosts.find((h) => h.name === name) || null;
-  }
-
-  getAllHosts() {
-    return this.hosts;
-  }
-
-  testHost(host) {
-    const effectiveHost = this._resolveHost(host);
-    if (!effectiveHost || effectiveHost.type === 'local') return true;
-    try {
-      this._exec(this._sshCmd(effectiveHost, 'echo ok'), 5000);
-      return true;
-    } catch {
-      return false;
-    }
-  }
-
-  _resolveHost(host) {
-    if (!host || host === 'local') return null;
-    if (typeof host === 'string') return this.getHost(host);
-    return host;
-  }
-
-  getRuntimeInfo(host = null) {
-    const effectiveHost = this._resolveHost(host);
-    if (!effectiveHost || effectiveHost.type === 'local') {
-      return {
-        homeDir: os.homedir(),
-        shell: this.shell,
-        platform: process.platform,
-        host: 'local'
-      };
-    }
-
-    try {
-      const output = this.execCommand(
-        "printf '__NEXUSCREW_HOME__%s\\n' \"$HOME\"; printf '__NEXUSCREW_SHELL__%s\\n' \"${SHELL:-/bin/sh}\"; uname -s",
-        effectiveHost,
-        5000
-      );
-      const lines = output.trim().split('\n');
-      const homeDir = lines.find((line) => line.startsWith('__NEXUSCREW_HOME__'))?.replace('__NEXUSCREW_HOME__', '') || '';
-      const shell = lines.find((line) => line.startsWith('__NEXUSCREW_SHELL__'))?.replace('__NEXUSCREW_SHELL__', '') || '/bin/sh';
-      const uname = lines[lines.length - 1] || '';
-      return {
-        homeDir: homeDir || '',
-        shell: shell || '/bin/sh',
-        platform: this._mapPlatform(uname),
-        host: effectiveHost.name || 'remote'
-      };
-    } catch {
-      return {
-        homeDir: '',
-        shell: '/bin/sh',
-        platform: 'unknown',
-        host: effectiveHost.name || 'remote'
-      };
-    }
-  }
-
-  execCommand(cmd, host = null, timeout = 10000) {
-    return this._exec(this._cmd(cmd, host), timeout);
-  }
-
-  resolveCommand(command, host = null) {
-    try {
-      const output = this.execCommand(`command -v ${command} 2>/dev/null`, host, 5000).trim();
-      return output || null;
-    } catch {
-      return null;
-    }
-  }
-
-  fileExists(filePath, host = null) {
-    try {
-      this.execCommand(`test -f ${this._quote(filePath)}`, host, 5000);
-      return true;
-    } catch {
-      return false;
-    }
-  }
-
-  readFile(filePath, host = null) {
-    return this.execCommand(`cat ${this._quote(filePath)}`, host, 5000);
-  }
-
-  runInteractiveShell(shellPath, script, host = null) {
-    const shellName = path.basename(shellPath || '/bin/sh');
-    const shellArgs = this._shellArgs(shellName, script)
-      .map((arg) => this._quote(arg))
-      .join(' ');
-    return this.execCommand(`${this._quote(shellPath)} ${shellArgs}`, host, 10000);
-  }
-
-  _interactiveShellCommand(shellPath) {
-    const shellName = path.basename(shellPath || '/bin/sh');
-    if (shellName === 'bash' || shellName === 'zsh') {
-      return `${shellPath} -il`;
-    }
-    if (shellName === 'fish') {
-      return `${shellPath} -i`;
-    }
-    return `${shellPath} -l`;
-  }
-
-  _cmd(cmd, host) {
-    const effectiveHost = this._resolveHost(host);
-    if (!effectiveHost || effectiveHost.type === 'local') return cmd;
-    return this._sshCmd(effectiveHost, 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(this._quote(cmd));
-    return parts.join(' ');
-  }
-
-  _quote(value) {
-    return `'${String(value).replace(/'/g, `'\\''`)}'`;
-  }
-
-  _mapPlatform(uname) {
-    const value = String(uname || '').trim().toLowerCase();
-    if (value === 'darwin') return 'darwin';
-    if (value === 'linux') return 'linux';
-    return value || 'unknown';
-  }
-
-  _exec(cmd, timeout = 10000) {
-    return execSync(cmd, {
-      encoding: 'utf8',
-      timeout,
-      stdio: ['pipe', 'pipe', 'pipe']
-    });
-  }
-}
-
-module.exports = TmuxManager;