recker 1.0.20-next.de24f7d → 1.0.20-next.e194d90

package/dist/mcp/tools/network.js

@@ -0,0 +1,267 @@
+import { createClient } from '../../core/client.js';
+import { createDNS } from '../../dns/index.js';
+import { createWhois } from '../../utils/whois.js';
+import { createConnection } from 'net';
+const dnsClient = createDNS({ provider: 'system' });
+const whoisClient = createWhois();
+async function httpRequest(args) {
+    const url = String(args.url || '');
+    const method = String(args.method || 'GET').toUpperCase();
+    const headers = args.headers || {};
+    const body = args.body;
+    const timeout = Number(args.timeout) || 10000;
+    const retries = Number(args.retries) || 0;
+    if (!url) {
+        return {
+            content: [{ type: 'text', text: 'Error: url is required' }],
+            isError: true,
+        };
+    }
+    try {
+        const client = createClient({
+            headers,
+            timeout,
+            retry: {
+                maxAttempts: retries,
+            },
+        });
+        let response;
+        switch (method) {
+            case 'GET':
+                response = await client.get(url);
+                break;
+            case 'POST':
+                response = await client.post(url, { json: body });
+                break;
+            case 'PUT':
+                response = await client.put(url, { json: body });
+                break;
+            case 'DELETE':
+                response = await client.delete(url);
+                break;
+            case 'PATCH':
+                response = await client.patch(url, { json: body });
+                break;
+            case 'HEAD':
+                response = await client.head(url);
+                break;
+            default:
+                return {
+                    content: [{ type: 'text', text: `Error: Unsupported method ${method}` }],
+                    isError: true,
+                };
+        }
+        const responseHeaders = {};
+        response.headers.forEach((val, key) => {
+            responseHeaders[key] = val;
+        });
+        const result = {
+            status: response.status,
+            statusText: response.statusText,
+            headers: responseHeaders,
+            data: await response.text(),
+        };
+        try {
+            result.data = JSON.parse(result.data);
+        }
+        catch {
+        }
+        return {
+            content: [{
+                    type: 'text',
+                    text: JSON.stringify(result, null, 2),
+                }],
+        };
+    }
+    catch (error) {
+        return {
+            content: [{
+                    type: 'text',
+                    text: `Request failed: ${error.message}`,
+                }],
+            isError: true,
+        };
+    }
+}
+async function dnsLookup(args) {
+    const domain = String(args.domain || '');
+    const type = String(args.type || 'A').toUpperCase();
+    if (!domain) {
+        return {
+            content: [{ type: 'text', text: 'Error: domain is required' }],
+            isError: true,
+        };
+    }
+    try {
+        let result;
+        if (type === 'ALL') {
+            result = await dnsClient.resolveAll(domain);
+        }
+        else {
+            result = await dnsClient.resolve(domain, type);
+        }
+        return {
+            content: [{
+                    type: 'text',
+                    text: JSON.stringify({ domain, type, result }, null, 2),
+                }],
+        };
+    }
+    catch (error) {
+        return {
+            content: [{
+                    type: 'text',
+                    text: `DNS lookup failed: ${error.message}`,
+                }],
+            isError: true,
+        };
+    }
+}
+async function whoisLookup(args) {
+    const query = String(args.query || '');
+    if (!query) {
+        return {
+            content: [{ type: 'text', text: 'Error: query is required' }],
+            isError: true,
+        };
+    }
+    try {
+        const result = await whoisClient.lookup(query);
+        return {
+            content: [{
+                    type: 'text',
+                    text: JSON.stringify({
+                        server: result.server,
+                        data: result.data,
+                    }, null, 2),
+                }],
+        };
+    }
+    catch (error) {
+        return {
+            content: [{
+                    type: 'text',
+                    text: `WHOIS lookup failed: ${error.message}`,
+                }],
+            isError: true,
+        };
+    }
+}
+async function ping(args) {
+    const host = String(args.host || '');
+    const port = Number(args.port) || 80;
+    const timeout = Number(args.timeout) || 5000;
+    const count = Number(args.count) || 3;
+    if (!host) {
+        return {
+            content: [{ type: 'text', text: 'Error: host is required' }],
+            isError: true,
+        };
+    }
+    const results = [];
+    for (let i = 0; i < count; i++) {
+        const start = Date.now();
+        try {
+            await new Promise((resolve, reject) => {
+                const socket = createConnection({ host, port, timeout });
+                socket.on('connect', () => {
+                    socket.destroy();
+                    resolve();
+                });
+                socket.on('timeout', () => {
+                    socket.destroy();
+                    reject(new Error('Timeout'));
+                });
+                socket.on('error', (err) => {
+                    socket.destroy();
+                    reject(err);
+                });
+            });
+            results.push({ seq: i + 1, time: Date.now() - start });
+        }
+        catch (error) {
+            results.push({ seq: i + 1, error: error.message });
+        }
+        if (i < count - 1) {
+            await new Promise(r => setTimeout(r, 200));
+        }
+    }
+    const successful = results.filter(r => !r.error);
+    const totalTime = successful.reduce((acc, r) => acc + (r.time || 0), 0);
+    const avg = successful.length > 0 ? totalTime / successful.length : 0;
+    return {
+        content: [{
+                type: 'text',
+                text: JSON.stringify({
+                    host,
+                    port,
+                    sent: count,
+                    received: successful.length,
+                    loss: `${((count - successful.length) / count * 100).toFixed(1)}%`,
+                    avgLatency: `${avg.toFixed(2)}ms`,
+                    details: results,
+                }, null, 2),
+            }],
+    };
+}
+export const networkTools = [
+    {
+        name: 'rek_http_request',
+        description: 'Perform an HTTP request to any URL using Recker\'s robust client. Supports all methods, headers, and automatic JSON parsing.',
+        inputSchema: {
+            type: 'object',
+            properties: {
+                url: { type: 'string', description: 'Target URL' },
+                method: { type: 'string', description: 'HTTP method (GET, POST, PUT, DELETE, etc.)', default: 'GET' },
+                headers: { type: 'object', description: 'Request headers' },
+                body: { type: 'object', description: 'JSON body for POST/PUT/PATCH' },
+                timeout: { type: 'number', description: 'Timeout in ms', default: 10000 },
+                retries: { type: 'number', description: 'Number of retries', default: 0 },
+            },
+            required: ['url'],
+        },
+    },
+    {
+        name: 'rek_dns_lookup',
+        description: 'Resolve DNS records for a domain. Supports A, AAAA, MX, TXT, NS, etc.',
+        inputSchema: {
+            type: 'object',
+            properties: {
+                domain: { type: 'string', description: 'Domain name to resolve' },
+                type: { type: 'string', description: 'Record type (A, AAAA, MX, TXT, NS, ALL)', default: 'A' },
+            },
+            required: ['domain'],
+        },
+    },
+    {
+        name: 'rek_whois_lookup',
+        description: 'Perform a WHOIS lookup for a domain or IP address to find registration info.',
+        inputSchema: {
+            type: 'object',
+            properties: {
+                query: { type: 'string', description: 'Domain or IP to lookup' },
+            },
+            required: ['query'],
+        },
+    },
+    {
+        name: 'rek_network_ping',
+        description: 'Check TCP connectivity to a host and port. Measures latency.',
+        inputSchema: {
+            type: 'object',
+            properties: {
+                host: { type: 'string', description: 'Hostname or IP' },
+                port: { type: 'number', description: 'Target port', default: 80 },
+                count: { type: 'number', description: 'Number of pings', default: 3 },
+                timeout: { type: 'number', description: 'Timeout per ping in ms', default: 5000 },
+            },
+            required: ['host'],
+        },
+    },
+];
+export const networkToolHandlers = {
+    rek_http_request: httpRequest,
+    rek_dns_lookup: dnsLookup,
+    rek_whois_lookup: whoisLookup,
+    rek_network_ping: ping,
+};

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

