@codesys/mcp-toolkit 1.0.7 → 1.0.9

package/dist/codesys_interop.js

@@ -43,7 +43,7 @@ var __awaiter = (this && this.__awaiter) || function (thisArg, _arguments, P, ge
 };
 Object.defineProperty(exports, "__esModule", { value: true });
 exports.executeCodesysScript = executeCodesysScript;
-const child_process_1 = require("child_process");
+const child_process_1 = require("child_process"); // Still using spawn
 const promises_1 = require("fs/promises");
 const path = __importStar(require("path"));
 const os = __importStar(require("os"));
@@ -52,6 +52,7 @@ const SCRIPT_SUCCESS_MARKER = 'SCRIPT_SUCCESS';
 const SCRIPT_ERROR_MARKER = 'SCRIPT_ERROR';
 /**
  * Executes a CODESYS Python script using the command line interface.
+ * Tries using spawn with shell:true and explicit quoting for cmd.exe.
  *
  * @param scriptContent The Python script code to execute.
  * @param codesysExePath The full path to the CODESYS.exe executable.
@@ -60,69 +61,84 @@ const SCRIPT_ERROR_MARKER = 'SCRIPT_ERROR';
  */
 function executeCodesysScript(scriptContent, codesysExePath, codesysProfileName) {
     return __awaiter(this, void 0, void 0, function* () {
-        // Validate arguments passed to the function
         if (!codesysExePath) {
             throw new Error('CODESYS executable path was not provided to executeCodesysScript.');
         }
         if (!codesysProfileName) {
             throw new Error('CODESYS profile name was not provided to executeCodesysScript.');
         }
-        // Create a temporary file for the script
         const tempDir = os.tmpdir();
-        const tempFileName = `codesys_script_${Date.now()}_${Math.random().toString(36).substring(7)}.py`;
+        const tempFileName = `codesys_script_${Date.now()}_${Math.random().toString(36).substring(2, 9)}.py`;
         const tempFilePath = path.join(tempDir, tempFileName);
         let output = '';
         let success = false;
+        let exitCode = null;
         try {
-            // Normalize line endings to LF (\n)
             const normalizedScriptContent = scriptContent.replace(/\r\n/g, '\n');
-            // Write the script content to the temporary file using latin1 encoding
-            yield (0, promises_1.writeFile)(tempFilePath, normalizedScriptContent, 'latin1'); // Explicitly use latin1
-            process.stderr.write(`Temporary script written to: ${tempFilePath} with latin1 encoding and LF line endings\n`); // Use process.stderr
-            // Add --additionalfolder argument
-            const additionalFolderPath = "C:\\Program Files\\CODESYS 3.5.21.0\\CODESYS\\AdditionalFolders\\Default"; // Assuming Default instance
-            // Fix: Use shell:true but ensure proper quoting for paths with spaces
-            const commandWithArgs = `"${codesysExePath}" --profile="${codesysProfileName}" --noUI --runscript="${tempFilePath}"`;
-            process.stderr.write(`Executing: ${commandWithArgs}\n`); // Log the command
-            // CONFIRMED WORKING APPROACH: Use simple exec() with complete quoting
-            // This approach is tested and works with the CODESYS executable
-            const execResult = yield new Promise((resolve) => {
-                process.stderr.write(`EXECUTING COMMAND: ${commandWithArgs}\n`);
-                // Execute command using exec which handles Windows command paths better
-                const childProcess = (0, child_process_1.exec)(commandWithArgs, { timeout: 30000 }, (error, stdout, stderr) => {
+            yield (0, promises_1.writeFile)(tempFilePath, normalizedScriptContent, 'latin1');
+            process.stderr.write(`Temporary script written to: ${tempFilePath}\n`);
+            // --- Force shell execution with explicit quoting for cmd.exe ---
+            // Meticulously construct the command string exactly as cmd.exe needs it.
+            // Rule 1: The executable path with spaces MUST be quoted.
+            // Rule 2: Arguments containing spaces MUST be quoted (or potentially escaped, but quotes are safer).
+            // Assuming profile name might have spaces, tempFilePath might too (less likely but possible).
+            const commandStringForShell = `"${codesysExePath}" --profile="${codesysProfileName}" --noUI --runscript="${tempFilePath}"`;
+            process.stderr.write(`Attempting to execute via shell: ${commandStringForShell}\n`); // Log the EXACT command
+            const spawnResult = yield new Promise((resolve) => {
+                let stdoutData = '';
+                let stderrData = '';
+                const controller = new AbortController();
+                const timeoutSignal = controller.signal;
+                const timeoutDuration = 30000; // 30 seconds
+                // Use shell: true. Pass the command string directly.
+                // On Windows, this uses cmd.exe.
+                // Pass the command string as the first argument when shell is true and args is empty/undefined.
+                const childProcess = (0, child_process_1.spawn)(commandStringForShell, [], {
+                    shell: true, // FORCE shell usage
+                    windowsHide: false,
+                    signal: timeoutSignal
+                });
+                const timeoutId = setTimeout(() => {
+                    process.stderr.write(`TIMEOUT: CODESYS process timed out after ${timeoutDuration / 1000} seconds\n`);
+                    controller.abort();
+                }, timeoutDuration);
+                childProcess.stdout.on('data', (data) => {
+                    const chunk = data.toString();
+                    stdoutData += chunk;
+                    process.stderr.write(`CODESYS stdout chunk: ${chunk.length > 100 ? chunk.substring(0, 100) + '...' : chunk}\n`);
+                });
+                childProcess.stderr.on('data', (data) => {
+                    // **** THIS IS CRITICAL - CAPTURE STDERR ****
+                    const chunk = data.toString();
+                    stderrData += chunk;
+                    process.stderr.write(`>>>> CODESYS stderr chunk: ${chunk}\n`); // Make stderr highly visible
+                });
+                childProcess.on('error', (error) => {
                     var _a;
-                    let combinedOutput = "";
-                    if (stdout)
-                        combinedOutput += stdout;
-                    if (stderr)
-                        combinedOutput += stderr;
-                    // Log results for debugging
-                    if (stdout)
-                        process.stderr.write(`CODESYS stdout: ${stdout.length > 100 ? stdout.substring(0, 100) + '...' : stdout}\n`);
-                    if (stderr)
-                        process.stderr.write(`CODESYS stderr: ${stderr}\n`);
-                    if (error) {
-                        process.stderr.write(`CODESYS exec error: ${error.message}\n`);
-                        resolve({ code: (_a = error.code) !== null && _a !== void 0 ? _a : 1, output: combinedOutput });
-                    }
-                    else {
-                        resolve({ code: 0, output: combinedOutput });
-                    }
+                    clearTimeout(timeoutId);
+                    process.stderr.write(`CODESYS spawn error (shell mode): ${error.message}\n`);
+                    resolve({ code: (_a = error.errno) !== null && _a !== void 0 ? _a : 1, output: stdoutData + stderrData + `\nSpawn Error: ${error.message}` });
                 });
-                // Safety cleanup for timeout case
-                childProcess.on('timeout', () => {
-                    process.stderr.write(`TIMEOUT: CODESYS process timed out after 30 seconds\n`);
-                    childProcess.kill();
-                    resolve({ code: 0, output: output + "\nTIMEOUT: CODESYS process timed out" });
+                childProcess.on('close', (code) => {
+                    clearTimeout(timeoutId);
+                    process.stderr.write(`CODESYS process closed with code: ${code}\n`);
+                    const combinedOutput = stdoutData + stderrData;
+                    resolve({ code: code, output: combinedOutput });
                 });
+                timeoutSignal.addEventListener('abort', () => {
+                    process.stderr.write('Abort signal received, killing process if still running.\n');
+                    // Kill logic remains the same
+                    if (!childProcess.killed)
+                        childProcess.kill('SIGTERM');
+                    setTimeout(() => { if (!childProcess.killed)
+                        childProcess.kill('SIGKILL'); }, 2000);
+                    resolve({ code: null, output: stdoutData + stderrData + "\nTIMEOUT: CODESYS process aborted due to timeout." });
+                }, { once: true });
             });
-            // Add exec results to our output and get the exit code
-            output += execResult.output;
-            const exitCode = execResult.code;
-            process.stderr.write(`CODESYS process exited with code: ${exitCode}\n`); // Use process.stderr
-            // Determine success based on exit code and output markers
-            // Note: CODESYS scripting might return exit code 0 even if the script had logical errors.
-            // Relying on specific output markers is more robust.
+            output = spawnResult.output;
+            exitCode = spawnResult.code;
+            // Success determination logic remains the same...
+            // [...]
             if (output.includes(SCRIPT_SUCCESS_MARKER)) {
                 success = true;
             }
@@ -130,48 +146,49 @@ function executeCodesysScript(scriptContent, codesysExePath, codesysProfileName)
                 success = false;
             }
             else {
-                // If no markers found, fall back to exit code (less reliable)
-                success = exitCode === 0;
-                if (!success) {
-                    // Append the specific CODESYS error if available and no other marker found
+                if (exitCode === 0) {
+                    console.warn("Warning: CODESYS script finished with exit code 0 but no SCRIPT_SUCCESS marker found.");
+                    success = !output.includes(SCRIPT_ERROR_MARKER); // Assume success if exit code 0 and no error marker
+                }
+                else {
+                    success = false;
+                    const exitMsg = exitCode !== null ? `exit code ${exitCode}` : 'signal or unknown reason';
+                    // Prepend error marker if not already present from script/stderr
                     if (!output.includes(SCRIPT_ERROR_MARKER)) {
-                        output += `\nSCRIPT_ERROR: Process exited with non-zero code ${exitCode}. Check CODESYS stderr output above for details.`;
+                        output = `SCRIPT_ERROR: Process exited with ${exitMsg}. Check CODESYS stderr output above for details.\n${output}`;
                     }
                     else {
-                        output += `\nSCRIPT_ERROR: Process exited with non-zero code ${exitCode}.`;
+                        // Potentially add exit code info if not already part of the error marker message
+                        if (!output.includes(`exited with ${exitMsg}`)) {
+                            output += `\n(Process exited with ${exitMsg})`;
+                        }
                     }
-                }
-                else {
-                    // If exit code is 0 but no success marker, treat as potential issue or simple script
-                    console.error("Warning: CODESYS script finished with exit code 0 but no SCRIPT_SUCCESS marker found."); // Log warning to stderr
-                    // Optionally, you could treat this as success or failure depending on requirements
-                    // For now, let's assume success if exit code is 0 and no error marker.
-                    if (!output.includes(SCRIPT_ERROR_MARKER)) {
-                        success = true;
+                    // Handle timeout message addition if necessary (should be added by abort handler)
+                    if (exitCode === null && !output.includes("TIMEOUT:") && !output.includes("Spawn Error:")) {
+                        output += `\nProcess may have been killed externally or timed out without proper exit code reporting.`;
                     }
                 }
             }
         }
         catch (error) {
-            process.stderr.write(`Error executing CODESYS script: ${error}\n`); // Use process.stderr
-            output += `\nSCRIPT_ERROR: Failed to execute script process. ${error.message}`;
+            process.stderr.write(`Error during script execution setup: ${error}\n`); // Catch errors *before* spawn
+            output += `\nSCRIPT_ERROR: Failed to set up script execution process. ${error.message}`;
             success = false;
         }
         finally {
-            // Clean up the temporary file
+            // Cleanup logic remains the same...
             try {
                 yield (0, promises_1.unlink)(tempFilePath);
-                process.stderr.write(`Temporary script deleted: ${tempFilePath}\n`); // Use process.stderr
+                process.stderr.write(`Temporary script deleted: ${tempFilePath}\n`);
             }
             catch (cleanupError) {
-                process.stderr.write(`Failed to delete temporary script file ${tempFilePath}: ${cleanupError}\n`); // Use process.stderr
-                // Don't overwrite the original error if cleanup fails
-                if (success) { // Only add cleanup error if the main process didn't already fail
+                process.stderr.write(`Failed to delete temporary script file ${tempFilePath}: ${cleanupError}\n`);
+                if (success) { // Only add warning if main process didn't already fail
                     output += `\nWARNING: Failed to delete temporary script file ${tempFilePath}. ${cleanupError.message}`;
                 }
             }
         }
-        process.stderr.write(`Final script output received:\n---\n${output}\n---\n`); // Use process.stderr
-        return { success, output }; // Revert return object
+        process.stderr.write(`Final script output received (Success: ${success}):\n---\n${output}\n---\n`);
+        return { success, output };
     });
 }

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@codesys/mcp-toolkit",
-  "version": "1.0.7",
+  "version": "1.0.9",
   "main": "dist/server.js",
   "bin": "./dist/bin.js",
   "scripts": {