@furlow/pipes 0.1.0

package/dist/index.js

@@ -0,0 +1,1282 @@
+// src/http/index.ts
+import axios from "axios";
+var HttpPipe = class {
+  name;
+  type = "http";
+  client;
+  config;
+  requestCount = 0;
+  windowStart = Date.now();
+  constructor(options) {
+    this.name = options.name;
+    this.config = options.config;
+    this.client = axios.create({
+      baseURL: options.config.base_url,
+      timeout: this.parseDuration(options.config.timeout ?? "30s"),
+      headers: options.config.headers
+    });
+    if (options.config.auth) {
+      this.client.interceptors.request.use((config) => {
+        const auth = options.config.auth;
+        switch (auth.type) {
+          case "bearer":
+            config.headers.Authorization = `Bearer ${auth.token}`;
+            break;
+          case "basic":
+            const credentials = Buffer.from(`${auth.username}:${auth.password}`).toString("base64");
+            config.headers.Authorization = `Basic ${credentials}`;
+            break;
+          case "header":
+            const headerName = auth.header_name ?? "Authorization";
+            config.headers[headerName] = auth.token;
+            break;
+        }
+        return config;
+      });
+    }
+  }
+  isConnected() {
+    return true;
+  }
+  /**
+   * Make an HTTP request
+   */
+  async request(method, path, options = {}) {
+    if (this.config.rate_limit) {
+      const now = Date.now();
+      const windowMs = this.parseDuration(this.config.rate_limit.per);
+      if (now - this.windowStart >= windowMs) {
+        this.requestCount = 0;
+        this.windowStart = now;
+      }
+      if (this.requestCount >= this.config.rate_limit.requests) {
+        return {
+          success: false,
+          error: "Rate limit exceeded",
+          status: 429
+        };
+      }
+      this.requestCount++;
+    }
+    const config = {
+      method,
+      url: path,
+      data: options.body,
+      headers: options.headers,
+      params: options.params
+    };
+    try {
+      const response = await this.requestWithRetry(config);
+      return {
+        success: true,
+        data: response.data,
+        status: response.status,
+        headers: response.headers
+      };
+    } catch (error) {
+      if (axios.isAxiosError(error)) {
+        return {
+          success: false,
+          error: error.message,
+          status: error.response?.status,
+          data: error.response?.data
+        };
+      }
+      return {
+        success: false,
+        error: error instanceof Error ? error.message : "Unknown error"
+      };
+    }
+  }
+  /**
+   * Make a request with retry logic
+   */
+  async requestWithRetry(config, attempt = 0) {
+    try {
+      return await this.client.request(config);
+    } catch (error) {
+      const maxAttempts = this.config.retry?.attempts ?? 0;
+      const delay = this.parseDuration(this.config.retry?.delay ?? "1s");
+      if (attempt < maxAttempts && axios.isAxiosError(error)) {
+        if (!error.response || error.response.status >= 500) {
+          await new Promise((resolve) => setTimeout(resolve, delay));
+          return this.requestWithRetry(config, attempt + 1);
+        }
+      }
+      throw error;
+    }
+  }
+  /**
+   * Convenience methods
+   */
+  async get(path, options) {
+    return this.request("GET", path, options);
+  }
+  async post(path, body, options) {
+    return this.request("POST", path, { body, ...options });
+  }
+  async put(path, body, options) {
+    return this.request("PUT", path, { body, ...options });
+  }
+  async patch(path, body, options) {
+    return this.request("PATCH", path, { body, ...options });
+  }
+  async delete(path, options) {
+    return this.request("DELETE", path, options);
+  }
+  /**
+   * Parse duration string to milliseconds
+   */
+  parseDuration(duration) {
+    const match = duration.match(/^(\d+)(ms|s|m|h)?$/);
+    if (!match) return 3e4;
+    const value = parseInt(match[1], 10);
+    const unit = match[2] ?? "s";
+    switch (unit) {
+      case "ms":
+        return value;
+      case "s":
+        return value * 1e3;
+      case "m":
+        return value * 60 * 1e3;
+      case "h":
+        return value * 60 * 60 * 1e3;
+      default:
+        return value * 1e3;
+    }
+  }
+};
+function createHttpPipe(options) {
+  return new HttpPipe(options);
+}
+
+// src/websocket/index.ts
+import WebSocket from "ws";
+var WebSocketPipe = class {
+  name;
+  type = "websocket";
+  ws = null;
+  config;
+  reconnectAttempts = 0;
+  reconnecting = false;
+  heartbeatInterval = null;
+  messageHandlers = /* @__PURE__ */ new Map();
+  connected = false;
+  constructor(options) {
+    this.name = options.name;
+    this.config = options.config;
+  }
+  /**
+   * Connect to the WebSocket server
+   */
+  async connect() {
+    return new Promise((resolve, reject) => {
+      try {
+        const headers = this.config.headers;
+        this.ws = new WebSocket(this.config.url, { headers });
+        this.ws.on("open", () => {
+          this.connected = true;
+          this.reconnectAttempts = 0;
+          this.reconnecting = false;
+          this.startHeartbeat();
+          resolve();
+        });
+        this.ws.on("message", (data) => {
+          this.handleMessage(data);
+        });
+        this.ws.on("close", () => {
+          this.connected = false;
+          this.stopHeartbeat();
+          this.handleDisconnect();
+        });
+        this.ws.on("error", (error) => {
+          if (!this.connected) {
+            reject(error);
+          }
+          this.emit("error", error);
+        });
+      } catch (error) {
+        reject(error);
+      }
+    });
+  }
+  /**
+   * Disconnect from the server
+   */
+  async disconnect() {
+    this.stopHeartbeat();
+    this.reconnecting = false;
+    if (this.ws) {
+      this.ws.close();
+      this.ws = null;
+    }
+    this.connected = false;
+  }
+  /**
+   * Check if connected
+   */
+  isConnected() {
+    return this.connected && this.ws?.readyState === WebSocket.OPEN;
+  }
+  /**
+   * Send a message
+   */
+  send(data) {
+    if (!this.isConnected()) {
+      return false;
+    }
+    const message = typeof data === "string" ? data : JSON.stringify(data);
+    this.ws.send(message);
+    return true;
+  }
+  /**
+   * Send and wait for a response (request-response pattern)
+   */
+  async request(data, options = {}) {
+    const { timeout = 3e4, responseEvent = "response" } = options;
+    if (!this.isConnected()) {
+      return { success: false, error: "Not connected" };
+    }
+    return new Promise((resolve) => {
+      const timer = setTimeout(() => {
+        this.off(responseEvent, handler);
+        resolve({ success: false, error: "Request timeout" });
+      }, timeout);
+      const handler = (response) => {
+        clearTimeout(timer);
+        this.off(responseEvent, handler);
+        resolve({ success: true, data: response });
+      };
+      this.on(responseEvent, handler);
+      this.send(data);
+    });
+  }
+  /**
+   * Register a message handler
+   */
+  on(event, handler) {
+    const handlers = this.messageHandlers.get(event) ?? [];
+    handlers.push(handler);
+    this.messageHandlers.set(event, handlers);
+  }
+  /**
+   * Remove a message handler
+   */
+  off(event, handler) {
+    const handlers = this.messageHandlers.get(event) ?? [];
+    const index = handlers.indexOf(handler);
+    if (index !== -1) {
+      handlers.splice(index, 1);
+    }
+  }
+  /**
+   * Emit an event to handlers
+   */
+  emit(event, data) {
+    const handlers = this.messageHandlers.get(event) ?? [];
+    for (const handler of handlers) {
+      try {
+        handler(data);
+      } catch (error) {
+        console.error(`WebSocket handler error for "${event}":`, error);
+      }
+    }
+  }
+  /**
+   * Handle incoming messages
+   */
+  handleMessage(rawData) {
+    let data;
+    try {
+      const str = rawData.toString();
+      data = JSON.parse(str);
+    } catch {
+      data = rawData.toString();
+    }
+    this.emit("message", data);
+    if (typeof data === "object" && data !== null && "event" in data) {
+      const event = data.event;
+      this.emit(event, data);
+    }
+  }
+  /**
+   * Handle disconnection
+   */
+  handleDisconnect() {
+    if (!this.config.reconnect?.enabled || this.reconnecting) {
+      return;
+    }
+    const maxAttempts = this.config.reconnect.max_attempts ?? 10;
+    const delay = this.parseDuration(this.config.reconnect.delay ?? "5s");
+    if (this.reconnectAttempts >= maxAttempts) {
+      this.emit("reconnect_failed", { attempts: this.reconnectAttempts });
+      return;
+    }
+    this.reconnecting = true;
+    this.reconnectAttempts++;
+    setTimeout(async () => {
+      try {
+        await this.connect();
+        this.emit("reconnected", { attempts: this.reconnectAttempts });
+      } catch {
+        this.reconnecting = false;
+        this.handleDisconnect();
+      }
+    }, delay);
+  }
+  /**
+   * Start heartbeat
+   */
+  startHeartbeat() {
+    if (!this.config.heartbeat?.interval) return;
+    const interval = this.parseDuration(this.config.heartbeat.interval);
+    const message = this.config.heartbeat.message ?? "ping";
+    this.heartbeatInterval = setInterval(() => {
+      if (this.isConnected()) {
+        this.send(message);
+      }
+    }, interval);
+  }
+  /**
+   * Stop heartbeat
+   */
+  stopHeartbeat() {
+    if (this.heartbeatInterval) {
+      clearInterval(this.heartbeatInterval);
+      this.heartbeatInterval = null;
+    }
+  }
+  /**
+   * Parse duration string to milliseconds
+   */
+  parseDuration(duration) {
+    const match = duration.match(/^(\d+)(ms|s|m|h)?$/);
+    if (!match) return 5e3;
+    const value = parseInt(match[1], 10);
+    const unit = match[2] ?? "s";
+    switch (unit) {
+      case "ms":
+        return value;
+      case "s":
+        return value * 1e3;
+      case "m":
+        return value * 60 * 1e3;
+      case "h":
+        return value * 60 * 60 * 1e3;
+      default:
+        return value * 1e3;
+    }
+  }
+};
+function createWebSocketPipe(options) {
+  return new WebSocketPipe(options);
+}
+
+// src/webhook/index.ts
+import { createHmac } from "crypto";
+var WebhookPipe = class {
+  name;
+  type = "webhook";
+  config;
+  handlers = [];
+  constructor(options) {
+    this.name = options.name;
+    this.config = options.config;
+  }
+  isConnected() {
+    return true;
+  }
+  /**
+   * Get the webhook path
+   */
+  getPath() {
+    return this.config.path;
+  }
+  /**
+   * Get the expected method
+   */
+  getMethod() {
+    return this.config.method ?? "POST";
+  }
+  /**
+   * Register a handler for incoming webhooks
+   */
+  onWebhook(handler) {
+    this.handlers.push(handler);
+    return () => {
+      const index = this.handlers.indexOf(handler);
+      if (index !== -1) {
+        this.handlers.splice(index, 1);
+      }
+    };
+  }
+  /**
+   * Handle an incoming webhook request
+   */
+  async handleRequest(body, headers) {
+    if (this.config.verification) {
+      const valid = this.verifySignature(body, headers);
+      if (!valid) {
+        return { success: false, error: "Invalid signature", status: 401 };
+      }
+    }
+    for (const handler of this.handlers) {
+      try {
+        await handler(body, headers);
+      } catch (error) {
+        console.error(`Webhook handler error:`, error);
+      }
+    }
+    if (this.config.handlers) {
+    }
+    return { success: true, status: 200 };
+  }
+  /**
+   * Verify webhook signature
+   */
+  verifySignature(body, headers) {
+    if (!this.config.verification) return true;
+    const { type, secret, header, algorithm } = this.config.verification;
+    const signatureHeader = header ?? "x-signature";
+    const receivedSignature = headers[signatureHeader.toLowerCase()];
+    if (!receivedSignature || !secret) {
+      return false;
+    }
+    const bodyString = typeof body === "string" ? body : JSON.stringify(body);
+    switch (type) {
+      case "hmac": {
+        const algo = algorithm ?? "sha256";
+        const expectedSignature = createHmac(algo, secret).update(bodyString).digest("hex");
+        const cleanReceived = receivedSignature.replace(/^sha\d+=/, "");
+        return this.timingSafeEqual(cleanReceived, expectedSignature);
+      }
+      case "token": {
+        return receivedSignature === secret;
+      }
+      case "signature": {
+        return true;
+      }
+      default:
+        return true;
+    }
+  }
+  /**
+   * Timing-safe string comparison
+   */
+  timingSafeEqual(a, b) {
+    if (a.length !== b.length) {
+      return false;
+    }
+    let result = 0;
+    for (let i = 0; i < a.length; i++) {
+      result |= a.charCodeAt(i) ^ b.charCodeAt(i);
+    }
+    return result === 0;
+  }
+};
+var WebhookSender = class {
+  /**
+   * Send a Discord webhook
+   */
+  static async sendDiscordWebhook(url, options) {
+    try {
+      const response = await fetch(url, {
+        method: "POST",
+        headers: { "Content-Type": "application/json" },
+        body: JSON.stringify(options)
+      });
+      if (!response.ok) {
+        return {
+          success: false,
+          error: `HTTP ${response.status}`,
+          status: response.status
+        };
+      }
+      return { success: true, status: response.status };
+    } catch (error) {
+      return {
+        success: false,
+        error: error instanceof Error ? error.message : "Unknown error"
+      };
+    }
+  }
+  /**
+   * Send a generic webhook
+   */
+  static async send(url, body, options = {}) {
+    try {
+      const response = await fetch(url, {
+        method: options.method ?? "POST",
+        headers: {
+          "Content-Type": "application/json",
+          ...options.headers
+        },
+        body: typeof body === "string" ? body : JSON.stringify(body)
+      });
+      let data;
+      try {
+        data = await response.json();
+      } catch {
+        data = await response.text();
+      }
+      return {
+        success: response.ok,
+        data,
+        status: response.status
+      };
+    } catch (error) {
+      return {
+        success: false,
+        error: error instanceof Error ? error.message : "Unknown error"
+      };
+    }
+  }
+};
+function createWebhookPipe(options) {
+  return new WebhookPipe(options);
+}
+
+// src/mqtt/index.ts
+import mqtt from "mqtt";
+var MqttPipe = class {
+  name;
+  type = "mqtt";
+  client = null;
+  config;
+  connected = false;
+  reconnectAttempts = 0;
+  messageHandlers = /* @__PURE__ */ new Map();
+  wildcardHandlers = /* @__PURE__ */ new Map();
+  constructor(options) {
+    this.name = options.name;
+    this.config = options.config;
+  }
+  /**
+   * Connect to the MQTT broker
+   */
+  async connect() {
+    return new Promise((resolve, reject) => {
+      const protocol = this.config.protocol ?? "mqtt";
+      const port = this.config.port ?? (protocol === "mqtts" || protocol === "wss" ? 8883 : 1883);
+      const url = `${protocol}://${this.config.broker}:${port}`;
+      const options = {
+        keepalive: this.config.keepalive ?? 60,
+        clean: this.config.clean ?? true,
+        reconnectPeriod: this.config.reconnect?.enabled !== false ? this.parseDuration(this.config.reconnect?.delay ?? "5s") : 0
+      };
+      if (this.config.auth) {
+        if (this.config.auth.username) options.username = this.config.auth.username;
+        if (this.config.auth.password) options.password = this.config.auth.password;
+        if (this.config.auth.clientId) options.clientId = this.config.auth.clientId;
+      }
+      if (this.config.will) {
+        options.will = {
+          topic: this.config.will.topic,
+          payload: Buffer.from(this.config.will.payload),
+          qos: this.config.will.qos ?? 0,
+          retain: this.config.will.retain ?? false
+        };
+      }
+      try {
+        this.client = mqtt.connect(url, options);
+        this.client.on("connect", () => {
+          this.connected = true;
+          this.reconnectAttempts = 0;
+          this.emit("connected", {});
+          resolve();
+        });
+        this.client.on("message", (topic, payload, packet) => {
+          this.handleMessage(topic, payload, packet);
+        });
+        this.client.on("error", (error) => {
+          if (!this.connected) {
+            reject(error);
+          }
+          this.emit("error", error);
+        });
+        this.client.on("close", () => {
+          this.connected = false;
+          this.emit("disconnected", {});
+        });
+        this.client.on("reconnect", () => {
+          this.reconnectAttempts++;
+          this.emit("reconnecting", { attempts: this.reconnectAttempts });
+        });
+        this.client.on("offline", () => {
+          this.connected = false;
+          this.emit("offline", {});
+        });
+      } catch (error) {
+        reject(error);
+      }
+    });
+  }
+  /**
+   * Disconnect from the broker
+   */
+  async disconnect() {
+    return new Promise((resolve) => {
+      if (this.client) {
+        this.client.end(false, {}, () => {
+          this.client = null;
+          this.connected = false;
+          resolve();
+        });
+      } else {
+        resolve();
+      }
+    });
+  }
+  /**
+   * Check if connected
+   */
+  isConnected() {
+    return this.connected && this.client?.connected === true;
+  }
+  /**
+   * Subscribe to a topic
+   */
+  async subscribe(topic, options = {}) {
+    if (!this.isConnected()) {
+      return { success: false, error: "Not connected" };
+    }
+    return new Promise((resolve) => {
+      this.client.subscribe(topic, { qos: options.qos ?? 0 }, (error, granted) => {
+        if (error) {
+          resolve({ success: false, error: error.message });
+        } else {
+          resolve({ success: true, data: granted });
+        }
+      });
+    });
+  }
+  /**
+   * Unsubscribe from a topic
+   */
+  async unsubscribe(topic) {
+    if (!this.isConnected()) {
+      return { success: false, error: "Not connected" };
+    }
+    return new Promise((resolve) => {
+      this.client.unsubscribe(topic, {}, (error) => {
+        if (error) {
+          resolve({ success: false, error: error.message });
+        } else {
+          resolve({ success: true });
+        }
+      });
+    });
+  }
+  /**
+   * Publish a message to a topic
+   */
+  async publish(topic, message, options = {}) {
+    if (!this.isConnected()) {
+      return { success: false, error: "Not connected" };
+    }
+    const payload = typeof message === "object" && !Buffer.isBuffer(message) ? JSON.stringify(message) : message;
+    const publishOptions = {
+      qos: options.qos ?? 0,
+      retain: options.retain ?? false
+    };
+    return new Promise((resolve) => {
+      this.client.publish(topic, payload, publishOptions, (error) => {
+        if (error) {
+          resolve({ success: false, error: error.message });
+        } else {
+          resolve({ success: true });
+        }
+      });
+    });
+  }
+  /**
+   * Register a handler for a specific topic
+   * Supports MQTT wildcards: + (single level), # (multi level)
+   */
+  on(topic, handler) {
+    if (topic.includes("+") || topic.includes("#")) {
+      const handlers = this.wildcardHandlers.get(topic) ?? [];
+      handlers.push(handler);
+      this.wildcardHandlers.set(topic, handlers);
+    } else {
+      const handlers = this.messageHandlers.get(topic) ?? [];
+      handlers.push(handler);
+      this.messageHandlers.set(topic, handlers);
+    }
+  }
+  /**
+   * Remove a handler
+   */
+  off(topic, handler) {
+    const map = topic.includes("+") || topic.includes("#") ? this.wildcardHandlers : this.messageHandlers;
+    const handlers = map.get(topic) ?? [];
+    const index = handlers.indexOf(handler);
+    if (index !== -1) {
+      handlers.splice(index, 1);
+    }
+  }
+  /**
+   * Emit to handlers
+   */
+  emit(event, data) {
+    const handlers = this.messageHandlers.get(event) ?? [];
+    for (const handler of handlers) {
+      try {
+        handler(event, data, {});
+      } catch (error) {
+        console.error(`MQTT handler error for "${event}":`, error);
+      }
+    }
+  }
+  /**
+   * Handle incoming messages
+   */
+  handleMessage(topic, payload, packet) {
+    let parsedPayload = payload;
+    try {
+      const str = payload.toString();
+      parsedPayload = JSON.parse(str);
+    } catch {
+      parsedPayload = payload.toString();
+    }
+    const exactHandlers = this.messageHandlers.get(topic) ?? [];
+    for (const handler of exactHandlers) {
+      try {
+        handler(topic, parsedPayload, packet);
+      } catch (error) {
+        console.error(`MQTT handler error for topic "${topic}":`, error);
+      }
+    }
+    for (const [pattern, handlers] of this.wildcardHandlers) {
+      if (this.topicMatches(pattern, topic)) {
+        for (const handler of handlers) {
+          try {
+            handler(topic, parsedPayload, packet);
+          } catch (error) {
+            console.error(`MQTT wildcard handler error for pattern "${pattern}":`, error);
+          }
+        }
+      }
+    }
+    this.emit("message", { topic, payload: parsedPayload, packet });
+  }
+  /**
+   * Check if a topic matches a pattern with MQTT wildcards
+   */
+  topicMatches(pattern, topic) {
+    const patternParts = pattern.split("/");
+    const topicParts = topic.split("/");
+    for (let i = 0; i < patternParts.length; i++) {
+      const patternPart = patternParts[i];
+      if (patternPart === "#") {
+        return true;
+      }
+      if (i >= topicParts.length) {
+        return false;
+      }
+      if (patternPart === "+") {
+        continue;
+      }
+      if (patternPart !== topicParts[i]) {
+        return false;
+      }
+    }
+    return patternParts.length === topicParts.length;
+  }
+  /**
+   * Parse duration string to milliseconds
+   */
+  parseDuration(duration) {
+    const match = duration.match(/^(\d+)(ms|s|m|h)?$/);
+    if (!match) return 5e3;
+    const value = parseInt(match[1], 10);
+    const unit = match[2] ?? "s";
+    switch (unit) {
+      case "ms":
+        return value;
+      case "s":
+        return value * 1e3;
+      case "m":
+        return value * 60 * 1e3;
+      case "h":
+        return value * 60 * 60 * 1e3;
+      default:
+        return value * 1e3;
+    }
+  }
+};
+function createMqttPipe(options) {
+  return new MqttPipe(options);
+}
+
+// src/tcp/index.ts
+import { createConnection, createServer } from "net";
+
+// src/tcp/udp.ts
+import { createSocket } from "dgram";
+var UdpPipe = class {
+  name;
+  type = "udp";
+  socket = null;
+  config;
+  bound = false;
+  messageHandlers = [];
+  eventHandlers = /* @__PURE__ */ new Map();
+  constructor(options) {
+    this.name = options.name;
+    this.config = options.config;
+  }
+  /**
+   * Bind to a port to receive messages
+   */
+  async bind(port) {
+    return new Promise((resolve, reject) => {
+      try {
+        this.socket = createSocket("udp4");
+        this.socket.on("message", (msg, rinfo) => {
+          this.handleMessage(msg, rinfo);
+        });
+        this.socket.on("error", (error) => {
+          if (!this.bound) {
+            reject(error);
+          }
+          this.emit("error", error);
+        });
+        this.socket.on("listening", () => {
+          this.bound = true;
+          const address = this.socket.address();
+          this.emit("listening", address);
+          resolve();
+        });
+        if (this.config.broadcast) {
+          this.socket.setBroadcast(true);
+        }
+        const bindPort = port ?? this.config.port;
+        const bindHost = this.config.host ?? "0.0.0.0";
+        this.socket.bind(bindPort, bindHost, () => {
+          if (this.config.multicast) {
+            this.socket.addMembership(this.config.multicast);
+          }
+        });
+      } catch (error) {
+        reject(error);
+      }
+    });
+  }
+  /**
+   * Close the socket
+   */
+  async disconnect() {
+    return new Promise((resolve) => {
+      if (this.socket) {
+        this.socket.close(() => {
+          this.socket = null;
+          this.bound = false;
+          resolve();
+        });
+      } else {
+        resolve();
+      }
+    });
+  }
+  /**
+   * Check if bound
+   */
+  isConnected() {
+    return this.bound;
+  }
+  /**
+   * Send data to a specific host and port
+   */
+  async send(data, host, port) {
+    if (!this.socket) {
+      this.socket = createSocket("udp4");
+      if (this.config.broadcast) {
+        this.socket.setBroadcast(true);
+      }
+    }
+    const buffer = typeof data === "string" ? Buffer.from(data) : data;
+    return new Promise((resolve) => {
+      this.socket.send(buffer, port, host, (error) => {
+        if (error) {
+          resolve({ success: false, error: error.message });
+        } else {
+          resolve({ success: true });
+        }
+      });
+    });
+  }
+  /**
+   * Broadcast data to all hosts on the network
+   */
+  async broadcast(data, port, address = "255.255.255.255") {
+    if (!this.socket) {
+      this.socket = createSocket("udp4");
+      this.socket.setBroadcast(true);
+    }
+    const buffer = typeof data === "string" ? Buffer.from(data) : data;
+    return new Promise((resolve) => {
+      this.socket.send(buffer, port, address, (error) => {
+        if (error) {
+          resolve({ success: false, error: error.message });
+        } else {
+          resolve({ success: true });
+        }
+      });
+    });
+  }
+  /**
+   * Send to multicast group
+   */
+  async multicast(data, port, group) {
+    const multicastGroup = group ?? this.config.multicast;
+    if (!multicastGroup) {
+      return { success: false, error: "No multicast group configured" };
+    }
+    return this.send(data, multicastGroup, port);
+  }
+  /**
+   * Register a message handler
+   */
+  onMessage(handler) {
+    this.messageHandlers.push(handler);
+  }
+  /**
+   * Remove a message handler
+   */
+  offMessage(handler) {
+    const index = this.messageHandlers.indexOf(handler);
+    if (index !== -1) {
+      this.messageHandlers.splice(index, 1);
+    }
+  }
+  /**
+   * Register an event handler
+   */
+  on(event, handler) {
+    const handlers = this.eventHandlers.get(event) ?? [];
+    handlers.push(handler);
+    this.eventHandlers.set(event, handlers);
+  }
+  /**
+   * Remove an event handler
+   */
+  off(event, handler) {
+    const handlers = this.eventHandlers.get(event) ?? [];
+    const index = handlers.indexOf(handler);
+    if (index !== -1) {
+      handlers.splice(index, 1);
+    }
+  }
+  /**
+   * Emit an event
+   */
+  emit(event, data) {
+    const handlers = this.eventHandlers.get(event) ?? [];
+    for (const handler of handlers) {
+      try {
+        handler(data);
+      } catch (error) {
+        console.error(`UDP handler error for "${event}":`, error);
+      }
+    }
+  }
+  /**
+   * Handle incoming messages
+   */
+  handleMessage(data, rinfo) {
+    const msg = { data, rinfo };
+    for (const handler of this.messageHandlers) {
+      try {
+        handler(msg);
+      } catch (error) {
+        console.error("UDP message handler error:", error);
+      }
+    }
+    this.emit("message", msg);
+  }
+};
+function createUdpPipe(options) {
+  return new UdpPipe(options);
+}
+
+// src/tcp/index.ts
+var TcpPipe = class {
+  name;
+  type = "tcp";
+  socket = null;
+  server = null;
+  config;
+  connected = false;
+  reconnectAttempts = 0;
+  reconnecting = false;
+  dataHandlers = [];
+  eventHandlers = /* @__PURE__ */ new Map();
+  constructor(options) {
+    this.name = options.name;
+    this.config = options.config;
+  }
+  /**
+   * Connect to a TCP server (client mode)
+   */
+  async connect() {
+    return new Promise((resolve, reject) => {
+      try {
+        this.socket = createConnection({
+          host: this.config.host,
+          port: this.config.port
+        });
+        this.socket.setEncoding(this.config.encoding ?? "utf8");
+        this.socket.on("connect", () => {
+          this.connected = true;
+          this.reconnectAttempts = 0;
+          this.reconnecting = false;
+          this.emit("connected");
+          resolve();
+        });
+        this.socket.on("data", (data) => {
+          this.handleData(data);
+        });
+        this.socket.on("close", () => {
+          this.connected = false;
+          this.emit("disconnected");
+          this.handleDisconnect();
+        });
+        this.socket.on("error", (error) => {
+          if (!this.connected) {
+            reject(error);
+          }
+          this.emit("error", error);
+        });
+        this.socket.on("end", () => {
+          this.connected = false;
+          this.emit("end");
+        });
+      } catch (error) {
+        reject(error);
+      }
+    });
+  }
+  /**
+   * Start a TCP server (server mode)
+   */
+  async listen(port) {
+    return new Promise((resolve, reject) => {
+      try {
+        this.server = createServer((socket) => {
+          socket.setEncoding(this.config.encoding ?? "utf8");
+          socket.on("data", (data) => {
+            this.handleData(data);
+          });
+          socket.on("error", (error) => {
+            this.emit("client_error", error);
+          });
+          this.emit("connection", socket);
+        });
+        this.server.on("error", (error) => {
+          reject(error);
+        });
+        this.server.listen(port ?? this.config.port, () => {
+          this.connected = true;
+          this.emit("listening");
+          resolve();
+        });
+      } catch (error) {
+        reject(error);
+      }
+    });
+  }
+  /**
+   * Disconnect / close
+   */
+  async disconnect() {
+    this.reconnecting = false;
+    return new Promise((resolve) => {
+      if (this.socket) {
+        this.socket.end(() => {
+          this.socket?.destroy();
+          this.socket = null;
+          this.connected = false;
+          resolve();
+        });
+      } else if (this.server) {
+        this.server.close(() => {
+          this.server = null;
+          this.connected = false;
+          resolve();
+        });
+      } else {
+        resolve();
+      }
+    });
+  }
+  /**
+   * Check if connected
+   */
+  isConnected() {
+    return this.connected;
+  }
+  /**
+   * Send data
+   */
+  async send(data) {
+    if (!this.socket || !this.connected) {
+      return { success: false, error: "Not connected" };
+    }
+    return new Promise((resolve) => {
+      this.socket.write(data, (error) => {
+        if (error) {
+          resolve({ success: false, error: error.message });
+        } else {
+          resolve({ success: true });
+        }
+      });
+    });
+  }
+  /**
+   * Send and wait for response (request-response pattern)
+   */
+  async request(data, options = {}) {
+    const { timeout = 3e4 } = options;
+    if (!this.socket || !this.connected) {
+      return { success: false, error: "Not connected" };
+    }
+    return new Promise((resolve) => {
+      const timer = setTimeout(() => {
+        this.offData(handler);
+        resolve({ success: false, error: "Request timeout" });
+      }, timeout);
+      const handler = (response) => {
+        clearTimeout(timer);
+        this.offData(handler);
+        resolve({ success: true, data: response });
+      };
+      this.onData(handler);
+      this.send(data);
+    });
+  }
+  /**
+   * Register a data handler
+   */
+  onData(handler) {
+    this.dataHandlers.push(handler);
+  }
+  /**
+   * Remove a data handler
+   */
+  offData(handler) {
+    const index = this.dataHandlers.indexOf(handler);
+    if (index !== -1) {
+      this.dataHandlers.splice(index, 1);
+    }
+  }
+  /**
+   * Register an event handler
+   */
+  on(event, handler) {
+    const handlers = this.eventHandlers.get(event) ?? [];
+    handlers.push(handler);
+    this.eventHandlers.set(event, handlers);
+  }
+  /**
+   * Remove an event handler
+   */
+  off(event, handler) {
+    const handlers = this.eventHandlers.get(event) ?? [];
+    const index = handlers.indexOf(handler);
+    if (index !== -1) {
+      handlers.splice(index, 1);
+    }
+  }
+  /**
+   * Emit an event
+   */
+  emit(event, data) {
+    const handlers = this.eventHandlers.get(event) ?? [];
+    for (const handler of handlers) {
+      try {
+        handler(data);
+      } catch (error) {
+        console.error(`TCP handler error for "${event}":`, error);
+      }
+    }
+  }
+  /**
+   * Handle incoming data
+   */
+  handleData(data) {
+    for (const handler of this.dataHandlers) {
+      try {
+        handler(data);
+      } catch (error) {
+        console.error("TCP data handler error:", error);
+      }
+    }
+    this.emit("data", data);
+  }
+  /**
+   * Handle disconnection with reconnect logic
+   */
+  handleDisconnect() {
+    if (!this.config.reconnect?.enabled || this.reconnecting) {
+      return;
+    }
+    const maxAttempts = this.config.reconnect.max_attempts ?? 10;
+    const delay = this.parseDuration(this.config.reconnect.delay ?? "5s");
+    if (this.reconnectAttempts >= maxAttempts) {
+      this.emit("reconnect_failed", { attempts: this.reconnectAttempts });
+      return;
+    }
+    this.reconnecting = true;
+    this.reconnectAttempts++;
+    setTimeout(async () => {
+      try {
+        await this.connect();
+        this.emit("reconnected", { attempts: this.reconnectAttempts });
+      } catch {
+        this.reconnecting = false;
+        this.handleDisconnect();
+      }
+    }, delay);
+  }
+  /**
+   * Parse duration string to milliseconds
+   */
+  parseDuration(duration) {
+    const match = duration.match(/^(\d+)(ms|s|m|h)?$/);
+    if (!match) return 5e3;
+    const value = parseInt(match[1], 10);
+    const unit = match[2] ?? "s";
+    switch (unit) {
+      case "ms":
+        return value;
+      case "s":
+        return value * 1e3;
+      case "m":
+        return value * 60 * 1e3;
+      case "h":
+        return value * 60 * 60 * 1e3;
+      default:
+        return value * 1e3;
+    }
+  }
+};
+function createTcpPipe(options) {
+  return new TcpPipe(options);
+}
+export {
+  HttpPipe,
+  MqttPipe,
+  TcpPipe,
+  UdpPipe,
+  WebSocketPipe,
+  WebhookPipe,
+  WebhookSender,
+  createHttpPipe,
+  createMqttPipe,
+  createTcpPipe,
+  createUdpPipe,
+  createWebSocketPipe,
+  createWebhookPipe
+};
+//# sourceMappingURL=index.js.map