lasal-mcp 0.1.0

package/dist/tools/hmiRuntime.js

@@ -0,0 +1,273 @@
+import { z } from "zod";
+import { spawn, execSync } from "child_process";
+import { existsSync, readFileSync, writeFileSync, mkdirSync, copyFileSync, readdirSync, statSync, unlinkSync, } from "fs";
+import { join, dirname } from "path";
+import { readState, writeState, getHmiForProject, setHmiForProject, clearHmiForProject } from "../state.js";
+import { DATASERVICE_EXE, killDataService, withEngineLock } from "../utils/engine.js";
+import { resolveLvpPath } from "../utils/resolvePaths.js";
+import { runVisuOps } from "../utils/visuScript.js";
+import { respond, fail } from "../utils/respond.js";
+import { checkHttpHealth } from "../core/http.js";
+import { isPidRunning, getPortForPid } from "../core/process.js";
+import { startStaticServer, stopStaticServer } from "../core/staticServer.js";
+export const hmiRuntimeSchema = {
+    action: z.enum(["start", "stop", "status"]).describe("Action to perform on the HMI runtime DataService."),
+    lvp_path: z
+        .string()
+        .optional()
+        .describe("Absolute path to the .lvp file. Omit to use the currently selected project."),
+    debugPublish: z
+        .boolean()
+        .optional()
+        .default(true)
+        .describe("Use debug publish (requires TypeScript project support). Fallback to standard publish on failure. Default true."),
+    publishFirst: z
+        .boolean()
+        .optional()
+        .default(true)
+        .describe("Publish the project before starting the DataService. Default true."),
+};
+function copyDirSync(src, dest) {
+    if (!existsSync(dest))
+        mkdirSync(dest, { recursive: true });
+    for (const item of readdirSync(src)) {
+        const srcPath = join(src, item);
+        const destPath = join(dest, item);
+        const stats = statSync(srcPath);
+        if (stats.isDirectory()) {
+            copyDirSync(srcPath, destPath);
+        }
+        else {
+            copyFileSync(srcPath, destPath);
+        }
+    }
+}
+function createJunction(src, dest) {
+    if (existsSync(dest)) {
+        try {
+            execSync(`rmdir "${dest}"`, { stdio: "pipe" });
+        }
+        catch {
+            try {
+                unlinkSync(dest);
+            }
+            catch { }
+        }
+    }
+    execSync(`mklink /J "${dest}" "${src}"`, { stdio: "pipe" });
+}
+export async function startHmiRuntime(args) {
+    const state = readState();
+    const warnings = [];
+    if (args.action === "stop") {
+        stopStaticServer();
+        const running = getHmiForProject(state);
+        if (running) {
+            killDataService(running.pid);
+            clearHmiForProject(state);
+            writeState(state);
+            return respond({ ok: true, message: `HMI runtime DataService (PID ${running.pid}) stopped.` });
+        }
+        else {
+            killDataService();
+            return respond({ ok: true, message: "No tracked HMI runtime running. Attempted global process kill." });
+        }
+    }
+    if (args.action === "status") {
+        const running = getHmiForProject(state);
+        if (running && isPidRunning(running.pid)) {
+            const healthy = await checkHttpHealth(`http://127.0.0.1:${running.port}/`, 1000, true);
+            // Make sure the static web server is up (it dies with the MCP process, unlike the DataService)
+            let url = running.url;
+            try {
+                const httpPort = await startStaticServer(running.dataDir);
+                url = `http://127.0.0.1:${httpPort}/index.html`;
+            }
+            catch { }
+            return respond({ ok: true, running: true, healthy, ...running, url });
+        }
+        else {
+            if (running) {
+                clearHmiForProject(state);
+                writeState(state);
+            }
+            return respond({ ok: true, running: false });
+        }
+    }
+    // action === "start"
+    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."]);
+    }
+    // 1. Publish first if requested
+    if (args.publishFirst ?? true) {
+        let debug = args.debugPublish ?? true;
+        let publishResult = await runVisuOps(resolved.path, [{ type: "publish", debug }]);
+        if (!publishResult.ok && debug) {
+            warnings.push("Debug publish failed (possibly due to disabled TypeScript). Retrying with standard publish...");
+            publishResult = await runVisuOps(resolved.path, [{ type: "publish", debug: false }]);
+        }
+        if (!publishResult.ok) {
+            return fail(`Failed to publish project before starting HMI runtime: ${publishResult.errors.join("\n")}`, []);
+        }
+    }
+    // 2. Discover published folders
+    const visuDir = dirname(resolved.path);
+    const webrootSrc = join(visuDir, "TempPreview", "Publish", "webroot");
+    const dataSrc = join(visuDir, "TempPreview", "Publish", "dataservice", "data");
+    if (!existsSync(webrootSrc)) {
+        return fail(`Published webroot not found at: ${webrootSrc}. Run HMI publish first.`, []);
+    }
+    // 3. Prepare HMI Dir (with override support)
+    const { HMI_DIR } = await import("../utils/config.js");
+    const dataDir = HMI_DIR;
+    try {
+        if (!existsSync(dataDir))
+            mkdirSync(dataDir, { recursive: true });
+        // Copy webroot files
+        copyDirSync(webrootSrc, dataDir);
+        // Copy dataservice data if available
+        if (existsSync(dataSrc)) {
+            copyDirSync(dataSrc, join(dataDir, "dataservice", "data"));
+        }
+        // Link rt folder
+        const visuDesignerDir = DATASERVICE_EXE.substring(0, DATASERVICE_EXE.indexOf("\\Lasal VISUDesigner"));
+        const rtSrc = join(visuDesignerDir, "SIGMATEK", "Lasal", "VISUDesigner", "Runtime", "rt");
+        if (existsSync(rtSrc)) {
+            try {
+                createJunction(rtSrc, join(dataDir, "rt"));
+            }
+            catch (e) {
+                const msg = e instanceof Error ? e.message : String(e);
+                warnings.push(`Warning: Failed to create junction for 'rt' directory: ${msg}`);
+            }
+        }
+        else {
+            warnings.push(`Warning: VISUDesigner Runtime 'rt' directory not found at ${rtSrc}. Paths starting with 'rt/' might fail to resolve.`);
+        }
+        // Create logs dir
+        const logDir = join(dataDir, "dataservice", "logs");
+        if (!existsSync(logDir))
+            mkdirSync(logDir, { recursive: true });
+        // 4. Map hardware-targeted stations to running LARS instances (if any),
+        //    otherwise keep the published connection config as-is.
+        const stationsJsonPath = join(dataDir, "dataservice", "data", "stations.json");
+        if (existsSync(stationsJsonPath)) {
+            try {
+                const stations = JSON.parse(readFileSync(stationsJsonPath, "utf-8"));
+                const list = Array.isArray(stations.stations) ? stations.stations : null;
+                if (list) {
+                    const { mapStationsToLars } = await import("../utils/lars.js");
+                    const mapping = mapStationsToLars(list, state.larsInstances ?? {});
+                    if (mapping.length > 0) {
+                        writeFileSync(stationsJsonPath, JSON.stringify(stations, null, 2), "utf-8");
+                        warnings.push(`DataService stations mapped to local LARS: ${mapping
+                            .map((m) => `${m.station} ${m.from} -> ${m.to}`)
+                            .join(", ")}`);
+                    }
+                }
+            }
+            catch { }
+        }
+        // 4b. Point the HMI frontend's WebSocket at the local DataService instead of the real panel
+        const dsconfigPath = join(dataDir, "res", "data", "dsconfig.json");
+        if (existsSync(dsconfigPath)) {
+            try {
+                const dsconfig = JSON.parse(readFileSync(dsconfigPath, "utf-8"));
+                dsconfig.ip = "127.0.0.1";
+                writeFileSync(dsconfigPath, JSON.stringify(dsconfig), "utf-8");
+            }
+            catch { }
+        }
+        // 5. Patch config.json
+        const configPath = join(dataDir, "dataservice", "config.json");
+        const dataConfigPath = join(dataDir, "dataservice", "data", "config.json");
+        const configContent = {
+            WindowsAutoExit: false,
+            WSAccessLog: true,
+            WSErrorLog: true,
+            LogDir: logDir,
+        };
+        writeFileSync(configPath, JSON.stringify(configContent, null, 2), "utf-8");
+        if (existsSync(join(dataDir, "dataservice", "data"))) {
+            writeFileSync(dataConfigPath, JSON.stringify(configContent, null, 2), "utf-8");
+        }
+    }
+    catch (e) {
+        const msg = e instanceof Error ? e.message : String(e);
+        return fail(`Failed to set up HMI runtime directory ${dataDir}: ${msg}`, []);
+    }
+    // 6. Kill any existing instance
+    const existing = getHmiForProject(state);
+    if (existing) {
+        killDataService(existing.pid);
+    }
+    else {
+        killDataService();
+    }
+    // 7. Spawn DataService detached
+    if (!existsSync(DATASERVICE_EXE)) {
+        return fail(`LasalVISUDataService.exe not found at standard path: ${DATASERVICE_EXE}`, [
+            "Make sure VISUDesigner is installed properly.",
+        ]);
+    }
+    try {
+        const child = spawn(DATASERVICE_EXE, [], {
+            cwd: dataDir,
+            detached: true,
+            stdio: "ignore",
+            windowsHide: true,
+        });
+        const pid = child.pid;
+        if (!pid) {
+            return fail("Failed to spawn LasalVISUDataService.exe process.", []);
+        }
+        child.unref();
+        // Poll HTTP health up to 10 seconds to detect startup and discover port
+        let healthy = false;
+        let port = 9980;
+        const startTime = Date.now();
+        while (Date.now() - startTime < 10000) {
+            const discoveredPort = getPortForPid(pid);
+            if (discoveredPort) {
+                port = discoveredPort;
+            }
+            const isHealthy = await checkHttpHealth(`http://127.0.0.1:${port}/`, 1000, true);
+            if (isHealthy) {
+                healthy = true;
+                break;
+            }
+            await new Promise((r) => setTimeout(r, 500));
+        }
+        // The DataService only speaks WebSocket (9980) and a binary protocol (9981), and the
+        // webroot can't be opened via file:// (ES-module CORS) — serve it over local HTTP.
+        let url;
+        try {
+            const httpPort = await startStaticServer(dataDir);
+            url = `http://127.0.0.1:${httpPort}/index.html`;
+        }
+        catch (e) {
+            const msg = e instanceof Error ? e.message : String(e);
+            warnings.push(`Failed to start static web server: ${msg}. Falling back to file:// URL.`);
+            url = `file:///${dataDir.replace(/\\/g, "/")}/index.html`;
+        }
+        setHmiForProject(state, { pid, port, url, dataDir });
+        writeState(state);
+        return respond({
+            ok: true,
+            success: true,
+            pid,
+            port,
+            url,
+            healthy,
+            ...(warnings.length ? { warnings } : {}),
+        });
+    }
+    catch (e) {
+        const msg = e instanceof Error ? e.message : String(e);
+        return fail(`Failed to launch HMI runtime: ${msg}`, []);
+    }
+}
+export async function hmiRuntimeHandler(args) {
+    return withEngineLock(() => startHmiRuntime(args));
+}

