Creating scene does not work (json parse error)

[eonhe]

It was working for a day then suddenly stopped working.

[eonhe]

ugh! now it's working again and I don't understand what's causing/fixing the issue

[rugia813]

i still have this error, not sure if same reason

[Navoren]

The Godot MCP tool's create_scene operation fails due to improper JSON parameter formatting.

Steps to Reproduce

1. Use mcp_godot_create_scene with basic parameters:

{
    "projectPath": "path-to-project",
    "scenePath": "test_scene.tscn",
    "rootNodeType": "Node2D"
}

Current Behavior

Parameters are passed to Godot as unquoted JSON:
{scene_path:test_scene.tscn,root_node_type:Node2D}

[Navoren]

The error still persist, is there any alternative?

[miamax80]

Hi,

I encountered the same (?) issue where the godot_operations.gd script was consistently failing with JSON parsing errors (JSON Error: Expected key, Invalid access to property or key 'scene_path').

It seems the root cause was in how the executeOperation method in src/index.ts was previously implemented.
It used execAsync, which executes commands via the system shell. This approach led to problems when passing the JSON parameter string as a command-line argument, as the shell's interpretation interfered with the JSON structure, causing the parsing failures in the Godot script.

To resolve this, I've refactored the executeOperation method (see below) to use child_process.spawn instead.

Key changes I did:

• Replaced execAsync with spawn: This executes the Godot command directly, avoiding shell interference.
• Arguments as Array: Command-line arguments (paths, operation name, JSON string, etc.) are now passed as an array directly to spawn, ensuring they are treated as distinct arguments.
• Removed Manual Quoting: The unnecessary single quotes around the JSON string (which were problematic) have been removed, as spawn handles argument passing correctly.
• Promise Handling: The spawn logic is now wrapped in a Promise for proper asynchronous handling of the process execution, output, and errors.

This approach ensures the JSON parameters are passed reliably to the Godot script without being mangled by shell interpretation, fixing the parsing errors.

Hope this helps.

  /**
   * Execute a Godot operation using the operations script
   * @param operation The operation to execute
   * @param params The parameters for the operation
   * @param projectPath The path to the Godot project
   * @returns The stdout and stderr from the operation
   */
  private async executeOperation(
    operation: string,
    params: OperationParams,
    projectPath: string
  ): Promise<{ stdout: string; stderr: string }> {
    return new Promise(async (resolve, reject) => { // Wrap in a Promise
      this.logDebug(`Executing operation: ${operation} in project: ${projectPath}`);
      this.logDebug(`Original operation params: ${JSON.stringify(params)}`);

      // Convert camelCase parameters to snake_case for Godot script
      const snakeCaseParams = this.convertCamelToSnakeCase(params);
      this.logDebug(`Converted snake_case params: ${JSON.stringify(snakeCaseParams)}`);

      // Ensure godotPath is set
      if (!this.godotPath) {
        await this.detectGodotPath();
        if (!this.godotPath) {
          return reject(new Error('Could not find a valid Godot executable path')); // Reject Promise
        }
      }

      try {
        // Serialize the snake_case parameters to a valid JSON string
        const paramsJson = JSON.stringify(snakeCaseParams);
        
        // No need to escape single quotes when using spawn
        // const escapedParams = paramsJson.replace(/'/g, "'\\''"); 

        // Add debug arguments if debug mode is enabled
        const debugArgs = GODOT_DEBUG_MODE ? ['--debug-godot'] : [];

        // Construct the arguments array for spawn
        const argsArray = [
          '--headless',
          '--path',
          projectPath, // No extra quotes needed for spawn
          '--script',
          this.operationsScriptPath, // No extra quotes needed for spawn
          operation,
          paramsJson, // Pass the JSON string directly as an argument
          ...debugArgs,
        ];

        this.logDebug(`Spawning Godot command: ${this.godotPath} ${argsArray.join(' ')}`);
        
        // Use spawn instead of execAsync
        const godotProcess = spawn(this.godotPath, argsArray, { stdio: 'pipe' });

        let stdoutData = '';
        let stderrData = '';

        godotProcess.stdout.on('data', (data) => {
          stdoutData += data.toString();
          this.logDebug(`[Godot Op stdout] ${data.toString().trim()}`);
        });

        godotProcess.stderr.on('data', (data) => {
          stderrData += data.toString();
          this.logDebug(`[Godot Op stderr] ${data.toString().trim()}`);
        });

        godotProcess.on('error', (error) => {
          this.logDebug(`Godot spawn error: ${error.message}`);
          // Include stdout/stderr in the rejection error for context
          reject(new Error(`Failed to spawn Godot: ${error.message}\nSTDOUT: ${stdoutData}\nSTDERR: ${stderrData}`));
        });

        godotProcess.on('close', (code) => {
          this.logDebug(`Godot operation process exited with code ${code}`);
          if (code === 0 || (!code && !stderrData.includes('[ERROR]'))) { // Consider no error output as success even with non-zero code sometimes
             resolve({ stdout: stdoutData, stderr: stderrData }); // Resolve Promise
          } else {
            // Reject with an error containing stdout/stderr
            reject(new Error(`Godot operation failed with code ${code}\nSTDOUT: ${stdoutData}\nSTDERR: ${stderrData}`));
          }
        });

      } catch (error: unknown) {
        this.logDebug(`Error during executeOperation setup: ${error}`);
        reject(error); // Reject Promise
      }
    }); // End of Promise wrapper
  }

[An-actual-duck]

I found this in the pull requests for the mcp

Just follow these steps:

In a terminal path to your godot-mcp folder and paste the following:

git fetch origin pull/18/head:fix/create-scene-args
git checkout fix/create-scene-args
npm install
npm run build

It worked for me, I hope it works for everyone else.