@tsed/cli 7.0.0-beta.3 → 7.0.0-beta.4

package/lib/esm/bin/tsed.js

@@ -15,7 +15,7 @@ register(pathToFileURL(join(import.meta.dirname, `../loaders/alias.hook.${EXT}`)
     },
     transferList: []
 });
-const { commands, CliCore, PKG, TEMPLATE_DIR, ArchitectureConvention, ProjectConvention } = await import("../index.js");
+const { tools, commands, resources, CliCore, PKG, TEMPLATE_DIR, ArchitectureConvention, ProjectConvention } = await import("../index.js");
 CliCore.bootstrap({
     name: "tsed",
     pkg: PKG,
@@ -24,6 +24,8 @@ CliCore.bootstrap({
     updateNotifier: true,
     checkPrecondition: true,
     commands,
+    tools,
+    resources,
     defaultProjectPreferences() {
         return {
             convention: ProjectConvention.DEFAULT,

package/lib/esm/commands/add/AddCmd.js

@@ -41,7 +41,8 @@ export class AddCmd {
         ];
     }
 }
-command(AddCmd, {
+command({
+    token: AddCmd,
     name: "add",
     description: "Add cli plugin to the current project",
     args: {

package/lib/esm/commands/generate/GenerateCmd.js

@@ -63,7 +63,8 @@ export class GenerateCmd {
         ];
     }
 }
-command(GenerateCmd, {
+command({
+    token: GenerateCmd,
     name: "generate",
     alias: "g",
     description: "Generate a new provider class",

package/lib/esm/commands/index.js

@@ -1,7 +1,9 @@
 import { AddCmd } from "./add/AddCmd.js";
 import { GenerateCmd } from "./generate/GenerateCmd.js";
 import { InitCmd } from "./init/InitCmd.js";
+import { InitOptionsCommand } from "./init/InitOptionsCmd.js";
+import { McpCommand } from "./mcp/McpCommand.js";
 import { RunCmd } from "./run/RunCmd.js";
 import { CreateTemplateCommand } from "./template/CreateTemplateCommand.js";
 import { UpdateCmd } from "./update/UpdateCmd.js";
-export default [AddCmd, InitCmd, GenerateCmd, UpdateCmd, RunCmd, CreateTemplateCommand];
+export default [AddCmd, InitCmd, InitOptionsCommand, GenerateCmd, UpdateCmd, RunCmd, CreateTemplateCommand, McpCommand];

package/lib/esm/commands/init/InitCmd.js

@@ -1,16 +1,14 @@
 import { basename, join } from "node:path";
-import { CliExeca, CliFs, CliLoadFile, cliPackageJson, CliPlugins, command, Configuration, createSubTasks, createTasksRunner, inject, PackageManager, PackageManagersModule, ProjectPackageJson } from "@tsed/cli-core";
+import { CliExeca, CliFs, CliLoadFile, cliPackageJson, CliPlugins, command, Configuration, createSubTasks, createTasksRunner, inject, PackageManagersModule, ProjectPackageJson } from "@tsed/cli-core";
 import { isString } from "@tsed/core";
 import { constant } from "@tsed/di";
 import { $asyncAlter } from "@tsed/hooks";
 import { kebabCase } from "change-case";
-import { DEFAULT_TSED_TAGS, TEMPLATE_DIR } from "../../constants/index.js";
+import { TEMPLATE_DIR } from "../../constants/index.js";
 import { exec } from "../../fn/exec.js";
 import { render } from "../../fn/render.js";
 import { taskOutput } from "../../fn/taskOutput.js";
-import { ArchitectureConvention } from "../../interfaces/ArchitectureConvention.js";
-import { PlatformType } from "../../interfaces/index.js";
-import { ProjectConvention } from "../../interfaces/ProjectConvention.js";
+import {} from "../../interfaces/index.js";
 import { PlatformsModule } from "../../platforms/PlatformsModule.js";
 import { RuntimesModule } from "../../runtimes/RuntimesModule.js";
 import { BunRuntime } from "../../runtimes/supports/BunRuntime.js";
@@ -34,45 +32,14 @@ export class InitCmd {
         this.execa = inject(CliExeca);
         this.fs = inject(CliFs);
     }
-    checkPrecondition(ctx) {
-        const isValid = (types, value) => (value ? Object.values(types).includes(value) : true);
-        if (!isValid(PlatformType, ctx.platform)) {
-            throw new Error(`Invalid selected platform: ${ctx.platform}. Possible values: ${Object.values(PlatformType).join(", ")}.`);
-        }
-        if (!isValid(ArchitectureConvention, ctx.architecture)) {
-            throw new Error(`Invalid selected architecture: ${ctx.architecture}. Possible values: ${Object.values(ArchitectureConvention).join(", ")}.`);
-        }
-        if (!isValid(ProjectConvention, ctx.convention)) {
-            throw new Error(`Invalid selected convention: ${ctx.convention}. Possible values: ${Object.values(ProjectConvention).join(", ")}.`);
-        }
-        const runtimes = this.runtimes.list();
-        if (!runtimes.includes(ctx.runtime)) {
-            throw new Error(`Invalid selected runtime: ${ctx.runtime}. Possible values: ${runtimes.join(", ")}.`);
-        }
-        const managers = this.packageManagers.list();
-        if (!managers.includes(ctx.packageManager)) {
-            throw new Error(`Invalid selected package manager: ${ctx.packageManager}. Possible values: ${managers.join(", ")}.`);
-        }
-        if (ctx.features) {
-            ctx.features.forEach((value) => {
-                const feature = FeaturesMap[value.toLowerCase()];
-                if (!feature) {
-                    throw new Error(`Invalid selected feature: ${value}. Possible values: ${Object.values(FeatureType).join(", ")}.`);
-                }
-            });
-        }
-    }
-    async $beforePrompt(initialOptions) {
+    async $prompt(initialOptions) {
         if (initialOptions.file) {
             const file = join(this.packageJson.cwd, initialOptions.file);
-            return {
+            initialOptions = {
                 ...initialOptions,
-                ...(await this.cliLoadFile.loadFile(file, InitSchema))
+                ...(await this.cliLoadFile.loadFile(file, InitSchema()))
             };
         }
-        return initialOptions;
-    }
-    $prompt(initialOptions) {
         if (initialOptions.skipPrompt) {
             return [];
         }
@@ -108,7 +75,7 @@ export class InitCmd {
             srcDir: constant("project.srcDir", "src")
         };
     }
-    async $beforeExec(ctx) {
+    async $exec(ctx) {
         this.fs.ensureDirSync(this.packageJson.cwd);
         ctx.projectName && (this.packageJson.name = ctx.projectName);
         ctx.packageManager && this.packageJson.setPreference("packageManager", ctx.packageManager);
@@ -148,9 +115,6 @@ export class InitCmd {
                 task: createSubTasks(() => this.cliPlugins.addPluginsDependencies(ctx), { ...ctx, concurrent: false })
             }
         ], ctx);
-    }
-    async $exec(ctx) {
-        this.checkPrecondition(ctx);
         const runtime = this.runtimes.get();
         ctx = {
             ...ctx,
@@ -355,67 +319,10 @@ export class InitCmd {
         taskOutput(`Plugins files rendered (${Date.now() - startTime}ms)`);
     }
 }
-command(InitCmd, {
+command({
+    token: InitCmd,
     name: "init",
     description: "Init a new Ts.ED project",
-    args: {
-        root: {
-            type: String,
-            defaultValue: ".",
-            description: "Root directory to initialize the Ts.ED project"
-        }
-    },
-    options: {
-        "-n, --project-name <projectName>": {
-            type: String,
-            defaultValue: "",
-            description: "Set the project name. By default, the project is the same as the name directory."
-        },
-        "-a, --arch <architecture>": {
-            type: String,
-            defaultValue: ArchitectureConvention.DEFAULT,
-            description: `Set the default architecture convention (${ArchitectureConvention.DEFAULT} or ${ArchitectureConvention.FEATURE})`
-        },
-        "-c, --convention <convention>": {
-            type: String,
-            defaultValue: ProjectConvention.DEFAULT,
-            description: `Set the default project convention (${ArchitectureConvention.DEFAULT} or ${ArchitectureConvention.FEATURE})`
-        },
-        "-p, --platform <platform>": {
-            type: String,
-            defaultValue: PlatformType.EXPRESS,
-            description: "Set the default platform for Ts.ED (express, koa or fastify)"
-        },
-        "--features <features...>": {
-            type: Array,
-            itemType: String,
-            defaultValue: [],
-            description: "List of the Ts.ED features."
-        },
-        "--runtime <runtime>": {
-            itemType: String,
-            defaultValue: "node",
-            description: "The default runtime used to run the project"
-        },
-        "-m, --package-manager <packageManager>": {
-            itemType: String,
-            defaultValue: PackageManager.YARN,
-            description: "The default package manager to install the project"
-        },
-        "-t, --tsed-version <version>": {
-            type: String,
-            defaultValue: DEFAULT_TSED_TAGS,
-            description: "Use a specific version of Ts.ED (format: 5.x.x)."
-        },
-        "-f, --file <path>": {
-            type: String,
-            description: "Location of a file in which the features are defined."
-        },
-        "-s, --skip-prompt": {
-            type: Boolean,
-            defaultValue: false,
-            description: "Skip the prompt."
-        }
-    },
+    inputSchema: InitSchema,
     disableReadUpPkg: true
 });

package/lib/esm/commands/init/InitOptionsCmd.js

@@ -0,0 +1,17 @@
+import { command } from "@tsed/cli-core";
+import { s } from "@tsed/schema";
+import { InitSchema } from "./config/InitSchema.js";
+export const InitOptionsCommand = command({
+    name: "init-options",
+    description: "Display available options for Ts.ED init command for external tool",
+    disableReadUpPkg: true,
+    inputSchema: s.object({
+        indent: s.number().default(0).description("Json indentation value").opt("-i, --indent <indent>")
+    }),
+    handler(data) {
+        console.log(JSON.stringify(InitSchema().toJSON({
+            useAlias: false,
+            customKeys: true
+        }), null, data.indent));
+    }
+}).token();

package/lib/esm/commands/init/config/FeaturesPrompt.js

@@ -9,7 +9,7 @@ export var FeatureType;
     FeatureType["PASSPORTJS"] = "passportjs";
     FeatureType["CONFIG"] = "config";
     FeatureType["COMMANDS"] = "commands";
-    FeatureType["DB"] = "db";
+    FeatureType["ORM"] = "orm";
     FeatureType["DOC"] = "doc";
     // CONFIG
     FeatureType["CONFIG_ENVS"] = "config:envs";
@@ -22,35 +22,35 @@ export var FeatureType;
     FeatureType["CONFIG_VAULT"] = "config:vault:premium";
     FeatureType["CONFIG_POSTGRES"] = "config:postgres:premium";
     // DOC
-    FeatureType["SWAGGER"] = "swagger";
-    FeatureType["SCALAR"] = "scalar";
+    FeatureType["SWAGGER"] = "doc:swagger";
+    FeatureType["SCALAR"] = "doc:scalar";
     // ORM
-    FeatureType["PRISMA"] = "prisma";
-    FeatureType["MONGOOSE"] = "mongoose";
+    FeatureType["PRISMA"] = "orm:prisma";
+    FeatureType["MONGOOSE"] = "orm:mongoose";
     // TYPEORM
-    FeatureType["TYPEORM"] = "typeorm";
-    FeatureType["TYPEORM_MYSQL"] = "typeorm:mysql";
-    FeatureType["TYPEORM_MARIADB"] = "typeorm:mariadb";
-    FeatureType["TYPEORM_POSTGRES"] = "typeorm:postgres";
-    FeatureType["TYPEORM_COCKROACHDB"] = "typeorm:cockroachdb";
-    FeatureType["TYPEORM_SQLITE"] = "typeorm:sqlite";
-    FeatureType["TYPEORM_BETTER_SQLITE3"] = "typeorm:better-sqlite3";
-    FeatureType["TYPEORM_CORDOVA"] = "typeorm:cordova";
-    FeatureType["TYPEORM_NATIVESCRIPT"] = "typeorm:nativescript";
-    FeatureType["TYPEORM_ORACLE"] = "typeorm:oracle";
-    FeatureType["TYPEORM_MSSQL"] = "typeorm:mssql";
-    FeatureType["TYPEORM_MONGODB"] = "typeorm:mongodb";
-    FeatureType["TYPEORM_SQLJS"] = "typeorm:sqljs";
-    FeatureType["TYPEORM_REACTNATIVE"] = "typeorm:reactnative";
-    FeatureType["TYPEORM_EXPO"] = "typeorm:expo";
+    FeatureType["TYPEORM"] = "orm:typeorm";
+    FeatureType["TYPEORM_MYSQL"] = "orm:typeorm:mysql";
+    FeatureType["TYPEORM_MARIADB"] = "orm:typeorm:mariadb";
+    FeatureType["TYPEORM_POSTGRES"] = "orm:typeorm:postgres";
+    FeatureType["TYPEORM_COCKROACHDB"] = "orm:typeorm:cockroachdb";
+    FeatureType["TYPEORM_SQLITE"] = "orm:typeorm:sqlite";
+    FeatureType["TYPEORM_BETTER_SQLITE3"] = "orm:typeorm:better-sqlite3";
+    FeatureType["TYPEORM_CORDOVA"] = "orm:typeorm:cordova";
+    FeatureType["TYPEORM_NATIVESCRIPT"] = "orm:typeorm:nativescript";
+    FeatureType["TYPEORM_ORACLE"] = "orm:typeorm:oracle";
+    FeatureType["TYPEORM_MSSQL"] = "orm:typeorm:mssql";
+    FeatureType["TYPEORM_MONGODB"] = "orm:typeorm:mongodb";
+    FeatureType["TYPEORM_SQLJS"] = "orm:typeorm:sqljs";
+    FeatureType["TYPEORM_REACTNATIVE"] = "orm:typeorm:reactnative";
+    FeatureType["TYPEORM_EXPO"] = "orm:typeorm:expo";
     // TESTING & LINTER
     FeatureType["TESTING"] = "testing";
-    FeatureType["JEST"] = "jest";
-    FeatureType["VITEST"] = "vitest";
+    FeatureType["JEST"] = "testing:jest";
+    FeatureType["VITEST"] = "testing:vitest";
     FeatureType["LINTER"] = "linter";
-    FeatureType["ESLINT"] = "eslint";
-    FeatureType["LINT_STAGED"] = "lintstaged";
-    FeatureType["PRETTIER"] = "prettier";
+    FeatureType["ESLINT"] = "linter:eslint";
+    FeatureType["LINT_STAGED"] = "linter:lintstaged";
+    FeatureType["PRETTIER"] = "linter:prettier";
 })(FeatureType || (FeatureType = {}));
 export const FeaturesMap = {
     [PlatformType.EXPRESS]: {
@@ -77,7 +77,7 @@ export const FeaturesMap = {
     [FeatureType.DOC]: {
         name: "Documentation"
     },
-    [FeatureType.DB]: {
+    [FeatureType.ORM]: {
         name: "Database"
     },
     [FeatureType.PASSPORTJS]: {
@@ -386,11 +386,11 @@ export const FeaturesPrompt = (availableRuntimes, availablePackageManagers) => [
     {
         type: "checkbox",
         name: "features",
-        message: "Check the features needed for your project",
+        message: "Choose the features needed for your project",
         choices: [
             FeatureType.CONFIG,
             FeatureType.GRAPHQL,
-            FeatureType.DB,
+            FeatureType.ORM,
             FeatureType.PASSPORTJS,
             FeatureType.SOCKETIO,
             FeatureType.DOC,
@@ -428,7 +428,7 @@ export const FeaturesPrompt = (availableRuntimes, availablePackageManagers) => [
         message: "Choose a ORM manager",
         type: "list",
         name: "featuresDB",
-        when: hasFeature(FeatureType.DB),
+        when: hasFeature(FeatureType.ORM),
         choices: [FeatureType.PRISMA, FeatureType.MONGOOSE, FeatureType.TYPEORM]
     },
     {

package/lib/esm/commands/init/config/InitSchema.js

@@ -1,27 +1,308 @@
-import { PackageManager } from "@tsed/cli-core";
+import { PackageManager, PackageManagersModule } from "@tsed/cli-core";
+import { inject } from "@tsed/di";
 import { s } from "@tsed/schema";
+import { DEFAULT_TSED_TAGS } from "../../../constants/index.js";
 import { ArchitectureConvention, PlatformType, ProjectConvention } from "../../../interfaces/index.js";
-import { FeatureType } from "./FeaturesPrompt.js";
-export const InitSchema = s
+import { RuntimesModule } from "../../../runtimes/RuntimesModule.js";
+import { FeaturesMap, FeatureType } from "../../init/config/FeaturesPrompt.js";
+export const InitSchema = () => s
     .object({
-    tsedVersion: s.string().optional().description("The CLI will use the given tsed version to generate the project"),
-    projectName: s.string().optional().description("The project name"),
-    platform: s
+    root: s.string().required().description("Current working directory to initialize Ts.ED project"),
+    projectName: s
         .string()
-        .enum(PlatformType)
+        .optional()
+        .prompt("What is your project name")
+        .when((ctx) => ctx.root !== ".")
+        .description("Set the project name. By default, the project is the same as the name directory.")
+        .opt("-n, --project-name <projectName>"),
+    platform: s
+        .enums(PlatformType)
         .default(PlatformType.EXPRESS)
-        .description("Node.js framework used to run server (Express, Koa, Fastify)"),
-    convention: s
+        .prompt("Choose the target Framework:")
+        .choices([
+        {
+            label: "Express.js",
+            value: PlatformType.EXPRESS,
+            checked: (options) => options.platform === PlatformType.EXPRESS || !options.platform // todo maybe it can be infered by default() and item value()
+        },
+        {
+            label: "Koa.js",
+            value: PlatformType.KOA,
+            checked: (options) => options.platform === PlatformType.KOA || !options.platform
+        },
+        {
+            label: "Fastify.js (beta)",
+            value: PlatformType.KOA,
+            checked: (options) => options.platform === PlatformType.KOA || !options.platform
+        }
+    ])
+        .description("Set the default platform for Ts.ED (Express.js, Koa.js or Fastify.js)")
+        .opt("-p, --platform <platform>"),
+    architecture: s
         .string()
-        .enum(ProjectConvention)
+        .enum(ArchitectureConvention)
+        .default(ArchitectureConvention.DEFAULT)
+        .prompt("Choose the architecture for your project:")
+        .description("Architecture convention for tree directory")
+        .choices([
+        {
+            label: "Ts.ED",
+            value: ArchitectureConvention.DEFAULT
+        },
+        {
+            label: "Feature",
+            value: ArchitectureConvention.FEATURE
+        }
+    ])
+        .opt("-a, --arch <architecture>"),
+    convention: s
+        .enums(ProjectConvention)
         .default(ProjectConvention.DEFAULT)
-        .description("Project convention (Ts.ED or Angular style)"),
-    packageManager: s.string().enum(PackageManager).default(PackageManager.NPM).description("Used project manager to install dependencies"),
+        .prompt("Choose the file naming convention:")
+        .description("Set the default file naming convention (Ts.ED, Angular).")
+        .choices([
+        {
+            label: "Ts.ED",
+            value: ProjectConvention.DEFAULT
+        },
+        {
+            label: "Angular",
+            value: ProjectConvention.ANGULAR
+        }
+    ])
+        .opt("-c, --convention <convention>"),
+    features: s
+        .array()
+        .items(s.enums(FeatureType))
+        .prompt("Choose the features needed for your project")
+        .description("List of features to enable (swagger, graphql, prisma, etc.).")
+        .choices([
+        {
+            label: "Commands",
+            value: FeatureType.COMMANDS
+        },
+        {
+            label: "Configuration sources",
+            value: FeatureType.CONFIG,
+            items: [
+                {
+                    label: "Envs",
+                    value: FeatureType.CONFIG_ENVS
+                },
+                {
+                    label: "Dotenv",
+                    value: FeatureType.CONFIG_DOTENV
+                },
+                {
+                    label: "JSON",
+                    value: FeatureType.CONFIG_JSON
+                },
+                {
+                    label: "YAML",
+                    value: FeatureType.CONFIG_YAML
+                },
+                {
+                    label: "AWS Secrets Manager (Premium)",
+                    value: FeatureType.CONFIG_AWS_SECRETS
+                },
+                {
+                    label: "IORedis (Premium)",
+                    value: FeatureType.CONFIG_IOREDIS
+                },
+                {
+                    label: "MongoDB (Premium)",
+                    value: FeatureType.CONFIG_MONGO
+                },
+                {
+                    label: "Vault (Premium)",
+                    value: FeatureType.CONFIG_VAULT
+                },
+                {
+                    label: "Postgres (Premium)",
+                    value: FeatureType.CONFIG_POSTGRES
+                }
+            ]
+        },
+        {
+            label: "ORM",
+            value: FeatureType.ORM,
+            items: [
+                {
+                    label: "Prisma",
+                    value: FeatureType.PRISMA
+                },
+                {
+                    label: "Mongoose",
+                    value: FeatureType.MONGOOSE
+                },
+                {
+                    label: "TypeORM",
+                    value: FeatureType.TYPEORM,
+                    items: [
+                        {
+                            label: "MySQL",
+                            value: FeatureType.TYPEORM_MYSQL
+                        },
+                        {
+                            label: "MariaDB",
+                            value: "db:typeorm:mariadb"
+                        },
+                        {
+                            label: "Postgres",
+                            value: "db:typeorm:postgres"
+                        },
+                        {
+                            label: "CockRoachDB",
+                            value: "db:typeorm:cockroachdb"
+                        },
+                        {
+                            label: "SQLite",
+                            value: "db:typeorm:sqlite"
+                        },
+                        {
+                            label: "Better SQLite3",
+                            value: "db:typeorm:better-sqlite3"
+                        },
+                        {
+                            label: "Cordova",
+                            value: "db:typeorm:cordova"
+                        },
+                        {
+                            label: "NativeScript",
+                            value: "db:typeorm:nativescript"
+                        },
+                        {
+                            label: "Oracle",
+                            value: "db:typeorm:oracle"
+                        },
+                        {
+                            label: "MsSQL",
+                            value: "db:typeorm:mssql"
+                        },
+                        {
+                            label: "MongoDB",
+                            value: "db:typeorm:mongodb"
+                        },
+                        {
+                            label: "SQL.js",
+                            value: "db:typeorm:sqljs"
+                        },
+                        {
+                            label: "ReactNative",
+                            value: "db:typeorm:reactnative"
+                        },
+                        {
+                            label: "Expo",
+                            value: "db:typeorm:expo"
+                        }
+                    ]
+                }
+            ]
+        },
+        {
+            label: "Documentation",
+            value: "doc",
+            items: [
+                {
+                    label: "Swagger",
+                    value: "doc:swagger"
+                },
+                {
+                    label: "Scalar",
+                    value: "doc:scalar"
+                }
+            ]
+        },
+        {
+            label: "TypeGraphQL",
+            value: "graphql",
+            items: []
+        },
+        {
+            label: "Linter",
+            value: "linter",
+            items: [
+                {
+                    label: "EsLint",
+                    value: "linter:eslint"
+                },
+                {
+                    label: "Prettier",
+                    value: "linter:prettier"
+                },
+                {
+                    label: "Lint on commit",
+                    value: "linter:lintstaged"
+                }
+            ]
+        },
+        {
+            label: "OpenID Connect provider",
+            value: "oidc",
+            items: []
+        },
+        {
+            label: "Passport.js",
+            value: "passportjs",
+            items: []
+        },
+        {
+            label: "Socket.io",
+            value: "socketio",
+            items: []
+        },
+        {
+            label: "Testing",
+            value: "testing",
+            items: [
+                {
+                    label: "Vitest",
+                    value: "testing:vitest"
+                },
+                {
+                    label: "Jest (unstable with ESM)",
+                    value: "testing:jest"
+                }
+            ]
+        }
+    ])
+        .opt("--features <features...>"),
     runtime: s
+        .enums(inject(RuntimesModule).list())
+        .default("node")
+        .description("Runtime (node, bun, ...).")
+        .opt("--runtime <runtime>"),
+    packageManager: s
+        .enums(inject(PackageManagersModule).list())
+        .default(PackageManager.NPM)
+        .choices([
+        {
+            label: FeaturesMap[PackageManager.NPM].name,
+            value: PackageManager.NPM
+        },
+        {
+            label: FeaturesMap[PackageManager.YARN_BERRY].name,
+            value: PackageManager.YARN_BERRY
+        },
+        {
+            label: FeaturesMap[PackageManager.PNPM].name,
+            value: PackageManager.PNPM
+        }
+    ])
+        .description("Package manager (npm, pnpm, yarn, bun).")
+        .opt("-m, --package-manager <packageManager>"),
+    GH_TOKEN: s
+        .string()
+        .optional()
+        .description("GitHub token to install premium plugins. For example config:aws_secrets:premium or all features endings by `:premium` needs a GH_TOKEN")
+        .opt("--gh-token <ghToken>"),
+    tsedVersion: s
         .string()
-        .enum("node", "babel", "swc", "webpack", "bun")
-        .description("The javascript runtime used to start application (node, node + webpack, node + swc, node + babel, bun)"),
-    features: s.array().items(s.string().enum(FeatureType)).required().minItems(1).description("List of feature to create the projet"),
-    skipPrompt: s.boolean().default(false).description("Skip the prompt")
+        .optional()
+        .default(DEFAULT_TSED_TAGS)
+        .description("Use a specific version of Ts.ED (format: x.x.x).")
+        .opt("-t, --tsed-version <version>"),
+    file: s.string().optional().description("Location of a file in which the features are defined.").opt("-f, --file <file>"),
+    skipPrompt: s.boolean().optional().default(false).description("Skip the prompt installation").opt("-s, --skip-prompt")
 })
     .unknown();

package/lib/esm/commands/mcp/McpCommand.js

@@ -0,0 +1,15 @@
+import { command } from "@tsed/cli-core";
+import { MCP_SERVER } from "@tsed/cli-mcp";
+import { inject } from "@tsed/di";
+import { s } from "@tsed/schema";
+const McpSchema = s.object({
+    http: s.boolean().default(false).description("Run MCP using HTTP server").opt("--http")
+});
+export const McpCommand = command({
+    name: "mcp",
+    description: "Run a MCP server",
+    inputSchema: McpSchema,
+    handler(data) {
+        return inject(MCP_SERVER).connect(data.http ? "streamable-http" : "stdio");
+    }
+}).token();