mcp-google-multi 4.2.0

package/dist/tools/forms.d.ts

@@ -0,0 +1,2 @@
+import { McpServer } from '@modelcontextprotocol/sdk/server/mcp.js';
+export declare function registerFormsTools(server: McpServer): void;

package/dist/tools/forms.js

@@ -0,0 +1,96 @@
+import { z } from 'zod';
+import { google } from 'googleapis';
+import { ACCOUNTS } from '../accounts.js';
+import { getClient } from '../client.js';
+import { handleGoogleApiError } from './_errors.js';
+const accountEnum = z.enum(ACCOUNTS);
+export function registerFormsTools(server) {
+    server.registerTool('forms_get', {
+        description: 'Get a Google Form (definition: questions, sections, settings). Requires forms.body scope.',
+        inputSchema: {
+            account: accountEnum.describe('Google account alias'),
+            formId: z.string().describe('Form ID'),
+        },
+    }, async ({ account, formId }) => {
+        try {
+            const auth = await getClient(account);
+            const forms = google.forms({ version: 'v1', auth });
+            const res = await forms.forms.get({ formId });
+            return {
+                content: [{ type: 'text', text: JSON.stringify(res.data, null, 2) }],
+            };
+        }
+        catch (error) {
+            return handleFormsError(error, account);
+        }
+    });
+    server.registerTool('forms_responses_list', {
+        description: 'List form responses. Requires forms.responses.readonly scope.',
+        inputSchema: {
+            account: accountEnum.describe('Google account alias'),
+            formId: z.string().describe('Form ID'),
+            pageSize: z.number().min(1).max(1000).optional().describe('Default: 100; max 1000. Responses can be large.'),
+            pageToken: z.string().optional(),
+            filter: z.string().optional().describe('Filter expression (e.g. "timestamp > 2026-01-01T00:00:00Z")'),
+        },
+    }, async ({ account, formId, pageSize, pageToken, filter }) => {
+        try {
+            const auth = await getClient(account);
+            const forms = google.forms({ version: 'v1', auth });
+            const res = await forms.forms.responses.list({
+                formId,
+                pageSize: pageSize ?? 100,
+                pageToken,
+                filter,
+            });
+            return {
+                content: [{ type: 'text', text: JSON.stringify(res.data, null, 2) }],
+            };
+        }
+        catch (error) {
+            return handleFormsError(error, account);
+        }
+    });
+    server.registerTool('forms_response_get', {
+        description: 'Get a single form response by ID',
+        inputSchema: {
+            account: accountEnum.describe('Google account alias'),
+            formId: z.string().describe('Form ID'),
+            responseId: z.string().describe('Response ID'),
+        },
+    }, async ({ account, formId, responseId }) => {
+        try {
+            const auth = await getClient(account);
+            const forms = google.forms({ version: 'v1', auth });
+            const res = await forms.forms.responses.get({ formId, responseId });
+            return {
+                content: [{ type: 'text', text: JSON.stringify(res.data, null, 2) }],
+            };
+        }
+        catch (error) {
+            return handleFormsError(error, account);
+        }
+    });
+    server.registerTool('forms_watches_list', {
+        description: 'List Pub/Sub watches on a form (notifications for new responses or schema changes)',
+        inputSchema: {
+            account: accountEnum.describe('Google account alias'),
+            formId: z.string().describe('Form ID'),
+        },
+    }, async ({ account, formId }) => {
+        try {
+            const auth = await getClient(account);
+            const forms = google.forms({ version: 'v1', auth });
+            const res = await forms.forms.watches.list({ formId });
+            return {
+                content: [{ type: 'text', text: JSON.stringify(res.data, null, 2) }],
+            };
+        }
+        catch (error) {
+            return handleFormsError(error, account);
+        }
+    });
+}
+function handleFormsError(error, account) {
+    return handleGoogleApiError(error, account, "Forms tools require the optional \"forms\" scope bundle. Add GOOGLE_OPTIONAL_SCOPES=forms (or include \"forms\" in the list) and re-auth.");
+}

package/dist/tools/gmail-mime.d.ts

