recker 1.0.29-next.3524ab6 → 1.0.29-next.cf0cafb

package/dist/ai/memory.d.ts

@@ -0,0 +1,35 @@
+import type { ChatMessage } from '../types/ai.js';
+import type { AIMemoryConfig } from '../types/ai-client.js';
+export declare class ConversationMemory {
+    private config;
+    private systemMessage;
+    private messages;
+    constructor(config?: AIMemoryConfig);
+    setSystemPrompt(prompt: string): void;
+    getSystemPrompt(): string;
+    addUserMessage(content: string): void;
+    addAssistantMessage(content: string): void;
+    addMessage(message: ChatMessage): void;
+    buildMessages(userPrompt: string): ChatMessage[];
+    recordResponse(content: string): void;
+    getMessages(): ChatMessage[];
+    getConversation(): readonly ChatMessage[];
+    getPairCount(): number;
+    clear(): void;
+    reset(): void;
+    setConfig(config: Partial<AIMemoryConfig>): void;
+    getConfig(): AIMemoryConfig;
+    private prune;
+    isEmpty(): boolean;
+    getMessageCount(): number;
+    toJSON(): {
+        config: AIMemoryConfig;
+        systemPrompt: string | null;
+        messages: ChatMessage[];
+    };
+    static fromJSON(data: {
+        config?: AIMemoryConfig;
+        systemPrompt?: string | null;
+        messages?: ChatMessage[];
+    }): ConversationMemory;
+}

package/dist/ai/memory.js

@@ -0,0 +1,136 @@
+const DEFAULT_MAX_PAIRS = 12;
+export class ConversationMemory {
+    config;
+    systemMessage = null;
+    messages = [];
+    constructor(config = {}) {
+        this.config = {
+            maxPairs: config.maxPairs ?? DEFAULT_MAX_PAIRS,
+            systemPrompt: config.systemPrompt ?? '',
+        };
+        if (this.config.systemPrompt) {
+            this.systemMessage = {
+                role: 'system',
+                content: this.config.systemPrompt,
+            };
+        }
+    }
+    setSystemPrompt(prompt) {
+        this.config.systemPrompt = prompt;
+        if (prompt) {
+            this.systemMessage = {
+                role: 'system',
+                content: prompt,
+            };
+        }
+        else {
+            this.systemMessage = null;
+        }
+    }
+    getSystemPrompt() {
+        return this.config.systemPrompt;
+    }
+    addUserMessage(content) {
+        this.messages.push({
+            role: 'user',
+            content,
+        });
+        this.prune();
+    }
+    addAssistantMessage(content) {
+        this.messages.push({
+            role: 'assistant',
+            content,
+        });
+        this.prune();
+    }
+    addMessage(message) {
+        if (message.role === 'system') {
+            this.setSystemPrompt(typeof message.content === 'string' ? message.content : '');
+            return;
+        }
+        this.messages.push(message);
+        this.prune();
+    }
+    buildMessages(userPrompt) {
+        this.addUserMessage(userPrompt);
+        return this.getMessages();
+    }
+    recordResponse(content) {
+        this.addAssistantMessage(content);
+    }
+    getMessages() {
+        const result = [];
+        if (this.systemMessage) {
+            result.push(this.systemMessage);
+        }
+        result.push(...this.messages);
+        return result;
+    }
+    getConversation() {
+        return this.messages;
+    }
+    getPairCount() {
+        let pairs = 0;
+        for (let i = 0; i < this.messages.length - 1; i += 2) {
+            if (this.messages[i].role === 'user' &&
+                this.messages[i + 1]?.role === 'assistant') {
+                pairs++;
+            }
+        }
+        return pairs;
+    }
+    clear() {
+        this.messages = [];
+    }
+    reset() {
+        this.messages = [];
+        this.systemMessage = null;
+        this.config.systemPrompt = '';
+    }
+    setConfig(config) {
+        if (config.maxPairs !== undefined) {
+            this.config.maxPairs = config.maxPairs;
+            this.prune();
+        }
+        if (config.systemPrompt !== undefined) {
+            this.setSystemPrompt(config.systemPrompt);
+        }
+    }
+    getConfig() {
+        return { ...this.config };
+    }
+    prune() {
+        const maxMessages = this.config.maxPairs * 2;
+        if (this.messages.length > maxMessages) {
+            const excess = this.messages.length - maxMessages;
+            const toRemove = Math.ceil(excess / 2) * 2;
+            this.messages = this.messages.slice(toRemove);
+        }
+    }
+    isEmpty() {
+        return this.messages.length === 0;
+    }
+    getMessageCount() {
+        return this.messages.length;
+    }
+    toJSON() {
+        return {
+            config: this.config,
+            systemPrompt: this.systemMessage?.content,
+            messages: [...this.messages],
+        };
+    }
+    static fromJSON(data) {
+        const memory = new ConversationMemory(data.config);
+        if (data.systemPrompt) {
+            memory.setSystemPrompt(data.systemPrompt);
+        }
+        if (data.messages) {
+            for (const msg of data.messages) {
+                memory.addMessage(msg);
+            }
+        }
+        return memory;
+    }
+}

