@furlow/pipes 0.1.0

package/dist/types-BW9r2ksN.d.ts

@@ -0,0 +1,152 @@
+/**
+ * Pipe types
+ */
+interface PipeResponse<T = unknown> {
+    success: boolean;
+    data?: T;
+    error?: string;
+    status?: number;
+    headers?: Record<string, string>;
+}
+interface Pipe {
+    name: string;
+    type: string;
+    connect?(): Promise<void>;
+    disconnect?(): Promise<void>;
+    isConnected(): boolean;
+}
+/** HTTP authentication type */
+type HttpAuthType = 'none' | 'header' | 'bearer' | 'basic';
+/** HTTP authentication config */
+interface HttpAuthConfig {
+    type: HttpAuthType;
+    token?: string;
+    username?: string;
+    password?: string;
+    header_name?: string;
+}
+/** HTTP rate limit config */
+interface HttpRateLimitConfig {
+    requests: number;
+    per: string;
+    retry_after?: boolean;
+}
+/** HTTP pipe configuration */
+interface HttpPipeConfig {
+    type: 'http';
+    base_url: string;
+    auth?: HttpAuthConfig;
+    headers?: Record<string, string>;
+    rate_limit?: HttpRateLimitConfig;
+    timeout?: string;
+    retry?: {
+        attempts?: number;
+        delay?: string;
+    };
+}
+/** Webhook verification configuration */
+interface WebhookVerification {
+    type: 'hmac' | 'signature' | 'token';
+    secret?: string;
+    header?: string;
+    algorithm?: 'sha1' | 'sha256' | 'sha512';
+}
+/** Webhook pipe configuration */
+interface WebhookPipeConfig {
+    type: 'webhook';
+    path: string;
+    method?: 'POST' | 'PUT' | 'PATCH';
+    verification?: WebhookVerification;
+    handlers?: {
+        event?: string;
+        when?: string;
+        actions: unknown[];
+    }[];
+}
+/** WebSocket pipe configuration */
+interface WebSocketPipeConfig {
+    type: 'websocket';
+    url: string;
+    headers?: Record<string, string>;
+    reconnect?: {
+        enabled?: boolean;
+        delay?: string;
+        max_attempts?: number;
+    };
+    heartbeat?: {
+        interval?: string;
+        message?: string;
+    };
+    handlers?: {
+        event: string;
+        when?: string;
+        actions: unknown[];
+    }[];
+}
+/** MQTT authentication config */
+interface MqttAuthConfig {
+    username?: string;
+    password?: string;
+    clientId?: string;
+}
+/** MQTT QoS level */
+type MqttQoS = 0 | 1 | 2;
+/** MQTT pipe configuration */
+interface MqttPipeConfig {
+    type: 'mqtt';
+    broker: string;
+    port?: number;
+    protocol?: 'mqtt' | 'mqtts' | 'ws' | 'wss';
+    auth?: MqttAuthConfig;
+    keepalive?: number;
+    clean?: boolean;
+    reconnect?: {
+        enabled?: boolean;
+        delay?: string;
+        max_attempts?: number;
+    };
+    will?: {
+        topic: string;
+        payload: string;
+        qos?: MqttQoS;
+        retain?: boolean;
+    };
+    handlers?: {
+        topic: string;
+        qos?: MqttQoS;
+        when?: string;
+        actions: unknown[];
+    }[];
+}
+/** TCP pipe configuration */
+interface TcpPipeConfig {
+    type: 'tcp';
+    host: string;
+    port: number;
+    reconnect?: {
+        enabled?: boolean;
+        delay?: string;
+        max_attempts?: number;
+    };
+    encoding?: BufferEncoding;
+    handlers?: {
+        event: string;
+        when?: string;
+        actions: unknown[];
+    }[];
+}
+/** UDP pipe configuration */
+interface UdpPipeConfig {
+    type: 'udp';
+    host?: string;
+    port: number;
+    multicast?: string;
+    broadcast?: boolean;
+    handlers?: {
+        event: string;
+        when?: string;
+        actions: unknown[];
+    }[];
+}
+
+export type { HttpAuthConfig as H, MqttAuthConfig as M, Pipe as P, TcpPipeConfig as T, UdpPipeConfig as U, WebSocketPipeConfig as W, HttpAuthType as a, HttpPipeConfig as b, HttpRateLimitConfig as c, MqttPipeConfig as d, MqttQoS as e, PipeResponse as f, WebhookPipeConfig as g, WebhookVerification as h };

package/dist/webhook/index.d.ts

