I am developing a visual studio code plugin and I am trying to keep track of the breakpoints which have been set/triggered. Right now I am able to track all the breakpoints which have been set before the debugger runs. However when the user adds a breakpoint during the debug proces I cannot track it.

I log the breakpoint by iterating through the breakpoints and setting them based on index in an array. When onDidSendMessage gets triggered I retrieve the message.body.hitBreakpointIds and that way I can retrieve the correct index from my array in which I have set them. However this same approach does not work when I try to add breakpoints during the debugprocess. Is there a way to achieve this?

My code:

import * as vscode from 'vscode';
import { Session } from "./../models/Session";
import { Breakpoint } from "./../models/Breakpoint";
import { Event } from "./../models/Event";
import { Log } from "./../models/Log";
import { BREAKPOINT, LOG, SESSION } from './../enum/event_enum';
import { getSnapshotWith, insertBp, insertEvent, insertSnapshot } from './../dbHelper/insert';
import { isEmptyObject } from './../helpers/isEmpty';
import { snapshot } from './snapshot';
import { Snapshot } from './../models/Snapshot';

interface IDebugSessionMonitor {
    startMonitoring(): void;
}

export class DebugSessionMonitor implements IDebugSessionMonitor {
    private map: Record<any, any> = {};
    private isRunning = false;
    private deletedSession: string | null = null;

    constructor() {
        this.startMonitoring();
    }

    public startMonitoring(): void {
        vscode.debug.onDidStartDebugSession(this.handleStartDebugSession.bind(this));
        vscode.debug.registerDebugAdapterTrackerFactory('*', {
            createDebugAdapterTracker: this.createDebugAdapterTracker.bind(this)
        });
        vscode.debug.onDidChangeBreakpoints(this.procesBreakpointDuringDebug.bind(this));
        vscode.debug.onDidTerminateDebugSession(this.handleTerminateDebugSession.bind(this));
    }

    private async handleStartDebugSession(session: vscode.DebugSession): Promise<void> {
        if (this.isRunning) {
            this.isRunning = false;
            return;
        }

        this.initializeSession();
        const ss = await this.createSession();
        await this.processBreakpoints(session, ss);
        this.captureSnapshots(ss);
        await this.finalizeSession(session, ss);
    }

    private initializeSession(): void {
        this.deletedSession = null;
        this.isRunning = true;
    }

    private async createSession(): Promise<any> {
        let ss = await Session.create({});
        await Event.create({ session_id: ss.session_id, type: SESSION.START });
        return ss;
    }

    private async processBreakpoints(session: vscode.DebugSession, ss: any): Promise<void> {
        for (const [index, breakpoint] of vscode.debug.breakpoints.entries()) {
            if (breakpoint instanceof vscode.SourceBreakpoint) {
                console.log(index);
                let bp = await insertBp(breakpoint, session.id, this.map);
                await insertEvent(BREAKPOINT.SET, { breakpoint_id: bp.breakpoint_id, session_id: ss.session_id });
                this.map[index] = bp.breakpoint_id;
            }
        }
    }

    private async captureSnapshots(ss: any): Promise<void> {
        let snapAllFiles = await snapshot(false);
        await insertSnapshot(snapAllFiles);

        let snapActiveFile = await snapshot(true);
        let af: any[] | typeof Snapshot | null = await insertSnapshot(snapActiveFile);

        if (!af || af.length === 0) {
            af = await getSnapshotWith({ hash: snapActiveFile[0].hash });
        } else {
            af = af[0];
        }

        let ev = await Event.findOne({where: { session_id: ss.session_id, type: SESSION.START }});
        ev.snapshot_id = af.snapshot_id;
        await ev.save();
    }

    private async finalizeSession(session: vscode.DebugSession, ss: any): Promise<void> {
        this.map["id"] = ss.session_id;
        ss.is_debug = !session.configuration?.noDebug;
        await ss.save();
    }

    private createDebugAdapterTracker(session: vscode.DebugSession) {
        return {
            onDidSendMessage: this.handleDebugAdapterMessage.bind(this),
            onError: (error: any) => console.error("Debug Adapter Error:", error),
            onExit: (code: any, signal: any) => console.log(`Debug Adapter closed: code=${code}, signal=${signal}`)
        };
    }

    private async handleDebugAdapterMessage(message: any): Promise<void> {
        try {
            if (isEmptyObject(this.map)) return;

            if (message.type === 'event' && message.event === 'output') {
                await this.processDebugOutput(message);
            }

            if (message.type === 'event' && message.event === 'stopped' && message.body.reason === 'breakpoint') {
                await this.processBreakpointHit(message);
            }
        } catch (err) {
            console.log("Error during breakpoint processing:", err);
        }
    }

    private async processDebugOutput(message: any): Promise<void> {
        const output = message.body.output;
        if (!output.includes("js-debug/")) {
            const logs = await Log.create({ stream: LOG.OUTPUT, output });
            await Event.create({ log_id: logs.log_id, session_id: this.map["id"], type: SESSION.LOG });
        }
    }

    private async processBreakpointHit(message: any): Promise<void> {
        console.log(message.body.breakpoints);
        const activeSession = vscode.debug.activeDebugSession;
        const breakpointIds = message.body.hitBreakpointIds || [];

        console.log(`Breakpoint triggered in session: ${activeSession?.name}`);
        console.log(`BREAKPOINT TRIGGERED IDs: ${breakpointIds}`);

        if (breakpointIds.length > 0) {
            for (const breakpointId of breakpointIds) {
                let bpId = this.map[breakpointId];
                if (bpId !== undefined) {
                    await Event.create({ breakpoint_id: bpId, session_id: this.map["id"], type: BREAKPOINT.TRIGGER });
                }
            }
        } else {
            await this.handleFallbackBreakpoint(message);
        }
    }

    private async procesBreakpointDuringDebug(session: vscode.DebugSession) : Promise<void> {
               //this is where I fail and have no idea how to tackle this problem
  
     }

    private async handleFallbackBreakpoint(message: any): Promise<void> {
        const stackTrace = await vscode.debug.activeDebugSession?.customRequest('stackTrace', { threadId: message.body.threadId });
        if (stackTrace && stackTrace.stackFrames.length > 0) {
            const frame = stackTrace.stackFrames[0];
            console.log(`Fallback: breakpoint at ${frame.source?.path}:${frame.line}`);
        }
    }

    private async handleTerminateDebugSession(session: vscode.DebugSession): Promise<void> {
        let sessionId = this.map.id;
        if (sessionId && this.deletedSession === null) {
            this.deletedSession = session.id;
            await Event.create({ session_id: sessionId, type: SESSION.END });
        }
        this.map = {};
    }
}