agentdrop-mcp-server 0.1.0

package/dist/api-client.d.ts

@@ -0,0 +1,49 @@
+import type { Agent, Transfer, InboxTransfer, DownloadResponse, CreateTransferResponse } from "./types";
+export declare class AgentDropApiError extends Error {
+    code?: string;
+    status?: number;
+    constructor(message: string, code?: string, status?: number);
+}
+export interface ApiClientOptions {
+    apiKey: string;
+    agentId: string;
+    apiBase?: string;
+}
+export declare class ApiClient {
+    private apiKey;
+    private agentId;
+    private apiBase;
+    constructor(options: ApiClientOptions);
+    private headers;
+    private request;
+    /** GET /v1/agents — list agents on the account. */
+    getAgents(): Promise<Agent[]>;
+    /** GET /v1/agents/:uuid/inbox — list incoming transfers for an agent. */
+    getInbox(agentUuid: string, opts?: {
+        status?: string;
+        limit?: number;
+    }): Promise<{
+        transfers: InboxTransfer[];
+        total: number;
+    }>;
+    /** GET /v1/transfers/:id — get transfer details. */
+    getTransfer(transferId: string): Promise<Transfer>;
+    /** GET /v1/transfers/:id/download — get presigned download URLs. */
+    downloadTransfer(transferId: string): Promise<DownloadResponse>;
+    /**
+     * POST /v1/transfers — create a transfer with files.
+     * Uses multipart/form-data built with native FormData.
+     */
+    createTransfer(data: {
+        recipient: string;
+        files: Array<{
+            name: string;
+            buffer: Buffer;
+            mimeType?: string;
+        }>;
+        message?: string;
+        expiresIn?: string;
+    }): Promise<CreateTransferResponse>;
+    /** Get the agent_id this client was configured with. */
+    getAgentId(): string;
+}

package/dist/api-client.js

@@ -0,0 +1,133 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.ApiClient = exports.AgentDropApiError = void 0;
+const USER_AGENT = "agentdrop-mcp/0.1.0";
+class AgentDropApiError extends Error {
+    constructor(message, code, status) {
+        super(message);
+        this.name = "AgentDropApiError";
+        this.code = code;
+        this.status = status;
+    }
+}
+exports.AgentDropApiError = AgentDropApiError;
+class ApiClient {
+    constructor(options) {
+        this.apiKey = options.apiKey;
+        this.agentId = options.agentId;
+        this.apiBase = (options.apiBase || "https://api.agent-drop.com").replace(/\/+$/, "");
+    }
+    headers() {
+        return {
+            Authorization: `Bearer ${this.apiKey}`,
+            "User-Agent": USER_AGENT,
+        };
+    }
+    async request(method, path, options) {
+        const url = new URL(`${this.apiBase}${path}`);
+        if (options?.params) {
+            for (const [k, v] of Object.entries(options.params)) {
+                url.searchParams.set(k, String(v));
+            }
+        }
+        const headers = {
+            ...this.headers(),
+            ...(options?.extraHeaders || {}),
+        };
+        const fetchOptions = { method, headers };
+        if (options?.body) {
+            fetchOptions.body = options.body;
+        }
+        const resp = await fetch(url.toString(), fetchOptions);
+        if (resp.status >= 400) {
+            let errMsg = await resp.text();
+            let errCode;
+            try {
+                const errJson = JSON.parse(errMsg);
+                const errObj = errJson.error || {};
+                errMsg = errObj.message || errMsg;
+                errCode = errObj.code;
+            }
+            catch {
+                // plain text error
+            }
+            throw new AgentDropApiError(errMsg, errCode, resp.status);
+        }
+        return (await resp.json());
+    }
+    /** GET /v1/agents — list agents on the account. */
+    async getAgents() {
+        const data = await this.request("GET", "/v1/agents");
+        return data.agents;
+    }
+    /** GET /v1/agents/:uuid/inbox — list incoming transfers for an agent. */
+    async getInbox(agentUuid, opts) {
+        const params = {};
+        if (opts?.status)
+            params.status = opts.status;
+        if (opts?.limit)
+            params.limit = opts.limit;
+        return this.request("GET", `/v1/agents/${agentUuid}/inbox`, { params });
+    }
+    /** GET /v1/transfers/:id — get transfer details. */
+    async getTransfer(transferId) {
+        const data = await this.request("GET", `/v1/transfers/${transferId}`);
+        return data;
+    }
+    /** GET /v1/transfers/:id/download — get presigned download URLs. */
+    async downloadTransfer(transferId) {
+        return this.request("GET", `/v1/transfers/${transferId}/download`, {
+            extraHeaders: {
+                "X-AgentDrop-Agent": this.agentId,
+            },
+        });
+    }
+    /**
+     * POST /v1/transfers — create a transfer with files.
+     * Uses multipart/form-data built with native FormData.
+     */
+    async createTransfer(data) {
+        const form = new FormData();
+        form.append("sender", this.agentId);
+        form.append("recipient", data.recipient);
+        form.append("mode", "direct");
+        form.append("is_encrypted", "false");
+        form.append("expires_in", data.expiresIn || "24h");
+        form.append("max_downloads", "10");
+        if (data.message) {
+            form.append("message", data.message);
+        }
+        for (const file of data.files) {
+            const blob = new Blob([file.buffer], {
+                type: file.mimeType || "application/octet-stream",
+            });
+            form.append("files", blob, file.name);
+        }
+        // Let fetch set Content-Type with boundary automatically
+        const resp = await fetch(`${this.apiBase}/v1/transfers`, {
+            method: "POST",
+            headers: this.headers(),
+            body: form,
+        });
+        if (resp.status >= 400) {
+            let errMsg = await resp.text();
+            let errCode;
+            try {
+                const errJson = JSON.parse(errMsg);
+                const errObj = errJson.error || {};
+                errMsg = errObj.message || errMsg;
+                errCode = errObj.code;
+            }
+            catch {
+                // plain text
+            }
+            throw new AgentDropApiError(errMsg, errCode, resp.status);
+        }
+        return (await resp.json());
+    }
+    /** Get the agent_id this client was configured with. */
+    getAgentId() {
+        return this.agentId;
+    }
+}
+exports.ApiClient = ApiClient;

