mcpmake 0.1.0

package/dist/commands/from/har.js

@@ -0,0 +1,255 @@
+import { defineCommand } from 'citty';
+import { loadHarFile } from '../../parser/har-loader.js';
+import { filterHarEntries } from '../../parser/har-filter.js';
+import { normalizeEntry } from '../../parser/har-normalizer.js';
+import { clusterEntries } from '../../transformer/har-clusterer.js';
+import { clustersToOperations } from '../../transformer/har-to-operations.js';
+import { deduplicateEntries } from '../../transformer/har-dedup.js';
+import { improveToolNames } from '../../transformer/llm-namer.js';
+import { buildAllTools } from '../../transformer/tool-builder.js';
+import { filterOperations } from '../../transformer/operation-filter.js';
+import { emitProject, emitPythonProject } from '../../emitter/index.js';
+import { targetArg, resolveTarget, resolveTransport, printWorkerNextSteps, } from './target-support.js';
+import { logger } from '../../utils/logger.js';
+import { fail } from '../../utils/fail.js';
+import { confirmOperations } from '../../utils/interactive.js';
+function toPackageName(name) {
+    return name
+        .toLowerCase()
+        .replace(/[^a-z0-9]+/g, '-')
+        .replace(/^-|-$/g, '');
+}
+export default defineCommand({
+    meta: {
+        name: 'har',
+        description: 'Generate an MCP server from a HAR (HTTP Archive) file',
+    },
+    args: {
+        file: {
+            type: 'positional',
+            description: 'Path to HAR file (exported from browser DevTools)',
+            required: true,
+        },
+        output: {
+            type: 'string',
+            alias: 'o',
+            description: 'Output directory for generated project',
+            required: true,
+        },
+        name: {
+            type: 'string',
+            alias: 'n',
+            description: 'Server name',
+        },
+        domain: {
+            type: 'string',
+            alias: 'd',
+            description: 'Only include requests to this domain (can repeat with commas)',
+        },
+        'include-errors': {
+            type: 'boolean',
+            description: 'Include requests that returned HTTP errors',
+            default: false,
+        },
+        'improve-names': {
+            type: 'boolean',
+            description: 'Use AI to generate better tool names (requires ANTHROPIC_API_KEY)',
+            default: false,
+        },
+        dedup: {
+            type: 'boolean',
+            description: 'Deduplicate pagination and retry requests',
+            default: true,
+        },
+        interactive: {
+            type: 'boolean',
+            description: 'Review and confirm detected tools before generation',
+            default: false,
+        },
+        force: {
+            type: 'boolean',
+            alias: 'f',
+            description: 'Overwrite existing output directory',
+            default: false,
+        },
+        transport: {
+            type: 'string',
+            alias: 't',
+            description: 'Transport mode: "stdio" (default) or "http"',
+            default: 'stdio',
+        },
+        include: {
+            type: 'string',
+            alias: 'i',
+            description: 'Only include operations matching these patterns (comma-separated)',
+        },
+        exclude: {
+            type: 'string',
+            alias: 'e',
+            description: 'Exclude operations matching these patterns (comma-separated)',
+        },
+        'dry-run': {
+            type: 'boolean',
+            description: 'Preview generated files without writing',
+            default: false,
+        },
+        format: {
+            type: 'string',
+            description: 'Output format: "typescript" (default), "python"',
+            default: 'typescript',
+        },
+        target: targetArg,
+    },
+    async run({ args }) {
+        logger.info(`Loading HAR file: ${args.file}`);
+        const har = await loadHarFile(args.file);
+        logger.info(`Found ${har.log.entries.length} total entries`);
+        // Filter noise
+        const allowedDomains = args.domain?.split(',').map((d) => d.trim()) ?? [];
+        const filtered = filterHarEntries(har.log.entries, {
+            allowedDomains: allowedDomains.length > 0 ? allowedDomains : undefined,
+            includeErrors: args['include-errors'] ?? false,
+        });
+        logger.info(`${filtered.length} API entries after filtering`);
+        if (filtered.length === 0) {
+            await fail('No API requests found after filtering. Try --domain to specify the API host.');
+        }
+        // Normalize paths (detect IDs, UUIDs, etc.)
+        let normalized = filtered.map(normalizeEntry);
+        // Deduplicate pagination and retries
+        if (args.dedup !== false) {
+            const before = normalized.length;
+            normalized = deduplicateEntries(normalized);
+            if (normalized.length < before) {
+                logger.info(`Deduplicated: ${before} → ${normalized.length} entries`);
+            }
+        }
+        // Cluster into logical operations
+        const clusters = clusterEntries(normalized);
+        logger.info(`Clustered into ${clusters.length} operations`);
+        // Convert to OperationDescriptors (shared with OpenAPI pipeline)
+        let { operations: allOperations, baseUrl, detectedAuth } = clustersToOperations(clusters);
+        // LLM-assisted naming
+        if (args['improve-names']) {
+            allOperations = await improveToolNames(allOperations);
+        }
+        // Apply include/exclude filters
+        let operations = filterOperations(allOperations, {
+            include: args.include?.split(',').map((s) => s.trim()),
+            exclude: args.exclude?.split(',').map((s) => s.trim()),
+        });
+        if (operations.length === 0) {
+            await fail('No operations left after filtering.');
+        }
+        if (operations.length !== allOperations.length) {
+            logger.info(`${operations.length} operations after filtering`);
+        }
+        // Interactive confirmation
+        if (args.interactive) {
+            operations = await confirmOperations(operations);
+            if (operations.length === 0) {
+                await fail('No operations selected.');
+            }
+        }
+        // Convert detected auth to AuthSchemes
+        const authSchemes = [];
+        const envVars = [];
+        for (const auth of detectedAuth) {
+            if (auth.type === 'bearer') {
+                authSchemes.push({
+                    type: 'http-bearer',
+                    envVarName: 'BEARER_TOKEN',
+                    description: 'Bearer token detected in HAR',
+                });
+                envVars.push({
+                    name: 'BEARER_TOKEN',
+                    description: 'Bearer authentication token',
+                    required: true,
+                });
+            }
+            else if (auth.type === 'basic') {
+                authSchemes.push({
+                    type: 'http-basic',
+                    envVarName: 'BASIC_USERNAME',
+                    description: 'Basic auth detected in HAR',
+                });
+                envVars.push({ name: 'BASIC_USERNAME', description: 'Basic auth username', required: true }, { name: 'BASIC_PASSWORD', description: 'Basic auth password', required: true });
+            }
+            else if (auth.type === 'apiKey') {
+                authSchemes.push({
+                    type: 'apiKey',
+                    envVarName: 'API_KEY',
+                    headerName: auth.headerName,
+                    in: 'header',
+                    description: `API key header: ${auth.headerName}`,
+                });
+                envVars.push({
+                    name: 'API_KEY',
+                    description: `API key (sent as header "${auth.headerName}")`,
+                    required: true,
+                });
+            }
+        }
+        // Dedupe env vars
+        const seen = new Set();
+        const uniqueEnvVars = envVars.filter((v) => {
+            if (seen.has(v.name))
+                return false;
+            seen.add(v.name);
+            return true;
+        });
+        // Build tools (reuses OpenAPI pipeline)
+        const tools = buildAllTools(operations);
+        const serverName = args.name ?? toPackageName(new URL(baseUrl).hostname);
+        const target = resolveTarget(args.target);
+        const transport = resolveTransport(target, args.transport);
+        const manifest = {
+            serverName,
+            serverVersion: '1.0.0',
+            baseUrl,
+            transport,
+            tools,
+            authSchemes,
+            envVars: [
+                { name: 'BASE_URL', description: 'API base URL', required: true, example: baseUrl },
+                ...uniqueEnvVars,
+            ],
+            target,
+        };
+        const emitOpts = {
+            outputDir: args.output,
+            force: args.force ?? false,
+            dryRun: args['dry-run'] ?? false,
+        };
+        const outputFormat = args.format ?? 'typescript';
+        if (target === 'cloudflare' && outputFormat === 'python') {
+            await fail('--target cloudflare is only available for TypeScript output (not --format python)');
+        }
+        logger.info(`Generating ${outputFormat} MCP server: ${serverName}` +
+            (target === 'cloudflare' ? ' (Cloudflare Workers)' : ''));
+        if (outputFormat === 'python') {
+            await emitPythonProject(manifest, emitOpts);
+        }
+        else {
+            await emitProject(manifest, emitOpts);
+        }
+        logger.success(`MCP server generated at: ${args.output}`);
+        logger.info('');
+        logger.info(`Tools generated: ${tools.length}`);
+        if (detectedAuth.length > 0) {
+            logger.info(`Auth detected: ${detectedAuth.map((a) => a.type).join(', ')}`);
+        }
+        if (target === 'cloudflare') {
+            printWorkerNextSteps(args.output);
+        }
+        else {
+            logger.info('');
+            logger.info('Next steps:');
+            logger.info(`  cd ${args.output}`);
+            logger.info('  cp .env.example .env  # fill in your credentials');
+            logger.info('  npm install');
+            logger.info('  npm run build');
+            logger.info('  npm start');
+        }
+    },
+});

