lasal-mcp 0.1.0

package/dist/tools/plcDiagnostics.js

@@ -0,0 +1,172 @@
+import { z } from "zod";
+import { existsSync, readFileSync, mkdirSync } from "fs";
+import { join } from "path";
+import { randomUUID } from "crypto";
+import { runScript, emitPy27String, emitPath } from "../utils/batchScript.js";
+import { resolveLcpPath } from "../utils/resolvePaths.js";
+import { withEngineLock, SCRATCH } from "../utils/engine.js";
+import { XMLParser } from "fast-xml-parser";
+function batchResultToResponse(br, extra) {
+    const body = {
+        ok: br.ok,
+        durationMs: br.durationMs,
+        ...(br.errors.length ? { errors: br.errors } : {}),
+        ...(br.warnings.length ? { warnings: br.warnings } : {}),
+        ...(br.logTail.length ? { logTail: br.logTail } : {}),
+        logPath: br.logPath,
+        ...extra,
+    };
+    return {
+        content: [{ type: "text", text: JSON.stringify(body, null, 2) }],
+        ...(br.ok ? {} : { isError: true }),
+    };
+}
+export const plcDiagnosticsSchema = {
+    action: z
+        .enum(["trace", "file_upload", "file_download", "file_delete", "code_analysis"])
+        .describe("PLC diagnostics/maintenance action to perform."),
+    lcp_path: z
+        .string()
+        .optional()
+        .describe("Absolute path to the .lcp file. Omit to use the currently selected project."),
+    connection: z.string().optional().describe("PLC connection string. Omit to use connection from project's .lss file."),
+    config_path: z.string().optional().describe("Absolute path to the DataAnalyzer config file (trace action only)."),
+    duration_ms: z
+        .number()
+        .int()
+        .optional()
+        .default(5000)
+        .describe("Duration in milliseconds to run the trace (trace action only). Default 5000."),
+    output_path: z.string().optional().describe("Destination path for the trace output or code analysis result."),
+    plc_path: z.string().optional().describe("File path on the PLC (for file upload/download/delete)."),
+    local_path: z.string().optional().describe("Local file path on the host (for file upload/download)."),
+};
+export async function plcDiagnosticsHandler(args) {
+    const resolved = resolveLcpPath(args.lcp_path);
+    if ("error" in resolved) {
+        return { content: [{ type: "text", text: resolved.error }], isError: true };
+    }
+    const id = randomUUID();
+    if (!existsSync(SCRATCH))
+        mkdirSync(SCRATCH, { recursive: true });
+    const logPath = join(SCRATCH, `diag_${id}.log`);
+    const conn = args.connection ?? "";
+    return withEngineLock(async () => {
+        switch (args.action) {
+            case "trace": {
+                if (!args.config_path) {
+                    return {
+                        content: [{ type: "text", text: "config_path is required for action 'trace'" }],
+                        isError: true,
+                    };
+                }
+                const outPath = args.output_path || join(SCRATCH, `trace_${id}.csv`);
+                const durationSec = (args.duration_ms ?? 5000) / 1000.0;
+                const script = [
+                    "# -*- coding: utf-8 -*-",
+                    "import sigmatek.lasal.batch as batch",
+                    "import time",
+                    `batch.OpenLogfile(${emitPath(logPath)})`,
+                    `prj = batch.LoadProject(${emitPath(resolved.path)})`,
+                    `batch.DataAnalyzerLoadConfig(${emitPy27String(args.config_path)})`,
+                    `batch.DataAnalyzerRun(prj, ${emitPy27String(conn)})`,
+                    `time.sleep(${durationSec})`,
+                    "batch.DataAnalyzerStop()",
+                    `batch.DataAnalyzerSaveData(${emitPy27String(outPath)})`,
+                    "batch.CloseProject(prj)",
+                ].join("\n") + "\n";
+                const br = await runScript(script, logPath);
+                return batchResultToResponse(br, { outputPath: outPath });
+            }
+            case "file_upload": {
+                if (!args.plc_path || !args.local_path) {
+                    return {
+                        content: [{ type: "text", text: "plc_path and local_path are required for action 'file_upload'" }],
+                        isError: true,
+                    };
+                }
+                // Upload transfers file from PLC (src) to host (dest)
+                const script = [
+                    "# -*- coding: utf-8 -*-",
+                    "import sigmatek.lasal.batch as batch",
+                    `batch.OpenLogfile(${emitPath(logPath)})`,
+                    `prj = batch.LoadProject(${emitPath(resolved.path)})`,
+                    `ok = batch.UploadFile(prj, ${emitPy27String(conn)}, ${emitPy27String(args.plc_path)}, ${emitPy27String(args.local_path)})`,
+                    "batch.CloseProject(prj)",
+                    `if not ok: raise RuntimeError("UploadFile failed")`,
+                ].join("\n") + "\n";
+                const br = await runScript(script, logPath);
+                return batchResultToResponse(br);
+            }
+            case "file_download": {
+                if (!args.plc_path || !args.local_path) {
+                    return {
+                        content: [
+                            { type: "text", text: "plc_path and local_path are required for action 'file_download'" },
+                        ],
+                        isError: true,
+                    };
+                }
+                // Download transfers file from host (src) to PLC (dest)
+                const script = [
+                    "# -*- coding: utf-8 -*-",
+                    "import sigmatek.lasal.batch as batch",
+                    `batch.OpenLogfile(${emitPath(logPath)})`,
+                    `prj = batch.LoadProject(${emitPath(resolved.path)})`,
+                    `ok = batch.DownloadFile(prj, ${emitPy27String(conn)}, ${emitPy27String(args.local_path)}, ${emitPy27String(args.plc_path)})`,
+                    "batch.CloseProject(prj)",
+                    `if not ok: raise RuntimeError("DownloadFile failed")`,
+                ].join("\n") + "\n";
+                const br = await runScript(script, logPath);
+                return batchResultToResponse(br);
+            }
+            case "file_delete": {
+                if (!args.plc_path) {
+                    return {
+                        content: [{ type: "text", text: "plc_path is required for action 'file_delete'" }],
+                        isError: true,
+                    };
+                }
+                const script = [
+                    "# -*- coding: utf-8 -*-",
+                    "import sigmatek.lasal.batch as batch",
+                    `batch.OpenLogfile(${emitPath(logPath)})`,
+                    `prj = batch.LoadProject(${emitPath(resolved.path)})`,
+                    `ok = batch.DeleteFileOnPLC(prj, ${emitPy27String(conn)}, ${emitPy27String(args.plc_path)})`,
+                    "batch.CloseProject(prj)",
+                    `if not ok: raise RuntimeError("DeleteFileOnPLC failed")`,
+                ].join("\n") + "\n";
+                const br = await runScript(script, logPath);
+                return batchResultToResponse(br);
+            }
+            case "code_analysis": {
+                const outPath = args.output_path || join(SCRATCH, `analysis_${id}.xml`);
+                const script = [
+                    "# -*- coding: utf-8 -*-",
+                    "import sigmatek.lasal.batch as batch",
+                    `batch.OpenLogfile(${emitPath(logPath)})`,
+                    `prj = batch.LoadProject(${emitPath(resolved.path)})`,
+                    `ok = batch.DoCodeAnalysisOnProjekt(prj, ${emitPy27String(outPath)})`,
+                    "batch.CloseProject(prj)",
+                    `if not ok: raise RuntimeError("DoCodeAnalysisOnProjekt failed")`,
+                ].join("\n") + "\n";
+                const br = await runScript(script, logPath);
+                let summary = {};
+                if (br.ok && existsSync(outPath)) {
+                    try {
+                        const rawXml = readFileSync(outPath, "utf-8");
+                        const parser = new XMLParser({ ignoreAttributes: false, attributeNamePrefix: "" });
+                        const parsed = parser.parse(rawXml);
+                        summary = parsed;
+                    }
+                    catch (e) {
+                        summary = { error: `Failed to parse analysis XML: ${e.message}`, path: outPath };
+                    }
+                }
+                return batchResultToResponse(br, { analysisResult: summary });
+            }
+            default:
+                return { content: [{ type: "text", text: `Unknown action: ${args.action}` }], isError: true };
+        }
+    });
+}

