@toolsdk.ai/registry 1.0.113 → 1.0.115

package/dist/domains/sandbox/clients/sandock-client.js

@@ -0,0 +1,178 @@
+import path from "node:path";
+import { createSandockClient } from "sandock";
+import { getSandockConfig } from "../../../shared/config/environment";
+import { getDirname } from "../../../shared/utils/file-util";
+import { extractLastOuterJSON } from "../../../shared/utils/string-util";
+import { PackageRepository } from "../../package/package-repository";
+import { generateMCPTestCode } from "../sandbox-utils";
+/**
+ * Sandock Sandbox Client
+ * Implements SandboxClient interface for Sandock provider
+ */
+export class SandockSandboxClient {
+    constructor(_runtime = "node") {
+        this.sandboxId = null;
+        this.initializing = null;
+        const __dirname = getDirname(import.meta.url);
+        const packagesDir = path.join(__dirname, "../../../../packages");
+        this.packageRepository = new PackageRepository(packagesDir);
+        const config = getSandockConfig();
+        this.client = createSandockClient({
+            baseUrl: config.apiUrl,
+            headers: {
+                Authorization: `Bearer ${config.apiKey}`,
+            },
+        });
+    }
+    async initialize() {
+        if (this.sandboxId) {
+            return;
+        }
+        if (this.initializing) {
+            await this.initializing;
+            return;
+        }
+        this.initializing = (async () => {
+            try {
+                // Create sandbox with pre-built MCP image
+                const createResponse = await this.client.POST("/api/sandbox", {
+                    body: {
+                        image: "seey/sandock-mcp:latest",
+                        workdir: "/mcpspace",
+                    },
+                });
+                if (!createResponse.data) {
+                    const errorMsg = "error" in createResponse ? JSON.stringify(createResponse.error) : "Unknown error";
+                    throw new Error(`Failed to create sandbox: ${errorMsg}`);
+                }
+                this.sandboxId = createResponse.data.data.id;
+                console.log(`[SandockSandboxClient] Sandbox created successfully: ${this.sandboxId}`);
+            }
+            catch (error) {
+                this.sandboxId = null;
+                throw error;
+            }
+            finally {
+                this.initializing = null;
+            }
+        })();
+        await this.initializing;
+    }
+    async executeShellCommand(cmd) {
+        if (!this.sandboxId) {
+            throw new Error("Sandbox not initialized. Call initialize() first.");
+        }
+        const response = await this.client.POST("/api/sandbox/{id}/shell", {
+            params: {
+                path: {
+                    id: this.sandboxId,
+                },
+            },
+            body: {
+                cmd,
+            },
+        });
+        if (!response.data) {
+            const errorMsg = "error" in response ? JSON.stringify(response.error) : "Unknown error";
+            throw new Error(`Shell command failed: ${errorMsg}`);
+        }
+        const stdout = response.data.data.stdout || "";
+        const stderr = response.data.data.stderr || "";
+        if (stderr.trim()) {
+            console.log(`[SandockSandboxClient] stderr: ${stderr}`);
+        }
+        return stdout;
+    }
+    async executeCode(code) {
+        if (!this.sandboxId) {
+            throw new Error("Sandbox not initialized. Call initialize() first.");
+        }
+        // Write code to a temporary file in /mcpspace (accessible to node_modules)
+        const tempFile = `/mcpspace/mcp_test_${Date.now()}.mjs`;
+        // Use Sandock's file write API (more reliable)
+        await this.client.POST("/api/sandbox/{id}/fs/write", {
+            params: {
+                path: { id: this.sandboxId },
+            },
+            body: {
+                path: tempFile,
+                content: code,
+            },
+        });
+        const output = await this.executeShellCommand(`cd /mcpspace && node ${tempFile}`);
+        // Asynchronously clean up temp file without blocking result return
+        this.client
+            .DELETE("/api/sandbox/{id}/fs", {
+            params: {
+                path: { id: this.sandboxId },
+                query: { path: tempFile },
+            },
+        })
+            .catch((error) => {
+            console.warn("[SandockSandboxClient] Warning: Could not delete temp file:", error);
+        });
+        return {
+            exitCode: 0,
+            result: output,
+        };
+    }
+    async listTools(packageKey) {
+        const mcpServerConfig = this.packageRepository.getPackageConfig(packageKey);
+        const testCode = generateMCPTestCode(mcpServerConfig, "listTools");
+        const response = await this.executeCode(testCode);
+        if (response.exitCode !== 0) {
+            throw new Error(`Failed to list tools: ${response.result}`);
+        }
+        const parsedResultStr = extractLastOuterJSON(response.result);
+        const result = JSON.parse(parsedResultStr);
+        return result.tools;
+    }
+    async executeTool(packageKey, toolName, argumentsObj, envs) {
+        const mcpServerConfig = this.packageRepository.getPackageConfig(packageKey);
+        const testCode = generateMCPTestCode(mcpServerConfig, "executeTool", toolName, argumentsObj, envs);
+        const response = await this.executeCode(testCode);
+        if (response.exitCode !== 0) {
+            throw new Error(`Failed to execute tool: ${response.result}`);
+        }
+        const parsedResultStr = extractLastOuterJSON(response.result);
+        const result = JSON.parse(parsedResultStr);
+        if (result.isError) {
+            console.error("[SandockSandboxClient] Tool execution error:", result.errorMessage);
+            throw new Error(result.errorMessage);
+        }
+        return result;
+    }
+    async destroy() {
+        if (!this.sandboxId) {
+            return;
+        }
+        const sandboxIdToStop = this.sandboxId;
+        this.sandboxId = null; // Clear immediately to avoid duplicate calls
+        // Asynchronously clean up sandbox without blocking result return
+        this.client
+            .POST("/api/sandbox/{id}/stop", {
+            params: {
+                path: {
+                    id: sandboxIdToStop,
+                },
+            },
+        })
+            .then((response) => {
+            if (!response.data && "error" in response) {
+                console.warn(`[SandockSandboxClient] Warning: Could not stop sandbox: ${JSON.stringify(response.error)}`);
+            }
+            else {
+                console.log("[SandockSandboxClient] Sandbox stopped successfully");
+            }
+        })
+            .catch((err) => {
+            const errorMessage = err.message;
+            if (errorMessage.includes("not found") || errorMessage.includes("404")) {
+                console.log("[SandockSandboxClient] Sandbox already stopped (not found on platform)");
+            }
+            else {
+                console.warn("[SandockSandboxClient] Warning: Could not stop sandbox:", errorMessage);
+            }
+        });
+    }
+}

