@mmmbuto/nexuscli 0.5.0

package/lib/server/models/Conversation.js

@@ -0,0 +1,259 @@
+const { prepare } = require('../db');
+const { v4: uuidv4 } = require('uuid');
+
+/**
+ * Conversation model - Manages chat sessions
+ */
+class Conversation {
+  /**
+   * Create new conversation
+   * @param {string} title - Conversation title
+   * @returns {Object} Created conversation
+   */
+  static create(title = 'New Conversation', workspacePath = null) {
+    const id = uuidv4();
+    const now = Date.now();
+
+    // Insert conversation
+    const stmt = prepare(`
+      INSERT INTO conversations (id, title, created_at, updated_at)
+      VALUES (?, ?, ?, ?)
+    `);
+
+    stmt.run(id, title, now, now);
+
+    // Also create session entry (for sidebar visibility)
+    // Use workspace where Claude CLI is executed (backend workdir)
+    const workspace = workspacePath || process.cwd();
+
+    const sessionStmt = prepare(`
+      INSERT INTO sessions (
+        id, engine, workspace_path, title,
+        last_used_at, created_at, message_count
+      )
+      VALUES (?, ?, ?, ?, ?, ?, ?)
+    `);
+
+    sessionStmt.run(
+      id,
+      'claude-code',
+      workspace,
+      title,
+      now,
+      now,
+      0
+    );
+
+    console.log(`[Conversation] Created conversation + session: ${id} in workspace ${workspace}`);
+
+    return {
+      id,
+      title,
+      created_at: now,
+      updated_at: now,
+      metadata: null
+    };
+  }
+
+  /**
+   * Get conversation by ID
+   * @param {string} id - Conversation ID
+   * @returns {Object|null} Conversation or null if not found
+   */
+  static getById(id) {
+    const stmt = prepare('SELECT * FROM conversations WHERE id = ?');
+    const conversation = stmt.get(id);
+
+    if (conversation && conversation.metadata) {
+      try {
+        conversation.metadata = JSON.parse(conversation.metadata);
+        // Map bookmarked to pinned for frontend compatibility
+        if (conversation.metadata.bookmarked !== undefined) {
+          conversation.metadata.pinned = conversation.metadata.bookmarked;
+        }
+      } catch (e) {
+        conversation.metadata = null;
+      }
+    }
+
+    return conversation;
+  }
+
+  /**
+   * List recent conversations
+   * @param {number} limit - Max number of conversations
+   * @returns {Array} List of conversations
+   */
+  static listRecent(limit = 20) {
+    const stmt = prepare(`
+      SELECT * FROM conversations
+      ORDER BY updated_at DESC
+      LIMIT ?
+    `);
+
+    const conversations = stmt.all(limit);
+
+    // Parse metadata and map bookmarked to pinned
+    conversations.forEach(conv => {
+      if (conv.metadata) {
+        try {
+          conv.metadata = JSON.parse(conv.metadata);
+          // Map bookmarked to pinned for frontend compatibility
+          if (conv.metadata.bookmarked !== undefined) {
+            conv.metadata.pinned = conv.metadata.bookmarked;
+          }
+        } catch (e) {
+          conv.metadata = null;
+        }
+      }
+    });
+
+    return conversations;
+  }
+
+  /**
+   * Update conversation title
+   * @param {string} id - Conversation ID
+   * @param {string} title - New title
+   */
+  static updateTitle(id, title) {
+    const stmt = prepare(`
+      UPDATE conversations
+      SET title = ?, updated_at = ?
+      WHERE id = ?
+    `);
+
+    stmt.run(title, Date.now(), id);
+  }
+
+  /**
+   * Touch conversation (update updated_at)
+   * @param {string} id - Conversation ID
+   */
+  static touch(id) {
+    const stmt = prepare(`
+      UPDATE conversations
+      SET updated_at = ?
+      WHERE id = ?
+    `);
+
+    stmt.run(Date.now(), id);
+  }
+
+  /**
+   * Update metadata
+   * @param {string} id - Conversation ID
+   * @param {Object} metadata - Metadata object
+   */
+  static updateMetadata(id, metadata) {
+    const stmt = prepare(`
+      UPDATE conversations
+      SET metadata = ?, updated_at = ?
+      WHERE id = ?
+    `);
+
+    stmt.run(JSON.stringify(metadata), Date.now(), id);
+  }
+
+  /**
+   * Delete conversation (cascade deletes messages)
+   * @param {string} id - Conversation ID
+   */
+  static delete(id) {
+    const stmt = prepare('DELETE FROM conversations WHERE id = ?');
+    stmt.run(id);
+  }
+
+  /**
+   * Count total conversations
+   * @returns {number} Total count
+   */
+  static count() {
+    const stmt = prepare('SELECT COUNT(*) as count FROM conversations');
+    const result = stmt.get();
+    return result ? result.count : 0;
+  }
+
+  /**
+   * List conversations grouped by date
+   * @param {number} limit - Max conversations per group (default: 20, 0 = unlimited)
+   * @returns {Object} Conversations grouped by: today, yesterday, last7days, last30days
+   */
+  static listGroupedByDate(limit = 20) {
+    // Use SQL CASE for date grouping - much faster than JS loop
+    const now = Date.now();
+    const oneDayMs = 24 * 60 * 60 * 1000;
+
+    const stmt = prepare(`
+      SELECT *,
+        CASE
+          WHEN (? - updated_at) < ? THEN 'today'
+          WHEN (? - updated_at) < ? THEN 'yesterday'
+          WHEN (? - updated_at) < ? THEN 'last7days'
+          WHEN (? - updated_at) < ? THEN 'last30days'
+          ELSE 'older'
+        END as date_group
+      FROM conversations
+      ORDER BY updated_at DESC
+      ${limit > 0 ? `LIMIT ${limit * 5}` : ''}
+    `);
+
+    const conversations = stmt.all(
+      now, oneDayMs,           // today
+      now, 2 * oneDayMs,       // yesterday
+      now, 7 * oneDayMs,       // last7days
+      now, 30 * oneDayMs       // last30days
+    );
+
+    const grouped = {
+      today: [],
+      yesterday: [],
+      last7days: [],
+      last30days: [],
+      older: []
+    };
+
+    // Single pass - group and parse metadata
+    for (const conv of conversations) {
+      const group = conv.date_group;
+      delete conv.date_group; // Clean up temp field
+
+      // Parse metadata
+      if (conv.metadata) {
+        try {
+          conv.metadata = JSON.parse(conv.metadata);
+          if (conv.metadata.bookmarked !== undefined) {
+            conv.metadata.pinned = conv.metadata.bookmarked;
+          }
+        } catch (e) {
+          conv.metadata = null;
+        }
+      }
+
+      // Add to group (respect limit per group)
+      if (limit === 0 || grouped[group].length < limit) {
+        grouped[group].push(conv);
+      }
+    }
+
+    return grouped;
+  }
+
+  /**
+   * Toggle bookmark status
+   * @param {string} id - Conversation ID
+   * @returns {boolean} New bookmark status
+   */
+  static toggleBookmark(id) {
+    const conversation = this.getById(id);
+    if (!conversation) return null;
+
+    const metadata = conversation.metadata || {};
+    metadata.bookmarked = !metadata.bookmarked;
+
+    this.updateMetadata(id, metadata);
+    return metadata.bookmarked;
+  }
+}
+
+module.exports = Conversation;

