decoy-mcp-server 1.0.0

package/dist/tools/forwarding-emails.js

@@ -0,0 +1,179 @@
+export const forwardingEmailTools = [
+    {
+        name: "forwarding_email_list",
+        description: "List all forwarding email addresses for the authenticated user",
+        inputSchema: {
+            type: "object",
+            properties: {
+                access_token: {
+                    type: "string",
+                    description: "Access token from auth_login",
+                },
+            },
+            required: ["access_token"],
+        },
+    },
+    {
+        name: "forwarding_email_add",
+        description: "Add a new forwarding email address. This is where decoy emails can be forwarded to.",
+        inputSchema: {
+            type: "object",
+            properties: {
+                access_token: {
+                    type: "string",
+                    description: "Access token from auth_login",
+                },
+                email: {
+                    type: "string",
+                    description: "Email address to add for forwarding (e.g., 'john@gmail.com')",
+                },
+            },
+            required: ["access_token", "email"],
+        },
+    },
+    {
+        name: "forwarding_email_delete",
+        description: "Delete a forwarding email address",
+        inputSchema: {
+            type: "object",
+            properties: {
+                access_token: {
+                    type: "string",
+                    description: "Access token from auth_login",
+                },
+                forwarding_email_id: {
+                    type: "string",
+                    description: "ID of the forwarding email to delete",
+                },
+            },
+            required: ["access_token", "forwarding_email_id"],
+        },
+    },
+];
+export async function handleForwardingEmailTool(name, args, apiUrl) {
+    const accessToken = args?.access_token;
+    if (!accessToken) {
+        return {
+            content: [{ type: "text", text: "access_token is required" }],
+            isError: true,
+        };
+    }
+    const headers = {
+        "Content-Type": "application/json",
+        Authorization: `Bearer ${accessToken}`,
+    };
+    switch (name) {
+        case "forwarding_email_list": {
+            const response = await fetch(`${apiUrl}/forwarding-emails`, {
+                method: "GET",
+                headers,
+            });
+            const data = await response.json();
+            if (!response.ok) {
+                return {
+                    content: [{ type: "text", text: `Failed to list forwarding emails: ${JSON.stringify(data)}` }],
+                    isError: true,
+                };
+            }
+            const emails = data.forwarding_emails || [];
+            if (emails.length === 0) {
+                return {
+                    content: [{ type: "text", text: "No forwarding emails configured. Use forwarding_email_add to add one." }],
+                };
+            }
+            // Decode the encrypted emails for display
+            const summary = emails
+                .map((e) => {
+                let emailDisplay = "Unknown";
+                if (e.encrypted_email) {
+                    try {
+                        emailDisplay = Buffer.from(e.encrypted_email, "base64").toString("utf-8");
+                        // Mask the email for privacy
+                        const [local, domain] = emailDisplay.split("@");
+                        if (local && domain) {
+                            const masked = local.length > 4
+                                ? local.substring(0, 4) + "•••"
+                                : local + "•••";
+                            emailDisplay = `${masked}@${domain}`;
+                        }
+                    }
+                    catch {
+                        emailDisplay = "***";
+                    }
+                }
+                return `- ID: ${e.id} | Email: ${emailDisplay} | Verified: ${e.is_verified ? "Yes" : "No"}`;
+            })
+                .join("\n");
+            return {
+                content: [{ type: "text", text: `Found ${emails.length} forwarding email(s):\n${summary}` }],
+            };
+        }
+        case "forwarding_email_add": {
+            const email = args?.email;
+            if (!email) {
+                return {
+                    content: [{ type: "text", text: "email is required" }],
+                    isError: true,
+                };
+            }
+            // Validate email format
+            const emailRegex = /^[^\s@]+@[^\s@]+\.[^\s@]+$/;
+            if (!emailRegex.test(email)) {
+                return {
+                    content: [{ type: "text", text: "Invalid email format" }],
+                    isError: true,
+                };
+            }
+            // Encode the email as base64 (matching the API expectation)
+            const encryptedEmail = Buffer.from(email).toString("base64");
+            const response = await fetch(`${apiUrl}/forwarding-emails`, {
+                method: "POST",
+                headers,
+                body: JSON.stringify({ encrypted_email: encryptedEmail }),
+            });
+            const data = await response.json();
+            if (!response.ok) {
+                return {
+                    content: [{ type: "text", text: `Failed to add forwarding email: ${JSON.stringify(data)}` }],
+                    isError: true,
+                };
+            }
+            return {
+                content: [
+                    {
+                        type: "text",
+                        text: `Forwarding email added!\nID: ${data.id}\nVerified: ${data.is_verified ? "Yes" : "Pending verification"}`,
+                    },
+                ],
+            };
+        }
+        case "forwarding_email_delete": {
+            const forwardingEmailId = args?.forwarding_email_id;
+            if (!forwardingEmailId) {
+                return {
+                    content: [{ type: "text", text: "forwarding_email_id is required" }],
+                    isError: true,
+                };
+            }
+            const response = await fetch(`${apiUrl}/forwarding-emails?id=${forwardingEmailId}`, {
+                method: "DELETE",
+                headers,
+            });
+            if (!response.ok) {
+                const data = await response.json();
+                return {
+                    content: [{ type: "text", text: `Failed to delete forwarding email: ${JSON.stringify(data)}` }],
+                    isError: true,
+                };
+            }
+            return {
+                content: [{ type: "text", text: `Forwarding email ${forwardingEmailId} deleted successfully.` }],
+            };
+        }
+        default:
+            return {
+                content: [{ type: "text", text: `Unknown forwarding email tool: ${name}` }],
+                isError: true,
+            };
+    }
+}