package/dist/commands/from/openapi.d.ts

@@ -0,0 +1,105 @@
+declare const _default: import("citty").CommandDef<{
+    spec: {
+        type: "positional";
+        description: string;
+        required: true;
+    };
+    output: {
+        type: "string";
+        alias: string;
+        description: string;
+        required: true;
+    };
+    name: {
+        type: "string";
+        alias: string;
+        description: string;
+    };
+    'base-url': {
+        type: "string";
+        alias: string;
+        description: string;
+    };
+    force: {
+        type: "boolean";
+        alias: string;
+        description: string;
+        default: false;
+    };
+    transport: {
+        type: "string";
+        alias: string;
+        description: string;
+        default: string;
+    };
+    include: {
+        type: "string";
+        alias: string;
+        description: string;
+    };
+    exclude: {
+        type: "string";
+        alias: string;
+        description: string;
+    };
+    'dry-run': {
+        type: "boolean";
+        description: string;
+        default: false;
+    };
+    client: {
+        type: "string";
+        alias: string;
+        description: string;
+    };
+    'no-resources': {
+        type: "boolean";
+        description: string;
+        default: false;
+    };
+    'no-prompts': {
+        type: "boolean";
+        description: string;
+        default: false;
+    };
+    'dynamic-discovery': {
+        type: "boolean";
+        description: string;
+        default: false;
+    };
+    'static-tools': {
+        type: "string";
+        description: string;
+    };
+    watch: {
+        type: "boolean";
+        alias: string;
+        description: string;
+        default: false;
+    };
+    'improve-names': {
+        type: "boolean";
+        description: string;
+        default: false;
+    };
+    overlay: {
+        type: "string";
+        description: string;
+    };
+    format: {
+        type: "string";
+        description: string;
+        default: string;
+    };
+    target: {
+        type: "string";
+        description: string;
+        default: string;
+    };
+    mcpb: {
+        type: "boolean";
+        description: string;
+        default: false;
+    };
+}>;
+export default _default;

