godot-mcp-runtime 2.3.0 → 3.1.0

package/dist/tools/node-tools.js

@@ -1,11 +1,12 @@
 import { existsSync } from 'fs';
 import { join } from 'path';
-import { normalizeParameters, convertCamelToSnakeCase, validatePath, createErrorResponse, extractGdError, validateSceneArgs, } from '../utils/godot-runner.js';
+import { normalizeParameters, validateSubPath, validateNodePath, createErrorResponse, validateSceneArgs, } from '../utils/godot-runner.js';
+import { executeSceneOp } from '../utils/handler-helpers.js';
 // --- Tool definitions ---
 export const nodeToolDefinitions = [
     {
-        name: 'delete_node',
-        description: 'Remove a node and all its children from a Godot scene file. Use when pruning the scene tree; for replacing a node in place, pair with add_node. Saves automatically. Cannot delete the scene root. Errors if nodePath does not exist. Returns { success, nodePath }.',
+        name: 'delete_nodes',
+        description: 'Remove one or more nodes (and their descendants) from a scene file. Always-array: pass a single-element nodePaths array for one-off deletes. Saves once at the end. Cannot delete the scene root — that entry returns an error and the rest still process. Returns: results array with one entry per nodePath in input order (success or error message).',
         annotations: { destructiveHint: true },
         inputSchema: {
             type: 'object',
@@ -15,36 +16,34 @@ export const nodeToolDefinitions = [
                     type: 'string',
                     description: 'Scene file path relative to the project (e.g. "scenes/main.tscn")',
                 },
-                nodePath: {
-                    type: 'string',
-                    description: 'Node path from scene root (e.g. "root/Player/Sprite2D")',
+                nodePaths: {
+                    type: 'array',
+                    items: { type: 'string' },
+                    description: 'Node paths from scene root to delete (e.g. ["root/Player/Sprite2D"])',
                 },
             },
-            required: ['projectPath', 'scenePath', 'nodePath'],
+            required: ['projectPath', 'scenePath', 'nodePaths'],
         },
-    },
-    {
-        name: 'set_node_property',
-        description: 'Set a single property on a node in a Godot scene file. For multiple properties on the same or different nodes, use batch_set_node_properties — one Godot process instead of N. Saves automatically. Primitives pass through; Vector2 ({x,y}), Vector3 ({x,y,z}), and Color ({r,g,b,a}) auto-convert. For other complex GDScript types (Resource, NodePath, etc.), use run_script. Errors if nodePath or property does not exist. Returns { success, nodePath, property }.',
-        annotations: { idempotentHint: true },
-        inputSchema: {
+        outputSchema: {
             type: 'object',
             properties: {
-                projectPath: { type: 'string', description: 'Path to the Godot project directory' },
-                scenePath: { type: 'string', description: 'Scene file path relative to the project' },
-                nodePath: { type: 'string', description: 'Node path from scene root (e.g. "root/Player")' },
-                property: {
-                    type: 'string',
-                    description: 'GDScript property name in snake_case (e.g. "position", "modulate", "collision_layer"). Use get_node_properties to discover valid names.',
+                results: {
+                    type: 'array',
+                    items: {
+                        type: 'object',
+                        properties: {
+                            nodePath: { type: 'string' },
+                            success: { type: 'boolean' },
+                            error: { type: 'string' },
+                        },
+                    },
                 },
-                value: { description: 'New property value' },
             },
-            required: ['projectPath', 'scenePath', 'nodePath', 'property', 'value'],
         },
     },
     {
-        name: 'batch_set_node_properties',
-        description: 'Set multiple node properties in a single Godot process — preferred over chained set_node_property calls (avoids ~3s startup per call). Same value-conversion rules as set_node_property. abortOnError stops on first failure (default false continues). Saves once at the end. Returns { results: [{ nodePath, property, success?, error? }] }.',
+        name: 'set_node_properties',
+        description: 'Set one or more node properties on a scene in a single Godot process. Always-array: pass a single-element updates array for one-off edits. Vector2 ({x,y}), Vector3 ({x,y,z}), and Color ({r,g,b,a}) auto-convert; primitives pass through. For other complex GDScript types (Resource, NodePath, etc.), use run_script. abortOnError stops on first failure (default false continues). Saves once at the end. Returns: results[] with one entry per update in input order (success or error).',
         annotations: { idempotentHint: true },
         inputSchema: {
             type: 'object',
@@ -57,8 +56,14 @@ export const nodeToolDefinitions = [
                     items: {
                         type: 'object',
                         properties: {
-                            nodePath: { type: 'string', description: 'Node path from scene root' },
-                            property: { type: 'string', description: 'GDScript property name in snake_case' },
+                            nodePath: {
+                                type: 'string',
+                                description: 'Node path from scene root (e.g. "root/Player")',
+                            },
+                            property: {
+                                type: 'string',
+                                description: 'GDScript property name in snake_case (e.g. "position", "modulate", "collision_layer")',
+                            },
                             value: { description: 'New property value' },
                         },
                         required: ['nodePath', 'property', 'value'],
@@ -71,28 +76,27 @@ export const nodeToolDefinitions = [
             },
             required: ['projectPath', 'scenePath', 'updates'],
         },
-    },
-    {
-        name: 'get_node_properties',
-        description: "Read a node's current property values from a scene file. For multiple nodes, use batch_get_node_properties (one process). changedOnly:true filters out properties matching their class defaults — useful for compact diffs. Errors if nodePath does not exist. Returns { nodePath, nodeType, properties: { [key]: value } }.",
-        annotations: { readOnlyHint: true },
-        inputSchema: {
+        outputSchema: {
             type: 'object',
             properties: {
-                projectPath: { type: 'string', description: 'Path to the Godot project directory' },
-                scenePath: { type: 'string', description: 'Scene file path relative to the project' },
-                nodePath: { type: 'string', description: 'Node path from scene root (e.g. "root/Player")' },
-                changedOnly: {
-                    type: 'boolean',
-                    description: 'Only return properties whose values differ from their class defaults (default: false)',
+                results: {
+                    type: 'array',
+                    items: {
+                        type: 'object',
+                        properties: {
+                            nodePath: { type: 'string' },
+                            property: { type: 'string' },
+                            success: { type: 'boolean' },
+                            error: { type: 'string' },
+                        },
+                    },
                 },
             },
-            required: ['projectPath', 'scenePath', 'nodePath'],
         },
     },
     {
-        name: 'batch_get_node_properties',
-        description: 'Get properties from multiple nodes in a single Godot process — preferred over chained get_node_properties calls. Per-node changedOnly toggles default-filtering individually. Returns { results: [{ nodePath, nodeType, properties?, error? }] }; failed reads include error and omit properties.',
+        name: 'get_node_properties',
+        description: "Read one or more nodes' current property values from a scene file in a single Godot process. Always-array: pass a single-element nodes array for one-off reads. Per-node changedOnly:true filters out properties matching class defaults (useful for compact diffs). Returns: { results: [{ nodePath, nodeType, properties?, error? }] }; failed reads include error and omit properties.",
         annotations: { readOnlyHint: true },
         inputSchema: {
             type: 'object',
@@ -105,7 +109,10 @@ export const nodeToolDefinitions = [
                     items: {
                         type: 'object',
                         properties: {
-                            nodePath: { type: 'string', description: 'Node path from scene root' },
+                            nodePath: {
+                                type: 'string',
+                                description: 'Node path from scene root (e.g. "root/Player")',
+                            },
                             changedOnly: {
                                 type: 'boolean',
                                 description: 'Only return properties differing from defaults (default: false)',
@@ -120,7 +127,7 @@ export const nodeToolDefinitions = [
     },
     {
         name: 'attach_script',
-        description: 'Attach an existing GDScript file to a node in a scene. Use after writing the script with the standard file tools and validating it via the validate tool. Replaces any previously attached script. Saves automatically. Errors if scriptPath does not exist or nodePath is not found. Returns { success, nodePath, scriptPath }.',
+        description: 'Attach an existing GDScript file to a node in a scene. Use after writing the script with the standard file tools and validating it via the validate tool. Replaces any previously attached script. Saves automatically. Returns: success with the resolved nodePath and scriptPath that were attached. Errors if scriptPath does not exist or nodePath is not found.',
         annotations: { idempotentHint: true },
         inputSchema: {
             type: 'object',
@@ -135,10 +142,18 @@ export const nodeToolDefinitions = [
             },
             required: ['projectPath', 'scenePath', 'nodePath', 'scriptPath'],
         },
+        outputSchema: {
+            type: 'object',
+            properties: {
+                success: { type: 'boolean' },
+                nodePath: { type: 'string' },
+                scriptPath: { type: 'string' },
+            },
+        },
     },
     {
         name: 'get_scene_tree',
-        description: 'Get the scene hierarchy as a nested tree of { name, type, path, children }. Use maxDepth:1 for a shallow listing of direct children only; default -1 returns the full tree. parentPath scopes the result to a subtree. Errors if scene does not exist or parentPath is not found.',
+        description: 'Get the scene hierarchy as a nested tree of { name, type, path, script, children }. Use maxDepth:1 for a shallow listing of direct children only; default -1 returns the full tree. parentPath scopes the result to a subtree. Returns the nested tree as JSON text. Errors if scene does not exist or parentPath is not found.',
         annotations: { readOnlyHint: true },
         inputSchema: {
             type: 'object',
@@ -159,7 +174,7 @@ export const nodeToolDefinitions = [
     },
     {
         name: 'duplicate_node',
-        description: 'Duplicate a node and its descendants in a Godot scene. Use to clone a configured subtree without re-creating it node-by-node via add_node. newName defaults to the original name + "2"; targetParentPath defaults to the original parent. Saves automatically. Errors if nodePath does not exist or targetParentPath cannot accept children. Returns { success, originalPath, newPath }.',
+        description: 'Duplicate a node and its descendants in a Godot scene. Use to clone a configured subtree without re-creating it node-by-node via add_node. newName defaults to the original name + "2"; targetParentPath defaults to the original parent. Saves automatically. Returns: success with originalPath and the newPath where the duplicate now lives — use newPath for follow-up edits. Errors if nodePath does not exist or targetParentPath cannot accept children.',
         inputSchema: {
             type: 'object',
             properties: {
@@ -177,10 +192,18 @@ export const nodeToolDefinitions = [
             },
             required: ['projectPath', 'scenePath', 'nodePath'],
         },
+        outputSchema: {
+            type: 'object',
+            properties: {
+                success: { type: 'boolean' },
+                originalPath: { type: 'string' },
+                newPath: { type: 'string' },
+            },
+        },
     },
     {
         name: 'get_node_signals',
-        description: 'List all signals defined on a node and their current connections. Use before connect_signal/disconnect_signal to verify signal/method names. Returns { nodePath, nodeType, signals: [{ name, connections: [{ signal, target, method }] }] }. The target field uses Godot absolute path format (/root/Scene/Node) — convert to scene-root-relative (root/Node) before passing to connect/disconnect_signal. Errors if node not found.',
+        description: 'List all signals defined on a node and their current connections. Use before connect_signal/disconnect_signal to verify signal/method names. The connections[].target field uses Godot absolute path format (/root/Scene/Node) — convert to scene-root-relative (root/Node) before passing to connect/disconnect_signal. Returns: nodeType and signals[], each with name and current connections (signal/target/method). Errors if node not found.',
         annotations: { readOnlyHint: true },
         inputSchema: {
             type: 'object',
@@ -191,10 +214,37 @@ export const nodeToolDefinitions = [
             },
             required: ['projectPath', 'scenePath', 'nodePath'],
         },
+        outputSchema: {
+            type: 'object',
+            properties: {
+                nodePath: { type: 'string' },
+                nodeType: { type: 'string' },
+                signals: {
+                    type: 'array',
+                    items: {
+                        type: 'object',
+                        properties: {
+                            name: { type: 'string' },
+                            connections: {
+                                type: 'array',
+                                items: {
+                                    type: 'object',
+                                    properties: {
+                                        signal: { type: 'string' },
+                                        target: { type: 'string' },
+                                        method: { type: 'string' },
+                                    },
+                                },
+                            },
+                        },
+                    },
+                },
+            },
+        },
     },
     {
         name: 'connect_signal',
-        description: 'Connect a signal from one node to a method on another node. Saves automatically. Errors if the signal does not exist on the source node or the method does not exist on the target node.',
+        description: 'Connect a signal on a source node to a method on a target node, persisting the connection in the .tscn. Use after get_node_signals to confirm the signal name on the source and the method name on the target. Connecting the same signal+method pair twice creates a duplicate connection — call get_node_signals first if uncertain. Saves automatically. Returns a plain-text confirmation naming the source, signal, target, and method. Errors if the signal does not exist on the source node or the method does not exist on the target node.',
         inputSchema: {
             type: 'object',
             properties: {
@@ -219,7 +269,8 @@ export const nodeToolDefinitions = [
     },
     {
         name: 'disconnect_signal',
-        description: 'Disconnect a signal connection between two nodes. Saves automatically. Errors if the connection does not exist — use get_node_signals first to verify.',
+        description: 'Remove an existing signal connection between two nodes, persisting the change in the .tscn. Use get_node_signals first to confirm the connection exists; recovery requires reconnecting via connect_signal. Saves automatically. Returns a plain-text confirmation naming the disconnected signal and target. Errors if the connection does not exist.',
+        annotations: { destructiveHint: true },
         inputSchema: {
             type: 'object',
             properties: {
@@ -235,71 +286,29 @@ export const nodeToolDefinitions = [
     },
 ];
 // --- Handlers ---
-export async function handleDeleteNode(runner, args) {
+export async function handleDeleteNodes(runner, args) {
     args = normalizeParameters(args);
     const v = validateSceneArgs(args);
     if ('isError' in v)
         return v;
-    if (!args.nodePath || !validatePath(args.nodePath)) {
-        return createErrorResponse('Valid nodePath is required', [
-            'Provide the node path (e.g. "root/Player")',
+    if (!args.nodePaths || !Array.isArray(args.nodePaths) || args.nodePaths.length === 0) {
+        return createErrorResponse('nodePaths array is required', [
+            'Provide a non-empty array of node paths (e.g. ["root/Player"])',
         ]);
     }
-    try {
-        const params = { scenePath: args.scenePath, nodePath: args.nodePath };
-        const { stdout, stderr } = await runner.executeOperation('delete_node', params, v.projectPath);
-        if (!stdout.trim()) {
-            return createErrorResponse(`Failed to delete node: ${extractGdError(stderr)}`, [
-                'Check if the node path is correct',
+    for (const p of args.nodePaths) {
+        if (typeof p !== 'string' || !validateNodePath(p)) {
+            return createErrorResponse('Invalid nodePath in nodePaths', [
+                'Provide a scene-tree path without ".." (e.g. "root/Player")',
             ]);
         }
-        return { content: [{ type: 'text', text: stdout }] };
-    }
-    catch (error) {
-        const errorMessage = error instanceof Error ? error.message : 'Unknown error';
-        return createErrorResponse(`Failed to delete node: ${errorMessage}`, [
-            'Ensure Godot is installed correctly',
-        ]);
     }
+    const params = { scenePath: args.scenePath, nodePaths: args.nodePaths };
+    return executeSceneOp(runner, 'delete_nodes', params, v.projectPath, 'Failed to delete nodes', [
+        'Check if the node paths are correct',
+    ]);
 }
-export async function handleSetNodeProperty(runner, args) {
-    args = normalizeParameters(args);
-    const v = validateSceneArgs(args);
-    if ('isError' in v)
-        return v;
-    if (!args.nodePath || !validatePath(args.nodePath)) {
-        return createErrorResponse('Valid nodePath is required', [
-            'Provide the node path (e.g. "root/Player")',
-        ]);
-    }
-    if (!args.property || args.value === undefined) {
-        return createErrorResponse('property and value are required', [
-            'Provide both property name and value',
-        ]);
-    }
-    try {
-        const params = {
-            scenePath: args.scenePath,
-            nodePath: args.nodePath,
-            property: args.property,
-            value: args.value,
-        };
-        const { stdout, stderr } = await runner.executeOperation('set_node_property', params, v.projectPath);
-        if (!stdout.trim()) {
-            return createErrorResponse(`Failed to update property: ${extractGdError(stderr)}`, [
-                'Check if the property name is valid for this node type',
-            ]);
-        }
-        return { content: [{ type: 'text', text: stdout }] };
-    }
-    catch (error) {
-        const errorMessage = error instanceof Error ? error.message : 'Unknown error';
-        return createErrorResponse(`Failed to set node property: ${errorMessage}`, [
-            'Ensure Godot is installed correctly',
-        ]);
-    }
-}
-export async function handleBatchSetNodeProperties(runner, args) {
+export async function handleSetNodeProperties(runner, args) {
     args = normalizeParameters(args);
     const v = validateSceneArgs(args);
     if ('isError' in v)
@@ -309,58 +318,14 @@ export async function handleBatchSetNodeProperties(runner, args) {
             'Provide an array of { nodePath, property, value }',
         ]);
     }
-    try {
-        const snakeUpdates = args.updates.map((u) => convertCamelToSnakeCase(u));
-        const params = {
-            scenePath: args.scenePath,
-            updates: snakeUpdates,
-            abortOnError: args.abortOnError ?? false,
-        };
-        const { stdout, stderr } = await runner.executeOperation('batch_set_node_properties', params, v.projectPath);
-        if (!stdout.trim()) {
-            return createErrorResponse(`Batch update failed: ${extractGdError(stderr)}`, [
-                'Check node paths and property names',
-            ]);
-        }
-        return { content: [{ type: 'text', text: stdout }] };
-    }
-    catch (error) {
-        const errorMessage = error instanceof Error ? error.message : 'Unknown error';
-        return createErrorResponse(`Batch set properties failed: ${errorMessage}`, [
-            'Ensure Godot is installed correctly',
-        ]);
-    }
+    const params = {
+        scenePath: args.scenePath,
+        updates: args.updates,
+        abortOnError: args.abortOnError ?? false,
+    };
+    return executeSceneOp(runner, 'set_node_properties', params, v.projectPath, 'Failed to set node properties', ['Check node paths and property names']);
 }
 export async function handleGetNodeProperties(runner, args) {
-    args = normalizeParameters(args);
-    const v = validateSceneArgs(args);
-    if ('isError' in v)
-        return v;
-    if (!args.nodePath || !validatePath(args.nodePath)) {
-        return createErrorResponse('Valid nodePath is required', [
-            'Provide the node path (e.g. "root/Player")',
-        ]);
-    }
-    try {
-        const params = { scenePath: args.scenePath, nodePath: args.nodePath };
-        if (args.changedOnly)
-            params.changedOnly = args.changedOnly;
-        const { stdout, stderr } = await runner.executeOperation('get_node_properties', params, v.projectPath);
-        if (!stdout.trim()) {
-            return createErrorResponse(`Failed to get properties: ${extractGdError(stderr)}`, [
-                'Check if the node path is correct',
-            ]);
-        }
-        return { content: [{ type: 'text', text: stdout }] };
-    }
-    catch (error) {
-        const errorMessage = error instanceof Error ? error.message : 'Unknown error';
-        return createErrorResponse(`Failed to get node properties: ${errorMessage}`, [
-            'Ensure Godot is installed correctly',
-        ]);
-    }
-}
-export async function handleBatchGetNodeProperties(runner, args) {
     args = normalizeParameters(args);
     const v = validateSceneArgs(args);
     if ('isError' in v)
@@ -370,37 +335,22 @@ export async function handleBatchGetNodeProperties(runner, args) {
             'Provide an array of { nodePath, changedOnly? }',
         ]);
     }
-    try {
-        const snakeNodes = args.nodes.map((n) => convertCamelToSnakeCase(n));
-        const params = { scenePath: args.scenePath, nodes: snakeNodes };
-        const { stdout, stderr } = await runner.executeOperation('batch_get_node_properties', params, v.projectPath);
-        if (!stdout.trim()) {
-            return createErrorResponse(`Batch get_properties failed: ${extractGdError(stderr)}`, [
-                'Check node paths',
-            ]);
-        }
-        return { content: [{ type: 'text', text: stdout }] };
-    }
-    catch (error) {
-        const errorMessage = error instanceof Error ? error.message : 'Unknown error';
-        return createErrorResponse(`Batch get properties failed: ${errorMessage}`, [
-            'Ensure Godot is installed correctly',
-        ]);
-    }
+    const params = { scenePath: args.scenePath, nodes: args.nodes };
+    return executeSceneOp(runner, 'get_node_properties', params, v.projectPath, 'Failed to get node properties', ['Check node paths']);
 }
 export async function handleAttachScript(runner, args) {
     args = normalizeParameters(args);
     const v = validateSceneArgs(args);
     if ('isError' in v)
         return v;
-    if (!args.nodePath || !validatePath(args.nodePath)) {
+    if (!args.nodePath || !validateNodePath(args.nodePath)) {
         return createErrorResponse('Valid nodePath is required', [
             'Provide the node path (e.g. "root/Player")',
         ]);
     }
-    if (!args.scriptPath || !validatePath(args.scriptPath)) {
+    if (!args.scriptPath || !validateSubPath(v.projectPath, args.scriptPath)) {
         return createErrorResponse('Valid scriptPath is required', [
-            'Provide the script path relative to the project',
+            'Provide a relative script path that stays inside the project directory',
         ]);
     }
     const scriptFullPath = join(v.projectPath, args.scriptPath);
@@ -409,123 +359,72 @@ export async function handleAttachScript(runner, args) {
             'Create the script file first',
         ]);
     }
-    try {
-        const params = {
-            scenePath: args.scenePath,
-            nodePath: args.nodePath,
-            scriptPath: args.scriptPath,
-        };
-        const { stdout, stderr } = await runner.executeOperation('attach_script', params, v.projectPath);
-        if (!stdout.trim()) {
-            return createErrorResponse(`Failed to attach script: ${extractGdError(stderr)}`, [
-                'Ensure the script is valid for this node type',
-            ]);
-        }
-        return { content: [{ type: 'text', text: stdout }] };
-    }
-    catch (error) {
-        const errorMessage = error instanceof Error ? error.message : 'Unknown error';
-        return createErrorResponse(`Failed to attach script: ${errorMessage}`, [
-            'Ensure Godot is installed correctly',
-        ]);
-    }
+    const params = {
+        scenePath: args.scenePath,
+        nodePath: args.nodePath,
+        scriptPath: args.scriptPath,
+    };
+    return executeSceneOp(runner, 'attach_script', params, v.projectPath, 'Failed to attach script', [
+        'Ensure the script is valid for this node type',
+    ]);
 }
 export async function handleGetSceneTree(runner, args) {
     args = normalizeParameters(args);
     const v = validateSceneArgs(args);
     if ('isError' in v)
         return v;
-    if (args.parentPath && !validatePath(args.parentPath)) {
-        return createErrorResponse('Invalid parentPath', ['Provide a valid path without ".."']);
-    }
-    try {
-        const params = { scenePath: args.scenePath };
-        if (args.parentPath)
-            params.parentPath = args.parentPath;
-        if (typeof args.maxDepth === 'number')
-            params.maxDepth = args.maxDepth;
-        const { stdout, stderr } = await runner.executeOperation('get_scene_tree', params, v.projectPath);
-        if (!stdout.trim()) {
-            return createErrorResponse(`Failed to get scene tree: ${extractGdError(stderr)}`, [
-                'Ensure the scene is valid',
-            ]);
-        }
-        return { content: [{ type: 'text', text: stdout }] };
-    }
-    catch (error) {
-        const errorMessage = error instanceof Error ? error.message : 'Unknown error';
-        return createErrorResponse(`Failed to get scene tree: ${errorMessage}`, [
-            'Ensure Godot is installed correctly',
+    if (args.parentPath && !validateNodePath(args.parentPath)) {
+        return createErrorResponse('Invalid parentPath', [
+            'Provide a scene-tree path without ".." (e.g. "root/Player")',
         ]);
     }
+    const params = { scenePath: args.scenePath };
+    if (args.parentPath)
+        params.parentPath = args.parentPath;
+    if (typeof args.maxDepth === 'number')
+        params.maxDepth = args.maxDepth;
+    return executeSceneOp(runner, 'get_scene_tree', params, v.projectPath, 'Failed to get scene tree', ['Ensure the scene is valid']);
 }
 export async function handleDuplicateNode(runner, args) {
     args = normalizeParameters(args);
     const v = validateSceneArgs(args);
     if ('isError' in v)
         return v;
-    if (!args.nodePath || !validatePath(args.nodePath)) {
+    if (!args.nodePath || !validateNodePath(args.nodePath)) {
         return createErrorResponse('Valid nodePath is required', [
             'Provide the node path to duplicate',
         ]);
     }
-    if (args.targetParentPath && !validatePath(args.targetParentPath)) {
-        return createErrorResponse('Invalid targetParentPath', ['Provide a valid path without ".."']);
-    }
-    try {
-        const params = { scenePath: args.scenePath, nodePath: args.nodePath };
-        if (args.newName)
-            params.newName = args.newName;
-        if (args.targetParentPath)
-            params.targetParentPath = args.targetParentPath;
-        const { stdout, stderr } = await runner.executeOperation('duplicate_node', params, v.projectPath);
-        if (!stdout.trim()) {
-            return createErrorResponse(`Failed to duplicate node: ${extractGdError(stderr)}`, [
-                'Check if the node path and target parent path are correct',
-            ]);
-        }
-        return { content: [{ type: 'text', text: stdout }] };
-    }
-    catch (error) {
-        const errorMessage = error instanceof Error ? error.message : 'Unknown error';
-        return createErrorResponse(`Failed to duplicate node: ${errorMessage}`, [
-            'Ensure Godot is installed correctly',
+    if (args.targetParentPath && !validateNodePath(args.targetParentPath)) {
+        return createErrorResponse('Invalid targetParentPath', [
+            'Provide a scene-tree path without ".." (e.g. "root/Player")',
         ]);
     }
+    const params = { scenePath: args.scenePath, nodePath: args.nodePath };
+    if (args.newName)
+        params.newName = args.newName;
+    if (args.targetParentPath)
+        params.targetParentPath = args.targetParentPath;
+    return executeSceneOp(runner, 'duplicate_node', params, v.projectPath, 'Failed to duplicate node', ['Check if the node path and target parent path are correct']);
 }
 export async function handleGetNodeSignals(runner, args) {
     args = normalizeParameters(args);
     const v = validateSceneArgs(args);
     if ('isError' in v)
         return v;
-    if (!args.nodePath || !validatePath(args.nodePath)) {
+    if (!args.nodePath || !validateNodePath(args.nodePath)) {
         return createErrorResponse('Valid nodePath is required', [
             'Provide the node path (e.g. "root/Button")',
         ]);
     }
-    try {
-        const params = { scenePath: args.scenePath, nodePath: args.nodePath };
-        const { stdout, stderr } = await runner.executeOperation('get_node_signals', params, v.projectPath);
-        if (!stdout.trim()) {
-            return createErrorResponse(`Failed to get signals: ${extractGdError(stderr)}`, [
-                'Check if the node path is correct',
-            ]);
-        }
-        return { content: [{ type: 'text', text: stdout }] };
-    }
-    catch (error) {
-        const errorMessage = error instanceof Error ? error.message : 'Unknown error';
-        return createErrorResponse(`Failed to get node signals: ${errorMessage}`, [
-            'Ensure Godot is installed correctly',
-        ]);
-    }
+    const params = { scenePath: args.scenePath, nodePath: args.nodePath };
+    return executeSceneOp(runner, 'get_node_signals', params, v.projectPath, 'Failed to get node signals', ['Check if the node path is correct']);
 }
-export async function handleConnectSignal(runner, args) {
-    args = normalizeParameters(args);
+function validateSignalArgs(args) {
     const v = validateSceneArgs(args);
     if ('isError' in v)
         return v;
-    if (!args.nodePath || !validatePath(args.nodePath)) {
+    if (!args.nodePath || !validateNodePath(args.nodePath)) {
         return createErrorResponse('Valid nodePath is required', ['Provide the source node path']);
     }
     if (!args.signal || !args.targetNodePath || !args.method) {
@@ -533,69 +432,46 @@ export async function handleConnectSignal(runner, args) {
             'Provide all three parameters',
         ]);
     }
-    if (!validatePath(args.targetNodePath)) {
-        return createErrorResponse('Invalid targetNodePath', ['Provide a valid path without ".."']);
-    }
-    try {
-        const params = {
-            scenePath: args.scenePath,
-            nodePath: args.nodePath,
-            signal: args.signal,
-            targetNodePath: args.targetNodePath,
-            method: args.method,
-        };
-        const { stdout, stderr } = await runner.executeOperation('connect_signal', params, v.projectPath);
-        if (!stdout.trim()) {
-            return createErrorResponse(`Failed to connect signal: ${extractGdError(stderr)}`, [
-                'Ensure the signal exists on the source node and the method exists on the target node',
-            ]);
-        }
-        return { content: [{ type: 'text', text: stdout }] };
-    }
-    catch (error) {
-        const errorMessage = error instanceof Error ? error.message : 'Unknown error';
-        return createErrorResponse(`Failed to connect signal: ${errorMessage}`, [
-            'Ensure Godot is installed correctly',
+    if (!validateNodePath(args.targetNodePath)) {
+        return createErrorResponse('Invalid targetNodePath', [
+            'Provide a scene-tree path without ".." (e.g. "root/Player")',
         ]);
     }
+    return {
+        projectPath: v.projectPath,
+        scenePath: v.scenePath,
+        nodePath: args.nodePath,
+        signal: args.signal,
+        targetNodePath: args.targetNodePath,
+        method: args.method,
+    };
+}
+export async function handleConnectSignal(runner, args) {
+    args = normalizeParameters(args);
+    const v = validateSignalArgs(args);
+    if ('isError' in v)
+        return v;
+    const params = {
+        scenePath: v.scenePath,
+        nodePath: v.nodePath,
+        signal: v.signal,
+        targetNodePath: v.targetNodePath,
+        method: v.method,
+    };
+    return executeSceneOp(runner, 'connect_signal', params, v.projectPath, 'Failed to connect signal', ['Ensure the signal exists on the source node and the method exists on the target node']);
 }
 export async function handleDisconnectSignal(runner, args) {
     args = normalizeParameters(args);
-    const v = validateSceneArgs(args);
+    const v = validateSignalArgs(args);
     if ('isError' in v)
         return v;
-    if (!args.nodePath || !validatePath(args.nodePath)) {
-        return createErrorResponse('Valid nodePath is required', ['Provide the source node path']);
-    }
-    if (!args.signal || !args.targetNodePath || !args.method) {
-        return createErrorResponse('signal, targetNodePath, and method are required', [
-            'Provide all three parameters',
-        ]);
-    }
-    if (!validatePath(args.targetNodePath)) {
-        return createErrorResponse('Invalid targetNodePath', ['Provide a valid path without ".."']);
-    }
-    try {
-        const params = {
-            scenePath: args.scenePath,
-            nodePath: args.nodePath,
-            signal: args.signal,
-            targetNodePath: args.targetNodePath,
-            method: args.method,
-        };
-        const { stdout, stderr } = await runner.executeOperation('disconnect_signal', params, v.projectPath);
-        if (!stdout.trim()) {
-            return createErrorResponse(`Failed to disconnect signal: ${extractGdError(stderr)}`, [
-                'Ensure the signal connection exists before trying to disconnect it',
-            ]);
-        }
-        return { content: [{ type: 'text', text: stdout }] };
-    }
-    catch (error) {
-        const errorMessage = error instanceof Error ? error.message : 'Unknown error';
-        return createErrorResponse(`Failed to disconnect signal: ${errorMessage}`, [
-            'Ensure Godot is installed correctly',
-        ]);
-    }
+    const params = {
+        scenePath: v.scenePath,
+        nodePath: v.nodePath,
+        signal: v.signal,
+        targetNodePath: v.targetNodePath,
+        method: v.method,
+    };
+    return executeSceneOp(runner, 'disconnect_signal', params, v.projectPath, 'Failed to disconnect signal', ['Ensure the signal connection exists before trying to disconnect it']);
 }
 //# sourceMappingURL=node-tools.js.map