package/dist/tools/messages.d.ts

@@ -0,0 +1,9 @@
+import { Tool } from "@modelcontextprotocol/sdk/types.js";
+export declare const messageTools: Tool[];
+export declare function handleMessageTool(name: string, args: Record<string, unknown> | undefined, apiUrl: string): Promise<{
+    content: Array<{
+        type: string;
+        text: string;
+    }>;
+    isError?: boolean;
+}>;

package/dist/tools/messages.js

@@ -0,0 +1,113 @@
+export const messageTools = [
+    {
+        name: "message_list",
+        description: "List all messages for the authenticated user",
+        inputSchema: {
+            type: "object",
+            properties: {
+                access_token: {
+                    type: "string",
+                    description: "Access token from auth_login",
+                },
+                limit: {
+                    type: "number",
+                    description: "Maximum number of messages to return (default: 50)",
+                },
+                offset: {
+                    type: "number",
+                    description: "Number of messages to skip (default: 0)",
+                },
+            },
+            required: ["access_token"],
+        },
+    },
+    {
+        name: "message_mark_read",
+        description: "Mark a message as read",
+        inputSchema: {
+            type: "object",
+            properties: {
+                access_token: {
+                    type: "string",
+                    description: "Access token from auth_login",
+                },
+                message_id: {
+                    type: "string",
+                    description: "ID of the message to mark as read",
+                },
+            },
+            required: ["access_token", "message_id"],
+        },
+    },
+];
+export async function handleMessageTool(name, args, apiUrl) {
+    const accessToken = args?.access_token;
+    if (!accessToken) {
+        return {
+            content: [{ type: "text", text: "access_token is required" }],
+            isError: true,
+        };
+    }
+    const headers = {
+        "Content-Type": "application/json",
+        Authorization: `Bearer ${accessToken}`,
+    };
+    switch (name) {
+        case "message_list": {
+            const limit = args?.limit || 50;
+            const offset = args?.offset || 0;
+            const response = await fetch(`${apiUrl}/messages?limit=${limit}&offset=${offset}`, {
+                method: "GET",
+                headers,
+            });
+            const data = await response.json();
+            if (!response.ok) {
+                return {
+                    content: [{ type: "text", text: `Failed to list messages: ${JSON.stringify(data)}` }],
+                    isError: true,
+                };
+            }
+            const messages = data.messages || [];
+            if (messages.length === 0) {
+                return {
+                    content: [{ type: "text", text: "No messages found." }],
+                };
+            }
+            const summary = messages
+                .map((m) => `- [${m.received_at}] Decoy: ${m.decoy_id} | Channel: ${m.channel} | Read: ${m.is_read} (ID: ${m.id})`)
+                .join("\n");
+            return {
+                content: [{ type: "text", text: `Found ${messages.length} messages:\n${summary}` }],
+            };
+        }
+        case "message_mark_read": {
+            const messageId = args?.message_id;
+            if (!messageId) {
+                return {
+                    content: [{ type: "text", text: "message_id is required" }],
+                    isError: true,
+                };
+            }
+            const response = await fetch(`${apiUrl}/messages/${messageId}`, {
+                method: "PUT",
+                headers,
+                body: JSON.stringify({ is_read: true }),
+            });
+            const data = await response.json();
+            if (!response.ok) {
+                return {
+                    content: [{ type: "text", text: `Failed to mark message as read: ${JSON.stringify(data)}` }],
+                    isError: true,
+                };
+            }
+            return {
+                content: [{ type: "text", text: `Message ${messageId} marked as read.` }],
+            };
+        }
+        default:
+            return {
+                content: [{ type: "text", text: `Unknown message tool: ${name}` }],
+                isError: true,
+            };
+    }
+}