package/dist/bin/cli.d.ts

@@ -0,0 +1,2 @@
+#!/usr/bin/env node
+export {};

package/dist/bin/cli.js

@@ -0,0 +1,8 @@
+#!/usr/bin/env node
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+const index_1 = require("../index");
+(0, index_1.main)().catch((err) => {
+    console.error("Fatal:", err);
+    process.exit(1);
+});

package/dist/inbox-poller.d.ts

@@ -0,0 +1,37 @@
+/**
+ * InboxPoller — Background polling for the MCP server.
+ *
+ * Uses the AgentDrop SDK's inbox() to check for new transfers,
+ * and fires a callback when unseen ones arrive. The MCP server
+ * uses this to push `notifications/message` to the client.
+ */
+import type { AgentDrop, Transfer } from "agentdrop-sdk";
+export interface InboxPollerOptions {
+    client: AgentDrop;
+    /** Milliseconds between polls. Default: 30 000 */
+    pollInterval?: number;
+    /** Called for each new incoming transfer. */
+    onNewTransfer: (transfer: Transfer) => void;
+}
+export declare class InboxPoller {
+    private client;
+    private pollInterval;
+    private onNewTransfer;
+    private seenIds;
+    private timer;
+    isRunning: boolean;
+    constructor(opts: InboxPollerOptions);
+    /**
+     * Snapshot current inbox so we don't alert on pre-existing transfers.
+     */
+    seedSeen(): Promise<void>;
+    /**
+     * Single poll cycle: fetch inbox, notify on new transfers.
+     */
+    checkInbox(): Promise<void>;
+    /**
+     * Start background polling. Seeds seen IDs first, then polls on interval.
+     */
+    start(): Promise<void>;
+    stop(): void;
+}

package/dist/inbox-poller.js

