trm-core 10.0.0 → 10.1.0

package/changelog.txt

@@ -8,10 +8,34 @@ Legend
 + : added
 - : removed
 
-2026-08-05 v10.0.0
+2026-10-12 v10.1.0
 -------------------
-+ usage of registry /transport route (when available)
-+ important log messages (kept visible at the end of an action)
+* trm-server/trm-rest upgrade from a backend before trm-server 7.0.0/trm-rest 6.0.0
+* trm-server/trm-rest upgrade cleanup after the install, deleting only objects not in the new release
+* trm-server/trm-rest kept in $ packages unless installed in /ATRM/ packages
+* deletion transport only includes objects that exist on the system
+* release transports missing from registry metadata read from the verified artifact
+! SAP entries check with percentage progress and batched reads
+! existing objects check batched
+
+2026-10-11 v10.0.1
+-------------------
+* rest client https agent import
+
+2026-10-11 v10.0.0
+-------------------
++ usage of registry /transport route
++ important log messages
+! uninstall
+* flows changes
+
+2026-09-23 v9.10.6
+-------------------
+! trm-commons ^5.1.0
+
+2026-07-29 v9.10.5
+-------------------
++ allow self signed certificates in rest client
 
 2026-07-29 v9.10.4
 -------------------

package/dist/actions/checkEngines/analyze.js

