mcpmake 0.1.1 → 0.2.1

package/dist/cloud/build-pipeline.js

@@ -1,310 +0,0 @@
-/**
- * Spec -> Generated project pipeline.
- *
- * Takes an uploaded spec file (OpenAPI or HAR), runs it through the existing
- * parser/transformer/emitter pipeline, audits the output, and returns a
- * BuildResult with the slug and image metadata.
- */
-import { randomBytes } from 'node:crypto';
-import { mkdir, readFile, rm, access } from 'node:fs/promises';
-import { join, extname, resolve } from 'node:path';
-import { logger } from '../utils/logger.js';
-import { auditGeneratedCode } from './security.js';
-// OpenAPI pipeline imports
-import { loadOpenApiSpec } from '../parser/openapi-loader.js';
-import { extractOperations } from '../parser/operation-extractor.js';
-import { detectAuthSchemes } from '../transformer/auth-detector.js';
-import { buildAllTools } from '../transformer/tool-builder.js';
-import { buildResources, buildPrompts } from '../transformer/resource-builder.js';
-import { emitProject } from '../emitter/index.js';
-// HAR pipeline imports
-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';
-const BUILD_BASE_DIR = '/tmp/mcpmake-build';
-/**
- * Generate a slug from a name (or random if not provided).
- * Format: kebab-case-name-xxxx where xxxx is 4 random hex chars.
- */
-function generateSlug(name) {
-    const suffix = randomBytes(2).toString('hex');
-    if (!name) {
-        return `mcp-server-${suffix}`;
-    }
-    const base = name
-        .toLowerCase()
-        .replace(/[^a-z0-9]+/g, '-')
-        .replace(/^-|-$/g, '')
-        .slice(0, 40);
-    return base ? `${base}-${suffix}` : `mcp-server-${suffix}`;
-}
-/**
- * Convert a title to a valid package name.
- */
-function toPackageName(title) {
-    return title
-        .toLowerCase()
-        .replace(/[^a-z0-9]+/g, '-')
-        .replace(/^-|-$/g, '');
-}
-/**
- * Build a project from an uploaded spec file.
- *
- * Steps:
- * 1. Generate slug and create temp build dir
- * 2. Run the appropriate pipeline (OpenAPI or HAR) to generate the project
- * 3. Audit the generated code for dangerous patterns
- * 4. Return build result
- */
-export async function buildFromSpec(specPath, opts) {
-    const slug = generateSlug(opts.name);
-    const buildDir = join(BUILD_BASE_DIR, slug);
-    // Path traversal guard: ensure buildDir stays within BUILD_BASE_DIR
-    const resolvedBuildDir = resolve(buildDir);
-    const resolvedBase = resolve(BUILD_BASE_DIR);
-    if (!resolvedBuildDir.startsWith(resolvedBase + '/')) {
-        throw new Error('Invalid build directory path');
-    }
-    await mkdir(buildDir, { recursive: true });
-    logger.info(`Build directory: ${buildDir}`);
-    let toolCount;
-    let buildSuccess = false;
-    try {
-        if (opts.format === 'openapi') {
-            toolCount = await runOpenApiPipeline(specPath, buildDir, opts.name);
-        }
-        else {
-            toolCount = await runHarPipeline(specPath, buildDir, opts.name);
-        }
-        // Audit the entire generated project (not just src/)
-        const audit = await auditGeneratedCode(buildDir);
-        if (!audit.safe) {
-            const findingsList = audit.findings.join('\n  - ');
-            throw new Error(`Code audit failed. Dangerous patterns found in generated code:\n  - ${findingsList}`);
-        }
-        logger.info('Code audit passed');
-        buildSuccess = true;
-    }
-    finally {
-        // Clean up build directory on failure
-        if (!buildSuccess) {
-            try {
-                await rm(buildDir, { recursive: true, force: true });
-            }
-            catch {
-                // Ignore cleanup errors
-            }
-        }
-    }
-    // Detect server type from generated project dependencies
-    const serverType = await detectServerType(buildDir);
-    return {
-        slug,
-        imageName: `mcpmake/${slug}`,
-        imageTag: 'latest',
-        buildDir,
-        toolCount,
-        serverType,
-    };
-}
-/**
- * Run the OpenAPI pipeline: parse spec -> extract operations -> build tools -> emit project.
- * Returns the number of tools generated.
- */
-async function runOpenApiPipeline(specPath, outputDir, name) {
-    logger.info(`Running OpenAPI pipeline for: ${specPath}`);
-    const { api } = await loadOpenApiSpec(specPath);
-    const { operations, baseUrl, securitySchemes, info } = extractOperations(api);
-    if (operations.length === 0) {
-        throw new Error('No operations found in the OpenAPI spec');
-    }
-    logger.info(`Found ${operations.length} operations`);
-    const tools = buildAllTools(operations);
-    const { authSchemes, envVars } = detectAuthSchemes(securitySchemes);
-    const serverName = name ? toPackageName(name) : toPackageName(info.title);
-    const resolvedBaseUrl = baseUrl;
-    if (!resolvedBaseUrl) {
-        throw new Error('No base URL found in spec');
-    }
-    const resources = buildResources(operations);
-    const prompts = buildPrompts(operations);
-    const manifest = {
-        serverName,
-        serverVersion: info.version ?? '1.0.0',
-        baseUrl: resolvedBaseUrl,
-        transport: 'http', // Always HTTP for hosted servers
-        tools,
-        resources,
-        prompts,
-        authSchemes,
-        envVars: [
-            {
-                name: 'BASE_URL',
-                description: 'API base URL',
-                required: true,
-                example: resolvedBaseUrl,
-            },
-            ...envVars,
-        ],
-    };
-    await emitProject(manifest, {
-        outputDir,
-        force: true,
-        dryRun: false,
-    });
-    return tools.length;
-}
-/**
- * Run the HAR pipeline: load HAR -> filter -> normalize -> cluster -> emit project.
- * Returns the number of tools generated.
- */
-async function runHarPipeline(specPath, outputDir, name) {
-    logger.info(`Running HAR pipeline for: ${specPath}`);
-    const har = await loadHarFile(specPath);
-    logger.info(`Found ${har.log.entries.length} total entries`);
-    // Filter noise (no domain restriction for hosted builds)
-    const filtered = filterHarEntries(har.log.entries, {
-        includeErrors: false,
-    });
-    if (filtered.length === 0) {
-        throw new Error('No API requests found in HAR file after filtering');
-    }
-    logger.info(`${filtered.length} API entries after filtering`);
-    // Normalize paths
-    const normalized = filtered.map(normalizeEntry);
-    // Cluster into operations
-    const clusters = clusterEntries(normalized);
-    logger.info(`Clustered into ${clusters.length} operations`);
-    // Convert to OperationDescriptors
-    const { operations, baseUrl, detectedAuth } = clustersToOperations(clusters);
-    if (operations.length === 0) {
-        throw new Error('No operations could be derived from HAR file');
-    }
-    // Build auth schemes and env vars
-    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;
-    });
-    const tools = buildAllTools(operations);
-    const serverName = name ? toPackageName(name) : toPackageName(new URL(baseUrl).hostname);
-    const manifest = {
-        serverName,
-        serverVersion: '1.0.0',
-        baseUrl,
-        transport: 'http', // Always HTTP for hosted servers
-        tools,
-        authSchemes,
-        envVars: [
-            { name: 'BASE_URL', description: 'API base URL', required: true, example: baseUrl },
-            ...uniqueEnvVars,
-        ],
-    };
-    await emitProject(manifest, {
-        outputDir,
-        force: true,
-        dryRun: false,
-    });
-    return tools.length;
-}
-/**
- * Detect whether a generated project is a Playwright-based server
- * by checking for a "playwright" dependency in its package.json.
- */
-async function detectServerType(buildDir) {
-    const pkgPath = join(buildDir, 'package.json');
-    try {
-        await access(pkgPath);
-        const raw = await readFile(pkgPath, 'utf-8');
-        const pkg = JSON.parse(raw);
-        const allDeps = {
-            ...pkg.dependencies,
-            ...pkg.devDependencies,
-        };
-        if ('playwright' in allDeps || 'playwright-core' in allDeps) {
-            logger.info('Detected Playwright server from package.json dependencies');
-            return 'playwright';
-        }
-    }
-    catch {
-        // No package.json or unreadable — default to http
-    }
-    return 'http';
-}
-/**
- * Detect the spec format from a file path.
- */
-export function detectFormat(filePath, contentType) {
-    const ext = extname(filePath).toLowerCase();
-    if (ext === '.har')
-        return 'har';
-    if (ext === '.yaml' || ext === '.yml' || ext === '.json') {
-        // Could be either OpenAPI JSON or HAR JSON; check content type hint
-        if (contentType?.includes('har'))
-            return 'har';
-        return 'openapi';
-    }
-    // Default to OpenAPI
-    return 'openapi';
-}
-/**
- * Detect format by inspecting file content.
- * Useful when the file extension is ambiguous (e.g., .json).
- */
-export async function detectFormatFromContent(filePath) {
-    const raw = await readFile(filePath, 'utf-8');
-    try {
-        const parsed = JSON.parse(raw);
-        // HAR files have a top-level "log" object with "entries"
-        if (parsed.log && Array.isArray(parsed.log.entries)) {
-            return 'har';
-        }
-    }
-    catch {
-        // Not valid JSON — probably YAML, assume OpenAPI
-    }
-    return 'openapi';
-}

