@navios/commander 1.6.0 → 1.8.0

package/lib/{help-command.token-DamE31Aw.cjs → help-command.token-BI5XnE07.cjs}

@@ -358,15 +358,40 @@ var CommandRegistryService = class {
 			try {
 				const shape = metadata.optionsSchema.def.shape;
 				if (shape && typeof shape === "object") for (const [key, fieldSchema] of Object.entries(shape)) {
-					const optionFlag = `--${key.replace(/([A-Z])/g, "-$1").toLowerCase()}`;
+					const kebabKey = key.replace(/([A-Z])/g, "-$1").toLowerCase();
+					const optionFlag = `--${kebabKey}`;
 					const fieldType = this.getSchemaTypeName(fieldSchema);
 					lines.push(`  ${optionFlag.padEnd(20)} ${fieldType}`);
+					this.formatNestedObjectOptions(fieldSchema, kebabKey, lines, "    ");
 				}
 			} catch {}
 		}
 		return lines.join("\n");
 	}
 	/**
+	* Recursively formats nested object options for help display.
+	* Shows nested fields with dot notation (e.g., --config.port)
+	*/ formatNestedObjectOptions(schema, parentPath, lines, indent) {
+		try {
+			let currentSchema = schema;
+			let typeName = currentSchema?.def?.type;
+			while (typeName === "optional" || typeName === "default") {
+				currentSchema = currentSchema?.def?.innerType;
+				typeName = currentSchema?.def?.type;
+			}
+			if (typeName !== "object") return;
+			const shape = currentSchema?.def?.shape;
+			if (!shape || typeof shape !== "object") return;
+			for (const [key, fieldSchema] of Object.entries(shape)) {
+				const kebabKey = key.replace(/([A-Z])/g, "-$1").toLowerCase();
+				const optionFlag = `--${parentPath}.${kebabKey}`;
+				const fieldType = this.getSchemaTypeName(fieldSchema);
+				lines.push(`${indent}${optionFlag.padEnd(20 - indent.length + 2)} ${fieldType}`);
+				this.formatNestedObjectOptions(fieldSchema, `${parentPath}.${kebabKey}`, lines, indent + "  ");
+			}
+		} catch {}
+	}
+	/**
 	* Gets a human-readable type name from a zod/v4 schema.
 	*/ getSchemaTypeName(schema) {
 		try {
@@ -409,6 +434,14 @@ var CommandRegistryService = class {
 		}
 	}
 	/**
+	* Get all registered command paths.
+	* Useful for smart command detection in argv parsing.
+	*
+	* @returns Array of command paths
+	*/ getAllPaths() {
+		return Array.from(this.commands.keys());
+	}
+	/**
 	* Clear all registered commands.
 	*/ clear() {
 		this.commands.clear();
@@ -435,4 +468,4 @@ Object.defineProperty(exports, '_CommandRegistryService', {
     return _CommandRegistryService;
   }
 });
-//# sourceMappingURL=help-command.token-DamE31Aw.cjs.map
+//# sourceMappingURL=help-command.token-BI5XnE07.cjs.map

package/lib/help-command.token-BI5XnE07.cjs.map

@@ -0,0 +1 @@
+{"version":3,"file":"help-command.token-BI5XnE07.cjs","names":["Injectable","CommandRegistryService","commands","Map","register","path","command","has","Error","set","getByPath","get","getAll","getAllAsArray","result","class","cls","push","formatCommandList","lines","metadata","description","padEnd","join","formatCommandHelp","commandPath","optionsSchema","shape","def","key","fieldSchema","Object","entries","kebabKey","replace","toLowerCase","optionFlag","fieldType","getSchemaTypeName","formatNestedObjectOptions","schema","parentPath","indent","currentSchema","typeName","type","innerType","length","isOptional","defaultValue","undefined","JSON","stringify","getSchemaMeta","directMeta","meta","getAllPaths","Array","from","keys","clear","InjectionToken","HelpCommandToken","create"],"sources":["../src/services/command-registry.service.mts","../src/tokens/help-command.token.mts"],"sourcesContent":["import { Injectable } from '@navios/core'\n\nimport type { ClassType } from '@navios/core'\n\nimport type { CommandMetadata } from '../metadata/index.mjs'\n\n/**\n * Represents a registered command with its metadata and module information.\n *\n * @public\n */\nexport interface RegisteredCommand {\n  /**\n   * The command class\n   */\n  class: ClassType\n  /**\n   * The command metadata from @Command decorator\n   */\n  metadata: CommandMetadata\n  /**\n   * Name of the module this command belongs to\n   */\n  moduleName: string\n}\n\n/**\n * Service for registering and looking up CLI commands.\n * Used internally by the CLI adapter to manage discovered commands.\n *\n * @public\n */\n@Injectable()\nexport class CommandRegistryService {\n  private commands = new Map<string, RegisteredCommand>()\n\n  /**\n   * Register a command with its metadata.\n   *\n   * @param path - The command path (e.g., 'greet', 'user:create')\n   * @param command - The registered command data\n   * @throws Error if a command with the same path is already registered\n   */\n  register(path: string, command: RegisteredCommand): void {\n    if (this.commands.has(path)) {\n      throw new Error(`[Navios Commander] Duplicate command path: ${path}`)\n    }\n    this.commands.set(path, command)\n  }\n\n  /**\n   * Get a command by its path.\n   *\n   * @param path - The command path\n   * @returns The registered command or undefined if not found\n   */\n  getByPath(path: string): RegisteredCommand | undefined {\n    return this.commands.get(path)\n  }\n\n  /**\n   * Get all registered commands.\n   *\n   * @returns Map of path to registered command\n   */\n  getAll(): Map<string, RegisteredCommand> {\n    return new Map(this.commands)\n  }\n\n  /**\n   * Get all registered commands as an array of path and class pairs.\n   * Useful for listing available commands.\n   *\n   * @returns Array of objects containing path and class\n   */\n  getAllAsArray(): Array<{ path: string; class: ClassType }> {\n    const result: Array<{ path: string; class: ClassType }> = []\n    for (const [path, { class: cls }] of this.commands) {\n      result.push({ path, class: cls })\n    }\n    return result\n  }\n\n  /**\n   * Formats help text listing all available commands with descriptions.\n   *\n   * @returns Formatted string listing all commands\n   */\n  formatCommandList(): string {\n    const lines = ['Available commands:', '']\n    for (const [path, { metadata }] of this.commands) {\n      const description = metadata.description\n      if (description) {\n        lines.push(`  ${path.padEnd(20)} ${description}`)\n      } else {\n        lines.push(`  ${path}`)\n      }\n    }\n    return lines.join('\\n')\n  }\n\n  /**\n   * Formats help text for a specific command.\n   *\n   * @param commandPath - The command path to show help for\n   * @returns Formatted string with command help\n   */\n  formatCommandHelp(commandPath: string): string {\n    const command = this.commands.get(commandPath)\n    if (!command) {\n      return `Unknown command: ${commandPath}\\n\\n${this.formatCommandList()}`\n    }\n\n    const { metadata } = command\n    const lines: string[] = []\n\n    lines.push(`Usage: ${metadata.path} [options]`)\n    lines.push('')\n\n    if (metadata.description) {\n      lines.push(metadata.description)\n      lines.push('')\n    }\n\n    // Extract options from schema if available\n    if (metadata.optionsSchema) {\n      lines.push('Options:')\n      try {\n        const shape = metadata.optionsSchema.def.shape\n        if (shape && typeof shape === 'object') {\n          for (const [key, fieldSchema] of Object.entries(shape)) {\n            const kebabKey = key.replace(/([A-Z])/g, '-$1').toLowerCase()\n            const optionFlag = `--${kebabKey}`\n            const fieldType = this.getSchemaTypeName(fieldSchema as any)\n            lines.push(`  ${optionFlag.padEnd(20)} ${fieldType}`)\n\n            // Check for nested object fields and display them with dot notation\n            this.formatNestedObjectOptions(fieldSchema as any, kebabKey, lines, '    ')\n          }\n        }\n      } catch {\n        // Schema introspection failed, skip options\n      }\n    }\n\n    return lines.join('\\n')\n  }\n\n  /**\n   * Recursively formats nested object options for help display.\n   * Shows nested fields with dot notation (e.g., --config.port)\n   */\n  private formatNestedObjectOptions(\n    schema: any,\n    parentPath: string,\n    lines: string[],\n    indent: string,\n  ): void {\n    try {\n      let currentSchema = schema\n      let typeName = currentSchema?.def?.type\n\n      // Unwrap optional/default wrappers\n      while (typeName === 'optional' || typeName === 'default') {\n        currentSchema = currentSchema?.def?.innerType\n        typeName = currentSchema?.def?.type\n      }\n\n      if (typeName !== 'object') {\n        return\n      }\n\n      const shape = currentSchema?.def?.shape\n      if (!shape || typeof shape !== 'object') {\n        return\n      }\n\n      for (const [key, fieldSchema] of Object.entries(shape)) {\n        const kebabKey = key.replace(/([A-Z])/g, '-$1').toLowerCase()\n        const optionFlag = `--${parentPath}.${kebabKey}`\n        const fieldType = this.getSchemaTypeName(fieldSchema as any)\n        lines.push(`${indent}${optionFlag.padEnd(20 - indent.length + 2)} ${fieldType}`)\n\n        // Recurse for deeper nesting\n        this.formatNestedObjectOptions(\n          fieldSchema as any,\n          `${parentPath}.${kebabKey}`,\n          lines,\n          indent + '  ',\n        )\n      }\n    } catch {\n      // Silently fail if schema introspection fails\n    }\n  }\n\n  /**\n   * Gets a human-readable type name from a zod/v4 schema.\n   */\n  private getSchemaTypeName(schema: any): string {\n    try {\n      let currentSchema = schema\n      let typeName = currentSchema?.def?.type\n      let isOptional = false\n      let defaultValue: any\n\n      // Unwrap optional/default wrappers\n      while (typeName === 'optional' || typeName === 'default') {\n        if (typeName === 'optional') {\n          isOptional = true\n        }\n        if (typeName === 'default') {\n          isOptional = true\n          defaultValue = currentSchema?.def?.defaultValue?.()\n        }\n        currentSchema = currentSchema?.def?.innerType\n        typeName = currentSchema?.def?.type\n      }\n\n      let result = `<${typeName || 'unknown'}>`\n      if (defaultValue !== undefined) {\n        result += ` (default: ${JSON.stringify(defaultValue)})`\n      } else if (isOptional) {\n        result += ' (optional)'\n      }\n\n      // Get description from meta() if available\n      const description = this.getSchemaMeta(schema)?.description\n      if (description) {\n        result += ` - ${description}`\n      }\n\n      return result\n    } catch {\n      return '<unknown>'\n    }\n  }\n\n  /**\n   * Gets metadata from a zod/v4 schema, traversing innerType if needed.\n   * zod/v4 v4 stores meta at the outermost layer when .meta() is called last,\n   * or in innerType when .meta() is called before .optional()/.default().\n   */\n  private getSchemaMeta(schema: any): Record<string, unknown> | undefined {\n    try {\n      // First check direct meta (when .meta() is called last in chain)\n      const directMeta = schema.meta?.()\n      if (directMeta) return directMeta\n\n      // Check innerType for wrapped schemas (optional, default, etc.)\n      const innerType = schema.def?.innerType\n      if (innerType) {\n        return this.getSchemaMeta(innerType)\n      }\n\n      return undefined\n    } catch {\n      return undefined\n    }\n  }\n\n  /**\n   * Get all registered command paths.\n   * Useful for smart command detection in argv parsing.\n   *\n   * @returns Array of command paths\n   */\n  getAllPaths(): string[] {\n    return Array.from(this.commands.keys())\n  }\n\n  /**\n   * Clear all registered commands.\n   */\n  clear(): void {\n    this.commands.clear()\n  }\n}\n","import { InjectionToken } from '@navios/core'\n\nimport type { HelpCommand } from '../overrides/help.command.mjs'\n\nexport const HelpCommandToken = InjectionToken.create<HelpCommand>('HelpCommand')\n"],"mappings":"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"}

package/lib/{help-command.token-XHx3WkoD.mjs → help-command.token-D81bRnnl.mjs}

@@ -358,15 +358,40 @@ var CommandRegistryService = class {
 			try {
 				const shape = metadata.optionsSchema.def.shape;
 				if (shape && typeof shape === "object") for (const [key, fieldSchema] of Object.entries(shape)) {
-					const optionFlag = `--${key.replace(/([A-Z])/g, "-$1").toLowerCase()}`;
+					const kebabKey = key.replace(/([A-Z])/g, "-$1").toLowerCase();
+					const optionFlag = `--${kebabKey}`;
 					const fieldType = this.getSchemaTypeName(fieldSchema);
 					lines.push(`  ${optionFlag.padEnd(20)} ${fieldType}`);
+					this.formatNestedObjectOptions(fieldSchema, kebabKey, lines, "    ");
 				}
 			} catch {}
 		}
 		return lines.join("\n");
 	}
 	/**
+	* Recursively formats nested object options for help display.
+	* Shows nested fields with dot notation (e.g., --config.port)
+	*/ formatNestedObjectOptions(schema, parentPath, lines, indent) {
+		try {
+			let currentSchema = schema;
+			let typeName = currentSchema?.def?.type;
+			while (typeName === "optional" || typeName === "default") {
+				currentSchema = currentSchema?.def?.innerType;
+				typeName = currentSchema?.def?.type;
+			}
+			if (typeName !== "object") return;
+			const shape = currentSchema?.def?.shape;
+			if (!shape || typeof shape !== "object") return;
+			for (const [key, fieldSchema] of Object.entries(shape)) {
+				const kebabKey = key.replace(/([A-Z])/g, "-$1").toLowerCase();
+				const optionFlag = `--${parentPath}.${kebabKey}`;
+				const fieldType = this.getSchemaTypeName(fieldSchema);
+				lines.push(`${indent}${optionFlag.padEnd(20 - indent.length + 2)} ${fieldType}`);
+				this.formatNestedObjectOptions(fieldSchema, `${parentPath}.${kebabKey}`, lines, indent + "  ");
+			}
+		} catch {}
+	}
+	/**
 	* Gets a human-readable type name from a zod/v4 schema.
 	*/ getSchemaTypeName(schema) {
 		try {
@@ -409,6 +434,14 @@ var CommandRegistryService = class {
 		}
 	}
 	/**
+	* Get all registered command paths.
+	* Useful for smart command detection in argv parsing.
+	*
+	* @returns Array of command paths
+	*/ getAllPaths() {
+		return Array.from(this.commands.keys());
+	}
+	/**
 	* Clear all registered commands.
 	*/ clear() {
 		this.commands.clear();
@@ -424,4 +457,4 @@ const HelpCommandToken = InjectionToken.create("HelpCommand");
 
 //#endregion
 export { _CommandRegistryService as n, HelpCommandToken as t };
-//# sourceMappingURL=help-command.token-XHx3WkoD.mjs.map
+//# sourceMappingURL=help-command.token-D81bRnnl.mjs.map

package/lib/help-command.token-D81bRnnl.mjs.map

@@ -0,0 +1 @@
+{"version":3,"file":"help-command.token-D81bRnnl.mjs","names":["Injectable","CommandRegistryService","commands","Map","register","path","command","has","Error","set","getByPath","get","getAll","getAllAsArray","result","class","cls","push","formatCommandList","lines","metadata","description","padEnd","join","formatCommandHelp","commandPath","optionsSchema","shape","def","key","fieldSchema","Object","entries","kebabKey","replace","toLowerCase","optionFlag","fieldType","getSchemaTypeName","formatNestedObjectOptions","schema","parentPath","indent","currentSchema","typeName","type","innerType","length","isOptional","defaultValue","undefined","JSON","stringify","getSchemaMeta","directMeta","meta","getAllPaths","Array","from","keys","clear","InjectionToken","HelpCommandToken","create"],"sources":["../src/services/command-registry.service.mts","../src/tokens/help-command.token.mts"],"sourcesContent":["import { Injectable } from '@navios/core'\n\nimport type { ClassType } from '@navios/core'\n\nimport type { CommandMetadata } from '../metadata/index.mjs'\n\n/**\n * Represents a registered command with its metadata and module information.\n *\n * @public\n */\nexport interface RegisteredCommand {\n  /**\n   * The command class\n   */\n  class: ClassType\n  /**\n   * The command metadata from @Command decorator\n   */\n  metadata: CommandMetadata\n  /**\n   * Name of the module this command belongs to\n   */\n  moduleName: string\n}\n\n/**\n * Service for registering and looking up CLI commands.\n * Used internally by the CLI adapter to manage discovered commands.\n *\n * @public\n */\n@Injectable()\nexport class CommandRegistryService {\n  private commands = new Map<string, RegisteredCommand>()\n\n  /**\n   * Register a command with its metadata.\n   *\n   * @param path - The command path (e.g., 'greet', 'user:create')\n   * @param command - The registered command data\n   * @throws Error if a command with the same path is already registered\n   */\n  register(path: string, command: RegisteredCommand): void {\n    if (this.commands.has(path)) {\n      throw new Error(`[Navios Commander] Duplicate command path: ${path}`)\n    }\n    this.commands.set(path, command)\n  }\n\n  /**\n   * Get a command by its path.\n   *\n   * @param path - The command path\n   * @returns The registered command or undefined if not found\n   */\n  getByPath(path: string): RegisteredCommand | undefined {\n    return this.commands.get(path)\n  }\n\n  /**\n   * Get all registered commands.\n   *\n   * @returns Map of path to registered command\n   */\n  getAll(): Map<string, RegisteredCommand> {\n    return new Map(this.commands)\n  }\n\n  /**\n   * Get all registered commands as an array of path and class pairs.\n   * Useful for listing available commands.\n   *\n   * @returns Array of objects containing path and class\n   */\n  getAllAsArray(): Array<{ path: string; class: ClassType }> {\n    const result: Array<{ path: string; class: ClassType }> = []\n    for (const [path, { class: cls }] of this.commands) {\n      result.push({ path, class: cls })\n    }\n    return result\n  }\n\n  /**\n   * Formats help text listing all available commands with descriptions.\n   *\n   * @returns Formatted string listing all commands\n   */\n  formatCommandList(): string {\n    const lines = ['Available commands:', '']\n    for (const [path, { metadata }] of this.commands) {\n      const description = metadata.description\n      if (description) {\n        lines.push(`  ${path.padEnd(20)} ${description}`)\n      } else {\n        lines.push(`  ${path}`)\n      }\n    }\n    return lines.join('\\n')\n  }\n\n  /**\n   * Formats help text for a specific command.\n   *\n   * @param commandPath - The command path to show help for\n   * @returns Formatted string with command help\n   */\n  formatCommandHelp(commandPath: string): string {\n    const command = this.commands.get(commandPath)\n    if (!command) {\n      return `Unknown command: ${commandPath}\\n\\n${this.formatCommandList()}`\n    }\n\n    const { metadata } = command\n    const lines: string[] = []\n\n    lines.push(`Usage: ${metadata.path} [options]`)\n    lines.push('')\n\n    if (metadata.description) {\n      lines.push(metadata.description)\n      lines.push('')\n    }\n\n    // Extract options from schema if available\n    if (metadata.optionsSchema) {\n      lines.push('Options:')\n      try {\n        const shape = metadata.optionsSchema.def.shape\n        if (shape && typeof shape === 'object') {\n          for (const [key, fieldSchema] of Object.entries(shape)) {\n            const kebabKey = key.replace(/([A-Z])/g, '-$1').toLowerCase()\n            const optionFlag = `--${kebabKey}`\n            const fieldType = this.getSchemaTypeName(fieldSchema as any)\n            lines.push(`  ${optionFlag.padEnd(20)} ${fieldType}`)\n\n            // Check for nested object fields and display them with dot notation\n            this.formatNestedObjectOptions(fieldSchema as any, kebabKey, lines, '    ')\n          }\n        }\n      } catch {\n        // Schema introspection failed, skip options\n      }\n    }\n\n    return lines.join('\\n')\n  }\n\n  /**\n   * Recursively formats nested object options for help display.\n   * Shows nested fields with dot notation (e.g., --config.port)\n   */\n  private formatNestedObjectOptions(\n    schema: any,\n    parentPath: string,\n    lines: string[],\n    indent: string,\n  ): void {\n    try {\n      let currentSchema = schema\n      let typeName = currentSchema?.def?.type\n\n      // Unwrap optional/default wrappers\n      while (typeName === 'optional' || typeName === 'default') {\n        currentSchema = currentSchema?.def?.innerType\n        typeName = currentSchema?.def?.type\n      }\n\n      if (typeName !== 'object') {\n        return\n      }\n\n      const shape = currentSchema?.def?.shape\n      if (!shape || typeof shape !== 'object') {\n        return\n      }\n\n      for (const [key, fieldSchema] of Object.entries(shape)) {\n        const kebabKey = key.replace(/([A-Z])/g, '-$1').toLowerCase()\n        const optionFlag = `--${parentPath}.${kebabKey}`\n        const fieldType = this.getSchemaTypeName(fieldSchema as any)\n        lines.push(`${indent}${optionFlag.padEnd(20 - indent.length + 2)} ${fieldType}`)\n\n        // Recurse for deeper nesting\n        this.formatNestedObjectOptions(\n          fieldSchema as any,\n          `${parentPath}.${kebabKey}`,\n          lines,\n          indent + '  ',\n        )\n      }\n    } catch {\n      // Silently fail if schema introspection fails\n    }\n  }\n\n  /**\n   * Gets a human-readable type name from a zod/v4 schema.\n   */\n  private getSchemaTypeName(schema: any): string {\n    try {\n      let currentSchema = schema\n      let typeName = currentSchema?.def?.type\n      let isOptional = false\n      let defaultValue: any\n\n      // Unwrap optional/default wrappers\n      while (typeName === 'optional' || typeName === 'default') {\n        if (typeName === 'optional') {\n          isOptional = true\n        }\n        if (typeName === 'default') {\n          isOptional = true\n          defaultValue = currentSchema?.def?.defaultValue?.()\n        }\n        currentSchema = currentSchema?.def?.innerType\n        typeName = currentSchema?.def?.type\n      }\n\n      let result = `<${typeName || 'unknown'}>`\n      if (defaultValue !== undefined) {\n        result += ` (default: ${JSON.stringify(defaultValue)})`\n      } else if (isOptional) {\n        result += ' (optional)'\n      }\n\n      // Get description from meta() if available\n      const description = this.getSchemaMeta(schema)?.description\n      if (description) {\n        result += ` - ${description}`\n      }\n\n      return result\n    } catch {\n      return '<unknown>'\n    }\n  }\n\n  /**\n   * Gets metadata from a zod/v4 schema, traversing innerType if needed.\n   * zod/v4 v4 stores meta at the outermost layer when .meta() is called last,\n   * or in innerType when .meta() is called before .optional()/.default().\n   */\n  private getSchemaMeta(schema: any): Record<string, unknown> | undefined {\n    try {\n      // First check direct meta (when .meta() is called last in chain)\n      const directMeta = schema.meta?.()\n      if (directMeta) return directMeta\n\n      // Check innerType for wrapped schemas (optional, default, etc.)\n      const innerType = schema.def?.innerType\n      if (innerType) {\n        return this.getSchemaMeta(innerType)\n      }\n\n      return undefined\n    } catch {\n      return undefined\n    }\n  }\n\n  /**\n   * Get all registered command paths.\n   * Useful for smart command detection in argv parsing.\n   *\n   * @returns Array of command paths\n   */\n  getAllPaths(): string[] {\n    return Array.from(this.commands.keys())\n  }\n\n  /**\n   * Clear all registered commands.\n   */\n  clear(): void {\n    this.commands.clear()\n  }\n}\n","import { InjectionToken } from '@navios/core'\n\nimport type { HelpCommand } from '../overrides/help.command.mjs'\n\nexport const HelpCommandToken = InjectionToken.create<HelpCommand>('HelpCommand')\n"],"mappings":"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"}

package/lib/{help.command-Bynoll_7.mjs → help.command-B14cbwE_.mjs}

@@ -1,5 +1,5 @@
 import { t as Command } from "./command.decorator-QiRU7ny3.mjs";
-import { n as _CommandRegistryService, t as HelpCommandToken } from "./help-command.token-XHx3WkoD.mjs";
+import { n as _CommandRegistryService, t as HelpCommandToken } from "./help-command.token-D81bRnnl.mjs";
 import { inject } from "@navios/core";
 import { z } from "zod/v4";
 import { ScreenLogger } from "@navios/commander-tui";
@@ -312,4 +312,4 @@ var HelpCommand = class {
 
 //#endregion
 export {  };
-//# sourceMappingURL=help.command-Bynoll_7.mjs.map
+//# sourceMappingURL=help.command-B14cbwE_.mjs.map

package/lib/{help.command-Bynoll_7.mjs.map → help.command-B14cbwE_.mjs.map}

@@ -1 +1 @@
-{"version":3,"file":"help.command-Bynoll_7.mjs","names":["ScreenLogger","inject","z","Command","CommandRegistryService","HelpCommandToken","helpOptionsSchema","object","command","string","optional","token","path","description","optionsSchema","priority","HelpCommand","logger","screen","context","commandRegistry","execute","options","log","formatCommandHelp","formatCommandList"],"sources":["../src/overrides/help.command.mts"],"sourcesContent":["import { ScreenLogger } from '@navios/commander-tui'\nimport { inject } from '@navios/core'\nimport { z } from 'zod/v4'\n\nimport { Command } from '../decorators/command.decorator.mjs'\nimport { CommandRegistryService } from '../services/command-registry.service.mjs'\nimport { HelpCommandToken } from '../tokens/help-command.token.mjs'\n\nimport type { CommandHandler } from '../interfaces/command-handler.interface.mjs'\n\nconst helpOptionsSchema = z.object({\n  command: z.string().optional(),\n})\n\ntype HelpOptions = z.infer<typeof helpOptionsSchema>\n\n/**\n * Built-in help command that lists all available commands or shows help for a specific command.\n *\n * @public\n */\n@Command({\n  token: HelpCommandToken,\n  path: 'help',\n  description: 'Show available commands or help for a specific command',\n  optionsSchema: helpOptionsSchema,\n  priority: 1000,\n})\nexport class HelpCommand implements CommandHandler<HelpOptions> {\n  private logger = inject(ScreenLogger, { screen: 'Help', context: 'Help' })\n  private commandRegistry = inject(CommandRegistryService)\n\n  async execute(options: HelpOptions): Promise<void> {\n    if (options.command) {\n      this.logger.log(this.commandRegistry.formatCommandHelp(options.command))\n    } else {\n      this.logger.log(this.commandRegistry.formatCommandList())\n    }\n  }\n}\n"],"mappings":";;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;AAUA,MAAMM,oBAAoBJ,EAAEK,OAAO,EACjCC,SAASN,EAAEO,QAAM,CAAGC,UAAQ,EAC9B,CAAA;;OASCP,QAAQ;CACPQ,OAAON;CACPO,MAAM;CACNC,aAAa;CACbC,eAAeR;CACfS,UAAU;CACZ,CAAA;AACO,IAAMC,cAAN,MAAMA;;;;CACHC,SAAShB,OAAOD,cAAc;EAAEkB,QAAQ;EAAQC,SAAS;EAAO,CAAA;CAChEC,kBAAkBnB,OAAOG,wBAAAA;CAEjC,MAAMiB,QAAQC,SAAqC;AACjD,MAAIA,QAAQd,QACV,MAAKS,OAAOM,IAAI,KAAKH,gBAAgBI,kBAAkBF,QAAQd,QAAO,CAAA;MAEtE,MAAKS,OAAOM,IAAI,KAAKH,gBAAgBK,mBAAiB,CAAA"}
+{"version":3,"file":"help.command-B14cbwE_.mjs","names":["ScreenLogger","inject","z","Command","CommandRegistryService","HelpCommandToken","helpOptionsSchema","object","command","string","optional","token","path","description","optionsSchema","priority","HelpCommand","logger","screen","context","commandRegistry","execute","options","log","formatCommandHelp","formatCommandList"],"sources":["../src/overrides/help.command.mts"],"sourcesContent":["import { ScreenLogger } from '@navios/commander-tui'\nimport { inject } from '@navios/core'\nimport { z } from 'zod/v4'\n\nimport { Command } from '../decorators/command.decorator.mjs'\nimport { CommandRegistryService } from '../services/command-registry.service.mjs'\nimport { HelpCommandToken } from '../tokens/help-command.token.mjs'\n\nimport type { CommandHandler } from '../interfaces/command-handler.interface.mjs'\n\nconst helpOptionsSchema = z.object({\n  command: z.string().optional(),\n})\n\ntype HelpOptions = z.infer<typeof helpOptionsSchema>\n\n/**\n * Built-in help command that lists all available commands or shows help for a specific command.\n *\n * @public\n */\n@Command({\n  token: HelpCommandToken,\n  path: 'help',\n  description: 'Show available commands or help for a specific command',\n  optionsSchema: helpOptionsSchema,\n  priority: 1000,\n})\nexport class HelpCommand implements CommandHandler<HelpOptions> {\n  private logger = inject(ScreenLogger, { screen: 'Help', context: 'Help' })\n  private commandRegistry = inject(CommandRegistryService)\n\n  async execute(options: HelpOptions): Promise<void> {\n    if (options.command) {\n      this.logger.log(this.commandRegistry.formatCommandHelp(options.command))\n    } else {\n      this.logger.log(this.commandRegistry.formatCommandList())\n    }\n  }\n}\n"],"mappings":";;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;AAUA,MAAMM,oBAAoBJ,EAAEK,OAAO,EACjCC,SAASN,EAAEO,QAAM,CAAGC,UAAQ,EAC9B,CAAA;;OASCP,QAAQ;CACPQ,OAAON;CACPO,MAAM;CACNC,aAAa;CACbC,eAAeR;CACfS,UAAU;CACZ,CAAA;AACO,IAAMC,cAAN,MAAMA;;;;CACHC,SAAShB,OAAOD,cAAc;EAAEkB,QAAQ;EAAQC,SAAS;EAAO,CAAA;CAChEC,kBAAkBnB,OAAOG,wBAAAA;CAEjC,MAAMiB,QAAQC,SAAqC;AACjD,MAAIA,QAAQd,QACV,MAAKS,OAAOM,IAAI,KAAKH,gBAAgBI,kBAAkBF,QAAQd,QAAO,CAAA;MAEtE,MAAKS,OAAOM,IAAI,KAAKH,gBAAgBK,mBAAiB,CAAA"}

package/lib/{help.command-DvKmMpB7.cjs → help.command-Dg-0v-yP.cjs}

@@ -1,5 +1,5 @@
 const require_command_decorator = require('./command.decorator-HziankUv.cjs');
-const require_help_command_token = require('./help-command.token-DamE31Aw.cjs');
+const require_help_command_token = require('./help-command.token-BI5XnE07.cjs');
 let _navios_core = require("@navios/core");
 let zod_v4 = require("zod/v4");
 let _navios_commander_tui = require("@navios/commander-tui");
@@ -311,4 +311,4 @@ var HelpCommand = class {
 };
 
 //#endregion
-//# sourceMappingURL=help.command-DvKmMpB7.cjs.map
+//# sourceMappingURL=help.command-Dg-0v-yP.cjs.map

package/lib/{help.command-DvKmMpB7.cjs.map → help.command-Dg-0v-yP.cjs.map}

@@ -1 +1 @@
-{"version":3,"file":"help.command-DvKmMpB7.cjs","names":["ScreenLogger","inject","z","Command","CommandRegistryService","HelpCommandToken","helpOptionsSchema","object","command","string","optional","token","path","description","optionsSchema","priority","HelpCommand","logger","screen","context","commandRegistry","execute","options","log","formatCommandHelp","formatCommandList"],"sources":["../src/overrides/help.command.mts"],"sourcesContent":["import { ScreenLogger } from '@navios/commander-tui'\nimport { inject } from '@navios/core'\nimport { z } from 'zod/v4'\n\nimport { Command } from '../decorators/command.decorator.mjs'\nimport { CommandRegistryService } from '../services/command-registry.service.mjs'\nimport { HelpCommandToken } from '../tokens/help-command.token.mjs'\n\nimport type { CommandHandler } from '../interfaces/command-handler.interface.mjs'\n\nconst helpOptionsSchema = z.object({\n  command: z.string().optional(),\n})\n\ntype HelpOptions = z.infer<typeof helpOptionsSchema>\n\n/**\n * Built-in help command that lists all available commands or shows help for a specific command.\n *\n * @public\n */\n@Command({\n  token: HelpCommandToken,\n  path: 'help',\n  description: 'Show available commands or help for a specific command',\n  optionsSchema: helpOptionsSchema,\n  priority: 1000,\n})\nexport class HelpCommand implements CommandHandler<HelpOptions> {\n  private logger = inject(ScreenLogger, { screen: 'Help', context: 'Help' })\n  private commandRegistry = inject(CommandRegistryService)\n\n  async execute(options: HelpOptions): Promise<void> {\n    if (options.command) {\n      this.logger.log(this.commandRegistry.formatCommandHelp(options.command))\n    } else {\n      this.logger.log(this.commandRegistry.formatCommandList())\n    }\n  }\n}\n"],"mappings":";;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;AAUA,MAAMM,oBAAoBJ,SAAEK,OAAO,EACjCC,SAASN,SAAEO,QAAM,CAAGC,UAAQ,EAC9B,CAAA;;OASCP,kCAAQ;CACPQ,OAAON;CACPO,MAAM;CACNC,aAAa;CACbC,eAAeR;CACfS,UAAU;CACZ,CAAA;AACO,IAAMC,cAAN,MAAMA;;;;CACHC,kCAAgBjB,oCAAc;EAAEkB,QAAQ;EAAQC,SAAS;EAAO,CAAA;CAChEC,2CAAyBhB,mDAAAA;CAEjC,MAAMiB,QAAQC,SAAqC;AACjD,MAAIA,QAAQd,QACV,MAAKS,OAAOM,IAAI,KAAKH,gBAAgBI,kBAAkBF,QAAQd,QAAO,CAAA;MAEtE,MAAKS,OAAOM,IAAI,KAAKH,gBAAgBK,mBAAiB,CAAA"}
+{"version":3,"file":"help.command-Dg-0v-yP.cjs","names":["ScreenLogger","inject","z","Command","CommandRegistryService","HelpCommandToken","helpOptionsSchema","object","command","string","optional","token","path","description","optionsSchema","priority","HelpCommand","logger","screen","context","commandRegistry","execute","options","log","formatCommandHelp","formatCommandList"],"sources":["../src/overrides/help.command.mts"],"sourcesContent":["import { ScreenLogger } from '@navios/commander-tui'\nimport { inject } from '@navios/core'\nimport { z } from 'zod/v4'\n\nimport { Command } from '../decorators/command.decorator.mjs'\nimport { CommandRegistryService } from '../services/command-registry.service.mjs'\nimport { HelpCommandToken } from '../tokens/help-command.token.mjs'\n\nimport type { CommandHandler } from '../interfaces/command-handler.interface.mjs'\n\nconst helpOptionsSchema = z.object({\n  command: z.string().optional(),\n})\n\ntype HelpOptions = z.infer<typeof helpOptionsSchema>\n\n/**\n * Built-in help command that lists all available commands or shows help for a specific command.\n *\n * @public\n */\n@Command({\n  token: HelpCommandToken,\n  path: 'help',\n  description: 'Show available commands or help for a specific command',\n  optionsSchema: helpOptionsSchema,\n  priority: 1000,\n})\nexport class HelpCommand implements CommandHandler<HelpOptions> {\n  private logger = inject(ScreenLogger, { screen: 'Help', context: 'Help' })\n  private commandRegistry = inject(CommandRegistryService)\n\n  async execute(options: HelpOptions): Promise<void> {\n    if (options.command) {\n      this.logger.log(this.commandRegistry.formatCommandHelp(options.command))\n    } else {\n      this.logger.log(this.commandRegistry.formatCommandList())\n    }\n  }\n}\n"],"mappings":";;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;AAUA,MAAMM,oBAAoBJ,SAAEK,OAAO,EACjCC,SAASN,SAAEO,QAAM,CAAGC,UAAQ,EAC9B,CAAA;;OASCP,kCAAQ;CACPQ,OAAON;CACPO,MAAM;CACNC,aAAa;CACbC,eAAeR;CACfS,UAAU;CACZ,CAAA;AACO,IAAMC,cAAN,MAAMA;;;;CACHC,kCAAgBjB,oCAAc;EAAEkB,QAAQ;EAAQC,SAAS;EAAO,CAAA;CAChEC,2CAAyBhB,mDAAAA;CAEjC,MAAMiB,QAAQC,SAAqC;AACjD,MAAIA,QAAQd,QACV,MAAKS,OAAOM,IAAI,KAAKH,gBAAgBI,kBAAkBF,QAAQd,QAAO,CAAA;MAEtE,MAAKS,OAAOM,IAAI,KAAKH,gBAAgBK,mBAAiB,CAAA"}

package/lib/index.cjs

@@ -1,5 +1,5 @@
 const require_command_decorator = require('./command.decorator-HziankUv.cjs');
-const require_help_command_token = require('./help-command.token-DamE31Aw.cjs');
+const require_help_command_token = require('./help-command.token-BI5XnE07.cjs');
 const require_cli_module_decorator = require('./cli-module.decorator-CXt38aqF.cjs');
 let _navios_core = require("@navios/core");
 let zod_v4 = require("zod/v4");
@@ -599,9 +599,13 @@ var CliParserService = class {
 	*
 	* @param argv - Array of command-line arguments (typically process.argv)
 	* @param optionsSchema - Optional zod/v4 schema to determine boolean flags and option types
+	* @param availableCommands - Optional list of registered command paths for smart detection.
+	*   When provided, scans argv to find the best matching command, enabling support for
+	*   custom launchers (tsx, ts-node, npx, etc.) that add extra args before the command.
 	* @returns Parsed command (space-separated if multi-word), options, and positional arguments
-	*/ parse(argv, optionsSchema) {
-		const args = argv.slice(2);
+	*/ parse(argv, optionsSchema, availableCommands) {
+		const startIndex = availableCommands?.length ? this.findCommandStartIndex(argv, availableCommands) : 2;
+		const args = argv.slice(startIndex);
 		if (args.length === 0) throw new Error("[Navios Commander] No command provided");
 		const booleanFields = optionsSchema ? this.extractBooleanFields(optionsSchema) : /* @__PURE__ */ new Set();
 		const arrayFields = optionsSchema ? this.extractArrayFields(optionsSchema) : /* @__PURE__ */ new Set();
@@ -623,12 +627,41 @@ var CliParserService = class {
 				if (equalIndex !== -1) {
 					const optionName = key.slice(0, equalIndex);
 					const optionValue = key.slice(equalIndex + 1);
-					const camelCaseKey = this.camelCase(optionName);
-					if (arrayFields.has(camelCaseKey) || arrayFields.has(optionName)) {
-						if (!options[camelCaseKey]) options[camelCaseKey] = [];
-						options[camelCaseKey].push(this.parseValue(optionValue));
-					} else options[camelCaseKey] = this.parseValue(optionValue);
+					if (this.isObjectNotation(optionName)) {
+						const processedPath = this.processObjectNotationKey(optionName);
+						if (optionsSchema ? this.isNestedArray(optionsSchema, processedPath) : false) {
+							const existingValue = this.getNestedProperty(options, processedPath);
+							if (!Array.isArray(existingValue)) this.setNestedProperty(options, processedPath, []);
+							this.getNestedProperty(options, processedPath).push(this.parseValue(optionValue));
+						} else this.setNestedProperty(options, processedPath, this.parseValue(optionValue));
+					} else {
+						const camelCaseKey = this.camelCase(optionName);
+						if (arrayFields.has(camelCaseKey) || arrayFields.has(optionName)) {
+							if (!options[camelCaseKey]) options[camelCaseKey] = [];
+							options[camelCaseKey].push(this.parseValue(optionValue));
+						} else options[camelCaseKey] = this.parseValue(optionValue);
+					}
 					i++;
+				} else if (this.isObjectNotation(key)) {
+					const processedPath = this.processObjectNotationKey(key);
+					const isBoolean = optionsSchema ? this.isNestedBoolean(optionsSchema, processedPath) : false;
+					const isArray = optionsSchema ? this.isNestedArray(optionsSchema, processedPath) : false;
+					const nextArg = args[i + 1];
+					if (isBoolean) {
+						this.setNestedProperty(options, processedPath, true);
+						i++;
+					} else if (isArray && nextArg && !nextArg.startsWith("-")) {
+						const existingValue = this.getNestedProperty(options, processedPath);
+						if (!Array.isArray(existingValue)) this.setNestedProperty(options, processedPath, []);
+						this.getNestedProperty(options, processedPath).push(this.parseValue(nextArg));
+						i += 2;
+					} else if (nextArg && !nextArg.startsWith("-")) {
+						this.setNestedProperty(options, processedPath, this.parseValue(nextArg));
+						i += 2;
+					} else {
+						this.setNestedProperty(options, processedPath, true);
+						i++;
+					}
 				} else {
 					const camelCaseKey = this.camelCase(key);
 					const isBoolean = booleanFields.has(camelCaseKey) || booleanFields.has(key);
@@ -685,6 +718,28 @@ var CliParserService = class {
 		};
 	}
 	/**
+	* Finds the index in argv where the command starts by matching against available commands.
+	* Prioritizes longer/more specific commands (e.g., 'db migrate' matches before 'db').
+	*
+	* @param argv - Full argv array
+	* @param availableCommands - List of registered command paths
+	* @returns Index where the command starts, or 2 as fallback
+	*/ findCommandStartIndex(argv, availableCommands) {
+		const sortedCommands = [...availableCommands].sort((a, b) => {
+			const aParts = a.split(" ").length;
+			const bParts = b.split(" ").length;
+			if (bParts !== aParts) return bParts - aParts;
+			return b.length - a.length;
+		});
+		for (let startIdx = 1; startIdx < argv.length; startIdx++) for (const cmd of sortedCommands) {
+			const cmdParts = cmd.split(" ");
+			const endIdx = startIdx + cmdParts.length;
+			if (endIdx > argv.length) continue;
+			if (argv.slice(startIdx, endIdx).join(" ") === cmd) return startIdx;
+		}
+		return 2;
+	}
+	/**
 	* Converts kebab-case to camelCase
 	*/ camelCase(str) {
 		return str.replace(/-([a-z])/g, (_, letter) => letter.toUpperCase());
@@ -767,6 +822,80 @@ var CliParserService = class {
 			return false;
 		}
 	}
+	/**
+	* Sets a nested property on an object using dot notation path.
+	* Creates intermediate objects as needed.
+	*
+	* @example
+	* setNestedProperty({}, 'a.b.c', 'value') // { a: { b: { c: 'value' } } }
+	*/ setNestedProperty(obj, path, value) {
+		const parts = path.split(".");
+		let current = obj;
+		for (let i = 0; i < parts.length - 1; i++) {
+			const part = parts[i];
+			if (!(part in current) || typeof current[part] !== "object" || current[part] === null) current[part] = {};
+			current = current[part];
+		}
+		current[parts[parts.length - 1]] = value;
+	}
+	/**
+	* Gets a nested property from an object using dot notation path.
+	* Returns undefined if path doesn't exist.
+	*/ getNestedProperty(obj, path) {
+		const parts = path.split(".");
+		let current = obj;
+		for (const part of parts) {
+			if (current === void 0 || current === null || typeof current !== "object") return;
+			current = current[part];
+		}
+		return current;
+	}
+	/**
+	* Checks if an option key contains dot notation (object notation).
+	* Returns true for keys like "obj.field" or "deep.nested.value".
+	*/ isObjectNotation(key) {
+		return key.includes(".");
+	}
+	/**
+	* Processes an option key that may contain object notation.
+	* Converts each segment from kebab-case to camelCase.
+	*
+	* @example
+	* processObjectNotationKey('my-obj.field-name') // 'myObj.fieldName'
+	*/ processObjectNotationKey(key) {
+		return key.split(".").map((segment) => this.camelCase(segment)).join(".");
+	}
+	/**
+	* Gets the nested schema for a given dot-notation path.
+	* Returns undefined if the path doesn't lead to a valid schema.
+	*/ getNestedSchema(schema, path) {
+		try {
+			const parts = path.split(".");
+			let currentSchema = schema;
+			for (const part of parts) {
+				while (currentSchema?.def?.type === "optional" || currentSchema?.def?.type === "default") currentSchema = currentSchema.def.innerType;
+				if (currentSchema?.def?.type !== "object") return;
+				const shape = currentSchema.def.shape;
+				if (!shape || !(part in shape)) return;
+				currentSchema = shape[part];
+			}
+			return currentSchema;
+		} catch {
+			return;
+		}
+	}
+	/**
+	* Checks if a nested path represents a boolean field in the schema.
+	*/ isNestedBoolean(schema, path) {
+		const nestedSchema = this.getNestedSchema(schema, path);
+		return nestedSchema ? this.isSchemaBoolean(nestedSchema) : false;
+	}
+	/**
+	* Checks if a nested path represents an array field in the schema.
+	*/ isNestedArray(schema, path) {
+		const nestedSchema = this.getNestedSchema(schema, path);
+		return nestedSchema ? this.isSchemaArray(nestedSchema) : false;
+	}
 	static {
 		_initClass$1();
 	}
@@ -1218,14 +1347,15 @@ var CommanderAdapterService = class {
 	*/ async run(argv = process.argv) {
 		if (!this.isReady) throw new Error("Adapter not ready. Call app.init() first.");
 		try {
-			const preliminaryParse = this.cliParser.parse(argv);
+			const commandPaths = this.commandRegistry.getAllPaths();
+			const preliminaryParse = this.cliParser.parse(argv, void 0, commandPaths);
 			if (preliminaryParse.options.help || preliminaryParse.options.h) {
 				if (preliminaryParse.command === "help") await this.executeCommand("help", {});
 				else await this.executeCommand("help", { command: preliminaryParse.command });
 				return;
 			}
 			const command = this.commandRegistry.getByPath(preliminaryParse.command);
-			const parsed = command?.metadata.optionsSchema ? this.cliParser.parse(argv, command.metadata.optionsSchema) : preliminaryParse;
+			const parsed = command?.metadata.optionsSchema ? this.cliParser.parse(argv, command.metadata.optionsSchema, commandPaths) : preliminaryParse;
 			await this.executeCommand(parsed.command, parsed.options, parsed.positionals);
 		} catch (error) {
 			if (error instanceof Error) {
@@ -1372,7 +1502,7 @@ function dynamicImport(modulePath) {
 			}
 			const { overrideConsoleLogger, ScreenManager } = tuiModule;
 			overrideConsoleLogger(options.tuiOptions?.hideDefaultScreen ?? false);
-			if (options.tuiOptions?.hideDefaultScreen) await Promise.resolve().then(() => require("./help.command-DvKmMpB7.cjs"));
+			if (options.tuiOptions?.hideDefaultScreen) await Promise.resolve().then(() => require("./help.command-Dg-0v-yP.cjs"));
 			const app = await _navios_core.NaviosFactory.create(appModule, {
 				adapter: defineCliEnvironment(),
 				logger: options.logLevels