mcpmake 0.1.1 → 0.2.1

package/dist/cloud/billing/billing-engine.d.ts

@@ -1,44 +0,0 @@
-export type BillingPlan = 'free' | 'hobbyist' | 'pro' | 'team' | 'enterprise';
-export interface PlanLimits {
-    /** Maximum allowed usage in minutes per billing period */
-    maxMinutes: number;
-    plan: BillingPlan;
-}
-export interface QuotaCheckResult {
-    allowed: boolean;
-    /** Minutes remaining in the current period */
-    remaining: number;
-    /** Plan limit in minutes */
-    limit: number;
-}
-/** Get the minute limits for a given billing plan. */
-export declare function getPlanLimits(plan: BillingPlan): PlanLimits;
-/** Monthly tool-call limit for a plan. */
-export declare function getCallLimit(plan: BillingPlan): number;
-/** Maximum hosted servers for a plan. */
-export declare function getServerLimit(plan: BillingPlan): number;
-/**
- * Check whether a user may create another server given how many they already
- * have. `allowed` is false once the count reaches the plan's server limit.
- */
-export declare function checkServerLimit(plan: BillingPlan, currentCount: number): {
-    allowed: boolean;
-    limit: number;
-    remaining: number;
-};
-/**
- * Check whether a user has tool-call quota remaining for the billing period.
- */
-export declare function checkCallQuota(plan: BillingPlan, usedCalls: number): {
-    allowed: boolean;
-    limit: number;
-    remaining: number;
-};
-/**
- * Check whether a user has quota remaining under their plan.
- *
- * @param _userId - The user ID (reserved for future per-user overrides)
- * @param plan - The user's billing plan
- * @param currentUsageMs - Current usage in milliseconds for the billing period
- */
-export declare function checkQuota(_userId: string, plan: BillingPlan, currentUsageMs: number): QuotaCheckResult;

package/dist/cloud/billing/billing-engine.js

@@ -1,81 +0,0 @@
-const PLAN_LIMITS = {
-    free: 500,
-    hobbyist: 5_000,
-    pro: 50_000,
-    team: 500_000,
-    enterprise: Infinity,
-};
-/**
- * Monthly tool-call (request) limits per plan. Overage on paid plans is billed
- * separately; the free tier is a hard cap. Tunable business constants.
- */
-const PLAN_CALL_LIMITS = {
-    free: 1_000,
-    hobbyist: 10_000,
-    pro: 100_000,
-    team: 1_000_000,
-    enterprise: Infinity,
-};
-/** Maximum number of concurrently hosted servers per plan. */
-const PLAN_SERVER_LIMITS = {
-    free: 1,
-    hobbyist: 3,
-    pro: 5,
-    team: 20,
-    enterprise: Infinity,
-};
-/** Get the minute limits for a given billing plan. */
-export function getPlanLimits(plan) {
-    return {
-        maxMinutes: PLAN_LIMITS[plan],
-        plan,
-    };
-}
-/** Monthly tool-call limit for a plan. */
-export function getCallLimit(plan) {
-    return PLAN_CALL_LIMITS[plan] ?? PLAN_CALL_LIMITS.free;
-}
-/** Maximum hosted servers for a plan. */
-export function getServerLimit(plan) {
-    return PLAN_SERVER_LIMITS[plan] ?? PLAN_SERVER_LIMITS.free;
-}
-/**
- * Check whether a user may create another server given how many they already
- * have. `allowed` is false once the count reaches the plan's server limit.
- */
-export function checkServerLimit(plan, currentCount) {
-    const limit = getServerLimit(plan);
-    return {
-        allowed: currentCount < limit,
-        limit,
-        remaining: Math.max(0, limit - currentCount),
-    };
-}
-/**
- * Check whether a user has tool-call quota remaining for the billing period.
- */
-export function checkCallQuota(plan, usedCalls) {
-    const limit = getCallLimit(plan);
-    return {
-        allowed: usedCalls < limit,
-        limit,
-        remaining: Math.max(0, limit - usedCalls),
-    };
-}
-/**
- * Check whether a user has quota remaining under their plan.
- *
- * @param _userId - The user ID (reserved for future per-user overrides)
- * @param plan - The user's billing plan
- * @param currentUsageMs - Current usage in milliseconds for the billing period
- */
-export function checkQuota(_userId, plan, currentUsageMs) {
-    const limit = PLAN_LIMITS[plan];
-    const usedMinutes = currentUsageMs / 60_000;
-    const remaining = Math.max(0, limit - usedMinutes);
-    return {
-        allowed: usedMinutes < limit,
-        remaining,
-        limit,
-    };
-}