package/dist/tools/stats.d.ts

@@ -0,0 +1,9 @@
+import { Tool } from "@modelcontextprotocol/sdk/types.js";
+export declare const statsTools: Tool[];
+export declare function handleStatsTool(name: string, args: Record<string, unknown> | undefined, apiUrl: string): Promise<{
+    content: Array<{
+        type: string;
+        text: string;
+    }>;
+    isError?: boolean;
+}>;

package/dist/tools/stats.js

@@ -0,0 +1,61 @@
+export const statsTools = [
+    {
+        name: "stats_get",
+        description: "Get user statistics (decoy count, messages received, spam blocked, etc.)",
+        inputSchema: {
+            type: "object",
+            properties: {
+                access_token: {
+                    type: "string",
+                    description: "Access token from auth_login",
+                },
+            },
+            required: ["access_token"],
+        },
+    },
+];
+export async function handleStatsTool(name, args, apiUrl) {
+    const accessToken = args?.access_token;
+    if (!accessToken) {
+        return {
+            content: [{ type: "text", text: "access_token is required" }],
+            isError: true,
+        };
+    }
+    const headers = {
+        "Content-Type": "application/json",
+        Authorization: `Bearer ${accessToken}`,
+    };
+    switch (name) {
+        case "stats_get": {
+            const response = await fetch(`${apiUrl}/user/stats`, {
+                method: "GET",
+                headers,
+            });
+            const data = await response.json();
+            if (!response.ok) {
+                return {
+                    content: [{ type: "text", text: `Failed to get stats: ${JSON.stringify(data)}` }],
+                    isError: true,
+                };
+            }
+            const stats = `
+User Statistics:
+- Total Decoys: ${data.decoys_count || 0}
+- Active Decoys: ${data.active_decoys || 0}
+- Messages Received: ${data.messages_received || 0}
+- Unread Messages: ${data.unread_count || 0}
+- Spam Blocked: ${data.spam_blocked || 0}
+- Last Updated: ${data.updated_at || 'N/A'}
+      `.trim();
+            return {
+                content: [{ type: "text", text: stats }],
+            };
+        }
+        default:
+            return {
+                content: [{ type: "text", text: `Unknown stats tool: ${name}` }],
+                isError: true,
+            };
+    }
+}

package/dist/tools/subdomain.d.ts

@@ -0,0 +1,9 @@
+import { Tool } from "@modelcontextprotocol/sdk/types.js";
+export declare const subdomainTools: Tool[];
+export declare function handleSubdomainTool(name: string, args: Record<string, unknown> | undefined, apiUrl: string): Promise<{
+    content: Array<{
+        type: string;
+        text: string;
+    }>;
+    isError?: boolean;
+}>;

package/dist/tools/subdomain.js

