codesysultra 1.0.0

package/dist/codesys_interop.js

@@ -0,0 +1,270 @@
+"use strict";
+/**
+ * CODESYS Interop Module
+ * Handles direct interaction with the CODESYS executable via command-line scripts.
+ *
+ * This module manages:
+ * - Creating temporary Python script files
+ * - Executing them via CODESYS's scripting engine
+ * - Capturing and processing results
+ *
+ * IMPORTANT: Path handling for Windows is critical - paths with spaces require
+ * special handling to avoid the 'C:\Program' not recognized error.
+ */
+var __createBinding = (this && this.__createBinding) || (Object.create ? (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    var desc = Object.getOwnPropertyDescriptor(m, k);
+    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.executeCodesysScript = executeCodesysScript;
+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")); // Import fs for existsSync check
+// Define expected success/error markers from the Python scripts
+const SCRIPT_SUCCESS_MARKER = 'SCRIPT_SUCCESS';
+const SCRIPT_ERROR_MARKER = 'SCRIPT_ERROR';
+/**
+ * Executes a CODESYS Python script using the command line interface.
+ *
+ * @param scriptContent The Python script code to execute.
+ * @param codesysExePath The full path to the CODESYS.exe executable (can contain spaces).
+ * @param codesysProfileName The name of the CODESYS profile to use for scripting.
+ * @returns A promise resolving to an object containing the success status and the script's output.
+ *
+ * NOTE: Using shell: true with careful command string quoting to handle
+ * CODESYS argument parsing quirks when launched non-interactively.
+ */
+function executeCodesysScript(scriptContent, codesysExePath, codesysProfileName) {
+    return __awaiter(this, void 0, void 0, function* () {
+        // --- Pre-checks ---
+        if (!codesysExePath)
+            throw new Error('CODESYS executable path was not provided.');
+        if (!codesysProfileName)
+            throw new Error('CODESYS profile name was not provided.');
+        if (!fs.existsSync(codesysExePath))
+            throw new Error(`CODESYS executable not found at provided path: ${codesysExePath}`);
+        // --- End Pre-checks ---
+        const tempDir = os.tmpdir();
+        const tempFileName = `codesys_script_${Date.now()}_${Math.random().toString(36).substring(2, 9)}.py`;
+        const tempFilePath = path.join(tempDir, tempFileName); // Path module uses OS-specific separators ('\' on Windows)
+        let output = '';
+        let stderrOutput = '';
+        let success = false;
+        let exitCode = null;
+        const codesysDir = path.dirname(codesysExePath); // Directory containing CODESYS.exe
+        try {
+            const normalizedScriptContent = scriptContent.replace(/\r\n/g, '\n'); // Normalize line endings
+            // <<< --- ADDED SCRIPT CONTENT LOGGING --- >>>
+            process.stderr.write(`INTEROP: Script content to be written (first 500 chars):\n`);
+            process.stderr.write(`------ START SCRIPT (TEMP FILE) -----\n`);
+            process.stderr.write(`${normalizedScriptContent.substring(0, 500)}\n`); // Log the first 500 chars
+            process.stderr.write(`------ END SCRIPT SNIPPET (TEMP FILE) -----\n`);
+            // <<< --- END SCRIPT CONTENT LOGGING --- >>>
+            yield (0, promises_1.writeFile)(tempFilePath, normalizedScriptContent, 'latin1'); // Write the normalized content
+            process.stderr.write(`INTEROP: Temp script written: ${tempFilePath}\n`);
+            // --- Construct command string for shell: true ---
+            // Quote the executable path itself
+            const quotedExePath = `"${codesysExePath}"`;
+            // Format arguments exactly as CODESYS seems to want: --option="Value With Spaces"
+            // The outer quotes are for the shell parser.
+            const profileArg = `--profile="${codesysProfileName}"`;
+            const scriptArg = `--runscript="${tempFilePath}"`; // tempFilePath from path.join has correct backslashes for Win
+            // Combine into a single string for the shell
+            const fullCommandString = `${quotedExePath} ${profileArg} --noUI ${scriptArg}`;
+            // Example result: "\"C:\\Program Files\\...\\CODESYS.exe\" --profile=\"CODESYS V3.5 SP21\" --noUI --runscript=\"C:\\Users\\...\\script.py\""
+            // --- End command string construction ---
+            process.stderr.write(`INTEROP: Spawning command (shell:true): ${fullCommandString}\n`);
+            process.stderr.write(`INTEROP ENV: CWD before spawn: ${process.cwd()}\n`);
+            process.stderr.write(`INTEROP ENV: Forcing CWD for spawn: ${codesysDir}\n`); // Re-enabled CWD change
+            // --- Create modified environment (Re-enabled) ---
+            const spawnEnv = Object.assign({}, process.env);
+            const pathSeparator = ';'; // Windows
+            const originalPath = spawnEnv.PATH || '';
+            spawnEnv.PATH = `${codesysDir}${pathSeparator}${originalPath}`; // Prepend CODESYS dir to PATH
+            process.stderr.write(`INTEROP ENV: MODIFIED PATH for spawn (prepended): ${spawnEnv.PATH.substring(0, 100)}...\n`); // Re-enabled ENV change
+            // --- End modified environment ---
+            const spawnResult = yield new Promise((resolve) => {
+                let stdoutData = '';
+                let stderrData = '';
+                const controller = new AbortController();
+                const timeoutSignal = controller.signal;
+                const timeoutDuration = 60000; // 60 seconds
+                // Pass the single command string, empty args array, and shell: true
+                const childProcess = (0, child_process_1.spawn)(fullCommandString, [], {
+                    windowsHide: true,
+                    signal: timeoutSignal,
+                    cwd: codesysDir, // Re-enabled CWD change
+                    env: spawnEnv, // Re-enabled ENV change
+                    shell: true // USE shell: true
+                });
+                const timeoutId = setTimeout(() => {
+                    process.stderr.write('INTEROP: Process timeout reached.\n');
+                    controller.abort();
+                }, timeoutDuration);
+                // --- Event Listeners (stdout, stderr, error, close, abort) ---
+                childProcess.stdout.on('data', (data) => {
+                    const chunk = data.toString();
+                    stdoutData += chunk;
+                    process.stderr.write(`INTEROP stdout chunk: ${chunk.length > 50 ? chunk.substring(0, 50) + '...' : chunk}\n`);
+                });
+                childProcess.stderr.on('data', (data) => {
+                    const chunk = data.toString();
+                    stderrData += chunk;
+                    // Check for specific error patterns
+                    if (chunk.includes('--profile="profile name"')) {
+                        process.stderr.write(`>>>> INTEROP STDERR DETECTED Profile Error Message: ${chunk}\n`);
+                    }
+                    else if (chunk.includes('is not recognized')) {
+                        process.stderr.write(`>>>> INTEROP STDERR DETECTED 'not recognized' (shell issue?): ${chunk}\n`);
+                    }
+                    else if (chunk.includes('SyntaxErrorException')) {
+                        process.stderr.write(`>>>> INTEROP STDERR DETECTED Syntax Error: ${chunk}\n`);
+                    } // More specific check
+                    else {
+                        process.stderr.write(`INTEROP stderr chunk: ${chunk}\n`);
+                    }
+                });
+                childProcess.on('error', (spawnError) => {
+                    var _a;
+                    clearTimeout(timeoutId);
+                    process.stderr.write(`INTEROP SPAWN ERROR (shell:true): ${spawnError.message}\n`);
+                    resolve({ code: (_a = spawnError.errno) !== null && _a !== void 0 ? _a : 1, stdout: stdoutData, stderr: stderrData, error: spawnError });
+                });
+                childProcess.on('close', (code) => {
+                    clearTimeout(timeoutId);
+                    process.stderr.write(`INTEROP: Process closed code: ${code}\n`);
+                    resolve({ code: code, stdout: stdoutData, stderr: stderrData });
+                });
+                timeoutSignal.addEventListener('abort', () => {
+                    process.stderr.write('INTEROP: Abort signal received, attempting to kill process.\n');
+                    if (!childProcess.killed) {
+                        if (!childProcess.kill('SIGTERM')) { // Try graceful termination first
+                            process.stderr.write('INTEROP: SIGTERM failed, attempting SIGKILL in 2s.\n');
+                            setTimeout(() => { if (!childProcess.killed)
+                                childProcess.kill('SIGKILL'); }, 2000);
+                        }
+                        else {
+                            process.stderr.write('INTEROP: SIGTERM sent.\n');
+                        }
+                    }
+                    resolve({ code: null, stdout: stdoutData, stderr: stderrData + "\nTIMEOUT: Process aborted due to timeout." });
+                }, { once: true });
+                // --- End Event Listeners ---
+            });
+            output = spawnResult.stdout;
+            stderrOutput = spawnResult.stderr;
+            exitCode = spawnResult.code;
+            // --- Success Determination Logic ---
+            success = false; // Assume failure unless proven otherwise
+            if (spawnResult.error) {
+                process.stderr.write(`INTEROP: Failure determined by spawn error: ${spawnResult.error.message}\n`);
+                if (!stderrOutput.includes(SCRIPT_ERROR_MARKER))
+                    stderrOutput = `SCRIPT_ERROR: Spawn failed: ${spawnResult.error.message}\n${stderrOutput}`;
+            }
+            else if (stderrOutput.includes('is not recognized as an internal or external command')) {
+                process.stderr.write("INTEROP: Failure determined by 'not recognized' error in stderr (shell:true quoting issue likely).\n");
+                if (!stderrOutput.includes(SCRIPT_ERROR_MARKER))
+                    stderrOutput = `SCRIPT_ERROR: Shell execution failed: ${stderrOutput}`;
+            }
+            else if (stderrOutput.includes('--profile="profile name"')) {
+                process.stderr.write("INTEROP: Failure determined by CODESYS profile error message in stderr.\n");
+                if (!stderrOutput.includes(SCRIPT_ERROR_MARKER))
+                    stderrOutput = `SCRIPT_ERROR: ${stderrOutput}`;
+            }
+            else if (stderrOutput.includes('SyntaxErrorException')) { // Check for syntax error specifically
+                process.stderr.write("INTEROP: Failure determined by CODESYS Script Syntax Error.\n");
+                if (!stderrOutput.includes(SCRIPT_ERROR_MARKER))
+                    stderrOutput = `SCRIPT_ERROR: ${stderrOutput}`; // Include the syntax error details
+            }
+            else {
+                // No spawn error, no shell error, no profile error, no syntax error -> check markers/exit code
+                process.stderr.write(`INTEROP: Checking markers/exit code (Code: ${exitCode})...\n`);
+                if (output.includes(SCRIPT_SUCCESS_MARKER) || stderrOutput.includes(SCRIPT_SUCCESS_MARKER)) {
+                    success = true;
+                    process.stderr.write("INTEROP: Success determined by SUCCESS marker.\n");
+                }
+                else if (output.includes(SCRIPT_ERROR_MARKER) || stderrOutput.includes(SCRIPT_ERROR_MARKER)) {
+                    success = false; // Explicit error marker found
+                    process.stderr.write("INTEROP: Failure determined by ERROR marker.\n");
+                }
+                else {
+                    // No markers found, rely solely on exit code
+                    success = exitCode === 0;
+                    if (success) {
+                        process.stderr.write(`INTEROP: Success determined by exit code 0 (no markers found).\n`);
+                    }
+                    else {
+                        process.stderr.write(`INTEROP: Failure determined by non-zero exit code ${exitCode} (no markers found).\n`);
+                        // Add generic failure message if stderr doesn't already contain SCRIPT_ERROR
+                        if (!stderrOutput.includes(SCRIPT_ERROR_MARKER))
+                            stderrOutput = `SCRIPT_ERROR: Process failed with exit code ${exitCode} (no markers found).\n${stderrOutput}`;
+                    }
+                }
+            }
+            // --- End Success Determination ---
+        }
+        catch (error) {
+            process.stderr.write(`INTEROP: Error during setup: ${error.message}\n${error.stack}\n`);
+            stderrOutput = `SCRIPT_ERROR: Failed during script execution setup: ${error.message}`;
+            success = false;
+        }
+        finally {
+            // Cleanup: Attempt to delete the temporary script file
+            try {
+                yield (0, promises_1.unlink)(tempFilePath);
+                process.stderr.write(`INTEROP: Temp script deleted: ${tempFilePath}\n`);
+            }
+            catch (cleanupError) {
+                process.stderr.write(`INTEROP: Failed to delete temp file ${tempFilePath}: ${cleanupError.message}\n`);
+                if (success)
+                    stderrOutput += `\nWARNING: Failed to delete temporary script file ${tempFilePath}. ${cleanupError.message}`;
+            }
+        }
+        // Final output processing
+        // Combine stderr and stdout only on failure to preserve clean success output
+        const finalOutput = success ? output : `${stderrOutput}\n${output}`.trim();
+        process.stderr.write(`INTEROP: Final Success: ${success}\n`);
+        process.stderr.write(`INTEROP: Final Output Length: ${finalOutput.length}\n---\n`);
+        return { success, output: finalOutput };
+    });
+}

package/dist/handlers/resources.js

@@ -0,0 +1,193 @@
+"use strict";
+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.registerResources = registerResources;
+const mcp_js_1 = require("@modelcontextprotocol/sdk/server/mcp.js");
+const codesys_interop_1 = require("../codesys_interop");
+const templates_1 = require("../templates");
+const path = __importStar(require("path"));
+function registerResources(server, config) {
+    const WORKSPACE_DIR = config.workspaceDir;
+    const codesysExePath = config.codesysPath;
+    const codesysProfileName = config.profileName;
+    console.error("HANDLERS: Registering Resources...");
+    // --- Resources ---
+    server.resource("project-status", "codesys://project/status", (uri) => __awaiter(this, void 0, void 0, function* () {
+        var _a, _b, _c, _d, _e;
+        console.error(`SERVER.TS Resource request: ${uri.href}`);
+        try {
+            const result = yield (0, codesys_interop_1.executeCodesysScript)(templates_1.CHECK_STATUS_SCRIPT, codesysExePath, codesysProfileName);
+            const outputLines = result.output.split(/[\r\n]+/).filter(line => line.trim());
+            const statusData = {};
+            outputLines.forEach(line => { const match = line.match(/^([^:]+):\s*(.*)$/); if (match) {
+                statusData[match[1].trim()] = match[2].trim();
+            } });
+            const statusText = `CODESYS Status:\n - Scripting OK: ${(_a = statusData['Scripting OK']) !== null && _a !== void 0 ? _a : 'Unknown'}\n - Project Open: ${(_b = statusData['Project Open']) !== null && _b !== void 0 ? _b : 'Unknown'}\n - Project Name: ${(_c = statusData['Project Name']) !== null && _c !== void 0 ? _c : 'Unknown'}\n - Project Path: ${(_d = statusData['Project Path']) !== null && _d !== void 0 ? _d : 'N/A'}`;
+            const isError = !result.success || ((_e = statusData['Scripting OK']) === null || _e === void 0 ? void 0 : _e.toLowerCase()) !== 'true';
+            // **** RETURN MCP STRUCTURE ****
+            return { contents: [{ uri: uri.href, text: statusText, contentType: "text/plain" }], isError: isError };
+        }
+        catch (error) {
+            console.error(`Error resource ${uri.href}:`, error);
+            // **** RETURN MCP STRUCTURE ****
+            return { contents: [{ uri: uri.href, text: `Failed status script: ${error.message}`, contentType: "text/plain" }], isError: true };
+        }
+    }));
+    // *** DEFINE TEMPLATES ***
+    const projectStructureTemplate = new mcp_js_1.ResourceTemplate("codesys://project/{+project_path}/structure", { list: undefined });
+    const pouCodeTemplate = new mcp_js_1.ResourceTemplate("codesys://project/{+project_path}/pou/{+pou_path}/code", { list: undefined });
+    // *** END DEFINE TEMPLATES ***
+    server.resource("project-structure", projectStructureTemplate, (uri, params) => __awaiter(this, void 0, void 0, function* () {
+        // *** DEFINE VARIABLES (like projectPath) ***
+        const projectPathParam = params.project_path;
+        if (typeof projectPathParam !== 'string') {
+            return { contents: [{ uri: uri.href, text: `Error: Invalid project path type (${typeof projectPathParam}).`, contentType: "text/plain" }], isError: true };
+        }
+        const projectPath = projectPathParam; // Define projectPath
+        if (!projectPath) {
+            return { contents: [{ uri: uri.href, text: "Error: Project path missing.", contentType: "text/plain" }], isError: true };
+        }
+        // *** END DEFINE VARIABLES ***
+        console.error(`Resource request: project structure for ${projectPath}`);
+        try {
+            const absoluteProjPath = path.normalize(path.isAbsolute(projectPath) ? projectPath : path.join(WORKSPACE_DIR, projectPath));
+            const escapedPathForPython = absoluteProjPath.replace(/\\/g, '\\\\');
+            // *** DEFINE scriptContent ***
+            const scriptContent = templates_1.GET_PROJECT_STRUCTURE_SCRIPT_TEMPLATE.replace("{PROJECT_FILE_PATH}", escapedPathForPython);
+            // *** END DEFINE scriptContent ***
+            const result = yield (0, codesys_interop_1.executeCodesysScript)(scriptContent, codesysExePath, codesysProfileName);
+            let structureText = `Error retrieving structure for ${absoluteProjPath}.\n\n${result.output}`;
+            let isError = !result.success;
+            if (result.success && result.output.includes("SCRIPT_SUCCESS")) {
+                const startMarker = "--- PROJECT STRUCTURE START ---";
+                const endMarker = "--- PROJECT STRUCTURE END ---";
+                const startIndex = result.output.indexOf(startMarker);
+                const endIndex = result.output.indexOf(endMarker);
+                if (startIndex !== -1 && endIndex !== -1 && startIndex < endIndex) {
+                    structureText = result.output.substring(startIndex + startMarker.length, endIndex).replace(/\\n/g, '\n').trim();
+                }
+                else {
+                    console.error("Error: Could not find structure markers in script output.");
+                    structureText = `Could not parse structure markers in output for ${absoluteProjPath}.\n\nOutput:\n${result.output}`;
+                    isError = true;
+                }
+            }
+            else {
+                isError = true;
+            }
+            // **** RETURN MCP STRUCTURE ****
+            return { contents: [{ uri: uri.href, text: structureText, contentType: "text/plain" }], isError: isError };
+        }
+        catch (error) {
+            console.error(`Error getting structure ${uri.href}:`, error);
+            // **** RETURN MCP STRUCTURE ****
+            return { contents: [{ uri: uri.href, text: `Failed structure script for '${projectPath}': ${error.message}`, contentType: "text/plain" }], isError: true };
+        }
+    }));
+    server.resource("pou-code", pouCodeTemplate, (uri, params) => __awaiter(this, void 0, void 0, function* () {
+        // *** DEFINE VARIABLES (like projectPath, pouPath) ***
+        const projectPathParam = params.project_path;
+        const pouPathParam = params.pou_path;
+        if (typeof projectPathParam !== 'string' || typeof pouPathParam !== 'string') {
+            return { contents: [{ uri: uri.href, text: "Error: Invalid project or POU path type.", contentType: "text/plain" }], isError: true };
+        }
+        const projectPath = projectPathParam; // Define projectPath
+        const pouPath = pouPathParam; // Define pouPath
+        if (!projectPath || !pouPath) {
+            return { contents: [{ uri: uri.href, text: "Error: Project or POU path missing.", contentType: "text/plain" }], isError: true };
+        }
+        // *** END DEFINE VARIABLES ***
+        console.error(`Resource request: POU code: Project='${projectPath}', POU='${pouPath}'`);
+        try {
+            const absoluteProjPath = path.normalize(path.isAbsolute(projectPath) ? projectPath : path.join(WORKSPACE_DIR, projectPath));
+            const sanitizedPouPath = String(pouPath).replace(/\\/g, '/').replace(/^\/+|\/+$/g, '');
+            const escapedProjPath = absoluteProjPath.replace(/\\/g, '\\\\');
+            // *** DEFINE scriptContent ***
+            let scriptContent = templates_1.GET_POU_CODE_SCRIPT_TEMPLATE.replace("{PROJECT_FILE_PATH}", escapedProjPath);
+            scriptContent = scriptContent.replace("{POU_FULL_PATH}", sanitizedPouPath);
+            // *** END DEFINE scriptContent ***
+            const result = yield (0, codesys_interop_1.executeCodesysScript)(scriptContent, codesysExePath, codesysProfileName);
+            let codeText = `Error retrieving code for object '${sanitizedPouPath}' in project '${absoluteProjPath}'.\n\n${result.output}`;
+            let isError = !result.success;
+            if (result.success && result.output.includes("SCRIPT_SUCCESS")) {
+                // ... (marker parsing logic using new markers) ...
+                const declStartMarker = "### POU DECLARATION START ###";
+                const declEndMarker = "### POU DECLARATION END ###";
+                const implStartMarker = "### POU IMPLEMENTATION START ###";
+                const implEndMarker = "### POU IMPLEMENTATION END ###";
+                const declStartIdx = result.output.indexOf(declStartMarker);
+                const declEndIdx = result.output.indexOf(declEndMarker);
+                const implStartIdx = result.output.indexOf(implStartMarker);
+                const implEndIdx = result.output.indexOf(implEndMarker);
+                let declaration = "/* Declaration not found in output */";
+                let implementation = "/* Implementation not found in output */";
+                if (declStartIdx !== -1 && declEndIdx !== -1 && declStartIdx < declEndIdx) {
+                    declaration = result.output.substring(declStartIdx + declStartMarker.length, declEndIdx).replace(/\\n/g, '\n').trim();
+                }
+                else {
+                    console.error(`WARN: Declaration markers not found correctly for ${sanitizedPouPath}`);
+                }
+                if (implStartIdx !== -1 && implEndIdx !== -1 && implStartIdx < implEndIdx) {
+                    implementation = result.output.substring(implStartIdx + implStartMarker.length, implEndIdx).replace(/\\n/g, '\n').trim();
+                }
+                else {
+                    console.error(`WARN: Implementation markers not found correctly for ${sanitizedPouPath}`);
+                }
+                codeText = `// ----- Declaration -----\n${declaration}\n\n// ----- Implementation -----\n${implementation}`;
+                // *** END MARKER PARSING ***
+            }
+            else {
+                isError = true;
+            }
+            // **** RETURN MCP STRUCTURE ****
+            return { contents: [{ uri: uri.href, text: codeText, contentType: "text/plain" }], isError: isError };
+        }
+        catch (error) {
+            console.error(`Error getting POU code ${uri.href}:`, error);
+            // **** RETURN MCP STRUCTURE ****
+            return { contents: [{ uri: uri.href, text: `Failed POU code script for '${pouPath}' in '${projectPath}': ${error.message}`, contentType: "text/plain" }], isError: true };
+        }
+    }));
+    // --- End Resources ---
+}