@codesys/mcp-toolkit 1.0.6 → 1.0.8

package/direct-codesys-mcp.js

@@ -0,0 +1,150 @@
+#!/usr/bin/env node
+const { exec } = require('child_process');
+const path = require('path');
+const fs = require('fs');
+const os = require('os');
+const { McpServer } = require('@modelcontextprotocol/sdk/server/mcp.js');
+const { StdioServerTransport } = require('@modelcontextprotocol/sdk/server/stdio.js');
+const { z } = require('zod');
+
+console.error("Starting standalone CODESYS MCP server...");
+
+// Create a simple MCP server
+const server = new McpServer({
+  name: "Standalone CODESYS MCP Server",
+  version: "1.0.0",
+  capabilities: { resources: {}, tools: {} }
+});
+
+// Direct implementation of executeCodesysScript
+async function executeCodesysScript(scriptContent, codesysExePath, codesysProfileName) {
+  // Validate inputs
+  if (!codesysExePath) throw new Error('CODESYS executable path was not provided');
+  if (!codesysProfileName) throw new Error('CODESYS profile name was not provided');
+  
+  console.error(`DIRECT: Using CODESYS Path: ${codesysExePath}`);
+  console.error(`DIRECT: Using CODESYS Profile: ${codesysProfileName}`);
+  
+  // Create temp script file
+  const tempDir = os.tmpdir();
+  const tempFileName = `codesys_script_${Date.now()}_${Math.random().toString(36).slice(2, 9)}.py`;
+  const tempFilePath = path.join(tempDir, tempFileName);
+  
+  let output = '';
+  let success = false;
+  
+  try {
+    // Write script to temp file
+    fs.writeFileSync(tempFilePath, scriptContent, 'latin1');
+    console.error(`DIRECT: Wrote script to: ${tempFilePath}`);
+    
+    // Build command with proper quoting
+    const commandWithArgs = `"${codesysExePath}" --profile="${codesysProfileName}" --noUI --runscript="${tempFilePath}"`;
+    console.error(`DIRECT: Command: ${commandWithArgs}`);
+    
+    // Execute using exec
+    success = await new Promise((resolve) => {
+      exec(commandWithArgs, (error, stdout, stderr) => {
+        if (stdout) output += stdout;
+        if (stderr) output += stderr;
+        
+        console.error(`DIRECT: stdout: ${stdout.slice(0, 200)}${stdout.length > 200 ? '...' : ''}`);
+        if (stderr) console.error(`DIRECT: stderr: ${stderr}`);
+        
+        if (error) {
+          console.error(`DIRECT: Error: ${error.message}`);
+          resolve(false);
+        } else {
+          resolve(true);
+        }
+      });
+    });
+    
+    // Check for success/error markers in output
+    if (output.includes('SCRIPT_SUCCESS')) {
+      success = true;
+    } else if (output.includes('SCRIPT_ERROR')) {
+      success = false;
+    }
+    
+  } catch (err) {
+    console.error(`DIRECT: Exception: ${err.message}`);
+    output += `\nError: ${err.message}`;
+    success = false;
+  } finally {
+    // Clean up temp file
+    try {
+      fs.unlinkSync(tempFilePath);
+      console.error(`DIRECT: Deleted temp file: ${tempFilePath}`);
+    } catch (err) {
+      console.error(`DIRECT: Failed to delete temp file: ${err.message}`);
+    }
+  }
+  
+  return { success, output };
+}
+
+// Implement a basic check_status tool
+server.tool("check_status", {}, async () => {
+  try {
+    const codesysPath = process.argv[2] || "C:\\Program Files\\CODESYS 3.5.21.0\\CODESYS\\Common\\CODESYS.exe";
+    const profileName = process.argv[3] || "CODESYS V3.5 SP21";
+    
+    console.error(`DIRECT: Check Status with ${codesysPath} and ${profileName}`);
+    
+    const scriptContent = `
+import sys, scriptengine as script_engine, os
+try:
+    print("Python script running")
+    print("Checking CODESYS status...")
+    scripting_ok = True
+    primary_project = script_engine.projects.primary
+    print("Primary project: " + str(primary_project))
+    print("SCRIPT_SUCCESS: Status check completed")
+    sys.exit(0)
+except Exception as e:
+    print("Error: " + str(e))
+    print("SCRIPT_ERROR: " + str(e))
+    sys.exit(1)
+`;
+    
+    const result = await executeCodesysScript(scriptContent, codesysPath, profileName);
+    return { 
+      content: [{ type: "text", text: `Status check ${result.success ? 'succeeded' : 'failed'}.\nOutput:\n${result.output}` }], 
+      isError: !result.success 
+    };
+  } catch (err) {
+    console.error(`DIRECT: Tool error: ${err.message}`);
+    return { content: [{ type: "text", text: `Error: ${err.message}` }], isError: true };
+  }
+});
+
+// Start the server
+async function startServer() {
+  try {
+    const transport = new StdioServerTransport();
+    console.error("DIRECT: Connecting server via stdio...");
+    await server.connect(transport);
+    console.error("DIRECT: Server connected and listening");
+  } catch (error) {
+    console.error("DIRECT: Failed to start server:", error);
+    process.exit(1);
+  }
+}
+
+// Show args
+console.error(`DIRECT: Args: ${JSON.stringify(process.argv)}`);
+
+// Start the server
+startServer();
+
+// Handle shutdown
+process.on('SIGINT', () => {
+  console.error('\nDIRECT: SIGINT received, shutting down...');
+  process.exit(0);
+});
+
+process.on('SIGTERM', () => {
+  console.error('\nDIRECT: SIGTERM received, shutting down...');
+  process.exit(0);
+});

