mcpmake 0.1.1 → 0.2.0

package/dist/cloud/billing/usage-store.js

@@ -1,85 +0,0 @@
-/**
- * Durable per-user usage accounting tied to a billing period.
- *
- * Records tool calls (and total requests) for the served MCP traffic so that
- * quota can be enforced and usage survives process restarts. Backed by the
- * `usage_summaries` Postgres table when a database is configured; otherwise an
- * in-memory fallback is used (dev / single-process).
- */
-import { randomBytes } from 'node:crypto';
-/**
- * Compute the billing period containing `now`.
- *
- * When `anchorEndMs` (a Stripe subscription's current_period_end) is provided
- * and in the future, the period is the month ending at that anchor; otherwise
- * it falls back to the calendar month (UTC). Calendar-month alignment is a safe
- * default for the free tier and approximates monthly subscriptions closely.
- */
-export function getBillingPeriod(now = new Date(), anchorEndMs) {
-    if (anchorEndMs && anchorEndMs > now.getTime()) {
-        const end = new Date(anchorEndMs);
-        // Compute "one month before end" without JS month-overflow. Using
-        // setUTCMonth(-1) on e.g. Mar 31 yields Mar 3 (Feb has no 31st), which would
-        // leave a 2–3 day gap where usage is keyed to a different period and quota
-        // appears to reset. Clamp the day to the target month's length instead.
-        const targetMonthIndex = end.getUTCMonth() - 1;
-        const year = targetMonthIndex < 0 ? end.getUTCFullYear() - 1 : end.getUTCFullYear();
-        const month = ((targetMonthIndex % 12) + 12) % 12;
-        const daysInTarget = new Date(Date.UTC(year, month + 1, 0)).getUTCDate();
-        const day = Math.min(end.getUTCDate(), daysInTarget);
-        const start = new Date(Date.UTC(year, month, day, end.getUTCHours(), end.getUTCMinutes(), end.getUTCSeconds(), end.getUTCMilliseconds()));
-        if (start.getTime() <= now.getTime()) {
-            return { start: start.toISOString(), end: end.toISOString() };
-        }
-    }
-    const start = new Date(Date.UTC(now.getUTCFullYear(), now.getUTCMonth(), 1));
-    const end = new Date(Date.UTC(now.getUTCFullYear(), now.getUTCMonth() + 1, 1));
-    return { start: start.toISOString(), end: end.toISOString() };
-}
-// ---------------------------------------------------------------------------
-// In-memory implementation (dev / no database)
-// ---------------------------------------------------------------------------
-const MAX_INMEMORY_KEYS = 50_000;
-export class InMemoryUsageStore {
-    counts = new Map();
-    key(userId, period) {
-        return `${userId}::${period.start}`;
-    }
-    async record(userId, period, toolCalls, requests) {
-        if (this.counts.size > MAX_INMEMORY_KEYS) {
-            // Drop the oldest-inserted half to bound memory.
-            const keep = Math.floor(MAX_INMEMORY_KEYS / 2);
-            this.counts = new Map([...this.counts].slice(-keep));
-        }
-        const k = this.key(userId, period);
-        const entry = this.counts.get(k) ?? { toolCalls: 0, requests: 0 };
-        entry.toolCalls += toolCalls;
-        entry.requests += requests;
-        this.counts.set(k, entry);
-    }
-    async getToolCalls(userId, period) {
-        return this.counts.get(this.key(userId, period))?.toolCalls ?? 0;
-    }
-}
-// ---------------------------------------------------------------------------
-// Postgres implementation
-// ---------------------------------------------------------------------------
-export class PgUsageStore {
-    db;
-    constructor(db) {
-        this.db = db;
-    }
-    async record(userId, period, toolCalls, requests) {
-        await this.db.query(`INSERT INTO usage_summaries (id, user_id, period_start, period_end, request_count, tool_calls)
-       VALUES ($1, $2, $3, $4, $5, $6)
-       ON CONFLICT (user_id, period_start)
-       DO UPDATE SET request_count = usage_summaries.request_count + EXCLUDED.request_count,
-                     tool_calls    = usage_summaries.tool_calls + EXCLUDED.tool_calls`, [randomBytes(16).toString('hex'), userId, period.start, period.end, requests, toolCalls]);
-    }
-    async getToolCalls(userId, period) {
-        const { rows } = await this.db.query(`SELECT COALESCE(SUM(tool_calls), 0) AS calls
-       FROM usage_summaries WHERE user_id = $1 AND period_start = $2`, [userId, period.start]);
-        const value = rows[0]?.calls ?? 0;
-        return typeof value === 'number' ? value : parseInt(value, 10) || 0;
-    }
-}

package/dist/cloud/billing/usage-tracker.d.ts