@@ -0,0 +1,70 @@
+"use strict";
+/**
+ * InboxPoller — Background polling for the MCP server.
+ *
+ * Uses the AgentDrop SDK's inbox() to check for new transfers,
+ * and fires a callback when unseen ones arrive. The MCP server
+ * uses this to push `notifications/message` to the client.
+ */
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.InboxPoller = void 0;
+class InboxPoller {
+    constructor(opts) {
+        this.seenIds = new Set();
+        this.timer = null;
+        this.isRunning = false;
+        this.client = opts.client;
+        this.pollInterval = opts.pollInterval ?? 30000;
+        this.onNewTransfer = opts.onNewTransfer;
+    }
+    /**
+     * Snapshot current inbox so we don't alert on pre-existing transfers.
+     */
+    async seedSeen() {
+        try {
+            const transfers = await this.client.inbox({ status: "active", limit: 50 });
+            for (const t of transfers) {
+                this.seenIds.add(t.id);
+            }
+        }
+        catch {
+            // Non-fatal — worst case we notify on old transfers once
+        }
+    }
+    /**
+     * Single poll cycle: fetch inbox, notify on new transfers.
+     */
+    async checkInbox() {
+        try {
+            const transfers = await this.client.inbox({ status: "active", limit: 20 });
+            for (const t of transfers) {
+                if (this.seenIds.has(t.id))
+                    continue;
+                this.seenIds.add(t.id);
+                this.onNewTransfer(t);
+            }
+        }
+        catch {
+            // Swallow — retry on next poll
+        }
+    }
+    /**
+     * Start background polling. Seeds seen IDs first, then polls on interval.
+     */
+    async start() {
+        if (this.isRunning)
+            return;
+        this.isRunning = true;
+        await this.seedSeen();
+        this.checkInbox(); // immediate first check after seed
+        this.timer = setInterval(() => this.checkInbox(), this.pollInterval);
+    }
+    stop() {
+        this.isRunning = false;
+        if (this.timer) {
+            clearInterval(this.timer);
+            this.timer = null;
+        }
+    }
+}
+exports.InboxPoller = InboxPoller;

package/dist/index.d.ts

@@ -0,0 +1 @@
+export declare function main(): Promise<void>;

package/dist/index.js

@@ -0,0 +1,89 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.main = main;
+const mcp_js_1 = require("@modelcontextprotocol/sdk/server/mcp.js");
+const stdio_js_1 = require("@modelcontextprotocol/sdk/server/stdio.js");
+const agentdrop_sdk_1 = require("agentdrop-sdk");
+const send_file_1 = require("./tools/send-file");
+const check_inbox_1 = require("./tools/check-inbox");
+const download_1 = require("./tools/download");
+const list_agents_1 = require("./tools/list-agents");
+const get_transfer_1 = require("./tools/get-transfer");
+const inbox_poller_1 = require("./inbox-poller");
+async function main() {
+    const apiKey = process.env.AGENTDROP_API_KEY;
+    const agentId = process.env.AGENTDROP_AGENT_ID;
+    const agentUuid = process.env.AGENTDROP_AGENT_UUID;
+    const apiBase = process.env.AGENTDROP_API_BASE;
+    const pollInterval = parseInt(process.env.AGENTDROP_POLL_INTERVAL || "30000", 10);
+    if (!apiKey) {
+        console.error("Error: AGENTDROP_API_KEY environment variable is required.\n" +
+            "Get your API key at https://agent-drop.com/dashboard/api-keys");
+        process.exit(1);
+    }
+    if (!agentId) {
+        console.error("Error: AGENTDROP_AGENT_ID environment variable is required.\n" +
+            "This is the agent_id of the agent you want to use (e.g. 'my-agent').");
+        process.exit(1);
+    }
+    const client = new agentdrop_sdk_1.AgentDrop({
+        apiKey,
+        agentId,
+        agentUuid,
+        apiBase,
+        shield: true,
+        shieldStrictness: "standard",
+    });
+    const server = new mcp_js_1.McpServer({
+        name: "agentdrop",
+        version: "0.2.0",
+    });
+    // Register tools
+    const tools = [
+        (0, send_file_1.createSendFileTool)(client),
+        (0, check_inbox_1.createCheckInboxTool)(client),
+        (0, download_1.createDownloadTool)(client),
+        (0, list_agents_1.createListAgentsTool)(client),
+        (0, get_transfer_1.createGetTransferTool)(client),
+    ];
+    for (const tool of tools) {
+        server.tool(tool.name, tool.description, tool.schema.shape, async (params) => {
+            try {
+                return await tool.handler(params);
+            }
+            catch (err) {
+                return {
+                    content: [
+                        {
+                            type: "text",
+                            text: `Error: ${err.message || String(err)}`,
+                        },
+                    ],
+                    isError: true,
+                };
+            }
+        });
+    }
+    const transport = new stdio_js_1.StdioServerTransport();
+    await server.connect(transport);
+    // Start inbox polling after MCP handshake is established
+    if (agentUuid) {
+        const poller = new inbox_poller_1.InboxPoller({
+            client,
+            pollInterval,
+            onNewTransfer: (transfer) => {
+                const fileNames = transfer.files
+                    .map((f) => f.name)
+                    .join(", ");
+                const from = transfer.sender || "unknown";
+                const msg = transfer.message ? ` — "${transfer.message}"` : "";
+                server.sendLoggingMessage({
+                    level: "info",
+                    logger: "agentdrop-inbox",
+                    data: `New AgentDrop transfer from "${from}": ${fileNames}${msg} (ID: ${transfer.id})`,
+                });
+            },
+        });
+        await poller.start();
+    }
+}

