search-console-mcp 1.11.0 → 1.12.0

package/README.md

@@ -13,17 +13,23 @@ A Model Context Protocol (MCP) server that transforms how you interact with **Go
 ## Why use this?
 
 ### ❌ The Old Way
-1.  Open Search Console -> Performance Tab
-2.  Filter by "Last 28 days"
-3.  Export to CSV
-4.  Open in Excel/Sheets
-5.  Create a filter for "Position > 10" AND "Impressions > 1000"
-6.  Analyze manually to find opportunities
+1.  Open Google Search Console → Export CSV
+2.  Open Bing Webmaster Tools → Export CSV
+3.  Paste both into a spreadsheet
+4.  Manually compare keywords across engines
+5.  Switch between accounts for different clients
+6.  Repeat weekly
 
 ### ✅ The New Way
 **Just ask:**
 > "Find low-hanging fruit keywords (positions 11-20) with high impressions that I should optimize."
 
+> "Compare my Google and Bing performance — where am I leaving Bing traffic on the table?"
+
+> "Run a health check across all my sites and give me 3 actions for next week."
+
+**One server. Both engines. Multiple accounts. Zero spreadsheets.**
+
 ---
 ## 🎯 Magic Prompts
 
@@ -47,15 +53,21 @@ Copy and paste these into your MCP client (Claude Desktop, etc.) to see the inte
 #### ⚡ The Speed vs. Ranking Correlator
 > "Fetch the top 5 pages by impressions. For these pages, run a PageSpeed audit. Is there any correlation between low performance scores and recently declining positions?"
 
-#### 🔍 Multi-Engine Comparison
+#### 🔀 Multi-Engine Comparison
 > "Compare my performance between Google and Bing for the last 30 days. Which keywords are ranking better on Bing but have lower traffic on Google?"
 
+#### 🎯 Bing Opportunity Finder
+> "Show me keywords where I'm in the top 5 on Google but not ranking on Bing. These are my easy Bing wins."
+
+#### ⚠️ Google Dependency Check
+> "Am I too dependent on Google? Check my click share across both engines and flag any keywords where over 85% of traffic comes from Google."
+
 ---
 
 ## 🔐 Authentication (Desktop Flow)
 
 Search Console MCP uses a **Secure Desktop Flow**. This provides high-security, professional grade authentication for your Google account:
-- **Multi-Account Support**: Automatically detects and stores separate tokens for different Google accounts based on your email.
+- **Multi-Account Support**: Connect multiple Google and Bing accounts. The server automatically picks the right one for each site.
 - **System Keychain Primary**: Tokens are stored in your OS's native credential manager (macOS Keychain, Windows Credential Manager, or Linux Secret Service).
 - **AES-256-GCM Hardware-Bound Encryption**: Fallback storage is encrypted with AES-256-GCM using a key derived from your unique hardware machine ID. Tokens stolen from your machine cannot be decrypted on another computer.
 - **Silent Background Refresh**: Tokens auto-refresh silently when they expire.
@@ -112,16 +124,36 @@ To access Bing data, you simply need an API Key.
 
 ---
 
