agent-relay 2.3.2 → 2.3.5

package/packages/sdk/src/transports/socket-transport.ts

@@ -1,115 +0,0 @@
-/**
- * Unix/TCP Socket Transport for Node.js environments.
- * @agent-relay/sdk
- */
-
-import net from 'node:net';
-import type { Transport, TransportConfig, TransportEvents, TransportState } from './types.js';
-
-export interface SocketTransportConfig extends TransportConfig {
-  /** Unix socket path or TCP host:port */
-  socketPath: string;
-}
-
-/**
- * Socket-based transport for Unix sockets and TCP connections.
- * This is the default transport for Node.js environments.
- */
-export class SocketTransport implements Transport {
-  private socket?: net.Socket;
-  private config: SocketTransportConfig;
-  private events: TransportEvents = {};
-  private _state: TransportState = 'disconnected';
-
-  constructor(config: SocketTransportConfig) {
-    this.config = {
-      connectTimeout: 5000,
-      ...config,
-    };
-  }
-
-  get state(): TransportState {
-    return this._state;
-  }
-
-  setEvents(events: TransportEvents): void {
-    this.events = events;
-  }
-
-  connect(): Promise<void> {
-    if (this._state !== 'disconnected') {
-      return Promise.resolve();
-    }
-
-    return new Promise((resolve, reject) => {
-      this._state = 'connecting';
-
-      const timeout = setTimeout(() => {
-        if (this._state === 'connecting') {
-          this.socket?.destroy();
-          this._state = 'disconnected';
-          reject(new Error('Connection timeout'));
-        }
-      }, this.config.connectTimeout);
-
-      this.socket = net.createConnection(this.config.socketPath, () => {
-        clearTimeout(timeout);
-        this._state = 'connected';
-        this.events.onConnect?.();
-        resolve();
-      });
-
-      this.socket.on('data', (data) => {
-        // Convert Buffer to Uint8Array for consistent interface
-        this.events.onData?.(new Uint8Array(data.buffer, data.byteOffset, data.byteLength));
-      });
-
-      this.socket.on('close', () => {
-        this._state = 'disconnected';
-        this.events.onClose?.();
-      });
-
-      this.socket.on('error', (err) => {
-        clearTimeout(timeout);
-        if (this._state === 'connecting') {
-          this._state = 'disconnected';
-          reject(err);
-        }
-        this.events.onError?.(err);
-      });
-    });
-  }
-
-  disconnect(): void {
-    if (!this.socket || this._state === 'disconnected') {
-      return;
-    }
-
-    this._state = 'closing';
-    this.socket.end();
-    this.socket = undefined;
-    this._state = 'disconnected';
-  }
-
-  send(data: Uint8Array | Buffer): boolean {
-    if (!this.socket || this._state !== 'connected') {
-      return false;
-    }
-
-    try {
-      // Ensure we're sending a Buffer
-      const buffer = data instanceof Buffer ? data : Buffer.from(data);
-      this.socket.write(buffer);
-      return true;
-    } catch {
-      return false;
-    }
-  }
-}
-
-/**
- * Create a socket transport for Unix/TCP connections.
- */
-export function createSocketTransport(socketPath: string, config?: TransportConfig): SocketTransport {
-  return new SocketTransport({ socketPath, ...config });
-}

package/packages/sdk/src/transports/types.ts

@@ -1,77 +0,0 @@
-/**
- * Transport abstraction for relay client communication.
- * @agent-relay/sdk
- *
- * Defines the interface for different transport implementations:
- * - SocketTransport: Unix/TCP sockets (Node.js)
- * - WebSocketTransport: WebSocket connections (Node.js and Browser)
- */
-
-/**
- * Transport connection state.
- */
-export type TransportState = 'disconnected' | 'connecting' | 'connected' | 'closing';
-
-/**
- * Transport event handlers.
- */
-export interface TransportEvents {
-  /** Called when transport connects successfully */
-  onConnect?: () => void;
-  /** Called when transport receives data */
-  onData?: (data: Uint8Array) => void;
-  /** Called when transport disconnects */
-  onClose?: () => void;
-  /** Called when transport encounters an error */
-  onError?: (error: Error) => void;
-}
-
-/**
- * Transport configuration options.
- */
-export interface TransportConfig {
-  /** Connection timeout in milliseconds */
-  connectTimeout?: number;
-}
-
-/**
- * Transport interface for relay client communication.
- *
- * Implementations must handle:
- * - Connection lifecycle (connect, disconnect)
- * - Binary data transmission
- * - Event callbacks for state changes
- */
-export interface Transport {
-  /** Current connection state */
-  readonly state: TransportState;
-
-  /**
-   * Connect to the relay endpoint.
-   * @throws Error if connection fails
-   */
-  connect(): Promise<void>;
-
-  /**
-   * Disconnect from the relay.
-   */
-  disconnect(): void;
-
-  /**
-   * Send binary data to the relay.
-   * @param data - Data to send (Buffer or Uint8Array)
-   * @returns true if data was queued for sending
-   */
-  send(data: Uint8Array | Buffer): boolean;
-
-  /**
-   * Set event handlers.
-   * @param events - Event handler callbacks
-   */
-  setEvents(events: TransportEvents): void;
-}
-
-/**
- * Transport factory function type.
- */
-export type TransportFactory = (config?: TransportConfig) => Transport;