package/dist/tools/check-inbox.d.ts

@@ -0,0 +1,34 @@
+import { z } from "zod";
+import type { AgentDrop } from "agentdrop-sdk";
+declare const schema: z.ZodObject<{
+    status: z.ZodOptional<z.ZodEnum<["active", "expired", "deleted"]>>;
+    limit: z.ZodOptional<z.ZodNumber>;
+}, "strip", z.ZodTypeAny, {
+    status?: "active" | "expired" | "deleted" | undefined;
+    limit?: number | undefined;
+}, {
+    status?: "active" | "expired" | "deleted" | undefined;
+    limit?: number | undefined;
+}>;
+export type CheckInboxInput = z.infer<typeof schema>;
+export declare function createCheckInboxTool(client: AgentDrop): {
+    name: "check_inbox";
+    description: string;
+    schema: z.ZodObject<{
+        status: z.ZodOptional<z.ZodEnum<["active", "expired", "deleted"]>>;
+        limit: z.ZodOptional<z.ZodNumber>;
+    }, "strip", z.ZodTypeAny, {
+        status?: "active" | "expired" | "deleted" | undefined;
+        limit?: number | undefined;
+    }, {
+        status?: "active" | "expired" | "deleted" | undefined;
+        limit?: number | undefined;
+    }>;
+    handler: (input: CheckInboxInput) => Promise<{
+        content: {
+            type: "text";
+            text: string;
+        }[];
+    }>;
+};
+export {};

package/dist/tools/check-inbox.js

@@ -0,0 +1,65 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.createCheckInboxTool = createCheckInboxTool;
+const zod_1 = require("zod");
+const schema = zod_1.z.object({
+    status: zod_1.z
+        .enum(["active", "expired", "deleted"])
+        .optional()
+        .describe("Filter by transfer status. Default: active"),
+    limit: zod_1.z
+        .number()
+        .optional()
+        .describe("Maximum number of transfers to return. Default: 50"),
+});
+function createCheckInboxTool(client) {
+    return {
+        name: "check_inbox",
+        description: "Check your AgentDrop inbox for incoming file transfers. Returns a list of transfers sent to your agent.",
+        schema,
+        handler: async (input) => {
+            const transfers = await client.inbox({
+                status: input.status,
+                limit: input.limit,
+            });
+            if (transfers.length === 0) {
+                return {
+                    content: [
+                        {
+                            type: "text",
+                            text: `Inbox is empty. No ${input.status || "active"} transfers found.`,
+                        },
+                    ],
+                };
+            }
+            const lines = [
+                `Found ${transfers.length} transfer(s):`,
+                ``,
+            ];
+            for (const t of transfers) {
+                const fileList = t.files.map((f) => f.name).join(", ");
+                const totalSize = t.totalSize || 0;
+                lines.push(`  [${t.id}]`);
+                lines.push(`    From:    ${t.sender}`);
+                lines.push(`    Files:   ${fileList} (${t.files.length} file(s), ${formatBytes(totalSize)})`);
+                lines.push(`    Status:  ${t.status}`);
+                lines.push(`    Created: ${t.createdAt || "N/A"}`);
+                lines.push(`    Expires: ${t.expiresAt || "N/A"}`);
+                if (t.message) {
+                    lines.push(`    Message: ${t.message}`);
+                }
+                lines.push(``);
+            }
+            return {
+                content: [{ type: "text", text: lines.join("\n") }],
+            };
+        },
+    };
+}
+function formatBytes(bytes) {
+    if (bytes === 0)
+        return "0 B";
+    const units = ["B", "KB", "MB", "GB"];
+    const i = Math.floor(Math.log(bytes) / Math.log(1024));
+    return `${(bytes / Math.pow(1024, i)).toFixed(i > 0 ? 1 : 0)} ${units[i]}`;
+}

