@codesys/mcp-toolkit 1.5.7 → 2.0.0-alpha.0

package/dist/sessionManager.js

@@ -1,798 +0,0 @@
-"use strict";
-/**
- * sessionManager.ts
- * Manages a persistent CODESYS session for improved performance
- *
- * This module implements a session management system that allows
- * keeping a CODESYS instance running for multiple operations, rather
- * than starting and stopping CODESYS for each command.
- */
-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.CodesysSessionManager = exports.SessionState = exports.SESSION_EVENTS = void 0;
-const child_process_1 = require("child_process");
-const promises_1 = require("fs/promises");
-const path = __importStar(require("path"));
-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',
-    FAILED: 'session:failed',
-    STOPPED: 'session:stopped',
-    TIMEOUT: 'session:timeout',
-    SCRIPT_COMPLETE: 'script:complete',
-    SCRIPT_ERROR: 'script:error'
-};
-/**
- * Session state constants
- */
-exports.SessionState = {
-    IDLE: 'idle',
-    STARTING: 'starting',
-    RUNNING: 'running',
-    BUSY: 'busy',
-    STOPPING: 'stopping',
-    STOPPED: 'stopped',
-    ERROR: 'error'
-};
-/**
- * Class to manage a persistent CODESYS session
- */
-class CodesysSessionManager extends events_1.EventEmitter {
-    /**
-     * Creates a new CODESYS session manager
-     *
-     * @param codesysExePath Path to CODESYS.exe
-     * @param codesysProfileName CODESYS profile name
-     * @param idleTimeoutMs Optional idle timeout in milliseconds
-     */
-    constructor(codesysExePath, codesysProfileName, idleTimeoutMs = DEFAULT_SESSION_IDLE_TIMEOUT) {
-        super();
-        this.codesysProcess = null;
-        this.sessionState = exports.SessionState.STOPPED;
-        this.idleTimeout = null;
-        this.pendingScripts = new Map();
-        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}`);
-        }
-        this.codesysExePath = codesysExePath;
-        this.codesysProfileName = codesysProfileName;
-        this.idleTimeoutMs = idleTimeoutMs;
-        this.sessionId = (0, uuid_1.v4)();
-        // Set up session directory and files
-        // IMPORTANT: Don't use a subdirectory - Python scripts expect files directly in SESSION_DIR
-        this.sessionDir = SESSION_DIR;
-        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`);
-            this.sessionState = exports.SessionState.RUNNING;
-            this.resetIdleTimeout();
-        });
-        this.on(exports.SESSION_EVENTS.FAILED, (error) => {
-            console.error(`SESSION_MANAGER: Session failed to start: ${error.message}`);
-            this.sessionState = exports.SessionState.ERROR;
-        });
-        this.on(exports.SESSION_EVENTS.STOPPED, () => {
-            console.error(`SESSION_MANAGER: Session stopped`);
-            this.sessionState = exports.SessionState.STOPPED;
-        });
-        this.on(exports.SESSION_EVENTS.TIMEOUT, () => {
-            console.error(`SESSION_MANAGER: Session timed out due to inactivity`);
-            this.stopSession();
-        });
-    }
-    /**
-     * Get current session state
-     */
-    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
-     */
-    startSession() {
-        return __awaiter(this, void 0, void 0, function* () {
-            if (this.sessionState !== exports.SessionState.STOPPED && this.sessionState !== exports.SessionState.ERROR) {
-                console.error(`SESSION_MANAGER: Cannot start session - already in state: ${this.sessionState}`);
-                return Promise.resolve(); // Session already running
-            }
-            this.sessionState = exports.SessionState.STARTING;
-            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 {
-                    // 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;
-                        }
-                    }
-                    // Wait a bit before checking again
-                    yield new Promise(resolve => setTimeout(resolve, DEFAULT_SESSION_POLL_INTERVAL));
-                }
-                catch (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;
-        });
-    }
-    /**
-     * Stop the CODESYS session
-     */
-    stopSession() {
-        return __awaiter(this, void 0, void 0, function* () {
-            if (this.sessionState === exports.SessionState.STOPPED) {
-                console.error('SESSION_MANAGER: Session already stopped');
-                return Promise.resolve();
-            }
-            this.sessionState = exports.SessionState.STOPPING;
-            // Clear idle timeout if it exists
-            if (this.idleTimeout) {
-                clearTimeout(this.idleTimeout);
-                this.idleTimeout = null;
-            }
-            // Reject any pending scripts
-            for (const [id, pending] of this.pendingScripts.entries()) {
-                clearTimeout(pending.timeout);
-                pending.reject(new Error('Session was stopped while script was pending'));
-                this.pendingScripts.delete(id);
-            }
-            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
-                    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 files (not entire directory)
-                try {
-                    if (fs.existsSync(this.sessionDir)) {
-                        console.error(`SESSION_MANAGER: Cleaning up session files in: ${this.sessionDir}`);
-                        // Remove only the session-related files, not the entire directory
-                        const filesToRemove = [
-                            this.commandFilePath,
-                            this.resultFilePath,
-                            this.stateFilePath,
-                            this.lockFilePath
-                        ];
-                        for (const filePath of filesToRemove) {
-                            if (fs.existsSync(filePath)) {
-                                fs.unlinkSync(filePath);
-                                console.error(`SESSION_MANAGER: Removed session file: ${filePath}`);
-                            }
-                        }
-                    }
-                }
-                catch (error) {
-                    console.error(`SESSION_MANAGER: Error cleaning up session files: ${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 {
-                    // Delete file
-                    fs.unlinkSync(curPath);
-                }
-            });
-            fs.rmdirSync(dirPath);
-        }
-    }
-    /**
-     * Execute a script in the persistent CODESYS session
-     *
-     * @param scriptContent The Python script to execute
-     * @param timeoutMs Optional timeout for the script execution
-     * @returns Promise with script execution result
-     */
-    executeScript(scriptContent_1) {
-        return __awaiter(this, arguments, void 0, function* (scriptContent, timeoutMs = DEFAULT_SCRIPT_TIMEOUT) {
-            // Generate a unique ID for this script execution
-            const scriptId = (0, uuid_1.v4)();
-            // Make sure we have an active session
-            const isActiveSession = this.sessionState === exports.SessionState.RUNNING ||
-                this.sessionState === exports.SessionState.BUSY;
-            if (!isActiveSession) {
-                if (this.sessionState === exports.SessionState.STARTING) {
-                    // Wait for session to start
-                    console.error('SESSION_MANAGER: Waiting for session to complete starting');
-                    yield new Promise((resolve) => {
-                        const checkInterval = setInterval(() => {
-                            if (this.sessionState === exports.SessionState.RUNNING ||
-                                this.sessionState === exports.SessionState.ERROR ||
-                                this.sessionState === exports.SessionState.STOPPED) {
-                                clearInterval(checkInterval);
-                                resolve();
-                            }
-                        }, 200);
-                    });
-                    const isNowActive = this.sessionState === exports.SessionState.RUNNING ||
-                        this.sessionState === exports.SessionState.BUSY;
-                    if (!isNowActive) {
-                        throw new Error(`Session is in ${this.sessionState} state, not running. Cannot execute script.`);
-                    }
-                }
-                else {
-                    throw new Error(`Session is in ${this.sessionState} state, not running. Cannot execute script.`);
-                }
-            }
-            // Reset idle timeout since we're about to do work
-            this.resetIdleTimeout();
-            // 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}`);
-            }
-            // IMPORTANT: Ensure only one script is executed at a time by checking if other scripts are pending
-            if (this.pendingScripts.size > 0) {
-                console.error(`SESSION_MANAGER: Waiting for ${this.pendingScripts.size} pending scripts to complete before executing new script`);
-                // Wait for all pending scripts to complete
-                yield new Promise((resolve) => {
-                    const checkInterval = setInterval(() => {
-                        if (this.pendingScripts.size === 0) {
-                            clearInterval(checkInterval);
-                            resolve();
-                        }
-                    }, 100);
-                });
-                console.error('SESSION_MANAGER: All pending scripts completed, proceeding with new script execution');
-            }
-            // Mark the session as busy
-            this.sessionState = exports.SessionState.BUSY;
-            // Read current command file to ensure we're not overwriting an in-progress command
-            try {
-                const currentCommandData = JSON.parse(fs.readFileSync(this.commandFilePath, 'utf8'));
-                if (currentCommandData.status === 'pending' || currentCommandData.status === 'processing') {
-                    console.error(`SESSION_MANAGER: Found pending command in file, waiting for it to complete`);
-                    // Wait for the command to complete (status to be 'ready')
-                    yield new Promise((resolve) => {
-                        const checkInterval = setInterval(() => {
-                            try {
-                                const checkData = JSON.parse(fs.readFileSync(this.commandFilePath, 'utf8'));
-                                if (checkData.status === 'ready') {
-                                    clearInterval(checkInterval);
-                                    resolve();
-                                }
-                            }
-                            catch (err) {
-                                // If we can't read the file, just continue
-                                console.error(`SESSION_MANAGER: Error reading command file during wait: ${err}`);
-                            }
-                        }, 100);
-                    });
-                    console.error('SESSION_MANAGER: Previous command completed, proceeding with new command');
-                }
-            }
-            catch (err) {
-                console.error(`SESSION_MANAGER: Error reading current command file: ${err}`);
-                // If we can't read the file, we'll try to proceed anyway
-            }
-            // Return a promise that will be resolved when script execution completes
-            return new Promise((resolve, reject) => __awaiter(this, void 0, void 0, function* () {
-                try {
-                    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) => {
-                            resolve(result);
-                            // Check if we have more pending scripts
-                            if (this.pendingScripts.size === 0) {
-                                this.sessionState = exports.SessionState.RUNNING;
-                            }
-                        },
-                        reject: (error) => {
-                            reject(error);
-                            // Check if we have more pending scripts
-                            if (this.pendingScripts.size === 0) {
-                                this.sessionState = exports.SessionState.RUNNING;
-                            }
-                        },
-                        timeout: scriptTimeout
-                    });
-                    // 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
-                    console.error(`SESSION_MANAGER: Writing command to file ${this.commandFilePath}`);
-                    console.error(`SESSION_MANAGER: Command data: ${JSON.stringify(commandData)}`);
-                    try {
-                        // Write command to file
-                        fs.writeFileSync(this.commandFilePath, JSON.stringify(commandData, null, 2));
-                        console.error(`SESSION_MANAGER: Command written to file`);
-                        // Verify the file was written correctly
-                        try {
-                            const verifyContent = fs.readFileSync(this.commandFilePath, 'utf8');
-                            console.error(`SESSION_MANAGER: Verification - Command file now contains: ${verifyContent.substring(0, 100)}...`);
-                        }
-                        catch (verifyErr) {
-                            console.error(`SESSION_MANAGER: Verification failed - could not read command file: ${verifyErr}`);
-                        }
-                    }
-                    catch (writeErr) {
-                        console.error(`SESSION_MANAGER: ERROR writing command file: ${writeErr}`);
-                        throw writeErr; // Re-throw to propagate the error
-                    }
-                    // Start reading the result file
-                    this.readResultFile(scriptId);
-                }
-                catch (error) {
-                    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}`);
-        // Count polling attempts for logging purposes
-        let pollCount = 0;
-        let lastLogTime = Date.now();
-        // We'll use a polling approach to read from the file
-        const pollInterval = setInterval(() => __awaiter(this, void 0, void 0, function* () {
-            try {
-                pollCount++;
-                const now = Date.now();
-                // Log progress every 5 seconds to show we're still working
-                if (now - lastLogTime > 5000) {
-                    console.error(`SESSION_MANAGER: Still polling for result of script ${scriptId}, attempt ${pollCount}`);
-                    lastLogTime = now;
-                }
-                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)) {
-                    if (pollCount % 50 === 0) { // Log less frequently
-                        console.error(`SESSION_MANAGER: Result file not found at ${this.resultFilePath} (attempt ${pollCount})`);
-                    }
-                    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} after ${pollCount} polls`);
-                            // 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 and forcibly resolve/reject the script after the script timeout
-        setTimeout(() => {
-            console.error(`SESSION_MANAGER: Max polling time reached for script ${scriptId}, cleaning up`);
-            clearInterval(pollInterval);
-            // If the script is still pending, force resolve/reject with timeout error
-            if (this.pendingScripts.has(scriptId)) {
-                const pending = this.pendingScripts.get(scriptId);
-                this.pendingScripts.delete(scriptId);
-                // Create a timeout result
-                const timeoutResult = {
-                    id: scriptId,
-                    success: false,
-                    output: `SCRIPT_ERROR: Script execution timed out after reaching maximum polling time. This typically happens when:\n` +
-                        `1. The script is stuck in an infinite loop\n` +
-                        `2. The script has triggered a deadlock in CODESYS\n` +
-                        `3. A CODESYS dialog or error popup is blocking execution\n` +
-                        `4. The project creation or opening is taking too long\n\n` +
-                        `If this is a project creation script, the project file might still have been created successfully.\n` +
-                        `Check the CODESYS UI to see if a project was created and manually close any dialog boxes.`
-                };
-                // Resolve with the timeout result rather than rejecting
-                // This allows the session to continue operating instead of going into error state
-                console.error(`SESSION_MANAGER: Resolving script ${scriptId} with timeout result`);
-                pending.resolve(timeoutResult);
-            }
-            // Check if we need to update session state
-            if (this.pendingScripts.size === 0) {
-                console.error(`SESSION_MANAGER: No more pending scripts, setting state to RUNNING`);
-                this.sessionState = exports.SessionState.RUNNING;
-            }
-        }, 60000); // 1 minute max polling time
-    }
-    /**
-     * Reset the idle timeout
-     */
-    resetIdleTimeout() {
-        // Clear existing timeout if any
-        if (this.idleTimeout) {
-            clearTimeout(this.idleTimeout);
-            this.idleTimeout = null;
-        }
-        // Set new timeout
-        if (this.idleTimeoutMs > 0) {
-            this.idleTimeout = setTimeout(() => {
-                console.error(`SESSION_MANAGER: Idle timeout (${this.idleTimeoutMs}ms) reached`);
-                this.emit(exports.SESSION_EVENTS.TIMEOUT);
-            }, this.idleTimeoutMs);
-        }
-    }
-}
-exports.CodesysSessionManager = CodesysSessionManager;