@tsed/cli-mcp 7.0.0-beta.3

package/lib/types/fn/definePrompt.d.ts

@@ -0,0 +1,45 @@
+import type { McpServer, PromptCallback } from "@modelcontextprotocol/sdk/server/mcp.js";
+import { type TokenProvider } from "@tsed/di";
+export type PromptProps = Parameters<McpServer["registerPrompt"]>[1] & {
+    token?: TokenProvider;
+    name: string;
+    handler: PromptCallback;
+};
+/**
+ * Prompts are reusable templates that help humans prompt models to interact with your server.
+ * They're designed to be user-driven, and might appear as slash commands in a chat interface.
+ *
+ * ```ts
+ * import {definePrompt} from "@tsed/cli-mcp";
+ *
+ * export default definePrompt({
+ *   name: "review-code",
+ *   title: 'Code review',
+ *   description: 'Review code for best practices and potential issues',
+ *   argsSchema: { code: z.string() }
+ *   handler: ({ code }) => ({
+ *     messages: [
+ *       {
+ *         role: 'user',
+ *         content: {
+ *           type: 'text',
+ *           text: `Please review this code:\n\n${code}`
+ *         }
+ *       }
+ *     ]
+ *   })
+ * });
+ * ```
+ *
+ * @param options {PromptProps}
+ */
+export declare function definePrompt(options: PromptProps): import("@tsed/cli-core").FactoryTokenProvider<{
+    handler(...args: any[]): Promise<any>;
+    title?: string;
+    description?: string;
+    argsSchema?: {
+        [k: string]: import("zod").ZodType<string, import("zod").ZodTypeDef, string> | import("zod").ZodOptional<import("zod").ZodType<string, import("zod").ZodTypeDef, string>>;
+    } | undefined;
+    token?: TokenProvider;
+    name: string;
+}>;

package/lib/types/fn/defineResource.d.ts

@@ -0,0 +1,46 @@
+import type { ReadResourceCallback, ResourceMetadata } from "@modelcontextprotocol/sdk/server/mcp.js";
+import { type TokenProvider } from "@tsed/di";
+type ResourceBaseProps = ResourceMetadata & {
+    token?: TokenProvider;
+    name: string;
+};
+type ResourceReadProps = ResourceBaseProps & {
+    uri: string;
+    handler: ReadResourceCallback;
+};
+type ResourceTemplateProps = ResourceBaseProps & {
+    uri: string;
+    handler: ReadResourceCallback;
+};
+export type ResourceProps = ResourceReadProps | ResourceTemplateProps;
+/**
+ * Resources can also expose data to LLMs, but unlike tools shouldn't perform significant computation or have side effects.
+ *
+ * Resources are designed to be used in an application-driven way, meaning MCP client applications can decide how to expose them. For example, a client could expose a resource picker to the human, or could expose them to the model directly.
+ *
+ * ```ts
+ * import {defineResource} from "@tsed/cli-mcp";
+ *
+ * export default defineResource({
+ *   name: "config",
+ *   uri: "config://app",
+ *   title: 'Application Config',
+ *   description: 'Application configuration data',
+ *   mimeType: 'text/plain'
+ *   handler(uri) {
+ *     return {
+ *      contents: [
+ *        {
+ *          uri: uri.href,
+ *          text: 'App configuration here'
+ *        }
+ *      ]
+ *   }
+ * });
+ * ```
+ *
+ * @param options
+ */
+export declare function defineResource(options: ResourceReadProps): TokenProvider;
+export declare function defineResource(options: ResourceTemplateProps): TokenProvider;
+export {};

package/lib/types/fn/defineTool.d.ts

