recker 1.0.22 → 1.0.23

package/dist/cli/index.js

@@ -993,6 +993,60 @@ ${colors.bold(colors.yellow('Examples:'))}
             process.exit(0);
         });
     });
+    serve
+        .command('webhook')
+        .alias('wh')
+        .description('Start a webhook receiver server')
+        .option('-p, --port <number>', 'Port to listen on', '3000')
+        .option('-h, --host <string>', 'Host to bind to', '127.0.0.1')
+        .option('-s, --status <code>', 'Response status code (200 or 204)', '204')
+        .option('-q, --quiet', 'Disable logging', false)
+        .addHelpText('after', `
+${colors.bold(colors.yellow('Examples:'))}
+  ${colors.green('$ rek serve webhook')}                 ${colors.gray('Start on port 3000')}
+  ${colors.green('$ rek serve wh -p 8080')}              ${colors.gray('Start on port 8080')}
+  ${colors.green('$ rek serve webhook --status 200')}    ${colors.gray('Return 200 instead of 204')}
+
+${colors.bold(colors.yellow('Endpoints:'))}
+  * /              ${colors.gray('Receive webhook without ID')}
+  * /:id           ${colors.gray('Receive webhook with custom ID')}
+
+${colors.bold(colors.yellow('Methods:'))}
+  ${colors.gray('GET, POST, PUT, PATCH, DELETE, HEAD, OPTIONS')}
+`)
+        .action(async (options) => {
+        const { createWebhookServer } = await import('../testing/mock-http-server.js');
+        const status = parseInt(options.status);
+        if (status !== 200 && status !== 204) {
+            console.error(colors.red('Status must be 200 or 204'));
+            process.exit(1);
+        }
+        const server = await createWebhookServer({
+            port: parseInt(options.port),
+            host: options.host,
+            status,
+            log: !options.quiet,
+        });
+        console.log(colors.green(`
+┌─────────────────────────────────────────────┐
+│  ${colors.bold('Recker Webhook Receiver')}                   │
+├─────────────────────────────────────────────┤
+│  URL: ${colors.cyan(server.url.padEnd(37))}│
+│  Status: ${colors.yellow(String(status).padEnd(34))}│
+├─────────────────────────────────────────────┤
+│  ${colors.cyan('*')} ${colors.cyan('/')}            ${colors.gray('Webhook without ID')}        │
+│  ${colors.cyan('*')} ${colors.cyan('/:id')}         ${colors.gray('Webhook with custom ID')}    │
+├─────────────────────────────────────────────┤
+│  Press ${colors.bold('Ctrl+C')} to stop                       │
+└─────────────────────────────────────────────┘
+`));
+        process.on('SIGINT', async () => {
+            console.log(colors.yellow('\nShutting down...'));
+            console.log(colors.gray(`Total webhooks received: ${server.webhooks.length}`));
+            await server.stop();
+            process.exit(0);
+        });
+    });
     serve
         .command('websocket')
         .alias('ws')

package/dist/cli/tui/shell-search.js

@@ -1,4 +1,4 @@
-import { createHybridSearch } from '../../mcp/search/index.js';
+import { createHybridSearch, createEmbedder, isFastembedAvailable } from '../../mcp/search/index.js';
 import { readFileSync, readdirSync, statSync, existsSync } from 'fs';
 import { join, relative, extname, basename, dirname } from 'path';
 import { fileURLToPath } from 'url';
@@ -24,6 +24,9 @@ export class ShellSearch {
             return;
         }
         this.hybridSearch = createHybridSearch({ debug: false });
+        if (await isFastembedAvailable()) {
+            this.hybridSearch.setEmbedder(createEmbedder());
+        }
         this.buildIndex();
         await this.hybridSearch.initialize(this.docsIndex);
         this.initialized = true;

package/dist/mcp/search/embedder.d.ts

@@ -0,0 +1,9 @@
+export declare function unloadEmbedder(): void;
+export declare function embed(text: string): Promise<number[]>;
+export declare function embedBatch(texts: string[]): Promise<number[][]>;
+export declare function createEmbedder(): (text: string, model?: string) => Promise<number[]>;
+export declare function isFastembedAvailable(): Promise<boolean>;
+export declare function getModelInfo(): {
+    name: string;
+    dimensions: number;
+};

package/dist/mcp/search/embedder.js