@@ -0,0 +1,17 @@
+import type { MCPTool, MCPToolResult } from '../types.js';
+export type MCPToolHandler = (args: Record<string, unknown>) => Promise<MCPToolResult>;
+export interface ToolModule {
+    tools: MCPTool[];
+    handlers: Record<string, MCPToolHandler>;
+}
+export declare class ToolRegistry {
+    private tools;
+    private handlers;
+    constructor();
+    registerTool(tool: MCPTool, handler: MCPToolHandler): void;
+    registerModule(module: ToolModule): void;
+    getTool(name: string): MCPTool | undefined;
+    listTools(): MCPTool[];
+    callTool(name: string, args: Record<string, unknown>): Promise<MCPToolResult>;
+    hasTool(name: string): boolean;
+}

package/dist/mcp/tools/registry.js

@@ -0,0 +1,37 @@
+export class ToolRegistry {
+    tools = new Map();
+    handlers = new Map();
+    constructor() { }
+    registerTool(tool, handler) {
+        if (this.tools.has(tool.name)) {
+            throw new Error(`Tool already registered: ${tool.name}`);
+        }
+        this.tools.set(tool.name, tool);
+        this.handlers.set(tool.name, handler);
+    }
+    registerModule(module) {
+        for (const tool of module.tools) {
+            const handler = module.handlers[tool.name];
+            if (!handler) {
+                throw new Error(`Handler missing for tool: ${tool.name}`);
+            }
+            this.registerTool(tool, handler);
+        }
+    }
+    getTool(name) {
+        return this.tools.get(name);
+    }
+    listTools() {
+        return Array.from(this.tools.values());
+    }
+    async callTool(name, args) {
+        const handler = this.handlers.get(name);
+        if (!handler) {
+            throw new Error(`Unknown tool: ${name}`);
+        }
+        return handler(args);
+    }
+    hasTool(name) {
+        return this.tools.has(name);
+    }
+}

