lasal-mcp 0.1.0

package/dist/tools/deployAll.js

@@ -0,0 +1,320 @@
+import { z } from "zod";
+import { join } from "path";
+import { randomUUID } from "crypto";
+import { existsSync, readFileSync } from "fs";
+import { runBatchOps, runScript, emitPy27String, emitPath, buildRawScript } from "../utils/batchScript.js";
+import { runVisuOps } from "../utils/visuScript.js";
+import { resolveLcpPath, resolveLvpPath } from "../utils/resolvePaths.js";
+import { withEngineLock, SCRATCH } from "../utils/engine.js";
+import { startHmiRuntime } from "./hmiRuntime.js";
+import { TIMEOUTS } from "../utils/config.js";
+import { preflightPlc, preflightHmi, resolveConnection, isLoopbackTarget } from "../utils/preflight.js";
+import { respond, fail } from "../utils/respond.js";
+import { batchToStepResult, visuToStepResult } from "../core/response.js";
+import { isTransientError } from "../core/errors.js";
+import { ensureScratch } from "../core/scratch.js";
+export const deployAllSchema = {
+    lcp_path: z.string().optional().describe("Absolute path to the .lcp file. Omit to use the selected project."),
+    lvp_path: z
+        .string()
+        .optional()
+        .describe("Absolute path to the .lvp file. Omit to auto-detect from the selected project."),
+    plc_connection: z
+        .string()
+        .optional()
+        .describe("PLC connection string (e.g. 'TCPIP:192.168.1.100'). Omit to use the connection saved in the project's .lss file."),
+    visu_connection: z
+        .string()
+        .optional()
+        .describe("HMI connection string (e.g. 'TCPIP:192.168.1.100'). Required when download_visu is true."),
+    compile: z.boolean().optional().default(true).describe("Compile the CLASS 2 project. Default true."),
+    compile_options: z
+        .enum(["RebuildAll", "BuildChanges"])
+        .optional()
+        .default("RebuildAll")
+        .describe("Compile mode. RebuildAll is safest; BuildChanges is faster for incremental work."),
+    download_plc: z
+        .boolean()
+        .optional()
+        .default(true)
+        .describe("Download the compiled CLASS 2 project to the PLC. Default true."),
+    update_visu_stations: z
+        .boolean()
+        .optional()
+        .default(true)
+        .describe("Run update_all_stations on the VISUDesigner project to sync datapoints after CLASS 2 changes. Default true."),
+    download_visu: z
+        .boolean()
+        .optional()
+        .default(false)
+        .describe("Download the VISUDesigner project to the HMI after updating stations. Requires visu_connection. Default false."),
+    visu_download_flags: z
+        .number()
+        .int()
+        .optional()
+        .default(0)
+        .describe("VISUDesigner download mode: 0=normal (default), 1=changes only, 2=publish+download changes."),
+    add_plc_loader: z
+        .boolean()
+        .optional()
+        .default(false)
+        .describe("Force loader download to PLC even if the target already has a compatible loader."),
+    add_visu_runtime: z
+        .boolean()
+        .optional()
+        .default(false)
+        .describe("Force runtime download to HMI even if the version already matches."),
+    start_plc: z
+        .boolean()
+        .optional()
+        .default(true)
+        .describe("Start the PLC runtime after a successful download. Default true."),
+    start_hmi_runtime: z
+        .boolean()
+        .optional()
+        .default(false)
+        .describe("Start the local HMI runtime (DataService) and copy HMI files after a successful compilation/update. Default false."),
+    timeout_s: z.number().int().optional().describe("Timeout override in seconds for compile and download steps."),
+};
+export async function deployAllHandler(args) {
+    return withEngineLock(async () => {
+        const doCompile = args.compile ?? true;
+        const doDownloadPlc = args.download_plc ?? true;
+        const doStartPlc = doDownloadPlc && (args.start_plc ?? true);
+        const doUpdateVisuStations = args.update_visu_stations ?? true;
+        const doDownloadVisu = args.download_visu ?? false;
+        const steps = {};
+        // Validate paths upfront
+        let lcpPath;
+        if (doCompile || doDownloadPlc) {
+            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."]);
+            }
+            lcpPath = resolved.path;
+        }
+        let lvpPath;
+        if (doUpdateVisuStations || doDownloadVisu || args.start_hmi_runtime) {
+            const resolved = resolveLvpPath(args.lvp_path);
+            if ("error" in resolved) {
+                return fail(resolved.error, ["Select a project first using select_project or specify lvp_path."]);
+            }
+            lvpPath = resolved.path;
+        }
+        if (doDownloadVisu && !args.visu_connection) {
+            return fail("visu_connection is required when download_visu is true.", ["Provide visu_connection."]);
+        }
+        // Resolve connections and preflight upfront
+        const plcConnectionInfo = lcpPath
+            ? resolveConnection(lcpPath, args.plc_connection)
+            : { connection: "", source: "none", ip: undefined, port: undefined };
+        const plcIp = plcConnectionInfo.ip ?? "";
+        const plcConnectionUsed = plcConnectionInfo.connection;
+        if (doDownloadPlc || doStartPlc) {
+            const pfPlc = await preflightPlc(lcpPath, args.plc_connection);
+            if (!pfPlc.ok) {
+                return respond({
+                    ok: false,
+                    preflightPlc: pfPlc,
+                    connections: {
+                        plc: { ip: plcIp, source: plcConnectionInfo.source, connection: plcConnectionUsed },
+                    },
+                    errors: pfPlc.problems.map((p) => p.message),
+                    hints: pfPlc.problems.map((p) => p.fix),
+                });
+            }
+        }
+        let visuIp = "";
+        if (doDownloadVisu) {
+            const pfHmi = await preflightHmi(lvpPath, args.visu_connection);
+            const m = args.visu_connection.match(/TCPIP:(.+)/i);
+            visuIp = m?.[1]?.split(":")[0] ?? args.visu_connection ?? "";
+            if (!pfHmi.ok) {
+                return respond({
+                    ok: false,
+                    preflightHmi: pfHmi,
+                    connections: {
+                        plc: { ip: plcIp, source: plcConnectionInfo.source, connection: plcConnectionUsed },
+                        visu: { ip: visuIp, connection: args.visu_connection ?? "" },
+                    },
+                    errors: pfHmi.problems.map((p) => p.message),
+                    hints: pfHmi.problems.map((p) => p.fix),
+                });
+            }
+        }
+        function failResponse(msg, hints = []) {
+            const body = {
+                ok: false,
+                steps,
+                connections: {
+                    plc: { ip: plcIp, source: plcConnectionInfo.source, connection: plcConnectionUsed },
+                    ...(doDownloadVisu ? { visu: { ip: visuIp, connection: args.visu_connection ?? "" } } : {}),
+                },
+                hints,
+            };
+            if (msg)
+                body.error = msg;
+            return respond(body);
+        }
+        // Step 1: compile
+        if (doCompile) {
+            const timeoutMs = args.timeout_s ? args.timeout_s * 1000 : TIMEOUTS.compile;
+            const br = await runBatchOps(lcpPath, [{ type: "compile", optionName: args.compile_options ?? "RebuildAll" }], timeoutMs);
+            steps.compile = batchToStepResult(br);
+            if (!br.ok)
+                return failResponse("Compilation step failed.", br.hints ?? []);
+        }
+        // Step 2: download PLC
+        if (doDownloadPlc) {
+            const timeoutMs = args.timeout_s ? args.timeout_s * 1000 : TIMEOUTS.download;
+            // LARS (local runtime) targets need the PC loader or the download ends in "Linker_Error".
+            const addLoaderAnyway = args.add_plc_loader ?? isLoopbackTarget(plcConnectionInfo);
+            let br = await runBatchOps(lcpPath, [
+                {
+                    type: "download",
+                    connection: plcConnectionUsed,
+                    addLoaderAnyway,
+                },
+            ], timeoutMs);
+            if (!br.ok && isTransientError(br.errors)) {
+                await new Promise((resolve) => setTimeout(resolve, 1000));
+                br = await runBatchOps(lcpPath, [
+                    {
+                        type: "download",
+                        connection: plcConnectionUsed,
+                        addLoaderAnyway,
+                    },
+                ], timeoutMs);
+                br.hints = [...(br.hints ?? []), "Retried download once due to a transient connection failure."];
+            }
+            steps.download_plc = batchToStepResult(br);
+            if (!br.ok)
+                return failResponse("PLC download step failed.", br.hints ?? []);
+        }
+        // Step 2a: verify PLC after download
+        if (doDownloadPlc) {
+            ensureScratch();
+            const id = randomUUID();
+            const logPath = join(SCRATCH, `${id}.log`);
+            const stepsPath = join(SCRATCH, `${id}.steps`);
+            const resultPath = join(SCRATCH, `${id}.state.json`);
+            const conn = plcConnectionUsed;
+            const bodyLines = [
+                "state_map = {}",
+                "for attr_name in dir(batch.PLCStates):",
+                "    if not attr_name.startswith('_'):",
+                "        try: state_map[int(getattr(batch.PLCStates, attr_name))] = attr_name",
+                "        except: pass",
+                `state_val = batch.GetPlcState(prj, ${emitPy27String(conn)})`,
+                "state_int = int(state_val)",
+                "state_name = state_map.get(state_int, 'Unknown(%d)' % state_int)",
+                "result = {'stateValue': state_int, 'stateName': state_name}",
+                "import json",
+                `f_state = open(${emitPath(resultPath)}, 'w')`,
+                "json.dump(result, f_state)",
+                "f_state.close()",
+            ];
+            const script = buildRawScript(lcpPath, bodyLines, logPath, stepsPath, ["get_state"]);
+            let br = await runScript(script, logPath, TIMEOUTS.script, ["get_state"], stepsPath);
+            let stateData = {};
+            if (existsSync(resultPath)) {
+                try {
+                    stateData = JSON.parse(readFileSync(resultPath, "utf-8"));
+                }
+                catch { }
+            }
+            steps.verify_plc = {
+                ...batchToStepResult(br),
+                plcState: stateData,
+            };
+            if (!br.ok)
+                return failResponse("PLC verification step failed.", br.hints ?? []);
+        }
+        // Step 2b: start PLC after download
+        if (doStartPlc) {
+            ensureScratch();
+            const id = randomUUID();
+            const logPath = join(SCRATCH, `${id}.log`);
+            const stepsPath = join(SCRATCH, `${id}.steps`);
+            const resultPath = join(SCRATCH, `${id}.state.json`);
+            const conn = plcConnectionUsed;
+            const bodyLines = [
+                `batch.Start(prj, ${emitPy27String(conn)})`,
+                "import time",
+                "time.sleep(1.0)",
+                "state_map = {}",
+                "for attr_name in dir(batch.PLCStates):",
+                "    if not attr_name.startswith('_'):",
+                "        try: state_map[int(getattr(batch.PLCStates, attr_name))] = attr_name",
+                "        except: pass",
+                `state_val = batch.GetPlcState(prj, ${emitPy27String(conn)})`,
+                "state_int = int(state_val)",
+                "state_name = state_map.get(state_int, 'Unknown(%d)' % state_int)",
+                "result = {'stateValue': state_int, 'stateName': state_name}",
+                "import json",
+                `f_state = open(${emitPath(resultPath)}, 'w')`,
+                "json.dump(result, f_state)",
+                "f_state.close()",
+            ];
+            const script = buildRawScript(lcpPath, bodyLines, logPath, stepsPath, ["start"]);
+            let br = await runScript(script, logPath, TIMEOUTS.script, ["start"], stepsPath);
+            if (!br.ok && isTransientError(br.errors)) {
+                await new Promise((resolve) => setTimeout(resolve, 1000));
+                br = await runScript(script, logPath, TIMEOUTS.script, ["start"], stepsPath);
+                br.hints = [...(br.hints ?? []), "Retried start once due to a transient connection failure."];
+            }
+            let stateData = {};
+            if (existsSync(resultPath)) {
+                try {
+                    stateData = JSON.parse(readFileSync(resultPath, "utf-8"));
+                }
+                catch { }
+            }
+            steps.start_plc = {
+                ...batchToStepResult(br),
+                postStartState: stateData,
+            };
+            if (!br.ok)
+                return failResponse("PLC start step failed.", br.hints ?? []);
+        }
+        // Step 3: update visu stations + optional download
+        if (doUpdateVisuStations || doDownloadVisu) {
+            const visuOps = [];
+            if (doUpdateVisuStations)
+                visuOps.push({ type: "update_all_stations" });
+            if (doDownloadVisu)
+                visuOps.push({
+                    type: "download",
+                    connection: args.visu_connection,
+                    flags: args.visu_download_flags ?? 0,
+                    add_runtime: args.add_visu_runtime ?? false,
+                });
+            const vr = await runVisuOps(lvpPath, visuOps, true, TIMEOUTS.visu);
+            steps.visu = visuToStepResult(vr);
+            if (!vr.ok)
+                return failResponse("Visu designer operations step failed.", vr.hints ?? []);
+        }
+        // Step 4: start HMI runtime
+        if (args.start_hmi_runtime) {
+            const startStart = Date.now();
+            const hmiRes = await startHmiRuntime({ action: "start", lvp_path: lvpPath });
+            steps.hmi_runtime = {
+                ok: !hmiRes.isError,
+                durationMs: Date.now() - startStart,
+                ...(hmiRes.isError
+                    ? { errors: [hmiRes.content[0]?.text ?? "Unknown error"] }
+                    : { logTail: [`HMI started: ${hmiRes.content[0]?.text ?? "started"}`] }),
+            };
+            if (hmiRes.isError)
+                return failResponse("HMI runtime start step failed.");
+        }
+        return respond({
+            ok: true,
+            steps,
+            connections: {
+                plc: { ip: plcIp, source: plcConnectionInfo.source, connection: plcConnectionUsed },
+                ...(doDownloadVisu ? { visu: { ip: visuIp, connection: args.visu_connection ?? "" } } : {}),
+            },
+        });
+    });
+}

