recker 1.0.80 → 1.0.82-next.b8590bb

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/raffel/client.d.ts

@@ -0,0 +1,38 @@
+import { ReckerWebSocket } from '../websocket/client.js';
+import type { RaffelClientOptions, RaffelCallOptions, ChannelEventHandler } from './types.js';
+type Listener = (...args: any[]) => void;
+declare class SimpleEmitter {
+    private listeners;
+    on(event: string, listener: Listener): this;
+    once(event: string, listener: Listener): this;
+    off(event: string, listener: Listener): this;
+    emit(event: string, ...args: any[]): boolean;
+}
+export declare class RaffelClient extends SimpleEmitter {
+    private ws;
+    private pendingCalls;
+    private subscribedChannels;
+    private idCounter;
+    private defaultTimeout;
+    private onEvent?;
+    constructor(url: string, options?: RaffelClientOptions);
+    connect(): Promise<void>;
+    close(code?: number, reason?: string): void;
+    get isConnected(): boolean;
+    get raw(): ReckerWebSocket;
+    call<T = unknown>(procedure: string, payload?: unknown, options?: RaffelCallOptions): Promise<T>;
+    notify(procedure: string, payload?: unknown): void;
+    subscribe(channel: string, handler?: ChannelEventHandler): void;
+    unsubscribe(channel: string): void;
+    publish(channel: string, event: string, data?: unknown): void;
+    cancel(id: string): void;
+    private handleMessage;
+    private handleEnvelope;
+    private handleChannelMessage;
+    private nextId;
+    private extractBaseId;
+    private sendChannelSubscribe;
+    private sendRaw;
+}
+export declare function createRaffelClient(url: string, options?: RaffelClientOptions): RaffelClient;
+export {};

package/dist/raffel/client.js