@@ -0,0 +1,129 @@
+import type { McpServer } from "@modelcontextprotocol/sdk/server/mcp.js";
+import type { RequestHandlerExtra } from "@modelcontextprotocol/sdk/shared/protocol.js";
+import type { CallToolResult, ServerNotification, ServerRequest, Tool } from "@modelcontextprotocol/sdk/types.js";
+import { type TokenProvider } from "@tsed/di";
+import { JsonSchema } from "@tsed/schema";
+export type ToolCallback<Args = undefined> = (args: Args, extra: RequestHandlerExtra<ServerRequest, ServerNotification>) => CallToolResult | Promise<CallToolResult>;
+type ToolConfig = Parameters<McpServer["registerTool"]>[1];
+export type ToolProps<Input, Output> = Omit<ToolConfig, "inputSchema" | "outputSchema"> & {
+    token?: TokenProvider;
+    name: string;
+    inputSchema?: JsonSchema<Input> | Tool["inputSchema"];
+    outputSchema?: JsonSchema<Output> | Tool["outputSchema"];
+    handler: ToolCallback<Input>;
+};
+/**
+ * Tools let LLMs take actions through your server. Tools can perform computation, fetch data and have side effects.
+ * Tools should be designed to be model-controlled - i.e. AI models will decide which tools to call, and the arguments.
+ *
+ * ```typescript
+ * import {defineTool} from "@tsed/cli-mcp";
+ * import {s} from "@tsed/schema";
+ *
+ * export default defineTool({
+ *  name: "my-tool",
+ *  title: "My Tool",
+ *  description: "My tool description",
+ *  inputSchema: s.object({
+ *    param1: s.string().required() // also support Zod
+ *  }),
+ *  outputSchema: s.object({
+ *     result: s.string().required() // also support Zod
+ *  }),
+ *  handler(args) {
+ *    return {
+ *      content: [],
+ *      structuredContent: {
+ *        result: "Hello World!"
+ *      }
+ *    }
+ * });
+ * ```
+ *
+ * @param options
+ */
+export declare function defineTool<Input, Output = undefined>(options: ToolProps<Input, Output>): import("@tsed/cli-core").FactoryTokenProvider<{
+    inputSchema: Record<string, import("zod").AnyZodObject> | undefined;
+    outputSchema: Record<string, import("zod").AnyZodObject> | undefined;
+    handler(args: Input, extra: RequestHandlerExtra<ServerRequest, ServerNotification>): Promise<{
+        [x: string]: unknown;
+        content: ({
+            [x: string]: unknown;
+            type: "text";
+            text: string;
+            _meta?: {
+                [x: string]: unknown;
+            } | undefined;
+        } | {
+            [x: string]: unknown;
+            type: "image";
+            data: string;
+            mimeType: string;
+            _meta?: {
+                [x: string]: unknown;
+            } | undefined;
+        } | {
+            [x: string]: unknown;
+            type: "audio";
+            data: string;
+            mimeType: string;
+            _meta?: {
+                [x: string]: unknown;
+            } | undefined;
+        } | {
+            [x: string]: unknown;
+            type: "resource_link";
+            name: string;
+            uri: string;
+            _meta?: {
+                [x: string]: unknown;
+            } | undefined;
+            description?: string | undefined;
+            mimeType?: string | undefined;
+            title?: string | undefined;
+            icons?: {
+                [x: string]: unknown;
+                src: string;
+                mimeType?: string | undefined;
+                sizes?: string[] | undefined;
+            }[] | undefined;
+        } | {
+            [x: string]: unknown;
+            type: "resource";
+            resource: {
+                [x: string]: unknown;
+                text: string;
+                uri: string;
+                _meta?: {
+                    [x: string]: unknown;
+                } | undefined;
+                mimeType?: string | undefined;
+            } | {
+                [x: string]: unknown;
+                uri: string;
+                blob: string;
+                _meta?: {
+                    [x: string]: unknown;
+                } | undefined;
+                mimeType?: string | undefined;
+            };
+            _meta?: {
+                [x: string]: unknown;
+            } | undefined;
+        })[];
+        _meta?: {
+            [x: string]: unknown;
+        } | undefined;
+        structuredContent?: {
+            [x: string]: unknown;
+        } | undefined;
+        isError?: boolean | undefined;
+    }>;
+    _meta?: Record<string, unknown> | undefined;
+    description?: string | undefined;
+    title?: string | undefined;
+    annotations?: import("@modelcontextprotocol/sdk/types.js").ToolAnnotations | undefined;
+    token?: TokenProvider;
+    name: string;
+}>;
+export {};

