search-console-mcp 1.11.0 → 1.11.1

package/dist/bing/client.js

@@ -35,29 +35,38 @@ export class BingClient {
     async getSiteList() {
         return this.request('GetUserSites');
     }
+    async addSite(siteUrl) {
+        return this.request('AddSite', { siteUrl }, true);
+    }
+    async removeSite(siteUrl) {
+        return this.request('RemoveSite', { siteUrl }, true);
+    }
     async getQueryStats(siteUrl) {
-        return this.request('GetQueryStats', { siteUrl }, true);
+        return this.request('GetQueryStats', { siteUrl });
     }
     async getPageStats(siteUrl) {
-        return this.request('GetPageStats', { siteUrl }, true);
+        return this.request('GetPageStats', { siteUrl });
+    }
+    async getPageQueryStats(siteUrl, page) {
+        return this.request('GetPageQueryStats', { siteUrl, page });
     }
-    async getPageQueryStats(siteUrl, pageUrl) {
-        return this.request('GetPageQueryStats', { siteUrl, pageUrl }, true);
+    async submitSitemap(siteUrl, feedUrl) {
+        await this.request('SubmitFeed', { siteUrl, feedUrl }, true);
     }
-    async submitSitemap(siteUrl, sitemapUrl) {
-        await this.request('SubmitSitemap', { siteUrl, sitemapUrl }, true);
+    async deleteSitemap(siteUrl, feedUrl) {
+        await this.request('RemoveFeed', { siteUrl, feedUrl }, true);
     }
-    async getSitemaps(siteUrl) {
-        return this.request('GetSitemaps', { siteUrl }, true);
+    async getFeeds(siteUrl) {
+        return this.request('GetFeeds', { siteUrl });
     }
     async getKeywordStats(q, country, language) {
-        return this.request('GetKeywordStats', { q, country, language }, true);
+        return this.request('GetKeywordStats', { q, country, language });
     }
     async getCrawlIssues(siteUrl) {
-        return this.request('GetCrawlIssues', { siteUrl }, true);
+        return this.request('GetCrawlIssues', { siteUrl });
     }
     async getUrlSubmissionQuota(siteUrl) {
-        return this.request('GetUrlSubmissionQuota', { siteUrl }, true);
+        return this.request('GetUrlSubmissionQuota', { siteUrl });
     }
     async submitUrl(siteUrl, url) {
         return this.request('SubmitUrl', { siteUrl, url }, true);
@@ -66,22 +75,22 @@ export class BingClient {
         return this.request('SubmitUrlBatch', { siteUrl, urlList }, true);
     }
     async getQueryPageStats(siteUrl) {
-        return this.request('GetQueryPageStats', { siteUrl }, true);
+        return this.request('GetQueryPageStats', { siteUrl });
     }
     async getRankAndTrafficStats(siteUrl) {
-        return this.request('GetRankAndTrafficStats', { siteUrl }, true);
+        return this.request('GetRankAndTrafficStats', { siteUrl });
     }
     async getCrawlStats(siteUrl) {
-        return this.request('GetCrawlStats', { siteUrl }, true);
+        return this.request('GetCrawlStats', { siteUrl });
     }
     async getUrlInfo(siteUrl, url) {
-        return this.request('GetUrlInfo', { siteUrl, url }, true);
+        return this.request('GetUrlInfo', { siteUrl, url });
     }
     async getLinkCounts(siteUrl) {
-        return this.request('GetLinkCounts', { siteUrl }, true);
+        return this.request('GetLinkCounts', { siteUrl });
     }
     async getRelatedKeywords(q, country, language) {
-        return this.request('GetRelatedKeywords', { q, country, language }, true);
+        return this.request('GetRelatedKeywords', { q, country, language });
     }
 }
 let cachedBingClient = null;

package/dist/bing/tools/analytics.js

@@ -119,3 +119,29 @@ export async function detectAnomalies(siteUrl, options = {}) {
     }
     return anomalies;
 }
+/**
+ * Get aggregate performance summary for a Bing site for the last N days.
+ */
+export async function getPerformanceSummary(siteUrl, days = 28) {
+    const stats = await getRankAndTrafficStats(siteUrl);
+    // Bing typically has historical data; filter for last N days
+    const endDate = new Date();
+    const startDate = new Date();
+    startDate.setDate(endDate.getDate() - days);
+    const filtered = stats.filter((row) => {
+        const d = new Date(row.Date);
+        return d >= startDate && d <= endDate;
+    });
+    const clicks = filtered.reduce((acc, row) => acc + row.Clicks, 0);
+    const impressions = filtered.reduce((acc, row) => acc + row.Impressions, 0);
+    const weightedPosSum = filtered.reduce((acc, row) => acc + (row.AvgPosition * row.Impressions), 0);
+    const avgPos = impressions > 0 ? weightedPosSum / impressions : 0;
+    return {
+        clicks,
+        impressions,
+        ctr: impressions > 0 ? clicks / impressions : 0,
+        position: parseFloat(avgPos.toFixed(2)),
+        startDate: startDate.toISOString().split('T')[0],
+        endDate: endDate.toISOString().split('T')[0]
+    };
+}

package/dist/bing/tools/seo-insights.js

@@ -1,4 +1,4 @@
-import { getQueryStats } from './analytics.js';
+import { getQueryStats, getQueryPageStats } from './analytics.js';
 /**
  * Find "low-hanging fruit" keywords in Bing.
  */
@@ -68,15 +68,62 @@ export async function findLowCTROpportunities(siteUrl, options = {}) {
         .sort((a, b) => b.Impressions - a.Impressions)
         .slice(0, limit);
 }
+/**
+ * Detect keyword cannibalization in Bing where multiple pages compete for the same query.
+ */
+export async function detectCannibalization(siteUrl, options = {}) {
+    const { minImpressions = 50, limit = 30 } = options;
+    const rows = await getQueryPageStats(siteUrl);
+    // Group by query
+    const queryMap = new Map();
+    for (const row of rows) {
+        if (row.Impressions < minImpressions)
+            continue;
+        if (!queryMap.has(row.Query)) {
+            queryMap.set(row.Query, []);
+        }
+        queryMap.get(row.Query).push({
+            page: row.Page,
+            clicks: row.Clicks,
+            impressions: row.Impressions,
+            date: row.Date
+        });
+    }
+    const cannibalization = [];
+    for (const [query, pages] of queryMap) {
+        if (pages.length >= 2) {
+            pages.sort((a, b) => b.clicks - a.clicks);
+            const totalClicks = pages.reduce((sum, p) => sum + p.clicks, 0);
+            const totalImpressions = pages.reduce((sum, p) => sum + p.impressions, 0);
+            // Calculate conflict score
+            const shares = pages.map(p => totalClicks > 0 ? p.clicks / totalClicks : 0);
+            const hhi = shares.reduce((sum, s) => sum + s * s, 0);
+            const conflictScore = 1 - hhi;
+            if (conflictScore > 0.1 || pages[1].impressions > (pages[0].impressions * 0.2)) {
+                cannibalization.push({
+                    query,
+                    pages,
+                    totalClicks,
+                    totalImpressions,
+                    clickShareConflict: parseFloat(conflictScore.toFixed(2))
+                });
+            }
+        }
+    }
+    return cannibalization
+        .sort((a, b) => (b.totalClicks * b.clickShareConflict) - (a.totalClicks * a.clickShareConflict))
+        .slice(0, limit);
+}
 /**
  * Generate prioritized Bing SEO recommendations.
  */
 export async function generateRecommendations(siteUrl) {
     const insights = [];
-    const [lowHangingFruit, strikingDistance, lowCTR] = await Promise.all([
+    const [lowHangingFruit, strikingDistance, lowCTR, cannibalization] = await Promise.all([
         findLowHangingFruit(siteUrl, { limit: 10 }),
         findStrikingDistance(siteUrl, { limit: 10 }),
-        findLowCTROpportunities(siteUrl, { limit: 10 })
+        findLowCTROpportunities(siteUrl, { limit: 10 }),
+        detectCannibalization(siteUrl, { limit: 10 })
     ]);
     if (lowHangingFruit.length > 0) {
         const totalPotential = lowHangingFruit.reduce((sum, l) => sum + l.potentialClicks, 0);
@@ -99,6 +146,16 @@ export async function generateRecommendations(siteUrl) {
             data: { topQueries: lowCTR.slice(0, 5).map(q => q.Query) }
         });
     }
+    if (cannibalization.length > 0) {
+        insights.push({
+            type: 'warning',
+            category: 'Content',
+            title: `${cannibalization.length} Bing Cannibalization Issues`,
+            description: `Multiple pages are competing for the same keywords in Bing. Consider consolidating content.`,
+            priority: 'medium',
+            data: { topIssues: cannibalization.slice(0, 3).map(c => c.query) }
+        });
+    }
     if (strikingDistance.length > 0) {
         insights.push({
             type: 'opportunity',

package/dist/bing/tools/sitemaps.js

@@ -7,7 +7,7 @@ import { getBingClient } from '../client.js';
  */
 export async function listSitemaps(siteUrl) {
     const client = await getBingClient();
-    return client.getSitemaps(siteUrl);
+    return client.getFeeds(siteUrl);
 }
 /**
  * Submit a sitemap to Bing Webmaster Tools.
@@ -20,3 +20,14 @@ export async function submitSitemap(siteUrl, sitemapUrl) {
     await client.submitSitemap(siteUrl, sitemapUrl);
     return `Successfully submitted sitemap: ${sitemapUrl} for site ${siteUrl}`;
 }
+/**
+ * Remove a sitemap from Bing Webmaster Tools.
+ *
+ * @param siteUrl - The URL of the site.
+ * @param sitemapUrl - The URL of the sitemap to remove.
+ */
+export async function deleteSitemap(siteUrl, sitemapUrl) {
+    const client = await getBingClient();
+    await client.deleteSitemap(siteUrl, sitemapUrl);
+    return `Successfully removed sitemap: ${sitemapUrl} for site ${siteUrl}`;
+}

package/dist/bing/tools/sites.js

@@ -8,3 +8,25 @@ export async function listSites() {
     const client = await getBingClient();
     return client.getSiteList();
 }
+/**
+ * Add a site to Bing Webmaster Tools.
+ *
+ * @param siteUrl - The URL of the site to add.
+ * @returns A success message.
+ */
+export async function addSite(siteUrl) {
+    const client = await getBingClient();
+    await client.addSite(siteUrl);
+    return `Successfully added site: ${siteUrl}`;
+}
+/**
+ * Remove a site from Bing Webmaster Tools.
+ *
+ * @param siteUrl - The URL of the site to remove.
+ * @returns A success message.
+ */
+export async function removeSite(siteUrl) {
+    const client = await getBingClient();
+    await client.removeSite(siteUrl);
+    return `Successfully removed site: ${siteUrl}`;
+}

package/dist/common/tools/seo-primitives.js

@@ -5,7 +5,7 @@ import { safeTest } from '../../common/utils/regex.js';
  * @param position - The average ranking position.
  * @returns The categorized bucket result.
  */
-export function getRankingBucket(position) {
+export function getRankingBucket(position, engine) {
     let bucket;
     if (position <= 0)
         bucket = 'Unranked';
@@ -17,7 +17,7 @@ export function getRankingBucket(position) {
         bucket = 'Page 2 (11-20)';
     else
         bucket = 'Page 3+';
-    return { position, bucket };
+    return { position, bucket, engine };
 }
 /**
  * Calculate the delta and percentage change between two traffic metrics.
@@ -26,7 +26,7 @@ export function getRankingBucket(position) {
  * @param previous - The baseline metric value.
  * @returns A detailed delta result including status.
  */
-export function calculateTrafficDelta(current, previous) {
+export function calculateTrafficDelta(current, previous, engine) {
     const absoluteChange = current - previous;
     let percentChange = 0;
     let status;
@@ -51,7 +51,7 @@ export function calculateTrafficDelta(current, previous) {
         else
             status = 'unchanged';
     }
-    return { current, previous, absoluteChange, percentChange, status };
+    return { current, previous, absoluteChange, percentChange, status, engine };
 }
 /**
  * Determine if a search query matches a brand pattern using regex.
@@ -60,12 +60,13 @@ export function calculateTrafficDelta(current, previous) {
  * @param brandRegexString - The regex string to use for matching.
  * @returns A brand detection result.
  */
-export function isBrandQuery(query, brandRegexString) {
+export function isBrandQuery(query, brandRegexString, engine) {
     const isBrand = safeTest(brandRegexString, 'i', query);
     return {
         query,
         isBrand,
-        matchedPattern: isBrand ? brandRegexString : undefined
+        matchedPattern: isBrand ? brandRegexString : undefined,
+        engine
     };
 }
 /**
@@ -106,6 +107,7 @@ export function isCannibalized(query, pageA, pageB) {
         pageB: "Page B",
         isCannibalized,
         overlapScore,
-        recommendation
+        recommendation,
+        engine: pageA.engine // Use engine from pageA if available
     };
 }

package/dist/index.js

@@ -35,20 +35,23 @@ const server = new McpServer({
     version: "1.0.0",
 });
 // Sites Tools
-server.tool("sites_list", "List all sites in Search Console", {}, async () => {
+server.tool("sites_list", "List all verified sites", { engine: z.enum(["google", "bing"]).optional().describe("The search engine (default: google)") }, async ({ engine = "google" }) => {
     try {
-        const result = await sites.listSites();
+        const results = engine === "google" ? await sites.listSites() : await bingSites.listSites();
         return {
-            content: [{ type: "text", text: JSON.stringify(result, null, 2) }]
+            content: [{ type: "text", text: JSON.stringify(results, null, 2) }]
         };
     }
     catch (error) {
         return formatError(error);
     }
 });
-server.tool("sites_add", "Add a website to Search Console", { siteUrl: z.string().describe("The URL of the site to add (e.g., 'https://example.com' or 'sc-domain:example.com')") }, async ({ siteUrl }) => {
+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)")
+}, async ({ siteUrl, engine = "google" }) => {
     try {
-        const result = await sites.addSite(siteUrl);
+        const result = engine === "google" ? await sites.addSite(siteUrl) : await bingSites.addSite(siteUrl);
         return {
             content: [{ type: "text", text: result }]
         };
@@ -57,9 +60,12 @@ server.tool("sites_add", "Add a website to Search Console", { siteUrl: z.string(
         return formatError(error);
     }
 });
-server.tool("sites_delete", "Remove a website from Search Console", { siteUrl: z.string().describe("The URL of the site to delete") }, async ({ siteUrl }) => {
+server.tool("sites_delete", "Remove a site from Search Console or Bing Webmaster Tools", {
+    siteUrl: z.string().describe("The URL of the site to delete"),
+    engine: z.enum(["google", "bing"]).optional().describe("The search engine (default: google)")
+}, async ({ siteUrl, engine = "google" }) => {
     try {
-        const result = await sites.deleteSite(siteUrl);
+        const result = engine === "google" ? await sites.deleteSite(siteUrl) : await bingSites.removeSite(siteUrl);
         return {
             content: [{ type: "text", text: result }]
         };
@@ -79,11 +85,14 @@ server.tool("sites_get", "Get information about a specific site", { siteUrl: z.s
         return formatError(error);
     }
 });
-server.tool("sites_health_check", "Run a health check on one or all verified sites. Checks week-over-week performance, sitemap status, and traffic anomalies. Returns a structured report with an overall status (healthy/warning/critical) per site.", {
-    siteUrl: z.string().optional().describe("Optional. The URL of a specific site to check. If omitted, checks all verified sites.")
-}, async ({ siteUrl }) => {
+server.tool("sites_health_check", "Run a health check on one or all verified sites. Checks performance trends and status.", {
+    siteUrl: z.string().optional().describe("Optional. The URL of a specific site to check."),
+    engine: z.enum(["google", "bing"]).optional().describe("The search engine (default: google)")
+}, async ({ siteUrl, engine = "google" }) => {
     try {
-        const result = await sitesHealth.healthCheck(siteUrl);
+        const result = engine === "google"
+            ? await sitesHealth.healthCheck(siteUrl)
+            : await bingHealth.healthCheck(siteUrl);
         return {
             content: [{ type: "text", text: JSON.stringify(result, null, 2) }]
         };
@@ -93,11 +102,14 @@ server.tool("sites_health_check", "Run a health check on one or all verified sit
     }
 });
 // Sitemaps Tools
-server.tool("sitemaps_list", "List sitemaps for a site", { siteUrl: z.string().describe("The URL of the site") }, async ({ siteUrl }) => {
+server.tool("sitemaps_list", "List sitemaps for a site", {
+    siteUrl: z.string().describe("The URL of the site"),
+    engine: z.enum(["google", "bing"]).optional().describe("The search engine (default: google)")
+}, async ({ siteUrl, engine = "google" }) => {
     try {
-        const result = await sitemaps.listSitemaps(siteUrl);
+        const results = engine === "google" ? await sitemaps.listSitemaps(siteUrl) : await bingSitemaps.listSitemaps(siteUrl);
         return {
-            content: [{ type: "text", text: JSON.stringify(result, null, 2) }]
+            content: [{ type: "text", text: JSON.stringify(results, null, 2) }]
         };
     }
     catch (error) {
@@ -118,12 +130,13 @@ server.tool("sitemaps_get", "Get details about a specific sitemap", {
         return formatError(error);
     }
 });
-server.tool("sitemaps_submit", "Submit a sitemap", {
+server.tool("sitemaps_submit", "Submit a sitemap to Search Console or Bing Webmaster Tools", {
     siteUrl: z.string().describe("The URL of the site"),
-    feedpath: z.string().describe("The URL of the sitemap")
-}, async ({ siteUrl, feedpath }) => {
+    feedpath: z.string().describe("The URL of the sitemap"),
+    engine: z.enum(["google", "bing"]).optional().describe("The search engine (default: google)")
+}, async ({ siteUrl, feedpath, engine = "google" }) => {
     try {
-        const result = await sitemaps.submitSitemap(siteUrl, feedpath);
+        const result = engine === "google" ? await sitemaps.submitSitemap(siteUrl, feedpath) : await bingSitemaps.submitSitemap(siteUrl, feedpath);
         return {
             content: [{ type: "text", text: result }]
         };
@@ -132,12 +145,13 @@ server.tool("sitemaps_submit", "Submit a sitemap", {
         return formatError(error);
     }
 });
-server.tool("sitemaps_delete", "Delete a sitemap", {
+server.tool("sitemaps_delete", "Delete a sitemap from Search Console or Bing Webmaster Tools", {
     siteUrl: z.string().describe("The URL of the site"),
-    feedpath: z.string().describe("The URL of the sitemap")
-}, async ({ siteUrl, feedpath }) => {
+    feedpath: z.string().describe("The URL of the sitemap"),
+    engine: z.enum(["google", "bing"]).optional().describe("The search engine (default: google)")
+}, async ({ siteUrl, feedpath, engine = "google" }) => {
     try {
-        const result = await sitemaps.deleteSitemap(siteUrl, feedpath);
+        const result = engine === "google" ? await sitemaps.deleteSitemap(siteUrl, feedpath) : await bingSitemaps.deleteSitemap(siteUrl, feedpath);
         return {
             content: [{ type: "text", text: result }]
         };
@@ -173,12 +187,15 @@ server.tool("analytics_query", "Query search analytics data with optional pagina
         return formatError(error);
     }
 });
-server.tool("analytics_performance_summary", "Get the aggregate performance metrics (clicks, impressions, CTR, position) for the last N days. Defaults to 28 days. Note: Data is typically delayed by 2-3 days.", {
+server.tool("analytics_performance_summary", "Get the aggregate performance metrics (clicks, impressions, CTR, position) for the last N days.", {
     siteUrl: z.string().describe("The URL of the site"),
-    days: z.number().optional().describe("Number of days to look back (default: 28)")
-}, async ({ siteUrl, days }) => {
+    days: z.number().optional().describe("Number of days to look back (default: 28)"),
+    engine: z.enum(["google", "bing"]).optional().describe("The search engine (default: google)")
+}, async ({ siteUrl, days, engine = "google" }) => {
     try {
-        const result = await analytics.getPerformanceSummary(siteUrl, days);
+        const result = engine === "google"
+            ? await analytics.getPerformanceSummary(siteUrl, days)
+            : await bingAnalytics.getPerformanceSummary(siteUrl, days);
         return {
             content: [{ type: "text", text: JSON.stringify(result, null, 2) }]
         };
@@ -353,13 +370,16 @@ server.tool("analytics_time_series", "Get advanced time series data including ro
     }
 });
 // Inspection Tools
-server.tool("inspection_inspect", "Inspect a URL to check its indexing status, crawl info, and mobile usability", {
-    siteUrl: z.string().describe("The URL of the property (must match a verified property in Search Console)"),
-    inspectionUrl: z.string().describe("The fully-qualified URL to inspect (must be under the siteUrl property)"),
-    languageCode: z.string().optional().describe("Language code for localized results (default: en-US)")
-}, async ({ siteUrl, inspectionUrl, languageCode }) => {
+server.tool("inspection_inspect", "Inspect a URL to check its indexing status, crawl info, and health", {
+    siteUrl: z.string().describe("The URL of the property"),
+    inspectionUrl: z.string().describe("The fully-qualified URL to inspect"),
+    languageCode: z.string().optional().describe("Language code for localized results (Google only)"),
+    engine: z.enum(["google", "bing"]).optional().describe("The search engine (default: google)")
+}, async ({ siteUrl, inspectionUrl, languageCode, engine = "google" }) => {
     try {
-        const result = await inspection.inspectUrl(siteUrl, inspectionUrl, languageCode);
+        const result = engine === "google"
+            ? await inspection.inspectUrl(siteUrl, inspectionUrl, languageCode)
+            : await bingInspection.getUrlInfo(siteUrl, inspectionUrl);
         return {
             content: [{ type: "text", text: JSON.stringify(result, null, 2) }]
         };
@@ -411,14 +431,17 @@ server.tool("seo_recommendations", "Generate SEO recommendations based on site p
         return formatError(error);
     }
 });
-server.tool("seo_low_hanging_fruit", "Find keywords with high impressions but low rankings (positions 5-20) that have potential for quick wins", {
+server.tool("seo_low_hanging_fruit", "Find keywords with high impressions but low rankings that have potential for growth", {
     siteUrl: z.string().describe("The site URL"),
-    days: z.number().optional().describe("Number of days to analyze (default: 28)"),
+    days: z.number().optional().describe("Number of days (Google only, default: 28)"),
     minImpressions: z.number().optional().describe("Minimum impressions threshold (default: 100)"),
-    limit: z.number().optional().describe("Max results to return (default: 50)")
-}, async ({ siteUrl, days, minImpressions, limit }) => {
+    limit: z.number().optional().describe("Max results to return (default: 50)"),
+    engine: z.enum(["google", "bing"]).optional().describe("The search engine (default: google)")
+}, async ({ siteUrl, days, minImpressions, limit, engine = "google" }) => {
     try {
-        const result = await seoInsights.findLowHangingFruit(siteUrl, { days, minImpressions, limit });
+        const result = engine === "google"
+            ? await seoInsights.findLowHangingFruit(siteUrl, { days, minImpressions, limit })
+            : await bingSeoInsights.findLowHangingFruit(siteUrl, { minImpressions, limit });
         return {
             content: [{ type: "text", text: JSON.stringify(result, null, 2) }]
         };
@@ -429,12 +452,15 @@ server.tool("seo_low_hanging_fruit", "Find keywords with high impressions but lo
 });
 server.tool("seo_cannibalization", "Detect keyword cannibalization - multiple pages competing for the same query", {
     siteUrl: z.string().describe("The site URL"),
-    days: z.number().optional().describe("Number of days to analyze (default: 28)"),
+    days: z.number().optional().describe("Number of days (Google only, default: 28)"),
     minImpressions: z.number().optional().describe("Minimum impressions threshold (default: 50)"),
-    limit: z.number().optional().describe("Max issues to return (default: 30)")
-}, async ({ siteUrl, days, minImpressions, limit }) => {
+    limit: z.number().optional().describe("Max issues to return (default: 30)"),
+    engine: z.enum(["google", "bing"]).optional().describe("The search engine (default: google)")
+}, async ({ siteUrl, days, minImpressions, limit, engine = "google" }) => {
     try {
-        const result = await seoInsights.detectCannibalization(siteUrl, { days, minImpressions, limit });
+        const result = engine === "google"
+            ? await seoInsights.detectCannibalization(siteUrl, { days, minImpressions, limit })
+            : await bingSeoInsights.detectCannibalization(siteUrl, { minImpressions, limit });
         return {
             content: [{ type: "text", text: JSON.stringify(result, null, 2) }]
         };
@@ -443,14 +469,17 @@ server.tool("seo_cannibalization", "Detect keyword cannibalization - multiple pa
         return formatError(error);
     }
 });
-server.tool("seo_low_ctr_opportunities", "Find queries ranking in positions 1-10 with low CTR (< 60% of benchmark). Great for title tag optimization.", {
+server.tool("seo_low_ctr_opportunities", "Find queries with low CTR relative to their ranking position. Great for title tag optimization.", {
     siteUrl: z.string().describe("The site URL"),
-    days: z.number().optional().describe("Number of days to analyze (default: 28)"),
+    days: z.number().optional().describe("Number of days (Google only, default: 28)"),
     minImpressions: z.number().optional().describe("Minimum impressions threshold (default: 500)"),
-    limit: z.number().optional().describe("Max results to return (default: 50)")
-}, async ({ siteUrl, days, minImpressions, limit }) => {
+    limit: z.number().optional().describe("Max issues to return (default: 50)"),
+    engine: z.enum(["google", "bing"]).optional().describe("The search engine (default: google)")
+}, async ({ siteUrl, days, minImpressions, limit, engine = "google" }) => {
     try {
-        const result = await seoInsights.findLowCTROpportunities(siteUrl, { days, minImpressions, limit });
+        const result = engine === "google"
+            ? await seoInsights.findLowCTROpportunities(siteUrl, { days, minImpressions, limit })
+            : await bingSeoInsights.findLowCTROpportunities(siteUrl, { minImpressions, limit });
         return {
             content: [{ type: "text", text: JSON.stringify(result, null, 2) }]
         };
@@ -461,11 +490,14 @@ server.tool("seo_low_ctr_opportunities", "Find queries ranking in positions 1-10
 });
 server.tool("seo_striking_distance", "Find keywords ranking in positions 8-15. These are high-priority targets to push to Page 1.", {
     siteUrl: z.string().describe("The site URL"),
-    days: z.number().optional().describe("Number of days to analyze (default: 28)"),
-    limit: z.number().optional().describe("Max results to return (default: 50)")
-}, async ({ siteUrl, days, limit }) => {
+    days: z.number().optional().describe("Number of days (Google only, default: 28)"),
+    limit: z.number().optional().describe("Max results to return (default: 50)"),
+    engine: z.enum(["google", "bing"]).optional().describe("The search engine (default: google)")
+}, async ({ siteUrl, days, limit, engine = "google" }) => {
     try {
-        const result = await seoInsights.findStrikingDistance(siteUrl, { days, limit });
+        const result = engine === "google"
+            ? await seoInsights.findStrikingDistance(siteUrl, { days, limit })
+            : await bingSeoInsights.findStrikingDistance(siteUrl, { limit });
         return {
             content: [{ type: "text", text: JSON.stringify(result, null, 2) }]
         };
@@ -506,12 +538,15 @@ server.tool("seo_brand_vs_nonbrand", "Analyze performance split between Brand an
 });
 server.tool("seo_quick_wins", "Find pages with queries ranking on page 2 (positions 11-20) that could be pushed to page 1", {
     siteUrl: z.string().describe("The site URL"),
-    days: z.number().optional().describe("Number of days to analyze (default: 28)"),
+    days: z.number().optional().describe("Number of days (Google only, default: 28)"),
     minImpressions: z.number().optional().describe("Minimum impressions threshold (default: 100)"),
-    limit: z.number().optional().describe("Max results to return (default: 20)")
-}, async ({ siteUrl, days, minImpressions, limit }) => {
+    limit: z.number().optional().describe("Max results to return (default: 20)"),
+    engine: z.enum(["google", "bing"]).optional().describe("The search engine (default: google)")
+}, async ({ siteUrl, days, minImpressions, limit, engine = "google" }) => {
     try {
-        const result = await seoInsights.findQuickWins(siteUrl, { days, minImpressions, limit });
+        const result = engine === "google"
+            ? await seoInsights.findQuickWins(siteUrl, { days, minImpressions, limit })
+            : await bingSeoInsights.findLowHangingFruit(siteUrl, { minImpressions, limit });
         return {
             content: [{ type: "text", text: JSON.stringify(result, null, 2) }]
         };
@@ -521,25 +556,30 @@ server.tool("seo_quick_wins", "Find pages with queries ranking on page 2 (positi
     }
 });
 // SEO Primitives (Atoms)
-server.tool("seo_primitive_ranking_bucket", "primitive: Get the ranking bucket for a specific position (e.g. Top 3, Page 1).", { position: z.number().describe("The ranking position") }, async ({ position }) => {
+server.tool("seo_primitive_ranking_bucket", "primitive: Get the ranking bucket for a specific position (e.g. Top 3, Page 1).", {
+    position: z.number().describe("The ranking position"),
+    engine: z.enum(["google", "bing"]).optional().describe("The search engine (optional)")
+}, async ({ position, engine }) => {
     return {
-        content: [{ type: "text", text: JSON.stringify(seoPrimitives.getRankingBucket(position), null, 2) }]
+        content: [{ type: "text", text: JSON.stringify(seoPrimitives.getRankingBucket(position, engine), null, 2) }]
     };
 });
 server.tool("seo_primitive_traffic_delta", "primitive: Calculate the delta between two traffic metrics (absolute and percentage).", {
     current: z.number().describe("Current value"),
-    previous: z.number().describe("Previous value")
-}, async ({ current, previous }) => {
+    previous: z.number().describe("Previous value"),
+    engine: z.enum(["google", "bing"]).optional().describe("The search engine (optional)")
+}, async ({ current, previous, engine }) => {
     return {
-        content: [{ type: "text", text: JSON.stringify(seoPrimitives.calculateTrafficDelta(current, previous), null, 2) }]
+        content: [{ type: "text", text: JSON.stringify(seoPrimitives.calculateTrafficDelta(current, previous, engine), null, 2) }]
     };
 });
 server.tool("seo_primitive_is_brand", "primitive: Check if a query is a brand query based on a regex pattern.", {
     query: z.string().describe("The search query"),
-    brandRegex: z.string().describe("Regex pattern to identify brand terms")
-}, async ({ query, brandRegex }) => {
+    brandRegex: z.string().describe("Regex pattern to identify brand terms"),
+    engine: z.enum(["google", "bing"]).optional().describe("The search engine (optional)")
+}, async ({ query, brandRegex, engine }) => {
     return {
-        content: [{ type: "text", text: JSON.stringify(seoPrimitives.isBrandQuery(query, brandRegex), null, 2) }]
+        content: [{ type: "text", text: JSON.stringify(seoPrimitives.isBrandQuery(query, brandRegex, engine), null, 2) }]
     };
 });
 server.tool("seo_primitive_is_cannibalized", "primitive: Check if two pages are competing for the same query based on their metrics.", {
@@ -549,10 +589,11 @@ server.tool("seo_primitive_is_cannibalized", "primitive: Check if two pages are
     pageA_clicks: z.number(),
     pageB_position: z.number(),
     pageB_impressions: z.number(),
-    pageB_clicks: z.number()
-}, async ({ query, pageA_position, pageA_impressions, pageA_clicks, pageB_position, pageB_impressions, pageB_clicks }) => {
-    const pageA = { position: pageA_position, impressions: pageA_impressions, clicks: pageA_clicks };
-    const pageB = { position: pageB_position, impressions: pageB_impressions, clicks: pageB_clicks };
+    pageB_clicks: z.number(),
+    engine: z.enum(["google", "bing"]).optional().describe("The search engine (optional)")
+}, async ({ query, pageA_position, pageA_impressions, pageA_clicks, pageB_position, pageB_impressions, pageB_clicks, engine }) => {
+    const pageA = { position: pageA_position, impressions: pageA_impressions, clicks: pageA_clicks, engine };
+    const pageB = { position: pageB_position, impressions: pageB_impressions, clicks: pageB_clicks, engine };
     return {
         content: [{ type: "text", text: JSON.stringify(seoPrimitives.isCannibalized(query, pageA, pageB), null, 2) }]
     };
@@ -597,6 +638,28 @@ server.tool("bing_sites_list", "List all sites verified in Bing Webmaster Tools"
         return formatError(error);
     }
 });
+server.tool("bing_sites_add", "Add a new site to Bing Webmaster Tools", { siteUrl: z.string().describe("The URL of the site to add") }, async ({ siteUrl }) => {
+    try {
+        const result = await bingSites.addSite(siteUrl);
+        return {
+            content: [{ type: "text", text: result }]
+        };
+    }
+    catch (error) {
+        return formatError(error);
+    }
+});
+server.tool("bing_sites_delete", "Remove a site from Bing Webmaster Tools", { siteUrl: z.string().describe("The URL of the site to remove") }, async ({ siteUrl }) => {
+    try {
+        const result = await bingSites.removeSite(siteUrl);
+        return {
+            content: [{ type: "text", text: result }]
+        };
+    }
+    catch (error) {
+        return formatError(error);
+    }
+});
 server.tool("bing_sitemaps_list", "List sitemaps for a Bing site", {
     siteUrl: z.string().describe("The URL of the site")
 }, async ({ siteUrl }) => {
@@ -624,6 +687,20 @@ server.tool("bing_sitemaps_submit", "Submit a sitemap to Bing Webmaster Tools",
         return formatError(error);
     }
 });
+server.tool("bing_sitemaps_delete", "Remove a sitemap from Bing Webmaster Tools", {
+    siteUrl: z.string().describe("The URL of the site"),
+    sitemapUrl: z.string().describe("The URL of the sitemap to remove")
+}, async ({ siteUrl, sitemapUrl }) => {
+    try {
+        const result = await bingSitemaps.deleteSitemap(siteUrl, sitemapUrl);
+        return {
+            content: [{ type: "text", text: result }]
+        };
+    }
+    catch (error) {
+        return formatError(error);
+    }
+});
 server.tool("bing_analytics_query", "Get query performance stats from Bing Webmaster Tools (Top Queries)", {
     siteUrl: z.string().describe("The URL of the site")
 }, async ({ siteUrl }) => {
@@ -1105,45 +1182,68 @@ server.resource("docs-bing-algorithm-updates", "docs://bing/algorithm-updates",
         }]
 }));
 // Prompts
-server.prompt("analyze-site-performance", { siteUrl: z.string().describe("The URL of the site to analyze") }, ({ siteUrl }) => ({
+server.prompt("analyze-site-performance", {
+    siteUrl: z.string().describe("The URL of the site to analyze"),
+    engine: z.enum(["google", "bing"]).optional().describe("The search engine to use (default: google)")
+}, ({ siteUrl, engine = "google" }) => ({
     messages: [{
             role: "user",
             content: {
                 type: "text",
-                text: `Please analyze the performance of the site ${siteUrl} for the last 28 days.
-        Use the 'analytics_performance_summary' tool to get high-level metrics, and 'analytics_query' to dig deeper into top queries and pages if needed.
-        Provide a summary of the site's health and any opportunities for improvement.`
+                text: `Please analyze the performance of the site ${siteUrl} on ${engine === 'google' ? 'Google' : 'Bing'} for the last 28 days.
+        ${engine === 'google'
+                    ? "Use the 'analytics_performance_summary' tool to get high-level metrics, and 'analytics_query' to dig deeper into top queries and pages if needed."
+                    : "Use the 'bing_analytics_query' tool to get query stats and 'bing_analytics_page' for page-level performance."}
+        Provide a summary of the site's health and any opportunities for improvement on ${engine === 'google' ? 'Google' : 'Bing'}.`
             }
         }]
 }));
-server.prompt("compare-performance", { siteUrl: z.string().describe("The URL of the site to analyze") }, ({ siteUrl }) => ({
+server.prompt("compare-performance", {
+    siteUrl: z.string().describe("The URL of the site to analyze"),
+    engine: z.enum(["google", "bing"]).optional().describe("The search engine to use (default: google)")
+}, ({ siteUrl, engine = "google" }) => ({
     messages: [{
             role: "user",
             content: {
                 type: "text",
-                text: `Compare the performance of ${siteUrl} for this week vs last week.
+                text: `Compare the performance of ${siteUrl} on ${engine === 'google' ? 'Google' : 'Bing'} for this week vs last week.
 
-Use the 'analytics_compare_periods' tool to compare the two periods:
+${engine === 'google'
+                    ? `Use the 'analytics_compare_periods' tool to compare the two periods:
 - Period 1 (this week): last 7 days ending 3 days ago (to account for data delay)
 - Period 2 (last week): the 7 days before that
 
 Analyze the changes in clicks, impressions, CTR, and position.
 Highlight any significant improvements or declines.
 If there are notable changes, use 'analytics_top_queries' to identify which queries are driving the change.`
+                    : `Use the 'bing_analytics_compare_periods' tool to compare the two periods.
+Define two 7-day ranges (e.g., current period and previous period).
+
+Analyze the changes in clicks, impressions, CTR, and position.
+Highlight any significant improvements or declines.
+Use 'bing_analytics_query' to identify which queries are driving changes in traffic.`}`
             }
         }]
 }));
-server.prompt("find-declining-pages", { siteUrl: z.string().describe("The URL of the site to analyze") }, ({ siteUrl }) => ({
+server.prompt("find-declining-pages", {
+    siteUrl: z.string().describe("The URL of the site to analyze"),
+    engine: z.enum(["google", "bing"]).optional().describe("The search engine to use (default: google)")
+}, ({ siteUrl, engine = "google" }) => ({
     messages: [{
             role: "user",
             content: {
                 type: "text",
-                text: `Find pages on ${siteUrl} that are losing traffic.
+                text: `Find pages on ${siteUrl} that are losing traffic on ${engine === 'google' ? 'Google' : 'Bing'}.
 
-Steps:
+${engine === 'google'
+                    ? `Steps:
 1. Use 'analytics_compare_periods' to compare this week vs last week overall
 2. Use 'analytics_query' with dimension 'page' to get page-level data for both periods
-3. Identify pages with significant click/impression drops
+3. Identify pages with significant click/impression drops`
+                    : `Steps:
+1. Use 'bing_analytics_compare_periods' to identify overall traffic direction.
+2. Use 'bing_analytics_page' to get top pages.
+3. Use 'bing_analytics_page_query' for specific pages to see which queries dropped.`}
 
 For each declining page, provide:
 - The URL
@@ -1152,25 +1252,24 @@ For each declining page, provide:
             }
         }]
 }));
-server.prompt("keyword-opportunities", { siteUrl: z.string().describe("The URL of the site to analyze") }, ({ siteUrl }) => ({
+server.prompt("keyword-opportunities", {
+    siteUrl: z.string().describe("The URL of the site to analyze"),
+    engine: z.enum(["google", "bing"]).optional().describe("The search engine to use (default: google)")
+}, ({ siteUrl, engine = "google" }) => ({
     messages: [{
             role: "user",
             content: {
                 type: "text",
-                text: `Find keyword opportunities for ${siteUrl}.
+                text: `Find keyword opportunities for ${siteUrl} on ${engine === 'google' ? 'Google' : 'Bing'}.
 
-Use 'analytics_top_queries' to get top queries, then analyze for:
+${engine === 'google'
+                    ? "Use 'analytics_top_queries' or 'seo_low_hanging_fruit' to find high-potential targets."
+                    : "Use 'bing_opportunity_finder' or 'bing_striking_distance' to find high-potential keywords."}
 
+Analyze for:
 1. **Low CTR, High Impressions**: Queries where you rank but don't get clicks
-   - These need better titles/meta descriptions
-   - Look for CTR < 2% with impressions > 100
-
-2. **High Position (>10), Good Impressions**: Queries not on page 1
-   - These are close to ranking well
-   - Small optimization could move them up
-
-3. **New Ranking Queries**: Queries that appeared recently
-   - Opportunities to create more content
+2. **High Position (>10), Good Impressions**: Queries not on page 1 (Striking Distance)
+3. **New Ranking Queries**: Queries that appeared recently (use comparison tools)
 
 Provide specific recommendations for the top 5 opportunities.`
             }
@@ -1178,17 +1277,18 @@ Provide specific recommendations for the top 5 opportunities.`
 }));
 server.prompt("new-content-impact", {
     siteUrl: z.string().describe("The URL of the site"),
-    pageUrl: z.string().describe("The URL of the new content to analyze")
-}, ({ siteUrl, pageUrl }) => ({
+    pageUrl: z.string().describe("The URL of the new content to analyze"),
+    engine: z.enum(["google", "bing"]).optional().describe("The search engine to use (default: google)")
+}, ({ siteUrl, pageUrl, engine = "google" }) => ({
     messages: [{
             role: "user",
             content: {
                 type: "text",
-                text: `Analyze the impact of new content at ${pageUrl} on site ${siteUrl}.
+                text: `Analyze the impact of new content at ${pageUrl} on site ${siteUrl} in ${engine === 'google' ? 'Google' : 'Bing'}.
 
-1. Use 'inspection_inspect' to check if the page is indexed
-2. Use 'analytics_query' with a page filter for this URL to get its performance data
-3. Identify which queries are driving traffic to this page
+1. Use '${engine === 'google' ? 'inspection_inspect' : 'bing_url_info'}' to check indexing status.
+2. Use '${engine === 'google' ? 'analytics_query' : 'bing_analytics_page_query'}' to get performance for this specific URL.
+3. Identify which queries are driving traffic to this page.
 
 Provide:
 - Indexing status
@@ -1198,53 +1298,54 @@ Provide:
             }
         }]
 }));
-server.prompt("mobile-vs-desktop", { siteUrl: z.string().describe("The URL of the site to analyze") }, ({ siteUrl }) => ({
+server.prompt("mobile-vs-desktop", {
+    siteUrl: z.string().describe("The URL of the site to analyze"),
+    engine: z.enum(["google", "bing"]).optional().describe("The search engine to use (default: google)")
+}, ({ siteUrl, engine = "google" }) => ({
     messages: [{
             role: "user",
             content: {
                 type: "text",
-                text: `Compare mobile vs desktop performance for ${siteUrl}.
+                text: `Compare mobile vs desktop performance for ${siteUrl} on ${engine === 'google' ? 'Google' : 'Bing'}.
 
-Use 'analytics_query' with dimension 'device' to get device-level metrics.
+${engine === 'google'
+                    ? "Use 'analytics_query' with dimension 'device' to get device-level metrics."
+                    : "Note: Bing Webmaster API provides limited native device breakdown via the public API, but check if 'bing_analytics_query' or 'bing_analytics_page' results show device distinctions if available."}
 
 Analyze:
-1. Click and impression distribution across devices
-2. CTR differences between mobile and desktop
+1. Click and impression distribution across devices (if data available)
+2. CTR differences
 3. Position ranking differences
 
-If there's a significant gap (e.g., mobile CTR much lower), investigate:
-- Use 'inspection_inspect' on key pages to check mobile usability
-- Recommend specific improvements
+If there's a significant gap, investigate:
+- Use '${engine === 'google' ? 'inspection_inspect' : 'bing_url_info'}' on key pages to check health/usability.
+- Recommend specific improvements.
 
 Provide a summary with actionable recommendations.`
             }
         }]
 }));
 server.prompt("site-health-check", {
-    siteUrl: z.string().optional().describe("Optional. The URL of a specific site to check. If omitted, checks all verified sites.")
-}, ({ siteUrl }) => ({
+    siteUrl: z.string().optional().describe("Optional. The URL of a specific site to check."),
+    engine: z.enum(["google", "bing"]).optional().describe("The search engine to use (default: google)")
+}, ({ siteUrl, engine = "google" }) => ({
     messages: [{
             role: "user",
             content: {
                 type: "text",
-                text: `Run a comprehensive health check${siteUrl ? ` for ${siteUrl}` : ' across all my verified sites'}.
+                text: `Run a comprehensive health check for ${siteUrl ? siteUrl : 'all verified sites'} on ${engine === 'google' ? 'Google' : 'Bing'}.
 
-Use the 'sites_health_check' tool${siteUrl ? ` with siteUrl '${siteUrl}'` : ' without a siteUrl to check all sites'}.
+Use the '${engine === 'google' ? 'sites_health_check' : 'bing_sites_health'}' tool.
 
 Then for each site in the results:
-
-1. **Summarize the status** (healthy / warning / critical) with a clear visual indicator.
-2. **Performance:** Report the week-over-week changes in clicks, impressions, CTR, and position.
-3. **Sitemaps:** Note any missing sitemaps, errors, or warnings.
-4. **Anomalies:** Highlight any traffic anomaly drops detected.
+1. **Summarize the status** (healthy / warning / critical).
+2. **Performance:** Report changes in clicks, impressions, CTR, and position.
+3. **Sitemaps:** Note any errors or warnings (use '${engine === 'google' ? 'sitemaps_list' : 'bing_crawl_issues'}').
+4. **Anomalies:** Highlight any traffic drops (use '${engine === 'google' ? 'analytics_anomalies' : 'bing_analytics_detect_anomalies'}').
 
 If any site has a 'critical' or 'warning' status:
-- List the specific issues found.
-- For critical traffic drops, use 'analytics_drop_attribution' to check if a Google algorithm update is the likely cause.
-- For sitemap errors, use 'sitemaps_list' to get detailed error information.
-- Provide 3 prioritized action items for each affected site.
-
-End with an overall portfolio summary and the single most important action to take right now.`
+- For critical drops, use '${engine === 'google' ? 'analytics_drop_attribution' : 'bing_analytics_drop_attribution'}'.
+- Provide 3 prioritized action items.`
             }
         }]
 }));
@@ -1272,7 +1373,7 @@ async function main() {
     const hasOAuthTokens = existsSync(tokenPath);
     if (!hasServiceAccount && !hasOAuthTokens) {
         console.error('\n╔══════════════════════════════════════════════════════════════╗');
-        console.error('║          🚀 Google Search Console MCP Server                 ║');
+        console.error('║                🚀 Search Console MCP                         ║');
         console.error('╚══════════════════════════════════════════════════════════════╝\n');
         console.error('❌ No authentication found.\n');
         console.error('💡 Please authorize with your Google Account:');
@@ -1284,7 +1385,7 @@ async function main() {
     }
     const transport = new StdioServerTransport();
     await server.connect(transport);
-    console.error("Google Search Console MCP Server running on stdio");
+    console.error("Search Console MCP running on stdio");
 }
 main().catch((error) => {
     console.error("Fatal error in main():", error);

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "search-console-mcp",
-  "version": "1.11.0",
+  "version": "1.11.1",
   "mcpName": "io.github.saurabhsharma2u/search-console-mcp",
   "description": "MCP server for Google Search and Bing Search APIs",
   "type": "module",