trm-client 7.5.1 → 7.7.0

package/README.md

@@ -12,22 +12,195 @@
 
 [trm-client](https://www.npmjs.com/package/trm-client) is the CLI implementation of the core functionalities of TRM.
 
-**TRM (Transport Request Manager)** is a package manager inspired solution built leveraging CTS that simplifies SAP ABAP transports.
+🚚 **TRM (Transport Request Manager)** is a package manager inspired solution built leveraging CTS that simplifies SAP ABAP transports.
+
+<p align="center">
+  <img src="https://docs.trmregistry.com/logo.png" alt="TRM Logo" />
+</p>
+
+TRM introduces **package-based software delivery** to the SAP ecosystem, bringing with it semantic versioning, dependency management, and automated deployment activities.
+
+---
+
+# What is TRM?
+
+TRM is a software that transforms how custom ABAP developments are published, installed, and maintained across SAP landscapes.
+Inspired by modern package managers, TRM introduces a declarative, version-controlled, and automated way to manage your SAP transports.
+
+With TRM, you can:
+
+- **Define a manifest** for each ABAP package (similar to `package.json` with Node.js or `pom.xml` with Maven)
+- **Version your products** ([SemVer](https://semver.org/) compliance)
+- **Declare dependencies** (to other TRM packages, SAP standard objects, or customizing data)
+- **Automate post-install activities**, such as client dependant customizing, cache invalidation etc.
+- **Validate system requirements** prior to installation
+- **Compare versions** of the same product across multiple SAP systems (in or outside the same landscape)
+- **Distribute** your product release to the public or to a restricted number of users:
+  - Registry (e.g., [trmregistry.com](https://trmregistry.com) or private registry)
+  - Local `.trm` files for offline installations
+
+## Modern approach for ABAP
+
+- Publish ABAP packages from a **central development system**
+- Deliver packages to target systems (outside of the original landscape e.g. customers development system) using a single CLI command (or in a pipeline)
+- Full support for **workbench objects**, **customizing**, and **translations**
+
+## Structured Manifest
+
+Each package includes a `manifest.json` that declares:
+
+- Version and metadata
+- System requirements
+- Dependencies
+- Post-install scripts
 
 # Documentation
 
-You can find the full documentation at [docs.trmregistry.com](https://docs.trmregistry.com).
+Full documentation can be seen at [https://docs.trmregistry.com/](https://docs.trmregistry.com).
+
+---
+
+<!-- START OF SETUP.MD -->
+
+# Dockerized version (Recommended)
+
+If you are using [Docker](https://www.docker.com/), the recommended approach is to use [trm-docker](https://github.com/RegestaItalia/trm-docker).
+
+## Download Docker Run Script
+
+This script is a small utility used to run TRM inside Docker. After installing the required SAP proprietary tools, the script can be moved into a directory included in your `PATH` so that it can be executed from anywhere.
+
+1. Go to the [trm-docker repository](https://github.com/RegestaItalia/trm-docker)
+2. Download the script corresponding to your operating system:
+   - **Windows**: download [win.cmd](https://raw.githubusercontent.com/RegestaItalia/trm-docker/refs/heads/main/win.cmd) and rename it to `trm.cmd`
+   - **macOS / Linux**: download [macos](https://raw.githubusercontent.com/RegestaItalia/trm-docker/refs/heads/main/macos), rename it to `trm`, and make it executable:
+     ```bash
+     chmod +x trm
+     ```
+3. In the same directory where you placed the script, create a folder named `init`.
+
+This `init` folder will later contain the SAP proprietary files required by TRM.
+
+## Download SAPCAR and SAPEXE and Extract Required Files
+
+SAPCAR is used to extract `.SAR` archives downloaded from SAP Software Center.
+
+### Download SAPCAR
+
+1. Log in to the [SAP Software Center](https://me.sap.com/softwarecenter)
+2. Click **SUPPORT PACKAGES & PATCHES**
+3. Expand **By Alphabetical Index (A–Z)** and select **S**
+4. Click **SAPCAR**
+5. Choose the **latest version**
+6. On the download page select your operating system:
+   - **WINDOWS ON X64 64BIT**
+   - **MACOS ON ARM64BIT**
+   - **MACOS X 64-BIT**
+7. Download:
+   - **Windows** → latest `.EXE`
+   - **macOS** → latest `.ZIP`
+8. If using macOS, extract the archive and make the binary executable:
+   ```bash
+   chmod +x SAPCAR
+   ```
+
+### Download SAP Kernel Files
+
+1. Go back to **SUPPORT PACKAGES & PATCHES**
+2. Expand **By Alphabetical Index (A–Z)** and select **K**
+3. Click **SAP KERNEL 64-BIT**
+4. Choose the **latest version**
+5. On the download page select **LINUX ON X86_64 64BIT**
+6. Download the latest **SAPEXE** archive  
+   (file name similar to `SAPEXE_###-########.SAR`)
+
+### Extract the Required Files
+
+1. Place the downloaded `SAPEXE_*.SAR` file in the same directory as `SAPCAR`.
+2. Extract it:
+
+   **Windows**
+   ```bash
+   SAPCAR -xvf SAPEXE_###-########.SAR
+   ```
+
+   **macOS / Linux**
+   ```bash
+   ./SAPCAR -xvf SAPEXE_###-########.SAR
+   ```
+
+3. After extraction, move the following files into the previously created `init` folder:
+
+   ```
+   R3trans
+   libicudata##.so
+   libicui18n##.so
+   libicuuc##.so
+   ```
+
+4. *(Optional)* If you want RFC functionality available in TRM, also move the following files into the `init` folder:
+
+   ```
+   startrfc
+   rfcexec
+   libsapnwrfc.so
+   libsapucum.so
+   ```
+
+## Pull docker image
+
+Execute this command to pull the latest docker image
+
+```bash
+docker pull --platform=linux/amd64 abaptrm/docker
+```
+
+## Initial Installation via Script
+
+Once the `init` folder is populated and the `trm` script is ready, run the script from the directory where it is located.
+
+**Windows**
+```bash
+trm
+```
+
+**macOS / Linux**
+```bash
+./trm
+```
+
+The first execution performs the initial setup of the Docker environment.\
+After the installation completes, you may move the script to a directory included in your system `PATH` so it can be executed from anywhere.
+
+**Windows**
+```
+C:\Windows\System32
+```
+
+**macOS / Linux**
+```
+/usr/local/bin
+```
+
+After this step, you can simply run:
+
+```bash
+trm
+```
+
+from any directory.
+
+---
 
-- [Setup](/docs/setup.md)
-- [Publish and install](https://docs.trmregistry.com/#/examples/1_publish_and_install)
+# Install via Npm
 
-## Install
+With [Node.js and npm](https://nodejs.org/en/download) installed, you can install [trm-client](https://www.npmjs.com/package/trm-client) via npm, as it is distributed as a Node.js package.
 
-First, make sure you have all the [requirements installed](/docs/setup.md).
+## TODO
 
-You can then install the CLI via npm:
+<!-- END OF SETUP.MD -->
 
-`npm install trm-client -g`
+---
 
 # Contributing
 

package/changelog.txt

@@ -8,6 +8,19 @@ Legend
 + : added
 - : removed
 
+2026-03-23 v7.7.0
+-------------------
+* pack command usage
+
+2026-03-11 v7.6.0
+-------------------
+* show subcommands in --help
++ command cg3y
++ command cg3z
+* trm-core ^8.5.3
++ TRM_DOCKERIZED env variable (for docker usage)
++ clear-cache command
+
 2026-03-10 v7.5.1
 -------------------
 * dependency tree package objects counter

package/dist/command/AbstractCommand.d.ts

@@ -31,6 +31,8 @@ export declare abstract class AbstractCommand {
     private getLogger;
     private getInquirer;
     private parseCommandArgs;
+    validateOutputFileArg(argValue: string): void;
+    validateInputFileArg(argValue: string): void;
     protected onArgs(): void;
     protected onTrmDepMissing(dependency: string): boolean;
     protected onTrmDepVersionNotSatisfied(trmPackage: Core.TrmPackage): boolean;

package/dist/command/AbstractCommand.js

@@ -56,6 +56,9 @@ const systemAlias_1 = require("../systemAlias");
 const chalk_1 = __importDefault(require("chalk"));
 const prompts_1 = require("./prompts");
 const fs_1 = require("fs");
+const path_1 = require("path");
+const constants_1 = __importDefault(require("constants"));
+const sanitize_filename_1 = __importDefault(require("sanitize-filename"));
 class AbstractCommand {
     constructor(program, name, aliases, subcommand) {
         this.name = name;
@@ -241,6 +244,62 @@ class AbstractCommand {
         }, {});
         return args;
     }
+    validateOutputFileArg(argValue) {
+        const resolvedPath = (0, path_1.resolve)(argValue);
+        if ((0, fs_1.existsSync)(resolvedPath)) {
+            const stats = (0, fs_1.statSync)(resolvedPath);
+            if (stats.isDirectory()) {
+                try {
+                    (0, fs_1.accessSync)(resolvedPath, constants_1.default.W_OK);
+                }
+                catch (_a) {
+                    throw new Error(`No write access to directory "${resolvedPath}"`);
+                }
+                return;
+            }
+            if (stats.isFile()) {
+                const dir = (0, path_1.dirname)(resolvedPath);
+                try {
+                    (0, fs_1.accessSync)(dir, constants_1.default.W_OK);
+                }
+                catch (_b) {
+                    throw new Error(`No write access to directory "${dir}"`);
+                }
+                const fileName = (0, path_1.basename)(resolvedPath);
+                const sanitizedFileName = (0, sanitize_filename_1.default)(fileName);
+                if (fileName !== sanitizedFileName) {
+                    throw new Error(`Invalid filename "${fileName}"`);
+                }
+                return;
+            }
+            throw new Error(`Output path "${resolvedPath}" is neither a file nor a directory`);
+        }
+        const dir = (0, path_1.dirname)(resolvedPath);
+        const fileName = (0, path_1.basename)(resolvedPath);
+        const sanitizedFileName = (0, sanitize_filename_1.default)(fileName);
+        if (!(0, fs_1.existsSync)(dir)) {
+            throw new Error(`Parent directory does not exist "${dir}"`);
+        }
+        try {
+            (0, fs_1.accessSync)(dir, constants_1.default.W_OK);
+        }
+        catch (_c) {
+            throw new Error(`No write access to directory "${dir}"`);
+        }
+        if (fileName !== sanitizedFileName) {
+            throw new Error(`Invalid filename "${fileName}"`);
+        }
+    }
+    validateInputFileArg(argValue) {
+        const resolvedPath = (0, path_1.resolve)(argValue);
+        if (!(0, fs_1.existsSync)(resolvedPath)) {
+            throw new Error(`"${resolvedPath}" does not exist`);
+        }
+        const stats = (0, fs_1.statSync)(resolvedPath);
+        if (!stats.isFile()) {
+            throw new Error(`"${resolvedPath}" is not a file`);
+        }
+    }
     onArgs() {
     }
     onTrmDepMissing(dependency) {
@@ -318,18 +377,19 @@ class AbstractCommand {
                 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 (this.registerOpts.requiresR3trans && process.platform === 'darwin') {
-                    Commons.Logger.info(`This command needs R3trans program dockerized in your OS.`);
+                const useDocker = utils_1.GlobalContext.getInstance().getSettings().r3transDocker;
+                if (this.registerOpts.requiresR3trans && useDocker) {
+                    Commons.Logger.info(`This command needs R3trans program dockerized.`);
                     Commons.Logger.loading(`Checking if docker is running...`);
                     if (yield (0, utils_1.isDockerRunning)()) {
                         const dockerName = utils_1.GlobalContext.getInstance().getSettings().r3transDockerName;
                         Commons.Logger.info(`Docker "${dockerName || 'local/r3trans'}" will be used.`);
                     }
                     else {
-                        throw new Error(`Command needs R3trans dockerized, docker is not currently running.`);
+                        throw new Error(`Command needs R3trans dockerized, docker engine is not currently running.`);
                     }
                 }
-                if (process.platform !== 'win32' && process.platform !== 'darwin') {
+                if (process.platform !== 'win32' && process.platform !== 'darwin' && process.platform !== 'linux') {
                     Commons.Logger.warning(`Running on untested OS "${process.platform}"! Some features aren't tested yet.`);
                 }
                 if (!this.registerOpts.noClientVersionCheck) {

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

@@ -0,0 +1,5 @@
+import { AbstractCommand } from "../AbstractCommand";
+export declare class Cg3y extends AbstractCommand {
+    protected init(): void;
+    protected handler(): Promise<void>;
+}

package/dist/command/implementations/Cg3y.js

@@ -0,0 +1,49 @@
+"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());
+    });
+};
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.Cg3y = void 0;
+const path_1 = require("path");
+const AbstractCommand_1 = require("../AbstractCommand");
+const trm_core_1 = require("trm-core");
+const trm_commons_1 = require("trm-commons");
+const promises_1 = require("fs/promises");
+const sanitize_filename_1 = __importDefault(require("sanitize-filename"));
+class Cg3y extends AbstractCommand_1.AbstractCommand {
+    init() {
+        this.registerOpts.requiresConnection = true;
+        this.registerOpts.requiresTrmDependencies = true;
+        this.command.description(`Download any released transport.`);
+        this.command.argument(`<transport>`, `Transport number.`);
+        this.command.argument(`[filename]`, `Name (or path) of the output file.`);
+    }
+    handler() {
+        return __awaiter(this, void 0, void 0, function* () {
+            if (!this.args.filename) {
+                this.args.filename = (0, path_1.join)(process.cwd(), `${(0, sanitize_filename_1.default)(this.args.transport.toUpperCase())}.zip`);
+            }
+            const extension = (0, path_1.extname)(this.args.filename);
+            if (extension !== '.zip') {
+                this.args.filename = this.args.filename + '.zip';
+            }
+            this.validateOutputFileArg(this.args.filename);
+            const result = yield (0, trm_core_1.cg3y)({
+                trkorr: this.args.transport.toUpperCase()
+            });
+            trm_commons_1.Logger.loading(`Transport downloaded, writing data to disk...`);
+            yield (0, promises_1.writeFile)(this.args.filename, result.binaries);
+            trm_commons_1.Logger.success(`Transport available at "${this.args.filename}"`);
+        });
+    }
+}
+exports.Cg3y = Cg3y;

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

@@ -0,0 +1,5 @@
+import { AbstractCommand } from "../AbstractCommand";
+export declare class Cg3z extends AbstractCommand {
+    protected init(): void;
+    protected handler(): Promise<void>;
+}

package/dist/command/implementations/Cg3z.js

@@ -0,0 +1,60 @@
+"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.Cg3z = void 0;
+const trm_commons_1 = require("trm-commons");
+const AbstractCommand_1 = require("../AbstractCommand");
+const trm_core_1 = require("trm-core");
+const utils_1 = require("../../utils");
+const promises_1 = require("fs/promises");
+const path_1 = require("path");
+class Cg3z extends AbstractCommand_1.AbstractCommand {
+    init() {
+        this.registerOpts.requiresConnection = true;
+        this.registerOpts.requiresTrmDependencies = true;
+        this.registerOpts.requiresR3trans = true;
+        this.command.description(`Upload any released transport.`);
+        this.command.argument(`<filename>`, `Name (or path) of the file.`);
+    }
+    handler() {
+        return __awaiter(this, void 0, void 0, function* () {
+            const extension = (0, path_1.extname)(this.args.filename);
+            var transportLayer;
+            try {
+                transportLayer = yield trm_core_1.SystemConnector.getDefaultTransportLayer();
+            }
+            catch (_a) { }
+            if (extension !== '.zip') {
+                this.args.filename = this.args.filename + '.zip';
+            }
+            this.validateInputFileArg(this.args.filename);
+            trm_commons_1.Logger.loading(`Reading file "${this.args.filename}"...`);
+            const binaries = yield (0, promises_1.readFile)(this.args.filename);
+            const result = yield (0, trm_core_1.cg3z)({
+                r3transOptions: {
+                    tempDirPath: (0, utils_1.getTempFolder)(),
+                    r3transDirPath: this.args.r3transPath,
+                    useDocker: utils_1.GlobalContext.getInstance().getSettings().r3transDocker,
+                    dockerOptions: {
+                        name: utils_1.GlobalContext.getInstance().getSettings().r3transDockerName
+                    }
+                },
+                binaries
+            });
+            trm_commons_1.Logger.success(`Uploaded ${trm_core_1.Transport.getTransportIcon()}  ${result.trkorr}`);
+            trm_commons_1.Logger.info(`Transport is now available in transaction STMS, ${trm_core_1.SystemConnector.getDest()} queue`);
+            trm_commons_1.Logger.info(`-> Manually import into ${trm_core_1.SystemConnector.getDest()} via STMS in the appropriate client`);
+            trm_commons_1.Logger.info(`-> Manually change ${result.trkorr} workbench content origin system to ${trm_core_1.SystemConnector.getDest()} via SE03 if needed`);
+            trm_commons_1.Logger.info(`-> Manually change ${result.trkorr} SAP packages transport layer to ${transportLayer || 'default'} via SE80 if needed`);
+        });
+    }
+}
+exports.Cg3z = Cg3z;

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

@@ -0,0 +1,5 @@
+import { AbstractCommand } from "../AbstractCommand";
+export declare class ClearCache extends AbstractCommand {
+    protected init(): void;
+    protected handler(): Promise<void>;
+}

package/dist/command/implementations/ClearCache.js

@@ -0,0 +1,27 @@
+"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.ClearCache = void 0;
+const AbstractCommand_1 = require("../AbstractCommand");
+const trm_commons_1 = require("trm-commons");
+const utils_1 = require("../../utils");
+class ClearCache extends AbstractCommand_1.AbstractCommand {
+    init() {
+        this.command.description(`Clear client cache.`);
+    }
+    handler() {
+        return __awaiter(this, void 0, void 0, function* () {
+            utils_1.GlobalContext.getInstance().clearCache();
+            trm_commons_1.Logger.success(`Cache cleared`);
+        });
+    }
+}
+exports.ClearCache = ClearCache;

package/dist/command/implementations/Install.js

@@ -20,6 +20,7 @@ const utils_1 = require("../../utils");
 const execa_1 = require("execa");
 const node_os_1 = __importDefault(require("node:os"));
 const lockfile_1 = require("trm-core/dist/lockfile");
+const node_path_1 = require("node:path");
 class Install extends AbstractCommand_1.AbstractCommand {
     init() {
         this.registerOpts.requiresConnection = true;
@@ -139,6 +140,11 @@ class Install extends AbstractCommand_1.AbstractCommand {
             }
             var registry;
             if (this.name === 'import') {
+                const extension = (0, node_path_1.extname)(this.args.filename);
+                if (extension !== '.trm') {
+                    this.args.filename = this.args.filename + 'trm';
+                }
+                this.validateInputFileArg(this.args.filename);
                 registry = new trm_core_1.FileSystem(this.args.filename);
             }
             else {

package/dist/command/implementations/Publish.js

@@ -8,6 +8,9 @@ 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.Publish = void 0;
 const trm_commons_1 = require("trm-commons");
@@ -15,15 +18,17 @@ const trm_core_1 = require("trm-core");
 const AbstractCommand_1 = require("../AbstractCommand");
 const utils_1 = require("../../utils");
 const semver_1 = require("semver");
+const path_1 = require("path");
+const sanitize_filename_1 = __importDefault(require("sanitize-filename"));
 class Publish extends AbstractCommand_1.AbstractCommand {
     init() {
         this.registerOpts.requiresConnection = true;
         this.registerOpts.requiresTrmDependencies = true;
         if (this.name === 'pack') {
             this.command.description(`Export a package to local file.`);
-            this.command.argument(`<filename>`, `Name (or path) of the file.`);
-            this.command.option(`--package <package>`, `Name of the package`);
-            this.command.option(`--version <version>`, `Version of the release`);
+            this.command.argument(`<package>`, `Name of the package`);
+            this.command.argument(`<version>`, `Version of the release`);
+            this.command.argument(`[filename]`, `Name (or path) of the output file.`);
         }
         else {
             this.registerOpts.requiresRegistry = true;
@@ -89,6 +94,14 @@ class Publish extends AbstractCommand_1.AbstractCommand {
                 if (this.validateVersion(this.args.version) !== true) {
                     throw new Error(this.validateVersion(this.args.version));
                 }
+                if (!this.args.filename) {
+                    this.args.filename = (0, path_1.join)(process.cwd(), `${(0, sanitize_filename_1.default)(this.args.package)}.trm`);
+                }
+                const extension = (0, path_1.extname)(this.args.filename);
+                if (extension !== '.trm') {
+                    this.args.filename = this.args.filename + '.trm';
+                }
+                this.validateOutputFileArg(this.args.filename);
                 registry = new trm_core_1.FileSystem(this.args.filename);
             }
             else {

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

@@ -16,4 +16,7 @@ export * from "./Content";
 export * from "./View";
 export * from "./Compare";
 export * from "./FindDependencies";
+export * from "./Cg3y";
+export * from "./Cg3z";
 export * from "./Settings";
+export * from "./ClearCache";

package/dist/command/implementations/index.js

@@ -32,4 +32,7 @@ __exportStar(require("./Content"), exports);
 __exportStar(require("./View"), exports);
 __exportStar(require("./Compare"), exports);
 __exportStar(require("./FindDependencies"), exports);
+__exportStar(require("./Cg3y"), exports);
+__exportStar(require("./Cg3z"), exports);
 __exportStar(require("./Settings"), exports);
+__exportStar(require("./ClearCache"), exports);

package/dist/index.js

@@ -20,8 +20,30 @@ program
 Full documentation available at https://docs.trmregistry.com/
 Public registry at https://trmregistry.com/
 
-© 2025 RegestaItalia https://regestaitalia.eu/`)
+© 2023 RegestaItalia https://regestaitalia.eu/`)
     .version((0, utils_1.getClientVersion)());
+program.configureHelp({
+    sortSubcommands: true,
+    visibleCommands: (cmd) => {
+        var commands = [];
+        cmd.commands.forEach(c => {
+            if (c.description()) {
+                commands.push(c);
+            }
+            c.commands.forEach(s => {
+                commands.push(s);
+            });
+        });
+        return commands;
+    },
+    subcommandTerm: (cmd) => {
+        var term = `${cmd.name()} ${cmd.usage()}`;
+        if (cmd.parent.name() !== program.name()) {
+            term = `${cmd.parent.name()} ${cmd.name()} ${cmd.usage()}`;
+        }
+        return term;
+    }
+});
 new implementations_1.Ping(program, 'ping').register();
 new implementations_1.Info(program, 'info').register();
 new implementations_1.Registry(program, 'registry', null, 'add').register();
@@ -48,5 +70,8 @@ new implementations_1.Content(program, 'content', ['contents']).register();
 new implementations_1.View(program, 'view').register();
 new implementations_1.Compare(program, 'compare').register();
 new implementations_1.FindDependencies(program, 'find-dependencies').register();
+new implementations_1.Cg3y(program, 'cg3y').register();
+new implementations_1.Cg3z(program, 'cg3z').register();
 new implementations_1.Settings(program, 'settings').register();
+new implementations_1.ClearCache(program, 'clear-cache').register();
 program.parse(process.argv);

package/dist/utils/GlobalContext.d.ts

@@ -7,6 +7,7 @@ export declare class GlobalContext {
     private _cache;
     private _connections;
     private _plugins;
+    private _dockerized;
     constructor();
     getSettings(): SettingsData;
     getGlobalNodeModules(): string;
@@ -23,6 +24,7 @@ export declare class GlobalContext {
     private getDefaultSettings;
     private setGlobalNpmPathInternal;
     private getSettingsInternal;
+    clearCache(): void;
     private getCacheInternal;
     private generateSettingsFile;
     private generateCacheFile;

package/dist/utils/GlobalContext.js

@@ -71,6 +71,7 @@ class GlobalContext {
         this._pluginsLoaded = false;
         this._connections = [];
         this._plugins = [];
+        this._dockerized = process.env.TRM_DOCKERIZED === 'true';
         this._settings = this.getSettingsInternal();
         this._cache = this.getCacheInternal();
         if (typeof (this._settings.r3transDocker) !== 'boolean') {
@@ -172,13 +173,24 @@ class GlobalContext {
         };
     }
     setGlobalNpmPathInternal() {
+        var path;
+        if (this._dockerized) {
+            trm_commons_1.Logger.log(`TRM running in docker environment, ignoring cache and recalculating NPM global path`, true);
+            path = (0, trm_commons_1.getGlobalNodeModules)();
+            this._cache['globalNpmPath'] = {
+                ts: -1,
+                data: path
+            };
+            trm_commons_1.Logger.log(`Npm global modules path set to ${path}`, true);
+            return;
+        }
         const globalNpmPathCache = this._cache.globalNpmPath;
         const isValid = !!globalNpmPathCache && !!globalNpmPathCache.ts && (Date.now() - globalNpmPathCache.ts) < this.getSettings().npmGlobalPathCheckCache * 1000;
         if (isValid) {
             return globalNpmPathCache.data;
         }
         trm_commons_1.Logger.loading(`Cache expired, setting npm global modules path...`, true);
-        const path = (0, trm_commons_1.getGlobalNodeModules)();
+        path = (0, trm_commons_1.getGlobalNodeModules)();
         trm_commons_1.Logger.log(`Npm global modules path set to ${path}`, true);
         this.setCache('globalNpmPath', path);
     }
@@ -210,11 +222,19 @@ class GlobalContext {
         this.generateSettingsFile(defaultSettings, filePath);
         return defaultSettings;
     }
+    clearCache() {
+        const filePath = this.getCacheFilePath();
+        this.generateCacheFile({}, filePath);
+    }
     getCacheInternal() {
         const filePath = this.getCacheFilePath();
         if (fs.existsSync(filePath)) {
             try {
-                return JSON.parse(fs.readFileSync(filePath).toString());
+                var data = JSON.parse(fs.readFileSync(filePath).toString());
+                if (this._dockerized) {
+                    delete data.globalNpmPath;
+                }
+                return data;
             }
             catch (e) { }
         }

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "trm-client",
-  "version": "7.5.1",
+  "version": "7.7.0",
   "description": "TRM (Transport Request Manager) Client",
   "main": "dist/index.js",
   "types": "dist/index.d.ts",
@@ -45,9 +45,10 @@
     "i": "^0.3.7",
     "ini": "^4.1.1",
     "lodash": "^4.17.21",
+    "sanitize-filename": "^1.6.3",
     "semver": "^7.7.4",
     "trm-commons": "^3.5.1",
-    "trm-core": "^8.5.1",
+    "trm-core": "^8.5.3",
     "trm-registry-types": "^2.1.0",
     "xml2js": "^0.6.2"
   },