@georanker/seo-mcp 0.14.0

package/LICENSE

@@ -0,0 +1,21 @@
+MIT License
+
+Copyright (c) 2026 GeoRanker
+
+Permission is hereby granted, free of charge, to any person obtaining a copy
+of this software and associated documentation files (the "Software"), to deal
+in the Software without restriction, including without limitation the rights
+to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
+copies of the Software, and to permit persons to whom the Software is
+furnished to do so, subject to the following conditions:
+
+The above copyright notice and this permission notice shall be included in all
+copies or substantial portions of the Software.
+
+THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
+AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
+OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
+SOFTWARE.

package/README.md

@@ -0,0 +1,47 @@
+**SEO & SERP MCP by GeoRanker**
+
+SERP data, multi-location rank tracking, Lighthouse SEO audits, broken internal links, backlinks and keyword volumes for AI agents, powered by GeoRanker.
+
+Client version 0.14.0. The client is MIT-licensed. npm is the primary installation route for released versions; GitHub source installation is the fallback. If the requested npm version is not yet available, use the source instructions below. The hosted service is managed separately by GeoRanker.
+
+**Install once, receive updates automatically**
+
+Use a supported Node.js version (see package.json engines) and npm. Run the no-query setup check, then add the npm launcher to your AI host. Git and a TypeScript build are needed only for the source-install fallback. Follow the [installation guide](docs/install.md) for configuration and migration from older clients.
+
+Each push to the public main branch runs the release workflow. After tests and clean-install checks pass, it publishes a client package with signed GitHub provenance. The launcher checks for this release at startup and every five minutes while running, verifies its repository, workflow and commit identity and artifact checksum, then installs locked production dependencies without lifecycle scripts. Automatic updates need Node.js and npm; Git and TypeScript builds are not required after initial installation. From 0.13.1, a version or schema compatibility error triggers an immediate signed release check without waiting for the five-minute interval. Runtime recovery checks are limited to once per worker release per session; ordinary errors do not trigger them. Active calls remain protected and failed requests are never replayed. From 0.13.0, a stable supervisor keeps the host MCP connection open and runs tools through an internal worker. It applies a verified worker update when no tool calls are active and 60 seconds have passed without tool activity. Idle refers to this MCP connection; existing provider jobs can remain pending. Calls are not replayed. A failed candidate leaves the current worker in place. Automatic checks stay quiet when nothing changes or an update is unavailable; a message is written only when an update is applied. After a cancelled or timed-out worker request, worker swaps wait for a normal host reconnect because completion is uncertain. Changes to the supervisor itself take effect on a normal host restart. Existing 0.12.0 clients acquire the supervisor on their next reconnect once 0.13.0 is prepared; subsequent compatible worker updates apply within the session without reinstalling or reconfiguring the host. If the release workflow or update verification fails, the installed version continues working. Use --update to prepare the latest commit immediately, or set GEORANKER_MCP_AUTO_UPDATE=0 to opt out. Updates do not create provider data jobs.
+
+> Show up to 20 Google organic results for car insurance in Bucharest, Romania, with positions, source URLs and freshness.
+
+**Tools**
+
+- search_serps
+- get_serp_result
+- create_rank_tracking_report
+- get_rank_tracking_report
+- update_rank_tracking_schedule
+- create_onpage_report
+- get_onpage_report
+- create_broken_links_report
+- get_broken_links_report
+- create_backlinks_report
+- get_backlinks_report
+- create_keyword_volume_report
+- get_keyword_volume_report
+
+Completed MCP results are eligible for reuse for seven days by default. Pass forceLive: true to bypass completed cache and request fresh upstream work. Pending work can be reused safely; retrieve the returned job ID instead of creating another request. Results disclose cache metadata and provider generation time when supplied. Report tools create persistent reports and use opaque reportId values, distinct from SERP jobId. Use each report’s matching get tool to retrieve it. Unknown or pending report status never triggers automatic recreation. For recurring rank reports, forceLive retrieves existing provider data and returns refreshNotice without a manual capture or duplicate schedule. The client negotiates the expanded SEO catalog while older clients retain their original tools. See [examples and limits](docs/examples.md). The [SEO report guide](docs/seo-reports.md) includes input examples, retrieval steps, scheduling and report-specific limits for all five families.
+
+The client enrolls automatically and stores its own installation credentials. Both GeoRanker products share their installation/account relationship for the same service origin. No manual provider API key is required. Setup performs no data query; data calls use the configured allowance and provider credits. SEO reports use server-managed provider credentials. Unregistered installations use the platform key; linked accounts use their own SEO key with free, verified or provider-credit allowances. Account linking and rebilling require service support. Rank checks count keywords × locations × engines, Lighthouse counts devices, link crawls count blocks of up to 100 requested pages (rounded up), keyword reports count keywords, and backlink reports count one. These are admission units, not provider credit prices. Only platform-key work also consumes the shared server allowance. Use optional campaignName to select an owned MCP campaign, or omit it for the installation default.
+
+Request independent tasks in parallel. The hosted service applies shared and per-installation limits and may briefly queue a call. Clients sharing an installation share its limits; the operator controls slots centrally. Keep pending job or report IDs and retrieve existing results. Cancelling a call does not guarantee that submitted work stopped. Completed-result reuse remains seven days by default.
+
+See [client privacy and data flow](docs/privacy.md). Package source is restricted to client transport, identity, updates and tool contracts. The hosted service, provider adapter and administration are not included.
+
+**Development**
+
+```sh
+npm ci
+npm test
+npm run pack:check
+```
+
+This client and its documentation are licensed under MIT; see LICENSE. Dependencies retain their own licenses. The hosted GeoRanker service, its private source and data access are governed separately by GeoRanker's service terms. Public exports allow npm publication; internal exports remain private. metadata.json describes the product; it is not an official MCP Registry submission.

