@baixfeng/godot-mcp-cli 1.0.11

package/dist/tools/enhanced_tools.js

@@ -0,0 +1,706 @@
+var __awaiter = (this && this.__awaiter) || function (thisArg, _arguments, P, generator) {
+    function adopt(value) { return value instanceof P ? value : new P(function (resolve) { resolve(value); }); }
+    return new (P || (P = Promise))(function (resolve, reject) {
+        function fulfilled(value) { try { step(generator.next(value)); } catch (e) { reject(e); } }
+        function rejected(value) { try { step(generator["throw"](value)); } catch (e) { reject(e); } }
+        function step(result) { result.done ? resolve(result.value) : adopt(result.value).then(fulfilled, rejected); }
+        step((generator = generator.apply(thisArg, _arguments || [])).next());
+    });
+};
+var __generator = (this && this.__generator) || function (thisArg, body) {
+    var _ = { label: 0, sent: function() { if (t[0] & 1) throw t[1]; return t[1]; }, trys: [], ops: [] }, f, y, t, g = Object.create((typeof Iterator === "function" ? Iterator : Object).prototype);
+    return g.next = verb(0), g["throw"] = verb(1), g["return"] = verb(2), typeof Symbol === "function" && (g[Symbol.iterator] = function() { return this; }), g;
+    function verb(n) { return function (v) { return step([n, v]); }; }
+    function step(op) {
+        if (f) throw new TypeError("Generator is already executing.");
+        while (g && (g = 0, op[0] && (_ = 0)), _) try {
+            if (f = 1, y && (t = op[0] & 2 ? y["return"] : op[0] ? y["throw"] || ((t = y["return"]) && t.call(y), 0) : y.next) && !(t = t.call(y, op[1])).done) return t;
+            if (y = 0, t) op = [op[0] & 2, t.value];
+            switch (op[0]) {
+                case 0: case 1: t = op; break;
+                case 4: _.label++; return { value: op[1], done: false };
+                case 5: _.label++; y = op[1]; op = [0]; continue;
+                case 7: op = _.ops.pop(); _.trys.pop(); continue;
+                default:
+                    if (!(t = _.trys, t = t.length > 0 && t[t.length - 1]) && (op[0] === 6 || op[0] === 2)) { _ = 0; continue; }
+                    if (op[0] === 3 && (!t || (op[1] > t[0] && op[1] < t[3]))) { _.label = op[1]; break; }
+                    if (op[0] === 6 && _.label < t[1]) { _.label = t[1]; t = op; break; }
+                    if (t && _.label < t[2]) { _.label = t[2]; _.ops.push(op); break; }
+                    if (t[2]) _.ops.pop();
+                    _.trys.pop(); continue;
+            }
+            op = body.call(thisArg, _);
+        } catch (e) { op = [6, e]; y = 0; } finally { f = t = 0; }
+        if (op[0] & 5) throw op[1]; return { value: op[0] ? op[1] : void 0, done: true };
+    }
+};
+// File: /server/src/tools/enhanced_tools.ts
+import { z } from 'zod';
+import { getGodotConnection } from '../utils/godot_connection.js';
+/**
+ * Enhanced tools for more complex operations in Godot
+ */
+// Constants
+var MAX_FRAMES_DISPLAY = 10;
+var DEFAULT_INDENT_SIZE = 2;
+// Utility Functions
+function formatNode(node, depth, includeVisibility) {
+    if (depth === void 0) { depth = 0; }
+    if (includeVisibility === void 0) { includeVisibility = false; }
+    var indent = ' '.repeat(depth * DEFAULT_INDENT_SIZE);
+    var output = "".concat(indent).concat(node.name, " (").concat(node.type, ")");
+    if (includeVisibility && node.visibility) {
+        var flags = [];
+        if (node.visibility.has_visible_method)
+            flags.push('has-visible');
+        if (node.visibility.visible)
+            flags.push('visible');
+        if (node.visibility.visible_in_tree)
+            flags.push('visible-in-tree');
+        if (flags.length > 0) {
+            output += " [".concat(flags.join(', '), "]");
+        }
+    }
+    if (node.children && node.children.length > 0) {
+        output += '\n';
+        output += node.children
+            .map(function (child) { return formatNode(child, depth + 1, includeVisibility); })
+            .join('\n');
+    }
+    return output;
+}
+function summarizeStackFrame(frame) {
+    var indexValue = typeof frame.index === 'number'
+        ? frame.index
+        : (typeof frame.index === 'string' && frame.index.length > 0 ? Number(frame.index) : undefined);
+    var fnName = typeof frame.function === 'string' && frame.function.length > 0
+        ? frame.function
+        : '(anonymous)';
+    var location = typeof frame.location === 'string' && frame.location.length > 0
+        ? frame.location
+        : (function () {
+            var script = typeof frame.script === 'string' ? frame.script : '';
+            var line = typeof frame.line === 'number' ? frame.line : undefined;
+            if (script && line !== undefined) {
+                return "".concat(script, ":").concat(line);
+            }
+            return script || 'location unavailable';
+        })();
+    if (typeof indexValue === 'number' && Number.isFinite(indexValue)) {
+        return "[".concat(indexValue, "] ").concat(fnName, " \u2014 ").concat(location);
+    }
+    return "".concat(fnName, " \u2014 ").concat(location);
+}
+function formatValue(value) {
+    if (value === undefined) {
+        return 'undefined';
+    }
+    if (value === null) {
+        return 'null';
+    }
+    if (typeof value === 'string') {
+        return "\"".concat(value, "\"");
+    }
+    if (typeof value === 'number' || typeof value === 'boolean') {
+        return String(value);
+    }
+    try {
+        return JSON.stringify(value, null, 2);
+    }
+    catch (_a) {
+        return String(value);
+    }
+}
+function safeGetDiagnostics(result) {
+    if (typeof result.diagnostics === 'object' && result.diagnostics !== null) {
+        return result.diagnostics;
+    }
+    return {};
+}
+function safeGetStringArray(value) {
+    if (Array.isArray(value)) {
+        return value.map(function (item) { return String(item); });
+    }
+    return [];
+}
+function formatEmptyDebugOutput(diagnostics) {
+    var source = diagnostics.source || 'unknown';
+    var detail = diagnostics.detail || 'No additional detail from publisher.';
+    var controlClass = diagnostics.control_class || 'unset';
+    var controlPath = diagnostics.control_path || 'unset';
+    var logFilePath = diagnostics.log_file_path || 'not-found';
+    var controlSearch = diagnostics.control_search || 'control search summary unavailable';
+    return [
+        'No debug output available.',
+        "Capture source: ".concat(source),
+        "Detail: ".concat(detail),
+        "Control class: ".concat(controlClass),
+        "Control path: ".concat(controlPath),
+        "Log file path: ".concat(logFilePath),
+        "Control search: ".concat(controlSearch),
+    ].join('\n');
+}
+function formatPanelHeader(diagnostics, lineCount, frameCount, successMessage) {
+    var header = [];
+    if (diagnostics.error) {
+        header.push("".concat(successMessage, ": ").concat(diagnostics.error));
+    }
+    else {
+        header.push("".concat(successMessage, "."));
+    }
+    header.push("Lines captured: ".concat(lineCount));
+    header.push("Frames parsed: ".concat(frameCount));
+    if (diagnostics.control_path) {
+        header.push("Panel control: ".concat(diagnostics.control_path));
+    }
+    else if (diagnostics.control_class) {
+        header.push("Panel type: ".concat(diagnostics.control_class));
+    }
+    if (diagnostics.tab_title) {
+        header.push("Tab title: ".concat(diagnostics.tab_title));
+    }
+    if (diagnostics.fallback_source) {
+        header.push("Fallback source: ".concat(diagnostics.fallback_source));
+    }
+    if (typeof diagnostics.timestamp === 'number') {
+        header.push("Captured: ".concat(new Date(diagnostics.timestamp).toISOString()));
+    }
+    if (diagnostics.search_summary) {
+        header.push("Search summary: ".concat(diagnostics.search_summary));
+    }
+    return header;
+}
+function formatStackFrames(frames) {
+    if (frames.length === 0) {
+        return 'No structured frames were parsed.';
+    }
+    return frames
+        .slice(0, MAX_FRAMES_DISPLAY)
+        .map(function (frame, index) { return "#".concat(index, ": ").concat(summarizeStackFrame(frame)); })
+        .join('\n');
+}
+// Module state for debug output streaming
+var debugOutputListenerAttached = false;
+/**
+ * Enhanced tools for more complex operations in Godot
+ */
+export var enhancedTools = [
+    {
+        name: 'get_editor_scene_structure',
+        description: 'Get the current scene hierarchy with optional detail flags',
+        parameters: z.object({
+            include_properties: z.boolean().optional()
+                .describe('Include common editor properties (position, rotation, etc.)'),
+            include_scripts: z.boolean().optional()
+                .describe('Include attached script information'),
+            max_depth: z.number().int().min(0).optional()
+                .describe('Limit traversal depth (0 = only root)')
+        }),
+        execute: function (_a) { return __awaiter(void 0, [_a], void 0, function (_b) {
+            var godot, params, result, structure, err_1;
+            var include_properties = _b.include_properties, include_scripts = _b.include_scripts, max_depth = _b.max_depth;
+            return __generator(this, function (_c) {
+                switch (_c.label) {
+                    case 0:
+                        godot = getGodotConnection();
+                        _c.label = 1;
+                    case 1:
+                        _c.trys.push([1, 3, , 4]);
+                        params = {};
+                        if (include_properties !== undefined)
+                            params.include_properties = include_properties;
+                        if (include_scripts !== undefined)
+                            params.include_scripts = include_scripts;
+                        if (max_depth !== undefined)
+                            params.max_depth = max_depth;
+                        return [4 /*yield*/, godot.sendCommand('get_editor_scene_structure', params)];
+                    case 2:
+                        result = _c.sent();
+                        if (result.error) {
+                            return [2 /*return*/, "Scene structure unavailable: ".concat(result.error)];
+                        }
+                        if (!result.structure || Object.keys(result.structure).length === 0) {
+                            return [2 /*return*/, 'No scene is currently open or the scene is empty.'];
+                        }
+                        structure = result.structure;
+                        return [2 /*return*/, [
+                                "Current Scene: ".concat(result.path),
+                                "Root Node: ".concat(result.root_node_name, " (").concat(result.root_node_type, ")"),
+                                '',
+                                'Scene Tree:',
+                                formatNode(structure)
+                            ].join('\n')];
+                    case 3:
+                        err_1 = _c.sent();
+                        throw new Error("Failed to get scene structure: ".concat(err_1.message));
+                    case 4: return [2 /*return*/];
+                }
+            });
+        }); },
+    },
+    {
+        name: 'get_runtime_scene_structure',
+        description: 'Inspect the live scene tree from the running game via the debugger',
+        parameters: z.object({
+            include_properties: z.boolean().optional()
+                .describe('Include common properties (position, rotation, etc.) when available'),
+            include_scripts: z.boolean().optional()
+                .describe('Include script information when available'),
+            max_depth: z.number().int().min(0).optional()
+                .describe('Limit traversal depth (0 = only root)'),
+            timeout_ms: z.number().int().min(100).max(5000).optional()
+                .describe('How long to wait for a live scene snapshot (milliseconds)')
+        }),
+        execute: function (_a) { return __awaiter(void 0, [_a], void 0, function (_b) {
+            var godot, params, result, structure, scenePath, rootName, rootType, err_2;
+            var include_properties = _b.include_properties, include_scripts = _b.include_scripts, max_depth = _b.max_depth, timeout_ms = _b.timeout_ms;
+            return __generator(this, function (_c) {
+                switch (_c.label) {
+                    case 0:
+                        godot = getGodotConnection();
+                        _c.label = 1;
+                    case 1:
+                        _c.trys.push([1, 3, , 4]);
+                        params = {};
+                        if (include_properties !== undefined)
+                            params.include_properties = include_properties;
+                        if (include_scripts !== undefined)
+                            params.include_scripts = include_scripts;
+                        if (max_depth !== undefined)
+                            params.max_depth = max_depth;
+                        if (timeout_ms !== undefined)
+                            params.timeout_ms = timeout_ms;
+                        return [4 /*yield*/, godot.sendCommand('get_runtime_scene_structure', params)];
+                    case 2:
+                        result = _c.sent();
+                        if (result.error) {
+                            return [2 /*return*/, "Runtime scene structure unavailable: ".concat(result.error)];
+                        }
+                        if (!result.structure) {
+                            return [2 /*return*/, 'Runtime scene data is unavailable. Ensure the project is running with the debugger attached.'];
+                        }
+                        structure = result.structure;
+                        scenePath = result.scene_path || 'Unknown scene';
+                        rootName = result.root_node_name || structure.name || 'Root';
+                        rootType = result.root_node_type || structure.type || 'Node';
+                        return [2 /*return*/, [
+                                "Runtime Scene Path: ".concat(scenePath),
+                                "Root Node: ".concat(rootName, " (").concat(rootType, ")"),
+                                '',
+                                'Live Scene Tree:',
+                                formatNode(structure, 0, true)
+                            ].join('\n')];
+                    case 3:
+                        err_2 = _c.sent();
+                        throw new Error("Failed to get runtime scene structure: ".concat(err_2.message));
+                    case 4: return [2 /*return*/];
+                }
+            });
+        }); },
+    },
+    {
+        name: 'get_debug_output',
+        description: 'Get the debug output from the Godot editor',
+        parameters: z.object({}),
+        execute: function () { return __awaiter(void 0, void 0, void 0, function () {
+            var godot, result, outputText, diagnostics, err_3;
+            return __generator(this, function (_a) {
+                switch (_a.label) {
+                    case 0:
+                        godot = getGodotConnection();
+                        _a.label = 1;
+                    case 1:
+                        _a.trys.push([1, 3, , 4]);
+                        return [4 /*yield*/, godot.sendCommand('get_debug_output', {})];
+                    case 2:
+                        result = _a.sent();
+                        outputText = typeof result.output === 'string' ? result.output : '';
+                        diagnostics = safeGetDiagnostics(result);
+                        if (!outputText || outputText.length === 0) {
+                            return [2 /*return*/, formatEmptyDebugOutput(diagnostics)];
+                        }
+                        return [2 /*return*/, "Debug Output:\n".concat(outputText)];
+                    case 3:
+                        err_3 = _a.sent();
+                        throw new Error("Failed to get debug output: ".concat(err_3.message));
+                    case 4: return [2 /*return*/];
+                }
+            });
+        }); },
+    },
+    {
+        name: 'get_editor_errors',
+        description: 'Read the Errors tab from the Godot editor bottom panel.',
+        parameters: z.object({}),
+        execute: function () { return __awaiter(void 0, void 0, void 0, function () {
+            var godot, result, text, lines, lineCount, diagnostics, detailLines, headerSections, body, err_4;
+            return __generator(this, function (_a) {
+                switch (_a.label) {
+                    case 0:
+                        godot = getGodotConnection();
+                        _a.label = 1;
+                    case 1:
+                        _a.trys.push([1, 3, , 4]);
+                        return [4 /*yield*/, godot.sendCommand('get_editor_errors', {})];
+                    case 2:
+                        result = _a.sent();
+                        text = typeof (result === null || result === void 0 ? void 0 : result.text) === 'string' ? result.text : '';
+                        lines = safeGetStringArray(result === null || result === void 0 ? void 0 : result.lines);
+                        lineCount = typeof (result === null || result === void 0 ? void 0 : result.line_count) === 'number'
+                            ? result.line_count
+                            : (lines.length > 0 ? lines.length : (text.length > 0 ? text.split('\n').length : 0));
+                        diagnostics = safeGetDiagnostics(result);
+                        detailLines = [];
+                        if (diagnostics.control_path) {
+                            detailLines.push("Control path: ".concat(diagnostics.control_path));
+                        }
+                        else if (diagnostics.control_class) {
+                            detailLines.push("Control class: ".concat(diagnostics.control_class));
+                        }
+                        if (typeof diagnostics.timestamp === 'number') {
+                            detailLines.push("Captured: ".concat(new Date(diagnostics.timestamp).toISOString()));
+                        }
+                        if (diagnostics.search_summary) {
+                            detailLines.push("Search summary: ".concat(diagnostics.search_summary));
+                        }
+                        if (text.length === 0) {
+                            return [2 /*return*/, detailLines.length > 0
+                                    ? "Errors tab is empty.\n".concat(detailLines.join('\n'))
+                                    : 'Errors tab is empty.'];
+                        }
+                        headerSections = ['Errors Tab Contents', "Lines: ".concat(lineCount)];
+                        if (detailLines.length > 0) {
+                            headerSections.push(detailLines.join(' | '));
+                        }
+                        body = lines.length > 0 ? lines.join('\n') : text;
+                        return [2 /*return*/, "".concat(headerSections.join('\n'), "\n\n").concat(body)];
+                    case 3:
+                        err_4 = _a.sent();
+                        throw new Error("Failed to read Errors tab: ".concat(err_4.message));
+                    case 4: return [2 /*return*/];
+                }
+            });
+        }); },
+    },
+    {
+        name: 'get_stack_trace_panel',
+        description: 'Capture the Godot debugger Stack Trace panel text and structured frames.',
+        parameters: z.object({
+            session_id: z.number().int().optional()
+                .describe('Optional debugger session ID to associate with the capture (defaults to the active session).')
+        }),
+        execute: function (_a) { return __awaiter(void 0, [_a], void 0, function (_b) {
+            var godot, params, result, panel, diagnostics, lines, frames_1, lineCount, resolvedSessionId, header, frameSection, body, err_5;
+            var _c;
+            var session_id = _b.session_id;
+            return __generator(this, function (_d) {
+                switch (_d.label) {
+                    case 0:
+                        godot = getGodotConnection();
+                        params = {};
+                        if (session_id !== undefined) {
+                            params.session_id = session_id;
+                        }
+                        _d.label = 1;
+                    case 1:
+                        _d.trys.push([1, 3, , 4]);
+                        return [4 /*yield*/, godot.sendCommand('get_stack_trace_panel', params)];
+                    case 2:
+                        result = _d.sent();
+                        panel = ((_c = result === null || result === void 0 ? void 0 : result.stack_trace_panel) !== null && _c !== void 0 ? _c : {});
+                        diagnostics = safeGetDiagnostics(panel);
+                        lines = safeGetStringArray(panel.lines);
+                        frames_1 = Array.isArray(panel.frames) ? panel.frames : [];
+                        lineCount = typeof panel.line_count === 'number' ? panel.line_count : lines.length;
+                        resolvedSessionId = typeof (result === null || result === void 0 ? void 0 : result.session_id) === 'number' ? result.session_id : undefined;
+                        header = formatPanelHeader(diagnostics, lineCount, frames_1.length, 'Stack trace panel captured successfully');
+                        if (resolvedSessionId !== undefined && resolvedSessionId >= 0) {
+                            header.push("Session ID: ".concat(resolvedSessionId));
+                        }
+                        frameSection = formatStackFrames(frames_1);
+                        body = lines.length > 0
+                            ? lines.join('\n')
+                            : (typeof panel.text === 'string' && panel.text.length > 0
+                                ? panel.text
+                                : 'Stack Trace tab is empty.');
+                        return [2 /*return*/, [
+                                header.join('\n'),
+                                '',
+                                'Parsed Frames:',
+                                frameSection,
+                                '',
+                                'Stack Trace Panel:',
+                                body
+                            ].join('\n')];
+                    case 3:
+                        err_5 = _d.sent();
+                        throw new Error("Failed to capture stack trace panel: ".concat(err_5.message));
+                    case 4: return [2 /*return*/];
+                }
+            });
+        }); },
+    },
+    {
+        name: 'get_stack_frames_panel',
+        description: 'Capture the Stack Frames panel contents (tree or text fallback) from the Godot editor.',
+        parameters: z.object({
+            session_id: z.number().int().optional()
+                .describe('Optional debugger session ID (defaults to the active session).'),
+            refresh: z.boolean().optional()
+                .describe('Request a fresh stack dump from the debugger before capturing.')
+        }),
+        execute: function (_a) { return __awaiter(void 0, [_a], void 0, function (_b) {
+            var godot, params, result, panel, diagnostics, lines, frames_2, lineCount, header, frameSection, body, err_6;
+            var _c;
+            var session_id = _b.session_id, refresh = _b.refresh;
+            return __generator(this, function (_d) {
+                switch (_d.label) {
+                    case 0:
+                        godot = getGodotConnection();
+                        params = {};
+                        if (session_id !== undefined)
+                            params.session_id = session_id;
+                        if (refresh !== undefined)
+                            params.refresh = refresh;
+                        _d.label = 1;
+                    case 1:
+                        _d.trys.push([1, 3, , 4]);
+                        return [4 /*yield*/, godot.sendCommand('get_stack_frames_panel', params)];
+                    case 2:
+                        result = _d.sent();
+                        panel = ((_c = result === null || result === void 0 ? void 0 : result.stack_frames_panel) !== null && _c !== void 0 ? _c : {});
+                        diagnostics = safeGetDiagnostics(panel);
+                        lines = safeGetStringArray(panel.lines);
+                        frames_2 = Array.isArray(panel.frames) ? panel.frames : [];
+                        lineCount = typeof panel.line_count === 'number' ? panel.line_count : lines.length;
+                        header = formatPanelHeader(diagnostics, lineCount, frames_2.length, 'Stack Frames panel captured successfully');
+                        frameSection = formatStackFrames(frames_2);
+                        body = lines.length > 0
+                            ? lines.join('\n')
+                            : (typeof panel.text === 'string' && panel.text.length > 0
+                                ? panel.text
+                                : 'Stack Frames tab is empty.');
+                        return [2 /*return*/, [
+                                header.join('\n'),
+                                '',
+                                'Parsed Frames:',
+                                frameSection,
+                                '',
+                                'Stack Frames Panel:',
+                                body
+                            ].join('\n')];
+                    case 3:
+                        err_6 = _d.sent();
+                        throw new Error("Failed to capture stack frames panel: ".concat(err_6.message));
+                    case 4: return [2 /*return*/];
+                }
+            });
+        }); },
+    },
+    {
+        name: 'evaluate_runtime_expression',
+        description: 'Evaluate a GDScript expression inside the running game via the remote debugger',
+        parameters: z.object({
+            expression: z.string().min(1)
+                .describe('Expression to evaluate in the runtime context (executed with the chosen node as self).'),
+            context_path: z.string().optional()
+                .describe('Optional node path (e.g. "/root/Main/Player") to use as the evaluation context.'),
+            capture_prints: z.boolean().optional()
+                .describe('Include print output from the expression (default true).'),
+            timeout_ms: z.number().int().min(100).max(5000).optional()
+                .describe('How long to wait for the evaluation result in milliseconds.')
+        }),
+        execute: function (_a) { return __awaiter(void 0, [_a], void 0, function (_b) {
+            var godot, params, result, success, formattedValue, outputLines, sections, err_7;
+            var expression = _b.expression, context_path = _b.context_path, capture_prints = _b.capture_prints, timeout_ms = _b.timeout_ms;
+            return __generator(this, function (_c) {
+                switch (_c.label) {
+                    case 0:
+                        godot = getGodotConnection();
+                        params = { expression: expression };
+                        if (context_path !== undefined)
+                            params.context_path = context_path;
+                        if (capture_prints !== undefined)
+                            params.capture_prints = capture_prints;
+                        if (timeout_ms !== undefined)
+                            params.timeout_ms = timeout_ms;
+                        _c.label = 1;
+                    case 1:
+                        _c.trys.push([1, 3, , 4]);
+                        return [4 /*yield*/, godot.sendCommand('evaluate_runtime', params)];
+                    case 2:
+                        result = _c.sent();
+                        if (!result) {
+                            return [2 /*return*/, 'Runtime evaluation did not return a result.'];
+                        }
+                        if (result.error) {
+                            return [2 /*return*/, "Runtime evaluation failed: ".concat(result.error)];
+                        }
+                        success = result.success !== false;
+                        formattedValue = formatValue(result.result);
+                        outputLines = safeGetStringArray(result.output);
+                        sections = [];
+                        sections.push(success ? 'Runtime evaluation succeeded.' : 'Runtime evaluation completed with errors.');
+                        sections.push("Result: ".concat(formattedValue));
+                        if (outputLines.length > 0) {
+                            sections.push('Print Output:');
+                            sections.push(outputLines.join('\n'));
+                        }
+                        if (result.error && result.error.length > 0 && success) {
+                            sections.push("Notes: ".concat(result.error));
+                        }
+                        return [2 /*return*/, sections.join('\n')];
+                    case 3:
+                        err_7 = _c.sent();
+                        throw new Error("Failed to evaluate expression: ".concat(err_7.message));
+                    case 4: return [2 /*return*/];
+                }
+            });
+        }); },
+    },
+    {
+        name: 'clear_debug_output',
+        description: 'Clear the Godot editor Output panel and reset streaming state.',
+        parameters: z.object({}),
+        execute: function () { return __awaiter(void 0, void 0, void 0, function () {
+            var godot, result, diagnostics, reason, method, attempts, timestamp, err_8;
+            return __generator(this, function (_a) {
+                switch (_a.label) {
+                    case 0:
+                        godot = getGodotConnection();
+                        _a.label = 1;
+                    case 1:
+                        _a.trys.push([1, 3, , 4]);
+                        return [4 /*yield*/, godot.sendCommand('clear_debug_output', {})];
+                    case 2:
+                        result = _a.sent();
+                        diagnostics = safeGetDiagnostics(result);
+                        if (!(result === null || result === void 0 ? void 0 : result.cleared)) {
+                            reason = typeof (result === null || result === void 0 ? void 0 : result.message) === 'string' && result.message.length > 0
+                                ? result.message
+                                : (diagnostics.error || 'Unknown reason');
+                            return [2 /*return*/, "Failed to clear debug output: ".concat(reason)];
+                        }
+                        method = typeof result.method === 'string' && result.method.length > 0
+                            ? result.method
+                            : 'unspecified method';
+                        attempts = Array.isArray(diagnostics.attempts)
+                            ? diagnostics.attempts.map(function (entry) { return String(entry); }).join(', ')
+                            : 'n/a';
+                        timestamp = typeof diagnostics.timestamp === 'number'
+                            ? new Date(diagnostics.timestamp).toISOString()
+                            : 'n/a';
+                        return [2 /*return*/, [
+                                'Debug Output panel cleared successfully.',
+                                "Method: ".concat(method),
+                                "Attempts: ".concat(attempts),
+                                "Timestamp: ".concat(timestamp)
+                            ].join('\n')];
+                    case 3:
+                        err_8 = _a.sent();
+                        throw new Error("Failed to clear debug output: ".concat(err_8.message));
+                    case 4: return [2 /*return*/];
+                }
+            });
+        }); },
+    },
+    {
+        name: 'stream_debug_output',
+        description: 'Subscribe or unsubscribe from live streaming of the editor Output panel.',
+        parameters: z.object({
+            action: z.enum(['start', 'stop']).default('start')
+                .describe('Choose "start" to begin streaming or "stop" to unsubscribe.')
+        }),
+        execute: function (_a) { return __awaiter(void 0, [_a], void 0, function (_b) {
+            var godot;
+            var action = _b.action;
+            return __generator(this, function (_c) {
+                switch (_c.label) {
+                    case 0:
+                        godot = getGodotConnection();
+                        if (!debugOutputListenerAttached) {
+                            debugOutputListenerAttached = true;
+                            godot.on('debug_output_frame', function (frame) {
+                                try {
+                                    var frameData = frame;
+                                    var lines = safeGetStringArray(frameData.lines);
+                                    var chunk = typeof frameData.chunk === 'string' ? frameData.chunk : '';
+                                    if (frameData.reset) {
+                                        console.log('\n[Godot Debug] Log reset.');
+                                    }
+                                    if (lines.length > 0) {
+                                        for (var _i = 0, lines_1 = lines; _i < lines_1.length; _i++) {
+                                            var line = lines_1[_i];
+                                            console.log("[Godot Debug] ".concat(line));
+                                        }
+                                    }
+                                    else if (chunk.length > 0) {
+                                        console.log("[Godot Debug] ".concat(chunk));
+                                    }
+                                }
+                                catch (err) {
+                                    console.error('Failed to print debug frame:', err);
+                                }
+                            });
+                        }
+                        if (!(action === 'start')) return [3 /*break*/, 2];
+                        return [4 /*yield*/, godot.sendCommand('subscribe_debug_output', {})];
+                    case 1:
+                        _c.sent();
+                        return [2 /*return*/, 'Subscribed to live debug output. New log lines will appear in the console.'];
+                    case 2: return [4 /*yield*/, godot.sendCommand('unsubscribe_debug_output', {})];
+                    case 3:
+                        _c.sent();
+                        return [2 /*return*/, 'Unsubscribed from live debug output.'];
+                }
+            });
+        }); },
+    },
+    {
+        name: 'clear_editor_errors',
+        description: 'Clear the Errors tab in the Godot editor debugger panel.',
+        parameters: z.object({}),
+        execute: function () { return __awaiter(void 0, void 0, void 0, function () {
+            var godot, result, diagnostics, reason, method, attempts, timestamp, err_9;
+            return __generator(this, function (_a) {
+                switch (_a.label) {
+                    case 0:
+                        godot = getGodotConnection();
+                        _a.label = 1;
+                    case 1:
+                        _a.trys.push([1, 3, , 4]);
+                        return [4 /*yield*/, godot.sendCommand('clear_editor_errors', {})];
+                    case 2:
+                        result = _a.sent();
+                        diagnostics = safeGetDiagnostics(result);
+                        if (!(result === null || result === void 0 ? void 0 : result.cleared)) {
+                            reason = typeof (result === null || result === void 0 ? void 0 : result.message) === 'string' && result.message.length > 0
+                                ? result.message
+                                : (diagnostics.error || 'Unknown reason');
+                            return [2 /*return*/, "Failed to clear Errors tab: ".concat(reason)];
+                        }
+                        method = typeof result.method === 'string' && result.method.length > 0
+                            ? result.method
+                            : 'unspecified method';
+                        attempts = Array.isArray(diagnostics.attempts)
+                            ? diagnostics.attempts.map(function (entry) { return String(entry); }).join(', ')
+                            : 'n/a';
+                        timestamp = typeof diagnostics.timestamp === 'number'
+                            ? new Date(diagnostics.timestamp).toISOString()
+                            : 'n/a';
+                        return [2 /*return*/, [
+                                'Errors tab cleared successfully.',
+                                "Method: ".concat(method),
+                                "Attempts: ".concat(attempts),
+                                "Timestamp: ".concat(timestamp)
+                            ].join('\n')];
+                    case 3:
+                        err_9 = _a.sent();
+                        throw new Error("Failed to clear Errors tab: ".concat(err_9.message));
+                    case 4: return [2 /*return*/];
+                }
+            });
+        }); },
+    },
+];
+//# sourceMappingURL=enhanced_tools.js.map