prism-mcp-server 20.0.7 → 20.0.8

package/dist/utils/tavilyApi.js

@@ -1,70 +0,0 @@
-/**
- * Tavily API Client
- *
- * This module provides Tavily Search and Extract helpers for the Web Scholar
- * pipeline. It serves as an additive alternative to Brave Search + Firecrawl
- * when TAVILY_API_KEY is set.
- *
- *   1. performTavilySearch — Web search returning URLs (mirrors Brave web search)
- *   2. performTavilyExtract — URL content extraction returning markdown (mirrors Firecrawl scrape)
- */
-import { tavily } from "@tavily/core";
-function getClient(apiKey) {
-    return tavily({ apiKey });
-}
-/**
- * Searches the web via Tavily and returns an array of result objects.
- */
-export async function performTavilySearch(apiKey, query, maxResults = 10) {
-    try {
-        const client = getClient(apiKey);
-        const response = await client.search(query, {
-            maxResults,
-            searchDepth: "advanced",
-            topic: "general",
-        });
-        return (response.results || []).map((r) => ({
-            title: r.title || "",
-            url: r.url || "",
-            content: r.content || "",
-            score: r.score ?? 0,
-        }));
-    }
-    catch (error) {
-        console.error(`[Tavily Search] Error performing search for query "${query}":`, error);
-        return [];
-    }
-}
-/**
- * Extracts article content from URLs via Tavily Extract.
- * Returns markdown content for each successfully extracted URL.
- */
-export async function performTavilyExtract(apiKey, urls) {
-    if (urls.length === 0)
-        return [];
-    const client = getClient(apiKey);
-    const allResults = [];
-    // Tavily extract accepts up to 20 URLs at once
-    for (let i = 0; i < urls.length; i += 20) {
-        const batch = urls.slice(i, i + 20);
-        try {
-            const response = await client.extract(batch, {
-                extractDepth: "basic",
-            });
-            // Optionally log failed URLs from this batch
-            if (response.failedResults && response.failedResults.length > 0) {
-                console.warn(`[Tavily Extract] Failed to extract ${response.failedResults.length} URLs in this batch.`, response.failedResults);
-            }
-            const mapped = (response.results || []).map((r) => ({
-                url: r.url || "",
-                rawContent: r.rawContent || "",
-            }));
-            allResults.push(...mapped);
-        }
-        catch (error) {
-            // Log the error but continue to the next batch to prevent total data loss
-            console.error(`[Tavily Extract] Error extracting batch ${i} to ${Math.min(i + 20, urls.length)}:`, error);
-        }
-    }
-    return allResults;
-}

package/dist/vm/quotaEnforcer.js