package/dist/src/cli.d.ts

@@ -0,0 +1,6 @@
+#!/usr/bin/env node
+interface StartupRecovery {
+    checksRemaining: number;
+}
+export declare function launch(bundledOnly?: boolean, recovery?: StartupRecovery): Promise<void>;
+export {};

package/dist/src/cli.js

@@ -0,0 +1,144 @@
+#!/usr/bin/env node
+// Keep the configured entry point stable; verified releases also update this launcher.
+import { realpathSync } from 'node:fs';
+import { pathToFileURL, fileURLToPath } from 'node:url';
+import { dirname, resolve } from 'node:path';
+import { CLIENT_PROFILE, CLIENT_REPOSITORY, CLIENT_VERSION } from './product.js';
+import { checkForUpdate, selectRelease, rollbackRelease } from './updater.js';
+const args = process.argv.slice(2);
+const supported = ['--setup', '--help', '-h', '--version', '-v', '--update'];
+const options = {
+    repository: CLIENT_REPOSITORY, version: CLIENT_VERSION,
+    bundledRoot: resolve(dirname(fileURLToPath(import.meta.url)), '../..'),
+    env: process.env,
+    log: message => process.stderr.write('GeoRanker ' + CLIENT_PROFILE + ' MCP: ' + message + '\n'),
+};
+async function runBundled() {
+    if (args[0] === '--update') {
+        const result = await checkForUpdate({ ...options, force: true });
+        process.stdout.write(JSON.stringify(result) + '\n');
+        if (result.status === 'failed')
+            process.exitCode = 1;
+        return;
+    }
+    if (args.length === 0) {
+        const { createSupervisor } = await import('./supervisor.js');
+        const { StdioServerTransport } = await import('@modelcontextprotocol/sdk/server/stdio.js');
+        const supervisor = await createSupervisor(options);
+        try {
+            await supervisor.connect(new StdioServerTransport());
+        }
+        catch (error) {
+            await supervisor.close();
+            throw error;
+        }
+        return;
+    }
+    const runtime = await import(pathToFileURL(resolve(options.bundledRoot, 'dist/src/runtime.js')).href);
+    await runtime.run();
+}
+async function runRelease(root, recovery) {
+    if (root === options.bundledRoot)
+        return runBundled();
+    const client = await import(pathToFileURL(resolve(root, 'dist/src/cli.js')).href);
+    if (typeof client.launch !== 'function')
+        throw new Error('Prepared client does not export its launcher.');
+    // The selected release owns its runtime AND future update checks. Avoid recursion.
+    await client.launch(true, recovery);
+}
+// This export is the stable delegation contract for already-installed launchers.
+// bundledOnly is used only by a parent launcher after it selects a verified release.
+export async function launch(bundledOnly = false, recovery = { checksRemaining: 1 }) {
+    if (args.length > 1 || (args.length === 1 && !supported.includes(args[0]))) {
+        throw Object.assign(new Error('Unsupported argument. Use --help. This package only connects to the hosted GeoRanker service.'), { code: 'CLI_ARGUMENTS' });
+    }
+    const attempted = new Set();
+    let failure;
+    // A cached launcher must own recovery too, even when an older bootstrap delegates.
+    if (bundledOnly) {
+        attempted.add(options.bundledRoot);
+        try {
+            await runBundled();
+            return;
+        }
+        catch (error) {
+            failure = error;
+        }
+    }
+    // Initialization may fall back through current, previous and bundled releases.
+    // runtime.run rejects only before a usable stdio connection is established.
+    for (let attempt = 0; !bundledOnly && attempt < 3; attempt++) {
+        const release = await selectRelease(options);
+        if (attempted.has(release.root))
+            break;
+        attempted.add(release.root);
+        try {
+            await runRelease(release.root, recovery);
+            return;
+        }
+        catch (error) {
+            failure = error;
+            if (!release.commit)
+                break;
+            options.log?.('The prepared client could not start. Trying the previous working client.');
+            await rollbackRelease(options, release.commit);
+        }
+    }
+    // A read-only or damaged pointer must not prevent use of the bundled client.
+    if (!attempted.has(options.bundledRoot)) {
+        attempted.add(options.bundledRoot);
+        try {
+            await runBundled();
+            return;
+        }
+        catch (error) {
+            failure = error;
+        }
+    }
+    // Older tool schemas can fail initialization before periodic updates start.
+    // Check once here, before accepting requests, so a verified compatible update can heal it.
+    if (recovery.checksRemaining > 0 && options.env.GEORANKER_MCP_AUTO_UPDATE !== '0' && (args.length === 0 || args[0] === '--setup')) {
+        // Share one recovery check across delegated launchers to bound startup retries.
+        recovery.checksRemaining--;
+        // Initialization cannot wait for the normal polling cooldown to heal stale schemas.
+        const prepared = await checkForUpdate({ ...options, force: true, log: undefined });
+        const updated = await selectRelease(options);
+        if (updated.commit && !attempted.has(updated.root)) {
+            try {
+                await runRelease(updated.root, recovery);
+                try {
+                    options.log?.('Applied verified client update ' + (prepared.version || updated.commit) + ' during startup recovery.');
+                }
+                catch { /* Logging cannot interrupt a recovered connection. */ }
+                return;
+            }
+            catch (error) {
+                failure = error;
+                await rollbackRelease(options, updated.commit);
+            }
+        }
+    }
+    throw failure;
+}
+function isEntryPoint() {
+    if (!process.argv[1])
+        return false;
+    const entry = resolve(process.argv[1]);
+    if (pathToFileURL(entry).href === import.meta.url)
+        return true;
+    try {
+        return pathToFileURL(realpathSync(entry)).href === import.meta.url;
+    }
+    catch {
+        return false;
+    }
+}
+if (isEntryPoint()) {
+    launch().catch((error) => {
+        const diagnostic = error;
+        const message = typeof diagnostic?.code === 'string' && typeof diagnostic?.message === 'string'
+            ? diagnostic.code + ': ' + diagnostic.message : 'The connection could not be started.';
+        process.stderr.write('GeoRanker ' + CLIENT_PROFILE + ' MCP: ' + message + '\n');
+        process.exitCode = 1;
+    });
+}