package/dist/commands/from/openapi.js

@@ -0,0 +1,302 @@
+import { defineConfigurableCommand } from '../../config/configurable-command.js';
+import { resolve } from 'node:path';
+import { execFile as execFileCb } from 'node:child_process';
+import { promisify } from 'node:util';
+import { loadOpenApiSpec } from '../../parser/openapi-loader.js';
+import { applyOverlay } from '../../parser/overlay-loader.js';
+import { extractOperations } from '../../parser/operation-extractor.js';
+import { detectAuthSchemes } from '../../transformer/auth-detector.js';
+import { buildAllTools } from '../../transformer/tool-builder.js';
+import { filterOperations } from '../../transformer/operation-filter.js';
+import { improveToolNames } from '../../transformer/llm-namer.js';
+import { buildResources, buildPrompts } from '../../transformer/resource-builder.js';
+import { applyClientCompat } from '../../transformer/client-compat.js';
+import { emitProject, emitPythonProject } from '../../emitter/index.js';
+import { printWorkerNextSteps } from './target-support.js';
+import { generateMcpb } from '../../emitter/mcpb-bundler.js';
+import { getProvider, getProviderNames } from '../../providers/index.js';
+import { logger } from '../../utils/logger.js';
+import { fail } from '../../utils/fail.js';
+import { watchFile } from '../../utils/watcher.js';
+const execFile = promisify(execFileCb);
+function toPackageName(title) {
+    return title
+        .toLowerCase()
+        .replace(/[^a-z0-9]+/g, '-')
+        .replace(/^-|-$/g, '');
+}
+export default defineConfigurableCommand('openapi', {
+    meta: {
+        name: 'openapi',
+        description: 'Generate an MCP server from an OpenAPI specification',
+    },
+    args: {
+        spec: {
+            type: 'positional',
+            description: `Path/URL to OpenAPI spec, or provider name (${getProviderNames().join(', ')})`,
+            required: true,
+        },
+        output: {
+            type: 'string',
+            alias: 'o',
+            description: 'Output directory for generated project',
+            required: true,
+        },
+        name: {
+            type: 'string',
+            alias: 'n',
+            description: 'Server name (defaults to API title from spec)',
+        },
+        'base-url': {
+            type: 'string',
+            alias: 'b',
+            description: 'Base URL override (defaults to first server in spec)',
+        },
+        force: {
+            type: 'boolean',
+            alias: 'f',
+            description: 'Overwrite existing output directory',
+            default: false,
+        },
+        transport: {
+            type: 'string',
+            alias: 't',
+            description: 'Transport mode: "stdio" (default) or "http"',
+            default: 'stdio',
+        },
+        include: {
+            type: 'string',
+            alias: 'i',
+            description: 'Only include operations matching these patterns (comma-separated tags, paths, or operationIds)',
+        },
+        exclude: {
+            type: 'string',
+            alias: 'e',
+            description: 'Exclude operations matching these patterns (comma-separated)',
+        },
+        'dry-run': {
+            type: 'boolean',
+            description: 'Preview generated files without writing',
+            default: false,
+        },
+        client: {
+            type: 'string',
+            alias: 'c',
+            description: 'Client compatibility mode: cursor, claude, openai',
+        },
+        'no-resources': {
+            type: 'boolean',
+            description: 'Skip generating MCP resources',
+            default: false,
+        },
+        'no-prompts': {
+            type: 'boolean',
+            description: 'Skip generating MCP prompts',
+            default: false,
+        },
+        'dynamic-discovery': {
+            type: 'boolean',
+            description: 'Emit 4 meta-tools instead of N individual tools (for large APIs)',
+            default: false,
+        },
+        'static-tools': {
+            type: 'string',
+            description: 'With --dynamic-discovery: also register first N tools statically',
+        },
+        watch: {
+            type: 'boolean',
+            alias: 'w',
+            description: 'Watch spec file for changes and regenerate',
+            default: false,
+        },
+        'improve-names': {
+            type: 'boolean',
+            description: 'Use AI to generate better tool names (requires ANTHROPIC_API_KEY)',
+            default: false,
+        },
+        overlay: {
+            type: 'string',
+            description: 'Path to an OpenAPI Overlay file (YAML/JSON) to patch the spec before processing',
+        },
+        format: {
+            type: 'string',
+            description: 'Output format: "typescript" (default), "python"',
+            default: 'typescript',
+        },
+        target: {
+            type: 'string',
+            description: 'Deployment target: "node" (default) or "cloudflare" (Cloudflare Workers)',
+            default: 'node',
+        },
+        mcpb: {
+            type: 'boolean',
+            description: 'Also generate an .mcpb bundle for one-click Claude Desktop install',
+            default: false,
+        },
+    },
+    async run({ args }) {
+        // Resolve provider shortcut
+        const provider = getProvider(args.spec);
+        const specPath = provider?.specUrl ?? args.spec;
+        if (provider) {
+            logger.info(`Using provider template: ${provider.name} (${provider.description})`);
+            if (provider.suggestedIncludes && !args.include) {
+                logger.info(`Tip: use --include ${provider.suggestedIncludes.join(',')} to reduce tool count`);
+            }
+        }
+        logger.info(`Loading OpenAPI spec from: ${specPath}`);
+        const { api } = await loadOpenApiSpec(specPath);
+        // Apply overlay if specified (patches spec before extraction)
+        if (args.overlay) {
+            await applyOverlay(api, args.overlay);
+        }
+        let { operations, baseUrl, securitySchemes, info } = extractOperations(api);
+        if (operations.length === 0) {
+            await fail('No operations found in the spec.');
+        }
+        logger.info(`Found ${operations.length} operations`);
+        // LLM-assisted naming
+        if (args['improve-names']) {
+            operations = await improveToolNames(operations);
+        }
+        const filtered = filterOperations(operations, {
+            include: args.include?.split(',').map((s) => s.trim()),
+            exclude: args.exclude?.split(',').map((s) => s.trim()),
+        });
+        if (filtered.length === 0) {
+            await fail('No operations left after filtering. Check your --include/--exclude patterns.');
+        }
+        if (filtered.length !== operations.length) {
+            logger.info(`${filtered.length} operations after filtering`);
+        }
+        let tools = buildAllTools(filtered);
+        if (args.client) {
+            tools = applyClientCompat(tools, args.client);
+        }
+        const { authSchemes, envVars } = detectAuthSchemes(securitySchemes);
+        const serverName = args.name ?? (provider ? provider.name : toPackageName(info.title));
+        const resolvedBaseUrl = args['base-url'] ?? baseUrl ?? provider?.baseUrl;
+        if (!resolvedBaseUrl) {
+            await fail('No base URL found in spec. Use --base-url to provide one.');
+        }
+        const target = args.target === 'cloudflare' ? 'cloudflare' : 'node';
+        // Cloudflare Workers always run as a stateless HTTP fetch handler — there is
+        // no stdio there. Override transport so shared template data stays coherent.
+        const transport = target === 'cloudflare' ? 'http' : args.transport === 'http' ? 'http' : 'stdio';
+        const resources = args['no-resources'] ? [] : buildResources(filtered);
+        const prompts = args['no-prompts'] ? [] : buildPrompts(filtered);
+        const dynamicDiscovery = args['dynamic-discovery'] ?? false;
+        const staticToolCount = args['static-tools'] ? parseInt(args['static-tools'], 10) : undefined;
+        const manifest = {
+            serverName,
+            serverVersion: info.version ?? '1.0.0',
+            baseUrl: resolvedBaseUrl,
+            transport: transport,
+            tools,
+            resources,
+            prompts,
+            authSchemes,
+            envVars: [
+                {
+                    name: 'BASE_URL',
+                    description: 'API base URL',
+                    required: true,
+                    example: resolvedBaseUrl,
+                },
+                ...envVars,
+            ],
+            dynamicDiscovery,
+            staticToolCount,
+            target,
+        };
+        const emitOpts = {
+            outputDir: args.output,
+            force: args.force ?? false,
+            dryRun: args['dry-run'] ?? false,
+        };
+        const outputFormat = args.format ?? 'typescript';
+        if (target === 'cloudflare' && outputFormat === 'python') {
+            await fail('--target cloudflare is only available for TypeScript output (not --format python)');
+        }
+        logger.info(`Generating ${outputFormat} MCP server: ${serverName}` +
+            (target === 'cloudflare' ? ' (Cloudflare Workers)' : ''));
+        if (outputFormat === 'python') {
+            await emitPythonProject(manifest, emitOpts);
+            logger.success(`Python MCP server generated at: ${args.output}`);
+            logger.info('');
+            logger.info('Next steps:');
+            logger.info(`  cd ${args.output}`);
+            logger.info('  cp .env.example .env  # fill in your credentials');
+            logger.info('  pip install -r requirements.txt');
+            logger.info('  python server.py');
+            if (args.mcpb) {
+                logger.warn('MCPB bundling is only supported for TypeScript projects');
+            }
+        }
+        else {
+            await emitProject(manifest, emitOpts);
+            logger.success(`MCP server generated at: ${args.output}`);
+            if (target === 'cloudflare') {
+                if (args.mcpb) {
+                    logger.warn('MCPB bundling is not applicable to the Cloudflare Workers target');
+                }
+                printWorkerNextSteps(args.output);
+            }
+            else if (args.mcpb && !args['dry-run']) {
+                const projectDir = resolve(args.output);
+                logger.info('Installing production dependencies...');
+                await execFile('npm', ['install', '--omit=dev'], {
+                    cwd: projectDir,
+                    timeout: 120_000,
+                });
+                logger.info('Building project...');
+                await execFile('npm', ['run', 'build'], {
+                    cwd: projectDir,
+                    timeout: 120_000,
+                });
+                logger.info('Creating .mcpb bundle...');
+                const mcpbPath = await generateMcpb({ projectDir });
+                logger.success(`MCPB bundle created: ${mcpbPath}`);
+            }
+            else {
+                logger.info('');
+                logger.info('Next steps:');
+                logger.info(`  cd ${args.output}`);
+                logger.info('  cp .env.example .env  # fill in your credentials');
+                logger.info('  npm install');
+                logger.info('  npm run build');
+                logger.info('  npm start');
+            }
+        }
+        // Watch mode — re-generate on spec file changes
+        if (args.watch && !provider) {
+            watchFile({
+                filePath: args.spec,
+                onChange: async () => {
+                    const { api: freshApi } = await loadOpenApiSpec(specPath);
+                    if (args.overlay) {
+                        await applyOverlay(freshApi, args.overlay);
+                    }
+                    const fresh = extractOperations(freshApi);
+                    const freshFiltered = filterOperations(fresh.operations, {
+                        include: args.include?.split(',').map((s) => s.trim()),
+                        exclude: args.exclude?.split(',').map((s) => s.trim()),
+                    });
+                    const freshTools = buildAllTools(freshFiltered);
+                    const freshAuth = detectAuthSchemes(fresh.securitySchemes);
+                    const freshResources = buildResources(freshFiltered);
+                    const freshPrompts = buildPrompts(freshFiltered);
+                    await emitProject({
+                        ...manifest,
+                        tools: freshTools,
+                        resources: freshResources,
+                        prompts: freshPrompts,
+                        authSchemes: freshAuth.authSchemes,
+                    }, { outputDir: args.output, force: true, dryRun: false });
+                },
+            });
+            // Keep the process alive
+            await new Promise(() => { });
+        }
+    },
+});