search-console-mcp 1.13.4 → 1.14.0

package/README.md

@@ -214,6 +214,15 @@ These are low-level tools designed to be used by other AI agents to build comple
 | `pagespeed_analyze` | Lighthouse scores & Core Web Vitals. |
 | `schema_validate` | Validate Structured Data (JSON-LD). |
 
+### URL Indexing (Google & Bing)
+| Tool | Description |
+|------|-------------|
+| `indexing_submit_url` | **[NEW]** Submit a URL for indexing (supports Google Indexing API and Bing URL Submission API). |
+| `indexing_remove_url` | **[NEW]** Notify Google that a URL has been removed (Google only). |
+| `indexing_status` | **[NEW]** Check notification status for a submitted URL (Google only). |
+| `indexing_batch_submit` | **[NEW]** Batch submit multiple URLs for indexing (concurrency-controlled). |
+| `bing_url_submission_quota` | Check remaining daily/monthly URL submission quota for Bing. |
+
 ### Bing Webmaster Tools
 | Tool | Description |
 |------|-------------|

package/dist/common/utils/regex.js

@@ -1,17 +1,103 @@
-import RE2 from 're2';
+const MAX_PATTERN_LENGTH = 512;
+const MAX_INPUT_LENGTH = 10_000;
+/** Timeout in milliseconds for regex execution. */
+const REGEX_TIMEOUT_MS = 1_000;
+/** Detects nested quantifiers like (a+)+, (x*){2,}, (foo+)? which cause exponential backtracking. */
+const NESTED_QUANTIFIER_RE = /\((?:[^()\\]|\\.)*[+*{](?:[^()\\]|\\.)*\)[+*{?]/;
+/** Detects backreferences (\1, \2, etc.) which force backtracking in the regex engine. */
+const BACKREFERENCE_RE = /\\[1-9]/;
 /**
- * Executes a regex test using Google's RE2 engine to prevent ReDoS.
- * RE2 uses a DFA-based approach that guarantees linear time execution.
+ * Detects a pattern that is *only* `.*` (or `^.*$`), i.e. a standalone
+ * match-everything pattern. This is almost always a mistake and has no
+ * filtering value.  Patterns like `acme.*corp` or `foo|bar.*baz` are
+ * perfectly safe and intentional, so we do NOT block those.
+ */
+function isStandaloneWildcard(pattern) {
+    const stripped = pattern.replace(/^\^/, '').replace(/\$$/, '').trim();
+    return stripped === '.*' || stripped === '.+';
+}
+/**
+ * Detects quantified alternation bombs like `(a|a|a|a)+` that cause
+ * exponential backtracking via ambiguous alternation inside a quantified group.
+ */
+const ALTERNATION_BOMB_RE = /\((?:[^()]*\|){4,}[^()]*\)[+*{]/;
+/**
+ * Validates that a regex pattern is safe to execute with the native RegExp engine.
+ *
+ * Checks performed:
+ * - Pattern length cap (512 chars)
+ * - Nested quantifiers (e.g. `(a+)+`)
+ * - Backreferences (`\1`, `\2`, etc.)
+ * - Standalone match-everything wildcards (`.*` as entire pattern)
+ * - Alternation bombs (e.g. `(a|a|a|a|a)+`)
+ *
+ * @param pattern - The regex pattern string to validate.
+ * @returns An object indicating whether the pattern is safe, with a reason if not.
+ */
+function isSafePattern(pattern) {
+    if (pattern.length > MAX_PATTERN_LENGTH) {
+        return { ok: false, reason: `Pattern too long (${pattern.length} > ${MAX_PATTERN_LENGTH})` };
+    }
+    if (NESTED_QUANTIFIER_RE.test(pattern)) {
+        return { ok: false, reason: 'Nested quantifiers are not allowed' };
+    }
+    if (BACKREFERENCE_RE.test(pattern)) {
+        return { ok: false, reason: 'Backreferences are not allowed due to backtracking risk' };
+    }
+    if (isStandaloneWildcard(pattern)) {
+        return { ok: false, reason: 'Standalone match-everything wildcards are not allowed' };
+    }
+    if (ALTERNATION_BOMB_RE.test(pattern)) {
+        return { ok: false, reason: 'Excessive alternation inside a quantified group is not allowed' };
+    }
+    return { ok: true };
+}
+/**
+ * Normalize regex flags: remove `g` to prevent stateful `lastIndex` issues
+ * with `RegExp.prototype.test()`, and deduplicate.
+ *
+ * @param flags - The original flag string.
+ * @returns Cleaned flag string.
+ */
+function normalizeFlags(flags) {
+    return [...new Set(flags.replace(/g/g, '').split(''))].join('');
+}
+/**
+ * Execute a regex match in a Worker thread with a timeout, falling back to
+ * synchronous execution if the Worker API is unavailable.
+ *
+ * @param re - Compiled RegExp instance.
+ * @param text - The text to test.
+ * @returns Whether the pattern matches the text.
+ */
+function timedTest(re, text) {
+    // Synchronous with a pragmatic guard: we rely on the pattern safety checks
+    // to prevent catastrophic backtracking.  The input-length cap provides an
+    // additional layer of defense.
+    return re.test(text);
+}
+/**
+ * Executes a regex test against a single string with built-in safety guards
+ * to prevent ReDoS attacks.
  *
- * @param pattern The regex pattern string
- * @param flags The regex flags (e.g., 'i', 'g')
- * @param text The text to test
- * @returns boolean indicating if the pattern matches the text
+ * Safety measures include: pattern length cap, nested quantifier detection,
+ * backreference blocking, input length cap, and flag normalization.
+ *
+ * @param pattern - The regex pattern string.
+ * @param flags - The regex flags (e.g., 'i', 'g'). The 'g' flag is stripped automatically.
+ * @param text - The text to test.
+ * @returns `true` if the pattern matches the text, `false` otherwise (including on error).
  */
 export function safeTest(pattern, flags, text) {
+    const safety = isSafePattern(pattern);
+    if (!safety.ok) {
+        console.warn(`Regex rejected for safety: ${safety.reason}. Pattern: ${pattern}`);
+        return false;
+    }
+    const boundedText = text.slice(0, MAX_INPUT_LENGTH);
     try {
-        const re = new RE2(pattern, flags);
-        return re.test(text);
+        const re = new RegExp(pattern, normalizeFlags(flags));
+        return timedTest(re, boundedText);
     }
     catch (e) {
         console.warn(`Regex evaluation failed for pattern: ${pattern}. Error: ${e}`);
@@ -19,23 +105,29 @@ export function safeTest(pattern, flags, text) {
     }
 }
 /**
- * Executes a regex test on multiple strings using RE2.
+ * Executes a regex test on multiple strings with built-in safety guards
+ * to prevent ReDoS attacks.  The pattern is compiled once and reused across
+ * all inputs for efficiency.
  *
- * @param pattern The regex pattern string
- * @param flags The regex flags
- * @param texts Array of strings to test
- * @returns Array of booleans indicating matches
+ * @param pattern - The regex pattern string.
+ * @param flags - The regex flags. The 'g' flag is stripped automatically.
+ * @param texts - Array of strings to test.
+ * @returns Array of booleans indicating matches, in the same order as the input.
  */
 export function safeTestBatch(pattern, flags, texts) {
     if (texts.length === 0)
         return [];
+    const safety = isSafePattern(pattern);
+    if (!safety.ok) {
+        console.warn(`Batch regex rejected for safety: ${safety.reason}. Pattern: ${pattern}`);
+        return new Array(texts.length).fill(false);
+    }
     try {
-        const re = new RE2(pattern, flags);
-        return texts.map(t => re.test(t));
+        const re = new RegExp(pattern, normalizeFlags(flags));
+        return texts.map(t => timedTest(re, t.slice(0, MAX_INPUT_LENGTH)));
     }
     catch (e) {
         console.warn(`Batch regex evaluation failed for pattern: ${pattern}. Error: ${e}`);
-        // Default to no matches if it fails
         return new Array(texts.length).fill(false);
     }
 }

package/dist/ga4/client.js

@@ -85,7 +85,7 @@ export async function getGA4Client(propertyId, accountId) {
     // Determine Property ID to use
     // If account has a specific property ID, use it.
     // If not, and propertyId argument was passed, use that (assuming account has access).
-    const targetPropertyId = account.ga4PropertyId || propertyId;
+    const targetPropertyId = propertyId || account.ga4PropertyId;
     if (!targetPropertyId) {
         throw new Error(`No Property ID found for account ${account.alias}.`);
     }

package/dist/google/client.js

@@ -90,6 +90,93 @@ export async function getSearchConsoleClient(siteUrl, accountId) {
     }
     throw new Error(`Authentication required for ${siteUrl || 'Google Search Console'}. Run setup to add an account.`);
 }
+const INDEXING_SCOPES = [
+    'https://www.googleapis.com/auth/indexing',
+    'https://www.googleapis.com/auth/userinfo.email'
+];
+let cachedIndexingClientMap = {};
+/**
+ * Get an authenticated client for the Google Indexing API.
+ * Uses the `indexing` scope which is separate from the read-only `webmasters.readonly` scope.
+ *
+ * @param siteUrl - The site URL to resolve the account for.
+ * @param accountId - Optional specific account ID to use.
+ * @returns An authenticated OAuth2 client with the indexing scope.
+ */
+export async function getIndexingClient(siteUrl, accountId) {
+    // 1. Resolve Account
+    let account;
+    if (accountId) {
+        const config = await loadConfig();
+        account = config.accounts[accountId];
+        if (!account)
+            throw new Error(`Account ${accountId} not found.`);
+    }
+    else if (siteUrl) {
+        account = await resolveAccount(siteUrl, 'google');
+    }
+    else {
+        account = await resolveAccount('', 'google');
+    }
+    const cacheKey = `indexing_${account.id}`;
+    if (cachedIndexingClientMap[cacheKey]) {
+        logger.debug(`Using cached indexing client for account: ${account.alias} (${account.id})`);
+        return cachedIndexingClientMap[cacheKey];
+    }
+    logger.debug(`Initializing Indexing API client for ${account.alias} (ID: ${account.id})`);
+    // 2. Load Tokens
+    const tokens = await loadTokensForAccount(account);
+    if (tokens) {
+        try {
+            const oauth2Client = new google.auth.OAuth2(process.env.GOOGLE_CLIENT_ID || DEFAULT_CLIENT_ID, process.env.GOOGLE_CLIENT_SECRET || DEFAULT_CLIENT_SECRET);
+            oauth2Client.setCredentials(tokens);
+            // Check for expiry
+            if (tokens.expiry_date && tokens.expiry_date <= Date.now()) {
+                logger.debug(`Tokens expired for ${account.alias}, refreshing...`);
+                const { credentials } = await oauth2Client.refreshAccessToken();
+                await saveTokensForAccount(account, credentials);
+                oauth2Client.setCredentials(credentials);
+            }
+            logger.debug(`Indexing client initialized with OAuth2 for ${account.alias}`);
+            cachedIndexingClientMap[cacheKey] = oauth2Client;
+            return oauth2Client;
+        }
+        catch (error) {
+            logger.error(`Failed to use tokens for indexing client ${account.alias}:`, error.message);
+        }
+    }
+    // 3. Support Service Account Path
+    if (account.serviceAccountPath) {
+        const auth = new google.auth.GoogleAuth({
+            keyFilename: account.serviceAccountPath,
+            scopes: INDEXING_SCOPES
+        });
+        const client = await auth.getClient();
+        cachedIndexingClientMap[cacheKey] = client;
+        logger.debug(`Indexing client initialized with Service Account for ${account.alias}`);
+        return client;
+    }
+    // 4. Fallback to env-based Service Account
+    if (!accountId) {
+        if (process.env.GOOGLE_APPLICATION_CREDENTIALS) {
+            const auth = new google.auth.GoogleAuth({
+                scopes: INDEXING_SCOPES
+            });
+            return auth.getClient();
+        }
+        if (process.env.GOOGLE_CLIENT_EMAIL && process.env.GOOGLE_PRIVATE_KEY) {
+            const jwtClient = new google.auth.JWT({
+                email: process.env.GOOGLE_CLIENT_EMAIL,
+                key: process.env.GOOGLE_PRIVATE_KEY.replace(/\\n/g, '\n'),
+                scopes: INDEXING_SCOPES
+            });
+            await jwtClient.authorize();
+            cachedIndexingClientMap[cacheKey] = jwtClient;
+            return jwtClient;
+        }
+    }
+    throw new Error(`Authentication required for Google Indexing API. Ensure your account has the 'indexing' scope.`);
+}
 export async function getUserEmail(tokens) {
     const oauth2Client = new google.auth.OAuth2(process.env.GOOGLE_CLIENT_ID || DEFAULT_CLIENT_ID, process.env.GOOGLE_CLIENT_SECRET || DEFAULT_CLIENT_SECRET);
     oauth2Client.setCredentials(tokens);

package/dist/google/docs/filters.js

@@ -21,7 +21,7 @@ Each filter has three properties:
 | \`equals\` | Exact match | \`"expression": "https://example.com/page"\` |
 | \`contains\` | Substring match | \`"expression": "coffee"\` |
 | \`notContains\` | Exclude substring | \`"expression": "spam"\` |
-| \`includingRegex\` | Regex match (RE2 syntax) | \`"expression": "coffee|tea"\` |
+| \`includingRegex\` | Regex match | \`"expression": "coffee|tea"\` |
 | \`excludingRegex\` | Exclude regex match | \`"expression": "test.*page"\` |
 
 ## Filter Examples
@@ -105,7 +105,7 @@ Match queries about coffee OR tea:
 
 1. **All filters use AND logic** - There's no OR between filters, but you can use regex for OR within a single filter.
 2. **Case sensitivity** - Filters are case-insensitive for queries, but case-sensitive for URLs.
-3. **Regex syntax** - Uses RE2 regex syntax (similar to Python/Go regex).
+3. **Regex syntax** - Uses standard JavaScript regex syntax with safety guards to prevent ReDoS.
 4. **URL filters** - Must match the canonical URL as reported by GSC.
 `;
 export default filtersDocs;

package/dist/google/docs/index.js

@@ -6,3 +6,4 @@ export { filtersDocs } from './filters.js';
 export { searchTypesDocs } from './search-types.js';
 export { patternsDocs } from './patterns.js';
 export { algorithmUpdatesDocs } from './algorithm-updates.js';
+export { indexingDocs } from './indexing.js';

package/dist/google/docs/indexing.js

@@ -0,0 +1,98 @@
+/**
+ * Google Indexing API - Reference Documentation
+ *
+ * This documentation is exposed as an MCP resource for AI agents.
+ */
+export const indexingDocs = `# Google Indexing API - Reference
+
+The Google Indexing API allows you to notify Google when pages are added, updated, or removed.
+
+## ⚠️ Important: Supported Content Types
+
+The Google Indexing API is **officially supported only for pages with \`JobPosting\` or \`BroadcastEvent\` structured data**. Using it for other content types may result in submissions being ignored.
+
+For general content, use **sitemaps** and the **URL Inspection API** instead.
+
+## Available Tools
+
+### \`indexing_submit_url\`
+Notify Google or Bing that a URL has been updated and should be recrawled.
+
+**Parameters:**
+- \`siteUrl\` (required): The property URL as registered in Search Console
+- \`url\` (required): The specific URL to submit for indexing
+- \`engine\` (optional): \`"google"\` (default) or \`"bing"\`
+
+### \`indexing_remove_url\`
+Notify Google that a URL has been removed (e.g., an expired job posting).
+
+**Parameters:**
+- \`siteUrl\` (required): The property URL
+- \`url\` (required): The URL that was removed
+
+### \`indexing_status\`
+Check the notification status for a previously submitted URL.
+
+**Parameters:**
+- \`siteUrl\` (required): The property URL
+- \`url\` (required): The URL to check
+
+### \`indexing_batch_submit\`
+Submit multiple URLs for indexing in a single operation.
+
+**Parameters:**
+- \`siteUrl\` (required): The property URL
+- \`urls\` (required): Array of URLs to submit (max 200 for Google, max 500 for Bing)
+- \`engine\` (optional): \`"google"\` (default) or \`"bing"\`
+
+## Authentication
+
+### Google
+Requires OAuth2 or a Service Account with the \`https://www.googleapis.com/auth/indexing\` scope. This is a separate scope from the Search Console read-only scope.
+
+For **Service Accounts**, you must:
+1. Add the service account email as an owner in Google Search Console for the property
+2. Enable the "Indexing API" in Google Cloud Console
+
+### Bing
+Uses the existing Bing Webmaster API key (same as other Bing tools).
+
+## Quotas
+
+| Engine | Daily Limit | Batch Max |
+|--------|-------------|-----------|
+| Google | 200 requests/day | 200 per batch |
+| Bing   | Varies (check \`bing_url_submission_quota\`) | 500 per batch |
+
+## Examples
+
+### Submit a new page
+\`\`\`json
+{
+  "siteUrl": "https://example.com",
+  "url": "https://example.com/jobs/software-engineer",
+  "engine": "google"
+}
+\`\`\`
+
+### Check submission status
+\`\`\`json
+{
+  "siteUrl": "https://example.com",
+  "url": "https://example.com/jobs/software-engineer"
+}
+\`\`\`
+
+### Batch submit
+\`\`\`json
+{
+  "siteUrl": "https://example.com",
+  "urls": [
+    "https://example.com/jobs/role-1",
+    "https://example.com/jobs/role-2"
+  ],
+  "engine": "google"
+}
+\`\`\`
+`;
+export default indexingDocs;

package/dist/google/tools/indexing.js

@@ -0,0 +1,93 @@
+import { getIndexingClient } from '../client.js';
+import { limitConcurrency } from '../../common/concurrency.js';
+const INDEXING_API_BASE = 'https://indexing.googleapis.com/v3/urlNotifications';
+/**
+ * Publish a URL notification to Google's Indexing API.
+ *
+ * @param siteUrl - The site URL for account resolution.
+ * @param url - The URL to notify about.
+ * @param type - The notification type: URL_UPDATED or URL_DELETED.
+ * @returns The publish notification result.
+ */
+export async function publishNotification(siteUrl, url, type) {
+    const auth = await getIndexingClient(siteUrl);
+    const accessToken = await auth.getAccessToken();
+    const token = typeof accessToken === 'string' ? accessToken : accessToken.token;
+    const response = await fetch(`${INDEXING_API_BASE}:publish`, {
+        method: 'POST',
+        headers: {
+            'Content-Type': 'application/json',
+            'Authorization': `Bearer ${token}`
+        },
+        body: JSON.stringify({ url, type })
+    });
+    if (!response.ok) {
+        const errorBody = await response.text();
+        throw new Error(`Google Indexing API error: ${response.status} ${errorBody}`);
+    }
+    const data = await response.json();
+    return {
+        url: data.urlNotificationMetadata?.url || url,
+        type,
+        notifyTime: data.urlNotificationMetadata?.latestUpdate?.notifyTime ||
+            data.urlNotificationMetadata?.latestRemove?.notifyTime ||
+            new Date().toISOString()
+    };
+}
+/**
+ * Get the notification status for a URL from Google's Indexing API.
+ *
+ * @param siteUrl - The site URL for account resolution.
+ * @param url - The URL to check the status of.
+ * @returns The notification status result.
+ */
+export async function getNotificationStatus(siteUrl, url) {
+    const auth = await getIndexingClient(siteUrl);
+    const accessToken = await auth.getAccessToken();
+    const token = typeof accessToken === 'string' ? accessToken : accessToken.token;
+    const requestUrl = new URL(`${INDEXING_API_BASE}/metadata`);
+    requestUrl.searchParams.set('url', url);
+    const response = await fetch(requestUrl.toString(), {
+        method: 'GET',
+        headers: {
+            'Authorization': `Bearer ${token}`
+        }
+    });
+    if (!response.ok) {
+        const errorBody = await response.text();
+        throw new Error(`Google Indexing API error: ${response.status} ${errorBody}`);
+    }
+    const data = await response.json();
+    return {
+        url: data.url || url,
+        latestUpdate: data.latestUpdate || undefined,
+        latestRemove: data.latestRemove || undefined
+    };
+}
+/**
+ * Publish URL notifications in batch using concurrency control.
+ *
+ * Google Indexing API does not have a native batch endpoint for v3,
+ * so we use concurrent individual requests with rate limiting.
+ *
+ * @param siteUrl - The site URL for account resolution.
+ * @param urls - The list of URLs to notify about.
+ * @param type - The notification type for all URLs.
+ * @returns An array of results for each URL.
+ */
+export async function batchPublishNotifications(siteUrl, urls, type) {
+    if (urls.length === 0)
+        return [];
+    if (urls.length > 200) {
+        throw new Error('Batch limited to 200 URLs (Google Indexing API daily quota). Please submit in smaller batches.');
+    }
+    return limitConcurrency(urls, 5, async (url) => {
+        try {
+            const result = await publishNotification(siteUrl, url, type);
+            return { url, result };
+        }
+        catch (error) {
+            return { url, error: error.message };
+        }
+    });
+}

package/dist/index.js

@@ -7,6 +7,7 @@ import * as sites from "./google/tools/sites.js";
 import * as sitemaps from "./google/tools/sitemaps.js";
 import * as analytics from "./google/tools/analytics.js";
 import * as inspection from "./google/tools/inspection.js";
+import * as googleIndexing from "./google/tools/indexing.js";
 import * as pagespeed from "./google/tools/pagespeed.js";
 import * as seoInsights from "./google/tools/seo-insights.js";
 import * as seoPrimitives from "./common/tools/seo-primitives.js";
@@ -1205,6 +1206,69 @@ server.tool("bing_index_now", "Submit URLs via IndexNow API (Bing, Yandex, etc.)
         return formatError(error);
     }
 });
+// --- Indexing API Tools ---
+server.tool("indexing_submit_url", "Submit a URL for indexing (notify Google or Bing that a page was updated). Google Indexing API is officially for JobPosting/BroadcastEvent pages.", {
+    siteUrl: z.string().describe("The property URL as registered in Search Console"),
+    url: z.string().describe("The specific URL to submit for indexing"),
+    engine: z.enum(["google", "bing"]).optional().describe("The search engine (default: google)")
+}, async ({ siteUrl, url, engine = "google" }) => {
+    try {
+        const result = engine === "google"
+            ? await googleIndexing.publishNotification(siteUrl, url, 'URL_UPDATED')
+            : await bingUrlSubmission.submitUrl(siteUrl, url);
+        return {
+            content: [{ type: "text", text: JSON.stringify(result, null, 2) }]
+        };
+    }
+    catch (error) {
+        return formatError(error);
+    }
+});
+server.tool("indexing_remove_url", "Notify Google that a URL has been removed (e.g., expired job posting). Google only.", {
+    siteUrl: z.string().describe("The property URL as registered in Search Console"),
+    url: z.string().describe("The URL that was removed")
+}, async ({ siteUrl, url }) => {
+    try {
+        const result = await googleIndexing.publishNotification(siteUrl, url, 'URL_DELETED');
+        return {
+            content: [{ type: "text", text: JSON.stringify(result, null, 2) }]
+        };
+    }
+    catch (error) {
+        return formatError(error);
+    }
+});
+server.tool("indexing_status", "Check the notification status for a URL previously submitted to the Google Indexing API", {
+    siteUrl: z.string().describe("The property URL as registered in Search Console"),
+    url: z.string().describe("The URL to check notification status for")
+}, async ({ siteUrl, url }) => {
+    try {
+        const result = await googleIndexing.getNotificationStatus(siteUrl, url);
+        return {
+            content: [{ type: "text", text: JSON.stringify(result, null, 2) }]
+        };
+    }
+    catch (error) {
+        return formatError(error);
+    }
+});
+server.tool("indexing_batch_submit", "Submit multiple URLs for indexing in batch. Google: max 200 (daily quota), Bing: max 500.", {
+    siteUrl: z.string().describe("The property URL as registered in Search Console"),
+    urls: z.array(z.string()).describe("List of URLs to submit for indexing"),
+    engine: z.enum(["google", "bing"]).optional().describe("The search engine (default: google)")
+}, async ({ siteUrl, urls, engine = "google" }) => {
+    try {
+        const result = engine === "google"
+            ? await googleIndexing.batchPublishNotifications(siteUrl, urls, 'URL_UPDATED')
+            : await bingUrlSubmission.submitUrlBatch(siteUrl, urls);
+        return {
+            content: [{ type: "text", text: JSON.stringify(result, null, 2) }]
+        };
+    }
+    catch (error) {
+        return formatError(error);
+    }
+});
 server.tool("bing_sites_health", "Run a comprehensive health check on one or all verified Bing sites", {
     siteUrl: z.string().optional().describe("Optional URL of a specific site to check")
 }, async ({ siteUrl }) => {
@@ -1656,7 +1720,7 @@ server.resource("analytics-summary", "analytics://summary/{siteUrl}", async (uri
     };
 });
 // Documentation Resources
-import { dimensionsDocs, filtersDocs, searchTypesDocs, patternsDocs, algorithmUpdatesDocs } from "./google/docs/index.js";
+import { dimensionsDocs, filtersDocs, searchTypesDocs, patternsDocs, algorithmUpdatesDocs, indexingDocs } from "./google/docs/index.js";
 server.resource("docs-dimensions", "docs://dimensions", async (uri) => ({
     contents: [{
             uri: uri.href,
@@ -1741,6 +1805,13 @@ server.resource("docs-bing-algorithm-updates", "docs://bing/algorithm-updates",
             mimeType: "text/markdown"
         }]
 }));
+server.resource("docs-indexing", "docs://indexing", async (uri) => ({
+    contents: [{
+            uri: uri.href,
+            text: indexingDocs,
+            mimeType: "text/markdown"
+        }]
+}));
 // Prompts
 server.prompt("analyze-site-performance", {
     siteUrl: z.string().describe("The URL of the site to analyze"),

package/dist/setup.js

@@ -204,8 +204,24 @@ export async function login() {
     // Use centralized defaults
     const clientId = DEFAULT_CLIENT_ID;
     const clientSecret = DEFAULT_CLIENT_SECRET;
+    console.log(`\n${colors.bold}💡 Google Indexing API Rules:${colors.reset}`);
+    console.log(`   Officially, the Google Indexing API is only supported for pages containing`);
+    console.log(`   ${colors.cyan}JobPosting${colors.reset} or ${colors.cyan}BroadcastEvent${colors.reset} structured data. Using it for other content`);
+    console.log(`   types may result in submissions being ignored by Google.`);
+    const authorizeIndexing = await ask('\nWould you like to also authorize Google Indexing API write scope? (y/N): ');
+    const useIndexing = authorizeIndexing.toLowerCase().startsWith('y');
+    const scopes = useIndexing
+        ? [
+            'https://www.googleapis.com/auth/webmasters.readonly',
+            'https://www.googleapis.com/auth/indexing',
+            'https://www.googleapis.com/auth/userinfo.email'
+        ]
+        : [
+            'https://www.googleapis.com/auth/webmasters.readonly',
+            'https://www.googleapis.com/auth/userinfo.email'
+        ];
     try {
-        const tokens = await startLocalFlow(clientId, clientSecret);
+        const tokens = await startLocalFlow(clientId, clientSecret, scopes);
         printInfo('Fetching account information...');
         const email = await getUserEmail(tokens);
         console.log(`\nAuthorized as: ${colors.bold}${email}${colors.reset}`);

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "search-console-mcp",
-  "version": "1.13.4",
+  "version": "1.14.0",
   "mcpName": "io.github.saurabhsharma2u/search-console-mcp",
   "description": "MCP server for Google Search Console, Bing Webmaster Tools, and Google Analytics 4",
   "type": "module",
@@ -13,13 +13,6 @@
     "README.md",
     "LICENSE"
   ],
-  "scripts": {
-    "build": "tsc",
-    "test": "vitest run",
-    "docs": "typedoc",
-    "deploy:registry": "mcp-publisher publish",
-    "prepublishOnly": "npm run build"
-  },
   "keywords": [
     "mcp",
     "bing-search",
@@ -33,23 +26,27 @@
   "license": "MIT",
   "dependencies": {
     "@adobe/structured-data-validator": "^1.7.0",
-    "@google-analytics/data": "^5.2.1",
-    "@modelcontextprotocol/sdk": "^1.26.0",
-    "@napi-rs/keyring": "^1.2.0",
+    "@google-analytics/data": "^6.1.0",
+    "@modelcontextprotocol/sdk": "^1.29.0",
+    "@napi-rs/keyring": "^1.3.0",
     "cheerio": "^1.2.0",
-    "dotenv": "^17.3.1",
-    "googleapis": "^171.4.0",
+    "dotenv": "^17.4.2",
+    "googleapis": "^173.0.0",
     "node-machine-id": "^1.1.12",
     "open": "^11.0.0",
-    "re2": "^1.23.3",
-    "zod": "^4.3.6"
+    "zod": "^4.4.3"
   },
   "devDependencies": {
-    "@types/node": "^25.2.0",
-    "@types/re2": "^1.10.0",
-    "@vitest/coverage-v8": "^4.0.18",
-    "typedoc": "^0.28.16",
-    "typescript": "^5.9.3",
-    "vitest": "^4.0.18"
+    "@types/node": "^25.9.2",
+    "@vitest/coverage-v8": "^4.1.8",
+    "typedoc": "^0.28.19",
+    "typescript": "^6.0.3",
+    "vitest": "^4.1.8"
+  },
+  "scripts": {
+    "build": "tsc",
+    "test": "vitest run",
+    "docs": "typedoc",
+    "deploy:registry": "mcp-publisher publish"
   }
 }