recker 1.0.80-next.70ea84d → 1.0.80

package/dist/index.d.ts

@@ -74,7 +74,6 @@ 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,7 +74,6 @@ 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/recker.d.ts

@@ -3,8 +3,6 @@ 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';
@@ -45,7 +43,6 @@ 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,7 +1,6 @@
 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';
@@ -151,7 +150,6 @@ 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-next.70ea84d';
+const VERSION = '1.0.80';
 let _version = null;
 export async function getVersion() {
     if (_version)

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "recker",
-  "version": "1.0.80-next.70ea84d",
+  "version": "1.0.80",
   "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,10 +211,6 @@
       "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",

package/dist/raffel/client.d.ts

@@ -1,38 +0,0 @@
-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

@@ -1,282 +0,0 @@
-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

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

package/dist/raffel/index.js

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

package/dist/raffel/types.d.ts

@@ -1,40 +0,0 @@
-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

@@ -1,14 +0,0 @@
-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;
-    }
-}