recker 1.0.83 → 1.0.84-next.ca0ad49

package/dist/raffel/transport-udp.js

@@ -0,0 +1,104 @@
+import { createSocket } from 'node:dgram';
+import { TransportCapability } from './transport.js';
+const MAX_DATAGRAM_SIZE = 65_507;
+const UDP_CAPABILITIES = TransportCapability.CALL |
+    TransportCapability.NOTIFY;
+export class UdpTransport {
+    capabilities = UDP_CAPABILITIES;
+    socket = null;
+    connected = false;
+    listeners = new Map();
+    host;
+    port;
+    options;
+    constructor(url, options = {}) {
+        const parsed = new URL(url.replace('udp://', 'http://'));
+        this.host = parsed.hostname;
+        this.port = parseInt(parsed.port, 10) || 9000;
+        this.options = options;
+    }
+    get isConnected() {
+        return this.connected;
+    }
+    async connect() {
+        return new Promise((resolve, reject) => {
+            const socketType = this.options.socketType ?? 'udp4';
+            this.socket = createSocket(socketType);
+            this.socket.on('message', (msg) => {
+                let parsed;
+                try {
+                    parsed = JSON.parse(msg.toString('utf8'));
+                }
+                catch {
+                    this.emit('error', new Error('Invalid JSON in UDP datagram'));
+                    return;
+                }
+                this.emit('message', parsed);
+            });
+            this.socket.on('error', (err) => {
+                this.emit('error', err);
+            });
+            this.socket.on('close', () => {
+                this.connected = false;
+                this.emit('disconnected');
+            });
+            this.socket.bind(0, () => {
+                this.connected = true;
+                this.emit('connected');
+                resolve();
+            });
+        });
+    }
+    close() {
+        if (this.socket) {
+            try {
+                this.socket.close();
+            }
+            catch { }
+            this.socket = null;
+        }
+        if (this.connected) {
+            this.connected = false;
+            this.emit('disconnected');
+        }
+    }
+    send(data) {
+        if (!this.socket || !this.connected) {
+            throw new Error('UDP transport not connected');
+        }
+        const json = JSON.stringify(data);
+        const buf = Buffer.from(json, 'utf8');
+        if (buf.length > MAX_DATAGRAM_SIZE) {
+            throw new Error(`Datagram size ${buf.length} exceeds maximum ${MAX_DATAGRAM_SIZE}`);
+        }
+        this.socket.send(buf, this.port, this.host);
+    }
+    on(event, listener) {
+        const set = this.listeners.get(event) ?? new Set();
+        set.add(listener);
+        this.listeners.set(event, set);
+    }
+    off(event, listener) {
+        const set = this.listeners.get(event);
+        if (set) {
+            set.delete(listener);
+            if (set.size === 0)
+                this.listeners.delete(event);
+        }
+    }
+    once(event, listener) {
+        const wrapped = (...args) => {
+            this.off(event, wrapped);
+            listener(...args);
+        };
+        this.on(event, wrapped);
+    }
+    emit(event, ...args) {
+        const set = this.listeners.get(event);
+        if (!set)
+            return;
+        for (const listener of [...set]) {
+            listener(...args);
+        }
+    }
+}

package/dist/raffel/transport-ws.d.ts

@@ -0,0 +1,19 @@
+import { ReckerWebSocket, type WebSocketOptions } from '../websocket/client.js';
+import type { RaffelTransport, RaffelTransportEvent } from './transport.js';
+type Listener = (...args: any[]) => void;
+export declare class WsTransport implements RaffelTransport {
+    readonly capabilities: number;
+    private ws;
+    private listeners;
+    constructor(url: string, options?: WebSocketOptions);
+    get isConnected(): boolean;
+    get socket(): ReckerWebSocket;
+    connect(): Promise<void>;
+    close(code?: number, reason?: string): void;
+    send(data: unknown): void;
+    on(event: RaffelTransportEvent, listener: Listener): void;
+    off(event: RaffelTransportEvent, listener: Listener): void;
+    once(event: RaffelTransportEvent, listener: Listener): void;
+    private emit;
+}
+export {};

package/dist/raffel/transport-ws.js

