mcpmake 0.1.1 → 0.2.1

package/dist/cloud/mailer.js

@@ -1,193 +0,0 @@
-/**
- * Minimal email sender for transactional emails (password reset, etc.).
- *
- * Supports two modes:
- *   1. Console (default) — logs the email to stdout. Useful for development
- *      and self-hosted instances without email infrastructure.
- *   2. SMTP — sends via an external SMTP relay. Requires env vars:
- *        SMTP_HOST, SMTP_PORT, SMTP_USER, SMTP_PASS, MAIL_FROM
- *
- * Uses Node.js built-in `net`/`tls` modules — zero external dependencies.
- */
-import { createConnection } from 'node:net';
-import { connect as tlsConnect } from 'node:tls';
-import { logger } from '../utils/logger.js';
-/**
- * Send an email. Falls back to console logging when SMTP is not configured.
- */
-export async function sendMail(options) {
-    const host = process.env.SMTP_HOST;
-    if (!host) {
-        logger.info(`[mailer] No SMTP configured — logging email to console`);
-        logger.info(`[mailer] To: ${options.to}`);
-        logger.info(`[mailer] Subject: ${options.subject}`);
-        logger.info(`[mailer] Body:\n${options.text}`);
-        return;
-    }
-    await sendSmtp(options);
-}
-// ---------------------------------------------------------------------------
-// Minimal SMTP client (STARTTLS on 587, implicit TLS on 465, plain on 25)
-// ---------------------------------------------------------------------------
-async function sendSmtp(options) {
-    const host = process.env.SMTP_HOST;
-    const port = parseInt(process.env.SMTP_PORT ?? '587', 10);
-    const user = process.env.SMTP_USER ?? '';
-    const pass = process.env.SMTP_PASS ?? '';
-    const from = process.env.MAIL_FROM ?? 'noreply@mcpmake.dev';
-    const implicitTls = port === 465;
-    const boundary = `----mcpmake${Date.now()}`;
-    const body = options.html
-        ? [
-            `MIME-Version: 1.0`,
-            `Content-Type: multipart/alternative; boundary="${boundary}"`,
-            ``,
-            `--${boundary}`,
-            `Content-Type: text/plain; charset=utf-8`,
-            ``,
-            options.text,
-            `--${boundary}`,
-            `Content-Type: text/html; charset=utf-8`,
-            ``,
-            options.html,
-            `--${boundary}--`,
-        ].join('\r\n')
-        : options.text;
-    const message = [
-        `From: ${from}`,
-        `To: ${options.to}`,
-        `Subject: ${options.subject}`,
-        `Date: ${new Date().toUTCString()}`,
-        ...(options.html ? [] : [`MIME-Version: 1.0`, `Content-Type: text/plain; charset=utf-8`]),
-        ``,
-        body,
-    ].join('\r\n');
-    return new Promise((resolve, reject) => {
-        const timeout = setTimeout(() => {
-            reject(new Error('SMTP timeout after 30s'));
-        }, 30_000);
-        let socket;
-        let buffer = '';
-        function cleanup() {
-            clearTimeout(timeout);
-            socket?.removeAllListeners();
-            socket?.destroy();
-        }
-        function readLine() {
-            return new Promise((res) => {
-                const check = () => {
-                    const idx = buffer.indexOf('\r\n');
-                    if (idx !== -1) {
-                        const line = buffer.slice(0, idx);
-                        buffer = buffer.slice(idx + 2);
-                        res(line);
-                    }
-                    else {
-                        socket.once('data', (chunk) => {
-                            buffer += chunk.toString();
-                            check();
-                        });
-                    }
-                };
-                check();
-            });
-        }
-        async function waitReply() {
-            let full = '';
-            // eslint-disable-next-line no-constant-condition
-            while (true) {
-                const line = await readLine();
-                full += line + '\r\n';
-                // Multi-line replies have "-" after the code, last line has " "
-                if (line.length >= 4 && line[3] === ' ') {
-                    return { code: parseInt(line.slice(0, 3), 10), text: full };
-                }
-            }
-        }
-        function send(cmd) {
-            socket.write(cmd + '\r\n');
-        }
-        async function run() {
-            // Greeting
-            await waitReply();
-            send(`EHLO mcpmake`);
-            await waitReply();
-            // STARTTLS for port 587
-            if (!implicitTls && port === 587) {
-                send('STARTTLS');
-                const tlsReply = await waitReply();
-                if (tlsReply.code !== 220) {
-                    throw new Error(`STARTTLS failed: ${tlsReply.text}`);
-                }
-                // Upgrade socket to TLS
-                const tlsSocket = tlsConnect({ socket, host, servername: host });
-                await new Promise((res, rej) => {
-                    tlsSocket.once('secureConnect', res);
-                    tlsSocket.once('error', rej);
-                });
-                socket = tlsSocket;
-                buffer = '';
-                send(`EHLO mcpmake`);
-                await waitReply();
-            }
-            // AUTH LOGIN
-            if (user && pass) {
-                send('AUTH LOGIN');
-                const authReply = await waitReply();
-                if (authReply.code !== 334) {
-                    throw new Error(`AUTH LOGIN rejected: ${authReply.text}`);
-                }
-                send(Buffer.from(user).toString('base64'));
-                await waitReply();
-                send(Buffer.from(pass).toString('base64'));
-                const loginReply = await waitReply();
-                if (loginReply.code !== 235) {
-                    throw new Error(`SMTP authentication failed: ${loginReply.text}`);
-                }
-            }
-            send(`MAIL FROM:<${from}>`);
-            const fromReply = await waitReply();
-            if (fromReply.code !== 250) {
-                throw new Error(`MAIL FROM rejected: ${fromReply.text}`);
-            }
-            send(`RCPT TO:<${options.to}>`);
-            const toReply = await waitReply();
-            if (toReply.code !== 250) {
-                throw new Error(`RCPT TO rejected: ${toReply.text}`);
-            }
-            send('DATA');
-            const dataReply = await waitReply();
-            if (dataReply.code !== 354) {
-                throw new Error(`DATA rejected: ${dataReply.text}`);
-            }
-            send(message + '\r\n.');
-            const msgReply = await waitReply();
-            if (msgReply.code !== 250) {
-                throw new Error(`Message rejected: ${msgReply.text}`);
-            }
-            send('QUIT');
-            cleanup();
-            resolve();
-        }
-        if (implicitTls) {
-            socket = tlsConnect({ host, port }, () => {
-                run().catch((err) => {
-                    cleanup();
-                    reject(err);
-                });
-            });
-        }
-        else {
-            socket = createConnection({ host, port }, () => {
-                run().catch((err) => {
-                    cleanup();
-                    reject(err);
-                });
-            });
-        }
-        socket.on('error', (err) => {
-            cleanup();
-            reject(new Error(`SMTP connection error: ${err.message}`));
-        });
-    });
-}

