recker 1.0.79 → 1.0.80-next.70ea84d

package/dist/cli/utils/serp-campaign.js

@@ -0,0 +1,53 @@
+import { runCrawlerSerpCampaign } from '../handlers/seo.js';
+export async function runSpiderKeywordCampaign(targetUrl, pages, config) {
+    const normalizedPages = pages.map((page) => ({
+        url: page.url,
+        seoReport: page.seoReport,
+    }));
+    return runCrawlerSerpCampaign(targetUrl, normalizedPages, config);
+}
+function toKeywordCampaignResult(item) {
+    return {
+        keyword: item.keyword,
+        found: Boolean(item.found),
+        position: item.bestPosition,
+        targetUrl: item.matchedUrl,
+        searchUrl: item.searchUrl,
+    };
+}
+function toSerpSeedMap(plan) {
+    return plan.map((seed) => ({
+        keyword: seed.keyword,
+        sourcePage: seed.sourcePage,
+        sourceWeight: seed.sourceWeight,
+    }));
+}
+export function toSerpPayload(campaign) {
+    return {
+        summary: {
+            queriesRequested: campaign.campaign.summary.queriesRequested,
+            queriesExecuted: campaign.campaign.summary.queriesExecuted,
+            queriesFound: campaign.campaign.summary.queriesFound,
+            avgTopPosition: campaign.campaign.summary.avgTopPosition,
+            top3Count: campaign.campaign.summary.top3Count,
+            top10Count: campaign.campaign.summary.top10Count,
+            topOrganicCompetitors: campaign.campaign.summary.topOrganicCompetitors,
+        },
+        campaign: campaign.campaign.campaign,
+        results: campaign.campaign.results.slice(0, 12).map((item) => toKeywordCampaignResult(item)),
+        pageComparison: campaign.campaign.pageComparison.map((item) => ({
+            pageUrl: item.pageUrl,
+            tracked: item.tracked,
+            found: item.found,
+            appearanceRate: `${item.appearanceRate.toFixed(1)}%`,
+            avgPosition: item.avgPosition === null ? 'n/a' : String(item.avgPosition),
+            top3: item.top3,
+            top10: item.top10,
+        })),
+        seedPlan: {
+            short: toSerpSeedMap(campaign.plan.short),
+            longTail: toSerpSeedMap(campaign.plan.longTail),
+            ordered: toSerpSeedMap(campaign.plan.ordered),
+        },
+    };
+}

package/dist/cli/utils/serp-config.d.ts

@@ -0,0 +1,26 @@
+import type { GoogleSearchAdvancedOptions } from '../../search/google.js';
+export declare const DEFAULT_SERP_KEYWORD_LIMIT = 5;
+export declare const DEFAULT_SERP_MAX_RESULTS = 10;
+export declare const DEFAULT_SERP_CONCURRENCY = 1;
+export declare const DEFAULT_SERP_DELAY_MS = 1200;
+export declare const DEFAULT_SERP_JITTER_MS = 450;
+export declare const DEFAULT_SERP_CAPTCHA_COOLDOWN_MS = 2400;
+export declare const DEFAULT_SERP_MAX_CONSECUTIVE_BLOCKS = 3;
+export declare const DEFAULT_SERP_RETRY_COUNT = 1;
+export declare const DEFAULT_SERP_RETRY_DELAY_MS = 1200;
+export declare const DEFAULT_SERP_HUMAN_PROFILE: 'chrome' | 'off';
+export interface SpiderSerpOptionConfig {
+    enabled: boolean;
+    topKeywordsLimit: number;
+    queriesLimit: number;
+    resultsPerQuery: number;
+    searchConcurrency: number;
+    searchDelayMs: number;
+    searchDelayJitterMs: number;
+    searchCaptchaCooldownMs: number;
+    searchMaxConsecutiveBlocks?: number;
+    searchRetryCount: number;
+    searchRetryDelayMs: number;
+    searchOptions: GoogleSearchAdvancedOptions;
+}
+export declare function parseSpiderSerpConfig(options: Record<string, unknown>): SpiderSerpOptionConfig;

package/dist/cli/utils/serp-config.js