@@ -0,0 +1,282 @@
+import { ReckerWebSocket } from '../websocket/client.js';
+import { RaffelError } from './types.js';
+class SimpleEmitter {
+    listeners = new Map();
+    on(event, listener) {
+        const set = this.listeners.get(event) ?? new Set();
+        set.add(listener);
+        this.listeners.set(event, set);
+        return this;
+    }
+    once(event, listener) {
+        const wrapped = (...args) => {
+            this.off(event, wrapped);
+            listener(...args);
+        };
+        return this.on(event, wrapped);
+    }
+    off(event, listener) {
+        const set = this.listeners.get(event);
+        if (set) {
+            set.delete(listener);
+            if (set.size === 0)
+                this.listeners.delete(event);
+        }
+        return this;
+    }
+    emit(event, ...args) {
+        const set = this.listeners.get(event);
+        if (!set)
+            return false;
+        for (const listener of [...set]) {
+            listener(...args);
+        }
+        return true;
+    }
+}
+export class RaffelClient extends SimpleEmitter {
+    ws;
+    pendingCalls = new Map();
+    subscribedChannels = new Map();
+    idCounter = 0;
+    defaultTimeout;
+    onEvent;
+    constructor(url, options = {}) {
+        super();
+        const { channels, channelHandlers, onEvent, defaultTimeout, ...wsOptions } = options;
+        this.defaultTimeout = defaultTimeout ?? 30_000;
+        this.onEvent = onEvent;
+        this.ws = new ReckerWebSocket(url, wsOptions);
+        if (channels) {
+            for (const ch of channels) {
+                this.subscribedChannels.set(ch, channelHandlers?.[ch] ?? null);
+            }
+        }
+        if (channelHandlers) {
+            for (const [ch, handler] of Object.entries(channelHandlers)) {
+                if (!this.subscribedChannels.has(ch)) {
+                    this.subscribedChannels.set(ch, handler);
+                }
+            }
+        }
+        this.ws.on('message', (msg) => this.handleMessage(msg));
+        this.ws.on('open', () => {
+            this.emit('raffel:connected');
+            for (const [channel] of this.subscribedChannels) {
+                this.sendChannelSubscribe(channel);
+            }
+        });
+        this.ws.on('close', (_code, _reason) => {
+            this.emit('raffel:disconnected');
+            for (const [id, pending] of this.pendingCalls) {
+                if (pending.timer)
+                    clearTimeout(pending.timer);
+                pending.reject(new Error(`Connection closed while waiting for response to ${id}`));
+            }
+            this.pendingCalls.clear();
+        });
+        this.ws.on('reconnecting', (attempt, delay) => {
+            this.emit('ws:reconnecting', attempt, delay);
+        });
+        this.ws.on('error', (err) => {
+            this.emit('ws:error', err);
+        });
+    }
+    async connect() {
+        return this.ws.connect();
+    }
+    close(code, reason) {
+        for (const [id, pending] of this.pendingCalls) {
+            if (pending.timer)
+                clearTimeout(pending.timer);
+            pending.reject(new Error(`Connection closed while waiting for response to ${id}`));
+        }
+        this.pendingCalls.clear();
+        this.ws.close(code, reason);
+    }
+    get isConnected() {
+        return this.ws.isConnected;
+    }
+    get raw() {
+        return this.ws;
+    }
+    async call(procedure, payload, options) {
+        const id = this.nextId();
+        const timeout = options?.timeout ?? this.defaultTimeout;
+        const envelope = {
+            id,
+            procedure,
+            type: 'request',
+            payload: payload ?? {},
+            metadata: {},
+        };
+        return new Promise((resolve, reject) => {
+            let timer = null;
+            const cleanup = () => {
+                this.pendingCalls.delete(id);
+                if (timer)
+                    clearTimeout(timer);
+                if (options?.signal) {
+                    options.signal.removeEventListener('abort', onAbort);
+                }
+            };
+            const onAbort = () => {
+                cleanup();
+                this.sendRaw({ id, type: 'cancel' });
+                reject(new Error(`Call to ${procedure} was aborted`));
+            };
+            if (timeout > 0) {
+                timer = setTimeout(() => {
+                    cleanup();
+                    reject(new Error(`Call to ${procedure} timed out after ${timeout}ms`));
+                }, timeout);
+            }
+            if (options?.signal) {
+                if (options.signal.aborted) {
+                    reject(new Error(`Call to ${procedure} was aborted`));
+                    return;
+                }
+                options.signal.addEventListener('abort', onAbort, { once: true });
+            }
+            this.pendingCalls.set(id, { resolve, reject, timer });
+            this.ws.sendJSON(envelope);
+        });
+    }
+    notify(procedure, payload) {
+        const envelope = {
+            id: this.nextId(),
+            procedure,
+            type: 'event',
+            payload: payload ?? {},
+            metadata: {},
+        };
+        this.ws.sendJSON(envelope);
+    }
+    subscribe(channel, handler) {
+        this.subscribedChannels.set(channel, handler ?? null);
+        if (this.ws.isConnected) {
+            this.sendChannelSubscribe(channel);
+        }
+    }
+    unsubscribe(channel) {
+        this.subscribedChannels.delete(channel);
+        if (this.ws.isConnected) {
+            const msg = {
+                id: this.nextId(),
+                type: 'unsubscribe',
+                channel,
+            };
+            this.ws.sendJSON(msg);
+        }
+    }
+    publish(channel, event, data) {
+        const msg = {
+            id: this.nextId(),
+            type: 'publish',
+            channel,
+            event,
+            data,
+        };
+        this.ws.sendJSON(msg);
+    }
+    cancel(id) {
+        const pending = this.pendingCalls.get(id);
+        if (pending) {
+            if (pending.timer)
+                clearTimeout(pending.timer);
+            pending.reject(new Error(`Call ${id} was cancelled`));
+            this.pendingCalls.delete(id);
+        }
+        this.sendRaw({ id, type: 'cancel' });
+    }
+    handleMessage(msg) {
+        if (typeof msg.data !== 'string')
+            return;
+        let parsed;
+        try {
+            parsed = JSON.parse(msg.data);
+        }
+        catch {
+            return;
+        }
+        if (parsed.channel) {
+            this.handleChannelMessage(parsed);
+        }
+        else if (parsed.procedure || parsed.type === 'cancel') {
+            this.handleEnvelope(parsed);
+        }
+        else {
+            this.emit('raffel:unknown', parsed);
+        }
+    }
+    handleEnvelope(envelope) {
+        const { id, type, procedure, payload } = envelope;
+        if (type === 'event' && procedure) {
+            this.onEvent?.(procedure, payload);
+            this.emit('raffel:event', procedure, payload);
+            return;
+        }
+        if (type === 'response' || type === 'error') {
+            const baseId = this.extractBaseId(id);
+            const pending = this.pendingCalls.get(baseId);
+            if (!pending)
+                return;
+            if (pending.timer)
+                clearTimeout(pending.timer);
+            this.pendingCalls.delete(baseId);
+            if (type === 'error') {
+                pending.reject(new RaffelError(payload, procedure));
+            }
+            else {
+                pending.resolve(payload);
+            }
+            return;
+        }
+    }
+    handleChannelMessage(msg) {
+        const { type, channel } = msg;
+        switch (type) {
+            case 'subscribed':
+                this.emit('raffel:channel:subscribed', channel, msg.members);
+                break;
+            case 'unsubscribed':
+                this.emit('raffel:channel:unsubscribed', channel);
+                break;
+            case 'event': {
+                const event = msg.event ?? '';
+                const data = msg.data;
+                const handler = this.subscribedChannels.get(channel);
+                if (handler)
+                    handler(event, data);
+                this.emit('raffel:channel:event', channel, event, data);
+                break;
+            }
+        }
+    }
+    nextId() {
+        return `req-${++this.idCounter}`;
+    }
+    extractBaseId(id) {
+        const suffixes = [':response', ':error'];
+        for (const suffix of suffixes) {
+            if (id.endsWith(suffix)) {
+                return id.slice(0, -suffix.length);
+            }
+        }
+        return id;
+    }
+    sendChannelSubscribe(channel) {
+        const msg = {
+            id: this.nextId(),
+            type: 'subscribe',
+            channel,
+        };
+        this.ws.sendJSON(msg);
+    }
+    sendRaw(data) {
+        this.ws.sendJSON(data);
+    }
+}
+export function createRaffelClient(url, options) {
+    return new RaffelClient(url, options);
+}

