MCP Debugger

Instructions

Implementation Reference

• src/server.ts:670-691 (handler)

  MCP tool handler for close_debug_session: validates sessionId, delegates to closeDebugSession method, logs closure, returns success JSON.

  case 'close_debug_session': {
    if (!args.sessionId) {
      throw new McpError(McpErrorCode.InvalidParams, 'Missing required sessionId');
    }
    
    const sessionName = this.getSessionName(args.sessionId);
    const sessionCreatedAt = Date.now(); // In real implementation, would track creation time
    const closed = await this.closeDebugSession(args.sessionId);
    
    if (closed) {
      // Log session closure
      this.logger.info('session:closed', {
        sessionId: args.sessionId,
        sessionName: sessionName,
        duration: Date.now() - sessionCreatedAt,
        timestamp: Date.now()
      });
    }
    
    result = { content: [{ type: 'text', text: JSON.stringify({ success: closed, message: closed ? `Closed debug session: ${args.sessionId}` : `Failed to close debug session: ${args.sessionId}` }) }] };
    break;
  }

• src/server.ts:472-472 (registration)

  Tool registration entry in listTools response, including schema definition.

  { name: 'close_debug_session', description: 'Close a debugging session', inputSchema: { type: 'object', properties: { sessionId: { type: 'string' } }, required: ['sessionId'] } },

• src/server.ts:265-268 (handler)

  Public wrapper method on DebugMcpServer that delegates to SessionManager.closeSession.

  public async closeDebugSession(sessionId: string): Promise<boolean> {
    return this.sessionManager.closeSession(sessionId);
  }

• src/session/session-manager-core.ts:157-194 (handler)

  Core implementation of closeSession: retrieves session, cleans up and stops proxyManager if present, updates state to STOPPED/TERMINATED, returns true on success.

  async closeSession(sessionId: string): Promise<boolean> {
    const session = this.sessionStore.get(sessionId); 
    if (!session) {
      this.logger.warn(`[SESSION_CLOSE_FAIL] Session not found: ${sessionId}`);
      return false;
    }
    this.logger.info(`Closing debug session: ${sessionId}. Active proxy: ${session.proxyManager ? 'yes' : 'no'}`);
    
    if (session.proxyManager) {
      // Always cleanup listeners first
      try {
        this.cleanupProxyEventHandlers(session, session.proxyManager);
      } catch (cleanupError) {
        this.logger.error(`[SessionManager] Critical error during listener cleanup for session ${sessionId}:`, cleanupError);
        // Continue with session closure despite cleanup errors
      }
      
      // Then stop the proxy
      try {
        await session.proxyManager.stop();
      } catch (error: unknown) { 
        const message = error instanceof Error ? error.message : String(error);
        this.logger.error(`[SessionManager] Error stopping proxy for session ${sessionId}:`, message);
      } finally {
        session.proxyManager = undefined;
      }
    }
    
    this._updateSessionState(session, SessionState.STOPPED);
    
    // Also update session lifecycle to TERMINATED
    this.sessionStore.update(sessionId, {
      sessionLifecycle: SessionLifecycleState.TERMINATED
    });
    
    this.logger.info(`Session ${sessionId} marked as STOPPED/TERMINATED.`);
    return true;
  }

• src/session/session-manager-core.ts:357-387 (helper)

  Helper method to clean up event handlers from proxyManager before stopping it.

  protected cleanupProxyEventHandlers(session: ManagedSession, proxyManager: IProxyManager): void {
    // Safety check to prevent double cleanup
    if (!this.sessionEventHandlers.has(session)) {
      this.logger.debug(`[SessionManager] Cleanup already performed for session ${session.id}`);
      return;
    }
  
    const handlers = this.sessionEventHandlers.get(session);
    if (!handlers) {
      this.logger.debug(`[SessionManager] No handlers found for session ${session.id}`);
      return;
    }
    
    let removedCount = 0;
    let failedCount = 0;
    
    handlers.forEach((handler, eventName) => {
      try {
        this.logger.debug(`[SessionManager] Removing ${eventName} listener for session ${session.id}`);
        proxyManager.removeListener(eventName, handler);
        removedCount++;
      } catch (error) {
        this.logger.error(`[SessionManager] Failed to remove ${eventName} listener for session ${session.id}:`, error);
        failedCount++;
        // Continue cleanup despite errors
      }
    });
    
    this.logger.info(`[SessionManager] Cleanup complete for session ${session.id}: ${removedCount} removed, ${failedCount} failed`);
    this.sessionEventHandlers.delete(session);
  }