package/dist/cloud/mcp-proxy.d.ts

@@ -1,58 +0,0 @@
-/**
- * Backend reverse-proxy for served MCP traffic.
- *
- * Each hosted server is reached at `{slug}.{domain}`. Caddy proxies the
- * wildcard subdomain to this backend (port 3001); the backend is the single
- * authoritative entry point: it validates the hashed `mf_` bearer token,
- * enforces quota, meters usage, and streams the request through to the
- * container listening on `127.0.0.1:{port}`.
- *
- * This resolves the data-path question in the launch plan: Caddy routes the
- * wildcard to the backend, the backend authenticates + meters, and the
- * container (which also validates MCP_AUTH_TOKEN) is the in-depth backstop.
- */
-import http from 'node:http';
-/** Body buffered for metering must never exceed this (MCP JSON-RPC is small). */
-export declare const MAX_PROXY_BODY: number;
-/**
- * Extract the server slug from a Host header given the apex domain.
- *
- * Returns the slug for `{slug}.{domain}` hosts, or null for the apex domain,
- * `www`, multi-label subdomains, or anything that isn't a valid slug.
- */
-export declare function extractSlug(host: string | undefined, domain: string): string | null;
-export type AuthResult = {
-    ok: true;
-} | {
-    ok: false;
-    status: number;
-    error: string;
-};
-/**
- * Validate the request's bearer token against a server's stored SHA-256 hash.
- */
-export declare function authorizeBearer(req: http.IncomingMessage, tokenHash: string): AuthResult;
-/**
- * Read a request body up to MAX_PROXY_BODY. Resolves `null` if the limit is
- * exceeded (caller should respond 413). Returns an empty buffer for bodyless
- * methods without touching the stream.
- */
-export declare function readBoundedBody(req: http.IncomingMessage): Promise<Buffer | null>;
-/**
- * Count billable tool calls in an MCP JSON-RPC request body, and surface the
- * primary tool name (for metrics). Best-effort: malformed bodies count as zero.
- */
-export declare function inspectMcpBody(body: Buffer | undefined, contentType: string | undefined): {
-    toolCalls: number;
-    primaryTool?: string;
-};
-/**
- * Stream-proxy a request to a local container upstream, preserving method,
- * headers, body, and streaming the response (including long-lived SSE).
- *
- * @param bufferedBody Pre-read request body to forward (empty for GET/DELETE).
- */
-export declare function proxyToUpstream(req: http.IncomingMessage, res: http.ServerResponse, upstreamPort: number, bufferedBody: Buffer, opts?: {
-    host?: string;
-    timeoutMs?: number;
-}): Promise<void>;