package/dist/domains/sandbox/sandbox-factory.d.ts

@@ -0,0 +1,8 @@
+import type { MCPSandboxProvider, SandboxClient } from "./sandbox-types";
+/**
+ * Sandbox Factory
+ * Creates appropriate sandbox client based on provider
+ */
+export declare class SandboxFactory {
+    static create(runtime: "node" | "python" | "java" | "go", provider: MCPSandboxProvider): SandboxClient;
+}

package/dist/domains/sandbox/sandbox-factory.js

@@ -0,0 +1,23 @@
+import { DaytonaSandboxClient } from "./clients/daytona-client";
+import { SandockSandboxClient } from "./clients/sandock-client";
+/**
+ * Sandbox Factory
+ * Creates appropriate sandbox client based on provider
+ */
+// biome-ignore lint/complexity/noStaticOnlyClass: Factory pattern
+export class SandboxFactory {
+    static create(runtime, provider) {
+        switch (provider) {
+            case "SANDOCK":
+                return new SandockSandboxClient(runtime);
+            case "DAYTONA":
+                return new DaytonaSandboxClient(runtime);
+            case "E2B":
+                throw new Error("E2B sandbox provider is not yet implemented");
+            case "LOCAL":
+                throw new Error("LOCAL provider should not use sandbox client");
+            default:
+                throw new Error(`Unknown sandbox provider: ${provider}`);
+        }
+    }
+}