package/dist/cloud/billing/credit-store.d.ts

@@ -1,64 +0,0 @@
-/**
- * Promotional tool-call credits.
- *
- * A persistent per-user balance of bonus tool-calls, consumed when a user is
- * over their plan's monthly call quota (before the 429 hard cap). Admins grant
- * and revoke from the dashboard; the serving hot path consumes.
- *
- * Concurrency: `consume` MUST be atomic — two concurrent over-quota requests
- * must not both decrement from the same read value (lost update = leaked free
- * credits). The Pg implementation does the decrement in a single conditional
- * UPDATE; the in-memory one is safe because each call runs to completion within
- * one event-loop turn.
- *
- * The ledger records only admin grants/revokes (low volume, truly auditable).
- * Per-request consumption is intentionally NOT ledgered — that would add a write
- * per over-quota tool call on the hot path; consumption totals are derivable
- * from usage accounting.
- */
-import type { Database } from '../db/index.js';
-export interface ConsumeResult {
-    consumed: boolean;
-    /** Remaining balance after the operation (best-effort; 0 when not consumed). */
-    balance: number;
-}
-export interface LedgerEntry {
-    delta: number;
-    reason: string;
-    actorId: string | null;
-    balanceAfter: number | null;
-    createdAt: string;
-}
-export interface CreditStore {
-    balance(userId: string): Promise<number>;
-    /** Add `amount` credits. Returns the new balance. */
-    grant(userId: string, amount: number, actorId: string): Promise<number>;
-    /** Remove up to `amount` credits (never below zero). Returns the new balance. */
-    revoke(userId: string, amount: number, actorId: string): Promise<number>;
-    /** Atomically consume `amount` credits if the balance covers it (all-or-nothing). */
-    consume(userId: string, amount: number): Promise<ConsumeResult>;
-    recentLedger(userId: string, limit: number): Promise<LedgerEntry[]>;
-}
-export declare class InMemoryCreditStore implements CreditStore {
-    private balances;
-    private ledger;
-    /** Set a balance, bounding the map so a long-lived dev process can't grow it
-     * without limit (drops the oldest-inserted half when the cap is exceeded). */
-    private setBalance;
-    private push;
-    balance(userId: string): Promise<number>;
-    grant(userId: string, amount: number, actorId: string): Promise<number>;
-    revoke(userId: string, amount: number, actorId: string): Promise<number>;
-    consume(userId: string, amount: number): Promise<ConsumeResult>;
-    recentLedger(userId: string, limit: number): Promise<LedgerEntry[]>;
-}
-export declare class PgCreditStore implements CreditStore {
-    private db;
-    constructor(db: Database);
-    private writeLedger;
-    balance(userId: string): Promise<number>;
-    grant(userId: string, amount: number, actorId: string): Promise<number>;
-    revoke(userId: string, amount: number, actorId: string): Promise<number>;
-    consume(userId: string, amount: number): Promise<ConsumeResult>;
-    recentLedger(userId: string, limit: number): Promise<LedgerEntry[]>;
-}

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