package/dist/tools/readClassSource.js

@@ -0,0 +1,147 @@
+import { existsSync, readFileSync, writeFileSync } from "fs";
+import { z } from "zod";
+import { resolveLcpPath } from "../utils/resolvePaths.js";
+import { parseLcp, parseStClass } from "../utils/lasalXml.js";
+import { isProcessRunning } from "../utils/engine.js";
+import { respond, fail } from "../utils/respond.js";
+export const classSourceSchema = {
+    action: z.enum(["read", "write"]).describe("'read' returns the source; 'write' overwrites it."),
+    class_name: z.string().describe("Name of the CLASS 2 class (e.g. 'Palletizer')."),
+    lcp_path: z.string().optional().describe("Absolute path to the .lcp file. Omit to use the selected project."),
+    include_header: z
+        .boolean()
+        .optional()
+        .default(false)
+        .describe("Also return the .h file contents (read only). Default false."),
+    source: z
+        .string()
+        .optional()
+        .describe("Full content to write to the .st file — must be latin1-compatible (write only)."),
+    header_source: z
+        .string()
+        .optional()
+        .describe("Content to write to the .h file. Omit to leave it unchanged (write only)."),
+};
+function resolveStPath(lcpPath, className) {
+    let lcpInfo;
+    try {
+        lcpInfo = parseLcp(lcpPath);
+    }
+    catch (e) {
+        return { error: `Failed to parse .lcp: ${e.message}` };
+    }
+    for (const cf of lcpInfo.classFiles) {
+        if (!cf.absPath.endsWith(".st") || !existsSync(cf.absPath))
+            continue;
+        try {
+            const info = parseStClass(cf.absPath);
+            if (info.name === className)
+                return { stPath: cf.absPath };
+        }
+        catch {
+            /* skip */
+        }
+    }
+    const available = lcpInfo.classFiles
+        .filter((f) => f.absPath.endsWith(".st") && existsSync(f.absPath))
+        .map((f) => {
+        try {
+            return parseStClass(f.absPath).name;
+        }
+        catch {
+            return null;
+        }
+    })
+        .filter((x) => x !== null);
+    return { error: `Class "${className}" not found.\nAvailable classes: ${available.join(", ")}` };
+}
+function validateLatin1(s) {
+    const offending = [];
+    for (let i = 0; i < s.length; i++) {
+        const code = s.charCodeAt(i);
+        if (code > 0xff) {
+            offending.push({ char: s[i], code, index: i });
+            if (offending.length >= 10)
+                break;
+        }
+    }
+    return {
+        ok: offending.length === 0,
+        offending: offending.length > 0 ? offending : undefined,
+    };
+}
+export async function classSourceHandler(args) {
+    const resolved = resolveLcpPath(args.lcp_path);
+    if ("error" in resolved) {
+        return fail(resolved.error, ["Select a project first using select_project or specify lcp_path."]);
+    }
+    const found = resolveStPath(resolved.path, args.class_name);
+    if ("error" in found) {
+        return fail(found.error, ["Make sure the class name is typed correctly."]);
+    }
+    const { stPath } = found;
+    if (args.action === "read") {
+        const result = {
+            ok: true,
+            className: args.class_name,
+            stPath,
+            source: readFileSync(stPath, "latin1"),
+        };
+        if (args.include_header) {
+            const hPath = stPath.replace(/\.st$/, ".h");
+            if (existsSync(hPath)) {
+                result.hPath = hPath;
+                result.headerSource = readFileSync(hPath, "latin1");
+            }
+        }
+        return respond(result);
+    }
+    // write
+    if (isProcessRunning("Lasal2.exe")) {
+        return fail("CLASS 2 IDE is open.", [
+            "Close the CLASS 2 IDE manually or run manage_class2 close before writing to Structured Text class files.",
+        ]);
+    }
+    if (!args.source) {
+        return fail("source is required for action 'write'", ["Provide the source parameter."]);
+    }
+    // Validate latin1
+    const validation = validateLatin1(args.source);
+    if (!validation.ok) {
+        const details = validation.offending.map((o) => `'${o.char}' (code: ${o.code}) at index ${o.index}`).join(", ");
+        return fail("Source contains non-latin1 characters.", [
+            "Make sure all characters in the source are representable in ISO-8859-1 (latin1). Offending characters: " +
+                details,
+        ]);
+    }
+    if (args.header_source !== undefined) {
+        const hValidation = validateLatin1(args.header_source);
+        if (!hValidation.ok) {
+            const details = hValidation.offending.map((o) => `'${o.char}' (code: ${o.code}) at index ${o.index}`).join(", ");
+            return fail("Header source contains non-latin1 characters.", [
+                "Make sure all characters in the header source are representable in ISO-8859-1 (latin1). Offending characters: " +
+                    details,
+            ]);
+        }
+    }
+    const result = { ok: true, className: args.class_name, stPath };
+    try {
+        writeFileSync(stPath, args.source, "latin1");
+        result.stWritten = true;
+    }
+    catch (e) {
+        return fail(`Failed to write .st file: ${e.message}`, []);
+    }
+    if (args.header_source !== undefined) {
+        const hPath = stPath.replace(/\.st$/, ".h");
+        try {
+            writeFileSync(hPath, args.header_source, "latin1");
+            result.hPath = hPath;
+            result.hWritten = true;
+        }
+        catch (e) {
+            result.hError = `Failed to write .h file: ${e.message}`;
+        }
+    }
+    return respond(result);
+}

