@yukkit/e2b-mcp-server 0.2.2 → 0.4.0

package/README.md

@@ -22,7 +22,7 @@ This server implements the [Model Context Protocol (MCP)](https://modelcontextpr
 
 ## Features
 
-- **8 Production-Ready Tools**: Complete toolkit for sandbox interaction
+- **10 Production-Ready Tools**: Complete toolkit for sandbox interaction
 - **Resource Management**: Automatic sandbox lifecycle management with configurable limits (default: 10 concurrent sandboxes)
 - **Robust Error Handling**: Custom error classes for clear diagnostics (SandboxError, SandboxNotFoundError, SandboxLimitExceededError)
 - **Production Logging**: Multi-level logging system (DEBUG, INFO, WARNING, ERROR) with timestamps
@@ -168,7 +168,30 @@ Get a public URL for accessing a service running in a sandbox.
 - `port`: Port number (1-65535)
 - `sandboxId`: Target sandbox ID
 
-### 8. kill_sandbox
+### 8. get_file_download_url
+
+Get a download URL for a file in the sandbox.
+
+**Parameters:**
+
+- `filePath`: Path to the file
+- `sandboxId`: Target sandbox ID
+
+### 9. list_sandbox_ids
+
+List all active sandbox IDs and get sandbox statistics.
+
+**Parameters:**
+
+None
+
+**Returns:**
+
+- `sandbox_ids`: Array of active sandbox IDs
+- `active_sandboxes`: Current number of active sandboxes
+- `max_sandboxes`: Maximum allowed sandboxes
+
+### 10. kill_sandbox
 
 Terminate a sandbox and clean up resources.
 

package/build/index.js

@@ -64,9 +64,14 @@ const getSandboxUrlSchema = z.object({
     port: z.number().min(1).max(65535).describe("Port number"),
     sandboxId: z.string().describe("Sandbox ID"),
 });
+const getFileDownloadUrlSchema = z.object({
+    filePath: z.string().min(1).describe("Path to the file"),
+    sandboxId: z.string().describe("Sandbox ID"),
+});
 const killSandboxSchema = z.object({
     sandboxId: z.string().describe("Sandbox ID"),
 });
+const listSandboxIdsSchema = z.object({});
 // Custom Errors
 class SandboxError extends Error {
     constructor(message) {
@@ -263,11 +268,21 @@ class E2BServer {
                     description: "Get the URL for a sandbox on a specific port",
                     inputSchema: zodToJsonSchema(getSandboxUrlSchema),
                 },
+                {
+                    name: "get_file_download_url",
+                    description: "Get a download URL for a file in the sandbox",
+                    inputSchema: zodToJsonSchema(getFileDownloadUrlSchema),
+                },
                 {
                     name: "kill_sandbox",
                     description: "Kill a sandbox",
                     inputSchema: zodToJsonSchema(killSandboxSchema),
                 },
+                {
+                    name: "list_sandbox_ids",
+                    description: "List all active sandbox IDs and statistics",
+                    inputSchema: zodToJsonSchema(listSandboxIdsSchema),
+                },
             ],
         }));
         this.server.setRequestHandler(CallToolRequestSchema, async (request) => {
@@ -284,12 +299,16 @@ class E2BServer {
                         return await this.handleWriteFile(request.params.arguments);
                     case "list_files":
                         return await this.handleListFiles(request.params.arguments);
+                    case "get_file_download_url":
+                        return await this.handleGetFileDownloadUrl(request.params.arguments);
                     case "run_code":
                         return await this.handleRunCode(request.params.arguments);
                     case "get_sandbox_url":
                         return await this.handleGetSandboxUrl(request.params.arguments);
                     case "kill_sandbox":
                         return await this.handleKillSandbox(request.params.arguments);
+                    case "list_sandbox_ids":
+                        return await this.handleListSandboxIds(request.params.arguments);
                     default:
                         throw new McpError(ErrorCode.MethodNotFound, `Unknown tool: ${request.params.name}`);
                 }
@@ -318,7 +337,6 @@ class E2BServer {
         const result = {
             sandboxId,
             message: `Sandbox created successfully with timeout ${timeout}ms`,
-            stats: this.sandboxManager.getStats(),
         };
         return {
             content: [
@@ -519,6 +537,31 @@ class E2BServer {
             throw new SandboxError(`Failed to get sandbox URL: ${error}`);
         }
     }
+    async handleGetFileDownloadUrl(args) {
+        const parsed = getFileDownloadUrlSchema.parse(args);
+        const sandbox = this.sandboxManager.getSandbox(parsed.sandboxId);
+        try {
+            const url = sandbox.downloadUrl(parsed.filePath);
+            const result = {
+                sandboxId: parsed.sandboxId,
+                filePath: parsed.filePath,
+                url,
+            };
+            logger.info(`Got download URL for file ${parsed.filePath} in sandbox ${parsed.sandboxId}`);
+            return {
+                content: [
+                    {
+                        type: "text",
+                        text: JSON.stringify(result, null, 2),
+                    },
+                ],
+            };
+        }
+        catch (error) {
+            logger.error(`Error getting file download URL: ${error}`);
+            throw new SandboxError(`Failed to get file download URL: ${error}`);
+        }
+    }
     async handleKillSandbox(args) {
         const parsed = killSandboxSchema.parse(args);
         await this.sandboxManager.killSandbox(parsed.sandboxId);
@@ -536,6 +579,24 @@ class E2BServer {
             ],
         };
     }
+    async handleListSandboxIds(args) {
+        listSandboxIdsSchema.parse(args);
+        const stats = this.sandboxManager.getStats();
+        const result = {
+            sandbox_ids: stats.sandbox_ids,
+            active_sandboxes: stats.active_sandboxes,
+            max_sandboxes: stats.max_sandboxes,
+        };
+        logger.info(`Listed ${stats.active_sandboxes} active sandboxes`);
+        return {
+            content: [
+                {
+                    type: "text",
+                    text: JSON.stringify(result, null, 2),
+                },
+            ],
+        };
+    }
     async run() {
         const transport = new StdioServerTransport();
         await this.server.connect(transport);

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@yukkit/e2b-mcp-server",
-  "version": "0.2.2",
+  "version": "0.4.0",
   "description": "A Model Context Protocol server",
   "repository": {
     "type": "git",