@@ -0,0 +1,70 @@
+import { P as Pipe, g as WebhookPipeConfig, f as PipeResponse } from '../types-BW9r2ksN.js';
+
+/**
+ * Webhook pipe for incoming and outgoing webhooks
+ */
+
+interface WebhookPipeOptions {
+    name: string;
+    config: WebhookPipeConfig;
+}
+type WebhookHandler = (body: unknown, headers: Record<string, string>) => void | Promise<void>;
+declare class WebhookPipe implements Pipe {
+    readonly name: string;
+    readonly type = "webhook";
+    private config;
+    private handlers;
+    constructor(options: WebhookPipeOptions);
+    isConnected(): boolean;
+    /**
+     * Get the webhook path
+     */
+    getPath(): string;
+    /**
+     * Get the expected method
+     */
+    getMethod(): string;
+    /**
+     * Register a handler for incoming webhooks
+     */
+    onWebhook(handler: WebhookHandler): () => void;
+    /**
+     * Handle an incoming webhook request
+     */
+    handleRequest(body: unknown, headers: Record<string, string>): Promise<PipeResponse>;
+    /**
+     * Verify webhook signature
+     */
+    private verifySignature;
+    /**
+     * Timing-safe string comparison
+     */
+    private timingSafeEqual;
+}
+/**
+ * Outgoing webhook sender
+ */
+declare class WebhookSender {
+    /**
+     * Send a Discord webhook
+     */
+    static sendDiscordWebhook(url: string, options: {
+        content?: string;
+        username?: string;
+        avatar_url?: string;
+        embeds?: Record<string, unknown>[];
+    }): Promise<PipeResponse>;
+    /**
+     * Send a generic webhook
+     */
+    static send(url: string, body: unknown, options?: {
+        headers?: Record<string, string>;
+        method?: string;
+    }): Promise<PipeResponse>;
+}
+/**
+ * Create a webhook pipe
+ */
+declare function createWebhookPipe(options: WebhookPipeOptions): WebhookPipe;
+
+export { type WebhookHandler, WebhookPipe, type WebhookPipeOptions, WebhookSender, createWebhookPipe };

package/dist/webhook/index.js

@@ -0,0 +1,169 @@
+// 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);
+}
+export {
+  WebhookPipe,
+  WebhookSender,
+  createWebhookPipe
+};
+//# sourceMappingURL=index.js.map

package/dist/webhook/index.js.map

@@ -0,0 +1 @@
+{"version":3,"sources":["../../src/webhook/index.ts"],"sourcesContent":["/**\n * Webhook pipe for incoming and outgoing webhooks\n */\n\nimport { createHmac } from 'node:crypto';\nimport type { Pipe, PipeResponse, WebhookPipeConfig } from '../types.js';\n\nexport interface WebhookPipeOptions {\n  name: string;\n  config: WebhookPipeConfig;\n}\n\nexport type WebhookHandler = (\n  body: unknown,\n  headers: Record<string, string>\n) => void | Promise<void>;\n\nexport class WebhookPipe implements Pipe {\n  public readonly name: string;\n  public readonly type = 'webhook';\n  private config: WebhookPipeConfig;\n  private handlers: WebhookHandler[] = [];\n\n  constructor(options: WebhookPipeOptions) {\n    this.name = options.name;\n    this.config = options.config;\n  }\n\n  isConnected(): boolean {\n    return true;\n  }\n\n  /**\n   * Get the webhook path\n   */\n  getPath(): string {\n    return this.config.path;\n  }\n\n  /**\n   * Get the expected method\n   */\n  getMethod(): string {\n    return this.config.method ?? 'POST';\n  }\n\n  /**\n   * Register a handler for incoming webhooks\n   */\n  onWebhook(handler: WebhookHandler): () => void {\n    this.handlers.push(handler);\n    return () => {\n      const index = this.handlers.indexOf(handler);\n      if (index !== -1) {\n        this.handlers.splice(index, 1);\n      }\n    };\n  }\n\n  /**\n   * Handle an incoming webhook request\n   */\n  async handleRequest(\n    body: unknown,\n    headers: Record<string, string>\n  ): Promise<PipeResponse> {\n    // Verify signature if configured\n    if (this.config.verification) {\n      const valid = this.verifySignature(body, headers);\n      if (!valid) {\n        return { success: false, error: 'Invalid signature', status: 401 };\n      }\n    }\n\n    // Call handlers\n    for (const handler of this.handlers) {\n      try {\n        await handler(body, headers);\n      } catch (error) {\n        console.error(`Webhook handler error:`, error);\n      }\n    }\n\n    // Check for config handlers\n    if (this.config.handlers) {\n      // These would be processed by the action executor\n    }\n\n    return { success: true, status: 200 };\n  }\n\n  /**\n   * Verify webhook signature\n   */\n  private verifySignature(\n    body: unknown,\n    headers: Record<string, string>\n  ): boolean {\n    if (!this.config.verification) return true;\n\n    const { type, secret, header, algorithm } = this.config.verification;\n    const signatureHeader = header ?? 'x-signature';\n    const receivedSignature = headers[signatureHeader.toLowerCase()];\n\n    if (!receivedSignature || !secret) {\n      return false;\n    }\n\n    const bodyString = typeof body === 'string' ? body : JSON.stringify(body);\n\n    switch (type) {\n      case 'hmac': {\n        const algo = algorithm ?? 'sha256';\n        const expectedSignature = createHmac(algo, secret)\n          .update(bodyString)\n          .digest('hex');\n\n        // Handle both raw and prefixed signatures\n        const cleanReceived = receivedSignature.replace(/^sha\\d+=/, '');\n        return this.timingSafeEqual(cleanReceived, expectedSignature);\n      }\n\n      case 'token': {\n        return receivedSignature === secret;\n      }\n\n      case 'signature': {\n        // Custom signature verification\n        // This would depend on the specific service\n        return true;\n      }\n\n      default:\n        return true;\n    }\n  }\n\n  /**\n   * Timing-safe string comparison\n   */\n  private timingSafeEqual(a: string, b: string): boolean {\n    if (a.length !== b.length) {\n      return false;\n    }\n\n    let result = 0;\n    for (let i = 0; i < a.length; i++) {\n      result |= a.charCodeAt(i) ^ b.charCodeAt(i);\n    }\n    return result === 0;\n  }\n}\n\n/**\n * Outgoing webhook sender\n */\nexport class WebhookSender {\n  /**\n   * Send a Discord webhook\n   */\n  static async sendDiscordWebhook(\n    url: string,\n    options: {\n      content?: string;\n      username?: string;\n      avatar_url?: string;\n      embeds?: Record<string, unknown>[];\n    }\n  ): Promise<PipeResponse> {\n    try {\n      const response = await fetch(url, {\n        method: 'POST',\n        headers: { 'Content-Type': 'application/json' },\n        body: JSON.stringify(options),\n      });\n\n      if (!response.ok) {\n        return {\n          success: false,\n          error: `HTTP ${response.status}`,\n          status: response.status,\n        };\n      }\n\n      return { success: true, status: response.status };\n    } catch (error) {\n      return {\n        success: false,\n        error: error instanceof Error ? error.message : 'Unknown error',\n      };\n    }\n  }\n\n  /**\n   * Send a generic webhook\n   */\n  static async send(\n    url: string,\n    body: unknown,\n    options: { headers?: Record<string, string>; method?: string } = {}\n  ): Promise<PipeResponse> {\n    try {\n      const response = await fetch(url, {\n        method: options.method ?? 'POST',\n        headers: {\n          'Content-Type': 'application/json',\n          ...options.headers,\n        },\n        body: typeof body === 'string' ? body : JSON.stringify(body),\n      });\n\n      let data: unknown;\n      try {\n        data = await response.json();\n      } catch {\n        data = await response.text();\n      }\n\n      return {\n        success: response.ok,\n        data,\n        status: response.status,\n      };\n    } catch (error) {\n      return {\n        success: false,\n        error: error instanceof Error ? error.message : 'Unknown error',\n      };\n    }\n  }\n}\n\n/**\n * Create a webhook pipe\n */\nexport function createWebhookPipe(options: WebhookPipeOptions): WebhookPipe {\n  return new WebhookPipe(options);\n}\n"],"mappings":"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","names":[]}

