@mmmbuto/nexuscli 0.5.0

package/lib/server/db/adapter.js

@@ -0,0 +1,314 @@
+const path = require('path');
+const fs = require('fs');
+
+// Termux-only: all data in ~/.nexuscli
+const dbDir = path.join(process.env.HOME, '.nexuscli');
+const dbPath = path.join(dbDir, 'nexuscli.db');
+
+// Ensure directory exists
+if (!fs.existsSync(dbDir)) {
+  fs.mkdirSync(dbDir, { recursive: true });
+  console.log(`✅ Created database directory: ${dbDir}`);
+}
+
+// Termux-only: use sql.js (no native compilation needed)
+const Driver = require('./drivers/sql-js');
+let db = null;
+
+console.log(`📦 Using sql.js driver (Termux-compatible)`);
+
+// Initialize database
+async function initDb(options = {}) {
+  const { skipMigrationCheck = false } = options;
+  const driver = new Driver(dbPath);
+  await driver.init();
+  db = driver;
+
+  console.log(`✅ Database ready: ${dbPath}`);
+
+  // Initialize schema
+  initSchema();
+
+  if (!skipMigrationCheck) {
+    const needsMigration = await checkMigrationNeeded();
+
+    if (needsMigration) {
+      console.log('[DB] Migration required - running migrations...');
+      const { runMigrations } = require('./migrate');
+      await runMigrations({ skipInit: true });
+    }
+  }
+
+  return db;
+}
+
+function initSchema() {
+  db.exec(`
+    -- Conversations table
+    CREATE TABLE IF NOT EXISTS conversations (
+      id TEXT PRIMARY KEY,
+      title TEXT NOT NULL,
+      created_at INTEGER NOT NULL,
+      updated_at INTEGER NOT NULL,
+      metadata TEXT
+    );
+
+    CREATE INDEX IF NOT EXISTS idx_conversations_updated_at
+    ON conversations(updated_at DESC);
+
+    -- Messages table
+    CREATE TABLE IF NOT EXISTS messages (
+      id TEXT PRIMARY KEY,
+      conversation_id TEXT NOT NULL,
+      role TEXT NOT NULL CHECK(role IN ('user', 'assistant', 'system')),
+      content TEXT NOT NULL,
+      created_at INTEGER NOT NULL,
+      metadata TEXT,
+      FOREIGN KEY (conversation_id) REFERENCES conversations(id) ON DELETE CASCADE
+    );
+
+    CREATE INDEX IF NOT EXISTS idx_messages_conversation_id
+    ON messages(conversation_id);
+
+    CREATE INDEX IF NOT EXISTS idx_messages_created_at
+    ON messages(created_at ASC);
+
+    -- Jobs table
+    CREATE TABLE IF NOT EXISTS jobs (
+      id TEXT PRIMARY KEY,
+      conversation_id TEXT,
+      message_id TEXT,
+      node_id TEXT NOT NULL,
+      tool TEXT NOT NULL,
+      command TEXT NOT NULL,
+      status TEXT NOT NULL CHECK(status IN ('queued', 'executing', 'completed', 'failed', 'cancelled')),
+      exit_code INTEGER,
+      stdout TEXT,
+      stderr TEXT,
+      duration INTEGER,
+      created_at INTEGER NOT NULL,
+      started_at INTEGER,
+      completed_at INTEGER,
+      FOREIGN KEY (conversation_id) REFERENCES conversations(id) ON DELETE SET NULL,
+      FOREIGN KEY (message_id) REFERENCES messages(id) ON DELETE SET NULL
+    );
+
+    CREATE INDEX IF NOT EXISTS idx_jobs_conversation_id
+    ON jobs(conversation_id);
+
+    CREATE INDEX IF NOT EXISTS idx_jobs_status
+    ON jobs(status);
+
+    CREATE INDEX IF NOT EXISTS idx_jobs_created_at
+    ON jobs(created_at DESC);
+
+    -- Users table
+    CREATE TABLE IF NOT EXISTS users (
+      id TEXT PRIMARY KEY,
+      username TEXT UNIQUE NOT NULL,
+      password_hash TEXT NOT NULL,
+      role TEXT NOT NULL DEFAULT 'user' CHECK(role IN ('admin', 'user')),
+      is_locked INTEGER NOT NULL DEFAULT 0,
+      failed_attempts INTEGER NOT NULL DEFAULT 0,
+      last_failed_attempt INTEGER,
+      locked_until INTEGER,
+      created_at INTEGER NOT NULL,
+      last_login INTEGER
+    );
+
+    CREATE INDEX IF NOT EXISTS idx_users_username
+    ON users(username);
+
+    -- Login attempts table
+    CREATE TABLE IF NOT EXISTS login_attempts (
+      id INTEGER PRIMARY KEY AUTOINCREMENT,
+      ip_address TEXT NOT NULL,
+      username TEXT,
+      success INTEGER NOT NULL DEFAULT 0,
+      timestamp INTEGER NOT NULL
+    );
+
+    CREATE INDEX IF NOT EXISTS idx_login_attempts_ip
+    ON login_attempts(ip_address, timestamp DESC);
+
+    CREATE INDEX IF NOT EXISTS idx_login_attempts_timestamp
+    ON login_attempts(timestamp DESC);
+
+    -- Nodes table
+    CREATE TABLE IF NOT EXISTS nodes (
+      id TEXT PRIMARY KEY,
+      hostname TEXT NOT NULL,
+      ip_address TEXT,
+      status TEXT NOT NULL CHECK(status IN ('online', 'offline', 'error')),
+      capabilities TEXT,
+      last_heartbeat INTEGER,
+      created_at INTEGER NOT NULL
+    );
+
+    CREATE INDEX IF NOT EXISTS idx_nodes_status
+    ON nodes(status);
+
+    -- API Keys table (encrypted storage for provider keys)
+    CREATE TABLE IF NOT EXISTS api_keys (
+      provider TEXT PRIMARY KEY,
+      api_key TEXT NOT NULL,
+      created_at INTEGER NOT NULL,
+      updated_at INTEGER NOT NULL
+    );
+  `);
+
+  console.log('✅ Database schema initialized');
+}
+
+/**
+ * Get API key for a provider
+ * @param {string} provider - Provider name (e.g., 'deepseek', 'openai')
+ * @returns {string|null} API key or null if not found
+ */
+function getApiKey(provider) {
+  if (!db) return null;
+  try {
+    const stmt = db.prepare('SELECT api_key FROM api_keys WHERE provider = ?');
+    const row = stmt.get(provider.toLowerCase());
+    return row?.api_key || null;
+  } catch (err) {
+    console.error(`[DB] Error getting API key for ${provider}:`, err.message);
+    return null;
+  }
+}
+
+/**
+ * Set API key for a provider
+ * @param {string} provider - Provider name
+ * @param {string} apiKey - API key value
+ * @returns {boolean} Success
+ */
+function setApiKey(provider, apiKey) {
+  if (!db) return false;
+  try {
+    const now = Date.now();
+    const stmt = db.prepare(`
+      INSERT INTO api_keys (provider, api_key, created_at, updated_at)
+      VALUES (?, ?, ?, ?)
+      ON CONFLICT(provider) DO UPDATE SET api_key = ?, updated_at = ?
+    `);
+    stmt.run(provider.toLowerCase(), apiKey, now, now, apiKey, now);
+    db.save();
+    return true;
+  } catch (err) {
+    console.error(`[DB] Error setting API key for ${provider}:`, err.message);
+    return false;
+  }
+}
+
+/**
+ * Delete API key for a provider
+ * @param {string} provider - Provider name
+ * @returns {boolean} Success
+ */
+function deleteApiKey(provider) {
+  if (!db) return false;
+  try {
+    const stmt = db.prepare('DELETE FROM api_keys WHERE provider = ?');
+    stmt.run(provider.toLowerCase());
+    db.save();
+    return true;
+  } catch (err) {
+    console.error(`[DB] Error deleting API key for ${provider}:`, err.message);
+    return false;
+  }
+}
+
+/**
+ * List all configured API key providers (without exposing keys)
+ * @returns {Array} List of provider names
+ */
+function listApiKeyProviders() {
+  if (!db) return [];
+  try {
+    const stmt = db.prepare('SELECT provider, created_at, updated_at FROM api_keys');
+    return stmt.all();
+  } catch (err) {
+    console.error('[DB] Error listing API key providers:', err.message);
+    return [];
+  }
+}
+
+async function checkMigrationNeeded() {
+  const currentDb = getDb();
+
+  if (!currentDb) {
+    console.error('[DB] Cannot check migration status - DB not initialized');
+    return false;
+  }
+
+  try {
+    const hasSessionsStmt = currentDb.prepare(`
+      SELECT name FROM sqlite_master
+      WHERE type='table' AND name='sessions'
+    `);
+    const hasSessions = hasSessionsStmt.get();
+
+    if (!hasSessions) {
+      console.log('[DB] sessions table not found - migration needed');
+      return true;
+    }
+
+    const conversationsCount = currentDb.prepare('SELECT COUNT(*) as count FROM conversations').get();
+    const sessionsCount = currentDb.prepare('SELECT COUNT(*) as count FROM sessions').get();
+
+    if (conversationsCount.count > sessionsCount.count) {
+      console.log('[DB] Unmigrated conversations found - migration needed');
+      return true;
+    }
+
+    console.log('[DB] No migration needed');
+    return false;
+  } catch (error) {
+    console.error('[DB] Error checking migration status:', error);
+    return false;
+  }
+}
+
+function getDb() {
+  return db;
+}
+
+function prepare(sql) {
+  return db.prepare(sql);
+}
+
+function saveDb() {
+  if (db) db.save();
+}
+
+// Graceful shutdown
+process.on('exit', () => {
+  if (db) {
+    db.close();
+    console.log('✅ Database connection closed');
+  }
+});
+
+process.on('SIGINT', () => {
+  if (db) {
+    db.close();
+    console.log('✅ Database connection closed (SIGINT)');
+  }
+  process.exit(0);
+});
+
+process.on('SIGTERM', () => {
+  if (db) db.close();
+});
+
+module.exports = {
+  initDb,
+  getDb,
+  prepare,
+  saveDb,
+  getApiKey,
+  setApiKey,
+  deleteApiKey,
+  listApiKeyProviders
+};

