codesysultra 1.0.0

package/dist/handlers/tools.js

@@ -0,0 +1,332 @@
+"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.registerTools = registerTools;
+const zod_1 = require("zod");
+const path = __importStar(require("path"));
+const types_1 = require("../types");
+const codesys_interop_1 = require("../codesys_interop");
+const utils_1 = require("../utils");
+const templates_1 = require("../templates");
+function registerTools(server, config) {
+    const WORKSPACE_DIR = config.workspaceDir;
+    const codesysExePath = config.codesysPath;
+    const codesysProfileName = config.profileName;
+    console.error("HANDLERS: Registering Tools...");
+    // --- Tools ---
+    server.tool("open_project", // Tool Name
+    "Opens an existing CODESYS project file.", // Tool Description
+    {
+        filePath: zod_1.z.string().describe("Path to the project file (e.g., 'C:/Projects/MyPLC.project' or '/Users/user/projects/my_project.project').")
+    }, (args) => __awaiter(this, void 0, void 0, function* () {
+        const { filePath } = args;
+        let absPath = path.normalize(path.isAbsolute(filePath) ? filePath : path.join(WORKSPACE_DIR, filePath));
+        console.error(`Tool call: open_project: ${absPath}`);
+        try {
+            const escapedPath = absPath.replace(/\\/g, '\\\\');
+            const script = templates_1.OPEN_PROJECT_SCRIPT_TEMPLATE.replace("{PROJECT_FILE_PATH}", escapedPath);
+            const result = yield (0, codesys_interop_1.executeCodesysScript)(script, codesysExePath, codesysProfileName);
+            const success = result.success && result.output.includes("SCRIPT_SUCCESS");
+            return { content: [{ type: "text", text: success ? `Project opened: ${absPath}` : `Failed open project ${absPath}. Output:\n${result.output}` }], isError: !success };
+        }
+        catch (e) {
+            console.error(`Error open_project ${absPath}: ${e}`);
+            return { content: [{ type: "text", text: `Error: ${e.message}` }], isError: true };
+        }
+    }));
+    server.tool("create_project", // Tool Name
+    "Creates a new CODESYS project from the standard template.", // Tool Description
+    {
+        filePath: zod_1.z.string().describe("Path where the new project file should be created (e.g., 'C:/Projects/NewPLC.project' or '/Users/user/projects/new_project.project').")
+    }, (args) => __awaiter(this, void 0, void 0, function* () {
+        const { filePath } = args;
+        let absPath = path.normalize(path.isAbsolute(filePath) ? filePath : path.join(WORKSPACE_DIR, filePath));
+        console.error(`Tool call: create_project (copy template): ${absPath}`);
+        let templatePath = "";
+        try {
+            // Template finding logic (same as before)
+            const baseDir = path.dirname(path.dirname(codesysExePath));
+            templatePath = path.normalize(path.join(baseDir, 'Templates', 'Standard.project'));
+            if (!(yield (0, utils_1.fileExists)(templatePath))) {
+                console.error(`WARN: Template not found relative to exe: ${templatePath}. Trying ProgramData...`);
+                const programData = process.env.ALLUSERSPROFILE || process.env.ProgramData || 'C:\\ProgramData';
+                const possibleTemplateDir = path.join(programData, 'CODESYS', 'CODESYS', codesysProfileName, 'Templates');
+                let potentialTemplatePath = path.normalize(path.join(possibleTemplateDir, 'Standard.project'));
+                if (yield (0, utils_1.fileExists)(potentialTemplatePath)) {
+                    templatePath = potentialTemplatePath;
+                    console.error(`DEBUG: Found template in ProgramData: ${templatePath}`);
+                }
+                else {
+                    const alternativeTemplateDir = path.join(programData, 'CODESYS', 'Templates');
+                    potentialTemplatePath = path.normalize(path.join(alternativeTemplateDir, 'Standard.project'));
+                    if (yield (0, utils_1.fileExists)(potentialTemplatePath)) {
+                        templatePath = potentialTemplatePath;
+                        console.error(`DEBUG: Found template in ProgramData (alternative): ${templatePath}`);
+                    }
+                    else {
+                        throw new Error(`Standard template project file not found at relative path or ProgramData locations.`);
+                    }
+                }
+            }
+            else {
+                console.error(`DEBUG: Found template relative to exe: ${templatePath}`);
+            }
+            // *** END TEMPLATE FINDING ***
+        }
+        catch (e) {
+            console.error(`Template Error: ${e.message}`);
+            return { content: [{ type: "text", text: `Template Error: ${e.message}` }], isError: true };
+        }
+        try {
+            const escProjPath = absPath.replace(/\\/g, '\\\\');
+            const escTmplPath = templatePath.replace(/\\/g, '\\\\');
+            const script = templates_1.CREATE_PROJECT_SCRIPT_TEMPLATE
+                .replace("{PROJECT_FILE_PATH}", escProjPath)
+                .replace("{TEMPLATE_PROJECT_PATH}", escTmplPath);
+            console.error(">>> create_project (copy-then-open): PREPARED SCRIPT:", script.substring(0, 500) + "...");
+            const result = yield (0, codesys_interop_1.executeCodesysScript)(script, codesysExePath, codesysProfileName);
+            console.error(">>> create_project (copy-then-open): EXECUTION RESULT:", JSON.stringify(result));
+            const success = result.success && result.output.includes("SCRIPT_SUCCESS");
+            return { content: [{ type: "text", text: success ? `Project created from template: ${absPath}` : `Failed create project ${absPath} from template. Output:\n${result.output}` }], isError: !success };
+        }
+        catch (e) {
+            console.error(`Error create_project ${absPath}: ${e}`);
+            return { content: [{ type: "text", text: `Error: ${e.message}` }], isError: true };
+        }
+    }));
+    server.tool("save_project", // Tool Name
+    "Saves the currently open CODESYS project.", // Tool Description
+    {
+        projectFilePath: zod_1.z.string().describe("Path to the project file to ensure is open before saving (e.g., 'C:/Projects/MyPLC.project').")
+    }, (args) => __awaiter(this, void 0, void 0, function* () {
+        const { projectFilePath } = args;
+        let absPath = path.normalize(path.isAbsolute(projectFilePath) ? projectFilePath : path.join(WORKSPACE_DIR, projectFilePath));
+        console.error(`Tool call: save_project: ${absPath}`);
+        try {
+            const escapedPath = absPath.replace(/\\/g, '\\\\');
+            const script = templates_1.SAVE_PROJECT_SCRIPT_TEMPLATE.replace("{PROJECT_FILE_PATH}", escapedPath);
+            const result = yield (0, codesys_interop_1.executeCodesysScript)(script, codesysExePath, codesysProfileName);
+            const success = result.success && result.output.includes("SCRIPT_SUCCESS");
+            return { content: [{ type: "text", text: success ? `Project saved: ${absPath}` : `Failed save project ${absPath}. Output:\n${result.output}` }], isError: !success };
+        }
+        catch (e) {
+            console.error(`Error save_project ${absPath}: ${e}`);
+            return { content: [{ type: "text", text: `Error: ${e.message}` }], isError: true };
+        }
+    }));
+    server.tool("create_pou", // Tool Name
+    "Creates a new Program, Function Block, or Function POU within the specified CODESYS project.", // Tool Description
+    {
+        projectFilePath: zod_1.z.string().describe("Path to the project file (e.g., 'C:/Projects/MyPLC.project')."),
+        name: zod_1.z.string().describe("Name for the new POU (must be a valid IEC identifier)."),
+        type: types_1.PouTypeEnum.describe("Type of POU (Program, FunctionBlock, Function)."),
+        language: types_1.ImplementationLanguageEnum.describe("Implementation language (ST, LD, FBD, etc.). CODESYS default will be used if specific language is not set or directly supported by scripting for this POU type."),
+        parentPath: zod_1.z.string().describe("Relative path under project root or application where the POU should be created (e.g., 'Application' or 'MyFolder/SubFolder').")
+    }, (args) => __awaiter(this, void 0, void 0, function* () {
+        const { projectFilePath, name, type, language, parentPath } = args;
+        let absPath = path.normalize(path.isAbsolute(projectFilePath) ? projectFilePath : path.join(WORKSPACE_DIR, projectFilePath));
+        const sanParentPath = parentPath.replace(/\\/g, '/').replace(/^\/+|\/+$/g, '');
+        const sanName = name.trim();
+        console.error(`Tool call: create_pou: Name='${sanName}', Type='${type}', Lang='${language}', Parent='${sanParentPath}', Project='${absPath}'`);
+        try {
+            const escProjPath = absPath.replace(/\\/g, '\\\\');
+            let script = templates_1.CREATE_POU_SCRIPT_TEMPLATE.replace("{PROJECT_FILE_PATH}", escProjPath);
+            script = script.replace("{POU_NAME}", sanName);
+            script = script.replace("{POU_TYPE_STR}", type);
+            script = script.replace("{IMPL_LANGUAGE_STR}", language);
+            script = script.replace("{PARENT_PATH}", sanParentPath);
+            console.error(">>> create_pou: PREPARED SCRIPT:", script.substring(0, 500) + "...");
+            const result = yield (0, codesys_interop_1.executeCodesysScript)(script, codesysExePath, codesysProfileName);
+            console.error(">>> create_pou: EXECUTION RESULT:", JSON.stringify(result));
+            const success = result.success && result.output.includes("SCRIPT_SUCCESS");
+            return { content: [{ type: "text", text: success ? `POU '${sanName}' created in '${sanParentPath}' of ${absPath}. Project saved.` : `Failed create POU '${sanName}'. Output:\n${result.output}` }], isError: !success };
+        }
+        catch (e) {
+            console.error(`Error create_pou ${sanName} in ${absPath}: ${e}`);
+            return { content: [{ type: "text", text: `Error: ${e.message}` }], isError: true };
+        }
+    }));
+    server.tool("set_pou_code", // Tool Name
+    "Sets the declaration and/or implementation code for a specific POU, Method, or Property.", // Tool Description
+    {
+        projectFilePath: zod_1.z.string().describe("Path to the project file (e.g., 'C:/Projects/MyPLC.project')."),
+        pouPath: zod_1.z.string().describe("Full relative path to the target object (e.g., 'Application/MyPOU', 'MyFolder/MyFB/MyMethod', 'MyFolder/MyFB/MyProperty')."),
+        declarationCode: zod_1.z.string().describe("Code for the declaration part (VAR...END_VAR). If omitted, the declaration is not changed.").optional(),
+        implementationCode: zod_1.z.string().describe("Code for the implementation logic part. If omitted, the implementation is not changed.").optional()
+    }, (args) => __awaiter(this, void 0, void 0, function* () {
+        const { projectFilePath, pouPath, declarationCode, implementationCode } = args;
+        if (declarationCode === undefined && implementationCode === undefined) {
+            return { content: [{ type: "text", text: "Error: At least one of declarationCode or implementationCode must be provided." }], isError: true };
+        }
+        let absPath = path.normalize(path.isAbsolute(projectFilePath) ? projectFilePath : path.join(WORKSPACE_DIR, projectFilePath));
+        const sanPouPath = pouPath.replace(/\\/g, '/').replace(/^\/+|\/+$/g, '');
+        console.error(`Tool call: set_pou_code: Target='${sanPouPath}', Project='${absPath}'`);
+        try {
+            const escProjPath = absPath.replace(/\\/g, '\\\\');
+            // Escape content for Python triple-quoted strings
+            const sanDeclCode = (declarationCode !== null && declarationCode !== void 0 ? declarationCode : "").replace(/\\/g, '\\\\').replace(/"""/g, '\\"\\"\\"');
+            const sanImplCode = (implementationCode !== null && implementationCode !== void 0 ? implementationCode : "").replace(/\\/g, '\\\\').replace(/"""/g, '\\"\\"\\"');
+            let script = templates_1.SET_POU_CODE_SCRIPT_TEMPLATE.replace("{PROJECT_FILE_PATH}", escProjPath);
+            script = script.replace("{POU_FULL_PATH}", sanPouPath);
+            script = script.replace("{DECLARATION_CONTENT}", sanDeclCode);
+            script = script.replace("{IMPLEMENTATION_CONTENT}", sanImplCode);
+            console.error(">>> set_pou_code: PREPARED SCRIPT:", script.substring(0, 500) + "...");
+            const result = yield (0, codesys_interop_1.executeCodesysScript)(script, codesysExePath, codesysProfileName);
+            console.error(">>> set_pou_code: EXECUTION RESULT:", JSON.stringify(result));
+            const success = result.success && result.output.includes("SCRIPT_SUCCESS");
+            return { content: [{ type: "text", text: success ? `Code set for '${sanPouPath}' in ${absPath}. Project saved.` : `Failed set code for '${sanPouPath}'. Output:\n${result.output}` }], isError: !success };
+        }
+        catch (e) {
+            console.error(`Error set_pou_code ${sanPouPath} in ${absPath}: ${e}`);
+            return { content: [{ type: "text", text: `Error: ${e.message}` }], isError: true };
+        }
+    }));
+    server.tool("create_property", // Tool Name
+    "Creates a new Property within a specific Function Block POU.", // Tool Description
+    {
+        projectFilePath: zod_1.z.string().describe("Path to the project file (e.g., 'C:/Projects/MyPLC.project')."),
+        // Assuming properties can only be added to FBs in standard CODESYS scripting
+        parentPouPath: zod_1.z.string().describe("Relative path to the parent Function Block POU (e.g., 'Application/MyFB')."),
+        propertyName: zod_1.z.string().describe("Name for the new property (must be a valid IEC identifier)."),
+        propertyType: zod_1.z.string().describe("Data type of the property (e.g., 'BOOL', 'INT', 'MyDUT').")
+    }, (args) => __awaiter(this, void 0, void 0, function* () {
+        const { projectFilePath, parentPouPath, propertyName, propertyType } = args;
+        let absPath = path.normalize(path.isAbsolute(projectFilePath) ? projectFilePath : path.join(WORKSPACE_DIR, projectFilePath));
+        const sanParentPath = parentPouPath.replace(/\\/g, '/').replace(/^\/+|\/+$/g, '');
+        const sanPropName = propertyName.trim();
+        const sanPropType = propertyType.trim();
+        console.error(`Tool call: create_property: Name='${sanPropName}', Type='${sanPropType}', ParentPOU='${sanParentPath}', Project='${absPath}'`);
+        if (!sanPropName || !sanPropType) {
+            return { content: [{ type: "text", text: `Error: Property name and type cannot be empty.` }], isError: true };
+        }
+        try {
+            const escProjPath = absPath.replace(/\\/g, '\\\\');
+            let script = templates_1.CREATE_PROPERTY_SCRIPT_TEMPLATE.replace("{PROJECT_FILE_PATH}", escProjPath);
+            script = script.replace("{PARENT_POU_FULL_PATH}", sanParentPath);
+            script = script.replace("{PROPERTY_NAME}", sanPropName);
+            script = script.replace("{PROPERTY_TYPE}", sanPropType);
+            console.error(">>> create_property: PREPARED SCRIPT:", script.substring(0, 500) + "...");
+            const result = yield (0, codesys_interop_1.executeCodesysScript)(script, codesysExePath, codesysProfileName);
+            console.error(">>> create_property: EXECUTION RESULT:", JSON.stringify(result));
+            const success = result.success && result.output.includes("SCRIPT_SUCCESS");
+            return {
+                content: [{ type: "text", text: success ? `Property '${sanPropName}' created under '${sanParentPath}' in ${absPath}. Project saved.` : `Failed to create property '${sanPropName}'. Output:\n${result.output}` }],
+                isError: !success
+            };
+        }
+        catch (e) {
+            console.error(`Error create_property ${sanPropName} in ${absPath}: ${e}`);
+            return { content: [{ type: "text", text: `Error: ${e.message}` }], isError: true };
+        }
+    }));
+    server.tool("create_method", // Tool Name
+    "Creates a new Method within a specific Function Block POU.", // Tool Description
+    {
+        projectFilePath: zod_1.z.string().describe("Path to the project file (e.g., 'C:/Projects/MyPLC.project')."),
+        // Assuming methods can typically only be added to FBs in standard CODESYS scripting
+        parentPouPath: zod_1.z.string().describe("Relative path to the parent Function Block POU (e.g., 'Application/MyFB')."),
+        methodName: zod_1.z.string().describe("Name of the new method (must be a valid IEC identifier)."),
+        returnType: zod_1.z.string().optional().describe("Return type (e.g., 'BOOL', 'INT'). Leave empty or omit for no return value (PROCEDURE)."),
+    }, (args) => __awaiter(this, void 0, void 0, function* () {
+        const { projectFilePath, parentPouPath, methodName, returnType } = args;
+        let absPath = path.normalize(path.isAbsolute(projectFilePath) ? projectFilePath : path.join(WORKSPACE_DIR, projectFilePath));
+        const sanParentPath = parentPouPath.replace(/\\/g, '/').replace(/^\/+|\/+$/g, '');
+        const sanMethName = methodName.trim();
+        const sanReturnType = (returnType !== null && returnType !== void 0 ? returnType : "").trim();
+        console.error(`Tool call: create_method: Name='${sanMethName}', Return='${sanReturnType}', ParentPOU='${sanParentPath}', Project='${absPath}'`);
+        if (!sanMethName) {
+            return { content: [{ type: "text", text: `Error: Method name cannot be empty.` }], isError: true };
+        }
+        try {
+            const escProjPath = absPath.replace(/\\/g, '\\\\');
+            let script = templates_1.CREATE_METHOD_SCRIPT_TEMPLATE.replace("{PROJECT_FILE_PATH}", escProjPath);
+            script = script.replace("{PARENT_POU_FULL_PATH}", sanParentPath);
+            script = script.replace("{METHOD_NAME}", sanMethName);
+            script = script.replace("{RETURN_TYPE}", sanReturnType);
+            console.error(">>> create_method: PREPARED SCRIPT:", script.substring(0, 500) + "...");
+            const result = yield (0, codesys_interop_1.executeCodesysScript)(script, codesysExePath, codesysProfileName);
+            console.error(">>> create_method: EXECUTION RESULT:", JSON.stringify(result));
+            const success = result.success && result.output.includes("SCRIPT_SUCCESS");
+            return {
+                content: [{ type: "text", text: success ? `Method '${sanMethName}' created under '${sanParentPath}' in ${absPath}. Project saved.` : `Failed to create method '${sanMethName}'. Output:\n${result.output}` }],
+                isError: !success
+            };
+        }
+        catch (e) {
+            console.error(`Error create_method ${sanMethName} in ${absPath}: ${e}`);
+            return { content: [{ type: "text", text: `Error: ${e.message}` }], isError: true };
+        }
+    }));
+    server.tool("compile_project", // Tool Name
+    "Compiles (Builds) the primary application within a CODESYS project.", // Tool Description
+    {
+        projectFilePath: zod_1.z.string().describe("Path to the project file containing the application to compile (e.g., 'C:/Projects/MyPLC.project').")
+    }, (args) => __awaiter(this, void 0, void 0, function* () {
+        const { projectFilePath } = args;
+        let absPath = path.normalize(path.isAbsolute(projectFilePath) ? projectFilePath : path.join(WORKSPACE_DIR, projectFilePath));
+        console.error(`Tool call: compile_project: ${absPath}`);
+        try {
+            const escapedPath = absPath.replace(/\\/g, '\\\\');
+            const script = templates_1.COMPILE_PROJECT_SCRIPT_TEMPLATE.replace("{PROJECT_FILE_PATH}", escapedPath);
+            const result = yield (0, codesys_interop_1.executeCodesysScript)(script, codesysExePath, codesysProfileName);
+            const success = result.success && result.output.includes("SCRIPT_SUCCESS");
+            // Check for actual compile errors in the output log
+            const hasCompileErrors = result.output.includes("Compile complete --") && !/ 0 error\(s\),/.test(result.output);
+            let message = success ? `Compilation initiated for application in ${absPath}. Check CODESYS messages for results.` : `Failed initiating compilation for ${absPath}. Output:\n${result.output}`;
+            let isError = !success; // Base error status on script success
+            if (success && hasCompileErrors) {
+                message += " WARNING: Build command reported errors in the output log.";
+                console.warn("Compile project reported build errors in the output.");
+                // Report as error if compile fails, even if script technically succeeded
+                isError = true;
+            }
+            return { content: [{ type: "text", text: message }], isError: isError };
+        }
+        catch (e) {
+            console.error(`Error compile_project ${absPath}: ${e}`);
+            return { content: [{ type: "text", text: `Error: ${e.message}` }], isError: true };
+        }
+    }));
+    // --- End Tools ---
+}