package/dist/websocket/index.d.ts

@@ -0,0 +1,84 @@
+import { P as Pipe, W as WebSocketPipeConfig, f as PipeResponse } from '../types-BW9r2ksN.js';
+
+/**
+ * WebSocket pipe for bidirectional communication
+ */
+
+interface WebSocketPipeOptions {
+    name: string;
+    config: WebSocketPipeConfig;
+}
+type WebSocketMessageHandler = (data: unknown) => void | Promise<void>;
+declare class WebSocketPipe implements Pipe {
+    readonly name: string;
+    readonly type = "websocket";
+    private ws;
+    private config;
+    private reconnectAttempts;
+    private reconnecting;
+    private heartbeatInterval;
+    private messageHandlers;
+    private connected;
+    constructor(options: WebSocketPipeOptions);
+    /**
+     * Connect to the WebSocket server
+     */
+    connect(): Promise<void>;
+    /**
+     * Disconnect from the server
+     */
+    disconnect(): Promise<void>;
+    /**
+     * Check if connected
+     */
+    isConnected(): boolean;
+    /**
+     * Send a message
+     */
+    send(data: unknown): boolean;
+    /**
+     * Send and wait for a response (request-response pattern)
+     */
+    request<T = unknown>(data: unknown, options?: {
+        timeout?: number;
+        responseEvent?: string;
+    }): Promise<PipeResponse<T>>;
+    /**
+     * Register a message handler
+     */
+    on(event: string, handler: WebSocketMessageHandler): void;
+    /**
+     * Remove a message handler
+     */
+    off(event: string, handler: WebSocketMessageHandler): void;
+    /**
+     * Emit an event to handlers
+     */
+    private emit;
+    /**
+     * Handle incoming messages
+     */
+    private handleMessage;
+    /**
+     * Handle disconnection
+     */
+    private handleDisconnect;
+    /**
+     * Start heartbeat
+     */
+    private startHeartbeat;
+    /**
+     * Stop heartbeat
+     */
+    private stopHeartbeat;
+    /**
+     * Parse duration string to milliseconds
+     */
+    private parseDuration;
+}
+/**
+ * Create a WebSocket pipe
+ */
+declare function createWebSocketPipe(options: WebSocketPipeOptions): WebSocketPipe;
+
+export { type WebSocketMessageHandler, WebSocketPipe, type WebSocketPipeOptions, createWebSocketPipe };