session-store.ts

/**
 * SessionStore - Pure data management for debug sessions
 * 
 * This class is extracted from SessionManager to handle all session
 * state management without external dependencies. This improves
 * testability and follows the Single Responsibility Principle.
 */
import { v4 as uuidv4 } from 'uuid';
import {
  DebugLanguage,
  SessionState,
  SessionLifecycleState,
  ExecutionState,
  DebugSessionInfo,
  Breakpoint,
  AdapterPolicy,
  getPolicyForLanguage
} from '@debugmcp/shared';
import { SessionNotFoundError } from '../errors/debug-errors.js';

/**
 * Parameters for creating a new debug session
 */
export interface CreateSessionParams {
  language: DebugLanguage;
  name?: string;
  executablePath?: string;  // Language-agnostic executable path
}

import { IProxyManager } from '../proxy/proxy-manager.js';

export interface ToolchainValidationState {
  compatible: boolean;
  toolchain: string;
  message?: string;
  suggestions?: string[];
  behavior?: string;
  binaryInfo?: Record<string, unknown>;
}

/**
 * Internal session representation with full details
 */
export interface ManagedSession extends DebugSessionInfo {
  executablePath?: string;  // Language-agnostic executable path
  proxyManager?: IProxyManager;
  breakpoints: Map<string, Breakpoint>;
  // New state model fields
  sessionLifecycle: SessionLifecycleState;
  executionState?: ExecutionState;
  logDir?: string;
  toolchainValidation?: ToolchainValidationState;
  // True once the first 'stopped' event after launch has been observed.
  // Used by the auto-continue trigger to identify the initial entry stop
  // even when the adapter reports a non-'entry' reason (e.g., js-debug
  // emits 'pause' from its post-attach forced pause).
  firstStopHandled?: boolean;
  // True for sessions established via attach_to_process. Attach targets may
  // run on a remote filesystem (container, pod, other machine), so host-side
  // file existence checks do not apply to their source paths.
  attachMode?: boolean;
}

/**
 * SessionStore manages the lifecycle and state of debug sessions
 * without any external dependencies, making it highly testable.
 */
export class SessionStore {
  private sessions: Map<string, ManagedSession> = new Map();

  /**
   * Selects the appropriate adapter policy based on language
   */
  public selectPolicy(language: DebugLanguage): AdapterPolicy {
    return getPolicyForLanguage(language);
  }

  /**
   * Creates a new debug session
   */
  createSession(params: CreateSessionParams): DebugSessionInfo {
    const { language, name, executablePath } = params;
    const sessionId = uuidv4();
    const sessionName = name || `session-${sessionId.substring(0, 8)}`;
    
    // Validate language
    if (!Object.values(DebugLanguage).includes(language)) {
      throw new Error(`Language '${language}' is not supported.`);
    }
    
    // Use policy to resolve executable path
    const policy = this.selectPolicy(language);
    const effectiveExecutablePath = policy.resolveExecutablePath(executablePath);
    
    const session: ManagedSession = {
      id: sessionId, 
      name: sessionName, 
      language: language, 
      state: SessionState.CREATED, 
      createdAt: new Date(), 
      updatedAt: new Date(), 
      breakpoints: new Map<string, Breakpoint>(), 
      executablePath: effectiveExecutablePath,
      proxyManager: undefined,
      // Initialize new state model
      sessionLifecycle: SessionLifecycleState.CREATED,
      executionState: undefined,
    };
    
    this.sessions.set(sessionId, session);
    
    return { 
      id: sessionId, 
      name: sessionName, 
      language: session.language, 
      state: session.state, 
      createdAt: session.createdAt, 
      updatedAt: session.updatedAt 
    };
  }

  /**
   * Retrieves a session by ID
   */
  get(sessionId: string): ManagedSession | undefined {
    return this.sessions.get(sessionId);
  }

  /**
   * Retrieves a session by ID, throwing if not found
   */
  getOrThrow(sessionId: string): ManagedSession {
    const session = this.sessions.get(sessionId);
    if (!session) {
      throw new SessionNotFoundError(sessionId);
    }
    return session;
  }

  /**
   * Sets a session directly (for testing purposes)
   */
  set(sessionId: string, session: ManagedSession): void {
    this.sessions.set(sessionId, session);
  }

  /**
   * Updates session fields
   */
  update(sessionId: string, updates: Partial<ManagedSession>): void {
    const session = this.getOrThrow(sessionId);
    Object.assign(session, updates);
    session.updatedAt = new Date();
  }

  /**
   * Updates only the session state
   */
  updateState(sessionId: string, newState: SessionState): void {
    const session = this.getOrThrow(sessionId);
    if (session.state !== newState) {
      session.state = newState;
      session.updatedAt = new Date();
    }
  }

  /**
   * Removes a session
   */
  remove(sessionId: string): boolean {
    return this.sessions.delete(sessionId);
  }

  /**
   * Gets all sessions as DebugSessionInfo (public interface)
   */
  getAll(): DebugSessionInfo[] {
    return Array.from(this.sessions.values()).map(s => ({
      id: s.id, 
      name: s.name, 
      language: s.language, 
      state: s.state, 
      createdAt: s.createdAt, 
      updatedAt: s.updatedAt
    }));
  }

  /**
   * Gets all sessions with full internal data
   */
  getAllManaged(): ManagedSession[] {
    return Array.from(this.sessions.values());
  }

  /**
   * Checks if a session exists
   */
  has(sessionId: string): boolean {
    return this.sessions.has(sessionId);
  }

  /**
   * Gets the number of sessions
   */
  size(): number {
    return this.sessions.size;
  }

  /**
   * Clears all sessions
   */
  clear(): void {
    this.sessions.clear();
  }
}