package/lib/server/db/drivers/better-sqlite3.js

@@ -0,0 +1,38 @@
+const Database = require('better-sqlite3');
+
+class BetterSqlite3Driver {
+  constructor(dbPath) {
+    this.dbPath = dbPath;
+    this.db = null;
+  }
+
+  async init() {
+    this.db = new Database(this.dbPath, {
+      verbose: process.env.NODE_ENV === 'development' ? console.log : null
+    });
+
+    // Enable WAL mode for better concurrency
+    this.db.pragma('journal_mode = WAL');
+    this.db.pragma('foreign_keys = ON');
+  }
+
+  save() {
+    // better-sqlite3 auto-saves, no-op
+  }
+
+  exec(sql) {
+    return this.db.exec(sql);
+  }
+
+  prepare(sql) {
+    return this.db.prepare(sql);
+  }
+
+  close() {
+    if (this.db) {
+      this.db.close();
+    }
+  }
+}
+
+module.exports = BetterSqlite3Driver;

package/lib/server/db/drivers/sql-js.js

@@ -0,0 +1,75 @@
+const initSqlJs = require('sql.js');
+const fs = require('fs');
+
+class SqlJsDriver {
+  constructor(dbPath) {
+    this.dbPath = dbPath;
+    this.db = null;
+    this.saveInterval = null;
+  }
+
+  async init() {
+    const SQL = await initSqlJs();
+
+    if (fs.existsSync(this.dbPath)) {
+      const buffer = fs.readFileSync(this.dbPath);
+      this.db = new SQL.Database(buffer);
+    } else {
+      this.db = new SQL.Database();
+    }
+
+    // Auto-save every 5 seconds
+    this.saveInterval = setInterval(() => this.save(), 5000);
+  }
+
+  save() {
+    if (!this.db) return;
+    const data = this.db.export();
+    const buffer = Buffer.from(data);
+    fs.writeFileSync(this.dbPath, buffer);
+  }
+
+  exec(sql) {
+    return this.db.run(sql);
+  }
+
+  prepare(sql) {
+    const stmt = this.db.prepare(sql);
+    return {
+      run: (...params) => {
+        stmt.bind(params);
+        stmt.step();
+        stmt.reset();
+        this.save();
+      },
+      get: (...params) => {
+        stmt.bind(params);
+        const result = stmt.step() ? stmt.getAsObject() : null;
+        stmt.reset();
+        return result;
+      },
+      all: (...params) => {
+        stmt.bind(params);
+        const results = [];
+        while (stmt.step()) {
+          results.push(stmt.getAsObject());
+        }
+        stmt.reset();
+        return results;
+      }
+    };
+  }
+
+  close() {
+    if (this.db) {
+      this.save();
+      this.db.close();
+    }
+    if (this.saveInterval) {
+      clearInterval(this.saveInterval);
+      this.saveInterval = null;
+    }
+  }
+}
+
+module.exports = SqlJsDriver;