package/dist/cloud/build-queue.d.ts

@@ -1,30 +0,0 @@
-/**
- * Bounded-concurrency queue for expensive build work.
- *
- * Each hosted-server build runs `npm install` + `docker build`, which are
- * CPU/IO heavy. Without a limit, a burst of create requests can exhaust the
- * host (a DoS / cryptomining vector). This serializes the heavy steps to a
- * small number of concurrent slots; excess work waits in a FIFO queue rather
- * than running all at once.
- *
- * Concurrency is `BUILD_CONCURRENCY` (default 2).
- */
-export declare class BuildQueue {
-    private readonly concurrency;
-    private active;
-    private readonly waiters;
-    constructor(concurrency: number);
-    /** Number of tasks currently running. */
-    get activeCount(): number;
-    /** Number of tasks waiting for a free slot. */
-    get queuedCount(): number;
-    private acquire;
-    private release;
-    /**
-     * Run `fn` once a build slot is available, releasing the slot afterwards
-     * (even if `fn` throws).
-     */
-    run<T>(fn: () => Promise<T>): Promise<T>;
-}
-/** Shared build queue used by all create / re-deploy paths. */
-export declare const buildQueue: BuildQueue;

package/dist/cloud/build-queue.js

@@ -1,70 +0,0 @@
-/**
- * Bounded-concurrency queue for expensive build work.
- *
- * Each hosted-server build runs `npm install` + `docker build`, which are
- * CPU/IO heavy. Without a limit, a burst of create requests can exhaust the
- * host (a DoS / cryptomining vector). This serializes the heavy steps to a
- * small number of concurrent slots; excess work waits in a FIFO queue rather
- * than running all at once.
- *
- * Concurrency is `BUILD_CONCURRENCY` (default 2).
- */
-import { logger } from '../utils/logger.js';
-export class BuildQueue {
-    concurrency;
-    active = 0;
-    waiters = [];
-    constructor(concurrency) {
-        this.concurrency = concurrency;
-    }
-    /** Number of tasks currently running. */
-    get activeCount() {
-        return this.active;
-    }
-    /** Number of tasks waiting for a free slot. */
-    get queuedCount() {
-        return this.waiters.length;
-    }
-    acquire() {
-        if (this.active < this.concurrency) {
-            this.active++;
-            return Promise.resolve();
-        }
-        return new Promise((resolve) => this.waiters.push(resolve));
-    }
-    release() {
-        const next = this.waiters.shift();
-        if (next) {
-            // Transfer the slot directly to the next waiter (active stays counted).
-            next();
-        }
-        else {
-            this.active--;
-        }
-    }
-    /**
-     * Run `fn` once a build slot is available, releasing the slot afterwards
-     * (even if `fn` throws).
-     */
-    async run(fn) {
-        const waitingBefore = this.queuedCount;
-        if (this.active >= this.concurrency) {
-            logger.info(`[build-queue] at capacity (${this.activeCount} active); queueing build (${waitingBefore + 1} waiting)`);
-        }
-        await this.acquire();
-        try {
-            return await fn();
-        }
-        finally {
-            this.release();
-        }
-    }
-}
-function parseConcurrency() {
-    const raw = parseInt(process.env.BUILD_CONCURRENCY ?? '2', 10);
-    if (!Number.isFinite(raw) || raw < 1)
-        return 2;
-    return Math.min(raw, 16);
-}
-/** Shared build queue used by all create / re-deploy paths. */
-export const buildQueue = new BuildQueue(parseConcurrency());

