easysend-mcp 1.0.1

package/README.md

@@ -0,0 +1,54 @@
+# easysend-mcp
+
+EasySend file sharing plugin for Claude Code. Upload, download, and share files directly from your AI assistant session.
+
+## Install
+
+Add to your Claude Code settings (`~/.claude/settings.json`):
+
+```json
+{
+    "mcpServers": {
+        "easysend": {
+            "command": "npx",
+            "args": ["easysend-mcp"]
+        }
+    }
+}
+```
+
+Or install globally:
+
+```bash
+npm install -g easysend-mcp
+```
+
+## Tools
+
+| Tool | Description |
+|------|-------------|
+| `upload_files` | Upload files and get a share link |
+| `get_bundle` | Get bundle info (files, sizes, expiry) |
+| `download_file` | Download a file by ID |
+| `download_bundle` | Download all files in a bundle |
+| `delete_file` | Delete a file (requires upload_token) |
+| `bundle_status` | Quick status check |
+
+## Usage Examples
+
+In Claude Code, just ask naturally:
+
+- "Upload report.pdf to EasySend"
+- "Share all the CSV files in this directory"
+- "What files are in easysend.co/Ab3Kz?"
+- "Download the files from that EasySend bundle"
+
+## No API Key Required
+
+EasySend's API is free and public. No authentication needed for uploads.
+
+## Links
+
+- Website: https://easysend.co
+- API Docs: https://easysend.co/api
+- MCP Docs: https://easysend.co/mcp

package/index.js

