lasal-mcp 0.1.0

package/dist/utils/visuDashboardIO.js

@@ -0,0 +1,198 @@
+import { copyFileSync, existsSync, writeFileSync, readFileSync, readdirSync } from "fs";
+import { join, basename, dirname } from "path";
+import { randomUUID } from "crypto";
+// Generate UUID v4
+export function newDesignTimeId() {
+    return randomUUID();
+}
+// Generate stripped instance ID
+export function newInstanceId(prefix) {
+    const uuid = newDesignTimeId().replace(/-/g, "");
+    return `${prefix}${uuid}`;
+}
+// Read Real Version from .lvp
+export function getFileEntryVersion(lvpPath, key) {
+    try {
+        if (existsSync(lvpPath)) {
+            const data = JSON.parse(readFileSync(lvpPath, "utf-8"));
+            if (data && data.fileEntryVersions && data.fileEntryVersions[key]) {
+                return data.fileEntryVersions[key];
+            }
+        }
+    }
+    catch { }
+    return "0.0.96"; // standard fallback
+}
+// Backup file alongside original
+const backedUpFiles = new Set();
+export function backupFile(filePath) {
+    if (backedUpFiles.has(filePath))
+        return null;
+    if (!existsSync(filePath))
+        return null;
+    const dir = dirname(filePath);
+    const base = basename(filePath);
+    const ts = Date.now();
+    const backupPath = join(dir, `${base}.bak-${ts}`);
+    copyFileSync(filePath, backupPath);
+    backedUpFiles.add(filePath);
+    return backupPath;
+}
+// Resolve Text Reference: List:AliasName -> ID
+export function resolveTextRef(projectDir, listName, aliasName) {
+    const locDir = join(projectDir, "Localization");
+    if (!existsSync(locDir))
+        return null;
+    try {
+        const langs = readdirSync(locDir);
+        for (const lang of langs) {
+            const listFile = join(locDir, lang, `${listName}.json`);
+            if (existsSync(listFile)) {
+                const content = readFileSync(listFile, "utf-8");
+                const data = JSON.parse(content);
+                if (data && Array.isArray(data.texts)) {
+                    const item = data.texts.find((t) => t.aliasName === aliasName);
+                    if (item && item.id)
+                        return item.id;
+                }
+            }
+        }
+    }
+    catch { }
+    return null;
+}
+// Resolve Schemes/StateSchemes: Group:Scheme -> designTimeId
+export function resolveSchemeRef(projectDir, schemeType, schemeName) {
+    const dir = join(projectDir, "Schemes", schemeType);
+    if (!existsSync(dir))
+        return null;
+    try {
+        for (const f of readdirSync(dir)) {
+            if (!f.endsWith(".json"))
+                continue;
+            const content = readFileSync(join(dir, f), "utf-8");
+            const data = JSON.parse(content);
+            if (data && Array.isArray(data.schemes)) {
+                const s = data.schemes.find((x) => x.name === schemeName);
+                if (s && s.designTimeId)
+                    return s.designTimeId;
+            }
+        }
+    }
+    catch { }
+    return null;
+}
+// Resolve Color Reference: Palette:ColorName -> ID
+export function resolveColorRef(projectDir, colorVal) {
+    if (!colorVal.includes(":"))
+        return null;
+    const [palette, name] = colorVal.split(":");
+    const path = join(projectDir, "Resources", `${palette}.colors`);
+    if (existsSync(path)) {
+        try {
+            const content = readFileSync(path, "utf-8");
+            const data = JSON.parse(content);
+            if (data && Array.isArray(data.colors)) {
+                const c = data.colors.find((x) => x.name === name);
+                if (c && c.id)
+                    return c.id;
+            }
+        }
+        catch { }
+    }
+    return null;
+}
+// Resolve Font Reference: FontStyleName -> designTimeId
+export function resolveFontRef(projectDir, fontName) {
+    const path = join(projectDir, "FontStyles", "FontStyles.json");
+    if (existsSync(path)) {
+        try {
+            const content = readFileSync(path, "utf-8");
+            const data = JSON.parse(content);
+            if (data && Array.isArray(data.fontStyles)) {
+                const f = data.fontStyles.find((x) => x.name === fontName);
+                if (f && f.designTimeId)
+                    return f.designTimeId;
+            }
+        }
+        catch { }
+    }
+    return null;
+}
+// Resolve StyleClass Reference: StyleClassName -> designTimeId
+export function resolveStyleClassRef(projectDir, className) {
+    const path = join(projectDir, "DefaultStyles", "DefaultStyles.json");
+    if (!existsSync(path))
+        return null;
+    try {
+        const content = readFileSync(path, "utf-8");
+        const data = JSON.parse(content);
+        if (data && Array.isArray(data.componentStyles)) {
+            const findInNode = (node) => {
+                if (node.name === className && node.designTimeId)
+                    return node.designTimeId;
+                if (Array.isArray(node.children)) {
+                    for (const child of node.children) {
+                        const res = findInNode(child);
+                        if (res)
+                            return res;
+                    }
+                }
+                return null;
+            };
+            for (const style of data.componentStyles) {
+                const res = findInNode(style);
+                if (res)
+                    return res;
+            }
+        }
+    }
+    catch { }
+    return null;
+}
+// Resolve Template Reference: templateName -> designTimeId
+export function resolveTemplateRef(projectDir, templateName) {
+    const path = join(projectDir, "ControlTemplate", `${templateName}.json`);
+    if (existsSync(path)) {
+        try {
+            const content = readFileSync(path, "utf-8");
+            const data = JSON.parse(content);
+            if (data && data.designTimeId)
+                return data.designTimeId;
+        }
+        catch { }
+    }
+    return null;
+}
+// Resolve Media Reference: mediaPath -> ID
+export function resolveMediaRef(projectDir, mediaPath) {
+    const filename = basename(mediaPath.replace(/\\/g, "/"));
+    const resDir = join(projectDir, "Resources");
+    if (!existsSync(resDir))
+        return null;
+    try {
+        for (const sub of readdirSync(resDir)) {
+            const subPath = join(resDir, sub);
+            if (existsSync(subPath)) {
+                for (const file of readdirSync(subPath)) {
+                    if (file.endsWith("Collection.json")) {
+                        const content = readFileSync(join(subPath, file), "utf-8");
+                        const data = JSON.parse(content);
+                        if (data && Array.isArray(data.mediaItems)) {
+                            const item = data.mediaItems.find((x) => x.name === filename);
+                            if (item && item.id)
+                                return item.id;
+                        }
+                    }
+                }
+            }
+        }
+    }
+    catch { }
+    return null;
+}
+// Tab indented JSON output
+export function writeTabIndentedJson(filePath, data) {
+    const content = JSON.stringify(data, null, "\t");
+    writeFileSync(filePath, content, "utf-8");
+}

