@navios/commander 1.5.0 → 1.6.0

package/lib/legacy-compat/index.d.cts

@@ -1,8 +1,9 @@
-import { i as CommandOptions, n as CliModuleOptions } from "../cli-module.decorator-CRaNGvgl.cjs";
+import { i as CommandOptions, n as CliModuleOptions } from "../cli-module.decorator-BV3vVKlR.cjs";
 import { ClassType } from "@navios/core";
 export * from "@navios/core/legacy-compat";
 
 //#region src/legacy-compat/decorators/command.decorator.d.mts
+
 /**
  * Legacy-compatible Command decorator.
  *
@@ -14,7 +15,7 @@ export * from "@navios/core/legacy-compat";
  * @example
  * ```typescript
  * import { Command, CommandHandler } from '@navios/commander/legacy-compat'
- * import { z } from 'zod'
+ * import { z } from 'zod/v4'
  *
  * const optionsSchema = z.object({
  *   name: z.string(),

package/lib/legacy-compat/index.d.cts.map

@@ -1 +1 @@
-{"version":3,"file":"index.d.cts","names":["ClassType","CommandOptions","Command","ClassType","CliModuleOptions","CliModule"],"sources":["../../src/legacy-compat/decorators/command.decorator.d.mts","../../src/legacy-compat/decorators/cli-module.decorator.d.mts"],"mappings":";;;;;;AAgCA;;;;ACRA;;;;;;;;;;;;;;;;;;;;;;;;iBDQwBE,OAAAA,CAAAA,OAAAA,EAAiBD,cAAAA,IAAAA,MAAAA,EAA0BD,SAAAA;;;;ACRnE;;;;;;;;;;;;;;;;;;;;iBAAwBK,SAAAA,CAAAA,OAAAA,GAAoBD,gBAAAA,IAAAA,MAAAA,EAA4BD,SAAAA,KAAcA,SAAAA"}
+{"version":3,"file":"index.d.cts","names":["ClassType","CommandOptions","Command","ClassType","CliModuleOptions","CliModule"],"sources":["../../src/legacy-compat/decorators/command.decorator.d.mts","../../src/legacy-compat/decorators/cli-module.decorator.d.mts"],"sourcesContent":["import type { ClassType } from '@navios/core'\n\nimport { type CommandOptions } from '../../decorators/command.decorator.mjs'\nexport type { CommandOptions }\n/**\n * Legacy-compatible Command decorator.\n *\n * Works with TypeScript experimental decorators (legacy API).\n *\n * @param options - Command configuration options\n * @returns A class decorator compatible with legacy decorator API\n *\n * @example\n * ```typescript\n * import { Command, CommandHandler } from '@navios/commander/legacy-compat'\n * import { z } from 'zod/v4'\n *\n * const optionsSchema = z.object({\n *   name: z.string(),\n *   greeting: z.string().optional().default('Hello')\n * })\n *\n * @Command({\n *   path: 'greet',\n *   optionsSchema: optionsSchema\n * })\n * export class GreetCommand implements CommandHandler<z.infer<typeof optionsSchema>> {\n *   async execute(options) {\n *     console.log(`${options.greeting}, ${options.name}!`)\n *   }\n * }\n * ```\n */\nexport declare function Command(options: CommandOptions): (target: ClassType) => any\n//# sourceMappingURL=command.decorator.d.mts.map\n","import type { ClassType } from '@navios/core'\n\nimport { type CliModuleOptions } from '../../decorators/cli-module.decorator.mjs'\nexport type { CliModuleOptions }\n/**\n * Legacy-compatible CliModule decorator.\n *\n * Works with TypeScript experimental decorators (legacy API).\n *\n * @param options - CLI module configuration options\n * @returns A class decorator compatible with legacy decorator API\n *\n * @example\n * ```typescript\n * import { CliModule } from '@navios/commander/legacy-compat'\n * import { GreetCommand } from './greet.command'\n * import { UserModule } from './user.module'\n *\n * @CliModule({\n *   commands: [GreetCommand],\n *   imports: [UserModule]\n * })\n * export class AppModule {}\n * ```\n */\nexport declare function CliModule(options?: CliModuleOptions): (target: ClassType) => ClassType\n//# sourceMappingURL=cli-module.decorator.d.mts.map\n"],"mappings":";;;;;;;;AAiCA;;;;ACRA;;;;;;;;;;;;;;;;;;;;;;;iBDQwBE,OAAAA,UAAiBD,0BAA0BD;;;;;AAAnE;;;;ACRA;;;;;;;;;;;;;;;iBAAwBK,SAAAA,WAAoBD,4BAA4BD,cAAcA"}

package/lib/legacy-compat/index.d.mts

@@ -1,8 +1,9 @@
-import { i as CommandOptions, n as CliModuleOptions } from "../cli-module.decorator-bsP5gEn7.mjs";
+import { i as CommandOptions, n as CliModuleOptions } from "../cli-module.decorator-DDlgpTgI.mjs";
 import { ClassType } from "@navios/core";
 export * from "@navios/core/legacy-compat";
 
 //#region src/legacy-compat/decorators/command.decorator.d.mts