package/dist/server.js

@@ -0,0 +1,122 @@
+"use strict";
+/**
+ * server.ts
+ * MCP Server for interacting with CODESYS via Python scripting.
+ * Refactored to be modular.
+ */
+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.startMcpServer = startMcpServer;
+const os = __importStar(require("os"));
+const mcp_js_1 = require("@modelcontextprotocol/sdk/server/mcp.js");
+const stdio_js_1 = require("@modelcontextprotocol/sdk/server/stdio.js");
+const resources_1 = require("./handlers/resources");
+const tools_1 = require("./handlers/tools");
+const fs = __importStar(require("fs"));
+// --- STARTUP LOG ---
+console.error(`>>> SERVER.TS TOP LEVEL EXECUTION @ ${new Date().toISOString()} <<<`);
+console.error(`>>> Node: ${process.version}, Platform: ${os.platform()}, Arch: ${os.arch()}`);
+console.error(`>>> Initial CWD: ${process.cwd()}`);
+// --- End Startup Log ---
+function startMcpServer(config) {
+    return __awaiter(this, void 0, void 0, function* () {
+        console.error(`>>> SERVER.TS startMcpServer() CALLED @ ${new Date().toISOString()} <<<`);
+        console.error(`>>> Config Received: ${JSON.stringify(config)}`);
+        const codesysExePath = config.codesysPath;
+        console.error(`SERVER.TS: Checking existence of CODESYS executable: ${codesysExePath}`);
+        try {
+            if (!fs.existsSync(codesysExePath)) {
+                console.error(`SERVER.TS ERROR: Determined CODESYS executable path does not exist: ${codesysExePath}`);
+                throw new Error(`CODESYS executable not found at specified path: ${codesysExePath}`);
+            }
+            else {
+                console.error(`SERVER.TS: Confirmed CODESYS executable exists.`);
+            }
+        }
+        catch (err) {
+            console.error(`SERVER.TS ERROR: Error checking CODESYS path existence: ${err.message}`);
+            throw err;
+        }
+        console.error("SERVER.TS: Initializing McpServer...");
+        const server = new mcp_js_1.McpServer({
+            name: "CODESYS Control MCP Server",
+            version: "1.7.1"
+        }, {
+            capabilities: {
+                resources: { listChanged: true },
+                tools: { listChanged: true }
+            }
+        });
+        console.error("SERVER.TS: McpServer instance created.");
+        // Register Resources and Tools
+        (0, resources_1.registerResources)(server, config);
+        (0, tools_1.registerTools)(server, config);
+        console.error("SERVER.TS: Resources and Tools registered.");
+        console.error("SERVER.TS: startServer() internal logic executing.");
+        try {
+            const transport = new stdio_js_1.StdioServerTransport();
+            console.error("SERVER.TS: Connecting MCP server via stdio...");
+            server.connect(transport);
+            console.error("SERVER.TS: MCP Server connection initiated via stdio.");
+        }
+        catch (error) {
+            console.error("FATAL: Failed to initiate MCP server connection:", error);
+            throw error;
+        }
+    });
+}
+// --- Graceful Shutdown / Unhandled Rejection ---
+process.on('SIGINT', () => {
+    console.error('\nSERVER.TS: SIGINT received, shutting down...');
+    process.exit(0);
+});
+process.on('SIGTERM', () => {
+    console.error('\nSERVER.TS: SIGTERM received, shutting down...');
+    process.exit(0);
+});
+process.on('unhandledRejection', (reason, promise) => {
+    console.error('SERVER.TS: Unhandled Rejection at:', promise, 'reason:', reason);
+});
+// --- End Graceful Shutdown / Unhandled Rejection ---
+console.error(">>> SERVER.TS Module Parsed <<<");