package/dist/src/config.d.ts

@@ -0,0 +1 @@
+export declare function secureUrl(value: string, name: string): URL;

package/dist/src/config.js

@@ -0,0 +1,16 @@
+import { AppError } from './errors.js';
+// Client URL validation only. Upstream API and operator configuration stay private.
+export function secureUrl(value, name) {
+    let url;
+    try {
+        url = new URL(value);
+    }
+    catch {
+        throw new AppError('CONFIG_ERROR', `${name} must be a valid URL.`);
+    }
+    const local = ['localhost', '127.0.0.1', '[::1]'].includes(url.hostname);
+    if ((url.protocol !== 'https:' && !(local && url.protocol === 'http:')) || url.username || url.password || url.search || url.hash) {
+        throw new AppError('CONFIG_ERROR', `${name} requires HTTPS without credentials, query parameters, or fragments. HTTP is allowed only on loopback.`);
+    }
+    return url;
+}

package/dist/src/enrollment.d.ts

@@ -0,0 +1 @@
+export declare function installationHeaders(url: URL, env: NodeJS.ProcessEnv): Promise<Record<string, string>>;

package/dist/src/enrollment.js

@@ -0,0 +1,68 @@
+import { createHash, randomUUID } from 'node:crypto';
+import { link, mkdir, readFile, rename, unlink, writeFile } from 'node:fs/promises';
+import { homedir } from 'node:os';
+import { join, resolve } from 'node:path';
+import { AppError } from './errors.js';
+import { newIdentity, registration } from './identity.js';
+function valid(value) {
+    return !!value && /^[a-f0-9]{8}-(?:[a-f0-9]{4}-){3}[a-f0-9]{12}$/.test(value.installationId) && /^[A-Za-z0-9_-]{43}$/.test(value.accessToken);
+}
+export async function installationHeaders(url, env) {
+    const directory = join(resolve(env.GEORANKER_STATE_DIR || join(homedir(), '.config', 'georanker-search-mcp')), 'client', createHash('sha256').update(url.origin).digest('hex'));
+    await mkdir(directory, { recursive: true, mode: 0o700 });
+    const identityPath = join(directory, 'identity.json');
+    let identity;
+    try {
+        identity = JSON.parse(await readFile(identityPath, 'utf8'));
+    }
+    catch (error) {
+        if (error.code !== 'ENOENT')
+            throw new AppError('STATE_ERROR', 'Cannot read the saved installation identity. Restore its backup; it was not replaced.');
+        // Link a completely written file without overwriting another launch's identity.
+        const temporary = `${identityPath}.${randomUUID()}.tmp`;
+        await writeFile(temporary, JSON.stringify(newIdentity(env.GEORANKER_DEVICE_FINGERPRINT)), { mode: 0o600, flag: 'wx' });
+        try {
+            await link(temporary, identityPath);
+        }
+        catch (linkError) {
+            if (linkError.code !== 'EEXIST')
+                throw linkError;
+        }
+        finally {
+            await unlink(temporary);
+        }
+        identity = JSON.parse(await readFile(identityPath, 'utf8'));
+    }
+    const path = join(directory, 'credentials.json');
+    let credentials;
+    try {
+        credentials = JSON.parse(await readFile(path, 'utf8'));
+        if (!valid(credentials))
+            throw new Error();
+    }
+    catch (error) {
+        if (error.code !== 'ENOENT')
+            throw new AppError('STATE_ERROR', 'Cannot read saved installation credentials. They were not replaced.');
+        let response;
+        try {
+            response = await fetch(new URL('/v1/installations', url), { method: 'POST', redirect: 'error', headers: { 'Content-Type': 'application/json' }, body: JSON.stringify(registration(identity, url.origin)), signal: AbortSignal.timeout(15_000) });
+        }
+        catch {
+            throw new AppError('ENROLLMENT_FAILED', 'Cannot register this installation. Check internet access and the system clock, then launch again. No paid request was made.');
+        }
+        if (!response.ok)
+            throw new AppError('ENROLLMENT_FAILED', `Registration returned HTTP ${response.status}. ${response.status === 429 ? 'Pilot signup limits were reached. Try again later.' : 'Contact the pilot operator if this persists.'} No paid request was made.`);
+        const text = await response.text();
+        if (text.length > 4096)
+            throw new AppError('ENROLLMENT_FAILED', 'Unexpected registration response.');
+        credentials = JSON.parse(text);
+        if (!valid(credentials))
+            throw new AppError('ENROLLMENT_FAILED', 'Invalid registration response.');
+        const temporary = `${path}.${randomUUID()}.tmp`;
+        await writeFile(temporary, JSON.stringify(credentials), { mode: 0o600, flag: 'wx' });
+        await rename(temporary, path);
+    }
+    if (!/^[a-f0-9]{64}$/.test(identity.deviceFingerprint))
+        throw new AppError('STATE_ERROR', 'Invalid saved device identity.');
+    return { Authorization: `Bearer ${credentials.accessToken}`, 'X-GeoRanker-Installation-Id': credentials.installationId, 'X-GeoRanker-Device-Fingerprint': identity.deviceFingerprint };
+}

