@agentailor/create-mcp-server 0.5.2 → 0.6.0

package/README.md

@@ -30,8 +30,9 @@ npx @agentailor/create-mcp-server --name=my-server
 | `--name` | `-n` | — | Project name (required in CLI mode) |
 | `--package-manager` | `-p` | `npm` | Package manager: npm, pnpm, yarn |
 | `--framework` | `-f` | `sdk` | Framework: sdk, fastmcp |
-| `--template` | `-t` | `stateless` | Server mode: stateless, stateful |
-| `--oauth` | — | `false` | Enable OAuth (sdk+stateful only) |
+| `--stdio` | — | `false` | Use stdio transport (for local clients) |
+| `--template` | `-t` | `stateless` | Server mode: stateless, stateful (HTTP only) |
+| `--oauth` | — | `false` | Enable OAuth (sdk+stateful only, incompatible with --stdio) |
 | `--no-git` | — | `false` | Skip git initialization |
 | `--help` | `-h` | — | Show help |
 | `--version` | `-V` | — | Show version |
@@ -39,10 +40,16 @@ npx @agentailor/create-mcp-server --name=my-server
 **Examples:**
 
 ```bash
-# Minimal - uses all defaults
+# Minimal - uses all defaults (HTTP streamable)
 npx @agentailor/create-mcp-server --name=my-server
 
-# Full options
+# stdio server (for local clients)
+npx @agentailor/create-mcp-server --name=my-server --stdio
+
+# stdio with FastMCP
+npx @agentailor/create-mcp-server --name=my-server --stdio --framework=fastmcp
+
+# Full HTTP options
 npx @agentailor/create-mcp-server \
   --name=my-auth-server \
   --package-manager=pnpm \
@@ -57,11 +64,12 @@ npx @agentailor/create-mcp-server -n my-server -p yarn -f fastmcp
 ## Features
 
 - **Two frameworks** — Official MCP SDK or FastMCP
-- **Two server modes** — stateless or stateful with session management
-- **Optional OAuth** — OIDC-compliant authentication (SDK only) ([setup guide](docs/oauth-setup.md))
+- **Two transport types** — HTTP (streamable) or stdio (for local cllients)
+- **Two HTTP server modes** — stateless or stateful with session management
+- **Optional OAuth** — OIDC-compliant authentication (SDK HTTP only) ([setup guide](docs/oauth-setup.md))
 - **Package manager choice** — npm, pnpm, or yarn
 - **TypeScript ready** — ready to customize
-- **Docker ready** — production Dockerfile included
+- **Docker ready** — production Dockerfile included (HTTP transport)
 - **MCP Inspector** — built-in debugging with `npm run inspect`
 
 ## Frameworks
@@ -93,7 +101,22 @@ server.start({ transportType: "httpStream", httpStream: { port: 3000 } });
 
 Learn more: [FastMCP Documentation](https://github.com/punkpeye/fastmcp)
 
-## Server Modes
+## Transport Types
+
+| Feature | HTTP (Streamable HTTP) | stdio |
+|---------|------------------------|-------|
+| Use case | Remote access, cloud deployment | Local clients (Claude Desktop) |
+| Protocol | HTTP/SSE | stdin/stdout |
+| Session management | ✓ (stateful mode) | — |
+| OAuth support | ✓ (SDK stateful) | — |
+| Docker deployment | ✓ | — |
+| Port configuration | ✓ | — |
+
+**HTTP**: Deploy as an HTTP server accessible remotely. Choose stateless or stateful mode.
+
+**stdio**: Run as a local process. Communicates over stdin/stdout. Ideal for local clients. No HTTP server, no port, no Dockerfile generated.
+
+## Server Modes (HTTP only)
 
 | Feature | Stateless (default) | Stateful |
 |---------|---------------------|----------|

package/dist/cli.d.ts

@@ -1,9 +1,10 @@
-import type { PackageManager, Framework } from './templates/common/types.js';
+import type { PackageManager, Framework, TransportType } from './templates/common/types.js';
 export type TemplateType = 'stateless' | 'stateful';
 export interface CLIOptions {
     name: string;
     packageManager: PackageManager;
     framework: Framework;
+    transport: TransportType;
     template: TemplateType;
     oauth: boolean;
     git: boolean;

package/dist/cli.js

@@ -23,6 +23,7 @@ export function parseArguments() {
         .addOption(new Option('-t, --template <type>', 'Template type')
         .choices(['stateless', 'stateful'])
         .default('stateless'))
+        .option('--stdio', 'Use stdio transport instead of HTTP', false)
         .option('--oauth', 'Enable OAuth authentication (sdk+stateful only)', false)
         .option('--no-git', 'Skip git repository initialization');
     program.parse();
@@ -41,6 +42,15 @@ export function parseArguments() {
         console.error('Run with --help for all options.\n');
         process.exit(1);
     }
+    // Validate stdio constraints
+    if (opts.stdio && opts.oauth) {
+        console.error('\nError: --stdio cannot be combined with --oauth\n');
+        process.exit(1);
+    }
+    if (opts.stdio && opts.template === 'stateful') {
+        console.error('\nError: --template=stateful is not applicable with --stdio (stdio is inherently stateless)\n');
+        process.exit(1);
+    }
     // Validate OAuth constraint
     if (opts.oauth && (opts.framework !== 'sdk' || opts.template !== 'stateful')) {
         console.error('\nError: --oauth is only valid with --framework=sdk and --template=stateful\n');
@@ -52,6 +62,7 @@ export function parseArguments() {
             name: opts.name,
             packageManager: opts.packageManager,
             framework: opts.framework,
+            transport: (opts.stdio ? 'stdio' : 'http'),
             template: opts.template,
             oauth: opts.oauth,
             git: opts.git, // Commander handles --no-git -> git: false

package/dist/cli.test.js

@@ -32,6 +32,7 @@ describe('CLI argument parsing', () => {
         const result = parseArguments();
         expect(result.options?.packageManager).toBe('npm');
         expect(result.options?.framework).toBe('sdk');
+        expect(result.options?.transport).toBe('http');
         expect(result.options?.template).toBe('stateless');
         expect(result.options?.oauth).toBe(false);
         expect(result.options?.git).toBe(true);
@@ -52,6 +53,7 @@ describe('CLI argument parsing', () => {
             name: 'test-project',
             packageManager: 'pnpm',
             framework: 'fastmcp',
+            transport: 'http',
             template: 'stateful',
             oauth: false,
             git: false,
@@ -142,4 +144,61 @@ describe('CLI argument parsing', () => {
         // No args = interactive mode
         expect(result.mode).toBe('interactive');
     });
+    it('--stdio sets transport to stdio', async () => {
+        process.argv = ['node', 'create-mcp-server', '--name=my-stdio-server', '--stdio'];
+        const { parseArguments } = await import('./cli.js');
+        const result = parseArguments();
+        expect(result.mode).toBe('cli');
+        expect(result.options?.transport).toBe('stdio');
+        expect(result.options?.oauth).toBe(false);
+    });
+    it('--stdio with --framework=fastmcp is valid', async () => {
+        process.argv = [
+            'node',
+            'create-mcp-server',
+            '--name=my-server',
+            '--stdio',
+            '--framework=fastmcp',
+        ];
+        const { parseArguments } = await import('./cli.js');
+        const result = parseArguments();
+        expect(result.options?.transport).toBe('stdio');
+        expect(result.options?.framework).toBe('fastmcp');
+    });
+    it('exits with error when --stdio combined with --oauth', async () => {
+        process.argv = [
+            'node',
+            'create-mcp-server',
+            '--name=test',
+            '--stdio',
+            '--oauth',
+            '--framework=sdk',
+            '--template=stateful',
+        ];
+        let exitCode;
+        process.exit = vi.fn((code) => {
+            exitCode = code;
+            throw new Error('process.exit called');
+        });
+        const consoleError = vi.spyOn(console, 'error').mockImplementation(() => { });
+        const { parseArguments } = await import('./cli.js');
+        expect(() => parseArguments()).toThrow('process.exit called');
+        expect(exitCode).toBe(1);
+        expect(consoleError).toHaveBeenCalledWith(expect.stringContaining('--stdio cannot be combined with --oauth'));
+        consoleError.mockRestore();
+    });
+    it('exits with error when --stdio combined with --template=stateful', async () => {
+        process.argv = ['node', 'create-mcp-server', '--name=test', '--stdio', '--template=stateful'];
+        let exitCode;
+        process.exit = vi.fn((code) => {
+            exitCode = code;
+            throw new Error('process.exit called');
+        });
+        const consoleError = vi.spyOn(console, 'error').mockImplementation(() => { });
+        const { parseArguments } = await import('./cli.js');
+        expect(() => parseArguments()).toThrow('process.exit called');
+        expect(exitCode).toBe(1);
+        expect(consoleError).toHaveBeenCalledWith(expect.stringContaining('--template=stateful is not applicable with --stdio'));
+        consoleError.mockRestore();
+    });
 });

package/dist/index.js

@@ -13,6 +13,7 @@ async function main() {
             projectName: options.name,
             packageManager: options.packageManager,
             framework: options.framework,
+            transport: options.transport,
             templateType: options.template,
             withOAuth: options.oauth,
             withGitInit: options.git,

package/dist/interactive.js

@@ -57,25 +57,48 @@ export async function runInteractiveMode() {
         initial: 0,
     }, { onCancel });
     const framework = frameworkResponse.framework || 'sdk';
-    // Server mode selection
-    const templateTypeResponse = await prompts({
+    // Transport selection
+    const transportResponse = await prompts({
         type: 'select',
-        name: 'templateType',
-        message: 'Server mode:',
+        name: 'transport',
+        message: 'Transport:',
         choices: [
-            { title: 'Stateless', value: 'stateless', description: 'Simple HTTP server' },
             {
-                title: 'Stateful',
-                value: 'stateful',
-                description: 'Session-based server with SSE support',
+                title: 'HTTP (Streamable HTTP)',
+                value: 'http',
+                description: 'Deploy as an HTTP server (recommended for remote access)',
+            },
+            {
+                title: 'stdio',
+                value: 'stdio',
+                description: 'For local use with local clients like Claude Desktop',
             },
         ],
         initial: 0,
     }, { onCancel });
-    const templateType = templateTypeResponse.templateType || 'stateless';
-    // OAuth prompt - only for SDK stateful template
+    const transport = transportResponse.transport || 'http';
+    // Server mode selection - only for HTTP transport
+    let templateType = 'stateless';
+    if (transport === 'http') {
+        const templateTypeResponse = await prompts({
+            type: 'select',
+            name: 'templateType',
+            message: 'Server mode:',
+            choices: [
+                { title: 'Stateless', value: 'stateless', description: 'Simple HTTP server' },
+                {
+                    title: 'Stateful',
+                    value: 'stateful',
+                    description: 'Session-based server with SSE support',
+                },
+            ],
+            initial: 0,
+        }, { onCancel });
+        templateType = templateTypeResponse.templateType || 'stateless';
+    }
+    // OAuth prompt - only for SDK stateful HTTP template
     let withOAuth = false;
-    if (framework === 'sdk' && templateType === 'stateful') {
+    if (transport === 'http' && framework === 'sdk' && templateType === 'stateful') {
         const oauthResponse = await prompts({
             type: 'confirm',
             name: 'withOAuth',
@@ -96,6 +119,7 @@ export async function runInteractiveMode() {
         projectName,
         packageManager,
         framework,
+        transport,
         templateType,
         withOAuth,
         withGitInit,

package/dist/project-generator.d.ts

@@ -1,4 +1,4 @@
-import type { Framework, PackageManager } from './templates/common/types.js';
+import type { Framework, PackageManager, TransportType } from './templates/common/types.js';
 import type { TemplateType } from './cli.js';
 export declare const packageManagerCommands: Record<PackageManager, {
     install: string;
@@ -8,6 +8,7 @@ export interface ProjectConfig {
     projectName: string;
     packageManager: PackageManager;
     framework: Framework;
+    transport: TransportType;
     templateType: TemplateType;
     withOAuth: boolean;
     withGitInit: boolean;

package/dist/project-generator.js

@@ -8,6 +8,7 @@ import { getEnvExampleTemplate } from './templates/common/env.example.js';
 import { getServerTemplate as getSdkStatelessServerTemplate, getIndexTemplate as getSdkStatelessIndexTemplate, getReadmeTemplate as getSdkStatelessReadmeTemplate, } from './templates/sdk/stateless/index.js';
 import { getServerTemplate as getSdkStatefulServerTemplate, getIndexTemplate as getSdkStatefulIndexTemplate, getReadmeTemplate as getSdkStatefulReadmeTemplate, getAuthTemplate as getSdkAuthTemplate, } from './templates/sdk/stateful/index.js';
 import { getServerTemplate as getFastMCPServerTemplate, getIndexTemplate as getFastMCPIndexTemplate, getReadmeTemplate as getFastMCPReadmeTemplate, } from './templates/fastmcp/index.js';
+import { getServerTemplate as getSdkStdioServerTemplate, getIndexTemplate as getSdkStdioIndexTemplate, getReadmeTemplate as getSdkStdioReadmeTemplate, } from './templates/sdk/stdio/index.js';
 import { getDockerfileTemplate, getDockerignoreTemplate } from './templates/deployment/index.js';
 const sdkTemplateFunctions = {
     stateless: {
@@ -33,12 +34,13 @@ export const packageManagerCommands = {
     yarn: { install: 'yarn', dev: 'yarn dev' },
 };
 export async function generateProject(config) {
-    const { projectName, packageManager, framework, templateType, withOAuth, withGitInit } = config;
+    const { projectName, packageManager, framework, transport, templateType, withOAuth, withGitInit, } = config;
     const templateOptions = {
-        withOAuth,
+        withOAuth: transport === 'http' ? withOAuth : false,
         packageManager,
         framework,
-        stateless: templateType === 'stateless',
+        stateless: transport === 'stdio' ? true : templateType === 'stateless',
+        transport,
     };
     const projectPath = join(process.cwd(), projectName);
     const srcPath = join(projectPath, 'src');
@@ -50,8 +52,12 @@ export async function generateProject(config) {
         // FastMCP templates
         filesToWrite.push(writeFile(join(srcPath, 'server.ts'), fastmcpTemplateFunctions.getServerTemplate(projectName)), writeFile(join(srcPath, 'index.ts'), fastmcpTemplateFunctions.getIndexTemplate(templateOptions)), writeFile(join(projectPath, 'README.md'), fastmcpTemplateFunctions.getReadmeTemplate(projectName, templateOptions)));
     }
+    else if (transport === 'stdio') {
+        // SDK stdio templates
+        filesToWrite.push(writeFile(join(srcPath, 'server.ts'), getSdkStdioServerTemplate(projectName)), writeFile(join(srcPath, 'index.ts'), getSdkStdioIndexTemplate(templateOptions)), writeFile(join(projectPath, 'README.md'), getSdkStdioReadmeTemplate(projectName, templateOptions)));
+    }
     else {
-        // SDK templates
+        // SDK HTTP templates (stateless or stateful)
         const templates = sdkTemplateFunctions[templateType];
         filesToWrite.push(writeFile(join(srcPath, 'server.ts'), templates.getServerTemplate(projectName)), writeFile(join(srcPath, 'index.ts'), templates.getIndexTemplate(templateOptions)), writeFile(join(projectPath, 'README.md'), templates.getReadmeTemplate(projectName, templateOptions)));
         // Conditionally add auth.ts for OAuth-enabled stateful template
@@ -61,8 +67,10 @@ export async function generateProject(config) {
     }
     // Common files for all templates
     filesToWrite.push(writeFile(join(projectPath, 'package.json'), getPackageJsonTemplate(projectName, templateOptions)), writeFile(join(projectPath, 'tsconfig.json'), getTsconfigTemplate()), writeFile(join(projectPath, '.gitignore'), getGitignoreTemplate()), writeFile(join(projectPath, '.env.example'), getEnvExampleTemplate(templateOptions)));
-    // Deployment files for all templates
-    filesToWrite.push(writeFile(join(projectPath, 'Dockerfile'), getDockerfileTemplate(templateOptions)), writeFile(join(projectPath, '.dockerignore'), getDockerignoreTemplate()));
+    // Deployment files for HTTP transport only (stdio servers are not HTTP services)
+    if (transport === 'http') {
+        filesToWrite.push(writeFile(join(projectPath, 'Dockerfile'), getDockerfileTemplate(templateOptions)), writeFile(join(projectPath, '.dockerignore'), getDockerignoreTemplate()));
+    }
     // Write all template files
     await Promise.all(filesToWrite);
     // Initialize git repository if requested
@@ -76,7 +84,7 @@ export async function generateProject(config) {
     }
     const commands = packageManagerCommands[packageManager];
     const frameworkName = framework === 'fastmcp' ? 'FastMCP' : 'MCP SDK';
-    console.log(`\nCreated ${projectName} with ${frameworkName} at ${projectPath}`);
+    console.log(`\nCreated ${projectName} with ${frameworkName} (${transport}) at ${projectPath}`);
     console.log(`\nNext steps:`);
     console.log(`  cd ${projectName}`);
     console.log(`  ${commands.install}`);

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

@@ -1,5 +1,16 @@
 export function getEnvExampleTemplate(options) {
+    const transport = options?.transport ?? 'http';
+    if (transport === 'stdio') {
+        return `# No environment variables required for stdio transport\n`;
+    }
     const withOAuth = options?.withOAuth ?? false;