package/dist/templates/check_status.py

@@ -0,0 +1,21 @@
+import sys, scriptengine as script_engine, os, traceback
+project_open = False; project_name = "No project open"; project_path = "N/A"; scripting_ok = False
+try:
+    scripting_ok = True; primary_project = script_engine.projects.primary
+    if primary_project:
+        project_open = True
+        try:
+            project_path = os.path.normcase(os.path.abspath(primary_project.path))
+            try:
+                 project_name = primary_project.get_name() # Might fail
+                 if not project_name: project_name = "Unnamed (path: %s)" % os.path.basename(project_path)
+            except: project_name = "Unnamed (path: %s)" % os.path.basename(project_path)
+        except Exception as e_path: project_path = "N/A (Error: %s)" % e_path; project_name = "Unnamed (Path Error)"
+    print("Project Open: %s" % project_open); print("Project Name: %s" % project_name)
+    print("Project Path: %s" % project_path); print("Scripting OK: %s" % scripting_ok)
+    print("SCRIPT_SUCCESS: Status check complete."); sys.exit(0)
+except Exception as e:
+    error_message = "Error during status check: %s" % e
+    print(error_message); print("Scripting OK: False")
+    # traceback.print_exc() # Optional traceback
+    print("SCRIPT_ERROR: %s" % error_message); sys.exit(1)

