trm-client 6.1.1 → 7.0.0

package/dist/command/implementations/Info.js

@@ -0,0 +1,245 @@
+"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.Info = void 0;
+const trm_commons_1 = require("trm-commons");
+const trm_core_1 = require("trm-core");
+const AbstractCommand_1 = require("../AbstractCommand");
+const utils_1 = require("../../utils");
+const semver_1 = require("semver");
+const chalk_1 = __importDefault(require("chalk"));
+const fs_1 = require("fs");
+const path_1 = require("path");
+const get_root_path_1 = require("get-root-path");
+class Info extends AbstractCommand_1.AbstractCommand {
+    init() {
+        this.registerOpts.requiresConnection = true;
+        this.registerOpts.addNoConnection = true;
+        this.registerOpts.requiresTrmDependencies = true;
+        this.command.description(`TRM Client/Server Info. Shows installed and available updates.`);
+    }
+    onTrmDepMissing(dependency) {
+        return false;
+    }
+    onTrmDepVersionNotSatisfied(trmPackage) {
+        return false;
+    }
+    getDependencyVersion(moduleName, rootModule = 'trm-client') {
+        var file;
+        try {
+            file = (0, fs_1.readFileSync)((0, path_1.join)(get_root_path_1.rootPath, `/node_modules/${rootModule}/node_modules/${moduleName}/package.json`));
+        }
+        catch (e) {
+            file = (0, fs_1.readFileSync)((0, path_1.join)(get_root_path_1.rootPath, `/node_modules/${moduleName}/package.json`));
+        }
+        if (!file) {
+            trm_commons_1.Logger.warning(`Library ${moduleName} (root ${rootModule}) was not found!`, true);
+        }
+        else {
+            return JSON.parse(file.toString()).version;
+        }
+    }
+    getNodeRfcVersion(npmGlobal) {
+        var file;
+        try {
+            file = (0, fs_1.readFileSync)((0, path_1.join)(npmGlobal, `/node-rfc/package.json`));
+        }
+        catch (e) {
+        }
+        if (!file) {
+            trm_commons_1.Logger.warning(`Library node-rfc was not found!`, true);
+        }
+        else {
+            return JSON.parse(file.toString()).version;
+        }
+    }
+    getNpmLatestForText(packageName, installedVersion, text) {
+        return __awaiter(this, void 0, void 0, function* () {
+            try {
+                const latestVersion = yield (0, utils_1.getNpmPackageLatestVersion)(packageName);
+                if ((0, semver_1.gte)(installedVersion, latestVersion)) {
+                    text += ` ${chalk_1.default.bgGreen('LATEST')}`;
+                }
+                else {
+                    text += ` ${chalk_1.default.bold('v' + latestVersion + ' available')}`;
+                }
+            }
+            catch (e) {
+                text += ` ${chalk_1.default.bgGray('Can\'t fetch latest version')}`;
+            }
+            return text;
+        });
+    }
+    handler() {
+        return __awaiter(this, void 0, void 0, function* () {
+            trm_commons_1.Logger.loading(`Reading data...`);
+            const npmGlobal = utils_1.GlobalContext.getInstance().getSettings().globalNodeModules;
+            const clientLatest = yield this.getCliVersionStatus();
+            const clientVersion = (0, utils_1.getClientVersion)();
+            const clientDependencies = (0, utils_1.getClientNodeDependencies)();
+            const trmDependencies = (0, trm_core_1.getCoreTrmDependencies)();
+            const trmDependenciesInstances = (yield this.getTrmDependenciesCheck()).dependencies;
+            const trmMissingDependencies = (yield this.getTrmDependenciesCheck()).missingDependencies;
+            const nodeRfcVersion = this.getNodeRfcVersion(npmGlobal);
+            const packages = yield this.getSystemPackages();
+            const trmRest = packages.find(o => o.compareName("trm-rest") && o.compareRegistry(trm_core_1.RegistryProvider.getRegistry()));
+            var nodeR3transVersion;
+            try {
+                nodeR3transVersion = this.getDependencyVersion("node-r3trans", "trm-core");
+                if (!nodeR3transVersion) {
+                    throw new Error();
+                }
+            }
+            catch (e) {
+                nodeR3transVersion = this.getDependencyVersion("node-r3trans");
+            }
+            var clientDependenciesTree = [];
+            if (clientDependencies) {
+                for (const d of Object.keys(clientDependencies).filter(k => k.startsWith('trm'))) {
+                    var dText = ``;
+                    var dInstalledVersion = this.getDependencyVersion(d);
+                    if (dInstalledVersion) {
+                        dText = ` -> ${dInstalledVersion}`;
+                        dText = yield this.getNpmLatestForText(d, dInstalledVersion, dText);
+                    }
+                    clientDependenciesTree.push({
+                        text: `${d} ${clientDependencies[d]}${dText}`,
+                        children: []
+                    });
+                }
+            }
+            var serverDependenciesTree = [];
+            if (trmDependencies) {
+                for (const d of Object.keys(trmDependencies)) {
+                    var dText = ``;
+                    const oTrmPackage = trmDependenciesInstances.find(o => o.compareName(d));
+                    if (oTrmPackage) {
+                        var dInstalledVersion;
+                        try {
+                            dInstalledVersion = oTrmPackage.manifest.get().version;
+                        }
+                        catch (e) {
+                            dText = ` -> ${e.message}`;
+                        }
+                        if (dInstalledVersion) {
+                            dText = ` -> ${dInstalledVersion}`;
+                            try {
+                                const dLatestVersion = (yield oTrmPackage.registry.getPackage(oTrmPackage.packageName, 'latest')).manifest.version;
+                                if ((0, semver_1.gte)(dInstalledVersion, dLatestVersion)) {
+                                    dText += ` ${chalk_1.default.bgGreen('LATEST')}`;
+                                }
+                                else {
+                                    dText += ` ${chalk_1.default.bold('v' + dLatestVersion + ' available')}`;
+                                }
+                            }
+                            catch (e) {
+                                dText += ` ${chalk_1.default.bgGray('Can\'t fetch latest version')}`;
+                            }
+                        }
+                    }
+                    else {
+                        const missingDependency = trmMissingDependencies.find(o => {
+                            if (typeof (o) === 'string') {
+                                if (o === d) {
+                                    return o;
+                                }
+                            }
+                        });
+                        if (missingDependency) {
+                            try {
+                                dText = ` -> ${chalk_1.default.bgRed(missingDependency.manifest.get().version)}`;
+                            }
+                            catch (e) {
+                                dText = ` -> ${chalk_1.default.bgRed('Not found')}`;
+                            }
+                        }
+                    }
+                    serverDependenciesTree.push({
+                        text: `${d} ${trmDependencies[d]}${dText}`,
+                        children: []
+                    });
+                }
+            }
+            if (trmRest && trmRest.manifest) {
+                serverDependenciesTree.push({
+                    text: `trm-rest -> ${trmRest.manifest.get().version}`,
+                    children: []
+                });
+            }
+            var clientChildrenTree = [{
+                    text: `trm-client ${clientVersion} ${(0, semver_1.gte)(clientLatest.localVersion, clientLatest.latestVersion) ? chalk_1.default.bgGreen('LATEST') : chalk_1.default.bold('v' + clientLatest.latestVersion + ' available')}`,
+                    children: clientDependenciesTree
+                }];
+            if (nodeRfcVersion) {
+                clientChildrenTree.push({
+                    text: yield this.getNpmLatestForText('node-rfc', nodeRfcVersion, `node-rfc ${nodeRfcVersion}`),
+                    children: []
+                });
+            }
+            else {
+                clientChildrenTree.push({
+                    text: `node-rfc ${chalk_1.default.bold('not found')}`,
+                    children: []
+                });
+            }
+            if (nodeR3transVersion) {
+                clientChildrenTree.push({
+                    text: yield this.getNpmLatestForText('node-r3trans', nodeR3transVersion, `node-r3trans ${nodeR3transVersion}`),
+                    children: []
+                });
+            }
+            else {
+                clientChildrenTree.push({
+                    text: `node-r3trans ${chalk_1.default.bold('not found')}`,
+                    children: []
+                });
+            }
+            const clientTree = {
+                text: chalk_1.default.bold(`Client`),
+                children: clientChildrenTree
+            };
+            const serverTree = {
+                text: chalk_1.default.bold(`Server (${trm_core_1.SystemConnector.getDest()})`),
+                children: serverDependenciesTree
+            };
+            const pluginsTree = {
+                text: chalk_1.default.bold(`Plugins`),
+                children: []
+            };
+            for (const plugin of utils_1.GlobalContext.getInstance().getPlugins()) {
+                try {
+                    const installedVersion = JSON.parse((0, fs_1.readFileSync)((0, path_1.join)(plugin.location, 'package.json')).toString()).version;
+                    pluginsTree.children.push({
+                        text: yield this.getNpmLatestForText(plugin.name, installedVersion, `${plugin.name} ${installedVersion}`),
+                        children: []
+                    });
+                }
+                catch (_a) {
+                    pluginsTree.children.push({
+                        text: plugin.name,
+                        children: []
+                    });
+                }
+            }
+            trm_commons_1.Logger.tree(clientTree);
+            if (!(trm_core_1.SystemConnector.systemConnector instanceof utils_1.DummyConnector)) {
+                trm_commons_1.Logger.tree(serverTree);
+            }
+            if (pluginsTree.children.length > 0) {
+                trm_commons_1.Logger.tree(pluginsTree);
+            }
+        });
+    }
+}
+exports.Info = Info;

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