+## 👥 Multi-Account Management
+
+Manage multiple Google and Bing accounts from the CLI:
+
+```bash
+# List all connected accounts
+npx search-console-mcp accounts list
+
+# Remove an account
+npx search-console-mcp accounts remove --account=marketing@company.com
+
+# Add a site boundary to an account
+npx search-console-mcp accounts add-site --account=marketing@company.com --site=example.com
+```
+
+When your AI agent queries a site, the server automatically resolves which account to use. [Learn more →](https://searchconsolemcp.mintlify.app/getting-started/multi-account)
+
+---
+
 
 ## 🛡️ Fort Knox Security
 
 This MCP server implements a multi-layered security architecture:
 
 *   **Keychain Integration**: Primarily uses the **macOS Keychain**, **Windows Credential Manager**, or **libsecret (Linux)** to store tokens.
-*   **Hardware-Bound Vault**: Fallback tokens are stored in `~/.search-console-mcp-tokens.enc` and encrypted with **AES-256-GCM**.
+*   **Encrypted Config**: Account configuration is stored in `~/.search-console-mcp-config.enc` using **AES-256-GCM** encryption.
 *   **Machine Fingerprinting**: The encryption key is derived from your unique hardware UUID and OS user. The encrypted file is useless if moved to another machine.
 *   **Minimalist Storage**: Only the `refresh_token` and `expiry_date` are stored.
-*   **Strict Unix Permissions**: The fallback file is created with `mode 600` (read/write only by your user).
+*   **Legacy Support**: Automatically detects credentials from older versions (tokens files, environment variables).
+*   **Strict Unix Permissions**: Config files are created with `mode 600` (read/write only by your user).
 
 ---
 

package/dist/accounts.js

@@ -0,0 +1,209 @@
+import { loadConfig, removeAccount, updateAccount } from './common/auth/config.js';
+function parseFlags(args) {
+    const flags = {};
+    for (const arg of args) {
+        const match = arg.match(/^--([^=]+)=(.+)$/);
+        if (match) {
+            flags[match[1]] = match[2];
+        }
+    }
+    return flags;
+}
+function findAccountByAliasOrId(accounts, identifier) {
+    // Try exact ID match first
+    if (accounts[identifier])
+        return accounts[identifier];
+    // Then try alias match (case-insensitive)
+    return Object.values(accounts).find((a) => a.alias?.toLowerCase() === identifier.toLowerCase() || a.id === identifier);
+}
+export async function main(args) {
+    const subcommand = args[0] || 'list';
+    const flags = parseFlags(args.slice(1));
+    // Positional args (non-flag args after the subcommand)
+    const positional = args.slice(1).filter(a => !a.startsWith('--'));
+    if (subcommand === 'list') {
+        try {
+            const config = await loadConfig();
+            const accounts = Object.values(config.accounts);
+            if (accounts.length === 0) {
+                console.log(JSON.stringify({
+                    accounts: [],
+                    message: "No accounts connected.",
+                    resolution: {
+                        command: "search-console-mcp setup",
+                        google: "search-console-mcp setup --engine=google",
+                        bing: "search-console-mcp setup --engine=bing"
+                    },
+                    setup_instructions: {
+                        google: [
+                            "Run: search-console-mcp setup --engine=google",
+                            "Choose OAuth 2.0 login or Service Account",
+                            "Authorize in browser and select sites to restrict (or allow all)"
+                        ],
+                        bing: [
+                            "Run: search-console-mcp setup --engine=bing",
+                            "Get your API key from https://www.bing.com/webmasters/settings/api",
+                            "Enter the API key when prompted"
+                        ]
+                    }
+                }, null, 2));
+                return;
+            }
+            const siteRows = [];
+            for (const a of accounts) {
+                const alias = a.alias || '[Unnamed]';
+                const engine = a.engine === 'google' ? 'Google' : 'Bing';
+                if (!a.websites || a.websites.length === 0) {
+                    siteRows.push({
+                        site: '[All Sites Authorized]',
+                        account: alias,
+                        engine: engine,
+                        id: a.id
+                    });
+                }
+                else {
+                    for (const site of a.websites) {
+                        siteRows.push({
+                            site: site,
+                            account: alias,
+                            engine: engine,
+                            id: a.id
+                        });
+                    }
+                }
+            }
+            console.log(JSON.stringify({ accounts: siteRows }, null, 2));
+        }
+        catch (error) {
+            console.log(JSON.stringify({
+                error: "Failed to list accounts",
+                message: error.message
+            }, null, 2));
+        }
+        return;
+    }
+    if (subcommand === 'remove') {
+        // Flags (agent): --account=alias --site=url  |  Positional (human): remove <alias_or_site>
+        const identifier = flags['account'] || flags['id'] || positional[0];
+        const siteToRemove = flags['site'];
+        if (!identifier && !siteToRemove) {
+            console.log(JSON.stringify({
+                error: "Missing arguments",
+                message: "Provide --account=<alias|id> to remove an account, or --site=<url> to remove a specific site boundary.",
+                resolution: {
+                    by_account: "search-console-mcp accounts remove --account=<alias_or_id>",
+                    by_site: "search-console-mcp accounts remove --site=<siteUrl>"
+                }
+            }, null, 2));
+            return;
+        }
+        try {
+            const config = await loadConfig();
+            if (identifier) {
+                // Remove entire account by alias or ID
+                const account = findAccountByAliasOrId(config.accounts, identifier);
+                if (!account) {
+                    console.log(JSON.stringify({
+                        error: "Account not found",
+                        message: `No account matching '${identifier}' was found.`,
+                        resolution: "Run: search-console-mcp accounts list"
+                    }, null, 2));
+                    return;
+                }
+                await removeAccount(account.id);
+                console.log(JSON.stringify({
+                    success: true,
+                    message: `Account '${account.alias}' (${account.id}) removed successfully.`
+                }, null, 2));
+            }
+            else if (siteToRemove) {
+                // Remove a specific site boundary from whichever account owns it
+                let found = false;
+                for (const account of Object.values(config.accounts)) {
+                    if (account.websites?.includes(siteToRemove)) {
+                        account.websites = account.websites.filter((w) => w !== siteToRemove);
+                        await updateAccount(account);
+                        found = true;
+                        console.log(JSON.stringify({
+                            success: true,
+                            message: `Site '${siteToRemove}' removed from account '${account.alias}'.`
+                        }, null, 2));
+                        break;
+                    }
+                }
+                if (!found) {
+                    console.log(JSON.stringify({
+                        error: "Site not found",
+                        message: `No account has '${siteToRemove}' in its site boundaries.`,
+                        resolution: "Run: search-console-mcp accounts list"
+                    }, null, 2));
+                }
+            }
+        }
+        catch (error) {
+            console.log(JSON.stringify({
+                error: "Failed to remove",
+                message: error.message
+            }, null, 2));
+        }
+        return;
+    }
+    if (subcommand === 'add-site') {
+        // Flags (agent): --account=alias --site=url  |  Positional (human): add-site <alias> <site>
+        const identifier = flags['account'] || flags['id'] || positional[0];
+        const site = flags['site'] || positional[1];
+        if (!identifier || !site) {
+            console.log(JSON.stringify({
+                error: "Missing arguments",
+                message: "Both --account and --site are required.",
+                resolution: "search-console-mcp accounts add-site --account=<alias_or_id> --site=<siteUrl>"
+            }, null, 2));
+            return;
+        }
+        try {
+            const config = await loadConfig();
+            const account = findAccountByAliasOrId(config.accounts, identifier);
+            if (!account) {
+                console.log(JSON.stringify({
+                    error: "Account not found",
+                    message: `No account matching '${identifier}' was found.`,
+                    resolution: "Run: search-console-mcp accounts list"
+                }, null, 2));
+                return;
+            }
+            if (!account.websites)
+                account.websites = [];
+            if (!account.websites.includes(site)) {
+                account.websites.push(site);
+                await updateAccount(account);
+                console.log(JSON.stringify({
+                    success: true,
+                    message: `Site '${site}' added to account '${account.alias}'.`
+                }, null, 2));
+            }
+            else {
+                console.log(JSON.stringify({
+                    success: true,
+                    message: `Account '${account.alias}' already has '${site}' in its boundaries.`
+                }, null, 2));
+            }
+        }
+        catch (error) {
+            console.log(JSON.stringify({
+                error: "Failed to add site",
+                message: error.message
+            }, null, 2));
+        }
+        return;
+    }
+    console.log(JSON.stringify({
+        error: "Unknown command",
+        message: `'${subcommand}' is not a valid subcommand.`,
+        resolution: {
+            list: "search-console-mcp accounts list",
+            remove_account: "search-console-mcp accounts remove --account=<alias_or_id>",
+            remove_site: "search-console-mcp accounts remove --site=<siteUrl>",
+            add_site: "search-console-mcp accounts add-site --account=<alias_or_id> --site=<siteUrl>"
+        }
+    }, null, 2));
+}

package/dist/bing/client.js

@@ -1,3 +1,5 @@
+import { resolveAccount } from '../common/auth/resolver.js';
+import { loadConfig } from '../common/auth/config.js';
 export class BingClient {
     apiKey;
     baseUrl = 'https://ssl.bing.com/webmaster/api.svc/json';
@@ -35,29 +37,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, pageUrl) {
-        return this.request('GetPageQueryStats', { siteUrl, pageUrl }, true);
+    async getPageQueryStats(siteUrl, page) {
+        return this.request('GetPageQueryStats', { siteUrl, page });
     }
-    async submitSitemap(siteUrl, sitemapUrl) {
-        await this.request('SubmitSitemap', { siteUrl, sitemapUrl }, true);
+    async submitSitemap(siteUrl, feedUrl) {
+        await this.request('SubmitFeed', { siteUrl, feedUrl }, true);
     }
-    async getSitemaps(siteUrl) {
-        return this.request('GetSitemaps', { siteUrl }, true);
+    async deleteSitemap(siteUrl, feedUrl) {
+        await this.request('RemoveFeed', { siteUrl, feedUrl }, 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,32 +77,59 @@ 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;
-export async function getBingClient() {
-    if (cachedBingClient)
-        return cachedBingClient;
-    const apiKey = process.env.BING_API_KEY;
+let cachedBingClients = {};
+export async function getBingClient(siteUrl, accountId) {
+    // 1. Resolve Account
+    let apiKey;
+    let cacheKey;
+    if (accountId) {
+        const config = await loadConfig();
+        const account = config.accounts[accountId];
+        if (!account || account.engine !== 'bing') {
+            throw new Error(`Bing account ${accountId} not found.`);
+        }
+        apiKey = account.apiKey;
+        cacheKey = account.id;
+    }
+    else {
+        try {
+            const account = await resolveAccount(siteUrl || '', 'bing');
+            apiKey = account.apiKey;
+            cacheKey = account.id;
+        }
+        catch (error) {
+            // Fallback to environment variable for legacy support if resolution fails or no site specified
+            apiKey = process.env.BING_API_KEY;
+            cacheKey = 'env_fallback';
+            if (!apiKey) {
+                throw error; // Re-throw the resolution error if no ENV fallback either
+            }
+        }
+    }
+    if (cachedBingClients[cacheKey])
+        return cachedBingClients[cacheKey];
     if (!apiKey) {
-        throw new Error('Bing API Key not found. Please set BING_API_KEY environment variable or run setup.');
+        throw new Error('Bing API Key not found. Please run setup to add an account.');
     }
-    cachedBingClient = new BingClient(apiKey);
-    return cachedBingClient;
+    const client = new BingClient(apiKey);
+    cachedBingClients[cacheKey] = client;
+    return client;
 }

package/dist/bing/tools/analytics.js

@@ -1,37 +1,69 @@
 import { getBingClient } from '../client.js';
 /**
- * Get query performance stats for a Bing site.
+ * Get query performance stats for a Bing site with optional date filtering.
  */
-export async function getQueryStats(siteUrl) {
-    const client = await getBingClient();
-    return client.getQueryStats(siteUrl);
+export async function getQueryStats(siteUrl, startDate, endDate) {
+    const client = await getBingClient(siteUrl);
+    const stats = await client.getQueryStats(siteUrl);
+    if (!startDate && !endDate)
+        return stats;
+    const start = startDate ? new Date(startDate) : new Date(0);
+    const end = endDate ? new Date(endDate) : new Date();
+    return stats.filter(row => {
+        const d = new Date(row.Date);
+        return d >= start && d <= end;
+    });
 }
 /**
- * Get page performance stats (top pages) for a Bing site.
+ * Get page performance stats (top pages) for a Bing site with optional date filtering.
  */
-export async function getPageStats(siteUrl) {
-    const client = await getBingClient();
-    return client.getPageStats(siteUrl);
+export async function getPageStats(siteUrl, startDate, endDate) {
+    const client = await getBingClient(siteUrl);
+    const stats = await client.getPageStats(siteUrl);
+    if (!startDate && !endDate)
+        return stats;
+    const start = startDate ? new Date(startDate) : new Date(0);
+    const end = endDate ? new Date(endDate) : new Date();
+    return stats.filter(row => {
+        const d = new Date(row.Date);
+        return d >= start && d <= end;
+    });
 }
 /**
- * Get query stats for a specific page on a Bing site.
+ * Get query stats for a specific page on a Bing site with optional date filtering.
  */
-export async function getPageQueryStats(siteUrl, pageUrl) {
-    const client = await getBingClient();
-    return client.getPageQueryStats(siteUrl, pageUrl);
+export async function getPageQueryStats(siteUrl, pageUrl, startDate, endDate) {
+    const client = await getBingClient(siteUrl);
+    const stats = await client.getPageQueryStats(siteUrl, pageUrl);
+    if (!startDate && !endDate)
+        return stats;
+    const start = startDate ? new Date(startDate) : new Date(0);
+    const end = endDate ? new Date(endDate) : new Date();
+    return stats.filter(row => {
+        const d = new Date(row.Date);
+        return d >= start && d <= end;
+    });
 }
 /**
- * Get combined query and page performance stats.
+ * Get combined query and page performance stats with optional date filtering.
  */
-export async function getQueryPageStats(siteUrl) {
-    const client = await getBingClient();
-    return client.getQueryPageStats(siteUrl);
+export async function getQueryPageStats(siteUrl, startDate, endDate) {
+    const client = await getBingClient(siteUrl);
+    const stats = await client.getQueryPageStats(siteUrl);
+    if (!startDate && !endDate)
+        return stats;
+    const start = startDate ? new Date(startDate) : new Date(0);
+    const end = endDate ? new Date(endDate) : new Date();
+    return stats.filter(row => {
+        const d = new Date(row.Date);
+        return d >= start && d <= end;
+    });
 }
 /**
  * Get historical rank and traffic statistics for a site.
  */
 export async function getRankAndTrafficStats(siteUrl) {
-    const client = await getBingClient();
+    const client = await getBingClient(siteUrl);
     return client.getRankAndTrafficStats(siteUrl);
 }
 /**
@@ -119,3 +151,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/crawl.js

@@ -10,6 +10,6 @@ export async function getCrawlIssues(siteUrl) {
  * Get crawl statistics for a site.
  */
 export async function getCrawlStats(siteUrl) {
-    const client = await getBingClient();
+    const client = await getBingClient(siteUrl);
     return client.getCrawlStats(siteUrl);
 }

package/dist/bing/tools/inspection.js

@@ -3,6 +3,6 @@ import { getBingClient } from '../client.js';
  * Get detailed indexing and crawl information for a URL.
  */
 export async function getUrlInfo(siteUrl, url) {
-    const client = await getBingClient();
+    const client = await getBingClient(siteUrl);
     return client.getUrlInfo(siteUrl, url);
 }

package/dist/bing/tools/links.js

@@ -3,6 +3,6 @@ import { getBingClient } from '../client.js';
  * Get link counts for a site.
  */
 export async function getLinkCounts(siteUrl) {
-    const client = await getBingClient();
+    const client = await getBingClient(siteUrl);
     return client.getLinkCounts(siteUrl);
 }

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',