package/dist/cloud/mcp-proxy.js

@@ -1,203 +0,0 @@
-/**
- * Backend reverse-proxy for served MCP traffic.
- *
- * Each hosted server is reached at `{slug}.{domain}`. Caddy proxies the
- * wildcard subdomain to this backend (port 3001); the backend is the single
- * authoritative entry point: it validates the hashed `mf_` bearer token,
- * enforces quota, meters usage, and streams the request through to the
- * container listening on `127.0.0.1:{port}`.
- *
- * This resolves the data-path question in the launch plan: Caddy routes the
- * wildcard to the backend, the backend authenticates + meters, and the
- * container (which also validates MCP_AUTH_TOKEN) is the in-depth backstop.
- */
-import http from 'node:http';
-import { verifyToken } from './security.js';
-/** Body buffered for metering must never exceed this (MCP JSON-RPC is small). */
-export const MAX_PROXY_BODY = 8 * 1024 * 1024; // 8 MB
-/** Methods that carry a request body we need to buffer for metering. */
-const BODY_METHODS = new Set(['POST', 'PUT', 'PATCH']);
-/** Hop-by-hop headers that must not be forwarded through a proxy (RFC 7230 §6.1). */
-const HOP_BY_HOP = new Set([
-    'connection',
-    'keep-alive',
-    'proxy-authenticate',
-    'proxy-authorization',
-    'te',
-    'trailers',
-    'transfer-encoding',
-    'upgrade',
-]);
-/**
- * Extract the server slug from a Host header given the apex domain.
- *
- * Returns the slug for `{slug}.{domain}` hosts, or null for the apex domain,
- * `www`, multi-label subdomains, or anything that isn't a valid slug.
- */
-export function extractSlug(host, domain) {
-    if (!host)
-        return null;
-    let h = host.trim().toLowerCase();
-    if (!h)
-        return null;
-    // Strip a trailing :port (ignore IPv6 brackets — server hosts are never IPv6 here)
-    if (h.startsWith('['))
-        return null;
-    const colon = h.lastIndexOf(':');
-    if (colon !== -1)
-        h = h.slice(0, colon);
-    const suffix = '.' + domain.trim().toLowerCase();
-    if (!h.endsWith(suffix))
-        return null;
-    const label = h.slice(0, -suffix.length);
-    if (!label || label === 'www' || label.includes('.'))
-        return null;
-    if (!/^[a-z0-9][a-z0-9-]*$/.test(label))
-        return null;
-    return label;
-}
-/**
- * Validate the request's bearer token against a server's stored SHA-256 hash.
- */
-export function authorizeBearer(req, tokenHash) {
-    const header = req.headers.authorization;
-    if (!header || !header.startsWith('Bearer ')) {
-        return { ok: false, status: 401, error: 'Missing or invalid Authorization header' };
-    }
-    const token = header.slice(7).trim();
-    if (!token || !verifyToken(token, tokenHash)) {
-        return { ok: false, status: 403, error: 'Invalid bearer token' };
-    }
-    return { ok: true };
-}
-/**
- * Read a request body up to MAX_PROXY_BODY. Resolves `null` if the limit is
- * exceeded (caller should respond 413). Returns an empty buffer for bodyless
- * methods without touching the stream.
- */
-export function readBoundedBody(req) {
-    if (!BODY_METHODS.has((req.method ?? 'GET').toUpperCase())) {
-        return Promise.resolve(Buffer.alloc(0));
-    }
-    return new Promise((resolve) => {
-        const chunks = [];
-        let total = 0;
-        let settled = false;
-        const finish = (value) => {
-            if (settled)
-                return;
-            settled = true;
-            resolve(value);
-        };
-        req.on('data', (chunk) => {
-            total += chunk.length;
-            if (total > MAX_PROXY_BODY) {
-                finish(null);
-                req.destroy();
-                return;
-            }
-            chunks.push(chunk);
-        });
-        req.on('end', () => finish(Buffer.concat(chunks)));
-        req.on('error', () => finish(null));
-        req.on('aborted', () => finish(null));
-    });
-}
-/**
- * Count billable tool calls in an MCP JSON-RPC request body, and surface the
- * primary tool name (for metrics). Best-effort: malformed bodies count as zero.
- */
-export function inspectMcpBody(body, contentType) {
-    if (!body || body.length === 0)
-        return { toolCalls: 0 };
-    if (contentType && !contentType.includes('json'))
-        return { toolCalls: 0 };
-    let parsed;
-    try {
-        parsed = JSON.parse(body.toString('utf-8'));
-    }
-    catch {
-        return { toolCalls: 0 };
-    }
-    const messages = Array.isArray(parsed) ? parsed : [parsed];
-    let toolCalls = 0;
-    let primaryTool;
-    for (const msg of messages) {
-        if (msg && typeof msg === 'object' && msg.method === 'tools/call') {
-            toolCalls++;
-            const params = msg.params;
-            if (!primaryTool && params && typeof params.name === 'string') {
-                primaryTool = params.name;
-            }
-        }
-    }
-    return { toolCalls, primaryTool };
-}
-/**
- * Stream-proxy a request to a local container upstream, preserving method,
- * headers, body, and streaming the response (including long-lived SSE).
- *
- * @param bufferedBody Pre-read request body to forward (empty for GET/DELETE).
- */
-export function proxyToUpstream(req, res, upstreamPort, bufferedBody, opts = {}) {
-    const host = opts.host ?? '127.0.0.1';
-    const timeoutMs = opts.timeoutMs ?? 120_000;
-    return new Promise((resolve) => {
-        // Clone headers, overriding hop-by-hop / length headers we re-derive.
-        const headers = { ...req.headers };
-        delete headers['content-length'];
-        delete headers['connection'];
-        delete headers['keep-alive'];
-        delete headers['transfer-encoding'];
-        headers.host = `${host}:${upstreamPort}`;
-        const hasBody = BODY_METHODS.has((req.method ?? 'GET').toUpperCase());
-        if (hasBody) {
-            headers['content-length'] = String(bufferedBody.length);
-        }
-        let settled = false;
-        const done = () => {
-            if (settled)
-                return;
-            settled = true;
-            resolve();
-        };
-        const upstream = http.request({ host, port: upstreamPort, method: req.method, path: req.url, headers, timeout: timeoutMs }, (proxyRes) => {
-            // Strip hop-by-hop headers from the upstream response (RFC 7230 §6.1);
-            // Node manages connection framing for our client side independently.
-            const resHeaders = {};
-            for (const [k, v] of Object.entries(proxyRes.headers)) {
-                if (!HOP_BY_HOP.has(k.toLowerCase()) && v !== undefined)
-                    resHeaders[k] = v;
-            }
-            res.writeHead(proxyRes.statusCode ?? 502, resHeaders);
-            proxyRes.pipe(res);
-            proxyRes.on('end', done);
-            proxyRes.on('error', () => {
-                res.destroy();
-                done();
-            });
-        });
-        upstream.on('timeout', () => {
-            upstream.destroy(new Error('upstream timeout'));
-        });
-        upstream.on('error', () => {
-            if (!res.headersSent) {
-                res.writeHead(502, { 'Content-Type': 'application/json' });
-                res.end(JSON.stringify({ error: 'Bad gateway: server is unreachable' }));
-            }
-            else {
-                res.destroy();
-            }
-            done();
-        });
-        // If the client disconnects, tear down the upstream request.
-        res.on('close', () => {
-            if (!settled)
-                upstream.destroy();
-        });
-        if (hasBody)
-            upstream.end(bufferedBody);
-        else
-            upstream.end();
-    });
-}