package/lib/types/index.d.ts

@@ -0,0 +1,4 @@
+export * from "./fn/definePrompt.js";
+export * from "./fn/defineResource.js";
+export * from "./fn/defineTool.js";
+export * from "./services/CLIMCPServer.js";

package/lib/types/interfaces/interfaces.d.ts

@@ -0,0 +1,13 @@
+import type { TokenProvider } from "@tsed/di";
+declare global {
+    namespace TsED {
+        interface Configuration {
+            prompts?: TokenProvider[];
+            resources?: TokenProvider[];
+            tools?: TokenProvider[];
+            mcp?: {
+                mode: "streamable-http" | "stdio";
+            };
+        }
+    }
+}

package/lib/types/services/CLIMCPServer.d.ts

@@ -0,0 +1,6 @@
+import "./McpServerFactory.js";
+export declare class CLIMCPServer {
+    protected constructor(settings: Partial<TsED.Configuration>);
+    static bootstrap(settings: Partial<TsED.Configuration>): Promise<void>;
+    bootstrap(): Promise<void>;
+}

package/lib/types/services/McpServerFactory.d.ts

@@ -0,0 +1,6 @@
+import { McpServer } from "@modelcontextprotocol/sdk/server/mcp.js";
+export declare const MCP_SERVER: import("@tsed/di").FactoryTokenProvider<{
+    server: McpServer;
+    connect(): Promise<void>;
+}>;
+export type MCP_SERVER = typeof MCP_SERVER;

package/lib/types/services/McpStdioServer.d.ts

@@ -0,0 +1,2 @@
+import type { McpServer } from "@modelcontextprotocol/sdk/server/mcp.js";
+export declare function mcpStdioServer(server: McpServer): Promise<void>;

package/lib/types/services/McpStreamableServer.d.ts

@@ -0,0 +1,2 @@
+import type { McpServer } from "@modelcontextprotocol/sdk/server/mcp.js";
+export declare function mcpStreamableServer(server: McpServer): Promise<void>;

package/lib/types/utils/toZod.d.ts

@@ -0,0 +1,2 @@
+import { type AnyZodObject } from "zod";
+export declare function toZod(schema: unknown): Record<string, AnyZodObject> | undefined;

package/package.json

