@codesys/mcp-toolkit 1.0.9 → 1.1.0

package/dist/codesys_interop.js

@@ -1,4 +1,16 @@
 "use strict";
+/**
+ * CODESYS Interop Module
+ * Handles direct interaction with the CODESYS executable via command-line scripts.
+ *
+ * This module manages:
+ * - Creating temporary Python script files
+ * - Executing them via CODESYS's scripting engine
+ * - Capturing and processing results
+ *
+ * IMPORTANT: Path handling for Windows is critical - paths with spaces require
+ * special handling to avoid the 'C:\Program' not recognized error.
+ */
 var __createBinding = (this && this.__createBinding) || (Object.create ? (function(o, m, k, k2) {
     if (k2 === undefined) k2 = k;
     var desc = Object.getOwnPropertyDescriptor(m, k);
@@ -43,152 +55,181 @@ 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"); // Still using spawn
+const child_process_1 = require("child_process"); // Use spawn directly
 const promises_1 = require("fs/promises");
 const path = __importStar(require("path"));
 const os = __importStar(require("os"));
+const fs = __importStar(require("fs")); // Import fs for existsSync check
 // Define expected success/error markers from the Python scripts
 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.
+ * @param codesysExePath The full path to the CODESYS.exe executable (can contain spaces).
  * @param codesysProfileName The name of the CODESYS profile to use for scripting.
  * @returns A promise resolving to an object containing the success status and the script's output.
+ *
+ * NOTE: This function uses spawn WITHOUT shell:true for robustness with Windows paths containing spaces.
+ * The approach uses modified environment variables and working directory to ensure proper execution.
  */
 function executeCodesysScript(scriptContent, codesysExePath, codesysProfileName) {
     return __awaiter(this, void 0, void 0, 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.');
-        }
+        // --- Pre-checks ---
+        if (!codesysExePath)
+            throw new Error('CODESYS executable path was not provided.');
+        if (!codesysProfileName)
+            throw new Error('CODESYS profile name was not provided.');
+        if (!fs.existsSync(codesysExePath))
+            throw new Error(`CODESYS executable not found at provided path: ${codesysExePath}`);
+        // --- End Pre-checks ---
         const tempDir = os.tmpdir();
         const tempFileName = `codesys_script_${Date.now()}_${Math.random().toString(36).substring(2, 9)}.py`;
         const tempFilePath = path.join(tempDir, tempFileName);
         let output = '';
+        let stderrOutput = '';
         let success = false;
         let exitCode = null;
+        const codesysDir = path.dirname(codesysExePath); // Directory containing CODESYS.exe
         try {
             const normalizedScriptContent = scriptContent.replace(/\r\n/g, '\n');
             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
+            process.stderr.write(`INTEROP: Temp script written: ${tempFilePath}\n`);
+            // --- Use spawn arguments array ---
+            const command = codesysExePath;
+            const args = [
+                `--profile=${codesysProfileName}`, // Format expected by CODESYS.exe
+                // Use = for profile? Or quotes? Check CODESYS docs. Assume '=' for now.
+                // If CODESYS needs quotes around the value *itself*: `--profile="${codesysProfileName}"`
+                '--noUI',
+                `--runscript=${tempFilePath}`
+                // If CODESYS needs quotes around the value *itself*: `--runscript="${tempFilePath}"`
+            ];
+            // --- End spawn arguments ---
+            process.stderr.write(`INTEROP: Spawning command: ${command}\n`);
+            process.stderr.write(`INTEROP: Spawning args: ${JSON.stringify(args)}\n`);
+            process.stderr.write(`INTEROP ENV: CWD before spawn: ${process.cwd()}\n`);
+            process.stderr.write(`INTEROP ENV: Forcing CWD for spawn: ${codesysDir}\n`);
+            // --- Create modified environment ---
+            const spawnEnv = Object.assign({}, process.env);
+            const pathSeparator = ';'; // Windows
+            const originalPath = spawnEnv.PATH || '';
+            spawnEnv.PATH = `${codesysDir}${pathSeparator}${originalPath}`;
+            process.stderr.write(`INTEROP ENV: MODIFIED PATH for spawn (prepended): ${spawnEnv.PATH.substring(0, 100)}...\n`);
+            // --- End modified environment ---
             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 timeoutDuration = 60000; // 60 seconds
+                const childProcess = (0, child_process_1.spawn)(command, args, {
+                    windowsHide: true,
+                    signal: timeoutSignal,
+                    cwd: codesysDir, // Force CWD
+                    env: spawnEnv, // Pass modified environment
+                    shell: false // <<< Ensure shell is false or omitted (default)
                 });
-                const timeoutId = setTimeout(() => {
-                    process.stderr.write(`TIMEOUT: CODESYS process timed out after ${timeoutDuration / 1000} seconds\n`);
-                    controller.abort();
-                }, timeoutDuration);
+                const timeoutId = setTimeout(() => { }, timeoutDuration);
+                // --- Event Listeners (stdout, stderr, error, close, abort) ---
+                // (Keep the event listener logic the same as the previous version)
                 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`);
+                    process.stderr.write(`INTEROP stdout chunk: ${chunk.length > 50 ? chunk.substring(0, 50) + '...' : 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
+                    if (chunk.includes('C:\\Program')) {
+                        process.stderr.write(`>>>> INTEROP STDERR DETECTED 'C:\\Program': ${chunk}\n`);
+                    }
+                    else {
+                        process.stderr.write(`INTEROP stderr chunk: ${chunk}\n`);
+                    }
                 });
-                childProcess.on('error', (error) => {
+                childProcess.on('error', (spawnError) => {
                     var _a;
                     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}` });
+                    process.stderr.write(`INTEROP SPAWN ERROR (shell:false): ${spawnError.message}\n`);
+                    resolve({ code: (_a = spawnError.errno) !== null && _a !== void 0 ? _a : 1, stdout: stdoutData, stderr: stderrData, error: spawnError });
                 });
                 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 });
+                    process.stderr.write(`INTEROP: Process closed code: ${code}\n`);
+                    resolve({ code: code, stdout: stdoutData, stderr: stderrData });
                 });
                 timeoutSignal.addEventListener('abort', () => {
-                    process.stderr.write('Abort signal received, killing process if still running.\n');
-                    // Kill logic remains the same
+                    process.stderr.write('INTEROP: Abort signal received, killing process.\n');
                     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." });
+                    resolve({ code: null, stdout: stdoutData, stderr: stderrData + "\nTIMEOUT: Process aborted due to timeout." });
                 }, { once: true });
+                // --- End Event Listeners ---
             });
-            output = spawnResult.output;
+            output = spawnResult.stdout;
+            stderrOutput = spawnResult.stderr;
             exitCode = spawnResult.code;
-            // Success determination logic remains the same...
-            // [...]
-            if (output.includes(SCRIPT_SUCCESS_MARKER)) {
-                success = true;
+            // success determination logic
+            if (stderrOutput.includes("'C:\\Program' is not recognized")) {
+                success = false;
+                process.stderr.write("INTEROP: Failure determined by 'C:\\Program' error in stderr.\n");
+                if (!stderrOutput.includes(SCRIPT_ERROR_MARKER))
+                    stderrOutput = `SCRIPT_ERROR: ${stderrOutput}`;
             }
-            else if (output.includes(SCRIPT_ERROR_MARKER)) {
+            else if (spawnResult.error) {
                 success = false;
+                process.stderr.write(`INTEROP: Failure determined by spawn error: ${spawnResult.error.message}\n`);
+                if (!stderrOutput.includes(SCRIPT_ERROR_MARKER))
+                    stderrOutput = `SCRIPT_ERROR: Spawn failed: ${spawnResult.error.message}\n${stderrOutput}`;
             }
             else {
-                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
+                process.stderr.write(`INTEROP: Checking markers/exit code (Code: ${exitCode})...\n`);
+                if (output.includes(SCRIPT_SUCCESS_MARKER) || stderrOutput.includes(SCRIPT_SUCCESS_MARKER)) {
+                    success = true;
+                    process.stderr.write("INTEROP: Success determined by SUCCESS marker.\n");
                 }
-                else {
+                else if (output.includes(SCRIPT_ERROR_MARKER) || stderrOutput.includes(SCRIPT_ERROR_MARKER)) {
                     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 = `SCRIPT_ERROR: Process exited with ${exitMsg}. Check CODESYS stderr output above for details.\n${output}`;
-                    }
+                    process.stderr.write("INTEROP: Failure determined by ERROR marker.\n");
+                }
+                else {
+                    success = exitCode === 0;
+                    if (success)
+                        process.stderr.write(`INTEROP: Success determined by exit code 0 (no markers found).\n`);
                     else {
-                        // 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})`;
-                        }
-                    }
-                    // 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.`;
+                        process.stderr.write(`INTEROP: Failure determined by non-zero exit code ${exitCode} (no markers found).\n`);
+                        if (!stderrOutput.includes(SCRIPT_ERROR_MARKER))
+                            stderrOutput = `SCRIPT_ERROR: Process failed with exit code ${exitCode} (no markers found).\n${stderrOutput}`;
                     }
                 }
             }
+            // --- End Success Determination ---
         }
         catch (error) {
-            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}`;
+            process.stderr.write(`INTEROP: Error during setup: ${error.message}\n${error.stack}\n`);
+            stderrOutput = `SCRIPT_ERROR: Failed during script execution setup: ${error.message}`;
             success = false;
         }
         finally {
-            // Cleanup logic remains the same...
+            // Cleanup: Attempt to delete the temporary script file
             try {
                 yield (0, promises_1.unlink)(tempFilePath);
-                process.stderr.write(`Temporary script deleted: ${tempFilePath}\n`);
+                process.stderr.write(`INTEROP: Temp script deleted: ${tempFilePath}\n`);
             }
             catch (cleanupError) {
-                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(`INTEROP: Failed to delete temp file ${tempFilePath}: ${cleanupError.message}\n`);
+                if (success)
+                    stderrOutput += `\nWARNING: Failed to delete temporary script file ${tempFilePath}. ${cleanupError.message}`;
             }
         }
-        process.stderr.write(`Final script output received (Success: ${success}):\n---\n${output}\n---\n`);
-        return { success, output };
+        // Final output processing
+        const finalOutput = success ? output : `${stderrOutput}\n${output}`.trim();
+        process.stderr.write(`INTEROP: Final Success: ${success}\n`);
+        process.stderr.write(`INTEROP: Final Output Length: ${finalOutput.length}\n---\n`);
+        return { success, output: finalOutput };
     });
 }