iobroker.javascript 10.2.2 → 10.2.4

package/build/lib/inspect.js

@@ -1,9 +1,4 @@
 "use strict";
-var __importDefault = (this && this.__importDefault) || function (mod) {
-    return (mod && mod.__esModule) ? mod : { "default": mod };
-};
-Object.defineProperty(exports, "__esModule", { value: true });
-exports.NodeInspector = void 0;
 /*
  * Copyright Node.js contributors. All rights reserved.
  *
@@ -25,318 +20,202 @@ exports.NodeInspector = void 0;
  * FROM, OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS
  * IN THE SOFTWARE.
  */
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+/*
+ * The inspector process. It is forked by the adapter (see `debugStart` in main.ts) and starts the process to debug -
+ * the javascript adapter itself with `--debugScript <scriptId>` or another adapter - with an enabled inspector.
+ * It connects to it via the DevTools protocol and translates the commands of the GUI into protocol calls and back.
+ *
+ * The communication with the host happens via IPC with JSON strings:
+ * - host -> inspector: `DebugCommand`
+ * - inspector -> host: `CommandToHost`
+ */
 const node_child_process_1 = require("node:child_process");
-const node_events_1 = require("node:events");
-const node_net_1 = require("node:net");
-const node_util_1 = require("node:util");
-const node_path_1 = require("node:path");
 const node_fs_1 = require("node:fs");
+const node_path_1 = require("node:path");
+const node_url_1 = require("node:url");
+const node_util_1 = require("node:util");
 // @ts-expect-error no types available
 const inspect_client_1 = __importDefault(require("node-inspect/lib/internal/inspect_client"));
-const debugger_1 = __importDefault(require("./debugger"));
-const breakOnStart = process.argv.includes('--breakOnStart');
 const debuglog = (0, node_util_1.debuglog)('inspect');
-let inspector;
-let scriptToDebug = ''; // script.js.yy
-let instanceToDebug = ''; // adapter.X
-let alreadyPausedOnFirstLine = false;
+/** Stay paused on the first line of the debugged process (used for the debugging of adapter instances) */
+const breakOnStart = process.argv.includes('--breakOnStart');
+/**
+ * By debugging of a script, stepping and "stop on exception" should not stop in the node internals,
+ * in 3rd party modules and in the adapter itself (e.g., in sandbox.js)
+ */
+const SCRIPT_BLACKBOX_PATTERNS = ['^node:', '/node_modules/', '[iI]o[bB]roker\\.javascript/build/'];
 class StartupError extends Error {
     constructor(message) {
         super(message);
         this.name = 'StartupError';
     }
 }