package/dist/tools/download.d.ts

@@ -0,0 +1,41 @@
+import { z } from "zod";
+import type { AgentDrop } from "agentdrop-sdk";
+declare const schema: z.ZodObject<{
+    transfer_id: z.ZodString;
+    output_dir: z.ZodOptional<z.ZodString>;
+}, "strip", z.ZodTypeAny, {
+    transfer_id: string;
+    output_dir?: string | undefined;
+}, {
+    transfer_id: string;
+    output_dir?: string | undefined;
+}>;
+export type DownloadInput = z.infer<typeof schema>;
+export declare function createDownloadTool(client: AgentDrop): {
+    name: "download_transfer";
+    description: string;
+    schema: z.ZodObject<{
+        transfer_id: z.ZodString;
+        output_dir: z.ZodOptional<z.ZodString>;
+    }, "strip", z.ZodTypeAny, {
+        transfer_id: string;
+        output_dir?: string | undefined;
+    }, {
+        transfer_id: string;
+        output_dir?: string | undefined;
+    }>;
+    handler: (input: DownloadInput) => Promise<{
+        content: {
+            type: "text";
+            text: string;
+        }[];
+        isError?: undefined;
+    } | {
+        content: {
+            type: "text";
+            text: string;
+        }[];
+        isError: boolean;
+    }>;
+};
+export {};

package/dist/tools/download.js

@@ -0,0 +1,70 @@
+"use strict";
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.createDownloadTool = createDownloadTool;
+const zod_1 = require("zod");
+const path_1 = __importDefault(require("path"));
+const agentdrop_sdk_1 = require("agentdrop-sdk");
+const schema = zod_1.z.object({
+    transfer_id: zod_1.z.string().describe("The transfer ID to download files from"),
+    output_dir: zod_1.z
+        .string()
+        .optional()
+        .describe("Directory to save downloaded files. Default: ./downloads"),
+});
+function createDownloadTool(client) {
+    return {
+        name: "download_transfer",
+        description: "Download files from an AgentDrop transfer. The SDK handles decryption and Shield malware scanning automatically.",
+        schema,
+        handler: async (input) => {
+            const outputDir = path_1.default.resolve(input.output_dir || "./downloads");
+            // Create a Transfer object the SDK can work with
+            const transfer = new agentdrop_sdk_1.Transfer({ id: input.transfer_id });
+            try {
+                const results = await client.download(transfer, outputDir);
+                if (results.length === 0) {
+                    return {
+                        content: [
+                            {
+                                type: "text",
+                                text: `No files downloaded from transfer ${input.transfer_id}.`,
+                            },
+                        ],
+                    };
+                }
+                const lines = [
+                    `Downloaded ${results.length} file(s) from transfer ${input.transfer_id}:`,
+                    ``,
+                ];
+                for (const file of results) {
+                    lines.push(`  ${file.path}`);
+                    if (file.warnings && file.warnings.length > 0) {
+                        for (const w of file.warnings) {
+                            lines.push(`    Warning: ${w}`);
+                        }
+                    }
+                }
+                return {
+                    content: [{ type: "text", text: lines.join("\n") }],
+                };
+            }
+            catch (err) {
+                if (err instanceof agentdrop_sdk_1.ShieldBlockError) {
+                    return {
+                        content: [
+                            {
+                                type: "text",
+                                text: `Shield blocked download: ${err.message}`,
+                            },
+                        ],
+                        isError: true,
+                    };
+                }
+                throw err;
+            }
+        },
+    };
+}

package/dist/tools/get-transfer.d.ts

@@ -0,0 +1,28 @@
+import { z } from "zod";
+import type { AgentDrop } from "agentdrop-sdk";
+declare const schema: z.ZodObject<{
+    transfer_id: z.ZodString;
+}, "strip", z.ZodTypeAny, {
+    transfer_id: string;
+}, {
+    transfer_id: string;
+}>;
+export type GetTransferInput = z.infer<typeof schema>;
+export declare function createGetTransferTool(client: AgentDrop): {
+    name: "get_transfer";
+    description: string;
+    schema: z.ZodObject<{
+        transfer_id: z.ZodString;
+    }, "strip", z.ZodTypeAny, {
+        transfer_id: string;
+    }, {
+        transfer_id: string;
+    }>;
+    handler: (input: GetTransferInput) => Promise<{
+        content: {
+            type: "text";
+            text: string;
+        }[];
+    }>;
+};
+export {};

