mcpmake 0.1.0

package/dist/emitter/index.js

@@ -0,0 +1,280 @@
+import { writeCodeUnits } from './code-writer.js';
+import { scaffoldProjectFiles, scaffoldSharedModules } from './project-scaffolder.js';
+import { scaffoldSiteProjectFiles, scaffoldSiteSharedModules } from './site-scaffolder.js';
+import { renderTemplate } from './template-loader.js';
+import { renderSiteTemplate } from './site-template-loader.js';
+import { renderPythonTemplate } from './python-template-loader.js';
+import { renderWorkerTemplate } from './worker-template-loader.js';
+import { buildCatalog } from '../transformer/catalog-builder.js';
+import { logger } from '../utils/logger.js';
+const SAFE_VERSION_RE = /^[0-9a-zA-Z._+-]{1,50}$/;
+export async function emitProject(manifest, options) {
+    // Cloudflare Workers target uses a separate (stateless Fetch-handler) pipeline.
+    if (manifest.target === 'cloudflare') {
+        return emitWorkerProject(manifest, options);
+    }
+    if (!/^[a-z0-9][a-z0-9._-]*$/.test(manifest.serverName)) {
+        throw new Error(`Invalid server name: "${manifest.serverName}". Must match /^[a-z0-9][a-z0-9._-]*$/`);
+    }
+    if (!SAFE_VERSION_RE.test(manifest.serverVersion)) {
+        logger.warn(`Unsafe server version "${manifest.serverVersion}" sanitized to "0.0.0"`);
+        manifest = { ...manifest, serverVersion: '0.0.0' };
+    }
+    const units = [];
+    // Project skeleton
+    units.push(...scaffoldProjectFiles(manifest));
+    // Shared source modules
+    units.push(...scaffoldSharedModules(manifest));
+    // Task manager (if any async operations detected)
+    const hasAsyncTools = manifest.tools.some((t) => t.isAsync);
+    if (hasAsyncTools) {
+        units.push({
+            filePath: 'src/task-manager.ts',
+            content: renderTemplate('task-manager.ts', manifest),
+        });
+        units.push({
+            filePath: 'src/task-handlers.ts',
+            content: renderTemplate('task-handlers.ts', manifest),
+        });
+        units.push({
+            filePath: 'src/task-sse.ts',
+            content: renderTemplate('task-sse.ts', manifest),
+        });
+    }
+    // OAuth module (if OAuth2 auth detected)
+    const hasOAuth = manifest.authSchemes.some((s) => s.type === 'oauth2');
+    if (hasOAuth) {
+        units.push({
+            filePath: 'src/oauth.ts',
+            content: renderTemplate('oauth.ts', manifest),
+        });
+    }
+    if (manifest.dynamicDiscovery) {
+        // Dynamic discovery mode: emit catalog + discovery meta-tools
+        const catalog = buildCatalog(manifest.tools);
+        units.push({
+            filePath: 'src/tool-catalog.json',
+            content: JSON.stringify(catalog, null, 2),
+        });
+        units.push({
+            filePath: 'src/discovery.ts',
+            content: renderTemplate('discovery.ts', manifest),
+        });
+        // Hybrid mode: also register first N tools statically
+        const staticCount = manifest.staticToolCount ?? 0;
+        const staticTools = manifest.tools.slice(0, staticCount);
+        if (staticTools.length > 0) {
+            for (const tool of staticTools) {
+                units.push({
+                    filePath: `src/tools/${tool.fileName}.ts`,
+                    content: renderTemplate('tool-handler.ts', tool),
+                });
+            }
+            units.push({
+                filePath: 'src/tools/index.ts',
+                content: renderTemplate('tool-index.ts', { tools: staticTools }),
+            });
+        }
+        logger.info(`Dynamic discovery: ${catalog.length} tools in catalog` +
+            (staticTools.length > 0 ? `, ${staticTools.length} static` : ''));
+    }
+    else {
+        // Standard mode: emit all tools individually
+        for (const tool of manifest.tools) {
+            units.push({
+                filePath: `src/tools/${tool.fileName}.ts`,
+                content: renderTemplate('tool-handler.ts', tool),
+            });
+        }
+        units.push({
+            filePath: 'src/tools/index.ts',
+            content: renderTemplate('tool-index.ts', { tools: manifest.tools }),
+        });
+    }
+    // Resources file (if any GET list endpoints exist)
+    if (manifest.resources && manifest.resources.length > 0) {
+        units.push({
+            filePath: 'src/resources.ts',
+            content: renderTemplate('resources.ts', { resources: manifest.resources }),
+        });
+    }
+    // Prompts file (if any)
+    if (manifest.prompts && manifest.prompts.length > 0) {
+        units.push({
+            filePath: 'src/prompts.ts',
+            content: renderTemplate('prompts.ts', { prompts: manifest.prompts }),
+        });
+    }
+    // Test files for each tool
+    for (const tool of manifest.tools) {
+        units.push({
+            filePath: `test/tools/${tool.fileName}.test.ts`,
+            content: renderTemplate('tool-test.ts', tool),
+        });
+    }
+    logger.info(`Writing ${units.length} files to ${options.outputDir}`);
+    await writeCodeUnits(units, options.outputDir, options);
+}
+/**
+ * Emit a Cloudflare Workers MCP server project (the `--target cloudflare` path).
+ *
+ * Workers is stateless and has no node:http server, so the SDK's
+ * StreamableHTTPServerTransport cannot run there. The entry (`src/index.ts`) is a
+ * hand-rolled JSON-RPC Fetch handler instead. The runtime-agnostic modules
+ * (`http.ts`, `auth.ts`, `trace.ts`) are reused verbatim from the Node templates —
+ * they only need `nodejs_compat`, which `wrangler.toml` enables.
+ *
+ * v1 scope is tools + initialize/ping/server-discover + bearer auth. Resources,
+ * prompts, the Tasks extension and OAuth2 outbound auth are not emitted for this
+ * target (a warning is logged and the user is pointed at `--target node`).
+ */
+export async function emitWorkerProject(manifest, options) {
+    if (!/^[a-z0-9][a-z0-9._-]*$/.test(manifest.serverName)) {
+        throw new Error(`Invalid server name: "${manifest.serverName}". Must match /^[a-z0-9][a-z0-9._-]*$/`);
+    }
+    if (!SAFE_VERSION_RE.test(manifest.serverVersion)) {
+        logger.warn(`Unsafe server version "${manifest.serverVersion}" sanitized to "0.0.0"`);
+        manifest = { ...manifest, serverVersion: '0.0.0' };
+    }
+    // Warn about features the Workers target does not emit (so nothing is silently
+    // dropped). Tools — the dominant case — are always fully emitted.
+    if ((manifest.resources?.length ?? 0) > 0 || (manifest.prompts?.length ?? 0) > 0) {
+        logger.warn(`Cloudflare target emits tools only — ${manifest.resources?.length ?? 0} resource(s) ` +
+            `and ${manifest.prompts?.length ?? 0} prompt(s) omitted. Use --target node to include them.`);
+    }
+    if (manifest.tools.some((t) => t.isAsync)) {
+        logger.warn('Cloudflare target: async tools run synchronously within the request (no Tasks extension / background polling).');
+    }
+    if (manifest.dynamicDiscovery) {
+        logger.warn('Cloudflare target does not support --dynamic-discovery; emitting all tools individually.');
+    }
+    const workerAuthSchemes = manifest.authSchemes.filter((s) => s.type !== 'oauth2');
+    if (workerAuthSchemes.length !== manifest.authSchemes.length) {
+        logger.warn('Cloudflare target: OAuth2 outbound auth is omitted (apiKey / bearer / basic are supported). Use --target node for OAuth2.');
+    }
+    const authEnvVars = manifest.envVars.filter((v) => v.name !== 'BASE_URL');
+    // The reused auth + config modules must see the filtered (no-oauth2) schemes so
+    // they never reference an un-emitted oauth.ts.
+    const templateData = {
+        ...manifest,
+        authSchemes: workerAuthSchemes,
+        authEnvVars,
+        hasOAuth: false,
+    };
+    const units = [
+        // Worker-specific files.
+        { filePath: 'src/index.ts', content: renderWorkerTemplate('worker.ts', templateData) },
+        { filePath: 'src/config.ts', content: renderWorkerTemplate('config.ts', templateData) },
+        { filePath: 'package.json', content: renderWorkerTemplate('package.json', templateData) },
+        { filePath: 'tsconfig.json', content: renderWorkerTemplate('tsconfig.json', templateData) },
+        { filePath: 'wrangler.toml', content: renderWorkerTemplate('wrangler.toml', templateData) },
+        { filePath: 'README.md', content: renderWorkerTemplate('readme.md', templateData) },
+        {
+            filePath: '.dev.vars.example',
+            content: renderWorkerTemplate('dev-vars.example', templateData),
+        },
+        { filePath: '.gitignore', content: renderWorkerTemplate('gitignore', templateData) },
+        // Runtime-agnostic modules reused from the Node templates (fetch / Buffer /
+        // AsyncLocalStorage — all covered by nodejs_compat).
+        { filePath: 'src/http.ts', content: renderTemplate('http-executor.ts', templateData) },
+        { filePath: 'src/auth.ts', content: renderTemplate('auth-provider.ts', templateData) },
+        { filePath: 'src/trace.ts', content: renderTemplate('trace.ts', templateData) },
+    ];
+    for (const tool of manifest.tools) {
+        units.push({
+            filePath: `src/tools/${tool.fileName}.ts`,
+            content: renderWorkerTemplate('tool-handler.ts', tool),
+        });
+    }
+    units.push({
+        filePath: 'src/tools/index.ts',
+        content: renderWorkerTemplate('tool-index.ts', { tools: manifest.tools }),
+    });
+    units.push({
+        filePath: 'test/server.test.ts',
+        content: renderWorkerTemplate('server.test.ts', templateData),
+    });
+    logger.info(`Writing ${units.length} Workers files to ${options.outputDir}`);
+    await writeCodeUnits(units, options.outputDir, options);
+}
+/**
+ * Emit a Playwright-based MCP server project from a SiteProjectManifest.
+ * Parallel to emitProject() but uses site-specific templates.
+ */
+export async function emitSiteProject(manifest, options) {
+    if (!/^[a-z0-9][a-z0-9._-]*$/.test(manifest.serverName)) {
+        throw new Error(`Invalid server name: "${manifest.serverName}". Must match /^[a-z0-9][a-z0-9._-]*$/`);
+    }
+    if (!SAFE_VERSION_RE.test(manifest.serverVersion)) {
+        logger.warn(`Unsafe server version "${manifest.serverVersion}" sanitized to "0.0.0"`);
+        manifest = { ...manifest, serverVersion: '0.0.0' };
+    }
+    const units = [];
+    // Project skeleton (package.json, tsconfig, Dockerfile, .env.example, .gitignore)
+    units.push(...scaffoldSiteProjectFiles(manifest));
+    // Shared source modules (server entry, config, browser-manager, site-descriptor.json)
+    units.push(...scaffoldSiteSharedModules(manifest));
+    // Tool files — choose template based on tool type
+    for (const tool of manifest.tools) {
+        const templateName = getSiteToolTemplate(tool);
+        units.push({
+            filePath: `src/tools/${tool.fileName}.ts`,
+            content: renderSiteTemplate(templateName, tool),
+        });
+    }
+    // Tool index (registers all tools)
+    units.push({
+        filePath: 'src/tools/index.ts',
+        content: renderSiteTemplate('tool-index.ts', { tools: manifest.tools }),
+    });
+    logger.info(`Writing ${units.length} files to ${options.outputDir}`);
+    await writeCodeUnits(units, options.outputDir, options);
+}
+/** Pick the right template for a site tool based on its type. */
+function getSiteToolTemplate(tool) {
+    switch (tool.toolType) {
+        case 'browser-lifecycle':
+            return 'tool-handler-lifecycle.ts';
+        case 'page-action':
+            return 'tool-handler-form.ts';
+        case 'element-action':
+        case 'navigation':
+            return 'tool-handler-action.ts';
+        default:
+            return 'tool-handler-action.ts';
+    }
+}
+/**
+ * Emit a Python MCP server project.
+ * Generates a single server.py file with all tools, plus requirements.txt.
+ */
+export async function emitPythonProject(manifest, options) {
+    if (!/^[a-z0-9][a-z0-9._-]*$/.test(manifest.serverName)) {
+        throw new Error(`Invalid server name: "${manifest.serverName}". Must match /^[a-z0-9][a-z0-9._-]*$/`);
+    }
+    const units = [];
+    const templateData = {
+        ...manifest,
+        authEnvVars: manifest.envVars.filter((v) => v.name !== 'BASE_URL'),
+    };
+    units.push({
+        filePath: 'server.py',
+        content: renderPythonTemplate('server.py', templateData),
+    });
+    units.push({
+        filePath: 'requirements.txt',
+        content: renderPythonTemplate('requirements.txt', manifest),
+    });
+    units.push({
+        filePath: '.env.example',
+        content: renderPythonTemplate('env.example', templateData),
+    });
+    if (manifest.transport === 'http') {
+        units.push({
+            filePath: 'Dockerfile',
+            content: renderPythonTemplate('dockerfile', manifest),
+        });
+    }
+    logger.info(`Writing ${units.length} Python files to ${options.outputDir}`);
+    await writeCodeUnits(units, options.outputDir, options);
+}

