trm-client 6.1.0 → 7.0.0

package/changelog.txt

@@ -8,6 +8,24 @@ Legend
 + : added
 - : removed
 
+2025-11-07 v7.0.0
+-------------------
+! trm-core ^8.1.3
+! command handler
+! commands arguments
++ deprecate command
+! createAlias/deleteAlias -> alias create/alias delete
+! addRegistry/removeRegistry -> registry add/registry rm
+
+2025-11-04 v6.2.0
+-------------------
+! trm-core ^8.1.1
++ dist-tag commands
+
+2025-10-29 v6.1.1
+-------------------
+* fallback to this._data for backward compatibility
+
 2025-10-26 v6.1.0
 -------------------
 + lock command

package/dist/command/AbstractCommand.d.ts

@@ -0,0 +1,42 @@
+import { Command } from "commander";
+import { RegisterCommandOpts } from "./RegisterCommandOpts";
+import { CliVersionStatus } from "../utils";
+import * as Core from "trm-core";
+import { Package } from "trm-registry-types";
+export declare abstract class AbstractCommand {
+    protected readonly name: string;
+    protected readonly aliases?: string[];
+    protected command: Command;
+    protected registerOpts: RegisterCommandOpts;
+    protected args: any;
+    private cliVersionStatus;
+    private registry;
+    private registryAuthData;
+    private registryAuthFailed;
+    private systemPackages;
+    private trmDependenciesCheck;
+    constructor(program: Command, name: string, aliases?: string[]);
+    getCliVersionStatus(): Promise<CliVersionStatus>;
+    getRegistry(): Core.AbstractRegistry;
+    hasRegistryAuthData(): boolean;
+    getRegistryAuthError(): Error;
+    registryWhoAmI(): Promise<void>;
+    viewRegistryPackage(packageName: string, print?: boolean): Promise<Package>;
+    getSystemPackages(): Promise<Core.TrmPackage[]>;
+    getTrmDependenciesCheck(): Promise<Core.CheckTrmDependencies>;
+    protected abstract init(): void;
+    protected abstract handler(): Promise<void>;
+    register(): void;
+    private getLogger;
+    private getInquirer;
+    private parseCommandArgs;
+    protected onArgs(): void;
+    protected onTrmDepMissing(dependency: string): boolean;
+    protected onTrmDepVersionNotSatisfied(trmPackage: Core.TrmPackage): boolean;
+    private checkTrmDependencies;
+    parseTextArg(name: string): string;
+    parseJsonArg(name: string): any;
+    parseArrayArg(name: string): string[];
+    parseNumberArg(name: string): number;
+    private execute;
+}

package/dist/command/AbstractCommand.js

