@codesys/mcp-toolkit 1.4.9 → 1.5.1

package/CHANGELOG.md

@@ -5,6 +5,19 @@ All notable changes to this project will be documented in this file.
 The format is based on [Keep a Changelog](https://keepachangelog.com/en/1.0.0/),
 and this project adheres to [Semantic Versioning](https://semver.org/spec/v2.0.0.html).
 
+## [1.5.1] - 2025-05-02
+### Added
+- Implemented direct session command handling for project creation
+- Added ability to communicate directly with active sessions via command.json
+- Created a simplified project creation script optimized for sessions
+- Added fallback to standard execution if direct approach fails
+
+## [1.5.0] - 2025-05-02
+### Changed
+- Temporarily disabled session management for create_project operations to ensure reliability
+- Reverted to direct script execution model for project creation operations
+- Project creation now uses a simpler, more reliable approach that works consistently
+
 ## [1.4.9] - 2025-05-02
 ### Fixed
 - Fixed critical issue with create_project not succeeding in persistent sessions

package/dist/codesys_interop.js

@@ -91,8 +91,8 @@ function executeCodesysScript(scriptContent, codesysExePath, codesysProfileName,
         if (!fs.existsSync(codesysExePath))
             throw new Error(`CODESYS executable not found at provided path: ${codesysExePath}`);
         // --- End Pre-checks ---
-        // Enable or disable session management
-        const SESSION_FEATURE_DISABLED = false; // Session feature enabled
+        // Session management feature control - TEMPORARILY DISABLE FOR DEBUGGING
+        const SESSION_FEATURE_DISABLED = true; // Session feature disabled for now
         // --- Check if we should use the persistent session ---
         if (!SESSION_FEATURE_DISABLED && sessionManager) {
             const sessionState = sessionManager.getState();

package/dist/direct_session_command.js

@@ -0,0 +1,261 @@
+"use strict";
+/**
+ * Direct Session Command Tool
+ *
+ * This file provides functions to directly interact with a CODESYS session
+ * by writing to the command.json file and reading from the result.json file.
+ *
+ * This is an alternative approach to the standard session management.
+ */
+var __createBinding = (this && this.__createBinding) || (Object.create ? (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    var desc = Object.getOwnPropertyDescriptor(m, k);
+    if (!desc || ("get" in desc ? !m.__esModule : desc.writable || desc.configurable)) {
+      desc = { enumerable: true, get: function() { return m[k]; } };
+    }
+    Object.defineProperty(o, k2, desc);
+}) : (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    o[k2] = m[k];
+}));
+var __setModuleDefault = (this && this.__setModuleDefault) || (Object.create ? (function(o, v) {
+    Object.defineProperty(o, "default", { enumerable: true, value: v });
+}) : function(o, v) {
+    o["default"] = v;
+});
+var __importStar = (this && this.__importStar) || (function () {
+    var ownKeys = function(o) {
+        ownKeys = Object.getOwnPropertyNames || function (o) {
+            var ar = [];
+            for (var k in o) if (Object.prototype.hasOwnProperty.call(o, k)) ar[ar.length] = k;
+            return ar;
+        };
+        return ownKeys(o);
+    };
+    return function (mod) {
+        if (mod && mod.__esModule) return mod;
+        var result = {};
+        if (mod != null) for (var k = ownKeys(mod), i = 0; i < k.length; i++) if (k[i] !== "default") __createBinding(result, mod, k[i]);
+        __setModuleDefault(result, mod);
+        return result;
+    };
+})();
+var __awaiter = (this && this.__awaiter) || function (thisArg, _arguments, P, generator) {
+    function adopt(value) { return value instanceof P ? value : new P(function (resolve) { resolve(value); }); }
+    return new (P || (P = Promise))(function (resolve, reject) {
+        function fulfilled(value) { try { step(generator.next(value)); } catch (e) { reject(e); } }
+        function rejected(value) { try { step(generator["throw"](value)); } catch (e) { reject(e); } }
+        function step(result) { result.done ? resolve(result.value) : adopt(result.value).then(fulfilled, rejected); }
+        step((generator = generator.apply(thisArg, _arguments || [])).next());
+    });
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.isSessionActive = isSessionActive;
+exports.executeScriptDirect = executeScriptDirect;
+exports.createProjectDirect = createProjectDirect;
+const fs = __importStar(require("fs"));
+const path = __importStar(require("path"));
+const os = __importStar(require("os"));
+const uuid_1 = require("uuid");
+// Session directory and file names
+const SESSION_DIR = path.join(os.tmpdir(), 'codesys_session');
+const COMMAND_FILE = path.join(SESSION_DIR, 'command.json');
+const RESULT_FILE = path.join(SESSION_DIR, 'result.json');
+const SESSION_LOCK_FILE = path.join(SESSION_DIR, 'session.lock');
+const STATE_FILE = path.join(SESSION_DIR, 'session_state.json');
+/**
+ * Check if a session is active by looking for the lock file
+ * @returns True if a session appears to be active
+ */
+function isSessionActive() {
+    try {
+        // Check if session directory exists
+        if (!fs.existsSync(SESSION_DIR)) {
+            console.error(`SESSION_DIR doesn't exist: ${SESSION_DIR}`);
+            return false;
+        }
+        // Check if lock file exists
+        if (!fs.existsSync(SESSION_LOCK_FILE)) {
+            console.error(`SESSION_LOCK_FILE doesn't exist: ${SESSION_LOCK_FILE}`);
+            return false;
+        }
+        // Check if command file exists
+        if (!fs.existsSync(COMMAND_FILE)) {
+            console.error(`COMMAND_FILE doesn't exist: ${COMMAND_FILE}`);
+            return false;
+        }
+        // Read the lock file to check age
+        const lockFileContent = fs.readFileSync(SESSION_LOCK_FILE, 'utf8');
+        const lockTime = parseFloat(lockFileContent);
+        const currentTime = Date.now() / 1000; // convert to seconds
+        const lockAgeSeconds = currentTime - lockTime;
+        // If lock is too old, session might be dead
+        if (lockAgeSeconds > 30) {
+            console.error(`Session lock file is too old (${lockAgeSeconds.toFixed(1)} seconds)`);
+            return false;
+        }
+        return true;
+    }
+    catch (error) {
+        console.error(`Error checking session: ${error}`);
+        return false;
+    }
+}
+/**
+ * Execute a script by directly writing to the command.json file
+ * @param scriptContent The Python script to execute
+ * @param timeoutMs Timeout in milliseconds
+ * @returns Promise that resolves to the script result
+ */
+function executeScriptDirect(scriptContent_1) {
+    return __awaiter(this, arguments, void 0, function* (scriptContent, timeoutMs = 60000) {
+        if (!isSessionActive()) {
+            throw new Error('No active session found');
+        }
+        // Generate a unique ID for this execution
+        const scriptId = (0, uuid_1.v4)();
+        // Create command data
+        const commandData = {
+            status: "pending",
+            command: {
+                id: scriptId,
+                type: "execute_script",
+                script: scriptContent,
+                timestamp: Date.now()
+            },
+            timestamp: Date.now()
+        };
+        console.error(`DIRECT_SESSION: Writing command to ${COMMAND_FILE}`);
+        // Write command to file
+        fs.writeFileSync(COMMAND_FILE, JSON.stringify(commandData, null, 2));
+        console.error(`DIRECT_SESSION: Command written to file`);
+        // Poll for result
+        return new Promise((resolve, reject) => {
+            let pollCount = 0;
+            const pollInterval = setInterval(() => {
+                pollCount++;
+                try {
+                    // Check if result file exists
+                    if (!fs.existsSync(RESULT_FILE)) {
+                        if (pollCount % 10 === 0) {
+                            console.error(`DIRECT_SESSION: Result file not found at ${RESULT_FILE} (poll ${pollCount})`);
+                        }
+                        return;
+                    }
+                    // Read result file
+                    const resultContent = fs.readFileSync(RESULT_FILE, 'utf8');
+                    try {
+                        const resultData = JSON.parse(resultContent);
+                        // Check if the result is complete and for our script
+                        if (resultData.status === 'complete' && resultData.result) {
+                            const result = resultData.result;
+                            if (result.id === scriptId) {
+                                console.error(`DIRECT_SESSION: Found result for script ${scriptId}`);
+                                // Clear interval
+                                clearInterval(pollInterval);
+                                // Resolve with the result
+                                resolve({
+                                    success: result.success,
+                                    output: result.output
+                                });
+                                return;
+                            }
+                        }
+                    }
+                    catch (parseError) {
+                        console.error(`DIRECT_SESSION: Error parsing result data: ${parseError}`);
+                    }
+                }
+                catch (error) {
+                    console.error(`DIRECT_SESSION: Error reading result file: ${error}`);
+                }
+            }, 100);
+            // Set timeout
+            setTimeout(() => {
+                clearInterval(pollInterval);
+                reject(new Error(`Script execution timed out after ${timeoutMs}ms`));
+            }, timeoutMs);
+        });
+    });
+}
+/**
+ * Create a project using a session
+ * @param targetProjectPath Full path to the project to create
+ * @param templateProjectPath Path to the template project
+ * @returns Promise that resolves when the project is created
+ */
+function createProjectDirect(targetProjectPath, templateProjectPath) {
+    return __awaiter(this, void 0, void 0, function* () {
+        try {
+            if (!isSessionActive()) {
+                throw new Error('No active session found');
+            }
+            // Normalize paths for cross-platform compatibility
+            const normalizedTargetPath = targetProjectPath.replace(/\\/g, '/');
+            const normalizedTemplatePath = templateProjectPath.replace(/\\/g, '/');
+            // Create a simplified project creation script that only copies the file and doesn't try to open it
+            const simpleProjectCreationScript = `
+import sys, os, shutil, time, traceback
+
+TEMPLATE_PROJECT_PATH = '${normalizedTemplatePath}'
+PROJECT_FILE_PATH = '${normalizedTargetPath}'
+
+print("Direct project creation script")
+print("  Template: %s" % TEMPLATE_PROJECT_PATH)
+print("  Target: %s" % PROJECT_FILE_PATH)
+
+try:
+    # Ensure the target directory exists
+    target_dir = os.path.dirname(PROJECT_FILE_PATH)
+    if not os.path.exists(target_dir):
+        print("Creating target directory: %s" % target_dir)
+        os.makedirs(target_dir)
+    
+    # Check if template exists
+    if not os.path.exists(TEMPLATE_PROJECT_PATH):
+        print("ERROR: Template project not found: %s" % TEMPLATE_PROJECT_PATH)
+        print("SCRIPT_ERROR: Template project not found")
+        sys.exit(1)
+    
+    # Copy the template to the target
+    print("Copying template to target...")
+    shutil.copy2(TEMPLATE_PROJECT_PATH, PROJECT_FILE_PATH)
+    
+    # Verify the file was created
+    if os.path.exists(PROJECT_FILE_PATH):
+        print("Project file created successfully: %s" % PROJECT_FILE_PATH)
+        print("File size: %d bytes" % os.path.getsize(PROJECT_FILE_PATH))
+        print("SCRIPT_SUCCESS: Project file created successfully")
+    else:
+        print("ERROR: Failed to create project file")
+        print("SCRIPT_ERROR: Failed to create project file")
+        sys.exit(1)
+except Exception as e:
+    print("ERROR: %s" % e)
+    traceback.print_exc()
+    print("SCRIPT_ERROR: %s" % e)
+    sys.exit(1)
+`;
+            // Execute the script directly
+            const result = yield executeScriptDirect(simpleProjectCreationScript, 120000);
+            if (result.success) {
+                return {
+                    success: true,
+                    message: `Project created successfully at ${targetProjectPath}`
+                };
+            }
+            else {
+                return {
+                    success: false,
+                    message: `Failed to create project: ${result.output}`
+                };
+            }
+        }
+        catch (error) {
+            return {
+                success: false,
+                message: `Error: ${error.message}`
+            };
+        }
+    });
+}

package/dist/server.js

@@ -69,6 +69,7 @@ const promises_1 = require("fs/promises");
 const fs = __importStar(require("fs"));
 const scriptLoader_1 = require("./scriptLoader");
 const sessionManager_1 = require("./sessionManager");
+const direct_session_command_1 = require("./direct_session_command");
 // --- Wrap server logic in an exported function ---
 function startMcpServer(config) {
     return __awaiter(this, void 0, void 0, function* () {
@@ -387,30 +388,42 @@ function startMcpServer(config) {
                     'SKIP_OPEN': inSession ? 'true' : 'false'
                 });
                 console.error(">>> create_project (copy-then-open): PREPARED SCRIPT:", scriptContent.substring(0, 500) + "...");
-                // Use a longer timeout for project creation operations in sessions (120 seconds)
-                // This helps prevent timing out on slower systems or when CODESYS is busy
+                // Try the direct session approach first if a session is active
                 let result;
-                // Check if we're running in a session
-                if (sessionManager &&
-                    (sessionManager.getState() === sessionManager_1.SessionState.RUNNING ||
-                        sessionManager.getState() === sessionManager_1.SessionState.BUSY)) {
-                    console.error(">>> create_project: Using session with extended timeout (120s)");
+                let usingDirectSession = false;
+                // Check if there's an active session using our direct method
+                if ((0, direct_session_command_1.isSessionActive)()) {
+                    console.error(">>> create_project: Detected active session, using direct command approach");
                     try {
-                        // Execute script directly through session manager to specify longer timeout
-                        const scriptResult = yield sessionManager.executeScript(scriptContent, 120000);
-                        result = {
-                            success: scriptResult.success,
-                            output: scriptResult.output
-                        };
+                        // Use our direct session command approach
+                        usingDirectSession = true;
+                        const directResult = yield (0, direct_session_command_1.createProjectDirect)(normalizedTargetPath, normalizedTemplatePath);
+                        if (directResult.success) {
+                            // Format the result to match the expected format
+                            result = {
+                                success: true,
+                                output: `SCRIPT_SUCCESS: Project created from template using direct session command.\n${directResult.message}`
+                            };
+                            console.error(">>> create_project: Direct session command succeeded");
+                        }
+                        else {
+                            console.error(`>>> create_project: Direct session command failed: ${directResult.message}`);
+                            // Fall back to regular script execution
+                            usingDirectSession = false;
+                            result = yield (0, codesys_interop_1.executeCodesysScript)(scriptContent, codesysExePath, codesysProfileName);
+                        }
                     }
-                    catch (sessionError) {
-                        console.error(`>>> create_project: Session execution failed, falling back to one-time execution: ${sessionError.message}`);
-                        // Fall back to one-time execution
+                    catch (directError) {
+                        console.error(`>>> create_project: Error with direct session command: ${directError.message}`);
+                        // Fall back to regular script execution
+                        usingDirectSession = false;
                         result = yield (0, codesys_interop_1.executeCodesysScript)(scriptContent, codesysExePath, codesysProfileName);
                     }
                 }
-                else {
-                    // Standard execution without a session
+                // If not using direct session, use the standard approach
+                if (!usingDirectSession) {
+                    // Use a longer timeout for project creation operations (120 seconds)
+                    console.error(">>> create_project: Using standard script execution");
                     result = yield (0, codesys_interop_1.executeCodesysScript)(scriptContent, codesysExePath, codesysProfileName, sessionManager);
                 }
                 console.error(">>> create_project (copy-then-open): EXECUTION RESULT:", JSON.stringify(result));

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@codesys/mcp-toolkit",
-  "version": "1.4.9",
+  "version": "1.5.1",
   "description": "Model Context Protocol (MCP) server for CODESYS automation platform",
   "main": "dist/server.js",
   "bin": {