package/dist/cloud/caddy-manager.d.ts

@@ -1,18 +0,0 @@
-/**
- * Dynamic reverse proxy routing via Caddy Admin API.
- *
- * Manages routes that map {slug}.{domain} -> localhost:{port}.
- * Caddy Admin API is assumed to run at http://localhost:2019.
- */
-/**
- * Add a route: {slug}.{domain} -> localhost:{port}
- */
-export declare function addRoute(slug: string, port: number, domain: string): Promise<void>;
-/**
- * Remove a route by slug.
- */
-export declare function removeRoute(slug: string, _domain: string): Promise<void>;
-/**
- * Check if a route exists for a given slug.
- */
-export declare function routeExists(slug: string, _domain: string): Promise<boolean>;

package/dist/cloud/caddy-manager.js

@@ -1,97 +0,0 @@
-/**
- * Dynamic reverse proxy routing via Caddy Admin API.
- *
- * Manages routes that map {slug}.{domain} -> localhost:{port}.
- * Caddy Admin API is assumed to run at http://localhost:2019.
- */
-import http from 'node:http';
-import { logger } from '../utils/logger.js';
-const CADDY_ADMIN = 'http://localhost:2019';
-/**
- * Add a route: {slug}.{domain} -> localhost:{port}
- */
-export async function addRoute(slug, port, domain) {
-    const hostname = `${slug}.${domain}`;
-    const route = {
-        '@id': `mcpmake-${slug}`,
-        match: [
-            {
-                host: [hostname],
-            },
-        ],
-        handle: [
-            {
-                handler: 'reverse_proxy',
-                upstreams: [
-                    {
-                        dial: `localhost:${port}`,
-                    },
-                ],
-            },
-        ],
-    };
-    await caddyRequest('POST', '/config/apps/http/servers/srv0/routes', route);
-    logger.info(`Caddy route added: ${hostname} -> localhost:${port}`);
-}
-/**
- * Remove a route by slug.
- */
-export async function removeRoute(slug, _domain) {
-    await caddyRequest('DELETE', `/id/mcpmake-${slug}`, undefined);
-    logger.info(`Caddy route removed: ${slug}`);
-}
-/**
- * Check if a route exists for a given slug.
- */
-export async function routeExists(slug, _domain) {
-    try {
-        const body = await caddyRequest('GET', `/id/mcpmake-${slug}`, undefined);
-        return body !== null;
-    }
-    catch {
-        return false;
-    }
-}
-/**
- * Low-level helper to call the Caddy Admin API.
- */
-function caddyRequest(method, path, body) {
-    return new Promise((resolve, reject) => {
-        const url = new URL(path, CADDY_ADMIN);
-        const payload = body !== undefined ? JSON.stringify(body) : undefined;
-        const req = http.request({
-            hostname: url.hostname,
-            port: Number(url.port),
-            path: url.pathname,
-            method,
-            headers: {
-                ...(payload
-                    ? { 'Content-Type': 'application/json', 'Content-Length': Buffer.byteLength(payload) }
-                    : {}),
-            },
-        }, (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) {
-                    reject(new Error(`Caddy API ${method} ${path} returned ${res.statusCode}: ${responseBody}`));
-                    return;
-                }
-                try {
-                    resolve(responseBody ? JSON.parse(responseBody) : null);
-                }
-                catch {
-                    resolve(responseBody || null);
-                }
-            });
-        });
-        req.on('error', (err) => {
-            reject(new Error(`Caddy API request failed: ${err.message}`));
-        });
-        if (payload) {
-            req.write(payload);
-        }
-        req.end();
-    });
-}