package/dist/browser/types/ai-client.d.ts

@@ -0,0 +1,29 @@
+import type { AIResponse, AIStream, ChatMessage, AIProvider } from './ai.js';
+export interface AIMemoryConfig {
+    maxPairs?: number;
+    systemPrompt?: string;
+}
+export interface PresetAIConfig {
+    provider: AIProvider;
+    apiKey?: string;
+    model: string;
+    baseUrl?: string;
+    memory?: AIMemoryConfig;
+    organization?: string;
+    headers?: Record<string, string>;
+}
+export interface ClientAI {
+    chat(prompt: string): Promise<AIResponse>;
+    chatStream(prompt: string): Promise<AIStream>;
+    prompt(prompt: string): Promise<AIResponse>;
+    promptStream(prompt: string): Promise<AIStream>;
+    clearMemory(): void;
+    getMemory(): readonly ChatMessage[];
+    setMemoryConfig(config: Partial<AIMemoryConfig>): void;
+    getMemoryConfig(): AIMemoryConfig;
+    readonly provider: AIProvider;
+    readonly model: string;
+}
+export interface ClientOptionsWithAI {
+    _aiConfig?: PresetAIConfig;
+}

package/dist/browser/types/ai-client.js

@@ -0,0 +1 @@
+export {};

package/dist/cli/tui/shell.js