@@ -0,0 +1,13 @@
+import { TrmPackage } from "trm-core";
+import { AbstractCommand } from "../AbstractCommand";
+export declare class Install extends AbstractCommand {
+    protected init(): void;
+    private selfUpdate;
+    private detectPackageManager;
+    private looksLikeYarnBerry;
+    private isPermsError;
+    private formatPermsHelp;
+    protected onArgs(): void;
+    protected onTrmDepVersionNotSatisfied(trmPackage: TrmPackage): boolean;
+    protected handler(): Promise<void>;
+}

package/dist/command/implementations/Install.js

@@ -0,0 +1,201 @@
+"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.Install = void 0;
+const trm_commons_1 = require("trm-commons");
+const trm_core_1 = require("trm-core");
+const AbstractCommand_1 = require("../AbstractCommand");
+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");
+class Install extends AbstractCommand_1.AbstractCommand {
+    init() {
+        this.registerOpts.requiresConnection = true;
+        this.registerOpts.requiresTrmDependencies = true;
+        this.registerOpts.requiresR3trans = true;
+        if (this.name === 'update') {
+            this.registerOpts.requiresRegistry = true;
+            this.command.argument(`[package]`, `Name of the package.`);
+            this.command.argument(`[version]`, `Version (or tag) of the release.`, `latest`);
+            this.command.description(`Update trm-client / Update package from registry into system.`);
+            this.command.addHelpText(`before`, `When no package name is specified, trm-client will self-update; all options are invalid, in this case.`);
+        }
+        else if (this.name === 'install') {
+            this.registerOpts.requiresRegistry = true;
+            this.command.argument(`<package>`, `Name of the package.`);
+            this.command.argument(`[version]`, `Version (or tag) of the release.`, `latest`);
+            this.command.description(`Install package from registry into system.`);
+        }
+        else if (this.name === 'clean-install') {
+            this.registerOpts.requiresRegistry = true;
+            this.command.argument(`<package>`, `Name of the package.`);
+            this.command.argument(`[version]`, `Version (or tag) of the release.`, `latest`);
+            this.command.description(`Clean install package from registry into system (requires lockfile).`);
+            this.command.option(`-L, --lock-file`, `Install lockfile`, `trm-lock.json`);
+        }
+        else if (this.name === 'import') {
+            this.command.argument(`<filename>`, `Name (or path) of the file.`);
+            this.command.description(`Import a package (as a file) into system.`);
+        }
+        this.command.option(`-t, --timeout <seconds>`, `Transport import timeout (in seconds)`, `180`);
+        this.command.option(`-T, --transport-layer <transport layer>`, `Package transport layer. (default: System default)`);
+        this.command.option(`--no-deps`, `Do not install dependencies.`, false);
+        this.command.option(`--no-obj-type`, `Do not check object types before import.`, false);
+        this.command.option(`--no-obj-check`, `Do not check if objects before import.`, false);
+        this.command.option(`--no-sap-entries`, `Do not check SAP entries before import.`, false);
+        this.command.option(`--no-lang-tr`, `Do not import language (translation) transport.`, false);
+        this.command.option(`--no-cust-tr`, `Do not import customizing transports.`, false);
+        this.command.option(`--no-install-tr`, `Do not create install transport.`, false);
+        this.command.option(`--no-namespace`, `Do not import namespace.`, false);
+        this.command.option(`--package-replacements <replacements>`, `SAP Package replacements (JSON or path to JSON file)`);
+        this.command.option(`--install-tr-target <target>`, `Install transport target system`);
+        this.command.option(`--no-prompts`, `No prompts (will force some decisions).`, false);
+    }
+    selfUpdate() {
+        return __awaiter(this, void 0, void 0, function* () {
+            const pm = this.detectPackageManager();
+            const target = `trm-client@latest`;
+            const command = pm === "pnpm"
+                ? { bin: "pnpm", args: ["add", "-g", target] }
+                : pm === "yarn1"
+                    ? { bin: "yarn", args: ["global", "add", target] }
+                    : { bin: "npm", args: ["install", "-g", target] };
+            try {
+                yield (0, execa_1.execa)(command.bin, command.args, { stdio: "inherit" });
+                trm_commons_1.Logger.success(`Client updated successfully.`);
+            }
+            catch (err) {
+                if (this.isPermsError(err)) {
+                    trm_commons_1.Logger.error(this.formatPermsHelp(command.bin));
+                }
+                if (command.bin === "yarn" && this.looksLikeYarnBerry()) {
+                    trm_commons_1.Logger.error(`\Detected Yarn ≥2 (Berry). It doesn't support reliable global installs.\n` +
+                        `    Try: npm install -g ${target}`);
+                }
+                throw err;
+            }
+        });
+    }
+    detectPackageManager() {
+        var _a;
+        const ua = (_a = process.env.npm_config_user_agent) !== null && _a !== void 0 ? _a : "";
+        if (ua.includes("pnpm/"))
+            return "pnpm";
+        if (ua.includes("yarn/1."))
+            return "yarn1";
+        return "npm";
+    }
+    looksLikeYarnBerry() {
+        var _a;
+        const ua = (_a = process.env.npm_config_user_agent) !== null && _a !== void 0 ? _a : "";
+        return ua.includes("yarn/") && !ua.includes("yarn/1.");
+    }
+    isPermsError(err) {
+        const msg = String((err === null || err === void 0 ? void 0 : err.message) || err);
+        return ((err === null || err === void 0 ? void 0 : err.code) === "EACCES" ||
+            (err === null || err === void 0 ? void 0 : err.errno) === -13 ||
+            /EACCES|EPERM|permission denied/i.test(msg));
+    }
+    formatPermsHelp(bin) {
+        const isUnix = node_os_1.default.platform() !== "win32";
+        return (`Permission error installing globally.\n` +
+            `Troubleshooting tips:\n` +
+            (isUnix
+                ? `  • If you used a system Node, configure a user-level global prefix:\n` +
+                    `      mkdir -p ~/.npm-global && npm config set prefix ~/.npm-global\n` +
+                    `      export PATH="$HOME/.npm-global/bin:$PATH"\n` +
+                    `    (Then rerun: ${bin} …)\n` +
+                    `  • Prefer using a Node version manager (nvm/fnm/volta) to avoid sudo.\n` +
+                    `  • Avoid running global installs with sudo unless you know why.\n`
+                : `  • Run your shell as Administrator, or use a Node manager (nvs/volta).\n`) +
+            ``);
+    }
+    onArgs() {
+        if (this.name === 'update' && !this.args.package) {
+            this.registerOpts = {};
+        }
+    }
+    onTrmDepVersionNotSatisfied(trmPackage) {
+        return !trmPackage.compareName(this.args.package);
+    }
+    handler() {
+        return __awaiter(this, void 0, void 0, function* () {
+            if (this.name === 'update' && !this.args.package) {
+                yield this.selfUpdate();
+                return;
+            }
+            var registry;
+            if (this.name === 'import') {
+                registry = new trm_core_1.FileSystem(this.args.filename);
+            }
+            else {
+                registry = this.getRegistry();
+            }
+            const packages = yield this.getSystemPackages();
+            const result = yield (0, trm_core_1.install)({
+                contextData: {
+                    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
+                        }
+                    },
+                    noInquirer: this.args.noPrompts,
+                    systemPackages: packages,
+                    noR3transInfo: false
+                },
+                packageData: {
+                    registry,
+                    name: this.args.package,
+                    version: this.args.version,
+                    overwrite: this.name === 'update'
+                },
+                installData: {
+                    checks: {
+                        noDependencies: this.args.noDeps,
+                        noObjectTypes: this.args.noObjType,
+                        noSapEntries: this.args.noSapEntries,
+                        noExistingObjects: this.args.noObjCheck,
+                        lockfile: this.args.lockFile ? lockfile_1.Lockfile.fromJson(this.parseJsonArg('lockFile')) : undefined
+                    },
+                    import: {
+                        noLang: this.args.noLangTr,
+                        noCust: this.args.noCustTr,
+                        timeout: this.parseNumberArg('timeout'),
+                        replaceExistingTransports: false
+                    },
+                    installDevclass: {
+                        keepOriginal: false,
+                        transportLayer: this.args.transportLayer,
+                        replacements: this.parseJsonArg('packageReplacements'),
+                        skipNamespace: this.args.noNamespace
+                    },
+                    installTransport: {
+                        create: !!this.args.noInstallTransport,
+                        targetSystem: this.args.installTrTarget
+                    }
+                }
+            });
+            var sOutput = `${result.manifest.name} v${result.manifest.version} installed`;
+            if (result.installTransport) {
+                sOutput += `, use ${result.installTransport.trkorr} transport in landscape`;
+            }
+            trm_commons_1.Logger.success(sOutput);
+        });
+    }
+}
+exports.Install = Install;

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

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