package/lib/server/models/Message.js

@@ -0,0 +1,228 @@
+const { prepare } = require('../db');
+const { v4: uuidv4 } = require('uuid');
+const Conversation = require('./Conversation');
+
+/**
+ * Message model - Individual chat messages
+ */
+class Message {
+  /**
+   * Create new message
+   * @param {string} conversationId - Parent conversation ID
+   * @param {string} role - Message role ('user' | 'assistant' | 'system')
+   * @param {string} content - Message content (markdown)
+   * @param {Object} metadata - Optional metadata
+   * @param {number} createdAt - Optional timestamp override
+   * @param {string} engine - Engine used ('claude' | 'codex')
+   * @returns {Object} Created message
+   */
+  static create(conversationId, role, content, metadata = null, createdAt = Date.now(), engine = 'claude') {
+    const id = uuidv4();
+    const now = createdAt || Date.now();
+
+    const stmt = prepare(`
+      INSERT INTO messages (id, conversation_id, role, content, created_at, metadata, engine)
+      VALUES (?, ?, ?, ?, ?, ?, ?)
+    `);
+
+    stmt.run(
+      id,
+      conversationId,
+      role,
+      content,
+      now,
+      metadata ? JSON.stringify(metadata) : null,
+      engine
+    );
+
+    // Touch conversation (update updated_at)
+    Conversation.touch(conversationId);
+
+    return {
+      id,
+      conversation_id: conversationId,
+      role,
+      content,
+      created_at: now,
+      metadata,
+      engine
+    };
+  }
+
+  /**
+   * Get message by ID
+   * @param {string} id - Message ID
+   * @returns {Object|null} Message or null if not found
+   */
+  static getById(id) {
+    const stmt = prepare('SELECT * FROM messages WHERE id = ?');
+    const message = stmt.get(id);
+
+    if (message && message.metadata) {
+      try {
+        message.metadata = JSON.parse(message.metadata);
+      } catch (e) {
+        message.metadata = null;
+      }
+    }
+
+    return message;
+  }
+
+  /**
+   * Get messages for conversation
+   * @param {string} conversationId - Conversation ID
+   * @param {number} limit - Max messages to return
+   * @param {number} offset - Offset for pagination
+   * @returns {Array} List of messages
+   */
+  static getByConversation(conversationId, limit = 100, offset = 0) {
+    const stmt = prepare(`
+      SELECT * FROM messages
+      WHERE conversation_id = ?
+      ORDER BY created_at ASC
+      LIMIT ? OFFSET ?
+    `);
+
+    const messages = stmt.all(conversationId, limit, offset);
+
+    // Parse metadata
+    messages.forEach(msg => {
+      if (msg.metadata) {
+        try {
+          msg.metadata = JSON.parse(msg.metadata);
+        } catch (e) {
+          msg.metadata = null;
+        }
+      }
+    });
+
+    return messages;
+  }
+
+  /**
+   * Get recent messages (across all conversations)
+   * @param {number} limit - Max messages
+   * @returns {Array} List of messages
+   */
+  static getRecent(limit = 50) {
+    const stmt = prepare(`
+      SELECT * FROM messages
+      ORDER BY created_at DESC
+      LIMIT ?
+    `);
+
+    return stmt.all(limit);
+  }
+
+  /**
+   * Update message content
+   * @param {string} id - Message ID
+   * @param {string} content - New content
+   */
+  static updateContent(id, content) {
+    const stmt = prepare(`
+      UPDATE messages
+      SET content = ?
+      WHERE id = ?
+    `);
+
+    const info = stmt.run(content, id);
+    return info.changes > 0;
+  }
+
+  /**
+   * Delete message
+   * @param {string} id - Message ID
+   */
+  static delete(id) {
+    const stmt = prepare('DELETE FROM messages WHERE id = ?');
+    const info = stmt.run(id);
+    return info.changes > 0;
+  }
+
+  /**
+   * Count messages in conversation
+   * @param {string} conversationId - Conversation ID
+   * @returns {number} Message count
+   */
+  static countByConversation(conversationId) {
+    const stmt = prepare(`
+      SELECT COUNT(*) as count FROM messages
+      WHERE conversation_id = ?
+    `);
+    const result = stmt.get(conversationId);
+    return result.count;
+  }
+
+  /**
+   * Get last engine used in conversation
+   * @param {string} conversationId - Conversation ID
+   * @returns {string|null} Last engine ('claude' | 'codex') or null
+   */
+  static getLastEngine(conversationId) {
+    const stmt = prepare(`
+      SELECT engine FROM messages
+      WHERE conversation_id = ?
+      ORDER BY created_at DESC
+      LIMIT 1
+    `);
+    const result = stmt.get(conversationId);
+    return result?.engine || null;
+  }
+
+  /**
+   * Get recent messages for context bridging
+   * Returns last N messages formatted for context injection
+   * @param {string} conversationId - Conversation ID
+   * @param {number} limit - Max messages (default 5)
+   * @returns {Array} Messages with role, content, engine
+   */
+  static getContextMessages(conversationId, limit = 5) {
+    const stmt = prepare(`
+      SELECT role, content, engine, created_at FROM messages
+      WHERE conversation_id = ?
+      ORDER BY created_at DESC
+      LIMIT ?
+    `);
+    const messages = stmt.all(conversationId, limit);
+    // Reverse to chronological order
+    return messages.reverse();
+  }
+
+  /**
+   * Build context string for engine bridging
+   * @param {string} conversationId - Conversation ID
+   * @param {string} newEngine - Engine being switched to
+   * @param {number} limit - Max messages for context
+   * @returns {string|null} Context string or null if no bridging needed
+   */
+  static buildBridgeContext(conversationId, newEngine, limit = 5) {
+    const lastEngine = this.getLastEngine(conversationId);
+
+    // No bridging needed if same engine or no previous messages
+    if (!lastEngine || lastEngine === newEngine) {
+      return null;
+    }
+
+    const messages = this.getContextMessages(conversationId, limit);
+    if (messages.length === 0) {
+      return null;
+    }
+
+    // Build context string
+    const contextLines = messages.map(m => {
+      const role = m.role === 'user' ? 'User' : 'Assistant';
+      const engineTag = m.engine ? ` [${m.engine}]` : '';
+      // Truncate long messages
+      const content = m.content.length > 500
+        ? m.content.substring(0, 500) + '...'
+        : m.content;
+      return `${role}${engineTag}: ${content}`;
+    });
+
+    return `[Context from previous ${lastEngine} session]\n${contextLines.join('\n\n')}`;
+  }
+}
+
+module.exports = Message;