package/dist/domains/sandbox/sandbox-pool-so.d.ts

@@ -0,0 +1,25 @@
+import type { MCPSandboxProvider, SandboxClient } from "./sandbox-types";
+/**
+ * Sandbox Pool Service Object
+ * Manages sandbox instance lifecycle with singleton pattern
+ */
+export declare class SandboxPoolSO {
+    private static instance;
+    private pools;
+    private readonly maxSize;
+    private constructor();
+    static getInstance(): SandboxPoolSO;
+    private getSandboxKey;
+    acquire(runtime: "node" | "python" | "java" | "go", provider: MCPSandboxProvider): Promise<SandboxClient>;
+    release(runtime: "node" | "python" | "java" | "go", provider: MCPSandboxProvider): Promise<void>;
+    /**
+     * LRU eviction strategy
+     * Evicts least recently used sandbox with zero reference count
+     */
+    private evictLRU;
+    cleanup(): Promise<void>;
+    getPoolStatus(): Record<string, {
+        refCount: number;
+        lastUsedAt: number;
+    }>;
+}

package/dist/domains/sandbox/sandbox-pool-so.js

@@ -0,0 +1,123 @@
+import { SandboxFactory } from "./sandbox-factory";
+/**
+ * Sandbox Pool Service Object
+ * Manages sandbox instance lifecycle with singleton pattern
+ */
+export class SandboxPoolSO {
+    constructor(maxSize = 10) {
+        this.pools = new Map();
+        this.maxSize = maxSize;
+    }
+    static getInstance() {
+        if (!SandboxPoolSO.instance) {
+            SandboxPoolSO.instance = new SandboxPoolSO();
+        }
+        return SandboxPoolSO.instance;
+    }
+    getSandboxKey(runtime, provider) {
+        return `sandbox-${provider}-${runtime}`;
+    }
+    async acquire(runtime, provider) {
+        const sandboxKey = this.getSandboxKey(runtime, provider);
+        const record = this.pools.get(sandboxKey);
+        if (record) {
+            record.refCount++;
+            record.lastUsedAt = Date.now();
+            console.log(`[SandboxPoolSO] Reusing existing sandbox: ${sandboxKey} (refCount: ${record.refCount})`);
+            return record.client;
+        }
+        if (this.pools.size >= this.maxSize) {
+            await this.evictLRU();
+        }
+        console.log(`[SandboxPoolSO] Creating new sandbox: ${sandboxKey}`);
+        const client = SandboxFactory.create(runtime, provider);
+        const newRecord = {
+            client,
+            refCount: 1,
+            lastUsedAt: Date.now(),
+            provider,
+            runtime,
+        };
+        this.pools.set(sandboxKey, newRecord);
+        return client;
+    }
+    async release(runtime, provider) {
+        const sandboxKey = this.getSandboxKey(runtime, provider);
+        const record = this.pools.get(sandboxKey);
+        if (!record) {
+            console.warn(`[SandboxPoolSO] Sandbox ${sandboxKey} not found in pool`);
+            return;
+        }
+        record.refCount = Math.max(0, record.refCount - 1);
+        record.lastUsedAt = Date.now();
+        console.log(`[SandboxPoolSO] Released sandbox: ${sandboxKey} (refCount: ${record.refCount})`);
+        if (record.refCount === 0) {
+            try {
+                await record.client.destroy();
+                this.pools.delete(sandboxKey);
+                console.log(`[SandboxPoolSO] Sandbox ${sandboxKey} destroyed and removed from pool`);
+            }
+            catch (error) {
+                console.error(`[SandboxPoolSO] Error destroying sandbox ${sandboxKey}:`, error);
+            }
+        }
+    }
+    /**
+     * LRU eviction strategy
+     * Evicts least recently used sandbox with zero reference count
+     */
+    async evictLRU() {
+        let lruKey = null;
+        let lruTime = Infinity;
+        for (const [key, record] of this.pools) {
+            if (record.refCount === 0 && record.lastUsedAt < lruTime) {
+                lruKey = key;
+                lruTime = record.lastUsedAt;
+            }
+        }
+        if (lruKey) {
+            const evictRecord = this.pools.get(lruKey);
+            if (evictRecord) {
+                try {
+                    await evictRecord.client.destroy();
+                    this.pools.delete(lruKey);
+                    console.log(`[SandboxPoolSO] Evicted LRU sandbox: ${lruKey}`);
+                }
+                catch (error) {
+                    console.error(`[SandboxPoolSO] Error evicting sandbox ${lruKey}:`, error);
+                }
+            }
+        }
+        else {
+            throw new Error("Cannot create new sandbox: max sandboxes reached and none are idle");
+        }
+    }
+    async cleanup() {
+        console.log(`[SandboxPoolSO] Cleaning up ${this.pools.size} sandbox(es)`);
+        const cleanupPromises = [];
+        for (const [key, record] of this.pools) {
+            cleanupPromises.push((async () => {
+                try {
+                    await record.client.destroy();
+                    console.log(`[SandboxPoolSO] Cleaned up sandbox: ${key}`);
+                }
+                catch (error) {
+                    console.error(`[SandboxPoolSO] Error cleaning up sandbox ${key}:`, error);
+                }
+            })());
+        }
+        await Promise.all(cleanupPromises);
+        this.pools.clear();
+        console.log("[SandboxPoolSO] All sandboxes cleaned up");
+    }
+    getPoolStatus() {
+        const status = {};
+        for (const [key, record] of this.pools) {
+            status[key] = {
+                refCount: record.refCount,
+                lastUsedAt: record.lastUsedAt,
+            };
+        }
+        return status;
+    }
+}