@@ -0,0 +1,340 @@
+#!/usr/bin/env node
+
+/**
+ * EasySend MCP Server  -  File sharing tools for Claude Code
+ * Upload, download, and share files via easysend.co
+ */
+
+import { Server } from '@modelcontextprotocol/sdk/server/index.js';
+import { StdioServerTransport } from '@modelcontextprotocol/sdk/server/stdio.js';
+import {
+    CallToolRequestSchema,
+    ListToolsRequestSchema,
+} from '@modelcontextprotocol/sdk/types.js';
+import { readFile, writeFile, stat } from 'node:fs/promises';
+import { basename, resolve, join } from 'node:path';
+import { createReadStream } from 'node:fs';
+
+const API = 'https://easysend.co/api/v1';
+
+// --- Tool definitions ---
+const TOOLS = [
+    {
+        name: 'upload_files',
+        description: 'Upload one or more files to EasySend and get a shareable link. No authentication required. Accepts any file type up to 1GB total.',
+        inputSchema: {
+            type: 'object',
+            properties: {
+                files: {
+                    type: 'array',
+                    items: { type: 'string' },
+                    description: 'Array of absolute file paths to upload',
+                },
+                description: {
+                    type: 'string',
+                    description: 'Optional note/description visible to recipients',
+                },
+            },
+            required: ['files'],
+        },
+    },
+    {
+        name: 'get_bundle',
+        description: 'Get information about an EasySend bundle  -  file list, sizes, download counts, expiry time.',
+        inputSchema: {
+            type: 'object',
+            properties: {
+                short_code: {
+                    type: 'string',
+                    description: 'The bundle code from the share URL (e.g. "Ab3Kz" from easysend.co/Ab3Kz)',
+                },
+            },
+            required: ['short_code'],
+        },
+    },
+    {
+        name: 'download_file',
+        description: 'Download a single file from an EasySend bundle by file ID and save it to disk.',
+        inputSchema: {
+            type: 'object',
+            properties: {
+                file_id: { type: 'number', description: 'The file ID from bundle info' },
+                save_path: { type: 'string', description: 'Optional path to save the file (default: current directory with original name)' },
+            },
+            required: ['file_id'],
+        },
+    },
+    {
+        name: 'download_bundle',
+        description: 'Download ALL files from an EasySend bundle to a local directory.',
+        inputSchema: {
+            type: 'object',
+            properties: {
+                short_code: { type: 'string', description: 'The bundle code' },
+                save_dir: { type: 'string', description: 'Directory to save files (default: current directory)' },
+            },
+            required: ['short_code'],
+        },
+    },
+    {
+        name: 'delete_file',
+        description: 'Delete a file from an EasySend bundle. Requires the upload_token returned during upload.',
+        inputSchema: {
+            type: 'object',
+            properties: {
+                file_id: { type: 'number', description: 'The file ID to delete' },
+                upload_token: { type: 'string', description: 'The upload token for authorization' },
+            },
+            required: ['file_id', 'upload_token'],
+        },
+    },
+    {
+        name: 'bundle_status',
+        description: 'Quick status check on an EasySend bundle  -  is it alive or expired, space remaining.',
+        inputSchema: {
+            type: 'object',
+            properties: {
+                short_code: { type: 'string', description: 'The bundle code' },
+            },
+            required: ['short_code'],
+        },
+    },
+];
+
+// --- Tool handlers ---
+
+async function handleUpload(args) {
+    const { files, description } = args;
+
+    if (!files || files.length === 0) {
+        return { content: [{ type: 'text', text: 'Error: No files specified.' }] };
+    }
+
+    // Validate files exist
+    for (const f of files) {
+        try {
+            await stat(resolve(f));
+        } catch {
+            return { content: [{ type: 'text', text: `Error: File not found: ${f}` }] };
+        }
+    }
+
+    // Build multipart form data manually
+    const boundary = '----EasySendMCP' + Date.now();
+    const parts = [];
+
+    for (const filePath of files) {
+        const absPath = resolve(filePath);
+        const name = basename(absPath);
+        const data = await readFile(absPath);
+        parts.push(
+            `--${boundary}\r\n` +
+            `Content-Disposition: form-data; name="files[]"; filename="${name}"\r\n` +
+            `Content-Type: application/octet-stream\r\n\r\n`
+        );
+        parts.push(data);
+        parts.push('\r\n');
+    }
+
+    if (description) {
+        parts.push(
+            `--${boundary}\r\n` +
+            `Content-Disposition: form-data; name="description"\r\n\r\n` +
+            description + '\r\n'
+        );
+    }
+
+    parts.push(`--${boundary}--\r\n`);
+
+    // Combine parts into a single buffer
+    const buffers = parts.map(p => typeof p === 'string' ? Buffer.from(p) : p);
+    const body = Buffer.concat(buffers);
+
+    const response = await fetch(`${API}/upload`, {
+        method: 'POST',
+        headers: { 'Content-Type': `multipart/form-data; boundary=${boundary}` },
+        body,
+    });
+
+    const data = await response.json();
+
+    if (!data.success) {
+        return { content: [{ type: 'text', text: `Upload failed: ${data.error || 'Unknown error'}` }] };
+    }
+
+    const shareUrl = `https://easysend.co/${data.short_code}`;
+    const text = [
+        `Uploaded ${files.length} file(s)!`,
+        `Share URL: ${shareUrl}`,
+        `Upload token: ${data.upload_token}`,
+        `Expires: ${data.expires_at || '3 days'}`,
+    ].join('\n');
+
+    return { content: [{ type: 'text', text }] };
+}
+
+async function handleGetBundle(args) {
+    const { short_code } = args;
+    const response = await fetch(`${API}/bundle/${encodeURIComponent(short_code)}`);
+    const data = await response.json();
+
+    if (!data.success) {
+        return { content: [{ type: 'text', text: `Error: ${data.error || 'Bundle not found'}` }] };
+    }
+
+    const lines = [
+        `Bundle: ${data.short_code}`,
+        `Files: ${data.file_count}`,
+        `Total size: ${formatSize(data.total_size_bytes)}`,
+        `Expires: ${data.expires_at}`,
+        `Expired: ${data.is_expired ? 'Yes' : 'No'}`,
+        `Encrypted: ${data.is_encrypted ? 'Yes' : 'No'}`,
+        `Views: ${data.view_count}`,
+        data.description ? `Note: ${data.description}` : null,
+        '',
+        'Files:',
+        ...data.files.map((f, i) =>
+            `  ${i + 1}. ${f.name} (${formatSize(f.size)})  -  ID: ${f.id}, Downloads: ${f.download_count}`
+        ),
+    ].filter(Boolean);
+
+    return { content: [{ type: 'text', text: lines.join('\n') }] };
+}
+
+async function handleDownloadFile(args) {
+    const { file_id, save_path } = args;
+
+    // First get file info from a bundle lookup isn't needed  -  just download
+    const response = await fetch(`${API}/download/${file_id}`);
+
+    if (!response.ok) {
+        return { content: [{ type: 'text', text: `Error: File not found or expired (HTTP ${response.status})` }] };
+    }
+
+    // Get filename from Content-Disposition header
+    const disposition = response.headers.get('content-disposition') || '';
+    const match = disposition.match(/filename="([^"]+)"/);
+    const fileName = match ? match[1] : `file_${file_id}`;
+
+    const saveTo = save_path ? resolve(save_path) : resolve(fileName);
+    const buffer = Buffer.from(await response.arrayBuffer());
+    await writeFile(saveTo, buffer);
+
+    return { content: [{ type: 'text', text: `Downloaded: ${saveTo} (${formatSize(buffer.length)})` }] };
+}
+
+async function handleDownloadBundle(args) {
+    const { short_code, save_dir } = args;
+
+    // Get bundle info
+    const infoRes = await fetch(`${API}/bundle/${encodeURIComponent(short_code)}`);
+    const info = await infoRes.json();
+
+    if (!info.success) {
+        return { content: [{ type: 'text', text: `Error: ${info.error || 'Bundle not found'}` }] };
+    }
+
+    if (info.is_encrypted) {
+        return { content: [{ type: 'text', text: 'Error: Cannot download encrypted bundles  -  files must be decrypted in the browser.' }] };
+    }
+
+    const dir = save_dir ? resolve(save_dir) : process.cwd();
+    const savedFiles = [];
+
+    for (const file of info.files) {
+        const response = await fetch(`${API}/download/${file.id}`);
+        if (!response.ok) continue;
+
+        const saveTo = join(dir, file.name);
+        const buffer = Buffer.from(await response.arrayBuffer());
+        await writeFile(saveTo, buffer);
+        savedFiles.push(saveTo);
+    }
+
+    return {
+        content: [{
+            type: 'text',
+            text: `Downloaded ${savedFiles.length} file(s) to ${dir}:\n` +
+                savedFiles.map(f => `  - ${f}`).join('\n'),
+        }],
+    };
+}
+
+async function handleDeleteFile(args) {
+    const { file_id, upload_token } = args;
+
+    const response = await fetch(`${API}/file/${file_id}`, {
+        method: 'DELETE',
+        headers: { 'Authorization': `Bearer ${upload_token}` },
+    });
+
+    const data = await response.json();
+
+    if (!data.success) {
+        return { content: [{ type: 'text', text: `Error: ${data.error || 'Delete failed'}` }] };
+    }
+
+    return { content: [{ type: 'text', text: `File ${file_id} deleted successfully.` }] };
+}
+
+async function handleBundleStatus(args) {
+    const { short_code } = args;
+    const response = await fetch(`${API}/bundle/${encodeURIComponent(short_code)}/status`);
+    const data = await response.json();
+
+    if (!data.success) {
+        return { content: [{ type: 'text', text: `Error: ${data.error || 'Bundle not found'}` }] };
+    }
+
+    const lines = [
+        `Bundle: ${short_code}`,
+        `Exists: ${data.exists ? 'Yes' : 'No'}`,
+        `Expired: ${data.is_expired ? 'Yes' : 'No'}`,
+        `Expires: ${data.expires_at}`,
+        `Used: ${formatSize(data.total_size_bytes)} / ${formatSize(data.max_size_bytes)}`,
+        `Remaining: ${formatSize(data.space_remaining)}`,
+        `Views: ${data.view_count}`,
+    ];
+
+    return { content: [{ type: 'text', text: lines.join('\n') }] };
+}
+
+function formatSize(bytes) {
+    if (bytes >= 1073741824) return (bytes / 1073741824).toFixed(2) + ' GB';
+    if (bytes >= 1048576) return (bytes / 1048576).toFixed(2) + ' MB';
+    if (bytes >= 1024) return (bytes / 1024).toFixed(2) + ' KB';
+    return bytes + ' B';
+}
+
+// --- MCP Server ---
+
+const server = new Server(
+    { name: 'easysend', version: '1.0.0' },
+    { capabilities: { tools: {} } }
+);
+
+server.setRequestHandler(ListToolsRequestSchema, async () => ({
+    tools: TOOLS,
+}));
+
+server.setRequestHandler(CallToolRequestSchema, async (request) => {
+    const { name, arguments: args } = request.params;
+
+    try {
+        switch (name) {
+            case 'upload_files': return await handleUpload(args);
+            case 'get_bundle': return await handleGetBundle(args);
+            case 'download_file': return await handleDownloadFile(args);
+            case 'download_bundle': return await handleDownloadBundle(args);
+            case 'delete_file': return await handleDeleteFile(args);
+            case 'bundle_status': return await handleBundleStatus(args);
+            default:
+                return { content: [{ type: 'text', text: `Unknown tool: ${name}` }] };
+        }
+    } catch (error) {
+        return { content: [{ type: 'text', text: `Error: ${error.message}` }] };
+    }
+});
+
+const transport = new StdioServerTransport();
+await server.connect(transport);

package/package.json

@@ -0,0 +1,22 @@
+{
+    "name": "easysend-mcp",
+    "version": "1.0.1",
+    "mcpName": "io.github.Easysend-co/easysend",
+    "description": "EasySend file sharing MCP server - upload, download and share files. No authentication required.",
+    "main": "index.js",
+    "type": "module",
+    "bin": {
+        "easysend-mcp": "./index.js"
+    },
+    "dependencies": {
+        "@modelcontextprotocol/sdk": "^1.0.0"
+    },
+    "keywords": ["mcp", "claude-code", "file-sharing", "easysend", "upload", "model-context-protocol"],
+    "license": "MIT",
+    "repository": {
+        "type": "git",
+        "url": "https://github.com/Easysend-co/easysend-mcp.git"
+    },
+    "homepage": "https://easysend.co/mcp",
+    "author": "EasySend <admin@easysend.co>"
+}