decoy-mcp-server 1.0.0

package/dist/tools/alerts.d.ts

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

package/dist/tools/alerts.js

@@ -0,0 +1,111 @@
+export const alertTools = [
+    {
+        name: "alert_list",
+        description: "List all alerts for the authenticated user",
+        inputSchema: {
+            type: "object",
+            properties: {
+                access_token: {
+                    type: "string",
+                    description: "Access token from auth_login",
+                },
+                include_dismissed: {
+                    type: "boolean",
+                    description: "Include dismissed alerts (default: false)",
+                },
+            },
+            required: ["access_token"],
+        },
+    },
+    {
+        name: "alert_dismiss",
+        description: "Dismiss an alert",
+        inputSchema: {
+            type: "object",
+            properties: {
+                access_token: {
+                    type: "string",
+                    description: "Access token from auth_login",
+                },
+                alert_id: {
+                    type: "string",
+                    description: "ID of the alert to dismiss",
+                },
+            },
+            required: ["access_token", "alert_id"],
+        },
+    },
+];
+export async function handleAlertTool(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 "alert_list": {
+            const response = await fetch(`${apiUrl}/alerts`, {
+                method: "GET",
+                headers,
+            });
+            const data = await response.json();
+            if (!response.ok) {
+                return {
+                    content: [{ type: "text", text: `Failed to list alerts: ${JSON.stringify(data)}` }],
+                    isError: true,
+                };
+            }
+            const alerts = data.alerts || [];
+            const includeDismissed = args?.include_dismissed;
+            const filteredAlerts = includeDismissed
+                ? alerts
+                : alerts.filter((a) => !a.dismissed);
+            if (filteredAlerts.length === 0) {
+                return {
+                    content: [{ type: "text", text: "No alerts found." }],
+                };
+            }
+            const summary = filteredAlerts
+                .map((a) => `- [${a.type}] ID: ${a.id} | Dismissed: ${a.dismissed} | Created: ${a.created_at}`)
+                .join("\n");
+            return {
+                content: [{ type: "text", text: `Found ${filteredAlerts.length} alerts:\n${summary}` }],
+            };
+        }
+        case "alert_dismiss": {
+            const alertId = args?.alert_id;
+            if (!alertId) {
+                return {
+                    content: [{ type: "text", text: "alert_id is required" }],
+                    isError: true,
+                };
+            }
+            const response = await fetch(`${apiUrl}/alerts`, {
+                method: "PUT",
+                headers,
+                body: JSON.stringify({ id: alertId, dismissed: true }),
+            });
+            const data = await response.json();
+            if (!response.ok) {
+                return {
+                    content: [{ type: "text", text: `Failed to dismiss alert: ${JSON.stringify(data)}` }],
+                    isError: true,
+                };
+            }
+            return {
+                content: [{ type: "text", text: `Alert ${alertId} dismissed.` }],
+            };
+        }
+        default:
+            return {
+                content: [{ type: "text", text: `Unknown alert tool: ${name}` }],
+                isError: true,
+            };
+    }
+}

package/dist/tools/auth.d.ts

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

package/dist/tools/auth.js

@@ -0,0 +1,90 @@
+export const authTools = [
+    {
+        name: "auth_login",
+        description: "Login to Decoy API using email hash or Apple identity token",
+        inputSchema: {
+            type: "object",
+            properties: {
+                email_hash: {
+                    type: "string",
+                    description: "SHA-256 hash of user email (for email-based login)",
+                },
+                apple_id_token: {
+                    type: "string",
+                    description: "Apple identity token (for Sign in with Apple)",
+                },
+            },
+            oneOf: [
+                { required: ["email_hash"] },
+                { required: ["apple_id_token"] },
+            ],
+        },
+    },
+    {
+        name: "auth_refresh",
+        description: "Refresh an expired access token using a refresh token",
+        inputSchema: {
+            type: "object",
+            properties: {
+                refresh_token: {
+                    type: "string",
+                    description: "The refresh token",
+                },
+            },
+            required: ["refresh_token"],
+        },
+    },
+];
+export async function handleAuthTool(name, args, apiUrl) {
+    switch (name) {
+        case "auth_login": {
+            const response = await fetch(`${apiUrl}/auth/login`, {
+                method: "POST",
+                headers: { "Content-Type": "application/json" },
+                body: JSON.stringify(args),
+            });
+            const data = await response.json();
+            if (!response.ok) {
+                return {
+                    content: [{ type: "text", text: `Login failed: ${JSON.stringify(data)}` }],
+                    isError: true,
+                };
+            }
+            return {
+                content: [
+                    {
+                        type: "text",
+                        text: `Login successful!\nUser ID: ${data.user_id}\nAccess Token: ${data.access_token}\nRefresh Token: ${data.refresh_token}`,
+                    },
+                ],
+            };
+        }
+        case "auth_refresh": {
+            const response = await fetch(`${apiUrl}/auth/refresh`, {
+                method: "POST",
+                headers: { "Content-Type": "application/json" },
+                body: JSON.stringify(args),
+            });
+            const data = await response.json();
+            if (!response.ok) {
+                return {
+                    content: [{ type: "text", text: `Token refresh failed: ${JSON.stringify(data)}` }],
+                    isError: true,
+                };
+            }
+            return {
+                content: [
+                    {
+                        type: "text",
+                        text: `Token refreshed!\nNew Access Token: ${data.access_token}`,
+                    },
+                ],
+            };
+        }
+        default:
+            return {
+                content: [{ type: "text", text: `Unknown auth tool: ${name}` }],
+                isError: true,
+            };
+    }
+}

