@codesys/mcp-toolkit 1.2.1 → 1.3.0

package/dist/sessionManager.js

@@ -58,9 +58,20 @@ const os = __importStar(require("os"));
 const fs = __importStar(require("fs"));
 const events_1 = require("events");
 const uuid_1 = require("uuid");
+const scriptLoader_1 = require("./scriptLoader");
 // Default timeout values
 const DEFAULT_SCRIPT_TIMEOUT = 60000; // 60 seconds
 const DEFAULT_SESSION_IDLE_TIMEOUT = 300000; // 5 minutes
+const DEFAULT_SESSION_POLL_INTERVAL = 1000; // 1 second
+// Session directory and file names
+const SESSION_DIR = path.join(os.tmpdir(), 'codesys_session');
+const COMMAND_FILE = 'command.json';
+const RESULT_FILE = 'result.json';
+const STATE_FILE = 'session_state.json';
+const SESSION_LOCK_FILE = 'session.lock';
+// Define expected success/error markers from the Python scripts
+const SCRIPT_SUCCESS_MARKER = 'SCRIPT_SUCCESS';
+const SCRIPT_ERROR_MARKER = 'SCRIPT_ERROR';
 // Event names
 exports.SESSION_EVENTS = {
     STARTED: 'session:started',
@@ -109,6 +120,13 @@ class CodesysSessionManager extends events_1.EventEmitter {
         this.codesysExePath = codesysExePath;
         this.codesysProfileName = codesysProfileName;
         this.idleTimeoutMs = idleTimeoutMs;
+        this.sessionId = (0, uuid_1.v4)();
+        // Set up session directory and files
+        this.sessionDir = path.join(SESSION_DIR, this.sessionId);
+        this.commandFilePath = path.join(this.sessionDir, COMMAND_FILE);
+        this.resultFilePath = path.join(this.sessionDir, RESULT_FILE);
+        this.stateFilePath = path.join(this.sessionDir, STATE_FILE);
+        this.lockFilePath = path.join(this.sessionDir, SESSION_LOCK_FILE);
         // Log status changes through event emitter
         this.on(exports.SESSION_EVENTS.STARTED, () => {
             console.error(`SESSION_MANAGER: Session started successfully`);
@@ -134,6 +152,70 @@ class CodesysSessionManager extends events_1.EventEmitter {
     getState() {
         return this.sessionState;
     }
+    /**
+     * Get the session directory
+     */
+    getSessionDir() {
+        return this.sessionDir;
+    }
+    /**
+     * Get the session ID
+     */
+    getSessionId() {
+        return this.sessionId;
+    }
+    /**
+     * Check if the session is active
+     * @returns Promise that resolves to true if the session is active
+     */
+    isSessionActive() {
+        return __awaiter(this, void 0, void 0, function* () {
+            try {
+                // If our internal state is not running, return false immediately
+                if (this.sessionState !== exports.SessionState.RUNNING && this.sessionState !== exports.SessionState.BUSY) {
+                    return false;
+                }
+                // Check if session directory exists
+                if (!fs.existsSync(this.sessionDir)) {
+                    return false;
+                }
+                // Check if state file exists
+                if (!fs.existsSync(this.stateFilePath)) {
+                    return false;
+                }
+                // Request status from the running session
+                const statusResult = yield this.executeScript('print("SCRIPT_SUCCESS: Session is active")', 5000);
+                return statusResult.success;
+            }
+            catch (error) {
+                console.error(`SESSION_MANAGER: Error checking session status: ${error}`);
+                return false;
+            }
+        });
+    }
+    /**
+     * Get detailed session information
+     * @returns Promise that resolves to session information
+     */
+    getSessionInfo() {
+        return __awaiter(this, void 0, void 0, function* () {
+            try {
+                // Check if session is active
+                const isActive = yield this.isSessionActive();
+                if (!isActive) {
+                    return null;
+                }
+                // Read the state file
+                const stateContent = yield (0, promises_1.readFile)(this.stateFilePath, 'utf8');
+                const stateData = JSON.parse(stateContent);
+                return stateData;
+            }
+            catch (error) {
+                console.error(`SESSION_MANAGER: Error getting session info: ${error}`);
+                return null;
+            }
+        });
+    }
     /**
      * Start a CODESYS session
      * @returns Promise that resolves when the session is started
@@ -145,55 +227,122 @@ class CodesysSessionManager extends events_1.EventEmitter {
                 return Promise.resolve(); // Session already running
             }
             this.sessionState = exports.SessionState.STARTING;
-            return new Promise((resolve, reject) => {
+            try {
+                console.error(`SESSION_MANAGER: Starting CODESYS session with profile: ${this.codesysProfileName}`);
+                // Create session directory if it doesn't exist
+                if (!fs.existsSync(SESSION_DIR)) {
+                    fs.mkdirSync(SESSION_DIR, { recursive: true });
+                }
+                // Create our specific session directory
+                if (!fs.existsSync(this.sessionDir)) {
+                    fs.mkdirSync(this.sessionDir, { recursive: true });
+                }
+                // Create initial state file
+                const initialState = {
+                    sessionId: this.sessionId,
+                    status: exports.SessionState.STARTING,
+                    startTime: new Date().toISOString()
+                };
+                yield (0, promises_1.writeFile)(this.stateFilePath, JSON.stringify(initialState, null, 2), 'utf8');
+                // Load the start_session script template
+                const scriptTemplate = yield (0, scriptLoader_1.loadScriptTemplate)('start_session');
+                // Interpolate parameters
+                const scriptContent = (0, scriptLoader_1.interpolateScript)(scriptTemplate, {
+                    SESSION_DIR: this.sessionDir,
+                    COMMAND_FILE: COMMAND_FILE,
+                    RESULT_FILE: RESULT_FILE,
+                    STATE_FILE: STATE_FILE,
+                    SESSION_ID: this.sessionId,
+                });
+                // Create a temp file for the script
+                const tempDir = os.tmpdir();
+                const tempFileName = `codesys_start_session_${Date.now()}_${Math.random().toString(36).substring(2, 9)}.py`;
+                const tempFilePath = path.join(tempDir, tempFileName);
+                // Write the script to the temp file
+                yield (0, promises_1.writeFile)(tempFilePath, scriptContent, 'latin1');
+                // Prepare CODESYS process
+                const codesysDir = path.dirname(this.codesysExePath);
+                const quotedExePath = `"${this.codesysExePath}"`;
+                const profileArg = `--profile="${this.codesysProfileName}"`;
+                // Start CODESYS with the session script - in "visible" mode so we can see it's running
+                const fullCommandString = `${quotedExePath} ${profileArg} --runscript="${tempFilePath}"`;
+                // Create a modified environment with CODESYS bin dir in PATH
+                const spawnEnv = Object.assign({}, process.env);
+                const pathSeparator = os.platform() === 'win32' ? ';' : ':';
+                const originalPath = spawnEnv.PATH || '';
+                spawnEnv.PATH = `${codesysDir}${pathSeparator}${originalPath}`;
+                // Spawn the process
+                this.codesysProcess = (0, child_process_1.spawn)(fullCommandString, [], {
+                    windowsHide: false, // Make visible to user
+                    cwd: codesysDir,
+                    env: spawnEnv,
+                    shell: true
+                });
+                // Handle process events
+                this.codesysProcess.on('error', (error) => {
+                    console.error(`SESSION_MANAGER: Error starting CODESYS: ${error.message}`);
+                    this.emit(exports.SESSION_EVENTS.FAILED, error);
+                    this.sessionState = exports.SessionState.ERROR;
+                });
+                this.codesysProcess.on('exit', (code) => {
+                    console.error(`SESSION_MANAGER: CODESYS process exited with code ${code}`);
+                    // Only change state if we're not already stopping
+                    if (this.sessionState !== exports.SessionState.STOPPING && this.sessionState !== exports.SessionState.STOPPED) {
+                        this.sessionState = exports.SessionState.ERROR;
+                        this.emit(exports.SESSION_EVENTS.FAILED, new Error(`CODESYS process exited unexpectedly with code ${code}`));
+                    }
+                });
+                // Wait for session to initialize by checking for the existence of pipes
+                const success = yield this.waitForSessionInitialization();
+                if (success) {
+                    this.sessionState = exports.SessionState.RUNNING;
+                    this.emit(exports.SESSION_EVENTS.STARTED);
+                    this.resetIdleTimeout();
+                }
+                else {
+                    throw new Error('Session failed to initialize within timeout');
+                }
+            }
+            catch (error) {
+                console.error(`SESSION_MANAGER: Error during session start: ${error.message}`);
+                this.sessionState = exports.SessionState.ERROR;
+                this.emit(exports.SESSION_EVENTS.FAILED, error);
+                throw error;
+            }
+        });
+    }
+    /**
+     * Wait for session initialization by checking for the existence of the pipes
+     * @param timeoutMs Timeout in milliseconds
+     * @returns Promise that resolves to true if session initialized successfully
+     */
+    waitForSessionInitialization() {
+        return __awaiter(this, arguments, void 0, function* (timeoutMs = 30000) {
+            const startTime = Date.now();
+            while (Date.now() - startTime < timeoutMs) {
                 try {
-                    console.error(`SESSION_MANAGER: Starting CODESYS session with profile: ${this.codesysProfileName}`);
-                    // Create a keep-alive script that keeps CODESYS running
-                    const keepAliveScript = this.createKeepAliveScript();
-                    // Prepare CODESYS process
-                    const codesysDir = path.dirname(this.codesysExePath);
-                    const quotedExePath = `"${this.codesysExePath}"`;
-                    const profileArg = `--profile="${this.codesysProfileName}"`;
-                    // Start CODESYS with the keep-alive script - in "visible" mode so we can see it's running
-                    const fullCommandString = `${quotedExePath} ${profileArg} --runscript="${keepAliveScript}"`;
-                    // Create a modified environment with CODESYS bin dir in PATH
-                    const spawnEnv = Object.assign({}, process.env);
-                    const pathSeparator = os.platform() === 'win32' ? ';' : ':';
-                    const originalPath = spawnEnv.PATH || '';
-                    spawnEnv.PATH = `${codesysDir}${pathSeparator}${originalPath}`;
-                    // Spawn the process
-                    this.codesysProcess = (0, child_process_1.spawn)(fullCommandString, [], {
-                        windowsHide: false, // Make visible to user
-                        cwd: codesysDir,
-                        env: spawnEnv,
-                        shell: true
-                    });
-                    // Handle process events
-                    this.codesysProcess.on('error', (error) => {
-                        console.error(`SESSION_MANAGER: Error starting CODESYS: ${error.message}`);
-                        this.emit(exports.SESSION_EVENTS.FAILED, error);
-                        reject(error);
-                    });
-                    // Give it a small delay to start properly
-                    setTimeout(() => {
-                        if (this.codesysProcess && !this.codesysProcess.killed) {
-                            this.emit(exports.SESSION_EVENTS.STARTED);
-                            this.resetIdleTimeout();
-                            resolve();
+                    // Check if files exist
+                    const commandFileExists = fs.existsSync(this.commandFilePath);
+                    const resultFileExists = fs.existsSync(this.resultFilePath);
+                    if (commandFileExists && resultFileExists) {
+                        // Read state file to check if session is ready
+                        const stateContent = yield (0, promises_1.readFile)(this.stateFilePath, 'utf8');
+                        const stateData = JSON.parse(stateContent);
+                        if (stateData.status === exports.SessionState.RUNNING) {
+                            console.error(`SESSION_MANAGER: Session initialized successfully`);
+                            return true;
                         }
-                        else {
-                            const error = new Error('CODESYS process failed to start');
-                            this.emit(exports.SESSION_EVENTS.FAILED, error);
-                            reject(error);
-                        }
-                    }, 2000); // 2 second delay to let CODESYS initialize
+                    }
+                    // Wait a bit before checking again
+                    yield new Promise(resolve => setTimeout(resolve, DEFAULT_SESSION_POLL_INTERVAL));
                 }
                 catch (error) {
-                    console.error(`SESSION_MANAGER: Error during session start: ${error.message}`);
-                    this.emit(exports.SESSION_EVENTS.FAILED, error);
-                    reject(error);
+                    console.error(`SESSION_MANAGER: Error checking session initialization: ${error}`);
+                    // Continue waiting
                 }
-            });
+            }
+            console.error(`SESSION_MANAGER: Session initialization timed out after ${timeoutMs}ms`);
+            return false;
         });
     }
     /**
@@ -217,29 +366,123 @@ class CodesysSessionManager extends events_1.EventEmitter {
                 pending.reject(new Error('Session was stopped while script was pending'));
                 this.pendingScripts.delete(id);
             }
-            return new Promise((resolve) => {
+            try {
+                // Check if we have a running session
+                if (fs.existsSync(this.sessionDir) && fs.existsSync(this.commandFilePath)) {
+                    // Load the stop_session script template
+                    const scriptTemplate = yield (0, scriptLoader_1.loadScriptTemplate)('stop_session');
+                    // Interpolate parameters
+                    const scriptContent = (0, scriptLoader_1.interpolateScript)(scriptTemplate, {
+                        SESSION_DIR: this.sessionDir,
+                        COMMAND_FILE: COMMAND_FILE,
+                        RESULT_FILE: RESULT_FILE,
+                        STATE_FILE: STATE_FILE,
+                        SESSION_ID: this.sessionId,
+                    });
+                    try {
+                        // Execute the stop script
+                        const tempDir = os.tmpdir();
+                        const tempFileName = `codesys_stop_session_${Date.now()}_${Math.random().toString(36).substring(2, 9)}.py`;
+                        const tempFilePath = path.join(tempDir, tempFileName);
+                        // Write the script to the temp file
+                        yield (0, promises_1.writeFile)(tempFilePath, scriptContent, 'latin1');
+                        // Prepare CODESYS process
+                        const codesysDir = path.dirname(this.codesysExePath);
+                        const quotedExePath = `"${this.codesysExePath}"`;
+                        const profileArg = `--profile="${this.codesysProfileName}"`;
+                        // Execute the stop script
+                        const fullCommandString = `${quotedExePath} ${profileArg} --noUI --runscript="${tempFilePath}"`;
+                        // Create a modified environment with CODESYS bin dir in PATH
+                        const spawnEnv = Object.assign({}, process.env);
+                        const pathSeparator = os.platform() === 'win32' ? ';' : ':';
+                        const originalPath = spawnEnv.PATH || '';
+                        spawnEnv.PATH = `${codesysDir}${pathSeparator}${originalPath}`;
+                        // Execute the script
+                        console.error('SESSION_MANAGER: Executing stop session script');
+                        const stopProcess = (0, child_process_1.spawn)(fullCommandString, [], {
+                            windowsHide: true,
+                            cwd: codesysDir,
+                            env: spawnEnv,
+                            shell: true
+                        });
+                        yield new Promise((resolve) => {
+                            stopProcess.on('exit', () => {
+                                resolve();
+                            });
+                            // Set a timeout in case the stop script hangs
+                            setTimeout(() => {
+                                resolve();
+                            }, 5000);
+                        });
+                        // Clean up the temp file
+                        try {
+                            yield (0, promises_1.unlink)(tempFilePath);
+                        }
+                        catch (error) {
+                            console.error(`SESSION_MANAGER: Error deleting temp file ${tempFilePath}: ${error}`);
+                        }
+                    }
+                    catch (error) {
+                        console.error(`SESSION_MANAGER: Error executing stop script: ${error}`);
+                    }
+                }
+                // If we have a process, kill it
                 if (this.codesysProcess && !this.codesysProcess.killed) {
                     console.error('SESSION_MANAGER: Stopping CODESYS process');
                     // First try SIGTERM
                     this.codesysProcess.kill('SIGTERM');
                     // Set a timeout to force kill if needed
-                    setTimeout(() => {
-                        if (this.codesysProcess && !this.codesysProcess.killed) {
-                            console.error('SESSION_MANAGER: SIGTERM failed, using SIGKILL');
-                            this.codesysProcess.kill('SIGKILL');
-                        }
-                        this.codesysProcess = null;
-                        this.emit(exports.SESSION_EVENTS.STOPPED);
-                        resolve();
-                    }, 2000); // Give it 2 seconds to terminate gracefully
+                    yield new Promise((resolve) => {
+                        setTimeout(() => {
+                            if (this.codesysProcess && !this.codesysProcess.killed) {
+                                console.error('SESSION_MANAGER: SIGTERM failed, using SIGKILL');
+                                this.codesysProcess.kill('SIGKILL');
+                            }
+                            resolve();
+                        }, 2000); // Give it 2 seconds to terminate gracefully
+                    });
+                }
+                // Clean up session directory
+                try {
+                    if (fs.existsSync(this.sessionDir)) {
+                        console.error(`SESSION_MANAGER: Cleaning up session directory: ${this.sessionDir}`);
+                        // Use recursive: true once we're on Node.js 14+
+                        this.recursiveRemoveDir(this.sessionDir);
+                    }
+                }
+                catch (error) {
+                    console.error(`SESSION_MANAGER: Error cleaning up session directory: ${error}`);
+                }
+                this.codesysProcess = null;
+                this.sessionState = exports.SessionState.STOPPED;
+                this.emit(exports.SESSION_EVENTS.STOPPED);
+            }
+            catch (error) {
+                console.error(`SESSION_MANAGER: Error during session stop: ${error}`);
+                this.sessionState = exports.SessionState.ERROR;
+                this.emit(exports.SESSION_EVENTS.FAILED, error);
+            }
+        });
+    }
+    /**
+     * Recursively remove a directory
+     * @param dirPath Directory path to remove
+     */
+    recursiveRemoveDir(dirPath) {
+        if (fs.existsSync(dirPath)) {
+            fs.readdirSync(dirPath).forEach((file) => {
+                const curPath = path.join(dirPath, file);
+                if (fs.lstatSync(curPath).isDirectory()) {
+                    // Recursive call
+                    this.recursiveRemoveDir(curPath);
                 }
                 else {
-                    this.codesysProcess = null;
-                    this.emit(exports.SESSION_EVENTS.STOPPED);
-                    resolve();
+                    // Delete file
+                    fs.unlinkSync(curPath);
                 }
             });
-        });
+            fs.rmdirSync(dirPath);
+        }
     }
     /**
      * Execute a script in the persistent CODESYS session
@@ -283,31 +526,35 @@ class CodesysSessionManager extends events_1.EventEmitter {
             this.resetIdleTimeout();
             // Mark the session as busy
             this.sessionState = exports.SessionState.BUSY;
+            // Check if the command file exists
+            if (!fs.existsSync(this.commandFilePath)) {
+                this.sessionState = exports.SessionState.ERROR;
+                throw new Error(`Command file not found at ${this.commandFilePath}`);
+            }
+            // Check if the result file exists
+            if (!fs.existsSync(this.resultFilePath)) {
+                this.sessionState = exports.SessionState.ERROR;
+                throw new Error(`Result file not found at ${this.resultFilePath}`);
+            }
             // Return a promise that will be resolved when script execution completes
             return new Promise((resolve, reject) => __awaiter(this, void 0, void 0, function* () {
                 try {
-                    // Create a temp file for the script
-                    const tempDir = os.tmpdir();
-                    const tempFileName = `codesys_script_${Date.now()}_${Math.random().toString(36).substring(2, 9)}.py`;
-                    const tempFilePath = path.join(tempDir, tempFileName);
-                    // Write the script to the temp file
-                    yield (0, promises_1.writeFile)(tempFilePath, scriptContent, 'latin1');
-                    console.error(`SESSION_MANAGER: Script ${scriptId} created at ${tempFilePath}`);
+                    console.error(`SESSION_MANAGER: Executing script ${scriptId}`);
                     // Set up a timeout for this script execution
                     const scriptTimeout = setTimeout(() => {
                         if (this.pendingScripts.has(scriptId)) {
                             const pending = this.pendingScripts.get(scriptId);
                             this.pendingScripts.delete(scriptId);
                             pending.reject(new Error(`Script execution timed out after ${timeoutMs}ms`));
+                            // Check if we have more pending scripts
+                            if (this.pendingScripts.size === 0) {
+                                this.sessionState = exports.SessionState.RUNNING;
+                            }
                         }
                     }, timeoutMs);
                     // Add to pending scripts
                     this.pendingScripts.set(scriptId, {
                         resolve: (result) => {
-                            // Clean up the temp file
-                            (0, promises_1.unlink)(tempFilePath).catch(err => {
-                                console.error(`SESSION_MANAGER: Error deleting temp file ${tempFilePath}: ${err.message}`);
-                            });
                             resolve(result);
                             // Check if we have more pending scripts
                             if (this.pendingScripts.size === 0) {
@@ -315,10 +562,6 @@ class CodesysSessionManager extends events_1.EventEmitter {
                             }
                         },
                         reject: (error) => {
-                            // Clean up the temp file
-                            (0, promises_1.unlink)(tempFilePath).catch(err => {
-                                console.error(`SESSION_MANAGER: Error deleting temp file ${tempFilePath}: ${err.message}`);
-                            });
                             reject(error);
                             // Check if we have more pending scripts
                             if (this.pendingScripts.size === 0) {
@@ -327,33 +570,103 @@ class CodesysSessionManager extends events_1.EventEmitter {
                         },
                         timeout: scriptTimeout
                     });
-                    // TODO: Implement the actual execution of the script in the running CODESYS instance
-                    // For now, we'll just simulate it with a timeout
-                    setTimeout(() => {
-                        if (this.pendingScripts.has(scriptId)) {
-                            const pending = this.pendingScripts.get(scriptId);
-                            clearTimeout(pending.timeout);
-                            this.pendingScripts.delete(scriptId);
-                            // Return a mocked result
-                            const result = {
-                                id: scriptId,
-                                success: true,
-                                output: "SCRIPT_SUCCESS: This is a mock implementation of script execution!"
-                            };
-                            pending.resolve(result);
-                        }
-                    }, 1000); // 1 second delay for mock result
+                    // Create the command to send
+                    const command = {
+                        id: scriptId,
+                        type: "execute_script",
+                        script: scriptContent,
+                        timestamp: Date.now()
+                    };
+                    // Prepare the command data
+                    const commandData = {
+                        status: "pending",
+                        command: command,
+                        timestamp: Date.now()
+                    };
+                    // Send the command by writing to the command file
+                    fs.writeFileSync(this.commandFilePath, JSON.stringify(commandData));
+                    console.error(`SESSION_MANAGER: Command written to file`);
+                    // Start reading the result file
+                    this.readResultFile(scriptId);
                 }
                 catch (error) {
-                    reject(error);
-                    // Check if we have more pending scripts
+                    console.error(`SESSION_MANAGER: Error executing script: ${error.message}`);
+                    // Remove from pending scripts
+                    if (this.pendingScripts.has(scriptId)) {
+                        const pending = this.pendingScripts.get(scriptId);
+                        clearTimeout(pending.timeout);
+                        this.pendingScripts.delete(scriptId);
+                    }
+                    // Update session state if no more pending scripts
                     if (this.pendingScripts.size === 0) {
                         this.sessionState = exports.SessionState.RUNNING;
                     }
+                    reject(error);
                 }
             }));
         });
     }
+    /**
+     * Read the result file for a specific script execution
+     * @param scriptId The script ID to read results for
+     */
+    readResultFile(scriptId) {
+        console.error(`SESSION_MANAGER: Starting to read result file for script ${scriptId}`);
+        // We'll use a polling approach to read from the file
+        const pollInterval = setInterval(() => __awaiter(this, void 0, void 0, function* () {
+            try {
+                if (!this.pendingScripts.has(scriptId)) {
+                    console.error(`SESSION_MANAGER: Script ${scriptId} is no longer pending, stopping poll`);
+                    clearInterval(pollInterval);
+                    return;
+                }
+                // Check if the result file exists
+                if (!fs.existsSync(this.resultFilePath)) {
+                    console.error(`SESSION_MANAGER: Result file not found at ${this.resultFilePath}`);
+                    return;
+                }
+                // Read the result file
+                const resultContent = yield (0, promises_1.readFile)(this.resultFilePath, 'utf8');
+                try {
+                    // Parse the result data
+                    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(`SESSION_MANAGER: Found result for script ${scriptId}`);
+                            // Remove from pending scripts
+                            if (this.pendingScripts.has(scriptId)) {
+                                const pending = this.pendingScripts.get(scriptId);
+                                clearTimeout(pending.timeout);
+                                this.pendingScripts.delete(scriptId);
+                                // Resolve with the result
+                                const scriptResult = {
+                                    id: scriptId,
+                                    success: result.success,
+                                    output: result.output
+                                };
+                                pending.resolve(scriptResult);
+                            }
+                            // Stop polling
+                            clearInterval(pollInterval);
+                            return;
+                        }
+                    }
+                }
+                catch (parseError) {
+                    console.error(`SESSION_MANAGER: Error parsing result data: ${parseError}`);
+                }
+            }
+            catch (error) {
+                console.error(`SESSION_MANAGER: Error reading result file: ${error}`);
+            }
+        }), 100); // Poll every 100ms
+        // Set a timeout to stop polling after the script timeout
+        setTimeout(() => {
+            clearInterval(pollInterval);
+        }, 60000); // 1 minute max polling time
+    }
     /**
      * Reset the idle timeout
      */