package/dist/utils/visuPropertyEncoding.js

@@ -0,0 +1,174 @@
+import { existsSync, readFileSync } from "fs";
+import { join } from "path";
+import { newDesignTimeId, resolveTextRef, resolveSchemeRef, resolveColorRef, resolveFontRef, resolveStyleClassRef, resolveTemplateRef, resolveMediaRef, } from "./visuDashboardIO.js";
+// Clean JSON helper for manifests (strips comments & trailing commas)
+export function cleanJson(content) {
+    content = content.replace(/\/\*[\s\S]*?\*\//g, "");
+    content = content.replace(/^[ \t]*\/\/.*$/gm, "");
+    content = content.replace(/,(\s*[\]}])/g, "$1");
+    return content;
+}
+// Load control manifest, merging inherited properties
+const manifestCache = {};
+export function loadControlManifest(projectDir, controlId) {
+    if (manifestCache[controlId])
+        return manifestCache[controlId];
+    const userPath = join(projectDir, "Runtime", "DesignerRuntime", "res", "components", "user", controlId, `${controlId}.json`);
+    const sigmatekPath = join(projectDir, "Runtime", "DesignerRuntime", "res", "components", "sigmatek", controlId, `${controlId}.json`);
+    let manifest = null;
+    if (existsSync(userPath)) {
+        manifest = JSON.parse(cleanJson(readFileSync(userPath, "utf-8")));
+    }
+    else if (existsSync(sigmatekPath)) {
+        manifest = JSON.parse(cleanJson(readFileSync(sigmatekPath, "utf-8")));
+    }
+    if (!manifest)
+        return null;
+    // Resolve base Component properties recursively
+    if (manifest.baseComponent && manifest.baseComponent !== controlId) {
+        const parent = loadControlManifest(projectDir, manifest.baseComponent);
+        if (parent && parent.properties) {
+            const mergedProps = [...(parent.properties || [])];
+            for (const prop of manifest.properties || []) {
+                const idx = mergedProps.findIndex((p) => p.name === prop.name);
+                if (idx >= 0)
+                    mergedProps[idx] = prop;
+                else
+                    mergedProps.push(prop);
+            }
+            manifest.properties = mergedProps;
+        }
+    }
+    manifestCache[controlId] = manifest;
+    return manifest;
+}
+// Format UUID function block ID
+export function resolveFunctionBlockRef(projectDir, fbName) {
+    const path = join(projectDir, "Functionblocks", `${fbName}.json`);
+    if (existsSync(path)) {
+        try {
+            const data = JSON.parse(cleanJson(readFileSync(path, "utf-8")));
+            if (data && data.id) {
+                let idStr = data.id;
+                if (idStr.startsWith("_")) {
+                    idStr = idStr.substring(1);
+                }
+                if (idStr.length === 32) {
+                    return `${idStr.substring(0, 8)}-${idStr.substring(8, 12)}-${idStr.substring(12, 16)}-${idStr.substring(16, 20)}-${idStr.substring(20)}`;
+                }
+                return idStr;
+            }
+        }
+        catch { }
+    }
+    return null;
+}
+// Encode property based on manifest entry and sourceType
+export function encodeProperty(projectDir, propName, manifestProp, sourceType, value) {
+    const propType = manifestProp ? manifestProp.propertyType || "none" : "none";
+    let typeId = 0;
+    let propTypeId = 2;
+    let refId;
+    switch (sourceType) {
+        case "constString":
+        case "constNumber":
+        case "constBool":
+            if (propType === "css") {
+                if (propName.startsWith("--theme-sig-element-")) {
+                    typeId = 17;
+                }
+                else {
+                    typeId = 0;
+                }
+                propTypeId = 2;
+            }
+            else if (propType === "rotation") {
+                typeId = 17;
+                propTypeId = 12;
+            }
+            else if (propType === "variable") {
+                typeId = 0;
+                propTypeId = 1;
+            }
+            else {
+                typeId = 0;
+                propTypeId = 2;
+            }
+            break;
+        case "datapoint":
+            typeId = 4;
+            propTypeId = 1;
+            refId = newDesignTimeId(); // freestanding UUID
+            if (typeof value === "string" && !value.includes(":")) {
+                value = `0:${value}`;
+            }
+            break;
+        case "text":
+            typeId = 5;
+            propTypeId = 1;
+            if (typeof value === "string" && value.includes(":")) {
+                const [listName, aliasName] = value.split(":");
+                refId = resolveTextRef(projectDir, listName, aliasName) || undefined;
+            }
+            break;
+        case "colorScheme":
+            // If it contains a colon, check if it resolves as a palette color first, then as colorScheme
+            if (typeof value === "string" && value.includes(":")) {
+                const paletteColorId = resolveColorRef(projectDir, value);
+                if (paletteColorId) {
+                    typeId = 9;
+                    propTypeId = 2;
+                    refId = paletteColorId;
+                    break;
+                }
+            }
+            typeId = 18;
+            propTypeId = 2;
+            refId = resolveSchemeRef(projectDir, "ColorSchemes", String(value)) || undefined;
+            break;
+        case "stateScheme":
+            typeId = 21;
+            propTypeId = 1;
+            refId = resolveSchemeRef(projectDir, "StateSchemes", String(value)) || undefined;
+            break;
+        case "functionBlock":
+            typeId = 1;
+            propTypeId = 3;
+            refId = resolveFunctionBlockRef(projectDir, String(value)) || undefined;
+            break;
+        case "compositeControl":
+            typeId = 23;
+            propTypeId = 5;
+            refId = resolveTemplateRef(projectDir, String(value)) || undefined;
+            break;
+        case "imageOrMedia":
+            typeId = 15;
+            propTypeId = 2;
+            refId = resolveMediaRef(projectDir, String(value)) || undefined;
+            break;
+        case "fontStyle":
+            typeId = 26;
+            propTypeId = 6;
+            refId = resolveFontRef(projectDir, String(value)) || undefined;
+            break;
+        case "styleClass":
+            typeId = 34;
+            propTypeId = 14;
+            refId = resolveStyleClassRef(projectDir, String(value)) || undefined;
+            break;
+        default:
+            // Fallback
+            typeId = 0;
+            propTypeId = 2;
+    }
+    const result = {
+        name: propName,
+        value,
+        typeId,
+        propTypeId,
+    };
+    if (refId) {
+        result.refId = refId;
+    }
+    return result;
+}