package/lib/server/db/migrate.js

@@ -0,0 +1,174 @@
+const fs = require('fs');
+const path = require('path');
+const { initDb, getDb, saveDb } = require('./adapter');
+
+const MIGRATIONS_DIR = path.join(__dirname, 'migrations');
+
+/**
+ * Get list of migration files in order
+ */
+function getMigrationFiles() {
+  const files = fs.readdirSync(MIGRATIONS_DIR)
+    .filter(f => f.endsWith('.sql'))
+    .sort(); // Alphabetical order ensures numeric order (001_, 002_, etc.)
+  return files;
+}
+
+/**
+ * Normalize and split SQL into executable statements.
+ * Keeps CREATE/INSERT blocks while stripping comment-only lines.
+ */
+function parseSqlStatements(sql) {
+  return sql
+    .replace(/\r\n/g, '\n')
+    .split(';')
+    .map(stmt => stmt.trim())
+    .map(stmt => {
+      const lines = stmt
+        .split('\n')
+        .map(line => line.trim())
+        .filter(line => line.length > 0 && !line.startsWith('--'));
+      return lines.join('\n').trim();
+    })
+    .filter(stmt => stmt.length > 0);
+}
+
+/**
+ * Get applied migrations from DB
+ */
+function getAppliedMigrations(db) {
+  try {
+    // Ensure migrations table exists
+    db.exec(`
+      CREATE TABLE IF NOT EXISTS _migrations (
+        id INTEGER PRIMARY KEY AUTOINCREMENT,
+        name TEXT UNIQUE NOT NULL,
+        applied_at INTEGER NOT NULL
+      )
+    `);
+
+    const stmt = db.prepare('SELECT name FROM _migrations ORDER BY id');
+    return stmt.all().map(row => row.name);
+  } catch (error) {
+    console.error('[Migration] Error getting applied migrations:', error.message);
+    return [];
+  }
+}
+
+/**
+ * Mark migration as applied
+ */
+function markMigrationApplied(db, name) {
+  const stmt = db.prepare('INSERT INTO _migrations (name, applied_at) VALUES (?, ?)');
+  stmt.run(name, Date.now());
+}
+
+/**
+ * Run a single migration file
+ */
+function runMigrationFile(db, filename) {
+  const filePath = path.join(MIGRATIONS_DIR, filename);
+  const migrationSql = fs.readFileSync(filePath, 'utf8');
+  const statements = parseSqlStatements(migrationSql);
+
+  console.log(`[Migration] Running ${filename} (${statements.length} statements)`);
+
+  for (let i = 0; i < statements.length; i++) {
+    const stmt = statements[i];
+
+    if (/^SELECT/i.test(stmt)) {
+      // Skip verification SELECT statements
+      continue;
+    }
+
+    try {
+      db.exec(stmt);
+    } catch (error) {
+      // Handle "duplicate column" errors gracefully
+      if (error.message.includes('duplicate column')) {
+        console.log(`[Migration] Column already exists (skipping): ${error.message}`);
+        continue;
+      }
+      console.error(`[Migration] Failed at statement ${i + 1}: ${error.message}`);
+      console.error('Statement preview:', stmt.substring(0, 200));
+      throw error;
+    }
+  }
+
+  markMigrationApplied(db, filename);
+  console.log(`[Migration] ✅ ${filename} applied`);
+}
+
+/**
+ * Run database migrations.
+ * @param {Object} options
+ * @param {boolean} options.skipInit - skip initDb (adapter already initialized)
+ */
+async function runMigrations(options = {}) {
+  const { skipInit = false } = options;
+
+  console.log('[Migration] Starting database migration...');
+
+  if (!skipInit && !getDb()) {
+    await initDb({ skipMigrationCheck: true });
+  }
+
+  const db = getDb();
+
+  if (!db) {
+    throw new Error('[Migration] Database instance not initialized');
+  }
+
+  const migrationFiles = getMigrationFiles();
+  const appliedMigrations = getAppliedMigrations(db);
+
+  console.log(`[Migration] Found ${migrationFiles.length} migration files`);
+  console.log(`[Migration] Already applied: ${appliedMigrations.length}`);
+
+  const pendingMigrations = migrationFiles.filter(f => !appliedMigrations.includes(f));
+
+  if (pendingMigrations.length === 0) {
+    console.log('[Migration] No pending migrations');
+    return;
+  }
+
+  console.log(`[Migration] Pending: ${pendingMigrations.join(', ')}`);
+
+  for (const file of pendingMigrations) {
+    runMigrationFile(db, file);
+  }
+
+  saveDb();
+
+  console.log('[Migration] All migrations completed');
+
+  // Verification counts
+  try {
+    const verifyStmt = db.prepare(`
+      SELECT 'conversations' as table_name, COUNT(*) as count FROM conversations
+      UNION ALL
+      SELECT 'sessions' as table_name, COUNT(*) as count FROM sessions
+    `);
+
+    const counts = verifyStmt.all();
+    console.log('[Migration] Verification:');
+    counts.forEach(row => console.log(`  ${row.table_name}: ${row.count} rows`));
+  } catch (error) {
+    console.error('[Migration] Verification failed:', error.message);
+  }
+}
+
+// Run if called directly
+if (require.main === module) {
+  runMigrations()
+    .then(() => {
+      console.log('[Migration] Complete');
+      process.exit(0);
+    })
+    .catch(error => {
+      console.error('[Migration] Failed:', error);
+      process.exit(1);
+    });
+}
+
+module.exports = { runMigrations };

