@vibecheckai/cli 3.2.5 → 3.3.0

package/mcp-server/conductor/session-manager.js

@@ -0,0 +1,500 @@
+/**
+ * Conductor Session Manager
+ * 
+ * Tracks active AI agent sessions per project.
+ * Enables multi-agent coordination by knowing which agents are active.
+ * 
+ * Codename: Conductor
+ */
+
+"use strict";
+
+import fs from "fs";
+import path from "path";
+import crypto from "crypto";
+import { conductorLogger as log, getErrorMessage } from "../logger.js";
+
+/**
+ * @typedef {Object} AgentSession
+ * @property {string} agentId - Agent identifier (cursor, copilot, etc.)
+ * @property {string} sessionId - Unique session ID
+ * @property {string} tier - User tier (FREE, STARTER, PRO, ENTERPRISE)
+ * @property {string} trust - Trust level (low, medium, high)
+ * @property {Date} startTime - Session start timestamp
+ * @property {Date} lastActivity - Last activity timestamp
+ * @property {string[]} workingFiles - Files this agent is working on
+ * @property {string[]} pendingProposals - Pending proposal IDs
+ * @property {string} projectRoot - Project root directory
+ */
+
+/**
+ * Default session timeout (30 minutes)
+ */
+const DEFAULT_SESSION_TIMEOUT_MS = 30 * 60 * 1000;
+
+/**
+ * Trust level mapping based on tier
+ */
+const TIER_TRUST_MAP = {
+  FREE: "low",
+  STARTER: "medium",
+  PRO: "high",
+  ENTERPRISE: "high",
+};
+
+/**
+ * Session Manager class
+ */
+class SessionManager {
+  constructor(options = {}) {
+    this.sessions = new Map(); // sessionId -> AgentSession
+    this.agentSessions = new Map(); // agentId -> Set<sessionId>
+    this.projectSessions = new Map(); // projectRoot -> Set<sessionId>
+    this.sessionTimeout = options.sessionTimeout || DEFAULT_SESSION_TIMEOUT_MS;
+    this.persistPath = options.persistPath || null;
+    
+    // Start cleanup interval
+    this.cleanupInterval = setInterval(() => {
+      this.cleanupExpiredSessions();
+    }, 60000); // Check every minute
+    
+    // Load persisted state if available
+    if (this.persistPath) {
+      this.loadState();
+    }
+  }
+  
+  /**
+   * Generate a unique session ID
+   * @returns {string} Session ID
+   */
+  generateSessionId() {
+    return `ses_${crypto.randomBytes(12).toString("hex")}`;
+  }
+  
+  /**
+   * Register a new agent session
+   * @param {Object} params - Session parameters
+   * @returns {AgentSession} Created session
+   */
+  registerSession({
+    agentId,
+    tier = "FREE",
+    projectRoot,
+    workingFiles = [],
+  }) {
+    const sessionId = this.generateSessionId();
+    const now = new Date();
+    
+    const session = {
+      agentId,
+      sessionId,
+      tier,
+      trust: TIER_TRUST_MAP[tier] || "low",
+      startTime: now,
+      lastActivity: now,
+      workingFiles,
+      pendingProposals: [],
+      projectRoot: path.resolve(projectRoot),
+    };
+    
+    // Store session
+    this.sessions.set(sessionId, session);
+    
+    // Index by agent
+    if (!this.agentSessions.has(agentId)) {
+      this.agentSessions.set(agentId, new Set());
+    }
+    this.agentSessions.get(agentId).add(sessionId);
+    
+    // Index by project
+    const normalizedRoot = path.resolve(projectRoot);
+    if (!this.projectSessions.has(normalizedRoot)) {
+      this.projectSessions.set(normalizedRoot, new Set());
+    }
+    this.projectSessions.get(normalizedRoot).add(sessionId);
+    
+    // Persist state
+    this.saveState();
+    
+    return session;
+  }
+  
+  /**
+   * Get a session by ID
+   * @param {string} sessionId - Session ID
+   * @returns {AgentSession|null} Session or null
+   */
+  getSession(sessionId) {
+    const session = this.sessions.get(sessionId);
+    if (!session) return null;
+    
+    // Check if expired
+    if (this.isSessionExpired(session)) {
+      this.terminateSession(sessionId);
+      return null;
+    }
+    
+    return session;
+  }
+  
+  /**
+   * Get all sessions for an agent
+   * @param {string} agentId - Agent ID
+   * @returns {AgentSession[]} Sessions
+   */
+  getAgentSessions(agentId) {
+    const sessionIds = this.agentSessions.get(agentId);
+    if (!sessionIds) return [];
+    
+    const sessions = [];
+    for (const sessionId of sessionIds) {
+      const session = this.getSession(sessionId);
+      if (session) {
+        sessions.push(session);
+      }
+    }
+    return sessions;
+  }
+  
+  /**
+   * Get all sessions for a project
+   * @param {string} projectRoot - Project root
+   * @returns {AgentSession[]} Sessions
+   */
+  getProjectSessions(projectRoot) {
+    const normalizedRoot = path.resolve(projectRoot);
+    const sessionIds = this.projectSessions.get(normalizedRoot);
+    if (!sessionIds) return [];
+    
+    const sessions = [];
+    for (const sessionId of sessionIds) {
+      const session = this.getSession(sessionId);
+      if (session) {
+        sessions.push(session);
+      }
+    }
+    return sessions;
+  }
+  
+  /**
+   * Get all active agents for a project
+   * @param {string} projectRoot - Project root
+   * @returns {Object[]} Active agents with their sessions
+   */
+  getActiveAgents(projectRoot) {
+    const sessions = this.getProjectSessions(projectRoot);
+    const agentMap = new Map();
+    
+    for (const session of sessions) {
+      if (!agentMap.has(session.agentId)) {
+        agentMap.set(session.agentId, {
+          agentId: session.agentId,
+          tier: session.tier,
+          trust: session.trust,
+          sessions: [],
+          workingFiles: new Set(),
+        });
+      }
+      
+      const agent = agentMap.get(session.agentId);
+      agent.sessions.push(session);
+      session.workingFiles.forEach(f => agent.workingFiles.add(f));
+    }
+    
+    // Convert sets to arrays
+    return Array.from(agentMap.values()).map(agent => ({
+      ...agent,
+      workingFiles: Array.from(agent.workingFiles),
+      sessionCount: agent.sessions.length,
+    }));
+  }
+  
+  /**
+   * Update session activity
+   * @param {string} sessionId - Session ID
+   * @param {Object} updates - Updates to apply
+   * @returns {AgentSession|null} Updated session
+   */
+  updateSession(sessionId, updates = {}) {
+    const session = this.sessions.get(sessionId);
+    if (!session) return null;
+    
+    // Update last activity
+    session.lastActivity = new Date();
+    
+    // Apply updates
+    if (updates.workingFiles) {
+      session.workingFiles = updates.workingFiles;
+    }
+    if (updates.pendingProposals) {
+      session.pendingProposals = updates.pendingProposals;
+    }
+    
+    // Persist state
+    this.saveState();
+    
+    return session;
+  }
+  
+  /**
+   * Add working file to session
+   * @param {string} sessionId - Session ID
+   * @param {string} filePath - File path
+   */
+  addWorkingFile(sessionId, filePath) {
+    const session = this.sessions.get(sessionId);
+    if (!session) return;
+    
+    if (!session.workingFiles.includes(filePath)) {
+      session.workingFiles.push(filePath);
+      session.lastActivity = new Date();
+      this.saveState();
+    }
+  }
+  
+  /**
+   * Remove working file from session
+   * @param {string} sessionId - Session ID
+   * @param {string} filePath - File path
+   */
+  removeWorkingFile(sessionId, filePath) {
+    const session = this.sessions.get(sessionId);
+    if (!session) return;
+    
+    const index = session.workingFiles.indexOf(filePath);
+    if (index !== -1) {
+      session.workingFiles.splice(index, 1);
+      session.lastActivity = new Date();
+      this.saveState();
+    }
+  }
+  
+  /**
+   * Add pending proposal to session
+   * @param {string} sessionId - Session ID
+   * @param {string} proposalId - Proposal ID
+   */
+  addPendingProposal(sessionId, proposalId) {
+    const session = this.sessions.get(sessionId);
+    if (!session) return;
+    
+    if (!session.pendingProposals.includes(proposalId)) {
+      session.pendingProposals.push(proposalId);
+      session.lastActivity = new Date();
+      this.saveState();
+    }
+  }
+  
+  /**
+   * Remove pending proposal from session
+   * @param {string} sessionId - Session ID
+   * @param {string} proposalId - Proposal ID
+   */
+  removePendingProposal(sessionId, proposalId) {
+    const session = this.sessions.get(sessionId);
+    if (!session) return;
+    
+    const index = session.pendingProposals.indexOf(proposalId);
+    if (index !== -1) {
+      session.pendingProposals.splice(index, 1);
+      session.lastActivity = new Date();
+      this.saveState();
+    }
+  }
+  
+  /**
+   * Check if session is expired
+   * @param {AgentSession} session - Session to check
+   * @returns {boolean} Is expired
+   */
+  isSessionExpired(session) {
+    const elapsed = Date.now() - new Date(session.lastActivity).getTime();
+    return elapsed > this.sessionTimeout;
+  }
+  
+  /**
+   * Terminate a session
+   * @param {string} sessionId - Session ID to terminate
+   * @returns {boolean} Success
+   */
+  terminateSession(sessionId) {
+    const session = this.sessions.get(sessionId);
+    if (!session) return false;
+    
+    // Remove from sessions
+    this.sessions.delete(sessionId);
+    
+    // Remove from agent index
+    const agentSessions = this.agentSessions.get(session.agentId);
+    if (agentSessions) {
+      agentSessions.delete(sessionId);
+      if (agentSessions.size === 0) {
+        this.agentSessions.delete(session.agentId);
+      }
+    }
+    
+    // Remove from project index
+    const projectSessions = this.projectSessions.get(session.projectRoot);
+    if (projectSessions) {
+      projectSessions.delete(sessionId);
+      if (projectSessions.size === 0) {
+        this.projectSessions.delete(session.projectRoot);
+      }
+    }
+    
+    // Persist state
+    this.saveState();
+    
+    return true;
+  }
+  
+  /**
+   * Cleanup expired sessions
+   */
+  cleanupExpiredSessions() {
+    const expiredIds = [];
+    
+    for (const [sessionId, session] of this.sessions) {
+      if (this.isSessionExpired(session)) {
+        expiredIds.push(sessionId);
+      }
+    }
+    
+    for (const sessionId of expiredIds) {
+      this.terminateSession(sessionId);
+    }
+    
+    if (expiredIds.length > 0) {
+      log.info(`Cleaned up ${expiredIds.length} expired sessions`);
+    }
+  }
+  
+  /**
+   * Get session statistics
+   * @returns {Object} Statistics
+   */
+  getStatistics() {
+    const stats = {
+      totalSessions: this.sessions.size,
+      activeAgents: this.agentSessions.size,
+      activeProjects: this.projectSessions.size,
+      byTier: { FREE: 0, STARTER: 0, PRO: 0, ENTERPRISE: 0 },
+      byTrust: { low: 0, medium: 0, high: 0 },
+    };
+    
+    for (const session of this.sessions.values()) {
+      stats.byTier[session.tier] = (stats.byTier[session.tier] || 0) + 1;
+      stats.byTrust[session.trust] = (stats.byTrust[session.trust] || 0) + 1;
+    }
+    
+    return stats;
+  }
+  
+  /**
+   * Save state to disk
+   */
+  saveState() {
+    if (!this.persistPath) return;
+    
+    try {
+      const dir = path.dirname(this.persistPath);
+      if (!fs.existsSync(dir)) {
+        fs.mkdirSync(dir, { recursive: true });
+      }
+      
+      const state = {
+        sessions: Array.from(this.sessions.entries()),
+        timestamp: new Date().toISOString(),
+      };
+      
+      fs.writeFileSync(this.persistPath, JSON.stringify(state, null, 2));
+    } catch (error) {
+      log.warn(`Failed to save state: ${getErrorMessage(error)}`);
+    }
+  }
+  
+  /**
+   * Load state from disk
+   */
+  loadState() {
+    if (!this.persistPath || !fs.existsSync(this.persistPath)) return;
+    
+    try {
+      const content = fs.readFileSync(this.persistPath, "utf-8");
+      const state = JSON.parse(content);
+      
+      // Restore sessions
+      for (const [sessionId, session] of state.sessions || []) {
+        // Convert date strings back to dates
+        session.startTime = new Date(session.startTime);
+        session.lastActivity = new Date(session.lastActivity);
+        
+        // Only restore non-expired sessions
+        if (!this.isSessionExpired(session)) {
+          this.sessions.set(sessionId, session);
+          
+          // Rebuild indexes
+          if (!this.agentSessions.has(session.agentId)) {
+            this.agentSessions.set(session.agentId, new Set());
+          }
+          this.agentSessions.get(session.agentId).add(sessionId);
+          
+          if (!this.projectSessions.has(session.projectRoot)) {
+            this.projectSessions.set(session.projectRoot, new Set());
+          }
+          this.projectSessions.get(session.projectRoot).add(sessionId);
+        }
+      }
+      
+      log.info(`Restored ${this.sessions.size} sessions from disk`);
+    } catch (error) {
+      log.warn(`Failed to load state: ${getErrorMessage(error)}`);
+    }
+  }
+  
+  /**
+   * Shutdown the session manager
+   */
+  shutdown() {
+    if (this.cleanupInterval) {
+      clearInterval(this.cleanupInterval);
+    }
+    this.saveState();
+  }
+}
+
+/**
+ * Create a session manager instance
+ * @param {Object} options - Options
+ * @returns {SessionManager} Manager instance
+ */
+function createSessionManager(options = {}) {
+  return new SessionManager(options);
+}
+
+// Default instance
+let defaultManager = null;
+
+/**
+ * Get the default session manager
+ * @param {string} projectRoot - Project root for persist path
+ * @returns {SessionManager} Default manager
+ */
+function getSessionManager(projectRoot) {
+  if (!defaultManager) {
+    const persistPath = projectRoot 
+      ? path.join(projectRoot, ".vibecheck", "conductor", "sessions.json")
+      : null;
+    defaultManager = createSessionManager({ persistPath });
+  }
+  return defaultManager;
+}
+
+export {
+  SessionManager,
+  createSessionManager,
+  getSessionManager,
+  TIER_TRUST_MAP,
+  DEFAULT_SESSION_TIMEOUT_MS,
+};