@mmmbuto/nexuscrew 0.2.0 → 0.2.2

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,21 +107,21 @@ 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 */
@@ -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' ? conv.host : null);
+      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();
   }
 }
 

package/lib/services/tmux-manager.js

@@ -1,124 +1,125 @@
 /**
  * TmuxManager — Core tmux operations for nexuscrew
  *
- * Manages tmux sessions locally and remotely via SSH.
- * Every AI session = one tmux window inside the master session.
+ * The primary unit is a standalone tmux session. nexuscrew never creates
+ * implicit "master" sessions and never assumes ownership of all tmux state.
  */
 
-const { execSync, exec } = require('child_process');
+const { execSync } = require('child_process');
 const path = require('path');
 const fs = require('fs');
-
-const TMUX_SESSION = 'nexuscrew';
+const os = require('os');
 
 class TmuxManager {
   constructor(config = {}) {
-    this.sessionName = config.tmuxSession || TMUX_SESSION;
-    this.logDir = config.logDir || path.join(process.env.HOME, '.nexuscrew', 'logs');
+    this.logDir = config.logDir || path.join(os.homedir(), '.nexuscrew', 'logs');
     this.hosts = config.hosts || [{ name: 'local', type: 'local' }];
+    this.shell = config.preferredShell || process.env.SHELL || '/bin/sh';
 
-    // 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);
+  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 [];
+    }
   }
 