@@ -208,26 +208,31 @@ function evaluate(context, engines, path, required) {
             switch (key) {
                 case 'trm':
                     for (const name of Object.keys(engines.trm)) {
+                        trm_commons_1.Logger.loading(`Checking engine requirement ${prefix}trm.${name}...`);
                         ok = push(`${prefix}trm.${name}`, yield checkTrm(context, name, engines.trm[name])) && ok;
                     }
                     break;
                 case 'components':
                     for (const name of Object.keys(engines.components)) {
+                        trm_commons_1.Logger.loading(`Checking engine requirement ${prefix}components.${name}...`);
                         ok = push(`${prefix}components.${name}`, yield checkComponent(context, name, engines.components[name])) && ok;
                     }
                     break;
                 case 'products':
                     for (const name of Object.keys(engines.products)) {
+                        trm_commons_1.Logger.loading(`Checking engine requirement ${prefix}products.${name}...`);
                         ok = push(`${prefix}products.${name}`, yield checkProduct(context, name, engines.products[name])) && ok;
                     }
                     break;
                 case 'notes':
                     for (const note of Object.keys(engines.notes)) {
+                        trm_commons_1.Logger.loading(`Checking engine requirement ${prefix}notes.${note}...`);
                         ok = push(`${prefix}notes.${note}`, yield checkNote(note, engines.notes[note])) && ok;
                     }
                     break;
                 case 'tables':
                     for (var i = 0; i < engines.tables.length; i++) {
+                        trm_commons_1.Logger.loading(`Checking engine requirement ${prefix}tables[${i}]...`);
                         ok = push(`${prefix}tables[${i}]`, yield checkTable(engines.tables[i])) && ok;
                     }
                     break;
@@ -235,6 +240,7 @@ function evaluate(context, engines, path, required) {
                     var alternatives = [];
                     var anyOk = false;
                     for (var j = 0; j < engines.anyOf.length; j++) {
+                        trm_commons_1.Logger.loading(`Checking engine alternative ${prefix}anyOf[${j}]...`);
                         const alternative = yield evaluate(context, engines.anyOf[j], `${prefix}anyOf[${j}]`, false);
                         alternatives = alternatives.concat(alternative.results);
                         anyOk = anyOk || alternative.ok;

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

@@ -1,5 +1,7 @@
 import { Step } from "@simonegaffurini/sammarksworkflow";
 import { CheckSapEntriesWorkflowContext } from ".";
+/** Entries read with one query. */
+export declare const SAP_ENTRIES_BATCH_SIZE = 25;
 /**
  * Workflow step that queries required SAP tables and builds a per-entry status report.
  *

package/dist/actions/checkSapEntries/analyze.js

@@ -9,9 +9,93 @@ var __awaiter = (this && this.__awaiter) || function (thisArg, _arguments, P, ge
     });
 };
 Object.defineProperty(exports, "__esModule", { value: true });
-exports.analyze = void 0;
+exports.analyze = exports.SAP_ENTRIES_BATCH_SIZE = void 0;
 const trm_commons_1 = require("trm-commons");
 const systemConnector_1 = require("../../systemConnector");
+const manifest_1 = require("../../manifest");
+const commons_1 = require("../../commons");
+/** Entries read with one query. */
+exports.SAP_ENTRIES_BATCH_SIZE = 25;
+// RFC_READ_TABLE option lines hold 72 characters: a batched condition also carries "OR ( " and " )"
+const BATCHED_CONDITION_MAX_LENGTH = 65;
+function entryError(table, tableEntry, e) {
+    const reason = e instanceof Error ? e.message : String(e);
+    return new Error(`Unable to check required SAP entry ${JSON.stringify(tableEntry)} in table "${table}": ${reason}`);
+}
+function checkEntry(table, tableEntry) {
+    return __awaiter(this, void 0, void 0, function* () {
+        try {
+            return yield systemConnector_1.SystemConnector.checkSapEntryExists(table, tableEntry);
+        }
+        catch (e) {
+            throw entryError(table, tableEntry, e);
+        }
+    });
+}
+/**
+ * Whether each entry of a table exists. Entries with the same fields are read together, in batches of
+ * {@link SAP_ENTRIES_BATCH_SIZE}; an entry a batch doesn't return is checked on its own, as are the entries
+ * of a batch that can't be read (e.g. rows too wide).
+ */
+function checkTableEntries(table, entries, onChecked) {
+    return __awaiter(this, void 0, void 0, function* () {
+        const status = new Array(entries.length);
+        const batches = new Map();
+        const singles = [];
+        entries.forEach((tableEntry, index) => {
+            let conditions;
+            try {
+                conditions = (0, manifest_1.getSapEntryConditions)(tableEntry);
+            }
+            catch (e) {
+                throw entryError(table, tableEntry, e);
+            }
+            if (conditions.some(condition => condition.length > BATCHED_CONDITION_MAX_LENGTH)) {
+                singles.push(index);
+                return;
+            }
+            const values = new Map(Object.keys(tableEntry).map(field => [field.trim().toUpperCase(), tableEntry[field].toString()]));
+            const fieldsKey = Array.from(values.keys()).sort().join(',');
+            if (!batches.has(fieldsKey)) {
+                batches.set(fieldsKey, []);
+            }
+            batches.get(fieldsKey).push({ index, values, conditions });
+        });
+        for (const [fieldsKey, group] of batches) {
+            const fields = fieldsKey.split(',');
+            // readTable returns camel-cased field names
+            const rowKeys = fields.map(field => Object.keys((0, commons_1.normalize)({ [field]: '' }))[0]);
+            for (let i = 0; i < group.length; i += exports.SAP_ENTRIES_BATCH_SIZE) {
+                const batch = group.slice(i, i + exports.SAP_ENTRIES_BATCH_SIZE);
+                let rows;
+                try {
+                    rows = yield systemConnector_1.SystemConnector.readTable(table.trim().toUpperCase(), fields.map(fieldName => ({ fieldName })), batch.map(o => `( ${o.conditions.join(' AND ')} )`).join(' OR '));
+                }
+                catch (e) {
+                    trm_commons_1.Logger.log(`Batch read of ${batch.length} entries in ${table} failed, checking them one by one: ${e}`, true);
+                    singles.push(...batch.map(o => o.index));
+                    continue;
+                }
+                for (const o of batch) {
+                    const found = rows.some(row => fields.every((field, f) => { var _a; return `${(_a = row[rowKeys[f]]) !== null && _a !== void 0 ? _a : ''}`.trim() === o.values.get(field).trim(); }));
+                    if (found) {
+                        status[o.index] = true;
+                    }
+                    else {
+                        // values the database matches but that read differently (e.g. numbers) are confirmed on their own
+                        singles.push(o.index);
+                    }
+                }
+                onChecked(batch.length - batch.filter(o => !status[o.index]).length);
+            }
+        }
+        for (const index of singles) {
+            status[index] = yield checkEntry(table, entries[index]);
+            onChecked(1);
+        }
+        return status;
+    });
+}
 /**
  * Workflow step that queries required SAP tables and builds a per-entry status report.
  *
@@ -60,7 +144,11 @@ exports.analyze = {
             return;
         }
         //2- check entries
+        let checked = 0;
+        const progress = (table) => trm_commons_1.Logger.loading(`Checking ${entriesCount} SAP entries: ${Math.floor(checked * 100 / entriesCount)}% (${table.trim()})...`);
         for (const table of Object.keys(context.output.sapEntries)) {
+            const requiredEntries = context.output.sapEntries[table];
+            progress(table);
             var tableExists = false;
             try {
                 for (const object of ['TABL', 'VIEW']) {
@@ -80,30 +168,26 @@ exports.analyze = {
             }
             if (!tableExists) {
                 context.runtime.missingTables.push(table);
-                context.output.sapEntries[table].forEach(tableEntry => {
+                requiredEntries.forEach(tableEntry => {
                     context.runtime.entriesStatus.bad.push({
                         table,
                         tableEntry
                     });
                 });
-                trm_commons_1.Logger.error(`Required ${context.output.sapEntries[table].length} entries in ${table}, but table or view was not found`, { debug: !context.rawInput.printOptions.information, important: true });
+                checked += requiredEntries.length;
+                trm_commons_1.Logger.error(`Required ${requiredEntries.length} entries in ${table}, but table or view was not found`, { debug: !context.rawInput.printOptions.information, important: true });
             }
             else {
                 var printTableHead = ['Table name'];
                 var printTableData = [];
-                var tableData;
                 printTableHead = printTableHead.concat(tableFields.find(o => o.tableName === table).fields);
                 printTableHead.push('Status');
-                for (const tableEntry of context.output.sapEntries[table]) {
-                    tableData = [table];
-                    var exists;
-                    try {
-                        exists = yield systemConnector_1.SystemConnector.checkSapEntryExists(table, tableEntry);
-                    }
-                    catch (e) {
-                        const reason = e instanceof Error ? e.message : String(e);
-                        throw new Error(`Unable to check required SAP entry ${JSON.stringify(tableEntry)} in table "${table}": ${reason}`);
-                    }
+                const statuses = yield checkTableEntries(table, requiredEntries, count => {
+                    checked += count;
+                    progress(table);
+                });
+                requiredEntries.forEach((tableEntry, index) => {
+                    const exists = statuses[index];
                     if (exists) {
                         context.runtime.entriesStatus.good.push({
                             table,
@@ -117,10 +201,8 @@ exports.analyze = {
                         });
                     }
                     const entryStatus = exists ? `OK` : `NOT FOUND`;
-                    tableData = tableData.concat(printTableHead.slice(1, -1).map(field => { var _a; return (_a = tableEntry[field]) !== null && _a !== void 0 ? _a : ''; }));
-                    tableData.push(entryStatus);
-                    printTableData.push(tableData);
-                }
+                    printTableData.push([table, ...printTableHead.slice(1, -1).map(field => { var _a; return (_a = tableEntry[field]) !== null && _a !== void 0 ? _a : ''; }), entryStatus]);
+                });
                 logTable.push({
                     header: printTableHead,
                     data: printTableData

package/dist/actions/commons/setSystemPackages.js

@@ -27,7 +27,7 @@ exports.setSystemPackages = {
             context.rawInput.contextData = {};
         }
         if (context.rawInput.contextData.systemPackages === undefined) {
-            trm_commons_1.Logger.loading(`Reading system data...`);
+            trm_commons_1.Logger.loading(`Reading system packages...`);
             context.rawInput.contextData.systemPackages = yield systemConnector_1.SystemConnector.getInstalledPackages(true, true);
         }
     })

package/dist/actions/commons/utils/actionLocks.d.ts

@@ -15,9 +15,10 @@ export declare function objectLockResource(object: {
 /** One non-expiring SAP lock owner; close only after workflow rollback has finished. */
 export declare class ActionLockScope {
     private readonly actionName;
+    private readonly enabled;
     private readonly ownerToken;
     private readonly held;
-    constructor(actionName: string);
+    constructor(actionName: string, enabled?: boolean);
     acquire(resources: LockResource[]): Promise<void>;
     release(): Promise<void>;
 }

package/dist/actions/commons/utils/actionLocks.js

@@ -42,13 +42,17 @@ function objectLockResource(object) {
 }
 /** One non-expiring SAP lock owner; close only after workflow rollback has finished. */
 class ActionLockScope {
-    constructor(actionName) {
+    constructor(actionName, enabled = true) {
         this.actionName = actionName;
+        this.enabled = enabled;
         this.ownerToken = (0, crypto_1.randomUUID)().replace(/-/g, "").toUpperCase();
         this.held = new Map();
     }
     acquire(resources) {
         return __awaiter(this, void 0, void 0, function* () {
+            if (!this.enabled) {
+                return;
+            }
             const requested = resources.map(actionLockKey);
             const fresh = requested.filter(key => !this.held.has(`${key.resourceType}:${key.resourceHash}`));
             if (fresh.length === 0) {
@@ -82,6 +86,9 @@ class ActionLockScope {
     }
     release() {
         return __awaiter(this, void 0, void 0, function* () {
+            if (!this.enabled) {
+                return;
+            }
             if (this.held.size === 0) {
                 return;
             }

package/dist/actions/commons/utils/index.d.ts

@@ -8,3 +8,4 @@ export * from "./installedDependency";
 export * from "./installRegistry";
 export * from "./dirtyEntries";
 export * from "./owningInstallation";
+export * from "./trmBackend";

package/dist/actions/commons/utils/index.js

@@ -24,3 +24,4 @@ __exportStar(require("./installedDependency"), exports);
 __exportStar(require("./installRegistry"), exports);
 __exportStar(require("./dirtyEntries"), exports);
 __exportStar(require("./owningInstallation"), exports);
+__exportStar(require("./trmBackend"), exports);

package/dist/actions/commons/utils/packageCleanup.d.ts

@@ -41,6 +41,8 @@ export interface PackageCleanupRevert {
 /** Minimum workflow context needed to remove an installed release from the target system. */
 export interface PackageCleanupContext {
     lockScope?: ActionLockScope;
+    /** Only the APIs of a backend older than this trm-core can be used: no test imports. */
+    legacyBackend?: boolean;
     rawInput: {
         packageData: {
             name: string;
@@ -74,6 +76,12 @@ export type PackageCleanupTarget = {
     incomingObjects: TADIR[];
     /** SAP packages that hold the incoming release. Empty when uninstalling. */
     keptDevclasses: string[];
+    /**
+     * When `true`, the incoming release is already imported: only the installed objects it doesn't
+     * ship are deleted. Otherwise every installed object is deleted before the import, except the
+     * tables the incoming release ships again.
+     */
+    incomingImported?: boolean;
     /** Logger/Inquirer prefix shown while the cleanup runs. */
     prefix: string;
     /** Action name used in abort messages, e.g. `Update`. */

package/dist/actions/commons/utils/packageCleanup.js

@@ -402,7 +402,8 @@ function getCustomizingSources(context, target) {
         if (sources.length === 0) {
             return [];
         }
-        if (target.keepCustomizing) {
+        // After the import, deleting by key would also delete the rows the incoming release has just written.
+        if (target.keepCustomizing || target.incomingImported) {
             trm_commons_1.Logger.warning(`Keeping customizing of ${sources.length} transports (${sources.join(', ')}).`, { important: true });
             return [];
         }
@@ -513,7 +514,10 @@ function createStagingPackage(context, namespace) {
             ctext: 'TRM upgrade cleanup',
             as4user: systemConnector_1.SystemConnector.getLogonUser(),
             dlvunit: 'HOME',
-            pdevclass: yield systemConnector_1.SystemConnector.getDefaultTransportLayer()
+            pdevclass: yield systemConnector_1.SystemConnector.getDefaultTransportLayer(),
+            // The package immediately receives transported objects. Some systems do not infer
+            // change recording from the transport layer when CREATE_PACKAGE is called directly.
+            korrflag: 'X'
         });
         yield systemConnector_1.SystemConnector.tadirInterface({
             pgmid: 'R3TR', object: 'DEVC', objName: stagingDevclass,
@@ -544,18 +548,46 @@ function cleanupInstalledPackage(context, target) {
                 target: systemConnector_1.SystemConnector.getDest()
             });
             context.revert.updateCleanupTransport = dummy;
-            const { previousNamespaces, previousTransportObjects } = yield readInstalledTransportObjects(installed);
+            const installedTransport = yield readInstalledTransportObjects(installed);
+            const previousNamespaces = installedTransport.previousNamespaces;
+            const previousTransportObjects = installedTransport.previousTransportObjects;
             const incomingObjects = target.incomingObjects;
+            const currentDevclasses = new Set(target.keptDevclasses.map(normalize));
+            const deletedKeys = new Set((context.runtime.deletedObjects || []).map(objectKey));
+            const { previousDevclasses, installedDevclasses, packageParents, otherInstallations, isOtherInstallation } = yield readInstallationTree(installed, context.runtime.previousInstallPackages, previousTransportObjects, context.runtime.deletedObjects || [], ((_a = context.rawInput.contextData) === null || _a === void 0 ? void 0 : _a.systemPackages) || []);
+            // After the import, the previous release is also what its SAP packages still contain beyond the
+            // incoming release: an installation without transport (e.g. trm-server/trm-rest installed with
+            // abapGit) or leftovers of an earlier upgrade.
+            if (target.incomingImported) {
+                const previousKeys = new Set(previousTransportObjects.map(objectKey));
+                let added = 0;
+                for (const devclass of previousDevclasses.values()) {
+                    if (isOtherInstallation(devclass)) {
+                        continue;
+                    }
+                    for (const object of yield systemConnector_1.SystemConnector.getDevclassObjects(devclass, false)) {
+                        if (!isDevclass(object) && !isNamespace(object) && !deletedKeys.has(objectKey(object)) && !previousKeys.has(objectKey(object))) {
+                            previousKeys.add(objectKey(object));
+                            previousTransportObjects.push({ pgmid: object.pgmid, object: object.object, objName: object.objName });
+                            added++;
+                        }
+                    }
+                }
+                trm_commons_1.Logger.log(`${added} objects of the previous release found in its SAP packages only`, true);
+            }
             // Tables shipped again by the new release are adjusted by its import instead of
             // being dropped and re-created, which would lose their data.
             const incomingKeys = new Set(incomingObjects.map(objectKey));
+            // Already imported, the objects of the incoming release are simply kept.
+            const keptIncoming = target.incomingImported ? previousTransportObjects.filter(object => incomingKeys.has(objectKey(object))) : [];
+            const keptIncomingKeys = new Set(keptIncoming.map(objectKey));
+            if (keptIncoming.length > 0) {
+                trm_commons_1.Logger.log(`Keeping ${keptIncoming.length} objects shipped again by the imported release`, true);
+            }
             const retainedTables = previousTransportObjects.filter(object => normalize(object.pgmid) === 'R3TR' && normalize(object.object) === 'TABL'
-                && incomingKeys.has(objectKey(object)));
+                && incomingKeys.has(objectKey(object)) && !keptIncomingKeys.has(objectKey(object)));
             const retainedKeys = new Set(retainedTables.map(objectKey));
             retainedTables.forEach(object => trm_commons_1.Logger.log(`Keeping table ${object.objName} (present in new release)`, true));
-            const currentDevclasses = new Set(target.keptDevclasses.map(normalize));
-            const deletedKeys = new Set((context.runtime.deletedObjects || []).map(objectKey));
-            const { previousDevclasses, installedDevclasses, packageParents, otherInstallations, isOtherInstallation } = yield readInstallationTree(installed, context.runtime.previousInstallPackages, previousTransportObjects, context.runtime.deletedObjects || [], ((_a = context.rawInput.contextData) === null || _a === void 0 ? void 0 : _a.systemPackages) || []);
             const generatedDevclasses = new Set(context.revert.sapPackages.map(normalize));
             otherInstallations.forEach(pkg => trm_commons_1.Logger.log(`Ignoring SAP package ${pkg.getDevclass()}: TRM package ${pkg.packageName} is installed there`, true));
             // Local additions remain cleanup candidates even when reused as incoming targets.
@@ -687,7 +719,7 @@ function cleanupInstalledPackage(context, target) {
             }
             // Installed objects moved to a package outside this installation (customer development)
             // are kept unless confirmed; those now in another TRM package belong to it and are kept.
-            const relocatedObjects = yield readRelocatedObjects(previousTransportObjects.filter(object => !retainedKeys.has(objectKey(object))), { previousDevclasses, isOtherInstallation });
+            const relocatedObjects = yield readRelocatedObjects(previousTransportObjects.filter(object => !retainedKeys.has(objectKey(object)) && !keptIncomingKeys.has(objectKey(object))), { previousDevclasses, isOtherInstallation });
             const movedKeys = new Set();
             const movedObjects = [];
             for (const object of relocatedObjects) {
@@ -743,13 +775,30 @@ function cleanupInstalledPackage(context, target) {
             // SAP packages the incoming release keeps are never deleted: a renamed installation has already
             // generated them (generate-devclass), and the import of the others updates them in place.
             const deletionObjects = new Map([...previousTransportObjects, ...additionalObjects]
-                .filter(object => !retainedKeys.has(objectKey(object)) && !movedKeys.has(objectKey(object)))
+                .filter(object => !retainedKeys.has(objectKey(object)) && !movedKeys.has(objectKey(object)) && !keptIncomingKeys.has(objectKey(object)))
                 .filter(object => !(isDevclass(object) && currentDevclasses.has(normalize(object.objName))))
                 .map(object => [objectKey(object), object]));
+            // Only objects that exist can be transported: the installed transport may list objects this system
+            // never had or already lost (e.g. a system copy).
+            const checkedObjects = Array.from(deletionObjects.values()).filter(object => normalize(object.pgmid) === 'R3TR' && !isNamespace(object));
+            if (checkedObjects.length > 0) {
+                const existing = new Set((yield systemConnector_1.SystemConnector.getExistingObjects(checkedObjects.map(object => ({
+                    pgmid: object.pgmid, object: object.object, objName: object.objName, devclass: ''
+                })))).map(objectKey));
+                checkedObjects.filter(object => !existing.has(objectKey(object))).forEach(object => {
+                    trm_commons_1.Logger.log(`Skipping ${object.pgmid} ${object.object} ${object.objName}: not on ${systemConnector_1.SystemConnector.getDest()}, nothing to delete`, true);
+                    deletionObjects.delete(objectKey(object));
+                });
+            }
             // TRM comment rows of the installed transport are not objects to delete.
             const hasObjectsToDelete = Array.from(deletionObjects.values()).some(object => normalize(object.pgmid) !== '*');
             if (!hasObjectsToDelete && retainedTables.length === 0 && customizingSources.length === 0) {
-                trm_commons_1.Logger.warning(`Nothing to delete for package ${context.rawInput.packageData.name}: deletion transport was not generated. Manual cleanup of previous release install might be necessary.`, { important: true });
+                if (target.incomingImported) {
+                    trm_commons_1.Logger.log(`The imported release ships every object of the previous one: nothing to delete`, true);
+                }
+                else {
+                    trm_commons_1.Logger.warning(`Nothing to delete for package ${context.rawInput.packageData.name}: deletion transport was not generated. Manual cleanup of previous release install might be necessary.`, { important: true });
+                }
                 try {
                     if (yield dummy.canBeDeleted()) {
                         yield dummy.delete();

package/dist/actions/commons/utils/releaseDeletionTransport.js

@@ -50,10 +50,17 @@ function releaseDeletionTransport(deletionTransport_1, registry_2, context_1) {
             trTarget: systemConnector_1.SystemConnector.getDest()
         });
         //3- import transport
-        trm_commons_1.Logger.loading(`Testing import...`);
-        const testRc = yield context.runtime.dele.import(true);
-        if (testRc < 0 || testRc > 8) {
-            throw new Error(`Test import of deletion transport failed: check logs.`);
+        // A legacy backend has no test import; in the same process the RFC metadata of its import
+        // function stays cached even after the upgrade is imported.
+        if (context.legacyBackend) {
+            trm_commons_1.Logger.log(`Skipping test import of ${deletionTransport.trkorr}: legacy TRM backend`, true);
+        }
+        else {
+            trm_commons_1.Logger.loading(`Testing import...`);
+            const testRc = yield context.runtime.dele.import(true);
+            if (testRc < 0 || testRc > 8) {
+                throw new Error(`Test import of deletion transport failed: check logs.`);
+            }
         }
         trm_commons_1.Logger.loading(`Importing ${deletionTransport.trkorr}`, true);
         // Mark before the mutating await: the import may change objects and still fail.

package/dist/actions/commons/utils/trmBackend.d.ts

@@ -0,0 +1,20 @@
+import { AbstractRegistry } from "../../../registry";
+/**
+ * First trm-server and trm-rest releases with the backend APIs this trm-core relies on
+ * (action locks, batch import, install transports, test imports, transport object locks).
+ */
+export declare const TRM_SERVER_API_VERSION = "7.0.0";
+export declare const TRM_REST_API_VERSION = "6.0.0";
+/**
+ * Permanent TADIR transport of the public trm-server and trm-rest: the same request in every release.
+ * The registry doesn't deliver it through its transport download: it's read from the release artifact.
+ */
+export declare const TRM_FIXED_TADIR_TRANSPORTS: Readonly<Record<string, string>>;
+/** Whether a package is the public trm-server or trm-rest: the TRM backend itself. */
+export declare function isTrmBackendPackage(registry: AbstractRegistry, name: string): boolean;
+/**
+ * Whether the connected TRM backend predates {@link TRM_SERVER_API_VERSION} / {@link TRM_REST_API_VERSION}.
+ * Such a backend can only upgrade itself, with the APIs of its own generation: the newer APIs exist
+ * only once the upgrade is imported.
+ */
+export declare function isLegacyTrmBackend(): Promise<boolean>;

package/dist/actions/commons/utils/trmBackend.js

@@ -0,0 +1,64 @@
+"use strict";
+var __awaiter = (this && this.__awaiter) || function (thisArg, _arguments, P, generator) {
+    function adopt(value) { return value instanceof P ? value : new P(function (resolve) { resolve(value); }); }
+    return new (P || (P = Promise))(function (resolve, reject) {
+        function fulfilled(value) { try { step(generator.next(value)); } catch (e) { reject(e); } }
+        function rejected(value) { try { step(generator["throw"](value)); } catch (e) { reject(e); } }
+        function step(result) { result.done ? resolve(result.value) : adopt(result.value).then(fulfilled, rejected); }
+        step((generator = generator.apply(thisArg, _arguments || [])).next());
+    });
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.TRM_FIXED_TADIR_TRANSPORTS = exports.TRM_REST_API_VERSION = exports.TRM_SERVER_API_VERSION = void 0;
+exports.isTrmBackendPackage = isTrmBackendPackage;
+exports.isLegacyTrmBackend = isLegacyTrmBackend;
+const semver_1 = require("semver");
+const trm_commons_1 = require("trm-commons");
+const registry_1 = require("../../../registry");
+const systemConnector_1 = require("../../../systemConnector");
+/**
+ * First trm-server and trm-rest releases with the backend APIs this trm-core relies on
+ * (action locks, batch import, install transports, test imports, transport object locks).
+ */
+exports.TRM_SERVER_API_VERSION = '7.0.0';
+exports.TRM_REST_API_VERSION = '6.0.0';
+/**
+ * Permanent TADIR transport of the public trm-server and trm-rest: the same request in every release.
+ * The registry doesn't deliver it through its transport download: it's read from the release artifact.
+ */
+exports.TRM_FIXED_TADIR_TRANSPORTS = {
+    'trm-server': 'TRMK900000',
+    'trm-rest': 'TRMK900001'
+};
+/** Whether a package is the public trm-server or trm-rest: the TRM backend itself. */
+function isTrmBackendPackage(registry, name) {
+    return registry.getRegistryType() === registry_1.RegistryType.PUBLIC
+        && [systemConnector_1.TRM_SERVER_PACKAGE_NAME, systemConnector_1.TRM_REST_PACKAGE_NAME].includes(name.trim().toLowerCase());
+}
+function installedVersion(read) {
+    return __awaiter(this, void 0, void 0, function* () {
+        var _a;
+        try {
+            return (_a = (yield read()).manifest) === null || _a === void 0 ? void 0 : _a.get().version;
+        }
+        catch (_b) {
+            // not installed
+            return undefined;
+        }
+    });
+}
+/**
+ * Whether the connected TRM backend predates {@link TRM_SERVER_API_VERSION} / {@link TRM_REST_API_VERSION}.
+ * Such a backend can only upgrade itself, with the APIs of its own generation: the newer APIs exist
+ * only once the upgrade is imported.
+ */
+function isLegacyTrmBackend() {
+    return __awaiter(this, void 0, void 0, function* () {
+        const isLegacy = (version, apiVersion) => !!version && (!(0, semver_1.valid)(version) || (0, semver_1.lt)(version, apiVersion));
+        const serverVersion = yield installedVersion(() => systemConnector_1.SystemConnector.getTrmServerPackage());
+        const restVersion = yield installedVersion(() => systemConnector_1.SystemConnector.getTrmRestPackage());
+        const legacy = isLegacy(serverVersion, exports.TRM_SERVER_API_VERSION) || isLegacy(restVersion, exports.TRM_REST_API_VERSION);
+        trm_commons_1.Logger.log(`TRM backend: trm-server ${serverVersion || '-'}, trm-rest ${restVersion || '-'}${legacy ? ' (legacy APIs)' : ''}`, true);
+        return legacy;
+    });
+}

package/dist/actions/install/checkSapEntries.js

@@ -57,7 +57,7 @@ exports.checkSapEntries = {
             context.runtime.missingSapEntries = missingEntries.length;
         }
         else {
-            trm_commons_1.Logger.success(`SAP entries checked.`);
+            trm_commons_1.Logger.success(`Requirements checked.`);
         }
     })
 };