@@ -0,0 +1,83 @@
+const MODEL_NAME = 'BGESmallENV15';
+const MODEL_DIMENSIONS = 384;
+let embedderInstance = null;
+let embedderPromise = null;
+let idleTimer = null;
+const IDLE_TIMEOUT_MS = 5 * 60 * 1000;
+function resetIdleTimer() {
+    if (idleTimer) {
+        clearTimeout(idleTimer);
+    }
+    idleTimer = setTimeout(() => {
+        unloadEmbedder();
+    }, IDLE_TIMEOUT_MS);
+}
+export function unloadEmbedder() {
+    if (idleTimer) {
+        clearTimeout(idleTimer);
+        idleTimer = null;
+    }
+    embedderInstance = null;
+    embedderPromise = null;
+}
+async function getEmbedder() {
+    if (embedderInstance) {
+        resetIdleTimer();
+        return embedderInstance;
+    }
+    if (embedderPromise) {
+        return embedderPromise;
+    }
+    embedderPromise = (async () => {
+        try {
+            const { EmbeddingModel, FlagEmbedding } = await import('fastembed');
+            embedderInstance = await FlagEmbedding.init({
+                model: EmbeddingModel[MODEL_NAME],
+            });
+            resetIdleTimer();
+            return embedderInstance;
+        }
+        catch (error) {
+            embedderPromise = null;
+            throw new Error(`Failed to initialize embedder: ${error}`);
+        }
+    })();
+    return embedderPromise;
+}
+export async function embed(text) {
+    const embedder = await getEmbedder();
+    const embeddings = await embedder.embed([text]);
+    for await (const embedding of embeddings) {
+        const vec = Array.isArray(embedding) ? embedding[0] : embedding;
+        return Array.from(vec);
+    }
+    throw new Error('No embedding generated');
+}
+export async function embedBatch(texts) {
+    const embedder = await getEmbedder();
+    const embeddings = await embedder.embed(texts);
+    const results = [];
+    for await (const embedding of embeddings) {
+        const vec = Array.isArray(embedding) ? embedding[0] : embedding;
+        results.push(Array.from(vec));
+    }
+    return results;
+}
+export function createEmbedder() {
+    return (text, _model) => embed(text);
+}
+export async function isFastembedAvailable() {
+    try {
+        await import('fastembed');
+        return true;
+    }
+    catch {
+        return false;
+    }
+}
+export function getModelInfo() {
+    return {
+        name: MODEL_NAME,
+        dimensions: MODEL_DIMENSIONS,
+    };
+}

package/dist/mcp/search/hybrid-search.d.ts

@@ -7,6 +7,7 @@ export declare class HybridSearch {
     private initialized;
     private config;
     constructor(config?: HybridSearchConfig);
+    setEmbedder(embedder: (text: string, model?: string) => Promise<number[]>): void;
     initialize(docs: IndexedDoc[]): Promise<void>;
     private loadPrecomputedEmbeddings;
     search(query: string, options?: SearchOptions): Promise<SearchResult[]>;

package/dist/mcp/search/hybrid-search.js

@@ -16,8 +16,12 @@ export class HybridSearch {
             fuzzyWeight: config.fuzzyWeight ?? 0.5,
             semanticWeight: config.semanticWeight ?? 0.5,
             debug: config.debug ?? false,
+            embedder: config.embedder,
         };
     }
