@lcap/nasl 0.3.9 → 0.3.10-beta

package/out/types/logic/Debugger.js

@@ -0,0 +1,912 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.Debugger = void 0;
+const { io } = require('socket.io-client');
+const __1 = require("..");
+const debugger_1 = require("../../service/debugger/debugger");
+const LOGIC_BRANCH = ['IfStatement', 'WhileStatement', 'SwitchStatement', 'ForEachStatement'];
+const parentAttrRoot = [undefined, 'consequent', 'alternate', 'cases'];
+function getScopeVariableNames(node) {
+    let variables = [];
+    let params = [];
+    let returns = [];
+    if (node?.view) {
+        variables = [...node.view.$def.variables];
+        params = [...node.view.$def.params];
+    }
+    if (node) {
+        variables = [...variables, ...node.variables];
+        params = [...params, ...node.params];
+        returns = [...returns, ...node.returns];
+    }
+    return {
+        variables: variables.map((v) => v.name),
+        params: params.map((p) => p.name),
+        returns: returns.map((r) => r.name),
+    };
+}
+function matchVariableValue(names, originData) {
+    return names.map((n) => {
+        const value = originData[n];
+        const type = typeof value;
+        return {
+            name: n,
+            result: {
+                type,
+                value,
+            },
+        };
+    });
+}
+function resolveFrontEndTarget(componentId, lineNumber) {
+    const view = __1.Vertex.getVertexByRef(componentId);
+    const sourceMap = view.sourceMap;
+    const targets = Object.values(sourceMap).filter((m) => {
+        if (m.node?.type === 'JSBlock')
+            return lineNumber >= m.from && lineNumber <= m.to;
+        else
+            return lineNumber === m.from;
+    });
+    // const arr = targets.map((item) => vertexsMap.get(item.vertexId));
+    //     let target;
+    //     for (let i = 0; i < arr.length; i++) {
+    //         if (!arr[i] || arr.includes(arr[i].parent)) {
+    //             continue;
+    //         }
+    //         target = targets[i];
+    //         break;
+    //     }
+    //     return {
+    //         ...target,
+    //         node: Vertex.getVertexByRef(target.vertexId),
+    //     };
+    let target;
+    const arr = targets.map((item) => __1.vertexsMap.get(item.node.id));
+    for (let i = 0; i < arr.length; i++) {
+        if (!arr[i] || arr.includes(arr[i].parent))
+            continue;
+        target = targets[i];
+    }
+    if (!target) {
+        return null;
+    }
+    return {
+        ...target,
+        node: __1.Vertex.getVertexByRef(target.node.id),
+    };
+}
+function resolveFrontEndCallFrame(callFrames, currentBreakTarget) {
+    const functionStack = callFrames.map((cf) => {
+        const view = __1.Vertex.getVertexByRef(cf.componentId);
+        const sourceMap = view.sourceMap;
+        const target = Object.values(sourceMap).find((m) => cf.line >= m.from && cf.line <= m.to && m.isLogic);
+        // const viewInvoke = Vertex.getVertexByRef(cf.componentId);
+        // const sourceMapInvoke = view.sourceMap;
+        const invokeItem = Object.values(sourceMap).find((m) => m.from === cf.invokeLocation.line && m.node.type === 'CallLogic');
+        return {
+            ...cf,
+            target,
+            invokeItem,
+        };
+    });
+    return [{
+            target: currentBreakTarget,
+        }, ...functionStack];
+}
+function resolveCallFrameSimple(callFrames) {
+    return callFrames.map((cf) => {
+        const view = __1.Vertex.getVertexByRef(cf.componentId);
+        const sourceMap = view.sourceMap;
+        // const target = Object.values(sourceMap).find((m) => cf.line >= m.from && cf.line <= m.to && m.isLogic);
+        const target = Object.values(sourceMap).find((m) => m.from === cf.line && m.node.type === 'CallLogic');
+        return {
+            ...cf,
+            target,
+        };
+    });
+}
+class SocketEvent extends __1.EventEmitter {
+    constructor() {
+        super(...arguments);
+        this.debuggerClient = null;
+    }
+    // emitSocket(eventName: string, payload: any) {
+    //     this.debuggerClient.emit('debug', {
+    //         event: eventName,
+    //         payload,
+    //     });
+    // }
+    emitSocket(payload) {
+        this.debuggerClient.emit('debug', payload);
+    }
+}
+const FrontEndProtocol = {
+    setbreakpoint(bp) {
+        return {
+            target: 'Frontend',
+            event: 'setbreakpoint',
+            payload: {
+                componentId: bp.componentId,
+                line: bp.lineNumberStart,
+                id: bp._uuid,
+                isTemporary: bp.isTemporary,
+            },
+        };
+    },
+    removeBreakpoint(bp) {
+        return {
+            target: 'Frontend',
+            event: 'removeBreakpoint',
+            payload: {
+                breakpointId: bp.remoteBreakpointId,
+                id: bp._uuid,
+            },
+        };
+    },
+    breakPointReceived() {
+        return {
+            target: 'Frontend',
+            event: 'breakPointReceived',
+        };
+    },
+    step(posibleBps) {
+        return {
+            target: 'Frontend',
+            event: 'step',
+            payload: {
+                posibleBps,
+            },
+        };
+    },
+    resume() {
+        return {
+            target: 'Frontend',
+            event: 'resume',
+        };
+    },
+    normalizeResponse(data) {
+        if (data.event) {
+            return {
+                event: data.event,
+                payload: data.payload,
+                source: 'Frontend',
+            };
+        }
+        return null;
+    },
+    evaluatescope(payload) {
+        return {
+            target: 'Frontend',
+            event: 'evaluatescope',
+            payload,
+        };
+    },
+    evaluate(payload) {
+        return {
+            target: 'Frontend',
+            event: 'evaluate',
+            payload,
+        };
+    },
+};
+const BackEndProtocol = {
+    setbreakpoint(bp) {
+        return {
+            target: 'Backend',
+            operation: {
+                appId: bp.appId,
+                className: bp.classIdentify,
+                lineNumber: bp.lineNumberStart,
+                eventType: 'BREAKPOINT',
+                breakpointStatus: 'ENABLED',
+            },
+        };
+    },
+    removeBreakpoint(bp) {
+        return {
+            target: 'Backend',
+            operation: {
+                appId: bp.appId,
+                className: bp.classIdentify,
+                lineNumber: bp.lineNumberStart,
+                eventType: 'BREAKPOINT',
+                breakpointStatus: 'DELETED',
+            },
+        };
+    },
+    resume(appid, threadId) {
+        return {
+            target: 'Backend',
+            operation: {
+                appId: appid,
+                eventType: 'RESUME',
+                threadId,
+            },
+        };
+    },
+    step(appid, threadId) {
+        return {
+            target: 'Backend',
+            operation: {
+                appId: appid,
+                eventType: 'STEP_OVER',
+                threadId,
+            },
+        };
+    },
+    normalizeResponse(data) {
+        switch (data.type) {
+            case 'DebugInfo':
+                return {
+                    event: 'paused',
+                    payload: data.data,
+                    source: 'Backend',
+                };
+            case 'ConnectionInfo':
+                return {
+                    event: 'connection',
+                    payload: data.data,
+                    source: 'Backend',
+                };
+            case 'ExceptionInfo':
+                return {
+                    event: 'exception',
+                    payload: data.message,
+                    source: 'Backend',
+                };
+            default:
+                return null;
+        }
+    },
+};
+class Debugger extends __1.EventEmitter {
+    constructor() {
+        super();
+        this.debuggerClient = null;
+        this.currentThread = null;
+        this.threads = [];
+        this.currentFrontEndThread = null;
+        this.frontendConnection = false;
+        this.backendConnection = false;
+        this.ideConnection = false;
+        this.breakPoints = [];
+        this.temporaryBreakPoint = null;
+        this.temporaryBreakPointTriggered = false;
+        this.logicIdClassMap = {};
+        this.classLogicIdMap = {};
+        this.booting = false;
+        this.on('backendConnected', this.onConnectionEnd.bind(this));
+        this.on('frontendConnected', this.onConnectionEnd.bind(this));
+    }
+    get isConnected() {
+        // return this.frontendConnection;
+        // return this.backendConnection;
+        return this.frontendConnection && this.backendConnection;
+    }
+    get isBreak() {
+        return (this.currentThread && this.currentThread.breakPoint);
+    }
+    get isInFrontendThread() {
+        return this.currentFrontEndThread === this.currentThread;
+    }
+    async closeConnect() {
+        if (this.debuggerClient) {
+            await new Promise((resolve) => {
+                this.debuggerClient.on('disconnect', (reason) => {
+                    if (reason === 'io client disconnect') {
+                        this.debuggerClient = null;
+                        this.frontendConnection = false;
+                        this.backendConnection = false;
+                        this.ideConnection = false;
+                        resolve('closed');
+                    }
+                });
+                this.debuggerClient.disconnect();
+            });
+        }
+    }
+    async boot() {
+        try {
+            if (this.debuggerClient) {
+                return;
+            }
+            this.ideConnection = false;
+            this.debuggerClient = await debugger_1.createSocketClient(this.app.appId);
+            this.ideConnection = true;
+            this.socketEventEmitter = new SocketEvent();
+            this.socketEventEmitter.debuggerClient = this.debuggerClient;
+            // this.debuggerClient.emit('debug', { source: 'ide' });
+            this.debuggerClient.on('debug', (data) => {
+                if (typeof data === 'object') {
+                    const { event, payload, source, } = FrontEndProtocol.normalizeResponse(data) || BackEndProtocol.normalizeResponse(data);
+                    this.socketEventEmitter.emit(event, payload, source);
+                }
+            });
+            this.socketEventEmitter.on('getBreakPoint', this.onFetchBreakPoint.bind(this));
+            this.socketEventEmitter.on('connection', this.onConnection.bind(this));
+            this.socketEventEmitter.on('breakpointsettle', this.onBreakPointSettle.bind(this));
+            this.socketEventEmitter.on('removeBreakpointsettle', this.onRemoveBreakpointsettle.bind(this));
+            this.socketEventEmitter.on('paused', this.onPaused.bind(this));
+            this.socketEventEmitter.on('evaluateresult', this.onEvaluateResult.bind(this));
+            this.socketEventEmitter.on('evaluatescoperesult', ({ code, data }) => {
+                if (code !== 200) {
+                    return;
+                }
+                // const result = data.result.value;
+                this.currentFrontEndThread.callFrameScope = data;
+            });
+            this.socketEventEmitter.on('logictrace', this.onLogicTrace.bind(this));
+            this.socketEventEmitter.on('logictraceend', this.onLogicTraceEnd.bind(this));
+            this.socketEventEmitter.on('exception', this.onBackEndException.bind(this));
+        }
+        catch (err) {
+            console.error(err);
+            throw '连接失败';
+        }
+    }
+    /*combineCallFrameScope(data) {
+        const {
+            variables,
+            params,
+            returns,
+        } = data;
+
+        const {
+            variables: currVariable,
+            params: currParams,
+            returns: currReturns,
+        } = this.currentCallFrameScope;
+        function comparePart(part, oldpart) {
+            const list
+            = part.forEach(({ name, result }) => {
+                if (result.subtype === 'error') {
+                    return oldpart.find((v) => v.name === name);
+                }
+            });
+        }
+    }*/
+    resetState() {
+        this.currentThread = null;
+        this.threads = [];
+        this.currentFrontEndThread = null;
+        this.temporaryBreakPoint = null;
+        this.temporaryBreakPointTriggered = false;
+    }
+    async onFetchBreakPoint(data) {
+        const componentId = data.data.sourceCodeId;
+        const promises = [];
+        this.breakPoints.forEach((bp) => {
+            if (bp.status === 'Enabled' && bp.componentId === componentId) {
+                const attachResult = bp.attachSourceMap();
+                if (attachResult) {
+                    promises.push(this.setRemoteBreakPointRoundTrip(bp));
+                }
+            }
+        });
+        await Promise.all(promises);
+        this.socketEventEmitter.emitSocket(FrontEndProtocol.breakPointReceived());
+    }
+    onBreakPointSettle(data) {
+        // if(!data.data || !data.data.id) {
+        //     bp.emit('bpsettled', false);
+        //     return;
+        // }
+        const bpid = data.data.id;
+        const bp = this.breakPoints.find((bp) => bp._uuid === bpid) || this.temporaryBreakPoint;
+        if (data.code !== 200) {
+            bp.emit('bpsettled', false);
+            return;
+        }
+        if (bp) {
+            bp.remoteBreakpointId = data.data.breakpointId;
+            bp.emit('bpsettled', true);
+        }
+    }
+    onRemoveBreakpointsettle(data) {
+        const bpid = data.data.id;
+        const bp = this.breakPoints.find((bp) => bp._uuid === bpid);
+        bp.emit('bpremoved');
+    }
+    async onConnection(data, source) {
+        if (source === 'Frontend') {
+            this.onFrontEndConnection(data);
+        }
+        if (source === 'Backend') {
+            await this.onBackEndConnection(data);
+        }
+    }
+    onFrontEndConnection(data) {
+        if (data.code === 200) {
+            this.frontendConnection = true;
+            const currentRequestId = data.data.requestId;
+            const idx = this.threads.findIndex((t) => t === this.currentFrontEndThread);
+            ~idx && this.threads.splice(idx, 1);
+            this.currentFrontEndThread = {
+                id: null,
+                requestId: currentRequestId,
+                frontendStack: null,
+                callFrameId: null,
+                breakPoint: null,
+                evaluateExpression: null,
+                evaluateValue: null,
+                callFrames: null,
+                callFrameScope: null,
+            };
+            this.threads.unshift(this.currentFrontEndThread);
+            this.emit('frontendConnected');
+        }
+        else {
+            this.frontendConnection = false;
+            this.emit('frontendConnectionFailed');
+        }
+    }
+    async onBackEndConnection(data) {
+        if (data.status === 'Connected') {
+            await this.loadBackEndSourceMap();
+            this.backendConnection = true;
+            this.emit('backendConnected');
+        }
+        else {
+            if (data.name === 'Frontend') {
+                this.frontendConnection = false;
+                this.emit('frontendConnectionFailed');
+            }
+            else {
+                this.backendConnection = false;
+                this.emit('backendConnectionFailed');
+            }
+        }
+    }
+    async loadBackEndSourceMap() {
+        const response = await debugger_1.sourceMapService.getSourceMap({
+            query: {
+                appId: this.app.firstMicroService.id,
+            },
+        });
+        const { vertexMap, logicIdClassMap, classLogicIdMap, } = response;
+        this.logicIdClassMap = logicIdClassMap || {};
+        this.classLogicIdMap = classLogicIdMap || {};
+        const map = Object.values(vertexMap || {});
+        Object.keys(this.logicIdClassMap).forEach((logicId) => {
+            const classname = this.logicIdClassMap[logicId];
+            const logic = __1.Vertex.getVertexByRef(logicId);
+            const sourcemap = {};
+            map.forEach((m) => {
+                if (m.classIdentify === classname) {
+                    sourcemap[m.vertexId] = m;
+                }
+            });
+            logic.sourceMap = sourcemap;
+        });
+    }
+    onConnectionEnd() {
+        // if (this.isConnected) {
+        //     this.breakPoints.forEach((bp) => {
+        //         if (bp.status === 'Enabled') {
+        //             const attachResult = bp.attachSourceMap();
+        //             if (attachResult) {
+        //                 this.setRemoteBreakPointRoundTrip(bp);
+        //             }
+        //         }
+        //     });
+        // }
+    }
+    onLogicTrace(data) {
+        this.temporaryLogicCallStack = data.data;
+    }
+    onLogicTraceEnd() {
+        // 跳出后端逻辑
+        this.currentFrontEndThread.frontendStack = null;
+        this.currentFrontEndThread.id = null;
+    }
+    onPaused(data, source) {
+        if (source === 'Frontend') {
+            this.onFrontEndPaused(data);
+        }
+        if (source === 'Backend') {
+            this.onBackEndPaused(data);
+        }
+    }
+    onFrontEndPaused({ code, data }) {
+        if (code !== 200) {
+            return;
+        }
+        // const requestId = data.requestId;
+        const location = data.location;
+        // const isTemporaryBreakPoint = data.isTemporaryBreakPoint;
+        // const callFrames = data.payload.callFrames;
+        const target = resolveFrontEndTarget(location.componentId, location.line);
+        // const view = Vertex.getVertexByRef(location.componentId);
+        // const sourceMap = view.sourceMap;
+        // const targets = Object.values(sourceMap).filter((m) => {
+        //     if (m.node?.type === 'JSBlock')
+        //         return location.line >= m.from && location.line <= m.to;
+        //     else
+        //         return location.line === m.from && m.node?.level === 'logicNode';
+        // });
+        // function getTarget(targets) {
+        //     const arr = targets.map((item) => vertexsMap.get(item.node.id));
+        //     for (let i = 0; i < arr.length; i++) {
+        //         if (!arr[i] || arr.includes(arr[i].parent))
+        //             continue;
+        //         return targets[i];
+        //     }
+        // }
+        // const target = getTarget(targets);
+        if (target) {
+            const currentFrontEndThread = this.currentFrontEndThread;
+            const logicItem = target.node;
+            let breakPoint = logicItem.getBreakPointByLineNumber(location.line);
+            if (!breakPoint) {
+                breakPoint = logicItem.addTemperaryBreakPoint();
+                this.temporaryBreakPoint = breakPoint;
+                this.temporaryBreakPointTriggered = true;
+            }
+            currentFrontEndThread.breakPoint = breakPoint; // isTemporaryBreakPoint ? this.temporaryBreakPoint : ;
+            const callframes = resolveFrontEndCallFrame(data.callFramesResolved, target);
+            currentFrontEndThread.callFrames = callframes;
+            const currentCallFrame = callframes[1];
+            const logic = logicItem.logic;
+            const frameVariables = getScopeVariableNames(logic);
+            this.socketEventEmitter.emitSocket(FrontEndProtocol.evaluatescope(Object.assign({}, frameVariables, {
+                callFrameId: currentCallFrame.callFrameId,
+            })));
+            currentFrontEndThread.callFrameId = currentCallFrame.callFrameId;
+            logicItem.folded = false;
+            this.app.emit('openLogicItem', logicItem);
+            this.app.emit('openDebugger');
+            this.currentThread = currentFrontEndThread;
+        }
+    }
+    async resolveBackEndTarget(className, lineNumber) {
+        const logicId = this.classLogicIdMap[className];
+        const logic = __1.Vertex.getVertexByRef(logicId);
+        const sourceMap = logic.sourceMap;
+        const targets = Object.values(sourceMap).filter((m) => lineNumber === m.lineFrom);
+        const arr = await Promise.all(targets.map(async (item) => {
+            const p = __1.vertexsMap.get(item.vertexId);
+            if (!p) {
+                const logic = __1.Vertex.getVertexByRef(item.logicId);
+                await logic.load();
+                return __1.vertexsMap.get(item.vertexId);
+            }
+            return p;
+        }));
+        let target;
+        for (let i = 0; i < arr.length; i++) {
+            if (!arr[i] || arr.includes(arr[i].parent)) {
+                continue;
+            }
+            target = targets[i];
+            break;
+        }
+        return {
+            ...target,
+            node: __1.Vertex.getVertexByRef(target.vertexId),
+        };
+    }
+    async onBackEndPaused(data) {
+        const { threadId, requestId: backReqId, className, lineNumber, stackFrames, variables, } = data;
+        const target = await this.resolveBackEndTarget(className, lineNumber);
+        if (target) {
+            const logicItem = __1.Vertex.getVertexByRef(target.vertexId);
+            let breakPoint = logicItem.getBreakPointByLineNumber(lineNumber);
+            if (!breakPoint) {
+                breakPoint = logicItem.addTemperaryBreakPoint();
+                this.temporaryBreakPoint = breakPoint;
+                this.temporaryBreakPointTriggered = true;
+            }
+            let threadCurrent;
+            if (this.currentFrontEndThread.requestId === backReqId) {
+                threadCurrent = this.currentFrontEndThread;
+                if (threadCurrent.id !== threadId) {
+                    Object.assign(this.currentFrontEndThread, {
+                        id: threadId,
+                        frontendStack: this.temporaryLogicCallStack?.callFramesResolved,
+                    });
+                }
+            }
+            else {
+                threadCurrent = this.threads.find((t) => t.id === threadId);
+                if (!threadCurrent) {
+                    threadCurrent = {
+                        id: threadId,
+                        frontendStack: null,
+                        breakPoint: null,
+                        evaluateValue: null,
+                        callFrames: null,
+                        callFrameScope: null,
+                    };
+                    this.threads.push(threadCurrent);
+                }
+            }
+            // TODO resolve frames and scope
+            let callFrames = await Promise.all(stackFrames.map(async (cf) => {
+                const { className, lineNumber, } = cf;
+                const target = await this.resolveBackEndTarget(className, lineNumber);
+                return {
+                    ...cf,
+                    target,
+                };
+            }));
+            const frontendStack = threadCurrent.frontendStack;
+            if (frontendStack) {
+                callFrames = callFrames.concat(resolveCallFrameSimple(frontendStack));
+            }
+            const logic = logicItem.logic;
+            const frameVariables = getScopeVariableNames(logic);
+            const callFrameScope = {
+                variables: matchVariableValue(frameVariables.variables, variables),
+                params: matchVariableValue(frameVariables.params, variables),
+                returns: matchVariableValue(frameVariables.returns, variables),
+            };
+            Object.assign(threadCurrent, {
+                breakPoint,
+                evaluateValue: null,
+                callFrames,
+                callFrameScope,
+            });
+            this.currentThread = threadCurrent;
+            this.app.emit('openLogicItem', logicItem);
+            this.app.emit('openDebugger');
+        }
+    }
+    onBackEndException(data) {
+    }
+    onEvaluateResult({ code, data }) {
+        if (code !== 200) {
+            return;
+        }
+        const result = data.result.value;
+        const currentFrontEndThread = this.currentFrontEndThread;
+        currentFrontEndThread.evaluateValue = {
+            [currentFrontEndThread.evaluateExpression]: result,
+        };
+    }
+    evaluateExpression(expression) {
+        const currentFrontEndThread = this.currentFrontEndThread;
+        currentFrontEndThread.evaluateExpression = expression;
+        this.socketEventEmitter.emitSocket(FrontEndProtocol.evaluate({
+            callFrameId: currentFrontEndThread.callFrameId,
+            expression,
+        }));
+    }
+    async setRemoteBreakPoint(bp) {
+        if (bp.isTemporary) {
+            this.temporaryBreakPoint = bp;
+        }
+        await this.setRemoteBreakPointRoundTrip(bp);
+    }
+    async removeAllBreakPoint() {
+        await debugger_1.breakpointService.removeAllBreakPoints({
+            query: {
+                appId: this.app.id,
+            },
+        });
+        await Promise.all(this.breakPoints.map(async (bp) => {
+            if (this.isConnected) {
+                await this.removeRemoteBreakPointRoundTrip(bp);
+            }
+            bp.removeOnLogicItem();
+        }));
+        this.breakPoints = [];
+    }
+    async enableAllBreakPoint() {
+        await debugger_1.breakpointService.updateAllBreakPointState({
+            query: {
+                appId: this.app.id,
+                status: 'Enabled',
+            },
+        });
+        await Promise.all(this.breakPoints.map(async (bp) => {
+            if (this.isConnected && bp.status === 'Disabled') {
+                await this.setRemoteBreakPointRoundTrip(bp);
+            }
+            bp.status = 'Enabled';
+        }));
+    }
+    async disableAllBreakPoint() {
+        await debugger_1.breakpointService.updateAllBreakPointState({
+            query: {
+                appId: this.app.id,
+                status: 'Disabled',
+            },
+        });
+        await Promise.all(this.breakPoints.map(async (bp) => {
+            if (this.isConnected && bp.status === 'Enabled') {
+                await this.removeRemoteBreakPointRoundTrip(bp);
+            }
+            bp.status = 'Disabled';
+        }));
+    }
+    async removeRemoteBreakPoint(bp) {
+        const index = this.breakPoints.findIndex((b) => b === bp);
+        if (index !== -1) {
+            if (this.isConnected) {
+                await this.removeRemoteBreakPointRoundTrip(bp);
+            }
+            this.breakPoints.splice(index, 1);
+        }
+    }
+    async removeRemoteBreakPointRoundTrip(bp) {
+        await new Promise((resolve) => {
+            let payload;
+            if (bp.target === 'Frontend') {
+                payload = FrontEndProtocol.removeBreakpoint(bp);
+                bp.once('bpremoved', () => {
+                    resolve(bp);
+                });
+            }
+            if (bp.target === 'Backend') {
+                payload = BackEndProtocol.removeBreakpoint(bp);
+                resolve(bp);
+            }
+            this.socketEventEmitter.emitSocket(payload);
+        });
+    }
+    async setRemoteBreakPointRoundTrip(bp) {
+        const result = await new Promise((resolve) => {
+            let payload;
+            if (bp.target === 'Frontend') {
+                payload = FrontEndProtocol.setbreakpoint(bp);
+                bp.once('bpsettled', () => {
+                    resolve(bp);
+                });
+            }
+            if (bp.target === 'Backend') {
+                payload = BackEndProtocol.setbreakpoint(bp);
+                resolve(bp);
+            }
+            this.socketEventEmitter.emitSocket(payload);
+        });
+        return result;
+    }
+    async step() {
+        if (!this.isBreak) {
+            return;
+        }
+        this.resetTemporaryBreakPoint();
+        if (this.currentThread) {
+            // 后端
+            if (this.currentThread === this.currentFrontEndThread && !this.currentThread.id) {
+                const thread = this.currentThread;
+                const logicitem = thread.breakPoint.logicItem;
+                const logic = logicitem.logic;
+                const componentId = logic.view.id;
+                const sourceMap = logic.view.sourceMap;
+                const breakpointTemporary = [];
+                function addBp(logicItem) {
+                    breakpointTemporary.push({
+                        componentId,
+                        line: sourceMap[logicItem.id].from,
+                        isTemporary: true,
+                        type: logicitem.type,
+                    });
+                }
+                function searchLogicItemPosibleBreakPoint(logicItem) {
+                    const type = logicItem.type;
+                    if (logicItem.level !== 'logicNode') {
+                        return;
+                    }
+                    if (LOGIC_BRANCH.includes(type)) {
+                        if (type === 'IfStatement') {
+                            addBp(logicItem);
+                            (logicItem.consequent || []).forEach(searchLogicItemPosibleBreakPoint);
+                            (logicItem.alternate || []).forEach(searchLogicItemPosibleBreakPoint);
+                        }
+                        if (type === 'WhileStatement') {
+                            addBp(logicItem);
+                            (logicItem.body || []).forEach(searchLogicItemPosibleBreakPoint);
+                        }
+                        if (type === 'SwitchStatement') {
+                            addBp(logicItem);
+                            const l = (logicItem.cases || []).length - 1;
+                            (logicItem.cases || []).forEach((c, idx) => {
+                                if (idx !== l) {
+                                    searchLogicItemPosibleBreakPoint(c);
+                                }
+                                (c.consequent || []).forEach(searchLogicItemPosibleBreakPoint);
+                                (c.alternate || []).forEach(searchLogicItemPosibleBreakPoint);
+                            });
+                        }
+                        if (type === 'ForEachStatement') {
+                            addBp(logicItem);
+                            (logicItem.body || []).forEach(searchLogicItemPosibleBreakPoint);
+                        }
+                    }
+                    else {
+                        if (logicItem.hasBreakPoint && logicItem.breakPoint && logicItem.breakPoint.status === 'Enabled') {
+                            return;
+                        }
+                        addBp(logicItem);
+                    }
+                }
+                logic.body.forEach(searchLogicItemPosibleBreakPoint);
+                this.socketEventEmitter.emitSocket(FrontEndProtocol.step(breakpointTemporary));
+                // const index = logicitem.logic.body.findIndex((l) => l === logicitem);
+                // const nextLogicItem = logicitem.logic.body[index + 1];
+                // if (nextLogicItem && nextLogicItem.type !== 'End') {
+                //     const breakPoint = nextLogicItem.addTemperaryBreakPoint();
+                //     await this.setRemoteBreakPoint(breakPoint);
+                //     this.resume();
+                // }
+            }
+            else {
+                this.socketEventEmitter.emitSocket(BackEndProtocol.step(this.app.id, this.currentThread.id));
+            }
+        }
+    }
+    async stepInto() {
+        // TODO
+        // if (!this.currentBreakPoint) {
+        //     return;
+        // }
+        // this.resetTemporaryBreakPoint();
+        // const logicitem = this.currentBreakPoint.logicItem;
+        // if (logicitem.type === 'CallLogic' && logicitem.callee) {
+        //     const logicId = logicitem.callee.split('/').pop();
+        //     const logic = Vertex.getVertexByRef(logicId);
+        //     const logicItem = logic.body[1];
+        //     const breakPoint = logicItem.addTemperaryBreakPoint();
+        //     await this.setRemoteBreakPoint(breakPoint);
+        //     this.resume();
+        // }
+    }
+    async stepOut() {
+        // TODO
+        // if (!this.currentBreakPoint) {
+        //     return;
+        // }
+        // if (this.currentCallFrames.length < 2) {
+        //     return;
+        // }
+        // this.resetTemporaryBreakPoint();
+        // const callFrame = this.currentCallFrames[1];
+        // const invokeLogicNode = callFrame.invokeItem.node;
+        // const logicItem = Vertex.getVertexByRef(invokeLogicNode.id);
+        // const invokeLogic = logicItem.logic;
+        // const idx = invokeLogic.body.findIndex((i) => i === logicItem);
+        // const nextItem = invokeLogic.body[idx + 1];
+        // if (nextItem && nextItem.type !== 'End') {
+        //     const breakPoint = nextItem.addTemperaryBreakPoint();
+        //     await this.setRemoteBreakPoint(breakPoint);
+        //     this.resume();
+        // }
+    }
+    resetTemporaryBreakPoint() {
+        if (this.temporaryBreakPointTriggered) {
+            this.temporaryBreakPoint.logicItem.temporaryBreakPoint = null;
+            this.temporaryBreakPoint = null;
+            this.temporaryBreakPointTriggered = false;
+        }
+    }
+    resumeUserAction() {
+        this.resetTemporaryBreakPoint();
+        this.resume();
+    }
+    resume() {
+        if (this.currentThread) {
+            if (this.currentThread === this.currentFrontEndThread) {
+                if (this.currentFrontEndThread.id) {
+                    this.socketEventEmitter.emitSocket(BackEndProtocol.resume(this.app.id, this.currentFrontEndThread.id));
+                }
+                else {
+                    this.socketEventEmitter.emitSocket(FrontEndProtocol.resume());
+                }
+            }
+            else {
+                this.socketEventEmitter.emitSocket(BackEndProtocol.resume(this.app.id, this.currentThread.id));
+            }
+            Object.assign(this.currentThread, {
+                callFrameId: null,
+                breakPoint: null,
+                evaluateExpression: null,
+                evaluateValue: null,
+                callFrames: null,
+                callFrameScope: null,
+            });
+        }
+    }
+}
+exports.Debugger = Debugger;
+//# sourceMappingURL=Debugger.js.map