package/lib/server/models/User.js

@@ -0,0 +1,115 @@
+const { prepare } = require('../db');
+const bcrypt = require('bcryptjs');
+const { v4: uuidv4 } = require('uuid');
+
+class User {
+  static create(username, password, role = 'user') {
+    const id = uuidv4();
+    const passwordHash = bcrypt.hashSync(password, 10);
+    const now = Date.now();
+
+    const stmt = prepare(`
+      INSERT INTO users (id, username, password_hash, role, created_at)
+      VALUES (?, ?, ?, ?, ?)
+    `);
+
+    stmt.run(id, username, passwordHash, role, now);
+
+    return { id, username, role, created_at: now };
+  }
+
+  static findByUsername(username) {
+    const stmt = prepare('SELECT * FROM users WHERE username = ?');
+    return stmt.get(username);
+  }
+
+  static findById(id) {
+    const stmt = prepare('SELECT * FROM users WHERE id = ?');
+    return stmt.get(id);
+  }
+
+  static verifyPassword(user, password) {
+    return bcrypt.compareSync(password, user.password_hash);
+  }
+
+  static updateLastLogin(userId) {
+    const stmt = prepare('UPDATE users SET last_login = ? WHERE id = ?');
+    stmt.run(Date.now(), userId);
+  }
+
+  static incrementFailedAttempts(userId) {
+    const now = Date.now();
+    const stmt = prepare(`
+      UPDATE users
+      SET failed_attempts = failed_attempts + 1,
+          last_failed_attempt = ?
+      WHERE id = ?
+    `);
+    stmt.run(now, userId);
+
+    // Lock account after 5 failed attempts for 15 minutes
+    const user = this.findById(userId);
+    if (user.failed_attempts >= 5) {
+      const lockUntil = now + (15 * 60 * 1000); // 15 minutes
+      const lockStmt = prepare(`
+        UPDATE users
+        SET is_locked = 1, locked_until = ?
+        WHERE id = ?
+      `);
+      lockStmt.run(lockUntil, userId);
+    }
+  }
+
+  static resetFailedAttempts(userId) {
+    const stmt = prepare(`
+      UPDATE users
+      SET failed_attempts = 0,
+          is_locked = 0,
+          locked_until = NULL
+      WHERE id = ?
+    `);
+    stmt.run(userId);
+  }
+
+  static isAccountLocked(user) {
+    if (!user.is_locked) return false;
+    if (!user.locked_until) return true;
+
+    const now = Date.now();
+    if (now < user.locked_until) {
+      return true;
+    }
+
+    // Unlock account if lock period expired
+    this.resetFailedAttempts(user.id);
+    return false;
+  }
+
+  static logLoginAttempt(ipAddress, username, success) {
+    const stmt = prepare(`
+      INSERT INTO login_attempts (ip_address, username, success, timestamp)
+      VALUES (?, ?, ?, ?)
+    `);
+    stmt.run(ipAddress, username, success ? 1 : 0, Date.now());
+  }
+
+  static getRecentLoginAttempts(ipAddress, windowMs = 15 * 60 * 1000) {
+    const since = Date.now() - windowMs;
+    const stmt = prepare(`
+      SELECT COUNT(*) as count
+      FROM login_attempts
+      WHERE ip_address = ? AND timestamp > ?
+    `);
+    const result = stmt.get(ipAddress, since);
+    return result ? result.count : 0;
+  }
+
+  static cleanupOldLoginAttempts(daysToKeep = 7) {
+    const cutoff = Date.now() - (daysToKeep * 24 * 60 * 60 * 1000);
+    const stmt = prepare('DELETE FROM login_attempts WHERE timestamp < ?');
+    stmt.run(cutoff);
+    return 0; // sql.js doesn't return changes count easily
+  }
+}
+
+module.exports = User;