package/dist/templates/compile_project.py

@@ -0,0 +1,55 @@
+import sys, scriptengine as script_engine, os, traceback
+{{ENSURE_PROJECT_OPEN_PYTHON_SNIPPET}}
+try:
+    print("DEBUG: compile_project script: Project='%s'" % PROJECT_FILE_PATH)
+    primary_project = ensure_project_open(PROJECT_FILE_PATH)
+    project_name = os.path.basename(PROJECT_FILE_PATH)
+    target_app = None
+    app_name = "N/A"
+
+    # Try getting active application first
+    try:
+        target_app = primary_project.active_application
+        if target_app:
+            app_name = getattr(target_app, 'get_name', lambda: "Unnamed App (Active)")()
+            print("DEBUG: Found active application: %s" % app_name)
+    except Exception as active_err:
+        print("WARN: Could not get active application: %s. Searching..." % active_err)
+
+    # If no active app, search for the first one
+    if not target_app:
+        print("DEBUG: Searching for first compilable application...")
+        apps = []
+        try:
+             # Search recursively through all project objects
+             all_children = primary_project.get_children(True)
+             for child in all_children:
+                  # Check using the marker property and if build method exists
+                  if hasattr(child, 'is_application') and child.is_application and hasattr(child, 'build'):
+                       app_name_found = getattr(child, 'get_name', lambda: "Unnamed App")()
+                       print("DEBUG: Found potential application object: %s" % app_name_found)
+                       apps.append(child)
+                       break # Take the first one found
+        except Exception as find_err: print("WARN: Error finding application object: %s" % find_err)
+
+        if not apps: raise RuntimeError("No compilable application found in project '%s'" % project_name)
+        target_app = apps[0]
+        app_name = getattr(target_app, 'get_name', lambda: "Unnamed App (First Found)")()
+        print("WARN: Compiling first found application: %s" % app_name)
+
+    print("DEBUG: Calling build() on app '%s'..." % app_name)
+    if not hasattr(target_app, 'build'):
+         raise TypeError("Selected object '%s' is not an application or doesn't support build()." % app_name)
+
+    # Execute the build
+    target_app.build();
+    print("DEBUG: Build command executed for application '%s'." % app_name)
+
+    # Check messages is harder without direct access to message store from script.
+    # Rely on CODESYS UI or log output for now.
+    print("Compile Initiated For Application: %s" % app_name); print("In Project: %s" % project_name)
+    print("SCRIPT_SUCCESS: Application compilation initiated."); sys.exit(0)
+except Exception as e:
+    detailed_error = traceback.format_exc()
+    error_message = "Error initiating compilation for project %s: %s\\n%s" % (PROJECT_FILE_PATH, e, detailed_error)
+    print(error_message); print("SCRIPT_ERROR: %s" % error_message); sys.exit(1)

