search-console-mcp 1.13.1 → 1.13.3

package/README.md

@@ -3,7 +3,7 @@
 
 A Model Context Protocol (MCP) server that transforms how you interact with **Google Search Console**, **Bing Webmaster Tools**, and **Google Analytics 4**. Stop exporting CSVs and start asking questions.
 
-[📚 View Documentation](https://searchconsolemcp.mintlify.app/)
+[📚 View Documentation](https://searchconsolemcp.saurabh.app/)
 
 ---
 

package/dist/bing/tools/analytics.js

@@ -177,3 +177,89 @@ export async function getPerformanceSummary(siteUrl, days = 28) {
         endDate: endDate.toISOString().split('T')[0]
     };
 }
+/**
+ * Detect rising or declining trends in Bing query performance.
+ *
+ * @param siteUrl - The URL of the site to analyze.
+ * @param options - Configuration including lookback period and click thresholds.
+ * @returns A list of queries showing significant momentum.
+ */
+export async function detectTrends(siteUrl, options = {}) {
+    const days = options.days || 28;
+    const threshold = options.threshold || 10;
+    const minClicks = options.minClicks || 100;
+    const limit = options.limit || 20;
+    const midPoint = Math.floor(days / 2);
+    const endDate = new Date();
+    endDate.setDate(endDate.getDate() - 2); // Data delay
+    const currentEndDate = new Date(endDate);
+    const currentStartDate = new Date(currentEndDate);
+    currentStartDate.setDate(currentStartDate.getDate() - midPoint + 1);
+    const previousEndDate = new Date(currentStartDate);
+    previousEndDate.setDate(previousEndDate.getDate() - 1);
+    const previousStartDate = new Date(previousEndDate);
+    previousStartDate.setDate(previousStartDate.getDate() - midPoint + 1);
+    const allStats = await getQueryStats(siteUrl);
+    const filterStats = (start, end) => {
+        const map = new Map();
+        allStats.forEach(stat => {
+            const d = new Date(stat.Date);
+            if (d >= start && d <= end) {
+                map.set(stat.Query, (map.get(stat.Query) || 0) + stat.Clicks);
+            }
+        });
+        return map;
+    };
+    const currentMap = filterStats(currentStartDate, currentEndDate);
+    const previousMap = filterStats(previousStartDate, previousEndDate);
+    const trends = [];
+    for (const [query, currClicks] of currentMap.entries()) {
+        const prevClicks = previousMap.get(query) || 0;
+        if (currClicks < minClicks && prevClicks < minClicks)
+            continue;
+        if (prevClicks > 0) {
+            const change = currClicks - prevClicks;
+            const percent = (change / prevClicks) * 100;
+            if (Math.abs(percent) >= threshold) {
+                trends.push({
+                    key: query,
+                    metric: 'clicks',
+                    change,
+                    changePercent: parseFloat(percent.toFixed(2)),
+                    trend: percent > 0 ? 'rising' : 'declining',
+                    currentValue: currClicks,
+                    previousValue: prevClicks
+                });
+            }
+        }
+        else if (currClicks >= minClicks) {
+            // Zero to Hero
+            trends.push({
+                key: query,
+                metric: 'clicks',
+                change: currClicks,
+                changePercent: 100,
+                trend: 'rising',
+                currentValue: currClicks,
+                previousValue: 0
+            });
+        }
+    }
+    // Also check for queries that dropped to zero
+    for (const [query, prevClicks] of previousMap.entries()) {
+        if (!currentMap.has(query) && prevClicks >= minClicks) {
+            trends.push({
+                key: query,
+                metric: 'clicks',
+                change: -prevClicks,
+                changePercent: -100,
+                trend: 'declining',
+                currentValue: 0,
+                previousValue: prevClicks
+            });
+        }
+    }
+    return trends
+        .sort((a, b) => Math.abs(b.change) - Math.abs(a.change))
+        .slice(0, limit);
+}

package/dist/bing/tools/crawl.js

@@ -3,7 +3,7 @@ import { getBingClient } from '../client.js';
  * Get crawl issues for a site.
  */
 export async function getCrawlIssues(siteUrl) {
-    const client = await getBingClient();
+    const client = await getBingClient(siteUrl);
     return client.getCrawlIssues(siteUrl);
 }
 /**

package/dist/bing/tools/keywords.js

@@ -3,13 +3,13 @@ import { getBingClient } from '../client.js';
  * Get historical stats for a keyword.
  */
 export async function getKeywordStats(q, country, language) {
-    const client = await getBingClient();
+    const client = await getBingClient(); // No siteUrl required for keyword research
     return client.getKeywordStats(q, country, language);
 }
 /**
  * Get related keywords and search volume.
  */
 export async function getRelatedKeywords(q, country, language) {
-    const client = await getBingClient();
+    const client = await getBingClient(); // No siteUrl required for keyword research
     return client.getRelatedKeywords(q, country, language);
 }

package/dist/bing/tools/sites-health.js

@@ -2,6 +2,7 @@ import * as bingSites from './sites.js';
 import * as bingSitemaps from './sitemaps.js';
 import * as bingAnalytics from './analytics.js';
 import * as bingCrawl from './crawl.js';
+import { limitConcurrency } from '../../common/concurrency.js';
 /**
  * Run a health check on a single Bing site.
  */
@@ -103,7 +104,7 @@ export async function healthCheck(siteUrl) {
     if (allSites.length === 0) {
         return [];
     }
-    const reports = await Promise.all(allSites.map((site) => checkSite(site.Url)));
+    const reports = await limitConcurrency(allSites, 5, (site) => checkSite(site.Url));
     const order = { critical: 0, warning: 1, healthy: 2 };
     return reports.sort((a, b) => (order[a.status] || 0) - (order[b.status] || 0));
 }

package/dist/common/utils/csv.js

@@ -6,12 +6,18 @@ export function jsonToCsv(data) {
     if (!data || data.length === 0) {
         return "";
     }
-    // Get headers from the first object
-    const headers = Object.keys(data[0]);
+    // Get all unique headers from all objects
+    const headerSet = new Set();
+    for (const row of data) {
+        if (row && typeof row === 'object') {
+            Object.keys(row).forEach(key => headerSet.add(key));
+        }
+    }
+    const headers = Array.from(headerSet);
     const csvRows = [headers.join(',')];
     for (const row of data) {
         const values = headers.map(header => {
-            const val = row[header];
+            const val = row && typeof row === 'object' ? row[header] : undefined;
             const stringVal = val === undefined || val === null ? '' : String(val);
             // Escape double quotes by doubling them
             const escaped = stringVal.replace(/"/g, '""');

package/dist/ga4/tools/analytics.js

@@ -29,6 +29,9 @@ export async function batchQueryAnalytics(options) {
             return cached.promise;
         }
         if (now - cached.timestamp < CACHE_TTL_MS) {
+            // LRU: Refresh key position
+            analyticsCache.delete(cacheKey);
+            analyticsCache.set(cacheKey, cached);
             return cached.data;
         }
         analyticsCache.delete(cacheKey);
@@ -77,6 +80,9 @@ export async function queryAnalytics(options) {
             return cached.promise;
         }
         if (now - cached.timestamp < CACHE_TTL_MS) {
+            // LRU: Refresh key position
+            analyticsCache.delete(cacheKey);
+            analyticsCache.set(cacheKey, cached);
             return cached.data;
         }
         analyticsCache.delete(cacheKey);

package/dist/ga4/tools/pagespeed.js

@@ -1,5 +1,6 @@
 import { getOrganicLandingPages } from './analytics.js';
 import { analyzePageSpeed } from '../../google/tools/pagespeed.js';
+import { limitConcurrency } from '../../common/concurrency.js';
 export async function getPageSpeedCorrelation(propertyId, domain, startDate, endDate, limit = 5, strategy = 'mobile', accountId) {
     // Normalize domain
     let baseUrl = domain.trim();
@@ -11,28 +12,25 @@ export async function getPageSpeedCorrelation(propertyId, domain, startDate, end
     }
     // 1. Get top organic landing pages
     const pages = await getOrganicLandingPages(propertyId, startDate, endDate, limit, accountId);
-    // 2. Run PageSpeed on each
-    const results = await Promise.allSettled(pages.map(async (page) => {
-        const path = page.landingPagePlusQueryString || page.pagePath;
-        if (!path)
-            throw new Error("No page path found");
-        const fullUrl = `${baseUrl}${path.startsWith('/') ? '' : '/'}${path}`;
-        const psiResult = await analyzePageSpeed(fullUrl, strategy);
-        return {
-            ...page,
-            pageSpeed: psiResult
-        };
-    }));
-    // 3. Merge
-    return results.map((res, index) => {
-        if (res.status === 'fulfilled') {
-            return res.value;
+    // 2. Run PageSpeed on each with concurrency limit
+    const results = await limitConcurrency(pages, 5, async (page) => {
+        try {
+            const path = page.landingPagePlusQueryString || page.pagePath;
+            if (!path)
+                throw new Error("No page path found");
+            const fullUrl = `${baseUrl}${path.startsWith('/') ? '' : '/'}${path}`;
+            const psiResult = await analyzePageSpeed(fullUrl, strategy);
+            return {
+                ...page,
+                pageSpeed: psiResult
+            };
         }
-        else {
+        catch (error) {
             return {
-                ...pages[index],
-                pageSpeedError: res.reason?.message || "Failed to analyze"
+                ...page,
+                pageSpeedError: error.message || "Failed to analyze"
             };
         }
     });
+    return results;
 }

package/dist/ga4/tools/properties.js

@@ -0,0 +1,28 @@
+import { loadConfig } from '../../common/auth/config.js';
+/**
+ * List configured GA4 properties.
+ * Since GA4 properties are configured explicitly during setup,
+ * we return the configured properties.
+ */
+export async function listProperties(accountId) {
+    const config = await loadConfig();
+    const accounts = Object.values(config.accounts).filter(a => a.engine === 'ga4');
+    if (accountId) {
+        const account = accounts.find(a => a.id === accountId);
+        if (!account) {
+            throw new Error(`GA4 account ${accountId} not found.`);
+        }
+        return [{
+                id: account.id,
+                alias: account.alias,
+                propertyId: account.ga4PropertyId,
+                siteUrl: account.ga4PropertyId // Alias for sites_list consistency
+            }];
+    }
+    return accounts.map(a => ({
+        id: a.id,
+        alias: a.alias,
+        propertyId: a.ga4PropertyId,
+        siteUrl: a.ga4PropertyId // Alias for sites_list consistency
+    }));
+}

package/dist/google/tools/advanced-analytics.js

@@ -158,7 +158,8 @@ export async function getTimeSeriesInsights(siteUrl, options = {}) {
         return {
             date: r.keys?.[dimensions.indexOf('date')] || '',
             dimensions: dimObj,
-            metrics: metricObj
+            metrics: metricObj,
+            original: r
         };
     }).sort((a, b) => a.date.localeCompare(b.date));
     // Support weekly granularity
@@ -166,33 +167,56 @@ export async function getTimeSeriesInsights(siteUrl, options = {}) {
         const weeklyData = {};
         data.forEach(d => {
             const date = new Date(d.date);
-            const day = date.getDay();
-            const diff = date.getDate() - day + (day === 0 ? -6 : 1); // Adjust to Monday
-            const monday = new Date(date.setDate(diff));
+            const day = date.getUTCDay();
+            const diff = date.getUTCDate() - day + (day === 0 ? -6 : 1); // Adjust to Monday
+            const monday = new Date(date);
+            monday.setUTCDate(diff);
             const weekKey = monday.toISOString().split('T')[0];
             if (!weeklyData[weekKey]) {
+                const initMetrics = {};
+                metrics.forEach(m => initMetrics[m] = 0);
                 weeklyData[weekKey] = {
                     date: weekKey,
                     dimensions: d.dimensions,
-                    metrics: { ...d.metrics }
+                    metrics: initMetrics,
+                    accumulators: { clicks: 0, impressions: 0, weightedPos: 0, count: 0 }
                 };
             }
-            else {
-                metrics.forEach(m => {
-                    if (m === 'position') {
-                        // For average position, we might need a weighted average, but simple average for now
-                        weeklyData[weekKey].metrics[m] = (weeklyData[weekKey].metrics[m] + d.metrics[m]) / 2;
-                    }
-                    else if (m === 'ctr') {
-                        weeklyData[weekKey].metrics[m] = (weeklyData[weekKey].metrics[m] + d.metrics[m]) / 2;
-                    }
-                    else {
-                        weeklyData[weekKey].metrics[m] += d.metrics[m];
-                    }
-                });
-            }
+            // Accumulate raw values
+            const entry = weeklyData[weekKey];
+            const r = d.original;
+            const clicks = r.clicks ?? 0;
+            const impressions = r.impressions ?? 0;
+            const position = r.position ?? 0;
+            entry.accumulators.clicks += clicks;
+            entry.accumulators.impressions += impressions;
+            entry.accumulators.weightedPos += (position * impressions);
+            entry.accumulators.count += 1;
         });
-        data = Object.values(weeklyData).sort((a, b) => a.date.localeCompare(b.date));
+        // Compute final weekly metrics
+        data = Object.values(weeklyData).map(w => {
+            const m = w.metrics;
+            const acc = w.accumulators;
+            const finalClicks = acc.clicks;
+            const finalImpressions = acc.impressions;
+            const finalCtr = finalImpressions > 0 ? finalClicks / finalImpressions : 0;
+            const finalPos = finalImpressions > 0 ? acc.weightedPos / finalImpressions : 0;
+            metrics.forEach(metric => {
+                if (metric === 'clicks')
+                    m[metric] = finalClicks;
+                else if (metric === 'impressions')
+                    m[metric] = finalImpressions;
+                else if (metric === 'ctr')
+                    m[metric] = finalCtr;
+                else if (metric === 'position')
+                    m[metric] = parseFloat(finalPos.toFixed(2));
+            });
+            return {
+                date: w.date,
+                dimensions: w.dimensions,
+                metrics: m
+            };
+        }).sort((a, b) => a.date.localeCompare(b.date));
     }
     // 1. Calculate Rolling Averages for EACH metric
     const history = data.map((d, i) => {

package/dist/google/tools/analytics.js

@@ -7,18 +7,17 @@ export function clearAnalyticsCache() {
 }
 function generateCacheKey(options) {
     const clone = { ...options };
-    // Dimensions order matters because it determines the order of keys in the response.
-    // We should NOT sort them.
-    /*
-    if (clone.dimensions) {
-      clone.dimensions = [...clone.dimensions].sort();
-    }
-    */
     if (clone.filters) {
         clone.filters = [...clone.filters].sort((a, b) => (a.dimension + a.operator + a.expression).localeCompare(b.dimension + b.operator + b.expression));
     }
-    // Sort object keys
-    return JSON.stringify(clone, Object.keys(clone).sort());
+    // We need a stable JSON string for the cache key.
+    // Instead of the broken JSON.stringify(clone, keys) which wipes nested objects,
+    // we manually sort the top-level keys.
+    const sorted = {};
+    Object.keys(clone).sort().forEach(key => {
+        sorted[key] = clone[key];
+    });
+    return JSON.stringify(sorted);
 }
 /**
  * Executes a raw query against the Google Search Console Search Analytics API.
@@ -36,6 +35,9 @@ export async function queryAnalytics(options) {
             return cached;
         }
         if (now - cached.timestamp < CACHE_TTL_MS) {
+            // LRU: Refresh key position
+            analyticsCache.delete(cacheKey);
+            analyticsCache.set(cacheKey, cached);
             return cached.data;
         }
         analyticsCache.delete(cacheKey);
@@ -57,13 +59,16 @@ export async function queryAnalytics(options) {
                 requestBody.startRow = options.startRow;
             }
             if (options.filters && options.filters.length > 0) {
-                requestBody.dimensionFilterGroups = [{
-                        filters: options.filters.map(f => ({
+                // We use separate dimensionFilterGroups for each filter to ensure they are joined by AND.
+                // GSC API joins multiple filters within the same group by OR if they share the same dimension.
+                // By putting them in separate groups, we guarantee strict AND behavior for all filters.
+                requestBody.dimensionFilterGroups = options.filters.map(f => ({
+                    filters: [{
                             dimension: f.dimension,
                             operator: f.operator,
                             expression: f.expression
-                        }))
-                    }];
+                        }]
+                }));
             }
             const res = await client.searchanalytics.query({
                 siteUrl: options.siteUrl,
@@ -356,24 +361,27 @@ export async function detectTrends(siteUrl, options = {}) {
     const limit = options.limit ?? 20;
     // Split the period into two halves
     const midPoint = Math.floor(days / 2);
-    const endDate = new Date();
-    endDate.setDate(endDate.getDate() - DATA_DELAY_DAYS);
-    const midDate = new Date(endDate);
-    midDate.setDate(midDate.getDate() - midPoint);
-    const startDate = new Date(midDate);
-    startDate.setDate(startDate.getDate() - midPoint);
+    // Calculate periods ensuring no overlap
+    const currentEndDate = new Date();
+    currentEndDate.setDate(currentEndDate.getDate() - DATA_DELAY_DAYS);
+    const currentStartDate = new Date(currentEndDate);
+    currentStartDate.setDate(currentStartDate.getDate() - midPoint + 1);
+    const previousEndDate = new Date(currentStartDate);
+    previousEndDate.setDate(previousEndDate.getDate() - 1);
+    const previousStartDate = new Date(previousEndDate);
+    previousStartDate.setDate(previousStartDate.getDate() - midPoint + 1);
     const [currentPeriod, previousPeriod] = await Promise.all([
         queryAnalytics({
             siteUrl,
-            startDate: midDate.toISOString().split('T')[0],
-            endDate: endDate.toISOString().split('T')[0],
+            startDate: currentStartDate.toISOString().split('T')[0],
+            endDate: currentEndDate.toISOString().split('T')[0],
             dimensions: [dimension],
             limit: 5000 // Get enough data to find trends
         }),
         queryAnalytics({
             siteUrl,
-            startDate: startDate.toISOString().split('T')[0],
-            endDate: midDate.toISOString().split('T')[0],
+            startDate: previousStartDate.toISOString().split('T')[0],
+            endDate: previousEndDate.toISOString().split('T')[0],
             dimensions: [dimension],
             limit: 5000
         })

package/dist/google/tools/inspection.js

@@ -9,7 +9,7 @@ import { limitConcurrency } from '../../common/concurrency.js';
  * @returns Comprehensive indexing and status information for the URL.
  */
 export async function inspectUrl(siteUrl, inspectionUrl, languageCode = 'en-US') {
-    const client = await getSearchConsoleClient();
+    const client = await getSearchConsoleClient(siteUrl);
     const res = await client.urlInspection.index.inspect({
         requestBody: {
             inspectionUrl,

package/dist/google/tools/sitemaps.js

@@ -6,7 +6,7 @@ import { getSearchConsoleClient } from '../client.js';
  * @returns A list of sitemap metadata objects.
  */
 export async function listSitemaps(siteUrl) {
-    const client = await getSearchConsoleClient();
+    const client = await getSearchConsoleClient(siteUrl);
     const res = await client.sitemaps.list({ siteUrl });
     return res.data.sitemap || [];
 }
@@ -18,7 +18,7 @@ export async function listSitemaps(siteUrl) {
  * @returns A success message.
  */
 export async function submitSitemap(siteUrl, feedpath) {
-    const client = await getSearchConsoleClient();
+    const client = await getSearchConsoleClient(siteUrl);
     await client.sitemaps.submit({ siteUrl, feedpath });
     return `Successfully submitted sitemap: ${feedpath} for ${siteUrl}`;
 }
@@ -30,7 +30,7 @@ export async function submitSitemap(siteUrl, feedpath) {
  * @returns A success message.
  */
 export async function deleteSitemap(siteUrl, feedpath) {
-    const client = await getSearchConsoleClient();
+    const client = await getSearchConsoleClient(siteUrl);
     await client.sitemaps.delete({ siteUrl, feedpath });
     return `Successfully deleted sitemap: ${feedpath} from ${siteUrl}`;
 }
@@ -42,7 +42,7 @@ export async function deleteSitemap(siteUrl, feedpath) {
  * @returns Sitemap details including status and item counts.
  */
 export async function getSitemap(siteUrl, feedpath) {
-    const client = await getSearchConsoleClient();
+    const client = await getSearchConsoleClient(siteUrl);
     const res = await client.sitemaps.get({ siteUrl, feedpath });
     return res.data;
 }

package/dist/index.js

@@ -32,7 +32,10 @@ import * as ga4Behavior from "./ga4/tools/behavior.js";
 import * as ga4PageSpeed from "./ga4/tools/pagespeed.js";
 import * as ga4GscComparator from "./common/tools/compare-engines/ga4-gsc-comparator.js";
 import * as ga4GscBingComparator from "./common/tools/compare-engines/ga4-gsc-bing-comparator.js";
+import * as ga4Properties from "./ga4/tools/properties.js";
 import { loadConfig, removeAccount, updateAccount } from './common/auth/config.js';
+import { normalizeWebsite } from './common/auth/resolver.js';
+import { limitConcurrency } from './common/concurrency.js';
 import { bingApiDocs, indexNowDocs, dimensionsDocs as bingDimensionsDocs, filtersDocs as bingFiltersDocs, searchTypesDocs as bingSearchTypesDocs, patternsDocs as bingPatternsDocs, algorithmUpdatesDocs as bingAlgorithmUpdatesDocs } from "./bing/docs/index.js";
 import { formatError } from "./common/errors.js";
 import { existsSync } from "fs";
@@ -64,7 +67,7 @@ const server = new McpServer({
 // Get Started Tool
 server.tool(getStartedToolName, getStartedToolDescription, getStartedToolSchema, getStartedHandler);
 // Sites Tools
-server.tool("sites_list", "List all verified sites across all authorized accounts", { engine: z.enum(["google", "bing"]).optional().describe("The search engine (default: google)") }, async ({ engine = "google" }) => {
+server.tool("sites_list", "List all verified sites or properties across all authorized accounts", { engine: z.enum(["google", "bing", "ga4"]).optional().describe("The search engine (default: google)") }, async ({ engine = "google" }) => {
     try {
         const config = await loadConfig();
         const accounts = Object.values(config.accounts).filter(a => a.engine === engine);
@@ -73,26 +76,54 @@ server.tool("sites_list", "List all verified sites across all authorized account
             const results = await bingSites.listSites();
             return { content: [{ type: "text", text: JSON.stringify(results, null, 2) }] };
         }
-        const allResults = [];
-        for (const account of accounts) {
+        const allResults = await limitConcurrency(accounts, 5, async (account) => {
             try {
-                const results = engine === "google"
-                    ? await sites.listSites(account.id)
-                    : await bingSites.listSites(account.id);
-                allResults.push({
+                let results;
+                if (engine === "google") {
+                    results = await sites.listSites(account.id);
+                }
+                else if (engine === "bing") {
+                    results = await bingSites.listSites(account.id);
+                }
+                else if (engine === "ga4") {
+                    results = await ga4Properties.listProperties(account.id);
+                }
+                else {
+                    results = [];
+                }
+                // Boundary Filtering: Honor the website in the config
+                if (account.websites && account.websites.length > 0) {
+                    results = results.filter(site => {
+                        const url = engine === "ga4" ? (site.propertyId) : (site.siteUrl || site.Url);
+                        if (!url)
+                            return false;
+                        // If it's a numeric property ID (GA4), check direct inclusion
+                        if (engine === "ga4" && /^\d+$/.test(url)) {
+                            return account.websites.includes(url);
+                        }
+                        try {
+                            const normalizedSite = normalizeWebsite(url).value;
+                            return account.websites.some(w => normalizeWebsite(w).value === normalizedSite);
+                        }
+                        catch {
+                            return account.websites.includes(url);
+                        }
+                    });
+                }
+                return {
                     account: account.alias,
                     accountId: account.id,
                     sites: results
-                });
+                };
             }
             catch (e) {
-                allResults.push({
+                return {
                     account: account.alias,
                     accountId: account.id,
                     error: e.message
-                });
+                };
             }
-        }
+        });
         return {
             content: [{ type: "text", text: JSON.stringify(allResults, null, 2) }]
         };
@@ -101,6 +132,65 @@ server.tool("sites_list", "List all verified sites across all authorized account
         return formatError(error);
     }
 });
+server.tool("bing_seo_cannibalization", "Detect pages competing for the same query in Bing.", {
+    siteUrl: z.string().describe("The URL of the site"),
+    minImpressions: z.number().optional().describe("Minimum impressions threshold (default 50)")
+}, async ({ siteUrl, minImpressions }) => {
+    try {
+        const results = await bingSeoInsights.detectCannibalization(siteUrl, { minImpressions });
+        return {
+            content: [{ type: "text", text: JSON.stringify(results, null, 2) }]
+        };
+    }
+    catch (error) {
+        return formatError(error);
+    }
+});
+server.tool("bing_seo_lost_queries", "Identify queries that lost significant traffic on Bing compared to the previous period.", {
+    siteUrl: z.string().describe("The URL of the site"),
+    days: z.number().optional().describe("Lookback period in days (default 28)")
+}, async ({ siteUrl, days }) => {
+    try {
+        const results = await bingSeoInsights.findLostQueries(siteUrl, { days });
+        return {
+            content: [{ type: "text", text: JSON.stringify(results, null, 2) }]
+        };
+    }
+    catch (error) {
+        return formatError(error);
+    }
+});
+server.tool("bing_brand_analysis", "Analyze Brand vs Non-Brand performance on Bing.", {
+    siteUrl: z.string().describe("The URL of the site"),
+    brandRegex: z.string().describe("Regex matching brand terms (e.g. 'acme|acmecorp')"),
+    days: z.number().optional().describe("Number of days to analyze (default 28)")
+}, async ({ siteUrl, brandRegex, days }) => {
+    try {
+        const results = await bingSeoInsights.analyzeBrandVsNonBrand(siteUrl, brandRegex, { days });
+        return {
+            content: [{ type: "text", text: JSON.stringify(results, null, 2) }]
+        };
+    }
+    catch (error) {
+        return formatError(error);
+    }
+});
+server.tool("bing_analytics_trends", "Detect rising or declining trends in Bing query performance", {
+    siteUrl: z.string().describe("The URL of the site"),
+    days: z.number().optional().describe("Number of days to analyze (default 28)"),
+    threshold: z.number().optional().describe("Minimum percentage change (default 10)"),
+    minClicks: z.number().optional().describe("Minimum clicks required (default 100)")
+}, async ({ siteUrl, days, threshold, minClicks }) => {
+    try {
+        const results = await bingAnalytics.detectTrends(siteUrl, { days, threshold, minClicks });
+        return {
+            content: [{ type: "text", text: JSON.stringify(results, null, 2) }]
+        };
+    }
+    catch (error) {
+        return formatError(error);
+    }
+});
 server.tool("sites_add", "Add a new site to Search Console or Bing Webmaster Tools", {
     siteUrl: z.string().describe("The URL of the site to add"),
     engine: z.enum(["google", "bing"]).optional().describe("The search engine (default: google)")

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "search-console-mcp",
-  "version": "1.13.1",
+  "version": "1.13.3",
   "mcpName": "io.github.saurabhsharma2u/search-console-mcp",
   "description": "MCP server for Google Search Console, Bing Webmaster Tools, and Google Analytics 4",
   "type": "module",
@@ -32,13 +32,13 @@
   "author": "",
   "license": "MIT",
   "dependencies": {
-    "@adobe/structured-data-validator": "^1.6.0",
+    "@adobe/structured-data-validator": "^1.7.0",
     "@google-analytics/data": "^5.2.1",
     "@modelcontextprotocol/sdk": "^1.26.0",
     "@napi-rs/keyring": "^1.2.0",
     "cheerio": "^1.2.0",
-    "dotenv": "^17.2.3",
-    "googleapis": "^171.0.0",
+    "dotenv": "^17.3.1",
+    "googleapis": "^171.4.0",
     "node-machine-id": "^1.1.12",
     "open": "^11.0.0",
     "re2": "^1.23.3",
@@ -52,4 +52,4 @@
     "typescript": "^5.9.3",
     "vitest": "^4.0.18"
   }
-}
+}