package/dist/src/errors.d.ts

@@ -0,0 +1,6 @@
+export declare class AppError extends Error {
+    readonly code: string;
+    readonly retryAfterSeconds?: number | undefined;
+    readonly details?: Record<string, unknown> | undefined;
+    constructor(code: string, message: string, retryAfterSeconds?: number | undefined, details?: Record<string, unknown> | undefined);
+}

package/dist/src/errors.js

@@ -0,0 +1,12 @@
+export class AppError extends Error {
+    code;
+    retryAfterSeconds;
+    details;
+    constructor(code, message, retryAfterSeconds, details) {
+        super(message);
+        this.code = code;
+        this.retryAfterSeconds = retryAfterSeconds;
+        this.details = details;
+        this.name = 'AppError';
+    }
+}

package/dist/src/identity.d.ts

@@ -0,0 +1,15 @@
+export declare function deviceFingerprint(): string;
+export interface InstallationIdentity {
+    privateKey: string;
+    publicKey: string;
+    deviceFingerprint: string;
+}
+export interface Registration {
+    publicKey: string;
+    deviceFingerprint: string;
+    timestamp: number;
+    nonce: string;
+    signature: string;
+}
+export declare function newIdentity(fingerprint?: string): InstallationIdentity;
+export declare function registration(identity: InstallationIdentity, origin: string): Registration;

