@slbdn/mcp-tester 1.3.0 → 1.4.0

package/CHANGELOG.md

@@ -5,6 +5,27 @@ All notable changes to this project will be documented in this file.
 The format is based on [Keep a Changelog](https://keepachangelog.com/en/1.0.0/),
 and this project adheres to [Semantic Versioning](https://semver.org/spec/v2.0.0.html).
 
+## [Unreleased]
+
+## [1.4.0] - 2026-07-01
+
+### Added
+- **HTTP and SSE transport support** — connect to remote MCP servers:
+  - `StreamableHttpServerConfig` (`transport: 'http'`) — modern MCP Streamable HTTP (POST + SSE GET)
+  - `SseServerConfig` (`transport: 'sse'`) — legacy SSE transport
+  - `ServerConfig` union type — `StdioServerConfig | StreamableHttpServerConfig | SseServerConfig`
+  - `getTransportType()` method — returns `'stdio'`, `'http'`, `'sse'`, or `null`
+  - URL auto-detection in CLI (passing a URL as first arg uses HTTP transport)
+  - CLI `--transport`, `--url`, `--headers` options on all commands
+  - 15 integration tests (Streamable HTTP + SSE) against server-everything
+  - 5 CLI HTTP transport tests
+  - 14 validation tests for HTTP/SSE configs
+
+### Changed
+- `MCPServerConfig` is now a deprecated alias for `StdioServerConfig` (backward compatible)
+- `start()` accepts the `ServerConfig` discriminated union instead of `MCPServerConfig`
+- CLI commands now accept `[command]` (optional) instead of `<command>` to support HTTP/SSE
+
 ## [1.3.0] - 2026-07-01
 
 ### Added

package/README.md

@@ -8,7 +8,7 @@
 [![npm downloads](https://img.shields.io/npm/dm/@slbdn/mcp-tester)](https://www.npmjs.com/package/@slbdn/mcp-tester)
 [![Node.js Version](https://img.shields.io/badge/node-%3E%3D18-brightgreen)](https://nodejs.org)
 [![License: MIT](https://img.shields.io/badge/License-MIT-yellow.svg)](https://opensource.org/licenses/MIT)
-[![Test Status](https://img.shields.io/badge/tests-635%20passing-brightgreen)](https://github.com/islobodan/mcp-tester/actions/workflows/test.yml)
+[![Test Status](https://img.shields.io/badge/tests-669%20passing-brightgreen)](https://github.com/islobodan/mcp-tester/actions/workflows/test.yml)
 [![Coverage](https://img.shields.io/badge/coverage-68%2F61%2F60%2F68-brightgreen)](https://github.com/islobodan/mcp-tester/actions/workflows/test.yml)  <!-- statements/branches/functions/lines -->
 
 A production-ready MCP (Model Context Protocol) client for **automated testing** of MCP servers with Jest.
@@ -50,7 +50,7 @@ No more manual clicking through inspectors — write real tests, run them in CI,
 │  │  │    MCPTimeoutError │ MCPConnectionError │ ...        │    │    │
 │  │  └──────────────────────┬───────────────────────────────┘    │    │
 │  └─────────────────────────┼─────────────────────────────────────┘    │
-│                            │ stdio (JSON-RPC)                        │
+│                            │ stdio, HTTP, SSE                        │
 │  ┌─────────────────────────▼─────────────────────────────────────┐  │
 │  │              MCP Server (child process)                       │  │
 │  │  ┌────────┐  ┌───────────┐  ┌──────────┐  ┌────────────┐   │  │
@@ -60,9 +60,9 @@ No more manual clicking through inspectors — write real tests, run them in CI,
 └─────────────────────────────────────────────────────────────────────┘
 ```
 
-**Data flow**: Your test calls `MCPClient` → which sends JSON-RPC over stdio → to the MCP server process → server responds → `MCPClient` returns typed results → your assertion validates them.
+**Data flow**: Your test calls `MCPClient` → which sends JSON-RPC over stdio/HTTP/SSE → to the MCP server → server responds → `MCPClient` returns typed results → your assertion validates them.
 
-**Key design**: `MCPClient` manages the server lifecycle (spawn/kill) and protocol handling. Your tests never deal with the transport layer directly.
+**Key design**: `MCPClient` manages the server lifecycle (spawn/kill for stdio, connect/disconnect for HTTP/SSE) and protocol handling. Your tests never deal with the transport layer directly.
 
 ## Why MCP Tester?
 
@@ -84,7 +84,7 @@ No more manual clicking through inspectors — write real tests, run them in CI,
 | Branches | 61% |
 | Functions | 60% |
 | Lines | 68% |
-| Tests | 635 passing |
+| Tests | 669 passing |
 
 Per-file coverage thresholds are set in `jest.config.js` to catch regressions while avoiding CI noise. Run `npm run test:coverage` to see the full breakdown by file. PRs automatically receive a coverage comment via GitHub Actions.
 
@@ -136,6 +136,22 @@ const result = await client.callTool({
 await client.stop();
 ```
 
+### Connect via HTTP
+
+```typescript
+// Streamable HTTP transport (recommended for remote servers)
+await client.start({
+  transport: 'http',
+  url: 'https://api.example.com/mcp',
+});
+
+// Legacy SSE transport
+await client.start({
+  transport: 'sse',
+  url: 'http://localhost:3000/sse',
+});
+```
+
 ### Test with Jest
 
 ```typescript

package/dist/cli/index.js

@@ -22,33 +22,95 @@ function getPackageVersion() {
 const program = new Command();
 program
     .name('mcp-tester')
-    .description('CLI tool for testing MCP servers')
+    .description('CLI tool for testing MCP servers (stdio, HTTP, and SSE transports)')
     .version(getPackageVersion(), '-V, --version');
-// Global options - use string type since commander passes strings
+// Global options (also added per-command via addTransportOptions below)
 program
     .option('-t, --timeout <ms>', 'Request timeout in milliseconds', '30000')
     .option('-v, --verbose', 'Enable verbose output')
     .option('-l, --log-level <level>', 'Log level (debug|info|warn|error)', 'info');
-// Test command - connects and verifies server is working
-program
-    .command('test')
-    .description('Test MCP server connection and list available capabilities')
-    .argument('<command>', 'Command to run the MCP server (e.g., "node", "python")')
-    .argument('[args...]', 'Arguments for the server command')
-    .action(async (command, args, opts) => {
-    const client = new MCPClient({
+/**
+ * Add transport options to a command. Commander requires options to be defined
+ * on the command itself for them to be recognized during argument parsing.
+ */
+function withTransport(cmd) {
+    return cmd
+        .option('-T, --transport <type>', 'Transport: stdio (default), http, or sse', undefined)
+        .option('--url <url>', 'Server URL for http/sse (e.g. http://localhost:3000/mcp)', undefined)
+        .option('--headers <json>', 'HTTP headers as JSON (e.g. \'{"Authorization":"Bearer x"}\')', undefined);
+}
+// ─── Helper: resolve server config from global opts + positional args ──────
+/**
+ * Build a ServerConfig from the global options and positional command/args.
+ *
+ * - If `--url` is provided → use HTTP/SSE transport
+ * - If `--transport http|sse` without `--url` → treat first positional arg as URL
+ * - Otherwise → stdio with command + args
+ */
+function resolveServerConfig(opts, command, args) {
+    const transport = String(opts['transport'] || '');
+    const url = opts['url'] ? String(opts['url']) : undefined;
+    const headersRaw = opts['headers'] ? String(opts['headers']) : undefined;
+    let headers;
+    if (headersRaw) {
+        try {
+            headers = JSON.parse(headersRaw);
+        }
+        catch {
+            console.error('❌ Invalid JSON for --headers');
+            process.exit(1);
+        }
+    }
+    // HTTP or SSE transport
+    if (transport === 'http' || transport === 'sse' || (url && transport)) {
+        const actualTransport = (transport || 'http');
+        const actualUrl = url || command;
+        if (!actualUrl) {
+            console.error(`❌ URL is required for ${actualTransport} transport. Use --url or pass as first argument.`);
+            process.exit(1);
+        }
+        return { transport: actualTransport, url: actualUrl, headers };
+    }
+    // Auto-detect: if command looks like a URL, use HTTP
+    if (command && (command.startsWith('http://') || command.startsWith('https://'))) {
+        return { transport: 'http', url: command, headers };
+    }
+    // Default: stdio
+    if (!command) {
+        console.error('❌ Command is required for stdio transport. Example: mcp-tester test node ./server.js');
+        process.exit(1);
+    }
+    return { command, args: args || [] };
+}
+/** Human-readable description of the connection target for logging. */
+function describeTarget(config) {
+    if ('url' in config) {
+        return `${config.transport}: ${config.url}`;
+    }
+    return `stdio: ${config.command} ${(config.args || []).join(' ')}`;
+}
+/** Create a client with global options. */
+function createClient(opts) {
+    return new MCPClient({
         name: 'mcp-tester-cli',
         version: '1.0.0',
         timeout: parseInt(String(opts['timeout'] || '30000')),
         logLevel: (opts['verbose'] ? 'debug' : String(opts['logLevel'] || 'info')),
     });
+}
+// ─── Commands ────────────────────────────────────────────────────────────
+// Test command - connects and verifies server is working
+withTransport(program
+    .command('test')
+    .description('Test MCP server connection and list available capabilities')
+    .argument('[command]', 'Command to run (stdio) or URL (http/sse)')
+    .argument('[args...]', 'Arguments for the server command')).action(async (command, args, opts) => {
+    const config = resolveServerConfig(opts, command, args);
+    const client = createClient(opts);
     try {
         console.log(`🔌 Connecting to MCP server...`);
-        console.log(`   Command: ${command} ${args.join(' ')}`);
-        await client.start({
-            command,
-            args,
-        });
+        console.log(`   ${describeTarget(config)}`);
+        await client.start(config);
         console.log(`✅ Connected successfully\n`);
         // Test tools
         console.log(`🛠️  Tools:`);
@@ -92,7 +154,7 @@ program
     catch (error) {
         console.error(`❌ Error: ${error instanceof Error ? error.message : String(error)}`);
         if (error instanceof MCPConnectionError) {
-            console.error('   → Server failed to start. Check command and server process.');
+            console.error('   → Connection failed. Check the URL or command.');
         }
         else if (error instanceof MCPTimeoutError) {
             console.error(`   → Request timed out after ${opts['timeout']}ms`);
@@ -107,22 +169,18 @@ program
     }
 });
 // List tools command
-program
+withTransport(program
     .command('list-tools')
     .alias('lt')
     .description('List all available tools from the MCP server')
-    .argument('<command>', 'Command to run the MCP server')
-    .argument('[args...]', 'Arguments for the server command')
+    .argument('[command]', 'Command to run (stdio) or URL (http/sse)')
+    .argument('[args...]', 'Arguments for the server command'))
     .option('--json', 'Output as JSON')
     .action(async (command, args, opts) => {
-    const client = new MCPClient({
-        name: 'mcp-tester-cli',
-        version: '1.0.0',
-        timeout: parseInt(String(opts['timeout'] || '30000')),
-        logLevel: opts['verbose'] ? 'debug' : 'info',
-    });
+    const config = resolveServerConfig(opts, command, args);
+    const client = createClient(opts);
     try {
-        await client.start({ command, args });
+        await client.start(config);
         const tools = await client.listTools();
         if (opts['json']) {
             console.log(JSON.stringify({ tools }, null, 2));
@@ -149,22 +207,18 @@ program
     }
 });
 // Call tool command
-program
+withTransport(program
     .command('call-tool')
     .alias('ct')
     .description('Call a tool on the MCP server')
     .argument('<tool-name>', 'Name of the tool to call')
-    .argument('<command>', 'Command to run the MCP server')
-    .argument('[args...]', 'Arguments for the server command')
+    .argument('[command]', 'Command to run (stdio) or URL (http/sse)')
+    .argument('[args...]', 'Arguments for the server command'))
     .option('--params <json>', 'Tool parameters as JSON string')
     .option('--json', 'Output as JSON')
     .action(async (toolName, command, serverArgs, opts) => {
-    const client = new MCPClient({
-        name: 'mcp-tester-cli',
-        version: '1.0.0',
-        timeout: parseInt(String(opts['timeout'] || '30000')),
-        logLevel: opts['verbose'] ? 'debug' : 'info',
-    });
+    const config = resolveServerConfig(opts, command, serverArgs);
+    const client = createClient(opts);
     let toolArgs = {};
     if (opts['params']) {
         try {
@@ -176,7 +230,7 @@ program
         }
     }
     try {
-        await client.start({ command, args: serverArgs });
+        await client.start(config);
         if (!opts['json']) {
             console.log(`🔧 Calling tool: ${toolName}`);
             if (Object.keys(toolArgs).length > 0) {
@@ -211,23 +265,19 @@ program
     }
 });
 // Read resource command
-program
+withTransport(program
     .command('read-resource')
     .alias('rr')
     .description('Read a resource from the MCP server')
     .argument('<uri>', 'URI of the resource to read')
-    .argument('<command>', 'Command to run the MCP server')
-    .argument('[args...]', 'Arguments for the server command')
+    .argument('[command]', 'Command to run (stdio) or URL (http/sse)')
+    .argument('[args...]', 'Arguments for the server command'))
     .option('--json', 'Output as JSON')
     .action(async (uri, command, serverArgs, opts) => {
-    const client = new MCPClient({
-        name: 'mcp-tester-cli',
-        version: '1.0.0',
-        timeout: parseInt(String(opts['timeout'] || '30000')),
-        logLevel: opts['verbose'] ? 'debug' : 'info',
-    });
+    const config = resolveServerConfig(opts, command, serverArgs);
+    const client = createClient(opts);
     try {
-        await client.start({ command, args: serverArgs });
+        await client.start(config);
         if (!opts['json']) {
             console.log(`📖 Reading resource: ${uri}`);
         }
@@ -253,22 +303,18 @@ program
     }
 });
 // Get prompt command
-program
+withTransport(program
     .command('get-prompt')
     .alias('gp')
     .description('Get a prompt from the MCP server')
     .argument('<name>', 'Name of the prompt')
-    .argument('<command>', 'Command to run the MCP server')
-    .argument('[args...]', 'Arguments for the server command')
+    .argument('[command]', 'Command to run (stdio) or URL (http/sse)')
+    .argument('[args...]', 'Arguments for the server command'))
     .option('--args <json>', 'Prompt arguments as JSON string')
     .option('--json', 'Output as JSON')
     .action(async (promptName, command, serverArgs, opts) => {
-    const client = new MCPClient({
-        name: 'mcp-tester-cli',
-        version: '1.0.0',
-        timeout: parseInt(String(opts['timeout'] || '30000')),
-        logLevel: opts['verbose'] ? 'debug' : 'info',
-    });
+    const config = resolveServerConfig(opts, command, serverArgs);
+    const client = createClient(opts);
     let promptArgs = {};
     if (opts['args']) {
         try {
@@ -280,7 +326,7 @@ program
         }
     }
     try {
-        await client.start({ command, args: serverArgs });
+        await client.start(config);
         if (!opts['json']) {
             console.log(`💬 Getting prompt: ${promptName}`);
         }
@@ -307,12 +353,12 @@ program
     }
 });
 // Generate test file command
-program
+withTransport(program
     .command('generate')
     .alias('gen')
     .description('Generate test file from MCP server inspection')
-    .argument('<command>', 'Command to run the MCP server')
-    .argument('[args...]', 'Arguments for the server command')
+    .argument('[command]', 'Command to run (stdio) or URL (http/sse)')
+    .argument('[args...]', 'Arguments for the server command'))
     .option('-o, --output <file>', 'Output file path (prints to stdout if omitted)')
     .option('--framework <fw>', 'Test framework: jest or vitest', 'jest')
     .option('--description <desc>', 'Description for the test suite')
@@ -328,17 +374,42 @@ program
     }
     try {
         console.error('🔍 Inspecting MCP server...');
-        const code = await generateTests({
-            command,
-            args: serverArgs,
-            framework: framework,
-            description: opts['description'],
-            includeResources: opts['resources'] !== false,
-            includePrompts: opts['prompts'] !== false,
-            includeTools: opts['tools'] !== false,
-            includeMatchers: opts['matchers'] !== false,
-            timeout: parseInt(String(opts['timeout'] || '30000')),
-        });
+        // generateTests supports stdio only (connects and inspects)
+        const config = resolveServerConfig(opts, command, serverArgs);
+        const timeout = parseInt(String(opts['timeout'] || '30000'));
+        let code;
+        if ('command' in config) {
+            code = await generateTests({
+                command: config.command,
+                args: config.args || [],
+                framework: framework,
+                description: opts['description'],
+                includeResources: opts['resources'] !== false,
+                includePrompts: opts['prompts'] !== false,
+                includeTools: opts['tools'] !== false,
+                includeMatchers: opts['matchers'] !== false,
+                timeout,
+            });
+        }
+        else {
+            // HTTP/SSE — connect directly
+            const client = new MCPClient({ name: 'mcp-tester-gen', version: '1.0.0', timeout });
+            try {
+                await client.start(config);
+                // For HTTP/SSE, generate from connected client
+                code = await generateFromClient(client, {
+                    framework: framework,
+                    description: opts['description'],
+                    includeResources: opts['resources'] !== false,
+                    includePrompts: opts['prompts'] !== false,
+                    includeTools: opts['tools'] !== false,
+                    includeMatchers: opts['matchers'] !== false,
+                });
+            }
+            finally {
+                await client.stop();
+            }
+        }
         if (opts['output']) {
             const fs = await import('fs');
             const path = await import('path');
@@ -360,12 +431,12 @@ program
     }
 });
 // Generate TypeScript types command
-program
+withTransport(program
     .command('generate-types')
     .alias('gen-types')
     .description('Generate TypeScript type declarations from MCP server tool schemas')
-    .argument('<command>', 'Command to run the MCP server')
-    .argument('[args...]', 'Arguments for the server command')
+    .argument('[command]', 'Command to run (stdio) or URL (http/sse)')
+    .argument('[args...]', 'Arguments for the server command'))
     .option('-o, --output <file>', 'Output file path (prints to stdout if omitted)')
     .option('--module-name <name>', 'Module name for import hints', '@slbdn/mcp-tester')
     .option('--no-resources', 'Skip resource URI types')
@@ -373,14 +444,33 @@ program
     .action(async (command, serverArgs, opts) => {
     try {
         console.error('🔍 Inspecting MCP server for type generation...');
-        const types = await generateTypes({
-            command,
-            args: serverArgs,
-            moduleName: opts['moduleName'],
-            includeResources: opts['resources'] !== false,
-            includePrompts: opts['prompts'] !== false,
-            timeout: parseInt(String(opts['timeout'] || '30000')),
-        });
+        const config = resolveServerConfig(opts, command, serverArgs);
+        const timeout = parseInt(String(opts['timeout'] || '30000'));
+        let types;
+        if ('command' in config) {
+            types = await generateTypes({
+                command: config.command,
+                args: config.args || [],
+                moduleName: opts['moduleName'],
+                includeResources: opts['resources'] !== false,
+                includePrompts: opts['prompts'] !== false,
+                timeout,
+            });
+        }
+        else {
+            const client = new MCPClient({ name: 'mcp-tester-gen', version: '1.0.0', timeout });
+            try {
+                await client.start(config);
+                types = await generateTypesFromClient(client, {
+                    moduleName: opts['moduleName'],
+                    includeResources: opts['resources'] !== false,
+                    includePrompts: opts['prompts'] !== false,
+                });
+            }
+            finally {
+                await client.stop();
+            }
+        }
         if (opts['output']) {
             const fs = await import('fs');
             const path = await import('path');
@@ -401,18 +491,135 @@ program
         process.exit(1);
     }
 });
-// Add custom help with examples using Commander's built-in help system
+// ─── Helpers for HTTP/SSE codegen (inline inspection) ─────────────────────
+async function generateFromClient(client, opts) {
+    const tools = opts.includeTools ? await client.listTools() : [];
+    const resources = opts.includeResources ? await client.listResources() : [];
+    const prompts = opts.includePrompts ? await client.listPrompts() : [];
+    // Build the test code inline (simplified version for HTTP/SSE)
+    const importLine = opts.framework === 'vitest' ? 'vitest' : '@jest/globals';
+    const matchersImport = opts.includeMatchers
+        ? `import { setup${opts.framework === 'vitest' ? 'Vitest' : 'Jest'}Matchers } from '@slbdn/mcp-tester';\n`
+        : '';
+    let code = `import { describe, it, expect, beforeAll, afterAll } from '${importLine}';\n`;
+    code += `import { MCPClient } from '@slbdn/mcp-tester';\n`;
+    if (matchersImport)
+        code += matchersImport;
+    code += '\n';
+    const desc = opts.description || 'Generated MCP Server Tests';
+    code += `describe('${desc}', () => {\n`;
+    code += `  let client: MCPClient;\n\n`;
+    code += `  beforeAll(async () => {\n`;
+    if (matchersImport) {
+        code += `    setup${opts.framework === 'vitest' ? 'Vitest' : 'Jest'}Matchers();\n`;
+    }
+    code += `    client = new MCPClient({ timeout: 30000 });\n`;
+    code += `    // Update the URL/command for your server\n`;
+    code += `    await client.start({ command: 'node', args: ['./server.js'] });\n`;
+    code += `  });\n\n`;
+    code += `  afterAll(async () => {\n    if (client.isConnected()) await client.stop();\n  });\n\n`;
+    if (opts.includeTools) {
+        code += `  // ─── Tools (${tools.length}) ───\n`;
+        for (const tool of tools) {
+            code += `  it('should have tool: ${tool.name}', async () => {\n`;
+            code += `    const tools = await client.listTools();\n`;
+            code += `    expect(tools.map(t => t.name)).toContain('${tool.name}');\n`;
+            code += `  });\n\n`;
+        }
+    }
+    if (opts.includeResources) {
+        code += `  // ─── Resources (${resources.length}) ───\n`;
+        code += `  it('should list resources', async () => {\n`;
+        code += `    const resources = await client.listResources();\n`;
+        code += `    expect(resources.length).toBeGreaterThan(0);\n`;
+        code += `  });\n\n`;
+    }
+    if (opts.includePrompts) {
+        code += `  // ─── Prompts (${prompts.length}) ───\n`;
+        code += `  it('should list prompts', async () => {\n`;
+        code += `    const prompts = await client.listPrompts();\n`;
+        code += `    expect(prompts.length).toBeGreaterThan(0);\n`;
+        code += `  });\n\n`;
+    }
+    code += `});\n`;
+    return code;
+}
+async function generateTypesFromClient(client, opts) {
+    const tools = await client.listTools();
+    const resources = opts.includeResources ? await client.listResources() : [];
+    const prompts = opts.includePrompts ? await client.listPrompts() : [];
+    const moduleName = opts.moduleName || '@slbdn/mcp-tester';
+    let code = `// Generated by mcp-tester generate-types\n`;
+    code += `// Source: MCP server inspection\n\n`;
+    code += `// Tool argument types\n`;
+    for (const tool of tools) {
+        code += `export interface ${toPascalCase(tool.name)}Args {\n`;
+        const props = tool.inputSchema?.properties || {};
+        const required = tool.inputSchema?.required || [];
+        for (const [key, schema] of Object.entries(props)) {
+            const s = schema;
+            const tsType = jsonSchemaToTs(s);
+            const optional = !required.includes(key) ? '?' : '';
+            code += `  ${key}${optional}: ${tsType};\n`;
+        }
+        code += `}\n\n`;
+    }
+    code += `export type ToolName = ${tools.map((t) => `'${t.name}'`).join(' | ') || 'string'};\n\n`;
+    if (resources.length > 0) {
+        code += `export type ResourceUri = ${resources.map((r) => `'${r.uri}'`).join(' | ')};\n\n`;
+    }
+    if (prompts.length > 0) {
+        code += `export type PromptName = ${prompts.map((p) => `'${p.name}'`).join(' | ')};\n\n`;
+    }
+    code += `// Import the client\n`;
+    code += `import { MCPClient, type ToolCall } from '${moduleName}';\n`;
+    return code;
+}
+function toPascalCase(s) {
+    return s.replace(/(^|[-_])(.)/g, (_, __, c) => c.toUpperCase());
+}
+function jsonSchemaToTs(schema) {
+    const type = schema.type;
+    switch (type) {
+        case 'string':
+            return 'string';
+        case 'number':
+        case 'integer':
+            return 'number';
+        case 'boolean':
+            return 'boolean';
+        case 'array':
+            return 'unknown[]';
+        case 'object':
+            return 'Record<string, unknown>';
+        default:
+            return 'unknown';
+    }
+}
+// ─── Help ────────────────────────────────────────────────────────────────
 program.addHelpText('after', `
 Examples:
+  # Stdio transport (default)
   mcp-tester test node ./server.js
   mcp-tester list-tools node ./server.js --json
   mcp-tester call-tool echo node ./server.js --params '{"message":"Hello"}'
-  mcp-tester read-resource text://example node ./server.js
-  mcp-tester get-prompt greet node ./server.js --args '{"name":"World"}'
-  mcp-tester lt node ./server.js                          # short alias for list-tools
-  mcp-tester ct echo node ./server.js --params '{}'       # short alias for call-tool
-  mcp-tester generate node ./server.js -o server.test.ts  # generate test file
-  mcp-tester generate-types node ./server.js -o server.d.ts  # generate TypeScript types
+
+  # HTTP transport
+  mcp-tester test --transport http --url http://localhost:3000/mcp
+  mcp-tester list-tools http://localhost:3000/mcp --json
+  mcp-tester call-tool echo http://localhost:3000/mcp --params '{"message":"Hi"}'
+
+  # SSE transport
+  mcp-tester test --transport sse --url http://localhost:3000/sse
+
+  # With custom headers
+  mcp-tester test --transport http --url https://api.example.com/mcp --headers '{"Authorization":"Bearer token"}'
+
+  # Generate tests and types (stdio)
+  mcp-tester generate node ./server.js -o server.test.ts
+  mcp-tester generate-types node ./server.js -o server.d.ts
+
+Short aliases: lt (list-tools), ct (call-tool), rr (read-resource), gp (get-prompt), gen (generate)
 `);
 // Show help when invoked with no arguments
 const args = process.argv.slice(2);