@@ -1,168 +0,0 @@
-/**
- * Promotional tool-call credits.
- *
- * A persistent per-user balance of bonus tool-calls, consumed when a user is
- * over their plan's monthly call quota (before the 429 hard cap). Admins grant
- * and revoke from the dashboard; the serving hot path consumes.
- *
- * Concurrency: `consume` MUST be atomic — two concurrent over-quota requests
- * must not both decrement from the same read value (lost update = leaked free
- * credits). The Pg implementation does the decrement in a single conditional
- * UPDATE; the in-memory one is safe because each call runs to completion within
- * one event-loop turn.
- *
- * The ledger records only admin grants/revokes (low volume, truly auditable).
- * Per-request consumption is intentionally NOT ledgered — that would add a write
- * per over-quota tool call on the hot path; consumption totals are derivable
- * from usage accounting.
- */
-import { randomBytes } from 'node:crypto';
-// ---------------------------------------------------------------------------
-// In-memory (dev / no database)
-// ---------------------------------------------------------------------------
-const MAX_INMEMORY_LEDGER = 5_000;
-/** Bound the per-user balance map (dev/no-DB only; prod uses the users table). */
-const MAX_INMEMORY_BALANCES = 50_000;
-export class InMemoryCreditStore {
-    balances = new Map();
-    ledger = [];
-    /** Set a balance, bounding the map so a long-lived dev process can't grow it
-     * without limit (drops the oldest-inserted half when the cap is exceeded). */
-    setBalance(userId, value) {
-        if (!this.balances.has(userId) && this.balances.size >= MAX_INMEMORY_BALANCES) {
-            const keep = Math.floor(MAX_INMEMORY_BALANCES / 2);
-            this.balances = new Map([...this.balances].slice(-keep));
-        }
-        this.balances.set(userId, value);
-    }
-    push(entry) {
-        this.ledger.push(entry);
-        if (this.ledger.length > MAX_INMEMORY_LEDGER) {
-            this.ledger.splice(0, this.ledger.length - MAX_INMEMORY_LEDGER);
-        }
-    }
-    async balance(userId) {
-        return this.balances.get(userId) ?? 0;
-    }
-    async grant(userId, amount, actorId) {
-        const next = (this.balances.get(userId) ?? 0) + amount;
-        this.setBalance(userId, next);
-        this.push({
-            userId,
-            delta: amount,
-            reason: 'admin_grant',
-            actorId,
-            balanceAfter: next,
-            createdAt: new Date().toISOString(),
-        });
-        return next;
-    }
-    async revoke(userId, amount, actorId) {
-        const current = this.balances.get(userId) ?? 0;
-        const next = Math.max(0, current - amount);
-        this.setBalance(userId, next);
-        this.push({
-            userId,
-            delta: next - current,
-            reason: 'admin_revoke',
-            actorId,
-            balanceAfter: next,
-            createdAt: new Date().toISOString(),
-        });
-        return next;
-    }
-    async consume(userId, amount) {
-        const current = this.balances.get(userId) ?? 0;
-        if (amount <= 0 || current < amount)
-            return { consumed: false, balance: 0 };
-        const next = current - amount;
-        this.setBalance(userId, next);
-        return { consumed: true, balance: next };
-    }
-    async recentLedger(userId, limit) {
-        return this.ledger
-            .filter((e) => e.userId === userId)
-            .slice(-limit)
-            .reverse()
-            .map(({ userId: _u, ...rest }) => rest);
-    }
-}
-// ---------------------------------------------------------------------------
-// Postgres
-// ---------------------------------------------------------------------------
-export class PgCreditStore {
-    db;
-    constructor(db) {
-        this.db = db;
-    }
-    async writeLedger(userId, delta, reason, actorId, balanceAfter) {
-        await this.db.query(`INSERT INTO credit_ledger (id, user_id, delta, reason, actor_id, balance_after)
-       VALUES ($1, $2, $3, $4, $5, $6)`, [randomBytes(16).toString('hex'), userId, delta, reason, actorId, balanceAfter]);
-    }
-    async balance(userId) {
-        const { rows } = await this.db.query('SELECT credits_calls FROM users WHERE id = $1', [userId]);
-        const v = rows[0]?.credits_calls ?? 0;
-        return typeof v === 'number' ? v : Number(v) || 0;
-    }
-    async grant(userId, amount, actorId) {
-        const { rows } = await this.db.query('UPDATE users SET credits_calls = credits_calls + $2 WHERE id = $1 RETURNING credits_calls', [userId, amount]);
-        if (rows.length === 0)
-            throw new Error(`User "${userId}" not found`);
-        const next = typeof rows[0].credits_calls === 'number'
-            ? rows[0].credits_calls
-            : Number(rows[0].credits_calls);
-        await this.writeLedger(userId, amount, 'admin_grant', actorId, next);
-        return next;
-    }
-    async revoke(userId, amount, actorId) {
-        // Single atomic statement: lock the row (FOR UPDATE), clamp at zero, and
-        // return both the old and new balance so the ledger delta is exact even
-        // under concurrent admin revokes (no read-modify-write window).
-        const { rows } = await this.db.query(`WITH prev AS (
-         SELECT credits_calls AS old_balance FROM users WHERE id = $1 FOR UPDATE
-       )
-       UPDATE users
-       SET credits_calls = GREATEST(0, users.credits_calls - $2)
-       FROM prev
-       WHERE users.id = $1
-       RETURNING users.credits_calls AS new_balance, prev.old_balance`, [userId, amount]);
-        if (rows.length === 0)
-            throw new Error(`User "${userId}" not found`);
-        const toNum = (v) => (typeof v === 'number' ? v : Number(v));
-        const next = toNum(rows[0].new_balance);
-        const before = toNum(rows[0].old_balance);
-        // Record the actual delta applied (clamped at zero), not the requested amount.
-        await this.writeLedger(userId, next - before, 'admin_revoke', actorId, next);
-        return next;
-    }
-    async consume(userId, amount) {
-        if (amount <= 0)
-            return { consumed: false, balance: 0 };
-        // Single atomic statement: decrement only if the balance covers it.
-        const { rows } = await this.db.query('UPDATE users SET credits_calls = credits_calls - $2 WHERE id = $1 AND credits_calls >= $2 RETURNING credits_calls', [userId, amount]);
-        if (rows.length === 0)
-            return { consumed: false, balance: 0 };
-        const balance = typeof rows[0].credits_calls === 'number'
-            ? rows[0].credits_calls
-            : Number(rows[0].credits_calls);
-        return { consumed: true, balance };
-    }
-    async recentLedger(userId, limit) {
-        const { rows } = await this.db.query(`SELECT delta, reason, actor_id, balance_after, created_at
-       FROM credit_ledger WHERE user_id = $1 ORDER BY created_at DESC LIMIT $2`, [userId, limit]);
-        return rows.map((row) => {
-            const createdAt = row.created_at;
-            return {
-                delta: typeof row.delta === 'number' ? row.delta : Number(row.delta ?? 0),
-                reason: String(row.reason ?? ''),
-                actorId: row.actor_id != null ? String(row.actor_id) : null,
-                balanceAfter: row.balance_after != null
-                    ? typeof row.balance_after === 'number'
-                        ? row.balance_after
-                        : Number(row.balance_after)
-                    : null,
-                createdAt: typeof createdAt === 'string' ? createdAt : new Date(createdAt).toISOString(),
-            };
-        });
-    }
-}