package/dist/cloud/metric-samples.d.ts

@@ -1,43 +0,0 @@
-/**
- * Durable time-series of host/API metrics for the admin charts.
- *
- * One row is written per sampler tick (every ~5 min by the ResourceMonitor's
- * onSample hook). Backed by the `metric_samples` Postgres table when a database
- * is configured; otherwise a bounded in-memory ring (dev / single-process).
- *
- * `requests`/`errors_*` are PER-INTERVAL deltas (read from the rolling
- * FailureTracker window), not cumulative totals.
- */
-import type { Database } from './db/index.js';
-export interface MetricSample {
-    /** ISO timestamp. */
-    sampledAt: string;
-    requests: number;
-    errors4xx: number;
-    errors5xx: number;
-    activeContainers: number;
-    memUsedPct: number;
-    diskUsedPct: number;
-    totalUsers: number;
-    totalServers: number;
-}
-export interface MetricSampleStore {
-    record(sample: MetricSample): Promise<void>;
-    /** Samples with `sampledAt` within the last `sinceMs`, oldest first. */
-    recent(sinceMs: number): Promise<MetricSample[]>;
-    /** Delete samples older than `olderThanMs`. */
-    prune(olderThanMs: number): Promise<void>;
-}
-export declare class InMemoryMetricSampleStore implements MetricSampleStore {
-    private samples;
-    record(sample: MetricSample): Promise<void>;
-    recent(sinceMs: number): Promise<MetricSample[]>;
-    prune(olderThanMs: number): Promise<void>;
-}
-export declare class PgMetricSampleStore implements MetricSampleStore {
-    private db;
-    constructor(db: Database);
-    record(sample: MetricSample): Promise<void>;
-    recent(sinceMs: number): Promise<MetricSample[]>;
-    prune(olderThanMs: number): Promise<void>;
-}

