layoutbridge-light 1.0.0 → 1.0.1

package/dist/src/transport/com.js

@@ -5,11 +5,20 @@
  * Windows-Rechner steht; der Interpreter und das Befehlsformat {cmd, args}
  * bleiben unveraendert.
  *
- * Ablauf je Aufruf:
- *  1. Interpreter und Handler zu einem Skript zusammensetzen, den Befehl als
- *     ASCII-JSON hineinschreiben und in eine temporaere .jsx-Datei legen.
- *  2. Eine .ps1-Datei danebenlegen, die sich die Anwendung ueber COM holt und
- *     ihr das Skript per doScript uebergibt. Erst GetActiveObject (Running
+ * Ablauf je Aufruf (seit Sitzung 80, A-74):
+ *  1. Interpreter und Handler samt festem Rahmen liegen als Skriptdatei in
+ *     einem festen Arbeitsordner (`%LOCALAPPDATA%\layoutbridge-spm\com`),
+ *     einmal je Buendelstand geschrieben (Pruefsumme im Namen). Daneben ein
+ *     festes PowerShell-Skript. Je Aufruf entstehen nur Datendateien: der
+ *     Befehl als ASCII-JSON und das Ergebnis. Vorher entstanden je Aufruf
+ *     zwei neue Skriptdateien (.jsx mit ~0,9 MB, .ps1) in einem neuen
+ *     Temp-Ordner; ein Virenschutz mit Echtzeitpruefung (beim Kunden Avira,
+ *     per Test bestaetigt 10.11.2026) hielt jede davon an – Aufrufe 12 s bis
+ *     122 s statt unter einer Sekunde. Ein fester Ordner laesst sich zudem
+ *     gezielt als Ausnahme eintragen.
+ *  2. PowerShell holt sich die Anwendung ueber COM und uebergibt ihr das
+ *     Skript per doScript, den Befehl und den Ergebnispfad ueber
+ *     withArguments (im Skript `arguments`). Erst GetActiveObject (Running
  *     Object Table), dann CoCreateInstance (New-Object -ComObject): InDesign
  *     traegt sich nicht in die Running Object Table ein, CoCreateInstance
  *     verbindet aber mit der laufenden Instanz und startet sie sonst - wie
@@ -29,24 +38,34 @@
  * der Rueckfall auf CoCreateInstance traegt.
  */
 import { spawn } from 'node:child_process';
-import { mkdtempSync, readFileSync, rmSync, writeFileSync } from 'node:fs';
+import { createHash, randomBytes } from 'node:crypto';
+import { existsSync, mkdirSync, readdirSync, readFileSync, renameSync, rmSync, statSync, writeFileSync, } from 'node:fs';
 import { tmpdir } from 'node:os';
 import { join } from 'node:path';
 import { buildScriptBundle, toAsciiJson } from './script-bundle.js';
-import { transportError, } from './transport.js';
+import { attachTiming, transportError, } from './transport.js';
 /** ScriptLanguage.javascript im Objektmodell – als Zahl, weil COM keine Aufzaehlung kennt. */
 export const SCRIPT_LANGUAGE_JAVASCRIPT = 1246973031;
 /** Zeilen, mit denen sich das PowerShell-Skript meldet, wenn es selbst abbricht. */
 export const APP_NOT_AVAILABLE_MARKER = 'IDC-COM-ERROR app_not_available:';
 export const SCRIPT_ERROR_MARKER = 'IDC-COM-ERROR script_error:';
+/** Zeile mit den Zeitanteilen aus PowerShell (nur Protokoll, A-74). */
+export const TIMING_MARKER = 'IDC-COM-TIMING';
+/** Aufgeraeumt wird, was laenger als einen Tag im Arbeitsordner liegt. */
+const STALE_MS = 24 * 60 * 60 * 1000;
+/**
+ * Fester Arbeitsordner des Windows-Transports:
+ * `%LOCALAPPDATA%\<produkt>\com`, ohne LOCALAPPDATA im Temp-Ordner.
+ */
+export function defaultComWorkDir(dataDirName = 'layoutbridge-spm', env = process.env) {
+    const local = env['LOCALAPPDATA'];
+    const base = local !== undefined && local.length > 0 ? local : tmpdir();
+    return join(base, dataDirName, 'com');
+}
 /** Text in einem PowerShell-Literal mit einfachen Anfuehrungszeichen. */
 export function escapeForPowerShell(text) {
     return text.replace(/'/g, "''");
 }
-/** Text in einem JavaScript-Literal mit doppelten Anfuehrungszeichen. */
-function escapeForJsString(text) {
-    return text.replace(/\\/g, '\\\\').replace(/"/g, '\\"');
-}
 /**
  * Wertet den Ausgang eines Aufrufs aus. Reine Funktion ohne Dateisystem und
  * ohne Prozess, damit die Einheitstests jede Fehlerart ohne Windows pruefen.
@@ -95,6 +114,60 @@ function markedMessage(stderr, marker) {
     const line = (end < 0 ? rest : rest.slice(0, end)).trim();
     return line.length > 0 ? line : marker.replace(':', '');
 }
+/** Zieht die Zeitzeile aus stderr: Zeitanteile und der uebrige Text. */
+export function splitTiming(stderr) {
+    const timing = {};
+    const kept = [];
+    for (const line of stderr.split(/\r?\n/)) {
+        const at = line.indexOf(TIMING_MARKER);
+        if (at < 0) {
+            kept.push(line);
+            continue;
+        }
+        for (const pair of line.slice(at + TIMING_MARKER.length).trim().split(/\s+/)) {
+            const eq = pair.indexOf('=');
+            if (eq <= 0)
+                continue;
+            const value = Number(pair.slice(eq + 1));
+            if (Number.isFinite(value))
+                timing['ps_' + pair.slice(0, eq)] = value;
+        }
+    }
+    return { timing, rest: kept.join('\n') };
+}
+/** Kurze Pruefsumme eines Textes fuer Dateinamen. */
+function shortHash(text) {
+    return createHash('sha256').update(text, 'utf8').digest('hex').slice(0, 16);
+}
+/**
+ * Schreibt eine Datei nur, wenn sie mit diesem Inhalt noch nicht da ist
+ * (Pruefsumme im Namen, Groesse als Vollstaendigkeitsprobe). Erst unter
+ * eigenem Namen, dann umbenennen: Mehrere Serverinstanzen koennen
+ * gleichzeitig starten, keine liest eine halb geschriebene Datei.
+ * Liefert true, wenn geschrieben wurde.
+ */
+export function ensureFile(path, content) {
+    const size = Buffer.byteLength(content, 'utf8');
+    try {
+        if (existsSync(path) && statSync(path).size === size)
+            return false;
+    }
+    catch {
+        /* dann neu schreiben */
+    }
+    const temporary = path + '.' + process.pid + '.' + randomBytes(4).toString('hex') + '.tmp';
+    writeFileSync(temporary, content, 'utf8');
+    try {
+        renameSync(temporary, path);
+    }
+    catch (error) {
+        rmSync(temporary, { force: true });
+        /* Eine andere Instanz war schneller und haelt die Datei offen. */
+        if (!(existsSync(path) && statSync(path).size === size))
+            throw error;
+    }
+    return true;
+}
 export class ComTransport {
     name = 'com';
     progIds;
@@ -102,44 +175,69 @@ export class ComTransport {
     defaultTimeoutMs;
     keepTempFiles;
     runner;
+    workDir;
+    sequence = 0;
+    cleaned = false;
+    /** Zuletzt bereitgelegtes Buendel (gleiches Objekt = gleicher Stand). */
+    preparedBundle = null;
+    preparedScriptPath = '';
+    preparedPowerShellPath = '';
     constructor(options = {}) {
         this.progIds = options.progIds ?? ['InDesign.Application'];
         this.powershellPath = options.powershellPath ?? 'powershell.exe';
         this.defaultTimeoutMs = options.defaultTimeoutMs ?? 120_000;
         this.keepTempFiles = options.keepTempFiles ?? false;
         this.runner = options.runner ?? runProcess;
+        this.workDir = options.workDir ?? defaultComWorkDir(options.dataDirName);
     }
-    /** Das vollstaendige Skript inklusive Rahmen, der das Ergebnis wegschreibt. */
-    buildScript(command, resultPath) {
-        const bundle = buildScriptBundle();
-        const commandLiteral = toAsciiJson(command);
-        const target = escapeForJsString(resultPath);
+    /**
+     * Das vollstaendige Skript: Buendel plus fester Rahmen. Der Befehl steht
+     * nicht darin – er kommt ueber withArguments (arguments[0] Befehl als
+     * ASCII-JSON, arguments[1] Ergebnispfad). So bleibt die Datei je
+     * Buendelstand gleich.
+     */
+    buildScript(bundle = buildScriptBundle()) {
         const frame = [
             '',
             '/* ---- Rahmen des com-Transports (ExtendScript, Windows) ---- */',
-            '(function () {',
-            '  var __text = IDC.run(' + commandLiteral + ');',
-            '  var __file = new File("' + target + '");',
+            'var __idcArgs = (typeof arguments !== "undefined" && arguments !== null) ? arguments : [];',
+            '(function (commandText, resultPath) {',
+            '  var __text, __file;',
+            '  if (commandText === undefined || commandText === null || resultPath === undefined || resultPath === null) {',
+            '    return "missing arguments";',
+            '  }',
+            '  __text = IDC.run(eval("(" + String(commandText) + ")"));',
+            '  __file = new File(String(resultPath));',
             '  __file.encoding = "UTF-8";',
             '  __file.lineFeed = "Unix";',
             '  __file.open("w");',
             '  __file.write(__text);',
             '  __file.close();',
             '  return "ok";',
-            '})();',
+            '})(__idcArgs[0], __idcArgs[1]);',
             '',
         ].join('\n');
         return bundle + '\n' + frame;
     }
     /**
-     * Das PowerShell-Skript: Anwendung ueber COM holen (GetActiveObject, sonst
-     * New-Object -ComObject), Skripttext lesen, doScript aufrufen. Bricht es selbst ab, meldet es sich mit einer
-     * Markerzeile, damit die Fehlerart nicht aus Fremdtexten geraten wird.
+     * Das feste PowerShell-Skript: Anwendung ueber COM holen (GetActiveObject,
+     * sonst New-Object -ComObject), Skript- und Befehlsdatei lesen, doScript
+     * mit withArguments aufrufen. Pfade kommen als Parameter. Bricht es selbst
+     * ab, meldet es sich mit einer Markerzeile, damit die Fehlerart nicht aus
+     * Fremdtexten geraten wird. Zeitanteile stehen in einer eigenen Zeile.
      */
-    buildPowerShell(scriptPath) {
+    buildPowerShell() {
         const ids = this.progIds.map((id) => "'" + escapeForPowerShell(id) + "'").join(', ');
         return [
+            'param([string]$ScriptPath, [string]$CommandPath, [string]$ResultPath)',
             '$ErrorActionPreference = ' + "'Stop'",
+            '$watch = [Diagnostics.Stopwatch]::StartNew()',
+            '$marks = @{}',
+            'function Write-IdcTiming {',
+            "  $line = '" + TIMING_MARKER + "'",
+            '  foreach ($key in $marks.Keys) { $line += (" " + $key + "=" + $marks[$key]) }',
+            '  [Console]::Error.WriteLine($line)',
+            '}',
             '$progIds = @(' + ids + ')',
             '$app = $null',
             '$reasons = @()',
@@ -161,40 +259,125 @@ export class ComTransport {
             '    }',
             '  }',
             '}',
+            "$marks['connect'] = $watch.ElapsedMilliseconds",
             'if ($null -eq $app) {',
+            '  Write-IdcTiming',
             '  [Console]::Error.WriteLine(' + "'" + APP_NOT_AVAILABLE_MARKER +
                 " ' + ($reasons -join '; '))",
             '  exit 3',
             '}',
-            '$scriptText = [IO.File]::ReadAllText(' + "'" + escapeForPowerShell(scriptPath) +
-                "', [Text.Encoding]::UTF8)",
+            '$scriptText = [IO.File]::ReadAllText($ScriptPath, [Text.Encoding]::UTF8)',
+            '$commandText = [IO.File]::ReadAllText($CommandPath, [Text.Encoding]::UTF8)',
+            "$marks['read'] = $watch.ElapsedMilliseconds - $marks['connect']",
             'try {',
-            '  $null = $app.DoScript($scriptText, ' + SCRIPT_LANGUAGE_JAVASCRIPT + ')',
+            '  $null = $app.DoScript($scriptText, ' + SCRIPT_LANGUAGE_JAVASCRIPT +
+                ', [object[]]@($commandText, $ResultPath))',
             '} catch {',
+            "  $marks['doscript'] = $watch.ElapsedMilliseconds - $marks['connect'] - $marks['read']",
+            '  Write-IdcTiming',
             '  [Console]::Error.WriteLine(' + "'" + SCRIPT_ERROR_MARKER +
                 " ' + $_.Exception.Message)",
             '  exit 4',
             '}',
+            "$marks['doscript'] = $watch.ElapsedMilliseconds - $marks['connect'] - $marks['read']",
+            "$marks['total'] = $watch.ElapsedMilliseconds",
+            'Write-IdcTiming',
             'exit 0',
             '',
         ].join('\n');
     }
+    /**
+     * Legt Skript- und PowerShell-Datei in den Arbeitsordner, falls noetig.
+     * Liefert true, wenn in diesem Aufruf eine davon geschrieben wurde.
+     */
+    prepare() {
+        const bundle = buildScriptBundle();
+        if (bundle === this.preparedBundle && existsSync(this.preparedScriptPath) && existsSync(this.preparedPowerShellPath)) {
+            return false;
+        }
+        mkdirSync(this.workDir, { recursive: true });
+        const script = this.buildScript(bundle);
+        const powerShell = this.buildPowerShell();
+        const scriptPath = join(this.workDir, 'script-' + shortHash(script) + '.jsx');
+        const powerShellPath = join(this.workDir, 'run-' + shortHash(powerShell) + '.ps1');
+        let written = ensureFile(scriptPath, script);
+        written = ensureFile(powerShellPath, powerShell) || written;
+        this.preparedBundle = bundle;
+        this.preparedScriptPath = scriptPath;
+        this.preparedPowerShellPath = powerShellPath;
+        if (!this.cleaned) {
+            this.cleaned = true;
+            this.removeStale([scriptPath, powerShellPath]);
+        }
+        return written;
+    }
+    /** Alte Dateien frueherer Staende und liegengebliebener Aufrufe entfernen. */
+    removeStale(keep) {
+        const now = Date.now();
+        let names = [];
+        try {
+            names = readdirSync(this.workDir);
+        }
+        catch {
+            return;
+        }
+        for (const name of names) {
+            const path = join(this.workDir, name);
+            if (keep.includes(path))
+                continue;
+            if (!/^(script-.*\.jsx|run-.*\.ps1|call-.*\.json|.*\.tmp)$/.test(name))
+                continue;
+            try {
+                if (now - statSync(path).mtimeMs > STALE_MS)
+                    rmSync(path, { force: true });
+            }
+            catch {
+                /* Aufraeumen darf keinen Aufruf scheitern lassen. */
+            }
+        }
+    }
     async send(command, options = {}) {
         const timeoutMs = options.timeoutMs ?? this.defaultTimeoutMs;
-        let directory;
+        const timing = { begin: Date.now() };
+        let mark = Date.now();
+        const lap = (key) => {
+            const now = Date.now();
+            timing[key] = now - mark;
+            mark = now;
+        };
+        this.sequence += 1;
+        const stem = 'call-' + process.pid + '-' + this.sequence + '-' + randomBytes(4).toString('hex');
+        const commandPath = join(this.workDir, stem + '.command.json');
+        const resultPath = join(this.workDir, stem + '.result.json');
         try {
-            directory = mkdtempSync(join(tmpdir(), 'idc-spm-'));
+            timing['script_written'] = this.prepare() ? 1 : 0;
+            writeFileSync(commandPath, toAsciiJson(command), 'utf8');
         }
         catch (error) {
-            return transportError('io_error', 'Could not create a temporary directory.', String(error));
+            return transportError('io_error', 'Could not prepare the script files of the Windows transport.', String(error));
         }
-        const scriptPath = join(directory, 'command.jsx');
-        const resultPath = join(directory, 'result.json');
-        const powerShellPath = join(directory, 'command.ps1');
+        lap('prepare');
         try {
-            writeFileSync(scriptPath, this.buildScript(command, resultPath), 'utf8');
-            writeFileSync(powerShellPath, this.buildPowerShell(scriptPath), 'utf8');
-            const outcome = await this.runner(this.powershellPath, ['-NoProfile', '-NonInteractive', '-ExecutionPolicy', 'Bypass', '-File', powerShellPath], timeoutMs);
+            const outcome = await this.runner(this.powershellPath, [
+                '-NoProfile',
+                '-NonInteractive',
+                '-ExecutionPolicy',
+                'Bypass',
+                '-File',
+                this.preparedPowerShellPath,
+                '-ScriptPath',
+                this.preparedScriptPath,
+                '-CommandPath',
+                commandPath,
+                '-ResultPath',
+                resultPath,
+            ], timeoutMs);
+            lap('process');
+            const split = splitTiming(outcome.stderr);
+            Object.assign(timing, split.timing);
+            if (split.timing['ps_total'] !== undefined && timing['process'] !== undefined) {
+                timing['ps_start'] = Math.max(0, timing['process'] - split.timing['ps_total']);
+            }
             let raw = null;
             try {
                 raw = readFileSync(resultPath, 'utf8');
@@ -202,17 +385,20 @@ export class ComTransport {
             catch {
                 raw = null;
             }
-            return interpretOutcome(outcome, raw, command, timeoutMs);
+            lap('read_result');
+            return attachTiming(interpretOutcome({ ...outcome, stderr: split.rest }, raw, command, timeoutMs), timing);
         }
         finally {
             if (!this.keepTempFiles) {
                 try {
-                    rmSync(directory, { recursive: true, force: true });
+                    rmSync(commandPath, { force: true });
+                    rmSync(resultPath, { force: true });
                 }
                 catch {
                     /* Aufraeumen darf keinen Aufruf scheitern lassen. */
                 }
             }
+            lap('cleanup');
         }
     }
     async close() {

package/dist/src/transport/transport.js

@@ -20,6 +20,28 @@ export const ERROR_KINDS = [
     'script_error',
     'license',
 ];
+/**
+ * Zeitanteile eines Aufrufs fuer das Protokoll (A-74, Sitzung 80). Haengt
+ * unter einem Symbol am Ergebnis: JSON.stringify und Object.keys sehen es
+ * nicht, die Antwort an den Client bleibt also unveraendert. Der Aufrufer
+ * nimmt es mit takeTiming() ab.
+ */
+export const TIMING = Symbol('idc.timing');
+export function attachTiming(result, timing) {
+    Object.defineProperty(result, TIMING, { value: timing, enumerable: false, configurable: true });
+    return result;
+}
+/** Liest die Zeitanteile und entfernt sie vom Ergebnis; null, wenn keine da sind. */
+export function takeTiming(result) {
+    if (result === null || typeof result !== 'object')
+        return null;
+    const holder = result;
+    const timing = holder[TIMING];
+    if (timing === undefined)
+        return null;
+    delete holder[TIMING];
+    return timing;
+}
 /** Baut einen Fehlerumschlag, ohne dass InDesign beteiligt war. */
 export function transportError(kind, message, details = null) {
     return { ok: false, warnings: [], error: { kind, message, details } };