@@ -371,31 +684,5 @@ class CodesysSessionManager extends events_1.EventEmitter {
             }, this.idleTimeoutMs);
         }
     }
-    /**
-     * Create a keep-alive script that keeps CODESYS running
-     * This is a placeholder for now - we'll need to implement
-     * a proper mechanism to keep CODESYS running while allowing
-     * additional scripts to be executed
-     */
-    createKeepAliveScript() {
-        // This is a placeholder - we need a real implementation
-        // that keeps CODESYS running and allows for executing other scripts
-        const tempScript = `
-    import time
-    
-    # This is a placeholder keep-alive script
-    # In a real implementation, we would:
-    # 1. Set up a communication channel (named pipe, socket, etc.)
-    # 2. Listen for script execution requests
-    # 3. Execute them and return results
-    
-    print("Keep-alive script running...")
-    
-    # Just keep running for now
-    while True:
-      time.sleep(1)
-    `;
-        return tempScript;
-    }
 }
 exports.CodesysSessionManager = CodesysSessionManager;

package/docs/session_management.md

@@ -1,4 +1,9 @@
-# CODESYS MCP Session Management
+# CODESYS MCP Session Management (Not Yet Implemented)
+
+> **IMPORTANT:** Session management is currently disabled in version 1.2.4. 
+> The `start_session` and `stop_session` commands exist but are non-functional.
+> All operations will run in standard mode (starting and stopping CODESYS for each operation).
+> This feature will be fully implemented in a future release.
 
 ## Overview
 

package/package.json

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