@@ -0,0 +1,125 @@
+import { getOptionValue, toOptionString, toNonNegativeInt, } from './option-helpers.js';
+export const DEFAULT_SERP_KEYWORD_LIMIT = 5;
+export const DEFAULT_SERP_MAX_RESULTS = 10;
+export const DEFAULT_SERP_CONCURRENCY = 1;
+export const DEFAULT_SERP_DELAY_MS = 1200;
+export const DEFAULT_SERP_JITTER_MS = 450;
+export const DEFAULT_SERP_CAPTCHA_COOLDOWN_MS = 2400;
+export const DEFAULT_SERP_MAX_CONSECUTIVE_BLOCKS = 3;
+export const DEFAULT_SERP_RETRY_COUNT = 1;
+export const DEFAULT_SERP_RETRY_DELAY_MS = 1_200;
+export const DEFAULT_SERP_HUMAN_PROFILE = 'chrome';
+function toSearchTransport(value) {
+    const raw = toOptionString(value)?.toLowerCase();
+    if (raw === 'auto' || raw === 'undici' || raw === 'curl')
+        return raw;
+    return 'curl';
+}
+function toSerpSearchSource(value) {
+    const raw = toOptionString(value)?.toLowerCase();
+    return raw === 'google' ? 'google' : 'google';
+}
+function parseSerpExtraParams(value) {
+    const raw = toOptionString(value);
+    if (!raw)
+        return undefined;
+    const params = {};
+    const chunks = raw.includes('&')
+        ? raw.split('&')
+        : raw.includes(';')
+            ? raw.split(';')
+            : raw.split(',');
+    for (const chunk of chunks) {
+        const pair = chunk.trim();
+        if (!pair)
+            continue;
+        const idx = pair.indexOf('=');
+        if (idx <= 0)
+            continue;
+        const key = pair.slice(0, idx).trim();
+        const value = pair.slice(idx + 1).trim();
+        if (!key || !value)
+            continue;
+        if (/^(true|false)$/i.test(value)) {
+            params[key] = value.toLowerCase() === 'true';
+            continue;
+        }
+        const numberValue = Number(value);
+        if (Number.isFinite(numberValue)) {
+            params[key] = numberValue;
+            continue;
+        }
+        params[key] = value;
+    }
+    return Object.keys(params).length > 0 ? params : undefined;
+}
+function parseSerpHumanProfile(value) {
+    if (typeof value !== 'string') {
+        return DEFAULT_SERP_HUMAN_PROFILE;
+    }
+    const normalized = value.trim().toLowerCase();
+    if (!normalized || normalized === 'off' || normalized === 'false' || normalized === 'none' || normalized === '0') {
+        return 'off';
+    }
+    if (normalized === 'chrome' || normalized === 'browser' || normalized === 'human') {
+        return 'chrome';
+    }
+    if (normalized === 'default' || normalized === 'on' || normalized === 'true' || normalized === '1') {
+        return 'chrome';
+    }
+    return DEFAULT_SERP_HUMAN_PROFILE;
+}
+export function parseSpiderSerpConfig(options) {
+    const enabled = Boolean(getOptionValue(options, 'serp', 'serpEnabled'));
+    const topKeywordsLimit = toNonNegativeInt(getOptionValue(options, 'serpTopKeywords', 'serp-top-keywords'), DEFAULT_SERP_KEYWORD_LIMIT);
+    const queriesLimit = toNonNegativeInt(getOptionValue(options, 'serpQueryLimit', 'serp-query-limit'), DEFAULT_SERP_MAX_RESULTS);
+    const resultsPerQuery = toNonNegativeInt(getOptionValue(options, 'serpResultsPerQuery', 'serp-results-per-query'), DEFAULT_SERP_MAX_RESULTS);
+    const searchConcurrency = toNonNegativeInt(getOptionValue(options, 'serpConcurrency', 'serp-concurrency'), DEFAULT_SERP_CONCURRENCY);
+    const searchDelayMs = toNonNegativeInt(getOptionValue(options, 'serpDelayMs', 'serp-delay-ms', 'serpDelay'), DEFAULT_SERP_DELAY_MS);
+    const searchDelayJitterMs = toNonNegativeInt(getOptionValue(options, 'serpDelayJitterMs', 'serp-delay-jitter-ms', 'serpJitterMs'), DEFAULT_SERP_JITTER_MS);
+    const searchCaptchaCooldownMs = toNonNegativeInt(getOptionValue(options, 'serpCaptchaCooldownMs', 'serp-captcha-cooldown-ms', 'serpCaptchaCooldown'), DEFAULT_SERP_CAPTCHA_COOLDOWN_MS);
+    const searchMaxConsecutiveBlocks = toNonNegativeInt(getOptionValue(options, 'serpMaxConsecutiveBlocks', 'serp-max-consecutive-blocks'), DEFAULT_SERP_MAX_CONSECUTIVE_BLOCKS);
+    const searchRetryCount = toNonNegativeInt(getOptionValue(options, 'serpRetryCount', 'serp-retry-count', 'serpRetries'), DEFAULT_SERP_RETRY_COUNT);
+    const searchRetryDelayMs = toNonNegativeInt(getOptionValue(options, 'serpRetryDelayMs', 'serp-retry-delay-ms', 'serpRetryDelay'), DEFAULT_SERP_RETRY_DELAY_MS);
+    const searchSource = toSerpSearchSource(getOptionValue(options, 'serpSource', 'serp-source'));
+    const country = getOptionValue(options, 'serpCountry', 'serp-country', 'serpRegion', 'serp-region');
+    return {
+        enabled,
+        topKeywordsLimit: topKeywordsLimit > 0 ? topKeywordsLimit : DEFAULT_SERP_KEYWORD_LIMIT,
+        queriesLimit: queriesLimit > 0 ? queriesLimit : DEFAULT_SERP_MAX_RESULTS,
+        resultsPerQuery: resultsPerQuery > 0 ? resultsPerQuery : DEFAULT_SERP_MAX_RESULTS,
+        searchConcurrency: searchConcurrency > 0 ? searchConcurrency : DEFAULT_SERP_CONCURRENCY,
+        searchDelayMs: searchDelayMs > 0 ? searchDelayMs : DEFAULT_SERP_DELAY_MS,
+        searchDelayJitterMs: searchDelayJitterMs > 0 ? searchDelayJitterMs : DEFAULT_SERP_JITTER_MS,
+        searchCaptchaCooldownMs: searchCaptchaCooldownMs > 0 ? searchCaptchaCooldownMs : DEFAULT_SERP_CAPTCHA_COOLDOWN_MS,
+        searchMaxConsecutiveBlocks: searchMaxConsecutiveBlocks >= 0
+            ? searchMaxConsecutiveBlocks
+            : DEFAULT_SERP_MAX_CONSECUTIVE_BLOCKS,
+        searchRetryCount: searchRetryCount >= 0 ? searchRetryCount : DEFAULT_SERP_RETRY_COUNT,
+        searchRetryDelayMs: searchRetryDelayMs > 0 ? searchRetryDelayMs : DEFAULT_SERP_RETRY_DELAY_MS,
+        searchOptions: {
+            transport: toSearchTransport(getOptionValue(options, 'serpTransport', 'serp-transport')),
+            source: searchSource,
+            timeout: toNonNegativeInt(getOptionValue(options, 'serpTimeout', 'serp-timeout'), 0) || undefined,
+            country: toOptionString(country),
+            gl: toOptionString(getOptionValue(options, 'serpGl', 'serp-gl')),
+            hl: toOptionString(getOptionValue(options, 'serpHl', 'serp-hl')),
+            safe: toOptionString(getOptionValue(options, 'serpSafe', 'serp-safe')),
+            as_q: toOptionString(getOptionValue(options, 'serpAsQ', 'serp-as-q')),
+            as_epq: toOptionString(getOptionValue(options, 'serpAsEpq', 'serp-as-epq', 'serpAsEpq')),
+            as_oq: toOptionString(getOptionValue(options, 'serpAsOq', 'serp-as-oq')),
+            as_eq: toOptionString(getOptionValue(options, 'serpAsEq', 'serp-as-eq')),
+            as_sitesearch: toOptionString(getOptionValue(options, 'serpAsSitesearch', 'serp-as-sitesearch', 'serpAsSitesearch')),
+            as_filetype: toOptionString(getOptionValue(options, 'serpAsFiletype', 'serp-as-filetype', 'serpAsFiletype')),
+            as_rights: toOptionString(getOptionValue(options, 'serpAsRights', 'serp-as-rights', 'serpAsRights')),
+            as_nlo: toOptionString(getOptionValue(options, 'serpAsNlo', 'serp-as-nlo', 'serpNlo')),
+            as_nhi: toOptionString(getOptionValue(options, 'serpAsNhi', 'serp-as-nhi', 'serpNhi')),
+            humanProfile: parseSerpHumanProfile(getOptionValue(options, 'serpHumanProfile', 'serp-human-profile')),
+            lr: toOptionString(getOptionValue(options, 'serpLr', 'serp-lr')),
+            cr: toOptionString(getOptionValue(options, 'serpCr', 'serp-cr')),
+            tbs: toOptionString(getOptionValue(options, 'serpTbs', 'serp-tbs')),
+            tbm: toOptionString(getOptionValue(options, 'serpTbm', 'serp-tbm')),
+            extraParams: parseSerpExtraParams(getOptionValue(options, 'serpExtra', 'serp-extra')),
+        },
+    };
+}