package/dist/domains/sandbox/sandbox-types.d.ts

@@ -0,0 +1,25 @@
+import type { Tool } from "@modelcontextprotocol/sdk/types.js";
+export interface SandboxExecuteResult {
+    exitCode: number;
+    result: string;
+}
+/**
+ * Sandbox Client Interface
+ * Unified abstraction for different sandbox providers (Daytona, E2B, Sandock)
+ */
+export interface SandboxClient {
+    initialize(): Promise<void>;
+    listTools(packageKey: string): Promise<Tool[]>;
+    executeTool(packageKey: string, toolName: string, args: Record<string, unknown>, envs?: Record<string, string>): Promise<unknown>;
+    destroy(): Promise<void>;
+}
+export type MCPSandboxProvider = "SANDOCK" | "DAYTONA" | "E2B" | "LOCAL";
+export interface MCPToolResult {
+    toolCount: number;
+    tools: Tool[];
+}
+export interface MCPExecuteResult {
+    result: unknown;
+    isError?: boolean;
+    errorMessage?: string;
+}

package/dist/domains/sandbox/sandbox-types.js

@@ -0,0 +1 @@
+export {};

package/dist/domains/sandbox/sandbox-utils.d.ts

@@ -0,0 +1,3 @@
+import type { MCPServerPackageConfig } from "../package/package-types";
+export declare function generateEnvVariables(env: MCPServerPackageConfig["env"], realEnvs?: Record<string, string>): string;
+export declare function generateMCPTestCode(mcpServerConfig: MCPServerPackageConfig, operation: "listTools" | "executeTool", toolName?: string, argumentsObj?: Record<string, unknown>, envs?: Record<string, string>): string;

package/dist/domains/sandbox/sandbox-utils.js