package/dist/command/implementations/List.js

@@ -0,0 +1,116 @@
+"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.List = void 0;
+const trm_commons_1 = require("trm-commons");
+const trm_core_1 = require("trm-core");
+const AbstractCommand_1 = require("../AbstractCommand");
+const chalk_1 = __importDefault(require("chalk"));
+class List extends AbstractCommand_1.AbstractCommand {
+    init() {
+        this.registerOpts.requiresConnection = true;
+        this.command.description(`List TRM packages in a system.`);
+        this.command.option(`-L, --locals`, `Include local packages (imported and exported)`, false);
+        this.command.option(`-o, --output-type`, `Output type (TREE or TABLE)`, 'TREE');
+    }
+    handler() {
+        return __awaiter(this, void 0, void 0, function* () {
+            const dest = trm_core_1.SystemConnector.getDest();
+            var aPackages = yield this.getSystemPackages();
+            var iLocals = aPackages.filter(o => o.registry.getRegistryType() === trm_core_1.RegistryType.LOCAL).length;
+            if (!this.args.locals) {
+                aPackages = aPackages.filter(o => o.registry.getRegistryType() !== trm_core_1.RegistryType.LOCAL);
+            }
+            if (aPackages.length > 0) {
+                const tableHead = [`Name`, `Version`, `Registry`, `Devclass`, `TRM transport`, `Landscape transport`];
+                var tableData = [];
+                for (const oPackage of aPackages) {
+                    try {
+                        const packageName = oPackage.packageName || '';
+                        const version = oPackage.manifest.get().version || '';
+                        const registry = oPackage.registry.getRegistryType() === trm_core_1.RegistryType.LOCAL ? chalk_1.default.bold(oPackage.registry.name) : oPackage.registry.name;
+                        const devclass = oPackage.getDevclass() || '';
+                        const linkedTransport = oPackage.manifest.getLinkedTransport();
+                        const landscapeTransport = yield oPackage.getWbTransport();
+                        var importTransport = '';
+                        if (linkedTransport && (yield linkedTransport.isImported())) {
+                            importTransport = linkedTransport.trkorr;
+                        }
+                        tableData.push([
+                            packageName,
+                            version,
+                            registry,
+                            devclass,
+                            importTransport,
+                            landscapeTransport ? landscapeTransport.trkorr : ''
+                        ]);
+                    }
+                    catch (e) {
+                        trm_commons_1.Logger.error(e, true);
+                    }
+                }
+                if (tableData.length < aPackages.length) {
+                    trm_commons_1.Logger.warning(`${aPackages.length - tableData.length} packages couldn't be printed (check logs).`);
+                }
+                trm_commons_1.Logger.info(`${dest} has ${aPackages.length} packages.`);
+                tableData = tableData.reverse();
+                if (this.args.outputType === 'TABLE') {
+                    trm_commons_1.Logger.table(tableHead, tableData);
+                }
+                else if (this.args.outputType === 'TREE') {
+                    const grouped = Object.entries(tableData.reduce((acc, row) => { var _a; var _b; return (((_a = acc[_b = row[2]]) !== null && _a !== void 0 ? _a : (acc[_b] = [])).push(row), acc); }, {})).map(([registry, packages]) => ({ registry, packages }));
+                    grouped.forEach(o => {
+                        var tree = {
+                            text: `Registry "${chalk_1.default.bold(o.registry)}"`,
+                            children: []
+                        };
+                        o.packages.forEach(p => {
+                            var packageTree = {
+                                text: chalk_1.default.bold(`${p[0]} v${p[1]}`),
+                                children: [{
+                                        text: `SAP Package: ${p[3]}`,
+                                        children: []
+                                    }]
+                            };
+                            if (p[4]) {
+                                packageTree.children.push({
+                                    text: `Import transport: ${p[4]}`,
+                                    children: []
+                                });
+                            }
+                            if (p[5]) {
+                                packageTree.children.push({
+                                    text: `Landscape transport: ${p[5]}`,
+                                    children: []
+                                });
+                            }
+                            tree.children.push(packageTree);
+                        });
+                        trm_commons_1.Logger.tree(tree);
+                    });
+                }
+                else {
+                    throw new Error(`Invalid output type "${this.args.outputType}".`);
+                }
+                if (iLocals > 0 && !this.args.locals) {
+                    trm_commons_1.Logger.warning(`There ${iLocals === 1 ? 'is' : 'are'} ${iLocals} local package${iLocals === 1 ? '' : 's'}. Run with option -L (--locals) to list ${iLocals === 1 ? 'it' : 'them'}.`);
+                }
+            }
+            else {
+                trm_commons_1.Logger.info(`${dest} has 0 packages.`);
+            }
+        });
+    }
+}
+exports.List = List;

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

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