+    setEmbedder(embedder) {
+        this.config.embedder = embedder;
+    }
     async initialize(docs) {
         this.docs = docs;
         this.fuse = new Fuse(docs, {
@@ -55,8 +59,13 @@ export class HybridSearch {
             }
             if (this.embeddingsData) {
                 for (const entry of this.embeddingsData.documents) {
-                    if (entry.vector && entry.vector.length > 0) {
-                        this.vectors.set(entry.id, entry.vector);
+                    if (entry.vector) {
+                        const vec = Array.isArray(entry.vector)
+                            ? entry.vector
+                            : Object.values(entry.vector);
+                        if (vec.length > 0) {
+                            this.vectors.set(entry.id, vec);
+                        }
                     }
                 }
                 this.log(`Loaded ${this.vectors.size} pre-computed embeddings (model: ${this.embeddingsData.model})`);
@@ -86,7 +95,7 @@ export class HybridSearch {
             this.log(`Fuzzy search found ${fuzzyResults.length} results`);
         }
         if ((mode === 'hybrid' || mode === 'semantic') && this.vectors.size > 0) {
-            const semanticResults = this.semanticSearch(searchQuery, limit * 2, category);
+            const semanticResults = await this.semanticSearch(searchQuery, limit * 2, category);
             for (const result of semanticResults) {
                 const existing = results.get(result.id);
                 if (existing) {
@@ -152,10 +161,53 @@ export class HybridSearch {
             source: 'fuzzy',
         }));
     }
-    semanticSearch(query, limit, category) {
+    async semanticSearch(query, limit, category) {
         if (!this.embeddingsData || this.vectors.size === 0) {
             return [];
         }
+        if (this.config.embedder) {
+            try {
+                const model = this.embeddingsData.model;
+                const queryVector = await this.config.embedder(query, model);
+                this.log(`Generated query vector using provided embedder (model: ${model})`);
+                const scores = [];
+                for (const [id, vector] of this.vectors) {
+                    if (category) {
+                        const entry = this.embeddingsData.documents.find((e) => e.id === id);
+                        if (!entry || !entry.category.toLowerCase().includes(category.toLowerCase())) {
+                            continue;
+                        }
+                    }
+                    if (vector.length !== queryVector.length)
+                        continue;
+                    const score = cosineSimilarity(queryVector, vector);
+                    if (score > 0.05) {
+                        scores.push({ id, score });
+                    }
+                }
+                const results = [];
+                for (const s of scores.sort((a, b) => b.score - a.score).slice(0, limit)) {
+                    const doc = this.docs.find((d) => d.id === s.id);
+                    const entry = this.embeddingsData.documents.find((e) => e.id === s.id);
+                    if (!doc && !entry)
+                        continue;
+                    const content = doc?.content || '';
+                    results.push({
+                        id: s.id,
+                        path: doc?.path || entry?.path || '',
+                        title: doc?.title || entry?.title || 'Unknown',
+                        content,
+                        snippet: this.extractSnippet(content, query),
+                        score: s.score,
+                        source: 'semantic',
+                    });
+                }
+                return results;
+            }
+            catch (error) {
+                this.log(`Embedder failed: ${error}. Falling back to synthetic vectors.`);
+            }
+        }
         const queryTerms = this.tokenize(query);
         const scores = [];
         for (const entry of this.embeddingsData.documents) {

package/dist/mcp/search/index.d.ts

@@ -1,3 +1,4 @@
 export { HybridSearch, createHybridSearch } from './hybrid-search.js';
 export { cosineSimilarity, levenshtein, stringSimilarity, reciprocalRankFusion, combineScores, } from './math.js';
+export { embed, embedBatch, createEmbedder, isFastembedAvailable, getModelInfo, unloadEmbedder, } from './embedder.js';
 export type { IndexedDoc, SearchResult, SearchOptions, HybridSearchConfig, EmbeddingsData, EmbeddingEntry, } from './types.js';

package/dist/mcp/search/index.js

@@ -1,2 +1,3 @@
 export { HybridSearch, createHybridSearch } from './hybrid-search.js';
 export { cosineSimilarity, levenshtein, stringSimilarity, reciprocalRankFusion, combineScores, } from './math.js';
+export { embed, embedBatch, createEmbedder, isFastembedAvailable, getModelInfo, unloadEmbedder, } from './embedder.js';

package/dist/mcp/search/types.d.ts

@@ -45,4 +45,5 @@ export interface HybridSearchConfig {
     fuzzyWeight?: number;
     semanticWeight?: number;
     debug?: boolean;
+    embedder?: (text: string, model?: string) => Promise<number[]>;
 }

package/dist/mcp/server.d.ts

@@ -22,9 +22,13 @@ export declare class MCPServer {
     private sseClients;
     private initialized;
     private toolRegistry;
+    private aiClient?;
     constructor(options?: MCPServerOptions);
     private indexReady;
     private ensureIndexReady;
+    private initAI;
+    private fastEmbedModel;
+    private generateEmbedding;
     private log;
     private findDocsPath;
     private findExamplesPath;

package/dist/mcp/server.js

@@ -3,6 +3,7 @@ import { readFileSync, readdirSync, statSync, existsSync } from 'fs';
 import { join, relative, extname, basename, dirname } from 'path';
 import { createInterface } from 'readline';
 import { fileURLToPath } from 'url';
+import { createAI } from '../ai/index.js';
 import { createHybridSearch } from './search/index.js';
 import { UnsupportedError } from '../core/errors.js';
 import { getIpInfo, isValidIP, isGeoIPAvailable, isBogon, isIPv6 } from './ip-intel.js';
@@ -19,6 +20,7 @@ export class MCPServer {
     sseClients = new Set();
     initialized = false;
     toolRegistry;
+    aiClient;
     constructor(options = {}) {
         this.options = {
             name: options.name || 'recker-docs',
@@ -32,7 +34,11 @@ export class MCPServer {
             toolsFilter: options.toolsFilter || [],
             toolPaths: options.toolPaths || [],
         };
-        this.hybridSearch = createHybridSearch({ debug: this.options.debug });
+        this.aiClient = this.initAI();
+        this.hybridSearch = createHybridSearch({
+            debug: this.options.debug,
+            embedder: (text, model) => this.generateEmbedding(text, model || 'BGESmallENV15'),
+        });
         this.toolRegistry = new ToolRegistry();
         this.registerInternalTools();
         this.toolRegistry.registerModule({
@@ -47,6 +53,56 @@ export class MCPServer {
         }
         await this.indexReady;
     }
+    initAI() {
+        const hasKeys = process.env.OPENAI_API_KEY || process.env.GOOGLE_API_KEY;
+        const hasLocal = process.env.OLLAMA_HOST || true;
+        if (!hasKeys) {
+            return undefined;
+        }
+        try {
+            return createAI({ debug: this.options.debug });
+        }
+        catch (e) {
+            this.log('Failed to initialize AI client:', e);
+            return undefined;
+        }
+    }
+    fastEmbedModel = null;
+    async generateEmbedding(text, model) {
+        if (model.toLowerCase().includes('bge')) {
+            if (!this.fastEmbedModel) {
+                try {
+                    const fastembed = await import('fastembed');
+                    const { FlagEmbedding } = fastembed;
+                    this.fastEmbedModel = await FlagEmbedding.init({
+                        model: model,
+                        showDownloadProgress: false
+                    });
+                }
+                catch (e) {
+                    throw new Error(`FastEmbed required for model ${model}. Install with: pnpm add fastembed`);
+                }
+            }
+            const vectors = this.fastEmbedModel.embed([text]);
+            for await (const v of vectors)
+                return Array.from(v);
+            throw new Error('No vector generated');
+        }
+        if (!this.aiClient) {
+            throw new Error('No AI client available for external embeddings');
+        }
+        let provider = 'openai';
+        if (model.includes('google') || model.includes('gecko'))
+            provider = 'google';
+        else if (model.includes('nomic') || model.includes('llama'))
+            provider = 'ollama';
+        const res = await this.aiClient.embed({
+            input: text,
+            provider,
+            model
+        });
+        return res.embeddings[0];
+    }
     log(message, data) {
         if (this.options.debug) {
             if (this.options.transport === 'stdio') {

package/dist/mini.d.ts

@@ -16,6 +16,12 @@ export interface MiniClient {
     put<T = unknown>(path: string, body?: unknown): Promise<MiniResponse<T>>;
     patch<T = unknown>(path: string, body?: unknown): Promise<MiniResponse<T>>;
     delete<T = unknown>(path: string): Promise<MiniResponse<T>>;
+    head<T = unknown>(path: string): Promise<MiniResponse<T>>;
+    options<T = unknown>(path: string): Promise<MiniResponse<T>>;
+    trace<T = unknown>(path: string): Promise<MiniResponse<T>>;
+    purge<T = unknown>(path: string): Promise<MiniResponse<T>>;
+    request<T = unknown>(method: string, path: string, body?: unknown): Promise<MiniResponse<T>>;
+    close(): Promise<void>;
 }
 export declare function createMiniClient(options: MiniClientOptions): MiniClient;
 export declare function miniGet<T = unknown>(url: string, headers?: Record<string, string>): Promise<MiniResponse<T>>;

package/dist/mini.js

@@ -1,8 +1,9 @@
-import { request as undiciRequest } from 'undici';
+import { Client, request as undiciRequest } from 'undici';
 export function createMiniClient(options) {
     const base = options.baseUrl.endsWith('/')
         ? options.baseUrl.slice(0, -1)
         : options.baseUrl;
+    const undiciClient = new Client(base);
     const defaultHeaders = options.headers || {};
     const jsonHeaders = {
         ...defaultHeaders,
@@ -16,44 +17,48 @@ export function createMiniClient(options) {
         arrayBuffer: () => body.arrayBuffer(),
         blob: async () => new Blob([await body.arrayBuffer()])
     });
+    const doRequest = async (method, path, body, useJsonHeaders = false) => {
+        const { statusCode, headers, body: resBody } = await undiciClient.request({
+            path,
+            method,
+            headers: useJsonHeaders ? jsonHeaders : defaultHeaders,
+            body: body !== undefined ? JSON.stringify(body) : undefined
+        });
+        return wrapResponse(statusCode, headers, resBody);
+    };
     return {
         async get(path) {
-            const { statusCode, headers, body } = await undiciRequest(base + path, {
-                method: 'GET',
-                headers: defaultHeaders
-            });
-            return wrapResponse(statusCode, headers, body);
+            return doRequest('GET', path);
         },
         async post(path, data) {
-            const { statusCode, headers, body } = await undiciRequest(base + path, {
-                method: 'POST',
-                headers: jsonHeaders,
-                body: data !== undefined ? JSON.stringify(data) : undefined
-            });
-            return wrapResponse(statusCode, headers, body);
+            return doRequest('POST', path, data, true);
         },
         async put(path, data) {
-            const { statusCode, headers, body } = await undiciRequest(base + path, {
-                method: 'PUT',
-                headers: jsonHeaders,
-                body: data !== undefined ? JSON.stringify(data) : undefined
-            });
-            return wrapResponse(statusCode, headers, body);
+            return doRequest('PUT', path, data, true);
         },
         async patch(path, data) {
-            const { statusCode, headers, body } = await undiciRequest(base + path, {
-                method: 'PATCH',
-                headers: jsonHeaders,
-                body: data !== undefined ? JSON.stringify(data) : undefined
-            });
-            return wrapResponse(statusCode, headers, body);
+            return doRequest('PATCH', path, data, true);
         },
         async delete(path) {
-            const { statusCode, headers, body } = await undiciRequest(base + path, {
-                method: 'DELETE',
-                headers: defaultHeaders
-            });
-            return wrapResponse(statusCode, headers, body);
+            return doRequest('DELETE', path);
+        },
+        async head(path) {
+            return doRequest('HEAD', path);
+        },
+        async options(path) {
+            return doRequest('OPTIONS', path);
+        },
+        async trace(path) {
+            return doRequest('TRACE', path);
+        },
+        async purge(path) {
+            return doRequest('PURGE', path);
+        },
+        async request(method, path, body) {
+            return doRequest(method.toUpperCase(), path, body, body !== undefined);
+        },
+        async close() {
+            await undiciClient.close();
         }
     };
 }

package/dist/testing/index.d.ts

@@ -8,8 +8,8 @@ export { MockWebSocketServer, createMockWebSocketServer, } from './mock-websocke
 export type { MockWebSocketServerOptions, MockWebSocketClient, MockWebSocketMessage, MockWebSocketStats, } from './mock-websocket-server.js';
 export { MockSSEServer, createMockSSEServer, } from './mock-sse-server.js';
 export type { MockSSEServerOptions, SSEEvent, MockSSEClient, MockSSEStats, } from './mock-sse-server.js';
-export { MockHttpServer, createMockHttpServer, } from './mock-http-server.js';
-export type { MockHttpServerOptions, MockHttpResponse, MockHttpRequest, MockHttpHandler, MockHttpStats, } from './mock-http-server.js';
+export { MockHttpServer, createMockHttpServer, createWebhookServer, } from './mock-http-server.js';
+export type { MockHttpServerOptions, MockHttpResponse, MockHttpRequest, MockHttpHandler, MockHttpStats, WebhookServerOptions, WebhookPayload, } from './mock-http-server.js';
 export { MockDnsServer, } from './mock-dns-server.js';
 export type { MockDnsServerOptions, DnsRecordType, DnsRecord, DnsMxRecord, DnsSoaRecord, DnsSrvRecord, MockDnsStats, } from './mock-dns-server.js';
 export { MockWhoisServer, } from './mock-whois-server.js';

package/dist/testing/index.js

@@ -3,7 +3,7 @@ export { MockUDPServer, createMockUDPServer, } from './mock-udp-server.js';
 export { MockHlsServer, createMockHlsVod, createMockHlsLive, createMockHlsMultiQuality, } from './mock-hls-server.js';
 export { MockWebSocketServer, createMockWebSocketServer, } from './mock-websocket-server.js';
 export { MockSSEServer, createMockSSEServer, } from './mock-sse-server.js';
-export { MockHttpServer, createMockHttpServer, } from './mock-http-server.js';
+export { MockHttpServer, createMockHttpServer, createWebhookServer, } from './mock-http-server.js';
 export { MockDnsServer, } from './mock-dns-server.js';
 export { MockWhoisServer, } from './mock-whois-server.js';
 export { MockTelnetServer, } from './mock-telnet-server.js';

package/dist/testing/mock-http-server.d.ts

@@ -81,6 +81,15 @@ export declare class MockHttpServer extends EventEmitter {
     optionsRoute(path: string, handler: MockHttpResponse | MockHttpHandler, options?: {
         times?: number;
     }): this;
+    trace(path: string, handler: MockHttpResponse | MockHttpHandler, options?: {
+        times?: number;
+    }): this;
+    connect(path: string, handler: MockHttpResponse | MockHttpHandler, options?: {
+        times?: number;
+    }): this;
+    purge(path: string, handler: MockHttpResponse | MockHttpHandler, options?: {
+        times?: number;
+    }): this;
     any(path: string, handler: MockHttpResponse | MockHttpHandler, options?: {
         times?: number;
     }): this;
@@ -97,3 +106,19 @@ export declare class MockHttpServer extends EventEmitter {
     static create(options?: MockHttpServerOptions): Promise<MockHttpServer>;
 }
 export declare function createMockHttpServer(routes?: Record<string, MockHttpResponse>, options?: MockHttpServerOptions): Promise<MockHttpServer>;
+export interface WebhookServerOptions extends MockHttpServerOptions {
+    log?: boolean;
+    logger?: (webhook: WebhookPayload) => void;
+    status?: 200 | 204;
+}
+export interface WebhookPayload {
+    id: string | null;
+    timestamp: Date;
+    method: string;
+    path: string;
+    headers: Record<string, string | string[] | undefined>;
+    body: any;
+}
+export declare function createWebhookServer(options?: WebhookServerOptions): Promise<MockHttpServer & {
+    webhooks: WebhookPayload[];
+}>;

package/dist/testing/mock-http-server.js

@@ -113,6 +113,15 @@ export class MockHttpServer extends EventEmitter {
     optionsRoute(path, handler, options) {
         return this.route('OPTIONS', path, handler, options);
     }
+    trace(path, handler, options) {
+        return this.route('TRACE', path, handler, options);
+    }
+    connect(path, handler, options) {
+        return this.route('CONNECT', path, handler, options);
+    }
+    purge(path, handler, options) {
+        return this.route('PURGE', path, handler, options);
+    }
     any(path, handler, options) {
         return this.route('*', path, handler, options);
     }
@@ -296,3 +305,39 @@ export async function createMockHttpServer(routes, options) {
     await server.start();
     return server;
 }
+export async function createWebhookServer(options = {}) {
+    const { log = true, logger, status = 204, ...serverOptions } = options;
+    const server = new MockHttpServer(serverOptions);
+    const webhooks = [];
+    const handleWebhook = (req, id) => {
+        const payload = {
+            id,
+            timestamp: new Date(),
+            method: req.method,
+            path: req.path,
+            headers: req.headers,
+            body: req.body,
+        };
+        webhooks.push(payload);
+        if (logger) {
+            logger(payload);
+        }
+        else if (log) {
+            const idStr = id ? ` [${id}]` : '';
+            console.log(`\n📥 Webhook received${idStr} at ${payload.timestamp.toISOString()}`);
+            console.log(`   Path: ${req.path}`);
+            if (req.body !== undefined) {
+                console.log(`   Body:`, typeof req.body === 'object' ? JSON.stringify(req.body, null, 2) : req.body);
+            }
+        }
+        return { status };
+    };
+    server.any('/', (req) => handleWebhook(req, null));
+    server.any('/:id', (req) => {
+        const match = req.path.match(/^\/([^/]+)$/);
+        const id = match ? match[1] : null;
+        return handleWebhook(req, id);
+    });
+    await server.start();
+    return Object.assign(server, { webhooks });
+}

package/package.json

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