package/dist/tools/selectProject.js

@@ -0,0 +1,47 @@
+import { existsSync } from "fs";
+import { z } from "zod";
+import { readState, writeState } from "../state.js";
+import { findLsmPath, parseSolution } from "../utils/projectScanner.js";
+export const selectProjectSchema = {
+    path: z.string().describe("Full path to the LASAL solution folder (must contain a .lsm file)."),
+};
+export async function selectProjectHandler(args) {
+    const lsmPath = findLsmPath(args.path);
+    if (!lsmPath || !existsSync(lsmPath)) {
+        return {
+            content: [
+                {
+                    type: "text",
+                    text: `Error: no .lsm file found in ${args.path}\nMake sure the path points to a valid LASAL solution folder.`,
+                },
+            ],
+            isError: true,
+        };
+    }
+    const state = readState();
+    state.currentProject = args.path;
+    writeState(state);
+    // Discover stations so the agent immediately knows available paths
+    let summary = { selectedPath: args.path };
+    try {
+        const solution = parseSolution(lsmPath);
+        summary.stations = solution.stations.map((s) => ({
+            name: s.name,
+            ip: s.ip ?? null,
+            port: s.port ?? "1954",
+            ssltls: s.ssltls === "1",
+            lcpPaths: s.lcpPaths,
+            lvpPaths: s.lvpPaths,
+        }));
+        summary.hint =
+            solution.stations.length > 1
+                ? "Multiple stations found. Pass lcp_path or lvp_path explicitly to tools that need them."
+                : "Single station found. Tools will auto-resolve lcp_path / lvp_path.";
+    }
+    catch {
+        summary.hint = "Could not parse solution file for station discovery.";
+    }
+    return {
+        content: [{ type: "text", text: JSON.stringify(summary, null, 2) }],
+    };
+}