+    const isSdk = options?.framework === 'sdk' || !options?.framework;
+    const allowedHostsVar = isSdk
+        ? `
+# Comma-separated list of additional allowed hosts (for deployment behind reverse proxies)
+# ALLOWED_HOSTS=my-server.example.com,my-server.us-central1.run.app
+`
+        : '';
     const oauthVars = withOAuth
         ? `
 # OAuth Configuration
@@ -15,5 +26,5 @@ OAUTH_AUDIENCE=https://your-mcp-server.com
 `
         : '';
     return `PORT=3000
-${oauthVars}`;
+${allowedHostsVar}${oauthVars}`;
 }

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

@@ -1,6 +1,7 @@
 export function getPackageJsonTemplate(projectName, options) {
     const withOAuth = options?.withOAuth ?? false;
     const framework = options?.framework ?? 'sdk';
+    const transport = options?.transport ?? 'http';
     let dependencies;
     let devDependencies;
     const commonDevDependencies = {
@@ -21,8 +22,19 @@ export function getPackageJsonTemplate(projectName, options) {
             ...commonDevDependencies,
         };
     }
+    else if (transport === 'stdio') {
+        // Official SDK stdio - no express needed
+        dependencies = {
+            '@modelcontextprotocol/sdk': '^1.26.0',
+            ...zodDependency,
+            ...dotEnvDependency,
+        };
+        devDependencies = {
+            ...commonDevDependencies,
+        };
+    }
     else {
-        // Official SDK dependencies
+        // Official SDK HTTP dependencies
         dependencies = {
             '@modelcontextprotocol/sdk': '^1.26.0',
             express: '^5.2.1',
@@ -37,6 +49,13 @@ export function getPackageJsonTemplate(projectName, options) {
             ...commonDevDependencies,
         };
     }
+    const inspectScripts = transport === 'stdio'
+        ? {
+            'inspect:tools': 'mcp-inspector --cli node dist/index.js --method tools/list',
+            'inspect:prompts': 'mcp-inspector --cli node dist/index.js --method prompts/list',
+            'inspect:resources': 'mcp-inspector --cli node dist/index.js --method resources/list',
+        }
+        : { inspect: 'mcp-inspector http://localhost:3000/mcp' };
     const packageJson = {
         name: projectName,
         version: '0.1.0',
@@ -46,7 +65,7 @@ export function getPackageJsonTemplate(projectName, options) {
             build: 'tsc',
             dev: 'tsc && node dist/index.js',
             start: 'node dist/index.js',
-            inspect: 'mcp-inspector http://localhost:3000/mcp',
+            ...inspectScripts,
         },
         dependencies,
         devDependencies,

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

@@ -49,6 +49,32 @@ describe('common templates', () => {
             const pkg = JSON.parse(template);
             expect(pkg.devDependencies['@types/express']).toBeDefined();
         });
+        it('should NOT include express or @types/express for SDK stdio', () => {
+            const template = getPackageJsonTemplate(projectName, {
+                framework: 'sdk',
+                transport: 'stdio',
+            });
+            const pkg = JSON.parse(template);
+            expect(pkg.dependencies['express']).toBeUndefined();
+            expect(pkg.devDependencies['@types/express']).toBeUndefined();
+            expect(pkg.dependencies['@modelcontextprotocol/sdk']).toBeDefined();
+        });
+        it('should use inspect:tools, inspect:prompts, inspect:resources scripts for stdio transport', () => {
+            const template = getPackageJsonTemplate(projectName, {
+                framework: 'sdk',
+                transport: 'stdio',
+            });
+            const pkg = JSON.parse(template);
+            expect(pkg.scripts['inspect:tools']).toContain('--method tools/list');
+            expect(pkg.scripts['inspect:prompts']).toContain('--method prompts/list');
+            expect(pkg.scripts['inspect:resources']).toContain('--method resources/list');
+            expect(pkg.scripts['inspect']).toBeUndefined();
+        });
+        it('should use http inspect script for http transport (default)', () => {
+            const template = getPackageJsonTemplate(projectName, { framework: 'sdk', transport: 'http' });
+            const pkg = JSON.parse(template);
+            expect(pkg.scripts.inspect).toContain('http://localhost:3000/mcp');
+        });
         it('should include required scripts', () => {
             const template = getPackageJsonTemplate(projectName);
             const pkg = JSON.parse(template);
@@ -89,5 +115,25 @@ describe('common templates', () => {
             const template = getEnvExampleTemplate();
             expect(template).toContain('PORT=');
         });
+        it('should include ALLOWED_HOSTS hint for SDK framework', () => {
+            const template = getEnvExampleTemplate({ framework: 'sdk' });
+            expect(template).toContain('ALLOWED_HOSTS');
+        });
+        it('should include ALLOWED_HOSTS hint by default (no framework specified)', () => {
+            const template = getEnvExampleTemplate();
+            expect(template).toContain('ALLOWED_HOSTS');
+        });
+        it('should NOT include ALLOWED_HOSTS for FastMCP framework', () => {
+            const template = getEnvExampleTemplate({ framework: 'fastmcp' });
+            expect(template).not.toContain('ALLOWED_HOSTS');
+        });
+        it('should NOT include PORT for stdio transport', () => {
+            const template = getEnvExampleTemplate({ transport: 'stdio' });
+            expect(template).not.toContain('PORT=');
+        });
+        it('should NOT include ALLOWED_HOSTS for stdio transport', () => {
+            const template = getEnvExampleTemplate({ transport: 'stdio' });
+            expect(template).not.toContain('ALLOWED_HOSTS');
+        });
     });
 });

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

@@ -1,5 +1,6 @@
 export type PackageManager = 'npm' | 'pnpm' | 'yarn';
 export type Framework = 'sdk' | 'fastmcp';
+export type TransportType = 'http' | 'stdio';
 /**
  * Base template options shared across all templates
  */
@@ -11,12 +12,14 @@ export interface BaseTemplateOptions {
  */
 export interface SdkTemplateOptions extends BaseTemplateOptions {
     withOAuth?: boolean;
+    transport?: TransportType;
 }
 /**
  * Template options for FastMCP templates
  */
 export interface FastMCPTemplateOptions extends BaseTemplateOptions {
     stateless?: boolean;
+    transport?: TransportType;
 }
 /**
  * Template options for common templates (package.json, env.example)
@@ -26,4 +29,5 @@ export interface CommonTemplateOptions extends BaseTemplateOptions {
     withOAuth?: boolean;
     framework?: Framework;
     stateless?: boolean;
+    transport?: TransportType;
 }

package/dist/templates/fastmcp/index.js

@@ -1,4 +1,13 @@
 export function getIndexTemplate(options) {
+    const transport = options?.transport ?? 'http';
+    if (transport === 'stdio') {
+        return `import { server } from './server.js';
+
+server.start({
+  transportType: "stdio",
+});
+`;
+    }
     const stateless = options?.stateless ?? false;
     const statelessConfig = stateless ? '\n    stateless: true,' : '';
     return `

