@objekt.sh/mcp-upload 0.1.1

package/LICENSE

@@ -0,0 +1,17 @@
+GNU AFFERO GENERAL PUBLIC LICENSE
+Version 3, 19 November 2007
+
+Copyright (C) 2026 0xLighthouse
+
+This program is free software: you can redistribute it and/or modify
+it under the terms of the GNU Affero General Public License as published by
+the Free Software Foundation, either version 3 of the License, or
+(at your option) any later version.
+
+This program is distributed in the hope that it will be useful,
+but WITHOUT ANY WARRANTY; without even the implied warranty of
+MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
+GNU Affero General Public License for more details.
+
+You should have received a copy of the GNU Affero General Public License
+along with this program. If not, see <https://www.gnu.org/licenses/>.

package/dist/index.js

@@ -0,0 +1,334 @@
+#!/usr/bin/env node
+
+// src/index.ts
+import { readFile, stat } from "fs/promises";
+import { basename, extname, resolve } from "path";
+import { McpServer } from "@modelcontextprotocol/sdk/server/mcp.js";
+import { StdioServerTransport } from "@modelcontextprotocol/sdk/server/stdio.js";
+import { z } from "zod";
+var GATEWAY_URL = process.env.OBJEKT_GATEWAY_URL ?? "https://api.objekt.sh";
+var API_KEY = process.env.OBJEKT_API_KEY ?? "";
+var MIME_MAP = {
+  ".jpg": "image/jpeg",
+  ".jpeg": "image/jpeg",
+  ".png": "image/png",
+  ".webp": "image/webp",
+  ".gif": "image/gif",
+  ".svg": "image/svg+xml",
+  ".pdf": "application/pdf",
+  ".html": "text/html",
+  ".css": "text/css",
+  ".js": "application/javascript",
+  ".json": "application/json",
+  ".txt": "text/plain",
+  ".md": "text/markdown"
+};
+function mimeFromPath(filePath) {
+  return MIME_MAP[extname(filePath).toLowerCase()] ?? "application/octet-stream";
+}
+var MAX_CONTENT_BYTES = 500 * 1024;
+var server = new McpServer(
+  { name: "Objekt.sh", version: "0.1.0" },
+  {
+    instructions: [
+      "Objekt.sh uploads files to decentralised storage (CDN, IPFS, Arweave).",
+      "",
+      "Encoding: use 'raw' for text formats (SVG, HTML, CSS, JSON, Markdown) \u2014 no base64 overhead.",
+      "Use 'base64' (default) for binary formats (PNG, JPEG, WebP, GIF, PDF).",
+      "",
+      "Supported formats: JPEG, PNG, WebP, GIF, SVG, PDF (up to 5MB via path, 500KB via content).",
+      "For host filesystem files, ALWAYS prefer the 'path' parameter \u2014 reads from disk, zero token cost.",
+      "Inline 'content' is capped at 500KB to avoid wasting tokens. Use 'path' for anything larger.",
+      "",
+      "Uploaded files return a permalink. Use get_file to check if a file already exists before re-uploading."
+    ].join("\n")
+  }
+);
+server.registerTool(
+  "upload_file",
+  {
+    title: "Upload File",
+    description: `Upload a file to objekt.sh storage. Accepts a host file path OR base64/raw content.
+
+For files on the HOST filesystem (e.g. /Users/name/photo.png): use 'path' \u2014 reads from disk, fastest.
+For files you have in memory: use 'content' + 'content_type'.
+For files at CONTAINER paths (e.g. /mnt/user-data/): use the upload_from_sandbox tool instead.`,
+    inputSchema: z.object({
+      path: z.string().optional().describe(
+        "Absolute path to the file on the HOST filesystem (e.g. /Users/you/photo.png). Do NOT use container paths like /mnt/user-data/."
+      ),
+      content: z.string().optional().describe(
+        "File content \u2014 base64-encoded for binaries, raw UTF-8 for text. Use this when the file path is not accessible from the host filesystem."
+      ),
+      content_type: z.string().optional().describe(
+        "MIME type (required with content, e.g. 'image/png'). Auto-detected when using path."
+      ),
+      encoding: z.enum(["base64", "raw"]).optional().describe(
+        "Content encoding. Default 'base64'. Use 'raw' for text types like SVG, HTML, CSS, JSON."
+      ),
+      name: z.string().optional().describe(
+        "Filename for the upload. Auto-detected from 'path'. Required when using 'content'."
+      )
+    }),
+    annotations: {
+      title: "Upload File",
+      readOnlyHint: false,
+      openWorldHint: true
+    }
+  },
+  async ({
+    path: filePath,
+    content,
+    content_type,
+    encoding = "base64",
+    name: customName
+  }) => {
+    if (!API_KEY) {
+      return {
+        content: [
+          {
+            type: "text",
+            text: "OBJEKT_API_KEY not set. Get a free key at objekt.sh/mcp"
+          }
+        ],
+        isError: true
+      };
+    }
+    let dataURL;
+    let fileName;
+    if (filePath) {
+      if (filePath.startsWith("/mnt/") || filePath.startsWith("/sandbox/") || filePath.startsWith("/tmp/sandbox")) {
+        return {
+          content: [
+            {
+              type: "text",
+              text: `"${filePath}" is a sandbox path \u2014 this tool runs on the host and cannot access it. Use upload_from_sandbox for sandbox files, or pass the content directly via the "content" parameter with "encoding": "raw" for text files or "base64" for binaries.`
+            }
+          ],
+          isError: true
+        };
+      }
+      const absPath = resolve(filePath);
+      try {
+        await stat(absPath);
+      } catch {
+        return {
+          content: [
+            { type: "text", text: `File not found: ${absPath}` }
+          ],
+          isError: true
+        };
+      }
+      const bytes = await readFile(absPath);
+      const mime = 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) {
+        return {
+          content: [
+            {
+              type: "text",
+              text: `Content too large (${(content.length / 1024).toFixed(0)}KB). Inline content is capped at ${MAX_CONTENT_BYTES / 1024}KB to avoid burning tokens. Use the 'path' parameter instead \u2014 it reads from disk with zero token overhead.`
+            }
+          ],
+          isError: true
+        };
+      }
+      if (!customName) {
+        return {
+          content: [
+            {
+              type: "text",
+              text: "'name' is required when using 'content' mode (e.g. 'diagram.svg'). Auto-detected only with 'path'."
+            }
+          ],
+          isError: true
+        };
+      }
+      fileName = customName;
+      if (encoding === "raw") {
+        const b64 = Buffer.from(content).toString("base64");
+        dataURL = `data:${content_type};base64,${b64}`;
+      } else {
+        dataURL = `data:${content_type};base64,${content}`;
+      }
+    } else {
+      return {
+        content: [
+          {
+            type: "text",
+            text: "Provide either 'path' (file path on host) or 'content' + 'content_type' (base64/raw content)."
+          }
+        ],
+        isError: true
+      };
+    }
+    const res = await fetch(`${GATEWAY_URL}/${fileName}`, {
+      method: "PUT",
+      headers: {
+        "Content-Type": "application/json",
+        Authorization: `Bearer ${API_KEY}`
+      },
+      body: JSON.stringify({ dataURL })
+    });
+    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: `Uploaded ${data.name} (${data.kind}, ${data.bytes} bytes)
+${data.permalink}`
+        }
+      ]
+    };
+  }
+);
+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.",
+    inputSchema: z.object({
+      sandbox_path: z.string().describe(
+        "Path to the file inside the sandbox (e.g. /mnt/user-data/uploads/photo.png)"
+      ),
+      name: z.string().optional().describe(
+        "Custom name for the uploaded file. Defaults to the filename."
+      )
+    }),
+    annotations: {
+      title: "Upload from Sandbox",
+      readOnlyHint: true,
+      openWorldHint: false
+    }
+  },
+  async ({ sandbox_path, name: customName }) => {
+    if (!API_KEY) {
+      return {
+        content: [
+          {
+            type: "text",
+            text: "OBJEKT_API_KEY not set. Get a free key at objekt.sh/mcp"
+          }
+        ],
+        isError: true
+      };
+    }
+    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}")\\"}"`;
+    return {
+      content: [
+        {
+          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.`
+        }
+      ]
+    };
+  }
+);
+server.registerTool(
+  "get_file",
+  {
+    title: "Get File",
+    description: "Get a file from objekt.sh by name. Returns a link to the file without downloading the content.",
+    inputSchema: z.object({
+      name: z.string().describe("File name/key (e.g. 'photo.png')")
+    }),
+    annotations: {
+      title: "Get File",
+      readOnlyHint: true,
+      openWorldHint: false
+    }
+  },
+  async ({ name }) => {
+    const res = await fetch(`${GATEWAY_URL}/${name}`, {
+      method: "HEAD",
+      headers: API_KEY ? { Authorization: `Bearer ${API_KEY}` } : {}
+    });
+    if (!res.ok) {
+      return {
+        content: [
+          {
+            type: "text",
+            text: `File not found: ${name} (${res.status})`
+          }
+        ],
+        isError: true
+      };
+    }
+    const contentType = res.headers.get("content-type") ?? "application/octet-stream";
+    const size = res.headers.get("content-length") ?? "unknown";
+    const url = `${GATEWAY_URL}/${name}`;
+    return {
+      content: [
+        {
+          type: "resource_link",
+          uri: url,
+          name,
+          mimeType: contentType
+        },
+        {
+          type: "text",
+          text: `${name} \u2014 ${contentType}, ${size} bytes
+${url}`
+        }
+      ]
+    };
+  }
+);
+server.registerTool(
+  "get_pricing",
+  {
+    title: "Get Pricing",
+    description: "Get current storage pricing and limits from objekt.sh.",
+    inputSchema: z.object({}),
+    annotations: {
+      title: "Get Pricing",
+      readOnlyHint: true,
+      openWorldHint: false
+    }
+  },
+  async () => {
+    const res = await fetch(`${GATEWAY_URL}/pricing`);
+    if (!res.ok) {
+      return {
+        content: [{ type: "text", text: "Failed to fetch pricing" }],
+        isError: true
+      };
+    }
+    const data = await res.json();
+    return {
+      content: [{ type: "text", text: JSON.stringify(data, null, 2) }]
+    };
+  }
+);
+var transport = new StdioServerTransport();
+await server.connect(transport);

package/package.json

@@ -0,0 +1,34 @@
+{
+  "name": "@objekt.sh/mcp-upload",
+  "version": "0.1.1",
+  "mcpName": "sh.objekt/mcp-upload",
+  "description": "MCP server for uploading files to objekt.sh from Claude Desktop, Cursor, and other MCP clients.",
+  "repository": {
+    "type": "git",
+    "url": "https://github.com/0xLighthouse/objekt-mcp-upload.git"
+  },
+  "type": "module",
+  "bin": {
+    "mcp-upload": "./dist/index.js"
+  },
+  "files": [
+    "dist"
+  ],
+  "dependencies": {
+    "@modelcontextprotocol/sdk": "^1.29.0",
+    "zod": "^3.25.0"
+  },
+  "devDependencies": {
+    "tsup": "^8.5.1",
+    "tsx": "^4.21.0",
+    "typescript": "^5.8.2"
+  },
+  "publishConfig": {
+    "access": "public"
+  },
+  "scripts": {
+    "build": "tsup src/index.ts --format esm",
+    "dev": "tsx src/index.ts",
+    "lint": "biome check"
+  }
+}