mcpmake 0.1.0

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

@@ -0,0 +1,51 @@
+declare const _default: import("citty").CommandDef<{
+    collection: {
+        type: "positional";
+        description: string;
+        required: true;
+    };
+    output: {
+        type: "string";
+        alias: string;
+        description: string;
+        required: true;
+    };
+    name: {
+        type: "string";
+        alias: string;
+        description: string;
+    };
+    transport: {
+        type: "string";
+        alias: string;
+        description: string;
+        default: string;
+    };
+    target: {
+        type: "string";
+        description: string;
+        default: string;
+    };
+    include: {
+        type: "string";
+        alias: string;
+        description: string;
+    };
+    exclude: {
+        type: "string";
+        alias: string;
+        description: string;
+    };
+    force: {
+        type: "boolean";
+        alias: string;
+        description: string;
+        default: false;
+    };
+    'dry-run': {
+        type: "boolean";
+        description: string;
+        default: false;
+    };
+}>;
+export default _default;

package/dist/commands/from/postman.js

@@ -0,0 +1,146 @@
+import { defineConfigurableCommand } from '../../config/configurable-command.js';
+import { loadPostmanCollection } from '../../parser/postman-loader.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 { buildAllTools } from '../../transformer/tool-builder.js';
+import { filterOperations } from '../../transformer/operation-filter.js';
+import { buildResources, buildPrompts } from '../../transformer/resource-builder.js';
+import { emitProject } 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';
+function toPackageName(name) {
+    return name
+        .toLowerCase()
+        .replace(/[^a-z0-9]+/g, '-')
+        .replace(/^-|-$/g, '');
+}
+export default defineConfigurableCommand('postman', {
+    meta: {
+        name: 'postman',
+        description: 'Generate an MCP server from a Postman Collection',
+    },
+    args: {
+        collection: {
+            type: 'positional',
+            description: 'Path to Postman Collection JSON file (v2.1)',
+            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 collection name)',
+        },
+        transport: {
+            type: 'string',
+            alias: 't',
+            description: 'Transport mode: "stdio" (default) or "http"',
+            default: 'stdio',
+        },
+        target: targetArg,
+        include: {
+            type: 'string',
+            alias: 'i',
+            description: 'Include operations matching patterns (comma-separated)',
+        },
+        exclude: {
+            type: 'string',
+            alias: 'e',
+            description: 'Exclude operations matching patterns (comma-separated)',
+        },
+        force: {
+            type: 'boolean',
+            alias: 'f',
+            description: 'Overwrite existing output directory',
+            default: false,
+        },
+        'dry-run': {
+            type: 'boolean',
+            description: 'Preview generated files without writing',
+            default: false,
+        },
+    },
+    async run({ args }) {
+        logger.info(`Loading Postman collection: ${args.collection}`);
+        const { entries, collectionName } = await loadPostmanCollection(args.collection);
+        logger.info(`Found ${entries.length} requests in collection`);
+        if (entries.length === 0) {
+            await fail('No requests found in collection.');
+        }
+        // Normalize → dedup → cluster → convert (shared pipeline)
+        let normalized = entries.map(normalizeEntry);
+        normalized = deduplicateEntries(normalized);
+        const clusters = clusterEntries(normalized);
+        logger.info(`Clustered into ${clusters.length} operations`);
+        const { operations: allOperations, baseUrl, detectedAuth } = clustersToOperations(clusters);
+        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.');
+        }
+        const tools = buildAllTools(operations);
+        const resources = buildResources(operations);
+        const prompts = buildPrompts(operations);
+        // Build auth
+        const authSchemes = [];
+        const envVars = [];
+        for (const auth of detectedAuth) {
+            if (auth.type === 'bearer') {
+                authSchemes.push({ type: 'http-bearer', envVarName: 'BEARER_TOKEN' });
+                envVars.push({ name: 'BEARER_TOKEN', description: 'Bearer token', required: true });
+            }
+            else if (auth.type === 'apiKey') {
+                authSchemes.push({
+                    type: 'apiKey',
+                    envVarName: 'API_KEY',
+                    headerName: auth.headerName,
+                    in: 'header',
+                });
+                envVars.push({
+                    name: 'API_KEY',
+                    description: `API key (${auth.headerName})`,
+                    required: true,
+                });
+            }
+        }
+        const seen = new Set();
+        const uniqueEnvVars = envVars.filter((v) => {
+            if (seen.has(v.name))
+                return false;
+            seen.add(v.name);
+            return true;
+        });
+        const serverName = args.name ?? toPackageName(collectionName);
+        const target = resolveTarget(args.target);
+        const transport = resolveTransport(target, args.transport);
+        await emitProject({
+            serverName,
+            serverVersion: '1.0.0',
+            baseUrl: baseUrl || 'https://api.example.com',
+            transport,
+            tools,
+            resources,
+            prompts,
+            authSchemes,
+            envVars: [
+                { name: 'BASE_URL', description: 'API base URL', required: true, example: baseUrl },
+                ...uniqueEnvVars,
+            ],
+            target,
+        }, { outputDir: args.output, force: args.force ?? false, dryRun: args['dry-run'] ?? false });
+        logger.success(`MCP server generated at: ${args.output}`);
+        logger.info(`Tools generated: ${tools.length}`);
+        if (target === 'cloudflare')
+            printWorkerNextSteps(args.output);
+    },
+});