@@ -0,0 +1,16 @@
+/**
+ * RFC 2047 encoded-word (`=?utf-8?B?...?=`) for non-ASCII header text.
+ * Long values are split into multiple <=75-char encoded-words separated
+ * by `\r\n ` (CRLF SPACE) per the RFC's folding rule.
+ */
+export declare function encodeHeaderValue(value: string): string;
+/**
+ * Encode an address-list header (To/Cc/Bcc/From). RFC 2047 forbids
+ * encoded-words inside the addr-spec, so only the display name is encoded.
+ */
+export declare function encodeAddressHeader(value: string): string;
+/**
+ * RFC 5322 §2.3: CR and LF MUST only occur together as CRLF in bodies.
+ * Normalize bare `\n` or `\r` to CRLF.
+ */
+export declare function normalizeBodyLineEndings(body: string): string;

package/dist/tools/gmail-mime.js

@@ -0,0 +1,64 @@
+/**
+ * RFC 2047 encoded-word (`=?utf-8?B?...?=`) for non-ASCII header text.
+ * Long values are split into multiple <=75-char encoded-words separated
+ * by `\r\n ` (CRLF SPACE) per the RFC's folding rule.
+ */
+export function encodeHeaderValue(value) {
+    // Span includes control chars on purpose — testing for "is this entire
+    // string ASCII?", not "is it printable?".
+    // eslint-disable-next-line no-control-regex
+    if (value === '' || /^[\x00-\x7F]*$/.test(value))
+        return value;
+    const prefix = '=?utf-8?B?';
+    const suffix = '?=';
+    const maxInner = 75 - prefix.length - suffix.length;
+    // base64 emits 4 output chars per 3 input bytes (always padded to a
+    // multiple of 4). Round maxInner DOWN to a multiple of 4 first.
+    const maxBytesPerChunk = Math.floor(maxInner / 4) * 3;
+    // Iterate by codepoint so each chunk's bytes form a complete UTF-8
+    // sequence — many MUAs decode encoded-words individually before joining,
+    // so a mid-byte split would surface as U+FFFD in those clients.
+    const chunks = [];
+    let buffered = [];
+    for (const char of value) {
+        const charBytes = Array.from(Buffer.from(char, 'utf-8'));
+        if (buffered.length + charBytes.length > maxBytesPerChunk && buffered.length > 0) {
+            chunks.push(`${prefix}${Buffer.from(buffered).toString('base64')}${suffix}`);
+            buffered = [];
+        }
+        buffered.push(...charBytes);
+    }
+    if (buffered.length > 0) {
+        chunks.push(`${prefix}${Buffer.from(buffered).toString('base64')}${suffix}`);
+    }
+    return chunks.join('\r\n ');
+}
+/**
+ * Encode an address-list header (To/Cc/Bcc/From). RFC 2047 forbids
+ * encoded-words inside the addr-spec, so only the display name is encoded.
+ */
+export function encodeAddressHeader(value) {
+    if (value === '')
+        return '';
+    return value.split(',').map((part) => {
+        const trimmed = part.trim();
+        if (trimmed === '')
+            return '';
+        const m = trimmed.match(/^(.*?)<([^>]+)>$/);
+        if (m) {
+            const rawName = m[1].trim().replace(/^"(.*)"$/, '$1').trim();
+            const addr = m[2].trim();
+            if (rawName === '')
+                return `<${addr}>`;
+            return `${encodeHeaderValue(rawName)} <${addr}>`;
+        }
+        return trimmed;
+    }).filter(Boolean).join(', ');
+}
+/**
+ * RFC 5322 §2.3: CR and LF MUST only occur together as CRLF in bodies.
+ * Normalize bare `\n` or `\r` to CRLF.
+ */
+export function normalizeBodyLineEndings(body) {
+    return body.replace(/\r\n|\r|\n/g, '\r\n');
+}

package/dist/tools/gmail.d.ts

@@ -0,0 +1,2 @@
+import { McpServer } from '@modelcontextprotocol/sdk/server/mcp.js';
+export declare function registerGmailTools(server: McpServer): void;