@@ -0,0 +1,418 @@
+"use strict";
+var __createBinding = (this && this.__createBinding) || (Object.create ? (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    var desc = Object.getOwnPropertyDescriptor(m, k);
+    if (!desc || ("get" in desc ? !m.__esModule : desc.writable || desc.configurable)) {
+      desc = { enumerable: true, get: function() { return m[k]; } };
+    }
+    Object.defineProperty(o, k2, desc);
+}) : (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    o[k2] = m[k];
+}));
+var __setModuleDefault = (this && this.__setModuleDefault) || (Object.create ? (function(o, v) {
+    Object.defineProperty(o, "default", { enumerable: true, value: v });
+}) : function(o, v) {
+    o["default"] = v;
+});
+var __importStar = (this && this.__importStar) || (function () {
+    var ownKeys = function(o) {
+        ownKeys = Object.getOwnPropertyNames || function (o) {
+            var ar = [];
+            for (var k in o) if (Object.prototype.hasOwnProperty.call(o, k)) ar[ar.length] = k;
+            return ar;
+        };
+        return ownKeys(o);
+    };
+    return function (mod) {
+        if (mod && mod.__esModule) return mod;
+        var result = {};
+        if (mod != null) for (var k = ownKeys(mod), i = 0; i < k.length; i++) if (k[i] !== "default") __createBinding(result, mod, k[i]);
+        __setModuleDefault(result, mod);
+        return result;
+    };
+})();
+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());
+    });
+};
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.AbstractCommand = void 0;
+const utils_1 = require("../utils");
+const LoggerType_1 = require("./LoggerType");
+const InquirerType_1 = require("./InquirerType");
+const Core = __importStar(require("trm-core"));
+const Commons = __importStar(require("trm-commons"));
+const registryAlias_1 = require("../registryAlias");
+const systemAlias_1 = require("../systemAlias");
+const chalk_1 = __importDefault(require("chalk"));
+const prompts_1 = require("./prompts");
+const fs_1 = require("fs");
+class AbstractCommand {
+    constructor(program, name, aliases) {
+        this.name = name;
+        this.aliases = aliases;
+        this.registerOpts = {};
+        this.args = {};
+        this.registryAuthData = false;
+        this.command = program.command(this.name);
+        if (aliases) {
+            this.command.aliases(aliases);
+        }
+        this.init();
+    }
+    getCliVersionStatus() {
+        return __awaiter(this, void 0, void 0, function* () {
+            if (!this.cliVersionStatus) {
+                this.cliVersionStatus = yield (0, utils_1.checkCliUpdate)(true);
+            }
+            return this.cliVersionStatus;
+        });
+    }
+    getRegistry() {
+        return this.registry;
+    }
+    hasRegistryAuthData() {
+        return this.registryAuthData;
+    }
+    getRegistryAuthError() {
+        return this.registryAuthFailed;
+    }
+    registryWhoAmI() {
+        return __awaiter(this, void 0, void 0, function* () {
+            const registry = this.getRegistry();
+            if (registry) {
+                Commons.Logger.loading(`Authenticating...`);
+                const whoAmI = yield registry.whoAmI();
+                Commons.Logger.info(`Username: ${whoAmI.user}`);
+                if (whoAmI.messages) {
+                    whoAmI.messages.forEach(m => Commons.Logger.registryResponse(m));
+                }
+            }
+        });
+    }
+    viewRegistryPackage(packageName_1) {
+        return __awaiter(this, arguments, void 0, function* (packageName, print = true) {
+            Commons.Logger.loading(`Reading registry...`);
+            var oRegistryView;
+            try {
+                oRegistryView = yield this.getRegistry().getPackage(packageName, 'latest');
+            }
+            catch (e) {
+                Commons.Logger.error(e, true);
+                oRegistryView = null;
+            }
+            if (print) {
+                if (!oRegistryView) {
+                    Commons.Logger.warning(`${chalk_1.default.bold('WARNING')}: This package was not found on the registry.`);
+                    Commons.Logger.warning(`${chalk_1.default.bold('WARNING')}: This package may have been deleted!`);
+                }
+                else {
+                    if (oRegistryView.deprecated) {
+                        if (oRegistryView.deprecated_message) {
+                            Commons.Logger.warning(`${chalk_1.default.bold('WARNING deprecate')}: ${oRegistryView.deprecated_message}`);
+                        }
+                        else {
+                            Commons.Logger.warning(`${chalk_1.default.bold('WARNING deprecate')}: v${oRegistryView.manifest.version} is deprecated`);
+                        }
+                    }
+                }
+            }
+            return oRegistryView;
+        });
+    }
+    getSystemPackages() {
+        return __awaiter(this, void 0, void 0, function* () {
+            if (!this.systemPackages) {
+                Commons.Logger.loading(`Reading "${Core.SystemConnector.getDest()}" packages...`);
+                this.systemPackages = yield Core.SystemConnector.getInstalledPackages(true, true, true);
+            }
+            return this.systemPackages;
+        });
+    }
+    getTrmDependenciesCheck() {
+        return __awaiter(this, void 0, void 0, function* () {
+            if (!this.trmDependenciesCheck) {
+                const packages = yield this.getSystemPackages();
+                this.trmDependenciesCheck = yield Core.checkCoreTrmDependencies(packages);
+            }
+            return this.trmDependenciesCheck;
+        });
+    }
+    register() {
+        const defaultLogger = utils_1.GlobalContext.getInstance().getSettings().loggerType;
+        const logOutputFolder = utils_1.GlobalContext.getInstance().getSettings().logOutputFolder;
+        this.command
+            .option(`--logger <logger type>`, `Logger type.`, defaultLogger)
+            .option(`--logger-out-dir <logger out dir>`, `Logger output directory.`, logOutputFolder)
+            .option(`--debug`, `Debug.`, false);
+        if (this.registerOpts.requiresConnection) {
+            this.command
+                .option(`-d, --dest <destination>`, `RFC System ID (Destination).`)
+                .option(`-u, --user <username>`, `Logon username.`)
+                .option(`-p, --password <password>`, `Logon password.`)
+                .option(`-m, --mandt <mandt>`, `Logon client.`)
+                .option(`-l, --lang <language>`, `Logon language.`)
+                .option(`-h, --application-server <address>`, `RFC Application server address.`)
+                .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`);
+            if (!this.registerOpts.noSystemAlias) {
+                this.command
+                    .option(`-a, --alias <alias>`, `System Alias.`);
+            }
+        }
+        if (this.registerOpts.requiresRegistry) {
+            this.command
+                .option(`-R, --registry <registry>`, `Registry.`);
+            if (!this.registerOpts.onlyRegistryAlias) {
+                this.command
+                    .option(`-E, --registry-endpoint <endpoint>`, `Registry endpoint.`)
+                    .option(`-A, --registry-auth <authentication>`, `Registry authentication (JSON or path to JSON file).`);
+            }
+        }
+        if (this.registerOpts.requiresR3trans) {
+            this.command
+                .option(`--r3trans-path <path>`, `R3trans program path. (default: Environment variable R3TRANS_HOME)`);
+        }
+        this.command.action(this.execute.bind(this));
+    }
+    getLogger(type, debug, logOutputFolder) {
+        if (!logOutputFolder || logOutputFolder.trim().toLowerCase() === 'default') {
+            logOutputFolder = (0, utils_1.getLogFolder)();
+        }
+        switch (type) {
+            case LoggerType_1.LoggerType.CLI: return new Commons.CliLogger(debug);
+            case LoggerType_1.LoggerType.CLI_LOG: return new Commons.CliLogFileLogger(logOutputFolder, debug);
+            case LoggerType_1.LoggerType.CONSOLE: return new Commons.ConsoleLogger(debug);
+            case LoggerType_1.LoggerType.VOID: return new Commons.DummyLogger();
+            default: throw new Error(`Unknown logger type "${type}". Possible values are ${Object.keys(LoggerType_1.LoggerType).map(k => LoggerType_1.LoggerType[k]).join(', ')}.`);
+        }
+    }
+    getInquirer(type) {
+        switch (type) {
+            case InquirerType_1.InquirerType.CLI: return new Commons.CliInquirer();
+            default: throw new Error(`Unknown inquirer type "${type}". Possible values are ${Object.keys(InquirerType_1.InquirerType).map(k => InquirerType_1.InquirerType[k]).join(', ')}.`);
+        }
+    }
+    parseCommandArgs(args1, args2) {
+        var args = this.command['_optionValues'] || {};
+        if (!args1) {
+            args1 = {};
+        }
+        if (!args2) {
+            args2 = {};
+        }
+        if (typeof (args1) === 'string') {
+            const oArg1 = this.command["_args"][0];
+            args[oArg1.name()] = args1;
+            if (typeof (args2) === 'string') {
+                const oArg2 = this.command["_args"][1];
+                args[oArg2.name()] = args2;
+            }
+            else {
+                args = Object.assign(Object.assign({}, args), args2);
+            }
+        }
+        else {
+            args = Object.assign(Object.assign({}, args), args1);
+        }
+        args = Object.entries(args).reduce((acc, [key, value]) => {
+            const newKey = key.includes(" ") ? key.replace(/ (\w)/g, (_, char) => char.toUpperCase()) : key;
+            acc[newKey] = value;
+            return acc;
+        }, {});
+        return args;
+    }
+    onArgs() {
+    }
+    onTrmDepMissing(dependency) {
+        return true;
+    }
+    onTrmDepVersionNotSatisfied(trmPackage) {
+        return true;
+    }
+    checkTrmDependencies() {
+        return __awaiter(this, void 0, void 0, function* () {
+            const trmDependenciesCheck = yield this.getTrmDependenciesCheck();
+            const trmDependencies = Core.getCoreTrmDependencies();
+            trmDependenciesCheck.missingDependencies.forEach(missingDependency => {
+                if (this.onTrmDepMissing(missingDependency)) {
+                    throw new Error(`Package "${missingDependency}" is not installed on ${Core.SystemConnector.getDest()}.`);
+                }
+            });
+            trmDependenciesCheck.versionNotSatisfiedDependencies.forEach(dependency => {
+                if (this.onTrmDepVersionNotSatisfied(dependency)) {
+                    const versionRange = trmDependencies[dependency.packageName];
+                    throw new Error(`Package "${dependency.packageName}" version ${dependency.manifest.get().version} is installed on ${Core.SystemConnector.getDest()}, but does not satisfy dependency version ${versionRange}. Update with command ${chalk_1.default.italic('trm update ' + dependency.packageName)}`);
+                }
+            });
+        });
+    }
+    parseTextArg(name) {
+        if (this.args[name]) {
+            try {
+                return (0, fs_1.readFileSync)(this.args[name]).toString();
+            }
+            catch (_a) {
+                return this.args[name];
+            }
+        }
+    }
+    parseJsonArg(name) {
+        if (this.args[name]) {
+            var sValue;
+            try {
+                sValue = (0, fs_1.readFileSync)(this.args[name]).toString();
+            }
+            catch (_a) {
+                sValue = this.args[name];
+            }
+            try {
+                return JSON.parse(sValue);
+            }
+            catch (_b) { }
+        }
+    }
+    parseArrayArg(name) {
+        if (this.args[name]) {
+            try {
+                return this.args[name].split(',').map(s => s.trim());
+            }
+            catch (_a) { }
+        }
+    }
+    parseNumberArg(name) {
+        if (this.args[name]) {
+            try {
+                return Number(this.args[name]);
+            }
+            catch (_a) { }
+        }
+    }
+    execute(args1, args2) {
+        return __awaiter(this, void 0, void 0, function* () {
+            this.args = this.parseCommandArgs(args1, args2);
+            this.onArgs();
+            var exitCode;
+            try {
+                if (this.registerOpts.requiresR3trans && process.platform === 'darwin') {
+                }
+                yield utils_1.GlobalContext.getInstance().load();
+                yield Commons.Plugin.call("client", "loadCore", { core: Core });
+                yield Commons.Plugin.call("client", "loadCommons", { commons: Commons });
+                Commons.Inquirer.inquirer = this.getInquirer(InquirerType_1.InquirerType.CLI);
+                Commons.Logger.logger = this.getLogger(this.args.logger, this.args.debug, this.args.loggerOutDir);
+                if (process.platform !== 'win32' && process.platform !== 'darwin') {
+                    Commons.Logger.warning(`Running on untested OS "${process.platform}"! Some features aren't tested yet.`);
+                }
+                yield this.getCliVersionStatus();
+                if (this.registerOpts.requiresRegistry) {
+                    var registryAlias;
+                    var registry;
+                    if (this.args.registry) {
+                        registryAlias = registryAlias_1.RegistryAlias.get(this.args.registry);
+                    }
+                    else if (this.args.registryEndpoint) {
+                        registryAlias = registryAlias_1.RegistryAlias.getTemporaryInstance(this.args.registryEndpoint, this.parseJsonArg('registryAuth'));
+                    }
+                    else {
+                        registryAlias = yield (0, prompts_1.pickRegistry)();
+                    }
+                    registry = registryAlias.getRegistry();
+                    try {
+                        const registryPing = yield registry.ping();
+                        if (this.registerOpts.registryAuthBlacklist && this.registerOpts.registryAuthBlacklist.includes(registryPing.authentication_type)) {
+                            throw new Error(`This command is not supported by registry "${registry.name}".`);
+                        }
+                        if (registryPing.messages) {
+                            registryPing.messages.forEach(m => Commons.Logger.registryResponse(m));
+                        }
+                    }
+                    catch (e) {
+                        Commons.Logger.error(e, true);
+                        if (!this.registerOpts.ignoreRegistryUnreachable) {
+                            throw new Error(`Registry "${registry.name}" is unreachable.`);
+                        }
+                    }
+                    if (registryAlias.authData) {
+                        try {
+                            yield registry.authenticate(registryAlias.authData);
+                        }
+                        catch (e) {
+                            this.registryAuthFailed = e;
+                            Commons.Logger.error(e, true);
+                            Commons.Logger.warning(`Registry "${registry.name}" login failed.`);
+                        }
+                    }
+                    this.registry = registry;
+                    this.registryAuthData = !!registryAlias.authData;
+                    Core.RegistryProvider.registry.push(registry);
+                }
+                registryAlias_1.RegistryAlias.getAll().forEach(o => {
+                    var append = true;
+                    var aliasRegistry = registryAlias_1.RegistryAlias.get(o.alias).getRegistry();
+                    Core.RegistryProvider.registry.forEach(k => {
+                        if (append) {
+                            append = !k.compare(aliasRegistry);
+                        }
+                    });
+                    if (append) {
+                        Core.RegistryProvider.registry.push(aliasRegistry);
+                    }
+                });
+                if (this.registerOpts.requiresConnection) {
+                    var system;
+                    if (this.args.alias) {
+                        system = systemAlias_1.SystemAlias.get(this.args.alias).getConnection();
+                    }
+                    else {
+                        system = (yield (0, prompts_1.connect)(this.args, true, this.registerOpts.addNoConnection)).getSystemConnector();
+                    }
+                    yield system.connect();
+                    Core.SystemConnector.systemConnector = system;
+                    yield Commons.Plugin.call("client", "onInitializeSystemConnector", Core.SystemConnector.systemConnector);
+                    if (this.registerOpts.requiresTrmDependencies) {
+                        yield this.checkTrmDependencies();
+                    }
+                }
+                yield this.handler();
+                if (Commons.Logger.logger instanceof Commons.CliLogger || Commons.Logger.logger instanceof Commons.CliLogFileLogger) {
+                    Commons.Logger.logger.forceStop();
+                }
+                exitCode = 0;
+            }
+            catch (e) {
+                yield (0, utils_1.logError)(e);
+                exitCode = 1;
+            }
+            finally {
+                if (Core.SystemConnector.systemConnector) {
+                    try {
+                        yield Core.SystemConnector.closeConnection();
+                    }
+                    catch (e) {
+                        Commons.Logger.error(`Couldn't close system connection!`, true);
+                        Commons.Logger.log(e.toString(), true);
+                    }
+                }
+                if (Commons.Logger.logger instanceof Commons.CliLogFileLogger) {
+                    const sessionId = Commons.Logger.logger.getSessionId();
+                    const logFilePath = Commons.Logger.logger.getFilePath();
+                    Commons.Logger.info(`Saved log output "${logFilePath}" for session ID ${sessionId}.`);
+                }
+                process.exit(exitCode);
+            }
+        });
+    }
+}
+exports.AbstractCommand = AbstractCommand;