package/dist/cloud/billing/index.d.ts

@@ -1,4 +0,0 @@
-export { UsageTracker } from './usage-tracker.js';
-export type { UsageEvent, UsageEventType, UsageSummary } from './usage-tracker.js';
-export { checkQuota, getPlanLimits } from './billing-engine.js';
-export type { BillingPlan, PlanLimits, QuotaCheckResult } from './billing-engine.js';

package/dist/cloud/billing/index.js

@@ -1,2 +0,0 @@
-export { UsageTracker } from './usage-tracker.js';
-export { checkQuota, getPlanLimits } from './billing-engine.js';

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

@@ -1,42 +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 type { Database } from '../db/index.js';
-export interface BillingPeriod {
-    /** ISO timestamp of the period start (inclusive). */
-    start: string;
-    /** ISO timestamp of the period end (exclusive). */
-    end: string;
-}
-/**
- * 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 declare function getBillingPeriod(now?: Date, anchorEndMs?: number): BillingPeriod;
-export interface UsageStore {
-    /** Add tool-call and request counts for a user in the given period. */
-    record(userId: string, period: BillingPeriod, toolCalls: number, requests: number): Promise<void>;
-    /** Total tool calls a user has made in the given period. */
-    getToolCalls(userId: string, period: BillingPeriod): Promise<number>;
-}
-export declare class InMemoryUsageStore implements UsageStore {
-    private counts;
-    private key;
-    record(userId: string, period: BillingPeriod, toolCalls: number, requests: number): Promise<void>;
-    getToolCalls(userId: string, period: BillingPeriod): Promise<number>;
-}
-export declare class PgUsageStore implements UsageStore {
-    private db;
-    constructor(db: Database);
-    record(userId: string, period: BillingPeriod, toolCalls: number, requests: number): Promise<void>;
-    getToolCalls(userId: string, period: BillingPeriod): Promise<number>;
-}

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