package/dist/cloud/container-backend.d.ts

@@ -1,62 +0,0 @@
-/**
- * Container backend driver abstraction.
- *
- * All container lifecycle operations go through a `ContainerBackend` rather than
- * calling the Docker socket helpers directly. Today the only implementation is
- * `LocalDockerDriver` (the local `/var/run/docker.sock`, no behavior change).
- *
- * The seam exists so a future cloud / multi-node move is a driver swap, not a
- * rewrite: a `RemoteDockerDriver` (TCP + mTLS) or a managed-cloud driver
- * (Fly Machines / Cloud Run) implements the same interface, and a placement
- * layer picks which driver to use per server. See TODO.md Sprint 8 — "Prep
- * seams" and "Tiered placement".
- */
-import type { StartContainerOpts, ContainerStatus } from './container-manager.js';
-export type { StartContainerOpts, ContainerStatus };
-/**
- * A backend capable of building images and running tenant containers.
- *
- * Method contracts mirror the existing `container-manager` functions exactly,
- * so swapping the default driver is invisible to callers.
- */
-export interface ContainerBackend {
-    /** Stable identifier for logs / the server record (which backend ran a container). */
-    readonly name: string;
-    /** Build an image from a generated project directory containing a Dockerfile. */
-    buildImage(buildDir: string, imageName: string, imageTag: string): Promise<void>;
-    /** Create + start a container; resolves to the container ID. */
-    startContainer(opts: StartContainerOpts): Promise<string>;
-    /** Stop and remove a container (best-effort; never throws on already-stopped). */
-    stopContainer(containerId: string): Promise<void>;
-    /** Stream container logs (multiplexed Docker frames decoded to text lines). */
-    getContainerLogs(containerId: string): AsyncIterable<string>;
-    /** Current runtime status; resolves to 'error' if the backend is unreachable. */
-    getContainerStatus(containerId: string): Promise<ContainerStatus>;
-    /** Reclaim disk by removing dangling images (best-effort). */
-    pruneDanglingImages(): Promise<void>;
-}
-/**
- * Default driver: the local Docker daemon over its Unix socket.
- *
- * Delegates to the `container-manager` helpers at call time (not construction)
- * so the well-tested socket code stays the single implementation and module
- * mocks still intercept.
- */
-export declare class LocalDockerDriver implements ContainerBackend {
-    readonly name = "local-docker";
-    buildImage(buildDir: string, imageName: string, imageTag: string): Promise<void>;
-    startContainer(opts: StartContainerOpts): Promise<string>;
-    stopContainer(containerId: string): Promise<void>;
-    getContainerLogs(containerId: string): AsyncIterable<string>;
-    getContainerStatus(containerId: string): Promise<ContainerStatus>;
-    pruneDanglingImages(): Promise<void>;
-}
-/**
- * Resolve the container backend.
- *
- * Single local driver for now; the future placement layer will pass the target
- * server/plan here to pick a driver per tenant.
- */
-export declare function getContainerBackend(): ContainerBackend;
-/** Override the backend (tests / future placement wiring). Pass null to reset. */
-export declare function setContainerBackend(backend: ContainerBackend | null): void;