@@ -0,0 +1,109 @@
+export function generateEnvVariables(env, realEnvs) {
+    if (!env) {
+        return "";
+    }
+    const envEntries = Object.entries(env).map(([key, _]) => {
+        if (realEnvs === null || realEnvs === void 0 ? void 0 : realEnvs[key]) {
+            return `${JSON.stringify(key)}: ${JSON.stringify(realEnvs[key])}`;
+        }
+        return `${JSON.stringify(key)}: "mock_value"`;
+    });
+    return envEntries.join(",\n        ");
+}
+export function generateMCPTestCode(mcpServerConfig, operation, toolName, argumentsObj, envs) {
+    const commonCode = `
+import { Client } from "@modelcontextprotocol/sdk/client/index.js";
+import { StdioClientTransport } from "@modelcontextprotocol/sdk/client/stdio.js";
+
+async function runMCP() {
+  let client;
+  try {
+    const packageName = "${mcpServerConfig.packageName}";
+
+    const transport = new StdioClientTransport({
+      command: "pnpx",
+      args: ["--silent", packageName],
+      env: {
+        ...Object.fromEntries(
+          Object.entries(process.env).filter(([_, v]) => v !== undefined)
+        ),
+        PNPM_HOME: "/root/.local/share/pnpm",
+        PNPM_STORE_PATH: "/pnpm-store",
+        ${generateEnvVariables(mcpServerConfig.env, envs)}
+      },
+    });
+
+    client = new Client(
+      {
+        name: "mcp-server-${mcpServerConfig.packageName}-client",
+        version: "1.0.0",
+      },
+      {
+        capabilities: {
+          tools: {},
+        },
+      },
+    );
+
+    await client.connect(transport);
+`;
+    if (operation === "listTools") {
+        return `${commonCode}
+    const toolsObj = await client.listTools();
+
+    const result = {
+      toolCount: toolsObj.tools.length,
+      tools: toolsObj.tools
+    };
+
+    process.stdout.write(JSON.stringify(result));
+  } catch (error) {
+    console.error("Error in MCP test:", error);
+    process.exitCode = 1;
+    process.stdout.write(JSON.stringify({ error: error.message || "Unknown error occurred" }));
+  } finally {
+    if (client) {
+      try {
+        await client.close();
+      } catch (closeError) {
+        console.error("Error closing MCP client:", closeError);
+      }
+    }
+  }
+}
+
+runMCP();
+    `;
+    }
+    else {
+        return `${commonCode}
+
+    const result = await client.callTool({
+      name: "${toolName}",
+      arguments: ${JSON.stringify(argumentsObj)}
+    });
+
+    process.stdout.write(JSON.stringify(result));
+  } catch (error) {
+    console.error("Error in MCP test:", error);
+    process.exitCode = 1;
+    process.stdout.write(JSON.stringify({ 
+      result: null, 
+      isError: true, 
+      errorMessage: error.message 
+    }));
+  } finally {
+    if (client) {
+      try {
+        await client.close();
+      } catch (closeError) {
+        console.error("Error closing MCP client:", closeError);
+      }
+    }
+  }
+}
+
+runMCP();
+  `;
+    }
+}

package/dist/domains/search/search-handler.d.ts

@@ -0,0 +1,47 @@
+export declare const searchHandler: {
+    search: ({ q, limit, offset, category, }: {
+        q: string;
+        limit?: number;
+        offset?: number;
+        category?: string;
+    }) => Promise<{
+        success: boolean;
+        code: number;
+        message: string;
+    }>;
+    suggest: (q: string, limit?: number) => Promise<{
+        success: boolean;
+        code: number;
+        message: string;
+    }>;
+    getFacets: () => Promise<{
+        success: boolean;
+        code: number;
+        message: string;
+    }>;
+    healthCheck: () => Promise<{
+        success: boolean;
+        code: number;
+        message: string;
+    }>;
+    initialize: () => Promise<{
+        success: boolean;
+        code: number;
+        message: string;
+    }>;
+    indexPackages: () => Promise<{
+        success: boolean;
+        code: number;
+        message: string;
+    }>;
+    clearIndex: () => Promise<{
+        success: boolean;
+        code: number;
+        message: string;
+    }>;
+    getStats: () => Promise<{
+        success: boolean;
+        code: number;
+        message: string;
+    }>;
+};

package/dist/domains/search/search-handler.js

