@toolsdk.ai/registry 1.0.113 → 1.0.115

package/dist/{search/search-service.js → domains/search/search-so.js}

@@ -1,117 +1,89 @@
-/**
- * MeiliSearch Service for Awesome MCP Registry
- * Handles search indexing and querying for MCP packages
- */
 import fs from "node:fs/promises";
-import path from "node:path";
 import { MeiliSearch } from "meilisearch";
-import { getDirname } from "../utils";
-const __dirname = getDirname(import.meta.url);
-class SearchService {
-    constructor(indexName = "mcp-packages") {
-        // MeiliSearch configuration
-        this.host = process.env.MEILI_HTTP_ADDR || "http://localhost:7700";
-        this.apiKey = process.env.MEILI_MASTER_KEY || null;
+import { getMeiliSearchConfig } from "../../shared/config/environment";
+/**
+ * Search Service Object
+ * Manages MeiliSearch connection and indexing with singleton pattern
+ */
+export class SearchSO {
+    constructor(client, _index, host, indexName) {
+        this.client = client;
+        this._index = _index;
+        this.host = host;
         this.indexName = indexName;
-        // Initialize MeiliSearch client
-        this.client = new MeiliSearch({
-            host: this.host,
-            apiKey: this.apiKey || undefined,
-        });
-        this._index = null;
-        this.isInitialized = false;
-    }
-    /**
-     * Get the initialization status
-     */
-    getIsInitialized() {
-        return this.isInitialized;
-    }
-    /**
-     * Get the MeiliSearch client
-     */
-    getClient() {
-        return this.client;
     }
     get index() {
         return this._index;
     }
-    set index(value) {
-        this._index = value;
+    get isInitialized() {
+        return this._index !== null;
     }
-    async initialize() {
+    static async getInstance(host, apiKey, indexName = "mcp-packages") {
+        var _a;
+        if ((_a = SearchSO.instance) === null || _a === void 0 ? void 0 : _a.isInitialized) {
+            return SearchSO.instance;
+        }
+        const meiliConfig = getMeiliSearchConfig();
+        const meiliHost = host || meiliConfig.host;
+        const meiliKey = apiKey || meiliConfig.apiKey || undefined;
+        const client = new MeiliSearch({
+            host: meiliHost,
+            apiKey: meiliKey,
+        });
+        console.log(`Connecting to MeiliSearch at ${meiliHost}...`);
+        await client.health();
+        console.log("✅ MeiliSearch is healthy");
+        let index;
         try {
-            console.log(`Connecting to MeiliSearch at ${this.host}...`);
-            // Check if MeiliSearch is running
-            await this.client.health();
-            console.log("✅ MeiliSearch is healthy");
-            // Create or get the index
-            try {
-                await this.client.createIndex(this.indexName, { primaryKey: "id" });
-                console.log(`✅ Created new index: ${this.indexName}`);
-            }
-            catch (error) {
-                if (error.message.includes("exists")) {
-                    console.log(`✅ Using existing index: ${this.indexName}`);
-                }
-                else {
-                    throw error;
-                }
-            }
-            // Get the index object
-            this.index = await this.client.getIndex(this.indexName);
-            // Configure search settings
-            await this.configureIndex();
-            this.isInitialized = true;
-            console.log("✅ Search service initialized successfully");
+            await client.createIndex(indexName, { primaryKey: "id" });
+            console.log(`✅ Created new index: ${indexName}`);
+            index = await client.getIndex(indexName);
         }
         catch (error) {
-            console.error("❌ Failed to initialize search service:", error.message);
-            console.log("💡 Make sure MeiliSearch is running on", this.host);
-            throw error;
+            if (error.message.includes("exists")) {
+                console.log(`✅ Using existing index: ${indexName}`);
+            }
+            index = await client.getIndex(indexName);
         }
+        const searchSO = new SearchSO(client, index, meiliHost, indexName);
+        await searchSO.configureIndex();
+        console.log("✅ Search service initialized successfully");
+        SearchSO.instance = searchSO;
+        return searchSO;
     }
-    /**
-     * Configure search index settings for optimal MCP package search
-     */
     async configureIndex() {
+        if (!this._index)
+            return;
         try {
-            // Configure searchable attributes (ranked by importance)
-            if (this.index) {
-                await this.index.updateSettings({
-                    searchableAttributes: [
-                        "name",
-                        "packageName",
-                        "description",
-                        "tools",
-                        "category",
-                        "author",
-                        "keywords",
-                    ],
-                    // Configure filterable attributes
-                    filterableAttributes: ["category", "validated", "author", "hasTools", "popularity"],
-                    // Configure sortable attributes
-                    sortableAttributes: ["popularity", "name", "category"],
-                    // Configure ranking rules for relevance
-                    rankingRules: [
-                        "words",
-                        "typo",
-                        "proximity",
-                        "attribute",
-                        "sort",
-                        "exactness",
-                        "popularity:desc",
-                    ],
-                    // Configure synonyms for better search
-                    synonyms: {
-                        ai: ["artificial intelligence", "machine learning", "ml"],
-                        db: ["database"],
-                        api: ["rest", "graphql"],
-                        auth: ["authentication", "authorization"],
-                        mcp: ["model context protocol"],
-                    },
-                });
-            }
+            await this._index.updateSettings({
+                searchableAttributes: [
+                    "name",
+                    "packageName",
+                    "description",
+                    "tools",
+                    "category",
+                    "author",
+                    "keywords",
+                ],
+                filterableAttributes: ["category", "validated", "author", "hasTools", "popularity"],
+                sortableAttributes: ["popularity", "name", "category"],
+                rankingRules: [
+                    "words",
+                    "typo",
+                    "proximity",
+                    "attribute",
+                    "sort",
+                    "exactness",
+                    "popularity:desc",
+                ],
+                synonyms: {
+                    ai: ["artificial intelligence", "machine learning", "ml"],
+                    db: ["database"],
+                    api: ["rest", "graphql"],
+                    auth: ["authentication", "authorization"],
+                    mcp: ["model context protocol"],
+                },
+            });
             console.log("✅ Search index configured");
         }
         catch (error) {
@@ -119,166 +91,13 @@ class SearchService {
             throw error;
         }
     }
-    /**
-     * Transform package data for search indexing
-     */
-    transformPackageForIndex(packageName, packageData) {
-        // Extract tools information
-        const tools = packageData.tools || {};
-        const toolNames = Object.keys(tools);
-        const toolDescriptions = Object.values(tools)
-            .map((t) => t.description || "")
-            .join(" ");
-        // Calculate basic popularity score (can be enhanced with real metrics)
-        const popularity = this.calculatePopularityScore(packageData);
-        // Create a safe ID by encoding special characters
-        const safeId = this.createSafeId(packageName);
-        return {
-            id: safeId,
-            name: packageData.name || packageName,
-            packageName: packageName,
-            description: packageData.description || "",
-            category: packageData.category || "uncategorized",
-            validated: packageData.validated || false,
-            author: this.extractAuthor(packageName),
-            tools: `${toolNames.join(" ")} ${toolDescriptions}`,
-            toolCount: toolNames.length,
-            hasTools: toolNames.length > 0,
-            keywords: this.extractKeywords(packageData, packageName),
-            popularity: popularity,
-            path: packageData.path || "",
-        };
-    }
-    /**
-     * Create a safe ID for MeiliSearch (alphanumeric, hyphens, underscores only)
-     */
-    createSafeId(packageName) {
-        return packageName
-            .replace(/@/g, "at-")
-            .replace(/\//g, "-")
-            .replace(/\./g, "_")
-            .replace(/:/g, "-")
-            .replace(/[^a-zA-Z0-9\-_]/g, "_")
-            .substring(0, 500); // Keep under 511 byte limit
-    }
-    /**
-     * Calculate a popularity score for ranking
-     */
-    calculatePopularityScore(packageData) {
-        let score = 0;
-        // Boost for validated packages
-        if (packageData.validated)
-            score += 10;
-        // Boost for packages with tools
-        const toolCount = Object.keys(packageData.tools || {}).length;
-        score += toolCount * 2;
-        // Boost for packages with good descriptions
-        if (packageData.description && packageData.description.length > 50)
-            score += 5;
-        return score;
-    }
-    /**
-     * Extract author from package name
-     */
-    extractAuthor(packageName) {
-        if (packageName.startsWith("@")) {
-            return packageName.split("/")[0].substring(1);
-        }
-        return "";
-    }
-    /**
-     * Extract relevant keywords from package data
-     */
-    extractKeywords(packageData, packageName) {
-        const keywords = [];
-        // Add category as keyword
-        if (packageData.category) {
-            keywords.push(packageData.category.replace(/-/g, " "));
-        }
-        // Extract keywords from description
-        if (packageData.description) {
-            const desc = packageData.description.toLowerCase();
-            const commonKeywords = [
-                "api",
-                "database",
-                "auth",
-                "search",
-                "ai",
-                "ml",
-                "tool",
-                "server",
-                "client",
-            ];
-            commonKeywords.forEach((keyword) => {
-                if (desc.includes(keyword))
-                    keywords.push(keyword);
-            });
-        }
-        // Extract from package name
-        const nameWords = packageName
-            .replace(/[@/\-_]/g, " ")
-            .split(" ")
-            .filter((w) => w.length > 2);
-        keywords.push(...nameWords);
-        return [...new Set(keywords)].join(" ");
-    }
-    /**
-     * Index all packages from the packages-list.json file
-     */
-    async indexPackages() {
-        if (!this.isInitialized) {
-            throw new Error("Search service not initialized. Call initialize() first.");
-        }
-        try {
-            console.log("📥 Loading packages data...");
-            const packagesPath = path.join(__dirname, "..", "..", "indexes", "packages-list.json");
-            const packagesData = await fs.readFile(packagesPath, "utf8");
-            const packages = JSON.parse(packagesData);
-            console.log(`📦 Found ${Object.keys(packages).length} packages to index`);
-            // Transform packages for indexing
-            const documents = Object.entries(packages).map(([packageName, packageData]) => this.transformPackageForIndex(packageName, packageData));
-            console.log("🔄 Indexing packages...");
-            // Add documents to index in batches
-            const batchSize = 1000;
-            const batches = [];
-            for (let i = 0; i < documents.length; i += batchSize) {
-                batches.push(documents.slice(i, i + batchSize));
-            }
-            for (let i = 0; i < batches.length; i++) {
-                const batch = batches[i];
-                if (this.index) {
-                    const task = await this.index.addDocuments(batch);
-                    console.log(`📝 Indexed batch ${i + 1}/${batches.length} (${batch.length} documents) - Task ID: ${task.taskUid}`);
-                    // Wait for task completion
-                    await this.client.waitForTask(task.taskUid);
-                }
-            }
-            // Get final stats
-            if (!this.index) {
-                throw new Error("Index is not initialized");
-            }
-            const stats = await this.index.getStats();
-            console.log(`✅ Indexing complete! ${stats.numberOfDocuments} documents indexed`);
-            return stats;
-        }
-        catch (error) {
-            console.error("❌ Failed to index packages:", error.message);
-            throw error;
-        }
-    }
-    /**
-     * Search packages with advanced options
-     */
     async search(query, options = {}) {
-        if (!this.isInitialized) {
-            throw new Error("Search service not initialized. Call initialize() first.");
+        if (!this._index) {
+            throw new Error("Search index not initialized. Call getInstance() first.");
         }
         try {
             const searchOptions = Object.assign({ limit: options.limit || 20, offset: options.offset || 0, filter: options.filter || undefined, sort: options.sort || ["popularity:desc"], attributesToHighlight: ["name", "description"], attributesToCrop: ["description"], cropLength: 100, highlightPreTag: "<mark>", highlightPostTag: "</mark>", matchingStrategy: options.matchingStrategy || "last" }, options);
-            if (!this.index) {
-                throw new Error("Index is not initialized");
-            }
-            const results = await this.index.search(query, searchOptions);
+            const results = await this._index.search(query, searchOptions);
             return {
                 hits: results.hits,
                 query: results.query,
@@ -293,18 +112,12 @@ class SearchService {
             throw error;
         }
     }
-    /**
-     * Get search suggestions/autocomplete
-     */
     async suggest(query, limit = 10) {
-        if (!this.isInitialized) {
-            throw new Error("Search service not initialized. Call initialize() first.");
+        if (!this._index) {
+            throw new Error("Search index not initialized");
         }
         try {
-            if (!this.index) {
-                throw new Error("Index is not initialized");
-            }
-            const results = await this.index.search(query, {
+            const results = await this._index.search(query, {
                 limit: limit,
                 attributesToRetrieve: ["name", "packageName", "category"],
                 attributesToHighlight: ["name"],
@@ -325,18 +138,46 @@ class SearchService {
             throw error;
         }
     }
-    /**
-     * Get faceted search results (for filters)
-     */
-    async getFacets() {
-        if (!this.isInitialized) {
-            throw new Error("Search service not initialized. Call initialize() first.");
+    async indexPackages(packagesPath) {
+        if (!this._index) {
+            throw new Error("Search index not initialized");
         }
         try {
-            if (!this.index) {
-                throw new Error("Index is not initialized");
+            console.log("📥 Loading packages data...");
+            const packagesData = await fs.readFile(packagesPath, "utf8");
+            const packages = JSON.parse(packagesData);
+            console.log(`📦 Found ${Object.keys(packages).length} packages to index`);
+            // Transform packages for indexing
+            const documents = Object.entries(packages).map(([packageName, packageData]) => this.transformPackageForIndex(packageName, packageData));
+            console.log("🔄 Indexing packages...");
+            // Add documents to index in batches
+            const batchSize = 1000;
+            const batches = [];
+            for (let i = 0; i < documents.length; i += batchSize) {
+                batches.push(documents.slice(i, i + batchSize));
+            }
+            for (let i = 0; i < batches.length; i++) {
+                const batch = batches[i];
+                const task = await this._index.addDocuments(batch);
+                console.log(`📝 Indexed batch ${i + 1}/${batches.length} (${batch.length} documents) - Task ID: ${task.taskUid}`);
+                await this.client.waitForTask(task.taskUid);
             }
-            const results = await this.index.search("", {
+            // Get final stats
+            const stats = await this._index.getStats();
+            console.log(`✅ Indexing complete! ${stats.numberOfDocuments} documents indexed`);
+            return stats;
+        }
+        catch (error) {
+            console.error("❌ Failed to index packages:", error.message);
+            throw error;
+        }
+    }
+    async getFacets() {
+        if (!this._index) {
+            throw new Error("Search index not initialized");
+        }
+        try {
+            const results = await this._index.search("", {
                 limit: 0,
                 facets: ["category", "validated", "author"],
             });
@@ -347,36 +188,24 @@ class SearchService {
             throw error;
         }
     }
-    /**
-     * Get index statistics
-     */
     async getStats() {
-        if (!this.isInitialized) {
-            throw new Error("Search service not initialized. Call initialize() first.");
+        if (!this._index) {
+            throw new Error("Search index not initialized");
         }
         try {
-            if (!this.index) {
-                throw new Error("Index is not initialized");
-            }
-            return await this.index.getStats();
+            return await this._index.getStats();
         }
         catch (error) {
             console.error("❌ Failed to get stats:", error.message);
             throw error;
         }
     }
-    /**
-     * Clear the index
-     */
     async clearIndex() {
-        if (!this.isInitialized) {
-            throw new Error("Search service not initialized. Call initialize() first.");
+        if (!this._index) {
+            throw new Error("Search index not initialized");
         }
         try {
-            if (!this.index) {
-                throw new Error("Index is not initialized");
-            }
-            const task = await this.index.deleteAllDocuments();
+            const task = await this._index.deleteAllDocuments();
             await this.client.waitForTask(task.taskUid);
             console.log("✅ Index cleared");
         }
@@ -385,9 +214,6 @@ class SearchService {
             throw error;
         }
     }
-    /**
-     * Health check for the search service
-     */
     async healthCheck() {
         try {
             await this.client.health();
@@ -410,7 +236,84 @@ class SearchService {
             };
         }
     }
+    transformPackageForIndex(packageName, packageData) {
+        const tools = packageData.tools || {};
+        const toolNames = Object.keys(tools);
+        const toolDescriptions = Object.values(tools)
+            .map((t) => t.description || "")
+            .join(" ");
+        const popularity = this.calculatePopularityScore(packageData);
+        const safeId = this.createSafeId(packageName);
+        return {
+            id: safeId,
+            name: packageData.name || packageName,
+            packageName: packageName,
+            description: packageData.description || "",
+            category: packageData.category || "uncategorized",
+            validated: packageData.validated || false,
+            author: this.extractAuthor(packageName),
+            tools: `${toolNames.join(" ")} ${toolDescriptions}`,
+            toolCount: toolNames.length,
+            hasTools: toolNames.length > 0,
+            keywords: this.extractKeywords(packageData, packageName),
+            popularity: popularity,
+            path: packageData.path || "",
+        };
+    }
+    createSafeId(packageName) {
+        return packageName
+            .replace(/@/g, "at-")
+            .replace(/\//g, "-")
+            .replace(/\./g, "_")
+            .replace(/:/g, "-")
+            .replace(/[^a-zA-Z0-9\-_]/g, "_")
+            .substring(0, 500);
+    }
+    calculatePopularityScore(packageData) {
+        let score = 0;
+        if (packageData.validated)
+            score += 10;
+        const toolCount = Object.keys(packageData.tools || {}).length;
+        score += toolCount * 2;
+        if (packageData.description && packageData.description.length > 50)
+            score += 5;
+        return score;
+    }
+    extractAuthor(packageName) {
+        if (packageName.startsWith("@")) {
+            return packageName.split("/")[0].substring(1);
+        }
+        return "";
+    }
+    extractKeywords(packageData, packageName) {
+        const keywords = [];
+        if (packageData.category) {
+            keywords.push(packageData.category.replace(/-/g, " "));
+        }
+        if (packageData.description) {
+            const desc = packageData.description.toLowerCase();
+            const commonKeywords = [
+                "api",
+                "database",
+                "auth",
+                "search",
+                "ai",
+                "ml",
+                "tool",
+                "server",
+                "client",
+            ];
+            commonKeywords.forEach((keyword) => {
+                if (desc.includes(keyword))
+                    keywords.push(keyword);
+            });
+        }
+        const nameWords = packageName
+            .replace(/[@/\-_]/g, " ")
+            .split(" ")
+            .filter((w) => w.length > 2);
+        keywords.push(...nameWords);
+        return [...new Set(keywords)].join(" ");
+    }
 }
-// Export singleton instance
-const searchService = new SearchService();
-export default searchService;
+SearchSO.instance = null;

package/dist/shared/config/environment.d.ts

@@ -0,0 +1,16 @@
+import type { MCPSandboxProvider } from "../../domains/sandbox/sandbox-types";
+export declare function getSandboxProvider(): MCPSandboxProvider;
+export declare function getDaytonaConfig(): {
+    apiKey: string;
+    apiUrl: string | undefined;
+};
+export declare function getSandockConfig(): {
+    apiKey: string;
+    apiUrl: string;
+};
+export declare function getMeiliSearchConfig(): {
+    host: string;
+    apiKey: string | null;
+};
+export declare function getServerPort(): number;
+export declare function isSearchEnabled(): boolean;

package/dist/shared/config/environment.js

@@ -0,0 +1,41 @@
+import path from "node:path";
+import dotenv from "dotenv";
+dotenv.config({ path: path.resolve(process.cwd(), ".env.local") });
+dotenv.config({ path: path.resolve(process.cwd(), ".env") });
+export function getSandboxProvider() {
+    console.log("process.env.MCP_SANDBOX_PROVIDER", process.env.MCP_SANDBOX_PROVIDER);
+    const provider = (process.env.MCP_SANDBOX_PROVIDER || "LOCAL").toUpperCase();
+    if (provider === "LOCAL" ||
+        provider === "DAYTONA" ||
+        provider === "SANDOCK" ||
+        provider === "E2B") {
+        return provider;
+    }
+    console.warn(`[Environment] Unsupported MCP_SANDBOX_PROVIDER value '${provider}', falling back to LOCAL mode`);
+    return "LOCAL";
+}
+export function getDaytonaConfig() {
+    return {
+        apiKey: process.env.DAYTONA_API_KEY || "",
+        apiUrl: process.env.DAYTONA_API_URL,
+    };
+}
+export function getSandockConfig() {
+    return {
+        apiKey: process.env.SANDOCK_API_KEY || "",
+        apiUrl: process.env.SANDOCK_API_URL || "https://sandock.ai",
+    };
+}
+export function getMeiliSearchConfig() {
+    return {
+        host: process.env.MEILI_HTTP_ADDR || "http://localhost:7700",
+        apiKey: process.env.MEILI_MASTER_KEY || null,
+    };
+}
+export function getServerPort() {
+    const port = process.env.PORT || process.env.MCP_SERVER_PORT;
+    return port ? parseInt(port, 10) : 3003;
+}
+export function isSearchEnabled() {
+    return process.env.ENABLE_SEARCH === "true";
+}