-function portIsFree(host, port, timeout = 9999) {
-    if (port === 0) {
-        // Binding to a random port.
-        return Promise.resolve();
+let inspector;
+/** ID of the debugged script, like `script.js.myScript` */
+let scriptToDebug = '';
+/** Main file of the debugged adapter */
+let instanceToDebug = '';
+function sendToHost(data) {
+    if (data.cmd === 'error') {
+        console.error(`[DEBUGGER] ${data.error}`);
     }
-    const retryDelay = 150;
-    let didTimeOut = false;
-    return new Promise((resolve, reject) => {
-        setTimeout(() => {
-            didTimeOut = true;
-            reject(new StartupError(`Timeout (${timeout}) waiting for ${host}:${port} to be free`));
-        }, timeout);
-        function pingPort() {
-            if (didTimeOut) {
-                return;
-            }
-            const socket = (0, node_net_1.connect)(port, host);
-            let didRetry = false;
-            function retry() {
-                if (!didRetry && !didTimeOut) {
-                    didRetry = true;
-                    setTimeout(pingPort, retryDelay);
-                }
-            }
-            socket.on('error', (error) => {
-                if (error.code === 'ECONNREFUSED') {
-                    resolve();
-                }
-                else {
-                    retry();
-                }
-            });
-            socket.on('connect', () => {
-                socket.destroy();
-                retry();
-            });
+    try {
+        process.send?.(JSON.stringify(data));
+    }
+    catch (e) {
+        // The host is not reachable anymore
+        console.error(`[DEBUGGER] Cannot send to host: ${e}`);
+    }
+}
+function errorToString(e) {
+    if (e instanceof Error) {
+        return e.message;
+    }
+    return typeof e === 'string' ? e : JSON.stringify(e);
+}
+function reportError(text, e) {
+    sendToHost({ cmd: 'error', error: e === undefined ? text : `${text}: ${errorToString(e)}` });
+}
+function remoteObjectToString(obj) {
+    if (!obj) {
+        return '';
+    }
+    if (obj.value !== undefined) {
+        return typeof obj.value === 'string' ? obj.value : JSON.stringify(obj.value);
+    }
+    return obj.unserializableValue || obj.description || obj.type;
+}
+function consoleTypeToSeverity(type) {
+    switch (type) {
+        case 'warning':
+            return 'warn';
+        case 'error':
+        case 'assert':
+            return 'error';
+        case 'debug':
+            return 'debug';
+        default:
+            return 'info';
+    }
+}
+/** Values like NaN, Infinity, -0 or BigInt cannot be transferred as JSON value */
+function toCallArgument(value) {
+    if (typeof value === 'number' && (!Number.isFinite(value) || Object.is(value, -0))) {
+        return { unserializableValue: Object.is(value, -0) ? '-0' : String(value) };
+    }
+    if (typeof value === 'bigint') {
+        return { unserializableValue: `${value}n` };
+    }
+    return value === undefined ? {} : { value };
+}
+function isUrlOfFile(url, file) {
+    let path = url;
+    if (url.startsWith('file://')) {
+        try {
+            path = (0, node_url_1.fileURLToPath)(url);
         }
-        pingPort();
-    });
+        catch {
+            return false;
+        }
+    }
+    path = (0, node_path_1.normalize)(path);
+    file = (0, node_path_1.normalize)(file);
+    return process.platform === 'win32' ? path.toLowerCase() === file.toLowerCase() : path === file;
 }
-function runScript(script, scriptArgs, inspectHost, inspectPort, childPrint) {
-    script = (0, node_path_1.normalize)(script);
-    return portIsFree(inspectHost, inspectPort).then(() => {
-        return new Promise(resolve => {
-            const args = [breakOnStart ? `--inspect-brk=${inspectPort}` : `--inspect=${inspectPort}`].concat([script], scriptArgs || []);
-            const child = (0, node_child_process_1.spawn)(process.execPath, args);
-            child.stdout.setEncoding('utf8');
-            child.stderr.setEncoding('utf8');
-            child.stdout.on('data', childPrint);
-            child.stderr.on('data', text => childPrint(text, true));
-            let output = '';
-            function waitForListenHint(text) {
-                output += text;
-                const res = /Debugger listening on ws:\/\/\[?(.+?)]?:(\d+)\//.exec(output);
-                if (res) {
-                    const host = res[1];
-                    const port = Number.parseInt(res[2]);
-                    child.stderr.removeListener('data', waitForListenHint);
-                    resolve([child, port, host]);
-                }
-            }
-            child.stderr.on('data', waitForListenHint);
-        });
+function createDomain(domain, client) {
+    return new Proxy({}, {
+        get: (_target, method) => 
+        // the object must not look like a promise
+        typeof method === 'string' && method !== 'then'
+            ? (params) => client.callMethod(`${domain}.${method}`, params)
+            : undefined,
     });
 }
-function createAgentProxy(domain, client) {
-    const agent = new node_events_1.EventEmitter();
-    agent.then = (...args) => {
-        // TODO: potentially fetch the protocol and pretty-print it here.
-        const descriptor = {
-            [node_util_1.inspect.custom](_depth, { stylize }) {
-                return stylize(`[Agent ${domain}]`, 'special');
-            },
-        };
-        return Promise.resolve(descriptor).then(...args);
-    };
-    return new Proxy(agent, {
-        get(target, name) {
-            if (name in target) {
-                return target[name];
+function runScript(script, scriptArgs, childPrint) {
+    return new Promise((resolve, reject) => {
+        // Always break on start: the process must not run before the debugger is connected, else it could
+        // execute the `debugger;` statement of the script before. Port 0 means any free port.
+        const child = (0, node_child_process_1.spawn)(process.execPath, ['--inspect-brk=127.0.0.1:0', (0, node_path_1.normalize)(script), ...scriptArgs]);
+        child.stdout.setEncoding('utf8');
+        child.stderr.setEncoding('utf8');
+        child.stdout.on('data', (text) => childPrint(text));
+        child.stderr.on('data', (text) => childPrint(text, true));
+        let output = '';
+        const timeout = setTimeout(() => {
+            child.stderr.removeListener('data', waitForListenHint);
+            child.kill();
+            reject(new StartupError('Timeout by starting of the process to debug'));
+        }, 10_000);
+        function waitForListenHint(text) {
+            output += text;
+            const res = /Debugger listening on ws:\/\/\[?(.+?)]?:(\d+)\//.exec(output);
+            if (res) {
+                clearTimeout(timeout);
+                child.stderr.removeListener('data', waitForListenHint);
+                resolve([child, parseInt(res[2], 10), res[1]]);
             }
-            return function callVirtualMethod(params) {
-                return client.callMethod(`${domain}.${name}`, params);
-            };
-        },
+        }
+        child.stderr.on('data', waitForListenHint);
+        child.on('error', error => {
+            clearTimeout(timeout);
+            reject(new StartupError(`Cannot start the process to debug: ${error.message}`));
+        });
     });
 }
 class NodeInspector {
-    options;
-    stdin;
-    stdout;
-    scripts;
-    delayedContext;
-    paused;
-    child;
-    _runScript;
-    client;
     Debugger;
-    HeapProfiler;
-    Profiler;
     Runtime;
-    handleDebugEvent;
+    client = new inspect_client_1.default();
+    file;
+    args;
+    child = null;
+    /** The protocol does not deliver the URLs in the call frames anymore, so remember them */
+    scriptUrls = {};
     mainScriptId;
-    mainFile;
-    repl;
-    constructor(options, stdin, stdout) {
-        this.options = options;
-        this.stdin = stdin;
-        this.stdout = stdout;
-        this.scripts = {};
-        this.delayedContext = null;
-        this.paused = true;
-        this.child = null;
-        if (options.script) {
-            this._runScript = runScript.bind(null, options.script, options.scriptArgs, options.host, options.port, this.childPrint.bind(this));
-        }
-        else {
-            this._runScript = () => Promise.resolve([null, options.port, options.host]);
-        }
-        this.client = new inspect_client_1.default();
-        this.Debugger = createAgentProxy('Debugger', this.client);
-        this.HeapProfiler = createAgentProxy('HeapProfiler', this.client);
-        this.Profiler = createAgentProxy('Profiler', this.client);
-        this.Runtime = createAgentProxy('Runtime', this.client);
-        this.handleDebugEvent = (fullName, params) => {
-            const [domain, name] = fullName.split('.');
-            if (domain === 'Debugger' && name === 'scriptParsed') {
-                // console.log(`Parsed: ${params.url}`);
-                if ((scriptToDebug && params.url.includes(scriptToDebug)) ||
-                    (instanceToDebug && params.url.includes(instanceToDebug))) {
-                    console.log(`My scriptID: ${params.scriptId}`);
-                    this.mainScriptId = params.scriptId;
-                    this.mainFile = params.url.replace('file:///', '');
-                    // load text of a script
-                    this.scripts[this.mainScriptId] = this.Debugger.getScriptSource({
-                        scriptId: this.mainScriptId,
-                    }).then((script) => ({
-                        script: script.scriptSource,
-                        scriptId: this.mainScriptId,
-                    }));
-                    // sometimes the pause event comes before scriptParsed
-                    if (this.delayedContext) {
-                        console.log('Send to debugger: readyToDebug');
-                        void this.scripts[this.mainScriptId]?.then(data => {
-                            // console.log(`Send to debugger: readyToDebug ${JSON.stringify(data)}`);
-                            sendToHost({
-                                cmd: 'readyToDebug',
-                                scriptId: this.mainScriptId,
-                                script: data.script,
-                                context: this.delayedContext,
-                                url: this.mainFile,
-                            });
-                            this.delayedContext = null;
-                        });
-                    }
-                }
-                return;
-            }
-            else if (domain === 'Debugger' && name === 'resumed') {
-                this.Debugger.emit(name, params);
-                sendToHost({ cmd: 'resumed', context: params });
-                return;
-            }
-            else if (domain === 'Debugger' && name === 'paused') {
-                console.log(`PAUSED!! ${alreadyPausedOnFirstLine}`);
-                if (!alreadyPausedOnFirstLine && params.reason === 'exception') {
-                    // ignore all exceptions by start
-                    this.Debugger.resume();
-                    return;
-                }
-                //console.warn(`${fullName}: => \n${JSON.stringify(params, null, 2)}`);
-                this.Debugger.emit(name, params);
-                if (!alreadyPausedOnFirstLine) {
-                    alreadyPausedOnFirstLine = true;
-                    // sometimes the pause event comes before scriptParsed
-                    if (this.mainScriptId && this.scripts[this.mainScriptId]) {
-                        void this.scripts[this.mainScriptId]?.then(data => sendToHost({
-                            cmd: 'readyToDebug',
-                            scriptId: data.scriptId,
-                            script: data.script,
-                            context: params,
-                            url: this.mainFile,
-                        }));
-                    }
-                    else {
-                        // store context to send it later when script ID will be known
-                        this.delayedContext = params;
-                        console.log('PAUSED, but no scriptId');
-                    }
-                }
-                else {
-                    // this.scripts[params.loca]
-                    //    .then(data =>
-                    sendToHost({ cmd: 'paused', context: params });
-                }
-                return;
-            }
-            if (domain === 'Runtime') {
-                //console.warn(`${fullName}: => \n${JSON.stringify(params, null, 2)}`);
-            }
-            if (domain === 'Runtime' && name === 'consoleAPICalled') {
-                const text = params.args[0].value;
-                if (instanceToDebug) {
-                    sendToHost({
-                        cmd: 'log',
-                        severity: params.type === 'warning' ? 'warn' : 'error',
-                        text,
-                        ts: Date.now(),
-                    });
-                }
-                else if (text.includes(`$$${scriptToDebug}$$`)) {
-                    console.log(`${fullName} [${params.executionContextId}]: => ${text}`);
-                    const [severity, _text] = text.split(`$$${scriptToDebug}$$`);
-                    sendToHost({
-                        cmd: 'log',
-                        severity: severity,
-                        text: _text,
-                        ts: params.args[1] && params.args[1].value ? params.args[1].value : Date.now(),
-                    });
-                }
-                else if (params.type === 'warning' || params.type === 'error') {
-                    sendToHost({
-                        cmd: 'log',
-                        severity: params.type === 'warning' ? 'warn' : 'error',
-                        text,
-                        ts: Date.now(),
-                    });
-                }
-                return;
+    mainFile = '';
+    mainScriptSource = null;
+    /** Sometimes the first pause comes before the main script is parsed */
+    delayedContext = null;
+    pausedOnFirstLine = false;
+    /** Execution context of the debugged script */
+    scriptContextId;
+    finished = false;
+    constructor(file, args) {
+        this.file = file;
+        this.args = args;
+        this.Debugger = createDomain('Debugger', this.client);
+        this.Runtime = createDomain('Runtime', this.client);
+        this.client.on('debugEvent', (fullName, params) => this.handleDebugEvent(fullName, params || {}));
+    }
+    async start() {
+        const [child, port, host] = await runScript(this.file, this.args, (text, isError) => this.childPrint(text, isError));
+        this.child = child;
+        child.on('exit', code => this.finish(`Process exited with code ${code}`));
+        for (let attempt = 1;; attempt++) {
+            try {
+                await this.client.connect(port, host);
+                break;
             }
-            else if (domain === 'Runtime' && (params.id === 2 || params.executionContextId === 2)) {
-                if (name === 'executionContextCreated') {
-                    console.warn(`${fullName}: =>\n${JSON.stringify(params, null, 2)}`);
-                }
-                else if (name === 'executionContextDestroyed') {
-                    console.warn(`${fullName}: =>\n${JSON.stringify(params, null, 2)}`);
-                    sendToHost({ cmd: 'finished', context: params });
+            catch (e) {
+                debuglog(`Connection attempt #${attempt} failed: ${e}`);
+                if (attempt >= 10) {
+                    throw new StartupError(`Cannot connect to the debugger on ${host}:${port}`);
                 }
-                return;
-            }
-            else if (domain === 'Runtime' &&
-                name === 'executionContextDestroyed' &&
-                params.executionContextId === 1) {
-                sendToHost({ cmd: 'finished', context: params });
-                console.log('Exited!');
-                setTimeout(() => process.exit(125), 200);
+                await new Promise(resolve => setTimeout(resolve, 500));
             }
-            else if (domain === 'Debugger' && name === 'scriptFailedToParse') {
-                // ignore
-                return;
-            }
-            console.warn(`${fullName}: =>\n${JSON.stringify(params, null, 2)}`);
-            /*if (domain in this) {
-                this[domain].emit(name, params);
-            }*/
-        };
-        this.client.on('debugEvent', this.handleDebugEvent);
-        const startRepl = (0, debugger_1.default)(this);
-        // Handle all possible exits
-        process.on('exit', () => this.killChild());
-        process.once('SIGTERM', process.exit.bind(process, 0));
-        process.once('SIGHUP', process.exit.bind(process, 0));
-        this.run()
-            .then(() => startRepl())
-            .then(repl => {
-            this.repl = repl;
-            this.repl.on('exit', () => process.exit(0));
-            this.paused = false;
-        })
-            .then(null, error => process.nextTick(() => {
-            throw error;
-        }));
-    }
-    suspendReplWhile(fn) {
-        if (this.repl) {
-            this.repl.pause();
         }
-        this.stdin.pause();
-        this.paused = true;
-        return new Promise(resolve => resolve(fn()))
-            .then(() => {
-            this.paused = false;
-            if (this.repl) {
-                this.repl.resume();
-                this.repl.displayPrompt();
-            }
-            this.stdin.resume();
-        })
-            .then(null, error => process.nextTick(() => {
-            throw error;
-        }));
+        await Promise.all([
+            this.Runtime.enable(),
+            this.Debugger.enable(),
+            this.Debugger.setPauseOnExceptions({ state: 'none' }),
+            this.Debugger.setAsyncCallStackDepth({ maxDepth: 1 }),
+            this.Debugger.setBlackboxPatterns({ patterns: scriptToDebug ? SCRIPT_BLACKBOX_PATTERNS : [] }),
+            this.Runtime.runIfWaitingForDebugger(),
+        ]);
     }
     killChild() {
         this.client.reset();
@@ -345,384 +224,420 @@ class NodeInspector {
             this.child = null;
         }
     }
-    run() {
-        this.killChild();
-        return this._runScript().then(([child, port, host]) => {
-            this.child = child;
-            let connectionAttempts = 0;
-            const attemptConnect = () => {
-                ++connectionAttempts;
-                debuglog('connection attempt #%d', connectionAttempts);
-                this.stdout.write('.');
-                return this.client.connect(port, host).then(() => {
-                    debuglog('connection established');
-                    this.stdout.write(' ok');
-                }, (error) => {
-                    debuglog('connect failed', error);
-                    // If it's failed to connect 10 times, then print a failed message
-                    if (connectionAttempts >= 10) {
-                        this.stdout.write(' failed to connect, please retry\n');
-                        process.exit(1);
-                    }
-                    return new Promise(resolve => setTimeout(resolve, 500)).then(attemptConnect);
-                });
-            };
-            this.print(`connecting to ${host}:${port} ..`, true);
-            return attemptConnect();
-        });
-    }
-    clearLine() {
-        if (this.stdout.isTTY) {
-            this.stdout.cursorTo(0);
-            this.stdout.clearLine(1);
-        }
-        else {
-            this.stdout.write('\b');
+    finish(reason) {
+        if (this.finished) {
+            return;
         }
-    }
-    print(text, oneLine = false) {
-        this.clearLine();
-        this.stdout.write(oneLine ? text : `${text}\n`);
+        this.finished = true;
+        debuglog(reason);
+        sendToHost({ cmd: 'finished', text: reason });
+        this.killChild();
+        setTimeout(() => process.exit(0), 200);
     }
     childPrint(text, isError) {
-        isError &&
-            this.print(text
-                .toString()
+        if (isError) {
+            const lines = text
                 .split(/\r\n|\r|\n/g)
-                .filter((chunk) => !!chunk)
-                .map((chunk) => `< ${chunk}`)
-                .join('\n'));
-        if (!this.paused) {
-            this.repl?.displayPrompt(true);
+                .filter(line => !!line)
+                .map(line => `< ${line}`);
+            lines.length && process.stdout.write(`${lines.join('\n')}\n`);
         }
-        if (/Waiting for the debugger to disconnect\.\.\.\n$/.test(text)) {
-            this.killChild();
-            sendToHost({ cmd: 'finished', text });
+        // The debugged process ended, but it waits till the debugger disconnects
+        if (text.includes('Waiting for the debugger to disconnect')) {
+            this.finish('Process finished');
         }
     }
-}
-exports.NodeInspector = NodeInspector;
-function parseArgv([target, ...args]) {
-    let host = '127.0.0.1';
-    let port = 9229;
-    let isRemote = false;
-    let script = target;
-    let scriptArgs = args;
-    const hostMatch = target.match(/^([^:]+):(\d+)$/);
-    const portMatch = target.match(/^--port=(\d+)$/);
-    if (hostMatch) {
-        // Connecting to remote debugger
-        // `node-inspect localhost:9229`
-        host = hostMatch[1];
-        port = parseInt(hostMatch[2], 10);
-        isRemote = true;
-        script = null;
-    }
-    else if (portMatch) {
-        // start debugee on custom port
-        // `node inspect --port=9230 script.js`
-        port = parseInt(portMatch[1], 10);
-        script = args[0];
-        scriptArgs = args.slice(1);
-    }
-    else if (args.length === 1 && /^\d+$/.test(args[0]) && target === '-p') {
-        // Start debugger against a given pid
-        const pid = parseInt(args[0], 10);
-        try {
-            // Windows does not support UNIX signals. To enable debugging, you can use an undocumented API function
-            // https://github.com/node-inspector/node-inspector?tab=readme-ov-file#windows
-            // @ts-expect-error undocumented function
-            process._debugProcess(pid);
+    handleDebugEvent(fullName, params) {
+        switch (fullName) {
+            case 'Debugger.scriptParsed':
+                this.onScriptParsed(params);
+                break;
+            case 'Debugger.paused':
+                this.onPaused(params);
+                break;
+            case 'Debugger.resumed':
+                sendToHost({ cmd: 'resumed', context: params });
+                break;
+            case 'Runtime.consoleAPICalled':
+                this.onConsoleApiCalled(params);
+                break;
+            case 'Runtime.executionContextCreated':
+                // main.ts gives the context of a script the name of the script
+                if (scriptToDebug && params.context?.name === scriptToDebug) {
+                    this.scriptContextId = params.context.id;
+                }
+                break;
+            case 'Runtime.executionContextDestroyed':
+                if (params.executionContextId === 1) {
+                    // the main context of the debugged process is gone
+                    this.finish('Process finished');
+                }
+                else if (this.scriptContextId !== undefined && params.executionContextId === this.scriptContextId) {
+                    // the script was stopped, but the process is still running
+                    sendToHost({ cmd: 'finished', context: params });
+                }
+                break;
+            default:
+                debuglog(`${fullName}: ${JSON.stringify(params)}`);
+                break;
         }
-        catch (e) {
-            if (e && e.code === 'ESRCH') {
-                console.error(`Target process: ${pid} doesn't exist.`);
-                process.exit(1);
-            }
-            throw e;
+    }
+    onScriptParsed(params) {
+        const { scriptId, url } = params;
+        if (!scriptId || !url) {
+            return;
         }
-        script = null;
-        isRemote = true;
-    }
-    return {
-        host,
-        port,
-        isRemote,
-        script,
-        scriptArgs,
-    };
-}
-function startInspect(argv = process.argv.slice(2), stdin = process.stdin, stdout = process.stdout) {
-    /*
-    if (argv.length < 1) {
-        const invokedAs = runAsStandalone ? 'node-inspect' : `${process.argv0} ${process.argv[1]}`;
-
-        console.error(`Usage: ${invokedAs} script.js`);
-        console.error(`       ${invokedAs} <host>:<port>`);
-        console.error(`       ${invokedAs} -p <pid>`);
-        process.exit(1);
-    }
-    */
-    const options = parseArgv(argv);
-    inspector = new NodeInspector(options, stdin, stdout);
-    stdin.resume();
-    function handleUnexpectedError(e) {
-        if (!(e instanceof StartupError)) {
-            console.error('There was an internal error in node-inspect. Please report this bug.');
-            console.error(e.message);
-            console.error(e.stack);
+        this.scriptUrls[scriptId] = url;
+        const isMain = scriptToDebug ? url === scriptToDebug : !!instanceToDebug && isUrlOfFile(url, instanceToDebug);
+        if (!isMain) {
+            return;
         }
-        else {
-            console.error(e.message);
+        debuglog(`Script to debug parsed: ${scriptId}`);
+        this.mainScriptId = scriptId;
+        this.mainFile = url.replace('file:///', '');
+        this.mainScriptSource = this.Debugger.getScriptSource({ scriptId }).then((result) => result.scriptSource);
+        if (this.delayedContext) {
+            const context = this.delayedContext;
+            this.delayedContext = null;
+            void this.sendReadyToDebug(context);
         }
-        inspector.child?.kill();
-        process.exit(1);
-    }
-    process.on('uncaughtException', handleUnexpectedError);
-}
-function extractErrorMessage(stack) {
-    if (!stack) {
-        return '<unknown>';
     }
-    const m = stack.match(/^\w+: ([^\n]+)/);
-    return m ? m[1] : stack;
-}
-function convertResultToError(result) {
-    const { className, description } = result;
-    const err = new Error(extractErrorMessage(description));
-    err.stack = description;
-    Object.defineProperty(err, 'name', { value: className });
-    return err;
-}
-process.on('message', (message) => {
-    if (typeof message === 'string') {
-        try {
-            message = JSON.parse(message);
+    onPaused(params) {
+        if (!this.pausedOnFirstLine) {
+            if (params.reason === 'Break on start' && !breakOnStart) {
+                // the process was started with --inspect-brk only to have time to set up the debugger
+                this.Debugger.resume().catch(e => reportError('Cannot resume', e));
+                return;
+            }
+            if (params.reason === 'exception') {
+                // ignore all exceptions till the start of the script
+                this.Debugger.resume().catch(e => reportError('Cannot resume', e));
+                return;
+            }
         }
-        catch {
-            return console.error(`Cannot parse: ${JSON.stringify(message)}`);
+        this.enrichCallFrames(params);
+        if (this.pausedOnFirstLine &&
+            scriptToDebug &&
+            params.reason === 'step' &&
+            !params.callFrames?.[0]?.url?.startsWith('script.js.')) {
+            // Stepping left the script, e.g., at the end of a callback. The blackbox patterns do not cover
+            // all internals of node.js, so continue the execution instead of stopping there
+            this.Debugger.resume().catch(e => reportError('Cannot resume', e));
+            return;
         }
-    }
-    processCommand(message);
-});
-sendToHost({ cmd: 'ready' });
-function processCommand(data) {
-    console.log(`[DEBUGGER]: processCommand: ${JSON.stringify(data)}`);
-    if (data.cmd === 'start') {
-        scriptToDebug = data.scriptName;
-        // we can request the script by name or iobroker instance to debug
-        if (scriptToDebug) {
-            startInspect([
-                `${__dirname}/../main.js`,
-                (data.instance || 0).toString(),
-                '--debug',
-                '--debugScript',
-                scriptToDebug,
-            ]);
+        if (this.pausedOnFirstLine) {
+            sendToHost({ cmd: 'paused', context: params });
         }
         else {
-            instanceToDebug = data.adapterInstance;
-            const [adapter, instance] = instanceToDebug.split('.');
-            let file;
-            try {
-                file = require.resolve(`iobroker.${adapter}`);
+            this.pausedOnFirstLine = true;
+            if (this.mainScriptSource) {
+                void this.sendReadyToDebug(params);
             }
-            catch (e) {
-                // try to locate in the same dir
-                const dir = (0, node_path_1.normalize)((0, node_path_1.join)(__dirname, '..', `iobroker.${adapter}`));
-                if ((0, node_fs_1.existsSync)(dir)) {
-                    const pack = require((0, node_path_1.join)(dir, 'package.json'));
-                    if ((0, node_fs_1.existsSync)((0, node_path_1.join)(dir, pack.main || `${adapter}.js`))) {
-                        file = (0, node_path_1.join)(dir, pack.main || `${adapter}.js`);
-                    }
-                }
-                if (!file) {
-                    sendToHost({ cmd: 'error', error: `Cannot locate iobroker.${adapter}`, errorContext: e });
-                    setTimeout(() => {
-                        sendToHost({ cmd: 'finished', context: `Cannot locate iobroker.${adapter}` });
-                        setTimeout(() => process.exit(124), 500);
-                    }, 200);
-                    return;
-                }
+            else {
+                // store the context to send it, when the main script is parsed
+                this.delayedContext = params;
             }
-            file = file.replace(/\\/g, '/');
-            instanceToDebug = file;
-            console.log(`Start ${file} ${instance} --debug`);
-            startInspect([file, instance, '--debug']);
         }
     }
-    else if (data.cmd === 'end') {
-        process.exit();
-    }
-    else if (data.cmd === 'source') {
-        inspector.Debugger.getScriptSource({ scriptId: data.scriptId }).then((script) => sendToHost({ cmd: 'script', scriptId: data.scriptId, text: script.scriptSource }));
-    }
-    else if (data.cmd === 'cont') {
-        inspector.Debugger.resume().catch((e) => sendToHost({ cmd: 'error', error: e }));
-    }
-    else if (data.cmd === 'next') {
-        inspector.Debugger.stepOver().catch((e) => sendToHost({ cmd: 'error', error: e }));
-    }
-    else if (data.cmd === 'pause') {
-        inspector.Debugger.pause().catch((e) => sendToHost({ cmd: 'error', error: e }));
-    }
-    else if (data.cmd === 'step') {
-        inspector.Debugger.stepInto().catch((e) => sendToHost({ cmd: 'error', error: e }));
-    }
-    else if (data.cmd === 'out') {
-        inspector.Debugger.stepOut().catch((e) => sendToHost({ cmd: 'error', error: e }));
-    }
-    else if (data.cmd === 'sb') {
-        console.log(JSON.stringify(data));
-        void Promise.all(data.breakpoints?.map((bp) => inspector.Debugger.setBreakpoint({
-            location: {
-                scriptId: bp.scriptId,
-                lineNumber: bp.lineNumber,
-                columnNumber: bp.columnNumber,
-            },
-        })
-            .then((result) => ({
-            id: result.breakpointId,
-            location: result.actualLocation,
-        }))
-            .catch((e) => sendToHost({
-            cmd: 'error',
-            error: `Cannot set breakpoint: ${e}`,
-            errorContext: e,
-            bp,
-        }))) || []).then(breakpoints => sendToHost({ cmd: 'sb', breakpoints }));
-    }
-    else if (data.cmd === 'cb') {
-        void Promise.all(data.breakpoints?.map(breakpointId => inspector.Debugger.removeBreakpoint({ breakpointId })
-            .then(() => breakpointId)
-            .catch((e) => {
-            console.error(`[DEBUGGER]: Cannot clear breakpoint: ${e}`);
+    async sendReadyToDebug(context) {
+        try {
+            const script = await this.mainScriptSource;
+            this.enrichCallFrames(context);
             sendToHost({
-                cmd: 'error',
-                error: `Cannot clear breakpoint: ${e}`,
-                errorContext: e,
-                id: breakpointId,
+                cmd: 'readyToDebug',
+                scriptId: this.mainScriptId,
+                script,
+                context,
+                url: this.mainFile,
             });
-        })) || []).then(breakpoints => {
-            console.error(`[DEBUGGER]: sent breakpoints ${JSON.stringify(breakpoints)}`);
-            sendToHost({ cmd: 'cb', breakpoints });
+        }
+        catch (e) {
+            reportError('Cannot read the source of the script to debug', e);
+        }
+    }
+    enrichCallFrames(context) {
+        context.callFrames?.forEach(frame => {
+            if (!frame.url) {
+                frame.url = this.scriptUrls[frame.location.scriptId] || '';
+            }
         });
     }
-    else if (data.cmd === 'watch') {
-        void Promise.all(data.expressions?.map(expr => inspector.Debugger.watch(expr).catch((e) => sendToHost({
-            cmd: 'error',
-            error: `Cannot watch expr: ${e}`,
-            errorContext: e,
-            expr,
-        }))) || []).then(() => console.log('Watch done'));
-    }
-    else if (data.cmd === 'unwatch') {
-        void Promise.all(data.expressions?.map(expr => inspector.Debugger.unwatch(expr).catch((e) => sendToHost({
-            cmd: 'error',
-            error: `Cannot unwatch expr: ${e}`,
-            errorContext: e,
-            expr,
-        }))) || []).then(() => console.log('Watch done'));
-    }
-    else if (data.cmd === 'scope') {
-        void Promise.all(data.scopes
-            ?.filter(scope => scope?.object?.objectId)
-            .map(scope => inspector.Runtime.getProperties({
-            objectId: scope.object.objectId,
-            generatePreview: true,
-        })
-            .then((result) => {
-            return { type: scope.type, properties: result };
-        })
-            .catch((e) => sendToHost({
-            cmd: 'error',
-            error: `Cannot get scopes expr: ${e}`,
-            errorContext: e,
-        }))) || []).then(scopes => sendToHost({ cmd: 'scope', scopes }));
-    }
-    else if (data.cmd === 'setValue') {
-        inspector.Debugger.setVariableValue({
-            variableName: data.variableName,
-            scopeNumber: data.scopeNumber,
-            newValue: data.newValue,
-            callFrameId: data.callFrameId,
-        })
-            .catch((e) => {
-            console.error(`Cannot setValue "${data.variableName}": ${e}`);
+    onConsoleApiCalled(params) {
+        const args = params.args || [];
+        if (instanceToDebug) {
             sendToHost({
-                cmd: 'setValue',
-                variableName: `Cannot setValue: ${e}`,
-                errorContext: e,
+                cmd: 'log',
+                severity: consoleTypeToSeverity(params.type),
+                text: args.map(arg => remoteObjectToString(arg)).join(' '),
+                ts: Date.now(),
             });
-        })
-            .then(() => {
-            console.log(`setValue "${data.variableName}" successful`);
+            return;
+        }
+        // The sandbox logs in debug mode as `console.log(`${severity}$$${scriptName}$$${message}`, Date.now())`
+        const text = remoteObjectToString(args[0]);
+        const marker = `$$${scriptToDebug}$$`;
+        const pos = text.indexOf(marker);
+        if (pos !== -1) {
             sendToHost({
-                cmd: 'setValue',
-                variableName: data.variableName,
-                scopeNumber: data.scopeNumber,
-                newValue: data.newValue,
-                callFrameId: data.callFrameId,
+                cmd: 'log',
+                severity: text.substring(0, pos),
+                text: text.substring(pos + marker.length),
+                ts: typeof args[1]?.value === 'number' ? args[1].value : Date.now(),
             });
-        });
+        }
+        else if (params.type === 'warning' || params.type === 'error') {
+            sendToHost({
+                cmd: 'log',
+                severity: consoleTypeToSeverity(params.type),
+                text: args.map(arg => remoteObjectToString(arg)).join(' '),
+                ts: Date.now(),
+            });
+        }
     }
-    else if (data.cmd === 'expressions') {
-        void Promise.all(data.expressions?.map(item => inspector.Debugger.evaluateOnCallFrame({
-            callFrameId: data.callFrameId,
-            expression: item.name,
-            objectGroup: 'node-inspect',
-            returnByValue: true,
-            generatePreview: true,
-        })
-            // @ts-expect-error fix later
-            .then(({ result, wasThrown }) => {
-            if (wasThrown) {
-                return { name: item.name, result: convertResultToError(result) };
+}
+function resolveAdapterMainFile(adapter) {
+    try {
+        return require.resolve(`iobroker.${adapter}`);
+    }
+    catch {
+        // try to locate it in the same node_modules directory as this adapter
+        const dir = (0, node_path_1.normalize)((0, node_path_1.join)(__dirname, '..', '..', '..', `iobroker.${adapter}`));
+        if ((0, node_fs_1.existsSync)((0, node_path_1.join)(dir, 'package.json'))) {
+            try {
+                const pack = JSON.parse((0, node_fs_1.readFileSync)((0, node_path_1.join)(dir, 'package.json'), 'utf8'));
+                const main = (0, node_path_1.join)(dir, pack.main || `${adapter}.js`);
+                if ((0, node_fs_1.existsSync)(main)) {
+                    return main;
+                }
             }
-            return { name: item.name, result };
-        })
-            .catch((e) => sendToHost({
-            cmd: 'expressions',
-            variableName: `Cannot setValue: ${e}`,
-            errorContext: e,
-        }))) || []).then(expressions => {
-            sendToHost({ cmd: 'expressions', expressions });
-        });
+            catch {
+                // ignore
+            }
+        }
     }
-    else if (data.cmd === 'stopOnException') {
-        inspector.Debugger.setPauseOnExceptions({
-            state: data.state ? 'all' : 'none',
-        }).catch((e) => sendToHost({
-            cmd: 'stopOnException',
-            variableName: `Cannot stopOnException: ${e}`,
-            errorContext: e,
-        }));
-    }
-    else if (data.cmd === 'getPossibleBreakpoints') {
-        inspector.Debugger.getPossibleBreakpoints({ start: data.start, end: data.end })
-            .then((breakpoints) => sendToHost({ cmd: 'getPossibleBreakpoints', breakpoints: breakpoints.locations }))
-            .catch((e) => sendToHost({
-            cmd: 'getPossibleBreakpoints',
-            variableName: `Cannot getPossibleBreakpoints: ${e}`,
-            errorContext: e,
-        }));
+    return undefined;
+}
+function startDebugging(data) {
+    if (inspector) {
+        reportError('The debugger is already started');
+        return;
     }
-    else {
-        console.error(`Unknown command: ${JSON.stringify(data)}`);
+    if (data.scriptName) {
+        scriptToDebug = data.scriptName;
+        inspector = new NodeInspector((0, node_path_1.join)(__dirname, '..', 'main.js'), [
+            (data.instance || 0).toString(),
+            '--debug',
+            '--debugScript',
+            scriptToDebug,
+        ]);
     }
+    else {
+        const [adapter, instance] = (data.adapterInstance || '').split('.');
+        const file = resolveAdapterMainFile(adapter);
+        if (!file) {
+            reportError(`Cannot locate iobroker.${adapter}`);
+            setTimeout(() => {
+                sendToHost({ cmd: 'finished', context: `Cannot locate iobroker.${adapter}` });
+                setTimeout(() => process.exit(0), 500);
+            }, 200);
+            return;
+        }
+        instanceToDebug = file;
+        inspector = new NodeInspector(file, [instance || '0', '--debug']);
+    }
+    inspector.start().catch((e) => {
+        reportError(e instanceof StartupError
+            ? e.message
+            : `Internal error in inspector: ${e instanceof Error ? e.stack : errorToString(e)}`);
+        inspector?.killChild();
+        setTimeout(() => process.exit(1), 200);
+    });
 }
-function sendToHost(data) {
-    if (data.cmd === 'error') {
-        console.error(data.text);
-        if (data.expr) {
-            console.error(`[EXPRESSION] ${JSON.stringify(data.expr)}`);
+async function processCommand(data) {
+    debuglog(`processCommand: ${JSON.stringify(data)}`);
+    if (data.cmd === 'start') {
+        startDebugging(data);
+        return;
+    }
+    if (data.cmd === 'end') {
+        process.exit(0);
+    }
+    if (!inspector) {
+        reportError(`Cannot process "${data.cmd}": the debugger is not started`);
+        return;
+    }
+    const { Debugger, Runtime } = inspector;
+    switch (data.cmd) {
+        case 'source':
+            try {
+                const { scriptSource } = (await Debugger.getScriptSource({
+                    scriptId: data.scriptId,
+                }));
+                sendToHost({ cmd: 'script', scriptId: data.scriptId, text: scriptSource });
+            }
+            catch (e) {
+                reportError(`Cannot read the source of script ${data.scriptId}`, e);
+            }
+            break;
+        case 'cont':
+        case 'next':
+        case 'step':
+        case 'out':
+        case 'pause': {
+            const method = { cont: 'resume', next: 'stepOver', step: 'stepInto', out: 'stepOut', pause: 'pause' }[data.cmd];
+            try {
+                await Debugger[method]();
+            }
+            catch (e) {
+                reportError(`Cannot execute "${data.cmd}"`, e);
+            }
+            break;
         }
-        if (data.bp) {
-            console.error(`[BP] ${JSON.stringify(data.bp)}`);
+        case 'sb': {
+            const breakpoints = await Promise.all((data.breakpoints || []).map(async (bp) => {
+                try {
+                    const result = (await Debugger.setBreakpoint({
+                        location: {
+                            scriptId: bp.scriptId,
+                            lineNumber: bp.lineNumber,
+                            columnNumber: bp.columnNumber,
+                        },
+                    }));
+                    return { id: result.breakpointId, location: result.actualLocation };
+                }
+                catch (e) {
+                    reportError(`Cannot set breakpoint on line ${bp.lineNumber + 1}`, e);
+                    return null;
+                }
+            }));
+            sendToHost({ cmd: 'sb', breakpoints: breakpoints.filter(bp => bp) });
+            break;
         }
-    }
-    if (process.send) {
-        process.send(JSON.stringify(data));
+        case 'cb': {
+            const breakpointIds = await Promise.all((data.breakpoints || []).map(async (breakpointId) => {
+                try {
+                    await Debugger.removeBreakpoint({ breakpointId });
+                }
+                catch (e) {
+                    // The breakpoint does not exist (anymore), so it is removed anyway
+                    debuglog(`Cannot clear breakpoint ${breakpointId}: ${e}`);
+                }
+                return breakpointId;
+            }));
+            sendToHost({ cmd: 'cb', breakpoints: breakpointIds });
+            break;
+        }
+        case 'scope': {
+            const scopes = await Promise.all((data.scopes || [])
+                .filter(scope => scope?.object?.objectId)
+                .map(async (scope) => {
+                try {
+                    const properties = (await Runtime.getProperties({
+                        objectId: scope.object.objectId,
+                        generatePreview: true,
+                    }));
+                    return { type: scope.type, name: scope.name, index: scope.index, properties };
+                }
+                catch (e) {
+                    // e.g., the execution was resumed in the meantime
+                    debuglog(`Cannot read scope: ${e}`);
+                    return null;
+                }
+            }));
+            sendToHost({ cmd: 'scope', scopes: scopes.filter(scope => scope) });
+            break;
+        }
+        case 'setValue':
+            try {
+                await Debugger.setVariableValue({
+                    variableName: data.variableName,
+                    scopeNumber: data.scopeNumber,
+                    newValue: toCallArgument(data.newValue?.value),
+                    callFrameId: data.callFrameId,
+                });
+                sendToHost({
+                    cmd: 'setValue',
+                    variableName: data.variableName,
+                    scopeNumber: data.scopeNumber,
+                    newValue: data.newValue,
+                    callFrameId: data.callFrameId,
+                });
+            }
+            catch (e) {
+                reportError(`Cannot set value of "${data.variableName}"`, e);
+            }
+            break;
+        case 'expressions': {
+            const expressions = await Promise.all((data.expressions || []).map(async (item) => {
+                try {
+                    const { result } = (await Debugger.evaluateOnCallFrame({
+                        callFrameId: data.callFrameId,
+                        expression: item.name,
+                        objectGroup: 'node-inspect',
+                        generatePreview: true,
+                    }));
+                    return { name: item.name, result };
+                }
+                catch (e) {
+                    return {
+                        name: item.name,
+                        result: {
+                            type: 'object',
+                            subtype: 'error',
+                            className: 'Error',
+                            description: errorToString(e),
+                        },
+                    };
+                }
+            }));
+            sendToHost({ cmd: 'expressions', expressions });
+            break;
+        }
+        case 'stopOnException':
+            try {
+                await Debugger.setPauseOnExceptions({ state: data.state ? 'all' : 'none' });
+            }
+            catch (e) {
+                reportError('Cannot change "stop on exception"', e);
+            }
+            break;
+        case 'getPossibleBreakpoints':
+            try {
+                const { locations } = (await Debugger.getPossibleBreakpoints({
+                    start: data.start,
+                    end: data.end,
+                }));
+                sendToHost({ cmd: 'getPossibleBreakpoints', breakpoints: locations });
+            }
+            catch (e) {
+                reportError('Cannot get possible breakpoints', e);
+            }
+            break;
+        default:
+            console.error(`[DEBUGGER] Unknown command: ${JSON.stringify(data)}`);
+            break;
     }
 }
+process.on('message', (message) => {
+    let command;
+    try {
+        command = typeof message === 'string' ? JSON.parse(message) : message;
+    }
+    catch {
+        console.error(`[DEBUGGER] Cannot parse: ${JSON.stringify(message)}`);
+        return;
+    }
+    processCommand(command).catch(e => reportError(`Cannot process "${command?.cmd}"`, e));
+});
+// Handle all possible exits and never leave the debugged process behind
+process.on('exit', () => inspector?.killChild());
+process.on('disconnect', () => process.exit(0));
+process.once('SIGTERM', () => process.exit(0));
+process.once('SIGHUP', () => process.exit(0));
+process.on('uncaughtException', (e) => {
+    reportError(`Internal error in inspector: ${e.stack || e.message}`);
+    inspector?.killChild();
+    process.exit(1);
+});
+sendToHost({ cmd: 'ready' });
 //# sourceMappingURL=inspect.js.map