@@ -1,192 +0,0 @@
-/**
- * v12.5: Tier-Gated VM Quota Enforcer
- *
- * Enforces subscription-based VM limits.
- * Each Synalux tier has maximum VM counts, CPU, RAM, and storage quotas.
- */
-import { debugLog } from "../utils/logger.js";
-// ─── Tier Quotas ─────────────────────────────────────────────
-const TIER_QUOTAS = {
-    free: {
-        maxVMs: 1,
-        maxCpuCores: 2,
-        maxRamGb: 4,
-        maxStorageGb: 20,
-        maxConcurrentRuns: 1,
-        allowedPlatforms: ["linux"],
-    },
-    standard: {
-        maxVMs: 5,
-        maxCpuCores: 8,
-        maxRamGb: 16,
-        maxStorageGb: 100,
-        maxConcurrentRuns: 2,
-        allowedPlatforms: ["linux", "macos", "windows"],
-    },
-    advanced: {
-        maxVMs: 20,
-        maxCpuCores: 32,
-        maxRamGb: 64,
-        maxStorageGb: 500,
-        maxConcurrentRuns: 5,
-        allowedPlatforms: ["linux", "macos", "windows", "ios", "android", "visionos"],
-    },
-    enterprise: {
-        maxVMs: -1, // unlimited
-        maxCpuCores: -1,
-        maxRamGb: -1,
-        maxStorageGb: -1,
-        maxConcurrentRuns: -1,
-        allowedPlatforms: ["*"],
-    },
-};
-// ─── State ───────────────────────────────────────────────────
-let currentTier = "free";
-let currentUsage = {
-    activeVMs: 0,
-    totalCpuCores: 0,
-    totalRamGb: 0,
-    totalStorageGb: 0,
-    concurrentRuns: 0,
-};
-export function setTier(tier) {
-    currentTier = tier;
-    debugLog(`VM Quota: Tier set to '${tier}'`);
-}
-export function getTier() {
-    return currentTier;
-}
-export function getQuota(tier) {
-    return { ...TIER_QUOTAS[tier || currentTier] };
-}
-export function getUsage() {
-    return { ...currentUsage };
-}
-export function updateUsage(usage) {
-    currentUsage = { ...currentUsage, ...usage };
-}
-// ─── Quota Checks ────────────────────────────────────────────
-function isUnlimited(value) {
-    return value === -1;
-}
-/**
- * Check if creating a new VM is allowed.
- */
-export function checkVMCreation(cpuCores = 1, ramGb = 2, storageGb = 10, platform = "linux") {
-    const quota = TIER_QUOTAS[currentTier];
-    // Check platform
-    if (!quota.allowedPlatforms.includes("*") && !quota.allowedPlatforms.includes(platform)) {
-        return {
-            allowed: false,
-            resource: "platform",
-            requested: 0,
-            available: 0,
-            limit: 0,
-            tier: currentTier,
-            reason: `Platform '${platform}' not available on ${currentTier} tier. Available: ${quota.allowedPlatforms.join(", ")}`,
-        };
-    }
-    // Check VM count
-    if (!isUnlimited(quota.maxVMs) && currentUsage.activeVMs >= quota.maxVMs) {
-        return {
-            allowed: false,
-            resource: "vms",
-            requested: 1,
-            available: quota.maxVMs - currentUsage.activeVMs,
-            limit: quota.maxVMs,
-            tier: currentTier,
-            reason: `VM limit reached (${currentUsage.activeVMs}/${quota.maxVMs})`,
-        };
-    }
-    // Check CPU
-    if (!isUnlimited(quota.maxCpuCores) && currentUsage.totalCpuCores + cpuCores > quota.maxCpuCores) {
-        return {
-            allowed: false,
-            resource: "cpu",
-            requested: cpuCores,
-            available: quota.maxCpuCores - currentUsage.totalCpuCores,
-            limit: quota.maxCpuCores,
-            tier: currentTier,
-            reason: `CPU quota exceeded (${currentUsage.totalCpuCores + cpuCores}/${quota.maxCpuCores} cores)`,
-        };
-    }
-    // Check RAM
-    if (!isUnlimited(quota.maxRamGb) && currentUsage.totalRamGb + ramGb > quota.maxRamGb) {
-        return {
-            allowed: false,
-            resource: "ram",
-            requested: ramGb,
-            available: quota.maxRamGb - currentUsage.totalRamGb,
-            limit: quota.maxRamGb,
-            tier: currentTier,
-            reason: `RAM quota exceeded (${currentUsage.totalRamGb + ramGb}/${quota.maxRamGb} GB)`,
-        };
-    }
-    // Check storage
-    if (!isUnlimited(quota.maxStorageGb) && currentUsage.totalStorageGb + storageGb > quota.maxStorageGb) {
-        return {
-            allowed: false,
-            resource: "storage",
-            requested: storageGb,
-            available: quota.maxStorageGb - currentUsage.totalStorageGb,
-            limit: quota.maxStorageGb,
-            tier: currentTier,
-            reason: `Storage quota exceeded (${currentUsage.totalStorageGb + storageGb}/${quota.maxStorageGb} GB)`,
-        };
-    }
-    return {
-        allowed: true,
-        resource: "all",
-        requested: 0,
-        available: 0,
-        limit: 0,
-        tier: currentTier,
-        reason: "All quota checks passed",
-    };
-}
-/**
- * Check if a concurrent run is allowed.
- */
-export function checkConcurrentRun() {
-    const quota = TIER_QUOTAS[currentTier];
-    if (!isUnlimited(quota.maxConcurrentRuns) && currentUsage.concurrentRuns >= quota.maxConcurrentRuns) {
-        return {
-            allowed: false,
-            resource: "concurrent_runs",
-            requested: 1,
-            available: quota.maxConcurrentRuns - currentUsage.concurrentRuns,
-            limit: quota.maxConcurrentRuns,
-            tier: currentTier,
-            reason: `Concurrent run limit reached (${currentUsage.concurrentRuns}/${quota.maxConcurrentRuns})`,
-        };
-    }
-    return {
-        allowed: true,
-        resource: "concurrent_runs",
-        requested: 1,
-        available: isUnlimited(quota.maxConcurrentRuns) ? -1 : quota.maxConcurrentRuns - currentUsage.concurrentRuns,
-        limit: quota.maxConcurrentRuns,
-        tier: currentTier,
-        reason: "Concurrent run allowed",
-    };
-}
-/**
- * Get a summary of quota usage vs limits.
- */
-export function getQuotaSummary() {
-    const limits = TIER_QUOTAS[currentTier];
-    const pct = (used, max) => max === -1 ? 0 : Math.round((used / max) * 100);
-    return {
-        tier: currentTier,
-        usage: { ...currentUsage },
-        limits: { ...limits },
-        percentUsed: {
-            vms: pct(currentUsage.activeVMs, limits.maxVMs),
-            cpu: pct(currentUsage.totalCpuCores, limits.maxCpuCores),
-            ram: pct(currentUsage.totalRamGb, limits.maxRamGb),
-            storage: pct(currentUsage.totalStorageGb, limits.maxStorageGb),
-            runs: pct(currentUsage.concurrentRuns, limits.maxConcurrentRuns),
-        },
-    };
-}
-debugLog("v12.5: VM quota enforcer loaded");