-  /** Check if master session exists */
-  hasSession(host = null) {
+  hasSession(sessionName, host = null) {
     try {
-      this._exec(this._cmd('tmux has-session -t ${SESSION} 2>/dev/null', host));
+      const cmd = this._cmd(`tmux has-session -t ${this._quote(sessionName)} 2>/dev/null`, host);
+      this._exec(cmd);
       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);
+  createSession({ sessionName, cwd, host = null, launcherCommand = '', shell = null }) {
+    const effectiveHost = this._resolveHost(host);
+    const effectiveShell = shell || this.shell;
+    const workingDir = cwd || os.homedir();
 
-    // For remote hosts, logs go to a local path
-    const fullCommand = cwd
-      ? `cd ${cwd} && ${command} 2>&1 | tee ${logPath}`
-      : `${command} 2>&1 | tee ${logPath}`;
+    if (this.hasSession(sessionName, effectiveHost)) {
+      throw new Error(`tmux session "${sessionName}" already exists`);
+    }
 
-    const cmd = this._cmd(
-      `tmux new-window -t \${SESSION} -n ${windowName} -c '${cwd || process.env.HOME}' "${fullCommand.replace(/"/g, '\\"')}"`,
-      host
+    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);
 
-    this._exec(cmd);
+    const logPath = this.ensureSessionLogging(sessionName, effectiveHost);
+    if (launcherCommand && launcherCommand.trim()) {
+      this.sendKeys(sessionName, launcherCommand.trim(), { enter: true, host: effectiveHost });
+    }
 
-    return { windowName, logPath };
+    return { sessionName, 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 = {}) {
+  ensureSessionLogging(sessionName, host = null) {
+    const effectiveHost = this._resolveHost(host);
+    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 \${SESSION}:${windowName} '${escapedText}'${enterSuffix}`,
-      opts.host
+      `tmux send-keys -t ${this._quote(sessionName)} '${escapedText}'${enterSuffix}`,
+      effectiveHost
     );
     this._exec(cmd);
   }
 
-  /**
-   * Send a special key (C-c, Escape, etc.)
-   */
-  sendSpecialKey(windowName, key, host = null) {
+  sendSpecialKey(sessionName, key, host = null) {
+    const effectiveHost = this._resolveHost(host);
     const cmd = this._cmd(
-      `tmux send-keys -t \${SESSION}:${windowName} ${key}`,
-      host
+      `tmux send-keys -t ${this._quote(sessionName)} ${key}`,
+      effectiveHost
     );
     this._exec(cmd);
   }
 
-  /** Interrupt: Escape then C-c (works for Claude/Codex/Gemini/Qwen) */
-  interrupt(windowName, host = null) {
-    this.sendSpecialKey(windowName, 'Escape', host);
+  interrupt(sessionName, host = null) {
+    const effectiveHost = this._resolveHost(host);
+    this.sendSpecialKey(sessionName, 'Escape', effectiveHost);
     setTimeout(() => {
-      this.sendSpecialKey(windowName, 'C-c', host);
+      this.sendSpecialKey(sessionName, 'C-c', effectiveHost);
     }, 100);
   }
 
-  /**
-   * Capture current pane content
-   * @returns {string} visible text in the pane
-   */
-  capturePane(windowName, host = null) {
+  capturePane(sessionName, host = null) {
     try {
       const cmd = this._cmd(
-        `tmux capture-pane -t \${SESSION}:${windowName} -p -S -100`,
-        host
+        `tmux capture-pane -t ${this._quote(sessionName)} -p -S -100`,
+        this._resolveHost(host)
       );
       return this._exec(cmd);
     } catch {
@@ -126,113 +127,57 @@ class TmuxManager {
     }
   }
 
-  /**
-   * 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) {
+  killSession(sessionName, host = null) {
     try {
       const cmd = this._cmd(
-        `tmux kill-window -t \${SESSION}:${windowName} 2>/dev/null`,
-        host
+        `tmux kill-session -t ${this._quote(sessionName)} 2>/dev/null`,
+        this._resolveHost(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;
+    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;
+    const effectiveHost = this._resolveHost(host);
+    if (!effectiveHost || effectiveHost.type === 'local') return true;
     try {
-      const sshCmd = this._sshCmd(host, 'echo ok');
-      this._exec(sshCmd, 5000);
+      this._exec(this._sshCmd(effectiveHost, 'echo ok'), 5000);
       return true;
     } catch {
       return false;
     }
   }
 
-  // --- Internal ---
+  _resolveHost(host) {
+    if (!host || host === 'local') return null;
+    if (typeof host === 'string') return this.getHost(host);
+    return host;
+  }
+
+  _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`;
+  }
 
-  /**
-   * 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);
+  _cmd(cmd, host) {
+    const effectiveHost = this._resolveHost(host);
+    if (!effectiveHost || effectiveHost.type === 'local') return cmd;
+    return this._sshCmd(effectiveHost, cmd);
   }
 
   _sshCmd(host, cmd) {
@@ -240,10 +185,14 @@ class TmuxManager {
     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);
+    parts.push(this._quote(cmd));
     return parts.join(' ');
   }
 
+  _quote(value) {
+    return `'${String(value).replace(/'/g, `'\\''`)}'`;
+  }
+
   _exec(cmd, timeout = 10000) {
     return execSync(cmd, {
       encoding: 'utf8',

package/package.json

@@ -1,7 +1,7 @@
 {
   "name": "@mmmbuto/nexuscrew",
-  "version": "0.2.0",
-  "description": "tmux-based AI cockpit — persistent sessions for Claude Code, Codex CLI, Gemini CLI, Qwen Code with remote SSH host support",
+  "version": "0.2.2",
+  "description": "tmux-based AI cockpit for real active sessions and launcher discovery across Termux, Linux, and macOS",
   "main": "lib/server/server.js",
   "bin": {
     "nexuscrew": "./bin/nexuscrew.js"
@@ -22,14 +22,10 @@
     "postinstall": "node bin/nexuscrew.js init --silent"
   },
   "dependencies": {
-    "bcryptjs": "^3.0.3",
+    "better-sqlite3": "npm:@mmmbuto/better-sqlite3-termux@12.8.0-termux.0",
     "commander": "^12.1.0",
     "cors": "^2.8.5",
     "express": "^4.21.0",
-    "express-rate-limit": "^8.2.1",
-    "jsonwebtoken": "^9.0.2",
-    "multer": "^2.0.2",
-    "sql.js": "^1.13.0",
     "uuid": "^10.0.0"
   },
   "optionalDependencies": {},