package/dist/bin.js

@@ -18,13 +18,22 @@ commander_1.program
     .option('-p, --codesys-profile <profile>', 'CODESYS profile name', 'CODESYS V3.5 SP21')
     .parse(process.argv);
 const options = commander_1.program.opts();
-// Log startup message for debugging
+// Enhanced logging for debugging purposes
+console.error(`========================================`);
 console.error(`Starting CODESYS MCP Server v${version}`);
-console.error(`Using CODESYS path: ${options.codesysPath}`);
-console.error(`Using CODESYS profile: ${options.codesysProfile}`);
-// Pass command line arguments to the CODESYS executable path and profile
+console.error(`CODESYS path: ${options.codesysPath}`);
+console.error(`CODESYS profile: ${options.codesysProfile}`);
+console.error(`Using Node.js ${process.version}`);
+console.error(`Current directory: ${process.cwd()}`);
+console.error(`========================================`);
+// Pass properly sanitized command line arguments
+const codesysPath = options.codesysPath.trim();
+const codesysProfile = options.codesysProfile.trim();
 // The server.js file expects these as positional parameters
-process.argv[2] = options.codesysPath;
-process.argv[3] = options.codesysProfile;
+process.argv[2] = codesysPath;
+process.argv[3] = codesysProfile;
+// Also set them as environment variables as a backup mechanism
+process.env.CODESYS_PATH = codesysPath;
+process.env.CODESYS_PROFILE = codesysProfile;
 // Import and start the server
 import('./server.js');

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"); // Use spawn directly
 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.
+ * Uses spawn for better handling of paths with spaces.
  *
  * @param scriptContent The Python script code to execute.
  * @param codesysExePath The full path to the CODESYS.exe executable.
@@ -69,58 +70,95 @@ function executeCodesysScript(scriptContent, codesysExePath, codesysProfileName)
         }
         // Create a temporary file for the script
         const tempDir = os.tmpdir();