package/dist/tools/setTargetIp.js

@@ -0,0 +1,114 @@
+import { existsSync } from "fs";
+import { z } from "zod";
+import { readState } from "../state.js";
+import { findLsmPath, parseSolution, updateLssConnection } from "../utils/projectScanner.js";
+export const setTargetIpSchema = {
+    station: z
+        .string()
+        .optional()
+        .describe("Station name to update (e.g. 'PLC', 'HMI'). Omit if the project has only one station."),
+    ip: z.string().optional().describe("New IP address (e.g. '192.168.1.100')."),
+    port: z.string().optional().describe("New port (default '1954'). Only change if non-standard."),
+    ssltls: z.boolean().optional().describe("Enable SSL/TLS for the connection. Omit to leave unchanged."),
+};
+export async function setTargetIpHandler(args) {
+    if (!args.ip && args.port === undefined && args.ssltls === undefined) {
+        return {
+            content: [{ type: "text", text: "Error: specify at least one of ip, port, or ssltls to update." }],
+            isError: true,
+        };
+    }
+    const state = readState();
+    if (!state.currentProject) {
+        return {
+            content: [{ type: "text", text: "No project selected. Call select_project first." }],
+            isError: true,
+        };
+    }
+    const lsmPath = findLsmPath(state.currentProject);
+    if (!lsmPath || !existsSync(lsmPath)) {
+        return {
+            content: [{ type: "text", text: `No .lsm file found in ${state.currentProject}` }],
+            isError: true,
+        };
+    }
+    let solution;
+    try {
+        solution = parseSolution(lsmPath);
+    }
+    catch (e) {
+        return {
+            content: [{ type: "text", text: `Failed to parse solution: ${e.message}` }],
+            isError: true,
+        };
+    }
+    if (solution.stations.length === 0) {
+        return {
+            content: [{ type: "text", text: "No stations found in solution." }],
+            isError: true,
+        };
+    }
+    let targetStation = solution.stations[0];
+    if (!targetStation) {
+        return {
+            content: [{ type: "text", text: "No stations found in solution." }],
+            isError: true,
+        };
+    }
+    if (args.station) {
+        const match = solution.stations.find((s) => s.name.toLowerCase() === args.station.toLowerCase());
+        if (!match) {
+            const names = solution.stations.map((s) => s.name).join(", ");
+            return {
+                content: [{ type: "text", text: `Station "${args.station}" not found. Available: ${names}` }],
+                isError: true,
+            };
+        }
+        targetStation = match;
+    }
+    else if (solution.stations.length > 1) {
+        const names = solution.stations.map((s) => `${s.name} (${s.ip ?? "no IP"})`).join(", ");
+        return {
+            content: [
+                {
+                    type: "text",
+                    text: `Multiple stations found — specify 'station':\n${names}`,
+                },
+            ],
+            isError: true,
+        };
+    }
+    try {
+        updateLssConnection(targetStation.lssPath, {
+            ip: args.ip,
+            port: args.port,
+            ssltls: args.ssltls !== undefined ? (args.ssltls ? "1" : "0") : undefined,
+        });
+    }
+    catch (e) {
+        return {
+            content: [{ type: "text", text: `Failed to update .lss: ${e.message}` }],
+            isError: true,
+        };
+    }
+    const updates = [];
+    if (args.ip)
+        updates.push(`IP → ${args.ip}`);
+    if (args.port)
+        updates.push(`PORT → ${args.port}`);
+    if (args.ssltls !== undefined)
+        updates.push(`SSLTLS → ${args.ssltls ? "1" : "0"}`);
+    return {
+        content: [
+            {
+                type: "text",
+                text: JSON.stringify({
+                    ok: true,
+                    station: targetStation.name,
+                    lssPath: targetStation.lssPath,
+                    updated: updates,
+                }, null, 2),
+            },
+        ],
+    };
+}