package/dist/mcp/types.d.ts

@@ -149,4 +149,3 @@ export interface MCPTransportOptions {
     retries?: number;
     transport?: any;
 }
-//# sourceMappingURL=types.d.ts.map

package/dist/plugins/auth/api-key.d.ts

@@ -0,0 +1,8 @@
+import { Middleware, Plugin } from '../../types/index.js';
+export interface ApiKeyAuthOptions {
+    key: string | (() => string | Promise<string>);
+    in?: 'header' | 'query';
+    name?: string;
+}
+export declare function apiKeyAuth(options: ApiKeyAuthOptions): Middleware;
+export declare function apiKeyAuthPlugin(options: ApiKeyAuthOptions): Plugin;

package/dist/plugins/auth/api-key.js

@@ -0,0 +1,27 @@
+export function apiKeyAuth(options) {
+    const location = options.in ?? 'header';
+    const name = options.name ?? 'X-API-Key';
+    return async (req, next) => {
+        const key = typeof options.key === 'function'
+            ? await options.key()
+            : options.key;
+        if (location === 'header') {
+            const newReq = req.withHeader(name, key);
+            return next(newReq);
+        }
+        else {
+            const url = new URL(req.url);
+            url.searchParams.set(name, key);
+            const newReq = {
+                ...req,
+                url: url.toString(),
+            };
+            return next(newReq);
+        }
+    };
+}
+export function apiKeyAuthPlugin(options) {
+    return (client) => {
+        client.use(apiKeyAuth(options));
+    };
+}

package/dist/plugins/auth/auth0.d.ts

@@ -0,0 +1,33 @@
+import { Middleware, Plugin } from '../../types/index.js';
+import { OIDCTokens } from './oidc.js';
+export interface Auth0Options {
+    domain: string;
+    clientId: string;
+    clientSecret?: string;
+    audience?: string;
+    scopes?: string[];
+    accessToken?: string | (() => string | Promise<string>);
+    refreshToken?: string;
+    tokenStorage?: {
+        get: () => Promise<OIDCTokens | null>;
+        set: (tokens: OIDCTokens) => Promise<void>;
+    };
+    organization?: string;
+    connection?: string;
+}
+export declare function generateAuth0AuthUrl(options: Auth0Options & {
+    redirectUri: string;
+    state?: string;
+    usePKCE?: boolean;
+}): Promise<{
+    url: string;
+    codeVerifier?: string;
+}>;
+export declare function exchangeAuth0Code(options: Auth0Options & {
+    code: string;
+    redirectUri: string;
+    codeVerifier?: string;
+}): Promise<OIDCTokens>;
+export declare function getAuth0UserInfo(domain: string, accessToken: string): Promise<Record<string, unknown>>;
+export declare function auth0(options: Auth0Options): Middleware;
+export declare function auth0Plugin(options: Auth0Options): Plugin;

package/dist/plugins/auth/auth0.js