@@ -0,0 +1,75 @@
+import { ReckerWebSocket } from '../websocket/client.js';
+import { TransportCapability } from './transport.js';
+const ALL_CAPABILITIES = TransportCapability.CALL |
+    TransportCapability.NOTIFY |
+    TransportCapability.SUBSCRIBE |
+    TransportCapability.PUBLISH |
+    TransportCapability.CANCEL |
+    TransportCapability.STREAM;
+export class WsTransport {
+    capabilities = ALL_CAPABILITIES;
+    ws;
+    listeners = new Map();
+    constructor(url, options = {}) {
+        this.ws = new ReckerWebSocket(url, options);
+        this.ws.on('message', (msg) => {
+            if (typeof msg.data !== 'string')
+                return;
+            let parsed;
+            try {
+                parsed = JSON.parse(msg.data);
+            }
+            catch {
+                return;
+            }
+            this.emit('message', parsed);
+        });
+        this.ws.on('open', () => this.emit('connected'));
+        this.ws.on('close', () => this.emit('disconnected'));
+        this.ws.on('reconnecting', (attempt, delay) => this.emit('reconnecting', attempt, delay));
+        this.ws.on('error', (err) => this.emit('error', err));
+    }
+    get isConnected() {
+        return this.ws.isConnected;
+    }
+    get socket() {
+        return this.ws;
+    }
+    async connect() {
+        return this.ws.connect();
+    }
+    close(code, reason) {
+        this.ws.close(code, reason);
+    }
+    send(data) {
+        this.ws.sendJSON(data);
+    }
+    on(event, listener) {
+        const set = this.listeners.get(event) ?? new Set();
+        set.add(listener);
+        this.listeners.set(event, set);
+    }
+    off(event, listener) {
+        const set = this.listeners.get(event);
+        if (set) {
+            set.delete(listener);
+            if (set.size === 0)
+                this.listeners.delete(event);
+        }
+    }
+    once(event, listener) {
+        const wrapped = (...args) => {
+            this.off(event, wrapped);
+            listener(...args);
+        };
+        this.on(event, wrapped);
+    }
+    emit(event, ...args) {
+        const set = this.listeners.get(event);
+        if (!set)
+            return;
+        for (const listener of [...set]) {
+            listener(...args);
+        }
+    }
+}

package/dist/raffel/transport.d.ts

@@ -0,0 +1,29 @@
+import type { RaffelEnvelope } from './types.js';
+export declare const TransportCapability: {
+    readonly CALL: 1;
+    readonly NOTIFY: 2;
+    readonly SUBSCRIBE: 4;
+    readonly PUBLISH: 8;
+    readonly CANCEL: 16;
+    readonly STREAM: 32;
+};
+export type TransportCapabilityFlag = (typeof TransportCapability)[keyof typeof TransportCapability];
+export type RaffelTransportEvent = 'connected' | 'disconnected' | 'message' | 'reconnecting' | 'error';
+type Listener = (...args: any[]) => void;
+export interface RaffelTransport {
+    readonly capabilities: number;
+    readonly isConnected: boolean;
+    connect(): Promise<void>;
+    close(code?: number, reason?: string): void;
+    send(data: unknown): void;
+    on(event: RaffelTransportEvent, listener: Listener): void;
+    off(event: RaffelTransportEvent, listener: Listener): void;
+    once(event: RaffelTransportEvent, listener: Listener): void;
+}
+export interface RaffelExecutableTransport extends RaffelTransport {
+    execute(envelope: RaffelEnvelope): Promise<unknown>;
+    executeStream?(envelope: RaffelEnvelope): AsyncIterable<unknown>;
+}
+export declare function hasExecute(transport: RaffelTransport): transport is RaffelExecutableTransport;
+export declare function hasCapability(transport: RaffelTransport, cap: number): boolean;
+export {};

package/dist/raffel/transport.js

@@ -0,0 +1,14 @@
+export const TransportCapability = {
+    CALL: 0b000001,
+    NOTIFY: 0b000010,
+    SUBSCRIBE: 0b000100,
+    PUBLISH: 0b001000,
+    CANCEL: 0b010000,
+    STREAM: 0b100000,
+};
+export function hasExecute(transport) {
+    return typeof transport.execute === 'function';
+}
+export function hasCapability(transport, cap) {
+    return (transport.capabilities & cap) === cap;
+}

package/dist/raffel/types.d.ts

@@ -20,12 +20,40 @@ export interface RaffelErrorPayload {
     message: string;
     details?: unknown;
 }
+export type RaffelTransportType = 'websocket' | 'http' | 'tcp' | 'udp' | 'jsonrpc';
+export interface RaffelHttpOptions {
+    headers?: Record<string, string>;
+    timeout?: number;
+}
+export interface RaffelTcpOptions {
+    keepAlive?: boolean;
+    keepAliveInterval?: number;
+    noDelay?: boolean;
+    reconnect?: boolean;
+    reconnectDelay?: number;
+    maxReconnectAttempts?: number;
+}
+export interface RaffelUdpOptions {
+    socketType?: 'udp4' | 'udp6';
+    enableAck?: boolean;
+    ackTimeout?: number;
+}
+export interface RaffelJsonRpcOptions {
+    path?: string;
+    headers?: Record<string, string>;
+}
 export type ChannelEventHandler = (event: string, data: unknown) => void;
-export interface RaffelClientOptions extends WebSocketOptions {
+export interface RaffelClientOptions {
+    transport?: RaffelTransportType;
+    defaultTimeout?: number;
     channels?: string[];
     channelHandlers?: Record<string, ChannelEventHandler>;
     onEvent?: (procedure: string, payload: unknown) => void;
-    defaultTimeout?: number;
+    ws?: WebSocketOptions;
+    http?: RaffelHttpOptions;
+    tcp?: RaffelTcpOptions;
+    udp?: RaffelUdpOptions;
+    jsonrpc?: RaffelJsonRpcOptions;
 }
 export interface RaffelCallOptions {
     timeout?: number;

package/dist/version.js

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

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "recker",
-  "version": "1.0.83",
+  "version": "1.0.84-next.ca0ad49",
   "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",