package/dist/cloud/metric-samples.js

@@ -1,85 +0,0 @@
-/**
- * Durable time-series of host/API metrics for the admin charts.
- *
- * One row is written per sampler tick (every ~5 min by the ResourceMonitor's
- * onSample hook). Backed by the `metric_samples` Postgres table when a database
- * is configured; otherwise a bounded in-memory ring (dev / single-process).
- *
- * `requests`/`errors_*` are PER-INTERVAL deltas (read from the rolling
- * FailureTracker window), not cumulative totals.
- */
-import { randomBytes } from 'node:crypto';
-// ---------------------------------------------------------------------------
-// In-memory (dev / no database) — bounded ring
-// ---------------------------------------------------------------------------
-/** 24h at 5-min cadence. */
-const MAX_INMEMORY_SAMPLES = 288;
-export class InMemoryMetricSampleStore {
-    samples = [];
-    async record(sample) {
-        this.samples.push(sample);
-        if (this.samples.length > MAX_INMEMORY_SAMPLES) {
-            this.samples.splice(0, this.samples.length - MAX_INMEMORY_SAMPLES);
-        }
-    }
-    async recent(sinceMs) {
-        const cutoff = Date.now() - sinceMs;
-        return this.samples.filter((s) => Date.parse(s.sampledAt) >= cutoff);
-    }
-    async prune(olderThanMs) {
-        const cutoff = Date.now() - olderThanMs;
-        this.samples = this.samples.filter((s) => Date.parse(s.sampledAt) >= cutoff);
-    }
-}
-// ---------------------------------------------------------------------------
-// Postgres
-// ---------------------------------------------------------------------------
-export class PgMetricSampleStore {
-    db;
-    constructor(db) {
-        this.db = db;
-    }
-    async record(sample) {
-        await this.db.query(`INSERT INTO metric_samples
-         (id, sampled_at, requests, errors_4xx, errors_5xx, active_containers,
-          mem_used_pct, disk_used_pct, total_users, total_servers)
-       VALUES ($1, $2, $3, $4, $5, $6, $7, $8, $9, $10)`, [
-            randomBytes(16).toString('hex'),
-            sample.sampledAt,
-            sample.requests,
-            sample.errors4xx,
-            sample.errors5xx,
-            sample.activeContainers,
-            sample.memUsedPct,
-            sample.diskUsedPct,
-            sample.totalUsers,
-            sample.totalServers,
-        ]);
-    }
-    async recent(sinceMs) {
-        const since = new Date(Date.now() - sinceMs).toISOString();
-        const { rows } = await this.db.query(`SELECT sampled_at, requests, errors_4xx, errors_5xx, active_containers,
-              mem_used_pct, disk_used_pct, total_users, total_servers
-       FROM metric_samples WHERE sampled_at >= $1 ORDER BY sampled_at ASC`, [since]);
-        return rows.map(rowToSample);
-    }
-    async prune(olderThanMs) {
-        const cutoff = new Date(Date.now() - olderThanMs).toISOString();
-        await this.db.query('DELETE FROM metric_samples WHERE sampled_at < $1', [cutoff]);
-    }
-}
-function rowToSample(row) {
-    const num = (v) => (typeof v === 'number' ? v : Number(v ?? 0));
-    const sampledAt = row.sampled_at;
-    return {
-        sampledAt: typeof sampledAt === 'string' ? sampledAt : new Date(sampledAt).toISOString(),
-        requests: num(row.requests),
-        errors4xx: num(row.errors_4xx),
-        errors5xx: num(row.errors_5xx),
-        activeContainers: num(row.active_containers),
-        memUsedPct: num(row.mem_used_pct),
-        diskUsedPct: num(row.disk_used_pct),
-        totalUsers: num(row.total_users),
-        totalServers: num(row.total_servers),
-    };
-}