package/dist/tools/get-transfer.js

@@ -0,0 +1,61 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.createGetTransferTool = createGetTransferTool;
+const zod_1 = require("zod");
+const USER_AGENT = "agentdrop-mcp/0.1.0";
+const schema = zod_1.z.object({
+    transfer_id: zod_1.z.string().describe("The transfer ID to look up"),
+});
+function createGetTransferTool(client) {
+    return {
+        name: "get_transfer",
+        description: "Get details about a specific AgentDrop transfer, including file list, status, and download count.",
+        schema,
+        handler: async (input) => {
+            // The SDK doesn't expose a getTransfer() method, so use direct fetch
+            const apiBase = client.apiBase || "https://api.agent-drop.com";
+            const apiKey = client.apiKey;
+            const resp = await fetch(`${apiBase}/v1/transfers/${input.transfer_id}`, {
+                headers: {
+                    Authorization: `Bearer ${apiKey}`,
+                    "User-Agent": USER_AGENT,
+                },
+            });
+            if (resp.status >= 400) {
+                const errText = await resp.text();
+                throw new Error(`Failed to get transfer (HTTP ${resp.status}): ${errText}`);
+            }
+            const t = (await resp.json());
+            const fileList = t.files
+                .map((f) => `${f.name} (${formatBytes(f.size)})`)
+                .join(", ");
+            const lines = [
+                `Transfer ${t.id}:`,
+                ``,
+                `  Sender:    ${t.sender}`,
+                `  Recipient: ${t.recipient}`,
+                `  Mode:      ${t.mode}`,
+                `  Status:    ${t.status}`,
+                `  Files:     ${fileList}`,
+                `  Size:      ${formatBytes(t.total_size)}`,
+                `  Downloads: ${t.downloads}/${t.max_downloads}`,
+                `  Encrypted: ${t.is_encrypted ? "yes" : "no"}`,
+                `  Created:   ${t.created_at}`,
+                `  Expires:   ${t.expires_at}`,
+            ];
+            if (t.message) {
+                lines.push(`  Message:   ${t.message}`);
+            }
+            return {
+                content: [{ type: "text", text: lines.join("\n") }],
+            };
+        },
+    };
+}
+function formatBytes(bytes) {
+    if (bytes === 0)
+        return "0 B";
+    const units = ["B", "KB", "MB", "GB"];
+    const i = Math.floor(Math.log(bytes) / Math.log(1024));
+    return `${(bytes / Math.pow(1024, i)).toFixed(i > 0 ? 1 : 0)} ${units[i]}`;
+}

package/dist/tools/list-agents.d.ts

@@ -0,0 +1,13 @@
+import { z } from "zod";
+import type { AgentDrop } from "agentdrop-sdk";
+export declare function createListAgentsTool(client: AgentDrop): {
+    name: "list_agents";
+    description: string;
+    schema: z.ZodObject<{}, "strip", z.ZodTypeAny, {}, {}>;
+    handler: () => Promise<{
+        content: {
+            type: "text";
+            text: string;
+        }[];
+    }>;
+};

package/dist/tools/list-agents.js

@@ -0,0 +1,55 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.createListAgentsTool = createListAgentsTool;
+const zod_1 = require("zod");
+const USER_AGENT = "agentdrop-mcp/0.1.0";
+const schema = zod_1.z.object({});
+function createListAgentsTool(client) {
+    return {
+        name: "list_agents",
+        description: "List your AgentDrop agents and their connection status. Shows all agents registered on your account.",
+        schema,
+        handler: async () => {
+            // The SDK doesn't expose a listAgents() method, so use direct fetch
+            const apiBase = client.apiBase || "https://api.agent-drop.com";
+            const apiKey = client.apiKey;
+            const resp = await fetch(`${apiBase}/v1/agents`, {
+                headers: {
+                    Authorization: `Bearer ${apiKey}`,
+                    "User-Agent": USER_AGENT,
+                },
+            });
+            if (resp.status >= 400) {
+                const errText = await resp.text();
+                throw new Error(`Failed to list agents (HTTP ${resp.status}): ${errText}`);
+            }
+            const data = (await resp.json());
+            const agents = data.agents;
+            if (agents.length === 0) {
+                return {
+                    content: [
+                        {
+                            type: "text",
+                            text: "No agents registered on this account.",
+                        },
+                    ],
+                };
+            }
+            const lines = [`Found ${agents.length} agent(s):`, ``];
+            for (const a of agents) {
+                lines.push(`  [${a.agent_id}]`);
+                lines.push(`    UUID:   ${a.id}`);
+                lines.push(`    Name:   ${a.name}`);
+                lines.push(`    Type:   ${a.agent_type}`);
+                lines.push(`    Status: ${a.connection_status}`);
+                if (a.last_seen_at) {
+                    lines.push(`    Last seen: ${a.last_seen_at}`);
+                }
+                lines.push(``);
+            }
+            return {
+                content: [{ type: "text", text: lines.join("\n") }],
+            };
+        },
+    };
+}

