@opensumi/ide-debug 2.12.1-next-079c1930

package/lib/browser/debug-session.js

@@ -0,0 +1,898 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.DebugSession = void 0;
+const ide_core_browser_1 = require("@opensumi/ide-core-browser");
+const debounce = require("lodash.debounce");
+const common_1 = require("../common");
+const debug_source_1 = require("./model/debug-source");
+const debug_thread_1 = require("./model/debug-thread");
+const breakpoint_1 = require("./breakpoint");
+const ide_core_common_1 = require("@opensumi/ide-core-common");
+class DebugSession {
+    constructor(id, options, connection, terminalService, workbenchEditorService, breakpointManager, modelManager, labelProvider, messages, fileSystem, sessionManager) {
+        this.id = id;
+        this.options = options;
+        this.connection = connection;
+        this.terminalService = terminalService;
+        this.workbenchEditorService = workbenchEditorService;
+        this.breakpointManager = breakpointManager;
+        this.modelManager = modelManager;
+        this.labelProvider = labelProvider;
+        this.messages = messages;
+        this.fileSystem = fileSystem;
+        this.sessionManager = sessionManager;
+        this.onDidChangeEmitter = new ide_core_browser_1.Emitter();
+        this.onDidChange = this.onDidChangeEmitter.event;
+        this._onDidChangeCallStack = new ide_core_browser_1.Emitter();
+        this.onDidChangeCallStack = this._onDidChangeCallStack.event;
+        this._onVariableChange = new ide_core_browser_1.Emitter();
+        this.onVariableChange = this._onVariableChange.event;
+        this._onCurrentThreadChange = new ide_core_browser_1.Emitter();
+        this.onCurrentThreadChange = this._onCurrentThreadChange.event;
+        this._onDidStop = new ide_core_browser_1.Emitter();
+        this.onDidStop = this._onDidStop.event;
+        this._onDidContinued = new ide_core_browser_1.Emitter();
+        this.onDidContinued = this._onDidContinued.event;
+        this._onDidThread = new ide_core_browser_1.Emitter();
+        this.onDidThread = this._onDidThread.event;
+        this._onRequest = new ide_core_browser_1.Emitter();
+        this.onRequest = this._onRequest.event;
+        this._onDidExitAdapter = new ide_core_browser_1.Emitter();
+        this.onDidExitAdapter = this._onDidExitAdapter.event;
+        this._onDidProgressStart = new ide_core_browser_1.Emitter();
+        this.onDidProgressStart = this._onDidProgressStart.event;
+        this._onDidProgressUpdate = new ide_core_browser_1.Emitter();
+        this.onDidProgressUpdate = this._onDidProgressUpdate.event;
+        this._onDidProgressEnd = new ide_core_browser_1.Emitter();
+        this.onDidProgressEnd = this._onDidProgressEnd.event;
+        this._onDidInvalidated = new ide_core_browser_1.Emitter();
+        this.onDidInvalidated = this._onDidInvalidated.event;
+        this._onDidChangeState = new ide_core_browser_1.Emitter();
+        this.onDidChangeState = this._onDidChangeState.event;
+        this.toDispose = new ide_core_browser_1.DisposableCollection();
+        this._capabilities = {};
+        this.updateDeffered = null;
+        this.exitDeferred = new ide_core_browser_1.Deferred();
+        this.cancellationMap = new Map();
+        this.toDisposeOnCurrentThread = new ide_core_browser_1.DisposableCollection();
+        this.initialized = false;
+        /**
+         * runtime 时候的临时缓存，每次调试的时候都应该清空，
+         * 会等待首次初始化完成
+         */
+        this.id2Breakpoint = new Map();
+        /**
+         * 初始化断点信息的锁
+         */
+        this.settingBreakpoints = null;
+        this._multipleThreadPaused = new Map();
+        this.sources = new Map();
+        this._threads = new Map();
+        this.scheduleUpdateThreads = debounce(() => this.updateThreads(undefined), 100);
+        this.pendingThreads = Promise.resolve();
+        this.terminated = false;
+        this.connection.onRequest('runInTerminal', (request) => {
+            this.runInTerminal(request);
+        });
+        this.toDispose.pushAll([
+            this.onDidChangeEmitter,
+            this.connection,
+            // 返回调试配置
+            this.on('initialized', () => {
+                this.configure();
+            }),
+            // 更新断点
+            this.on('breakpoint', ({ body }) => this.onUpdateBreakpoint(body)),
+            this.on('continued', async (event) => {
+                const { body: { allThreadsContinued, threadId } } = event;
+                this.handleCancellation(threadId);
+                if (this.supportsThreadIdCorrespond) {
+                    if (threadId) {
+                        this._multipleThreadPaused.delete(threadId);
+                    }
+                    else if (allThreadsContinued !== false) {
+                        this._multipleThreadPaused.clear();
+                    }
+                    await this.updateCurrentThread();
+                    this._onDidContinued.fire(event);
+                    return;
+                }
+                // 更新线程
+                if (allThreadsContinued !== false) {
+                    this.clearThreads();
+                    this._onDidContinued.fire(event);
+                    return;
+                }
+                if (threadId) {
+                    this.clearThread(threadId);
+                }
+                this.onStateChange();
+                this._onDidContinued.fire(event);
+            }),
+            this.on('stopped', async (event) => {
+                const { body } = event;
+                this.stoppedDetails = body;
+                const { threadId } = body;
+                const reportTime = this.sessionManager.reportTime(common_1.DEBUG_REPORT_NAME.DEBUG_STOPPED, {
+                    sessionId: this.id,
+                    threadId,
+                });
+                if (this.supportsThreadIdCorrespond === true) {
+                    await this.collectPausedThread(body);
+                    if (body.threadId && this._multipleThreadPaused.has(body.threadId)) {
+                        const pauseThread = this._multipleThreadPaused.get(body.threadId);
+                        await this.updateCurrentThread(pauseThread);
+                        await this.updateCurrentThreadFramesOnFocus();
+                    }
+                }
+                else {
+                    this.updateDeffered = new ide_core_browser_1.Deferred();
+                    await this.updateThreads(body);
+                    await this.updateCurrentThreadFramesOnFocus();
+                    this.updateDeffered.resolve();
+                }
+                reportTime('stopped');
+                // action 结束后需要清除
+                const extra = this.sessionManager.getExtra(this.id, threadId);
+                if (threadId && extra && extra.action) {
+                    extra.action = undefined;
+                    this.sessionManager.setExtra(this.id, `${threadId !== null && threadId !== void 0 ? threadId : ''}`, extra);
+                }
+                this.onStateChange();
+                this._onDidStop.fire(event);
+            }),
+            this.on('thread', (event) => {
+                const { body: { reason, threadId } } = event;
+                if (this.supportsThreadIdCorrespond) {
+                    // 当 supportsThreadIdCorrespond 开启的时候，只有在 DebugState 为 Stopped 的时候才发送 thread dap 事件
+                    if (this.state === common_1.DebugState.Stopped) {
+                        this._onDidThread.fire(event);
+                    }
+                    return;
+                }
+                if (reason === 'started') {
+                    // 队列更新线程
+                    this.scheduleUpdateThreads();
+                }
+                else if (reason === 'exited') {
+                    // 清理线程数据
+                    this.clearThread(threadId);
+                }
+                this._onDidThread.fire(event);
+            }),
+            this.on('terminated', () => {
+                this.terminated = true;
+            }),
+            this.on('exited', (reason) => {
+                this.exitDeferred.resolve(reason);
+            }),
+            this.on('progressStart', (event) => {
+                this._onDidProgressStart.fire(event);
+            }),
+            this.on('progressUpdate', (event) => {
+                this._onDidProgressUpdate.fire(event);
+            }),
+            this.on('progressEnd', (event) => {
+                this._onDidProgressEnd.fire(event);
+            }),
+            this.on('invalidated', async (event) => {
+                this._onDidInvalidated.fire(event);
+                if (!(event.body.areas && event.body.areas.length === 1 && (event.body.areas[0] === 'variables' || event.body.areas[0] === 'watch'))) {
+                    this.cancelAllRequests();
+                    this.clearThreads();
+                    await this.updateThreads(this.stoppedDetails);
+                }
+                this.fireDidChange();
+            }),
+            this.on('capabilities', (event) => this.updateCapabilities(event.body.capabilities)),
+            this.breakpointManager.onDidChangeBreakpoints((event) => this.runtimeUpdateBreakpoint(event)),
+            this.breakpointManager.onDidChangeExceptionsBreakpoints((args) => {
+                if (this.breakpointManager.breakpointsEnabled) {
+                    this.setExceptionBreakpoints(args);
+                }
+            }),
+            ide_core_common_1.Disposable.create(() => {
+                // 清除断点的运行时状态
+                this.breakpointManager.clearAllStatus(this.id);
+            }),
+        ]);
+    }
+    fireDidChange() {
+        this.onDidChangeEmitter.fire(undefined);
+        this.onStateChange();
+    }
+    get capabilities() {
+        return this._capabilities;
+    }
+    get supportsThreadIdCorrespond() {
+        return !!this.capabilities.supportsThreadIdCorrespond;
+    }
+    get configuration() {
+        return this.options.configuration;
+    }
+    get parentSession() {
+        return this.options.parentSession;
+    }
+    get compact() {
+        return !!this.options.compact;
+    }
+    async start() {
+        await this.workbenchEditorService.saveAll();
+        await this.initialize();
+        await this.launchOrAttach();
+    }
+    async runInTerminal({ arguments: { title, cwd, args, env } }) {
+        return this.doRunInTerminal({ name: title, cwd, env }, args.join(' '));
+    }
+    async doRunInTerminal(options, command) {
+        const activeTerminal = this.terminalService.terminals.find((terminal) => terminal.name === options.name && terminal.isActive);
+        let processId;
+        // 当存在同名终端并且处于激活状态时，复用该终端
+        if (activeTerminal) {
+            if (command) {
+                this.terminalService.sendText(activeTerminal.id, command);
+            }
+            processId = await this.terminalService.getProcessId(activeTerminal.id);
+        }
+        else {
+            const terminal = await this.terminalService.createTerminal(options);
+            terminal.show();
+            if (command) {
+                this.terminalService.sendText(terminal.id, command);
+                processId = await this.terminalService.getProcessId(terminal.id);
+            }
+        }
+        return { processId };
+    }
+    async initialize() {
+        const response = await this.connection.sendRequest('initialize', {
+            clientID: 'KatiTian',
+            clientName: 'KatiTian IDE',
+            adapterID: this.configuration.type,
+            locale: 'en-US',
+            linesStartAt1: true,
+            columnsStartAt1: true,
+            pathFormat: 'path',
+            supportsVariableType: false,
+            supportsVariablePaging: false,
+            supportsRunInTerminalRequest: true,
+            supportsProgressReporting: true,
+            supportsInvalidatedEvent: true,
+        }, this.configuration);
+        this.updateCapabilities(response.body || {});
+        this.onStateChange();
+    }
+    async launchOrAttach() {
+        if (this.parentSession && this.parentSession.state === common_1.DebugState.Inactive) {
+            throw (0, ide_core_browser_1.canceled)();
+        }
+        try {
+            if (this.configuration.request === 'attach') {
+                await this.sendRequest('attach', this.configuration);
+            }
+            else {
+                await this.sendRequest('launch', this.configuration);
+            }
+        }
+        catch (reason) {
+            this.fireExited(reason);
+            this.messages.error(reason.message || 'Debug session initialization failed. See console for details.');
+            throw reason && reason.message;
+        }
+    }
+    async configure() {
+        await this.initBreakpoints();
+        // 更新exceptionBreakpoint配置
+        this.breakpointManager.setExceptionBreakpoints(this.capabilities.exceptionBreakpointFilters || []);
+        if (this.capabilities.supportsConfigurationDoneRequest) {
+            await this.sendRequest('configurationDone', {});
+        }
+        this.initialized = true;
+        if (!this.supportsThreadIdCorrespond) {
+            await this.updateThreads(undefined);
+        }
+    }
+    async setExceptionBreakpoints(args) {
+        return this.sendRequest('setExceptionBreakpoints', args);
+    }
+    onStateChange() {
+        const state = this.state;
+        if (this.previousState !== state) {
+            this.previousState = state;
+            this._onDidChangeState.fire(state);
+        }
+    }
+    /**
+     * 运行时的断点修改
+     * TODO:// 待重构 @倾一
+     * @param body
+     */
+    async onUpdateBreakpoint(body) {
+        let breakpoint;
+        if (this.settingBreakpoints) {
+            await this.settingBreakpoints.promise;
+        }
+        try {
+            const raw = body.breakpoint;
+            switch (body.reason) {
+                case 'new':
+                    if (raw.source && typeof raw.line === 'number' && raw.id && !this.id2Breakpoint.has(raw.id)) {
+                        const uri = debug_source_1.DebugSource.toUri(raw.source);
+                        const bp = breakpoint_1.DebugBreakpoint.create(uri, { line: raw.line, column: raw.column });
+                        bp.status.set(this.id, raw);
+                        this.addBreakpoint(bp);
+                    }
+                    break;
+                case 'removed':
+                    if (raw.id) {
+                        breakpoint = this.id2Breakpoint.get(raw.id);
+                        if (breakpoint) {
+                            this.delBreakpoint(breakpoint);
+                        }
+                    }
+                    break;
+                case 'changed':
+                    if (raw.id) {
+                        breakpoint = this.id2Breakpoint.get(raw.id);
+                        if (breakpoint) {
+                            breakpoint.status.set(this.id, raw);
+                            this.breakpointManager.updateBreakpoint(breakpoint);
+                        }
+                    }
+                    break;
+                default:
+                    break;
+            }
+        }
+        finally { }
+    }
+    async setBreakpoints(affected) {
+        const promises = [];
+        for (const uri of affected) {
+            const source = await this.toSource(uri);
+            const enableds = this.breakpointManager.getBreakpoints(uri).filter((b) => this.breakpointManager.breakpointsEnabled && b.enabled);
+            promises.push(this.sendRequest('setBreakpoints', {
+                source: source.raw,
+                sourceModified: false,
+                lines: enableds.map((breakpoint) => breakpoint.raw.line),
+                breakpoints: enableds.map((breakpoint) => breakpoint.raw),
+            })
+                .then((res) => {
+                res.body.breakpoints.forEach((status, index) => {
+                    var _a, _b;
+                    if (status.id) {
+                        this.id2Breakpoint.set(status.id, enableds[index]);
+                    }
+                    const enabledBp = enableds[index];
+                    enabledBp.raw.line = (_a = status.line) !== null && _a !== void 0 ? _a : enabledBp.raw.line;
+                    enabledBp.raw.column = (_b = status.column) !== null && _b !== void 0 ? _b : enabledBp.raw.column;
+                    enabledBp.status.set(this.id, status);
+                });
+                this.breakpointManager.updateBreakpoints(enableds, true);
+                this.breakpointManager.resolveBpDeffered();
+                return Promise.resolve();
+            })
+                .catch((error) => {
+                if (!(error instanceof Error)) {
+                    const genericMessage = 'Breakpoint not valid for current debug session';
+                    const message = error.message ? `${error.message}` : genericMessage;
+                    enableds.forEach((breakpoint) => {
+                        breakpoint.status.set(this.id, { verified: false, message });
+                        this.breakpointManager.updateBreakpoint(breakpoint, true);
+                    });
+                }
+            }));
+        }
+        return await Promise.all(promises);
+    }
+    delBreakpoint(breakpoint) {
+        return this.breakpointManager.delBreakpoint(breakpoint);
+    }
+    async addBreakpoint(breakpoint, isBpDeferred) {
+        if (isBpDeferred) {
+            this.breakpointManager.setBpDeffered();
+        }
+        this.breakpointManager.addBreakpoint(breakpoint);
+        return this.breakpointManager.promiseBpDeffered();
+    }
+    /**
+     * 运行时修改断点信息
+     */
+    async runtimeUpdateBreakpoint(event) {
+        const { affected, statusUpdated } = event;
+        if (statusUpdated) {
+            return;
+        }
+        return await this.setBreakpoints(affected);
+    }
+    /**
+     * 初始化加载用户的断点信息
+     */
+    async initBreakpoints() {
+        this.settingBreakpoints = new ide_core_browser_1.Deferred();
+        this.id2Breakpoint.clear();
+        // 当配置为noDebug时，仅运行程序，不设置断点
+        if (!this.configuration.noDebug) {
+            await this.setBreakpoints(this.breakpointManager.affected.map((str) => ide_core_browser_1.URI.parse(str)));
+        }
+        this.settingBreakpoints.resolve();
+        this.settingBreakpoints = null;
+    }
+    get currentThread() {
+        return this._currentThread;
+    }
+    set currentThread(thread) {
+        this.toDisposeOnCurrentThread.dispose();
+        this._currentThread = thread;
+        if (thread) {
+            this.toDisposeOnCurrentThread.push(thread.onDidChanged(() => this.fireDidChange()));
+        }
+    }
+    get multipleThreadPaused() {
+        return this._multipleThreadPaused;
+    }
+    hasInMultipleThreadPaused(id) {
+        return this._multipleThreadPaused.has(id);
+    }
+    clearThreads() {
+        var _a;
+        const frontEndTime = this.sessionManager.reportTime(common_1.DEBUG_REPORT_NAME.DEBUG_UI_FRONTEND_TIME, {
+            sessionId: this.id,
+            threadId: (_a = this.currentThread) === null || _a === void 0 ? void 0 : _a.id,
+            threadAmount: this.threadCount,
+        });
+        this._threads.forEach((thread) => {
+            thread.clear();
+        });
+        this._onDidChangeCallStack.fire();
+        this.collocationThread();
+        frontEndTime('clearThreads');
+    }
+    clearThread(threadId) {
+        const frontEndTime = this.sessionManager.reportTime(common_1.DEBUG_REPORT_NAME.DEBUG_UI_FRONTEND_TIME, {
+            sessionId: this.id,
+            threadId,
+            threadAmount: this.threadCount,
+        });
+        const thread = this._threads.get(threadId);
+        if (thread) {
+            thread.clear();
+            this._onDidChangeCallStack.fire();
+        }
+        this.collocationThread();
+        frontEndTime('clearThread');
+    }
+    get state() {
+        if (this.connection.disposed) {
+            return common_1.DebugState.Inactive;
+        }
+        if (!this.initialized) {
+            return common_1.DebugState.Initializing;
+        }
+        const thread = this.currentThread;
+        if (thread) {
+            return thread.stopped ? common_1.DebugState.Stopped : common_1.DebugState.Running;
+        }
+        else if (this.supportsThreadIdCorrespond) {
+            return common_1.DebugState.Running;
+        }
+        return !!this.stoppedThreads.next().value ? common_1.DebugState.Stopped : common_1.DebugState.Running;
+    }
+    get currentFrame() {
+        return this.currentThread && this.currentThread.currentFrame;
+    }
+    async getScopes(parent) {
+        const { currentFrame } = this;
+        return currentFrame ? currentFrame.getScopes(parent) : [];
+    }
+    get label() {
+        if (common_1.InternalDebugSessionOptions.is(this.options) && this.options.id) {
+            return this.configuration.name + ' (' + (this.options.id + 1) + ')';
+        }
+        return this.configuration.name;
+    }
+    get visible() {
+        return this.state > common_1.DebugState.Inactive;
+    }
+    getSource(raw) {
+        const uri = debug_source_1.DebugSource.toUri(raw).toString();
+        const source = this.sources.get(uri) || new debug_source_1.DebugSource(this, this.labelProvider, this.modelManager, this.workbenchEditorService, this.fileSystem);
+        source.update({ raw });
+        this.sources.set(uri, source);
+        return source;
+    }
+    getSourceForUri(uri) {
+        return this.sources.get(uri.toString());
+    }
+    async toSource(uri) {
+        const source = this.getSourceForUri(uri);
+        if (source) {
+            return source;
+        }
+        return this.getSource(await this.toDebugSource(uri));
+    }
+    async toDebugSource(uri) {
+        if (uri.scheme === debug_source_1.DebugSource.SCHEME) {
+            return {
+                name: uri.path.toString(),
+                sourceReference: Number(uri.query),
+            };
+        }
+        const name = uri.displayName;
+        let path = uri.toString();
+        if (uri.scheme === 'file') {
+            path = await this.fileSystem.getFsPath(path);
+        }
+        return {
+            name,
+            path,
+            adapterData: undefined,
+            sourceReference: undefined,
+        };
+    }
+    get threads() {
+        return Array.from(this._threads.values());
+    }
+    get threadCount() {
+        return this._threads.size;
+    }
+    *getThreads(filter) {
+        for (const thread of this.threads) {
+            if (filter(thread)) {
+                yield thread;
+            }
+        }
+    }
+    get runningThreads() {
+        return this.getThreads((thread) => !thread.stopped);
+    }
+    get stoppedThreads() {
+        return this.getThreads((thread) => thread.stopped);
+    }
+    async rawFetchThreads(threadId) {
+        const arg = typeof threadId === 'undefined' ? null : { threadId };
+        const response = await this.sendRequest('threads', arg);
+        if (response && response.body && response.body.threads && Array.isArray(response.body.threads)) {
+            return Promise.resolve(response.body.threads);
+        }
+        return Promise.resolve([]);
+    }
+    async fetchThreads() {
+        const rawThreads = await this.rawFetchThreads();
+        const existing = this._threads;
+        const threads = [];
+        for (const raw of rawThreads) {
+            const id = raw.id;
+            const thread = existing.get(id) || new debug_thread_1.DebugThread(this);
+            threads.push(thread);
+            thread.update({ raw });
+        }
+        return Promise.resolve(threads);
+    }
+    updateThreads(stoppedDetails) {
+        return this.pendingThreads = this.pendingThreads.then(async () => {
+            try {
+                // java debugger returns an empty body sometimes
+                const threads = await this.rawFetchThreads();
+                this.doUpdateThreads(threads, stoppedDetails);
+            }
+            catch (e) {
+                // console.error(e);
+            }
+        });
+    }
+    doUpdateThreads(rawThreads, stoppedDetails) {
+        const frontEndTime = this.sessionManager.reportTime(common_1.DEBUG_REPORT_NAME.DEBUG_UI_FRONTEND_TIME, {
+            sessionId: this.id,
+            threadId: stoppedDetails === null || stoppedDetails === void 0 ? void 0 : stoppedDetails.threadId,
+            threadAmount: rawThreads.length,
+        });
+        const threadIds = [];
+        rawThreads.forEach((raw) => {
+            threadIds.push(raw.id);
+            if (!this._threads.has(raw.id)) {
+                const thread = new debug_thread_1.DebugThread(this);
+                const data = { raw };
+                thread.update(data);
+                this._threads.set(raw.id, thread);
+            }
+            else if (raw.name) {
+                const oldThread = this._threads.get(raw.id);
+                if (oldThread) {
+                    oldThread.raw.name = raw.name;
+                }
+            }
+        });
+        this._threads.forEach((dthread) => {
+            var _a;
+            const { raw: { id } } = dthread;
+            if (threadIds.indexOf(id) === -1) {
+                this._threads.delete(id);
+            }
+            if (stoppedDetails && (stoppedDetails.allThreadsStopped || stoppedDetails.threadId === id)) {
+                (_a = this._threads.get(id)) === null || _a === void 0 ? void 0 : _a.update({ stoppedDetails });
+            }
+        });
+        this.collocationThread(stoppedDetails);
+        frontEndTime('doUpdateThreads');
+    }
+    /**
+     * 两种更新 currentThread 方式
+     * 一. collocationThread: 在 threads 列表里查找
+     * 二. updateCurrentThread: 发送 threads DAP 给 debug server，由 server 去查找并返回。前提是 supportsThreadIdCorrespond 必须为 true
+     */
+    collocationThread(stoppedDetails) {
+        var _a;
+        const { currentThread } = this;
+        let threadId = currentThread && currentThread.raw.id;
+        if (stoppedDetails && !stoppedDetails.preserveFocusHint && !!stoppedDetails.threadId) {
+            threadId = stoppedDetails.threadId;
+        }
+        this.currentThread = typeof threadId === 'number' && this._threads.get(threadId) || this._threads.values().next().value;
+        if (((_a = this.currentThread) === null || _a === void 0 ? void 0 : _a.raw.id) !== threadId) {
+            this.fireDidChange();
+        }
+    }
+    async updateCurrentThread(thread) {
+        if (thread) {
+            this.currentThread = thread;
+            this._onCurrentThreadChange.fire(this.currentThread);
+        }
+        else {
+            this.currentThread = undefined;
+            this._onCurrentThreadChange.fire(undefined);
+        }
+    }
+    /**
+     * 收集被暂停的线程 map
+     */
+    async collectPausedThread(stoppedDetails) {
+        const threads = await this.rawFetchThreads(stoppedDetails === null || stoppedDetails === void 0 ? void 0 : stoppedDetails.threadId);
+        if (threads.length === 0) {
+            return new Map();
+        }
+        const debugThread = stoppedDetails.threadId && this._multipleThreadPaused.has(stoppedDetails.threadId) ? this._multipleThreadPaused.get(stoppedDetails.threadId) : new debug_thread_1.DebugThread(this);
+        const data = { raw: threads[0] };
+        if (stoppedDetails && (stoppedDetails.allThreadsStopped || stoppedDetails.threadId === threads[0].id)) {
+            data.stoppedDetails = stoppedDetails;
+        }
+        if (debugThread) {
+            debugThread.update(data);
+            await this.rawFetchFrames(debugThread);
+            this._multipleThreadPaused.set(debugThread.raw.id, debugThread);
+        }
+        return this._multipleThreadPaused;
+    }
+    async updateCurrentThreadFramesOnFocus() {
+        await this.rawFetchFrames(this.currentThread);
+        this._onDidChangeCallStack.fire();
+        const editor = this.workbenchEditorService.currentEditor;
+        const focus = (f) => {
+            if (this.stoppedDetails && !this.stoppedDetails.preserveFocusHint) {
+                this.currentThread.currentFrame = f;
+            }
+        };
+        if (this.currentThread && !this.currentFrame) {
+            // 过滤出有效的 frame source 资源
+            const frames = this.currentThread.frames.filter((f) => f && f.source && f.source.raw.presentationHint !== 'deemphasize');
+            if (frames.length === 0) {
+                return;
+            }
+            if (editor) {
+                const model = editor.monacoEditor.getModel();
+                if (model) {
+                    const uri = ide_core_browser_1.URI.parse(model.uri.toString());
+                    const curFram = frames.filter((f) => f.source.uri.toString() === uri.toString());
+                    if (Array.isArray(curFram)) {
+                        focus(curFram[0]);
+                    }
+                }
+            }
+            else {
+                focus(frames[0]);
+            }
+        }
+    }
+    async rawFetchFrames(thread) {
+        if (!thread || thread.frameCount) {
+            return;
+        }
+        if (this.capabilities.supportsDelayedStackTraceLoading) {
+            await thread.rawFetchFrames(1);
+            await thread.rawFetchFrames(19);
+        }
+        else {
+            await thread.rawFetchFrames();
+        }
+    }
+    async terminate(restart) {
+        if (!this.terminated && this.capabilities.supportsTerminateRequest && this.configuration.request === 'launch') {
+            this.terminated = true;
+            this.sendRequest('terminate', { restart });
+            if (!await this.exited(1000)) {
+                await this.disconnect(restart);
+            }
+        }
+        else {
+            await this.disconnect(restart);
+        }
+    }
+    async disconnect(restart) {
+        try {
+            this.sendRequest('disconnect', { restart });
+        }
+        catch (reason) {
+            this.fireExited(reason);
+            return;
+        }
+        finally {
+            this._onDidExitAdapter.fire();
+            this.onStateChange();
+        }
+        const timeout = 500;
+        if (!await this.exited(timeout)) {
+            this.fireExited(new Error(`timeout after ${timeout} ms`));
+        }
+    }
+    updateCapabilities(capabilities) {
+        Object.assign(this._capabilities, capabilities);
+    }
+    fireExited(reason) {
+        this.connection.fire('exited', { reason });
+    }
+    exited(timeout) {
+        return Promise.race([
+            this.exitDeferred.promise.then(() => true, () => false),
+            new Promise((resolve) => {
+                setTimeout(resolve, timeout, false);
+            }),
+        ]);
+    }
+    async restart() {
+        if (this.capabilities.supportsRestartRequest) {
+            this.terminated = false;
+            await this.sendRequest('restart', {});
+            return true;
+        }
+        return false;
+    }
+    dispose() {
+        this.toDispose.dispose();
+    }
+    async evaluate(expression, context) {
+        var _a;
+        // evaluate muse wait for frames updated
+        if (this.updateDeffered) {
+            await ((_a = this.updateDeffered) === null || _a === void 0 ? void 0 : _a.promise);
+        }
+        const frameId = this.currentFrame && this.currentFrame.raw.id;
+        const response = await this.sendRequest('evaluate', { expression, frameId, context });
+        return response.body;
+    }
+    async goto(args) {
+        if (this.capabilities.supportsGotoTargetsRequest) {
+            const res = await this.sendRequest('goto', args);
+            return res;
+        }
+    }
+    async cancel(progressId) {
+        return this.sendRequest('cancel', { progressId });
+    }
+    async setVariableValue(args) {
+        if (this.capabilities.supportsSetVariable) {
+            const res = await this.sendRequest('setVariable', args);
+            this._onVariableChange.fire();
+            return res;
+        }
+    }
+    async breakpointLocations(uri, line) {
+        var _a;
+        const source = await this.toSource(uri);
+        const response = await this.sendRequest('breakpointLocations', { source: source.raw, line });
+        const positions = (((_a = response.body) === null || _a === void 0 ? void 0 : _a.breakpoints) || []).map((item) => ({ lineNumber: item.line, column: item.column || 1 }));
+        return Object.values(positions.reduce((obj, p) => (Object.assign(Object.assign({}, obj), { [`${p.lineNumber}:${p.column}`]: p })), {}));
+    }
+    async sendRequest(command, args, token) {
+        var _a, _b, _c;
+        if ((!this._capabilities.supportsTerminateRequest && command === 'terminate') ||
+            (!this._capabilities.supportsCompletionsRequest && command === 'completions') ||
+            (!this._capabilities.supportsTerminateThreadsRequest && command === 'terminateThreads')) {
+            throw new Error(`debug: ${command} not supported`);
+        }
+        let requestToken;
+        if (['continue', 'next', 'stepIn', 'stepOut', 'threads'].some((c) => command === c)) {
+            this.handleCancellation((_a = this.currentThread) === null || _a === void 0 ? void 0 : _a.raw.id);
+        }
+        if (['stackTrace', 'scopes', 'variables', 'completions', 'threads'].some((c) => command === c)) {
+            requestToken = ((_b = this.currentThread) === null || _b === void 0 ? void 0 : _b.raw.id) ? this.getNewCancellationToken((_c = this.currentThread) === null || _c === void 0 ? void 0 : _c.raw.id, token) : undefined;
+        }
+        try {
+            return await this.connection.sendRequest(command, args, this.configuration, requestToken);
+        }
+        finally {
+            this._onRequest.fire(command);
+        }
+    }
+    async takeCommand(command) {
+        return new Promise((resolve) => {
+            const disposable = this.onRequest((e) => {
+                if (e === command) {
+                    disposable.dispose();
+                    resolve();
+                }
+            });
+        });
+    }
+    sendCustomRequest(command, args) {
+        return this.connection.sendCustomRequest(command, args);
+    }
+    on(kind, listener) {
+        return this.connection.on(kind, listener);
+    }
+    get onDidCustomEvent() {
+        return this.connection.onDidCustomEvent;
+    }
+    // REPL
+    hasSeparateRepl() {
+        return !this.parentSession || this.options.repl !== 'mergeWithParent';
+    }
+    // REPL end
+    // report service
+    reportTime(name, defaults) {
+        return this.sessionManager.reportTime(name, defaults);
+    }
+    // Cancellation
+    getNewCancellationToken(threadId, token) {
+        const tokenSource = new ide_core_common_1.CancellationTokenSource(token);
+        const tokens = this.cancellationMap.get(threadId) || [];
+        tokens.push(tokenSource);
+        this.cancellationMap.set(threadId, tokens);
+        return tokenSource.token;
+    }
+    cancelAllRequests() {
+        this.cancellationMap.forEach((tokens) => tokens.forEach((t) => t.cancel()));
+        this.cancellationMap.clear();
+    }
+    handleCancellation(threadId) {
+        if (threadId) {
+            const tokens = this.cancellationMap.get(threadId);
+            this.cancellationMap.delete(threadId);
+            if (tokens) {
+                tokens.forEach((t) => t.cancel());
+            }
+        }
+        else {
+            this.cancelAllRequests();
+        }
+    }
+    // Cancellation end
+    getDebugProtocolBreakpoint(breakpointId) {
+        const data = this.breakpointManager.getBreakpoints().find((bp) => bp.id === breakpointId);
+        if (data) {
+            const status = data.status.get(this.id);
+            const bp = {
+                id: status === null || status === void 0 ? void 0 : status.id,
+                verified: !!(status === null || status === void 0 ? void 0 : status.verified),
+                message: status === null || status === void 0 ? void 0 : status.message,
+                source: status === null || status === void 0 ? void 0 : status.source,
+                line: status === null || status === void 0 ? void 0 : status.line,
+                column: status === null || status === void 0 ? void 0 : status.column,
+                endLine: status === null || status === void 0 ? void 0 : status.endLine,
+                endColumn: status === null || status === void 0 ? void 0 : status.endColumn,
+                instructionReference: status === null || status === void 0 ? void 0 : status.instructionReference,
+                offset: status === null || status === void 0 ? void 0 : status.offset,
+            };
+            return bp;
+        }
+        return undefined;
+    }
+    currentEditor() {
+        var _a;
+        return (_a = this.getModel()) === null || _a === void 0 ? void 0 : _a.editor;
+    }
+    getModel() {
+        return this.modelManager.model;
+    }
+}
+exports.DebugSession = DebugSession;
+//# sourceMappingURL=debug-session.js.map