package/dist/command/InquirerType.d.ts

@@ -0,0 +1,3 @@
+export declare enum InquirerType {
+    CLI = "CLI"
+}

package/dist/command/InquirerType.js

@@ -0,0 +1,7 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.InquirerType = void 0;
+var InquirerType;
+(function (InquirerType) {
+    InquirerType["CLI"] = "CLI";
+})(InquirerType || (exports.InquirerType = InquirerType = {}));

package/dist/{utils/executeCommand.d.ts → command/LoggerType.d.ts}

@@ -5,7 +5,3 @@ export declare enum LoggerType {
     VOID = "VOID",
     KEY = "VALUE"
 }
-export declare enum InquirerType {
-    CLI = "CLI"
-}
-export declare function executeCommand(args: any): Promise<void>;

package/dist/command/LoggerType.js

@@ -0,0 +1,11 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.LoggerType = void 0;
+var LoggerType;
+(function (LoggerType) {
+    LoggerType["CLI"] = "CLI";
+    LoggerType["CLI_LOG"] = "CLI_LOG";
+    LoggerType["CONSOLE"] = "CONSOLE";
+    LoggerType["VOID"] = "VOID";
+    LoggerType["KEY"] = "VALUE";
+})(LoggerType || (exports.LoggerType = LoggerType = {}));

package/dist/{utils/registerCommand.d.ts → command/RegisterCommandOpts.d.ts}

@@ -1,11 +1,12 @@
-import { Command } from "commander";
 import { AuthenticationType } from "trm-registry-types";
-export declare function registerCommand(command: Command, args?: {
+export interface RegisterCommandOpts {
     requiresConnection?: boolean;
     addNoConnection?: boolean;
     requiresTrmDependencies?: boolean;
     requiresRegistry?: boolean;
+    onlyRegistryAlias?: boolean;
     registryAuthBlacklist?: AuthenticationType[];
     noSystemAlias?: boolean;
     ignoreRegistryUnreachable?: boolean;
-}): void;
+    requiresR3trans?: boolean;
+}

package/dist/command/implementations/Alias.d.ts

@@ -0,0 +1,8 @@
+import { AbstractCommand } from "../AbstractCommand";
+export declare class Alias extends AbstractCommand {
+    protected init(): void;
+    private view;
+    private check;
+    private edit;
+    protected handler(): Promise<void>;
+}