trm-client 11.1.2 → 11.3.0

package/changelog.txt

@@ -8,6 +8,23 @@ Legend
 + : added
 - : removed
 
+2026-09-23 v11.3.0
+-------------------
++ system alias connection data saved after connecting when changed (e.g. rotated tokens)
+! alias check saves updated connection data
+! compare reads systems one at a time, closing each connection before opening the next
+
+2026-09-23 v11.2.0
+-------------------
+! trm-core ^9.10.6
+! trm-commons ^5.1.0
++ --connection-type option (env TRM_CONNECTION_TYPE) for non interactive connection
++ --connection-args option (env TRM_CONNECTION_ARGS), JSON or JSON file path passed to connection
++ cli option names mapped to connection argument keys
++ warning for connection arguments not supported by connection type
++ possible values in invalid connection type error
+! forward rfc destination no longer defaults to NONE (NONE only for non interactive connection)
+
 2026-09-02 v11.1.2
 -------------------
 ! trm-core ^9.10.5

package/dist/command/AbstractCommand.d.ts

@@ -46,6 +46,8 @@ export declare abstract class AbstractCommand {
     private checkTrmDependencies;
     parseTextArg(name: string): string;
     parseJsonArg(name: string): any;
+    private getConnectArgs;
+    private parseConnectionArgs;
     parseArrayArg(name: string): string[];
     parseNumberArg(name: string): number;
     run(args?: any, options?: AbstractCommandRunOptions): Promise<void>;

package/dist/command/AbstractCommand.js

@@ -46,6 +46,7 @@ var __importDefault = (this && this.__importDefault) || function (mod) {
 };
 Object.defineProperty(exports, "__esModule", { value: true });
 exports.AbstractCommand = void 0;
+const commander_1 = require("commander");
 const utils_1 = require("../utils");
 const LoggerType_1 = require("./LoggerType");
 const InquirerType_1 = require("./InquirerType");
@@ -206,7 +207,9 @@ class AbstractCommand {
                 .option(`-r, --sap-router <sap router>`, `RFC SAP Router.`)
                 .option(`-n, --sys-nr <sysnr>`, `Instance number.`)
                 .option(`-e, --endpoint <endpoint>`, `REST endpoint.`)
-                .option(`-x, --forward-rfc-dest [destination]`, `REST forward destination.`, `NONE`);
+                .option(`-x, --forward-rfc-dest [destination]`, `REST forward RFC destination.`)
+                .addOption(new commander_1.Option(`--connection-type <type>`, `Connection type (e.g. RFC, REST or a plugin connection type), skips the connection prompt.`).env(`TRM_CONNECTION_TYPE`))
+                .addOption(new commander_1.Option(`--connection-args <arguments>`, `Connection arguments, passed to the connection type (JSON or path to JSON file).`).env(`TRM_CONNECTION_ARGS`));
             if (!this.registerOpts.noSystemAlias) {
                 this.command
                     .option(`-a, --alias <alias>`, `System Alias.`);
@@ -384,6 +387,52 @@ class AbstractCommand {
             catch (_a) { }
         }
     }
+    getConnectArgs() {
+        const connectArgs = Object.assign({}, this.args);
+        const mapping = [
+            ['client', 'mandt'],
+            ['passwd', 'password'],
+            ['ashost', 'applicationServer'],
+            ['sysnr', 'sysNr'],
+            ['saprouter', 'sapRouter']
+        ];
+        mapping.forEach(([key, cliKey]) => {
+            if (connectArgs[key] === undefined && connectArgs[cliKey] !== undefined) {
+                connectArgs[key] = connectArgs[cliKey];
+            }
+        });
+        if (this.args.connectionType) {
+            connectArgs.type = this.args.connectionType;
+            if (typeof connectArgs.forwardRfcDest !== 'string') {
+                connectArgs.forwardRfcDest = 'NONE';
+            }
+        }
+        connectArgs.connectionArgs = this.parseConnectionArgs();
+        return connectArgs;
+    }
+    parseConnectionArgs() {
+        if (!this.args.connectionArgs) {
+            return undefined;
+        }
+        var sValue;
+        try {
+            sValue = (0, fs_1.readFileSync)(this.args.connectionArgs).toString();
+        }
+        catch (_a) {
+            sValue = this.args.connectionArgs;
+        }
+        var value;
+        try {
+            value = JSON.parse(sValue);
+        }
+        catch (_b) {
+            throw new Error(`Invalid connection arguments: expected a JSON object or the path to a JSON file.`);
+        }
+        if (!value || typeof value !== 'object' || Array.isArray(value)) {
+            throw new Error(`Invalid connection arguments: expected a JSON object.`);
+        }
+        return value;
+    }
     parseArrayArg(name) {
         if (this.args[name]) {
             try {
@@ -493,13 +542,25 @@ class AbstractCommand {
                 });
                 if (this.registerOpts.requiresConnection) {
                     var system;
+                    var systemAlias;
                     if (this.args.alias) {
-                        system = systemAlias_1.SystemAlias.get(this.args.alias).getConnection();
+                        systemAlias = systemAlias_1.SystemAlias.get(this.args.alias);
+                        system = systemAlias.getConnection();
                     }
                     else {
-                        system = (yield (0, prompts_1.connect)(this.args, true, this.registerOpts.addNoConnection)).connect.getSystemConnector();
+                        const connectArgs = this.getConnectArgs();
+                        system = (yield (0, prompts_1.connect)(connectArgs, !this.args.connectionType, this.registerOpts.addNoConnection)).connect.getSystemConnector();
                     }
                     yield system.connect(false);
+                    if (systemAlias) {
+                        try {
+                            systemAlias.saveChanges();
+                        }
+                        catch (e) {
+                            Commons.Logger.warning(`Couldn't update system alias "${this.args.alias}" data.`);
+                            Commons.Logger.error(e, true);
+                        }
+                    }
                     Core.SystemConnector.systemConnector = system;
                     yield Commons.Plugin.call("client", "onInitializeSystemConnector", Core.SystemConnector.systemConnector);
                     if (this.registerOpts.requiresTrmDependencies) {

package/dist/command/implementations/Alias.js

@@ -33,9 +33,10 @@ class Alias extends AbstractCommand_1.AbstractCommand {
     check(alias) {
         return __awaiter(this, void 0, void 0, function* () {
             trm_commons_1.Logger.loading(`Checking connection with alias "${alias.alias}"...`);
-            const oSystemAlias = new systemAlias_1.SystemAlias(alias.type, alias.data);
+            const oSystemAlias = new systemAlias_1.SystemAlias(alias.type, alias.data, alias.alias);
             try {
                 yield oSystemAlias.getConnection().connect(false);
+                oSystemAlias.saveChanges();
                 trm_commons_1.Logger.success(`Connection to alias "${alias.alias}" OK.`);
             }
             catch (e) {

package/dist/command/implementations/Compare.js

@@ -24,7 +24,7 @@ class Compare extends AbstractCommand_1.AbstractCommand {
     promptConnections() {
         return __awaiter(this, void 0, void 0, function* () {
             if (this.connections.length > 0) {
-                trm_commons_1.Logger.info(`Compare systems: ${this.connections.map(o => o.getDest()).join(', ')}`);
+                trm_commons_1.Logger.info(`Compare systems: ${this.connections.map(o => o.connector.getDest()).join(', ')}`);
             }
             var askConnection = true;
             const inq1 = yield trm_commons_1.Inquirer.prompt([{
@@ -39,7 +39,8 @@ class Compare extends AbstractCommand_1.AbstractCommand {
                 const connectArgs = yield (0, prompts_1.connect)({}, false, false);
                 const systemConnector = connectArgs.connect.getSystemConnector();
                 yield systemConnector.connect(false);
-                this.connections.push(systemConnector);
+                yield systemConnector.closeConnection();
+                this.connections.push({ connector: systemConnector });
                 return true;
             }
             else {
@@ -56,8 +57,7 @@ class Compare extends AbstractCommand_1.AbstractCommand {
                 for (const sAlias of inputConnections) {
                     if (typeof (sAlias) === 'string') {
                         const oAlias = systemAlias_1.SystemAlias.get(sAlias);
-                        const oConnection = oAlias.getConnection();
-                        this.connections.push(oConnection);
+                        this.connections.push({ connector: oAlias.getConnection(), alias: oAlias });
                     }
                 }
             }
@@ -67,7 +67,7 @@ class Compare extends AbstractCommand_1.AbstractCommand {
                     keepPrompt = yield this.promptConnections();
                 }
             }
-            trm_commons_1.Logger.info(`Compare systems: ${this.connections.map(o => o.getDest()).join(', ')}`);
+            trm_commons_1.Logger.info(`Compare systems: ${this.connections.map(o => o.connector.getDest()).join(', ')}`);
             const tableHead = [`System`, `Installed`, `Version`, `Devclass`, `Import transport`];
             var tableData = [];
             trm_commons_1.Logger.loading(`Reading registry data...`);
@@ -77,14 +77,30 @@ class Compare extends AbstractCommand_1.AbstractCommand {
             }
             catch (e) { }
             trm_commons_1.Logger.loading(`Reading system data...`);
-            for (const oConnection of this.connections) {
+            for (const { connector: oConnection, alias: oAlias } of this.connections) {
+                yield oConnection.connect(false);
+                if (oAlias) {
+                    try {
+                        oAlias.saveChanges();
+                    }
+                    catch (e) {
+                        trm_commons_1.Logger.error(e, true);
+                    }
+                }
                 trm_core_1.SystemConnector.systemConnector = oConnection;
                 const system = trm_core_1.SystemConnector.getDest() || '';
                 var installed;
                 var version;
                 var devclass;
                 var importTransport;
-                const aSystemPackages = yield trm_core_1.SystemConnector.getInstalledPackages(true);
+                var aSystemPackages;
+                try {
+                    aSystemPackages = yield trm_core_1.SystemConnector.getInstalledPackages(true);
+                }
+                finally {
+                    yield oConnection.closeConnection();
+                    trm_core_1.SystemConnector.systemConnector = undefined;
+                }
                 const oSystemView = aSystemPackages.find(o => o.compareName(packageName) && o.compareRegistry(registry));
                 if (oSystemView && oSystemView.manifest) {
                     installed = 'Yes';

package/dist/command/prompts/connect.d.ts

@@ -13,8 +13,9 @@ export type ConnectArguments = {
     noSystemAlias?: boolean;
     force?: boolean;
     endpoint?: string;
-    forwardRfcDest?: string;
+    forwardRfcDest?: string | boolean;
     connection?: ISystemConnector;
+    connectionArgs?: Record<string, any>;
 };
 export declare function connect(commandArgs: ConnectArguments, createAliasIfNotExist?: boolean, addNoConnection?: boolean): Promise<{
     connect: IConnect;

package/dist/command/prompts/connect.js

@@ -14,6 +14,20 @@ const systemAlias_1 = require("../../systemAlias");
 const utils_1 = require("../../utils");
 const trm_commons_1 = require("trm-commons");
 const lodash_1 = require("lodash");
+function applyConnectionArgs(connection, commandArgs) {
+    const connectionArgs = commandArgs.connectionArgs;
+    if (!connectionArgs) {
+        return commandArgs;
+    }
+    const declared = connection.connectionArgs;
+    if (Array.isArray(declared)) {
+        const unknown = Object.keys(connectionArgs).filter(k => !declared.find(o => o.name === k));
+        if (unknown.length > 0) {
+            trm_commons_1.Logger.warning(`Connection "${connection.name}" doesn't support argument(s) ${unknown.join(', ')}. Supported arguments: ${declared.map(o => o.name).join(', ') || 'none'}.`);
+        }
+    }
+    return Object.assign(Object.assign({}, commandArgs), connectionArgs);
+}
 const languageList = [
     { value: 'AR', name: 'AR (Arabic)' },
     { value: 'BG', name: 'BG (Bulgarian)' },
@@ -128,7 +142,7 @@ function connect(commandArgs_1) {
             }
             connection.setData(inq2.data);
             if (connection.onAfterLoginData) {
-                yield connection.onAfterLoginData(force, commandArgs);
+                yield connection.onAfterLoginData(force, applyConnectionArgs(connection, commandArgs));
             }
             if (!(0, lodash_1.isEqual)(inq2.data, connection.getData())) {
                 systemAlias_1.SystemAlias.delete(inq2.alias);
@@ -170,8 +184,9 @@ function connect(commandArgs_1) {
             }
             const connectionType = utils_1.GlobalContext.getInstance().getConnections().find(o => o.name === type);
             if (!connectionType) {
-                throw new Error(`Invalid connection type "${type}"`);
+                throw new Error(`Invalid connection type "${type}". Possible values are ${utils_1.GlobalContext.getInstance().getConnections().map(o => o.name).join(', ')}.`);
             }
+            commandArgs = applyConnectionArgs(connectionType, commandArgs);
             if (connectionType.onConnectionData) {
                 yield connectionType.onConnectionData(force, commandArgs);
             }

package/dist/systemAlias/SystemAlias.d.ts

@@ -4,13 +4,17 @@ import { IConnect } from "trm-commons";
 export declare class SystemAlias {
     type: string;
     private _data;
-    constructor(type: string, _data: any);
+    private _name?;
+    private _connection;
+    constructor(type: string, _data: any, _name?: string);
     getConnection(): ISystemConnector;
+    saveChanges(): void;
     private static generateFile;
     private static getSystemAliasFilePath;
     static getAll(): SystemAliasData[];
     static get(name: string): SystemAlias;
     static create(name: string, type: string, data: any): SystemAlias;
+    static update(name: string, data: any): void;
     static delete(name: string): void;
     private static deepEqual;
     static compare(a: SystemAlias, b: SystemAlias): boolean;

package/dist/systemAlias/SystemAlias.js

@@ -53,9 +53,10 @@ const ini = __importStar(require("ini"));
 const trm_commons_1 = require("trm-commons");
 const SYSTEM_FILE_NAME = "systems.ini";
 class SystemAlias {
-    constructor(type, _data) {
+    constructor(type, _data, _name) {
         this.type = type;
         this._data = _data;
+        this._name = _name;
     }
     getConnection() {
         const connection = utils_1.GlobalContext.getInstance().getConnections().find(o => o.name === this.type);
@@ -63,8 +64,28 @@ class SystemAlias {
             throw new Error(`Unknown connection type "${this.type}". Possible values are ${utils_1.GlobalContext.getInstance().getConnections().map(k => k.name).join(', ')}.`);
         }
         connection.setData(this._data.data || this._data);
+        this._connection = connection;
         return connection.getSystemConnector();
     }
+    saveChanges() {
+        if (!this._name || !this._connection) {
+            return;
+        }
+        const normalize = (data) => {
+            const normalized = {};
+            Object.keys(data || {}).sort().forEach(key => {
+                if (key !== 'type' && data[key] !== undefined && data[key] !== null) {
+                    normalized[key] = `${data[key]}`;
+                }
+            });
+            return normalized;
+        };
+        const newData = this._connection.getData();
+        if (!SystemAlias.deepEqual(normalize(this._data.data || this._data), normalize(newData))) {
+            SystemAlias.update(this._name, newData);
+            this._data = newData;
+        }
+    }
     static generateFile(content, filePath) {
         if (!filePath) {
             filePath = this.getSystemAliasFilePath();
@@ -110,7 +131,7 @@ class SystemAlias {
         const aAlias = this.getAll();
         const alias = aAlias.find(o => o.alias.trim().toUpperCase() === name.trim().toUpperCase());
         if (alias) {
-            return new SystemAlias(alias.type, alias);
+            return new SystemAlias(alias.type, alias, alias.alias);
         }
         else {
             throw new Error(`System alias "${name}" not found.`);
@@ -135,6 +156,15 @@ class SystemAlias {
         }
         return new SystemAlias(type, data);
     }
+    static update(name, data) {
+        const aAlias = this.getAll();
+        const alias = aAlias.find(o => o.alias.trim().toUpperCase() === name.trim().toUpperCase());
+        if (!alias) {
+            throw new Error(`System alias "${name}" not found.`);
+        }
+        alias.data = data;
+        this.generateFile(aAlias);
+    }
     static delete(name) {
         var aAlias = this.getAll();
         aAlias = aAlias.filter(o => o.alias.trim().toUpperCase() !== name.trim().toUpperCase());

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "trm-client",
-  "version": "11.1.2",
+  "version": "11.3.0",
   "description": "TRM (Transport Request Manager) Client",
   "main": "dist/index.js",
   "types": "dist/index.d.ts",
@@ -46,13 +46,13 @@
     "lodash": "^4.17.21",
     "sanitize-filename": "^1.6.3",
     "semver": "^7.7.4",
-    "trm-commons": "^5.0.1",
-    "trm-core": "^9.10.5",
+    "trm-commons": "^5.1.0",
+    "trm-core": "^9.10.6",
     "trm-registry-types": "^2.4.0",
     "xml2js": "^0.6.2"
   },
   "peerDependencies": {
-    "trm-commons": "^5.0.1"
+    "trm-commons": "^5.1.0"
   },
   "devDependencies": {
     "@types/ini": "^1.3.31",