package/dist/src/identity.js

@@ -0,0 +1,21 @@
+import { createHash, createPrivateKey, generateKeyPairSync, randomBytes, sign } from 'node:crypto';
+import { arch, cpus, hostname, platform } from 'node:os';
+import { AppError } from './errors.js';
+export function deviceFingerprint() {
+    // Supporting, self-reported signal only. This is not hardware attestation.
+    return createHash('sha256').update(JSON.stringify({ hostname: hostname(), platform: platform(), arch: arch(), cpu: cpus()[0]?.model || '' })).digest('hex');
+}
+export function newIdentity(fingerprint = deviceFingerprint()) {
+    if (!/^[a-f0-9]{64}$/.test(fingerprint))
+        throw new AppError('CONFIG_ERROR', 'Device fingerprint must be a lowercase SHA-256 hex string.');
+    const pair = generateKeyPairSync('ed25519');
+    return { privateKey: pair.privateKey.export({ format: 'der', type: 'pkcs8' }).toString('base64url'), publicKey: pair.publicKey.export({ format: 'der', type: 'spki' }).toString('base64url'), deviceFingerprint: fingerprint };
+}
+function message(input, origin) {
+    return Buffer.from(JSON.stringify(['georanker-installation-v1', origin, input.publicKey, input.deviceFingerprint, input.timestamp, input.nonce]));
+}
+export function registration(identity, origin) {
+    const input = { publicKey: identity.publicKey, deviceFingerprint: identity.deviceFingerprint, timestamp: Date.now(), nonce: randomBytes(24).toString('base64url') };
+    const key = createPrivateKey({ key: Buffer.from(identity.privateKey, 'base64url'), format: 'der', type: 'pkcs8' });
+    return { ...input, signature: sign(null, message(input, origin), key).toString('base64url') };
+}

package/dist/src/product-contract.d.ts