package/dist/templates/fastmcp/readme.js

@@ -1,6 +1,7 @@
 export function getReadmeTemplate(projectName, options) {
     const packageManager = options?.packageManager ?? 'npm';
     const stateless = options?.stateless ?? false;
+    const transport = options?.transport ?? 'http';
     const commands = {
         npm: {
             install: 'npm install',
@@ -8,6 +9,9 @@ export function getReadmeTemplate(projectName, options) {
             build: 'npm run build',
             start: 'npm start',
             inspect: 'npm run inspect',
+            inspectTools: 'npm run inspect:tools',
+            inspectPrompts: 'npm run inspect:prompts',
+            inspectResources: 'npm run inspect:resources',
         },
         pnpm: {
             install: 'pnpm install',
@@ -15,6 +19,9 @@ export function getReadmeTemplate(projectName, options) {
             build: 'pnpm build',
             start: 'pnpm start',
             inspect: 'pnpm inspect',
+            inspectTools: 'pnpm inspect:tools',
+            inspectPrompts: 'pnpm inspect:prompts',
+            inspectResources: 'pnpm inspect:resources',
         },
         yarn: {
             install: 'yarn',
@@ -22,9 +29,101 @@ export function getReadmeTemplate(projectName, options) {
             build: 'yarn build',
             start: 'yarn start',
             inspect: 'yarn inspect',
+            inspectTools: 'yarn inspect:tools',
+            inspectPrompts: 'yarn inspect:prompts',
+            inspectResources: 'yarn inspect:resources',
         },
     };
     const cmd = commands[packageManager];
+    if (transport === 'stdio') {
+        return `# ${projectName}
+
+A stdio MCP server built with FastMCP.
+
+## About
+
+This project was created with [@agentailor/create-mcp-server](https://www.npmjs.com/package/@agentailor/create-mcp-server) using [FastMCP](https://github.com/punkpeye/fastmcp).
+
+## Getting Started
+
+\`\`\`bash
+# Install dependencies
+${cmd.install}
+
+# Build and run
+${cmd.dev}
+
+# Or build and start separately
+${cmd.build}
+${cmd.start}
+\`\`\`
+
+## Testing with MCP Inspector
+
+This project includes [MCP Inspector](https://github.com/modelcontextprotocol/inspector) as a dev dependency. Build the project first (\`${cmd.build}\`), then use the inspect scripts:
+
+\`\`\`bash
+# List tools
+${cmd.inspectTools}
+
+# List prompts
+${cmd.inspectPrompts}
+
+# List resources
+${cmd.inspectResources}
+\`\`\`
+
+You can also call tools directly:
+
+\`\`\`bash
+# Call a tool
+npx @modelcontextprotocol/inspector --cli node dist/index.js --method tools/call --tool-name start-notification-stream --tool-arg interval=100 --tool-arg count=5
+
+# Call a tool with JSON arguments
+npx @modelcontextprotocol/inspector --cli node dist/index.js --method tools/call --tool-name start-notification-stream --tool-arg 'options={"interval": 100, "count": 5}'
+\`\`\`
+
+## 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     # FastMCP server definition (tools, prompts, resources)
+│   └── index.ts      # Server startup configuration
+├── package.json
+├── tsconfig.json
+└── README.md
+\`\`\`
+
+## Customization
+
+- Add new tools, prompts, and resources in \`src/server.ts\`
+- Modify transport configuration in \`src/index.ts\`
+
+## Learn More
+
+- [FastMCP](https://github.com/punkpeye/fastmcp) - The framework powering this server
+- [Model Context Protocol](https://modelcontextprotocol.io/)
+`;
+    }
     const modeDescription = stateless
         ? 'A stateless streamable HTTP MCP server built with FastMCP.'
         : 'A stateful streamable HTTP MCP server built with FastMCP.';

package/dist/templates/fastmcp/templates.test.js

@@ -54,6 +54,12 @@ describe('fastmcp templates', () => {
             const template = getIndexTemplate({ stateless: true });
             expect(template).toContain('stateless: true');
         });
+        it('should use stdio transportType when transport is stdio', () => {
+            const template = getIndexTemplate({ transport: 'stdio' });
+            expect(template).toContain('transportType: "stdio"');
+            expect(template).not.toContain('httpStream');
+            expect(template).not.toContain('PORT');
+        });
     });
     describe('getReadmeTemplate', () => {
         it('should include project name', () => {
@@ -83,5 +89,21 @@ describe('fastmcp templates', () => {
             const template = getReadmeTemplate(projectName, { stateless: true });
             expect(template).toContain('stateless');
         });
+        it('should NOT include HTTP endpoint section for stdio', () => {
+            const template = getReadmeTemplate(projectName, { transport: 'stdio' });
+            expect(template).not.toContain('POST /mcp');
+            expect(template).not.toContain('GET /health');
+        });
+        it('should include MCP Inspector CLI commands for stdio', () => {
+            const template = getReadmeTemplate(projectName, { transport: 'stdio' });
+            expect(template).toContain('inspect:tools');
+            expect(template).toContain('inspect:prompts');
+            expect(template).toContain('inspect:resources');
+        });
+        it('should NOT include Docker section for stdio', () => {
+            const template = getReadmeTemplate(projectName, { transport: 'stdio' });
+            expect(template).not.toContain('docker build');
+            expect(template).not.toContain('Dockerfile');
+        });
     });
 });

package/dist/templates/sdk/stateful/index.js

@@ -14,13 +14,18 @@ import {
   getOAuthMetadataUrl,
   validateOAuthConfig,
 } from './auth.js';`
-        : `import { type Request, type Response } from 'express';
+        : `import 'dotenv/config';
+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 appSetup = `const app = createMcpExpressApp();
+    const appSetup = `const allowedHosts = process.env.ALLOWED_HOSTS?.split(',') ?? [];
+
+const app = createMcpExpressApp({
+  allowedHosts: ['localhost', '127.0.0.1', '[::1]', ...allowedHosts],
+});
 
 // Health check endpoint for container orchestration
 app.get('/health', (_, res) => res.sendStatus(200));`;

package/dist/templates/sdk/stateful/readme.js

@@ -133,7 +133,7 @@ ${commands.build}
 ${commands.start}
 \`\`\`
 
-The server will start on port 3000 by default. You can change this by setting the \`PORT\` environment variable.
+The server will start on port 3000 by default. You can change this by setting the \`PORT\` environment variable. To allow additional hosts (e.g. when deploying behind a reverse proxy), set \`ALLOWED_HOSTS\` as a comma-separated list.
 
 ## Testing with MCP Inspector
 

package/dist/templates/sdk/stateful/templates.test.js

@@ -36,7 +36,7 @@ describe('sdk/stateful templates', () => {
         it('should use createMcpExpressApp', () => {
             const template = getIndexTemplate();
             expect(template).toContain('createMcpExpressApp');
-            expect(template).toContain('const app = createMcpExpressApp()');
+            expect(template).toContain('const app = createMcpExpressApp({');
         });
         it('should configure /mcp endpoint', () => {
             const template = getIndexTemplate();
@@ -46,7 +46,12 @@ describe('sdk/stateful templates', () => {
         });
         it('should use PORT from environment variable', () => {
             const template = getIndexTemplate();
-            expect(template).toContain('process.env.PORT || 3000');
+            expect(template).toContain('process.env.PORT');
+        });
+        it('should pass allowedHosts to createMcpExpressApp', () => {
+            const template = getIndexTemplate();
+            expect(template).toContain('allowedHosts');
+            expect(template).toContain("ALLOWED_HOSTS?.split(',')");
         });
         // Stateful-specific tests
         it('should use session ID header', () => {

package/dist/templates/sdk/stateless/index.js

@@ -7,7 +7,11 @@ import { createMcpExpressApp } from '@modelcontextprotocol/sdk/server/express.js
 import { StreamableHTTPServerTransport } from '@modelcontextprotocol/sdk/server/streamableHttp.js';
 import { getServer } from './server.js';
 
-const app = createMcpExpressApp();
+const allowedHosts = process.env.ALLOWED_HOSTS?.split(',') ?? [];
+
+const app = createMcpExpressApp({
+  allowedHosts: ['localhost', '127.0.0.1', '[::1]', ...allowedHosts],
+});
 
 // Health check endpoint for container orchestration
 app.get('/health', (_, res) => res.sendStatus(200));

package/dist/templates/sdk/stateless/readme.js

@@ -45,7 +45,7 @@ ${commands.build}
 ${commands.start}
 \`\`\`
 
-The server will start on port 3000 by default. You can change this by setting the \`PORT\` environment variable.
+The server will start on port 3000 by default. You can change this by setting the \`PORT\` environment variable. To allow additional hosts (e.g. when deploying behind a reverse proxy), set \`ALLOWED_HOSTS\` as a comma-separated list.
 
 ## Testing with MCP Inspector
 

package/dist/templates/sdk/stateless/templates.test.js

@@ -36,7 +36,7 @@ describe('sdk/stateless templates', () => {
         it('should use createMcpExpressApp', () => {
             const template = getIndexTemplate();
             expect(template).toContain('createMcpExpressApp');
-            expect(template).toContain('const app = createMcpExpressApp()');
+            expect(template).toContain('const app = createMcpExpressApp({');
         });
         it('should configure /mcp endpoint', () => {
             const template = getIndexTemplate();
@@ -46,7 +46,12 @@ describe('sdk/stateless templates', () => {
         });
         it('should use PORT from environment variable', () => {
             const template = getIndexTemplate();
-            expect(template).toContain('process.env.PORT || 3000');
+            expect(template).toContain('process.env.PORT');
+        });
+        it('should pass allowedHosts to createMcpExpressApp', () => {
+            const template = getIndexTemplate();
+            expect(template).toContain('allowedHosts');
+            expect(template).toContain("ALLOWED_HOSTS?.split(',')");
         });
         // Stateless-specific tests
         it('should use undefined sessionIdGenerator for stateless mode', () => {

package/dist/templates/sdk/stdio/index.d.ts

@@ -0,0 +1,5 @@
+export type { SdkTemplateOptions as TemplateOptions } from '../../common/types.js';
+import type { SdkTemplateOptions } from '../../common/types.js';
+export declare function getIndexTemplate(_options?: SdkTemplateOptions): string;
+export { getServerTemplate } from './server.js';
+export { getReadmeTemplate } from './readme.js';

package/dist/templates/sdk/stdio/index.js

@@ -0,0 +1,21 @@
+// Options parameter kept for type consistency with other SDK templates
+// eslint-disable-next-line @typescript-eslint/no-unused-vars
+export function getIndexTemplate(_options) {
+    return `import { StdioServerTransport } from "@modelcontextprotocol/sdk/server/stdio.js";
+import { getServer } from './server.js';
+
+async function main() {
+  const server = getServer();
+  const transport = new StdioServerTransport();
+  await server.connect(transport);
+  console.error("MCP Server running on stdio");
+}
+
+main().catch((error) => {
+  console.error("Fatal error in main():", error);
+  process.exit(1);
+});
+`;
+}
+export { getServerTemplate } from './server.js';
+export { getReadmeTemplate } from './readme.js';

package/dist/templates/sdk/stdio/readme.d.ts

@@ -0,0 +1,2 @@
+import type { TemplateOptions } from './index.js';
+export declare function getReadmeTemplate(projectName: string, options?: TemplateOptions): string;

package/dist/templates/sdk/stdio/readme.js

@@ -0,0 +1,119 @@
+export function getReadmeTemplate(projectName, options) {
+    const packageManager = options?.packageManager ?? 'npm';
+    const commands = {
+        npm: {
+            install: 'npm install',
+            dev: 'npm run dev',
+            build: 'npm run build',
+            start: 'npm start',
+            inspectTools: 'npm run inspect:tools',
+            inspectPrompts: 'npm run inspect:prompts',
+            inspectResources: 'npm run inspect:resources',
+        },
+        pnpm: {
+            install: 'pnpm install',
+            dev: 'pnpm dev',
+            build: 'pnpm build',
+            start: 'pnpm start',
+            inspectTools: 'pnpm inspect:tools',
+            inspectPrompts: 'pnpm inspect:prompts',
+            inspectResources: 'pnpm inspect:resources',
+        },
+        yarn: {
+            install: 'yarn',
+            dev: 'yarn dev',
+            build: 'yarn build',
+            start: 'yarn start',
+            inspectTools: 'yarn inspect:tools',
+            inspectPrompts: 'yarn inspect:prompts',
+            inspectResources: 'yarn inspect:resources',
+        },
+    }[packageManager];
+    return `# ${projectName}
+
+A stdio MCP (Model Context Protocol) server using the official MCP SDK.
+
+## About
+
+This project was created with [@agentailor/create-mcp-server](https://www.npmjs.com/package/@agentailor/create-mcp-server).
+
+## Getting Started
+
+\`\`\`bash
+# Install dependencies
+${commands.install}
+
+# Build and run
+${commands.dev}
+
+# Or build and start separately
+${commands.build}
+${commands.start}
+\`\`\`
+
+## Testing with MCP Inspector
+
+This project includes [MCP Inspector](https://github.com/modelcontextprotocol/inspector) as a dev dependency. Build the project first (\`${commands.build}\`), then use the inspect scripts:
+
+\`\`\`bash
+# List tools
+${commands.inspectTools}
+
+# List prompts
+${commands.inspectPrompts}
+
+# List resources
+${commands.inspectResources}
+\`\`\`
+
+You can also call tools directly:
+
+\`\`\`bash
+# Call a tool
+npx @modelcontextprotocol/inspector --cli node dist/index.js --method tools/call --tool-name start-notification-stream --tool-arg interval=100 --tool-arg count=5
+
+# Call a tool with JSON arguments
+npx @modelcontextprotocol/inspector --cli node dist/index.js --method tools/call --tool-name start-notification-stream --tool-arg 'options={"interval": 100, "count": 5}'
+\`\`\`
+
+## 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      # stdio transport startup
+├── package.json
+├── tsconfig.json
+└── README.md
+\`\`\`
+
+## Customization
+
+- Add new tools, prompts, and resources in \`src/server.ts\`
+- Modify 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/sdk/stdio/server.d.ts

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

package/dist/templates/sdk/stdio/server.js

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

package/dist/templates/sdk/stdio/templates.test.d.ts

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

package/dist/templates/sdk/stdio/templates.test.js

@@ -0,0 +1,111 @@
+import { describe, it, expect } from 'vitest';
+import { getServerTemplate, getIndexTemplate, getReadmeTemplate } from './index.js';
+describe('sdk/stdio 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 import StdioServerTransport', () => {
+            const template = getIndexTemplate();
+            expect(template).toContain('StdioServerTransport');
+            expect(template).toContain('@modelcontextprotocol/sdk/server/stdio.js');
+        });
+        it('should NOT import express or createMcpExpressApp', () => {
+            const template = getIndexTemplate();
+            expect(template).not.toContain('express');
+            expect(template).not.toContain('createMcpExpressApp');
+        });
+        it('should NOT reference PORT', () => {
+            const template = getIndexTemplate();
+            expect(template).not.toContain('PORT');
+            expect(template).not.toContain('process.env.PORT');
+        });
+        it('should connect server to StdioServerTransport', () => {
+            const template = getIndexTemplate();
+            expect(template).toContain('new StdioServerTransport()');
+            expect(template).toContain('server.connect(transport)');
+        });
+        it('should log to stderr, not stdout', () => {
+            const template = getIndexTemplate();
+            expect(template).toContain('console.error("MCP Server running on stdio")');
+        });
+        it('should wrap startup in async main with error handling', () => {
+            const template = getIndexTemplate();
+            expect(template).toContain('async function main()');
+            expect(template).toContain('main().catch');
+            expect(template).toContain('process.exit(1)');
+        });
+    });
+    describe('getReadmeTemplate', () => {
+        it('should include project name', () => {
+            const template = getReadmeTemplate(projectName);
+            expect(template).toContain(`# ${projectName}`);
+        });
+        it('should describe stdio transport', () => {
+            const template = getReadmeTemplate(projectName);
+            expect(template).toContain('stdio');
+        });
+        it('should include MCP Inspector CLI commands', () => {
+            const template = getReadmeTemplate(projectName);
+            expect(template).toContain('inspect:tools');
+            expect(template).toContain('inspect:prompts');
+            expect(template).toContain('inspect:resources');
+        });
+        it('should NOT mention HTTP API endpoints', () => {
+            const template = getReadmeTemplate(projectName);
+            expect(template).not.toContain('POST /mcp');
+            expect(template).not.toContain('GET /health');
+        });
+        it('should NOT mention PORT or ALLOWED_HOSTS', () => {
+            const template = getReadmeTemplate(projectName);
+            expect(template).not.toContain('PORT');
+            expect(template).not.toContain('ALLOWED_HOSTS');
+        });
+        it('should NOT include Docker deployment section', () => {
+            const template = getReadmeTemplate(projectName);
+            expect(template).not.toContain('docker build');
+            expect(template).not.toContain('Dockerfile');
+        });
+        it('should use npm commands by default', () => {
+            const template = getReadmeTemplate(projectName);
+            expect(template).toContain('npm install');
+            expect(template).toContain('npm run dev');
+        });
+        it('should use pnpm commands when specified', () => {
+            const template = getReadmeTemplate(projectName, { packageManager: 'pnpm' });
+            expect(template).toContain('pnpm install');
+            expect(template).toContain('pnpm dev');
+            expect(template).not.toContain('npm run');
+        });
+        it('should use yarn commands when specified', () => {
+            const template = getReadmeTemplate(projectName, { packageManager: 'yarn' });
+            expect(template).toContain('yarn\n');
+            expect(template).toContain('yarn dev');
+            expect(template).not.toContain('npm run');
+        });
+    });
+});

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@agentailor/create-mcp-server",
-  "version": "0.5.2",
+  "version": "0.6.0",
   "description": "Create a new MCP (Model Context Protocol) server project",
   "type": "module",
   "bin": {