package/dist/commands/from/target-support.d.ts

@@ -0,0 +1,11 @@
+export type EmitTarget = 'node' | 'cloudflare';
+/** Citty arg definition — spread into a command's `args` block. */
+export declare const targetArg: {
+    type: "string";
+    description: string;
+    default: string;
+};
+export declare function resolveTarget(raw: unknown): EmitTarget;
+/** Workers is stateless HTTP-only; otherwise honour `--transport`. */
+export declare function resolveTransport(target: EmitTarget, rawTransport: unknown): 'stdio' | 'http';
+export declare function printWorkerNextSteps(output: string): void;

package/dist/commands/from/target-support.js

@@ -0,0 +1,33 @@
+/**
+ * Shared `--target` (deployment target) support for the `from <source>` commands.
+ *
+ * `node` (default) emits a Node.js server; `cloudflare` emits a stateless
+ * Cloudflare Workers project. The Workers target always runs as an HTTP Fetch
+ * handler, so it overrides `--transport`.
+ */
+import { logger } from '../../utils/logger.js';
+/** Citty arg definition — spread into a command's `args` block. */
+export const targetArg = {
+    type: 'string',
+    description: 'Deployment target: "node" (default) or "cloudflare" (Cloudflare Workers)',
+    default: 'node',
+};
+export function resolveTarget(raw) {
+    return raw === 'cloudflare' ? 'cloudflare' : 'node';
+}
+/** Workers is stateless HTTP-only; otherwise honour `--transport`. */
+export function resolveTransport(target, rawTransport) {
+    if (target === 'cloudflare')
+        return 'http';
+    return rawTransport === 'http' ? 'http' : 'stdio';
+}
+export function printWorkerNextSteps(output) {
+    logger.info('');
+    logger.info('Next steps:');
+    logger.info(`  cd ${output}`);
+    logger.info('  npm install');
+    logger.info('  cp .dev.vars.example .dev.vars  # fill in MCP_AUTH_TOKEN + API credentials');
+    logger.info('  npm run dev            # local Workers runtime (wrangler dev)');
+    logger.info('  npx wrangler secret put MCP_AUTH_TOKEN   # then each API credential');
+    logger.info('  npx wrangler deploy');
+}

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

@@ -0,0 +1,75 @@
+declare const _default: import("citty").CommandDef<{
+    url: {
+        type: "positional";
+        description: string;
+        required: true;
+    };
+    output: {
+        type: "string";
+        alias: string;
+        description: string;
+        required: true;
+    };
+    name: {
+        type: "string";
+        alias: string;
+        description: string;
+    };
+    timeout: {
+        type: "string";
+        description: string;
+        default: string;
+    };
+    headless: {
+        type: "boolean";
+        description: string;
+        default: false;
+    };
+    navigate: {
+        type: "string";
+        description: string;
+    };
+    transport: {
+        type: "string";
+        alias: string;
+        description: string;
+        default: string;
+    };
+    target: {
+        type: "string";
+        description: string;
+        default: string;
+    };
+    include: {
+        type: "string";
+        alias: string;
+        description: string;
+    };
+    exclude: {
+        type: "string";
+        alias: string;
+        description: string;
+    };
+    force: {
+        type: "boolean";
+        alias: string;
+        description: string;
+        default: false;
+    };
+    'improve-names': {
+        type: "boolean";
+        description: string;
+        default: false;
+    };
+    interactive: {
+        type: "boolean";
+        description: string;
+        default: false;
+    };
+    'dry-run': {
+        type: "boolean";
+        description: string;
+        default: false;
+    };
+}>;
+export default _default;

package/dist/commands/from/url.js