@@ -1517,7 +1517,7 @@ ${colors.bold('Network:')}
     }
     async runSpider(args) {
         let url = '';
-        let maxDepth = 3;
+        let maxDepth = 5;
         let maxPages = 100;
         let concurrency = 5;
         let seoEnabled = false;
@@ -1525,7 +1525,7 @@ ${colors.bold('Network:')}
         for (let i = 0; i < args.length; i++) {
             const arg = args[i];
             if (arg.startsWith('depth=')) {
-                maxDepth = parseInt(arg.split('=')[1]) || 4;
+                maxDepth = parseInt(arg.split('=')[1]) || 5;
             }
             else if (arg.startsWith('limit=')) {
                 maxPages = parseInt(arg.split('=')[1]) || 100;
@@ -1547,7 +1547,7 @@ ${colors.bold('Network:')}
             if (!this.baseUrl) {
                 console.log(colors.yellow('Usage: spider <url> [options]'));
                 console.log(colors.gray('  Options:'));
-                console.log(colors.gray('    depth=4           Max crawl depth'));
+                console.log(colors.gray('    depth=5           Max crawl depth'));
                 console.log(colors.gray('    limit=100         Max pages to crawl'));
                 console.log(colors.gray('    concurrency=5     Concurrent requests'));
                 console.log(colors.gray('    seo               Enable SEO analysis'));
@@ -2710,7 +2710,7 @@ ${colors.bold('Network:')}
   ${colors.bold('Web Crawler:')}
     ${colors.green('spider <url>')}        Crawl website following internal links.
                              ${colors.gray('Options:')}
-                             ${colors.white('--depth=4')}     ${colors.gray('Maximum depth to crawl')}
+                             ${colors.white('--depth=5')}     ${colors.gray('Maximum depth to crawl')}
                              ${colors.white('--limit=100')}   ${colors.gray('Maximum pages to crawl')}
                              ${colors.white('--concurrency=5')} ${colors.gray('Parallel requests')}
 

package/dist/mcp/server.js

@@ -9,6 +9,8 @@ import { UnsupportedError } from '../core/errors.js';
 import { getIpInfo, isValidIP, isGeoIPAvailable, isBogon, isIPv6 } from './ip-intel.js';
 import { networkTools, networkToolHandlers } from './tools/network.js';
 import { seoTools, seoToolHandlers } from './tools/seo.js';
+import { scrapeTools, scrapeToolHandlers } from './tools/scrape.js';
+import { securityTools, securityToolHandlers } from './tools/security.js';
 import { ToolRegistry } from './tools/registry.js';
 import { loadToolModules } from './tools/loader.js';
 export class MCPServer {
@@ -50,6 +52,14 @@ export class MCPServer {
             tools: seoTools,
             handlers: seoToolHandlers
         });
+        this.toolRegistry.registerModule({
+            tools: scrapeTools,
+            handlers: scrapeToolHandlers
+        });
+        this.toolRegistry.registerModule({
+            tools: securityTools,
+            handlers: securityToolHandlers
+        });
     }
     indexReady = null;
     async ensureIndexReady() {

package/dist/mcp/tools/scrape.d.ts

@@ -0,0 +1,3 @@
+import type { MCPTool, MCPToolResult } from '../types.js';
+export declare const scrapeTools: MCPTool[];
+export declare const scrapeToolHandlers: Record<string, (args: Record<string, unknown>) => Promise<MCPToolResult>>;

package/dist/mcp/tools/scrape.js

@@ -0,0 +1,156 @@
+import { createClient } from '../../core/client.js';
+import { ScrapeDocument } from '../../scrape/document.js';
+async function scrapeUrl(args) {
+    const url = String(args.url || '');
+    const selectors = args.selectors;
+    const extract = args.extract;
+    const selector = args.selector;
+    if (!url) {
+        return {
+            content: [{ type: 'text', text: 'Error: url is required' }],
+            isError: true,
+        };
+    }
+    try {
+        const client = createClient({ timeout: 30000 });
+        const response = await client.get(url);
+        const html = await response.text();
+        const doc = await ScrapeDocument.create(html, { baseUrl: url });
+        const output = {
+            url,
+            title: doc.title(),
+        };
+        if (selector) {
+            const elements = doc.selectAll(selector);
+            output.results = elements.map(el => ({
+                text: el.text(),
+                html: el.html(),
+                tag: el.tagName(),
+                attrs: el.attrs(),
+            }));
+            output.count = elements.length;
+        }
+        if (selectors && Object.keys(selectors).length > 0) {
+            const extracted = {};
+            for (const [key, sel] of Object.entries(selectors)) {
+                const isMultiple = sel.endsWith('[]');
+                const actualSel = isMultiple ? sel.slice(0, -2) : sel;
+                if (isMultiple) {
+                    extracted[key] = doc.texts(actualSel);
+                }
+                else {
+                    extracted[key] = doc.text(actualSel);
+                }
+            }
+            output.data = extracted;
+        }
+        const extractSet = new Set(extract || []);
+        if (extractSet.has('links') || extractSet.has('all')) {
+            const links = doc.links({ absolute: true });
+            output.links = links.slice(0, 100).map(l => ({
+                href: l.href,
+                text: l.text?.slice(0, 100),
+                rel: l.rel,
+            }));
+            output.linkCount = links.length;
+        }
+        if (extractSet.has('images') || extractSet.has('all')) {
+            const images = doc.images({ absolute: true });
+            output.images = images.slice(0, 50).map(img => ({
+                src: img.src,
+                alt: img.alt,
+                width: img.width,
+                height: img.height,
+            }));
+            output.imageCount = images.length;
+        }
+        if (extractSet.has('meta') || extractSet.has('all')) {
+            output.meta = doc.meta();
+        }
+        if (extractSet.has('og') || extractSet.has('all')) {
+            output.openGraph = doc.openGraph();
+        }
+        if (extractSet.has('twitter') || extractSet.has('all')) {
+            output.twitterCard = doc.twitterCard();
+        }
+        if (extractSet.has('jsonld') || extractSet.has('all')) {
+            output.jsonLd = doc.jsonLd();
+        }
+        if (extractSet.has('tables') || extractSet.has('all')) {
+            const tables = doc.tables();
+            output.tables = tables.slice(0, 10).map(t => ({
+                headers: t.headers,
+                rows: t.rows.slice(0, 50),
+            }));
+            output.tableCount = tables.length;
+        }
+        if (extractSet.has('forms') || extractSet.has('all')) {
+            output.forms = doc.forms();
+        }
+        if (extractSet.has('headings')) {
+            output.headings = {
+                h1: doc.texts('h1'),
+                h2: doc.texts('h2'),
+                h3: doc.texts('h3'),
+            };
+        }
+        return {
+            content: [{
+                    type: 'text',
+                    text: JSON.stringify(output, null, 2),
+                }],
+        };
+    }
+    catch (error) {
+        return {
+            content: [{
+                    type: 'text',
+                    text: `Scrape failed: ${error.message}`,
+                }],
+            isError: true,
+        };
+    }
+}
+export const scrapeTools = [
+    {
+        name: 'rek_scrape',
+        description: `Scrape a web page and extract data using CSS selectors.
+
+Supports multiple extraction modes:
+- Single selector: Extract elements matching one CSS selector
+- Selector map: Extract multiple fields at once
+- Built-in extractors: links, images, meta, og, twitter, jsonld, tables, forms, headings
+
+Examples:
+- Get all product titles: selector=".product-title"
+- Extract multiple fields: selectors={"title":"h1","price":".price","desc":".description"}
+- Get all links and images: extract=["links","images"]
+- Full extraction: extract=["all"]`,
+        inputSchema: {
+            type: 'object',
+            properties: {
+                url: {
+                    type: 'string',
+                    description: 'URL to scrape',
+                },
+                selector: {
+                    type: 'string',
+                    description: 'Single CSS selector to extract elements (e.g., ".product-card", "article h2")',
+                },
+                selectors: {
+                    type: 'object',
+                    description: 'Map of field names to CSS selectors. Add [] suffix for multiple values (e.g., {"title":"h1","links[]":"a"})',
+                },
+                extract: {
+                    type: 'array',
+                    items: { type: 'string' },
+                    description: 'Built-in extractors to run: links, images, meta, og, twitter, jsonld, tables, forms, headings, all',
+                },
+            },
+            required: ['url'],
+        },
+    },
+];
+export const scrapeToolHandlers = {
+    rek_scrape: scrapeUrl,
+};

package/dist/mcp/tools/security.d.ts

@@ -0,0 +1,3 @@
+import type { MCPTool, MCPToolResult } from '../types.js';
+export declare const securityTools: MCPTool[];
+export declare const securityToolHandlers: Record<string, (args: Record<string, unknown>) => Promise<MCPToolResult>>;

package/dist/mcp/tools/security.js

@@ -0,0 +1,471 @@
+import { createClient } from '../../core/client.js';
+import { inspectTLS } from '../../utils/tls-inspector.js';
+import { rdap, supportsRDAP } from '../../utils/rdap.js';
+import { getIpInfo, isValidIP } from '../ip-intel.js';
+import { analyzeSecurityHeaders, quickSecurityCheck } from '../../utils/security-grader.js';
+import { validateSpf, validateDmarc, checkDkim, checkDnsHealth, getSecurityRecords, } from '../../utils/dns-toolkit.js';
+async function tlsInspect(args) {
+    const host = String(args.host || '');
+    const port = Number(args.port) || 443;
+    if (!host) {
+        return {
+            content: [{ type: 'text', text: 'Error: host is required' }],
+            isError: true,
+        };
+    }
+    try {
+        const info = await inspectTLS(host, port);
+        const output = {
+            host,
+            port,
+            valid: info.valid,
+            authorized: info.authorized,
+            certificate: {
+                subject: info.subject,
+                issuer: info.issuer,
+                validFrom: info.validFrom.toISOString(),
+                validTo: info.validTo.toISOString(),
+                daysRemaining: info.daysRemaining,
+                serialNumber: info.serialNumber,
+                fingerprint256: info.fingerprint256,
+            },
+            connection: {
+                protocol: info.protocol,
+                cipher: info.cipher,
+            },
+            subjectAltNames: info.altNames,
+            publicKey: info.pubkey,
+            extendedKeyUsage: info.extKeyUsage,
+            warnings: [],
+        };
+        if (info.daysRemaining <= 30) {
+            output.warnings.push(`Certificate expires in ${info.daysRemaining} days!`);
+        }
+        if (!info.authorized) {
+            output.warnings.push(`Certificate not trusted: ${info.authorizationError?.message || 'unknown reason'}`);
+        }
+        if (info.pubkey && info.pubkey.algo === 'rsa' && info.pubkey.size < 2048) {
+            output.warnings.push(`RSA key size ${info.pubkey.size} bits is considered weak`);
+        }
+        return {
+            content: [{ type: 'text', text: JSON.stringify(output, null, 2) }],
+        };
+    }
+    catch (error) {
+        return {
+            content: [{ type: 'text', text: `TLS inspection failed: ${error.message}` }],
+            isError: true,
+        };
+    }
+}
+async function rdapLookup(args) {
+    const query = String(args.query || '');
+    if (!query) {
+        return {
+            content: [{ type: 'text', text: 'Error: query (domain or IP) is required' }],
+            isError: true,
+        };
+    }
+    if (!query.includes(':') && !/^\d+\.\d+\.\d+\.\d+$/.test(query)) {
+        const tld = query.split('.').pop()?.toLowerCase() || '';
+        if (!supportsRDAP(tld)) {
+            return {
+                content: [{
+                        type: 'text',
+                        text: `RDAP is not available for .${tld} domains. Use rek_whois_lookup instead for traditional WHOIS data.`,
+                    }],
+                isError: true,
+            };
+        }
+    }
+    try {
+        const client = createClient({ timeout: 15000 });
+        const result = await rdap(client, query);
+        const output = {
+            query,
+            ldhName: result.ldhName,
+            handle: result.handle,
+            status: result.status,
+        };
+        if (result.events) {
+            output.events = {};
+            for (const event of result.events) {
+                output.events[event.eventAction] = event.eventDate;
+            }
+        }
+        if (result.nameservers) {
+            output.nameservers = result.nameservers.map(ns => ns.ldhName);
+        }
+        if (result.entities) {
+            output.entities = result.entities.map(entity => ({
+                handle: entity.handle,
+                roles: entity.roles,
+            }));
+        }
+        if (result.secureDNS) {
+            output.dnssec = result.secureDNS.delegationSigned ? 'signed' : 'unsigned';
+        }
+        return {
+            content: [{ type: 'text', text: JSON.stringify(output, null, 2) }],
+        };
+    }
+    catch (error) {
+        return {
+            content: [{ type: 'text', text: `RDAP lookup failed: ${error.message}` }],
+            isError: true,
+        };
+    }
+}
+async function geoipLookup(args) {
+    const ip = String(args.ip || '');
+    if (!ip) {
+        return {
+            content: [{ type: 'text', text: 'Error: ip address is required' }],
+            isError: true,
+        };
+    }
+    if (!isValidIP(ip)) {
+        return {
+            content: [{ type: 'text', text: `Invalid IP address: ${ip}` }],
+            isError: true,
+        };
+    }
+    try {
+        const info = await getIpInfo(ip);
+        const output = {
+            ip: info.ip,
+            isIPv6: info.isIPv6,
+        };
+        if (info.bogon) {
+            output.bogon = true;
+            output.bogonType = info.bogonType;
+            output.note = 'This is a private/reserved IP address. No geolocation available.';
+        }
+        else {
+            output.location = {
+                city: info.city,
+                region: info.region,
+                country: info.country,
+                countryCode: info.countryCode,
+                continent: info.continent,
+                coordinates: info.loc,
+                timezone: info.timezone,
+                postalCode: info.postal,
+                accuracyRadius: info.accuracy ? `${info.accuracy} km` : undefined,
+            };
+        }
+        return {
+            content: [{ type: 'text', text: JSON.stringify(output, null, 2) }],
+        };
+    }
+    catch (error) {
+        return {
+            content: [{ type: 'text', text: `GeoIP lookup failed: ${error.message}` }],
+            isError: true,
+        };
+    }
+}
+async function securityHeadersAnalyze(args) {
+    const url = String(args.url || '');
+    const quick = Boolean(args.quick);
+    if (!url) {
+        return {
+            content: [{ type: 'text', text: 'Error: url is required' }],
+            isError: true,
+        };
+    }
+    try {
+        const client = createClient({ timeout: 15000 });
+        const response = await client.head(url);
+        if (quick) {
+            const result = quickSecurityCheck(response.headers);
+            return {
+                content: [{
+                        type: 'text',
+                        text: JSON.stringify({
+                            url,
+                            secure: result.secure,
+                            criticalIssues: result.criticalIssues,
+                        }, null, 2),
+                    }],
+            };
+        }
+        const report = analyzeSecurityHeaders(response.headers);
+        const output = {
+            url,
+            grade: report.grade,
+            score: report.score,
+            summary: report.summary,
+        };
+        const failed = report.details.filter(d => d.status === 'fail');
+        const warnings = report.details.filter(d => d.status === 'warn');
+        const passed = report.details.filter(d => d.status === 'pass');
+        if (failed.length > 0) {
+            output.failed = failed.map(d => ({
+                header: d.header,
+                message: d.message,
+                recommendation: d.recommendation,
+            }));
+        }
+        if (warnings.length > 0) {
+            output.warnings = warnings.map(d => ({
+                header: d.header,
+                message: d.message,
+                recommendation: d.recommendation,
+            }));
+        }
+        output.passed = passed.map(d => d.header);
+        if (report.csp) {
+            output.csp = {
+                score: report.csp.score,
+                issues: report.csp.issues,
+                missingDirectives: report.csp.missingDirectives,
+                hasUnsafeInline: report.csp.hasUnsafeInline,
+                hasUnsafeEval: report.csp.hasUnsafeEval,
+            };
+        }
+        return {
+            content: [{ type: 'text', text: JSON.stringify(output, null, 2) }],
+        };
+    }
+    catch (error) {
+        return {
+            content: [{ type: 'text', text: `Security headers analysis failed: ${error.message}` }],
+            isError: true,
+        };
+    }
+}
+async function dnsToolkit(args) {
+    const domain = String(args.domain || '');
+    const check = String(args.check || 'all');
+    const dkimSelector = args.dkimSelector;
+    if (!domain) {
+        return {
+            content: [{ type: 'text', text: 'Error: domain is required' }],
+            isError: true,
+        };
+    }
+    try {
+        const output = { domain };
+        if (check === 'all' || check === 'health') {
+            const healthReport = await checkDnsHealth(domain);
+            output.health = {
+                score: healthReport.score,
+                grade: healthReport.grade,
+                checks: healthReport.checks,
+            };
+        }
+        if (check === 'all' || check === 'spf') {
+            const spfResult = await validateSpf(domain);
+            output.spf = {
+                valid: spfResult.valid,
+                record: spfResult.record,
+                mechanisms: spfResult.mechanisms,
+                lookupCount: spfResult.lookupCount,
+                warnings: spfResult.warnings,
+                errors: spfResult.errors,
+            };
+        }
+        if (check === 'all' || check === 'dmarc') {
+            const dmarcResult = await validateDmarc(domain);
+            output.dmarc = {
+                valid: dmarcResult.valid,
+                record: dmarcResult.record,
+                policy: dmarcResult.policy,
+                subdomainPolicy: dmarcResult.subdomainPolicy,
+                percentage: dmarcResult.percentage,
+                reportingUris: dmarcResult.rua,
+                warnings: dmarcResult.warnings,
+            };
+        }
+        if (check === 'all' || check === 'dkim') {
+            const selectors = dkimSelector
+                ? [dkimSelector]
+                : ['default', 'google', 'selector1', 'selector2', 'k1', 's1', 'dkim'];
+            const dkimResults = [];
+            for (const sel of selectors) {
+                const result = await checkDkim(domain, sel);
+                if (result.found) {
+                    dkimResults.push({
+                        selector: sel,
+                        found: true,
+                        publicKey: result.publicKey?.slice(0, 50) + '...',
+                    });
+                }
+            }
+            output.dkim = {
+                found: dkimResults.length > 0,
+                selectors: dkimResults,
+                note: dkimResults.length === 0
+                    ? 'No DKIM records found with common selectors. Specify dkimSelector parameter if you know the selector.'
+                    : undefined,
+            };
+        }
+        if (check === 'all' || check === 'records') {
+            const records = await getSecurityRecords(domain);
+            output.securityRecords = {
+                spf: records.spf,
+                dmarc: records.dmarc,
+                caa: records.caa,
+                mx: records.mx,
+            };
+        }
+        return {
+            content: [{ type: 'text', text: JSON.stringify(output, null, 2) }],
+        };
+    }
+    catch (error) {
+        return {
+            content: [{ type: 'text', text: `DNS toolkit failed: ${error.message}` }],
+            isError: true,
+        };
+    }
+}
+export const securityTools = [
+    {
+        name: 'rek_tls_inspect',
+        description: `Inspect SSL/TLS certificate and connection details for a host.
+
+Returns:
+- Certificate validity and expiration
+- Subject and issuer details
+- Subject Alternative Names (SANs)
+- TLS protocol version and cipher suite
+- Public key algorithm and size
+- Warnings for expiring certs, weak keys, or trust issues
+
+Use this to check certificate health, debug TLS issues, or audit HTTPS configuration.`,
+        inputSchema: {
+            type: 'object',
+            properties: {
+                host: {
+                    type: 'string',
+                    description: 'Hostname to inspect (e.g., "example.com")',
+                },
+                port: {
+                    type: 'number',
+                    description: 'Port number (default: 443)',
+                    default: 443,
+                },
+            },
+            required: ['host'],
+        },
+    },
+    {
+        name: 'rek_rdap_lookup',
+        description: `Perform RDAP lookup (modern WHOIS) for a domain or IP address.
+
+RDAP provides structured JSON data including:
+- Registration dates (created, updated, expires)
+- Status (active, locked, etc.)
+- Nameservers
+- DNSSEC status
+- Registrar/Registrant info
+
+Note: Some TLDs (.io, .ai, etc.) don't support RDAP yet - use rek_whois_lookup for those.`,
+        inputSchema: {
+            type: 'object',
+            properties: {
+                query: {
+                    type: 'string',
+                    description: 'Domain name or IP address to lookup',
+                },
+            },
+            required: ['query'],
+        },
+    },
+    {
+        name: 'rek_geoip_lookup',
+        description: `Get geolocation data for an IP address using MaxMind GeoLite2 database.
+
+Returns:
+- City, region, country, continent
+- Coordinates (latitude, longitude)
+- Timezone
+- Accuracy radius
+- Bogon detection (identifies private/reserved IPs)
+
+Database is cached locally and updated automatically.`,
+        inputSchema: {
+            type: 'object',
+            properties: {
+                ip: {
+                    type: 'string',
+                    description: 'IPv4 or IPv6 address to lookup',
+                },
+            },
+            required: ['ip'],
+        },
+    },
+    {
+        name: 'rek_security_headers',
+        description: `Analyze HTTP security headers for a URL.
+
+Grades (A+ to F) based on:
+- HSTS (Strict-Transport-Security)
+- CSP (Content-Security-Policy) with detailed analysis
+- X-Frame-Options / frame-ancestors
+- X-Content-Type-Options
+- Referrer-Policy
+- Permissions-Policy
+- Cross-Origin policies (COOP, COEP, CORP)
+- Information leakage (Server, X-Powered-By)
+
+Use quick=true for a fast critical issues check.`,
+        inputSchema: {
+            type: 'object',
+            properties: {
+                url: {
+                    type: 'string',
+                    description: 'URL to analyze',
+                },
+                quick: {
+                    type: 'boolean',
+                    description: 'Quick mode - only check critical security issues',
+                    default: false,
+                },
+            },
+            required: ['url'],
+        },
+    },
+    {
+        name: 'rek_dns_toolkit',
+        description: `Advanced DNS security analysis for email authentication and DNS health.
+
+Checks:
+- SPF validation (syntax, lookup count, mechanisms)
+- DMARC validation (policy, reporting, alignment)
+- DKIM discovery (tries common selectors)
+- CAA records (certificate authority authorization)
+- MX records
+- Overall DNS health score
+
+Use check parameter to run specific checks: "all", "health", "spf", "dmarc", "dkim", "records"`,
+        inputSchema: {
+            type: 'object',
+            properties: {
+                domain: {
+                    type: 'string',
+                    description: 'Domain to analyze',
+                },
+                check: {
+                    type: 'string',
+                    description: 'Which check to run: all, health, spf, dmarc, dkim, records',
+                    default: 'all',
+                },
+                dkimSelector: {
+                    type: 'string',
+                    description: 'Specific DKIM selector to check (if known)',
+                },
+            },
+            required: ['domain'],
+        },
+    },
+];
+export const securityToolHandlers = {
+    rek_tls_inspect: tlsInspect,
+    rek_rdap_lookup: rdapLookup,
+    rek_geoip_lookup: geoipLookup,
+    rek_security_headers: securityHeadersAnalyze,
+    rek_dns_toolkit: dnsToolkit,
+};

package/dist/mcp/tools/seo.js

@@ -160,8 +160,8 @@ async function seoAnalyze(args) {
 }
 async function seoSpiderCrawl(args) {
     const url = String(args.url || '');
-    const maxPages = Number(args.maxPages) || 20;
-    const maxDepth = Number(args.maxDepth) || 3;
+    const maxPages = Number(args.maxPages) || 100;
+    const maxDepth = Number(args.maxDepth) || 5;
     const concurrency = Number(args.concurrency) || 3;
     if (!url) {
         return {
@@ -377,12 +377,12 @@ Returns per-page scores and prioritized recommendations for improving overall si
                 maxPages: {
                     type: 'number',
                     description: 'Maximum pages to crawl',
-                    default: 20,
+                    default: 100,
                 },
                 maxDepth: {
                     type: 'number',
                     description: 'Maximum link depth to follow',
-                    default: 3,
+                    default: 5,
                 },
                 concurrency: {
                     type: 'number',

package/dist/scrape/spider.js

@@ -86,7 +86,7 @@ export class Spider {
     pendingCount = 0;
     constructor(options = {}) {
         this.options = {
-            maxDepth: options.maxDepth ?? 4,
+            maxDepth: options.maxDepth ?? 5,
             maxPages: options.maxPages ?? 100,
             sameDomain: options.sameDomain ?? true,
             concurrency: options.concurrency ?? 5,

package/dist/types/ai-client.d.ts

@@ -0,0 +1,29 @@
+import type { AIResponse, AIStream, ChatMessage, AIProvider } from './ai.js';
+export interface AIMemoryConfig {
+    maxPairs?: number;
+    systemPrompt?: string;
+}
+export interface PresetAIConfig {
+    provider: AIProvider;
+    apiKey?: string;
+    model: string;
+    baseUrl?: string;
+    memory?: AIMemoryConfig;
+    organization?: string;
+    headers?: Record<string, string>;
+}
+export interface ClientAI {
+    chat(prompt: string): Promise<AIResponse>;
+    chatStream(prompt: string): Promise<AIStream>;
+    prompt(prompt: string): Promise<AIResponse>;
+    promptStream(prompt: string): Promise<AIStream>;
+    clearMemory(): void;
+    getMemory(): readonly ChatMessage[];
+    setMemoryConfig(config: Partial<AIMemoryConfig>): void;
+    getMemoryConfig(): AIMemoryConfig;
+    readonly provider: AIProvider;
+    readonly model: string;
+}
+export interface ClientOptionsWithAI {
+    _aiConfig?: PresetAIConfig;
+}

package/dist/types/ai-client.js

@@ -0,0 +1 @@
+export {};

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "recker",
-  "version": "1.0.29-next.3524ab6",
+  "version": "1.0.29-next.cf0cafb",
   "description": "AI & DevX focused HTTP client for Node.js 18+",
   "main": "./dist/index.js",
   "types": "./dist/index.d.ts",