trm-core 9.10.6 → 10.0.0

package/README.md

@@ -43,7 +43,27 @@ Install the official CLI client via npm:
 npm install trm-client -g
 ```
 
+# Development
+
+To contribute to `trm-core`, fork the repository, clone your fork, and install the dependencies:
+
+```bash
+git clone https://github.com/RegestaItalia/trm-core.git
+cd trm-core
+npm ci
+```
+
+The project requires Node.js 22.12.0 or newer. Before submitting a change, run the test suite and compile the TypeScript project:
+
+```bash
+npm test
+npm run build
+```
+
+Development guides for specific areas of the codebase are available in [`docs/development`](docs/development/). Follow the relevant guide when your change affects one of those areas.
+
 # Contributing
+
 Like every other TRM open-source projects, contributions are always welcomed ❤️.
 
 Make sure to open an issue first.

package/changelog.txt

@@ -8,13 +8,10 @@ Legend
 + : added
 - : removed
 
-2026-09-23 v9.10.6
+2026-08-05 v10.0.0
 -------------------
-! trm-commons ^5.1.0
-
-2026-07-29 v9.10.5
--------------------
-+ allow self signed certificates in rest client
++ usage of registry /transport route (when available)
++ important log messages (kept visible at the end of an action)
 
 2026-07-29 v9.10.4
 -------------------

package/dist/actions/cg3y/download.js

@@ -47,22 +47,52 @@ const transport_1 = require("../../transport");
 const trm_commons_1 = require("trm-commons");
 const AdmZip = __importStar(require("adm-zip"));
 const systemConnector_1 = require("../../systemConnector");
+/**
+ * Workflow step that verifies and exports a released transport into a ZIP archive.
+ *
+ * 1- check is released, exportable request
+ *
+ * 2- download
+ *
+ * 3- zip
+ *
+*/
+const TRKORR_PATTERN = /^[A-Z0-9]{3}K\d{6}$/;
+const TASK_TRFUNCTIONS = ['S', 'R', 'Q', 'X'];
+function isEmptyBinary(buffer) {
+    return !buffer || buffer.length === 0;
+}
 exports.download = {
     name: 'download',
     run: (context) => __awaiter(void 0, void 0, void 0, function* () {
-        trm_commons_1.Logger.log('Download step', true);
-        const transport = new transport_1.Transport(context.rawInput.trkorr);
+        const trkorr = (context.rawInput.trkorr || '').trim().toUpperCase();
+        if (!TRKORR_PATTERN.test(trkorr)) {
+            throw new Error(`Invalid transport number "${context.rawInput.trkorr}".`);
+        }
+        const transport = new transport_1.Transport(trkorr);
         trm_commons_1.Logger.loading(`Checking "${transport.trkorr}"...`);
-        const exists = !!(yield transport.getE070());
-        if (!exists) {
+        const e070 = yield transport.getE070();
+        if (!e070) {
             throw new Error(`Transport "${transport.trkorr}" was not found in ${systemConnector_1.SystemConnector.getDest()}.`);
         }
+        //1- check is released, exportable request
+        if (TASK_TRFUNCTIONS.includes(e070.trfunction)) {
+            throw new Error(`"${transport.trkorr}" is a task, not a transport request. Download its request instead.`);
+        }
         const isReleased = yield transport.isReleased();
         if (!isReleased) {
             throw new Error(`Transport "${transport.trkorr}" is not released. To download, release it first.`);
         }
+        if (!(e070.tarsystem || '').trim()) {
+            throw new Error(`Transport "${transport.trkorr}" is a local request (no target system) and has no export files.`);
+        }
+        //2- download
         trm_commons_1.Logger.loading(`Downloading transport ${transport_1.Transport.getTransportIcon()}  ${transport.trkorr}...`);
         const data = yield transport.download();
+        if (isEmptyBinary(data.binaries.header) || isEmptyBinary(data.binaries.data)) {
+            throw new Error(`Transport "${transport.trkorr}" export files are missing or empty.`);
+        }
+        //3- zip
         const zip = new AdmZip.default();
         zip.addFile(data.filenames.header, data.binaries.header);
         zip.addFile(data.filenames.data, data.binaries.data);

package/dist/actions/cg3y/index.d.ts

@@ -1,15 +1,38 @@
 import { TRKORR } from "../../client";
+/** Input required to export a transport from the connected SAP system. */
 export interface Cg3yActionInput {
+    /**
+    * Released SAP transport request number to export, for example `DEVK900123`.
+    */
     trkorr: TRKORR;
 }
 type WorkflowRuntime = {};
+/** Result of a successful {@link cg3y} export. */
 export type Cg3yActionOutput = {
+    /**
+    * ZIP archive containing the transport's `K` header file and `R` data file.
+    */
     binaries: Buffer;
 };
+/** Internal workflow state used by the CG3Y action steps. */
 export interface Cg3yWorkflowContext {
+    /** Original action input. */
     rawInput: Cg3yActionInput;
+    /** Reserved runtime state for workflow steps. */
     runtime?: WorkflowRuntime;
+    /** Export result, populated by the download step. */
     output?: Cg3yActionOutput;
 }
+/**
+ * Exports a released SAP transport as an in-memory ZIP archive.
+ *
+ * The connected user is authorized first, then the action verifies that the transport
+ * exists and is released before downloading its header and data files.
+ *
+ * @param inputData Transport export request.
+ * @returns A ZIP archive containing one matching transport header/data pair.
+ * @throws When authorization fails, the transport number is invalid, the transport does not exist, is a task,
+ * is not released, is a local request without target system, or its export files are missing or empty.
+ */
 export declare function cg3y(inputData: Cg3yActionInput): Promise<Cg3yActionOutput>;
 export {};

package/dist/actions/cg3y/index.js

@@ -8,29 +8,32 @@ var __awaiter = (this && this.__awaiter) || function (thisArg, _arguments, P, ge
         step((generator = generator.apply(thisArg, _arguments || [])).next());
     });
 };
-var __importDefault = (this && this.__importDefault) || function (mod) {
-    return (mod && mod.__esModule) ? mod : { "default": mod };
-};
 Object.defineProperty(exports, "__esModule", { value: true });
 exports.cg3y = cg3y;
-const sammarksworkflow_1 = __importDefault(require("@simonegaffurini/sammarksworkflow"));
-const util_1 = require("util");
-const trm_commons_1 = require("trm-commons");
 const __1 = require("..");
 const download_1 = require("./download");
 ;
 const WORKFLOW_NAME = 'cg3y';
+/**
+ * Exports a released SAP transport as an in-memory ZIP archive.
+ *
+ * The connected user is authorized first, then the action verifies that the transport
+ * exists and is released before downloading its header and data files.
+ *
+ * @param inputData Transport export request.
+ * @returns A ZIP archive containing one matching transport header/data pair.
+ * @throws When authorization fails, the transport number is invalid, the transport does not exist, is a task,
+ * is not released, is a local request without target system, or its export files are missing or empty.
+ */
 function cg3y(inputData) {
     return __awaiter(this, void 0, void 0, function* () {
         const workflow = [
             __1.checkServerAuth,
             download_1.download
         ];
-        trm_commons_1.Logger.log(`Ready to execute workflow ${WORKFLOW_NAME}, input data: ${(0, util_1.inspect)(inputData, { breakLength: Infinity, compact: true })}`, true);
-        const result = yield (0, sammarksworkflow_1.default)(WORKFLOW_NAME, workflow, {
+        const result = yield (0, __1.executeWorkflow)(WORKFLOW_NAME, workflow, {
             rawInput: inputData
-        });
-        trm_commons_1.Logger.log(`Workflow ${WORKFLOW_NAME} result: ${(0, util_1.inspect)(result, { breakLength: Infinity, compact: true })}`, true);
+        }, __1.workflowCallbacks);
         return {
             binaries: result.output.binaries
         };

package/dist/actions/cg3z/index.d.ts

@@ -1,17 +1,81 @@
-import { R3transOptions } from "node-r3trans";
 import { TRKORR } from "../../client";
+/** Shared execution settings for the CG3Z action. */
+export type Cg3zActionInputContextData = {
+    /**
+     * Disable interactive prompts. Any required choice without an explicit value then causes an error.
+     */
+    noInquirer?: boolean;
+};
+/** Options controlling the transport upload. */
+export type Cg3zActionInputUploadData = {
+    /**
+     * Whether to overwrite a transport that already exists in the target system (E070 entry,
+     * header or data file). `true` overwrites and `false` aborts. When omitted, the user is asked;
+     * with `noInquirer` the upload is aborted.
+     */
+    overwrite?: boolean;
+};
+/** Input required to upload a transport to the connected SAP system. */
 export interface Cg3zActionInput {
-    r3transOptions?: R3transOptions;
+    /** Optional shared execution settings. */
+    contextData?: Cg3zActionInputContextData;
+    /** Optional upload settings. */
+    uploadData?: Cg3zActionInputUploadData;
+    /**
+    * ZIP archive containing exactly one matching `K` header file and `R` data file.
+    */
     binaries: Buffer;
 }
-type WorkflowRuntime = {};
+/** SAP changes attempted by the upload step, each set before its call so a failure is rolled back too. */
+export type Cg3zUploadProgress = {
+    /** The transport was already in the connected system import queue: rollback must never remove it. */
+    queued: boolean;
+    /** Header (cofile) write attempted. */
+    header?: boolean;
+    /** Data file write attempted. */
+    data?: boolean;
+    /** Forward to the connected system import queue attempted. */
+    forwarded?: boolean;
+};
+type WorkflowRuntime = {
+    /** Upload progress, set once SAP writes begin. */
+    progress?: Cg3zUploadProgress;
+    /** State of an existing transport that is being overwritten, restored on rollback. */
+    overwritten?: {
+        /** The transport already had an E070 entry: rollback must never delete it. */
+        e070: boolean;
+        /** Previous header (cofile) content. */
+        header?: Buffer;
+        /** Previous data file content. */
+        data?: Buffer;
+    };
+};
+/** Result of a successful {@link cg3z} upload. */
 export type Cg3zActionOutput = {
+    /**
+    * Transport request number derived from the uploaded file names.
+    */
     trkorr: TRKORR;
 };
+/** Internal workflow state used by the CG3Z action steps. */
 export interface Cg3zWorkflowContext {
+    /** Original action input. */
     rawInput: Cg3zActionInput;
+    /** Reserved runtime state for workflow steps. */
     runtime?: WorkflowRuntime;
+    /** Upload result, populated after the archive has been validated. */
     output?: Cg3zActionOutput;
 }
+/**
+ * Uploads and forwards one SAP transport from an in-memory ZIP archive. When an existing transport
+ * is overwritten, its TMS text is refreshed too.
+ *
+ * @param inputData Transport archive and optional upload settings.
+ * @returns The uploaded transport request number.
+ * @throws When authorization fails, the archive is malformed, the header/data files do
+ * not identify the same transport, the transport already exists and overwriting is refused
+ * (or cannot be confirmed with `noInquirer`), or the upload/forward operation fails. A transport-text
+ * refresh failure (overwrite only) is logged as a warning and does not reject the action.
+ */
 export declare function cg3z(inputData: Cg3zActionInput): Promise<Cg3zActionOutput>;
 export {};

package/dist/actions/cg3z/index.js

@@ -8,31 +8,42 @@ var __awaiter = (this && this.__awaiter) || function (thisArg, _arguments, P, ge
         step((generator = generator.apply(thisArg, _arguments || [])).next());
     });
 };
-var __importDefault = (this && this.__importDefault) || function (mod) {
-    return (mod && mod.__esModule) ? mod : { "default": mod };
-};
 Object.defineProperty(exports, "__esModule", { value: true });
 exports.cg3z = cg3z;
-const sammarksworkflow_1 = __importDefault(require("@simonegaffurini/sammarksworkflow"));
-const util_1 = require("util");
-const trm_commons_1 = require("trm-commons");
 const __1 = require("..");
 const upload_1 = require("./upload");
+const utils_1 = require("../commons/utils");
 ;
 const WORKFLOW_NAME = 'cg3z';
+/**
+ * Uploads and forwards one SAP transport from an in-memory ZIP archive. When an existing transport
+ * is overwritten, its TMS text is refreshed too.
+ *
+ * @param inputData Transport archive and optional upload settings.
+ * @returns The uploaded transport request number.
+ * @throws When authorization fails, the archive is malformed, the header/data files do
+ * not identify the same transport, the transport already exists and overwriting is refused
+ * (or cannot be confirmed with `noInquirer`), or the upload/forward operation fails. A transport-text
+ * refresh failure (overwrite only) is logged as a warning and does not reject the action.
+ */
 function cg3z(inputData) {
     return __awaiter(this, void 0, void 0, function* () {
+        var _a, _b;
+        const trkorr = (0, upload_1.parseTransportArchive)(inputData.binaries).trkorr;
+        const lockScope = new utils_1.ActionLockScope(WORKFLOW_NAME);
+        yield lockScope.acquire([{ type: "TRANSPORT", name: trkorr }]);
         const workflow = [
             __1.checkServerAuth,
             upload_1.upload
         ];
-        trm_commons_1.Logger.log(`Ready to execute workflow ${WORKFLOW_NAME}, input data: ${(0, util_1.inspect)(inputData, { breakLength: Infinity, compact: true })}`, true);
-        const result = yield (0, sammarksworkflow_1.default)(WORKFLOW_NAME, workflow, {
-            rawInput: inputData
-        });
-        trm_commons_1.Logger.log(`Workflow ${WORKFLOW_NAME} result: ${(0, util_1.inspect)(result, { breakLength: Infinity, compact: true })}`, true);
-        return {
-            trkorr: result.output.trkorr
-        };
+        (_a = inputData.contextData) !== null && _a !== void 0 ? _a : (inputData.contextData = {});
+        (_b = inputData.uploadData) !== null && _b !== void 0 ? _b : (inputData.uploadData = {});
+        return (0, utils_1.withActionLockScope)(lockScope, () => __awaiter(this, void 0, void 0, function* () {
+            const result = yield (0, __1.executeWorkflow)(WORKFLOW_NAME, workflow, {
+                rawInput: inputData,
+                runtime: {}
+            }, __1.workflowCallbacks);
+            return { trkorr: result.output.trkorr };
+        }));
     });
 }

package/dist/actions/cg3z/upload.d.ts

@@ -1,3 +1,23 @@
 import { Step } from "@simonegaffurini/sammarksworkflow";
 import { Cg3zWorkflowContext } from ".";
+import * as AdmZip from "adm-zip";
+export declare function parseTransportArchive(binaries: Buffer): {
+    header: AdmZip.IZipEntry;
+    data: AdmZip.IZipEntry;
+    trkorr: string;
+};
+/**
+ * Workflow step that validates, uploads, and forwards a transport archive, refreshing the TMS text of an overwritten transport.
+ *
+ * 1- identifying transport
+ *
+ * 2- check existing transport (overwrite confirmation)
+ *
+ * 3- upload
+ *
+ * 4- forward
+ *
+ * 5- refresh text, if overwritten
+ *
+*/
 export declare const upload: Step<Cg3zWorkflowContext>;

package/dist/actions/cg3z/upload.js

@@ -43,57 +43,186 @@ var __awaiter = (this && this.__awaiter) || function (thisArg, _arguments, P, ge
 };
 Object.defineProperty(exports, "__esModule", { value: true });
 exports.upload = void 0;
+exports.parseTransportArchive = parseTransportArchive;
 const transport_1 = require("../../transport");
 const trm_commons_1 = require("trm-commons");
 const AdmZip = __importStar(require("adm-zip"));
 const systemConnector_1 = require("../../systemConnector");
+const stopWarning_1 = require("../stopWarning");
+const TRANSPORT_FILE_PATTERN = /^([KR])([A-Z0-9]{6,})\.([A-Z0-9]{3})$/;
+/**
+ * Parses a transport file name (`K900001.TST` / `R900001.TST`), ignoring any folder prefix and case.
+ *
+ * @returns The file kind and transport number, or `undefined` when the name is not a transport file.
+ */
+function parseTransportFileName(entryName) {
+    const baseName = entryName.split(/[\\/]/).pop().trim().toUpperCase();
+    const match = TRANSPORT_FILE_PATTERN.exec(baseName);
+    if (!match) {
+        return undefined;
+    }
+    return {
+        kind: match[1],
+        trkorr: `${match[3]}K${match[2]}`
+    };
+}
+function parseTransportArchive(binaries) {
+    const zip = new AdmZip.default(binaries);
+    const headers = [];
+    const data = [];
+    zip.forEach(entry => {
+        if (entry.isDirectory)
+            return;
+        const file = parseTransportFileName(entry.entryName);
+        if (!file)
+            return;
+        (file.kind === 'K' ? headers : data).push({ entry, trkorr: file.trkorr });
+    });
+    if (headers.length !== 1 || data.length !== 1) {
+        throw new Error(`Transport archive must contain exactly one header (K<number>.<SID>) and one data (R<number>.<SID>) file, found ${headers.length} header(s) and ${data.length} data file(s).`);
+    }
+    const trkorr = data[0].trkorr;
+    if (headers[0].trkorr !== trkorr) {
+        throw new Error(`Transport header (${headers[0].trkorr}) and data (${trkorr}) don't match!`);
+    }
+    return { header: headers[0].entry, data: data[0].entry, trkorr };
+}
+/**
+ * Workflow step that validates, uploads, and forwards a transport archive, refreshing the TMS text of an overwritten transport.
+ *
+ * 1- identifying transport
+ *
+ * 2- check existing transport (overwrite confirmation)
+ *
+ * 3- upload
+ *
+ * 4- forward
+ *
+ * 5- refresh text, if overwritten
+ *
+*/
 exports.upload = {
     name: 'upload',
     run: (context) => __awaiter(void 0, void 0, void 0, function* () {
-        trm_commons_1.Logger.log('Upload step', true);
+        var _a, _b;
+        //1- identifying transport
         trm_commons_1.Logger.loading(`Reading data...`);
-        const zip = new AdmZip.default(context.rawInput.binaries);
-        var aHeader = [];
-        var aData = [];
-        zip.forEach(e => {
-            if (e.entryName.startsWith('K')) {
-                aHeader.push(e);
+        const archive = parseTransportArchive(context.rawInput.binaries);
+        context.output = {
+            trkorr: archive.trkorr
+        };
+        //2- check existing transport
+        const trkorr = context.output.trkorr;
+        const dest = systemConnector_1.SystemConnector.getDest();
+        const existingE070 = !!(yield new transport_1.Transport(trkorr).getE070());
+        const existingFiles = yield transport_1.Transport.readBinaryFiles(trkorr);
+        const existing = [
+            existingE070 ? 'request (E070)' : undefined,
+            existingFiles.header ? 'header file' : undefined,
+            existingFiles.data ? 'data file' : undefined
+        ].filter(Boolean);
+        if (existing.length > 0) {
+            const existingText = `Transport ${transport_1.Transport.getTransportIcon()}  ${trkorr} already exists in ${dest} (${existing.join(', ')})`;
+            let overwrite = (_a = context.rawInput.uploadData) === null || _a === void 0 ? void 0 : _a.overwrite;
+            if (typeof overwrite !== 'boolean') {
+                if ((_b = context.rawInput.contextData) === null || _b === void 0 ? void 0 : _b.noInquirer) {
+                    throw new Error(`${existingText}. Set overwrite to replace it.`);
+                }
+                overwrite = (yield trm_commons_1.Inquirer.prompt({
+                    type: 'confirm',
+                    name: 'overwrite',
+                    default: false,
+                    message: `${existingText}. Overwrite?`
+                })).overwrite;
             }
-            if (e.entryName.startsWith('R')) {
-                aData.push(e);
+            if (!overwrite) {
+                throw new Error(`${existingText}. Upload aborted.`);
             }
-        });
-        if (aHeader.length === 0) {
-            throw new Error(`Couldn't find transport header file.`);
+            trm_commons_1.Logger.warning(`${existingText}, overwriting.`);
+            context.runtime.overwritten = {
+                e070: existingE070,
+                header: existingFiles.header,
+                data: existingFiles.data
+            };
         }
-        if (aData.length === 0) {
-            throw new Error(`Couldn't find transport data file.`);
+        //an import queue entry that existed before this run is never removed
+        const queued = (yield systemConnector_1.SystemConnector.readTmsQueue(dest)).some(o => o.trkorr === trkorr);
+        //3- upload
+        (0, stopWarning_1.stopWarning)('cg3z');
+        trm_commons_1.Logger.loading(`Uploading transport ${transport_1.Transport.getTransportIcon()}  ${trkorr}...`);
+        //progress is tracked before each call: a failed write or forward may still have changed SAP
+        const progress = { queued };
+        context.runtime.progress = progress;
+        for (const kind of ['header', 'data']) {
+            progress[kind] = true;
+            yield transport_1.Transport.writeBinaryFile(trkorr, kind, (kind === 'header' ? archive.header : archive.data).getData());
         }
-        if (aHeader.length > 1 || aData.length > 1) {
-            throw new Error(`Found multiple transports in same zip file!`);
+        //4- forward
+        trm_commons_1.Logger.loading(`Forwarding transport ${transport_1.Transport.getTransportIcon()}  ${trkorr}...`);
+        progress.forwarded = true;
+        yield systemConnector_1.SystemConnector.forwardTransport(trkorr, dest, dest, true);
+        //5- refresh text (only an overwritten transport can have a stale TMS text)
+        if (context.runtime.overwritten) {
+            try {
+                trm_commons_1.Logger.loading(`Refreshing transport ${transport_1.Transport.getTransportIcon()}  ${trkorr}...`);
+                yield systemConnector_1.SystemConnector.refreshTransportTmsTxt(trkorr);
+            }
+            catch (e) {
+                trm_commons_1.Logger.warning(`Couldn't refresh transport ${trkorr} text: ${(e === null || e === void 0 ? void 0 : e.message) || e}`, { important: true });
+            }
         }
-        context.output = {
-            trkorr: transport_1.Transport.getTrkorrFromFileName(aData[0].entryName)
-        };
-        if (transport_1.Transport.getTrkorrFromFileName(aHeader[0].entryName) !== context.output.trkorr) {
-            throw new Error(`Transport header and data don't match!`);
+    }),
+    revert: (context) => __awaiter(void 0, void 0, void 0, function* () {
+        var _a, _b;
+        const trkorr = (_a = context.output) === null || _a === void 0 ? void 0 : _a.trkorr;
+        const progress = (_b = context.runtime) === null || _b === void 0 ? void 0 : _b.progress;
+        if (!trkorr || !progress) {
+            return;
         }
-        trm_commons_1.Logger.loading(`Uploading transport ${transport_1.Transport.getTransportIcon()}  ${context.output.trkorr}...`);
-        yield transport_1.Transport.upload(context.output.trkorr, {
-            binary: {
-                header: aHeader[0].getData(),
-                data: aData[0].getData()
-            },
-            trTarget: systemConnector_1.SystemConnector.getDest()
-        });
-        trm_commons_1.Logger.loading(`Forwarding transport ${transport_1.Transport.getTransportIcon()}  ${context.output.trkorr}...`);
-        yield systemConnector_1.SystemConnector.forwardTransport(context.output.trkorr, systemConnector_1.SystemConnector.getDest(), systemConnector_1.SystemConnector.getDest(), true);
-        try {
-            trm_commons_1.Logger.loading(`Refreshing transport ${transport_1.Transport.getTransportIcon()}  ${context.output.trkorr}...`);
-            yield systemConnector_1.SystemConnector.refreshTransportTmsTxt(context.output.trkorr);
+        const overwritten = context.runtime.overwritten;
+        let firstError;
+        //the request (E070) is never deleted: the upload doesn't create it, and an existing one isn't ours
+        //remove the import queue entry added by this run (the forward targets the connected system)
+        if (progress.forwarded && !progress.queued) {
+            try {
+                trm_commons_1.Logger.loading(`Removing ${trkorr} from ${systemConnector_1.SystemConnector.getDest()} import queue...`, true);
+                yield systemConnector_1.SystemConnector.deleteTmsTransport(trkorr, systemConnector_1.SystemConnector.getDest());
+            }
+            catch (e) {
+                firstError !== null && firstError !== void 0 ? firstError : (firstError = e);
+            }
+        }
+        //files created by this run: no file deletion API, emptied files are treated as missing
+        const created = ['header', 'data'].filter(kind => progress[kind] && !(overwritten === null || overwritten === void 0 ? void 0 : overwritten[kind]));
+        for (const kind of created) {
+            try {
+                trm_commons_1.Logger.loading(`Emptying uploaded ${trkorr} ${kind} file...`, true);
+                yield transport_1.Transport.writeBinaryFile(trkorr, kind, Buffer.alloc(0));
+            }
+            catch (e) {
+                firstError !== null && firstError !== void 0 ? firstError : (firstError = e);
+            }
+        }
+        if (created.length > 0) {
+            trm_commons_1.Logger.warning(`Uploaded ${trkorr} files (${created.join(', ')}) were emptied in ${systemConnector_1.SystemConnector.getDest()}: delete them from the transport directory if needed.`, { important: true });
+        }
+        //restore overwritten files only after the destructive cleanup succeeded
+        if (!firstError && overwritten) {
+            for (const kind of ['header', 'data']) {
+                if (!progress[kind] || !overwritten[kind]) {
+                    continue;
+                }
+                try {
+                    trm_commons_1.Logger.loading(`Restoring previous ${trkorr} ${kind} file...`, true);
+                    yield transport_1.Transport.writeBinaryFile(trkorr, kind, overwritten[kind]);
+                }
+                catch (e) {
+                    firstError !== null && firstError !== void 0 ? firstError : (firstError = e);
+                }
+            }
         }
-        catch (_a) {
-            trm_commons_1.Logger.warning(`Coudln't refresh transport text!`);
+        if (firstError) {
+            throw firstError;
         }
     })
 };

package/dist/actions/checkEngines/analyze.d.ts

@@ -0,0 +1,11 @@
+import { Step } from "@simonegaffurini/sammarksworkflow";
+import { CheckEnginesWorkflowContext } from ".";
+/**
+ * Workflow step that evaluates the engines declaration against the connected system.
+ *
+ * 1- evaluate engines
+ *
+ * 2- print table
+ *
+*/
+export declare const analyze: Step<CheckEnginesWorkflowContext>;