-        const tempFileName = `codesys_script_${Date.now()}_${Math.random().toString(36).substring(7)}.py`;
+        // Ensure temp file name is safe for command line (though spawn handles args better)
+        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
-            // Use exec instead of spawn - more reliable for command line processing
-            const exitCode = yield new Promise((resolve, reject) => {
-                const timeoutMs = 30000; // 30 seconds
-                let timeoutHandle = null;
-                // Start the command using exec
-                const childProcess = (0, child_process_1.exec)(commandWithArgs, (error, stdout, stderr) => {
+            yield (0, promises_1.writeFile)(tempFilePath, normalizedScriptContent, 'latin1');
+            process.stderr.write(`Temporary script written to: ${tempFilePath} with latin1 encoding and LF line endings\n`);
+            // --- Use spawn ---
+            const command = codesysExePath; // The executable itself
+            const args = [
+                `--profile=${codesysProfileName}`, // Format expected by CODESYS.exe
+                '--noUI',
+                `--runscript=${tempFilePath}` // Format expected by CODESYS.exe
+                // If CODESYS requires quotes *around* the profile/script path *value*, adjust like:
+                // `--profile="${codesysProfileName}"`,
+                // `--runscript="${tempFilePath}"`,
+                // But usually, spawn handles the argument separation correctly without needing inner quotes unless the *program itself* requires them.
+                // Test without inner quotes first.
+            ];
+            process.stderr.write(`Spawning: ${command} with args: ${JSON.stringify(args)}\n`);
+            const spawnResult = yield new Promise((resolve, reject) => {
+                let stdoutData = '';
+                let stderrData = '';
+                // Spawn the process. Detached:false is default. Timeout via AbortController recommended for spawn.
+                const controller = new AbortController();
+                const timeoutSignal = controller.signal;
+                const timeoutDuration = 30000; // 30 seconds
+                const childProcess = (0, child_process_1.spawn)(command, args, {
+                    windowsHide: true, // Hides the console window on Windows
+                    signal: timeoutSignal // Use AbortSignal for timeout
+                });
+                const timeoutId = setTimeout(() => {
+                    process.stderr.write(`TIMEOUT: CODESYS process timed out after ${timeoutDuration / 1000} seconds\n`);
+                    controller.abort(); // Abort the process via the signal
+                }, 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) => {
+                    const chunk = data.toString();
+                    stderrData += chunk;
+                    process.stderr.write(`CODESYS stderr chunk: ${chunk}\n`); // Log stderr more verbosely
+                });
+                childProcess.on('error', (error) => {
                     var _a;
-                    if (timeoutHandle)
-                        clearTimeout(timeoutHandle);
-                    // Save all output
-                    if (stdout)
-                        output += stdout;
-                    if (stderr) {
-                        process.stderr.write(`CODESYS stderr: ${stderr}\n`);
-                        output += stderr;
-                    }
-                    if (error) {
-                        // Command failed
-                        process.stderr.write(`CODESYS process error: ${error.message}\n`);
-                        resolve((_a = error.code) !== null && _a !== void 0 ? _a : 1); // Return error code
-                    }
-                    else {
-                        // Command succeeded
-                        resolve(0);
-                    }
+                    clearTimeout(timeoutId); // Clear timeout on explicit error
+                    // This usually means the process couldn't be spawned (e.g., EACCES, ENOENT)
+                    process.stderr.write(`CODESYS spawn error: ${error.message}\n`);
+                    // Don't reject here, resolve with error info like exec did
+                    resolve({ code: (_a = error.errno) !== null && _a !== void 0 ? _a : 1, output: stdoutData + stderrData + `\nSpawn Error: ${error.message}` });
+                });
+                childProcess.on('close', (code) => {
+                    clearTimeout(timeoutId); // Clear timeout on successful close
+                    process.stderr.write(`CODESYS process closed with code: ${code}\n`);
+                    const combinedOutput = stdoutData + stderrData;
+                    resolve({ code: code, output: combinedOutput });
                 });
-                // Set a timeout
-                timeoutHandle = setTimeout(() => {
-                    process.stderr.write(`TIMEOUT: CODESYS process did not complete in ${timeoutMs}ms\n`);
-                    childProcess.kill();
-                    resolve(0); // Continue processing with what we have
-                }, timeoutMs);
+                // Handle the timeout signal specifically
+                timeoutSignal.addEventListener('abort', () => {
+                    process.stderr.write('Abort signal received, killing process if still running.\n');
+                    if (!childProcess.killed) {
+                        childProcess.kill('SIGTERM'); // Attempt graceful kill first
+                        // Optionally force kill after a short delay if SIGTERM doesn't work
+                        setTimeout(() => {
+                            if (!childProcess.killed) {
+                                process.stderr.write('SIGTERM ineffective, sending SIGKILL.\n');
+                                childProcess.kill('SIGKILL');
+                            }
+                        }, 2000); // 2 second grace period
+                    }
+                    // Resolve with timeout information. The 'close' event might still fire later with a specific code.
+                    // We already logged the timeout, let the 'close' handler report the final code.
+                    // If 'close' doesn't fire after kill, it might indicate a deeper issue.
+                    // We could resolve here with a timeout indicator, but letting 'close' handle it is cleaner if it works.
+                    // If 'close' never fires after abort/kill, the promise might hang. Let's add a failsafe resolve in the listener.
+                    // Revised: Resolve directly on abort to ensure promise completion.
+                    resolve({ code: null, output: stdoutData + stderrData + "\nTIMEOUT: CODESYS process aborted due to timeout." });
+                }, { once: true }); // Ensure listener is called only once
             });
-            process.stderr.write(`CODESYS process exited with code: ${exitCode}\n`); // Use process.stderr
+            output = spawnResult.output;
+            exitCode = spawnResult.code; // Can be null if process killed before exit code retrieved
             // 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.
             if (output.includes(SCRIPT_SUCCESS_MARKER)) {
                 success = true;
             }
@@ -128,48 +166,50 @@ 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
+                // Fallback logic (handle null exit code)
+                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';
                     if (!output.includes(SCRIPT_ERROR_MARKER)) {
-                        output += `\nSCRIPT_ERROR: Process exited with non-zero code ${exitCode}. Check CODESYS stderr output above for details.`;
+                        output += `\nSCRIPT_ERROR: Process exited with ${exitMsg}. Check CODESYS stderr output above for details.`;
                     }
                     else {
-                        output += `\nSCRIPT_ERROR: Process exited with non-zero code ${exitCode}.`;
+                        output += `\nSCRIPT_ERROR: 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;
+                    // Add timeout message specifically if that was the cause
+                    if (output.includes("TIMEOUT: CODESYS process aborted")) {
+                        // Message already added by the abort handler
+                    }
+                    else if (exitCode === null && !output.includes("Spawn Error:")) {
+                        // If exit code is null but not due to spawn error or handled timeout, add generic killed message
+                        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 executing CODESYS script: ${error}\n`);
+            output += `\nSCRIPT_ERROR: Failed to set up script execution process. ${error.message}`;
             success = false;
         }
         finally {
             // Clean up the temporary file
             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) {
                     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 };
     });
 }