package/dist/command/implementations/Lock.js

@@ -0,0 +1,40 @@
+"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.Lock = void 0;
+const trm_commons_1 = require("trm-commons");
+const AbstractCommand_1 = require("../AbstractCommand");
+const fs_1 = require("fs");
+class Lock extends AbstractCommand_1.AbstractCommand {
+    init() {
+        this.registerOpts.requiresConnection = true;
+        this.registerOpts.requiresRegistry = true;
+        this.registerOpts.ignoreRegistryUnreachable = true;
+        this.command.description(`Generate a lockfile for a TRM package.`);
+        this.command.argument(`<package>`, `Name of the package to generate lock file.`);
+        this.command.argument(`[output path]`, `Output path.`, 'trm-lock.json');
+    }
+    handler() {
+        return __awaiter(this, void 0, void 0, function* () {
+            const packages = yield this.getSystemPackages();
+            trm_commons_1.Logger.loading(`Generating lock file...`);
+            const source = packages.find(o => o.compareName(this.args.package) && o.compareRegistry(this.getRegistry()));
+            if (!source) {
+                throw new Error(`Package "${this.args.package}" not found`);
+            }
+            const lock = yield source.getLockfile(packages);
+            trm_commons_1.Logger.loading(`Writing lock file...`);
+            (0, fs_1.writeFileSync)(this.args.outputPath, lock.toJson());
+            trm_commons_1.Logger.info(`Generated lock file "${this.args.outputPath}"`);
+        });
+    }
+}
+exports.Lock = Lock;

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

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