package/lib/server/db/migrations/001_ultra_light_schema.sql

@@ -0,0 +1,96 @@
+-- ============================================================
+-- SESSIONS: Lightweight index of all CLI sessions
+-- ============================================================
+CREATE TABLE IF NOT EXISTS sessions (
+  id TEXT PRIMARY KEY,
+  engine TEXT NOT NULL DEFAULT 'claude-code',
+  workspace_path TEXT NOT NULL,
+  session_path TEXT,
+  title TEXT NOT NULL,
+  last_used_at INTEGER NOT NULL,
+  created_at INTEGER NOT NULL,
+  pinned INTEGER DEFAULT 0,
+  importance INTEGER DEFAULT 0,
+  message_count INTEGER DEFAULT 0,
+  metadata TEXT
+);
+
+CREATE INDEX IF NOT EXISTS idx_sessions_workspace ON sessions(workspace_path);
+CREATE INDEX IF NOT EXISTS idx_sessions_last_used ON sessions(last_used_at DESC);
+CREATE INDEX IF NOT EXISTS idx_sessions_pinned ON sessions(pinned, last_used_at DESC);
+
+-- ============================================================
+-- SESSION_SUMMARIES: Contextual memory for each session
+-- ============================================================
+CREATE TABLE IF NOT EXISTS session_summaries (
+  session_id TEXT PRIMARY KEY,
+  summary_short TEXT NOT NULL,
+  summary_long TEXT,
+  key_decisions TEXT,
+  tools_used TEXT,
+  files_modified TEXT,
+  updated_at INTEGER NOT NULL,
+  version INTEGER DEFAULT 1,
+  FOREIGN KEY (session_id) REFERENCES sessions(id) ON DELETE CASCADE
+);
+
+CREATE INDEX IF NOT EXISTS idx_summaries_updated ON session_summaries(updated_at DESC);
+
+-- ============================================================
+-- WORKSPACE_MEMORY: Project-level context (optional)
+-- ============================================================
+CREATE TABLE IF NOT EXISTS workspace_memory (
+  id INTEGER PRIMARY KEY AUTOINCREMENT,
+  workspace_path TEXT UNIQUE NOT NULL,
+  summary TEXT,
+  tech_stack TEXT,
+  architecture_notes TEXT,
+  important_files TEXT,
+  session_count INTEGER DEFAULT 0,
+  last_activity INTEGER,
+  updated_at INTEGER NOT NULL
+);
+
+CREATE INDEX IF NOT EXISTS idx_workspace_memory_activity ON workspace_memory(last_activity DESC);
+
+-- ============================================================
+-- MIGRATION: Map old conversations to new sessions
+-- ============================================================
+INSERT INTO sessions (
+  id,
+  engine,
+  workspace_path,
+  session_path,
+  title,
+  last_used_at,
+  created_at,
+  pinned,
+  importance,
+  message_count,
+  metadata
+)
+SELECT
+  c.id,
+  'claude-code' as engine,
+  COALESCE(
+    json_extract(c.metadata, '$.workspace'),
+    '/data/data/com.termux/files/home/Dev/NexusCLI/backend'
+  ) as workspace_path,
+  NULL as session_path,
+  c.title,
+  c.updated_at as last_used_at,
+  c.created_at,
+  COALESCE(json_extract(c.metadata, '$.bookmarked'), 0) as pinned,
+  0 as importance,
+  (SELECT COUNT(*) FROM messages WHERE conversation_id = c.id) as message_count,
+  c.metadata
+FROM conversations c
+WHERE NOT EXISTS (SELECT 1 FROM sessions WHERE id = c.id);
+
+-- ============================================================
+-- VERIFICATION: Count check
+-- ============================================================
+-- This will be run separately for verification
+-- SELECT 'OLD' as source, COUNT(*) as count FROM conversations
+-- UNION ALL
+-- SELECT 'NEW' as source, COUNT(*) as count FROM sessions;

package/lib/server/db/migrations/002_session_conversation_mapping.sql

@@ -0,0 +1,19 @@
+-- ============================================================
+-- MIGRATION 002: Add conversation_id mapping to sessions
+-- Enables sync pattern: conversationId -> sessionId per engine
+-- ============================================================
+
+-- Add conversation_id column for frontend mapping
+ALTER TABLE sessions ADD COLUMN conversation_id TEXT;
+
+-- Index for fast lookup by conversation
+CREATE INDEX IF NOT EXISTS idx_sessions_conversation ON sessions(conversation_id);
+
+-- Composite index for engine + conversation lookup
+CREATE INDEX IF NOT EXISTS idx_sessions_engine_conversation ON sessions(engine, conversation_id);
+
+-- ============================================================
+-- BACKFILL: Set conversation_id = id for existing sessions
+-- (maintains backwards compatibility)
+-- ============================================================
+UPDATE sessions SET conversation_id = id WHERE conversation_id IS NULL;