package/dist/templates/create_method.py

@@ -0,0 +1,68 @@
+import sys, scriptengine as script_engine, os, traceback
+{{ENSURE_PROJECT_OPEN_PYTHON_SNIPPET}}
+{{FIND_OBJECT_BY_PATH_PYTHON_SNIPPET}}
+PARENT_POU_FULL_PATH = "{PARENT_POU_FULL_PATH}" # e.g., "Application/MyFB"
+METHOD_NAME = "{METHOD_NAME}"
+RETURN_TYPE = "{RETURN_TYPE}" # Can be empty string for no return type
+# Optional: Language
+# LANG_GUID_STR = "{LANG_GUID_STR}" # Example if needed
+
+try:
+    print("DEBUG: create_method script: ParentPOU='%s', Name='%s', ReturnType='%s', Project='%s'" % (PARENT_POU_FULL_PATH, METHOD_NAME, RETURN_TYPE, PROJECT_FILE_PATH))
+    primary_project = ensure_project_open(PROJECT_FILE_PATH)
+    if not PARENT_POU_FULL_PATH: raise ValueError("Parent POU full path empty.")
+    if not METHOD_NAME: raise ValueError("Method name empty.")
+    # RETURN_TYPE can be empty
+
+    # Find the parent POU object
+    parent_pou_object = find_object_by_path_robust(primary_project, PARENT_POU_FULL_PATH, "parent POU")
+    if not parent_pou_object: raise ValueError("Parent POU object not found: %s" % PARENT_POU_FULL_PATH)
+
+    parent_pou_name = getattr(parent_pou_object, 'get_name', lambda: PARENT_POU_FULL_PATH)()
+    print("DEBUG: Found Parent POU object: %s" % parent_pou_name)
+
+     # Check if parent object supports creating methods (should implement ScriptIecLanguageMemberContainer)
+    if not hasattr(parent_pou_object, 'create_method'):
+         raise TypeError("Parent object '%s' of type %s does not support create_method." % (parent_pou_name, type(parent_pou_object).__name__))
+
+    # Default language to None (usually ST)
+    lang_guid = None
+    # Use None if RETURN_TYPE is empty string, otherwise use the string
+    actual_return_type = RETURN_TYPE if RETURN_TYPE else None
+    print("DEBUG: Calling create_method: Name='%s', ReturnType=%s, Lang=%s" % (METHOD_NAME, actual_return_type, lang_guid))
+
+    # Call the create_method method ON THE PARENT POU
+    new_method_object = parent_pou_object.create_method(
+        name=METHOD_NAME,
+        return_type=actual_return_type,
+        language=lang_guid # Pass None to use default
+    )
+
+    if new_method_object:
+        new_meth_name = getattr(new_method_object, 'get_name', lambda: METHOD_NAME)()
+        print("DEBUG: Method object created: %s" % new_meth_name)
+
+        # --- SAVE THE PROJECT TO PERSIST THE NEW METHOD OBJECT ---
+        try:
+            print("DEBUG: Saving Project (after method creation)...")
+            primary_project.save()
+            print("DEBUG: Project saved successfully after method creation.")
+        except Exception as save_err:
+            print("ERROR: Failed to save Project after creating method: %s" % save_err)
+            detailed_error = traceback.format_exc()
+            error_message = "Error saving Project after creating method '%s': %s\\n%s" % (METHOD_NAME, save_err, detailed_error)
+            print(error_message); print("SCRIPT_ERROR: %s" % error_message); sys.exit(1)
+        # --- END SAVING ---
+
+        print("Method Created: %s" % new_meth_name)
+        print("Parent POU: %s" % PARENT_POU_FULL_PATH)
+        print("Return Type: %s" % (RETURN_TYPE if RETURN_TYPE else "(None)"))
+        print("SCRIPT_SUCCESS: Method created successfully."); sys.exit(0)
+    else:
+         error_message = "Failed to create method '%s' under '%s'. create_method returned None." % (METHOD_NAME, parent_pou_name)
+         print(error_message); print("SCRIPT_ERROR: %s" % error_message); sys.exit(1)
+
+except Exception as e:
+    detailed_error = traceback.format_exc()
+    error_message = "Error creating method '%s' under POU '%s' in project '%s': %s\\n%s" % (METHOD_NAME, PARENT_POU_FULL_PATH, PROJECT_FILE_PATH, e, detailed_error)
+    print(error_message); print("SCRIPT_ERROR: %s" % error_message); sys.exit(1)