package/dist/tools/send-file.d.ts

@@ -0,0 +1,53 @@
+import { z } from "zod";
+import type { AgentDrop } from "agentdrop-sdk";
+declare const schema: z.ZodObject<{
+    recipient: z.ZodString;
+    file_path: z.ZodString;
+    message: z.ZodOptional<z.ZodString>;
+    expires_in: z.ZodOptional<z.ZodString>;
+}, "strip", z.ZodTypeAny, {
+    recipient: string;
+    file_path: string;
+    message?: string | undefined;
+    expires_in?: string | undefined;
+}, {
+    recipient: string;
+    file_path: string;
+    message?: string | undefined;
+    expires_in?: string | undefined;
+}>;
+export type SendFileInput = z.infer<typeof schema>;
+export declare function createSendFileTool(client: AgentDrop): {
+    name: "send_file";
+    description: string;
+    schema: z.ZodObject<{
+        recipient: z.ZodString;
+        file_path: z.ZodString;
+        message: z.ZodOptional<z.ZodString>;
+        expires_in: z.ZodOptional<z.ZodString>;
+    }, "strip", z.ZodTypeAny, {
+        recipient: string;
+        file_path: string;
+        message?: string | undefined;
+        expires_in?: string | undefined;
+    }, {
+        recipient: string;
+        file_path: string;
+        message?: string | undefined;
+        expires_in?: string | undefined;
+    }>;
+    handler: (input: SendFileInput) => Promise<{
+        content: {
+            type: "text";
+            text: string;
+        }[];
+        isError: boolean;
+    } | {
+        content: {
+            type: "text";
+            text: string;
+        }[];
+        isError?: undefined;
+    }>;
+};
+export {};

package/dist/tools/send-file.js

@@ -0,0 +1,76 @@
+"use strict";
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.createSendFileTool = createSendFileTool;
+const zod_1 = require("zod");
+const promises_1 = __importDefault(require("fs/promises"));
+const path_1 = __importDefault(require("path"));
+const schema = zod_1.z.object({
+    recipient: zod_1.z.string().describe("The recipient agent_id (e.g. 'my-agent')"),
+    file_path: zod_1.z.string().describe("Absolute path to the file to send"),
+    message: zod_1.z.string().optional().describe("Optional message to attach"),
+    expires_in: zod_1.z
+        .string()
+        .optional()
+        .describe("Expiry duration (e.g. '24h', '7d'). Default: 24h"),
+});
+function createSendFileTool(client) {
+    return {
+        name: "send_file",
+        description: "Send a file to another AgentDrop agent. The file is encrypted end-to-end via the SDK and delivered to the recipient's inbox.",
+        schema,
+        handler: async (input) => {
+            const filePath = path_1.default.resolve(input.file_path);
+            // Verify file exists
+            try {
+                await promises_1.default.access(filePath);
+            }
+            catch {
+                return {
+                    content: [
+                        {
+                            type: "text",
+                            text: `Error: File not found at ${filePath}`,
+                        },
+                    ],
+                    isError: true,
+                };
+            }
+            const result = await client.send(input.recipient, [filePath], {
+                message: input.message,
+                encrypt: true,
+                expiresIn: input.expires_in,
+            });
+            const fileName = path_1.default.basename(filePath);
+            const totalSize = result.total_size || 0;
+            const lines = [
+                `Transfer created successfully.`,
+                ``,
+                `  ID:        ${result.id}`,
+                `  Recipient: ${result.recipient}`,
+                `  File:      ${fileName} (${formatBytes(totalSize)})`,
+                `  Status:    ${result.status}`,
+                `  Expires:   ${result.expires_at}`,
+                `  Encrypted: ${result.is_encrypted ? "yes" : "no"}`,
+            ];
+            if (result.url) {
+                lines.push(`  URL:       ${result.url}`);
+            }
+            if (input.message) {
+                lines.push(`  Message:   ${input.message}`);
+            }
+            return {
+                content: [{ type: "text", text: lines.join("\n") }],
+            };
+        },
+    };
+}
+function formatBytes(bytes) {
+    if (bytes === 0)
+        return "0 B";
+    const units = ["B", "KB", "MB", "GB"];
+    const i = Math.floor(Math.log(bytes) / Math.log(1024));
+    return `${(bytes / Math.pow(1024, i)).toFixed(i > 0 ? 1 : 0)} ${units[i]}`;
+}