package/dist/tools/decoys.d.ts

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

package/dist/tools/decoys.js

@@ -0,0 +1,293 @@
+export const decoyTools = [
+    {
+        name: "decoy_list",
+        description: "List all decoys for the authenticated user",
+        inputSchema: {
+            type: "object",
+            properties: {
+                access_token: {
+                    type: "string",
+                    description: "Access token from auth_login",
+                },
+            },
+            required: ["access_token"],
+        },
+    },
+    {
+        name: "decoy_create",
+        description: "Create a new decoy account with optional email forwarding",
+        inputSchema: {
+            type: "object",
+            properties: {
+                access_token: {
+                    type: "string",
+                    description: "Access token from auth_login",
+                },
+                service_name: {
+                    type: "string",
+                    description: "Name of the service (e.g., 'Netflix', 'Spotify')",
+                },
+                avatar: {
+                    type: "string",
+                    description: "Avatar variant name. Options: cool, chef, space, wizard, pirate, dj, baseball, floral-crown, bucket, chic-berret, chic-big-hat, chic-headband, headphones, cowboy, detective, explorer, jester, luchador, ninja, pilot, pinkrock, queen, samurai, ski, snorkle, steampunk, super, viking, beekeeper, firefighter, mariachi, nurse, pharoh, robot, aqua, farmer, gladiator, knight, painter, angel. Random if omitted.",
+                },
+                label: {
+                    type: "string",
+                    description: "Optional label for the decoy (max 200 chars)",
+                },
+                forward_enabled: {
+                    type: "boolean",
+                    description: "Whether to forward emails to your real email address",
+                },
+                forwarding_email_id: {
+                    type: "string",
+                    description: "ID of the forwarding email to use (from forwarding_email_list)",
+                },
+            },
+            required: ["access_token", "service_name"],
+        },
+    },
+    {
+        name: "decoy_update",
+        description: "Update a decoy's avatar, service name, or label",
+        inputSchema: {
+            type: "object",
+            properties: {
+                access_token: {
+                    type: "string",
+                    description: "Access token from auth_login",
+                },
+                decoy_id: {
+                    type: "string",
+                    description: "The decoy ID to update",
+                },
+                avatar: {
+                    type: "string",
+                    description: "New avatar variant name (same options as decoy_create)",
+                },
+                service_name: {
+                    type: "string",
+                    description: "New service name",
+                },
+                label: {
+                    type: "string",
+                    description: "New label",
+                },
+            },
+            required: ["access_token", "decoy_id"],
+        },
+    },
+    {
+        name: "decoy_delete",
+        description: "Delete a decoy",
+        inputSchema: {
+            type: "object",
+            properties: {
+                access_token: {
+                    type: "string",
+                    description: "Access token from auth_login",
+                },
+                decoy_id: {
+                    type: "string",
+                    description: "ID of the decoy to delete",
+                },
+            },
+            required: ["access_token", "decoy_id"],
+        },
+    },
+    {
+        name: "decoy_get_thread",
+        description: "Get all messages for a specific decoy",
+        inputSchema: {
+            type: "object",
+            properties: {
+                access_token: {
+                    type: "string",
+                    description: "Access token from auth_login",
+                },
+                decoy_id: {
+                    type: "string",
+                    description: "ID of the decoy",
+                },
+            },
+            required: ["access_token", "decoy_id"],
+        },
+    },
+];
+export async function handleDecoyTool(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 "decoy_list": {
+            const response = await fetch(`${apiUrl}/decoys`, {
+                method: "GET",
+                headers,
+            });
+            const data = await response.json();
+            if (!response.ok) {
+                return {
+                    content: [{ type: "text", text: `Failed to list decoys: ${JSON.stringify(data)}` }],
+                    isError: true,
+                };
+            }
+            const decoys = data.decoys || [];
+            if (decoys.length === 0) {
+                return {
+                    content: [{ type: "text", text: "No decoys found." }],
+                };
+            }
+            const summary = decoys
+                .map((d) => `- ID: ${d.id} | Status: ${d.status} | Email Hash: ${d.decoy_email_hash || 'N/A'}`)
+                .join("\n");
+            return {
+                content: [{ type: "text", text: `Found ${decoys.length} decoys:\n${summary}` }],
+            };
+        }
+        case "decoy_create": {
+            const serviceName = args?.service_name;
+            if (!serviceName) {
+                return {
+                    content: [{ type: "text", text: "service_name is required" }],
+                    isError: true,
+                };
+            }
+            const avatar = args?.avatar;
+            const forwardEnabled = args?.forward_enabled || false;
+            const forwardingEmailId = args?.forwarding_email_id;
+            const label = args?.label;
+            // Send structured parameters — the agent API handles encryption server-side
+            const requestBody = { service_name: serviceName };
+            if (avatar)
+                requestBody.avatar = avatar;
+            if (label)
+                requestBody.label = label;
+            if (forwardEnabled && forwardingEmailId) {
+                requestBody.forward_enabled = true;
+                requestBody.forwarding_email_id = forwardingEmailId;
+            }
+            const response = await fetch(`${apiUrl}/decoys`, {
+                method: "POST",
+                headers,
+                body: JSON.stringify(requestBody),
+            });
+            const data = await response.json();
+            if (!response.ok) {
+                return {
+                    content: [{ type: "text", text: `Failed to create decoy: ${JSON.stringify(data)}` }],
+                    isError: true,
+                };
+            }
+            const forwardingStatus = forwardEnabled
+                ? `\nForwarding: Enabled (to email ID: ${forwardingEmailId})`
+                : "\nForwarding: Disabled (emails go to inbox only)";
+            return {
+                content: [
+                    {
+                        type: "text",
+                        text: `Decoy created!\nID: ${data.id}\nService: ${serviceName}\nEmail: ${data.email || data.decoy_email_hash}${forwardingStatus}`,
+                    },
+                ],
+            };
+        }
+        case "decoy_update": {
+            const decoyId = args?.decoy_id;
+            if (!decoyId) {
+                return {
+                    content: [{ type: "text", text: "decoy_id is required" }],
+                    isError: true,
+                };
+            }
+            const body = {};
+            if (args?.avatar)
+                body.avatar = args.avatar;
+            if (args?.service_name)
+                body.service_name = args.service_name;
+            if (args?.label !== undefined)
+                body.label = args.label;
+            const response = await fetch(`${apiUrl}/decoys/${decoyId}`, {
+                method: "PATCH",
+                headers,
+                body: JSON.stringify(body),
+            });
+            const data = await response.json();
+            if (!response.ok) {
+                return {
+                    content: [{ type: "text", text: `Failed to update decoy: ${JSON.stringify(data)}` }],
+                    isError: true,
+                };
+            }
+            return {
+                content: [{ type: "text", text: `Decoy ${decoyId} updated successfully` }],
+            };
+        }
+        case "decoy_delete": {
+            const decoyId = args?.decoy_id;
+            if (!decoyId) {
+                return {
+                    content: [{ type: "text", text: "decoy_id is required" }],
+                    isError: true,
+                };
+            }
+            const response = await fetch(`${apiUrl}/decoys/${decoyId}`, {
+                method: "DELETE",
+                headers,
+            });
+            if (!response.ok) {
+                const data = await response.json();
+                return {
+                    content: [{ type: "text", text: `Failed to delete decoy: ${JSON.stringify(data)}` }],
+                    isError: true,
+                };
+            }
+            return {
+                content: [{ type: "text", text: `Decoy ${decoyId} deleted successfully.` }],
+            };
+        }
+        case "decoy_get_thread": {
+            const decoyId = args?.decoy_id;
+            if (!decoyId) {
+                return {
+                    content: [{ type: "text", text: "decoy_id is required" }],
+                    isError: true,
+                };
+            }
+            const response = await fetch(`${apiUrl}/decoys/${decoyId}/thread`, {
+                method: "GET",
+                headers,
+            });
+            const data = await response.json();
+            if (!response.ok) {
+                return {
+                    content: [{ type: "text", text: `Failed to get thread: ${JSON.stringify(data)}` }],
+                    isError: true,
+                };
+            }
+            const messages = data.messages || [];
+            if (messages.length === 0) {
+                return {
+                    content: [{ type: "text", text: "No messages found for this decoy." }],
+                };
+            }
+            const summary = messages
+                .map((m) => `- [${m.received_at}] ${m.direction} via ${m.channel} (ID: ${m.id})`)
+                .join("\n");
+            return {
+                content: [{ type: "text", text: `Found ${messages.length} messages:\n${summary}` }],
+            };
+        }
+        default:
+            return {
+                content: [{ type: "text", text: `Unknown decoy tool: ${name}` }],
+                isError: true,
+            };
+    }
+}

package/dist/tools/forwarding-emails.d.ts

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