package/dist/cloud/metrics.d.ts

@@ -1,26 +0,0 @@
-/**
- * In-memory usage metrics for hosted MCP servers.
- * Tracks request counts, tool call breakdowns, and activity timestamps.
- */
-export interface ServerMetrics {
-    slug: string;
-    totalRequests: number;
-    toolCalls: Record<string, number>;
-    lastActiveAt: string;
-    createdAt: string;
-}
-export declare class MetricsStore {
-    private metrics;
-    init(slug: string): void;
-    recordRequest(slug: string, toolName?: string): void;
-    get(slug: string): ServerMetrics | undefined;
-    getAll(): ServerMetrics[];
-    delete(slug: string): void;
-    /**
-     * Get top tools by call count for a given server.
-     */
-    getTopTools(slug: string, limit?: number): Array<{
-        tool: string;
-        calls: number;
-    }>;
-}

package/dist/cloud/metrics.js

@@ -1,59 +0,0 @@
-/**
- * In-memory usage metrics for hosted MCP servers.
- * Tracks request counts, tool call breakdowns, and activity timestamps.
- */
-export class MetricsStore {
-    metrics = new Map();
-    init(slug) {
-        if (this.metrics.has(slug))
-            return;
-        const now = new Date().toISOString();
-        this.metrics.set(slug, {
-            slug,
-            totalRequests: 0,
-            toolCalls: {},
-            lastActiveAt: now,
-            createdAt: now,
-        });
-    }
-    recordRequest(slug, toolName) {
-        let entry = this.metrics.get(slug);
-        if (!entry) {
-            this.init(slug);
-            entry = this.metrics.get(slug);
-        }
-        entry.totalRequests++;
-        entry.lastActiveAt = new Date().toISOString();
-        if (toolName) {
-            // Only track if the tool is already known or we haven't hit the cap
-            if (toolName in entry.toolCalls || Object.keys(entry.toolCalls).length < 500) {
-                entry.toolCalls[toolName] = (entry.toolCalls[toolName] ?? 0) + 1;
-            }
-        }
-    }
-    get(slug) {
-        const entry = this.metrics.get(slug);
-        return entry ? { ...entry, toolCalls: { ...entry.toolCalls } } : undefined;
-    }
-    getAll() {
-        return [...this.metrics.values()].map((e) => ({
-            ...e,
-            toolCalls: { ...e.toolCalls },
-        }));
-    }
-    delete(slug) {
-        this.metrics.delete(slug);
-    }
-    /**
-     * Get top tools by call count for a given server.
-     */
-    getTopTools(slug, limit = 10) {
-        const entry = this.metrics.get(slug);
-        if (!entry)
-            return [];
-        return Object.entries(entry.toolCalls)
-            .sort(([, a], [, b]) => b - a)
-            .slice(0, limit)
-            .map(([tool, calls]) => ({ tool, calls }));
-    }
-}