package/dist/utils/visuScript.js

@@ -0,0 +1,262 @@
+import { writeFileSync } from "fs";
+import { join } from "path";
+import { randomUUID } from "crypto";
+import { VISUDESIGNER_EXE, SCRATCH, killVisuDesigner } from "./engine.js";
+import { runEngineScript } from "./scriptRunner.js";
+import { ensureScratch } from "../core/scratch.js";
+function emitStr(s) {
+    return `"${s.replace(/\\/g, "\\\\").replace(/"/g, '\\"').replace(/\n/g, "\\n").replace(/\r/g, "\\r")}"`;
+}
+function emitPyScalar(v) {
+    if (v === null || v === undefined)
+        return "None";
+    if (typeof v === "boolean")
+        return v ? "True" : "False";
+    if (typeof v === "number")
+        return String(v);
+    return emitStr(String(v));
+}
+function emitStrList(arr) {
+    return `[${arr.map(emitStr).join(", ")}]`;
+}
+function emitOptStrList(arr) {
+    return arr && arr.length > 0 ? emitStrList(arr) : "None";
+}
+function emitTextElementsForEntry(entry) {
+    const { id, ...langs } = entry;
+    const langKeys = Object.keys(langs).filter((k) => langs[k] !== undefined);
+    if (langKeys.length === 0) {
+        return [`lvd.TextElement(${emitStr(id)})`];
+    }
+    return langKeys.map((lang) => `lvd.TextElement(${emitStr(id)}, ${emitStr(lang)}, ${emitStr(langs[lang])})`);
+}
+function emitTextList(def) {
+    let elements = "None";
+    if (def.texts && def.texts.length > 0) {
+        const elems = def.texts.flatMap(emitTextElementsForEntry);
+        elements = `[${elems.join(", ")}]`;
+    }
+    const rev = def.revision ? emitStr(def.revision) : "None";
+    return `lvd.TextList(${emitStr(def.name)}, ${elements}, ${rev})`;
+}
+function emitTextListForRemove(def) {
+    const elems = def.ids.map((id) => `lvd.TextElement(${emitStr(id)})`).join(", ");
+    return `lvd.TextList(${emitStr(def.name)}, [${elems}], None)`;
+}
+function emitPropertySet(def) {
+    return `lvd.PropertySet(${emitStr(def.element)}, ${emitStr(def.property)}, ${emitPyScalar(def.value)})`;
+}
+function emitSchemeEntry(e) {
+    const prop = e.property ? emitStr(e.property) : "None";
+    const val = emitPyScalar(e.value ?? null);
+    const newPos = e.new_position !== undefined ? String(e.new_position) : "None";
+    return `lvd.SchemeEntry(${e.position}, ${prop}, ${val}, ${newPos})`;
+}
+function emitSchemeFull(def) {
+    const inp = def.input ? emitStr(def.input) : "None";
+    let entries = "None";
+    if (def.entries && def.entries.length > 0) {
+        entries = `[${def.entries.map(emitSchemeEntry).join(", ")}]`;
+    }
+    return `lvd.Scheme(${emitStr(def.scheme_type)}, ${emitStr(def.name)}, ${inp}, ${entries})`;
+}
+function emitSchemeForRemove(def) {
+    return `lvd.Scheme(${emitStr(def.scheme_type)}, ${emitStr(def.name)}, None, None)`;
+}
+// Positions or entries to remove
+function emitSchemeForRemoveEntries(def) {
+    const positions = def.positions ?? def.entries?.map((e) => e.position) ?? [];
+    const elems = positions.map((p) => `lvd.SchemeEntry(${p})`).join(", ");
+    return `lvd.Scheme(${emitStr(def.scheme_type)}, ${emitStr(def.name)}, None, [${elems}])`;
+}
+function emitSchemeForMoves(def) {
+    const moves = def.moves ?? [];
+    const elems = moves.map((m) => `lvd.SchemeEntry(${m.from}, None, None, ${m.to})`).join(", ");
+    return `lvd.Scheme(${emitStr(def.scheme_type)}, ${emitStr(def.name)}, None, [${elems}])`;
+}
+function emitSchemeForInput(def) {
+    const inp = def.input ? emitStr(def.input) : "None";
+    return `lvd.Scheme(${emitStr(def.scheme_type)}, ${emitStr(def.name)}, ${inp}, None)`;
+}
+function emitMediaItem(def) {
+    return `lvd.MediaItem(${emitStr(def.media_type)}, ${emitStr(def.path ?? def.name ?? "")})`;
+}
+export function buildVisuScript(lvpPath, ops, logPath, stepsPath, saveAtEnd = true) {
+    const lines = [];
+    const expectedSteps = ["LoadProject"];
+    lines.push('    f_step = open(r"' + stepsPath + '", "a", encoding="utf-8")', '    f_step.write("STEP LoadProject OK\\n")', "    f_step.close()", "");
+    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 "update_all_stations":
+                opLines.push("lvd.UpdateAllStations(prj)");
+                break;
+            case "update_station":
+                opLines.push(`lvd.UpdateStation(prj, ${op.station_nr})`);
+                break;
+            case "publish":
+                opLines.push(`lvd.PublishProject(prj, ${op.debug ? "True" : "False"})`);
+                break;
+            case "add_text_lists":
+                opLines.push(`lvd.AddTextLists(prj, [${op.text_lists.map(emitTextList).join(", ")}])`);
+                break;
+            case "remove_text_lists":
+                opLines.push(`lvd.RemoveTextLists(prj, ${emitStrList(op.names)})`);
+                break;
+            case "add_texts":
+                opLines.push(`lvd.AddTexts(prj, [${op.text_lists.map(emitTextList).join(", ")}])`);
+                break;
+            case "remove_texts":
+                opLines.push(`lvd.RemoveTexts(prj, [${op.text_lists.map(emitTextListForRemove).join(", ")}])`);
+                break;
+            case "change_texts":
+                opLines.push(`lvd.ChangeTexts(prj, [${op.text_lists.map(emitTextList).join(", ")}])`);
+                break;
+            case "change_component_texts":
+                opLines.push(`lvd.ChangeComponentTexts(prj, [${op.text_lists.map(emitTextList).join(", ")}])`);
+                break;
+            case "set_text_list_revisions":
+                opLines.push(`lvd.SetTextListRevisions(prj, [${op.text_lists.map(emitTextList).join(", ")}])`);
+                break;
+            case "set_component_text_list_revisions":
+                opLines.push(`lvd.SetComponentTextListRevisions(prj, [${op.text_lists.map(emitTextList).join(", ")}])`);
+                break;
+            case "csv_export_text_lists":
+                opLines.push(`lvd.CsvExportTextLists(prj, ${emitStr(op.csv_path)}, ${emitOptStrList(op.text_lists)}, ${emitOptStrList(op.languages)})`);
+                break;
+            case "csv_import_text_lists":
+                opLines.push(`lvd.CsvImportTextLists(prj, ${emitStrList(op.file_paths)}, ${emitOptStrList(op.text_lists)}, ${emitOptStrList(op.languages)})`);
+                break;
+            case "csv_export_component_text_lists":
+                opLines.push(`lvd.CsvExportComponentTextLists(prj, ${emitStr(op.csv_path)}, ${emitOptStrList(op.text_lists)}, ${emitOptStrList(op.languages)})`);
+                break;
+            case "csv_import_component_text_lists":
+                opLines.push(`lvd.CsvImportComponentTextLists(prj, ${emitStrList(op.file_paths)}, ${emitOptStrList(op.text_lists)}, ${emitOptStrList(op.languages)})`);
+                break;
+            case "set_datapoint_properties":
+                opLines.push(`lvd.SetDatapointProperties(prj, [${op.properties.map(emitPropertySet).join(", ")}])`);
+                break;
+            case "set_datatype_properties":
+                opLines.push(`lvd.SetDataTypeProperties(prj, [${op.properties.map(emitPropertySet).join(", ")}])`);
+                break;
+            case "add_schemes":
+                opLines.push(`lvd.AddSchemes(prj, [${op.schemes.map(emitSchemeFull).join(", ")}])`);
+                break;
+            case "remove_schemes":
+                opLines.push(`lvd.RemoveSchemes(prj, [${op.schemes.map(emitSchemeForRemove).join(", ")}])`);
+                break;
+            case "add_scheme_entries":
+                opLines.push(`lvd.AddSchemeEntries(prj, [${op.schemes.map(emitSchemeFull).join(", ")}])`);
+                break;
+            case "remove_scheme_entries":
+                opLines.push(`lvd.RemoveSchemeEntries(prj, [${op.schemes.map(emitSchemeForRemoveEntries).join(", ")}])`);
+                break;
+            case "move_scheme_entries":
+                opLines.push(`lvd.MoveSchemeEntries(prj, [${op.schemes.map(emitSchemeForMoves).join(", ")}])`);
+                break;
+            case "set_scheme_inputs":
+                opLines.push(`lvd.SetSchemeInputs(prj, [${op.schemes.map(emitSchemeForInput).join(", ")}])`);
+                break;
+            case "set_scheme_properties":
+                opLines.push(`lvd.SetSchemeProperties(prj, ${emitStr(op.scheme_type)}, [${op.properties.map(emitPropertySet).join(", ")}])`);
+                break;
+            case "set_scheme_entry_properties":
+                opLines.push(`lvd.SetSchemeEntryProperties(prj, [${op.schemes.map(emitSchemeFull).join(", ")}])`);
+                break;
+            case "add_media_items": {
+                const overwrite = op.overwrite ? "True" : "False";
+                opLines.push(`lvd.AddMediaItems(prj, [${op.items.map(emitMediaItem).join(", ")}], ${overwrite})`);
+                break;
+            }
+            case "remove_media_items":
+                opLines.push(`lvd.RemoveMediaItems(prj, [${op.items.map(emitMediaItem).join(", ")}])`);
+                break;
+            case "add_code_modules":
+                opLines.push(`lvd.AddCodeModules(prj, ${emitStrList(op.paths)})`);
+                break;
+            case "remove_code_modules":
+                opLines.push(`lvd.RemoveCodeModules(prj, ${emitStrList(op.names)})`);
+                break;
+            case "update_property_values":
+                opLines.push("lvd.UpdatePropertyValues(prj)");
+                break;
+            case "download": {
+                const flags = op.flags ?? 0;
+                const addRuntime = op.add_runtime ? "True" : "False";
+                opLines.push(`lvd.DownloadProject(prj, ${emitStr(op.connection)}, ${flags}, ${addRuntime})`);
+                break;
+            }
+        }
+        for (const opLine of opLines) {
+            lines.push(`    ${opLine}`);
+        }
+        lines.push(`    f_step = open(r"${stepsPath}", "a", encoding="utf-8")`, `    f_step.write("STEP ${label} OK\\n")`, `    f_step.close()`, "");
+    }
+    if (saveAtEnd) {
+        expectedSteps.push("SaveProject");
+        lines.push("    lvd.SaveProject(prj)", `    f_step = open(r"${stepsPath}", "a", encoding="utf-8")`, `    f_step.write("STEP SaveProject OK\\n")`, `    f_step.close()`, "");
+    }
+    expectedSteps.push("CloseProject");
+    lines.push("    lvd.CloseProject(prj)", `    f_step = open(r"${stepsPath}", "a", encoding="utf-8")`, `    f_step.write("STEP CloseProject OK\\n")`, `    f_step.close()`, "");
+    const finalScript = [
+        "import sys",
+        "import traceback",
+        `log_file = open(${emitStr(logPath)}, "w", encoding="utf-8")`,
+        "sys.stdout = log_file",
+        "sys.stderr = log_file",
+        "",
+        "import sigmatek.lasal.lvd as lvd",
+        "lvd.SetExceptionOnError(True)",
+        "",
+        "try:",
+        `    prj = lvd.LoadProject(${emitStr(lvpPath)})`,
+        "    if prj is None: raise RuntimeError('Failed to load project')",
+        "",
+        lines.join("\n"),
+        "except Exception as e:",
+        "    print('(ERROR) Exception occurred during script execution:')",
+        "    traceback.print_exc()",
+        "    sys.exit(1)",
+        "finally:",
+        "    log_file.close()",
+    ].join("\n") + "\n";
+    return {
+        script: finalScript,
+        expectedSteps,
+    };
+}
+export async function runVisuOps(lvpPath, ops, saveAtEnd = true, timeoutMs = 180_000) {
+    ensureScratch();
+    const id = randomUUID();
+    const scriptPath = join(SCRATCH, `visu_${id}.py`);
+    const logPath = join(SCRATCH, `visu_${id}.log`);
+    const stepsPath = join(SCRATCH, `visu_${id}.steps`);
+    const { script, expectedSteps } = buildVisuScript(lvpPath, ops, logPath, stepsPath, saveAtEnd);
+    writeFileSync(scriptPath, script, "utf-8");
+    killVisuDesigner();
+    const result = await runEngineScript(scriptPath, {
+        exe: VISUDESIGNER_EXE,
+        argsFor: (p) => ["--script", p],
+        timeoutMs,
+        logEncoding: "utf-8",
+        killOnFailure: killVisuDesigner,
+        expectedSteps,
+        stepsPath,
+    }, logPath);
+    return {
+        ok: result.ok,
+        exitCode: result.exitCode,
+        logPath: result.logPath,
+        errors: result.errors,
+        warnings: result.warnings,
+        durationMs: result.durationMs,
+        steps: result.steps,
+        timedOut: result.timedOut,
+        hints: result.hints,
+    };
+}