@@ -0,0 +1,94 @@
+import { oidc, generatePKCE } from './oidc.js';
+export async function generateAuth0AuthUrl(options) {
+    const issuer = `https://${options.domain}`;
+    const pkce = options.usePKCE ? generatePKCE() : undefined;
+    const params = new URLSearchParams({
+        response_type: 'code',
+        client_id: options.clientId,
+        redirect_uri: options.redirectUri,
+        scope: (options.scopes || ['openid', 'profile', 'email']).join(' '),
+    });
+    if (options.audience) {
+        params.set('audience', options.audience);
+    }
+    if (options.state) {
+        params.set('state', options.state);
+    }
+    if (options.organization) {
+        params.set('organization', options.organization);
+    }
+    if (options.connection) {
+        params.set('connection', options.connection);
+    }
+    if (pkce) {
+        params.set('code_challenge', pkce.codeChallenge);
+        params.set('code_challenge_method', 'S256');
+    }
+    return {
+        url: `${issuer}/authorize?${params.toString()}`,
+        codeVerifier: pkce?.codeVerifier,
+    };
+}
+export async function exchangeAuth0Code(options) {
+    const tokenUrl = `https://${options.domain}/oauth/token`;
+    const params = {
+        grant_type: 'authorization_code',
+        client_id: options.clientId,
+        code: options.code,
+        redirect_uri: options.redirectUri,
+    };
+    if (options.clientSecret) {
+        params.client_secret = options.clientSecret;
+    }
+    if (options.codeVerifier) {
+        params.code_verifier = options.codeVerifier;
+    }
+    const response = await fetch(tokenUrl, {
+        method: 'POST',
+        headers: {
+            'Content-Type': 'application/json',
+        },
+        body: JSON.stringify(params),
+    });
+    if (!response.ok) {
+        const error = await response.text();
+        throw new Error(`Auth0 token exchange failed: ${error}`);
+    }
+    const data = await response.json();
+    return {
+        accessToken: data.access_token,
+        refreshToken: data.refresh_token,
+        idToken: data.id_token,
+        expiresAt: data.expires_in ? Date.now() + data.expires_in * 1000 : undefined,
+        tokenType: data.token_type || 'Bearer',
+    };
+}
+export async function getAuth0UserInfo(domain, accessToken) {
+    const response = await fetch(`https://${domain}/userinfo`, {
+        headers: {
+            Authorization: `Bearer ${accessToken}`,
+        },
+    });
+    if (!response.ok) {
+        throw new Error(`Failed to get user info: ${response.status}`);
+    }
+    return response.json();
+}
+export function auth0(options) {
+    const issuer = `https://${options.domain}`;
+    return oidc({
+        issuer,
+        clientId: options.clientId,
+        clientSecret: options.clientSecret,
+        scopes: options.scopes || ['openid', 'profile', 'email'],
+        accessToken: options.accessToken,
+        refreshToken: options.refreshToken,
+        tokenStorage: options.tokenStorage,
+        audience: options.audience,
+    });
+}
+export function auth0Plugin(options) {
+    return (client) => {
+        client.use(auth0(options));
+    };
+}

package/dist/plugins/auth/aws-sigv4.d.ts

@@ -0,0 +1,10 @@
+import { Middleware, Plugin } from '../../types/index.js';
+export interface AWSSignatureV4Options {
+    accessKeyId: string;
+    secretAccessKey: string;
+    region: string;
+    service: string;
+    sessionToken?: string;
+}
+export declare function awsSignatureV4(options: AWSSignatureV4Options): Middleware;
+export declare function awsSignatureV4Plugin(options: AWSSignatureV4Options): Plugin;

package/dist/plugins/auth/aws-sigv4.js