+
 /**
  * Legacy-compatible Command decorator.
  *
@@ -14,7 +15,7 @@ export * from "@navios/core/legacy-compat";
  * @example
  * ```typescript
  * import { Command, CommandHandler } from '@navios/commander/legacy-compat'
- * import { z } from 'zod'
+ * import { z } from 'zod/v4'
  *
  * const optionsSchema = z.object({
  *   name: z.string(),

package/lib/legacy-compat/index.d.mts.map

@@ -1 +1 @@
-{"version":3,"file":"index.d.mts","names":["ClassType","CommandOptions","Command","ClassType","CliModuleOptions","CliModule"],"sources":["../../src/legacy-compat/decorators/command.decorator.d.mts","../../src/legacy-compat/decorators/cli-module.decorator.d.mts"],"mappings":";;;;;;AAgCA;;;;ACRA;;;;;;;;;;;;;;;;;;;;;;;;iBDQwBE,OAAAA,CAAAA,OAAAA,EAAiBD,cAAAA,IAAAA,MAAAA,EAA0BD,SAAAA;;;;ACRnE;;;;;;;;;;;;;;;;;;;;iBAAwBK,SAAAA,CAAAA,OAAAA,GAAoBD,gBAAAA,IAAAA,MAAAA,EAA4BD,SAAAA,KAAcA,SAAAA"}
+{"version":3,"file":"index.d.mts","names":["ClassType","CommandOptions","Command","ClassType","CliModuleOptions","CliModule"],"sources":["../../src/legacy-compat/decorators/command.decorator.d.mts","../../src/legacy-compat/decorators/cli-module.decorator.d.mts"],"sourcesContent":["import type { ClassType } from '@navios/core'\n\nimport { type CommandOptions } from '../../decorators/command.decorator.mjs'\nexport type { CommandOptions }\n/**\n * Legacy-compatible Command decorator.\n *\n * Works with TypeScript experimental decorators (legacy API).\n *\n * @param options - Command configuration options\n * @returns A class decorator compatible with legacy decorator API\n *\n * @example\n * ```typescript\n * import { Command, CommandHandler } from '@navios/commander/legacy-compat'\n * import { z } from 'zod/v4'\n *\n * const optionsSchema = z.object({\n *   name: z.string(),\n *   greeting: z.string().optional().default('Hello')\n * })\n *\n * @Command({\n *   path: 'greet',\n *   optionsSchema: optionsSchema\n * })\n * export class GreetCommand implements CommandHandler<z.infer<typeof optionsSchema>> {\n *   async execute(options) {\n *     console.log(`${options.greeting}, ${options.name}!`)\n *   }\n * }\n * ```\n */\nexport declare function Command(options: CommandOptions): (target: ClassType) => any\n//# sourceMappingURL=command.decorator.d.mts.map\n","import type { ClassType } from '@navios/core'\n\nimport { type CliModuleOptions } from '../../decorators/cli-module.decorator.mjs'\nexport type { CliModuleOptions }\n/**\n * Legacy-compatible CliModule decorator.\n *\n * Works with TypeScript experimental decorators (legacy API).\n *\n * @param options - CLI module configuration options\n * @returns A class decorator compatible with legacy decorator API\n *\n * @example\n * ```typescript\n * import { CliModule } from '@navios/commander/legacy-compat'\n * import { GreetCommand } from './greet.command'\n * import { UserModule } from './user.module'\n *\n * @CliModule({\n *   commands: [GreetCommand],\n *   imports: [UserModule]\n * })\n * export class AppModule {}\n * ```\n */\nexport declare function CliModule(options?: CliModuleOptions): (target: ClassType) => ClassType\n//# sourceMappingURL=cli-module.decorator.d.mts.map\n"],"mappings":";;;;;;;;AAiCA;;;;ACRA;;;;;;;;;;;;;;;;;;;;;;;iBDQwBE,OAAAA,UAAiBD,0BAA0BD;;;;;AAAnE;;;;ACRA;;;;;;;;;;;;;;;iBAAwBK,SAAAA,WAAoBD,4BAA4BD,cAAcA"}

package/lib/legacy-compat/index.mjs

@@ -1,30 +1,9 @@
-import { t as Command$1 } from "../command.decorator-DVLSAqYZ.mjs";
-import { t as CliModule$1 } from "../cli-module.decorator-UGbtkRYc.mjs";
+import { t as Command$1 } from "../command.decorator-QiRU7ny3.mjs";
+import { t as CliModule$1 } from "../cli-module.decorator-DAjf_r_W.mjs";
+import { createClassContext } from "@navios/core/legacy-compat";
 
 export * from "@navios/core/legacy-compat"
 