@@ -0,0 +1,125 @@
+{
+  "name": "@tsed/cli-mcp",
+  "description": "MCP CLI for Ts.ED.",
+  "version": "7.0.0-beta.3",
+  "type": "module",
+  "main": "./lib/esm/index.js",
+  "source": "./src/index.ts",
+  "module": "./lib/esm/index.js",
+  "typings": "./lib/types/index.d.ts",
+  "exports": {
+    ".": {
+      "cli-tsed-source": "./src/index.ts",
+      "types": "./lib/types/index.d.ts",
+      "import": "./lib/esm/index.js",
+      "default": "./lib/esm/index.js"
+    }
+  },
+  "scripts": {
+    "build": "yarn build:ts",
+    "build:ts": "tsc --build tsconfig.esm.json",
+    "test": "vitest run",
+    "test:ci": "vitest run --coverage.thresholds.autoUpdate=true"
+  },
+  "bin": {
+    "tsed": "lib/esm/bin/tsed.js",
+    "tsed-mcp": "lib/esm/bin/tsed-mcp.js"
+  },
+  "files": [
+    "lib/esm/bin/tsed.js",
+    "lib/esm/bin/tsed-mcp.js",
+    "lib/esm/bin",
+    "lib",
+    "templates"
+  ],
+  "keywords": [
+    "Ts.ED",
+    "cli",
+    "typescript",
+    "framework",
+    "rest",
+    "api",
+    "express",
+    "decorators"
+  ],
+  "engines": {
+    "node": ">=14"
+  },
+  "dependencies": {
+    "@modelcontextprotocol/sdk": "^1.19.1",
+    "@swc-node/register": "^1.10.9",
+    "@swc/core": "1.7.26",
+    "@swc/helpers": "^0.5.13",
+    "@tsed/cli-core": "7.0.0-beta.3",
+    "@tsed/core": ">=8.18.0",
+    "@tsed/di": ">=8.18.0",
+    "@tsed/hooks": ">=8.18.0",
+    "@tsed/logger": ">=8.0.3",
+    "@tsed/logger-std": ">=8.0.3",
+    "@tsed/normalize-path": ">=8.18.0",
+    "@tsed/openspec": ">=8.18.0",
+    "@tsed/schema": ">=8.18.0",
+    "chalk": "^5.3.0",
+    "change-case": "^5.4.4",
+    "consolidate": "^1.0.4",
+    "create-frame": "^1.0.0",
+    "fs-extra": "^11.2.0",
+    "globby": "^14.0.2",
+    "read-pkg-up": "^11.0.0",
+    "rxjs": "^7.8.1",
+    "semver": "^7.6.3",
+    "ts-morph": "27.0.0",
+    "tslib": "^2.7.0"
+  },
+  "devDependencies": {
+    "@tsed/typescript": "7.0.0-beta.3",
+    "@types/change-case": "^2.3.1",
+    "@types/consolidate": "0.14.4",
+    "cross-env": "7.0.3",
+    "express": "5.1.0",
+    "typescript": "5.6.2",
+    "vitest": "3.2.4"
+  },
+  "peerDependencies": {
+    "@tsed/core": ">=8.0.0",
+    "@tsed/di": ">=8.0.0",
+    "@tsed/hooks": ">=8.0.0",
+    "@tsed/logger": ">=8.0.2",
+    "@tsed/logger-std": ">=8.0.2",
+    "@tsed/openspec": ">=8.0.0",
+    "@tsed/schema": ">=8.0.0"
+  },
+  "peerDependenciesMeta": {
+    "@tsed/core": {
+      "optional": false
+    },
+    "@tsed/di": {
+      "optional": false
+    },
+    "@tsed/hooks": {
+      "optional": false
+    },
+    "@tsed/logger": {
+      "optional": false
+    },
+    "@tsed/logger-std": {
+      "optional": false
+    },
+    "@tsed/openspec": {
+      "optional": false
+    },
+    "@tsed/schema": {
+      "optional": false
+    }
+  },
+  "repository": "https://github.com/tsedio/tsed-cli",
+  "bugs": {
+    "url": "https://github.com/tsedio/tsed-cli/issues"
+  },
+  "homepage": "https://github.com/tsedio/tsed-cli/tree/master/packages/cli-mcp",
+  "author": "Romain Lenzotti",
+  "license": "MIT",
+  "publishConfig": {
+    "tag": "beta"
+  }
+}

package/readme.md

