webmaster-mcp 0.1.0 → 0.1.1

package/dist/cli/index.js

@@ -1,49 +1,97 @@
 #!/usr/bin/env node
-import { createContext } from '../server/context.js';
-import { GoogleProvider } from '../providers/google/index.js';
+import { WebmasterError } from '../core/errors.js';
+import { createServer } from '../mcp/index.js';
 import { BingProvider } from '../providers/bing/index.js';
+import { GoogleProvider } from '../providers/google/index.js';
 import { YandexProvider } from '../providers/yandex/index.js';
-import { createServer } from '../mcp/index.js';
-import { WebmasterError } from '../core/errors.js';
-async function main() { const args = process.argv.slice(2); const command = args[0] ?? 'mcp'; if (command === 'mcp' || args.includes('--mcponce-background') || process.env.MCPONCE_BACKGROUND_SERVER === '1') {
-    await createServer().run();
-    return;
-} const { service, store, accounts } = createContext(); const nameIndex = args.indexOf('--name'); const name = nameIndex >= 0 ? args[nameIndex + 1] ?? 'default' : 'default'; if (!/^[A-Za-z0-9_-]{1,40}$/.test(name))
-    throw new Error('Invalid account name.'); if (command === 'sites') {
-    process.stdout.write(`${JSON.stringify(await service.sites(), null, 2)}\n`);
-    return;
-} if (command !== 'auth')
-    throw new Error('Usage: webmaster-mcp [mcp|sites|auth]'); const action = args[1]; if (action === 'status') {
-    for (const engine of ['google', 'bing', 'yandex'])
-        for (const account of accounts.names(engine)) {
-            const connected = !!await store.get(engine, account);
-            process.stdout.write(`${engine.padEnd(7)} ${account.padEnd(12)} ${connected ? '✓ connected' : '✗ not connected'}\n`);
-        }
-    return;
-} if (action === 'logout') {
-    const engine = args[2];
-    if (!['google', 'bing', 'yandex'].includes(engine))
-        throw new Error('Choose google, bing, or yandex.');
-    await accounts.remove(engine, name);
-    process.stdout.write(`${engine}/${name} disconnected.\n`);
-    return;
-} if (action === 'google') {
-    await new GoogleProvider(store, name, fetch, args.includes('--write')).authenticate();
-    accounts.add('google', name);
-}
-else if (action === 'bing') {
-    await new BingProvider(store, name).authenticate();
-    accounts.add('bing', name);
-}
-else if (action === 'yandex') {
-    await new YandexProvider(store, name).authenticate();
-    accounts.add('yandex', name);
+import { createContext } from '../server/context.js';
+function printHelp() {
+    process.stdout.write(`webmaster-mcp v0.1.0
+Unified local-first MCP server for Google Search Console, Bing Webmaster Tools, and Yandex Webmaster.
+
+Usage:
+  webmaster-mcp [command] [options]
+
+Commands:
+  mcp                     Start the MCP server over stdio
+  sites                   List all verified properties across connected engines
+  auth google [--write]   Authenticate with Google Search Console via browser OAuth
+  auth bing               Authenticate with Bing Webmaster Tools API key
+  auth yandex             Authenticate with Yandex Webmaster via OAuth token
+  auth status             Show connection status for all search engines
+  auth logout <engine>    Disconnect an engine (google | bing | yandex)
+  help, --help, -h        Show this help message
+
+Options:
+  --name <account>        Account profile name (default: "default")
+  --write                 Request read/write scopes for Google OAuth
+\n`);
 }
-else
-    throw new Error('Usage: webmaster-mcp auth [google|bing|yandex|status|logout]'); process.stdout.write(`${action}/${name} connected.\n`); }
-main().catch(error => { if (error instanceof WebmasterError) {
-    process.stderr.write(`${error.code}: ${error.message}\n`);
+async function main() {
+    const args = process.argv.slice(2);
+    if (args.length === 0 || args.includes('--help') || args.includes('-h') || args[0] === 'help') {
+        if (args.includes('--mcponce-background') || process.env.MCPONCE_BACKGROUND_SERVER === '1') {
+            await createServer().run();
+            return;
+        }
+        printHelp();
+        return;
+    }
+    const command = args[0];
+    if (command === 'mcp' || args.includes('--mcponce-background') || process.env.MCPONCE_BACKGROUND_SERVER === '1') {
+        await createServer().run();
+        return;
+    }
+    const { service, store, accounts } = createContext();
+    const nameIndex = args.indexOf('--name');
+    const name = nameIndex >= 0 ? (args[nameIndex + 1] ?? 'default') : 'default';
+    if (!/^[A-Za-z0-9_-]{1,40}$/.test(name))
+        throw new Error('Invalid account name.');
+    if (command === 'sites') {
+        process.stdout.write(`${JSON.stringify(await service.sites(), null, 2)}\n`);
+        return;
+    }
+    if (command !== 'auth')
+        throw new Error('Usage: webmaster-mcp [mcp|sites|auth|help]. Run webmaster-mcp --help for details.');
+    const action = args[1];
+    if (action === 'status') {
+        for (const engine of ['google', 'bing', 'yandex'])
+            for (const account of accounts.names(engine)) {
+                const connected = !!(await store.get(engine, account));
+                process.stdout.write(`${engine.padEnd(7)} ${account.padEnd(12)} ${connected ? '✓ connected' : '✗ not connected'}\n`);
+            }
+        return;
+    }
+    if (action === 'logout') {
+        const engine = args[2];
+        if (!['google', 'bing', 'yandex'].includes(engine))
+            throw new Error('Choose google, bing, or yandex.');
+        await accounts.remove(engine, name);
+        process.stdout.write(`${engine}/${name} disconnected.\n`);
+        return;
+    }
+    if (action === 'google') {
+        await new GoogleProvider(store, name, fetch, args.includes('--write')).authenticate();
+        accounts.add('google', name);
+    }
+    else if (action === 'bing') {
+        await new BingProvider(store, name).authenticate();
+        accounts.add('bing', name);
+    }
+    else if (action === 'yandex') {
+        await new YandexProvider(store, name).authenticate();
+        accounts.add('yandex', name);
+    }
+    else
+        throw new Error('Usage: webmaster-mcp auth [google|bing|yandex|status|logout]');
+    process.stdout.write(`${action}/${name} connected.\n`);
 }
-else {
-    process.stderr.write(`ERROR: ${error instanceof Error ? error.message : String(error)}\n`);
-} process.exitCode = 1; });
+main().catch((error) => {
+    if (error instanceof WebmasterError) {
+        process.stderr.write(`${error.code}: ${error.message}\n`);
+    }
+    else {
+        process.stderr.write(`ERROR: ${error instanceof Error ? error.message : String(error)}\n`);
+    }
+    process.exitCode = 1;
+});

package/dist/core/analysis/index.js

@@ -1,14 +1,103 @@
 import { aggregate } from '../normalize/index.js';
-export function findCtrOpportunities(rows, config = { minImpressions: 100, maxCtr: 0.02 }) { return rows.filter(r => (r.impressions ?? 0) >= config.minImpressions && r.ctr !== undefined && r.ctr <= config.maxCtr).map(metric => ({ kind: 'low_ctr', metric, reason: `${metric.impressions} impressions with ${(metric.ctr * 100).toFixed(2)}% CTR` })); }
-export function findNearFirstPage(rows, config = { minImpressions: 50, minPosition: 8, maxPosition: 20 }) { return rows.filter(r => (r.impressions ?? 0) >= config.minImpressions && r.position !== undefined && r.position >= config.minPosition && r.position <= config.maxPosition).map(metric => ({ kind: 'near_first_page', metric, reason: `Average position ${metric.position.toFixed(1)} with ${metric.impressions} impressions` })); }
-function declines(current, previous, key, fraction) { const older = new Map(aggregate(previous, key).map(r => [`${r.engine}\0${r.site}\0${r[key]}`, r])); return aggregate(current, key).flatMap(metric => { const before = older.get(`${metric.engine}\0${metric.site}\0${metric[key]}`); if (!before || !before.clicks || metric.clicks === undefined || metric.clicks > before.clicks * (1 - fraction))
-    return []; return [{ kind: key === 'page' ? 'declining_page' : 'declining_query', metric, previous: before, reason: `Clicks fell from ${before.clicks} to ${metric.clicks}` }]; }); }
-export function findDecliningPages(current, previous, fraction = 0.2) { return declines(current, previous, 'page', fraction); }
-export function findDecliningQueries(current, previous, fraction = 0.2) { return declines(current, previous, 'query', fraction); }
-export function findImpressionGrowthWithoutClicks(current, previous, config = { minGrowth: 0.3, maxClickGrowth: 0.05 }) { const older = new Map(aggregate(previous, 'query').map(r => [`${r.engine}\0${r.site}\0${r.query}`, r])); return aggregate(current, 'query').flatMap(metric => { const before = older.get(`${metric.engine}\0${metric.site}\0${metric.query}`); if (!before?.impressions || metric.impressions === undefined || metric.impressions < before.impressions * (1 + config.minGrowth) || (metric.clicks ?? 0) > (before.clicks ?? 0) * (1 + config.maxClickGrowth))
-    return []; return [{ kind: 'impression_growth_without_clicks', metric, previous: before, reason: `Impressions grew from ${before.impressions} to ${metric.impressions} while clicks stayed near ${before.clicks ?? 0}` }]; }); }
-export function compareEngines(rows) { return aggregate(rows, 'engine').map(r => ({ engine: r.engine, site: r.site, clicks: r.clicks, impressions: r.impressions, ctr: r.ctr, position: r.position, semantics: 'Provider reported metrics; counting, position, and data freshness can differ.' })); }
-export function findEngineGaps(rows, engines, minImpressions = 1) { const byPage = new Map(); for (const r of aggregate(rows.filter(x => !!x.page), 'page'))
-    byPage.set(r.page, [...(byPage.get(r.page) ?? []), r]); return [...byPage].flatMap(([page, found]) => { const visible = found.filter(r => (r.impressions ?? 0) >= minImpressions).map(r => r.engine); const absent = engines.filter(e => !found.some(r => r.engine === e)); return visible.length && absent.length ? [{ page, visibleIn: visible, absentFromResults: absent, interpretation: 'No row returned for this engine; this does not prove the URL is not indexed.' }] : []; }); }
-export function findIndexingGaps(inspections) { const byUrl = new Map(); for (const i of inspections)
-    byUrl.set(i.url, [...(byUrl.get(i.url) ?? []), i]); return [...byUrl].flatMap(([url, items]) => { const indexed = items.filter(i => i.state === 'indexed').map(i => i.engine); const notIndexed = items.filter(i => i.state === 'not_indexed').map(i => i.engine); return indexed.length && notIndexed.length ? [{ url, indexed, notIndexed, evidence: items }] : []; }); }
+export function findCtrOpportunities(rows, config = { minImpressions: 100, maxCtr: 0.02 }) {
+    return rows
+        .filter((r) => (r.impressions ?? 0) >= config.minImpressions && r.ctr !== undefined && r.ctr <= config.maxCtr)
+        .map((metric) => ({
+        kind: 'low_ctr',
+        metric,
+        reason: `${metric.impressions} impressions with ${(metric.ctr * 100).toFixed(2)}% CTR`,
+    }));
+}
+export function findNearFirstPage(rows, config = { minImpressions: 50, minPosition: 8, maxPosition: 20 }) {
+    return rows
+        .filter((r) => (r.impressions ?? 0) >= config.minImpressions &&
+        r.position !== undefined &&
+        r.position >= config.minPosition &&
+        r.position <= config.maxPosition)
+        .map((metric) => ({
+        kind: 'near_first_page',
+        metric,
+        reason: `Average position ${metric.position.toFixed(1)} with ${metric.impressions} impressions`,
+    }));
+}
+function declines(current, previous, key, fraction) {
+    const older = new Map(aggregate(previous, key).map((r) => [`${r.engine}\0${r.site}\0${r[key]}`, r]));
+    return aggregate(current, key).flatMap((metric) => {
+        const before = older.get(`${metric.engine}\0${metric.site}\0${metric[key]}`);
+        if (!before?.clicks || metric.clicks === undefined || metric.clicks > before.clicks * (1 - fraction))
+            return [];
+        return [
+            {
+                kind: key === 'page' ? 'declining_page' : 'declining_query',
+                metric,
+                previous: before,
+                reason: `Clicks fell from ${before.clicks} to ${metric.clicks}`,
+            },
+        ];
+    });
+}
+export function findDecliningPages(current, previous, fraction = 0.2) {
+    return declines(current, previous, 'page', fraction);
+}
+export function findDecliningQueries(current, previous, fraction = 0.2) {
+    return declines(current, previous, 'query', fraction);
+}
+export function findImpressionGrowthWithoutClicks(current, previous, config = { minGrowth: 0.3, maxClickGrowth: 0.05 }) {
+    const older = new Map(aggregate(previous, 'query').map((r) => [`${r.engine}\0${r.site}\0${r.query}`, r]));
+    return aggregate(current, 'query').flatMap((metric) => {
+        const before = older.get(`${metric.engine}\0${metric.site}\0${metric.query}`);
+        if (!before?.impressions ||
+            metric.impressions === undefined ||
+            metric.impressions < before.impressions * (1 + config.minGrowth) ||
+            (metric.clicks ?? 0) > (before.clicks ?? 0) * (1 + config.maxClickGrowth))
+            return [];
+        return [
+            {
+                kind: 'impression_growth_without_clicks',
+                metric,
+                previous: before,
+                reason: `Impressions grew from ${before.impressions} to ${metric.impressions} while clicks stayed near ${before.clicks ?? 0}`,
+            },
+        ];
+    });
+}
+export function compareEngines(rows) {
+    return aggregate(rows, 'engine').map((r) => ({
+        engine: r.engine,
+        site: r.site,
+        clicks: r.clicks,
+        impressions: r.impressions,
+        ctr: r.ctr,
+        position: r.position,
+        semantics: 'Provider reported metrics; counting, position, and data freshness can differ.',
+    }));
+}
+export function findEngineGaps(rows, engines, minImpressions = 1) {
+    const byPage = new Map();
+    for (const r of aggregate(rows.filter((x) => !!x.page), 'page'))
+        byPage.set(r.page, [...(byPage.get(r.page) ?? []), r]);
+    return [...byPage].flatMap(([page, found]) => {
+        const visible = found.filter((r) => (r.impressions ?? 0) >= minImpressions).map((r) => r.engine);
+        const absent = engines.filter((e) => !found.some((r) => r.engine === e));
+        return visible.length && absent.length
+            ? [
+                {
+                    page,
+                    visibleIn: visible,
+                    absentFromResults: absent,
+                    interpretation: 'No row returned for this engine; this does not prove the URL is not indexed.',
+                },
+            ]
+            : [];
+    });
+}
+export function findIndexingGaps(inspections) {
+    const byUrl = new Map();
+    for (const i of inspections)
+        byUrl.set(i.url, [...(byUrl.get(i.url) ?? []), i]);
+    return [...byUrl].flatMap(([url, items]) => {
+        const indexed = items.filter((i) => i.state === 'indexed').map((i) => i.engine);
+        const notIndexed = items.filter((i) => i.state === 'not_indexed').map((i) => i.engine);
+        return indexed.length && notIndexed.length ? [{ url, indexed, notIndexed, evidence: items }] : [];
+    });
+}

package/dist/core/auth/accounts.d.ts

@@ -1,6 +1,6 @@
+import type { Cache } from '../cache/index.js';
 import type { Engine } from '../types/index.js';
 import type { CredentialStore } from './store.js';
-import type { Cache } from '../cache/index.js';
 export declare class AccountRegistry {
     private cache;
     private store;

package/dist/core/auth/accounts.js

@@ -5,8 +5,20 @@ export class AccountRegistry {
         this.cache = cache;
         this.store = store;
     }
-    names(engine) { const rows = this.cache.db.prepare('SELECT account FROM accounts WHERE provider=? ORDER BY account').all(engine); const names = rows.map(r => r.account); if (!names.includes('default'))
-        names.unshift('default'); return names; }
-    add(engine, account) { this.cache.db.prepare('INSERT OR IGNORE INTO accounts(provider,account) VALUES (?,?)').run(engine, account); }
-    async remove(engine, account) { await this.store.delete(engine, account); this.cache.db.prepare('DELETE FROM accounts WHERE provider=? AND account=?').run(engine, account); }
+    names(engine) {
+        const rows = this.cache.db
+            .prepare('SELECT account FROM accounts WHERE provider=? ORDER BY account')
+            .all(engine);
+        const names = rows.map((r) => r.account);
+        if (!names.includes('default'))
+            names.unshift('default');
+        return names;
+    }
+    add(engine, account) {
+        this.cache.db.prepare('INSERT OR IGNORE INTO accounts(provider,account) VALUES (?,?)').run(engine, account);
+    }
+    async remove(engine, account) {
+        await this.store.delete(engine, account);
+        this.cache.db.prepare('DELETE FROM accounts WHERE provider=? AND account=?').run(engine, account);
+    }
 }

package/dist/core/auth/prompt.js

@@ -1,4 +1,18 @@
 import { createInterface } from 'node:readline';
 import { Writable } from 'node:stream';
-export async function secretPrompt(label) { if (!process.stdin.isTTY)
-    throw new Error('Interactive terminal required.'); process.stderr.write(label); const output = new Writable({ write(_chunk, _encoding, callback) { callback(); } }); const rl = createInterface({ input: process.stdin, output, terminal: true }); return new Promise(resolve => rl.question('', answer => { rl.close(); process.stderr.write('\n'); resolve(answer.trim()); })); }
+export async function secretPrompt(label) {
+    if (!process.stdin.isTTY)
+        throw new Error('Interactive terminal required.');
+    process.stderr.write(label);
+    const output = new Writable({
+        write(_chunk, _encoding, callback) {
+            callback();
+        },
+    });
+    const rl = createInterface({ input: process.stdin, output, terminal: true });
+    return new Promise((resolve) => rl.question('', (answer) => {
+        rl.close();
+        process.stderr.write('\n');
+        resolve(answer.trim());
+    }));
+}

package/dist/core/auth/store.js

@@ -1,22 +1,33 @@
 import { Entry } from '@napi-rs/keyring';
 export class KeychainCredentialStore {
-    entry(provider, account) { return new Entry('webmaster-mcp', `${provider}/${account}`); }
-    async get(provider, account = 'default') { const env = process.env[`WEBMASTER_${provider.toUpperCase()}_${account.toUpperCase().replace(/[^A-Z0-9]/g, '_')}`] ?? (account === 'default' ? process.env[`WEBMASTER_${provider.toUpperCase()}_TOKEN`] : undefined); if (env)
-        return provider === 'bing' ? { apiKey: env } : { accessToken: env }; try {
-        const value = this.entry(provider, account).getPassword();
-        return value ? JSON.parse(value) : null;
+    entry(provider, account) {
+        return new Entry('webmaster-mcp', `${provider}/${account}`);
     }
-    catch (e) {
-        if (String(e).toLowerCase().includes('no entry'))
-            return null;
-        throw new Error('OS credential store unavailable. Configure a desktop keyring or use a development environment variable.');
-    } }
-    async set(provider, account, credentials) { this.entry(provider, account).setPassword(JSON.stringify(credentials)); }
-    async delete(provider, account) { try {
-        this.entry(provider, account).deletePassword();
+    async get(provider, account = 'default') {
+        const env = process.env[`WEBMASTER_${provider.toUpperCase()}_${account.toUpperCase().replace(/[^A-Z0-9]/g, '_')}`] ??
+            (account === 'default' ? process.env[`WEBMASTER_${provider.toUpperCase()}_TOKEN`] : undefined);
+        if (env)
+            return provider === 'bing' ? { apiKey: env } : { accessToken: env };
+        try {
+            const value = this.entry(provider, account).getPassword();
+            return value ? JSON.parse(value) : null;
+        }
+        catch (e) {
+            if (String(e).toLowerCase().includes('no entry'))
+                return null;
+            throw new Error('OS credential store unavailable. Configure a desktop keyring or use a development environment variable.');
+        }
+    }
+    async set(provider, account, credentials) {
+        this.entry(provider, account).setPassword(JSON.stringify(credentials));
+    }
+    async delete(provider, account) {
+        try {
+            this.entry(provider, account).deletePassword();
+        }
+        catch (e) {
+            if (!String(e).toLowerCase().includes('no entry'))
+                throw e;
+        }
     }
-    catch (e) {
-        if (!String(e).toLowerCase().includes('no entry'))
-            throw e;
-    } }
 }

package/dist/core/cache/index.js

@@ -1,21 +1,51 @@
-import Database from 'better-sqlite3';
 import { createHash } from 'node:crypto';
 import { mkdirSync } from 'node:fs';
-import { dirname } from 'node:path';
 import { homedir } from 'node:os';
-export function defaultDataPath() { if (process.env.WEBMASTER_MCP_DATA_DIR)
-    return `${process.env.WEBMASTER_MCP_DATA_DIR}/cache.db`; if (process.platform === 'darwin')
-    return `${homedir()}/Library/Application Support/webmaster-mcp/cache.db`; if (process.platform === 'win32')
-    return `${process.env.LOCALAPPDATA ?? homedir()}/webmaster-mcp/cache.db`; return `${process.env.XDG_CACHE_HOME ?? `${homedir()}/.cache`}/webmaster-mcp/cache.db`; }
-function stable(value) { if (Array.isArray(value))
-    return value.map(stable); if (value && typeof value === 'object')
-    return Object.fromEntries(Object.entries(value).sort(([a], [b]) => a.localeCompare(b)).map(([k, v]) => [k, stable(v)])); return value; }
-export function cacheKey(provider, account, site, operation, params) { return createHash('sha256').update(JSON.stringify(stable({ provider, account, site, operation, params }))).digest('hex'); }
+import { dirname } from 'node:path';
+import Database from 'better-sqlite3';
+export function defaultDataPath() {
+    if (process.env.WEBMASTER_MCP_DATA_DIR)
+        return `${process.env.WEBMASTER_MCP_DATA_DIR}/cache.db`;
+    if (process.platform === 'darwin')
+        return `${homedir()}/Library/Application Support/webmaster-mcp/cache.db`;
+    if (process.platform === 'win32')
+        return `${process.env.LOCALAPPDATA ?? homedir()}/webmaster-mcp/cache.db`;
+    return `${process.env.XDG_CACHE_HOME ?? `${homedir()}/.cache`}/webmaster-mcp/cache.db`;
+}
+function stable(value) {
+    if (Array.isArray(value))
+        return value.map(stable);
+    if (value && typeof value === 'object')
+        return Object.fromEntries(Object.entries(value)
+            .sort(([a], [b]) => a.localeCompare(b))
+            .map(([k, v]) => [k, stable(v)]));
+    return value;
+}
+export function cacheKey(provider, account, site, operation, params) {
+    return createHash('sha256')
+        .update(JSON.stringify(stable({ provider, account, site, operation, params })))
+        .digest('hex');
+}
 export class Cache {
     db;
-    constructor(path = defaultDataPath()) { if (path !== ':memory:')
-        mkdirSync(dirname(path), { recursive: true, mode: 0o700 }); this.db = new Database(path); this.db.pragma('busy_timeout = 5000'); this.db.pragma('journal_mode = WAL'); this.db.exec('CREATE TABLE IF NOT EXISTS accounts(provider TEXT NOT NULL,account TEXT NOT NULL,PRIMARY KEY(provider,account)); CREATE TABLE IF NOT EXISTS cache(key TEXT PRIMARY KEY,value TEXT NOT NULL,expires INTEGER NOT NULL)'); }
-    get(key) { const row = this.db.prepare('SELECT value FROM cache WHERE key=? AND expires>?').get(key, Date.now()); return row ? JSON.parse(row.value) : null; }
-    set(key, value, ttlMs) { this.db.prepare('INSERT INTO cache(key,value,expires) VALUES (?,?,?) ON CONFLICT(key) DO UPDATE SET value=excluded.value,expires=excluded.expires').run(key, JSON.stringify(value), Date.now() + ttlMs); }
-    close() { this.db.close(); }
+    constructor(path = defaultDataPath()) {
+        if (path !== ':memory:')
+            mkdirSync(dirname(path), { recursive: true, mode: 0o700 });
+        this.db = new Database(path);
+        this.db.pragma('busy_timeout = 5000');
+        this.db.pragma('journal_mode = WAL');
+        this.db.exec('CREATE TABLE IF NOT EXISTS accounts(provider TEXT NOT NULL,account TEXT NOT NULL,PRIMARY KEY(provider,account)); CREATE TABLE IF NOT EXISTS cache(key TEXT PRIMARY KEY,value TEXT NOT NULL,expires INTEGER NOT NULL)');
+    }
+    get(key) {
+        const row = this.db.prepare('SELECT value FROM cache WHERE key=? AND expires>?').get(key, Date.now());
+        return row ? JSON.parse(row.value) : null;
+    }
+    set(key, value, ttlMs) {
+        this.db
+            .prepare('INSERT INTO cache(key,value,expires) VALUES (?,?,?) ON CONFLICT(key) DO UPDATE SET value=excluded.value,expires=excluded.expires')
+            .run(key, JSON.stringify(value), Date.now() + ttlMs);
+    }
+    close() {
+        this.db.close();
+    }
 }

package/dist/core/errors.js

@@ -10,7 +10,12 @@ export class WebmasterError extends Error {
 export function normalizeError(engine, account, error) {
     if (error instanceof WebmasterError)
         return { engine, account, code: error.code, message: error.message };
-    return { engine, account, code: 'UPSTREAM_ERROR', message: 'Provider request failed. Check provider status and local configuration.' };
+    return {
+        engine,
+        account,
+        code: 'UPSTREAM_ERROR',
+        message: 'Provider request failed. Check provider status and local configuration.',
+    };
 }
 export function httpError(status) {
     if (status === 401)
@@ -21,4 +26,6 @@ export function httpError(status) {
         return new WebmasterError('RATE_LIMITED', 'Provider rate limit reached.', status);
     return new WebmasterError('UPSTREAM_ERROR', `Provider returned HTTP ${status}.`, status);
 }
-export function redact(value) { return value.replace(/(Bearer|OAuth|apikey=|access_token=|refresh_token=)\s*[^\s&"']+/gi, '$1 [REDACTED]'); }
+export function redact(value) {
+    return value.replace(/(Bearer|OAuth|apikey=|access_token=|refresh_token=)\s*[^\s&"']+/gi, '$1 [REDACTED]');
+}

package/dist/core/normalize/index.js

@@ -1,7 +1,11 @@
-export function finite(value) { const n = typeof value === 'number' ? value : typeof value === 'string' && value.trim() ? Number(value) : NaN; return Number.isFinite(n) ? n : undefined; }
+export function finite(value) {
+    const n = typeof value === 'number' ? value : typeof value === 'string' && value.trim() ? Number(value) : NaN;
+    return Number.isFinite(n) ? n : undefined;
+}
 export function metric(input) {
     const clicks = finite(input.clicks), impressions = finite(input.impressions);
-    const ctr = finite(input.ctr) ?? (clicks !== undefined && impressions !== undefined && impressions > 0 ? clicks / impressions : undefined);
+    const ctr = finite(input.ctr) ??
+        (clicks !== undefined && impressions !== undefined && impressions > 0 ? clicks / impressions : undefined);
     return { ...input, clicks, impressions, ctr, position: finite(input.position) };
 }
 export function aggregate(rows, key) {
@@ -11,5 +15,24 @@ export function aggregate(rows, key) {
         const id = `${row.engine}\0${row.site}\0${value}`;
         groups.set(id, [...(groups.get(id) ?? []), row]);
     }
-    return [...groups.values()].map(group => { const first = group[0]; const clicks = group.some(r => r.clicks !== undefined) ? group.reduce((n, r) => n + (r.clicks ?? 0), 0) : undefined; const impressions = group.some(r => r.impressions !== undefined) ? group.reduce((n, r) => n + (r.impressions ?? 0), 0) : undefined; const positions = group.filter(r => r.position !== undefined); const weight = positions.reduce((n, r) => n + (r.impressions ?? 1), 0); return metric({ engine: first.engine, site: first.site, account: first.account, [key]: first[key], clicks, impressions, position: weight ? positions.reduce((n, r) => n + r.position * (r.impressions ?? 1), 0) / weight : undefined }); });
+    return [...groups.values()].map((group) => {
+        const first = group[0];
+        const clicks = group.some((r) => r.clicks !== undefined)
+            ? group.reduce((n, r) => n + (r.clicks ?? 0), 0)
+            : undefined;
+        const impressions = group.some((r) => r.impressions !== undefined)
+            ? group.reduce((n, r) => n + (r.impressions ?? 0), 0)
+            : undefined;
+        const positions = group.filter((r) => r.position !== undefined);
+        const weight = positions.reduce((n, r) => n + (r.impressions ?? 1), 0);
+        return metric({
+            engine: first.engine,
+            site: first.site,
+            account: first.account,
+            [key]: first[key],
+            clicks,
+            impressions,
+            position: weight ? positions.reduce((n, r) => n + r.position * (r.impressions ?? 1), 0) / weight : undefined,
+        });
+    });
 }

package/dist/core/scheduler.js

@@ -7,46 +7,73 @@ export class RequestScheduler {
     constructor(policy) {
         this.policy = policy;
     }
-    async slot() { if (this.active >= this.policy.concurrency)
-        await new Promise(resolve => this.queue.push(resolve));
-    else
-        this.active++; const delay = Math.max(0, this.next - Date.now()); this.next = Math.max(Date.now(), this.next) + this.policy.minimumDelay; if (delay)
-        await new Promise(r => setTimeout(r, delay)); return () => { const next = this.queue.shift(); if (next)
-        next();
-    else
-        this.active--; }; }
-    async run(fn) { const release = await this.slot(); try {
-        for (let attempt = 0;; attempt++) {
-            try {
-                return await fn();
-            }
-            catch (e) {
-                const retryable = e instanceof WebmasterError ? e.code === 'RATE_LIMITED' || e.code === 'NETWORK_ERROR' || (e.status !== undefined && e.status >= 500) : e instanceof TypeError;
-                if (!retryable || attempt >= this.policy.retries)
-                    throw e;
-                await new Promise(r => setTimeout(r, Math.min(5000, 250 * 2 ** attempt + Math.random() * 100)));
+    async slot() {
+        if (this.active >= this.policy.concurrency)
+            await new Promise((resolve) => this.queue.push(resolve));
+        else
+            this.active++;
+        const delay = Math.max(0, this.next - Date.now());
+        this.next = Math.max(Date.now(), this.next) + this.policy.minimumDelay;
+        if (delay)
+            await new Promise((r) => setTimeout(r, delay));
+        return () => {
+            const next = this.queue.shift();
+            if (next)
+                next();
+            else
+                this.active--;
+        };
+    }
+    async run(fn) {
+        const release = await this.slot();
+        try {
+            for (let attempt = 0;; attempt++) {
+                try {
+                    return await fn();
+                }
+                catch (e) {
+                    const retryable = e instanceof WebmasterError
+                        ? e.code === 'RATE_LIMITED' || e.code === 'NETWORK_ERROR' || (e.status !== undefined && e.status >= 500)
+                        : e instanceof TypeError;
+                    if (!retryable || attempt >= this.policy.retries)
+                        throw e;
+                    await new Promise((r) => setTimeout(r, Math.min(5000, 250 * 2 ** attempt + Math.random() * 100)));
+                }
             }
         }
+        finally {
+            release();
+        }
     }
-    finally {
-        release();
-    } }
 }
-export const schedules = { google: { concurrency: 3, minimumDelay: 100, retries: 2 }, bing: { concurrency: 2, minimumDelay: 250, retries: 2 }, yandex: { concurrency: 2, minimumDelay: 200, retries: 2 } };
+export const schedules = {
+    google: { concurrency: 3, minimumDelay: 100, retries: 2 },
+    bing: { concurrency: 2, minimumDelay: 250, retries: 2 },
+    yandex: { concurrency: 2, minimumDelay: 200, retries: 2 },
+};
 const shared = new Map();
-export function providerScheduler(engine) { let scheduler = shared.get(engine); if (!scheduler) {
-    scheduler = new RequestScheduler(schedules[engine]);
-    shared.set(engine, scheduler);
-} return scheduler; }
-export async function jsonFetch(fetcher, url, options = {}) { let response; try {
-    response = await fetcher(url, { ...options, signal: options.signal ?? AbortSignal.timeout(15000) });
+export function providerScheduler(engine) {
+    let scheduler = shared.get(engine);
+    if (!scheduler) {
+        scheduler = new RequestScheduler(schedules[engine]);
+        shared.set(engine, scheduler);
+    }
+    return scheduler;
 }
-catch {
-    throw new WebmasterError('NETWORK_ERROR', 'Provider network request failed.');
-} if (!response.ok)
-    throw httpError(response.status); try {
-    return await response.json();
+export async function jsonFetch(fetcher, url, options = {}) {
+    let response;
+    try {
+        response = await fetcher(url, { ...options, signal: options.signal ?? AbortSignal.timeout(15000) });
+    }
+    catch {
+        throw new WebmasterError('NETWORK_ERROR', 'Provider network request failed.');
+    }
+    if (!response.ok)
+        throw httpError(response.status);
+    try {
+        return await response.json();
+    }
+    catch {
+        throw new WebmasterError('UPSTREAM_ERROR', 'Provider returned invalid JSON.');
+    }
 }
-catch {
-    throw new WebmasterError('UPSTREAM_ERROR', 'Provider returned invalid JSON.');
-} }

package/dist/core/service.d.ts

@@ -1,5 +1,5 @@
+import { type Cache } from './cache/index.js';
 import type { Capability, Engine, PartialResult, PerformanceQuery, SearchMetric, UrlInspection, WebmasterProvider } from './types/index.js';
-import { Cache } from './cache/index.js';
 export declare class WebmasterService {
     readonly providers: WebmasterProvider[];
     readonly cache: Cache;