package/dist/raffel/index.d.ts

@@ -0,0 +1,2 @@
+export * from './client.js';
+export * from './types.js';

package/dist/raffel/index.js

@@ -0,0 +1,2 @@
+export * from './client.js';
+export * from './types.js';

package/dist/raffel/types.d.ts

@@ -0,0 +1,40 @@
+import type { WebSocketOptions } from '../websocket/client.js';
+export interface RaffelEnvelope {
+    id: string;
+    procedure?: string;
+    type: string;
+    payload?: unknown;
+    metadata?: Record<string, unknown>;
+}
+export interface RaffelChannelMessage {
+    id?: string;
+    type: string;
+    channel: string;
+    event?: string;
+    data?: unknown;
+    members?: string[];
+}
+export interface RaffelErrorPayload {
+    code: string;
+    status: number;
+    message: string;
+    details?: unknown;
+}
+export type ChannelEventHandler = (event: string, data: unknown) => void;
+export interface RaffelClientOptions extends WebSocketOptions {
+    channels?: string[];
+    channelHandlers?: Record<string, ChannelEventHandler>;
+    onEvent?: (procedure: string, payload: unknown) => void;
+    defaultTimeout?: number;
+}
+export interface RaffelCallOptions {
+    timeout?: number;
+    signal?: AbortSignal;
+}
+export declare class RaffelError extends Error {
+    code: string;
+    status: number;
+    details?: unknown;
+    procedure?: string;
+    constructor(payload: RaffelErrorPayload, procedure?: string);
+}

