mcp-google-gsc 1.0.0

package/LICENSE

@@ -0,0 +1,21 @@
+MIT License
+
+Copyright (c) 2026 drak-marketing
+
+Permission is hereby granted, free of charge, to any person obtaining a copy
+of this software and associated documentation files (the "Software"), to deal
+in the Software without restriction, including without limitation the rights
+to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
+copies of the Software, and to permit persons to whom the Software is
+furnished to do so, subject to the following conditions:
+
+The above copyright notice and this permission notice shall be included in all
+copies or substantial portions of the Software.
+
+THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
+AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
+OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
+SOFTWARE.

package/README.md

@@ -0,0 +1,114 @@
+# mcp-gsc
+
+MCP server for Google Search Console -- search analytics, URL inspection, and site management via Claude.
+
+## Features
+
+- **Search Analytics** -- Query clicks, impressions, CTR, and position with flexible dimension filters (query, page, device, country, date)
+- **URL Inspection** -- Check indexing status, mobile usability, and rich results for any URL
+- **Site Listing** -- List all verified Search Console properties accessible to your service account
+- **Multi-Client Support** -- Manage multiple GSC properties with per-directory config mapping
+
+## Installation
+
+### From npm
+
+```bash
+npm install mcp-gsc
+```
+
+### From source
+
+```bash
+git clone https://github.com/drak-marketing/mcp-gsc.git
+cd mcp-gsc
+npm install
+npm run build
+```
+
+## Configuration
+
+### Service Account Setup
+
+1. Create a Google Cloud service account with Search Console API access
+2. Download the JSON key file
+3. Add the service account email as a user in Google Search Console for each property
+
+### Config File
+
+Create a `config.json` in the project root (see `config.example.json` for the full structure):
+
+```json
+{
+  "default_credentials": "/path/to/service-account-key.json",
+  "clients": {
+    "my-project": {
+      "site_url": "sc-domain:example.com",
+      "credentials": "/path/to/service-account-key.json"
+    }
+  }
+}
+```
+
+### Environment Variable
+
+Alternatively, set `GOOGLE_APPLICATION_CREDENTIALS` to the path of your service account key file. The config file takes precedence when present.
+
+## Usage
+
+Add to your Claude Code `.mcp.json`:
+
+```json
+{
+  "mcpServers": {
+    "gsc": {
+      "command": "node",
+      "args": ["/path/to/mcp-gsc/dist/index.js"]
+    }
+  }
+}
+```
+
+Or if installed globally:
+
+```json
+{
+  "mcpServers": {
+    "gsc": {
+      "command": "npx",
+      "args": ["mcp-gsc"]
+    }
+  }
+}
+```
+
+## Tools
+
+| Tool | Description |
+|------|-------------|
+| `gsc_get_client_context` | Detect the GSC property from your working directory based on config mapping |
+| `gsc_list_sites` | List all verified Search Console properties accessible to the service account |
+| `gsc_search_analytics` | Query search performance data (clicks, impressions, CTR, position) with dimension and filter support |
+| `gsc_inspection` | Inspect a URL for indexing status, mobile usability, and rich results |
+
+### gsc_search_analytics
+
+Supports dimensions: `query`, `page`, `device`, `country`, `date`. Filter by any dimension with operators like `equals`, `contains`, `notContains`. Date range defaults to the last 28 days.
+
+### gsc_inspection
+
+Returns index coverage, crawl status, mobile usability verdict, and rich result details for a specific URL within a property.
+
+## Architecture
+
+- **Resilience** -- Uses cockatiel for retry with exponential backoff and circuit breaker patterns on all Google API calls
+- **Logging** -- Structured logging via pino with configurable log levels
+- **Response Handling** -- Responses truncated at 200KB to stay within MCP transport limits
+
+## License
+
+MIT -- see [LICENSE](LICENSE).
+
+---
+
+Built by Mark Harnett / [drak-marketing](https://github.com/drak-marketing)

package/config.example.json

@@ -0,0 +1,10 @@
+{
+  "credentials_file": "/path/to/service-account.json",
+  "clients": {
+    "my-client": {
+      "name": "My Client",
+      "folder": "/path/to/project",
+      "site_url": "https://example.com/"
+    }
+  }
+}

package/dist/build-info.json

@@ -0,0 +1 @@
+{"sha":"65b772d","builtAt":"2026-04-03T23:26:46.310Z"}

package/dist/errors.d.ts

@@ -0,0 +1,17 @@
+export declare class GscAuthError extends Error {
+    readonly cause?: unknown | undefined;
+    constructor(message: string, cause?: unknown | undefined);
+}
+export declare class GscRateLimitError extends Error {
+    readonly retryAfterMs: number;
+    constructor(retryAfterMs: number, cause?: unknown);
+}
+export declare class GscServiceError extends Error {
+    readonly cause?: unknown | undefined;
+    constructor(message: string, cause?: unknown | undefined);
+}
+export declare function validateCredentials(credentialsFile: string): {
+    valid: boolean;
+    missing: string[];
+};
+export declare function classifyError(error: any): Error;

package/dist/errors.js

@@ -0,0 +1,58 @@
+// ============================================
+// TYPED ERRORS
+// ============================================
+export class GscAuthError extends Error {
+    cause;
+    constructor(message, cause) {
+        super(message);
+        this.cause = cause;
+        this.name = "GscAuthError";
+    }
+}
+export class GscRateLimitError extends Error {
+    retryAfterMs;
+    constructor(retryAfterMs, cause) {
+        super(`Rate limited, retry after ${retryAfterMs}ms`);
+        this.retryAfterMs = retryAfterMs;
+        this.name = "GscRateLimitError";
+        this.cause = cause;
+    }
+}
+export class GscServiceError extends Error {
+    cause;
+    constructor(message, cause) {
+        super(message);
+        this.cause = cause;
+        this.name = "GscServiceError";
+    }
+}
+// ============================================
+// STARTUP CREDENTIAL VALIDATION
+// ============================================
+export function validateCredentials(credentialsFile) {
+    const missing = [];
+    if (!credentialsFile || credentialsFile.trim() === "") {
+        missing.push("credentials_file (in config.json or GOOGLE_APPLICATION_CREDENTIALS env var)");
+    }
+    return { valid: missing.length === 0, missing };
+}
+export function classifyError(error) {
+    const message = error?.message || String(error);
+    const status = error?.code || error?.status;
+    if (status === 401 ||
+        status === 403 ||
+        message.includes("invalid_grant") ||
+        message.includes("PERMISSION_DENIED") ||
+        message.includes("access_denied") ||
+        message.includes("Invalid credentials")) {
+        return new GscAuthError(`Auth failed: ${message}. Check service account credentials and permissions.`, error);
+    }
+    if (status === 429 || message.includes("rateLimitExceeded") || message.includes("RESOURCE_EXHAUSTED")) {
+        const retryMs = 60_000;
+        return new GscRateLimitError(retryMs, error);
+    }
+    if (status >= 500 || message.includes("INTERNAL") || message.includes("UNAVAILABLE")) {
+        return new GscServiceError(`GSC API server error: ${message}`, error);
+    }
+    return error;
+}

package/dist/index.d.ts

@@ -0,0 +1,2 @@
+#!/usr/bin/env node
+export {};

package/dist/index.js

@@ -0,0 +1,354 @@
+#!/usr/bin/env node
+import { Server } from "@modelcontextprotocol/sdk/server/index.js";
+import { StdioServerTransport } from "@modelcontextprotocol/sdk/server/stdio.js";
+import { CallToolRequestSchema, ListToolsRequestSchema, } from "@modelcontextprotocol/sdk/types.js";
+import { readFileSync, existsSync } from "fs";
+import { join, dirname } from "path";
+import { google } from "googleapis";
+import { GscAuthError, GscRateLimitError, GscServiceError, classifyError, validateCredentials, } from "./errors.js";
+import { tools } from "./tools.js";
+import { withResilience, safeResponse, logger } from "./resilience.js";
+// Log build fingerprint at startup
+try {
+    const __buildInfoDir = dirname(new URL(import.meta.url).pathname);
+    const buildInfo = JSON.parse(readFileSync(join(__buildInfoDir, "build-info.json"), "utf-8"));
+    console.error(`[build] SHA: ${buildInfo.sha} (${buildInfo.builtAt})`);
+}
+catch {
+    // build-info.json not present (dev mode)
+}
+function loadConfig() {
+    const configPath = join(dirname(new URL(import.meta.url).pathname), "..", "config.json");
+    if (!existsSync(configPath)) {
+        throw new Error(`Config file not found at ${configPath}. Copy config.example.json to config.json and fill in your credentials.`);
+    }
+    const raw = JSON.parse(readFileSync(configPath, "utf-8"));
+    return {
+        credentials_file: raw.credentials_file || process.env.GOOGLE_APPLICATION_CREDENTIALS || "",
+        clients: raw.clients || {},
+    };
+}
+function getClientFromWorkingDir(config, cwd) {
+    for (const [key, client] of Object.entries(config.clients)) {
+        if (cwd.startsWith(client.folder) || cwd.includes(key)) {
+            return client;
+        }
+    }
+    return null;
+}
+function getDefaultSiteUrl(config) {
+    const clients = Object.values(config.clients);
+    return clients.length > 0 ? clients[0].site_url : null;
+}
+// ============================================
+// DATE HELPERS
+// ============================================
+function resolveDate(dateStr) {
+    const today = new Date();
+    if (dateStr === "today") {
+        return today.toISOString().slice(0, 10);
+    }
+    const match = dateStr.match(/^(\d+)daysAgo$/);
+    if (match) {
+        const days = parseInt(match[1], 10);
+        const d = new Date(today);
+        d.setDate(d.getDate() - days);
+        return d.toISOString().slice(0, 10);
+    }
+    return dateStr; // assume YYYY-MM-DD
+}
+function parseDimensionFilter(filterStr) {
+    if (!filterStr)
+        return null;
+    const operators = [
+        "includingRegex", "excludingRegex",
+        "notContains", "notEquals",
+        "contains", "equals",
+    ];
+    for (const op of operators) {
+        const parts = filterStr.split(` ${op} `, 2);
+        if (parts.length === 2) {
+            return {
+                dimension: parts[0].trim(),
+                operator: op,
+                expression: parts[1].trim(),
+            };
+        }
+    }
+    return null;
+}
+// ============================================
+// GOOGLE SEARCH CONSOLE API CLIENT
+// ============================================
+class GscManager {
+    config;
+    service = null;
+    constructor(config) {
+        this.config = config;
+        const creds = validateCredentials(config.credentials_file);
+        if (!creds.valid) {
+            const msg = `[STARTUP ERROR] Missing required credentials: ${creds.missing.join(", ")}. MCP will not function.`;
+            console.error(msg);
+            throw new GscAuthError(msg);
+        }
+    }
+    getService() {
+        if (!this.service) {
+            const auth = new google.auth.GoogleAuth({
+                keyFile: this.config.credentials_file,
+                scopes: ["https://www.googleapis.com/auth/webmasters.readonly"],
+            });
+            this.service = google.searchconsole({ version: "v1", auth });
+            console.error(`[startup] Service account loaded from: ${this.config.credentials_file}`);
+        }
+        return this.service;
+    }
+    async listSites() {
+        const svc = this.getService();
+        return withResilience(async () => {
+            const resp = await svc.sites.list();
+            const sites = (resp.data.siteEntry || []).map((entry) => ({
+                site_url: entry.siteUrl || "",
+                permission_level: entry.permissionLevel || "",
+            }));
+            return { sites, count: sites.length };
+        }, "gsc_list_sites");
+    }
+    async searchAnalytics(options) {
+        const svc = this.getService();
+        const siteUrl = options.siteUrl || getDefaultSiteUrl(this.config);
+        if (!siteUrl) {
+            return { error: "No site_url provided and none found in config" };
+        }
+        const rowLimit = Math.min(Math.max(1, options.rowLimit), 25000);
+        const startDate = resolveDate(options.startDate);
+        const endDate = resolveDate(options.endDate);
+        const requestBody = {
+            startDate,
+            endDate,
+            dimensions: options.dimensions,
+            type: options.searchType,
+            rowLimit,
+            aggregationType: options.aggregationType,
+        };
+        const parsed = parseDimensionFilter(options.dimensionFilter);
+        if (parsed) {
+            requestBody.dimensionFilterGroups = [{
+                    filters: [{
+                            dimension: parsed.dimension,
+                            operator: parsed.operator,
+                            expression: parsed.expression,
+                        }],
+                }];
+        }
+        return withResilience(async () => {
+            const resp = await svc.searchanalytics.query({
+                siteUrl,
+                requestBody,
+            });
+            const rows = (resp.data.rows || []).map((row) => {
+                const r = {};
+                for (let i = 0; i < options.dimensions.length; i++) {
+                    if (row.keys && i < row.keys.length) {
+                        r[options.dimensions[i]] = row.keys[i];
+                    }
+                }
+                r.clicks = row.clicks || 0;
+                r.impressions = row.impressions || 0;
+                r.ctr = Math.round((row.ctr || 0) * 10000) / 10000;
+                r.position = Math.round((row.position || 0) * 10) / 10;
+                return r;
+            });
+            return {
+                rows,
+                row_count: rows.length,
+                date_range: `${startDate} to ${endDate}`,
+                site_url: siteUrl,
+            };
+        }, "gsc_search_analytics");
+    }
+    async inspection(url, siteUrl) {
+        const svc = this.getService();
+        const resolvedSiteUrl = siteUrl || getDefaultSiteUrl(this.config);
+        if (!resolvedSiteUrl) {
+            return { error: "No site_url provided and none found in config" };
+        }
+        return withResilience(async () => {
+            try {
+                const resp = await svc.urlInspection.index.inspect({
+                    requestBody: {
+                        inspectionUrl: url,
+                        siteUrl: resolvedSiteUrl,
+                    },
+                });
+                const result = resp.data.inspectionResult || {};
+                const indexStatus = result.indexStatusResult || {};
+                const mobile = result.mobileUsabilityResult || {};
+                const rich = result.richResultsResult || {};
+                return {
+                    url,
+                    site_url: resolvedSiteUrl,
+                    index_status: {
+                        verdict: indexStatus.verdict || "UNKNOWN",
+                        coverage_state: indexStatus.coverageState || "",
+                        indexing_state: indexStatus.indexingState || "",
+                        last_crawl_time: indexStatus.lastCrawlTime || "",
+                        page_fetch_state: indexStatus.pageFetchState || "",
+                        robots_txt_state: indexStatus.robotsTxtState || "",
+                        crawled_as: indexStatus.crawledAs || "",
+                        referring_urls: indexStatus.referringUrls || [],
+                    },
+                    mobile_usability: {
+                        verdict: mobile.verdict || "UNKNOWN",
+                        issues: (mobile.issues || []).map((i) => i.issueType || ""),
+                    },
+                    rich_results: {
+                        verdict: rich.verdict || "UNKNOWN",
+                    },
+                };
+            }
+            catch (err) {
+                return { error: String(err), url, site_url: resolvedSiteUrl };
+            }
+        }, "gsc_inspection");
+    }
+}
+// ============================================
+// MCP SERVER
+// ============================================
+const config = loadConfig();
+const gscManager = new GscManager(config);
+const server = new Server({
+    name: "mcp-gsc",
+    version: "1.0.0",
+}, {
+    capabilities: {
+        tools: {},
+    },
+});
+server.setRequestHandler(ListToolsRequestSchema, async () => {
+    return { tools };
+});
+server.setRequestHandler(CallToolRequestSchema, async (request) => {
+    const { name, arguments: args } = request.params;
+    try {
+        switch (name) {
+            case "gsc_get_client_context": {
+                const cwd = args?.working_directory;
+                const client = getClientFromWorkingDir(config, cwd);
+                if (!client) {
+                    return {
+                        content: [{
+                                type: "text",
+                                text: JSON.stringify({
+                                    error: "No client found for working directory",
+                                    working_directory: cwd,
+                                    available_clients: Object.entries(config.clients).map(([k, v]) => ({
+                                        key: k,
+                                        name: v.name,
+                                        folder: v.folder,
+                                    })),
+                                }, null, 2),
+                            }],
+                    };
+                }
+                return {
+                    content: [{
+                            type: "text",
+                            text: JSON.stringify({
+                                client_name: client.name,
+                                site_url: client.site_url,
+                                folder: client.folder,
+                            }, null, 2),
+                        }],
+                };
+            }
+            case "gsc_list_sites": {
+                const result = await gscManager.listSites();
+                return {
+                    content: [{
+                            type: "text",
+                            text: JSON.stringify(safeResponse(result, "listSites"), null, 2),
+                        }],
+                };
+            }
+            case "gsc_search_analytics": {
+                const dimensions = (args?.dimensions || "query")
+                    .split(",")
+                    .map((d) => d.trim())
+                    .filter(Boolean);
+                const result = await gscManager.searchAnalytics({
+                    startDate: args?.start_date || "90daysAgo",
+                    endDate: args?.end_date || "today",
+                    dimensions,
+                    searchType: args?.search_type || "web",
+                    dimensionFilter: args?.dimension_filter || "",
+                    rowLimit: args?.row_limit || 100,
+                    aggregationType: args?.aggregation_type || "auto",
+                    siteUrl: args?.site_url || "",
+                });
+                return {
+                    content: [{
+                            type: "text",
+                            text: JSON.stringify(safeResponse(result, "searchAnalytics"), null, 2),
+                        }],
+                };
+            }
+            case "gsc_inspection": {
+                const result = await gscManager.inspection(args?.url, args?.site_url || "");
+                return {
+                    content: [{
+                            type: "text",
+                            text: JSON.stringify(result, null, 2),
+                        }],
+                };
+            }
+            default:
+                throw new Error(`Unknown tool: ${name}`);
+        }
+    }
+    catch (rawError) {
+        const error = classifyError(rawError);
+        logger.error({ error_type: error.name, message: error.message }, "Tool call failed");
+        const response = {
+            error: true,
+            error_type: error.name,
+            message: error.message,
+        };
+        if (error instanceof GscAuthError) {
+            response.action_required = "Check service account credentials and Search Console permissions.";
+        }
+        else if (error instanceof GscRateLimitError) {
+            response.retry_after_ms = error.retryAfterMs;
+            response.action_required = `Rate limited. Retry after ${Math.ceil(error.retryAfterMs / 1000)} seconds.`;
+        }
+        else if (error instanceof GscServiceError) {
+            response.action_required = "Google Search Console API server error. This is transient - retry in a few minutes.";
+        }
+        else {
+            response.details = rawError.stack;
+        }
+        return {
+            content: [{
+                    type: "text",
+                    text: JSON.stringify(response, null, 2),
+                }],
+            isError: true,
+        };
+    }
+});
+// Start server
+async function main() {
+    try {
+        await gscManager.listSites();
+        console.error("[startup] Auth verified: GSC API call succeeded");
+    }
+    catch (err) {
+        console.error(`[STARTUP WARNING] Auth check FAILED: ${err.message}`);
+        console.error(`[STARTUP WARNING] MCP will start but API calls may fail until auth is fixed.`);
+    }
+    const transport = new StdioServerTransport();
+    await server.connect(transport);
+    console.error("[startup] MCP GSC server running");
+}
+main().catch(console.error);

package/dist/resilience.d.ts

@@ -0,0 +1,3 @@
+export declare const logger: import("pino").Logger<never>;
+export declare function safeResponse<T>(data: T, context: string): T;
+export declare function withResilience<T>(fn: () => Promise<T>, operationName: string): Promise<T>;

package/dist/resilience.js

@@ -0,0 +1,76 @@
+import { retry, circuitBreaker, wrap, handleAll, timeout, TimeoutStrategy, ExponentialBackoff, ConsecutiveBreaker, } from "cockatiel";
+import pino from "pino";
+// ============================================
+// LOGGER
+// ============================================
+export const logger = pino({
+    level: process.env.LOG_LEVEL || "info",
+    ...(process.env.NODE_ENV !== "test" && {
+        transport: {
+            target: "pino-pretty",
+            options: {
+                colorize: true,
+                singleLine: true,
+                translateTime: "SYS:standard",
+            },
+        },
+    }),
+});
+// ============================================
+// SAFE RESPONSE (Response Size Limiting)
+// ============================================
+const MAX_RESPONSE_SIZE = 200_000; // 200KB
+export function safeResponse(data, context) {
+    const jsonStr = JSON.stringify(data);
+    const sizeBytes = Buffer.byteLength(jsonStr, "utf-8");
+    if (sizeBytes > MAX_RESPONSE_SIZE) {
+        logger.warn({ sizeBytes, maxSize: MAX_RESPONSE_SIZE, context }, `Response exceeds size limit, truncating`);
+        if (Array.isArray(data)) {
+            const truncated = data.slice(0, Math.max(1, Math.floor(data.length * 0.5)));
+            return truncated;
+        }
+        if (typeof data === "object" && data !== null) {
+            const obj = data;
+            for (const key of ["items", "results", "data", "rows"]) {
+                if (Array.isArray(obj[key])) {
+                    obj[key] = obj[key].slice(0, Math.max(1, Math.floor(obj[key].length * 0.5)));
+                    return obj;
+                }
+            }
+        }
+    }
+    return data;
+}
+// ============================================
+// RETRY + CIRCUIT BREAKER + TIMEOUT
+// ============================================
+const backoff = new ExponentialBackoff({
+    initialDelay: 100,
+    maxDelay: 5_000,
+});
+const retryPolicy = retry(handleAll, {
+    maxAttempts: 3,
+    backoff,
+});
+const circuitBreakerPolicy = circuitBreaker(handleAll, {
+    halfOpenAfter: 60_000,
+    breaker: new ConsecutiveBreaker(5),
+});
+const timeoutPolicy = timeout(30_000, TimeoutStrategy.Cooperative);
+const policy = wrap(timeoutPolicy, circuitBreakerPolicy, retryPolicy);
+// ============================================
+// WRAPPED API CALL WITH LOGGING
+// ============================================
+export async function withResilience(fn, operationName) {
+    try {
+        logger.debug({ operation: operationName }, "Starting API call");
+        const result = await policy.execute(() => fn());
+        logger.debug({ operation: operationName }, "API call succeeded");
+        return result;
+    }
+    catch (err) {
+        const error = err instanceof Error ? err : new Error(String(err));
+        logger.error({ operation: operationName, error: error.message, stack: error.stack }, "API call failed after retries");
+        throw error;
+    }
+}

package/dist/tools.d.ts

@@ -0,0 +1,2 @@
+import { Tool } from "@modelcontextprotocol/sdk/types.js";
+export declare const tools: Tool[];

package/dist/tools.js

@@ -0,0 +1,83 @@
+export const tools = [
+    {
+        name: "gsc_get_client_context",
+        description: "Get the current GSC client context based on working directory. Call this first to confirm which Search Console property you're working with.",
+        inputSchema: {
+            type: "object",
+            properties: {
+                working_directory: {
+                    type: "string",
+                    description: "The current working directory",
+                },
+            },
+            required: ["working_directory"],
+        },
+    },
+    {
+        name: "gsc_list_sites",
+        description: "List all verified sites/properties in Google Search Console.",
+        inputSchema: {
+            type: "object",
+            properties: {},
+        },
+    },
+    {
+        name: "gsc_search_analytics",
+        description: 'Query Google Search Console search analytics data. Returns clicks, impressions, CTR, and position for queries, pages, devices, countries, or dates.',
+        inputSchema: {
+            type: "object",
+            properties: {
+                start_date: {
+                    type: "string",
+                    description: 'Start date (YYYY-MM-DD or relative like "90daysAgo", "30daysAgo", "7daysAgo", "today")',
+                },
+                end_date: {
+                    type: "string",
+                    description: 'End date (YYYY-MM-DD or relative like "today")',
+                },
+                dimensions: {
+                    type: "string",
+                    description: "Comma-separated dimensions: query, page, device, country, date",
+                },
+                search_type: {
+                    type: "string",
+                    description: 'Search type: web, image, video, news (default "web")',
+                },
+                dimension_filter: {
+                    type: "string",
+                    description: 'Optional filter (e.g., "query contains nonprofit", "page contains /blog/", "country equals USA")',
+                },
+                row_limit: {
+                    type: "number",
+                    description: "Max rows to return (default 100, max 25000)",
+                },
+                aggregation_type: {
+                    type: "string",
+                    description: 'Aggregation: auto, byPage, byProperty (default "auto")',
+                },
+                site_url: {
+                    type: "string",
+                    description: "Site URL (optional - auto-detected from working directory config)",
+                },
+            },
+        },
+    },
+    {
+        name: "gsc_inspection",
+        description: "Inspect a URL to check if it is indexed in Google Search. Returns index status, mobile usability, and rich results data.",
+        inputSchema: {
+            type: "object",
+            properties: {
+                url: {
+                    type: "string",
+                    description: 'The fully qualified URL to inspect (e.g., "https://www.example.com/blog/post")',
+                },
+                site_url: {
+                    type: "string",
+                    description: "Site URL / property (optional - auto-detected from config)",
+                },
+            },
+            required: ["url"],
+        },
+    },
+];

package/package.json

@@ -0,0 +1,44 @@
+{
+  "name": "mcp-google-gsc",
+  "version": "1.0.0",
+  "description": "MCP server for Google Search Console API with multi-client support, search analytics, and URL inspection.",
+  "main": "dist/index.js",
+  "types": "dist/index.d.ts",
+  "type": "module",
+  "exports": {
+    ".": {
+      "import": "./dist/index.js",
+      "types": "./dist/index.d.ts"
+    }
+  },
+  "files": [
+    "dist",
+    "README.md",
+    "LICENSE",
+    "config.example.json"
+  ],
+  "scripts": {
+    "build": "tsc && node -e \"fs=require('fs');cp=require('child_process');sha=cp.execSync('git rev-parse --short HEAD 2>/dev/null||echo unknown').toString().trim();fs.writeFileSync('dist/build-info.json',JSON.stringify({sha,builtAt:new Date().toISOString()}))\"",
+    "start": "node dist/index.js",
+    "dev": "tsx src/index.ts",
+    "test": "vitest run"
+  },
+  "author": "drak-marketing",
+  "license": "MIT",
+  "engines": {
+    "node": ">=18.0.0"
+  },
+  "dependencies": {
+    "@modelcontextprotocol/sdk": "^0.5.0",
+    "cockatiel": "^3.2.1",
+    "googleapis": "^144.0.0",
+    "pino": "^8.21.0",
+    "pino-pretty": "^13.1.3"
+  },
+  "devDependencies": {
+    "@types/node": "^20.10.0",
+    "tsx": "^4.7.0",
+    "typescript": "^5.3.0",
+    "vitest": "^4.0.18"
+  }
+}