@@ -0,0 +1,241 @@
+# @tsed/cli-mcp
+
+<p style="text-align: center" align="center">
+ <a href="https://tsed.dev" target="_blank"><img src="https://tsed.dev/tsed-og.png" width="200" alt="Ts.ED logo"/></a>
+</p>
+
+[![Build & Release](https://github.com/tsedio/tsed-cli/workflows/Build%20&%20Release/badge.svg?branch=master)](https://github.com/tsedio/tsed-cli/actions?query=workflow%3A%22Build+%26+Release%22)
+[![npm version](https://img.shields.io/npm/v/%40tsed/cli-mcp.svg)](https://www.npmjs.com/package/@tsed/cli-mcp)
+[![semantic-release](https://img.shields.io/badge/%20%20%F0%9F%93%A6%F0%9F%9A%80-semantic--release-e10079.svg)](https://github.com/semantic-release/semantic-release)
+
+> Model Context Protocol (MCP) server tooling for Ts.ED and the Ts.ED CLI.
+
+This package provides:
+
+- A lightweight bootstrapper to run an MCP server over stdio (`CLIMCPServer`).
+- Simple helpers to declare MCP entities with Ts.ED DI context: `defineTool`, `defineResource`, and `definePrompt`.
+- Utilities to bridge `@tsed/schema` and Zod for MCP schemas.
+
+It can be used to expose Ts.ED CLI features to your AI client (e.g., Claude Desktop) or to build your own MCP server in a Ts.ED application or script.
+
+## Requirements
+
+- Node.js >= 14 (per package `engines`)
+- ESM module support
+
+## Installation
+
+```bash
+# with npm
+npm i @tsed/cli-mcp
+# or with yarn
+yarn add @tsed/cli-mcp
+# or with pnpm
+pnpm add @tsed/cli-mcp
+```
+
+## Quick start
+
+The fastest way to start an MCP server is to:
+
+1. Define one or more tools/resources/prompts with the helpers.
+2. Bootstrap the server with `CLIMCPServer.bootstrap`.
+
+### 1) Define a Tool
+
+```ts
+import {defineTool} from "@tsed/cli-mcp";
+import {s} from "@tsed/schema"; // or use zod directly
+
+export const helloTool = defineTool({
+  name: "hello",
+  title: "Hello",
+  description: "Returns a friendly greeting",
+  inputSchema: s.object({name: s.string().required()}), // also supports Zod
+  outputSchema: s.object({message: s.string().required()}),
+  async handler({name}) {
+    return {
+      content: [],
+      structuredContent: {message: `Hello, ${name}!`}
+    };
+  }
+});
+```
+
+### 2) Define a Resource (optional)
+
+```ts
+import {defineResource} from "@tsed/cli-mcp";
+
+export const configResource = defineResource({
+  name: "config",
+  uri: "config://app",
+  title: "Application Config",
+  description: "Current app configuration",
+  mimeType: "text/plain",
+  handler(uri) {
+    return {
+      contents: [
+        {
+          uri: uri.href,
+          text: "App configuration here"
+        }
+      ]
+    };
+  }
+});
+```
+
+### 3) Define a Prompt (optional)
+
+```ts
+import {definePrompt} from "@tsed/cli-mcp";
+import {z} from "zod";
+
+export const reviewPrompt = definePrompt({
+  name: "review-code",
+  title: "Code review",
+  description: "Review code for best practices and potential issues",
+  argsSchema: z.object({code: z.string()}),
+  handler: ({code}) => ({
+    messages: [
+      {
+        role: "user",
+        content: {type: "text", text: `Please review this code:\n\n${code}`}
+      }
+    ]
+  })
+});
+```
+
+### 4) Bootstrap the MCP server (stdio)
+
+```ts
+import {CLIMCPServer} from "@tsed/cli-mcp";
+import type {TokenProvider} from "@tsed/di";
+import {helloTool} from "./tools/helloTool";
+import {configResource} from "./resources/configResource";
+import {reviewPrompt} from "./prompts/reviewPrompt";
+
+await CLIMCPServer.bootstrap({
+  name: "my-mcp-server",
+  version: "0.0.0",
+  tools: [helloTool],
+  resources: [configResource],
+  prompts: [reviewPrompt]
+});
+```
+
+The server will start over stdio using `@modelcontextprotocol/sdk`'s `StdioServerTransport`. You can then register it in any MCP-compatible client.
+
+## Using with Ts.ED CLI
+
+The Ts.ED CLI ships a binary that exposes CLI features over MCP using this package. Once installed, you can run:
+
+```bash
+npx tsed-mcp
+```
+
+One built‑in example tool is `generate-file`, which leverages the CLI generators:
+
+```ts
+import {defineTool} from "@tsed/cli-mcp";
+import {object, string, array, number} from "@tsed/schema";
+import {inject} from "@tsed/di";
+import {CliProjectService} from "@tsed/cli";
+import {CliTemplatesService} from "@tsed/cli";
+
+export const generateTool = defineTool({
+  name: "generate-file",
+  title: "Generate file",
+  description: "Generate a new Ts.ED provider class depending on the given parameters.",
+  inputSchema: object({
+    type: string().required(),
+    name: string().required(),
+    route: string(),
+    directory: string(),
+    templateType: string(),
+    middlewarePosition: string()
+  }),
+  outputSchema: object({
+    files: array().items(string()),
+    count: number()
+  }),
+  async handler(args) {
+    const project = inject(CliProjectService);
+    const templates = inject(CliTemplatesService);
+    // map args to template options, render and transform files...
+    await project.createFromTemplate(args.type as any, args as any);
+    await project.transformFiles(args as any);
+    return {content: [], structuredContent: {files: templates.renderedFiles, count: templates.renderedFiles.length}};
+  }
+});
+```
+
+## API Overview
+
+- `defineTool(options)`
+  - Registers an MCP tool inside Ts.ED DI and ensures the handler runs inside a `DIContext`.
+  - Accepts `inputSchema`/`outputSchema` as `@tsed/schema` or Zod. `@tsed/schema` is automatically converted to Zod.
+- `defineResource(options)`
+  - Registers an MCP resource (static `uri` or `template`) with a DI‑aware handler.
+- `definePrompt(options)`
+  - Registers a reusable prompt template available to clients.
+- `CLIMCPServer.bootstrap(settings)`
+  - Creates the Ts.ED injector, loads plugins, registers provided tools/resources/prompts, and starts MCP over stdio.
+
+### Schema note
+
+This package includes a small helper to convert `@tsed/schema` to Zod at runtime so you can write your schemas once:
+
+```ts
+import {s} from "@tsed/schema";
+// under the hood we transform JsonSchema -> Zod for MCP SDK
+```
+
+## Configuration reference
+
+`CLIMCPServer.bootstrap(settings: Partial<TsED.Configuration>)` supports all usual Ts.ED CLI settings plus:
+
+- `name`: MCP server name (string)
+- `version`: MCP server version (string)
+- `tools`: `TokenProvider[]` returned by `defineTool`
+- `resources`: `TokenProvider[]` returned by `defineResource`
+- `prompts`: `TokenProvider[]` returned by `definePrompt`
+- `logger.level`: log level (e.g., `info`, `debug`)
+
+## Contributors
+
+Please read [contributing guidelines here](https://tsed.dev/CONTRIBUTING.html)
+
+<a href="https://github.com/tsedio/ts-express-decorators/graphs/contributors"><img src="https://opencollective.com/tsed/contributors.svg?width=890" /></a>
+
+## Backers
+
+Thank you to all our backers! 🙏 [[Become a backer](https://opencollective.com/tsed#backer)]
+
+<a href="https://opencollective.com/tsed#backers" target="_blank"><img src="https://opencollective.com/tsed/tiers/backer.svg?width=890"></a>
+
+## Sponsors
+
+Support this project by becoming a sponsor. Your logo will show up here with a link to your
+website. [[Become a sponsor](https://opencollective.com/tsed#sponsor)]
+
+## License
+
+The MIT License (MIT)
+
+Copyright (c) 2016 - Today Romain Lenzotti
+
+Permission is hereby granted, free of charge, to any person obtaining a copy of this software and associated
+documentation files (the "Software"), to deal in the Software without restriction, including without limitation the
+rights to use, copy, modify, merge, publish, distribute, sublicense, and/or sell copies of the Software, and to permit
+persons to whom the Software is furnished to do so, subject to the following conditions:
+
+The above copyright notice and this permission notice shall be included in all copies or substantial portions of the
+Software.
+
+THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE
+WARRANTIES OF MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE AUTHORS OR
+COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR
+OTHERWISE, ARISING FROM, OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE SOFTWARE.