mcp-google-multi 4.2.0

package/dist/tools/meet.js

@@ -0,0 +1,133 @@
+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 registerMeetTools(server) {
+    // ─── Conference records (past meetings) ────────────────────────────────
+    server.registerTool('meet_conference_records_list', {
+        description: 'List past conference records (completed Meet sessions) the user has access to',
+        inputSchema: {
+            account: accountEnum.describe('Google account alias'),
+            pageSize: z.number().min(1).max(100).optional(),
+            pageToken: z.string().optional(),
+            filter: z.string().optional().describe('Filter expression, e.g. "space.meeting_code=abc-defg-hij"'),
+        },
+    }, async ({ account, pageSize, pageToken, filter }) => {
+        try {
+            const auth = await getClient(account);
+            const meet = google.meet({ version: 'v2', auth });
+            const res = await meet.conferenceRecords.list({
+                pageSize: pageSize ?? 20,
+                pageToken,
+                filter,
+            });
+            return {
+                content: [{ type: 'text', text: JSON.stringify(res.data, null, 2) }],
+            };
+        }
+        catch (error) {
+            return handleMeetError(error, account);
+        }
+    });
+    server.registerTool('meet_conference_record_get', {
+        description: 'Get a single conference record by resource name (e.g. conferenceRecords/abc123)',
+        inputSchema: {
+            account: accountEnum.describe('Google account alias'),
+            name: z.string().describe('Resource name, format: conferenceRecords/{conference_record}'),
+        },
+    }, async ({ account, name }) => {
+        try {
+            const auth = await getClient(account);
+            const meet = google.meet({ version: 'v2', auth });
+            const res = await meet.conferenceRecords.get({ name });
+            return {
+                content: [{ type: 'text', text: JSON.stringify(res.data, null, 2) }],
+            };
+        }
+        catch (error) {
+            return handleMeetError(error, account);
+        }
+    });
+    // ─── Recordings ────────────────────────────────────────────────────────
+    server.registerTool('meet_recordings_list', {
+        description: 'List recordings within a conference record. Returns Drive file IDs that can be downloaded via drive_download.',
+        inputSchema: {
+            account: accountEnum.describe('Google account alias'),
+            parent: z.string().describe('Parent conference record, format: conferenceRecords/{id}'),
+            pageSize: z.number().min(1).max(100).optional(),
+            pageToken: z.string().optional(),
+        },
+    }, async ({ account, parent, pageSize, pageToken }) => {
+        try {
+            const auth = await getClient(account);
+            const meet = google.meet({ version: 'v2', auth });
+            const res = await meet.conferenceRecords.recordings.list({
+                parent,
+                pageSize: pageSize ?? 20,
+                pageToken,
+            });
+            return {
+                content: [{ type: 'text', text: JSON.stringify(res.data, null, 2) }],
+            };
+        }
+        catch (error) {
+            return handleMeetError(error, account);
+        }
+    });
+    // ─── Transcripts ───────────────────────────────────────────────────────
+    server.registerTool('meet_transcripts_list', {
+        description: 'List transcripts within a conference record',
+        inputSchema: {
+            account: accountEnum.describe('Google account alias'),
+            parent: z.string().describe('Parent conference record, format: conferenceRecords/{id}'),
+            pageSize: z.number().min(1).max(100).optional(),
+            pageToken: z.string().optional(),
+        },
+    }, async ({ account, parent, pageSize, pageToken }) => {
+        try {
+            const auth = await getClient(account);
+            const meet = google.meet({ version: 'v2', auth });
+            const res = await meet.conferenceRecords.transcripts.list({
+                parent,
+                pageSize: pageSize ?? 20,
+                pageToken,
+            });
+            return {
+                content: [{ type: 'text', text: JSON.stringify(res.data, null, 2) }],
+            };
+        }
+        catch (error) {
+            return handleMeetError(error, account);
+        }
+    });
+    server.registerTool('meet_transcript_entries_list', {
+        description: 'List entries (per-speaker text segments) within a transcript. The actual transcript content.',
+        inputSchema: {
+            account: accountEnum.describe('Google account alias'),
+            parent: z.string().describe('Parent transcript, format: conferenceRecords/{id}/transcripts/{id}'),
+            pageSize: z.number().min(1).max(1000).optional(),
+            pageToken: z.string().optional(),
+        },
+    }, async ({ account, parent, pageSize, pageToken }) => {
+        try {
+            const auth = await getClient(account);
+            const meet = google.meet({ version: 'v2', auth });
+            const res = await meet.conferenceRecords.transcripts.entries.list({
+                parent,
+                pageSize: pageSize ?? 200,
+                pageToken,
+            });
+            return {
+                content: [{ type: 'text', text: JSON.stringify(res.data, null, 2) }],
+            };
+        }
+        catch (error) {
+            return handleMeetError(error, account);
+        }
+    });
+}
+function handleMeetError(error, account) {
+    return handleGoogleApiError(error, account, "Meet API requires the meetings.space.readonly scope and the Google Meet API enabled in Cloud Console. Confirm both for this account.");
+}