@@ -0,0 +1,113 @@
+import path from "node:path";
+import { getDirname } from "../../shared/utils/file-util";
+import { createErrorResponse, createResponse } from "../../shared/utils/response-util";
+import { SearchSO } from "./search-so";
+const __dirname = getDirname(import.meta.url);
+let searchSO = null;
+async function getSearchSO() {
+    if (!searchSO) {
+        searchSO = await SearchSO.getInstance();
+    }
+    return searchSO;
+}
+export const searchHandler = {
+    search: async ({ q, limit = 20, offset = 0, category, }) => {
+        try {
+            const filter = category ? `category = '${category}'` : undefined;
+            const so = await getSearchSO();
+            const results = await so.search(q, { limit, offset, filter });
+            return createResponse(results);
+        }
+        catch (error) {
+            console.error("Search failed:", error.stack);
+            return createErrorResponse(error.message || "Search failed", 500);
+        }
+    },
+    suggest: async (q, limit = 10) => {
+        try {
+            const so = await getSearchSO();
+            const suggestions = await so.suggest(q, limit);
+            return createResponse({ suggestions });
+        }
+        catch (error) {
+            console.error("Failed to get suggestions:", error.stack);
+            return createErrorResponse(error.message || "Failed to get suggestions", 400);
+        }
+    },
+    getFacets: async () => {
+        try {
+            const so = await getSearchSO();
+            const facets = await so.getFacets();
+            return createResponse({
+                categories: facets === null || facets === void 0 ? void 0 : facets.category,
+                authors: facets === null || facets === void 0 ? void 0 : facets.author,
+                validated: facets === null || facets === void 0 ? void 0 : facets.validated,
+            });
+        }
+        catch (error) {
+            console.error("Failed to get facets:", error.stack);
+            return createErrorResponse(error.message || "Failed to get facets", 500);
+        }
+    },
+    healthCheck: async () => {
+        try {
+            const so = await getSearchSO();
+            const health = await so.healthCheck();
+            return createResponse(health);
+        }
+        catch (error) {
+            console.error("Health check failed:", error.stack);
+            return createErrorResponse(error.message || "Health check failed", 500);
+        }
+    },
+    initialize: async () => {
+        try {
+            searchSO = await SearchSO.getInstance();
+            return createResponse({ message: "Search service initialized successfully" });
+        }
+        catch (error) {
+            console.error("Failed to initialize search service:", error.stack);
+            return createErrorResponse(error.message || "Failed to initialize search service", 500);
+        }
+    },
+    indexPackages: async () => {
+        try {
+            const so = await getSearchSO();
+            const packagesPath = path.join(__dirname, "../../../indexes/packages-list.json");
+            const stats = await so.indexPackages(packagesPath);
+            return createResponse({
+                message: `Indexed ${stats.numberOfDocuments} documents`,
+                details: stats,
+            });
+        }
+        catch (error) {
+            console.error("Failed to index packages:", error.stack);
+            return createErrorResponse(error.message || "Failed to index packages", 500);
+        }
+    },
+    clearIndex: async () => {
+        try {
+            const so = await getSearchSO();
+            await so.clearIndex();
+            return createResponse({ message: "Index cleared successfully" });
+        }
+        catch (error) {
+            console.error("Failed to clear index:", error.stack);
+            return createErrorResponse(error.message || "Failed to clear index", 500);
+        }
+    },
+    getStats: async () => {
+        try {
+            const so = await getSearchSO();
+            const stats = await so.getStats();
+            return createResponse({
+                message: "Index statistics retrieved successfully",
+                details: stats,
+            });
+        }
+        catch (error) {
+            console.error("Failed to get index statistics:", error.stack);
+            return createErrorResponse(error.message || "Failed to get index statistics", 500);
+        }
+    },
+};

package/dist/domains/search/search-route.d.ts

@@ -0,0 +1,2 @@
+import { OpenAPIHono } from "@hono/zod-openapi";
+export declare const searchRoutes: OpenAPIHono<import("hono").Env, {}, "/">;