trm-client 9.4.1 → 10.0.1

package/changelog.txt

@@ -8,6 +8,25 @@ Legend
 + : added
 - : removed
 
+2026-07-06 v10.0.1
+-------------------
++ picker type in metadata
++ custom pickers in metadata
++ negated in metadata
+! commands gui relevance, icons and grouping
+
+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/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,47 @@ class Alias extends AbstractCommand_1.AbstractCommand {
     }
 }
 exports.Alias = Alias;
+Alias.metadata = [
+    {
+        id: "alias",
+        command: "alias",
+        title: "Manage aliases",
+        group: "system",
+        guiRelevant: false,
+        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,21 @@ class Cg3y extends AbstractCommand_1.AbstractCommand {
     }
 }
 exports.Cg3y = Cg3y;
+Cg3y.metadata = {
+    id: "cg3y",
+    command: "cg3y",
+    title: "Download transport",
+    group: "utility",
+    groupPriority: 8,
+    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", pickerType: "output" })
+    ],
+    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,21 @@ class Cg3z extends AbstractCommand_1.AbstractCommand {
     }
 }
 exports.Cg3z = Cg3z;
+Cg3z.metadata = {
+    id: "cg3z",
+    command: "cg3z",
+    title: "Upload transport",
+    group: "utility",
+    groupPriority: 7,
+    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", pickerType: "input" })
+    ],
+    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,24 @@ class Content extends AbstractCommand_1.AbstractCommand {
     }
 }
 exports.Content = Content;
+Content.metadata = {
+    id: "content",
+    command: "content",
+    aliases: ["contents"],
+    title: "Package content",
+    group: "registry",
+    groupPriority: 7,
+    description: "View the contents of a package release in registry.",
+    icon: "FolderTree",
+    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>;
 }

package/dist/command/implementations/Deprecate.js

@@ -12,14 +12,8 @@ Object.defineProperty(exports, "__esModule", { value: true });
 exports.Deprecate = void 0;
 const trm_commons_1 = require("trm-commons");
 const AbstractCommand_1 = require("../AbstractCommand");
+const helpers_1 = require("../metadata/helpers");
 class Deprecate extends AbstractCommand_1.AbstractCommand {
-    init() {
-        this.registerOpts.requiresRegistry = true;
-        this.command.description(`Deprecate a package release from registry.`);
-        this.command.argument(`<package>`, `Name of the package.`);
-        this.command.argument(`<version>`, `Version of the release.`);
-        this.command.option(`--note <note>`, `Deprecation note`);
-    }
     handler() {
         return __awaiter(this, void 0, void 0, function* () {
             if (!this.args.note) {
@@ -33,3 +27,21 @@ class Deprecate extends AbstractCommand_1.AbstractCommand {
     }
 }
 exports.Deprecate = Deprecate;
+Deprecate.metadata = {
+    id: "deprecate",
+    command: "deprecate",
+    title: "Deprecate release",
+    group: "registry",
+    description: "Deprecate a package release in the registry.",
+    icon: "ArchiveX",
+    arguments: [
+        (0, helpers_1.argument)(0, { name: "package", label: "Package", description: "Package name." }),
+        (0, helpers_1.argument)(1, { name: "version", label: "Version", description: "Release version." })
+    ],
+    options: [
+        (0, helpers_1.option)("--note <note>", { name: "note", label: "Deprecation note", description: "Message shown for the deprecated release." })
+    ],
+    requirements: {
+        requiresRegistry: true
+    }
+};

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

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

package/dist/command/implementations/Dirty.js

@@ -17,15 +17,8 @@ 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"));
+const helpers_1 = require("../metadata/helpers");
 class Dirty extends AbstractCommand_1.AbstractCommand {
-    init() {
-        this.registerOpts.requiresConnection = true;
-        this.registerOpts.requiresRegistry = true;
-        this.registerOpts.ignoreRegistryUnreachable = true;
-        this.command.description(`Show local objetcs that flagged a package as dirty.`);
-        this.command.argument(`<package>`, `Name of the dirty package to check.`);
-        this.command.option(`--latest-only`, `Show only the latest transports with changes`, false);
-    }
     keepFirstByKey(entries) {
         const seen = new Set();
         return entries.filter(entry => {
@@ -78,3 +71,23 @@ class Dirty extends AbstractCommand_1.AbstractCommand {
     }
 }
 exports.Dirty = Dirty;
+Dirty.metadata = {
+    id: "dirty",
+    command: "dirty",
+    title: "Show dirty entries",
+    group: "package",
+    guiRelevant: false,
+    description: "Show objects that caused a package to be marked as dirty.",
+    icon: "TriangleAlert",
+    arguments: [
+        (0, helpers_1.argument)(0, { name: "package", label: "Package", description: "Package to inspect." })
+    ],
+    options: [
+        (0, helpers_1.option)("--latest-only", { name: "latestOnly", label: "Latest only", description: "Show only the latest transports that contain changes.", control: "checkbox", defaultValue: false })
+    ],
+    requirements: {
+        requiresConnection: true,
+        requiresRegistry: true,
+        ignoreRegistryUnreachable: true
+    }
+};