webmaster-mcp 0.1.0 → 0.1.1

package/dist/core/service.js

@@ -1,6 +1,6 @@
-import { normalizeError, WebmasterError } from './errors.js';
-import { validateSite, validateUrl, canonicalSite, range } from './validation.js';
 import { cacheKey } from './cache/index.js';
+import { normalizeError, WebmasterError } from './errors.js';
+import { canonicalSite, range, validateSite, validateUrl } from './validation.js';
 export class WebmasterService {
     providers;
     cache;
@@ -10,39 +10,119 @@ export class WebmasterService {
         this.cache = cache;
         this.providerFactory = providerFactory;
     }
-    selected(engines, account) { return this.providers.filter(p => (!engines || engines.includes(p.id)) && (!account || p.account === account)); }
-    oneAccount(rows, account) { if (account)
-        return rows; const chosen = new Map(); for (const row of rows) {
-        const current = chosen.get(row.engine);
-        if (!current || row.account === 'default')
-            chosen.set(row.engine, row.account ?? 'default');
-    } return rows.filter(row => (row.account ?? 'default') === chosen.get(row.engine)); }
-    async collect(capability, fn, engines, account) { if (this.providerFactory)
-        this.providers.splice(0, this.providers.length, ...this.providerFactory()); const selected = this.selected(engines, account); const settled = await Promise.allSettled(selected.map(async (p) => { if (!p.supports(capability))
-        throw new Error('UNSUPPORTED'); if (!await p.isAuthenticated()) {
-        if (engines?.includes(p.id) || account)
-            throw new WebmasterError('AUTH_FAILED', `${p.id}/${p.account} is not connected.`);
-        return [];
-    } return fn(p); })); const results = [], errors = []; settled.forEach((item, i) => { const p = selected[i]; if (item.status === 'fulfilled')
-        results.push(...item.value);
-    else
-        errors.push(item.reason?.message === 'UNSUPPORTED' ? { engine: p.id, account: p.account, code: 'UNSUPPORTED', message: `${capability} is not supported by ${p.id}.` } : normalizeError(p.id, p.account, item.reason)); }); return { results, errors }; }
-    async sites() { const data = await this.collect('sites', p => this.cached(p, '', 'sites', {}, 3600000, () => p.getSites())); const grouped = new Map(); for (const s of data.results) {
-        const id = canonicalSite(s.site);
-        const entry = grouped.get(id) ?? { site: id, engines: [], accounts: {} };
-        if (!entry.engines.includes(s.engine))
-            entry.engines.push(s.engine);
-        entry.accounts[s.engine] = [...(entry.accounts[s.engine] ?? []), s.account];
-        grouped.set(id, entry);
-    } return { results: [...grouped.values()], errors: data.errors }; }
-    async cached(p, site, operation, params, ttl, load) { const key = cacheKey(p.id, p.account, site, operation, params); const hit = this.cache.get(key); if (hit !== null)
-        return hit; const value = await load(); this.cache.set(key, value, ttl); return value; }
-    async metrics(operation, input, engines) { range.parse(input); validateSite(input.site); const id = canonicalSite(input.site); const data = await this.collect(operation, async (p) => { const sites = await this.cached(p, '', 'sites', {}, 3600000, () => p.getSites()); const owned = sites.find(s => canonicalSite(s.site) === id); if (!owned)
-        throw new WebmasterError('PERMISSION_DENIED', 'Site is not available in this account.'); const providerInput = { ...input, site: owned.site }; const rows = await this.cached(p, owned.site, operation, providerInput, 21600000, () => p[operation === 'performance' ? 'getPerformance' : operation === 'pages' ? 'getPages' : 'getQueries'](providerInput)); return rows.map(row => ({ ...row, site: id })); }, engines, input.account); data.results = this.oneAccount(data.results, input.account); if (input.sort)
-        data.results.sort((a, b) => (b[input.sort] ?? 0) - (a[input.sort] ?? 0)); if (input.limit)
-        data.results = data.results.slice(0, input.limit); return data; }
-    async sitemaps(site, engines, account) { validateSite(site); const id = canonicalSite(site); const data = await this.collect('sitemaps', async (p) => { const sites = await p.getSites(); const owned = sites.find(s => canonicalSite(s.site) === id); if (!owned)
-        throw new WebmasterError('PERMISSION_DENIED', 'Site is not available in this account.'); const rows = await this.cached(p, owned.site, 'sitemaps', {}, 1800000, () => p.getSitemaps(owned.site)); return rows.map(row => ({ ...row, site: id, account: p.account })); }, engines, account); data.results = this.oneAccount(data.results, account); return data; }
-    async inspect(site, url, engines, account) { validateUrl(site, url); const id = canonicalSite(site); const data = await this.collect('urlInspection', async (p) => { const sites = await p.getSites(); const owned = sites.find(s => canonicalSite(s.site) === id); if (!owned)
-        throw new WebmasterError('PERMISSION_DENIED', 'Site is not available in this account.'); const row = await this.cached(p, owned.site, 'inspect_url', { url }, 300000, () => p.inspectUrl(owned.site, url)); return [{ ...row, site: id, account: p.account }]; }, engines, account); data.results = this.oneAccount(data.results, account); return data; }
+    selected(engines, account) {
+        return this.providers.filter((p) => (!engines || engines.includes(p.id)) && (!account || p.account === account));
+    }
+    oneAccount(rows, account) {
+        if (account)
+            return rows;
+        const chosen = new Map();
+        for (const row of rows) {
+            const current = chosen.get(row.engine);
+            if (!current || row.account === 'default')
+                chosen.set(row.engine, row.account ?? 'default');
+        }
+        return rows.filter((row) => (row.account ?? 'default') === chosen.get(row.engine));
+    }
+    async collect(capability, fn, engines, account) {
+        if (this.providerFactory)
+            this.providers.splice(0, this.providers.length, ...this.providerFactory());
+        const selected = this.selected(engines, account);
+        const settled = await Promise.allSettled(selected.map(async (p) => {
+            if (!p.supports(capability))
+                throw new Error('UNSUPPORTED');
+            if (!(await p.isAuthenticated())) {
+                if (engines?.includes(p.id) || account)
+                    throw new WebmasterError('AUTH_FAILED', `${p.id}/${p.account} is not connected.`);
+                return [];
+            }
+            return fn(p);
+        }));
+        const results = [], errors = [];
+        settled.forEach((item, i) => {
+            const p = selected[i];
+            if (item.status === 'fulfilled')
+                results.push(...item.value);
+            else
+                errors.push(item.reason?.message === 'UNSUPPORTED'
+                    ? {
+                        engine: p.id,
+                        account: p.account,
+                        code: 'UNSUPPORTED',
+                        message: `${capability} is not supported by ${p.id}.`,
+                    }
+                    : normalizeError(p.id, p.account, item.reason));
+        });
+        return { results, errors };
+    }
+    async sites() {
+        const data = await this.collect('sites', (p) => this.cached(p, '', 'sites', {}, 3600000, () => p.getSites()));
+        const grouped = new Map();
+        for (const s of data.results) {
+            const id = canonicalSite(s.site);
+            const entry = grouped.get(id) ?? { site: id, engines: [], accounts: {} };
+            if (!entry.engines.includes(s.engine))
+                entry.engines.push(s.engine);
+            entry.accounts[s.engine] = [...(entry.accounts[s.engine] ?? []), s.account];
+            grouped.set(id, entry);
+        }
+        return { results: [...grouped.values()], errors: data.errors };
+    }
+    async cached(p, site, operation, params, ttl, load) {
+        const key = cacheKey(p.id, p.account, site, operation, params);
+        const hit = this.cache.get(key);
+        if (hit !== null)
+            return hit;
+        const value = await load();
+        this.cache.set(key, value, ttl);
+        return value;
+    }
+    async metrics(operation, input, engines) {
+        range.parse(input);
+        validateSite(input.site);
+        const id = canonicalSite(input.site);
+        const data = await this.collect(operation, async (p) => {
+            const sites = await this.cached(p, '', 'sites', {}, 3600000, () => p.getSites());
+            const owned = sites.find((s) => canonicalSite(s.site) === id);
+            if (!owned)
+                throw new WebmasterError('PERMISSION_DENIED', 'Site is not available in this account.');
+            const providerInput = { ...input, site: owned.site };
+            const rows = await this.cached(p, owned.site, operation, providerInput, 21600000, () => p[operation === 'performance' ? 'getPerformance' : operation === 'pages' ? 'getPages' : 'getQueries'](providerInput));
+            return rows.map((row) => ({ ...row, site: id }));
+        }, engines, input.account);
+        data.results = this.oneAccount(data.results, input.account);
+        if (input.sort)
+            data.results.sort((a, b) => (b[input.sort] ?? 0) - (a[input.sort] ?? 0));
+        if (input.limit)
+            data.results = data.results.slice(0, input.limit);
+        return data;
+    }
+    async sitemaps(site, engines, account) {
+        validateSite(site);
+        const id = canonicalSite(site);
+        const data = await this.collect('sitemaps', async (p) => {
+            const sites = await p.getSites();
+            const owned = sites.find((s) => canonicalSite(s.site) === id);
+            if (!owned)
+                throw new WebmasterError('PERMISSION_DENIED', 'Site is not available in this account.');
+            const rows = await this.cached(p, owned.site, 'sitemaps', {}, 1800000, () => p.getSitemaps(owned.site));
+            return rows.map((row) => ({ ...row, site: id, account: p.account }));
+        }, engines, account);
+        data.results = this.oneAccount(data.results, account);
+        return data;
+    }
+    async inspect(site, url, engines, account) {
+        validateUrl(site, url);
+        const id = canonicalSite(site);
+        const data = await this.collect('urlInspection', async (p) => {
+            const sites = await p.getSites();
+            const owned = sites.find((s) => canonicalSite(s.site) === id);
+            if (!owned)
+                throw new WebmasterError('PERMISSION_DENIED', 'Site is not available in this account.');
+            const row = await this.cached(p, owned.site, 'inspect_url', { url }, 300000, () => p.inspectUrl(owned.site, url));
+            return [{ ...row, site: id, account: p.account }];
+        }, engines, account);
+        data.results = this.oneAccount(data.results, account);
+        return data;
+    }
 }