@@ -0,0 +1,60 @@
+/** Public MCP product identities and input contracts. No provider configuration belongs here. */
+import type { SeoToolName } from './seo-contract.js';
+export declare const SERVER_VERSION = "0.14.0";
+export type ProductProfile = 'combined' | 'seo' | 'scraping';
+export type JobKind = 'search' | 'page';
+export declare const PRODUCT_PROFILES: {
+    readonly combined: {
+        readonly name: "georanker-search-mcp";
+        readonly title: "GeoRanker Search MCP";
+        readonly endpoint: "/mcp";
+        readonly searchTool: "search";
+        readonly fetchTool: "fetch_page";
+        readonly resultTool: "get_search_result";
+    };
+    readonly seo: {
+        readonly name: "georanker-seo-mcp";
+        readonly title: "SEO & SERP MCP by GeoRanker";
+        readonly endpoint: "/seo/mcp";
+        readonly searchTool: "search_serps";
+        readonly resultTool: "get_serp_result";
+    };
+    readonly scraping: {
+        readonly name: "georanker-web-scraping-mcp";
+        readonly title: "Web Scraping MCP by GeoRanker";
+        readonly endpoint: "/scraping/mcp";
+        readonly fetchTool: "fetch_page";
+        readonly resultTool: "get_fetch_result";
+    };
+};
+export declare function profileForEndpoint(path: string): ProductProfile | undefined;
+export interface SearchInput {
+    query: string;
+    limit?: number;
+    pages?: number;
+    region?: string;
+    searchEngine?: 'google' | 'bing' | 'yahoo';
+    language?: string;
+    waitMs?: number;
+    forceLive?: boolean;
+}
+export interface SearchResultInput {
+    jobId: string;
+    waitMs?: number;
+    limit?: number;
+    format?: 'text' | 'html';
+    /** Internal constraint set by the server profile, never a caller-controlled tool argument. */
+    expectedKind?: JobKind;
+}
+export interface FetchPageInput {
+    url: string;
+    format?: 'text' | 'html';
+    waitMs?: number;
+    forceLive?: boolean;
+}
+export interface SearchServiceLike {
+    seoReport?(name: SeoToolName, input: Record<string, unknown>, signal?: AbortSignal): Promise<object>;
+    search(input: SearchInput, signal?: AbortSignal): Promise<object>;
+    fetchPage(input: FetchPageInput, signal?: AbortSignal): Promise<object>;
+    getSearchResult(input: SearchResultInput, signal?: AbortSignal): Promise<object>;
+}

package/dist/src/product-contract.js

@@ -0,0 +1,29 @@
+export const SERVER_VERSION = '0.14.0';
+export const PRODUCT_PROFILES = {
+    combined: {
+        name: 'georanker-search-mcp',
+        title: 'GeoRanker Search MCP',
+        endpoint: '/mcp',
+        searchTool: 'search',
+        fetchTool: 'fetch_page',
+        resultTool: 'get_search_result',
+    },
+    seo: {
+        name: 'georanker-seo-mcp',
+        title: 'SEO & SERP MCP by GeoRanker',
+        endpoint: '/seo/mcp',
+        searchTool: 'search_serps',
+        resultTool: 'get_serp_result',
+    },
+    scraping: {
+        name: 'georanker-web-scraping-mcp',
+        title: 'Web Scraping MCP by GeoRanker',
+        endpoint: '/scraping/mcp',
+        fetchTool: 'fetch_page',
+        resultTool: 'get_fetch_result',
+    },
+};
+export function profileForEndpoint(path) {
+    return Object.keys(PRODUCT_PROFILES)
+        .find(profile => PRODUCT_PROFILES[profile].endpoint === path);
+}

package/dist/src/product.d.ts

@@ -0,0 +1,3 @@
+export declare const CLIENT_PROFILE: "seo";
+export declare const CLIENT_REPOSITORY: "georanker/georanker-seo-mcp";
+export declare const CLIENT_VERSION: "0.14.0";

package/dist/src/product.js

@@ -0,0 +1,4 @@
+// Fixed product identity; users install the other package for the other audience.
+export const CLIENT_PROFILE = 'seo';
+export const CLIENT_REPOSITORY = 'georanker/georanker-seo-mcp';
+export const CLIENT_VERSION = '0.14.0';

package/dist/src/remote.d.ts

@@ -0,0 +1,20 @@
+export { deviceFingerprint } from './identity.js';
+import { type ProductProfile, type SearchServiceLike, type SearchInput, type SearchResultInput, type FetchPageInput } from './product-contract.js';
+import { type SeoToolName } from './seo-contract.js';
+export declare const PILOT_MCP_URL = "https://grmcp.ibl.ro/mcp";
+export declare class RemoteService implements SearchServiceLike {
+    private readonly env;
+    private readonly profile;
+    private connection?;
+    private readonly url;
+    private headers?;
+    constructor(env: NodeJS.ProcessEnv, profile?: ProductProfile);
+    private connect;
+    initialize(): Promise<void>;
+    private call;
+    search(input: SearchInput, signal?: AbortSignal): Promise<object>;
+    seoReport(name: SeoToolName, input: Record<string, unknown>, signal?: AbortSignal): Promise<object>;
+    fetchPage(input: FetchPageInput, signal?: AbortSignal): Promise<object>;
+    getSearchResult(input: SearchResultInput, signal?: AbortSignal): Promise<object>;
+    close(): Promise<void>;
+}