@@ -0,0 +1,244 @@
+import { defineCommand } from 'citty';
+import { recordBrowserSession } from '../../recorder/browser-recorder.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 } 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: 'url',
+        description: 'Generate an MCP server by recording browser interactions with a website',
+    },
+    args: {
+        url: {
+            type: 'positional',
+            description: 'URL to open in the browser',
+            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 hostname)',
+        },
+        timeout: {
+            type: 'string',
+            description: 'Idle timeout in seconds before auto-closing (default: 300)',
+            default: '300',
+        },
+        headless: {
+            type: 'boolean',
+            description: 'Headless / CI capture: load the page non-interactively (no window to drive) and capture API traffic automatically',
+            default: false,
+        },
+        navigate: {
+            type: 'string',
+            description: 'Comma-separated same-origin URLs/paths to auto-visit in --headless mode to surface more API calls',
+        },
+        transport: {
+            type: 'string',
+            alias: 't',
+            description: 'Transport mode: "stdio" (default) or "http"',
+            default: 'stdio',
+        },
+        target: targetArg,
+        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)',
+        },
+        force: {
+            type: 'boolean',
+            alias: 'f',
+            description: 'Overwrite existing output directory',
+            default: false,
+        },
+        'improve-names': {
+            type: 'boolean',
+            description: 'Use AI to generate better tool names (requires ANTHROPIC_API_KEY)',
+            default: false,
+        },
+        interactive: {
+            type: 'boolean',
+            description: 'Review and confirm detected tools before generation',
+            default: false,
+        },
+        'dry-run': {
+            type: 'boolean',
+            description: 'Preview generated files without writing',
+            default: false,
+        },
+    },
+    async run({ args }) {
+        const timeoutMs = parseInt(args.timeout ?? '300', 10) * 1000;
+        // Record browser session
+        const { entries, baseUrl } = await recordBrowserSession({
+            url: args.url,
+            timeout: timeoutMs,
+            headless: args.headless ?? false,
+            navigate: args.navigate
+                ?.split(',')
+                .map((s) => s.trim())
+                .filter(Boolean),
+        });
+        logger.info(`Captured ${entries.length} total requests`);
+        // Filter noise (reuse HAR pipeline)
+        const targetHost = new URL(args.url).hostname;
+        const filtered = filterHarEntries(entries, {
+            allowedDomains: [targetHost],
+            includeErrors: false,
+        });
+        logger.info(`${filtered.length} API requests after filtering`);
+        if (filtered.length === 0) {
+            await fail(args.headless
+                ? 'No API requests captured. Pass --navigate with paths that trigger API calls, or use interactive mode (omit --headless).'
+                : 'No API requests captured. Try interacting with the page more.');
+        }
+        // Normalize → dedup → cluster → convert (shared HAR pipeline)
+        let normalized = filtered.map(normalizeEntry);
+        const beforeDedup = normalized.length;
+        normalized = deduplicateEntries(normalized);
+        if (normalized.length < beforeDedup) {
+            logger.info(`Deduplicated: ${beforeDedup} → ${normalized.length} entries`);
+        }
+        const clusters = clusterEntries(normalized);
+        logger.info(`Clustered into ${clusters.length} operations`);
+        let { operations: allOperations, 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.');
+            }
+        }
+        // Build auth schemes
+        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 from browser session',
+                });
+                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 from browser session',
+                });
+                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;
+        });
+        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,
+        };
+        logger.info(`Generating MCP server: ${serverName}` +
+            (target === 'cloudflare' ? ' (Cloudflare Workers)' : ''));
+        await emitProject(manifest, {
+            outputDir: args.output,
+            force: args.force ?? false,
+            dryRun: args['dry-run'] ?? false,
+        });
+        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/website.d.ts

@@ -0,0 +1,75 @@
+declare const _default: import("citty").CommandDef<{
+    url: {
+        type: "positional";
+        description: string;
+        required: true;
+    };
+    output: {
+        type: "string";
+        alias: string;
+        description: string;
+        required: true;
+    };
+    name: {
+        type: "string";
+        alias: string;
+        description: string;
+    };
+    depth: {
+        type: "string";
+        description: string;
+        default: string;
+    };
+    'max-pages': {
+        type: "string";
+        description: string;
+        default: string;
+    };
+    timeout: {
+        type: "string";
+        description: string;
+        default: string;
+    };
+    transport: {
+        type: "string";
+        alias: string;
+        description: string;
+        default: string;
+    };
+    headless: {
+        type: "boolean";
+        description: string;
+        default: false;
+    };
+    force: {
+        type: "boolean";
+        alias: string;
+        description: string;
+        default: false;
+    };
+    'dry-run': {
+        type: "boolean";
+        description: string;
+        default: false;
+    };
+    'improve-names': {
+        type: "boolean";
+        description: string;
+        default: false;
+    };
+    'max-sessions': {
+        type: "string";
+        description: string;
+        default: string;
+    };
+    hybrid: {
+        type: "boolean";
+        description: string;
+        default: false;
+    };
+    goal: {
+        type: "string";
+        description: string;
+    };
+}>;
+export default _default;