@objekt.sh/mcp-upload 0.1.1 → 0.1.5

package/README.md

@@ -0,0 +1,34 @@
+# @objekt.sh/mcp-upload
+
+MCP server for uploading files to decentralised storage from Claude Desktop, Cursor, or any MCP client.
+
+## Setup
+
+Get a free API key at [objekt.sh/mcp](https://objekt.sh/mcp), then add to your MCP config:
+
+```json
+{
+  "mcpServers": {
+    "objekt": {
+      "command": "npx",
+      "args": ["-y", "@objekt.sh/mcp-upload"],
+      "env": {
+        "OBJEKT_API_KEY": "objekt_mcp_..."
+      }
+    }
+  }
+}
+```
+
+## Tools
+
+| Tool | Description |
+|------|-------------|
+| `upload_file` | Upload by host path or inline content |
+| `upload_from_sandbox` | Returns curl command for sandbox uploads |
+| `get_file` | Get file metadata and permalink |
+| `get_pricing` | Current storage tier pricing |
+
+## Docs
+
+[objekt.sh/mcp](https://objekt.sh/mcp) — setup, pricing, best practices.

package/dist/index.js

@@ -27,8 +27,9 @@ function mimeFromPath(filePath) {
   return MIME_MAP[extname(filePath).toLowerCase()] ?? "application/octet-stream";
 }
 var MAX_CONTENT_BYTES = 500 * 1024;
+var VERSION = "0.1.5";
 var server = new McpServer(
-  { name: "Objekt.sh", version: "0.1.0" },
+  { name: "Objekt.sh", version: VERSION },
   {
     instructions: [
       "Objekt.sh uploads files to decentralised storage (CDN, IPFS, Arweave).",
@@ -94,7 +95,8 @@ For files at CONTAINER paths (e.g. /mnt/user-data/): use the upload_from_sandbox
         isError: true
       };
     }
-    let dataURL;
+    let fileBytes;
+    let fileMime;
     let fileName;
     if (filePath) {
       if (filePath.startsWith("/mnt/") || filePath.startsWith("/sandbox/") || filePath.startsWith("/tmp/sandbox")) {
@@ -119,13 +121,12 @@ For files at CONTAINER paths (e.g. /mnt/user-data/): use the upload_from_sandbox
           isError: true
         };
       }
-      const bytes = await readFile(absPath);
-      const mime = mimeFromPath(absPath);
+      const buffer = await readFile(absPath);
+      fileBytes = new Uint8Array(buffer);
+      fileMime = mimeFromPath(absPath);
       fileName = customName ?? basename(absPath);
-      const b64 = bytes.toString("base64");
-      dataURL = `data:${mime};base64,${b64}`;
     } else if (content && content_type) {
-      if (content.length > MAX_CONTENT_BYTES) {
+      if (Buffer.byteLength(content) > MAX_CONTENT_BYTES) {
         return {
           content: [
             {
@@ -148,11 +149,11 @@ For files at CONTAINER paths (e.g. /mnt/user-data/): use the upload_from_sandbox
         };
       }
       fileName = customName;
+      fileMime = content_type;
       if (encoding === "raw") {
-        const b64 = Buffer.from(content).toString("base64");
-        dataURL = `data:${content_type};base64,${b64}`;
+        fileBytes = new Uint8Array(Buffer.from(content));
       } else {
-        dataURL = `data:${content_type};base64,${content}`;
+        fileBytes = new Uint8Array(Buffer.from(content, "base64"));
       }
     } else {
       return {
@@ -165,13 +166,12 @@ For files at CONTAINER paths (e.g. /mnt/user-data/): use the upload_from_sandbox
         isError: true
       };
     }
+    const form = new FormData();
+    form.append("file", new Blob([fileBytes], { type: fileMime }), fileName);
     const res = await fetch(`${GATEWAY_URL}/${fileName}`, {
       method: "PUT",
-      headers: {
-        "Content-Type": "application/json",
-        Authorization: `Bearer ${API_KEY}`
-      },
-      body: JSON.stringify({ dataURL })
+      headers: { Authorization: `Bearer ${API_KEY}` },
+      body: form
     });
     if (!res.ok) {
       const text = await res.text();
@@ -207,7 +207,7 @@ server.registerTool(
   "upload_from_sandbox",
   {
     title: "Upload from Sandbox",
-    description: "Upload a file from a sandbox environment (e.g. Claude Desktop VM, claude.ai container). Returns a bash command to run in the sandbox shell. Use this when the file is at a sandbox path like /mnt/user-data/ that the host cannot access.",
+    description: "Upload a file from a sandbox/container path (e.g. /mnt/user-data/, /home/claude/) that the host cannot access. Reads the file and uploads it directly \u2014 single tool call, no shell commands needed.",
     inputSchema: z.object({
       sandbox_path: z.string().describe(
         "Path to the file inside the sandbox (e.g. /mnt/user-data/uploads/photo.png)"
@@ -218,8 +218,8 @@ server.registerTool(
     }),
     annotations: {
       title: "Upload from Sandbox",
-      readOnlyHint: true,
-      openWorldHint: false
+      readOnlyHint: false,
+      openWorldHint: true
     }
   },
   async ({ sandbox_path, name: customName }) => {
@@ -235,20 +235,54 @@ server.registerTool(
       };
     }
     const fileName = customName ?? basename(sandbox_path);
-    const mime = mimeFromPath(sandbox_path);
-    const cmd = `curl -s -X PUT "${GATEWAY_URL}/${fileName}" \\
-  -H "Content-Type: application/json" \\
-  -H "Authorization: Bearer ${API_KEY}" \\
-  -d "{\\"dataURL\\":\\"data:${mime};base64,$(base64 -w0 "${sandbox_path}" 2>/dev/null || base64 -i "${sandbox_path}")\\"}"`;
+    const fileMime = mimeFromPath(sandbox_path);
+    let fileBytes;
+    try {
+      const buffer = await readFile(sandbox_path);
+      fileBytes = new Uint8Array(buffer);
+    } catch {
+      return {
+        content: [
+          {
+            type: "text",
+            text: `File not found or not readable: ${sandbox_path}`
+          }
+        ],
+        isError: true
+      };
+    }
+    const form = new FormData();
+    form.append("file", new Blob([fileBytes], { type: fileMime }), fileName);
+    const res = await fetch(`${GATEWAY_URL}/${fileName}`, {
+      method: "PUT",
+      headers: { Authorization: `Bearer ${API_KEY}` },
+      body: form
+    });
+    if (!res.ok) {
+      const text = await res.text();
+      return {
+        content: [
+          {
+            type: "text",
+            text: `Upload failed (${res.status}): ${text}`
+          }
+        ],
+        isError: true
+      };
+    }
+    const data = await res.json();
     return {
       content: [
+        {
+          type: "resource_link",
+          uri: data.permalink,
+          name: data.name,
+          mimeType: data.kind
+        },
         {
           type: "text",
-          text: `Run this command in your shell to upload the file:
-
-${cmd}
-
-This reads the file from the container filesystem and uploads it directly to objekt.sh.`
+          text: `Uploaded ${data.name} (${data.kind}, ${data.bytes} bytes)
+${data.permalink}`
         }
       ]
     };
@@ -330,5 +364,98 @@ server.registerTool(
     };
   }
 );
+server.registerTool(
+  "check_connection",
+  {
+    title: "Check Connection",
+    description: "Test connectivity to api.objekt.sh. Use this to diagnose sandbox egress issues. If it fails, the user needs to add api.objekt.sh to their domain allowlist (Settings \u2192 Capabilities \u2192 Domain Allowlist).",
+    inputSchema: z.object({}),
+    annotations: {
+      title: "Check Connection",
+      readOnlyHint: true,
+      openWorldHint: true
+    }
+  },
+  async () => {
+    const checks = {
+      gateway: GATEWAY_URL,
+      apiKey: API_KEY ? "set" : "missing",
+      egress: "unknown",
+      latencyMs: 0
+    };
+    const start = Date.now();
+    try {
+      const res = await fetch(`${GATEWAY_URL}/pricing`, {
+        signal: AbortSignal.timeout(1e4)
+      });
+      checks.latencyMs = Date.now() - start;
+      checks.egress = res.ok ? "ok" : `http_${res.status}`;
+    } catch {
+      checks.latencyMs = Date.now() - start;
+      checks.egress = "blocked";
+    }
+    if (checks.egress === "blocked") {
+      return {
+        content: [
+          {
+            type: "text",
+            text: `Cannot reach ${GATEWAY_URL}
+
+This usually means network egress is blocked. To fix:
+1. Go to Settings \u2192 Capabilities
+2. Enable "Allow network egress"
+3. Under Domain Allowlist, add: api.objekt.sh
+
+API key: ${checks.apiKey}`
+          }
+        ],
+        isError: true
+      };
+    }
+    if (checks.apiKey === "missing") {
+      return {
+        content: [
+          {
+            type: "text",
+            text: `Egress: ${checks.egress} (${checks.latencyMs}ms)
+API key: missing \u2014 set OBJEKT_API_KEY in your MCP server config. Get a key at objekt.sh/mcp`
+          }
+        ],
+        isError: true
+      };
+    }
+    return {
+      content: [
+        {
+          type: "text",
+          text: `Egress: ${checks.egress} (${checks.latencyMs}ms)
+Gateway: ${checks.gateway}
+API key: ${checks.apiKey}`
+        }
+      ]
+    };
+  }
+);
+server.registerTool(
+  "get_version",
+  {
+    title: "Get Version",
+    description: "Returns the installed version of the Objekt.sh MCP server.",
+    inputSchema: z.object({}),
+    annotations: {
+      title: "Get Version",
+      readOnlyHint: true,
+      openWorldHint: false
+    }
+  },
+  async () => ({
+    content: [
+      {
+        type: "text",
+        text: `objekt.sh/mcp-upload v${VERSION}`
+      }
+    ]
+  })
+);
 var transport = new StdioServerTransport();
 await server.connect(transport);

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@objekt.sh/mcp-upload",
-  "version": "0.1.1",
+  "version": "0.1.5",
   "mcpName": "sh.objekt/mcp-upload",
   "description": "MCP server for uploading files to objekt.sh from Claude Desktop, Cursor, and other MCP clients.",
   "repository": {
@@ -12,7 +12,8 @@
     "mcp-upload": "./dist/index.js"
   },
   "files": [
-    "dist"
+    "dist",
+    "README.md"
   ],
   "dependencies": {
     "@modelcontextprotocol/sdk": "^1.29.0",