godot-mcp-runtime 1.1.0 → 2.0.0

package/dist/tools/node-tools.js

@@ -1,89 +1,87 @@
-import { join } from 'path';
 import { existsSync } from 'fs';
-import { normalizeParameters, convertCamelToSnakeCase, validatePath, createErrorResponse, extractGdError, } from '../utils/godot-runner.js';
+import { join } from 'path';
+import { normalizeParameters, convertCamelToSnakeCase, validatePath, createErrorResponse, extractGdError, validateSceneArgs, } from '../utils/godot-runner.js';
+// --- Tool definitions ---
 export const nodeToolDefinitions = [
     {
-        name: 'manage_node',
-        description: 'Read or modify nodes in a Godot scene file using headless Godot. All mutation operations (delete, update_property, attach_script, duplicate, connect_signal, disconnect_signal) save automatically — no explicit save call needed.\n\nOperations:\n- delete: Remove a node from the scene (required: nodePath)\n- update_property: Set a property on a node (required: nodePath, property, value)\n- get_properties: Read a node\'s current property values (required: nodePath; optional: changedOnly)\n- attach_script: Attach a GDScript file to a node (required: nodePath, scriptPath)\n- list: List direct child node names and types (optional: parentPath)\n- get_tree: Get the full scene hierarchy as a tree structure, always from root (optional: maxDepth)\n- duplicate: Duplicate a node and its children (required: nodePath; optional: newName, targetParentPath)\n- get_signals: List all signals defined on a node and their current connections (required: nodePath). Returns { nodePath, nodeType, signals: [{ name, connections: [{ signal, target, method }] }] }. Note: the target field uses Godot absolute path format (e.g. /root/Scene/Node) — convert to scene-root-relative (e.g. root/Node) before passing to connect_signal or disconnect_signal.\n- connect_signal: Connect a signal from one node to a method on another (required: nodePath, signal, targetNodePath, method). Errors if the signal does not exist on the source node or the method does not exist on the target node.\n- disconnect_signal: Disconnect a signal connection (required: nodePath, signal, targetNodePath, method). Errors if the connection does not exist — use get_signals first to verify it is present.',
+        name: 'delete_node',
+        description: 'Remove a node from a Godot scene file. Saves automatically.',
         inputSchema: {
             type: 'object',
             properties: {
-                operation: {
-                    type: 'string',
-                    enum: ['delete', 'update_property', 'get_properties', 'attach_script', 'list', 'get_tree', 'duplicate', 'get_signals', 'connect_signal', 'disconnect_signal'],
-                    description: 'The node operation to perform',
-                },
-                projectPath: {
-                    type: 'string',
-                    description: 'Path to the Godot project directory',
-                },
-                scenePath: {
-                    type: 'string',
-                    description: 'Path to the scene file relative to the project (e.g. "scenes/main.tscn")',
-                },
-                nodePath: {
-                    type: 'string',
-                    description: 'Node path from scene root (e.g. "root/Player/Sprite2D"). Required for delete, update_property, get_properties, attach_script, duplicate, get_signals, connect_signal, disconnect_signal.',
-                },
-                property: {
-                    type: 'string',
-                    description: '[update_property] GDScript property name in snake_case (e.g. "position", "modulate", "collision_layer"). Use get_properties to discover valid property names.',
-                },
-                value: {
-                    description: '[update_property] New property value. Primitives (string, number, boolean, array, object) are passed as-is. Vector2 ({"x","y"}), Vector3 ({"x","y","z"}), and Color ({"r","g","b","a"}) are automatically converted. Use run_script for other complex GDScript types.',
-                },
-                scriptPath: {
-                    type: 'string',
-                    description: '[attach_script] Path to the GDScript file relative to the project (e.g. "scripts/player.gd")',
-                },
-                parentPath: {
-                    type: 'string',
-                    description: '[list] Scope results to this node path from scene root (e.g. "root/Player"). Defaults to the root node. Note: ignored by get_tree, which always starts from the scene root.',
-                },
-                changedOnly: {
-                    type: 'boolean',
-                    description: '[get_properties] Only return properties whose values differ from their class defaults (default: false)',
-                },
-                maxDepth: {
-                    type: 'number',
-                    description: '[get_tree] Maximum recursion depth. -1 for unlimited (default: -1). 1 returns only direct children.',
-                },
-                newName: {
-                    type: 'string',
-                    description: '[duplicate] Name for the duplicated node. Defaults to the original name + "2".',
-                },
-                targetParentPath: {
-                    type: 'string',
-                    description: '[duplicate] Node path of the parent to add the duplicate to. Defaults to the same parent as the original.',
-                },
-                signal: {
-                    type: 'string',
-                    description: '[connect_signal, disconnect_signal] Signal name on the source node (e.g. "pressed", "body_entered")',
-                },
-                targetNodePath: {
-                    type: 'string',
-                    description: '[connect_signal, disconnect_signal] Path of the target node that receives the signal (from scene root)',
-                },
-                method: {
-                    type: 'string',
-                    description: '[connect_signal, disconnect_signal] Method name on the target node to call when the signal fires',
-                },
+                projectPath: { type: 'string', description: 'Path to the Godot project directory' },
+                scenePath: { 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")' },
+            },
+            required: ['projectPath', 'scenePath', 'nodePath'],
+        },
+    },
+    {
+        name: 'set_node_property',
+        description: 'Set a property on a node in a Godot scene file. Saves automatically. Primitives (string, number, boolean, array, object) are passed as-is. Vector2 ({"x","y"}), Vector3 ({"x","y","z"}), and Color ({"r","g","b","a"}) are automatically converted. Use run_script for other complex GDScript types.',
+        inputSchema: {
+            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.' },
+                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. Saves automatically. Returns { results: [{ nodePath, property, success?, error? }] }.',
+        inputSchema: {
+            type: 'object',
+            properties: {
+                projectPath: { type: 'string', description: 'Path to the Godot project directory' },
+                scenePath: { type: 'string', description: 'Scene file path relative to the project' },
                 updates: {
                     type: 'array',
-                    description: '[update_property batch] Multiple property updates in one Godot process. Requires scenePath at top level. Returns { results: [{ nodePath, property, success?, error? }] }.',
+                    description: 'Property updates to apply',
                     items: {
                         type: 'object',
                         properties: {
-                            nodePath: { type: 'string', description: 'Node path from scene root (e.g. "root/Player")' },
+                            nodePath: { type: 'string', description: 'Node path from scene root' },
                             property: { type: 'string', description: 'GDScript property name in snake_case' },
                             value: { description: 'New property value' },
                         },
                         required: ['nodePath', 'property', 'value'],
                     },
                 },
+                abortOnError: { type: 'boolean', description: 'Stop processing on first error (default: false)' },
+            },
+            required: ['projectPath', 'scenePath', 'updates'],
+        },
+    },
+    {
+        name: 'get_node_properties',
+        description: 'Read a node\'s current property values from a Godot scene file.',
+        inputSchema: {
+            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)' },
+            },
+            required: ['projectPath', 'scenePath', 'nodePath'],
+        },
+    },
+    {
+        name: 'batch_get_node_properties',
+        description: 'Get properties from multiple nodes in a single Godot process. Returns { results: [{ nodePath, nodeType, properties?, error? }] }.',
+        inputSchema: {
+            type: 'object',
+            properties: {
+                projectPath: { type: 'string', description: 'Path to the Godot project directory' },
+                scenePath: { type: 'string', description: 'Scene file path relative to the project' },
                 nodes: {
                     type: 'array',
-                    description: '[get_properties batch] Get properties from multiple nodes in one Godot process. Requires scenePath at top level. Returns { results: [{ nodePath, nodeType, properties?, error? }] }.',
+                    description: 'Nodes to read properties from',
                     items: {
                         type: 'object',
                         properties: {
@@ -93,229 +91,391 @@ export const nodeToolDefinitions = [
                         required: ['nodePath'],
                     },
                 },
-                abortOnError: {
-                    type: 'boolean',
-                    description: '[update_property batch] Stop processing on first error (default: false)',
-                },
             },
-            required: ['operation', 'projectPath', 'scenePath'],
+            required: ['projectPath', 'scenePath', 'nodes'],
+        },
+    },
+    {
+        name: 'attach_script',
+        description: 'Attach a GDScript file to a node in a Godot scene. Saves automatically.',
+        inputSchema: {
+            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")' },
+                scriptPath: { type: 'string', description: 'Path to the GDScript file relative to the project (e.g. "scripts/player.gd")' },
+            },
+            required: ['projectPath', 'scenePath', 'nodePath', 'scriptPath'],
+        },
+    },
+    {
+        name: 'get_scene_tree',
+        description: 'Get the scene hierarchy as a tree structure. Use maxDepth: 1 for a shallow listing of direct children only.',
+        inputSchema: {
+            type: 'object',
+            properties: {
+                projectPath: { type: 'string', description: 'Path to the Godot project directory' },
+                scenePath: { type: 'string', description: 'Scene file path relative to the project' },
+                parentPath: { type: 'string', description: 'Scope to a subtree starting at this node path (e.g. "root/Player")' },
+                maxDepth: { type: 'number', description: 'Maximum recursion depth. -1 for unlimited (default: -1). 1 returns only direct children.' },
+            },
+            required: ['projectPath', 'scenePath'],
+        },
+    },
+    {
+        name: 'duplicate_node',
+        description: 'Duplicate a node and its children in a Godot scene. Saves automatically.',
+        inputSchema: {
+            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 to duplicate' },
+                newName: { type: 'string', description: 'Name for the duplicated node (default: original name + "2")' },
+                targetParentPath: { type: 'string', description: 'Parent node path for the duplicate (default: same parent as original)' },
+            },
+            required: ['projectPath', 'scenePath', 'nodePath'],
+        },
+    },
+    {
+        name: 'get_node_signals',
+        description: 'List all signals defined on a node and their current connections. Returns { nodePath, nodeType, signals: [{ name, connections: [{ signal, target, method }] }] }. Note: the target field uses Godot absolute path format (e.g. /root/Scene/Node) — convert to scene-root-relative (e.g. root/Node) before passing to connect_signal or disconnect_signal.',
+        inputSchema: {
+            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/Button")' },
+            },
+            required: ['projectPath', 'scenePath', 'nodePath'],
+        },
+    },
+    {
+        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.',
+        inputSchema: {
+            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: 'Source node path from scene root' },
+                signal: { type: 'string', description: 'Signal name on the source node (e.g. "pressed", "body_entered")' },
+                targetNodePath: { type: 'string', description: 'Target node path from scene root that receives the signal' },
+                method: { type: 'string', description: 'Method name on the target node to call when the signal fires' },
+            },
+            required: ['projectPath', 'scenePath', 'nodePath', 'signal', 'targetNodePath', 'method'],
+        },
+    },
+    {
+        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.',
+        inputSchema: {
+            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: 'Source node path from scene root' },
+                signal: { type: 'string', description: 'Signal name on the source node' },
+                targetNodePath: { type: 'string', description: 'Target node path from scene root' },
+                method: { type: 'string', description: 'Method name on the target node' },
+            },
+            required: ['projectPath', 'scenePath', 'nodePath', 'signal', 'targetNodePath', 'method'],
         },
     },
 ];
