@coffrify/mcp 0.1.2

package/README.md

@@ -0,0 +1,95 @@
+# @coffrify/mcp
+
+**MCP server for Coffrify** — gives AI agents (Claude Desktop, Cursor, Windsurf, OpenAI Agents SDK) direct access to encrypted file transfer infrastructure.
+
+## What is MCP ?
+
+[Model Context Protocol](https://modelcontextprotocol.io) is a standard for connecting AI agents to tools. With this server, agents can :
+
+- Send encrypted file transfers
+- Manage webhook subscriptions
+- Query audit logs
+- Create/revoke API keys
+- All without leaving the chat.
+
+## Setup
+
+### Claude Desktop
+
+Edit `~/Library/Application Support/Claude/claude_desktop_config.json` (macOS) or `%APPDATA%/Claude/claude_desktop_config.json` (Windows) :
+
+```json
+{
+  "mcpServers": {
+    "coffrify": {
+      "command": "npx",
+      "args": ["-y", "@coffrify/mcp"],
+      "env": {
+        "COFFRIFY_API_KEY": "cfy_live_xxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxx"
+      }
+    }
+  }
+}
+```
+
+Restart Claude. You should see "coffrify" tools in the 🔌 menu.
+
+### Cursor
+
+Edit `~/.cursor/mcp.json` :
+
+```json
+{
+  "mcpServers": {
+    "coffrify": {
+      "command": "npx",
+      "args": ["-y", "@coffrify/mcp"],
+      "env": { "COFFRIFY_API_KEY": "cfy_live_..." }
+    }
+  }
+}
+```
+
+### Cline / other MCP clients
+
+Same pattern — `command: npx`, `args: ["-y", "@coffrify/mcp"]`, env contains `COFFRIFY_API_KEY`.
+
+## Available tools
+
+| Tool | What it does |
+|---|---|
+| `coffrify_list_transfers` | List recent transfers |
+| `coffrify_get_transfer` | Full details of one transfer |
+| `coffrify_create_transfer` | Create transfer with files, expiry, password, etc. |
+| `coffrify_delete_transfer` | Delete a transfer |
+| `coffrify_list_webhooks` | List webhook subscriptions |
+| `coffrify_create_webhook` | Create webhook + return secret |
+| `coffrify_test_webhook` | Send test ping |
+| `coffrify_list_webhook_deliveries` | Debug failures / see latency |
+| `coffrify_replay_webhook_delivery` | Replay a past event |
+| `coffrify_list_api_keys` | List API keys (hashes only) |
+| `coffrify_create_api_key` | Create new key with scopes |
+| `coffrify_revoke_api_key` | Revoke a key |
+| `coffrify_query_audit_log` | Filter audit log by action, actor, time |
+| `coffrify_get_workspace_info` | Current workspace + plan + scopes |
+
+## Example usage in Claude
+
+```
+You: "Send my latest report to ada@lovelace.io, expire after 24h, password protect it."
+
+Claude (uses coffrify_create_transfer):
+  → Creates the transfer
+  → Returns the share URL + token
+  → Optionally sets up a webhook to notify on download
+```
+
+## Auth
+
+Generate an API key in your Coffrify dashboard with the scopes you want the agent to have. **Use a `cfy_test_` key for sandbox testing**, only use `cfy_live_` once you trust the agent.
+
+We recommend a dedicated API key per agent installation, with `expires_in_days` set, so you can revoke it cleanly.
+
+## License
+
+MIT

package/dist/server.js

@@ -0,0 +1,273 @@
+#!/usr/bin/env node
+
+// src/server.ts
+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 { Coffrify } from "@coffrify/sdk";
+var apiKey = process.env.COFFRIFY_API_KEY;
+var apiUrl = process.env.COFFRIFY_API_URL ?? "https://api.coffrify.com";
+if (!apiKey) {
+  console.error("[coffrify-mcp] COFFRIFY_API_KEY env var required");
+  process.exit(1);
+}
+var coffrify = new Coffrify({ apiKey, apiUrl });
+var server = new Server(
+  { name: "coffrify", version: "0.1.0" },
+  { capabilities: { tools: {} } }
+);
+var TOOLS = [
+  {
+    name: "coffrify_list_transfers",
+    description: "List recent encrypted file transfers in the workspace. Returns id, short_code, title, status, downloads count, expiration.",
+    inputSchema: {
+      type: "object",
+      properties: {
+        limit: { type: "number", description: "Max results (default 20)", default: 20 },
+        status: { type: "string", description: "Filter by status: active|expired|deleted" }
+      }
+    }
+  },
+  {
+    name: "coffrify_get_transfer",
+    description: "Get full details of a transfer including files, settings, scan status.",
+    inputSchema: {
+      type: "object",
+      properties: { id: { type: "string", description: "Transfer ID (tr_...)" } },
+      required: ["id"]
+    }
+  },
+  {
+    name: "coffrify_create_transfer",
+    description: "Create a new encrypted file transfer. Returns the transfer + share URL. Files must be uploaded separately to the presigned URLs returned.",
+    inputSchema: {
+      type: "object",
+      properties: {
+        files: {
+          type: "array",
+          items: {
+            type: "object",
+            properties: {
+              name: { type: "string" },
+              size: { type: "number" },
+              mime_type: { type: "string" }
+            },
+            required: ["name", "size"]
+          }
+        },
+        expires_in_hours: { type: "number", default: 168 },
+        max_downloads: { type: "number" },
+        password: { type: "string" },
+        transfer_title: { type: "string" },
+        burn_after_read: { type: "boolean" }
+      },
+      required: ["files"]
+    }
+  },
+  {
+    name: "coffrify_delete_transfer",
+    description: "Delete a transfer (immediate, irreversible).",
+    inputSchema: {
+      type: "object",
+      properties: { id: { type: "string" } },
+      required: ["id"]
+    }
+  },
+  {
+    name: "coffrify_list_webhooks",
+    description: "List configured webhook endpoints in the workspace.",
+    inputSchema: { type: "object", properties: {} }
+  },
+  {
+    name: "coffrify_create_webhook",
+    description: "Create a webhook subscription. Returns the webhook + a secret (shown once).",
+    inputSchema: {
+      type: "object",
+      properties: {
+        name: { type: "string" },
+        url: { type: "string", description: "HTTPS endpoint" },
+        events: {
+          type: "array",
+          items: {
+            type: "string",
+            enum: ["transfer.created", "transfer.downloaded", "transfer.expired", "transfer.deleted", "transfer.scanned", "transfer.cloned", "transfer.limit_reached"]
+          }
+        }
+      },
+      required: ["name", "url", "events"]
+    }
+  },
+  {
+    name: "coffrify_test_webhook",
+    description: "Send a test ping event to a webhook to verify the endpoint is reachable.",
+    inputSchema: {
+      type: "object",
+      properties: { id: { type: "string" } },
+      required: ["id"]
+    }
+  },
+  {
+    name: "coffrify_list_webhook_deliveries",
+    description: "List recent delivery attempts for a webhook (debug failures, see latency, replay).",
+    inputSchema: {
+      type: "object",
+      properties: {
+        webhook_id: { type: "string" },
+        limit: { type: "number", default: 20 }
+      },
+      required: ["webhook_id"]
+    }
+  },
+  {
+    name: "coffrify_replay_webhook_delivery",
+    description: "Replay a past webhook delivery (creates a new event_id).",
+    inputSchema: {
+      type: "object",
+      properties: { delivery_id: { type: "string" } },
+      required: ["delivery_id"]
+    }
+  },
+  {
+    name: "coffrify_list_api_keys",
+    description: "List API keys in the workspace (key values are hashed and never returned).",
+    inputSchema: { type: "object", properties: {} }
+  },
+  {
+    name: "coffrify_create_api_key",
+    description: "Create a new API key. Returns the key value ONCE \u2014 must be stored securely. Specify scopes for least-privilege access.",
+    inputSchema: {
+      type: "object",
+      properties: {
+        name: { type: "string" },
+        description: { type: "string" },
+        environment: { type: "string", enum: ["live", "test"], default: "live" },
+        scopes: {
+          type: "array",
+          items: { type: "string" },
+          description: "e.g. ['transfers:read', 'transfers:write', 'webhooks:manage']"
+        },
+        expires_in_days: { type: "number" },
+        allowed_ips: { type: "array", items: { type: "string" }, description: "CIDR allowlist" }
+      },
+      required: ["name"]
+    }
+  },
+  {
+    name: "coffrify_revoke_api_key",
+    description: "Revoke an API key (immediate, irreversible).",
+    inputSchema: {
+      type: "object",
+      properties: { id: { type: "string" } },
+      required: ["id"]
+    }
+  },
+  {
+    name: "coffrify_query_audit_log",
+    description: "Query the workspace audit log. Pro tier: 30 days. Entreprise: 365 days. Filter by action, actor, time range.",
+    inputSchema: {
+      type: "object",
+      properties: {
+        action: { type: "string", description: "e.g. 'transfer.downloaded'" },
+        actor_id: { type: "string" },
+        resource_type: { type: "string" },
+        since: { type: "string", description: "ISO date or relative (e.g. 24h ago)" },
+        until: { type: "string", description: "ISO date" },
+        limit: { type: "number", default: 100 }
+      }
+    }
+  },
+  {
+    name: "coffrify_get_workspace_info",
+    description: "Get current workspace info: plan, scopes of the current API key, environment.",
+    inputSchema: { type: "object", properties: {} }
+  }
+];
+server.setRequestHandler(ListToolsRequestSchema, async () => ({
+  tools: TOOLS
+}));
+server.setRequestHandler(CallToolRequestSchema, async (request) => {
+  const { name, arguments: args = {} } = request.params;
+  try {
+    let result;
+    switch (name) {
+      case "coffrify_list_transfers":
+        result = await coffrify.transfers.list(args);
+        break;
+      case "coffrify_get_transfer":
+        result = await coffrify.transfers.get(args.id);
+        break;
+      case "coffrify_create_transfer": {
+        const a = args;
+        result = await coffrify.transfers.create(a.files, {
+          expires_in_hours: a.expires_in_hours,
+          max_downloads: a.max_downloads,
+          password: a.password,
+          transfer_title: a.transfer_title,
+          burn_after_read: a.burn_after_read
+        });
+        break;
+      }
+      case "coffrify_delete_transfer":
+        result = await coffrify.transfers.delete(args.id);
+        break;
+      case "coffrify_list_webhooks":
+        result = await coffrify.webhooks.list();
+        break;
+      case "coffrify_create_webhook": {
+        const a = args;
+        result = await coffrify.webhooks.create({ name: a.name, url: a.url, events: a.events });
+        break;
+      }
+      case "coffrify_test_webhook":
+        result = await coffrify.webhooks.test(args.id);
+        break;
+      case "coffrify_list_webhook_deliveries": {
+        const a = args;
+        result = await coffrify.webhooks.deliveries(a.webhook_id, { limit: a.limit });
+        break;
+      }
+      case "coffrify_replay_webhook_delivery":
+        result = await coffrify.webhooks.replay(args.delivery_id);
+        break;
+      case "coffrify_list_api_keys":
+        result = await coffrify.apiKeys.list();
+        break;
+      case "coffrify_create_api_key":
+        result = await coffrify.apiKeys.create(args);
+        break;
+      case "coffrify_revoke_api_key":
+        result = await coffrify.apiKeys.revoke(args.id);
+        break;
+      case "coffrify_query_audit_log": {
+        const a = args;
+        let since = a.since;
+        if (since && /^\d+[hdw]$/.test(since)) {
+          const m = since.match(/^(\d+)([hdw])$/);
+          const n = parseInt(m[1]);
+          const ms = m[2] === "h" ? n * 36e5 : m[2] === "d" ? n * 864e5 : n * 7 * 864e5;
+          since = new Date(Date.now() - ms).toISOString();
+        }
+        result = await coffrify.audit.list({ ...a, since });
+        break;
+      }
+      case "coffrify_get_workspace_info": {
+        result = await coffrify.http.request("GET", "/me");
+        break;
+      }
+      default:
+        throw new Error(`Unknown tool: ${name}`);
+    }
+    return {
+      content: [{ type: "text", text: JSON.stringify(result, null, 2) }]
+    };
+  } catch (e) {
+    return {
+      content: [{ type: "text", text: `Error: ${e?.message ?? "unknown"}
+${JSON.stringify(e?.details ?? {}, null, 2)}` }],
+      isError: true
+    };
+  }
+});
+var transport = new StdioServerTransport();
+await server.connect(transport);
+console.error("[coffrify-mcp] Server connected via stdio");

package/package.json

@@ -0,0 +1,45 @@
+{
+  "name": "@coffrify/mcp",
+  "version": "0.1.2",
+  "description": "Coffrify MCP server — gives Claude/Cursor/Windsurf agents direct access to Coffrify (transfers, webhooks, audit, API keys).",
+  "type": "module",
+  "bin": {
+    "coffrify-mcp": "./dist/server.js"
+  },
+  "main": "./dist/server.js",
+  "files": [
+    "dist",
+    "README.md"
+  ],
+  "keywords": [
+    "coffrify",
+    "mcp",
+    "model-context-protocol",
+    "claude",
+    "ai-agents"
+  ],
+  "license": "MIT",
+  "homepage": "https://coffrify.com/integrations/mcp",
+  "engines": {
+    "node": ">=18"
+  },
+  "publishConfig": {
+    "access": "public"
+  },
+  "dependencies": {
+    "@modelcontextprotocol/sdk": "^1.0.0",
+    "zod": "^3.23.8",
+    "@coffrify/sdk": "0.3.6"
+  },
+  "devDependencies": {
+    "@types/node": "^22.0.0",
+    "tsup": "^8.0.0",
+    "tsx": "^4.20.0",
+    "typescript": "^5.0.0"
+  },
+  "scripts": {
+    "build": "tsup src/server.ts --format esm --clean --shims",
+    "dev": "tsx src/server.ts",
+    "lint": "tsc --noEmit"
+  }
+}