@alanse/mcp-server-google-workspace 0.2.1 → 1.0.2

package/dist/tools/gmail/labels/gmail_modify_labels.js

@@ -0,0 +1,65 @@
+import { google } from "googleapis";
+import { ResponseFormatter } from "../../../lib/response-formatter.js";
+export const schema = {
+    name: "gmail_modify_labels",
+    description: "Add or remove labels from a Gmail message. Can add and remove multiple labels in a single operation. Use gmail_list_labels to get available label IDs.",
+    inputSchema: {
+        type: "object",
+        properties: {
+            messageId: {
+                type: "string",
+                description: "The Gmail message ID to modify",
+            },
+            addLabelIds: {
+                type: "array",
+                items: { type: "string" },
+                description: "Array of label IDs to add (e.g., ['INBOX', 'STARRED', 'Label_123'])",
+                optional: true,
+            },
+            removeLabelIds: {
+                type: "array",
+                items: { type: "string" },
+                description: "Array of label IDs to remove (e.g., ['UNREAD', 'SPAM'])",
+                optional: true,
+            },
+        },
+        required: ["messageId"],
+    },
+};
+export async function modifyLabels(args) {
+    try {
+        const gmail = google.gmail("v1");
+        const { messageId, addLabelIds = [], removeLabelIds = [] } = args;
+        // Validate at least one operation
+        if (addLabelIds.length === 0 && removeLabelIds.length === 0) {
+            return ResponseFormatter.error(new Error("At least one of addLabelIds or removeLabelIds must be provided"));
+        }
+        // Modify labels
+        const response = await gmail.users.messages.modify({
+            userId: "me",
+            id: messageId,
+            requestBody: {
+                addLabelIds: addLabelIds.length > 0 ? addLabelIds : undefined,
+                removeLabelIds: removeLabelIds.length > 0 ? removeLabelIds : undefined,
+            },
+        });
+        const updatedLabels = response.data.labelIds || [];
+        let output = `✅ Successfully modified labels for message: ${messageId}\n\n`;
+        if (addLabelIds.length > 0) {
+            output += `➕ Added labels: ${addLabelIds.join(", ")}\n`;
+        }
+        if (removeLabelIds.length > 0) {
+            output += `➖ Removed labels: ${removeLabelIds.join(", ")}\n`;
+        }
+        output += `\n📋 Current labels: ${updatedLabels.join(", ") || "(none)"}`;
+        return ResponseFormatter.success({
+            messageId,
+            addedLabels: addLabelIds,
+            removedLabels: removeLabelIds,
+            currentLabels: updatedLabels,
+        }, output);
+    }
+    catch (error) {
+        return ResponseFormatter.error(error);
+    }
+}

package/dist/tools/gmail/send/gmail_draft_message.js

@@ -0,0 +1,117 @@
+import { google } from "googleapis";
+import { ResponseFormatter } from "../../../lib/response-formatter.js";
+import { prepareGmailMessage, generateGmailWebUrl, } from "../../../lib/gmail-helpers.js";
+export const schema = {
+    name: "gmail_draft_message",
+    description: "Create a draft email message in Gmail. The draft is saved but not sent, allowing for later editing or sending. Supports plain text or HTML body, CC/BCC recipients, and threading.",
+    inputSchema: {
+        type: "object",
+        properties: {
+            subject: {
+                type: "string",
+                description: "Email subject line",
+            },
+            body: {
+                type: "string",
+                description: "Email body content (plain text or HTML)",
+            },
+            bodyFormat: {
+                type: "string",
+                enum: ["plain", "html"],
+                description: "Body format type (default: plain)",
+                optional: true,
+            },
+            to: {
+                type: "string",
+                description: "Recipient email address(es). Multiple addresses can be comma-separated.",
+                optional: true,
+            },
+            cc: {
+                type: "string",
+                description: "CC recipient(s). Multiple addresses can be comma-separated.",
+                optional: true,
+            },
+            bcc: {
+                type: "string",
+                description: "BCC recipient(s). Multiple addresses can be comma-separated.",
+                optional: true,
+            },
+            threadId: {
+                type: "string",
+                description: "Thread ID to reply to (makes this a reply draft in an existing conversation)",
+                optional: true,
+            },
+            inReplyTo: {
+                type: "string",
+                description: "Message-ID header of the message being replied to (for threading)",
+                optional: true,
+            },
+            references: {
+                type: "string",
+                description: "References header for email threading (space-separated Message-IDs)",
+                optional: true,
+            },
+        },
+        required: ["subject", "body"],
+    },
+};
+export async function draftMessage(args) {
+    try {
+        const gmail = google.gmail("v1");
+        const { subject, body, bodyFormat = "plain", to, cc, bcc, threadId, inReplyTo, references, } = args;
+        // Prepare base64url encoded MIME message
+        const encodedMessage = prepareGmailMessage({
+            to: to || "",
+            subject,
+            body,
+            bodyFormat,
+            cc,
+            bcc,
+            inReplyTo,
+            references,
+        });
+        // Create the draft
+        const response = await gmail.users.drafts.create({
+            userId: "me",
+            requestBody: {
+                message: {
+                    raw: encodedMessage,
+                    threadId: threadId || undefined,
+                },
+            },
+        });
+        const draft = response.data;
+        const draftId = draft.id || "";
+        const messageId = draft.message?.id || "";
+        const draftThreadId = draft.message?.threadId || "";
+        let output = `✅ Draft created successfully!\n\n`;
+        output += `Draft ID: ${draftId}\n`;
+        output += `Message ID: ${messageId}\n`;
+        if (draftThreadId)
+            output += `Thread ID: ${draftThreadId}\n`;
+        output += `Web URL: ${generateGmailWebUrl(messageId)}\n\n`;
+        output += `📧 Details:\n`;
+        if (to)
+            output += `  To: ${to}\n`;
+        if (cc)
+            output += `  CC: ${cc}\n`;
+        if (bcc)
+            output += `  BCC: ${bcc}\n`;
+        output += `  Subject: ${subject}\n`;
+        output += `  Format: ${bodyFormat}\n`;
+        if (threadId)
+            output += `  Reply to thread: ${threadId}\n`;
+        output += `\n💡 The draft is saved in your Gmail Drafts folder and can be edited or sent later.`;
+        return ResponseFormatter.success({
+            draftId,
+            messageId,
+            threadId: draftThreadId,
+            subject,
+            bodyFormat,
+            to: to || null,
+        }, output);
+    }
+    catch (error) {
+        return ResponseFormatter.error(error);
+    }
+}