-//#region ../../node_modules/@navios/di/lib/legacy-compat/index.mjs
-/**
-* Compatibility layer for converting legacy decorator signatures to Stage 3 format.
-*
-* This module provides utilities to create mock Stage 3 decorator contexts
-* from legacy decorator arguments, and manages metadata storage using WeakMap.
-*/ const classMetadataMap = /* @__PURE__ */ new WeakMap();
-/**
-* Creates a mock ClassDecoratorContext for legacy class decorators.
-* @internal
-*/ function createClassContext(target) {
-	if (!classMetadataMap.has(target)) classMetadataMap.set(target, {});
-	const metadata = classMetadataMap.get(target);
-	return {
-		kind: "class",
-		name: target.name,
-		metadata,
-		addInitializer() {}
-	};
-}
-
-//#endregion
 //#region src/legacy-compat/decorators/command.decorator.mts
 /**
 * Legacy-compatible Command decorator.
@@ -37,7 +16,7 @@ export * from "@navios/core/legacy-compat"
 * @example
 * ```typescript
 * import { Command, CommandHandler } from '@navios/commander/legacy-compat'
-* import { z } from 'zod'
+* import { z } from 'zod/v4'
 *
 * const optionsSchema = z.object({
 *   name: z.string(),

package/lib/legacy-compat/index.mjs.map

@@ -1 +1 @@
-{"version":3,"file":"index.mjs","names":["createClassContext","Command","OriginalCommand","options","target","context","originalDecorator","createClassContext","CliModule","OriginalCliModule","options","commands","controllers","imports","guards","overrides","target","context","originalDecorator"],"sources":["../../../../node_modules/@navios/di/lib/legacy-compat/index.mjs","../../src/legacy-compat/decorators/command.decorator.mts","../../src/legacy-compat/decorators/cli-module.decorator.mts"],"sourcesContent":["import { t as Injectable$1 } from \"../injectable.decorator-CyPrBzBN.mjs\";\nimport { t as Factory$1 } from \"../factory.decorator-_IPWcwQn.mjs\";\n\n//#region src/legacy-compat/context-compat.mts\n/**\n* Compatibility layer for converting legacy decorator signatures to Stage 3 format.\n*\n* This module provides utilities to create mock Stage 3 decorator contexts\n* from legacy decorator arguments, and manages metadata storage using WeakMap.\n*/ const classMetadataMap = /* @__PURE__ */ new WeakMap();\n/**\n* Gets the constructor from a prototype (for method decorators).\n*/ function getConstructor(prototype) {\n\tif (!prototype || typeof prototype !== \"object\") return null;\n\tconst constructor = prototype.constructor;\n\tif (constructor && typeof constructor === \"function\") return constructor;\n\treturn null;\n}\n/**\n* Creates a mock ClassDecoratorContext for legacy class decorators.\n* @internal\n*/ function createClassContext(target) {\n\tif (!classMetadataMap.has(target)) classMetadataMap.set(target, {});\n\tconst metadata = classMetadataMap.get(target);\n\treturn {\n\t\tkind: \"class\",\n\t\tname: target.name,\n\t\tmetadata,\n\t\taddInitializer() {}\n\t};\n}\n/**\n* Creates a mock ClassMethodDecoratorContext for legacy method decorators.\n*\n* Note: Method decorators need to share metadata with the class context\n* because endpoint metadata is stored at the class level.\n* @internal\n*/ function createMethodContext(target, propertyKey, descriptor) {\n\tconst constructor = getConstructor(target);\n\tif (!constructor) throw new Error(\"[Navios] Could not determine class constructor from method decorator target.\");\n\tif (!classMetadataMap.has(constructor)) classMetadataMap.set(constructor, {});\n\treturn {\n\t\tkind: \"method\",\n\t\tname: propertyKey,\n\t\tmetadata: classMetadataMap.get(constructor),\n\t\tstatic: false,\n\t\tprivate: false,\n\t\taccess: {\n\t\t\thas: () => true,\n\t\t\tget: () => descriptor.value,\n\t\t\tset: () => {}\n\t\t},\n\t\taddInitializer() {}\n\t};\n}\n\n//#endregion\n//#region src/legacy-compat/injectable.decorator.mts\n/**\n* Legacy-compatible Injectable decorator.\n*\n* Works with TypeScript experimental decorators (legacy API).\n*\n* @param options - Injectable configuration options\n* @returns A class decorator compatible with legacy decorator API\n*\n* @example\n* ```typescript\n* @Injectable()\n* export class UserService {\n*   getUser(id: string) {\n*     return { id, name: 'John' }\n*   }\n* }\n* ```\n*/ function Injectable(options = {}) {\n\treturn function(target) {\n\t\tconst context = createClassContext(target);\n\t\treturn (Object.keys(options).length === 0 ? Injectable$1() : Injectable$1(options))(target, context);\n\t};\n}\n\n//#endregion\n//#region src/legacy-compat/factory.decorator.mts\n/**\n* Legacy-compatible Factory decorator.\n*\n* Works with TypeScript experimental decorators (legacy API).\n*\n* @param options - Factory configuration options\n* @returns A class decorator compatible with legacy decorator API\n*\n* @example\n* ```typescript\n* @Factory()\n* export class DatabaseConnectionFactory {\n*   create() {\n*     return { host: 'localhost', port: 5432 }\n*   }\n* }\n* ```\n*/ function Factory(options = {}) {\n\treturn function(target) {\n\t\tconst context = createClassContext(target);\n\t\treturn (Object.keys(options).length === 0 ? Factory$1() : Factory$1(options))(target, context);\n\t};\n}\n\n//#endregion\nexport { Factory, Injectable, createClassContext, createMethodContext };\n//# sourceMappingURL=index.mjs.map","import type { ClassType } from '@navios/core'\nimport { createClassContext } from '@navios/di/legacy-compat'\n\nimport {\n  Command as OriginalCommand,\n  type CommandOptions,\n} from '../../decorators/command.decorator.mjs'\n\nexport type { CommandOptions }\n\n/**\n * Legacy-compatible Command decorator.\n *\n * Works with TypeScript experimental decorators (legacy API).\n *\n * @param options - Command configuration options\n * @returns A class decorator compatible with legacy decorator API\n *\n * @example\n * ```typescript\n * import { Command, CommandHandler } from '@navios/commander/legacy-compat'\n * import { z } from 'zod'\n *\n * const optionsSchema = z.object({\n *   name: z.string(),\n *   greeting: z.string().optional().default('Hello')\n * })\n *\n * @Command({\n *   path: 'greet',\n *   optionsSchema: optionsSchema\n * })\n * export class GreetCommand implements CommandHandler<z.infer<typeof optionsSchema>> {\n *   async execute(options) {\n *     console.log(`${options.greeting}, ${options.name}!`)\n *   }\n * }\n * ```\n */\nexport function Command(options: CommandOptions) {\n  return function (target: ClassType) {\n    const context = createClassContext(target)\n    const originalDecorator = OriginalCommand(options)\n    return originalDecorator(target, context)\n  }\n}\n","import type { ClassType } from '@navios/core'\nimport { createClassContext } from '@navios/di/legacy-compat'\n\nimport {\n  CliModule as OriginalCliModule,\n  type CliModuleOptions,\n} from '../../decorators/cli-module.decorator.mjs'\n\nexport type { CliModuleOptions }\n\n/**\n * Legacy-compatible CliModule decorator.\n *\n * Works with TypeScript experimental decorators (legacy API).\n *\n * @param options - CLI module configuration options\n * @returns A class decorator compatible with legacy decorator API\n *\n * @example\n * ```typescript\n * import { CliModule } from '@navios/commander/legacy-compat'\n * import { GreetCommand } from './greet.command'\n * import { UserModule } from './user.module'\n *\n * @CliModule({\n *   commands: [GreetCommand],\n *   imports: [UserModule]\n * })\n * export class AppModule {}\n * ```\n */\nexport function CliModule(\n  options: CliModuleOptions = {\n    commands: [],\n    controllers: [],\n    imports: [],\n    guards: [],\n    overrides: [],\n  },\n) {\n  return function (target: ClassType) {\n    const context = createClassContext(target)\n    const originalDecorator = OriginalCliModule(options)\n    return originalDecorator(target, context)\n  }\n}\n"],"x_google_ignoreList":[0],"mappings":";;;;;;;;;;;GASG,MAAM,mCAAmC,IAAI,SAAS;;;;GAYtD,SAAS,mBAAmB,QAAQ;AACtC,KAAI,CAAC,iBAAiB,IAAI,OAAO,CAAE,kBAAiB,IAAI,QAAQ,EAAE,CAAC;CACnE,MAAM,WAAW,iBAAiB,IAAI,OAAO;AAC7C,QAAO;EACN,MAAM;EACN,MAAM,OAAO;EACb;EACA,iBAAiB;EACjB;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;GCUF,SAAgBC,QAAQE,SAAuB;AAC7C,QAAO,SAAUC,QAAiB;EAChC,MAAMC,UAAUL,mBAAmBI,OAAAA;AAEnC,SAD0BF,UAAgBC,QAAAA,CACjBC,QAAQC,QAAAA;;;;;;;;;;;;;;;;;;;;;;;;;;GCZrC,SAAgBG,UACdE,UAA4B;CAC1BC,UAAU,EAAE;CACZC,aAAa,EAAE;CACfC,SAAS,EAAE;CACXC,QAAQ,EAAE;CACVC,WAAW,EAAE;CACd,EAAA;AAED,QAAO,SAAUC,QAAiB;EAChC,MAAMC,UAAUV,mBAAmBS,OAAAA;AAEnC,SAD0BP,YAAkBC,QAAAA,CACnBM,QAAQC,QAAAA"}
+{"version":3,"file":"index.mjs","names":["createClassContext","Command","OriginalCommand","options","target","context","originalDecorator","createClassContext","CliModule","OriginalCliModule","options","commands","controllers","imports","guards","overrides","target","context","originalDecorator"],"sources":["../../src/legacy-compat/decorators/command.decorator.mts","../../src/legacy-compat/decorators/cli-module.decorator.mts"],"sourcesContent":["import { createClassContext } from '@navios/core/legacy-compat'\n\nimport type { ClassType } from '@navios/core'\n\nimport {\n  Command as OriginalCommand,\n  type CommandOptions,\n} from '../../decorators/command.decorator.mjs'\n\nexport type { CommandOptions }\n\n/**\n * Legacy-compatible Command decorator.\n *\n * Works with TypeScript experimental decorators (legacy API).\n *\n * @param options - Command configuration options\n * @returns A class decorator compatible with legacy decorator API\n *\n * @example\n * ```typescript\n * import { Command, CommandHandler } from '@navios/commander/legacy-compat'\n * import { z } from 'zod/v4'\n *\n * const optionsSchema = z.object({\n *   name: z.string(),\n *   greeting: z.string().optional().default('Hello')\n * })\n *\n * @Command({\n *   path: 'greet',\n *   optionsSchema: optionsSchema\n * })\n * export class GreetCommand implements CommandHandler<z.infer<typeof optionsSchema>> {\n *   async execute(options) {\n *     console.log(`${options.greeting}, ${options.name}!`)\n *   }\n * }\n * ```\n */\nexport function Command(options: CommandOptions) {\n  return function (target: ClassType) {\n    const context = createClassContext(target)\n    const originalDecorator = OriginalCommand(options)\n    return originalDecorator(target, context)\n  }\n}\n","import { createClassContext } from '@navios/core/legacy-compat'\n\nimport type { ClassType } from '@navios/core'\n\nimport {\n  CliModule as OriginalCliModule,\n  type CliModuleOptions,\n} from '../../decorators/cli-module.decorator.mjs'\n\nexport type { CliModuleOptions }\n\n/**\n * Legacy-compatible CliModule decorator.\n *\n * Works with TypeScript experimental decorators (legacy API).\n *\n * @param options - CLI module configuration options\n * @returns A class decorator compatible with legacy decorator API\n *\n * @example\n * ```typescript\n * import { CliModule } from '@navios/commander/legacy-compat'\n * import { GreetCommand } from './greet.command'\n * import { UserModule } from './user.module'\n *\n * @CliModule({\n *   commands: [GreetCommand],\n *   imports: [UserModule]\n * })\n * export class AppModule {}\n * ```\n */\nexport function CliModule(\n  options: CliModuleOptions = {\n    commands: [],\n    controllers: [],\n    imports: [],\n    guards: [],\n    overrides: [],\n  },\n) {\n  return function (target: ClassType) {\n    const context = createClassContext(target)\n    const originalDecorator = OriginalCliModule(options)\n    return originalDecorator(target, context)\n  }\n}\n"],"mappings":";;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;GAwCA,SAAgBC,QAAQE,SAAuB;AAC7C,QAAO,SAAUC,QAAiB;EAChC,MAAMC,UAAUL,mBAAmBI,OAAAA;AAEnC,SAD0BF,UAAgBC,QAAAA,CACjBC,QAAQC,QAAAA;;;;;;;;;;;;;;;;;;;;;;;;;;GCZrC,SAAgBG,UACdE,UAA4B;CAC1BC,UAAU,EAAE;CACZC,aAAa,EAAE;CACfC,SAAS,EAAE;CACXC,QAAQ,EAAE;CACVC,WAAW,EAAE;CACd,EAAA;AAED,QAAO,SAAUC,QAAiB;EAChC,MAAMC,UAAUV,mBAAmBS,OAAAA;AAEnC,SAD0BP,YAAkBC,QAAAA,CACnBM,QAAQC,QAAAA"}