package/dist/raffel/types.js

@@ -0,0 +1,14 @@
+export class RaffelError extends Error {
+    code;
+    status;
+    details;
+    procedure;
+    constructor(payload, procedure) {
+        super(payload.message);
+        this.name = 'RaffelError';
+        this.code = payload.code;
+        this.status = payload.status;
+        this.details = payload.details;
+        this.procedure = procedure;
+    }
+}

package/dist/recker.d.ts

@@ -3,6 +3,8 @@ import { getVersion, getVersionInfo } from './version.js';
 import { type RequestPromise } from './core/request-promise.js';
 import type { RequestOptions } from './types/index.js';
 import { type WebSocketOptions, type ReckerWebSocket } from './websocket/client.js';
+import { type RaffelClient } from './raffel/client.js';
+import type { RaffelClientOptions } from './raffel/types.js';
 import { createWhois, type WhoisResult, type WhoisOptions } from './utils/whois.js';
 import { type DNSClientOptions, type DNSClient } from './dns/index.js';
 import type { AIClientConfig } from './types/ai.js';
@@ -43,6 +45,7 @@ export declare const recker: {
     dns: typeof dns;
     dnsSecurity: typeof dnsSecurity;
     ws: typeof ws;
+    raffel: (url: string, options?: RaffelClientOptions) => RaffelClient;
     video: typeof video;
     isVideoSupported: typeof isVideoSupported;
     extractVideo: typeof extractVideo;

package/dist/recker.js

@@ -1,6 +1,7 @@
 import { createClient } from './core/client.js';
 import { getVersion, getVersionSync, getVersionInfo } from './version.js';
 import { createWebSocket } from './websocket/client.js';
+import { createRaffelClient } from './raffel/client.js';
 import { whois as whoisLookup, isDomainAvailable, createWhois } from './utils/whois.js';
 import { createDNS } from './dns/index.js';
 import { createAI } from './ai/index.js';
@@ -150,6 +151,7 @@ export const recker = {
     dns,
     dnsSecurity,
     ws,
+    raffel: (url, options) => createRaffelClient(url, options),
     video,
     isVideoSupported,
     extractVideo,

package/dist/version.js

@@ -1,4 +1,4 @@
-const VERSION = '1.0.80';
+const VERSION = '1.0.82-next.b8590bb';
 let _version = null;
 export async function getVersion() {
     if (_version)

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "recker",
-  "version": "1.0.80",
+  "version": "1.0.82-next.b8590bb",
   "description": "Multi-Protocol SDK for the AI Era - HTTP, WebSocket, DNS, FTP, SFTP, Telnet, HLS unified with AI providers and MCP tools",
   "main": "./dist/index.js",
   "types": "./dist/index.d.ts",
@@ -211,6 +211,10 @@
       "types": "./dist/presets/*.d.ts",
       "import": "./dist/presets/*.js"
     },
+    "./raffel": {
+      "types": "./dist/raffel/index.d.ts",
+      "import": "./dist/raffel/index.js"
+    },
     "./package.json": "./package.json"
   },
   "browser": "./dist/browser/browser/index.js",
@@ -303,7 +307,7 @@
     "build:browser": "tsc -p tsconfig.browser.json",
     "build:browser:bundle": "pnpm build:browser && node scripts/bundle-browser.js",
     "build:cli": "node scripts/bundle-cli.js",
-    "build:binary": "npx pkg ./dist/bin/rek.cjs --output dist/bin/recker --targets node18-linux-x64,node18-macos-x64,node18-win-x64",
+    "build:binary": "node scripts/build-sea.js",
     "test": "NODE_OPTIONS='--max-old-space-size=512' vitest run",
     "test:coverage": "NODE_OPTIONS='--max-old-space-size=512' vitest run --coverage",
     "test:curl-impersonate:coverage": "NODE_OPTIONS='--max-old-space-size=512' vitest run --config vitest.config.curl-impersonate.ts --coverage",