package/dist/core/validation.js

@@ -1,35 +1,56 @@
 import { z } from 'zod';
 import { WebmasterError } from './errors.js';
 export const date = z.iso.date();
-export const range = z.object({ site: z.string().min(1), from: date, to: date, account: z.string().optional(), limit: z.number().int().min(1).max(25000).optional(), sort: z.enum(['clicks', 'impressions', 'ctr', 'position']).optional() }).refine(x => x.from <= x.to, 'from must be before to');
-export function validateSite(site) { if (/^sc-domain:[a-z0-9.-]+$/i.test(site))
-    return site; try {
+export const range = z
+    .object({
+    site: z.string().min(1),
+    from: date,
+    to: date,
+    account: z.string().optional(),
+    limit: z.number().int().min(1).max(25000).optional(),
+    sort: z.enum(['clicks', 'impressions', 'ctr', 'position']).optional(),
+})
+    .refine((x) => x.from <= x.to, 'from must be before to');
+export function validateSite(site) {
+    if (/^sc-domain:[a-z0-9.-]+$/i.test(site))
+        return site;
+    try {
+        const u = new URL(site);
+        if (!['http:', 'https:'].includes(u.protocol) || !u.hostname || u.username || u.password || u.hash)
+            throw new Error();
+        return site;
+    }
+    catch {
+        throw new WebmasterError('INVALID_INPUT', 'Site must be an HTTP(S) property URL or sc-domain property.');
+    }
+}
+export function canonicalSite(site) {
+    validateSite(site);
+    if (site.startsWith('sc-domain:'))
+        return site.toLowerCase();
     const u = new URL(site);
-    if (!['http:', 'https:'].includes(u.protocol) || !u.hostname || u.username || u.password || u.hash)
-        throw new Error();
-    return site;
+    u.hash = '';
+    return u.href;
 }
-catch {
-    throw new WebmasterError('INVALID_INPUT', 'Site must be an HTTP(S) property URL or sc-domain property.');
-} }
-export function canonicalSite(site) { validateSite(site); if (site.startsWith('sc-domain:'))
-    return site.toLowerCase(); const u = new URL(site); u.hash = ''; return u.href; }
-export function validateUrl(site, url) { validateSite(site); try {
-    const target = new URL(url);
-    if (!['http:', 'https:'].includes(target.protocol) || target.username || target.password || target.hash)
-        throw new Error();
-    if (site.startsWith('sc-domain:')) {
-        const domain = site.slice(10);
-        if (target.hostname !== domain && !target.hostname.endsWith(`.${domain}`))
+export function validateUrl(site, url) {
+    validateSite(site);
+    try {
+        const target = new URL(url);
+        if (!['http:', 'https:'].includes(target.protocol) || target.username || target.password || target.hash)
             throw new Error();
+        if (site.startsWith('sc-domain:')) {
+            const domain = site.slice(10);
+            if (target.hostname !== domain && !target.hostname.endsWith(`.${domain}`))
+                throw new Error();
+        }
+        else {
+            const property = new URL(site);
+            if (target.origin !== property.origin || !target.pathname.startsWith(property.pathname))
+                throw new Error();
+        }
+        return target.href;
     }
-    else {
-        const property = new URL(site);
-        if (target.origin !== property.origin || !target.pathname.startsWith(property.pathname))
-            throw new Error();
+    catch {
+        throw new WebmasterError('INVALID_INPUT', 'URL must be HTTP(S) and belong to the selected site.');
     }
-    return target.href;
 }
-catch {
-    throw new WebmasterError('INVALID_INPUT', 'URL must be HTTP(S) and belong to the selected site.');
-} }

package/dist/index.d.ts

@@ -1,8 +1,8 @@
-export * from './core/types/index.js';
 export * from './core/analysis/index.js';
-export * from './core/service.js';
-export * from './core/cache/index.js';
 export * from './core/auth/store.js';
-export { GoogleProvider } from './providers/google/index.js';
+export * from './core/cache/index.js';
+export * from './core/service.js';
+export * from './core/types/index.js';
 export { BingProvider } from './providers/bing/index.js';
+export { GoogleProvider } from './providers/google/index.js';
 export { YandexProvider } from './providers/yandex/index.js';

package/dist/index.js

@@ -1,8 +1,8 @@
-export * from './core/types/index.js';
 export * from './core/analysis/index.js';
-export * from './core/service.js';
-export * from './core/cache/index.js';
 export * from './core/auth/store.js';
-export { GoogleProvider } from './providers/google/index.js';
+export * from './core/cache/index.js';
+export * from './core/service.js';
+export * from './core/types/index.js';
 export { BingProvider } from './providers/bing/index.js';
+export { GoogleProvider } from './providers/google/index.js';
 export { YandexProvider } from './providers/yandex/index.js';

package/dist/mcp/index.js

@@ -1,4 +1,15 @@
 import { createMcpServer } from 'mcponce';
 import { createContext } from '../server/context.js';
 import { registerTools } from './tools/index.js';
-export function createServer() { const { service } = createContext(); const app = createMcpServer({ name: 'webmaster-mcp', version: '0.1.0', background: process.env.MCP_BACKGROUND !== '0', coerceInputs: true, dataDir: process.env.WEBMASTER_MCP_DATA_DIR }); registerTools(app, service); return app; }
+export function createServer() {
+    const { service } = createContext();
+    const app = createMcpServer({
+        name: 'webmaster-mcp',
+        version: '0.1.0',
+        background: process.env.MCP_BACKGROUND !== '0',
+        coerceInputs: true,
+        dataDir: process.env.WEBMASTER_MCP_DATA_DIR,
+    });
+    registerTools(app, service);
+    return app;
+}

package/dist/mcp/tools/index.js

@@ -1,15 +1,96 @@
 import { z } from 'zod';
-import { compareEngines, findCtrOpportunities, findNearFirstPage, findDecliningPages, findDecliningQueries, findImpressionGrowthWithoutClicks, findEngineGaps, findIndexingGaps } from '../../core/analysis/index.js';
+import { compareEngines, findCtrOpportunities, findDecliningPages, findDecliningQueries, findEngineGaps, findImpressionGrowthWithoutClicks, findIndexingGaps, findNearFirstPage, } from '../../core/analysis/index.js';
 const engines = z.array(z.enum(['google', 'bing', 'yandex'])).optional();
 const base = { site: z.string(), from: z.iso.date(), to: z.iso.date(), engines, account: z.string().optional() };
-function previousRange(from, to) { const days = (Date.parse(to) - Date.parse(from)) / 86400000 + 1; const end = new Date(Date.parse(from) - 86400000); const start = new Date(end.getTime() - (days - 1) * 86400000); return { from: start.toISOString().slice(0, 10), to: end.toISOString().slice(0, 10) }; }
+function previousRange(from, to) {
+    const days = (Date.parse(to) - Date.parse(from)) / 86400000 + 1;
+    const end = new Date(Date.parse(from) - 86400000);
+    const start = new Date(end.getTime() - (days - 1) * 86400000);
+    return { from: start.toISOString().slice(0, 10), to: end.toISOString().slice(0, 10) };
+}
 export function registerTools(app, service) {
-    app.tool({ name: 'sites', description: 'List normalized sites across connected webmaster accounts.', handler: () => service.sites() });
+    app.tool({
+        name: 'sites',
+        description: 'List normalized sites across connected webmaster accounts.',
+        handler: () => service.sites(),
+    });
     for (const operation of ['performance', 'queries', 'pages'])
-        app.tool({ name: operation, description: `Get normalized ${operation} metrics with partial provider errors.`, inputSchema: z.object({ ...base, limit: z.number().int().min(1).max(25000).optional(), sort: z.enum(['clicks', 'impressions', 'ctr', 'position']).optional() }), handler: (a) => service.metrics(operation, a, a.engines) });
-    app.tool({ name: 'sitemaps', description: 'List submitted sitemaps for a verified site.', inputSchema: z.object({ site: z.string(), engines, account: z.string().optional() }), handler: (a) => service.sitemaps(a.site, a.engines, a.account) });
-    app.tool({ name: 'inspect_url', description: 'Inspect URL indexing where provider API offers evidence; unknown means unverified.', inputSchema: z.object({ site: z.string(), url: z.url(), engines, account: z.string().optional() }), handler: (a) => service.inspect(a.site, a.url, a.engines, a.account) });
-    app.tool({ name: 'compare_engines', description: 'Compare provider-reported metrics without equating their counting semantics.', inputSchema: z.object(base), handler: async (a) => { const data = await service.metrics('performance', a, a.engines); return { ...data, results: compareEngines(data.results) }; } });
-    app.tool({ name: 'opportunities', description: 'Deterministic CTR, ranking and trend candidates with supporting metrics.', inputSchema: z.object({ ...base, minImpressions: z.number().min(0).default(100), maxCtr: z.number().min(0).max(1).default(0.02), declineFraction: z.number().min(0).max(1).default(0.2) }), handler: async (a) => { const prior = previousRange(a.from, a.to); const [queries, pages, oldQueries, oldPages] = await Promise.all([service.metrics('queries', a, a.engines), service.metrics('pages', a, a.engines), service.metrics('queries', { ...a, ...prior }, a.engines), service.metrics('pages', { ...a, ...prior }, a.engines)]); return { results: [...findCtrOpportunities(queries.results, { minImpressions: a.minImpressions, maxCtr: a.maxCtr }), ...findNearFirstPage(queries.results), ...findDecliningPages(pages.results, oldPages.results, a.declineFraction), ...findDecliningQueries(queries.results, oldQueries.results, a.declineFraction), ...findImpressionGrowthWithoutClicks(queries.results, oldQueries.results)], errors: [...queries.errors, ...pages.errors, ...oldQueries.errors, ...oldPages.errors] }; } });
-    app.tool({ name: 'indexing_gaps', description: 'Find verified indexing differences for supplied URLs and search visibility gaps. Missing performance rows are not indexing proof.', inputSchema: z.object({ ...base, urls: z.array(z.url()).max(20).optional() }), handler: async (a) => { const pageData = await service.metrics('pages', a, a.engines); const selected = (a.engines ?? ['google', 'bing', 'yandex']).filter(engine => !pageData.errors.some(e => e.engine === engine)); const inspected = await Promise.all((a.urls ?? []).map((url) => service.inspect(a.site, url, a.engines, a.account))); return { results: { visibilityGaps: findEngineGaps(pageData.results, selected), verifiedIndexingGaps: findIndexingGaps(inspected.flatMap(x => x.results)), inspections: inspected.flatMap(x => x.results) }, errors: [...pageData.errors, ...inspected.flatMap(x => x.errors)] }; } });
+        app.tool({
+            name: operation,
+            description: `Get normalized ${operation} metrics with partial provider errors.`,
+            inputSchema: z.object({
+                ...base,
+                limit: z.number().int().min(1).max(25000).optional(),
+                sort: z.enum(['clicks', 'impressions', 'ctr', 'position']).optional(),
+            }),
+            handler: (a) => service.metrics(operation, a, a.engines),
+        });
+    app.tool({
+        name: 'sitemaps',
+        description: 'List submitted sitemaps for a verified site.',
+        inputSchema: z.object({ site: z.string(), engines, account: z.string().optional() }),
+        handler: (a) => service.sitemaps(a.site, a.engines, a.account),
+    });
+    app.tool({
+        name: 'inspect_url',
+        description: 'Inspect URL indexing where provider API offers evidence; unknown means unverified.',
+        inputSchema: z.object({ site: z.string(), url: z.url(), engines, account: z.string().optional() }),
+        handler: (a) => service.inspect(a.site, a.url, a.engines, a.account),
+    });
+    app.tool({
+        name: 'compare_engines',
+        description: 'Compare provider-reported metrics without equating their counting semantics.',
+        inputSchema: z.object(base),
+        handler: async (a) => {
+            const data = await service.metrics('performance', a, a.engines);
+            return { ...data, results: compareEngines(data.results) };
+        },
+    });
+    app.tool({
+        name: 'opportunities',
+        description: 'Deterministic CTR, ranking and trend candidates with supporting metrics.',
+        inputSchema: z.object({
+            ...base,
+            minImpressions: z.number().min(0).default(100),
+            maxCtr: z.number().min(0).max(1).default(0.02),
+            declineFraction: z.number().min(0).max(1).default(0.2),
+        }),
+        handler: async (a) => {
+            const prior = previousRange(a.from, a.to);
+            const [queries, pages, oldQueries, oldPages] = await Promise.all([
+                service.metrics('queries', a, a.engines),
+                service.metrics('pages', a, a.engines),
+                service.metrics('queries', { ...a, ...prior }, a.engines),
+                service.metrics('pages', { ...a, ...prior }, a.engines),
+            ]);
+            return {
+                results: [
+                    ...findCtrOpportunities(queries.results, { minImpressions: a.minImpressions, maxCtr: a.maxCtr }),
+                    ...findNearFirstPage(queries.results),
+                    ...findDecliningPages(pages.results, oldPages.results, a.declineFraction),
+                    ...findDecliningQueries(queries.results, oldQueries.results, a.declineFraction),
+                    ...findImpressionGrowthWithoutClicks(queries.results, oldQueries.results),
+                ],
+                errors: [...queries.errors, ...pages.errors, ...oldQueries.errors, ...oldPages.errors],
+            };
+        },
+    });
+    app.tool({
+        name: 'indexing_gaps',
+        description: 'Find verified indexing differences for supplied URLs and search visibility gaps. Missing performance rows are not indexing proof.',
+        inputSchema: z.object({ ...base, urls: z.array(z.url()).max(20).optional() }),
+        handler: async (a) => {
+            const pageData = await service.metrics('pages', a, a.engines);
+            const selected = (a.engines ?? ['google', 'bing', 'yandex']).filter((engine) => !pageData.errors.some((e) => e.engine === engine));
+            const inspected = await Promise.all((a.urls ?? []).map((url) => service.inspect(a.site, url, a.engines, a.account)));
+            return {
+                results: {
+                    visibilityGaps: findEngineGaps(pageData.results, selected),
+                    verifiedIndexingGaps: findIndexingGaps(inspected.flatMap((x) => x.results)),
+                    inspections: inspected.flatMap((x) => x.results),
+                },
+                errors: [...pageData.errors, ...inspected.flatMap((x) => x.errors)],
+            };
+        },
+    });
 }

package/dist/providers/bing/index.js

@@ -1,8 +1,8 @@
+import { secretPrompt } from '../../core/auth/prompt.js';
 import { WebmasterError } from '../../core/errors.js';
-import { providerScheduler, jsonFetch } from '../../core/scheduler.js';
-import { metric, finite } from '../../core/normalize/index.js';
+import { finite, metric } from '../../core/normalize/index.js';
+import { jsonFetch, providerScheduler } from '../../core/scheduler.js';
 import { validateSite } from '../../core/validation.js';
-import { secretPrompt } from '../../core/auth/prompt.js';
 export class BingProvider {
     store;
     account;
@@ -14,18 +14,72 @@ export class BingProvider {
         this.account = account;
         this.fetcher = fetcher;
     }
-    supports(c) { return ['sites', 'performance', 'queries', 'pages', 'sitemaps'].includes(c); }
-    async authenticate() { const key = await secretPrompt('Bing Webmaster API key: '); if (!key)
-        throw new WebmasterError('INVALID_INPUT', 'Empty Bing API key.'); await this.store.set('bing', this.account, { apiKey: key }); }
-    async isAuthenticated() { return !!(await this.store.get('bing', this.account)); }
-    async request(method, params = {}) { const credential = await this.store.get('bing', this.account); if (!credential?.apiKey)
-        throw new WebmasterError('AUTH_FAILED', 'Bing is not connected. Run auth bing.'); const url = new URL(`https://ssl.bing.com/webmaster/api.svc/json/${method}`); url.searchParams.set('apikey', credential.apiKey); for (const [k, v] of Object.entries(params))
-        url.searchParams.set(k, v); return this.scheduler.run(async () => { const data = await jsonFetch(this.fetcher, url.href); if (data?.ErrorCode)
-        throw new WebmasterError(data.ErrorCode === 3 ? 'AUTH_FAILED' : 'UPSTREAM_ERROR', 'Bing rejected the request.'); return data.d; }); }
-    async getSites() { const rows = await this.request('GetUserSites'); return (rows ?? []).filter((x) => x.IsVerified).map((x) => ({ site: x.Url, engine: this.id, account: this.account })); }
-    async stats(input, method, dimension) { validateSite(input.site); const rows = await this.request(method, { siteUrl: input.site }); return (rows ?? []).map((r) => { const match = String(r.Date ?? '').match(/\/Date\((\d+)/); const date = match ? new Date(Number(match[1])).toISOString().slice(0, 10) : String(r.Date ?? '').slice(0, 10); return metric({ engine: this.id, site: input.site, account: this.account, date, ...(dimension ? { [dimension]: r.Query } : {}), clicks: finite(r.Clicks), impressions: finite(r.Impressions), position: finite(r.AvgImpressionPosition) }); }).filter((r) => r.date && r.date >= input.from && r.date <= input.to).slice(0, input.limit ?? 25000); }
-    getPerformance(input) { return this.stats(input, 'GetRankAndTrafficStats'); }
-    getPages(input) { return this.stats(input, 'GetPageStats', 'page'); }
-    getQueries(input) { return this.stats(input, 'GetQueryStats', 'query'); }
-    async getSitemaps(site) { validateSite(site); const rows = await this.request('GetFeeds', { siteUrl: site }); return (rows ?? []).map((r) => ({ engine: this.id, site, url: r.Url ?? r.FeedUrl, status: r.Status })); }
+    supports(c) {
+        return ['sites', 'performance', 'queries', 'pages', 'sitemaps'].includes(c);
+    }
+    async authenticate() {
+        const key = await secretPrompt('Bing Webmaster API key: ');
+        if (!key)
+            throw new WebmasterError('INVALID_INPUT', 'Empty Bing API key.');
+        await this.store.set('bing', this.account, { apiKey: key });
+    }
+    async isAuthenticated() {
+        return !!(await this.store.get('bing', this.account));
+    }
+    async request(method, params = {}) {
+        const credential = (await this.store.get('bing', this.account));
+        if (!credential?.apiKey)
+            throw new WebmasterError('AUTH_FAILED', 'Bing is not connected. Run auth bing.');
+        const url = new URL(`https://ssl.bing.com/webmaster/api.svc/json/${method}`);
+        url.searchParams.set('apikey', credential.apiKey);
+        for (const [k, v] of Object.entries(params))
+            url.searchParams.set(k, v);
+        return this.scheduler.run(async () => {
+            const data = await jsonFetch(this.fetcher, url.href);
+            if (data?.ErrorCode)
+                throw new WebmasterError(data.ErrorCode === 3 ? 'AUTH_FAILED' : 'UPSTREAM_ERROR', 'Bing rejected the request.');
+            return data.d;
+        });
+    }
+    async getSites() {
+        const rows = await this.request('GetUserSites');
+        return (rows ?? [])
+            .filter((x) => x.IsVerified)
+            .map((x) => ({ site: x.Url, engine: this.id, account: this.account }));
+    }
+    async stats(input, method, dimension) {
+        validateSite(input.site);
+        const rows = await this.request(method, { siteUrl: input.site });
+        return (rows ?? [])
+            .map((r) => {
+            const match = String(r.Date ?? '').match(/\/Date\((\d+)/);
+            const date = match ? new Date(Number(match[1])).toISOString().slice(0, 10) : String(r.Date ?? '').slice(0, 10);
+            return metric({
+                engine: this.id,
+                site: input.site,
+                account: this.account,
+                date,
+                ...(dimension ? { [dimension]: r.Query } : {}),
+                clicks: finite(r.Clicks),
+                impressions: finite(r.Impressions),
+                position: finite(r.AvgImpressionPosition),
+            });
+        })
+            .filter((r) => r.date && r.date >= input.from && r.date <= input.to)
+            .slice(0, input.limit ?? 25000);
+    }
+    getPerformance(input) {
+        return this.stats(input, 'GetRankAndTrafficStats');
+    }
+    getPages(input) {
+        return this.stats(input, 'GetPageStats', 'page');
+    }
+    getQueries(input) {
+        return this.stats(input, 'GetQueryStats', 'query');
+    }
+    async getSitemaps(site) {
+        validateSite(site);
+        const rows = await this.request('GetFeeds', { siteUrl: site });
+        return (rows ?? []).map((r) => ({ engine: this.id, site, url: r.Url ?? r.FeedUrl, status: r.Status }));
+    }
 }