-export async function handleManageNode(runner, args) {
+// --- Handlers ---
+export async function handleDeleteNode(runner, args) {
     args = normalizeParameters(args);
-    const operation = args.operation;
-    if (!operation) {
-        return createErrorResponse('operation is required', ['Provide one of: delete, update_property, get_properties, attach_script, list, get_tree, duplicate, get_signals, connect_signal, disconnect_signal']);
-    }
-    if (!args.projectPath || !args.scenePath) {
-        return createErrorResponse('projectPath and scenePath are required', ['Provide valid paths for both']);
-    }
-    if (!validatePath(args.projectPath) || !validatePath(args.scenePath)) {
-        return createErrorResponse('Invalid path', ['Provide valid paths without ".." or other potentially unsafe characters']);
-    }
-    const projectFile = join(args.projectPath, 'project.godot');
-    if (!existsSync(projectFile)) {
-        return createErrorResponse(`Not a valid Godot project: ${args.projectPath}`, ['Ensure the path points to a directory containing a project.godot file']);
-    }
-    const sceneFullPath = join(args.projectPath, args.scenePath);
-    if (!existsSync(sceneFullPath)) {
-        return createErrorResponse(`Scene file does not exist: ${args.scenePath}`, ['Ensure the scene path is correct']);
-    }
-    // Operations that require nodePath (skipped when batch params are provided)
-    const isBatchOp = (operation === 'update_property' && args.updates && Array.isArray(args.updates)) ||
-        (operation === 'get_properties' && args.nodes && Array.isArray(args.nodes));
-    const needsNodePath = ['delete', 'update_property', 'get_properties', 'attach_script', 'duplicate', 'get_signals', 'connect_signal', 'disconnect_signal'];
-    if (needsNodePath.includes(operation) && !isBatchOp) {
-        if (!args.nodePath) {
-            return createErrorResponse(`nodePath is required for ${operation}`, ['Provide the node path (e.g. "root/Player")']);
+    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 };
+        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']);
         }
-        if (!validatePath(args.nodePath)) {
-            return createErrorResponse('Invalid node path', ['Provide a valid path without ".."']);
+        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']);
+    }
+}
+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('update_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) {
+    args = normalizeParameters(args);
+    const v = validateSceneArgs(args);
+    if ('isError' in v)
+        return v;
+    if (!args.updates || !Array.isArray(args.updates)) {
+        return createErrorResponse('updates array is required', ['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_update_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']);
+    }
+}
+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)
+        return v;
+    if (!args.nodes || !Array.isArray(args.nodes)) {
+        return createErrorResponse('nodes array is required', ['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']);
+    }
+}
+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)) {
+        return createErrorResponse('Valid nodePath is required', ['Provide the node path (e.g. "root/Player")']);
+    }
+    if (!args.scriptPath || !validatePath(args.scriptPath)) {
+        return createErrorResponse('Valid scriptPath is required', ['Provide the script path relative to the project']);
+    }
+    const scriptFullPath = join(v.projectPath, args.scriptPath);
+    if (!existsSync(scriptFullPath)) {
+        return createErrorResponse(`Script file does not exist: ${args.scriptPath}`, ['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']);
+    }
+}
+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']);
+    }
+}
+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)) {
+        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']);
+    }
+}
+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)) {
+        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']);
+    }
+}
+export async function handleConnectSignal(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 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('connect_node_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']);
+    }
+}
+export async function handleDisconnectSignal(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 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 {
-        switch (operation) {
-            case 'delete': {
-                const params = { scenePath: args.scenePath, nodePath: args.nodePath };
-                const { stdout, stderr } = await runner.executeOperation('delete_node', params, args.projectPath);
-                if (!stdout.trim()) {
-                    return createErrorResponse(`Failed to delete node: ${extractGdError(stderr)}`, ['Check if the node path is correct']);
-                }
-                return { content: [{ type: 'text', text: stdout }] };
-            }
-            case 'update_property': {
-                // Batch mode: updates array
-                if (args.updates && Array.isArray(args.updates)) {
-                    // Convert each item to snake_case for GDScript
-                    // (convertCamelToSnakeCase doesn't recurse into arrays, so we map over items)
-                    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_update_node_properties', params, args.projectPath);
-                    if (!stdout.trim()) {
-                        return createErrorResponse(`Batch update failed: ${extractGdError(stderr)}`, ['Check node paths and property names']);
-                    }
-                    return { content: [{ type: 'text', text: stdout }] };
-                }
-                // Single-op
-                if (!args.property || args.value === undefined) {
-                    return createErrorResponse('property and value are required for update_property', ['Provide both property name and value']);
-                }
-                const params = {
-                    scenePath: args.scenePath,
-                    nodePath: args.nodePath,
-                    property: args.property,
-                    value: args.value,
-                };
-                const { stdout, stderr } = await runner.executeOperation('update_node_property', params, args.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 }] };
-            }
-            case 'get_properties': {
-                // Batch mode: nodes array
-                if (args.nodes && Array.isArray(args.nodes)) {
-                    // Convert each item to snake_case for GDScript
-                    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, args.projectPath);
-                    if (!stdout.trim()) {
-                        return createErrorResponse(`Batch get_properties failed: ${extractGdError(stderr)}`, ['Check node paths']);
-                    }
-                    return { content: [{ type: 'text', text: stdout }] };
-                }
-                // Single-op
-                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, args.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 }] };
-            }
-            case 'attach_script': {
-                if (!args.scriptPath) {
-                    return createErrorResponse('scriptPath is required for attach_script', ['Provide the script path relative to the project']);
-                }
-                if (!validatePath(args.scriptPath)) {
-                    return createErrorResponse('Invalid script path', ['Provide a valid path without ".."']);
-                }
-                const scriptFullPath = join(args.projectPath, args.scriptPath);
-                if (!existsSync(scriptFullPath)) {
-                    return createErrorResponse(`Script file does not exist: ${args.scriptPath}`, ['Create the script file first']);
-                }
-                const params = {
-                    scenePath: args.scenePath,
-                    nodePath: args.nodePath,
-                    scriptPath: args.scriptPath,
-                };
-                const { stdout, stderr } = await runner.executeOperation('attach_script', params, args.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 }] };
-            }
-            case 'list': {
-                if (args.parentPath && !validatePath(args.parentPath)) {
-                    return createErrorResponse('Invalid parent path', ['Provide a valid path without ".."']);
-                }
-                const params = { scenePath: args.scenePath };
-                if (args.parentPath)
-                    params.parentPath = args.parentPath;
-                const { stdout, stderr } = await runner.executeOperation('list_nodes', params, args.projectPath);
-                if (!stdout.trim()) {
-                    return createErrorResponse(`Failed to list nodes: ${extractGdError(stderr)}`, ['Check if the parent path is correct']);
-                }
-                return { content: [{ type: 'text', text: stdout }] };
-            }
-            case 'get_tree': {
-                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, args.projectPath);
-                if (!stdout.trim()) {
-                    return createErrorResponse(`Failed to get scene tree: ${extractGdError(stderr)}`, ['Ensure the scene is valid']);
-                }
-                return { content: [{ type: 'text', text: stdout }] };
-            }
-            case 'duplicate': {
-                if (args.targetParentPath && !validatePath(args.targetParentPath)) {
-                    return createErrorResponse('Invalid targetParentPath', ['Provide a valid path without ".."']);
-                }
-                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, args.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 }] };
-            }
-            case 'get_signals': {
-                const params = { scenePath: args.scenePath, nodePath: args.nodePath };
-                const { stdout, stderr } = await runner.executeOperation('get_node_signals', params, args.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 }] };
-            }
-            case 'connect_signal': {
-                if (!args.signal || !args.targetNodePath || !args.method) {
-                    return createErrorResponse('signal, targetNodePath, and method are required for connect_signal', ['Provide all three parameters']);
-                }
-                if (!validatePath(args.targetNodePath)) {
-                    return createErrorResponse('Invalid targetNodePath', ['Provide a valid path without ".."']);
-                }
-                const params = {
-                    scenePath: args.scenePath,
-                    nodePath: args.nodePath,
-                    signal: args.signal,
-                    targetNodePath: args.targetNodePath,
-                    method: args.method,
-                };
-                const { stdout, stderr } = await runner.executeOperation('connect_node_signal', params, args.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 }] };
-            }
-            case 'disconnect_signal': {
-                if (!args.signal || !args.targetNodePath || !args.method) {
-                    return createErrorResponse('signal, targetNodePath, and method are required for disconnect_signal', ['Provide all three parameters']);
-                }
-                if (!validatePath(args.targetNodePath)) {
-                    return createErrorResponse('Invalid targetNodePath', ['Provide a valid path without ".."']);
-                }
-                const params = {
-                    scenePath: args.scenePath,
-                    nodePath: args.nodePath,
-                    signal: args.signal,
-                    targetNodePath: args.targetNodePath,
-                    method: args.method,
-                };
-                const { stdout, stderr } = await runner.executeOperation('disconnect_node_signal', params, args.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 }] };
-            }
-            default:
-                return createErrorResponse(`Unknown operation: ${operation}`, ['Use one of: delete, update_property, get_properties, attach_script, list, get_tree, duplicate, get_signals, connect_signal, disconnect_signal']);
+        const params = {
+            scenePath: args.scenePath,
+            nodePath: args.nodePath,
+            signal: args.signal,
+            targetNodePath: args.targetNodePath,
+            method: args.method,
+        };
+        const { stdout, stderr } = await runner.executeOperation('disconnect_node_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 ${operation} node: ${errorMessage}`, ['Ensure Godot is installed correctly', 'Check if the GODOT_PATH environment variable is set correctly']);
+        return createErrorResponse(`Failed to disconnect signal: ${errorMessage}`, ['Ensure Godot is installed correctly']);
     }
 }
 //# sourceMappingURL=node-tools.js.map