@@ -0,0 +1,302 @@
+export const subdomainTools = [
+    {
+        name: "subdomain_status",
+        description: "Get the user's personal alias (subdomain) status — whether claimed, enabled, and disabled alias count",
+        inputSchema: {
+            type: "object",
+            properties: {
+                access_token: {
+                    type: "string",
+                    description: "Access token from auth_login",
+                },
+            },
+            required: ["access_token"],
+        },
+    },
+    {
+        name: "subdomain_claim",
+        description: "Claim a personal alias subdomain (e.g., 'yourname' gives you *@yourname.decoys.me). This is permanent and cannot be changed.",
+        inputSchema: {
+            type: "object",
+            properties: {
+                access_token: {
+                    type: "string",
+                    description: "Access token from auth_login",
+                },
+                subdomain: {
+                    type: "string",
+                    description: "The subdomain to claim (3-32 chars, lowercase alphanumeric + hyphens)",
+                },
+            },
+            required: ["access_token", "subdomain"],
+        },
+    },
+    {
+        name: "subdomain_toggle",
+        description: "Enable or disable the personal alias catch-all. When disabled, emails to *@yourname.decoys.me are not received.",
+        inputSchema: {
+            type: "object",
+            properties: {
+                access_token: {
+                    type: "string",
+                    description: "Access token from auth_login",
+                },
+                enabled: {
+                    type: "boolean",
+                    description: "true to enable, false to disable",
+                },
+            },
+            required: ["access_token", "enabled"],
+        },
+    },
+    {
+        name: "alias_list_disabled",
+        description: "List all disabled (blocked) aliases for the personal subdomain. Re-enable them with alias_enable.",
+        inputSchema: {
+            type: "object",
+            properties: {
+                access_token: {
+                    type: "string",
+                    description: "Access token from auth_login",
+                },
+            },
+            required: ["access_token"],
+        },
+    },
+    {
+        name: "alias_disable",
+        description: "Disable (block) a personal alias so it no longer receives emails. Reversible. e.g., disable 'netflix' to block netflix@yourname.decoys.me",
+        inputSchema: {
+            type: "object",
+            properties: {
+                access_token: {
+                    type: "string",
+                    description: "Access token from auth_login",
+                },
+                alias: {
+                    type: "string",
+                    description: "The alias local part to disable (e.g., 'netflix')",
+                },
+            },
+            required: ["access_token", "alias"],
+        },
+    },
+    {
+        name: "alias_enable",
+        description: "Restore a previously disabled alias so it receives emails again",
+        inputSchema: {
+            type: "object",
+            properties: {
+                access_token: {
+                    type: "string",
+                    description: "Access token from auth_login",
+                },
+                alias: {
+                    type: "string",
+                    description: "The alias local part to restore (e.g., 'netflix')",
+                },
+            },
+            required: ["access_token", "alias"],
+        },
+    },
+    {
+        name: "alias_stats",
+        description: "Get first-seen dates for personal aliases (when each alias first received an email)",
+        inputSchema: {
+            type: "object",
+            properties: {
+                access_token: {
+                    type: "string",
+                    description: "Access token from auth_login",
+                },
+                aliases: {
+                    type: "array",
+                    items: { type: "string" },
+                    description: "List of alias names to check (max 100)",
+                },
+            },
+            required: ["access_token", "aliases"],
+        },
+    },
+];
+export async function handleSubdomainTool(name, args, apiUrl) {
+    const accessToken = args?.access_token;
+    if (!accessToken) {
+        return {
+            content: [{ type: "text", text: "access_token is required" }],
+            isError: true,
+        };
+    }
+    const headers = {
+        "Content-Type": "application/json",
+        Authorization: `Bearer ${accessToken}`,
+    };
+    switch (name) {
+        case "subdomain_status": {
+            const response = await fetch(`${apiUrl}/subdomain`, {
+                method: "GET",
+                headers,
+            });
+            const data = await response.json();
+            if (!response.ok) {
+                return {
+                    content: [{ type: "text", text: `Failed to get subdomain status: ${JSON.stringify(data)}` }],
+                    isError: true,
+                };
+            }
+            return {
+                content: [{ type: "text", text: JSON.stringify(data, null, 2) }],
+            };
+        }
+        case "subdomain_claim": {
+            const subdomain = args?.subdomain;
+            if (!subdomain) {
+                return {
+                    content: [{ type: "text", text: "subdomain is required" }],
+                    isError: true,
+                };
+            }
+            const response = await fetch(`${apiUrl}/subdomain`, {
+                method: "PUT",
+                headers,
+                body: JSON.stringify({ subdomain }),
+            });
+            const data = await response.json();
+            if (!response.ok) {
+                return {
+                    content: [{ type: "text", text: `Failed to claim subdomain: ${JSON.stringify(data)}` }],
+                    isError: true,
+                };
+            }
+            return {
+                content: [{ type: "text", text: JSON.stringify(data, null, 2) }],
+            };
+        }
+        case "subdomain_toggle": {
+            const enabled = args?.enabled;
+            if (typeof enabled !== "boolean") {
+                return {
+                    content: [{ type: "text", text: "enabled (boolean) is required" }],
+                    isError: true,
+                };
+            }
+            const response = await fetch(`${apiUrl}/subdomain?action=toggle`, {
+                method: "PUT",
+                headers,
+                body: JSON.stringify({ enabled }),
+            });
+            const data = await response.json();
+            if (!response.ok) {
+                return {
+                    content: [{ type: "text", text: `Failed to toggle subdomain: ${JSON.stringify(data)}` }],
+                    isError: true,
+                };
+            }
+            return {
+                content: [{ type: "text", text: `Subdomain ${enabled ? "enabled" : "disabled"} successfully` }],
+            };
+        }
+        case "alias_list_disabled": {
+            const response = await fetch(`${apiUrl}/subdomain?action=disabled`, {
+                method: "GET",
+                headers,
+            });
+            const data = await response.json();
+            if (!response.ok) {
+                return {
+                    content: [{ type: "text", text: `Failed to list disabled aliases: ${JSON.stringify(data)}` }],
+                    isError: true,
+                };
+            }
+            const aliases = data.disabled_aliases || [];
+            if (aliases.length === 0) {
+                return {
+                    content: [{ type: "text", text: "No disabled aliases found." }],
+                };
+            }
+            const summary = aliases
+                .map((a) => `- ID: ${a.id} | Disabled at: ${a.created_at}`)
+                .join("\n");
+            return {
+                content: [{ type: "text", text: `Found ${aliases.length} disabled aliases:\n${summary}` }],
+            };
+        }
+        case "alias_disable": {
+            const alias = args?.alias;
+            if (!alias) {
+                return {
+                    content: [{ type: "text", text: "alias is required" }],
+                    isError: true,
+                };
+            }
+            const response = await fetch(`${apiUrl}/subdomain?action=disable`, {
+                method: "POST",
+                headers,
+                body: JSON.stringify({ alias }),
+            });
+            const data = await response.json();
+            if (!response.ok) {
+                return {
+                    content: [{ type: "text", text: `Failed to disable alias: ${JSON.stringify(data)}` }],
+                    isError: true,
+                };
+            }
+            return {
+                content: [{ type: "text", text: `Alias "${alias}" disabled successfully${data.already_existed ? " (was already disabled)" : ""}` }],
+            };
+        }
+        case "alias_enable": {
+            const alias = args?.alias;
+            if (!alias) {
+                return {
+                    content: [{ type: "text", text: "alias is required" }],
+                    isError: true,
+                };
+            }
+            const response = await fetch(`${apiUrl}/subdomain?action=disable`, {
+                method: "DELETE",
+                headers,
+                body: JSON.stringify({ alias }),
+            });
+            const data = await response.json();
+            if (!response.ok) {
+                return {
+                    content: [{ type: "text", text: `Failed to enable alias: ${JSON.stringify(data)}` }],
+                    isError: true,
+                };
+            }
+            return {
+                content: [{ type: "text", text: `Alias "${alias}" restored successfully` }],
+            };
+        }
+        case "alias_stats": {
+            const aliases = args?.aliases;
+            if (!aliases || !Array.isArray(aliases) || aliases.length === 0) {
+                return {
+                    content: [{ type: "text", text: "aliases array is required" }],
+                    isError: true,
+                };
+            }
+            const response = await fetch(`${apiUrl}/subdomain?action=alias-stats`, {
+                method: "POST",
+                headers,
+                body: JSON.stringify({ aliases }),
+            });
+            const data = await response.json();
+            if (!response.ok) {
+                return {
+                    content: [{ type: "text", text: `Failed to get alias stats: ${JSON.stringify(data)}` }],
+                    isError: true,
+                };
+            }
+            return {
+                content: [{ type: "text", text: JSON.stringify(data, null, 2) }],
+            };
+        }
+        default:
+            return {
+                content: [{ type: "text", text: `Unknown subdomain tool: ${name}` }],
+                isError: true,
+            };
+    }
+}