lasal-mcp 0.1.0

package/dist/utils/batchScript.js

@@ -0,0 +1,257 @@
+import { writeFileSync, readFileSync, existsSync } from "fs";
+import { join } from "path";
+import { randomUUID } from "crypto";
+import { CLASS2_EXE, SCRATCH, killClass2 } from "./engine.js";
+import { runEngineScript } from "./scriptRunner.js";
+import { ensureScratch } from "../core/scratch.js";
+export function validateMbcsEncodable(s) {
+    for (let i = 0; i < s.length; i++) {
+        const code = s.charCodeAt(i);
+        if (code > 0xff) {
+            throw new Error(`String contains character '${s[i]}' (U+${code.toString(16).padStart(4, "0")}) at position ${i} ` +
+                `which is not representable in mbcs/latin1. Path or value: "${s}"`);
+        }
+    }
+}
+export function emitPy27String(s) {
+    validateMbcsEncodable(s);
+    return `u"${s.replace(/\\/g, "\\\\").replace(/"/g, '\\"')}".encode('mbcs')`;
+}
+export function emitPath(p) {
+    return emitPy27String(p);
+}
+function emitPy27StringList(arr) {
+    return `[${arr.map(emitPy27String).join(", ")}]`;
+}
+/** Build the body of a batch.py Python 2.7 script from a list of operations. */
+export function buildBatchScript(lcpPath, ops, logPath, stepsPath) {
+    const lines = [
+        "# -*- coding: utf-8 -*-",
+        "import sigmatek.lasal.batch as batch",
+        "import sys",
+        "import traceback",
+        "batch.SetExceptionOnError(True)",
+        `batch.OpenLogfile(${emitPath(logPath)})`,
+        "try:",
+        `    prj = batch.LoadProject(${emitPath(lcpPath)})`,
+        "",
+    ];
+    const expectedSteps = [];
+    for (let i = 0; i < ops.length; i++) {
+        const op = ops[i];
+        if (!op)
+            continue;
+        const label = `${i}_${op.type}`;
+        expectedSteps.push(label);
+        const opLines = [];
+        switch (op.type) {
+            case "create_network":
+                opLines.push(`batch.CreateNetwork(prj, ${emitPy27String(op.name)})`);
+                break;
+            case "delete_network":
+                opLines.push(`batch.DeleteNetwork(prj, ${emitPy27String(op.name)}, ${op.deleteConnections ? "True" : "False"}, False)`);
+                break;
+            case "rename_network":
+                opLines.push(`batch.RenameNetwork(prj, ${emitPy27String(op.oldName)}, ${emitPy27String(op.newName)})`);
+                break;
+            case "duplicate_network":
+                opLines.push(`batch.DuplicateNetwork(prj, ${emitPy27String(op.name)}, ${emitPy27String(op.newName)})`);
+                break;
+            case "add_object":
+                opLines.push(`batch.CreateObject(prj, ${emitPy27String(op.network)}, ${emitPy27String(op.className)}, ${emitPy27String(op.objectName)}, ${op.x ?? 0}, ${op.y ?? 0}, ${op.visualized ? "True" : "False"})`);
+                break;
+            case "remove_object":
+                opLines.push(`batch.DeleteObject(prj, ${emitPy27String(op.network)}, ${emitPy27String(op.objectName)}, ${op.deleteConnections !== false ? "True" : "False"})`);
+                break;
+            case "rename_object":
+                opLines.push(`batch.RenameObject(prj, ${emitPy27String(op.network)}, ${emitPy27String(op.oldName)}, ${emitPy27String(op.newName)})`);
+                break;
+            case "change_object_class":
+                opLines.push(`batch.ChangeClass(prj, ${emitPy27String(op.network)}, ${emitPy27String(op.objectName)}, ${emitPy27String(op.className)}, False)`);
+                break;
+            case "create_connection": {
+                const net = op.network;
+                if (net) {
+                    opLines.push(`batch.CreateConnection(prj, ${emitPy27String(net)}, ${emitPy27String(op.fromObject)}, ${emitPy27String(op.fromClient)}, ${emitPy27String(net)}, ${emitPy27String(op.toObject)}, ${emitPy27String(op.toServer)})`);
+                }
+                else {
+                    opLines.push(`batch.CreateConnection2(prj, ${emitPy27String(op.fromObject)}, ${emitPy27String(op.fromClient)}, ${emitPy27String(op.toObject)}, ${emitPy27String(op.toServer)})`);
+                }
+                break;
+            }
+            case "delete_connection": {
+                const net = op.network;
+                if (net) {
+                    opLines.push(`batch.DeleteConnection(prj, ${emitPy27String(net)}, ${emitPy27String(op.objectName)}, ${emitPy27String(op.clientName)})`);
+                }
+                else {
+                    opLines.push(`batch.DeleteConnection2(prj, ${emitPy27String(op.objectName)}, ${emitPy27String(op.clientName)})`);
+                }
+                break;
+            }
+            case "set_init_value": {
+                const net = op.network;
+                if (net) {
+                    opLines.push(`batch.SetInitValue(prj, ${emitPy27String(net)}, ${emitPy27String(op.objectName)}, ${emitPy27String(op.channelName)}, ${emitPy27String(op.value)})`);
+                }
+                else {
+                    opLines.push(`batch.SetInitValue2(prj, ${emitPy27String(op.objectName)}, ${emitPy27String(op.channelName)}, ${emitPy27String(op.value)})`);
+                }
+                break;
+            }
+            case "delete_class":
+                opLines.push(`batch.DeleteClass(prj, ${emitPy27String(op.className)}, ${op.force ? "True" : "False"})`);
+                break;
+            case "compile": {
+                const optName = op.optionName ?? "RebuildAll";
+                opLines.push(`batch.Compile(prj, batch.CompileOptions.${optName})`);
+                break;
+            }
+            case "download": {
+                const conn = op.connection ?? "";
+                opLines.push(`batch.Download(prj, ${emitPy27String(conn)}, ${op.addLoaderAnyway ? "True" : "False"}, False)`);
+                const stateJsonPath = logPath.replace(/\.log$/, ".state.json");
+                opLines.push("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(stateJsonPath)}, 'w')`, "json.dump(result, f_state)", "f_state.close()");
+                break;
+            }
+            case "set_task_order":
+                opLines.push(`batch.SetTaskOrder(prj, ${emitPy27String(op.network)}, ${emitPy27String(op.objectName)}, ${emitPy27String(op.task)}, ${emitPy27String(String(op.position))})`);
+                break;
+            case "set_task_time":
+                opLines.push(`batch.SetTaskTime(prj, ${emitPy27String(op.network)}, ${emitPy27String(op.objectName)}, ${emitPy27String(op.task)}, ${emitPy27String(op.time)})`);
+                break;
+            case "set_task_cpu_core":
+                opLines.push(`batch.SetTaskCPUCore(prj, ${emitPy27String(op.network)}, ${emitPy27String(op.objectName)}, ${emitPy27String(op.task)}, ${Number(op.core)})`);
+                break;
+            case "set_multi_cpu_core":
+                opLines.push(`batch.SetMultiCPUCore(prj, ${op.multiCore ? "True" : "False"})`);
+                break;
+            case "set_visualized_flag":
+                opLines.push(`batch.SetVisualizedFlag(prj, ${emitPy27String(op.network)}, ${emitPy27String(op.objectName)}, ${op.isVisualized ? "True" : "False"})`);
+                break;
+            case "set_comment_network":
+                opLines.push(`batch.SetCommentNetwork(prj, ${emitPy27String(op.network)}, ${emitPy27String(op.comment)})`);
+                break;
+            case "set_comment_object":
+                opLines.push(`batch.SetCommentObject(prj, ${emitPy27String(op.network)}, ${emitPy27String(op.objectName)}, ${emitPy27String(op.comment)})`);
+                break;
+            case "set_network_options":
+                opLines.push(`batch.SetNetworkOptions(prj, ${emitPy27String(op.network)}, ${emitPy27StringList(op.optionNames)}, ${op.resetAllOthers ? "True" : "False"})`);
+                break;
+            case "reset_network_options":
+                opLines.push(`batch.ResetNetworkOptions(prj, ${emitPy27String(op.network)}, ${emitPy27StringList(op.optionNames)})`);
+                break;
+            case "move_network_to_folder":
+                opLines.push(`batch.MoveNetworkToFolder(prj, ${emitPy27String(op.network)}, ${emitPy27String(op.folder)})`);
+                break;
+            case "set_parameter_value":
+                opLines.push(`batch.SetParameterValue(prj, ${emitPy27String(op.network)}, ${emitPy27String(op.objectName)}, ${emitPy27String(op.parameterName)}, ${emitPy27String(op.value)})`);
+                break;
+            case "save":
+                break;
+        }
+        for (const opLine of opLines) {
+            lines.push(`    ${opLine}`);
+        }
+        lines.push(`    f_step = open(${emitPath(stepsPath)}, "a"); f_step.write("STEP ${label} OK\\n"); f_step.close()`, "");
+    }
+    lines.push("    batch.Save(prj)", "    batch.CloseProject(prj)", "except Exception as e:", "    traceback.print_exc()", "    sys.exit(1)");
+    return {
+        script: lines.join("\n") + "\n",
+        expectedSteps,
+    };
+}
+export function buildRawScript(lcpPath, bodyLines, logPath, stepsPath, expectedSteps) {
+    const lines = [
+        "# -*- coding: utf-8 -*-",
+        "import sigmatek.lasal.batch as batch",
+        "import sys",
+        "import json",
+        "import traceback",
+        "batch.SetExceptionOnError(True)",
+        `batch.OpenLogfile(${emitPath(logPath)})`,
+        "try:",
+        `    prj = batch.LoadProject(${emitPath(lcpPath)})`,
+    ];
+    for (const line of bodyLines) {
+        lines.push(`    ${line}`);
+    }
+    for (const step of expectedSteps) {
+        lines.push(`    f = open(${emitPath(stepsPath)}, "a"); f.write("STEP ${step} OK\\n"); f.close()`);
+    }
+    lines.push("    batch.CloseProject(prj)", "except Exception as e:", "    traceback.print_exc()", "    sys.exit(1)");
+    return lines.join("\n") + "\n";
+}
+export async function runScript(script, logPath, timeoutMs = 120_000, expectedSteps = [], stepsPath) {
+    ensureScratch();
+    const id = randomUUID();
+    const scriptPath = join(SCRATCH, `${id}.py`);
+    if (!stepsPath)
+        stepsPath = join(SCRATCH, `${id}.steps`);
+    writeFileSync(scriptPath, script, "utf-8");
+    const command = `"${CLASS2_EXE}" /script:"${scriptPath}"`;
+    const result = await runEngineScript(scriptPath, {
+        exe: CLASS2_EXE,
+        argsFor: (p) => [`/script:${p}`],
+        timeoutMs,
+        logEncoding: "latin1",
+        killOnFailure: killClass2,
+        expectedSteps,
+        stepsPath,
+    }, logPath);
+    return {
+        ok: result.ok,
+        exitCode: result.exitCode,
+        logPath: result.logPath,
+        errors: result.errors,
+        warnings: result.warnings,
+        logTail: result.logTail,
+        durationMs: result.durationMs,
+        command,
+        steps: result.steps,
+        timedOut: result.timedOut,
+        hints: result.hints,
+    };
+}
+export async function runBatchOps(lcpPath, ops, timeoutMs = 120_000) {
+    ensureScratch();
+    const id = randomUUID();
+    const scriptPath = join(SCRATCH, `${id}.py`);
+    const logPath = join(SCRATCH, `${id}.log`);
+    const stepsPath = join(SCRATCH, `${id}.steps`);
+    const { script, expectedSteps } = buildBatchScript(lcpPath, ops, logPath, stepsPath);
+    writeFileSync(scriptPath, script, "utf-8");
+    const command = `"${CLASS2_EXE}" /script:"${scriptPath}"`;
+    killClass2();
+    const result = await runEngineScript(scriptPath, {
+        exe: CLASS2_EXE,
+        argsFor: (p) => [`/script:${p}`],
+        timeoutMs,
+        logEncoding: "latin1",
+        killOnFailure: killClass2,
+        expectedSteps,
+        stepsPath,
+    }, logPath);
+    let postDownloadState;
+    const stateJsonPath = logPath.replace(/\.log$/, ".state.json");
+    if (existsSync(stateJsonPath)) {
+        try {
+            postDownloadState = JSON.parse(readFileSync(stateJsonPath, "utf-8"));
+        }
+        catch { }
+    }
+    return {
+        ok: result.ok,
+        exitCode: result.exitCode,
+        logPath: result.logPath,
+        errors: result.errors,
+        warnings: result.warnings,
+        logTail: result.logTail,
+        durationMs: result.durationMs,
+        command,
+        steps: result.steps,
+        timedOut: result.timedOut,
+        hints: result.hints,
+        postDownloadState,
+    };
+}

package/dist/utils/config.js

@@ -0,0 +1,34 @@
+import { z } from "zod";
+const envInt = z.coerce.number().int().positive();
+const ConfigSchema = z.object({
+    LASAL_MCP_TIMEOUT_COMPILE: envInt.default(600_000),
+    LASAL_MCP_TIMEOUT_DOWNLOAD: envInt.default(600_000),
+    LASAL_MCP_TIMEOUT_VISU: envInt.default(300_000),
+    LASAL_MCP_TIMEOUT_SCRIPT: envInt.default(120_000),
+    LASAL_MCP_HMI_DIR: z.string().default("C:\\lslvisu"),
+    LASAL_MCP_SCRATCH_MAX_AGE_H: envInt.default(24),
+    LASAL_MCP_LARS_GC_MIN_AGE_H: envInt.default(0),
+    LASAL_MCP_LARS_GC_STATIONS_DIRS: z.string().default(""),
+});
+function loadConfig() {
+    const raw = {};
+    for (const key of ConfigSchema.keyof().options) {
+        const val = process.env[key];
+        if (val !== undefined)
+            raw[key] = val;
+    }
+    return ConfigSchema.parse(raw);
+}
+const cfg = loadConfig();
+export const TIMEOUTS = {
+    compile: cfg.LASAL_MCP_TIMEOUT_COMPILE,
+    download: cfg.LASAL_MCP_TIMEOUT_DOWNLOAD,
+    visu: cfg.LASAL_MCP_TIMEOUT_VISU,
+    script: cfg.LASAL_MCP_TIMEOUT_SCRIPT,
+};
+export const HMI_DIR = cfg.LASAL_MCP_HMI_DIR;
+export const SCRATCH_MAX_AGE_H = cfg.LASAL_MCP_SCRATCH_MAX_AGE_H;
+export const LARS_GC_MIN_AGE_H = cfg.LASAL_MCP_LARS_GC_MIN_AGE_H;
+export const LARS_GC_STATIONS_DIRS = cfg.LASAL_MCP_LARS_GC_STATIONS_DIRS.split(";")
+    .map((s) => s.trim())
+    .filter(Boolean);

package/dist/utils/editTransaction.js

@@ -0,0 +1,39 @@
+import { copyFileSync, existsSync, mkdirSync } from "fs";
+import { join, basename } from "path";
+import { SCRATCH } from "./engine.js";
+import { randomUUID } from "crypto";
+export class EditTransaction {
+    runId = randomUUID();
+    backupDir;
+    backups = new Map(); // originalPath -> backupPath
+    constructor() {
+        this.backupDir = join(SCRATCH, `backup-${this.runId}`);
+    }
+    backup(filePath) {
+        if (this.backups.has(filePath))
+            return;
+        if (!existsSync(filePath))
+            return;
+        if (!existsSync(this.backupDir)) {
+            mkdirSync(this.backupDir, { recursive: true });
+        }
+        const backupFile = join(this.backupDir, `${randomUUID()}-${basename(filePath)}`);
+        copyFileSync(filePath, backupFile);
+        this.backups.set(filePath, backupFile);
+    }
+    commit() {
+        this.backups.clear();
+    }
+    rollback() {
+        const restored = [];
+        for (const [originalPath, backupPath] of this.backups.entries()) {
+            try {
+                copyFileSync(backupPath, originalPath);
+                restored.push(originalPath);
+            }
+            catch { }
+        }
+        this.backups.clear();
+        return { restored };
+    }
+}

package/dist/utils/engine.js

@@ -0,0 +1,163 @@
+import { existsSync, readdirSync, statSync, unlinkSync } from "fs";
+import { execSync } from "child_process";
+import { join } from "path";
+import { tmpdir } from "os";
+import { SCRATCH_MAX_AGE_H } from "./config.js";
+// ─── Executable Paths ────────────────────────────────────────────────────────
+export const VISUDESIGNER_EXE = process.env.LASAL_VISUDESIGNER_EXE || "C:\\Program Files\\Sigmatek\\Lasal\\VISUDesigner\\VISUDesigner.exe";
+export const CLASS2_EXE = process.env.LASAL_CLASS2_EXE || "C:\\Program Files (x86)\\Sigmatek\\Lasal\\Class2\\Bin\\Lasal2.exe";
+function extractVersion(name) {
+    const m = name.match(/V(\d+(?:_\d+)*)/);
+    if (!m?.[1])
+        return [0];
+    return m[1].split("_").map(Number);
+}
+function compareVersions(a, b) {
+    const len = Math.max(a.length, b.length);
+    for (let i = 0; i < len; i++) {
+        const diff = (b[i] ?? 0) - (a[i] ?? 0);
+        if (diff !== 0)
+            return diff;
+    }
+    return 0;
+}
+function versionSort(names) {
+    return [...names].sort((a, b) => compareVersions(extractVersion(a), extractVersion(b)));
+}
+export function resolveDataServiceExe() {
+    if (process.env.LASAL_DATASERVICE_EXE) {
+        return { path: process.env.LASAL_DATASERVICE_EXE, searched: [] };
+    }
+    const root = "C:\\Program Files";
+    const searched = [];
+    if (!existsSync(root)) {
+        return { path: "", searched: [`${root} (does not exist)`] };
+    }
+    try {
+        const dirs = readdirSync(root).filter((d) => d.startsWith("Lasal VISUDesigner V"));
+        const sortedDirs = versionSort(dirs);
+        for (const dir of sortedDirs) {
+            const parentPath = join(root, dir);
+            try {
+                const subDirs = readdirSync(parentPath).filter((d) => d.startsWith("Lasal VISUDataService V"));
+                const sortedSubDirs = versionSort(subDirs);
+                for (const subDir of sortedSubDirs) {
+                    const exePath = join(parentPath, subDir, "Windows", "LasalVISUDataService.exe");
+                    searched.push(exePath);
+                    if (existsSync(exePath)) {
+                        return { path: exePath, searched };
+                    }
+                }
+            }
+            catch { }
+        }
+        if (dirs.length === 0) {
+            searched.push(`${root} (no 'Lasal VISUDesigner V*' directories found)`);
+        }
+    }
+    catch { }
+    return { path: "", searched };
+}
+const _dsResolved = resolveDataServiceExe();
+export const DATASERVICE_EXE = _dsResolved.path;
+export const DATASERVICE_SEARCHED = _dsResolved.searched;
+function findEdgePath() {
+    const paths = [
+        "C:\\Program Files (x86)\\Microsoft\\Edge\\Application\\msedge.exe",
+        "C:\\Program Files\\Microsoft\\Edge\\Application\\msedge.exe",
+    ];
+    for (const p of paths) {
+        if (existsSync(p))
+            return p;
+    }
+    return "";
+}
+export const EDGE_EXE = process.env.LASAL_EDGE_EXE || findEdgePath();
+// ─── Scratch Directory & Cleanup ─────────────────────────────────────────────
+export const SCRATCH = join(tmpdir(), "lasal-mcp");
+export function cleanupScratch() {
+    if (!existsSync(SCRATCH))
+        return;
+    try {
+        const files = readdirSync(SCRATCH);
+        const now = Date.now();
+        const cutoff = SCRATCH_MAX_AGE_H * 60 * 60 * 1000;
+        for (const file of files) {
+            const filePath = join(SCRATCH, file);
+            try {
+                const stats = statSync(filePath);
+                if (now - stats.mtimeMs > cutoff) {
+                    unlinkSync(filePath);
+                }
+            }
+            catch {
+                // Ignore single file deletion failures
+            }
+        }
+    }
+    catch {
+        // Ignore folder reading failures
+    }
+}
+// ─── Centralized Process Killing & Status ────────────────────────────────────
+export function isProcessRunning(imageName) {
+    try {
+        const out = execSync(`tasklist /FI "IMAGENAME eq ${imageName}" /NH`, { stdio: "pipe", encoding: "utf-8" });
+        return out.toLowerCase().includes(imageName.toLowerCase());
+    }
+    catch {
+        return false;
+    }
+}
+export function getProcessPid(imageName) {
+    try {
+        const out = execSync(`tasklist /FI "IMAGENAME eq ${imageName}" /FO CSV /NH`, { stdio: "pipe", encoding: "utf-8" });
+        const m = out.match(/"([^"]+)"\s*,\s*"(\d+)"/);
+        if (m && m[1] && m[2] && m[1].toLowerCase() === imageName.toLowerCase()) {
+            return parseInt(m[2]);
+        }
+    }
+    catch { }
+    return undefined;
+}
+export function killClass2() {
+    try {
+        execSync(`taskkill /IM "Lasal2.exe" /F /T`, { stdio: "pipe" });
+    }
+    catch {
+        // Not running
+    }
+}
+export function killVisuDesigner() {
+    try {
+        execSync(`taskkill /IM "VISUDesigner.exe" /F /T`, { stdio: "pipe" });
+    }
+    catch {
+        // Not running
+    }
+}
+export function killDataService(pid) {
+    if (pid) {
+        try {
+            execSync(`taskkill /PID ${pid} /F /T`, { stdio: "pipe" });
+        }
+        catch {
+            // Failed to kill by PID
+        }
+    }
+    else {
+        try {
+            execSync(`taskkill /IM "LasalVISUDataService.exe" /F /T`, { stdio: "pipe" });
+        }
+        catch {
+            // Not running
+        }
+    }
+}
+// ─── Global Engine Mutex ─────────────────────────────────────────────────────
+let currentPromise = Promise.resolve();
+export async function withEngineLock(fn) {
+    const next = currentPromise.then(fn);
+    currentPromise = next.catch(() => { });
+    return next;
+}