package/dist/tools/hmiBrowser.js

@@ -0,0 +1,224 @@
+import { z } from "zod";
+import { chromium } from "playwright-core";
+import { readState } from "../state.js";
+import { EDGE_EXE } from "../utils/engine.js";
+import { checkHttpHealth } from "../core/http.js";
+import { findLsmPath, parseSolution } from "../utils/projectScanner.js";
+/** Find the live HMI panel URL: the station that owns an .lvp project, served on port 80. */
+async function findLiveHmiUrl() {
+    const state = readState();
+    if (!state.currentProject)
+        return null;
+    try {
+        const lsmPath = findLsmPath(state.currentProject);
+        if (!lsmPath)
+            return null;
+        const solution = parseSolution(lsmPath);
+        const hmiStation = solution.stations.find((s) => s.lvpPaths.length > 0 && s.ip);
+        if (!hmiStation?.ip)
+            return null;
+        const url = `http://${hmiStation.ip}/`;
+        const reachable = await checkHttpHealth(url, 2000, true);
+        return reachable ? url : null;
+    }
+    catch {
+        return null;
+    }
+}
+export const hmiBrowserSchema = {
+    action: z
+        .enum(["open", "screenshot", "console", "eval", "click", "type", "wait", "close"])
+        .describe("Action to perform in the HMI browser session."),
+    url: z
+        .string()
+        .optional()
+        .describe("URL to navigate to (open action only). Defaults to the live HMI panel (http://<hmi-station-ip>/) when reachable, else the local HMI runtime URL."),
+    viewport: z
+        .object({
+        width: z.number().int(),
+        height: z.number().int(),
+    })
+        .optional()
+        .describe("Browser viewport size (open action only). Defaults to 1200x800."),
+    fullPage: z.boolean().optional().default(false).describe("Take a full page screenshot (screenshot action only)."),
+    selector: z.string().optional().describe("CSS/Text selector to screenshot, click, type, or wait for."),
+    text: z.string().optional().describe("Text content to type, or to find for clicking."),
+    x: z.number().int().optional().describe("X coordinate for mouse click."),
+    y: z.number().int().optional().describe("Y coordinate for mouse click."),
+    expression: z.string().optional().describe("JavaScript expression to evaluate (eval action only)."),
+    ms: z.number().int().optional().describe("Milliseconds to wait (wait action only)."),
+    clear: z
+        .boolean()
+        .optional()
+        .default(false)
+        .describe("Clear the console/error buffers after reading them (console action only)."),
+};
+let browser = null;
+let context = null;
+let page = null;
+const consoleLogs = [];
+const pageErrors = [];
+async function ensureBrowser() {
+    if (browser)
+        return;
+    const launchOptions = {
+        headless: true,
+    };
+    if (EDGE_EXE) {
+        launchOptions.executablePath = EDGE_EXE;
+    }
+    else {
+        launchOptions.channel = "msedge";
+    }
+    browser = await chromium.launch(launchOptions);
+    context = await browser.newContext();
+    page = await context.newPage();
+    page.on("console", (msg) => {
+        consoleLogs.push(`[${msg.type()}] ${msg.text()}`);
+        if (consoleLogs.length > 500)
+            consoleLogs.shift();
+    });
+    page.on("pageerror", (err) => {
+        pageErrors.push(err.stack || err.message);
+        if (pageErrors.length > 100)
+            pageErrors.shift();
+    });
+}
+export async function hmiBrowserHandler(args) {
+    try {
+        if (args.action === "close") {
+            if (browser) {
+                await browser.close();
+                browser = null;
+                context = null;
+                page = null;
+            }
+            return { content: [{ type: "text", text: "Browser session closed." }] };
+        }
+        await ensureBrowser();
+        const p = page;
+        switch (args.action) {
+            case "open": {
+                const state = readState();
+                // Default: live HMI panel if reachable, else the local simulation runtime
+                const targetUrl = args.url || (await findLiveHmiUrl()) || state.hmiRuntime?.url || "file:///C:/lslvisu/index.html";
+                const width = args.viewport?.width ?? 1200;
+                const height = args.viewport?.height ?? 800;
+                await p.setViewportSize({ width, height });
+                await p.goto(targetUrl, { waitUntil: "networkidle", timeout: 15000 });
+                // Also wait a brief moment for HMI animation to settle
+                await new Promise((resolve) => setTimeout(resolve, 1500));
+                return {
+                    content: [
+                        { type: "text", text: `Successfully opened ${targetUrl} with viewport ${width}x${height}` },
+                    ],
+                };
+            }
+            case "screenshot": {
+                let buffer;
+                if (args.selector) {
+                    buffer = await p.locator(args.selector).screenshot();
+                }
+                else {
+                    buffer = await p.screenshot({ fullPage: args.fullPage });
+                }
+                return {
+                    content: [
+                        {
+                            type: "image",
+                            data: buffer.toString("base64"),
+                            mimeType: "image/png",
+                        },
+                    ],
+                };
+            }
+            case "console": {
+                const logs = [...consoleLogs];
+                const errors = [...pageErrors];
+                if (args.clear) {
+                    consoleLogs.length = 0;
+                    pageErrors.length = 0;
+                }
+                return {
+                    content: [
+                        {
+                            type: "text",
+                            text: JSON.stringify({ logs, errors }, null, 2),
+                        },
+                    ],
+                };
+            }
+            case "eval": {
+                if (!args.expression) {
+                    return {
+                        content: [{ type: "text", text: "expression is required for action 'eval'" }],
+                        isError: true,
+                    };
+                }
+                const res = await p.evaluate(args.expression);
+                return {
+                    content: [
+                        {
+                            type: "text",
+                            text: JSON.stringify(res, null, 2),
+                        },
+                    ],
+                };
+            }
+            case "click": {
+                if (args.selector) {
+                    await p.click(args.selector, { timeout: 10000 });
+                }
+                else if (args.text) {
+                    await p.click(`text=${args.text}`, { timeout: 10000 });
+                }
+                else if (args.x !== undefined && args.y !== undefined) {
+                    await p.mouse.click(args.x, args.y);
+                }
+                else {
+                    return {
+                        content: [
+                            { type: "text", text: "selector, text, or coordinates (x, y) required for action 'click'" },
+                        ],
+                        isError: true,
+                    };
+                }
+                // Give time for click events/transitions to resolve
+                await new Promise((resolve) => setTimeout(resolve, 500));
+                return { content: [{ type: "text", text: "Click executed successfully." }] };
+            }
+            case "type": {
+                if (!args.selector) {
+                    return {
+                        content: [{ type: "text", text: "selector is required for action 'type'" }],
+                        isError: true,
+                    };
+                }
+                const val = args.text ?? "";
+                await p.fill(args.selector, val, { timeout: 10000 });
+                return { content: [{ type: "text", text: `Successfully typed "${val}" into ${args.selector}.` }] };
+            }
+            case "wait": {
+                if (args.selector) {
+                    await p.waitForSelector(args.selector, { timeout: args.ms ?? 10000 });
+                    return { content: [{ type: "text", text: `Selector ${args.selector} appeared.` }] };
+                }
+                else if (args.ms) {
+                    await new Promise((resolve) => setTimeout(resolve, args.ms));
+                    return { content: [{ type: "text", text: `Waited for ${args.ms} ms.` }] };
+                }
+                else {
+                    return {
+                        content: [{ type: "text", text: "selector or ms is required for action 'wait'" }],
+                        isError: true,
+                    };
+                }
+            }
+            default:
+                return { content: [{ type: "text", text: `Unknown action: ${args.action}` }], isError: true };
+        }
+    }
+    catch (e) {
+        return { content: [{ type: "text", text: `Browser error: ${e.message}` }], isError: true };
+    }
+}