package/dist/core/client.d.ts

@@ -22,6 +22,7 @@ interface BatchRequestOptions<T = ReckerResponse> {
     signal?: AbortSignal;
     deadlineMs?: number;
 }
+type RequestWithBodyOptions = Omit<RequestOptions, 'method'>;
 export interface ExtendedClientOptions extends ClientOptions {
     retry?: RetryOptions;
     cache?: ClientCacheConfig;
@@ -36,6 +37,7 @@ export declare class Client {
     private hooks;
     private transport;
     private curlTransport?;
+    private proxyConfig?;
     private defaultHeaders;
     private defaultHeadersObj;
     private defaultParams;
@@ -104,28 +106,31 @@ export declare class Client {
         };
     }>;
     private requestWithBody;
-    post<T = unknown>(path: string, body?: any, options?: Omit<RequestOptions, 'method' | 'body'>): RequestPromise<T>;
-    put<T = unknown>(path: string, body?: any, options?: Omit<RequestOptions, 'method' | 'body'>): RequestPromise<T>;
-    patch<T = unknown>(path: string, body?: any, options?: Omit<RequestOptions, 'method' | 'body'>): RequestPromise<T>;
+    post<T = unknown>(path: string, options?: RequestWithBodyOptions): RequestPromise<T>;
+    post<T = unknown>(path: string, body?: unknown, options?: RequestWithBodyOptions): RequestPromise<T>;
+    put<T = unknown>(path: string, options?: RequestWithBodyOptions): RequestPromise<T>;
+    put<T = unknown>(path: string, body?: unknown, options?: RequestWithBodyOptions): RequestPromise<T>;
+    patch<T = unknown>(path: string, options?: RequestWithBodyOptions): RequestPromise<T>;
+    patch<T = unknown>(path: string, body?: unknown, options?: RequestWithBodyOptions): RequestPromise<T>;
     delete<T = unknown>(path: string, options?: Omit<RequestOptions, 'method'>): RequestPromise<T>;
     head<T = unknown>(path: string, options?: Omit<RequestOptions, 'method'>): RequestPromise<T>;
     options<T = unknown>(path: string, options?: Omit<RequestOptions, 'method'>): RequestPromise<T>;
     trace<T = unknown>(path: string, options?: Omit<RequestOptions, 'method'>): RequestPromise<T>;
     connect<T = unknown>(path: string, options?: Omit<RequestOptions, 'method'>): RequestPromise<T>;
     purge<T = unknown>(path: string, options?: Omit<RequestOptions, 'method'>): RequestPromise<T>;
-    propfind<T = unknown>(path: string, body?: any, options?: Omit<RequestOptions, 'method' | 'body'>): RequestPromise<T>;
-    proppatch<T = unknown>(path: string, body?: any, options?: Omit<RequestOptions, 'method' | 'body'>): RequestPromise<T>;
+    propfind<T = unknown>(path: string, body?: unknown, options?: RequestWithBodyOptions): RequestPromise<T>;
+    proppatch<T = unknown>(path: string, body?: unknown, options?: RequestWithBodyOptions): RequestPromise<T>;
     mkcol<T = unknown>(path: string, options?: Omit<RequestOptions, 'method'>): RequestPromise<T>;
     copy<T = unknown>(path: string, options?: Omit<RequestOptions, 'method'>): RequestPromise<T>;
     move<T = unknown>(path: string, options?: Omit<RequestOptions, 'method'>): RequestPromise<T>;
-    lock<T = unknown>(path: string, body?: any, options?: Omit<RequestOptions, 'method' | 'body'>): RequestPromise<T>;
+    lock<T = unknown>(path: string, body?: unknown, options?: RequestWithBodyOptions): RequestPromise<T>;
     unlock<T = unknown>(path: string, options?: Omit<RequestOptions, 'method'>): RequestPromise<T>;
-    link<T = unknown>(path: string, body?: any, options?: Omit<RequestOptions, 'method' | 'body'>): RequestPromise<T>;
-    unlink<T = unknown>(path: string, body?: any, options?: Omit<RequestOptions, 'method' | 'body'>): RequestPromise<T>;
+    link<T = unknown>(path: string, body?: unknown, options?: RequestWithBodyOptions): RequestPromise<T>;
+    unlink<T = unknown>(path: string, body?: unknown, options?: RequestWithBodyOptions): RequestPromise<T>;
     scrape(path: string, options?: RequestOptions): ScrapePromise<ReckerResponse>;
     paginate<T>(path: string, options?: RequestOptions & PaginationOptions<T>): AsyncGenerator<T>;
-    pages<T = any>(path: string, options?: RequestOptions & PaginationOptions): AsyncGenerator<PageResult<T>>;
-    page<T = any>(path: string, pageNumber: number, options?: RequestOptions & {
+    pages<T = unknown>(path: string, options?: RequestOptions & PaginationOptions): AsyncGenerator<PageResult<T>>;
+    page<T = unknown>(path: string, pageNumber: number, options?: RequestOptions & {
         pageParam?: string;
     }): RequestPromise<T>;
     getAll<T>(path: string, options?: RequestOptions & PaginationOptions<T>): Promise<T[]>;

package/dist/core/client.js

@@ -28,8 +28,34 @@ import { ReckerWebSocket } from '../websocket/client.js';
 import { whois as performWhois, isDomainAvailable } from '../utils/whois.js';
 import { MemoryCookieJar } from '../cookies/memory-cookie-jar.js';
 import { scrape as scrapeHelper } from '../plugins/scrape.js';
+const toError = (error) => error instanceof Error ? error : new Error(String(error));
+const BODY_OPTION_HINTS = [
+    'json',
+    'form',
+    'xml',
+    'yaml',
+    'csv',
+    'body',
+    'headers',
+    'timeout',
+    'retry',
+    'hooks',
+    'searchParams',
+    'params',
+    'beforeRedirect',
+    'maxRedirects',
+    'followRedirects',
+    'http2',
+    'useCurl',
+];
 function isNodeRuntime() {
-    return typeof globalThis !== 'undefined' && Boolean(globalThis.process?.versions?.node);
+    const maybeNodeGlobal = globalThis;
+    return typeof globalThis !== 'undefined' && Boolean(maybeNodeGlobal.process?.versions?.node);
+}
+function isRequestWithBodyOptions(value) {
+    if (!isPlainObject(value))
+        return false;
+    return BODY_OPTION_HINTS.some((key) => Object.prototype.hasOwnProperty.call(value, key));
 }
 class LazyTransport {
     factory;
@@ -67,7 +93,7 @@ class LazyTransport {
         await this.resolving;
     }
 }
-function createLazyCurlTransport() {
+function createLazyCurlTransport(proxy) {
     if (!isNodeRuntime()) {
         return {
             async dispatch(req) {
@@ -77,7 +103,7 @@ function createLazyCurlTransport() {
     }
     return new LazyTransport(async () => {
         const { CurlTransport } = await import('../transport/curl.js');
-        return new CurlTransport();
+        return new CurlTransport(proxy);
     });
 }
 class LazyCacheStorage {
@@ -179,6 +205,7 @@ export class Client {
     hooks;
     transport;
     curlTransport;
+    proxyConfig;
     defaultHeaders;
     defaultHeadersObj;
     defaultParams;
@@ -222,6 +249,7 @@ export class Client {
         this.defaultParams = options.defaults?.params || {};
         this.paginationConfig = options.pagination;
         this.maxResponseSize = options.maxResponseSize;
+        this.proxyConfig = options.proxy;
         const runtimeEventBus = options.runtimeEventBus;
         if (runtimeEventBus) {
             this.runtimeEventBus = {
@@ -254,7 +282,7 @@ export class Client {
         else if (options.useCurl) {
             if (this.debugEnabled)
                 console.log('[DEBUG] Using Curl Transport');
-            this.transport = createLazyCurlTransport();
+            this.transport = createLazyCurlTransport(options.proxy);
             this.transportKind = 'curl';
         }
         else if (isNodeRuntime()) {
@@ -290,8 +318,9 @@ export class Client {
             this.transportKind = 'undici';
         }
         else {
-            if (this.debugEnabled)
-                console.log('[DEBUG] Using Fetch Transport');
+            if (this.debugEnabled && this.logger) {
+                this.logger.debug('Using Fetch Transport');
+            }
             this.transport = new FetchTransport();
             this.transportKind = 'fetch';
         }
@@ -317,7 +346,8 @@ export class Client {
                 interval: this.concurrencyConfig.interval
             });
             registerPlugin((client) => {
-                client.middlewares.unshift(this.requestPool.asMiddleware());
+                const pluginClient = client;
+                pluginClient.middlewares?.unshift(this.requestPool.asMiddleware());
             }, {
                 name: 'recker:request-pool',
                 priority: 130,
@@ -525,7 +555,7 @@ export class Client {
         try {
             if (req.useCurl && this.transportKind !== 'curl') {
                 if (!this.curlTransport) {
-                    this.curlTransport = createLazyCurlTransport();
+                    this.curlTransport = createLazyCurlTransport(this.proxyConfig);
                 }
                 const response = await this.curlTransport.dispatch(req);
                 if (context) {
@@ -552,7 +582,7 @@ export class Client {
                 this.runtimeEventBus.emit('transport:error', {
                     context,
                     req,
-                    error: error instanceof Error ? error : new Error(String(error))
+                    error: toError(error)
                 });
             }
             throw error;
@@ -768,7 +798,7 @@ export class Client {
                     });
                     return response;
                 }, (error) => {
-                    const requestError = error instanceof Error ? error : new Error(String(error));
+                    const requestError = toError(error);
                     this.runtimeEventBus.emit('request:failed', {
                         context: requestContext,
                         req,
@@ -849,7 +879,7 @@ export class Client {
                 });
                 return response;
             }, (error) => {
-                const requestError = error instanceof Error ? error : new Error(String(error));
+                const requestError = toError(error);
                 this.runtimeEventBus.emit('request:failed', {
                     context: requestContext,
                     req,
@@ -873,8 +903,9 @@ export class Client {
         return this.request(path, { ...options, method: 'GET' });
     }
     async warmup() {
-        if (this.transport && 'warmup' in this.transport && typeof this.transport.warmup === 'function') {
-            await this.transport.warmup();
+        const transport = this.transport;
+        if (transport?.warmup) {
+            await transport.warmup();
         }
     }
     async batch(requests, options = {}) {
@@ -899,29 +930,14 @@ export class Client {
     }
     requestWithBody(method, path, bodyOrOptions, options) {
         let actualBody = bodyOrOptions;
-        let actualOptions = options;
-        const isOptionsEmpty = actualOptions === undefined ||
-            (typeof actualOptions === 'object' && actualOptions !== null && Object.keys(actualOptions).length === 0);
-        if (isOptionsEmpty && isPlainObject(bodyOrOptions)) {
-            const potentialOptions = bodyOrOptions;
-            if (potentialOptions.json !== undefined ||
-                potentialOptions.form !== undefined ||
-                potentialOptions.xml !== undefined ||
-                potentialOptions.yaml !== undefined ||
-                potentialOptions.csv !== undefined ||
-                potentialOptions.body !== undefined ||
-                potentialOptions.headers !== undefined ||
-                potentialOptions.timeout !== undefined ||
-                potentialOptions.retry !== undefined ||
-                potentialOptions.hooks !== undefined ||
-                potentialOptions.searchParams !== undefined ||
-                potentialOptions.params !== undefined) {
-                actualOptions = bodyOrOptions;
-                actualBody = undefined;
-            }
-        }
-        actualOptions = actualOptions || {};
-        const { json, form, xml, yaml, csv, ...restOptions } = actualOptions;
+        let actualOptions = options || {};
+        const isOptionsEmpty = options === undefined
+            || (isPlainObject(options) && Object.keys(options).length === 0);
+        if (isOptionsEmpty && isRequestWithBodyOptions(bodyOrOptions)) {
+            actualOptions = bodyOrOptions;
+            actualBody = undefined;
+        }
+        const { json, form, xml, yaml, csv, body: explicitBody, ...restOptions } = actualOptions;
         let finalBody = actualBody;
         let explicitContentType;
         if (form !== undefined) {
@@ -944,8 +960,8 @@ export class Client {
             finalBody = serializeCsv(csv);
             explicitContentType = 'text/csv';
         }
-        else if (restOptions.body !== undefined) {
-            finalBody = restOptions.body;
+        else if (explicitBody !== undefined) {
+            finalBody = explicitBody;
         }
         const { body: processedBody, contentType } = processBody(finalBody);
         const headers = new Headers(restOptions.headers);

package/dist/index.d.ts

@@ -74,6 +74,7 @@ export * from './utils/concurrency.js';
 export * as presets from './presets/index.js';
 export * as testing from './testing/index.js';
 export * as protocols from './protocols/index.js';
+export * from './raffel/index.js';
 export * from './mcp/client.js';
 export * from './mcp/contract.js';
 export * as template from './template/index.js';

package/dist/index.js

@@ -74,6 +74,7 @@ export * from './utils/concurrency.js';
 export * as presets from './presets/index.js';
 export * as testing from './testing/index.js';
 export * as protocols from './protocols/index.js';
+export * from './raffel/index.js';
 export * from './mcp/client.js';
 export * from './mcp/contract.js';
 export * as template from './template/index.js';

package/dist/mcp/cli.js

@@ -3,6 +3,7 @@ import { RekCommand as Command } from '../cli/router.js';
 import { MCPServer } from './server.js';
 import { listCategories, DEFAULT_CATEGORY, validateCategories, estimateCategoryTokens, } from './profiles.js';
 import { LEGACY_TOOL_GROUPS } from './legacy-tool-groups.js';
+import { consoleLogger } from '../types/logger.js';
 const program = new Command('recker-mcp');
 program
     .description('Start the Recker MCP server for AI agent integration')
@@ -29,25 +30,25 @@ program
     opts.transport = opts.transport || 'stdio';
     opts.port = opts.port || '3100';
     if (opts.listCategories) {
-        console.log('╔═══════════════════════════════════════════════════════════════════╗');
-        console.log('║                    Recker MCP Categories                          ║');
-        console.log('╚═══════════════════════════════════════════════════════════════════╝');
-        console.log('');
-        console.log('Available categories:');
-        console.log('');
+        consoleLogger.info('╔═══════════════════════════════════════════════════════════════════╗');
+        consoleLogger.info('║                    Recker MCP Categories                          ║');
+        consoleLogger.info('╚═══════════════════════════════════════════════════════════════════╝');
+        consoleLogger.info('');
+        consoleLogger.info('Available categories:');
+        consoleLogger.info('');
         for (const category of listCategories()) {
             const toolCount = category.toolCount === -1 ? 'all' : category.toolCount;
             const icon = category.icon || '📦';
-            console.log(`  ${icon} ${category.name.padEnd(12)} ${category.description}`);
-            console.log(`               Tools: ${toolCount}, ~${category.estimatedTokens} tokens`);
-            console.log('');
+            consoleLogger.info(`  ${icon} ${category.name.padEnd(12)} ${category.description}`);
+            consoleLogger.info(`               Tools: ${toolCount}, ~${category.estimatedTokens} tokens`);
+            consoleLogger.info('');
         }
-        console.log('Usage examples:');
-        console.log('  recker-mcp                                # Default: minimal category');
-        console.log('  recker-mcp --category=minimal,seo         # Combine categories');
-        console.log('  recker-mcp -c seo,security                # Short form');
-        console.log('  recker-mcp --category=full                # All tools (high context)');
-        console.log('');
+        consoleLogger.info('Usage examples:');
+        consoleLogger.info('  recker-mcp                                # Default: minimal category');
+        consoleLogger.info('  recker-mcp --category=minimal,seo         # Combine categories');
+        consoleLogger.info('  recker-mcp -c seo,security                # Short form');
+        consoleLogger.info('  recker-mcp --category=full                # All tools (high context)');
+        consoleLogger.info('');
         process.exit(0);
     }
     const useExplicitCategory = Boolean(opts.category);
@@ -55,8 +56,8 @@ program
         const categoryNames = opts.category.split(',').map((p) => p.trim());
         const validation = validateCategories(categoryNames);
         if (!validation.valid) {
-            console.error(`Invalid category(s): ${validation.invalid.join(', ')}`);
-            console.error('Use --list-categories to see available categories');
+            consoleLogger.error(`Invalid category(s): ${validation.invalid.join(', ')}`);
+            consoleLogger.error('Use --list-categories to see available categories');
             process.exit(1);
         }
     }
@@ -97,7 +98,7 @@ program
     const transport = opts.transport;
     const port = parseInt(opts.port, 10);
     if (!['stdio', 'http', 'sse'].includes(transport)) {
-        console.error(`Invalid transport mode: ${transport}. Use: stdio, http, or sse`);
+        consoleLogger.error(`Invalid transport mode: ${transport}. Use: stdio, http, or sse`);
         process.exit(1);
     }
     const effectiveCategory = useExplicitCategory ? opts.category : (!opts.only && !opts.filter ? DEFAULT_CATEGORY : undefined);
@@ -112,25 +113,25 @@ program
         toolsFilter: !effectiveCategory && toolsFilter.length > 0 ? toolsFilter : undefined,
     });
     if (transport !== 'stdio') {
-        console.log('╔═══════════════════════════════════════════════════════════════════╗');
-        console.log('║                    Recker MCP Server                              ║');
-        console.log('╚═══════════════════════════════════════════════════════════════════╝');
-        console.log('');
-        console.log(`  Transport: ${transport}`);
-        console.log(`  Port:      ${port}`);
-        console.log(`  Debug:     ${opts.debug ? 'enabled' : 'disabled'}`);
+        consoleLogger.info('╔═══════════════════════════════════════════════════════════════════╗');
+        consoleLogger.info('║                    Recker MCP Server                              ║');
+        consoleLogger.info('╚═══════════════════════════════════════════════════════════════════╝');
+        consoleLogger.info('');
+        consoleLogger.info(`  Transport: ${transport}`);
+        consoleLogger.info(`  Port:      ${port}`);
+        consoleLogger.info(`  Debug:     ${opts.debug ? 'enabled' : 'disabled'}`);
         if (effectiveCategory) {
             const tokens = estimateCategoryTokens(effectiveCategory);
-            console.log(`  Category:  ${effectiveCategory} (~${tokens} tokens)`);
+            consoleLogger.info(`  Category:  ${effectiveCategory} (~${tokens} tokens)`);
         }
         else if (toolsFilter.length > 0) {
-            console.log(`  Filters:   ${toolsFilter.join(', ')}`);
+            consoleLogger.info(`  Filters:   ${toolsFilter.join(', ')}`);
         }
         else {
-            console.log(`  Category:  minimal (default)`);
+            consoleLogger.info('  Category:  minimal (default)');
         }
-        console.log('');
-        console.log('  Available tools:');
+        consoleLogger.info('');
+        consoleLogger.info('  Available tools:');
         const allTools = [
             ...LEGACY_TOOL_GROUPS.docs,
             ...LEGACY_TOOL_GROUPS.network,
@@ -148,15 +149,15 @@ program
             return positive.includes(tool);
         });
         enabledTools.forEach(tool => {
-            console.log(`    ✓ ${tool}`);
+            consoleLogger.info(`    ✓ ${tool}`);
         });
         const disabledTools = allTools.filter(t => !enabledTools.includes(t));
         if (disabledTools.length > 0) {
-            disabledTools.forEach(tool => {
-                console.log(`    ✗ ${tool} (disabled)`);
+            disabledTools.forEach((tool) => {
+                consoleLogger.info(`    ✗ ${tool} (disabled)`);
             });
         }
-        console.log('');
+        consoleLogger.info('');
     }
     await server.start();
 });

package/dist/mcp/client.d.ts

@@ -1,5 +1,5 @@
 import { EventEmitter } from 'events';
-import type { MCPServerInfo, MCPTool, MCPToolResult, MCPResource, MCPResourceContent, MCPPrompt, MCPPromptMessage } from './types.js';
+import type { MCPServerInfo, MCPTool, MCPToolResult, MCPResource, MCPResourceContent, MCPPrompt, MCPPromptMessage, MCPTransportOptions } from './types.js';
 export interface MCPClientOptions {
     endpoint: string;
     clientName?: string;
@@ -9,7 +9,7 @@ export interface MCPClientOptions {
     timeout?: number;
     retries?: number;
     debug?: boolean;
-    transport?: any;
+    transport?: MCPTransportOptions['transport'];
 }
 interface ResolvedMCPClientOptions {
     endpoint: string;