package/dist/cloud/container-backend.js

@@ -1,59 +0,0 @@
-/**
- * Container backend driver abstraction.
- *
- * All container lifecycle operations go through a `ContainerBackend` rather than
- * calling the Docker socket helpers directly. Today the only implementation is
- * `LocalDockerDriver` (the local `/var/run/docker.sock`, no behavior change).
- *
- * The seam exists so a future cloud / multi-node move is a driver swap, not a
- * rewrite: a `RemoteDockerDriver` (TCP + mTLS) or a managed-cloud driver
- * (Fly Machines / Cloud Run) implements the same interface, and a placement
- * layer picks which driver to use per server. See TODO.md Sprint 8 — "Prep
- * seams" and "Tiered placement".
- */
-import * as docker from './container-manager.js';
-/**
- * Default driver: the local Docker daemon over its Unix socket.
- *
- * Delegates to the `container-manager` helpers at call time (not construction)
- * so the well-tested socket code stays the single implementation and module
- * mocks still intercept.
- */
-export class LocalDockerDriver {
-    name = 'local-docker';
-    buildImage(buildDir, imageName, imageTag) {
-        return docker.buildImage(buildDir, imageName, imageTag);
-    }
-    startContainer(opts) {
-        return docker.startContainer(opts);
-    }
-    stopContainer(containerId) {
-        return docker.stopContainer(containerId);
-    }
-    getContainerLogs(containerId) {
-        return docker.getContainerLogs(containerId);
-    }
-    getContainerStatus(containerId) {
-        return docker.getContainerStatus(containerId);
-    }
-    pruneDanglingImages() {
-        return docker.pruneDanglingImages();
-    }
-}
-let cached = null;
-/**
- * Resolve the container backend.
- *
- * Single local driver for now; the future placement layer will pass the target
- * server/plan here to pick a driver per tenant.
- */
-export function getContainerBackend() {
-    if (!cached) {
-        cached = new LocalDockerDriver();
-    }
-    return cached;
-}
-/** Override the backend (tests / future placement wiring). Pass null to reset. */
-export function setContainerBackend(backend) {
-    cached = backend;
-}