@@ -1,38 +0,0 @@
-export type UsageEventType = 'session-start' | 'session-end' | 'tool-call' | 'screenshot';
-export interface UsageEvent {
-    userId: string;
-    slug: string;
-    eventType: UsageEventType;
-    timestamp: Date;
-    /** Duration in milliseconds (for session-end events) */
-    durationMs?: number;
-    /** Extra metadata */
-    metadata?: Record<string, unknown>;
-}
-export interface UsageSummary {
-    userId: string;
-    totalSessionsMs: number;
-    totalToolCalls: number;
-    totalScreenshots: number;
-    /** Usage broken down by site slug */
-    bySlug: Map<string, {
-        sessionsMs: number;
-        toolCalls: number;
-        screenshots: number;
-    }>;
-}
-export declare class UsageTracker {
-    private events;
-    private activeSessions;
-    private appendEvent;
-    /** Start a new session for a user + site slug. Returns a session key. */
-    startSession(userId: string, slug: string): string;
-    /** End an active session. Records the duration. */
-    endSession(sessionKey: string): void;
-    /** Record a tool call event. */
-    recordToolCall(userId: string, slug: string, metadata?: Record<string, unknown>): void;
-    /** Record a screenshot capture event. */
-    recordScreenshot(userId: string, slug: string, metadata?: Record<string, unknown>): void;
-    /** Get a usage summary for a specific user. */
-    getUsageSummary(userId: string): UsageSummary;
-}

package/dist/cloud/billing/usage-tracker.js

@@ -1,95 +0,0 @@
-/**
- * In-memory usage tracker for billing purposes.
- * Tracks sessions, tool calls, and screenshots per user/slug.
- */
-const MAX_EVENTS = 50_000;
-export class UsageTracker {
-    events = [];
-    activeSessions = new Map();
-    appendEvent(event) {
-        this.events.push(event);
-        if (this.events.length > MAX_EVENTS) {
-            // Keep the newest half to avoid unbounded memory growth
-            this.events = this.events.slice(-Math.floor(MAX_EVENTS / 2));
-        }
-    }
-    /** Start a new session for a user + site slug. Returns a session key. */
-    startSession(userId, slug) {
-        const key = `${userId}:${slug}:${Date.now()}`;
-        this.activeSessions.set(key, { userId, slug, startedAt: new Date() });
-        this.appendEvent({
-            userId,
-            slug,
-            eventType: 'session-start',
-            timestamp: new Date(),
-        });
-        return key;
-    }
-    /** End an active session. Records the duration. */
-    endSession(sessionKey) {
-        const session = this.activeSessions.get(sessionKey);
-        if (!session)
-            return;
-        const durationMs = Date.now() - session.startedAt.getTime();
-        this.appendEvent({
-            userId: session.userId,
-            slug: session.slug,
-            eventType: 'session-end',
-            timestamp: new Date(),
-            durationMs,
-        });
-        this.activeSessions.delete(sessionKey);
-    }
-    /** Record a tool call event. */
-    recordToolCall(userId, slug, metadata) {
-        this.appendEvent({
-            userId,
-            slug,
-            eventType: 'tool-call',
-            timestamp: new Date(),
-            metadata,
-        });
-    }
-    /** Record a screenshot capture event. */
-    recordScreenshot(userId, slug, metadata) {
-        this.appendEvent({
-            userId,
-            slug,
-            eventType: 'screenshot',
-            timestamp: new Date(),
-            metadata,
-        });
-    }
-    /** Get a usage summary for a specific user. */
-    getUsageSummary(userId) {
-        const userEvents = this.events.filter((e) => e.userId === userId);
-        const bySlug = new Map();
-        let totalSessionsMs = 0;
-        let totalToolCalls = 0;
-        let totalScreenshots = 0;
-        for (const event of userEvents) {
-            let slugEntry = bySlug.get(event.slug);
-            if (!slugEntry) {
-                slugEntry = { sessionsMs: 0, toolCalls: 0, screenshots: 0 };
-                bySlug.set(event.slug, slugEntry);
-            }
-            switch (event.eventType) {
-                case 'session-end':
-                    if (event.durationMs != null) {
-                        totalSessionsMs += event.durationMs;
-                        slugEntry.sessionsMs += event.durationMs;
-                    }
-                    break;
-                case 'tool-call':
-                    totalToolCalls++;
-                    slugEntry.toolCalls++;
-                    break;
-                case 'screenshot':
-                    totalScreenshots++;
-                    slugEntry.screenshots++;
-                    break;
-            }
-        }
-        return { userId, totalSessionsMs, totalToolCalls, totalScreenshots, bySlug };
-    }
-}

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

@@ -1,39 +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.
- */
-export interface BuildResult {
-    slug: string;
-    imageName: string;
-    imageTag: string;
-    buildDir: string;
-    toolCount: number;
-    /** Detected server type based on project dependencies. */
-    serverType: 'http' | 'playwright';
-}
-export interface BuildOptions {
-    name?: string;
-    format: 'openapi' | 'har';
-}
-/**
- * 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 declare function buildFromSpec(specPath: string, opts: BuildOptions): Promise<BuildResult>;
-/**
- * Detect the spec format from a file path.
- */
-export declare function detectFormat(filePath: string, contentType?: string): 'openapi' | 'har';
-/**
- * Detect format by inspecting file content.
- * Useful when the file extension is ambiguous (e.g., .json).
- */
-export declare function detectFormatFromContent(filePath: string): Promise<'openapi' | 'har'>;

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>;