package/packages/sdk/src/transports/websocket-transport.ts

@@ -1,245 +0,0 @@
-/**
- * WebSocket Transport for browser and Node.js environments.
- * @agent-relay/sdk
- *
- * Uses native WebSocket in browsers and 'ws' package in Node.js.
- * The transport expects the daemon to have a WebSocket endpoint (e.g., /ws).
- */
-
-import type { Transport, TransportConfig, TransportEvents, TransportState } from './types.js';
-
-export interface WebSocketTransportConfig extends TransportConfig {
-  /** WebSocket URL (e.g., ws://localhost:3888/ws) */
-  url: string;
-  /** Protocols to use in WebSocket handshake */
-  protocols?: string | string[];
-}
-
-// Simple close event type (works in both browser and Node.js)
-interface CloseEventLike {
-  code?: number;
-  reason?: string;
-  wasClean?: boolean;
-}
-
-// Simple message event type (works in both browser and Node.js)
-interface MessageEventLike {
-  data: ArrayBuffer | string | Buffer;
-}
-
-// Type for WebSocket (works in both browser and Node.js with 'ws')
-interface WebSocketLike {
-  readyState: number;
-  CONNECTING: number;
-  OPEN: number;
-  CLOSING: number;
-  CLOSED: number;
-  send(data: ArrayBuffer | Uint8Array | string): void;
-  close(): void;
-  onopen: ((ev: Event) => void) | null;
-  onclose: ((ev: CloseEventLike) => void) | null;
-  onerror: ((ev: Event | Error) => void) | null;
-  onmessage: ((ev: MessageEventLike) => void) | null;
-  binaryType: string;
-}
-
-// Constructor type for WebSocket
-type WebSocketConstructor = new (url: string, protocols?: string | string[]) => WebSocketLike;
-
-/**
- * WebSocket-based transport for browser and Node.js.
- *
- * In browsers, uses native WebSocket.
- * In Node.js, requires 'ws' package (optional dependency).
- */
-export class WebSocketTransport implements Transport {
-  private ws?: WebSocketLike;
-  private config: WebSocketTransportConfig;
-  private events: TransportEvents = {};
-  private _state: TransportState = 'disconnected';
-  private WebSocketImpl?: WebSocketConstructor;
-
-  constructor(config: WebSocketTransportConfig) {
-    this.config = {
-      connectTimeout: 5000,
-      ...config,
-    };
-  }
-
-  get state(): TransportState {
-    return this._state;
-  }
-
-  setEvents(events: TransportEvents): void {
-    this.events = events;
-  }
-
-  /**
-   * Get WebSocket implementation (native or 'ws' package).
-   */
-  private async getWebSocketImpl(): Promise<WebSocketConstructor> {
-    if (this.WebSocketImpl) {
-      return this.WebSocketImpl;
-    }
-
-    // Check for browser environment
-    if (typeof globalThis !== 'undefined' && 'WebSocket' in globalThis) {
-      this.WebSocketImpl = (globalThis as { WebSocket: WebSocketConstructor }).WebSocket;
-      return this.WebSocketImpl;
-    }
-
-    // Node.js environment - try to load 'ws' package
-    try {
-      // Dynamic import of 'ws' for Node.js
-      // eslint-disable-next-line @typescript-eslint/no-explicit-any
-      const wsModule = await import('ws' as any) as any;
-      const impl = wsModule.default || wsModule.WebSocket || wsModule;
-      if (!impl) {
-        throw new Error('ws module loaded but WebSocket constructor not found');
-      }
-      this.WebSocketImpl = impl as WebSocketConstructor;
-      return this.WebSocketImpl;
-    } catch {
-      throw new Error(
-        'WebSocket not available. In Node.js, install the "ws" package:\n' +
-        '  npm install ws\n\n' +
-        'In browsers, native WebSocket should be available.'
-      );
-    }
-  }
-
-  async connect(): Promise<void> {
-    if (this._state !== 'disconnected') {
-      return;
-    }
-
-    const WebSocketImpl = await this.getWebSocketImpl();
-
-    return new Promise((resolve, reject) => {
-      this._state = 'connecting';
-
-      const timeout = setTimeout(() => {
-        if (this._state === 'connecting') {
-          this.ws?.close();
-          this._state = 'disconnected';
-          reject(new Error('Connection timeout'));
-        }
-      }, this.config.connectTimeout);
-
-      try {
-        this.ws = new WebSocketImpl(this.config.url, this.config.protocols);
-        this.ws.binaryType = 'arraybuffer';
-
-        this.ws.onopen = () => {
-          clearTimeout(timeout);
-          this._state = 'connected';
-          this.events.onConnect?.();
-          resolve();
-        };
-
-        this.ws.onmessage = (event: MessageEventLike) => {
-          // Handle binary data
-          if (event.data instanceof ArrayBuffer) {
-            this.events.onData?.(new Uint8Array(event.data));
-          } else if (typeof event.data === 'string') {
-            // Convert string to Uint8Array (shouldn't happen with binaryType = 'arraybuffer')
-            const encoder = new TextEncoder();
-            this.events.onData?.(encoder.encode(event.data));
-          } else if (event.data && typeof (event.data as Buffer).buffer !== 'undefined') {
-            // Handle Node.js Buffer
-            const buf = event.data as Buffer;
-            this.events.onData?.(new Uint8Array(buf.buffer, buf.byteOffset, buf.byteLength));
-          }
-        };
-
-        this.ws.onclose = () => {
-          clearTimeout(timeout);
-          this._state = 'disconnected';
-          this.events.onClose?.();
-        };
-
-        this.ws.onerror = (event: Event | Error) => {
-          clearTimeout(timeout);
-          const error = event instanceof Error
-            ? event
-            : new Error('WebSocket error');
-          if (this._state === 'connecting') {
-            this._state = 'disconnected';
-            reject(error);
-          }
-          this.events.onError?.(error);
-        };
-      } catch (err) {
-        clearTimeout(timeout);
-        this._state = 'disconnected';
-        reject(err instanceof Error ? err : new Error(String(err)));
-      }
-    });
-  }
-
-  disconnect(): void {
-    if (!this.ws || this._state === 'disconnected') {
-      return;
-    }
-
-    this._state = 'closing';
-    this.ws.close();
-    this.ws = undefined;
-    this._state = 'disconnected';
-  }
-
-  send(data: Uint8Array | Buffer): boolean {
-    if (!this.ws || this._state !== 'connected') {
-      return false;
-    }
-
-    try {
-      // WebSocket send accepts ArrayBuffer or Uint8Array
-      // Convert Buffer to Uint8Array for browser compatibility
-      let bytes: Uint8Array;
-      if (data instanceof Uint8Array) {
-        bytes = data;
-      } else {
-        // Handle Buffer (Node.js)
-        const buf = data as Buffer;
-        bytes = new Uint8Array(buf.buffer, buf.byteOffset, buf.byteLength);
-      }
-      this.ws.send(bytes);
-      return true;
-    } catch {
-      return false;
-    }
-  }
-}
-
-/**
- * Create a WebSocket transport.
- *
- * @param url - WebSocket URL (e.g., ws://localhost:3888/ws)
- * @param config - Additional configuration options
- */
-export function createWebSocketTransport(
-  url: string,
-  config?: Omit<WebSocketTransportConfig, 'url'>
-): WebSocketTransport {
-  return new WebSocketTransport({ url, ...config });
-}
-
-/**
- * Convert a socket path to WebSocket URL.
- * Useful when daemon provides both Unix socket and WebSocket endpoints.
- *
- * @param host - Host address (default: localhost)
- * @param port - Port number (default: 3888)
- * @param path - WebSocket path (default: /ws)
- * @param secure - Use wss:// instead of ws:// (default: false)
- */
-export function socketPathToWsUrl(
-  host = 'localhost',
-  port = 3888,
-  path = '/ws',
-  secure = false
-): string {
-  const protocol = secure ? 'wss' : 'ws';
-  return `${protocol}://${host}:${port}${path}`;
-}