hono-mcp 1.3.0

package/README.md

@@ -0,0 +1,249 @@
+# Hono MCP Server
+
+一个基于 [Hono](https://hono.dev/) 构建的 Model Context Protocol (MCP) 服务器，支持多种部署方式。
+
+## ✨ 特性
+
+- 🎯 **装饰器模式**：使用 TypeScript 装饰器优雅地定义 MCP 工具
+- 🚀 **多种部署方式**：支持 Vercel 部署和本地 CLI 运行
+- 🔧 **统一命令接口**：通过 `executeCommand` 和 `help` 两个工具管理所有命令
+- 📦 **即插即用**：通过 `npx` 快速启动，无需复杂配置
+- 🛡️ **类型安全**：使用 TypeScript 和 Zod 进行类型检查和验证
+- 🎨 **易于扩展**：添加新命令只需创建新的装饰器类
+
+## 📦 安装
+
+### 通过 npx 直接运行（推荐）
+
+```bash
+npx hono-mcp
+```
+
+### 全局安装
+
+```bash
+npm install -g hono-mcp
+hono-mcp
+```
+
+### 作为项目依赖安装
+
+```bash
+npm install hono-mcp
+npx hono-mcp
+```
+
+## 🚀 使用方法
+
+### 命令行使用
+
+```bash
+# 使用默认配置（端口 3000）
+npx hono-mcp
+
+# 指定端口
+npx hono-mcp --port 8080
+
+# 指定主机
+npx hono-mcp --host localhost
+
+# 指定环境
+npx hono-mcp --env development
+
+# 组合使用
+npx hono-mcp --port 8080 --host localhost --env development
+
+# 查看帮助
+npx hono-mcp --help
+```
+
+### 环境变量
+
+```bash
+# 设置端口
+export PORT=8080
+npx hono-mcp
+
+# 设置主机
+export HOST=localhost
+npx hono-mcp
+
+# 设置环境
+export NODE_ENV=development
+npx hono-mcp
+```
+
+## 🌐 部署方式
+
+### 方式 1：Vercel 部署
+
+1. **克隆项目**
+
+```bash
+git clone https://github.com/Fromsko/hono-mcp-remote-server.git
+cd hono-mcp-remote-server
+```
+
+2. **安装依赖**
+
+```bash
+bun install
+```
+
+3. **本地开发**
+
+```bash
+bun run dev:vercel
+```
+
+4. **部署到 Vercel**
+
+```bash
+vc deploy
+```
+
+或者通过 Vercel Dashboard 连接 GitHub 仓库进行自动部署。
+
+### 方式 2：本地服务器
+
+1. **克隆项目**
+
+```bash
+git clone https://github.com/Fromsko/hono-mcp-remote-server.git
+cd hono-mcp-remote-server
+```
+
+2. **安装依赖**
+
+```bash
+bun install
+```
+
+3. **构建项目**
+
+```bash
+bun run build
+```
+
+4. **启动服务器**
+
+```bash
+bun run start
+```
+
+或者使用 npx：
+
+```bash
+npx hono-mcp --port 3000
+```
+
+## 📡 API 端点
+
+- **GET `/`** - 服务器信息和可用工具列表
+- **POST `/mcp/*`** - MCP 协议端点，用于工具执行
+- **GET `/help`** - 查看所有可用命令的帮助信息
+- **GET `/vscode`** - VS Code 设置示例
+
+## 🔧 开发
+
+### 本地开发
+
+```bash
+# 安装依赖
+bun install
+
+# 开发模式（CLI）
+bun run dev
+
+# 开发模式（Vercel）
+bun run dev:vercel
+
+# 构建
+bun run build
+
+# 启动生产服务器
+bun run start
+```
+
+### 添加新命令
+
+使用装饰器模式创建新命令非常简单：
+
+```typescript
+import { Command, Param } from '../decorators/command.js'
+import { z } from 'zod'
+import type { CommandHandler } from '../decorators/command.js'
+
+@Command('math.square', 'Calculate the square of a number')
+export class SquareCommand implements CommandHandler {
+  @Param(z.number().describe('The number to square'))
+  number!: number
+
+  async execute() {
+    const result = this.number * this.number
+    return {
+      content: [{ type: 'text', text: `${this.number}² = ${result}` }],
+    }
+  }
+}
+```
+
+然后在 `src/index.ts` 中导入该命令：
+
+```typescript
+import './commands/math.js'
+import './commands/your-new-command.js'
+```
+
+## 📖 使用 MCP 服务器
+
+### 通过 executeCommand 工具
+
+```json
+{
+  "type": "math.add",
+  "params": {
+    "a": 5,
+    "b": 3
+  }
+}
+```
+
+### 通过 help 工具
+
+查看所有可用命令及其描述。
+
+## 🎯 可用命令
+
+当前支持以下数学运算命令：
+
+- `math.add` - 加法运算
+- `math.subtract` - 减法运算
+- `math.multiply` - 乘法运算
+- `math.divide` - 除法运算
+
+## 📚 设计文档
+
+详细的设计文档请参考：[MCP 装饰器模式设计文档](./docs/MCP-装饰器模式设计文档.md)
+
+## 🤝 贡献
+
+欢迎提交 Issue 和 Pull Request！
+
+## 📄 许可证
+
+MIT License
+
+## 🔗 相关链接
+
+- [Hono 文档](https://hono.dev/)
+- [MCP 协议规范](https://modelcontextprotocol.io/)
+- [mcp-handler](https://github.com/modelcontextprotocol/typescript-sdk)
+
+## 📞 联系方式
+
+作者: fromsko
+
+---
+
+**提示**: 使用 `npx hono-mcp --help` 查看完整的命令行选项。

package/dist/cli.js

@@ -0,0 +1,80 @@
+#!/usr/bin/env node
+import { serve } from '@hono/node-server';
+import app from './index.js';
+function parseArgs() {
+    const args = process.argv.slice(2);
+    const options = {};
+    for (let i = 0; i < args.length; i++) {
+        const arg = args[i];
+        if (arg === '--port' || arg === '-p') {
+            options.port = parseInt(args[++i], 10);
+        }
+        else if (arg === '--host' || arg === '-h') {
+            options.host = args[++i];
+        }
+        else if (arg === '--env') {
+            options.env = args[++i];
+        }
+        else if (arg === '--help' || arg === '-help') {
+            console.log(`
+Usage: hono-mcp [options]
+
+Options:
+  --port, -p <port>       Port to listen on (default: 3000)
+  --host, -h <host>       Host to bind to (default: 0.0.0.0)
+  --env <environment>     Environment: development or production (default: production)
+  --help, -help           Show this help message
+
+Examples:
+  hono-mcp                          # Start server on default port 3000
+  hono-mcp --port 8080              # Start server on port 8080
+  hono-mcp --port 8080 --host localhost  # Start on localhost:8080
+  hono-mcp --env development        # Start in development mode
+      `);
+            process.exit(0);
+        }
+    }
+    return options;
+}
+async function main() {
+    const options = parseArgs();
+    const port = options.port || parseInt(process.env.PORT || '3000', 10);
+    const host = options.host || process.env.HOST || '0.0.0.0';
+    const env = options.env || process.env.NODE_ENV || 'production';
+    console.log(`🚀 Starting Hono MCP Server...`);
+    console.log(`📦 Environment: ${env}`);
+    console.log(`🌐 Host: ${host}`);
+    console.log(`🔌 Port: ${port}`);
+    console.log(`📡 MCP Endpoint: http://${host}:${port}/mcp`);
+    console.log(`📖 Help: http://${host}:${port}/help`);
+    console.log('');
+    try {
+        const server = await serve({
+            fetch: app.fetch,
+            port,
+            hostname: host,
+        });
+        console.log(`✅ Server is running!`);
+        console.log(``);
+        console.log(`Press Ctrl+C to stop the server`);
+        process.on('SIGINT', () => {
+            console.log('\n\n🛑 Shutting down server...');
+            server.close(() => {
+                console.log('✅ Server stopped');
+                process.exit(0);
+            });
+        });
+        process.on('SIGTERM', () => {
+            console.log('\n\n🛑 Shutting down server...');
+            server.close(() => {
+                console.log('✅ Server stopped');
+                process.exit(0);
+            });
+        });
+    }
+    catch (error) {
+        console.error('❌ Failed to start server:', error);
+        process.exit(1);
+    }
+}
+main();

package/dist/commands/math.js

@@ -0,0 +1,105 @@
+var __decorate = (this && this.__decorate) || function (decorators, target, key, desc) {
+    var c = arguments.length, r = c < 3 ? target : desc === null ? desc = Object.getOwnPropertyDescriptor(target, key) : desc, d;
+    if (typeof Reflect === "object" && typeof Reflect.decorate === "function") r = Reflect.decorate(decorators, target, key, desc);
+    else for (var i = decorators.length - 1; i >= 0; i--) if (d = decorators[i]) r = (c < 3 ? d(r) : c > 3 ? d(target, key, r) : d(target, key)) || r;
+    return c > 3 && r && Object.defineProperty(target, key, r), r;
+};
+var __metadata = (this && this.__metadata) || function (k, v) {
+    if (typeof Reflect === "object" && typeof Reflect.metadata === "function") return Reflect.metadata(k, v);
+};
+import { z } from 'zod';
+import { Command, Param } from '../decorators/command.js';
+let AddCommand = class AddCommand {
+    a;
+    b;
+    async execute() {
+        const result = this.a + this.b;
+        return {
+            content: [{ type: 'text', text: `${this.a} + ${this.b} = ${result}` }],
+        };
+    }
+};
+__decorate([
+    Param(z.number().describe('First number')),
+    __metadata("design:type", Number)
+], AddCommand.prototype, "a", void 0);
+__decorate([
+    Param(z.number().describe('Second number')),
+    __metadata("design:type", Number)
+], AddCommand.prototype, "b", void 0);
+AddCommand = __decorate([
+    Command('math.add', 'Add two numbers')
+], AddCommand);
+export { AddCommand };
+let SubtractCommand = class SubtractCommand {
+    a;
+    b;
+    async execute() {
+        const result = this.a - this.b;
+        return {
+            content: [{ type: 'text', text: `${this.a} - ${this.b} = ${result}` }],
+        };
+    }
+};
+__decorate([
+    Param(z.number().describe('First number')),
+    __metadata("design:type", Number)
+], SubtractCommand.prototype, "a", void 0);
+__decorate([
+    Param(z.number().describe('Second number')),
+    __metadata("design:type", Number)
+], SubtractCommand.prototype, "b", void 0);
+SubtractCommand = __decorate([
+    Command('math.subtract', 'Subtract two numbers')
+], SubtractCommand);
+export { SubtractCommand };
+let MultiplyCommand = class MultiplyCommand {
+    a;
+    b;
+    async execute() {
+        const result = this.a * this.b;
+        return {
+            content: [{ type: 'text', text: `${this.a} × ${this.b} = ${result}` }],
+        };
+    }
+};
+__decorate([
+    Param(z.number().describe('First number')),
+    __metadata("design:type", Number)
+], MultiplyCommand.prototype, "a", void 0);
+__decorate([
+    Param(z.number().describe('Second number')),
+    __metadata("design:type", Number)
+], MultiplyCommand.prototype, "b", void 0);
+MultiplyCommand = __decorate([
+    Command('math.multiply', 'Multiply two numbers')
+], MultiplyCommand);
+export { MultiplyCommand };
+let DivideCommand = class DivideCommand {
+    a;
+    b;
+    async execute() {
+        if (this.b === 0) {
+            return {
+                content: [{ type: 'text', text: 'Error: Division by zero' }],
+                isError: true,
+            };
+        }
+        const result = this.a / this.b;
+        return {
+            content: [{ type: 'text', text: `${this.a} ÷ ${this.b} = ${result}` }],
+        };
+    }
+};
+__decorate([
+    Param(z.number().describe('First number')),
+    __metadata("design:type", Number)
+], DivideCommand.prototype, "a", void 0);
+__decorate([
+    Param(z.number().describe('Second number')),
+    __metadata("design:type", Number)
+], DivideCommand.prototype, "b", void 0);
+DivideCommand = __decorate([
+    Command('math.divide', 'Divide two numbers')
+], DivideCommand);
+export { DivideCommand };

package/dist/data/vscode-settings.json

@@ -0,0 +1,188 @@
+{
+    "security.workspace.trust.untrustedFiles": "open",
+    "workbench.colorTheme": "One Dark Modern",
+    "editor.fontFamily": "'JetBrains Mono', 'maple mono', 'Fira Code', 'Consolas', monospace",
+    "editor.tabSize": 4,
+    "editor.fontSize": 17,
+    "editor.fontLigatures": true,
+    "editor.fontWeight": 100,
+    "editor.lineNumbers": "on",
+    "editor.cursorStyle": "line-thin",
+    "editor.wordWrap": "on",
+    "editor.scrollBeyondLastLine": false,
+    "editor.renderControlCharacters": false,
+    "editor.linkedEditing": true,
+    "editor.mouseWheelZoom": true,
+    "editor.multiCursorModifier": "alt",
+    "editor.dragAndDrop": true,
+    "editor.showUnused": true,
+    "editor.emptySelectionClipboard": true,
+    "editor.accessibilityPageSize": 500,
+    "editor.minimap.maxColumn": 70,
+    "editor.minimap.renderCharacters": true,
+    "editor.minimap.showSlider": "always",
+    "editor.tokenColorCustomizations": {
+        "textMateRules": [
+            {
+                "name": "Comments",
+                "scope": "comment, punctuation.definition.comment",
+                "settings": {
+                    "foreground": "#458b29"
+                }
+            }
+        ]
+    },
+    "editor.unicodeHighlight.allowedLocales": {
+        "ja": true
+    },
+    "editor.formatOnSave": true,
+    "editor.formatOnPaste": true,
+    "editor.formatOnType": true,
+    "editor.formatOnSaveMode": "file",
+    "editor.foldingImportsByDefault": false,
+    "editor.codeActionsOnSave": {
+        "source.organizeImports": "always",
+        "source.fixAll.stylelint": "always",
+        "source.fixAll.tsserver": "always",
+        "source.unusedImports": "always"
+    },
+    "editor.defaultFormatter": "esbenp.prettier-vscode",
+    "prettier.semi": true,
+    "editor.quickSuggestions": {
+        "other": "on",
+        "comments": "on",
+        "strings": "on"
+    },
+    "editor.quickSuggestionsDelay": 0,
+    "editor.suggest.matchOnWordStartOnly": true,
+    "editor.suggestFontSize": 14,
+    "editor.suggestLineHeight": 22,
+    "editor.suggest.preview": true,
+    "editor.suggest.showStatusBar": true,
+    "editor.suggest.filterGraceful": true,
+    "editor.suggest.shareSuggestSelections": true,
+    "editor.suggestSelection": "first",
+    "editor.suggest.showIcons": true,
+    "editor.suggest.showMethods": true,
+    "editor.suggest.showFunctions": true,
+    "editor.suggest.showConstructors": true,
+    "editor.suggest.showFields": true,
+    "editor.suggest.showVariables": true,
+    "editor.suggest.showUnits": true,
+    "editor.suggest.showValues": true,
+    "editor.suggest.showSnippets": true,
+    "editor.suggest.showKeywords": true,
+    "editor.suggest.showWords": true,
+    "editor.suggest.showOperators": true,
+    "editor.suggest.insertMode": "insert",
+    "editor.suggest.snippetsPreventQuickSuggestions": false,
+    "editor.suggest.localityBonus": true,
+    "editor.suggestOnTriggerCharacters": true,
+    "editor.acceptSuggestionOnCommitCharacter": true,
+    "editor.acceptSuggestionOnEnter": "smart",
+    "editor.parameterHints.enabled": true,
+    "editor.inlineSuggest.fontFamily": "'JetBrains Mono', 'Fira Code', 'Consolas', monospace",
+    "editor.inlineSuggest.suppressSuggestions": false,
+    "editor.autoClosingBrackets": "always",
+    "editor.autoClosingQuotes": "always",
+    "editor.autoSurround": "languageDefined",
+    "editor.largeFileOptimizations": false,
+    "tailwindCSS.includeLanguages": {
+        "plaintext": "html"
+    },
+    "files.autoSave": "afterDelay",
+    "workbench.editor.doubleClickTabToToggleEditorGroupSizes": "maximize",
+    "files.autoSaveDelay": 1000,
+    "files.refactoring.autoSave": true,
+    "files.associations": {
+        "*.vue": "vue",
+        "*.cjs": "javascript",
+        "*.mjs": "javascript",
+        "*.css": "tailwindcss"
+    },
+    "terminal.integrated.tabs.enabled": true,
+    "terminal.integrated.cursorStyle": "line",
+    "terminal.integrated.cursorBlinking": true,
+    "terminal.integrated.cursorStyleInactive": "line",
+    "terminal.integrated.fontFamily": "'JetBrains Mono', Consolas, 'Fira Code', monospace",
+    "terminal.integrated.enableMultiLinePasteWarning": "never",
+    "git.ignoreMissingGitWarning": true,
+    "git.confirmSync": false,
+    "git.enableSmartCommit": true,
+    "git.autofetch": true,
+    "git.openRepositoryInParentFolders": "never",
+    "debug.onTaskErrors": "debugAnyway",
+    "security.promptForLocalFileProtocolHandling": false,
+    "trae.preview.permission": {
+        "localhost": {
+            "fileSystem": "granted"
+        }
+    },
+    "python.analysis.importFormat": "absolute",
+    "python.analysis.autoFormatStrings": false,
+    "javascript.updateImportsOnFileMove.enabled": "never",
+    "typescript.updateImportsOnFileMove.enabled": "always",
+    "extensions.ignoreRecommendations": false,
+    "code-runner.clearPreviousOutput": true,
+    "code-runner.runInTerminal": true,
+    "bracket-pair-colorizer-2.depreciation-notice": false,
+    "debug.inlineValues": "on",
+    "debug.openDebug": "openOnDebugBreak",
+    "workbench.startupEditor": "none",
+    "explorer.confirmDelete": false,
+    "explorer.confirmDragAndDrop": false,
+    "explorer.confirmPasteNative": false,
+    "notebook.output.scrolling": true,
+    "notebook.output.textLineLimit": 100,
+    "path-autocomplete.extensionOnImport": true,
+    "path-autocomplete.pathMappings": {
+        "./*": "${folder}/*"
+    },
+    "[markdown]": {
+        "editor.defaultFormatter": "yzhang.markdown-all-in-one"
+    },
+    "[html]": {
+        "editor.defaultFormatter": "vscode.html-language-features"
+    },
+    "[typescript]": {
+        "editor.rulers": [120],
+        "editor.defaultFormatter": "esbenp.prettier-vscode"
+    },
+    "[typescriptreact]": {
+        "editor.defaultFormatter": "esbenp.prettier-vscode"
+    },
+    "[jsonc]": {
+        "editor.defaultFormatter": "vscode.json-language-features"
+    },
+    "terminal.integrated.defaultProfile.windows": "Command Prompt",
+    "application.extensionMarketUrl": "https://marketplace.visualstudio.com/",
+    "[go]": {
+        "editor.defaultFormatter": "golang.go"
+    },
+    "[rust]": {
+        "editor.defaultFormatter": "rust-lang.rust-analyzer"
+    },
+    "workbench.secondarySideBar.defaultVisibility": "hidden",
+    "npm.packageManager": "bun",
+    "[python]": {
+        "editor.defaultFormatter": "charliermarsh.ruff"
+    },
+    "AI.toolcall.confirmMode": "autoRun",
+    "update.showReleaseNotes": false,
+    "explorer.compactFolders": false,
+    "rest-client.enableTelemetry": false,
+    "workbench.iconTheme": "material-icon-theme",
+    "workbench.view.showQuietly": {
+        "workbench.panel.output": false
+    },
+    "breadcrumbs.enabled": false,
+    "trae.tab.enableSummaryAutoDisplay": true,
+    "diffEditor.ignoreTrimWhitespace": false,
+    "go.lintTool": "golangci-lint-v2",
+    "liveServer.settings.donotVerifyTags": true,
+    "liveServer.settings.donotShowInfoMsg": true,
+    "cursor-infinity.autoOpenPanel": false,
+    "files.participants.timeout": 0,
+    "chat.detectParticipant.enabled": false,
+    "chat.disableAIFeatures": true
+}

package/dist/decorators/command.js

@@ -0,0 +1,37 @@
+import "reflect-metadata";
+const PARAM_METADATA_KEY = "command:params";
+const commandRegistry = new Map();
+export function Command(type, description) {
+    return function (constructor) {
+        const instance = new constructor();
+        const params = new Map();
+        const paramMetadata = Reflect.getMetadata(PARAM_METADATA_KEY, constructor) || {};
+        Object.entries(paramMetadata).forEach(([key, schema]) => {
+            params.set(key, schema);
+        });
+        commandRegistry.set(type, {
+            type,
+            description,
+            params,
+            handler: instance.execute.bind(instance),
+        });
+        return constructor;
+    };
+}
+export function Param(schema) {
+    return function (target, propertyKey) {
+        const constructor = target.constructor;
+        const existingParams = Reflect.getMetadata(PARAM_METADATA_KEY, constructor) || {};
+        existingParams[propertyKey] = schema;
+        Reflect.defineMetadata(PARAM_METADATA_KEY, existingParams, constructor);
+    };
+}
+export function getCommandRegistry() {
+    return commandRegistry;
+}
+export function getCommand(type) {
+    return commandRegistry.get(type);
+}
+export function getAllCommands() {
+    return Array.from(commandRegistry.values());
+}

package/dist/index.js

@@ -0,0 +1,40 @@
+import 'reflect-metadata';
+import { Hono } from "hono";
+import { createMcpHandler } from "mcp-handler";
+import vscodeSettings from './data/vscode-settings.json' with { type: 'json' };
+import { executeCommandTool, helpTool } from "./tools/decorator-tools.js";
+import './commands/math.js';
+const app = new Hono();
+const tools = [executeCommandTool, helpTool];
+var ToolName;
+(function (ToolName) {
+    ToolName["ExecuteCommand"] = "executeCommand";
+    ToolName["Help"] = "help";
+})(ToolName || (ToolName = {}));
+const handler = createMcpHandler((server) => {
+    tools.forEach((tool) => {
+        tool(server);
+    });
+}, {}, {
+    basePath: "/",
+    maxDuration: 60,
+    verboseLogs: true,
+});
+app.all("/mcp/*", async (c) => {
+    return await handler(c.req.raw);
+});
+app.get("/vscode", async (c) => {
+    return c.json(vscodeSettings);
+});
+app.get("/", async (c) => {
+    return c.json({
+        message: "Hono MCP Server - Math Operations",
+        endpoints: {
+            mcp: "/mcp",
+            testEdgeConfig: "/test-edge-config",
+            description: "MCP server with math operation tools (add, subtract, multiply, divide)",
+        },
+        tools: Object.values(ToolName),
+    });
+});
+export default app;

package/dist/tools/decorator-tools.js

@@ -0,0 +1,93 @@
+import { z } from "zod";
+import { getCommandRegistry } from "../decorators/command.js";
+export const executeCommandTool = (server) => {
+    server.tool("executeCommand", "Execute any command by specifying its type and parameters", {
+        type: {
+            type: "string",
+            description: "Command type (e.g., math.add, math.subtract, math.multiply, math.divide)",
+        },
+        params: {
+            type: "object",
+            description: "Command parameters",
+        },
+    }, async ({ type, params }) => {
+        const command = getCommandRegistry().get(type);
+        if (!command) {
+            return {
+                content: [
+                    {
+                        type: "text",
+                        text: `Unknown command type: ${type}\n\nAvailable commands:\n${Array.from(getCommandRegistry().keys())
+                            .map((t) => `- ${t}`)
+                            .join("\n")}`,
+                    },
+                ],
+                isError: true,
+            };
+        }
+        const schema = z.object(Object.fromEntries(Array.from(command.params.entries()).map(([key, val]) => [key, val])));
+        const validationResult = schema.safeParse(params);
+        if (!validationResult.success) {
+            return {
+                content: [
+                    {
+                        type: "text",
+                        text: `Invalid parameters: ${validationResult.error.message}`,
+                    },
+                ],
+                isError: true,
+            };
+        }
+        return await command.handler(validationResult.data);
+    });
+};
+export const helpTool = (server) => {
+    server.tool("help", "Get help information about available commands", {
+        type: {
+            type: "string",
+            description: "Command type to get help for (optional)",
+        },
+    }, async ({ type }) => {
+        if (type) {
+            const command = getCommandRegistry().get(type);
+            if (!command) {
+                return {
+                    content: [
+                        {
+                            type: "text",
+                            text: `Unknown command type: ${type}\n\nAvailable commands:\n${Array.from(getCommandRegistry().keys())
+                                .map((t) => `- ${t}`)
+                                .join("\n")}`,
+                        },
+                    ],
+                    isError: true,
+                };
+            }
+            const paramsInfo = Array.from(command.params.entries())
+                .map(([key, schema]) => {
+                const description = schema.description || "No description";
+                return `- ${key}: ${description}`;
+            })
+                .join("\n");
+            return {
+                content: [
+                    {
+                        type: "text",
+                        text: `Command: ${command.type}\nDescription: ${command.description}\n\nParameters:\n${paramsInfo}`,
+                    },
+                ],
+            };
+        }
+        const commandList = Array.from(getCommandRegistry().values())
+            .map((cmd) => `- ${cmd.type}: ${cmd.description}`)
+            .join("\n");
+        return {
+            content: [
+                {
+                    type: "text",
+                    text: `Available commands:\n${commandList}\n\nUse help with a specific command type for details.`,
+                },
+            ],
+        };
+    });
+};

package/package.json

@@ -0,0 +1,49 @@
+{
+  "name": "hono-mcp",
+  "version": "1.3.0",
+  "description": "MCP server built with Hono - supports both Vercel deployment and npx CLI usage",
+  "main": "dist/index.js",
+  "bin": {
+    "hono-mcp": "dist/cli.js"
+  },
+  "type": "module",
+  "files": [
+    "dist",
+    "README.md"
+  ],
+  "scripts": {
+    "build": "tsc",
+    "start": "node dist/cli.js",
+    "dev": "tsx src/cli.ts",
+    "dev:vercel": "tsx src/index.ts"
+  },
+  "keywords": [
+    "mcp",
+    "hono",
+    "model-context-protocol",
+    "mcp-server",
+    "cli",
+    "npx",
+    "vercel",
+    "server",
+    "api",
+    "typescript",
+    "decorator"
+  ],
+  "author": "fromsko",
+  "license": "MIT",
+  "dependencies": {
+    "@hono/node-server": "^1.19.7",
+    "@modelcontextprotocol/sdk": "^1.17.3",
+    "@vercel/edge-config": "^1.4.3",
+    "hono": "^4.9.2",
+    "mcp-handler": "^1.0.1",
+    "reflect-metadata": "^0.2.2",
+    "zod": "^3"
+  },
+  "devDependencies": {
+    "@types/node": "^20.11.17",
+    "tsx": "^4.7.0",
+    "typescript": "^5.9.3"
+  }
+}