mcpmake 0.1.0

package/dist/cloud/web/templates/partials/pricing-table.hbs

@@ -0,0 +1,103 @@
+<div class="pricing-grid">
+  <!-- Free -->
+  <article class="pricing-card">
+    <div class="pricing-card-header">
+      <h3 class="pricing-tier-name">Free</h3>
+      <div class="pricing-amount"><span class="pricing-currency">$</span><span class="pricing-value">0</span><span class="pricing-period">/mo</span></div>
+      <p class="pricing-tagline">Get started instantly</p>
+    </div>
+    <ul class="pricing-features">
+      <li>1 MCP server</li>
+      <li>500 requests / month</li>
+      <li>8-hour idle shutdown</li>
+      <li>Community support</li>
+    </ul>
+    <div class="pricing-card-footer">
+      <a href="/register" class="btn btn-secondary btn-block">Get started</a>
+      <p class="pricing-note">No credit card required</p>
+    </div>
+  </article>
+
+  <!-- Hobbyist -->
+  <article class="pricing-card">
+    <div class="pricing-card-header">
+      <h3 class="pricing-tier-name">Hobbyist</h3>
+      <div class="pricing-amount"><span class="pricing-currency">$</span><span class="pricing-value">9</span><span class="pricing-period">/mo</span></div>
+      <p class="pricing-tagline">For side projects</p>
+    </div>
+    <ul class="pricing-features">
+      <li>5 MCP servers</li>
+      <li>10,000 requests / month</li>
+      <li>24-hour keep-alive</li>
+      <li>Email support</li>
+    </ul>
+    <div class="pricing-card-footer">
+      {{#if csrfToken}}
+      <form method="POST" action="/dashboard/billing/checkout">
+        <input type="hidden" name="_csrf" value="{{csrfToken}}">
+        <input type="hidden" name="plan" value="hobbyist">
+        <button type="submit" class="btn btn-secondary btn-block">Subscribe</button>
+      </form>
+      {{else}}
+      <a href="/register?plan=hobbyist" class="btn btn-secondary btn-block">Subscribe</a>
+      {{/if}}
+    </div>
+  </article>
+
+  <!-- Pro (featured) -->
+  <article class="pricing-card pricing-card--featured">
+    <div class="pricing-badge">Popular</div>
+    <div class="pricing-card-header">
+      <h3 class="pricing-tier-name">Pro</h3>
+      <div class="pricing-amount"><span class="pricing-currency">$</span><span class="pricing-value">29</span><span class="pricing-period">/mo</span></div>
+      <p class="pricing-tagline">For production APIs</p>
+    </div>
+    <ul class="pricing-features">
+      <li>20 MCP servers</li>
+      <li>100,000 requests / month</li>
+      <li>Always-on servers</li>
+      <li>Custom domain</li>
+      <li>90-day log retention</li>
+      <li>Priority support</li>
+    </ul>
+    <div class="pricing-card-footer">
+      {{#if csrfToken}}
+      <form method="POST" action="/dashboard/billing/checkout">
+        <input type="hidden" name="_csrf" value="{{csrfToken}}">
+        <input type="hidden" name="plan" value="pro">
+        <button type="submit" class="btn btn-primary btn-block">Subscribe</button>
+      </form>
+      {{else}}
+      <a href="/register?plan=pro" class="btn btn-primary btn-block">Subscribe</a>
+      {{/if}}
+    </div>
+  </article>
+
+  <!-- Team -->
+  <article class="pricing-card">
+    <div class="pricing-card-header">
+      <h3 class="pricing-tier-name">Team</h3>
+      <div class="pricing-amount"><span class="pricing-currency">$</span><span class="pricing-value">99</span><span class="pricing-period">/mo</span></div>
+      <p class="pricing-tagline">For organizations</p>
+    </div>
+    <ul class="pricing-features">
+      <li>Unlimited MCP servers</li>
+      <li>1,000,000 requests / month</li>
+      <li>Always-on servers</li>
+      <li>RBAC &amp; workspaces</li>
+      <li>Audit logs</li>
+      <li>Dedicated support</li>
+    </ul>
+    <div class="pricing-card-footer">
+      {{#if csrfToken}}
+      <form method="POST" action="/dashboard/billing/checkout">
+        <input type="hidden" name="_csrf" value="{{csrfToken}}">
+        <input type="hidden" name="plan" value="team">
+        <button type="submit" class="btn btn-primary btn-block">Subscribe</button>
+      </form>
+      {{else}}
+      <a href="/register?plan=team" class="btn btn-secondary btn-block">Subscribe</a>
+      {{/if}}
+    </div>
+  </article>
+</div>

package/dist/cloud/web/templates/partials/server-card.hbs

@@ -0,0 +1,19 @@
+<div class="server-card">
+  <div class="server-card-header">
+    <a href="/dashboard/servers/{{slug}}" class="server-card-name">{{slug}}</a>
+    {{> status-badge status=status}}
+  </div>
+  <div class="server-card-meta">
+    <span>{{toolCount}} tools</span>
+    <span>Last active: {{formatDate lastActiveAt}}</span>
+  </div>
+  <div class="server-card-actions">
+    <a href="/dashboard/servers/{{slug}}" class="btn btn-sm btn-secondary">View</a>
+    <a href="/dashboard/servers/{{slug}}/logs" class="btn btn-sm btn-secondary">Logs</a>
+    <form method="POST" action="/dashboard/servers/{{slug}}/delete"
+          x-data x-on:submit.prevent="if(confirm('Delete server {{slug}}?')) $el.submit()">
+      <input type="hidden" name="_csrf" value="{{csrfToken}}">
+      <button type="submit" class="btn btn-sm btn-danger">Delete</button>
+    </form>
+  </div>
+</div>

package/dist/cloud/web/templates/partials/status-badge.hbs

@@ -0,0 +1 @@
+<span class="status-badge status-{{status}}">{{status}}</span>

package/dist/commands/bundle.d.ts

@@ -0,0 +1,18 @@
+declare const _default: import("citty").CommandDef<{
+    directory: {
+        type: "positional";
+        description: string;
+        required: true;
+    };
+    output: {
+        type: "string";
+        alias: string;
+        description: string;
+    };
+    'skip-build': {
+        type: "boolean";
+        description: string;
+        default: false;
+    };
+}>;
+export default _default;

package/dist/commands/bundle.js

@@ -0,0 +1,82 @@
+import { defineCommand } from 'citty';
+import { resolve } from 'node:path';
+import { execFile as execFileCb } from 'node:child_process';
+import { promisify } from 'node:util';
+import { logger } from '../utils/logger.js';
+import { fail } from '../utils/fail.js';
+import { pathExists } from '../utils/fs.js';
+import { generateMcpb } from '../emitter/mcpb-bundler.js';
+const execFile = promisify(execFileCb);
+export default defineCommand({
+    meta: {
+        name: 'bundle',
+        description: 'Bundle a generated MCP server project into an .mcpb file',
+    },
+    args: {
+        directory: {
+            type: 'positional',
+            description: 'Path to the generated MCP server project',
+            required: true,
+        },
+        output: {
+            type: 'string',
+            alias: 'o',
+            description: 'Output path for the .mcpb file',
+        },
+        'skip-build': {
+            type: 'boolean',
+            description: 'Skip npm install and build steps (use if already built)',
+            default: false,
+        },
+    },
+    async run({ args }) {
+        const projectDir = resolve(args.directory);
+        const pkgPath = resolve(projectDir, 'package.json');
+        if (!(await pathExists(pkgPath))) {
+            await fail(`Not a valid project directory (no package.json): ${projectDir}`);
+        }
+        if (!args['skip-build']) {
+            await buildProject(projectDir);
+        }
+        const outputPath = args.output ? resolve(args.output) : undefined;
+        logger.info('Creating .mcpb bundle...');
+        try {
+            const mcpbPath = await generateMcpb({
+                projectDir,
+                outputPath,
+            });
+            logger.success(`MCPB bundle created: ${mcpbPath}`);
+        }
+        catch (err) {
+            const message = err instanceof Error ? err.message : String(err);
+            await fail(`Bundle failed: ${message}`, err);
+        }
+    },
+});
+/**
+ * Install production dependencies and build the project.
+ */
+async function buildProject(projectDir) {
+    logger.info('Installing production dependencies...');
+    try {
+        await execFile('npm', ['install', '--omit=dev'], {
+            cwd: projectDir,
+            timeout: 120_000,
+        });
+    }
+    catch (err) {
+        const message = err instanceof Error ? err.message : String(err);
+        throw new Error(`npm install failed: ${message}`);
+    }
+    logger.info('Building project...');
+    try {
+        await execFile('npm', ['run', 'build'], {
+            cwd: projectDir,
+            timeout: 120_000,
+        });
+    }
+    catch (err) {
+        const message = err instanceof Error ? err.message : String(err);
+        throw new Error(`npm run build failed: ${message}`);
+    }
+}

package/dist/commands/ci.d.ts

@@ -0,0 +1,25 @@
+export interface WorkflowOptions {
+    /** Path to the spec, relative to the repo root (e.g. `api-spec.yaml`). */
+    spec: string;
+    /** Generated server directory (e.g. `./mcp-server`). */
+    output: string;
+    /** Source adapter. */
+    source: 'openapi' | 'har' | 'postman';
+    /** Optional server name. */
+    name?: string;
+    /** Transport mode for the generated server. */
+    transport: 'stdio' | 'http';
+    /** mcpmake version/tag to run in CI (e.g. `latest`, `0.1.0`). */
+    version: string;
+}
+/**
+ * Build the `.github/workflows/mcpmake.yaml` contents. Pure + testable.
+ *
+ * The workflow regenerates the MCP server from the spec on every change and
+ * fails if the committed output is stale — the "keep generated code in sync
+ * with the spec" guarantee (the Stainless-style auto-regenerate-on-spec-change
+ * workflow). It also runs `mcpmake verify` for OpenAPI specs.
+ */
+export declare function buildWorkflowYaml(opts: WorkflowOptions): string;
+declare const _default: import("citty").CommandDef<import("citty").ArgsDef>;
+export default _default;

package/dist/commands/ci.js

@@ -0,0 +1,149 @@
+import { defineCommand } from 'citty';
+import { writeFile, mkdir, access } from 'node:fs/promises';
+import { resolve, dirname } from 'node:path';
+import { logger } from '../utils/logger.js';
+import { fail } from '../utils/fail.js';
+const SOURCES = new Set(['openapi', 'har', 'postman']);
+const TRANSPORTS = new Set(['stdio', 'http']);
+/** Shell-quote a value for safe interpolation into a `run:` step. */
+function q(value) {
+    return `"${value.replace(/"/g, '\\"')}"`;
+}
+/**
+ * Build the `.github/workflows/mcpmake.yaml` contents. Pure + testable.
+ *
+ * The workflow regenerates the MCP server from the spec on every change and
+ * fails if the committed output is stale — the "keep generated code in sync
+ * with the spec" guarantee (the Stainless-style auto-regenerate-on-spec-change
+ * workflow). It also runs `mcpmake verify` for OpenAPI specs.
+ */
+export function buildWorkflowYaml(opts) {
+    const runner = `npx --yes mcpmake@${opts.version}`;
+    const genFlags = [
+        `-o ${q(opts.output)}`,
+        opts.name ? `-n ${q(opts.name)}` : '',
+        opts.transport === 'http' ? '-t http' : '',
+        '-f',
+    ]
+        .filter(Boolean)
+        .join(' ');
+    const generate = `${runner} from ${opts.source} ${q(opts.spec)} ${genFlags}`;
+    const verify = `${runner} verify ${q(opts.spec)} -p ${q(opts.output)}`;
+    const lines = [
+        '# Generated by `mcpmake ci init`.',
+        '# Regenerates the MCP server from the spec on every change and fails if the',
+        '# committed output is out of date — keep your generated server in sync with',
+        '# the API spec. Re-run `mcpmake from ...` locally and commit when this fails.',
+        'name: mcpmake',
+        '',
+        'on:',
+        '  push:',
+        '    paths:',
+        `      - ${q(opts.spec)}`,
+        "      - '.github/workflows/mcpmake.yaml'",
+        '  pull_request:',
+        '    paths:',
+        `      - ${q(opts.spec)}`,
+        '  workflow_dispatch:',
+        '',
+        'jobs:',
+        '  sync:',
+        '    runs-on: ubuntu-latest',
+        '    steps:',
+        '      - uses: actions/checkout@v4',
+        '      - uses: actions/setup-node@v4',
+        '        with:',
+        "          node-version: '20'",
+        '      - name: Regenerate MCP server from spec',
+        `        run: ${generate}`,
+    ];
+    // `mcpmake verify` currently supports OpenAPI specs only.
+    if (opts.source === 'openapi') {
+        lines.push('      - name: Verify generated server matches the spec', `        run: ${verify}`);
+    }
+    lines.push('      - name: Fail if the generated server is out of date', '        run: |', `          if [ -n "$(git status --porcelain ${q(opts.output)})" ]; then`, `            echo "::error::The committed MCP server under ${opts.output} is out of date with ${opts.spec}. Regenerate it and commit the result."`, `            git --no-pager diff -- ${q(opts.output)}`, '            exit 1', '          fi', '');
+    return lines.join('\n');
+}
+const initCommand = defineCommand({
+    meta: {
+        name: 'init',
+        description: 'Generate a GitHub Actions workflow that regenerates + verifies the MCP server when the spec changes',
+    },
+    args: {
+        spec: {
+            type: 'positional',
+            description: 'Path to the API spec, relative to the repo root (e.g. api-spec.yaml)',
+            required: true,
+        },
+        output: {
+            type: 'string',
+            alias: 'o',
+            description: 'Generated server directory',
+            default: './mcp-server',
+        },
+        source: {
+            type: 'string',
+            alias: 's',
+            description: 'Source adapter: openapi | har | postman',
+            default: 'openapi',
+        },
+        name: {
+            type: 'string',
+            alias: 'n',
+            description: 'Server name passed to generation',
+        },
+        transport: {
+            type: 'string',
+            alias: 't',
+            description: 'Transport for the generated server: stdio | http',
+            default: 'stdio',
+        },
+        'mcpmake-version': {
+            type: 'string',
+            description: 'mcpmake version/tag to run in CI (e.g. latest, 0.1.0)',
+            default: 'latest',
+        },
+        force: {
+            type: 'boolean',
+            alias: 'f',
+            description: 'Overwrite an existing workflow file',
+            default: false,
+        },
+    },
+    async run({ args }) {
+        const source = String(args.source);
+        const transport = String(args.transport);
+        if (!SOURCES.has(source)) {
+            await fail(`Invalid --source "${source}". Use one of: openapi, har, postman.`);
+        }
+        if (!TRANSPORTS.has(transport)) {
+            await fail(`Invalid --transport "${transport}". Use one of: stdio, http.`);
+        }
+        const workflowPath = resolve('.github/workflows/mcpmake.yaml');
+        const exists = await access(workflowPath).then(() => true, () => false);
+        if (exists && !args.force) {
+            await fail(`${workflowPath} already exists. Re-run with --force to overwrite.`);
+        }
+        const yaml = buildWorkflowYaml({
+            spec: args.spec,
+            output: String(args.output),
+            source: source,
+            name: args.name ? String(args.name) : undefined,
+            transport: transport,
+            version: String(args['mcpmake-version']),
+        });
+        await mkdir(dirname(workflowPath), { recursive: true });
+        await writeFile(workflowPath, yaml, 'utf-8');
+        logger.success(`Wrote ${workflowPath}`);
+        logger.info('Commit it, and CI will keep the generated server in sync with the spec.');
+    },
+});
+export default defineCommand({
+    meta: {
+        name: 'ci',
+        description: 'CI integration helpers (GitHub Actions)',
+    },
+    subCommands: {
+        init: initCommand,
+    },
+});

package/dist/commands/deploy.d.ts

@@ -0,0 +1,24 @@
+declare const _default: import("citty").CommandDef<{
+    spec: {
+        type: "positional";
+        description: string;
+        required: true;
+    };
+    name: {
+        type: "string";
+        alias: string;
+        description: string;
+    };
+    server: {
+        type: "string";
+        alias: string;
+        description: string;
+        default: string;
+    };
+    token: {
+        type: "string";
+        alias: string;
+        description: string;
+    };
+}>;
+export default _default;

package/dist/commands/deploy.js

@@ -0,0 +1,145 @@
+import { defineConfigurableCommand } from '../config/configurable-command.js';
+import { readFile, stat } from 'node:fs/promises';
+import { basename, extname, resolve } from 'node:path';
+import http from 'node:http';
+import https from 'node:https';
+import { logger } from '../utils/logger.js';
+import { fail } from '../utils/fail.js';
+const MAX_SPEC_SIZE = 5 * 1024 * 1024; // 5 MB
+export default defineConfigurableCommand('deploy', {
+    meta: {
+        name: 'deploy',
+        description: 'Deploy an MCP server to the hosting backend',
+    },
+    args: {
+        spec: {
+            type: 'positional',
+            description: 'Path to OpenAPI spec or HAR file',
+            required: true,
+        },
+        name: {
+            type: 'string',
+            alias: 'n',
+            description: 'Server name (default: derived from spec)',
+        },
+        server: {
+            type: 'string',
+            alias: 's',
+            description: 'Cloud server URL',
+            default: 'http://localhost:3001',
+        },
+        token: {
+            type: 'string',
+            alias: 't',
+            description: 'Admin token (or set MCPMAKE_ADMIN_TOKEN) for gated backends',
+        },
+    },
+    async run({ args }) {
+        const specPath = resolve(args.spec);
+        // Validate file exists and size
+        let fileInfo;
+        try {
+            fileInfo = await stat(specPath);
+        }
+        catch (err) {
+            return await fail(`File not found: ${specPath}`, err);
+        }
+        if (fileInfo.size > MAX_SPEC_SIZE) {
+            return await fail(`Spec file too large (${Math.round(fileInfo.size / 1024)}KB). Maximum is 5MB.`);
+        }
+        const ext = extname(specPath).toLowerCase();
+        const allowedExtensions = new Set(['.yaml', '.yml', '.json', '.har']);
+        if (!allowedExtensions.has(ext)) {
+            await fail('Invalid file type. Accepted: .yaml, .yml, .json, .har');
+        }
+        logger.info(`Deploying spec: ${specPath}`);
+        const serverUrl = args.server;
+        logger.info(`Target: ${serverUrl}`);
+        // Read the spec file
+        const specData = await readFile(specPath);
+        const fileName = basename(specPath);
+        // Build multipart form data
+        const boundary = `----mcpmake${Date.now()}${Math.random().toString(36).slice(2)}`;
+        const parts = [];
+        // Add name field if provided
+        if (args.name) {
+            parts.push(Buffer.from(`--${boundary}\r\nContent-Disposition: form-data; name="name"\r\n\r\n${args.name}\r\n`));
+        }
+        // Add spec file
+        parts.push(Buffer.from(`--${boundary}\r\nContent-Disposition: form-data; name="spec"; filename="${fileName}"\r\nContent-Type: application/octet-stream\r\n\r\n`));
+        parts.push(specData);
+        parts.push(Buffer.from(`\r\n--${boundary}--\r\n`));
+        const body = Buffer.concat(parts);
+        // POST to the hosting backend
+        logger.info('Uploading spec...');
+        const adminToken = args.token ?? process.env.MCPMAKE_ADMIN_TOKEN;
+        try {
+            const result = await postMultipart(serverUrl, '/api/servers', boundary, body, adminToken);
+            logger.success('Server deployed!');
+            logger.info('');
+            logger.info(`  Slug:     ${result.slug}`);
+            logger.info(`  Endpoint: ${result.endpoint}`);
+            logger.info(`  Token:    ${result.bearerToken}`);
+            logger.info(`  Tools:    ${result.toolCount}`);
+            logger.info('');
+            logger.info('Claude Desktop config (add to claude_desktop_config.json):');
+            logger.info('');
+            logger.info(JSON.stringify(result.claudeDesktopConfig, null, 2));
+            logger.info('');
+        }
+        catch (err) {
+            const message = err instanceof Error ? err.message : String(err);
+            await fail(`Deploy failed: ${message}`, err);
+        }
+    },
+});
+/**
+ * POST multipart form data to the hosting backend.
+ */
+function postMultipart(serverUrl, path, boundary, body, adminToken) {
+    return new Promise((resolve, reject) => {
+        const url = new URL(path, serverUrl);
+        const transport = url.protocol === 'https:' ? https : http;
+        const headers = {
+            'Content-Type': `multipart/form-data; boundary=${boundary}`,
+            'Content-Length': body.length,
+        };
+        if (adminToken) {
+            headers['Authorization'] = `Bearer ${adminToken}`;
+        }
+        const req = transport.request({
+            hostname: url.hostname,
+            port: url.port,
+            path: url.pathname,
+            method: 'POST',
+            headers,
+        }, (res) => {
+            const chunks = [];
+            res.on('data', (chunk) => chunks.push(chunk));
+            res.on('end', () => {
+                const responseBody = Buffer.concat(chunks).toString('utf-8');
+                if (res.statusCode && res.statusCode >= 400) {
+                    try {
+                        const err = JSON.parse(responseBody);
+                        reject(new Error(err.error ?? `Server returned ${res.statusCode}`));
+                    }
+                    catch {
+                        reject(new Error(`Server returned ${res.statusCode}: ${responseBody}`));
+                    }
+                    return;
+                }
+                try {
+                    resolve(JSON.parse(responseBody));
+                }
+                catch {
+                    reject(new Error(`Invalid response from server: ${responseBody}`));
+                }
+            });
+        });
+        req.on('error', (err) => {
+            reject(new Error(`Connection failed: ${err.message}`));
+        });
+        req.write(body);
+        req.end();
+    });
+}

package/dist/commands/diff.d.ts

@@ -0,0 +1,18 @@
+declare const _default: import("citty").CommandDef<{
+    oldSpec: {
+        type: "positional";
+        description: string;
+        required: true;
+    };
+    newSpec: {
+        type: "positional";
+        description: string;
+        required: true;
+    };
+    format: {
+        type: "string";
+        description: string;
+        default: string;
+    };
+}>;
+export default _default;