@@ -0,0 +1,88 @@
+import { createHash, createHmac } from 'node:crypto';
+function sha256(str) {
+    return createHash('sha256').update(str).digest('hex');
+}
+export function awsSignatureV4(options) {
+    return async (req, next) => {
+        const url = new URL(req.url);
+        const host = url.host;
+        const pathname = url.pathname;
+        const queryString = url.search.slice(1);
+        const now = new Date();
+        const amzDate = now.toISOString().replace(/[:-]|\.\d{3}/g, '');
+        const dateStamp = amzDate.slice(0, 8);
+        const method = req.method;
+        const canonicalUri = pathname || '/';
+        const canonicalQueryString = queryString
+            .split('&')
+            .filter(Boolean)
+            .sort()
+            .join('&');
+        let payload = '';
+        if (req.body) {
+            if (typeof req.body === 'string') {
+                payload = req.body;
+            }
+            else if (req.body instanceof ArrayBuffer) {
+                payload = Buffer.from(req.body).toString();
+            }
+        }
+        const payloadHash = sha256(payload);
+        const headers = {
+            host,
+            'x-amz-date': amzDate,
+            'x-amz-content-sha256': payloadHash,
+        };
+        if (options.sessionToken) {
+            headers['x-amz-security-token'] = options.sessionToken;
+        }
+        req.headers.forEach((value, key) => {
+            headers[key.toLowerCase()] = value;
+        });
+        const signedHeaders = Object.keys(headers).sort().join(';');
+        const canonicalHeaders = Object.keys(headers)
+            .sort()
+            .map(key => `${key}:${headers[key].trim()}\n`)
+            .join('');
+        const canonicalRequest = [
+            method,
+            canonicalUri,
+            canonicalQueryString,
+            canonicalHeaders,
+            signedHeaders,
+            payloadHash,
+        ].join('\n');
+        const algorithm = 'AWS4-HMAC-SHA256';
+        const credentialScope = `${dateStamp}/${options.region}/${options.service}/aws4_request`;
+        const stringToSign = [
+            algorithm,
+            amzDate,
+            credentialScope,
+            sha256(canonicalRequest),
+        ].join('\n');
+        const getSignatureKey = (key, dateStamp, regionName, serviceName) => {
+            const kDate = createHmac('sha256', `AWS4${key}`).update(dateStamp).digest();
+            const kRegion = createHmac('sha256', kDate).update(regionName).digest();
+            const kService = createHmac('sha256', kRegion).update(serviceName).digest();
+            const kSigning = createHmac('sha256', kService).update('aws4_request').digest();
+            return kSigning;
+        };
+        const signingKey = getSignatureKey(options.secretAccessKey, dateStamp, options.region, options.service);
+        const signature = createHmac('sha256', signingKey)
+            .update(stringToSign)
+            .digest('hex');
+        const authorizationHeader = `${algorithm} Credential=${options.accessKeyId}/${credentialScope}, SignedHeaders=${signedHeaders}, Signature=${signature}`;
+        let newReq = req.withHeader('Authorization', authorizationHeader);
+        newReq = newReq.withHeader('x-amz-date', amzDate);
+        newReq = newReq.withHeader('x-amz-content-sha256', payloadHash);
+        if (options.sessionToken) {
+            newReq = newReq.withHeader('x-amz-security-token', options.sessionToken);
+        }
+        return next(newReq);
+    };
+}
+export function awsSignatureV4Plugin(options) {
+    return (client) => {
+        client.use(awsSignatureV4(options));
+    };
+}

package/dist/plugins/auth/azure-ad.d.ts

@@ -0,0 +1,48 @@
+import { Middleware, Plugin } from '../../types/index.js';
+import { OIDCTokens } from './oidc.js';
+export interface AzureADOptions {
+    tenantId: string;
+    clientId: string;
+    clientSecret?: string;
+    clientCertificate?: {
+        thumbprint: string;
+        privateKey: string;
+    };
+    scopes?: string[];
+    accessToken?: string | (() => string | Promise<string>);
+    refreshToken?: string;
+    tokenStorage?: {
+        get: () => Promise<OIDCTokens | null>;
+        set: (tokens: OIDCTokens) => Promise<void>;
+    };
+    cloudInstance?: string;
+    b2c?: {
+        tenantName: string;
+        policy: string;
+    };
+}
+export declare function generateAzureADAuthUrl(options: AzureADOptions & {
+    redirectUri: string;
+    state?: string;
+    nonce?: string;
+    usePKCE?: boolean;
+    prompt?: 'login' | 'none' | 'consent' | 'select_account';
+    loginHint?: string;
+    domainHint?: string;
+}): Promise<{
+    url: string;
+    codeVerifier?: string;
+}>;
+export declare function exchangeAzureADCode(options: AzureADOptions & {
+    code: string;
+    redirectUri: string;
+    codeVerifier?: string;
+}): Promise<OIDCTokens>;
+export declare function azureADOnBehalfOf(options: AzureADOptions & {
+    assertion: string;
+    scope: string;
+}): Promise<OIDCTokens>;
+export declare function getAzureADUserInfo(accessToken: string): Promise<Record<string, unknown>>;
+export declare function azureAD(options: AzureADOptions): Middleware;
+export declare function azureADPlugin(options: AzureADOptions): Plugin;
+export { azureAD as entraId, azureADPlugin as entraIdPlugin };