package/dist/tools/status.js

@@ -0,0 +1,146 @@
+import { existsSync } from "fs";
+import { readState, getHmiForProject } from "../state.js";
+import { findLsmPath, parseSolution, findLcpFiles, findLvpFiles } from "../utils/projectScanner.js";
+import { CLASS2_EXE, VISUDESIGNER_EXE, resolveDataServiceExe, isProcessRunning, getProcessPid, } from "../utils/engine.js";
+import { pingHost } from "../utils/preflight.js";
+import { LARS_EXE, readLarsWorkspaces, getLarsPids, isLarsHealthy, larsConfigPath } from "../utils/lars.js";
+import { respond } from "../utils/respond.js";
+import { checkHttpHealth } from "../core/http.js";
+export const lasalStatusSchema = {};
+export async function lasalStatusHandler() {
+    const state = readState();
+    const projDir = state.currentProject;
+    const projectInfo = {
+        selected: projDir,
+        lcpPaths: projDir ? findLcpFiles(projDir) : [],
+        lvpPaths: projDir ? findLvpFiles(projDir) : [],
+    };
+    const stations = [];
+    if (projDir) {
+        const lsmPath = findLsmPath(projDir);
+        if (lsmPath) {
+            try {
+                const soln = parseSolution(lsmPath);
+                for (const stn of soln.stations) {
+                    const ip = stn.ip ?? "";
+                    let reachable = false;
+                    if (ip) {
+                        reachable = await pingHost(ip, parseInt(stn.port ?? "1954", 10) || 1954, 1000);
+                    }
+                    stations.push({
+                        name: stn.name,
+                        ip: stn.ip,
+                        port: stn.port ?? "1954",
+                        reachable,
+                        lcp: stn.lcpPaths[0] ?? null,
+                        lvp: stn.lvpPaths[0] ?? null,
+                    });
+                }
+            }
+            catch { }
+        }
+    }
+    const dsResult = resolveDataServiceExe();
+    const engines = {
+        class2: { path: CLASS2_EXE, exists: existsSync(CLASS2_EXE) },
+        visuDesigner: { path: VISUDESIGNER_EXE, exists: existsSync(VISUDESIGNER_EXE) },
+        dataService: {
+            path: dsResult.path,
+            exists: dsResult.path ? existsSync(dsResult.path) : false,
+            resolvedVia: process.env.LASAL_DATASERVICE_EXE ? "env" : "glob",
+            ...(dsResult.path === "" ? { searched: dsResult.searched } : {}),
+        },
+        lars: {
+            path: LARS_EXE,
+            exists: existsSync(LARS_EXE),
+            configPath: larsConfigPath(),
+        },
+    };
+    const processes = {
+        class2Running: isProcessRunning("Lasal2.exe"),
+        visuDesignerRunning: isProcessRunning("VISUDesigner.exe"),
+        dataServicePid: getProcessPid("LasalVISUDataService.exe"),
+    };
+    // Check HMI runtime health (per project)
+    const hmiRuntimeInfo = await (async () => {
+        const running = getHmiForProject(state, projDir ?? undefined);
+        if (running) {
+            const pid = running.pid;
+            const port = running.port;
+            const url = running.url;
+            const isRunning = processes.dataServicePid === pid;
+            let healthy = false;
+            if (isRunning && port) {
+                healthy = await checkHttpHealth(`http://127.0.0.1:${port}/`);
+            }
+            return {
+                running: isRunning,
+                pid,
+                port,
+                url,
+                healthy,
+            };
+        }
+        if (processes.dataServicePid) {
+            // Found untracked DataService running
+            return {
+                running: true,
+                pid: processes.dataServicePid,
+                healthy: await checkHttpHealth(`http://127.0.0.1:9980/`), // Try standard port
+            };
+        }
+        return { running: false };
+    })();
+    // LARS instances (from lasalos2.xml workspace config)
+    const larsWorkspaces = readLarsWorkspaces();
+    const larsInstances = state.larsInstances ?? {};
+    const lars = {
+        configured: await Promise.all(larsWorkspaces.map(async (w) => {
+            const inst = larsInstances[w.name];
+            const pids = getLarsPids(w.name);
+            const running = pids.length > 0;
+            return {
+                name: w.name,
+                onlinePort: w.onlinePort,
+                running,
+                pid: pids[0] ?? inst?.pid ?? null,
+                healthy: running ? await isLarsHealthy(w.onlinePort) : false,
+                stationName: inst?.stationName ?? null,
+                lcpPath: inst?.lcpPath ?? null,
+                targetedAtLars: inst?.originalIp ? true : false,
+            };
+        })),
+    };
+    const hints = [];
+    if (!projDir) {
+        hints.push("No project is currently selected. Use select_project with the path to your project folder first.");
+    }
+    else {
+        if (stations.length === 0) {
+            hints.push("No stations found. Check if the project is structured correctly with an .lsm file.");
+        }
+        else {
+            const unreachable = stations.filter((s) => !s.reachable);
+            if (unreachable.length > 0) {
+                const larsHints = lars.configured.filter((l) => l.running && l.stationName).map((l) => l.stationName);
+                hints.push(`Some stations are unreachable (${unreachable.map((u) => u.name).join(", ")}). ` +
+                    (larsHints.length
+                        ? `LARS is running for: ${larsHints.join(", ")} — use lars_runtime set_station_target to point those stations at LARS.`
+                        : "No real PLC/HMI on the network? Use lars_runtime setup + start to simulate stations locally."));
+            }
+        }
+        if (processes.class2Running) {
+            hints.push("CLASS 2 IDE is open. Close it manually or call manage_class2 close before running batch operations (compile/download).");
+        }
+    }
+    return respond({
+        ok: true,
+        project: projectInfo,
+        stations,
+        engines,
+        processes,
+        hmiRuntime: hmiRuntimeInfo,
+        lars,
+        hints,
+    });
+}