package/dist/types.d.ts

@@ -0,0 +1,57 @@
+/**
+ * MCP-server specific types.
+ *
+ * The SDK (`agentdrop-sdk`) exports Transfer, AgentDrop, DownloadedFile,
+ * ShieldBlockError, etc. These types are only kept for the two tools
+ * (list_agents, get_transfer) that still use direct fetch calls.
+ */
+/** An agent registered on the account (from GET /v1/agents). */
+export interface Agent {
+    id: string;
+    agent_id: string;
+    agent_type: string;
+    name: string;
+    description?: string;
+    connection_status: string;
+    key_version: number;
+    last_seen_at: string | null;
+    metadata?: Record<string, unknown>;
+    created_at: string;
+}
+/** A file within a transfer. */
+export interface TransferFile {
+    id: string;
+    name: string;
+    size: number;
+    content_type: string;
+}
+/** A file transfer (from GET /v1/transfers/:id). */
+export interface TransferDetail {
+    id: string;
+    sender: string;
+    recipient: string;
+    status: string;
+    mode: string;
+    message?: string;
+    file_count: number;
+    total_size: number;
+    is_encrypted: boolean;
+    auto_delete: boolean;
+    files: TransferFile[];
+    downloads: number;
+    max_downloads: number;
+    expires_at: string;
+    created_at: string;
+    download_url?: string;
+}
+/** API error shape. */
+export interface ApiError {
+    error: {
+        code: string;
+        message: string;
+        details?: Array<{
+            field: string;
+            message: string;
+        }>;
+    };
+}

package/dist/types.js

@@ -0,0 +1,9 @@
+"use strict";
+/**
+ * MCP-server specific types.
+ *
+ * The SDK (`agentdrop-sdk`) exports Transfer, AgentDrop, DownloadedFile,
+ * ShieldBlockError, etc. These types are only kept for the two tools
+ * (list_agents, get_transfer) that still use direct fetch calls.
+ */
+Object.defineProperty(exports, "__esModule", { value: true });

package/package.json

@@ -0,0 +1,48 @@
+{
+  "name": "agentdrop-mcp-server",
+  "version": "0.1.0",
+  "description": "MCP server for AgentDrop — encrypted file transfer for AI agents",
+  "bin": {
+    "agentdrop-mcp": "./dist/bin/cli.js"
+  },
+  "main": "dist/index.js",
+  "types": "dist/index.d.ts",
+  "files": [
+    "dist/"
+  ],
+  "scripts": {
+    "build": "tsc",
+    "test": "vitest run",
+    "test:watch": "vitest",
+    "prepublishOnly": "npm run build",
+    "start": "node dist/bin/cli.js"
+  },
+  "keywords": [
+    "agentdrop",
+    "mcp",
+    "ai",
+    "agents",
+    "file-transfer",
+    "model-context-protocol"
+  ],
+  "author": "AgentDrop",
+  "license": "MIT",
+  "repository": {
+    "type": "git",
+    "url": "https://github.com/qFlav/AgentDrop"
+  },
+  "homepage": "https://agent-drop.com",
+  "engines": {
+    "node": ">=18.0.0"
+  },
+  "dependencies": {
+    "@modelcontextprotocol/sdk": "^1.12.0",
+    "agentdrop-sdk": "^0.2.2",
+    "zod": "^3.24.0"
+  },
+  "devDependencies": {
+    "@types/node": "^20.11.0",
+    "typescript": "^5.3.0",
+    "vitest": "^4.1.1"
+  }
+}