@agentailor/create-mcp-server 0.1.0

package/README.md

@@ -0,0 +1,19 @@
+# @agentailor/create-mcp-server
+
+Create a new MCP (Model Context Protocol) server project.
+
+## Usage
+
+```bash
+npx @agentailor/create-mcp-server
+```
+
+This will prompt you for a project name and create a new directory with a README.md file.
+
+## What is MCP?
+
+The [Model Context Protocol](https://modelcontextprotocol.io/) (MCP) is an open protocol that enables AI assistants to interact with external tools, data sources, and services.
+
+## License
+
+MIT

package/dist/index.d.ts

@@ -0,0 +1,2 @@
+#!/usr/bin/env node
+export {};

package/dist/index.js

@@ -0,0 +1,114 @@
+#!/usr/bin/env node
+import prompts from 'prompts';
+import { mkdir, writeFile } from 'node:fs/promises';
+import { join } from 'node:path';
+import { getPackageJsonTemplate } from './templates/common/package.json.js';
+import { getTsconfigTemplate } from './templates/common/tsconfig.json.js';
+import { getGitignoreTemplate } from './templates/common/gitignore.js';
+import { getEnvExampleTemplate } from './templates/common/env.example.js';
+import { getServerTemplate as getStatelessServerTemplate, getIndexTemplate as getStatelessIndexTemplate, getReadmeTemplate as getStatelessReadmeTemplate, } from './templates/streamable-http/index.js';
+import { getServerTemplate as getStatefulServerTemplate, getIndexTemplate as getStatefulIndexTemplate, getReadmeTemplate as getStatefulReadmeTemplate, } from './templates/stateful-streamable-http/index.js';
+const templateFunctions = {
+    stateless: {
+        getServerTemplate: getStatelessServerTemplate,
+        getIndexTemplate: getStatelessIndexTemplate,
+        getReadmeTemplate: getStatelessReadmeTemplate,
+    },
+    stateful: {
+        getServerTemplate: getStatefulServerTemplate,
+        getIndexTemplate: getStatefulIndexTemplate,
+        getReadmeTemplate: getStatefulReadmeTemplate,
+    },
+};
+const packageManagerCommands = {
+    npm: { install: 'npm install', dev: 'npm run dev' },
+    pnpm: { install: 'pnpm install', dev: 'pnpm dev' },
+    yarn: { install: 'yarn', dev: 'yarn dev' },
+};
+async function main() {
+    console.log('\n🚀 Create MCP Server\n');
+    const onCancel = () => {
+        console.log('\n❌ Operation cancelled\n');
+        process.exit(0);
+    };
+    const projectNameResponse = await prompts({
+        type: 'text',
+        name: 'projectName',
+        message: 'Project name:',
+        initial: 'my-mcp-server',
+        validate: (value) => {
+            if (!value)
+                return 'Project name is required';
+            if (!/^[a-z0-9-_]+$/i.test(value)) {
+                return 'Project name can only contain letters, numbers, hyphens, and underscores';
+            }
+            return true;
+        },
+    }, { onCancel });
+    const { projectName } = projectNameResponse;
+    if (!projectName) {
+        console.log('\n❌ Project name is required\n');
+        process.exit(1);
+    }
+    const packageManagerResponse = await prompts({
+        type: 'select',
+        name: 'packageManager',
+        message: 'Package manager:',
+        choices: [
+            { title: 'npm', value: 'npm' },
+            { title: 'pnpm', value: 'pnpm' },
+            { title: 'yarn', value: 'yarn' },
+        ],
+        initial: 0,
+    }, { onCancel });
+    const packageManager = packageManagerResponse.packageManager || 'npm';
+    const templateTypeResponse = await prompts({
+        type: 'select',
+        name: 'templateType',
+        message: 'Template type:',
+        choices: [
+            { title: 'Stateless', value: 'stateless', description: 'Simple stateless HTTP server' },
+            {
+                title: 'Stateful',
+                value: 'stateful',
+                description: 'Session-based server with SSE support',
+            },
+        ],
+        initial: 0,
+    }, { onCancel });
+    const templateType = templateTypeResponse.templateType || 'stateless';
+    const templates = templateFunctions[templateType];
+    const projectPath = join(process.cwd(), projectName);
+    const srcPath = join(projectPath, 'src');
+    try {
+        // Create directories
+        await mkdir(srcPath, { recursive: true });
+        // Write all template files
+        await Promise.all([
+            writeFile(join(srcPath, 'server.ts'), templates.getServerTemplate(projectName)),
+            writeFile(join(srcPath, 'index.ts'), templates.getIndexTemplate()),
+            writeFile(join(projectPath, 'package.json'), getPackageJsonTemplate(projectName)),
+            writeFile(join(projectPath, 'tsconfig.json'), getTsconfigTemplate()),
+            writeFile(join(projectPath, '.gitignore'), getGitignoreTemplate()),
+            writeFile(join(projectPath, '.env.example'), getEnvExampleTemplate()),
+            writeFile(join(projectPath, 'README.md'), templates.getReadmeTemplate(projectName)),
+        ]);
+        const commands = packageManagerCommands[packageManager];
+        console.log(`\n✅ Created ${projectName} at ${projectPath}`);
+        console.log(`\nNext steps:`);
+        console.log(`  cd ${projectName}`);
+        console.log(`  ${commands.install}`);
+        console.log(`  ${commands.dev}`);
+        console.log(`\n`);
+    }
+    catch (error) {
+        if (error instanceof Error) {
+            console.error(`\n❌ Error: ${error.message}\n`);
+        }
+        else {
+            console.error('\n❌ An unexpected error occurred\n');
+        }
+        process.exit(1);
+    }
+}
+main();

package/dist/templates/common/env.example.d.ts

@@ -0,0 +1 @@
+export declare function getEnvExampleTemplate(): string;

package/dist/templates/common/env.example.js

@@ -0,0 +1,4 @@
+export function getEnvExampleTemplate() {
+    return `PORT=3000
+`;
+}

package/dist/templates/common/gitignore.d.ts

@@ -0,0 +1 @@
+export declare function getGitignoreTemplate(): string;

package/dist/templates/common/gitignore.js

@@ -0,0 +1,8 @@
+export function getGitignoreTemplate() {
+    return `node_modules/
+dist/
+*.log
+.DS_Store
+.env
+`;
+}

package/dist/templates/common/package.json.d.ts

@@ -0,0 +1 @@
+export declare function getPackageJsonTemplate(projectName: string): string;

package/dist/templates/common/package.json.js

@@ -0,0 +1,27 @@
+export function getPackageJsonTemplate(projectName) {
+    const packageJson = {
+        name: projectName,
+        version: '0.1.0',
+        type: 'module',
+        main: 'dist/index.js',
+        scripts: {
+            build: 'tsc',
+            dev: 'tsc && node dist/index.js',
+            start: 'node dist/index.js',
+        },
+        dependencies: {
+            '@modelcontextprotocol/sdk': '^1.12.1',
+            express: '^5.1.0',
+            zod: '^3.25.30',
+        },
+        devDependencies: {
+            '@types/express': '^5.0.0',
+            '@types/node': '^22.15.21',
+            typescript: '^5.8.3',
+        },
+        engines: {
+            node: '>=20',
+        },
+    };
+    return JSON.stringify(packageJson, null, 2) + '\n';
+}

package/dist/templates/common/templates.test.d.ts

@@ -0,0 +1 @@
+export {};

package/dist/templates/common/templates.test.js

@@ -0,0 +1,60 @@
+import { describe, it, expect } from 'vitest';
+import { getPackageJsonTemplate } from './package.json.js';
+import { getTsconfigTemplate } from './tsconfig.json.js';
+import { getGitignoreTemplate } from './gitignore.js';
+import { getEnvExampleTemplate } from './env.example.js';
+describe('common templates', () => {
+    const projectName = 'test-project';
+    describe('getPackageJsonTemplate', () => {
+        it('should include project name', () => {
+            const template = getPackageJsonTemplate(projectName);
+            const pkg = JSON.parse(template);
+            expect(pkg.name).toBe(projectName);
+        });
+        it('should use correct SDK package', () => {
+            const template = getPackageJsonTemplate(projectName);
+            const pkg = JSON.parse(template);
+            expect(pkg.dependencies['@modelcontextprotocol/sdk']).toBeDefined();
+        });
+        it('should include required scripts', () => {
+            const template = getPackageJsonTemplate(projectName);
+            const pkg = JSON.parse(template);
+            expect(pkg.scripts.build).toBe('tsc');
+            expect(pkg.scripts.dev).toBeDefined();
+            expect(pkg.scripts.start).toBeDefined();
+        });
+        it('should be valid JSON', () => {
+            const template = getPackageJsonTemplate(projectName);
+            expect(() => JSON.parse(template)).not.toThrow();
+        });
+    });
+    describe('getTsconfigTemplate', () => {
+        it('should be valid JSON', () => {
+            const template = getTsconfigTemplate();
+            expect(() => JSON.parse(template)).not.toThrow();
+        });
+        it('should target ES2022 with NodeNext modules', () => {
+            const template = getTsconfigTemplate();
+            const config = JSON.parse(template);
+            expect(config.compilerOptions.target).toBe('ES2022');
+            expect(config.compilerOptions.module).toBe('NodeNext');
+        });
+    });
+    describe('getGitignoreTemplate', () => {
+        it('should ignore node_modules and dist', () => {
+            const template = getGitignoreTemplate();
+            expect(template).toContain('node_modules/');
+            expect(template).toContain('dist/');
+        });
+        it('should ignore .env', () => {
+            const template = getGitignoreTemplate();
+            expect(template).toContain('.env');
+        });
+    });
+    describe('getEnvExampleTemplate', () => {
+        it('should include PORT variable', () => {
+            const template = getEnvExampleTemplate();
+            expect(template).toContain('PORT=');
+        });
+    });
+});

package/dist/templates/common/tsconfig.json.d.ts

@@ -0,0 +1 @@
+export declare function getTsconfigTemplate(): string;

package/dist/templates/common/tsconfig.json.js

@@ -0,0 +1,19 @@
+export function getTsconfigTemplate() {
+    const tsconfig = {
+        compilerOptions: {
+            target: 'ES2022',
+            module: 'NodeNext',
+            moduleResolution: 'NodeNext',
+            outDir: './dist',
+            rootDir: './src',
+            strict: true,
+            esModuleInterop: true,
+            skipLibCheck: true,
+            forceConsistentCasingInFileNames: true,
+            declaration: true,
+        },
+        include: ['src/**/*'],
+        exclude: ['node_modules', 'dist'],
+    };
+    return JSON.stringify(tsconfig, null, 2) + '\n';
+}

package/dist/templates/stateful-streamable-http/index.d.ts

@@ -0,0 +1,3 @@
+export declare function getIndexTemplate(): string;
+export { getServerTemplate } from './server.js';
+export { getReadmeTemplate } from './readme.js';

package/dist/templates/stateful-streamable-http/index.js

@@ -0,0 +1,140 @@
+export function getIndexTemplate() {
+    return `import { type Request, type Response } from 'express';
+import { randomUUID } from 'node:crypto';
+import { createMcpExpressApp } from '@modelcontextprotocol/sdk/server/express.js';
+import { StreamableHTTPServerTransport } from '@modelcontextprotocol/sdk/server/streamableHttp.js';
+import { isInitializeRequest } from '@modelcontextprotocol/sdk/types.js';
+import { getServer } from './server.js';
+
+const app = createMcpExpressApp();
+
+// Map to store transports by session ID
+const transports: { [sessionId: string]: StreamableHTTPServerTransport } = {};
+
+app.post('/mcp', async (req: Request, res: Response) => {
+  const sessionId = req.headers['mcp-session-id'] as string | undefined;
+  if (sessionId) {
+    console.log(\`Received MCP request for session: \${sessionId}\`);
+  }
+
+  try {
+    let transport: StreamableHTTPServerTransport;
+
+    if (sessionId && transports[sessionId]) {
+      // Reuse existing transport
+      transport = transports[sessionId];
+    } else if (!sessionId && isInitializeRequest(req.body)) {
+      // New initialization request
+      transport = new StreamableHTTPServerTransport({
+        sessionIdGenerator: () => randomUUID(),
+        onsessioninitialized: (sessionId: string) => {
+          // Store the transport by session ID when session is initialized
+          console.log(\`Session initialized with ID: \${sessionId}\`);
+          transports[sessionId] = transport;
+        },
+      });
+
+      // Set up onclose handler to clean up transport when closed
+      transport.onclose = () => {
+        const sid = transport.sessionId;
+        if (sid && transports[sid]) {
+          console.log(\`Transport closed for session \${sid}, removing from transports map\`);
+          delete transports[sid];
+        }
+      };
+
+      // Connect the transport to the MCP server BEFORE handling the request
+      const server = getServer();
+      await server.connect(transport);
+
+      await transport.handleRequest(req, res, req.body);
+      return;
+    } else {
+      // Invalid request - no session ID or not initialization request
+      res.status(400).json({
+        jsonrpc: '2.0',
+        error: {
+          code: -32000,
+          message: 'Bad Request: No valid session ID provided',
+        },
+        id: null,
+      });
+      return;
+    }
+
+    // Handle the request with existing transport
+    await transport.handleRequest(req, res, req.body);
+  } catch (error) {
+    console.error('Error handling MCP request:', error);
+    if (!res.headersSent) {
+      res.status(500).json({
+        jsonrpc: '2.0',
+        error: {
+          code: -32603,
+          message: 'Internal server error',
+        },
+        id: null,
+      });
+    }
+  }
+});
+
+app.get('/mcp', async (req: Request, res: Response) => {
+  const sessionId = req.headers['mcp-session-id'] as string | undefined;
+  if (!sessionId || !transports[sessionId]) {
+    res.status(400).send('Invalid or missing session ID');
+    return;
+  }
+
+  console.log(\`Establishing SSE stream for session \${sessionId}\`);
+  const transport = transports[sessionId];
+  await transport.handleRequest(req, res);
+});
+
+app.delete('/mcp', async (req: Request, res: Response) => {
+  const sessionId = req.headers['mcp-session-id'] as string | undefined;
+  if (!sessionId || !transports[sessionId]) {
+    res.status(400).send('Invalid or missing session ID');
+    return;
+  }
+
+  console.log(\`Received session termination request for session \${sessionId}\`);
+
+  try {
+    const transport = transports[sessionId];
+    await transport.handleRequest(req, res);
+  } catch (error) {
+    console.error('Error handling session termination:', error);
+    if (!res.headersSent) {
+      res.status(500).send('Error processing session termination');
+    }
+  }
+});
+
+// Start the server
+const PORT = process.env.PORT || 3000;
+app.listen(PORT, () => {
+  console.log(\`MCP Stateful HTTP Server listening on port \${PORT}\`);
+});
+
+// Handle server shutdown
+process.on('SIGINT', async () => {
+  console.log('Shutting down server...');
+
+  // Close all active transports to properly clean up resources
+  for (const sessionId in transports) {
+    try {
+      console.log(\`Closing transport for session \${sessionId}\`);
+      await transports[sessionId].close();
+      delete transports[sessionId];
+    } catch (error) {
+      console.error(\`Error closing transport for session \${sessionId}:\`, error);
+    }
+  }
+  console.log('Server shutdown complete');
+  process.exit(0);
+});
+`;
+}
+export { getServerTemplate } from './server.js';
+export { getReadmeTemplate } from './readme.js';

package/dist/templates/stateful-streamable-http/readme.d.ts

@@ -0,0 +1 @@
+export declare function getReadmeTemplate(projectName: string): string;

package/dist/templates/stateful-streamable-http/readme.js

@@ -0,0 +1,86 @@
+export function getReadmeTemplate(projectName) {
+    return `# ${projectName}
+
+A stateful streamable HTTP MCP (Model Context Protocol) server with session management.
+
+## About
+
+This project was created with [@agentailor/create-mcp-server](https://www.npmjs.com/package/@agentailor/create-mcp-server).
+
+## Getting Started
+
+\`\`\`bash
+# Install dependencies
+npm install
+
+# Build and run in development
+npm run dev
+
+# Or build and start separately
+npm run build
+npm start
+\`\`\`
+
+The server will start on port 3000 by default. You can change this by setting the \`PORT\` environment variable.
+
+## API Endpoints
+
+- **POST /mcp** - Main MCP endpoint for JSON-RPC messages
+  - First request must be an initialization request (no session ID required)
+  - Subsequent requests must include \`mcp-session-id\` header
+- **GET /mcp** - Server-Sent Events (SSE) stream for server-initiated messages
+  - Requires \`mcp-session-id\` header
+- **DELETE /mcp** - Terminate a session
+  - Requires \`mcp-session-id\` header
+
+## Session Management
+
+This server maintains stateful sessions:
+
+1. **Initialize**: Send a POST request without a session ID to start a new session
+2. **Session ID**: The server returns an \`mcp-session-id\` header in the response
+3. **Subsequent requests**: Include the session ID in the \`mcp-session-id\` header
+4. **SSE Stream**: Use GET /mcp with your session ID to receive server-initiated messages
+5. **Terminate**: Send DELETE /mcp with your session ID to end the session
+
+## Included Examples
+
+This server comes with example implementations to help you get started:
+
+### Prompts
+
+- **greeting-template** - A simple greeting prompt that takes a name parameter
+
+### Tools
+
+- **start-notification-stream** - Sends periodic notifications for testing. Parameters:
+  - \`interval\`: Milliseconds between notifications (default: 100)
+  - \`count\`: Number of notifications to send (default: 10, use 0 for unlimited)
+
+### Resources
+
+- **greeting-resource** - A simple text resource at \`https://example.com/greetings/default\`
+
+## Project Structure
+
+\`\`\`
+${projectName}/
+├── src/
+│   ├── server.ts     # MCP server definition (tools, prompts, resources)
+│   └── index.ts      # Express app and stateful HTTP transport setup
+├── package.json
+├── tsconfig.json
+└── README.md
+\`\`\`
+
+## Customization
+
+- Add new tools, prompts, and resources in \`src/server.ts\`
+- Modify the HTTP transport configuration in \`src/index.ts\`
+
+## Learn More
+
+- [Model Context Protocol](https://modelcontextprotocol.io/)
+- [MCP TypeScript SDK](https://github.com/modelcontextprotocol/typescript-sdk)
+`;
+}

package/dist/templates/stateful-streamable-http/server.d.ts

@@ -0,0 +1 @@
+export { getServerTemplate } from '../streamable-http/server.js';

package/dist/templates/stateful-streamable-http/server.js

@@ -0,0 +1,2 @@
+// Re-export from stateless template - server logic is identical
+export { getServerTemplate } from '../streamable-http/server.js';

package/dist/templates/stateful-streamable-http/templates.test.d.ts

@@ -0,0 +1 @@
+export {};

package/dist/templates/stateful-streamable-http/templates.test.js

@@ -0,0 +1,111 @@
+import { describe, it, expect } from 'vitest';
+import { getServerTemplate, getIndexTemplate, getReadmeTemplate } from './index.js';
+describe('stateful-streamable-http templates', () => {
+    const projectName = 'test-project';
+    describe('getServerTemplate', () => {
+        it('should include project name in server config', () => {
+            const template = getServerTemplate(projectName);
+            expect(template).toContain(`name: '${projectName}'`);
+        });
+        it('should use correct SDK imports', () => {
+            const template = getServerTemplate(projectName);
+            expect(template).toContain("from '@modelcontextprotocol/sdk/types.js'");
+            expect(template).toContain("from '@modelcontextprotocol/sdk/server/mcp.js'");
+        });
+        it('should include example prompt', () => {
+            const template = getServerTemplate(projectName);
+            expect(template).toContain('greeting-template');
+            expect(template).toContain('registerPrompt');
+        });
+        it('should include example tool', () => {
+            const template = getServerTemplate(projectName);
+            expect(template).toContain('start-notification-stream');
+            expect(template).toContain('registerTool');
+        });
+        it('should include example resource', () => {
+            const template = getServerTemplate(projectName);
+            expect(template).toContain('greeting-resource');
+            expect(template).toContain('registerResource');
+        });
+    });
+    describe('getIndexTemplate', () => {
+        it('should use correct SDK import for transport', () => {
+            const template = getIndexTemplate();
+            expect(template).toContain("from '@modelcontextprotocol/sdk/server/streamableHttp.js'");
+        });
+        it('should use createMcpExpressApp', () => {
+            const template = getIndexTemplate();
+            expect(template).toContain('createMcpExpressApp');
+            expect(template).toContain('const app = createMcpExpressApp()');
+        });
+        it('should configure /mcp endpoint', () => {
+            const template = getIndexTemplate();
+            expect(template).toContain("app.post('/mcp'");
+            expect(template).toContain("app.get('/mcp'");
+            expect(template).toContain("app.delete('/mcp'");
+        });
+        it('should use PORT from environment variable', () => {
+            const template = getIndexTemplate();
+            expect(template).toContain('process.env.PORT || 3000');
+        });
+        // Stateful-specific tests
+        it('should use session ID header', () => {
+            const template = getIndexTemplate();
+            expect(template).toContain('mcp-session-id');
+        });
+        it('should store transports by session ID', () => {
+            const template = getIndexTemplate();
+            expect(template).toContain('const transports');
+            expect(template).toContain('transports[sessionId]');
+        });
+        it('should use isInitializeRequest for new sessions', () => {
+            const template = getIndexTemplate();
+            expect(template).toContain('isInitializeRequest');
+        });
+        it('should generate session IDs with randomUUID', () => {
+            const template = getIndexTemplate();
+            expect(template).toContain('randomUUID');
+            expect(template).toContain('sessionIdGenerator');
+        });
+        it('should handle session cleanup on close', () => {
+            const template = getIndexTemplate();
+            expect(template).toContain('transport.onclose');
+            expect(template).toContain('delete transports[sid]');
+        });
+        it('should close all transports on SIGINT', () => {
+            const template = getIndexTemplate();
+            expect(template).toContain("process.on('SIGINT'");
+            expect(template).toContain('transports[sessionId].close()');
+        });
+    });
+    describe('getReadmeTemplate', () => {
+        it('should include project name', () => {
+            const template = getReadmeTemplate(projectName);
+            expect(template).toContain(`# ${projectName}`);
+        });
+        it('should include getting started instructions', () => {
+            const template = getReadmeTemplate(projectName);
+            expect(template).toContain('npm install');
+            expect(template).toContain('npm run dev');
+        });
+        it('should document the /mcp endpoint', () => {
+            const template = getReadmeTemplate(projectName);
+            expect(template).toContain('/mcp');
+        });
+        // Stateful-specific documentation tests
+        it('should document session management', () => {
+            const template = getReadmeTemplate(projectName);
+            expect(template).toContain('mcp-session-id');
+            expect(template).toContain('Session');
+        });
+        it('should document SSE stream support', () => {
+            const template = getReadmeTemplate(projectName);
+            expect(template).toContain('GET /mcp');
+            expect(template).toContain('SSE');
+        });
+        it('should document session termination', () => {
+            const template = getReadmeTemplate(projectName);
+            expect(template).toContain('DELETE /mcp');
+        });
+    });
+});

package/dist/templates/streamable-http/index.d.ts

@@ -0,0 +1,3 @@
+export declare function getIndexTemplate(): string;
+export { getServerTemplate } from './server.js';
+export { getReadmeTemplate } from './readme.js';

package/dist/templates/streamable-http/index.js

@@ -0,0 +1,83 @@
+export function getIndexTemplate() {
+    return `import { type Request, type Response } from 'express';
+import { createMcpExpressApp } from '@modelcontextprotocol/sdk/server/express.js';
+import { StreamableHTTPServerTransport } from '@modelcontextprotocol/sdk/server/streamableHttp.js';
+import { getServer } from './server.js';
+
+const app = createMcpExpressApp();
+
+app.post('/mcp', async (req: Request, res: Response) => {
+  const server = getServer();
+  try {
+    const transport: StreamableHTTPServerTransport = new StreamableHTTPServerTransport({
+      sessionIdGenerator: undefined,
+    });
+    await server.connect(transport);
+    await transport.handleRequest(req, res, req.body);
+    res.on('close', () => {
+      console.log('Request closed');
+      transport.close();
+      server.close();
+    });
+  } catch (error) {
+    console.error('Error handling MCP request:', error);
+    if (!res.headersSent) {
+      res.status(500).json({
+        jsonrpc: '2.0',
+        error: {
+          code: -32603,
+          message: 'Internal server error',
+        },
+        id: null,
+      });
+    }
+  }
+});
+
+app.get('/mcp', async (req: Request, res: Response) => {
+  console.log('Received GET MCP request');
+  res.writeHead(405).end(
+    JSON.stringify({
+      jsonrpc: '2.0',
+      error: {
+        code: -32000,
+        message: 'Method not allowed.',
+      },
+      id: null,
+    })
+  );
+});
+
+app.delete('/mcp', async (req: Request, res: Response) => {
+  console.log('Received DELETE MCP request');
+  res.writeHead(405).end(
+    JSON.stringify({
+      jsonrpc: '2.0',
+      error: {
+        code: -32000,
+        message: 'Method not allowed.',
+      },
+      id: null,
+    })
+  );
+});
+
+// Start the server
+const PORT = process.env.PORT || 3000;
+app.listen(PORT, (error) => {
+  if (error) {
+    console.error('Failed to start server:', error);
+    process.exit(1);
+  }
+  console.log(\`MCP Streamable HTTP Server listening on port \${PORT}\`);
+});
+
+// Handle server shutdown
+process.on('SIGINT', async () => {
+  console.log('Shutting down server...');
+  process.exit(0);
+});
+`;
+}
+export { getServerTemplate } from './server.js';
+export { getReadmeTemplate } from './readme.js';

package/dist/templates/streamable-http/readme.d.ts

@@ -0,0 +1 @@
+export declare function getReadmeTemplate(projectName: string): string;

package/dist/templates/streamable-http/readme.js

@@ -0,0 +1,70 @@
+export function getReadmeTemplate(projectName) {
+    return `# ${projectName}
+
+A stateless streamable HTTP MCP (Model Context Protocol) server.
+
+## About
+
+This project was created with [@agentailor/create-mcp-server](https://www.npmjs.com/package/@agentailor/create-mcp-server).
+
+## Getting Started
+
+\`\`\`bash
+# Install dependencies
+npm install
+
+# Build and run in development
+npm run dev
+
+# Or build and start separately
+npm run build
+npm start
+\`\`\`
+
+The server will start on port 3000 by default. You can change this by setting the \`PORT\` environment variable.
+
+## API Endpoint
+
+- **POST /mcp** - Main MCP endpoint for JSON-RPC messages
+
+## Included Examples
+
+This server comes with example implementations to help you get started:
+
+### Prompts
+
+- **greeting-template** - A simple greeting prompt that takes a name parameter
+
+### Tools
+
+- **start-notification-stream** - Sends periodic notifications for testing. Parameters:
+  - \`interval\`: Milliseconds between notifications (default: 100)
+  - \`count\`: Number of notifications to send (default: 10, use 0 for unlimited)
+
+### Resources
+
+- **greeting-resource** - A simple text resource at \`https://example.com/greetings/default\`
+
+## Project Structure
+
+\`\`\`
+${projectName}/
+├── src/
+│   ├── server.ts     # MCP server definition (tools, prompts, resources)
+│   └── index.ts      # Express app and HTTP transport setup
+├── package.json
+├── tsconfig.json
+└── README.md
+\`\`\`
+
+## Customization
+
+- Add new tools, prompts, and resources in \`src/server.ts\`
+- Modify the HTTP transport configuration in \`src/index.ts\`
+
+## Learn More
+
+- [Model Context Protocol](https://modelcontextprotocol.io/)
+- [MCP TypeScript SDK](https://github.com/modelcontextprotocol/typescript-sdk)
+`;
+}

package/dist/templates/streamable-http/server.d.ts

@@ -0,0 +1 @@
+export declare function getServerTemplate(projectName: string): string;

package/dist/templates/streamable-http/server.js

@@ -0,0 +1,105 @@
+export function getServerTemplate(projectName) {
+    return `import type { CallToolResult, GetPromptResult, ReadResourceResult } from '@modelcontextprotocol/sdk/types.js';
+import { McpServer } from '@modelcontextprotocol/sdk/server/mcp.js';
+import { z } from 'zod';
+
+export function getServer() {
+  // Create an MCP server with implementation details
+  const server = new McpServer(
+    {
+      name: '${projectName}',
+      version: '1.0.0',
+    },
+    { capabilities: { logging: {} } }
+  );
+
+  // Register a simple prompt
+  server.registerPrompt(
+    'greeting-template',
+    {
+      description: 'A simple greeting prompt template',
+      argsSchema: {
+        name: z.string().describe('Name to include in greeting'),
+      },
+    },
+    async ({ name }): Promise<GetPromptResult> => {
+      return {
+        messages: [
+          {
+            role: 'user',
+            content: {
+              type: 'text',
+              text: \`Please greet \${name} in a friendly manner.\`,
+            },
+          },
+        ],
+      };
+    }
+  );
+
+  // Register a tool for testing resumability
+  server.registerTool(
+    'start-notification-stream',
+    {
+      description: 'Starts sending periodic notifications for testing resumability',
+      inputSchema: {
+        interval: z
+          .number()
+          .describe('Interval in milliseconds between notifications')
+          .default(100),
+        count: z.number().describe('Number of notifications to send (0 for 100)').default(10),
+      },
+    },
+    async ({ interval, count }, extra): Promise<CallToolResult> => {
+      const sleep = (ms: number) => new Promise((resolve) => setTimeout(resolve, ms));
+      let counter = 0;
+
+      while (count === 0 || counter < count) {
+        counter++;
+        try {
+          await server.sendLoggingMessage(
+            {
+              level: 'info',
+              data: \`Periodic notification #\${counter} at \${new Date().toISOString()}\`,
+            },
+            extra.sessionId
+          );
+        } catch (error) {
+          console.error('Error sending notification:', error);
+        }
+        // Wait for the specified interval
+        await sleep(interval);
+      }
+
+      return {
+        content: [
+          {
+            type: 'text',
+            text: \`Started sending periodic notifications every \${interval}ms\`,
+          },
+        ],
+      };
+    }
+  );
+
+  // Create a simple resource at a fixed URI
+  server.registerResource(
+    'greeting-resource',
+    'https://example.com/greetings/default',
+    { mimeType: 'text/plain' },
+    async (): Promise<ReadResourceResult> => {
+      return {
+        contents: [
+          {
+            uri: 'https://example.com/greetings/default',
+            text: 'Hello, world!',
+          },
+        ],
+      };
+    }
+  );
+
+  return server;
+}
+`;
+}

package/dist/templates/streamable-http/templates.test.d.ts

@@ -0,0 +1 @@
+export {};

package/dist/templates/streamable-http/templates.test.js

@@ -0,0 +1,80 @@
+import { describe, it, expect } from 'vitest';
+import { getServerTemplate, getIndexTemplate, getReadmeTemplate } from './index.js';
+describe('streamable-http templates', () => {
+    const projectName = 'test-project';
+    describe('getServerTemplate', () => {
+        it('should include project name in server config', () => {
+            const template = getServerTemplate(projectName);
+            expect(template).toContain(`name: '${projectName}'`);
+        });
+        it('should use correct SDK imports', () => {
+            const template = getServerTemplate(projectName);
+            expect(template).toContain("from '@modelcontextprotocol/sdk/types.js'");
+            expect(template).toContain("from '@modelcontextprotocol/sdk/server/mcp.js'");
+        });
+        it('should include example prompt', () => {
+            const template = getServerTemplate(projectName);
+            expect(template).toContain('greeting-template');
+            expect(template).toContain('registerPrompt');
+        });
+        it('should include example tool', () => {
+            const template = getServerTemplate(projectName);
+            expect(template).toContain('start-notification-stream');
+            expect(template).toContain('registerTool');
+        });
+        it('should include example resource', () => {
+            const template = getServerTemplate(projectName);
+            expect(template).toContain('greeting-resource');
+            expect(template).toContain('registerResource');
+        });
+    });
+    describe('getIndexTemplate', () => {
+        it('should use correct SDK import for transport', () => {
+            const template = getIndexTemplate();
+            expect(template).toContain("from '@modelcontextprotocol/sdk/server/streamableHttp.js'");
+        });
+        it('should use createMcpExpressApp', () => {
+            const template = getIndexTemplate();
+            expect(template).toContain('createMcpExpressApp');
+            expect(template).toContain('const app = createMcpExpressApp()');
+        });
+        it('should configure /mcp endpoint', () => {
+            const template = getIndexTemplate();
+            expect(template).toContain("app.post('/mcp'");
+            expect(template).toContain("app.get('/mcp'");
+            expect(template).toContain("app.delete('/mcp'");
+        });
+        it('should use PORT from environment variable', () => {
+            const template = getIndexTemplate();
+            expect(template).toContain('process.env.PORT || 3000');
+        });
+        // Stateless-specific tests
+        it('should use undefined sessionIdGenerator for stateless mode', () => {
+            const template = getIndexTemplate();
+            expect(template).toContain('sessionIdGenerator: undefined');
+        });
+        it('should return 405 for GET requests', () => {
+            const template = getIndexTemplate();
+            expect(template).toContain('res.writeHead(405)');
+        });
+    });
+    describe('getReadmeTemplate', () => {
+        it('should include project name', () => {
+            const template = getReadmeTemplate(projectName);
+            expect(template).toContain(`# ${projectName}`);
+        });
+        it('should include getting started instructions', () => {
+            const template = getReadmeTemplate(projectName);
+            expect(template).toContain('npm install');
+            expect(template).toContain('npm run dev');
+        });
+        it('should document the /mcp endpoint', () => {
+            const template = getReadmeTemplate(projectName);
+            expect(template).toContain('/mcp');
+        });
+        it('should describe stateless behavior', () => {
+            const template = getReadmeTemplate(projectName);
+            expect(template).toContain('stateless');
+        });
+    });
+});

package/package.json

@@ -0,0 +1,53 @@
+{
+  "name": "@agentailor/create-mcp-server",
+  "version": "0.1.0",
+  "description": "Create a new MCP (Model Context Protocol) server project",
+  "type": "module",
+  "bin": {
+    "create-mcp-server": "./dist/index.js"
+  },
+  "files": [
+    "dist"
+  ],
+  "scripts": {
+    "build": "tsc",
+    "test": "vitest run",
+    "test:watch": "vitest",
+    "lint": "eslint src/",
+    "lint:fix": "eslint src/ --fix",
+    "format": "prettier --write src/",
+    "format:check": "prettier --check src/",
+    "prepublishOnly": "npm run build"
+  },
+  "keywords": [
+    "mcp",
+    "model-context-protocol",
+    "claude",
+    "ai",
+    "scaffold",
+    "cli"
+  ],
+  "author": "agentailor",
+  "license": "MIT",
+  "repository": {
+    "type": "git",
+    "url": "https://github.com/agentailor/create-mcp-server"
+  },
+  "engines": {
+    "node": ">=20"
+  },
+  "dependencies": {
+    "prompts": "^2.4.2"
+  },
+  "devDependencies": {
+    "@eslint/js": "^9.39.2",
+    "@types/node": "^20.0.0",
+    "@types/prompts": "^2.4.9",
+    "eslint": "^9.39.2",
+    "eslint-config-prettier": "^10.1.8",
+    "prettier": "^3.7.4",
+    "typescript": "^5.0.0",
+    "typescript-eslint": "^8.51.0",
+    "vitest": "^4.0.16"
+  }
+}