trm-client 9.4.0 → 10.0.0

package/changelog.txt

@@ -8,6 +8,18 @@ Legend
 + : added
 - : removed
 
+2026-07-06 v10.0.0
+-------------------
++ expose commands metadata
+! format commands descriptions and longtexts
+- execa dependency
+- support for dockerized trm
+* cache management
+
+2026-07-02 v9.4.1
+-------------------
++ expose exports
+
 2026-06-15 v9.4.0
 -------------------
 ! trm-core ^9.8.0

package/dist/cli.d.ts

@@ -0,0 +1,2 @@
+#!/usr/bin/env node
+export {};

package/dist/cli.js

@@ -0,0 +1,78 @@
+#!/usr/bin/env node
+"use strict";
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+const dotenv_1 = __importDefault(require("dotenv"));
+const commander_1 = require("commander");
+const utils_1 = require("./utils");
+const implementations_1 = require("./command/implementations");
+const trm_core_1 = require("trm-core");
+dotenv_1.default.config({
+    quiet: true
+});
+const program = new commander_1.Command();
+program
+    .name(`trm`)
+    .description(`${trm_core_1.Transport.getTransportIcon()}  TRM - Transport Request Manager CLI
+        
+Full documentation available at https://docs.trmregistry.com/
+Public registry at https://trmregistry.com/
+
+© 2023 RegestaItalia https://regestaitalia.eu/`)
+    .version(process.env.DEVELOPMENT && process.env.DEVELOPMENT.toLowerCase().trim() === 'true' ? 'Development' : (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();
+new implementations_1.Registry(program, 'registry', null, 'rm').register();
+new implementations_1.Login(program, 'login').register();
+new implementations_1.WhoAmI(program, 'whoami').register();
+new implementations_1.Logout(program, 'logout').register();
+new implementations_1.Alias(program, 'alias').register();
+new implementations_1.Alias(program, 'alias', null, 'create').register();
+new implementations_1.Alias(program, 'alias', null, 'delete').register();
+new implementations_1.Publish(program, 'publish').register();
+new implementations_1.DistTag(program, 'dist-tag', null, 'add').register();
+new implementations_1.DistTag(program, 'dist-tag', null, 'rm').register();
+new implementations_1.Publish(program, 'pack', ['export']).register();
+new implementations_1.Lock(program, 'lock', ['lock-file']).register();
+new implementations_1.Unpublish(program, 'unpublish').register();
+new implementations_1.Deprecate(program, 'deprecate').register();
+new implementations_1.Install(program, 'install', ['i']).register();
+new implementations_1.Install(program, 'clean-install', ['ci']).register();
+new implementations_1.Install(program, 'update').register();
+new implementations_1.Install(program, 'import').register();
+new implementations_1.List(program, 'list', ['ls']).register();
+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.Dirty(program, 'dirty').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/command/AbstractCommand.d.ts

@@ -4,19 +4,22 @@ 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 readonly subcommand?: string;
     protected command: Command;
     protected registerOpts: RegisterCommandOpts;
     protected args: any;
+    protected readonly name: string;
+    protected readonly aliases?: string[];
+    protected readonly subcommand?: string;
     private cliVersionStatus;
     private registry;
     private registryAuthData;
     private registryAuthFailed;
     private systemPackages;
     private trmDependenciesCheck;
+    private metadata;
     constructor(program: Command, name: string, aliases?: string[], subcommand?: string);
+    constructor(name: string, aliases?: string[], subcommand?: string);
+    private getMetadata;
     getCliVersionStatus(): Promise<CliVersionStatus>;
     getRegistry(): Core.AbstractRegistry;
     hasRegistryAuthData(): boolean;
@@ -25,11 +28,11 @@ export declare abstract class AbstractCommand {
     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 normalizeArgs;
     private parseCommandArgs;
     validateOutputFileArg(argValue: string): void;
     validateInputFileArg(argValue: string): void;
@@ -41,5 +44,7 @@ export declare abstract class AbstractCommand {
     parseJsonArg(name: string): any;
     parseArrayArg(name: string): string[];
     parseNumberArg(name: string): number;
+    run(args?: any): Promise<void>;
     private execute;
+    private executePrepared;
 }

package/dist/command/AbstractCommand.js

@@ -59,33 +59,48 @@ const fs_1 = require("fs");
 const path_1 = require("path");
 const constants_1 = __importDefault(require("constants"));
 const sanitize_filename_1 = __importDefault(require("sanitize-filename"));
+const applyCommandMetadata_1 = require("./metadata/applyCommandMetadata");
 class AbstractCommand {
-    constructor(program, name, aliases, subcommand) {
-        this.name = name;
-        this.aliases = aliases;
-        this.subcommand = subcommand;
+    constructor(programOrName, nameOrAliases, aliasesOrSubcommand, subcommandArg) {
         this.registerOpts = {};
         this.args = {};
         this.registryAuthData = false;
-        const index = program.commands.findIndex(c => c.name() === this.name);
-        if (index >= 0) {
-            if (subcommand) {
-                this.command = program.commands[index];
+        const program = typeof programOrName === "string" ? undefined : programOrName;
+        this.name = typeof programOrName === "string" ? programOrName : nameOrAliases;
+        this.aliases = typeof programOrName === "string" ? nameOrAliases : aliasesOrSubcommand;
+        this.subcommand = typeof programOrName === "string" ? aliasesOrSubcommand : subcommandArg;
+        this.metadata = this.getMetadata();
+        if (this.metadata) {
+            this.registerOpts = Object.assign({}, this.metadata.requirements);
+        }
+        if (program) {
+            const index = program.commands.findIndex(c => c.name() === this.name);
+            if (index >= 0) {
+                if (this.subcommand) {
+                    this.command = program.commands[index];
+                }
+                else {
+                    throw new Error(`Command "${this.name}" declared multiple times without subcommand.`);
+                }
             }
             else {
-                throw new Error(`Command "${this.name}" declared multiple times without subcommand.`);
+                this.command = program.command(this.name);
+            }
+            if (this.subcommand) {
+                this.command = this.command.command(this.subcommand);
+            }
+            if (this.aliases) {
+                this.command.aliases(this.aliases);
+            }
+            if (this.metadata) {
+                (0, applyCommandMetadata_1.applyCommandMetadata)(this.command, this.metadata);
             }
         }
-        else {
-            this.command = program.command(this.name);
-        }
-        if (this.subcommand) {
-            this.command = this.command.command(this.subcommand);
-        }
-        if (aliases) {
-            this.command.aliases(aliases);
-        }
-        this.init();
+    }
+    getMetadata() {
+        const metadata = this.constructor.metadata;
+        const entries = Array.isArray(metadata) ? metadata : metadata ? [metadata] : [];
+        return entries.find(entry => entry.command === this.name && entry.subcommand === this.subcommand);
     }
     getCliVersionStatus() {
         return __awaiter(this, void 0, void 0, function* () {
@@ -171,6 +186,9 @@ class AbstractCommand {
         });
     }
     register() {
+        if (!this.command) {
+            throw new Error(`Command "${this.name}" cannot be registered without a Commander program.`);
+        }
         const defaultLogger = utils_1.GlobalContext.getInstance().getSettings().loggerType;
         const logOutputFolder = utils_1.GlobalContext.getInstance().getSettings().logOutputFolder;
         this.command
@@ -227,22 +245,38 @@ class AbstractCommand {
             default: throw new Error(`Unknown inquirer type "${type}". Possible values are ${Object.keys(InquirerType_1.InquirerType).map(k => InquirerType_1.InquirerType[k]).join(', ')}.`);
         }
     }
+    normalizeArgs(args = {}) {
+        const defaultLogger = utils_1.GlobalContext.getInstance().getSettings().loggerType;
+        const logOutputFolder = utils_1.GlobalContext.getInstance().getSettings().logOutputFolder;
+        const normalized = {
+            logger: defaultLogger,
+            loggerOutDir: logOutputFolder,
+            debug: false
+        };
+        if (this.metadata) {
+            [...this.metadata.arguments, ...this.metadata.options].forEach(field => {
+                if (field.defaultValue !== undefined) {
+                    normalized[field.name] = field.defaultValue;
+                }
+            });
+        }
+        const providedArgs = Object.entries(args).reduce((acc, [key, value]) => {
+            const newKey = key.replace(/[ -](\w)/g, (_, char) => char.toUpperCase());
+            acc[newKey] = value;
+            return acc;
+        }, {});
+        return Object.assign(Object.assign({}, normalized), providedArgs);
+    }
     parseCommandArgs(argsValues) {
         var args = {};
-        const commandOpts = this.command['_optionValues'] || {};
-        const commandArgs = this.command["_args"] || [];
+        const commandOpts = this.command ? this.command.opts() : {};
+        const commandArgs = this.metadata ? [...this.metadata.arguments].sort((a, b) => a.position - b.position) : [];
         commandArgs.forEach((a, i) => {
             if (typeof (argsValues[i]) === 'string') {
-                args[a.name()] = argsValues[i];
+                args[a.name] = argsValues[i];
             }
         });
-        args = Object.assign(Object.assign({}, commandOpts), args);
-        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;
+        return this.normalizeArgs(Object.assign(Object.assign({}, commandOpts), args));
     }
     validateOutputFileArg(argValue) {
         const resolvedPath = (0, path_1.resolve)(argValue);
@@ -366,11 +400,23 @@ class AbstractCommand {
             catch (_a) { }
         }
     }
+    run() {
+        return __awaiter(this, arguments, void 0, function* (args = {}) {
+            this.args = this.normalizeArgs(args);
+            this.onArgs();
+            yield this.executePrepared(false);
+        });
+    }
     execute(...args) {
         return __awaiter(this, void 0, void 0, function* () {
             this.args = this.parseCommandArgs(args);
             this.onArgs();
-            var exitCode;
+            const exitCode = yield this.executePrepared(true);
+            process.exit(exitCode);
+        });
+    }
+    executePrepared(logErrors) {
+        return __awaiter(this, void 0, void 0, function* () {
             try {
                 yield utils_1.GlobalContext.getInstance().load();
                 yield Commons.Plugin.call("client", "loadCore", { core: Core });
@@ -457,11 +503,14 @@ class AbstractCommand {
                 if (Commons.Logger.logger instanceof Commons.CliLogger || Commons.Logger.logger instanceof Commons.CliLogFileLogger) {
                     Commons.Logger.logger.forceStop();
                 }
-                exitCode = 0;
+                return 0;
             }
             catch (e) {
-                yield (0, utils_1.logError)(e);
-                exitCode = 1;
+                if (logErrors) {
+                    yield (0, utils_1.logError)(e);
+                    return 1;
+                }
+                throw e;
             }
             finally {
                 if (Core.SystemConnector.systemConnector) {
@@ -478,7 +527,6 @@ class AbstractCommand {
                     const logFilePath = Commons.Logger.logger.getFilePath();
                     Commons.Logger.info(`Saved log output "${logFilePath}" for session ID ${sessionId}.`);
                 }
-                process.exit(exitCode);
             }
         });
     }

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

@@ -1,6 +1,7 @@
 import { AbstractCommand } from "../AbstractCommand";
+import { CommandMetadata } from "../metadata/CommandMetadata";
 export declare class Alias extends AbstractCommand {
-    protected init(): void;
+    static readonly metadata: CommandMetadata[];
     private view;
     private check;
     private edit;

package/dist/command/implementations/Alias.js

@@ -15,20 +15,8 @@ const AbstractCommand_1 = require("../AbstractCommand");
 const prompts_1 = require("../prompts");
 const systemAlias_1 = require("../../systemAlias");
 const utils_1 = require("../../utils");
+const helpers_1 = require("../metadata/helpers");
 class Alias extends AbstractCommand_1.AbstractCommand {
-    init() {
-        if (this.subcommand === 'create') {
-            this.command.description(`Create a new system alias.`);
-            this.command.argument(`<alias>`, `Alias name.`);
-        }
-        else if (this.subcommand === 'delete') {
-            this.command.description(`Delete a system alias.`);
-            this.command.argument(`<alias>`, `Alias name.`);
-        }
-        else {
-            this.command.description(`Manage system aliases.`);
-        }
-    }
     view(alias) {
         const connection = utils_1.GlobalContext.getInstance().getConnections().find(o => o.name === alias.type);
         if (!connection) {
@@ -170,3 +158,46 @@ class Alias extends AbstractCommand_1.AbstractCommand {
     }
 }
 exports.Alias = Alias;
+Alias.metadata = [
+    {
+        id: "alias",
+        command: "alias",
+        title: "Manage aliases",
+        group: "system",
+        description: "Create, view, edit, check, or delete system aliases.",
+        icon: "Network",
+        arguments: [],
+        options: [],
+        requirements: {}
+    },
+    {
+        id: "alias:create",
+        command: "alias",
+        subcommand: "create",
+        title: "Create alias",
+        group: "system",
+        guiRelevant: false,
+        description: "Create a system alias.",
+        icon: "Network",
+        arguments: [
+            (0, helpers_1.argument)(0, { name: "alias", label: "Alias", description: "Name of the system alias." })
+        ],
+        options: [],
+        requirements: {}
+    },
+    {
+        id: "alias:delete",
+        command: "alias",
+        subcommand: "delete",
+        title: "Delete alias",
+        group: "system",
+        guiRelevant: false,
+        description: "Delete a system alias.",
+        icon: "Network",
+        arguments: [
+            (0, helpers_1.argument)(0, { name: "alias", label: "Alias", description: "Name of the system alias." })
+        ],
+        options: [],
+        requirements: {}
+    }
+];

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

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

package/dist/command/implementations/Cg3y.js

@@ -19,14 +19,8 @@ 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"));
+const helpers_1 = require("../metadata/helpers");
 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) {
@@ -47,3 +41,20 @@ class Cg3y extends AbstractCommand_1.AbstractCommand {
     }
 }
 exports.Cg3y = Cg3y;
+Cg3y.metadata = {
+    id: "cg3y",
+    command: "cg3y",
+    title: "Download transport",
+    group: "utility",
+    description: "Download a released transport from the connected system.",
+    icon: "Download",
+    arguments: [
+        (0, helpers_1.argument)(0, { name: "transport", label: "Transport", description: "Transport request number." }),
+        (0, helpers_1.argument)(1, { name: "filename", label: "Output file", description: "Output file name or path.", required: false, control: "file-picker" })
+    ],
+    options: [],
+    requirements: {
+        requiresConnection: true,
+        requiresTrmDependencies: true
+    }
+};

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

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

package/dist/command/implementations/Cg3z.js

@@ -16,14 +16,8 @@ const trm_core_1 = require("trm-core");
 const utils_1 = require("../../utils");
 const promises_1 = require("fs/promises");
 const path_1 = require("path");
+const helpers_1 = require("../metadata/helpers");
 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);
@@ -58,3 +52,20 @@ class Cg3z extends AbstractCommand_1.AbstractCommand {
     }
 }
 exports.Cg3z = Cg3z;
+Cg3z.metadata = {
+    id: "cg3z",
+    command: "cg3z",
+    title: "Upload transport",
+    group: "utility",
+    description: "Upload a released transport archive to the connected system.",
+    icon: "Upload",
+    arguments: [
+        (0, helpers_1.argument)(0, { name: "filename", label: "Transport archive", description: "Transport archive file name or path.", control: "file-picker" })
+    ],
+    options: [],
+    requirements: {
+        requiresConnection: true,
+        requiresTrmDependencies: true,
+        requiresR3trans: true
+    }
+};

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

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

package/dist/command/implementations/ClearCache.js

@@ -14,9 +14,6 @@ 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();
@@ -25,3 +22,14 @@ class ClearCache extends AbstractCommand_1.AbstractCommand {
     }
 }
 exports.ClearCache = ClearCache;
+ClearCache.metadata = {
+    id: "clear-cache",
+    command: "clear-cache",
+    title: "Clear cache",
+    group: "utility",
+    description: "Clear the client cache.",
+    icon: "Trash2",
+    arguments: [],
+    options: [],
+    requirements: {}
+};

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

@@ -1,7 +1,8 @@
 import { AbstractCommand } from "../AbstractCommand";
+import { CommandMetadata } from "../metadata/CommandMetadata";
 export declare class Compare extends AbstractCommand {
+    static readonly metadata: CommandMetadata;
     private connections;
-    protected init(): void;
     private promptConnections;
     protected handler(): Promise<void>;
 }

package/dist/command/implementations/Compare.js

@@ -15,18 +15,12 @@ const trm_core_1 = require("trm-core");
 const AbstractCommand_1 = require("../AbstractCommand");
 const systemAlias_1 = require("../../systemAlias");
 const prompts_1 = require("../prompts");
+const helpers_1 = require("../metadata/helpers");
 class Compare extends AbstractCommand_1.AbstractCommand {
     constructor() {
         super(...arguments);
         this.connections = [];
     }
-    init() {
-        this.registerOpts.requiresRegistry = true;
-        this.registerOpts.ignoreRegistryUnreachable = true;
-        this.command.description(`Compare a package between different systems.`);
-        this.command.argument(`<package>`, `Name of the package.`);
-        this.command.option(`-c, --connections <json>`, `Array of system connection aliases (JSON or path to JSON file).`);
-    }
     promptConnections() {
         return __awaiter(this, void 0, void 0, function* () {
             if (this.connections.length > 0) {
@@ -131,3 +125,22 @@ class Compare extends AbstractCommand_1.AbstractCommand {
     }
 }
 exports.Compare = Compare;
+Compare.metadata = {
+    id: "compare",
+    command: "compare",
+    title: "Compare package",
+    group: "package",
+    guiRelevant: false,
+    description: "Compare a package across multiple systems.",
+    icon: "GitCompare",
+    arguments: [
+        (0, helpers_1.argument)(0, { name: "package", label: "Package", description: "Package name." })
+    ],
+    options: [
+        (0, helpers_1.option)("-c, --connections <json>", { name: "connections", label: "Connections", description: "System connection aliases as JSON, or a path to a JSON file.", control: "textarea" })
+    ],
+    requirements: {
+        requiresRegistry: true,
+        ignoreRegistryUnreachable: true
+    }
+};

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

@@ -1,5 +1,6 @@
 import { AbstractCommand } from "../AbstractCommand";
+import { CommandMetadata } from "../metadata/CommandMetadata";
 export declare class Content extends AbstractCommand {
-    protected init(): void;
+    static readonly metadata: CommandMetadata;
     protected handler(): Promise<void>;
 }

package/dist/command/implementations/Content.js

@@ -17,16 +17,8 @@ const trm_commons_1 = require("trm-commons");
 const AbstractCommand_1 = require("../AbstractCommand");
 const utils_1 = require("../../utils");
 const chalk_1 = __importDefault(require("chalk"));
+const helpers_1 = require("../metadata/helpers");
 class Content extends AbstractCommand_1.AbstractCommand {
-    init() {
-        this.registerOpts.requiresRegistry = true;
-        this.registerOpts.requiresR3trans = true;
-        this.command.description(`Extract and list content of a package.`);
-        this.command.addHelpText(`before`, `This command has no effect when trying to login into a registry that doesn't require authentication.`);
-        this.command.argument(`<package>`, `Name of the package.`);
-        this.command.argument(`[version]`, `Version or tag of the package`, 'latest');
-        this.command.option(`--full`, `Show all transport entries of the package`, false);
-    }
     handler() {
         return __awaiter(this, void 0, void 0, function* () {
             var transports = {};
@@ -193,3 +185,23 @@ class Content extends AbstractCommand_1.AbstractCommand {
     }
 }
 exports.Content = Content;
+Content.metadata = {
+    id: "content",
+    command: "content",
+    aliases: ["contents"],
+    title: "Package content",
+    group: "registry",
+    description: "View the contents of a package release in registry.",
+    icon: "ListTree",
+    arguments: [
+        (0, helpers_1.argument)(0, { name: "package", label: "Package", description: "Package name." }),
+        (0, helpers_1.argument)(1, { name: "version", label: "Version", description: "Package version or distribution tag.", required: false, defaultValue: "latest" })
+    ],
+    options: [
+        (0, helpers_1.option)("--full", { name: "full", label: "Full content", description: "Show all transport entries in the package.", control: "checkbox", defaultValue: false })
+    ],
+    requirements: {
+        requiresRegistry: true,
+        requiresR3trans: true
+    }
+};

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

@@ -1,5 +1,6 @@
 import { AbstractCommand } from "../AbstractCommand";
+import { CommandMetadata } from "../metadata/CommandMetadata";
 export declare class Deprecate extends AbstractCommand {
-    protected init(): void;
+    static readonly metadata: CommandMetadata;
     protected handler(): Promise<void>;
 }