package/dist/emitter/mcpb-bundler.d.ts

@@ -0,0 +1,31 @@
+export interface McpbManifest {
+    schema_version: string;
+    name: string;
+    version: string;
+    description: string;
+    author: string;
+    license: string;
+    runtime: string;
+    entry_point: string;
+    tools: {
+        name: string;
+        description: string;
+    }[];
+    env_vars: {
+        name: string;
+        description: string;
+        required: boolean;
+    }[];
+}
+/**
+ * Generate an .mcpb bundle from a built MCP server project.
+ *
+ * The bundle is a zip file containing:
+ *   manifest.json  - metadata, tool list, config schema
+ *   server/        - the Node.js server code (package.json, dist/, node_modules/)
+ */
+export declare function generateMcpb(opts: {
+    projectDir: string;
+    outputPath?: string;
+    manifest?: Partial<McpbManifest>;
+}): Promise<string>;

package/dist/emitter/mcpb-bundler.js

@@ -0,0 +1,172 @@
+import { readFile, readdir, mkdtemp, rm, cp, writeFile } from 'node:fs/promises';
+import { resolve, join, basename } from 'node:path';
+import { tmpdir } from 'node:os';
+import { execFile as execFileCb } from 'node:child_process';
+import { promisify } from 'node:util';
+import { logger } from '../utils/logger.js';
+import { pathExists } from '../utils/fs.js';
+const execFile = promisify(execFileCb);
+/**
+ * Generate an .mcpb bundle from a built MCP server project.
+ *
+ * The bundle is a zip file containing:
+ *   manifest.json  - metadata, tool list, config schema
+ *   server/        - the Node.js server code (package.json, dist/, node_modules/)
+ */
+export async function generateMcpb(opts) {
+    const { projectDir } = opts;
+    // Validate project structure
+    const pkgPath = resolve(projectDir, 'package.json');
+    if (!(await pathExists(pkgPath))) {
+        throw new Error(`Not a valid project directory (no package.json): ${projectDir}`);
+    }
+    const distDir = resolve(projectDir, 'dist');
+    if (!(await pathExists(distDir))) {
+        throw new Error(`No dist/ directory found. Build the project first: cd ${projectDir} && npm run build`);
+    }
+    // Read project metadata
+    const pkgJson = JSON.parse(await readFile(pkgPath, 'utf-8'));
+    const projectName = pkgJson.name ?? 'mcp-server';
+    const projectVersion = pkgJson.version ?? '1.0.0';
+    const projectDescription = pkgJson.description ?? '';
+    // Extract tool list (reuse same strategies as publish.ts)
+    const tools = await extractToolList(projectDir);
+    // Extract env vars from .env.example
+    const envVars = await extractEnvVars(projectDir);
+    // Build the manifest
+    const manifest = {
+        schema_version: '1.0',
+        name: opts.manifest?.name ?? projectName,
+        version: opts.manifest?.version ?? projectVersion,
+        description: opts.manifest?.description ?? projectDescription,
+        author: opts.manifest?.author ?? '',
+        license: opts.manifest?.license ?? 'proprietary',
+        runtime: opts.manifest?.runtime ?? 'node',
+        entry_point: opts.manifest?.entry_point ?? 'server/dist/index.js',
+        tools: opts.manifest?.tools ?? tools,
+        env_vars: opts.manifest?.env_vars ?? envVars,
+    };
+    // Create temp staging directory
+    const stagingDir = await mkdtemp(join(tmpdir(), 'mcpb-'));
+    try {
+        // Create server/ subdirectory with the project contents
+        const serverDir = join(stagingDir, 'server');
+        // Copy dist/
+        await cp(resolve(projectDir, 'dist'), join(serverDir, 'dist'), { recursive: true });
+        // Copy package.json (stripped to essentials)
+        const minimalPkg = {
+            name: pkgJson.name,
+            version: pkgJson.version,
+            description: pkgJson.description,
+            type: pkgJson.type,
+            main: pkgJson.main,
+            dependencies: pkgJson.dependencies,
+        };
+        await writeFile(join(serverDir, 'package.json'), JSON.stringify(minimalPkg, null, 2), 'utf-8');
+        // Copy node_modules/ if present
+        const nodeModulesDir = resolve(projectDir, 'node_modules');
+        if (await pathExists(nodeModulesDir)) {
+            await cp(nodeModulesDir, join(serverDir, 'node_modules'), { recursive: true });
+        }
+        // Write manifest.json at root of the bundle
+        await writeFile(join(stagingDir, 'manifest.json'), JSON.stringify(manifest, null, 2), 'utf-8');
+        // Determine output path
+        const outputPath = opts.outputPath ?? resolve(projectDir, '..', `${basename(projectDir)}.mcpb`);
+        // Create the zip archive using the system zip command
+        await execFile('zip', ['-r', '-q', resolve(outputPath), '.'], {
+            cwd: stagingDir,
+        });
+        return outputPath;
+    }
+    finally {
+        // Clean up staging directory
+        await rm(stagingDir, { recursive: true, force: true });
+    }
+}
+/**
+ * Extract tool names and descriptions from a generated project.
+ * Tries tool-catalog.json first, then scans src/tools/*.ts files.
+ */
+async function extractToolList(projectDir) {
+    // Strategy 1: tool-catalog.json (dynamic discovery projects)
+    const catalogPath = resolve(projectDir, 'src/tool-catalog.json');
+    if (await pathExists(catalogPath)) {
+        try {
+            const catalog = JSON.parse(await readFile(catalogPath, 'utf-8'));
+            if (Array.isArray(catalog)) {
+                return catalog.map((entry) => ({
+                    name: entry.name,
+                    description: entry.description ?? entry.title ?? '',
+                }));
+            }
+        }
+        catch {
+            logger.warn('Failed to parse tool-catalog.json, falling back to tool file scanning');
+        }
+    }
+    // Strategy 2: Parse individual tool handler files in src/tools/
+    const toolsDir = resolve(projectDir, 'src/tools');
+    if (!(await pathExists(toolsDir))) {
+        return [];
+    }
+    const tools = [];
+    let entries;
+    try {
+        entries = await readdir(toolsDir);
+    }
+    catch {
+        return [];
+    }
+    for (const file of entries) {
+        if (file === 'index.ts' || !file.endsWith('.ts'))
+            continue;
+        try {
+            const content = await readFile(join(toolsDir, file), 'utf-8');
+            const nameMatch = content.match(/registerTool\(\s*['"]([^'"]+)['"]/);
+            if (!nameMatch)
+                continue;
+            const descMatch = content.match(/description:\s*[`'"]([^`'"]*)[`'"]/);
+            tools.push({
+                name: nameMatch[1],
+                description: descMatch ? descMatch[1] : '',
+            });
+        }
+        catch {
+            // skip files that can't be read
+        }
+    }
+    return tools;
+}
+/**
+ * Extract environment variable definitions from .env.example.
+ * Each line is expected to be: VAR_NAME=value  # optional comment
+ */
+async function extractEnvVars(projectDir) {
+    const envPath = resolve(projectDir, '.env.example');
+    if (!(await pathExists(envPath))) {
+        return [];
+    }
+    const content = await readFile(envPath, 'utf-8');
+    const vars = [];
+    for (const line of content.split('\n')) {
+        const trimmed = line.trim();
+        if (!trimmed || trimmed.startsWith('#'))
+            continue;
+        const eqIndex = trimmed.indexOf('=');
+        if (eqIndex === -1)
+            continue;
+        const name = trimmed.slice(0, eqIndex).trim();
+        if (!name)
+            continue;
+        // Extract inline comment as description
+        const valuePart = trimmed.slice(eqIndex + 1);
+        const commentIndex = valuePart.indexOf('#');
+        const description = commentIndex >= 0 ? valuePart.slice(commentIndex + 1).trim() : '';
+        vars.push({
+            name,
+            description,
+            required: true,
+        });
+    }
+    return vars;
+}

package/dist/emitter/project-scaffolder.d.ts

@@ -0,0 +1,4 @@
+import type { ProjectManifest } from '../types/index.js';
+import type { CodeUnit } from './code-writer.js';
+export declare function scaffoldProjectFiles(manifest: ProjectManifest): CodeUnit[];
+export declare function scaffoldSharedModules(manifest: ProjectManifest): CodeUnit[];

package/dist/emitter/project-scaffolder.js

@@ -0,0 +1,89 @@
+import { renderTemplate } from './template-loader.js';
+/**
+ * At/above this tool count, registering every tool upfront is a real token-cost
+ * problem; the README recommends `--dynamic-discovery` (the #1 buyer concern).
+ */
+const DISCOVERY_RECOMMEND_THRESHOLD = 50;
+export function scaffoldProjectFiles(manifest) {
+    const dynamicDiscovery = manifest.dynamicDiscovery ?? false;
+    const units = [
+        {
+            filePath: 'package.json',
+            content: renderTemplate('package.json', manifest),
+        },
+        {
+            filePath: 'tsconfig.json',
+            content: renderTemplate('tsconfig.json', manifest),
+        },
+        {
+            filePath: '.env.example',
+            content: renderTemplate('env.example', {
+                ...manifest,
+                authEnvVars: manifest.envVars.filter((v) => v.name !== 'BASE_URL'),
+            }),
+        },
+        {
+            filePath: '.gitignore',
+            content: renderTemplate('gitignore', manifest),
+        },
+        {
+            filePath: 'README.md',
+            content: renderTemplate('readme.md', {
+                ...manifest,
+                authEnvVars: manifest.envVars.filter((v) => v.name !== 'BASE_URL'),
+                dynamicDiscovery,
+                recommendDiscovery: !dynamicDiscovery && manifest.tools.length >= DISCOVERY_RECOMMEND_THRESHOLD,
+            }),
+        },
+    ];
+    if (manifest.transport === 'http') {
+        units.push({
+            filePath: 'Dockerfile',
+            content: renderTemplate('dockerfile', manifest),
+        });
+    }
+    return units;
+}
+export function scaffoldSharedModules(manifest) {
+    const hasOAuth = manifest.authSchemes.some((s) => s.type === 'oauth2');
+    const hasDynamicDiscovery = manifest.dynamicDiscovery ?? false;
+    const hasStaticTools = !hasDynamicDiscovery || (manifest.staticToolCount ?? 0) > 0;
+    const hasAsyncTools = manifest.tools.some((t) => t.isAsync);
+    const templateData = {
+        ...manifest,
+        hasResources: (manifest.resources?.length ?? 0) > 0,
+        hasPrompts: (manifest.prompts?.length ?? 0) > 0,
+        hasOAuth,
+        hasDynamicDiscovery,
+        hasStaticTools,
+        hasAsyncTools,
+    };
+    return [
+        {
+            filePath: 'src/index.ts',
+            content: renderTemplate(manifest.transport === 'http' ? 'server-main-http.ts' : 'server-main.ts', templateData),
+        },
+        {
+            filePath: 'src/config.ts',
+            content: renderTemplate('config.ts', manifest),
+        },
+        {
+            filePath: 'src/auth.ts',
+            content: renderTemplate('auth-provider.ts', templateData),
+        },
+        {
+            filePath: 'src/http.ts',
+            content: renderTemplate('http-executor.ts', manifest),
+        },
+        {
+            // W3C Trace Context — the executor stamps the active traceparent onto
+            // upstream calls; the HTTP server establishes the context per request.
+            filePath: 'src/trace.ts',
+            content: renderTemplate('trace.ts', manifest),
+        },
+        {
+            filePath: 'src/types.ts',
+            content: renderTemplate('types.ts', manifest),
+        },
+    ];
+}

package/dist/emitter/python-template-loader.d.ts

@@ -0,0 +1,4 @@
+/**
+ * Template loader for Python MCP server templates.
+ */
+export declare function renderPythonTemplate(name: string, data: any): string;

package/dist/emitter/python-template-loader.js

@@ -0,0 +1,30 @@
+/**
+ * Template loader for Python MCP server templates.
+ */
+import { readFileSync } from 'node:fs';
+import { resolve, dirname } from 'node:path';
+import { fileURLToPath } from 'node:url';
+import Handlebars from 'handlebars';
+const __dirname = dirname(fileURLToPath(import.meta.url));
+const PYTHON_TEMPLATE_DIR = resolve(__dirname, 'python-templates');
+const pythonTemplateCache = new Map();
+Handlebars.registerHelper('eq', function (a, b) {
+    return a === b;
+});
+Handlebars.registerHelper('pyDocstring', function (str) {
+    if (!str)
+        return '';
+    return str.replace(/"""/g, '\\"\\"\\"').replace(/\\/g, '\\\\');
+});
+// eslint-disable-next-line @typescript-eslint/no-explicit-any
+export function renderPythonTemplate(name, data) {
+    if (!pythonTemplateCache.has(name)) {
+        const templatePath = resolve(PYTHON_TEMPLATE_DIR, `${name}.hbs`);
+        if (!templatePath.startsWith(PYTHON_TEMPLATE_DIR + '/')) {
+            throw new Error(`Invalid python template name: ${name}`);
+        }
+        const raw = readFileSync(templatePath, 'utf-8');
+        pythonTemplateCache.set(name, Handlebars.compile(raw, { noEscape: true }));
+    }
+    return pythonTemplateCache.get(name)(data);
+}

package/dist/emitter/python-templates/dockerfile.hbs

@@ -0,0 +1,14 @@
+FROM python:3.12-slim
+
+WORKDIR /app
+COPY requirements.txt .
+RUN pip install --no-cache-dir -r requirements.txt
+COPY server.py .
+COPY .env.example .env
+
+ENV TRANSPORT=http
+ENV PORT=3000
+
+EXPOSE 3000
+
+CMD ["python", "server.py"]

package/dist/emitter/python-templates/env.example.hbs

@@ -0,0 +1,6 @@
+# {{serverName}} configuration
+BASE_URL={{{baseUrl}}}
+{{#each authEnvVars}}
+# {{description}}
+{{name}}=
+{{/each}}

package/dist/emitter/python-templates/requirements.txt.hbs

@@ -0,0 +1,4 @@
+mcp>=1.0.0
+httpx>=0.27.0
+pydantic>=2.0.0
+python-dotenv>=1.0.0