package/dist/tools/inspectProject.js

@@ -0,0 +1,162 @@
+import { existsSync } from "fs";
+import { z } from "zod";
+import { parseLcp, parseStClass, parseLcn } from "../utils/lasalXml.js";
+import { resolveLcpPath } from "../utils/resolvePaths.js";
+export const inspectProjectSchema = {
+    lcp_path: z
+        .string()
+        .optional()
+        .describe("Absolute path to the .lcp file. Omit to use the currently selected project."),
+    class_names: z
+        .array(z.string())
+        .optional()
+        .describe("Return full channel details only for these class names. Omit to get a summary of all classes (name + channel counts). " +
+        "Use this to drill into specific classes after the initial summary."),
+    include_networks: z
+        .boolean()
+        .optional()
+        .default(false)
+        .describe("Include network objects in the output. Default false to keep output small."),
+    include_connections: z
+        .boolean()
+        .optional()
+        .default(false)
+        .describe("Include network connections in the output (requires include_networks). Default false."),
+};
+export async function inspectProjectHandler(args) {
+    const resolved = resolveLcpPath(args.lcp_path);
+    if ("error" in resolved) {
+        return { content: [{ type: "text", text: resolved.error }], isError: true };
+    }
+    let lcpInfo;
+    try {
+        lcpInfo = parseLcp(resolved.path);
+    }
+    catch (e) {
+        return {
+            content: [{ type: "text", text: `Failed to parse .lcp: ${e.message}` }],
+            isError: true,
+        };
+    }
+    const filterNames = args.class_names ? new Set(args.class_names) : null;
+    // Parse class definitions
+    const classErrors = [];
+    const parsedClasses = [];
+    for (const cf of lcpInfo.classFiles) {
+        if (!cf.absPath.endsWith(".st") || !existsSync(cf.absPath))
+            continue;
+        try {
+            const info = parseStClass(cf.absPath);
+            if (filterNames && !filterNames.has(info.name))
+                continue;
+            const hPath = cf.absPath.replace(/\.st$/, ".h");
+            parsedClasses.push({ ...info, stPath: cf.absPath, hPath });
+        }
+        catch (e) {
+            classErrors.push(`${cf.relativePath}: ${e.message}`);
+        }
+    }
+    // Build class output: summary (no filter) vs full detail (with filter)
+    let classesOutput;
+    if (filterNames) {
+        // Full detail for requested classes
+        classesOutput = parsedClasses.map((c) => ({
+            name: c.name,
+            revision: c.revision,
+            stPath: c.stPath,
+            hPath: c.hPath,
+            taskTypes: { cyclic: c.cyclicTask, realtime: c.realtimeTask, background: c.backgroundTask },
+            servers: c.servers.map((s) => ({
+                name: s.name,
+                visualized: s.visualized,
+                initialize: s.initialize,
+                defValue: s.defValue,
+                writeProtected: s.writeProtected,
+                retentive: s.retentive,
+                ...(s.comment ? { comment: s.comment } : {}),
+            })),
+            clients: c.clients.map((cl) => ({
+                name: cl.name,
+                required: cl.required,
+                internal: cl.internal,
+                ...(cl.comment ? { comment: cl.comment } : {}),
+            })),
+        }));
+    }
+    else {
+        // Summary only — parse all but return just names + counts (avoids giant output)
+        const allClasses = [];
+        for (const cf of lcpInfo.classFiles) {
+            if (!cf.absPath.endsWith(".st") || !existsSync(cf.absPath))
+                continue;
+            try {
+                const info = parseStClass(cf.absPath);
+                allClasses.push({
+                    name: info.name,
+                    revision: info.revision,
+                    servers: info.servers.length,
+                    clients: info.clients.length,
+                });
+            }
+            catch {
+                /* skip */
+            }
+        }
+        classesOutput = allClasses;
+    }
+    const result = {
+        projectName: lcpInfo.projectName,
+        lcpPath: lcpInfo.lcpPath,
+        projectDir: lcpInfo.projectDir,
+        totalClasses: lcpInfo.classFiles.filter((f) => f.absPath.endsWith(".st")).length,
+        totalNetworks: lcpInfo.networkFiles.length,
+        ...(filterNames ? { classDetail: classesOutput } : { classSummary: classesOutput }),
+    };
+    // Networks (optional)
+    if (args.include_networks) {
+        const networks = [];
+        const networkErrors = [];
+        for (const nf of lcpInfo.networkFiles) {
+            if (!existsSync(nf.absPath))
+                continue;
+            try {
+                networks.push(parseLcn(nf.absPath));
+            }
+            catch (e) {
+                networkErrors.push(`${nf.relativePath}: ${e.message}`);
+            }
+        }
+        result.networks = networks.map((n) => ({
+            name: n.name,
+            lcnPath: n.lcnPath,
+            objects: n.objects.map((o) => ({
+                name: o.name,
+                className: o.className,
+                ...(Object.keys(o.channelValues).length ? { channelValues: o.channelValues } : {}),
+            })),
+            ...(args.include_connections
+                ? {
+                    connections: n.connections.map((c) => ({
+                        source: c.source,
+                        destination: c.destination,
+                        ...(c.remote ? { remote: true, station: c.station } : {}),
+                    })),
+                }
+                : {}),
+        }));
+        if (networkErrors.length)
+            result.networkParseErrors = networkErrors;
+    }
+    if (classErrors.length)
+        result.classParseErrors = classErrors;
+    const json = JSON.stringify(result, null, 2);
+    const MAX_RESPONSE_CHARS = 100_000;
+    if (json.length > MAX_RESPONSE_CHARS) {
+        result.truncationWarning = `Response truncated from ${json.length} to ${MAX_RESPONSE_CHARS} chars. Use class_names filter or disable include_networks/include_connections to narrow results.`;
+        const truncated = json.slice(0, MAX_RESPONSE_CHARS) + "\n... (truncated)";
+        return { content: [{ type: "text", text: truncated }] };
+    }
+    return {
+        content: [{ type: "text", text: json }],
+    };
+}