package/dist/tools/gmail/send/gmail_send_message.js

@@ -0,0 +1,109 @@
+import { google } from "googleapis";
+import { ResponseFormatter } from "../../../lib/response-formatter.js";
+import { prepareGmailMessage, generateGmailWebUrl, } from "../../../lib/gmail-helpers.js";
+export const schema = {
+    name: "gmail_send_message",
+    description: "Send an email message via Gmail. Supports plain text or HTML body, CC/BCC recipients, and threading (replies). The message will be sent immediately.",
+    inputSchema: {
+        type: "object",
+        properties: {
+            to: {
+                type: "string",
+                description: "Recipient email address(es). Multiple addresses can be comma-separated.",
+            },
+            subject: {
+                type: "string",
+                description: "Email subject line",
+            },
+            body: {
+                type: "string",
+                description: "Email body content (plain text or HTML)",
+            },
+            bodyFormat: {
+                type: "string",
+                enum: ["plain", "html"],
+                description: "Body format type (default: plain)",
+                optional: true,
+            },
+            cc: {
+                type: "string",
+                description: "CC recipient(s). Multiple addresses can be comma-separated.",
+                optional: true,
+            },
+            bcc: {
+                type: "string",
+                description: "BCC recipient(s). Multiple addresses can be comma-separated.",
+                optional: true,
+            },
+            threadId: {
+                type: "string",
+                description: "Thread ID to reply to (makes this a reply in an existing conversation)",
+                optional: true,
+            },
+            inReplyTo: {
+                type: "string",
+                description: "Message-ID header of the message being replied to (for threading)",
+                optional: true,
+            },
+            references: {
+                type: "string",
+                description: "References header for email threading (space-separated Message-IDs)",
+                optional: true,
+            },
+        },
+        required: ["to", "subject", "body"],
+    },
+};
+export async function sendMessage(args) {
+    try {
+        const gmail = google.gmail("v1");
+        const { to, subject, body, bodyFormat = "plain", cc, bcc, threadId, inReplyTo, references, } = args;
+        // Prepare base64url encoded MIME message
+        const encodedMessage = prepareGmailMessage({
+            to,
+            subject,
+            body,
+            bodyFormat,
+            cc,
+            bcc,
+            inReplyTo,
+            references,
+        });
+        // Send the message
+        const response = await gmail.users.messages.send({
+            userId: "me",
+            requestBody: {
+                raw: encodedMessage,
+                threadId: threadId || undefined,
+            },
+        });
+        const sentMessage = response.data;
+        const messageId = sentMessage.id || "";
+        const sentThreadId = sentMessage.threadId || "";
+        let output = `✅ Message sent successfully!\n\n`;
+        output += `Message ID: ${messageId}\n`;
+        output += `Thread ID: ${sentThreadId}\n`;
+        output += `Web URL: ${generateGmailWebUrl(messageId)}\n\n`;
+        output += `📧 Details:\n`;
+        output += `  To: ${to}\n`;
+        if (cc)
+            output += `  CC: ${cc}\n`;
+        if (bcc)
+            output += `  BCC: ${bcc}\n`;
+        output += `  Subject: ${subject}\n`;
+        output += `  Format: ${bodyFormat}\n`;
+        if (threadId)
+            output += `  Reply to thread: ${threadId}\n`;
+        return ResponseFormatter.success({
+            messageId,
+            threadId: sentThreadId,
+            labelIds: sentMessage.labelIds || [],
+            to,
+            subject,
+            bodyFormat,
+        }, output);
+    }
+    catch (error) {
+        return ResponseFormatter.error(error);
+    }
+}