package/dist/tools/searchconsole.d.ts

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

package/dist/tools/searchconsole.js

@@ -0,0 +1,258 @@
+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 registerSearchConsoleTools(server) {
+    // ─── Sites ───────────────────────────────────────────────
+    server.registerTool('searchconsole_sites_list', {
+        description: 'List all sites (properties) the account has access to in Google Search Console',
+        inputSchema: {
+            account: accountEnum.describe('Google account alias'),
+        },
+    }, async ({ account }) => {
+        try {
+            const auth = await getClient(account);
+            const wm = google.webmasters({ version: 'v3', auth });
+            const res = await wm.sites.list();
+            return {
+                content: [{ type: 'text', text: JSON.stringify(res.data.siteEntry ?? [], null, 2) }],
+            };
+        }
+        catch (error) {
+            return handleSearchConsoleError(error, account);
+        }
+    });
+    server.registerTool('searchconsole_sites_get', {
+        description: 'Get details for a specific site (property) in Google Search Console',
+        inputSchema: {
+            account: accountEnum.describe('Google account alias'),
+            siteUrl: z.string().describe('Site URL exactly as it appears in Search Console (e.g. "https://example.com/" or "sc-domain:example.com")'),
+        },
+    }, async ({ account, siteUrl }) => {
+        try {
+            const auth = await getClient(account);
+            const wm = google.webmasters({ version: 'v3', auth });
+            const res = await wm.sites.get({ siteUrl });
+            return {
+                content: [{ type: 'text', text: JSON.stringify(res.data, null, 2) }],
+            };
+        }
+        catch (error) {
+            return handleSearchConsoleError(error, account);
+        }
+    });
+    server.registerTool('searchconsole_sites_add', {
+        description: 'Add a site (property) to Google Search Console. You still need to verify ownership separately.',
+        inputSchema: {
+            account: accountEnum.describe('Google account alias'),
+            siteUrl: z.string().describe('Site URL to add (e.g. "https://example.com/" or "sc-domain:example.com")'),
+        },
+    }, async ({ account, siteUrl }) => {
+        try {
+            const auth = await getClient(account);
+            const wm = google.webmasters({ version: 'v3', auth });
+            await wm.sites.add({ siteUrl });
+            return {
+                content: [{ type: 'text', text: JSON.stringify({ success: true, siteUrl }, null, 2) }],
+            };
+        }
+        catch (error) {
+            return handleSearchConsoleError(error, account);
+        }
+    });
+    server.registerTool('searchconsole_sites_delete', {
+        description: 'Remove a site (property) from Google Search Console',
+        inputSchema: {
+            account: accountEnum.describe('Google account alias'),
+            siteUrl: z.string().describe('Site URL to remove'),
+        },
+    }, async ({ account, siteUrl }) => {
+        try {
+            const auth = await getClient(account);
+            const wm = google.webmasters({ version: 'v3', auth });
+            await wm.sites.delete({ siteUrl });
+            return {
+                content: [{ type: 'text', text: JSON.stringify({ success: true, deleted: siteUrl }, null, 2) }],
+            };
+        }
+        catch (error) {
+            return handleSearchConsoleError(error, account);
+        }
+    });
+    // ─── Sitemaps ────────────────────────────────────────────
+    server.registerTool('searchconsole_sitemaps_list', {
+        description: 'List all sitemaps submitted for a site in Google Search Console',
+        inputSchema: {
+            account: accountEnum.describe('Google account alias'),
+            siteUrl: z.string().describe('Site URL (e.g. "https://example.com/" or "sc-domain:example.com")'),
+        },
+    }, async ({ account, siteUrl }) => {
+        try {
+            const auth = await getClient(account);
+            const wm = google.webmasters({ version: 'v3', auth });
+            const res = await wm.sitemaps.list({ siteUrl });
+            return {
+                content: [{ type: 'text', text: JSON.stringify(res.data.sitemap ?? [], null, 2) }],
+            };
+        }
+        catch (error) {
+            return handleSearchConsoleError(error, account);
+        }
+    });
+    server.registerTool('searchconsole_sitemaps_get', {
+        description: 'Get details for a specific sitemap submitted to Google Search Console',
+        inputSchema: {
+            account: accountEnum.describe('Google account alias'),
+            siteUrl: z.string().describe('Site URL'),
+            feedpath: z.string().describe('Full URL of the sitemap (e.g. "https://example.com/sitemap.xml")'),
+        },
+    }, async ({ account, siteUrl, feedpath }) => {
+        try {
+            const auth = await getClient(account);
+            const wm = google.webmasters({ version: 'v3', auth });
+            const res = await wm.sitemaps.get({ siteUrl, feedpath });
+            return {
+                content: [{ type: 'text', text: JSON.stringify(res.data, null, 2) }],
+            };
+        }
+        catch (error) {
+            return handleSearchConsoleError(error, account);
+        }
+    });
+    server.registerTool('searchconsole_sitemaps_submit', {
+        description: 'Submit a sitemap to Google Search Console for a site',
+        inputSchema: {
+            account: accountEnum.describe('Google account alias'),
+            siteUrl: z.string().describe('Site URL'),
+            feedpath: z.string().describe('Full URL of the sitemap to submit (e.g. "https://example.com/sitemap.xml")'),
+        },
+    }, async ({ account, siteUrl, feedpath }) => {
+        try {
+            const auth = await getClient(account);
+            const wm = google.webmasters({ version: 'v3', auth });
+            await wm.sitemaps.submit({ siteUrl, feedpath });
+            return {
+                content: [{ type: 'text', text: JSON.stringify({ success: true, siteUrl, feedpath }, null, 2) }],
+            };
+        }
+        catch (error) {
+            return handleSearchConsoleError(error, account);
+        }
+    });
+    server.registerTool('searchconsole_sitemaps_delete', {
+        description: 'Delete a sitemap from Google Search Console',
+        inputSchema: {
+            account: accountEnum.describe('Google account alias'),
+            siteUrl: z.string().describe('Site URL'),
+            feedpath: z.string().describe('Full URL of the sitemap to delete'),
+        },
+    }, async ({ account, siteUrl, feedpath }) => {
+        try {
+            const auth = await getClient(account);
+            const wm = google.webmasters({ version: 'v3', auth });
+            await wm.sitemaps.delete({ siteUrl, feedpath });
+            return {
+                content: [{ type: 'text', text: JSON.stringify({ success: true, deleted: feedpath }, null, 2) }],
+            };
+        }
+        catch (error) {
+            return handleSearchConsoleError(error, account);
+        }
+    });
+    // ─── Search Analytics ────────────────────────────────────
+    server.registerTool('searchconsole_searchanalytics_query', {
+        description: 'Query Google Search Console search analytics data. Returns clicks, impressions, CTR, and position for your site. Supports filtering by query, page, country, device, search type, and date range.',
+        inputSchema: {
+            account: accountEnum.describe('Google account alias'),
+            siteUrl: z.string().describe('Site URL (e.g. "https://example.com/" or "sc-domain:example.com")'),
+            startDate: z.string().describe('Start date (YYYY-MM-DD). Data is available starting ~3 days ago.'),
+            endDate: z.string().describe('End date (YYYY-MM-DD)'),
+            dimensions: z.array(z.enum(['query', 'page', 'country', 'device', 'searchAppearance', 'date'])).optional()
+                .describe('Dimensions to group by. Common: ["query", "page"], ["date"], ["query", "date"]'),
+            type: z.enum(['web', 'image', 'video', 'news', 'discover', 'googleNews']).optional()
+                .describe('Search type filter (default: web)'),
+            dimensionFilterGroups: z.array(z.object({
+                groupType: z.enum(['and']).optional(),
+                filters: z.array(z.object({
+                    dimension: z.enum(['query', 'page', 'country', 'device', 'searchAppearance']),
+                    operator: z.enum(['contains', 'equals', 'notContains', 'notEquals', 'includingRegex', 'excludingRegex']),
+                    expression: z.string(),
+                })),
+            })).optional()
+                .describe('Filters to narrow results. Example: filter by page containing "/blog/" or query containing "keyword"'),
+            rowLimit: z.number().min(1).max(25000).optional()
+                .describe('Max rows to return (default: 1000, max: 25000)'),
+            startRow: z.number().min(0).optional()
+                .describe('Zero-based row offset for pagination (default: 0)'),
+            aggregationType: z.enum(['auto', 'byPage', 'byProperty']).optional()
+                .describe('How to aggregate data (default: auto)'),
+            dataState: z.enum(['all', 'final']).optional()
+                .describe('"all" includes fresh (not finalized) data; "final" only finalized data'),
+        },
+    }, async ({ account, siteUrl, startDate, endDate, dimensions, type, dimensionFilterGroups, rowLimit, startRow, aggregationType, dataState }) => {
+        try {
+            const auth = await getClient(account);
+            const wm = google.webmasters({ version: 'v3', auth });
+            const requestBody = { startDate, endDate };
+            if (dimensions)
+                requestBody.dimensions = dimensions;
+            if (type)
+                requestBody.type = type;
+            if (dimensionFilterGroups)
+                requestBody.dimensionFilterGroups = dimensionFilterGroups;
+            if (rowLimit)
+                requestBody.rowLimit = rowLimit;
+            if (startRow !== undefined)
+                requestBody.startRow = startRow;
+            if (aggregationType)
+                requestBody.aggregationType = aggregationType;
+            if (dataState)
+                requestBody.dataState = dataState;
+            const res = await wm.searchanalytics.query({ siteUrl, requestBody });
+            const summary = {
+                rowCount: res.data.rows?.length ?? 0,
+                responseAggregationType: res.data.responseAggregationType,
+                rows: res.data.rows ?? [],
+            };
+            return {
+                content: [{ type: 'text', text: JSON.stringify(summary, null, 2) }],
+            };
+        }
+        catch (error) {
+            return handleSearchConsoleError(error, account);
+        }
+    });
+    // ─── URL Inspection ──────────────────────────────────────
+    server.registerTool('searchconsole_url_inspect', {
+        description: 'Inspect a URL using the Google Search Console URL Inspection API. Returns indexing status, crawl info, rich results, AMP status, and mobile usability for a specific URL.',
+        inputSchema: {
+            account: accountEnum.describe('Google account alias'),
+            siteUrl: z.string().describe('Site URL as registered in Search Console (e.g. "https://example.com/" or "sc-domain:example.com")'),
+            inspectionUrl: z.string().describe('The fully-qualified URL to inspect (must be under the siteUrl property)'),
+            languageCode: z.string().optional().describe('BCP-47 language code for localized results (e.g. "en-US", "fr")'),
+        },
+    }, async ({ account, siteUrl, inspectionUrl, languageCode }) => {
+        try {
+            const auth = await getClient(account);
+            const searchconsole = google.searchconsole({ version: 'v1', auth });
+            const res = await searchconsole.urlInspection.index.inspect({
+                requestBody: {
+                    inspectionUrl,
+                    siteUrl,
+                    languageCode: languageCode ?? 'en',
+                },
+            });
+            return {
+                content: [{ type: 'text', text: JSON.stringify(res.data, null, 2) }],
+            };
+        }
+        catch (error) {
+            return handleSearchConsoleError(error, account);
+        }
+    });
+}
+function handleSearchConsoleError(error, account) {
+    return handleGoogleApiError(error, account);
+}

package/dist/tools/sheets.d.ts

@@ -0,0 +1,34 @@
+import { McpServer } from '@modelcontextprotocol/sdk/server/mcp.js';
+export declare function registerSheetsTools(server: McpServer): void;
+export declare function buildCellFormat(input: {
+    backgroundColor?: {
+        red?: number;
+        green?: number;
+        blue?: number;
+        alpha?: number;
+    };
+    textFormat?: {
+        foregroundColor?: {
+            red?: number;
+            green?: number;
+            blue?: number;
+            alpha?: number;
+        };
+        bold?: boolean;
+        italic?: boolean;
+        underline?: boolean;
+        strikethrough?: boolean;
+        fontFamily?: string;
+        fontSize?: number;
+    };
+    horizontalAlignment?: string;
+    verticalAlignment?: string;
+    wrapStrategy?: string;
+    numberFormat?: {
+        type: string;
+        pattern?: string;
+    };
+}): {
+    format: any;
+    fields: string;
+};