create-mcp-forge 0.1.0

package/LICENSE

@@ -0,0 +1,21 @@
+MIT License
+
+Copyright (c) 2026 hiyilmaz
+
+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.

package/README.md

@@ -0,0 +1,370 @@
+# mcp-forge
+
+⚡ **The fastest way to build MCP servers**
+
+A powerful CLI tool for scaffolding [Model Context Protocol](https://modelcontextprotocol.io) servers with production-ready templates.
+
+[![npm version](https://img.shields.io/npm/v/mcp-forge.svg)](https://www.npmjs.com/package/mcp-forge)
+[![License: MIT](https://img.shields.io/badge/License-MIT-yellow.svg)](https://opensource.org/licenses/MIT)
+
+## Features
+
+- 🚀 **Instant Setup** - Create production-ready MCP servers in seconds
+- 📦 **Multiple Templates** - PostgreSQL, REST API, FileSystem, or start from scratch
+- 🔧 **TypeScript First** - Full type safety and modern tooling
+- ✅ **Test Ready** - Pre-configured testing with Vitest
+- 🎯 **Claude Desktop Integration** - Automatic registration with Claude Desktop
+- 🛠️ **Best Practices** - Error handling, validation, and security built-in
+
+## Quick Start
+
+```bash
+npx mcp-forge init my-server
+```
+
+Follow the interactive prompts to:
+
+1. Choose a template (empty, postgresql, rest-api, filesystem)
+2. Select language (TypeScript)
+3. Automatically register with Claude Desktop
+
+Your MCP server is ready! 🎉
+
+## Installation
+
+### Global Installation (Optional)
+
+```bash
+npm install -g mcp-forge
+mcp-forge init my-server
+```
+
+### One-Time Use (Recommended)
+
+```bash
+npx mcp-forge init my-server
+```
+
+## Usage
+
+### Interactive Mode
+
+```bash
+npx mcp-forge init my-server
+```
+
+The CLI will guide you through:
+
+- Template selection
+- Language preference
+- Claude Desktop registration
+
+### Non-Interactive Mode
+
+```bash
+npx mcp-forge init my-server \
+  --template postgresql \
+  --language typescript \
+  --no-register
+```
+
+### CLI Options
+
+```bash
+mcp-forge init <project-name> [options]
+
+Options:
+  -t, --template <name>    Template to use (empty|postgresql|rest-api|filesystem)
+  -l, --language <lang>    Language to use (typescript)
+  --no-register           Skip Claude Desktop registration
+  -h, --help              Display help
+```
+
+## Templates
+
+### 🗂️ Empty Template
+
+Minimal MCP server with basic structure. Perfect for custom implementations.
+
+```bash
+npx mcp-forge init my-server --template empty
+```
+
+**Includes:**
+
+- Basic MCP server setup
+- TypeScript configuration
+- Test scaffolding
+
+---
+
+### 🐘 PostgreSQL Template
+
+Full-featured database MCP server with connection pooling and query tools.
+
+```bash
+npx mcp-forge init my-db-server --template postgresql
+```
+
+**Tools Included:**
+
+- `query_database` - Execute raw SQL queries
+- `list_tables` - List all database tables
+- `describe_table` - Get table schema information
+
+**Features:**
+
+- Connection pooling with `pg`
+- Environment-based configuration
+- Parameterized queries for security
+- Comprehensive error handling
+
+---
+
+### 🌐 REST API Template
+
+HTTP client MCP server for interacting with REST APIs.
+
+```bash
+npx mcp-forge init my-api-server --template rest-api
+```
+
+**Tools Included:**
+
+- `fetch_api` - Make HTTP requests (GET, POST, PUT, DELETE)
+- `get_api_status` - Check API health
+
+**Features:**
+
+- Built-in HTTP client
+- Request/response validation
+- Timeout handling
+- Error recovery
+
+---
+
+### 📁 FileSystem Template
+
+Secure file operations MCP server with path traversal protection.
+
+```bash
+npx mcp-forge init my-fs-server --template filesystem
+```
+
+**Tools Included:**
+
+- `read_file` - Read file contents
+- `write_file` - Write to files
+- `list_directory` - List directory contents
+
+**Features:**
+
+- Path traversal protection
+- Configurable allowed directories
+- Safe file operations
+- Comprehensive validation
+
+## Project Structure
+
+```
+my-server/
+├── src/
+│   ├── index.ts              # Main server entry point
+│   └── tools/                # Tool implementations
+│       └── *.ts
+├── tests/
+│   └── *.test.ts             # Test files
+├── .env.example              # Environment template
+├── package.json
+├── tsconfig.json
+└── README.md
+```
+
+## Development Workflow
+
+### 1. Create Your Server
+
+```bash
+npx mcp-forge init my-server --template postgresql
+cd my-server
+```
+
+### 2. Configure Environment
+
+```bash
+cp .env.example .env
+# Edit .env with your configuration
+```
+
+### 3. Install Dependencies
+
+```bash
+npm install
+```
+
+### 4. Start Development
+
+```bash
+npm run dev
+```
+
+### 5. Run Tests
+
+```bash
+npm test
+```
+
+### 6. Build for Production
+
+```bash
+npm run build
+```
+
+## Claude Desktop Integration
+
+mcp-forge automatically registers your server with Claude Desktop during initialization.
+
+### Manual Registration
+
+If you skipped registration or need to register later:
+
+1. Open Claude Desktop configuration:
+   - **macOS**: `~/Library/Application Support/Claude/claude_desktop_config.json`
+   - **Windows**: `%APPDATA%\Claude\claude_desktop_config.json`
+
+2. Add your server:
+
+```json
+{
+  "mcpServers": {
+    "my-server": {
+      "command": "node",
+      "args": ["/absolute/path/to/my-server/dist/index.js"]
+    }
+  }
+}
+```
+
+3. Restart Claude Desktop
+
+## Testing
+
+All templates include pre-configured testing with Vitest.
+
+```bash
+# Run tests once
+npm test
+
+# Watch mode
+npm run test:watch
+```
+
+### Example Test
+
+```typescript
+import { describe, it, expect } from "vitest";
+
+describe("My Tool", () => {
+  it("should process input correctly", () => {
+    const result = myTool({ input: "test" });
+    expect(result).toBe("expected");
+  });
+});
+```
+
+## Requirements
+
+- **Node.js**: >= 18.0.0
+- **npm**: >= 8.0.0
+
+## Best Practices
+
+### Error Handling
+
+All templates include comprehensive error handling:
+
+```typescript
+try {
+  // Tool logic
+  return { content: [{ type: "text", text: result }] };
+} catch (error) {
+  return {
+    content: [
+      {
+        type: "text",
+        text: `Error: ${error.message}`,
+      },
+    ],
+    isError: true,
+  };
+}
+```
+
+### Input Validation
+
+Validate all tool inputs:
+
+```typescript
+if (!input || typeof input !== "string") {
+  throw new Error("Invalid input: expected string");
+}
+```
+
+### Security
+
+- Never expose sensitive data in error messages
+- Use environment variables for credentials
+- Validate and sanitize all user inputs
+- Implement path traversal protection for file operations
+
+## Troubleshooting
+
+### Server Not Appearing in Claude Desktop
+
+1. Check configuration file syntax (valid JSON)
+2. Verify absolute paths in `args`
+3. Ensure server is built (`npm run build`)
+4. Restart Claude Desktop
+
+### TypeScript Errors
+
+```bash
+# Clean and rebuild
+rm -rf dist node_modules
+npm install
+npm run build
+```
+
+### Tests Failing
+
+```bash
+# Update dependencies
+npm update
+
+# Clear cache
+npm cache clean --force
+```
+
+## Contributing
+
+Contributions are welcome! Please feel free to submit a Pull Request.
+
+## License
+
+MIT © mcp-forge Maintainer
+
+## Resources
+
+- [Model Context Protocol Documentation](https://modelcontextprotocol.io)
+- [MCP SDK](https://github.com/modelcontextprotocol/sdk)
+- [Claude Desktop](https://claude.ai/desktop)
+
+## Support
+
+- 🐛 [Report Issues](https://github.com/hiyilmaz/mcp-forge/issues)
+- 💬 [Discussions](https://github.com/hiyilmaz/mcp-forge/discussions)
+- 📧 Email: mcpforge@grisis.com
+
+---
+
+**Built with ❤️ for the MCP community**

package/dist/index.d.ts

@@ -0,0 +1 @@
+#!/usr/bin/env node

package/dist/index.js

@@ -0,0 +1,160 @@
+#!/usr/bin/env node
+
+// src/index.ts
+import { Command } from "commander";
+
+// src/commands/init.ts
+import * as clack2 from "@clack/prompts";
+import { existsSync as existsSync2 } from "fs";
+import { join as join3 } from "path";
+
+// src/utils/scaffold.ts
+import { cpSync, mkdirSync, readFileSync, writeFileSync } from "fs";
+import { join, dirname } from "path";
+import { fileURLToPath } from "url";
+var __dirname = dirname(fileURLToPath(import.meta.url));
+function scaffoldProject(projectName, template) {
+  const targetDir = join(process.cwd(), projectName);
+  const templateDir = join(__dirname, "../templates", template);
+  mkdirSync(targetDir, { recursive: true });
+  cpSync(templateDir, targetDir, { recursive: true });
+  replaceTokensInDirectory(targetDir, projectName);
+}
+function replaceTokensInDirectory(dir, projectName) {
+  const files = [
+    "package.json",
+    "README.md",
+    "src/index.ts",
+    "tests/index.test.ts"
+  ];
+  for (const file of files) {
+    const filePath = join(dir, file);
+    try {
+      let content = readFileSync(filePath, "utf-8");
+      content = content.replace(/\{\{PROJECT_NAME\}\}/g, projectName);
+      writeFileSync(filePath, content, "utf-8");
+    } catch (error) {
+    }
+  }
+}
+
+// src/utils/claude-config.ts
+import { existsSync, readFileSync as readFileSync2, writeFileSync as writeFileSync2, mkdirSync as mkdirSync2 } from "fs";
+import { join as join2, dirname as dirname2 } from "path";
+import { homedir } from "os";
+import * as clack from "@clack/prompts";
+function getConfigPath() {
+  const platform = process.platform;
+  if (platform === "darwin") {
+    return join2(homedir(), "Library", "Application Support", "Claude", "claude_desktop_config.json");
+  } else if (platform === "win32") {
+    return join2(process.env.APPDATA || "", "Claude", "claude_desktop_config.json");
+  } else {
+    return join2(homedir(), ".config", "Claude", "claude_desktop_config.json");
+  }
+}
+async function registerWithClaudeDesktop(projectName, projectPath) {
+  const configPath = getConfigPath();
+  let config = { mcpServers: {} };
+  if (existsSync(configPath)) {
+    try {
+      const content = readFileSync2(configPath, "utf-8");
+      config = JSON.parse(content);
+      if (!config.mcpServers) {
+        config.mcpServers = {};
+      }
+    } catch (error) {
+      clack.log.warn("Could not parse existing config, creating new one");
+    }
+  }
+  if (config.mcpServers[projectName]) {
+    const overwrite = await clack.confirm({
+      message: `Entry "${projectName}" already exists in Claude Desktop config. Overwrite?`,
+      initialValue: false
+    });
+    if (clack.isCancel(overwrite) || !overwrite) {
+      clack.log.info("Skipped Claude Desktop registration");
+      return;
+    }
+  }
+  config.mcpServers[projectName] = {
+    command: "node",
+    args: [join2(projectPath, "src", "index.js")]
+  };
+  try {
+    mkdirSync2(dirname2(configPath), { recursive: true });
+    writeFileSync2(configPath, JSON.stringify(config, null, 2), "utf-8");
+    clack.log.success("Registered with Claude Desktop");
+    clack.log.warn("\u26A0\uFE0F  Restart Claude Desktop to apply changes");
+  } catch (error) {
+    clack.log.error(`Failed to register: ${error.message}`);
+  }
+}
+
+// src/commands/init.ts
+async function init(projectName, options) {
+  clack2.intro("\u26A1  mcp-forge  v0.1.0");
+  if (!projectName || projectName.length < 2 || !/^[a-z0-9-]+$/i.test(projectName)) {
+    clack2.outro("\u274C Invalid project name. Use alphanumeric characters and hyphens only (min 2 chars).");
+    process.exit(1);
+  }
+  const targetDir = join3(process.cwd(), projectName);
+  if (existsSync2(targetDir)) {
+    clack2.outro(`\u274C Directory "${projectName}" already exists.`);
+    process.exit(1);
+  }
+  const template = options.template || await clack2.select({
+    message: "Which template would you like to use?",
+    options: [
+      { value: "empty", label: "Empty MCP (clean starting point)" },
+      { value: "postgresql", label: "PostgreSQL MCP (database tools)" },
+      { value: "rest-api", label: "REST API Wrapper MCP (HTTP tools)" },
+      { value: "filesystem", label: "Local FileSystem MCP (file tools)" }
+    ]
+  });
+  if (clack2.isCancel(template)) {
+    clack2.cancel("Operation cancelled.");
+    process.exit(0);
+  }
+  const language = options.language || await clack2.select({
+    message: "Which language?",
+    options: [
+      { value: "typescript", label: "TypeScript" }
+    ]
+  });
+  if (clack2.isCancel(language)) {
+    clack2.cancel("Operation cancelled.");
+    process.exit(0);
+  }
+  const autoRegister = options.register !== void 0 ? options.register : await clack2.confirm({
+    message: "Auto-register with Claude Desktop? (recommended)",
+    initialValue: true
+  });
+  if (clack2.isCancel(autoRegister)) {
+    clack2.cancel("Operation cancelled.");
+    process.exit(0);
+  }
+  const spinner2 = clack2.spinner();
+  spinner2.start("Creating your MCP server...");
+  scaffoldProject(projectName, template);
+  spinner2.stop("\u2714  Project scaffolded");
+  if (autoRegister) {
+    await registerWithClaudeDesktop(projectName, targetDir);
+  }
+  clack2.outro(`\u2705  ${projectName} is ready!
+
+Next steps:
+  cd ${projectName}
+  npm install
+  npm run dev
+
+Docs: https://github.com/org/mcp-forge`);
+}
+
+// src/index.ts
+var program = new Command();
+program.name("mcp-forge").description("The fastest way to build MCP servers").version("0.1.0");
+program.command("init <project-name>").description("Initialize a new MCP server project").option("--template <template>", "Template to use (empty, postgresql, rest-api, filesystem)").option("--language <language>", "Language to use (typescript)").option("--no-register", "Skip Claude Desktop auto-registration").action(async (projectName, options) => {
+  await init(projectName, options);
+});
+program.parse();

package/dist/templates/empty/README.md

@@ -0,0 +1,16 @@
+# {{PROJECT_NAME}}
+
+MCP server built with mcp-forge.
+
+## Development
+
+```bash
+npm install
+npm run dev
+```
+
+## Testing
+
+```bash
+npm test
+```

package/dist/templates/empty/package.json

@@ -0,0 +1,17 @@
+{
+  "name": "{{PROJECT_NAME}}",
+  "version": "0.1.0",
+  "type": "module",
+  "scripts": {
+    "build": "tsc",
+    "dev": "tsc && node src/index.js",
+    "test": "vitest run"
+  },
+  "dependencies": {
+    "@modelcontextprotocol/sdk": "^0.5.0"
+  },
+  "devDependencies": {
+    "typescript": "^5.3.3",
+    "vitest": "^1.2.0"
+  }
+}

package/dist/templates/empty/src/index.ts

@@ -0,0 +1,26 @@
+#!/usr/bin/env node
+import { Server } from '@modelcontextprotocol/sdk/server/index.js';
+import { StdioServerTransport } from '@modelcontextprotocol/sdk/server/stdio.js';
+
+export const server = new Server(
+  {
+    name: '{{PROJECT_NAME}}',
+    version: '0.1.0',
+  },
+  {
+    capabilities: {
+      tools: {},
+    },
+  }
+);
+
+async function main() {
+  const transport = new StdioServerTransport();
+  await server.connect(transport);
+  console.error('MCP server running on stdio');
+}
+
+main().catch((error) => {
+  console.error('Server error:', error);
+  process.exit(1);
+});

package/dist/templates/empty/tests/index.test.ts

@@ -0,0 +1,9 @@
+import { describe, it, expect } from 'vitest';
+import { server } from '../src/index.js';
+
+describe('MCP Server', () => {
+  it('server instance is defined', () => {
+    expect(server).toBeDefined();
+    expect(server).toBeInstanceOf(Object);
+  });
+});

package/dist/templates/empty/tsconfig.json

@@ -0,0 +1,12 @@
+{
+  "compilerOptions": {
+    "target": "ES2022",
+    "module": "ESNext",
+    "moduleResolution": "bundler",
+    "lib": ["ES2022"],
+    "strict": true,
+    "esModuleInterop": true,
+    "skipLibCheck": true
+  },
+  "include": ["src/**/*", "tests/**/*"]
+}

package/dist/templates/filesystem/.env.example

@@ -0,0 +1 @@
+ALLOWED_BASE_PATH=/path/to/allowed/directory

package/dist/templates/filesystem/README.md

@@ -0,0 +1,37 @@
+# {{PROJECT_NAME}}
+
+Local FileSystem MCP server built with mcp-forge.
+
+## Setup
+
+1. Copy `.env.example` to `.env` and configure allowed path:
+```bash
+cp .env.example .env
+```
+
+2. Install dependencies:
+```bash
+npm install
+```
+
+## Development
+
+```bash
+npm run dev
+```
+
+## Testing
+
+```bash
+npm test
+```
+
+## Tools
+
+- `read_file`: Read file contents (restricted to ALLOWED_BASE_PATH)
+- `write_file`: Write file contents (restricted to ALLOWED_BASE_PATH)
+- `list_directory`: List directory contents (restricted to ALLOWED_BASE_PATH)
+
+## Security
+
+All file operations are restricted to the path specified in `ALLOWED_BASE_PATH` environment variable. Path traversal attacks are blocked.

package/dist/templates/filesystem/package.json

@@ -0,0 +1,18 @@
+{
+  "name": "{{PROJECT_NAME}}",
+  "version": "0.1.0",
+  "type": "module",
+  "scripts": {
+    "build": "tsc",
+    "dev": "tsc && node src/index.js",
+    "test": "vitest run"
+  },
+  "dependencies": {
+    "@modelcontextprotocol/sdk": "^0.5.0"
+  },
+  "devDependencies": {
+    "@types/node": "^20.11.0",
+    "typescript": "^5.3.3",
+    "vitest": "^1.2.0"
+  }
+}

package/dist/templates/filesystem/src/index.ts

@@ -0,0 +1,56 @@
+#!/usr/bin/env node
+import { Server } from '@modelcontextprotocol/sdk/server/index.js';
+import { StdioServerTransport } from '@modelcontextprotocol/sdk/server/stdio.js';
+import { CallToolRequestSchema } from '@modelcontextprotocol/sdk/types.js';
+import { readFile, writeFile, listDirectory } from './tools/filesystem.js';
+
+export const server = new Server(
+  {
+    name: '{{PROJECT_NAME}}',
+    version: '0.1.0',
+  },
+  {
+    capabilities: {
+      tools: {},
+    },
+  }
+);
+
+server.setRequestHandler(CallToolRequestSchema, async (request) => {
+  try {
+    const { name, arguments: args } = request.params;
+
+    switch (name) {
+      case 'read_file': {
+        const content = readFile((args?.path as string) || '');
+        return { content: [{ type: 'text', text: content }] };
+      }
+      case 'write_file': {
+        writeFile((args?.path as string) || '', (args?.content as string) || '');
+        return { content: [{ type: 'text', text: 'File written successfully' }] };
+      }
+      case 'list_directory': {
+        const files = listDirectory((args?.path as string) || '');
+        return { content: [{ type: 'text', text: JSON.stringify(files, null, 2) }] };
+      }
+      default:
+        throw new Error(`Unknown tool: ${name}`);
+    }
+  } catch (error: any) {
+    return {
+      content: [{ type: 'text', text: `Error: ${error.message}` }],
+      isError: true,
+    };
+  }
+});
+
+async function main() {
+  const transport = new StdioServerTransport();
+  await server.connect(transport);
+  console.error('FileSystem MCP server running on stdio');
+}
+
+main().catch((error) => {
+  console.error('Server error:', error);
+  process.exit(1);
+});

package/dist/templates/filesystem/src/tools/filesystem.ts

@@ -0,0 +1,52 @@
+import { readFileSync, writeFileSync, readdirSync, mkdirSync } from 'fs';
+import { join, resolve, dirname } from 'path';
+
+const ALLOWED_BASE_PATH = resolve(process.env.ALLOWED_BASE_PATH || process.cwd());
+
+function isPathAllowed(filePath: string): boolean {
+  const resolvedPath = resolve(filePath);
+  return resolvedPath.startsWith(ALLOWED_BASE_PATH);
+}
+
+export function readFile(path: string): string {
+  const fullPath = join(ALLOWED_BASE_PATH, path);
+  
+  if (!isPathAllowed(fullPath)) {
+    throw new Error('Access denied: Path outside allowed directory');
+  }
+
+  try {
+    return readFileSync(fullPath, 'utf-8');
+  } catch (error: any) {
+    throw new Error(`File read error: ${error.message}`);
+  }
+}
+
+export function writeFile(path: string, content: string): void {
+  const fullPath = join(ALLOWED_BASE_PATH, path);
+  
+  if (!isPathAllowed(fullPath)) {
+    throw new Error('Access denied: Path outside allowed directory');
+  }
+
+  try {
+    mkdirSync(dirname(fullPath), { recursive: true });
+    writeFileSync(fullPath, content, 'utf-8');
+  } catch (error: any) {
+    throw new Error(`File write error: ${error.message}`);
+  }
+}
+
+export function listDirectory(path: string): string[] {
+  const fullPath = join(ALLOWED_BASE_PATH, path);
+  
+  if (!isPathAllowed(fullPath)) {
+    throw new Error('Access denied: Path outside allowed directory');
+  }
+
+  try {
+    return readdirSync(fullPath);
+  } catch (error: any) {
+    throw new Error(`Directory read error: ${error.message}`);
+  }
+}

package/dist/templates/filesystem/tests/filesystem.test.ts

@@ -0,0 +1,12 @@
+import { describe, it, expect } from 'vitest';
+import { readFile, writeFile } from '../src/tools/filesystem.js';
+
+describe('FileSystem Tools', () => {
+  it('readFile blocks path traversal', () => {
+    expect(() => readFile('../../etc/passwd')).toThrow('Access denied');
+  });
+
+  it('writeFile blocks path traversal', () => {
+    expect(() => writeFile('../../etc/passwd', 'test')).toThrow('Access denied');
+  });
+});

package/dist/templates/filesystem/tsconfig.json

@@ -0,0 +1,12 @@
+{
+  "compilerOptions": {
+    "target": "ES2022",
+    "module": "ESNext",
+    "moduleResolution": "bundler",
+    "lib": ["ES2022"],
+    "strict": true,
+    "esModuleInterop": true,
+    "skipLibCheck": true
+  },
+  "include": ["src/**/*", "tests/**/*"]
+}

package/dist/templates/postgresql/.env.example

@@ -0,0 +1 @@
+DATABASE_URL=postgresql://user:password@localhost:5432/database

package/dist/templates/postgresql/README.md

@@ -0,0 +1,33 @@
+# {{PROJECT_NAME}}
+
+PostgreSQL MCP server built with mcp-forge.
+
+## Setup
+
+1. Copy `.env.example` to `.env` and configure your database:
+```bash
+cp .env.example .env
+```
+
+2. Install dependencies:
+```bash
+npm install
+```
+
+## Development
+
+```bash
+npm run dev
+```
+
+## Testing
+
+```bash
+npm test
+```
+
+## Tools
+
+- `query_database`: Execute raw SQL queries
+- `list_tables`: List all tables in the database
+- `describe_table`: Get column information for a table

package/dist/templates/postgresql/package.json

@@ -0,0 +1,19 @@
+{
+  "name": "{{PROJECT_NAME}}",
+  "version": "0.1.0",
+  "type": "module",
+  "scripts": {
+    "build": "tsc",
+    "dev": "tsc && node src/index.js",
+    "test": "vitest run"
+  },
+  "dependencies": {
+    "@modelcontextprotocol/sdk": "^0.5.0",
+    "pg": "^8.11.0"
+  },
+  "devDependencies": {
+    "@types/pg": "^8.11.0",
+    "typescript": "^5.3.3",
+    "vitest": "^1.2.0"
+  }
+}

package/dist/templates/postgresql/src/index.ts

@@ -0,0 +1,56 @@
+#!/usr/bin/env node
+import { Server } from '@modelcontextprotocol/sdk/server/index.js';
+import { StdioServerTransport } from '@modelcontextprotocol/sdk/server/stdio.js';
+import { CallToolRequestSchema } from '@modelcontextprotocol/sdk/types.js';
+import { queryDatabase, listTables, describeTable } from './tools/database.js';
+
+export const server = new Server(
+  {
+    name: '{{PROJECT_NAME}}',
+    version: '0.1.0',
+  },
+  {
+    capabilities: {
+      tools: {},
+    },
+  }
+);
+
+server.setRequestHandler(CallToolRequestSchema, async (request) => {
+  try {
+    const { name, arguments: args } = request.params;
+
+    switch (name) {
+      case 'query_database': {
+        const result = await queryDatabase((args?.sql as string) || '');
+        return { content: [{ type: 'text', text: JSON.stringify(result, null, 2) }] };
+      }
+      case 'list_tables': {
+        const tables = await listTables();
+        return { content: [{ type: 'text', text: JSON.stringify(tables, null, 2) }] };
+      }
+      case 'describe_table': {
+        const columns = await describeTable((args?.tableName as string) || '');
+        return { content: [{ type: 'text', text: JSON.stringify(columns, null, 2) }] };
+      }
+      default:
+        throw new Error(`Unknown tool: ${name}`);
+    }
+  } catch (error: any) {
+    return {
+      content: [{ type: 'text', text: `Error: ${error.message}` }],
+      isError: true,
+    };
+  }
+});
+
+async function main() {
+  const transport = new StdioServerTransport();
+  await server.connect(transport);
+  console.error('PostgreSQL MCP server running on stdio');
+}
+
+main().catch((error) => {
+  console.error('Server error:', error);
+  process.exit(1);
+});

package/dist/templates/postgresql/src/tools/database.ts

@@ -0,0 +1,49 @@
+import { Pool } from 'pg';
+
+const pool = new Pool({
+  connectionString: process.env.DATABASE_URL,
+});
+
+export async function queryDatabase(sql: string) {
+  if (!sql || sql.trim().length === 0) {
+    throw new Error('SQL query cannot be empty');
+  }
+  
+  try {
+    const result = await pool.query(sql);
+    return result.rows;
+  } catch (error: any) {
+    throw new Error(`Database error: ${error.message}`);
+  }
+}
+
+export async function listTables() {
+  try {
+    const result = await pool.query(`
+      SELECT tablename FROM pg_tables 
+      WHERE schemaname = 'public'
+      ORDER BY tablename
+    `);
+    return result.rows.map(row => row.tablename);
+  } catch (error: any) {
+    throw new Error(`Database error: ${error.message}`);
+  }
+}
+
+export async function describeTable(tableName: string) {
+  if (!tableName || tableName.trim().length === 0) {
+    throw new Error('Table name cannot be empty');
+  }
+  
+  try {
+    const result = await pool.query(`
+      SELECT column_name, data_type, is_nullable
+      FROM information_schema.columns
+      WHERE table_schema = 'public' AND table_name = $1
+      ORDER BY ordinal_position
+    `, [tableName]);
+    return result.rows;
+  } catch (error: any) {
+    throw new Error(`Database error: ${error.message}`);
+  }
+}

package/dist/templates/postgresql/tests/database.test.ts

@@ -0,0 +1,32 @@
+import { describe, it, expect, vi } from 'vitest';
+import { queryDatabase, listTables, describeTable } from '../src/tools/database.js';
+
+vi.mock('pg', () => ({
+  Pool: vi.fn(() => ({
+    query: vi.fn((sql: string) => {
+      if (sql.includes('pg_tables')) {
+        return Promise.resolve({ rows: [{ tablename: 'users' }, { tablename: 'posts' }] });
+      }
+      if (sql.includes('information_schema')) {
+        return Promise.resolve({ rows: [{ column_name: 'id', data_type: 'integer', is_nullable: 'NO' }] });
+      }
+      return Promise.resolve({ rows: [{ id: 1, name: 'test' }] });
+    }),
+  })),
+}));
+
+describe('Database Tools', () => {
+  it('queryDatabase validates non-empty SQL', async () => {
+    await expect(queryDatabase('')).rejects.toThrow('SQL query cannot be empty');
+  });
+
+  it('listTables returns array of table names', async () => {
+    const tables = await listTables();
+    expect(Array.isArray(tables)).toBe(true);
+    expect(tables).toContain('users');
+  });
+
+  it('describeTable validates table name', async () => {
+    await expect(describeTable('')).rejects.toThrow('Table name cannot be empty');
+  });
+});

package/dist/templates/postgresql/tsconfig.json

@@ -0,0 +1,12 @@
+{
+  "compilerOptions": {
+    "target": "ES2022",
+    "module": "ESNext",
+    "moduleResolution": "bundler",
+    "lib": ["ES2022"],
+    "strict": true,
+    "esModuleInterop": true,
+    "skipLibCheck": true
+  },
+  "include": ["src/**/*", "tests/**/*"]
+}

package/dist/templates/rest-api/.env.example

@@ -0,0 +1,2 @@
+API_BASE_URL=https://api.example.com
+API_KEY=your_api_key_here

package/dist/templates/rest-api/README.md

@@ -0,0 +1,32 @@
+# {{PROJECT_NAME}}
+
+REST API Wrapper MCP server built with mcp-forge.
+
+## Setup
+
+1. Copy `.env.example` to `.env` and configure your API:
+```bash
+cp .env.example .env
+```
+
+2. Install dependencies:
+```bash
+npm install
+```
+
+## Development
+
+```bash
+npm run dev
+```
+
+## Testing
+
+```bash
+npm test
+```
+
+## Tools
+
+- `get_resource`: Make GET requests to the API
+- `post_resource`: Make POST requests to the API

package/dist/templates/rest-api/package.json

@@ -0,0 +1,19 @@
+{
+  "name": "{{PROJECT_NAME}}",
+  "version": "0.1.0",
+  "type": "module",
+  "scripts": {
+    "build": "tsc",
+    "dev": "tsc && node src/index.js",
+    "test": "vitest run"
+  },
+  "dependencies": {
+    "@modelcontextprotocol/sdk": "^0.5.0",
+    "node-fetch": "^3.3.0"
+  },
+  "devDependencies": {
+    "@types/node": "^20.11.0",
+    "typescript": "^5.3.3",
+    "vitest": "^1.2.0"
+  }
+}

package/dist/templates/rest-api/src/index.ts

@@ -0,0 +1,52 @@
+#!/usr/bin/env node
+import { Server } from '@modelcontextprotocol/sdk/server/index.js';
+import { StdioServerTransport } from '@modelcontextprotocol/sdk/server/stdio.js';
+import { CallToolRequestSchema } from '@modelcontextprotocol/sdk/types.js';
+import { getResource, postResource } from './tools/api.js';
+
+export const server = new Server(
+  {
+    name: '{{PROJECT_NAME}}',
+    version: '0.1.0',
+  },
+  {
+    capabilities: {
+      tools: {},
+    },
+  }
+);
+
+server.setRequestHandler(CallToolRequestSchema, async (request) => {
+  try {
+    const { name, arguments: args } = request.params;
+
+    switch (name) {
+      case 'get_resource': {
+        const result = await getResource((args?.path as string) || '');
+        return { content: [{ type: 'text', text: JSON.stringify(result, null, 2) }] };
+      }
+      case 'post_resource': {
+        const result = await postResource((args?.path as string) || '', args?.data);
+        return { content: [{ type: 'text', text: JSON.stringify(result, null, 2) }] };
+      }
+      default:
+        throw new Error(`Unknown tool: ${name}`);
+    }
+  } catch (error: any) {
+    return {
+      content: [{ type: 'text', text: `Error: ${error.message}` }],
+      isError: true,
+    };
+  }
+});
+
+async function main() {
+  const transport = new StdioServerTransport();
+  await server.connect(transport);
+  console.error('REST API MCP server running on stdio');
+}
+
+main().catch((error) => {
+  console.error('Server error:', error);
+  process.exit(1);
+});

package/dist/templates/rest-api/src/tools/api.ts

@@ -0,0 +1,66 @@
+import fetch from 'node-fetch';
+
+const BASE_URL = process.env.API_BASE_URL || '';
+const API_KEY = process.env.API_KEY || '';
+const TIMEOUT = 10000;
+
+export async function getResource(path: string) {
+  const controller = new AbortController();
+  const timeout = setTimeout(() => controller.abort(), TIMEOUT);
+
+  try {
+    const response = await fetch(`${BASE_URL}${path}`, {
+      method: 'GET',
+      headers: {
+        'Authorization': `Bearer ${API_KEY}`,
+        'Content-Type': 'application/json',
+      },
+      signal: controller.signal,
+    });
+
+    clearTimeout(timeout);
+
+    if (!response.ok) {
+      throw new Error(`HTTP ${response.status}: ${response.statusText}`);
+    }
+
+    return await response.json();
+  } catch (error: any) {
+    clearTimeout(timeout);
+    if (error.name === 'AbortError') {
+      throw new Error('Request timeout');
+    }
+    throw new Error(`API error: ${error.message}`);
+  }
+}
+
+export async function postResource(path: string, data: any) {
+  const controller = new AbortController();
+  const timeout = setTimeout(() => controller.abort(), TIMEOUT);
+
+  try {
+    const response = await fetch(`${BASE_URL}${path}`, {
+      method: 'POST',
+      headers: {
+        'Authorization': `Bearer ${API_KEY}`,
+        'Content-Type': 'application/json',
+      },
+      body: JSON.stringify(data),
+      signal: controller.signal,
+    });
+
+    clearTimeout(timeout);
+
+    if (!response.ok) {
+      throw new Error(`HTTP ${response.status}: ${response.statusText}`);
+    }
+
+    return await response.json();
+  } catch (error: any) {
+    clearTimeout(timeout);
+    if (error.name === 'AbortError') {
+      throw new Error('Request timeout');
+    }
+    throw new Error(`API error: ${error.message}`);
+  }
+}

package/dist/templates/rest-api/tests/api.test.ts

@@ -0,0 +1,32 @@
+import { describe, it, expect, vi, beforeEach } from 'vitest';
+
+vi.mock('node-fetch', () => ({
+  default: vi.fn((url: string, options: any) => {
+    if (options?.signal?.aborted) {
+      return Promise.reject(new Error('AbortError'));
+    }
+    return Promise.resolve({
+      ok: true,
+      status: 200,
+      json: () => Promise.resolve({ success: true }),
+    });
+  }),
+}));
+
+describe('API Tools', () => {
+  beforeEach(() => {
+    vi.clearAllMocks();
+  });
+
+  it('getResource makes HTTP request', async () => {
+    const { getResource } = await import('../src/tools/api.js');
+    const result = await getResource('/test');
+    expect(result).toEqual({ success: true });
+  });
+
+  it('postResource makes HTTP POST request', async () => {
+    const { postResource } = await import('../src/tools/api.js');
+    const result = await postResource('/test', { data: 'test' });
+    expect(result).toEqual({ success: true });
+  });
+});

package/dist/templates/rest-api/tsconfig.json

@@ -0,0 +1,12 @@
+{
+  "compilerOptions": {
+    "target": "ES2022",
+    "module": "ESNext",
+    "moduleResolution": "bundler",
+    "lib": ["ES2022"],
+    "strict": true,
+    "esModuleInterop": true,
+    "skipLibCheck": true
+  },
+  "include": ["src/**/*", "tests/**/*"]
+}

package/package.json

@@ -0,0 +1,49 @@
+{
+  "name": "create-mcp-forge",
+  "version": "0.1.0",
+  "description": "The fastest way to build MCP servers",
+  "type": "module",
+  "bin": {
+    "create-mcp-forge": "./dist/index.js"
+  },
+  "scripts": {
+    "build": "tsup && cp -r templates dist/",
+    "dev": "tsup --watch",
+    "test": "vitest run",
+    "test:watch": "vitest"
+  },
+  "keywords": [
+    "mcp",
+    "cli",
+    "scaffold",
+    "model-context-protocol",
+    "anthropic",
+    "claude"
+  ],
+  "author": "hiyilmaz",
+  "license": "MIT",
+  "repository": {
+    "type": "git",
+    "url": "git+https://github.com/hiyilmaz/mcp-forge.git"
+  },
+  "bugs": {
+    "url": "https://github.com/hiyilmaz/mcp-forge/issues"
+  },
+  "homepage": "https://github.com/hiyilmaz/mcp-forge#readme",
+  "files": [
+    "dist"
+  ],
+  "dependencies": {
+    "@clack/prompts": "^0.7.0",
+    "commander": "^12.0.0"
+  },
+  "devDependencies": {
+    "@types/node": "^20.11.0",
+    "tsup": "^8.0.1",
+    "typescript": "^5.3.3",
+    "vitest": "^1.2.0"
+  },
+  "engines": {
+    "node": ">=18.0.0"
+  }
+}