package/package.json

@@ -1,28 +1,19 @@
 {
   "name": "@navios/commander",
-  "version": "1.5.0",
+  "version": "1.6.0",
+  "license": "MIT",
   "author": {
     "name": "Oleksandr Hanzha",
     "email": "alex@granted.name"
   },
   "repository": {
-    "directory": "packages/commander",
     "type": "git",
-    "url": "https://github.com/navios-org/commander.git"
-  },
-  "license": "MIT",
-  "peerDependencies": {
-    "@navios/commander-tui": "^1.0.0",
-    "zod": "^4.0.0"
-  },
-  "peerDependenciesMeta": {
-    "@navios/commander-tui": {
-      "optional": true
-    }
+    "url": "https://github.com/navios-org/commander.git",
+    "directory": "packages/commander"
   },
-  "typings": "./lib/index.d.mts",
   "main": "./lib/index.cjs",
   "module": "./lib/index.mjs",
+  "typings": "./lib/index.d.mts",
   "exports": {
     ".": {
       "import": {
@@ -45,13 +36,32 @@
       }
     }
   },
+  "scripts": {
+    "check": "yarn run -T tsgo -b",
+    "lint": "yarn run -T oxlint --fix && yarn run -T oxfmt",
+    "test": "vitest",
+    "test:ci": "vitest run",
+    "build": "yarn run -T tsdown",
+    "publish:pkg": "yarn npm publish --access public",
+    "publish:next": "yarn npm publish --access public --tag next"
+  },
+  "dependencies": {
+    "@navios/core": "^1.0.0"
+  },
   "devDependencies": {
     "@navios/builder": "^1.0.0",
+    "@navios/commander-tui": "1.6.1",
     "tsx": "^4.21.0",
     "typescript": "^5.9.3",
     "zod": "^4.3.5"
   },
-  "dependencies": {
-    "@navios/core": "^1.0.0"
+  "peerDependencies": {
+    "@navios/commander-tui": "^1.0.0",
+    "zod": "^4.0.0"
+  },
+  "peerDependenciesMeta": {
+    "@navios/commander-tui": {
+      "optional": true
+    }
   }
 }

package/src/__tests__/commander.factory.e2e.spec.mts

@@ -1,11 +1,13 @@
+import { inject } from '@navios/core'
 import { beforeEach, describe, expect, it, vi } from 'vitest'
-import { z } from 'zod'
-
-import type { CommandHandler } from '../interfaces/command-handler.interface.mjs'
+import { z } from 'zod/v4'
 
 import { CommanderFactory } from '../commander.factory.mjs'
 import { CliModule } from '../decorators/cli-module.decorator.mjs'
 import { Command } from '../decorators/command.decorator.mjs'
+import { CommandExecutionContext } from '../tokens/index.mjs'
+
+import type { CommandHandler } from '../interfaces/command-handler.interface.mjs'
 
 describe('CommanderApplication E2E - run() with different argv', () => {
   describe('simple command without options', () => {
@@ -112,9 +114,7 @@ describe('CommanderApplication E2E - run() with different argv', () => {
       })
 
       @Command({ path: 'deploy', optionsSchema })
-      class DeployCommand implements CommandHandler<
-        z.infer<typeof optionsSchema>
-      > {
+      class DeployCommand implements CommandHandler<z.infer<typeof optionsSchema>> {
         async execute(options: z.infer<typeof optionsSchema>) {
           executeMock(options)
         }
@@ -144,9 +144,7 @@ describe('CommanderApplication E2E - run() with different argv', () => {
       })
 
       @Command({ path: 'build', optionsSchema })
-      class BuildCommand implements CommandHandler<
-        z.infer<typeof optionsSchema>
-      > {
+      class BuildCommand implements CommandHandler<z.infer<typeof optionsSchema>> {
         async execute(options: z.infer<typeof optionsSchema>) {
           executeMock(options)
         }
@@ -181,9 +179,7 @@ describe('CommanderApplication E2E - run() with different argv', () => {
     })
 
     @Command({ path: 'greet', optionsSchema })
-    class GreetCommand implements CommandHandler<
-      z.infer<typeof optionsSchema>
-    > {
+    class GreetCommand implements CommandHandler<z.infer<typeof optionsSchema>> {
       async execute(options: z.infer<typeof optionsSchema>) {
         executeMock(options)
       }
@@ -243,13 +239,7 @@ describe('CommanderApplication E2E - run() with different argv', () => {
       await app.init()
 
       const adapter = app.getAdapter()
-      await adapter.run([
-        'node',
-        'script.js',
-        'greet',
-        '--name=Charlie',
-        '--greeting=Hey',
-      ])
+      await adapter.run(['node', 'script.js', 'greet', '--name=Charlie', '--greeting=Hey'])
 
       expect(executeMock).toHaveBeenCalledWith({
         name: 'Charlie',
@@ -293,9 +283,7 @@ describe('CommanderApplication E2E - run() with different argv', () => {
     })
 
     @Command({ path: 'serve', optionsSchema })
-    class ServeCommand implements CommandHandler<
-      z.infer<typeof optionsSchema>
-    > {
+    class ServeCommand implements CommandHandler<z.infer<typeof optionsSchema>> {
       async execute(options: z.infer<typeof optionsSchema>) {
         executeMock(options)
       }
@@ -378,9 +366,7 @@ describe('CommanderApplication E2E - run() with different argv', () => {
     })
 
     @Command({ path: 'start', optionsSchema })
-    class StartCommand implements CommandHandler<
-      z.infer<typeof optionsSchema>
-    > {
+    class StartCommand implements CommandHandler<z.infer<typeof optionsSchema>> {
       async execute(options: z.infer<typeof optionsSchema>) {
         executeMock(options)
       }
@@ -520,9 +506,7 @@ describe('CommanderApplication E2E - run() with different argv', () => {
       })
 
       @Command({ path: 'db rollback', optionsSchema })
-      class DbRollbackWithOptionsCommand implements CommandHandler<
-        z.infer<typeof optionsSchema>
-      > {
+      class DbRollbackWithOptionsCommand implements CommandHandler<z.infer<typeof optionsSchema>> {
         async execute(options: z.infer<typeof optionsSchema>) {
           executeMock(options)
         }
@@ -562,9 +546,9 @@ describe('CommanderApplication E2E - run() with different argv', () => {
       await app.init()
 
       const adapter = app.getAdapter()
-      await expect(
-        adapter.run(['node', 'script.js', 'invalid']),
-      ).rejects.toThrow('[Navios Commander] Command not found: invalid')
+      await expect(adapter.run(['node', 'script.js', 'invalid'])).rejects.toThrow(
+        '[Navios Commander] Command not found: invalid',
+      )
 
       await app.close()
     })
@@ -591,44 +575,134 @@ describe('CommanderApplication E2E - run() with different argv', () => {
 
     @Command({ path: 'copy', optionsSchema })
     class CopyCommand implements CommandHandler<z.infer<typeof optionsSchema>> {
-      async execute(options: z.infer<typeof optionsSchema>) {
-        executeMock(options)
+      async execute(options: z.infer<typeof optionsSchema>, positionals?: string[]) {
+        executeMock(options, positionals)
+      }
+    }
+
+    const noOptionsMock = vi.fn()
+
+    @Command({ path: 'ping' })
+    class PingCommand implements CommandHandler {
+      async execute(_options: unknown, positionals?: string[]) {
+        noOptionsMock(positionals)
       }
     }
 
     @CliModule({
-      commands: [CopyCommand],
+      commands: [CopyCommand, PingCommand],
     })
     class TestModule {}
 
     beforeEach(() => {
       executeMock.mockClear()
+      noOptionsMock.mockClear()
     })
 
-    it('should parse command with options only', async () => {
+    it('should pass empty positionals for command without options', async () => {
       const app = await CommanderFactory.create(TestModule)
       await app.init()
 
       const adapter = app.getAdapter()
-      await adapter.run(['node', 'script.js', 'copy', '--force'])
+      await adapter.run(['node', 'script.js', 'ping'])
 
-      expect(executeMock).toHaveBeenCalledWith({
-        force: true,
-      })
+      expect(noOptionsMock).toHaveBeenCalledWith([])
       await app.close()
     })
 
-    it('should parse command with mixed options and positionals', async () => {
+    it('should parse command with options only and empty positionals', async () => {
       const app = await CommanderFactory.create(TestModule)
       await app.init()
 
       const adapter = app.getAdapter()
-      // Note: positionals are not extracted in this test, but the command should still execute
       await adapter.run(['node', 'script.js', 'copy', '--force'])
 
-      expect(executeMock).toHaveBeenCalledWith({
-        force: true,
-      })
+      expect(executeMock).toHaveBeenCalledWith({ force: true }, [])
+      await app.close()
+    })
+
+    it('should pass positionals as second argument to execute', async () => {
+      const app = await CommanderFactory.create(TestModule)
+      await app.init()
+
+      const adapter = app.getAdapter()
+      // Positionals must come after at least one option because the parser
+      // collects command words until it hits an argument starting with '-'
+      await adapter.run(['node', 'script.js', 'copy', '--force', 'source.txt', 'dest.txt'])
+
+      expect(executeMock).toHaveBeenCalledWith({ force: true }, ['source.txt', 'dest.txt'])
+      await app.close()
+    })
+
+    it('should pass multiple positionals after options', async () => {
+      const app = await CommanderFactory.create(TestModule)
+      await app.init()
+
+      const adapter = app.getAdapter()
+      await adapter.run([
+        'node',
+        'script.js',
+        'copy',
+        '--force',
+        'file1.txt',
+        'file2.txt',
+        'file3.txt',
+      ])
+
+      expect(executeMock).toHaveBeenCalledWith({ force: true }, [
+        'file1.txt',
+        'file2.txt',
+        'file3.txt',
+      ])
+      await app.close()
+    })
+  })
+
+  describe('positionals via execution context', () => {
+    const contextMock = vi.fn()
+
+    const processSchema = z.object({
+      verbose: z.boolean().optional().default(false),
+    })
+
+    @Command({ path: 'process', optionsSchema: processSchema })
+    class ProcessCommand implements CommandHandler<z.infer<typeof processSchema>> {
+      private ctx = inject(CommandExecutionContext)
+
+      async execute() {
+        contextMock(this.ctx.getPositionals())
+      }
+    }
+
+    @CliModule({
+      commands: [ProcessCommand],
+    })
+    class ContextTestModule {}
+
+    beforeEach(() => {
+      contextMock.mockClear()
+    })
+
+    it('should access positionals via CommandExecutionContext', async () => {
+      const app = await CommanderFactory.create(ContextTestModule)
+      await app.init()
+
+      const adapter = app.getAdapter()
+      // Positionals must come after at least one option
+      await adapter.run(['node', 'script.js', 'process', '--verbose', 'file1.txt', 'file2.txt'])
+
+      expect(contextMock).toHaveBeenCalledWith(['file1.txt', 'file2.txt'])
+      await app.close()
+    })
+
+    it('should return empty array when no positionals via context', async () => {
+      const app = await CommanderFactory.create(ContextTestModule)
+      await app.init()
+
+      const adapter = app.getAdapter()
+      await adapter.run(['node', 'script.js', 'process', '--verbose'])
+
+      expect(contextMock).toHaveBeenCalledWith([])
       await app.close()
     })
   })
@@ -648,9 +722,7 @@ describe('CommanderApplication E2E - run() with different argv', () => {
     })
 
     @Command({ path: 'app deploy', optionsSchema: deploySchema })
-    class DeployCommand implements CommandHandler<
-      z.infer<typeof deploySchema>
-    > {
+    class DeployCommand implements CommandHandler<z.infer<typeof deploySchema>> {
       async execute(options: z.infer<typeof deploySchema>) {
         executeMock(options)
       }
@@ -768,9 +840,7 @@ describe('CommanderApplication E2E - run() with different argv', () => {
     })
 
     @Command({ path: 'process', optionsSchema })
-    class ProcessCommand implements CommandHandler<
-      z.infer<typeof optionsSchema>
-    > {
+    class ProcessCommand implements CommandHandler<z.infer<typeof optionsSchema>> {
       async execute(options: z.infer<typeof optionsSchema>) {
         executeMock(options)
       }
@@ -790,13 +860,7 @@ describe('CommanderApplication E2E - run() with different argv', () => {
       await app.init()
 
       const adapter = app.getAdapter()
-      await adapter.run([
-        'node',
-        'script.js',
-        'process',
-        '--path',
-        '/usr/local/bin',
-      ])
+      await adapter.run(['node', 'script.js', 'process', '--path', '/usr/local/bin'])
 
       expect(executeMock).toHaveBeenCalledWith({
         path: '/usr/local/bin',
@@ -835,9 +899,7 @@ describe('CommanderApplication E2E - run() with different argv', () => {
       })
 
       @Command({ path: 'json-process', optionsSchema: jsonSchema })
-      class JsonProcessCommand implements CommandHandler<
-        z.infer<typeof jsonSchema>
-      > {
+      class JsonProcessCommand implements CommandHandler<z.infer<typeof jsonSchema>> {
         async execute(options: z.infer<typeof jsonSchema>) {
           executeMock(options)
         }
@@ -902,9 +964,7 @@ describe('CommanderApplication E2E - run() with different argv', () => {
     })
 
     @Command({ path: 'welcome', optionsSchema })
-    class WelcomeCommand implements CommandHandler<
-      z.infer<typeof optionsSchema>
-    > {
+    class WelcomeCommand implements CommandHandler<z.infer<typeof optionsSchema>> {
       async execute(options: z.infer<typeof optionsSchema>) {
         executeMock(options)
       }
@@ -971,15 +1031,7 @@ describe('CommanderApplication E2E - run() with different argv', () => {
       await app.init()
 
       const adapter = app.getAdapter()
-      await adapter.run([
-        'node',
-        'script.js',
-        'welcome',
-        '--name',
-        'Charlie',
-        '--count',
-        '3',
-      ])
+      await adapter.run(['node', 'script.js', 'welcome', '--name', 'Charlie', '--count', '3'])
 
       expect(executeMock).toHaveBeenCalledWith({
         name: 'Charlie',
@@ -1076,16 +1128,14 @@ describe('CommanderApplication E2E - run() with different argv', () => {
       await app.close()
     })
 
-    it('should validate options with Zod schema', async () => {
+    it('should validate options with zod/v4 schema', async () => {
       const optionsSchema = z.object({
         name: z.string().min(1),
         email: z.string().email(),
       })
 
       @Command({ path: 'create-user', optionsSchema })
-      class CreateUserCommand implements CommandHandler<
-        z.infer<typeof optionsSchema>
-      > {
+      class CreateUserCommand implements CommandHandler<z.infer<typeof optionsSchema>> {
         async execute(options: z.infer<typeof optionsSchema>) {
           executeMock(options)
         }
@@ -1145,9 +1195,7 @@ describe('CommanderApplication E2E - run() with different argv', () => {
 
       // 3 commands: cmd1, cmd2, and the built-in help command
       expect(commands).toHaveLength(3)
-      expect(commands.map((c) => c.path)).toEqual(
-        expect.arrayContaining(['cmd1', 'cmd2', 'help']),
-      )
+      expect(commands.map((c) => c.path)).toEqual(expect.arrayContaining(['cmd1', 'cmd2', 'help']))
 
       await app.close()
     })

package/src/commands/help.command.mts

@@ -1,5 +1,5 @@
 import { inject, Logger } from '@navios/core'
-import { z } from 'zod'
+import { z } from 'zod/v4'
 
 import { Command } from '../decorators/command.decorator.mjs'
 import { CommandRegistryService } from '../services/command-registry.service.mjs'

package/src/decorators/cli-module.decorator.mts

@@ -1,11 +1,8 @@
-import type { ClassType, Registry } from '@navios/core'
-
 import { Module, getModuleMetadata, getModuleCustomEntry } from '@navios/core'
 
-import {
-  CommandEntryKey,
-  type CommandEntryValue,
-} from '../metadata/command-entry.metadata.mjs'
+import type { ClassType, Registry } from '@navios/core'
+
+import { CommandEntryKey, type CommandEntryValue } from '../metadata/command-entry.metadata.mjs'
 
 /**
  * Options for the `@CliModule` decorator.
@@ -108,9 +105,7 @@ export function CliModule(
 ) {
   return (target: ClassType, context: ClassDecoratorContext) => {
     if (context.kind !== 'class') {
-      throw new Error(
-        '[Navios Commander] @CliModule decorator can only be used on classes.',
-      )
+      throw new Error('[Navios Commander] @CliModule decorator can only be used on classes.')
     }
 
     // Apply standard @Module decorator first

package/src/decorators/command.decorator.mts

@@ -1,7 +1,7 @@
 import { Injectable, InjectableScope, InjectionToken } from '@navios/core'
 
 import type { ClassType, ClassTypeWithInstance, Registry } from '@navios/core'
-import type { ZodObject } from 'zod'
+import type { z } from 'zod/v4'
 
 import { getCommandMetadata } from '../metadata/index.mjs'
 
@@ -29,10 +29,10 @@ export interface CommandOptions {
    */
   description?: string
   /**
-   * Optional Zod schema for validating command options.
+   * Optional zod/v4 schema for validating command options.
    * If provided, options will be validated and parsed according to this schema.
    */
-  optionsSchema?: ZodObject
+  optionsSchema?: z.ZodObject
   /**
    * Priority level for the command.
    * Higher priority commands will be loaded first.
@@ -57,7 +57,7 @@ export interface CommandOptions {
  * @example
  * ```typescript
  * import { Command, CommandHandler } from '@navios/commander'
- * import { z } from 'zod'
+ * import { z } from 'zod/v4'
  *
  * const optionsSchema = z.object({
  *   name: z.string(),

package/src/define-environment.mts

@@ -1,10 +1,10 @@
-import type { AnyInjectableType, InjectionToken } from '@navios/core'
-
 import { AdapterToken } from '@navios/core'
 
-import { CommanderAdapterService } from './services/commander-adapter.service.mjs'
-import { CommandRegistryService } from './services/command-registry.service.mjs'
+import type { AnyInjectableType, InjectionToken } from '@navios/core'
+
 import { CliParserService } from './services/cli-parser.service.mjs'
+import { CommandRegistryService } from './services/command-registry.service.mjs'
+import { CommanderAdapterService } from './services/commander-adapter.service.mjs'
 
 /**
  * Defines the CLI environment configuration for use with NaviosFactory.