@vibecheckai/cli 3.9.0 → 4.0.0

package/mcp-server/src/services/session-service.ts

@@ -0,0 +1,550 @@
+/**
+ * Session Service - Comprehensive agent session management
+ * Tracks agent interactions, provides context continuity, and enables audit trails
+ */
+
+import * as fs from 'fs';
+import * as path from 'path';
+import * as os from 'os';
+import * as crypto from 'crypto';
+
+// ═══════════════════════════════════════════════════════════════════════════════
+// Types
+// ═══════════════════════════════════════════════════════════════════════════════
+
+export interface AgentSession {
+  id: string;
+  agentId?: string;
+  agentName?: string;
+  startedAt: string;
+  lastActivityAt: string;
+  expiresAt: string;
+  status: 'active' | 'idle' | 'expired' | 'terminated';
+
+  // Context
+  workspacePath: string;
+  currentIntent?: SessionIntent;
+
+  // Metrics
+  metrics: SessionMetrics;
+
+  // History
+  toolCalls: ToolCallRecord[];
+  stateChanges: StateChange[];
+
+  // Security
+  securityContext: SecurityContext;
+}
+
+export interface SessionIntent {
+  summary: string;
+  constraints: string[];
+  setAt: string;
+  hash: string;
+}
+
+export interface SessionMetrics {
+  totalToolCalls: number;
+  successfulCalls: number;
+  failedCalls: number;
+  blockedCalls: number;
+  totalDurationMs: number;
+  averageLatencyMs: number;
+
+  // By category
+  callsByCategory: Record<string, number>;
+
+  // Firewall metrics
+  firewallViolations: number;
+  claimsVerified: number;
+  claimsPassed: number;
+  claimsFailed: number;
+}
+
+export interface ToolCallRecord {
+  id: string;
+  timestamp: string;
+  toolName: string;
+  category: 'cli' | 'firewall' | 'prompt' | 'utility';
+  tier: 'free' | 'pro';
+
+  // Input/Output
+  inputSummary: string;
+  outputSummary?: string;
+
+  // Result
+  status: 'success' | 'error' | 'blocked';
+  durationMs: number;
+  errorMessage?: string;
+  blockReason?: string;
+
+  // Context
+  intentHash?: string;
+  firewallMode?: string;
+}
+
+export interface StateChange {
+  timestamp: string;
+  type: 'intent_set' | 'intent_cleared' | 'mode_changed' | 'checkpoint_created' | 'fix_applied';
+  before: string;
+  after: string;
+  metadata?: Record<string, unknown>;
+}
+
+export interface SecurityContext {
+  tier: 'free' | 'pro';
+  firewallMode: 'off' | 'observe' | 'enforce';
+  hasActiveIntent: boolean;
+  intentHash?: string;
+  lastVerificationAt?: string;
+  trustScore: number; // 0-100
+}
+
+export interface SessionSummary {
+  id: string;
+  duration: string;
+  status: 'active' | 'idle' | 'expired' | 'terminated';
+  metrics: {
+    totalCalls: number;
+    successRate: string;
+    avgLatency: string;
+  };
+  intent?: string;
+  recentActivity: string[];
+}
+
+// ═══════════════════════════════════════════════════════════════════════════════
+// Session Service Implementation
+// ═══════════════════════════════════════════════════════════════════════════════
+
+export class SessionService {
+  private currentSession: AgentSession | null = null;
+  private sessionStorePath: string;
+  private readonly SESSION_TIMEOUT_MS = 30 * 60 * 1000; // 30 minutes
+  private readonly IDLE_TIMEOUT_MS = 5 * 60 * 1000; // 5 minutes
+  private readonly MAX_TOOL_CALLS_STORED = 500;
+
+  constructor(workspacePath: string) {
+    this.sessionStorePath = path.join(os.homedir(), '.vibecheck', 'sessions');
+    this.ensureSessionStore();
+    this.currentSession = this.createSession(workspacePath);
+  }
+
+  private ensureSessionStore(): void {
+    if (!fs.existsSync(this.sessionStorePath)) {
+      fs.mkdirSync(this.sessionStorePath, { recursive: true });
+    }
+  }
+
+  /**
+   * Create a new session
+   */
+  private createSession(workspacePath: string): AgentSession {
+    const now = new Date();
+    const session: AgentSession = {
+      id: this.generateSessionId(),
+      startedAt: now.toISOString(),
+      lastActivityAt: now.toISOString(),
+      expiresAt: new Date(now.getTime() + this.SESSION_TIMEOUT_MS).toISOString(),
+      status: 'active',
+      workspacePath,
+
+      metrics: {
+        totalToolCalls: 0,
+        successfulCalls: 0,
+        failedCalls: 0,
+        blockedCalls: 0,
+        totalDurationMs: 0,
+        averageLatencyMs: 0,
+        callsByCategory: {},
+        firewallViolations: 0,
+        claimsVerified: 0,
+        claimsPassed: 0,
+        claimsFailed: 0,
+      },
+
+      toolCalls: [],
+      stateChanges: [],
+
+      securityContext: {
+        tier: 'free',
+        firewallMode: 'off',
+        hasActiveIntent: false,
+        trustScore: 100,
+      },
+    };
+
+    this.saveSession(session);
+    return session;
+  }
+
+  private generateSessionId(): string {
+    const timestamp = Date.now().toString(36);
+    const random = crypto.randomBytes(4).toString('hex');
+    return `vcs_${timestamp}_${random}`;
+  }
+
+  /**
+   * Record a tool call
+   */
+  recordToolCall(record: Omit<ToolCallRecord, 'id' | 'timestamp'>): void {
+    if (!this.currentSession) return;
+
+    const fullRecord: ToolCallRecord = {
+      ...record,
+      id: `tc_${Date.now()}_${Math.random().toString(36).substring(2, 7)}`,
+      timestamp: new Date().toISOString(),
+    };
+
+    // Add to history (keep last N calls)
+    this.currentSession.toolCalls.push(fullRecord);
+    if (this.currentSession.toolCalls.length > this.MAX_TOOL_CALLS_STORED) {
+      this.currentSession.toolCalls = this.currentSession.toolCalls.slice(-this.MAX_TOOL_CALLS_STORED);
+    }
+
+    // Update metrics
+    this.currentSession.metrics.totalToolCalls++;
+    this.currentSession.metrics.totalDurationMs += record.durationMs;
+    this.currentSession.metrics.averageLatencyMs =
+      this.currentSession.metrics.totalDurationMs / this.currentSession.metrics.totalToolCalls;
+
+    if (record.status === 'success') {
+      this.currentSession.metrics.successfulCalls++;
+    } else if (record.status === 'error') {
+      this.currentSession.metrics.failedCalls++;
+    } else if (record.status === 'blocked') {
+      this.currentSession.metrics.blockedCalls++;
+    }
+
+    // Update category counts
+    this.currentSession.metrics.callsByCategory[record.category] =
+      (this.currentSession.metrics.callsByCategory[record.category] || 0) + 1;
+
+    // Update activity
+    this.currentSession.lastActivityAt = new Date().toISOString();
+    this.currentSession.status = 'active';
+
+    this.saveSession(this.currentSession);
+  }
+
+  /**
+   * Record a state change
+   */
+  recordStateChange(change: Omit<StateChange, 'timestamp'>): void {
+    if (!this.currentSession) return;
+
+    this.currentSession.stateChanges.push({
+      ...change,
+      timestamp: new Date().toISOString(),
+    });
+
+    // Keep last 100 state changes
+    if (this.currentSession.stateChanges.length > 100) {
+      this.currentSession.stateChanges = this.currentSession.stateChanges.slice(-100);
+    }
+
+    this.saveSession(this.currentSession);
+  }
+
+  /**
+   * Update security context
+   */
+  updateSecurityContext(updates: Partial<SecurityContext>): void {
+    if (!this.currentSession) return;
+
+    this.currentSession.securityContext = {
+      ...this.currentSession.securityContext,
+      ...updates,
+    };
+
+    this.saveSession(this.currentSession);
+  }
+
+  /**
+   * Set current intent
+   */
+  setIntent(summary: string, constraints: string[]): void {
+    if (!this.currentSession) return;
+
+    const intent: SessionIntent = {
+      summary,
+      constraints,
+      setAt: new Date().toISOString(),
+      hash: this.hashIntent(summary, constraints),
+    };
+
+    const previousIntent = this.currentSession.currentIntent?.summary || 'none';
+
+    this.currentSession.currentIntent = intent;
+    this.currentSession.securityContext.hasActiveIntent = true;
+    this.currentSession.securityContext.intentHash = intent.hash;
+
+    this.recordStateChange({
+      type: 'intent_set',
+      before: previousIntent,
+      after: summary,
+      metadata: { constraints },
+    });
+  }
+
+  /**
+   * Clear current intent
+   */
+  clearIntent(): void {
+    if (!this.currentSession) return;
+
+    const previousIntent = this.currentSession.currentIntent?.summary || 'none';
+
+    this.currentSession.currentIntent = undefined;
+    this.currentSession.securityContext.hasActiveIntent = false;
+    this.currentSession.securityContext.intentHash = undefined;
+
+    this.recordStateChange({
+      type: 'intent_cleared',
+      before: previousIntent,
+      after: 'none',
+    });
+  }
+
+  private hashIntent(summary: string, constraints: string[]): string {
+    const content = `${summary}|${constraints.sort().join('|')}`;
+    return crypto.createHash('sha256').update(content).digest('hex').substring(0, 16);
+  }
+
+  /**
+   * Record firewall violation
+   */
+  recordFirewallViolation(): void {
+    if (!this.currentSession) return;
+
+    this.currentSession.metrics.firewallViolations++;
+    this.currentSession.securityContext.trustScore = Math.max(
+      0,
+      this.currentSession.securityContext.trustScore - 10
+    );
+
+    this.saveSession(this.currentSession);
+  }
+
+  /**
+   * Record claim verification
+   */
+  recordClaimVerification(passed: boolean): void {
+    if (!this.currentSession) return;
+
+    this.currentSession.metrics.claimsVerified++;
+    if (passed) {
+      this.currentSession.metrics.claimsPassed++;
+      // Slightly increase trust score on passed verification
+      this.currentSession.securityContext.trustScore = Math.min(
+        100,
+        this.currentSession.securityContext.trustScore + 2
+      );
+    } else {
+      this.currentSession.metrics.claimsFailed++;
+      // Decrease trust score on failed verification
+      this.currentSession.securityContext.trustScore = Math.max(
+        0,
+        this.currentSession.securityContext.trustScore - 15
+      );
+    }
+
+    this.currentSession.securityContext.lastVerificationAt = new Date().toISOString();
+    this.saveSession(this.currentSession);
+  }
+
+  /**
+   * Get current session
+   */
+  getSession(): AgentSession | null {
+    return this.currentSession;
+  }
+
+  /**
+   * Get session summary
+   */
+  getSessionSummary(): SessionSummary | null {
+    if (!this.currentSession) return null;
+
+    const session = this.currentSession;
+    const startTime = new Date(session.startedAt);
+    const now = new Date();
+    const durationMs = now.getTime() - startTime.getTime();
+
+    const hours = Math.floor(durationMs / (1000 * 60 * 60));
+    const minutes = Math.floor((durationMs % (1000 * 60 * 60)) / (1000 * 60));
+    const seconds = Math.floor((durationMs % (1000 * 60)) / 1000);
+
+    const successRate = session.metrics.totalToolCalls > 0
+      ? ((session.metrics.successfulCalls / session.metrics.totalToolCalls) * 100).toFixed(1)
+      : '100';
+
+    const recentCalls = session.toolCalls.slice(-5).map(tc =>
+      `${tc.toolName} (${tc.status})`
+    );
+
+    return {
+      id: session.id,
+      duration: `${hours}h ${minutes}m ${seconds}s`,
+      status: session.status,
+      metrics: {
+        totalCalls: session.metrics.totalToolCalls,
+        successRate: `${successRate}%`,
+        avgLatency: `${Math.round(session.metrics.averageLatencyMs)}ms`,
+      },
+      intent: session.currentIntent?.summary,
+      recentActivity: recentCalls,
+    };
+  }
+
+  /**
+   * Get detailed session metrics
+   */
+  getDetailedMetrics(): SessionMetrics & { trustScore: number; sessionDuration: string } | null {
+    if (!this.currentSession) return null;
+
+    const startTime = new Date(this.currentSession.startedAt);
+    const now = new Date();
+    const durationMs = now.getTime() - startTime.getTime();
+    const hours = Math.floor(durationMs / (1000 * 60 * 60));
+    const minutes = Math.floor((durationMs % (1000 * 60 * 60)) / (1000 * 60));
+
+    return {
+      ...this.currentSession.metrics,
+      trustScore: this.currentSession.securityContext.trustScore,
+      sessionDuration: `${hours}h ${minutes}m`,
+    };
+  }
+
+  /**
+   * Get tool call history
+   */
+  getToolCallHistory(limit?: number): ToolCallRecord[] {
+    if (!this.currentSession) return [];
+
+    const calls = this.currentSession.toolCalls;
+    return limit ? calls.slice(-limit) : calls;
+  }
+
+  /**
+   * Get state change history
+   */
+  getStateChangeHistory(limit?: number): StateChange[] {
+    if (!this.currentSession) return [];
+
+    const changes = this.currentSession.stateChanges;
+    return limit ? changes.slice(-limit) : changes;
+  }
+
+  /**
+   * Check if session is healthy
+   */
+  isSessionHealthy(): { healthy: boolean; issues: string[] } {
+    if (!this.currentSession) {
+      return { healthy: false, issues: ['No active session'] };
+    }
+
+    const issues: string[] = [];
+    const session = this.currentSession;
+
+    // Check expiry
+    if (new Date(session.expiresAt) <= new Date()) {
+      issues.push('Session has expired');
+    }
+
+    // Check trust score
+    if (session.securityContext.trustScore < 50) {
+      issues.push(`Low trust score (${session.securityContext.trustScore}/100)`);
+    }
+
+    // Check error rate
+    if (session.metrics.totalToolCalls > 10) {
+      const errorRate = session.metrics.failedCalls / session.metrics.totalToolCalls;
+      if (errorRate > 0.3) {
+        issues.push(`High error rate (${(errorRate * 100).toFixed(1)}%)`);
+      }
+    }
+
+    // Check firewall violations
+    if (session.metrics.firewallViolations > 5) {
+      issues.push(`Multiple firewall violations (${session.metrics.firewallViolations})`);
+    }
+
+    return {
+      healthy: issues.length === 0,
+      issues,
+    };
+  }
+
+  /**
+   * Terminate session
+   */
+  terminateSession(reason?: string): void {
+    if (!this.currentSession) return;
+
+    this.currentSession.status = 'terminated';
+    this.recordStateChange({
+      type: 'mode_changed',
+      before: 'active',
+      after: 'terminated',
+      metadata: { reason },
+    });
+
+    this.saveSession(this.currentSession);
+  }
+
+  /**
+   * Save session to disk
+   */
+  private saveSession(session: AgentSession): void {
+    try {
+      const filePath = path.join(this.sessionStorePath, `${session.id}.json`);
+      fs.writeFileSync(filePath, JSON.stringify(session, null, 2));
+    } catch {
+      // Failed to save - continue anyway
+    }
+  }
+
+  /**
+   * Load session from disk
+   */
+  loadSession(sessionId: string): AgentSession | null {
+    try {
+      const filePath = path.join(this.sessionStorePath, `${sessionId}.json`);
+      if (fs.existsSync(filePath)) {
+        return JSON.parse(fs.readFileSync(filePath, 'utf-8'));
+      }
+    } catch {
+      // Failed to load
+    }
+    return null;
+  }
+
+  /**
+   * List recent sessions
+   */
+  listRecentSessions(limit: number = 10): { id: string; startedAt: string; status: string }[] {
+    try {
+      const files = fs.readdirSync(this.sessionStorePath)
+        .filter(f => f.endsWith('.json'))
+        .map(f => {
+          const filePath = path.join(this.sessionStorePath, f);
+          const stats = fs.statSync(filePath);
+          return { file: f, mtime: stats.mtime };
+        })
+        .sort((a, b) => b.mtime.getTime() - a.mtime.getTime())
+        .slice(0, limit);
+
+      return files.map(f => {
+        const session = this.loadSession(f.file.replace('.json', ''));
+        return session ? {
+          id: session.id,
+          startedAt: session.startedAt,
+          status: session.status,
+        } : null;
+      }).filter((s): s is { id: string; startedAt: string; status: string } => s !== null);
+    } catch {
+      return [];
+    }
+  }
+}