@push.rocks/smartproxy 20.0.1 → 21.1.0

package/dist_ts/detection/utils/buffer-utils.js

@@ -0,0 +1,127 @@
+/**
+ * Buffer manipulation utilities for protocol detection
+ */
+// Import from protocols
+import { HttpParser } from '../../protocols/http/index.js';
+/**
+ * BufferAccumulator class for handling fragmented data
+ */
+export class BufferAccumulator {
+    constructor() {
+        this.chunks = [];
+        this.totalLength = 0;
+    }
+    /**
+     * Append data to the accumulator
+     */
+    append(data) {
+        this.chunks.push(data);
+        this.totalLength += data.length;
+    }
+    /**
+     * Get the accumulated buffer
+     */
+    getBuffer() {
+        if (this.chunks.length === 0) {
+            return Buffer.alloc(0);
+        }
+        if (this.chunks.length === 1) {
+            return this.chunks[0];
+        }
+        return Buffer.concat(this.chunks, this.totalLength);
+    }
+    /**
+     * Get current buffer length
+     */
+    length() {
+        return this.totalLength;
+    }
+    /**
+     * Clear all accumulated data
+     */
+    clear() {
+        this.chunks = [];
+        this.totalLength = 0;
+    }
+    /**
+     * Check if accumulator has minimum bytes
+     */
+    hasMinimumBytes(minBytes) {
+        return this.totalLength >= minBytes;
+    }
+}
+/**
+ * Read a big-endian 16-bit integer from buffer
+ */
+export function readUInt16BE(buffer, offset) {
+    if (offset + 2 > buffer.length) {
+        throw new Error('Buffer too short for UInt16BE read');
+    }
+    return (buffer[offset] << 8) | buffer[offset + 1];
+}
+/**
+ * Read a big-endian 24-bit integer from buffer
+ */
+export function readUInt24BE(buffer, offset) {
+    if (offset + 3 > buffer.length) {
+        throw new Error('Buffer too short for UInt24BE read');
+    }
+    return (buffer[offset] << 16) | (buffer[offset + 1] << 8) | buffer[offset + 2];
+}
+/**
+ * Find a byte sequence in a buffer
+ */
+export function findSequence(buffer, sequence, startOffset = 0) {
+    if (sequence.length === 0) {
+        return startOffset;
+    }
+    const searchLength = buffer.length - sequence.length + 1;
+    for (let i = startOffset; i < searchLength; i++) {
+        let found = true;
+        for (let j = 0; j < sequence.length; j++) {
+            if (buffer[i + j] !== sequence[j]) {
+                found = false;
+                break;
+            }
+        }
+        if (found) {
+            return i;
+        }
+    }
+    return -1;
+}
+/**
+ * Extract a line from buffer (up to CRLF or LF)
+ */
+export function extractLine(buffer, startOffset = 0) {
+    // Delegate to protocol parser
+    return HttpParser.extractLine(buffer, startOffset);
+}
+/**
+ * Check if buffer starts with a string (case-insensitive)
+ */
+export function startsWithString(buffer, str, offset = 0) {
+    if (offset + str.length > buffer.length) {
+        return false;
+    }
+    const bufferStr = buffer.slice(offset, offset + str.length).toString('utf8');
+    return bufferStr.toLowerCase() === str.toLowerCase();
+}
+/**
+ * Safe buffer slice that doesn't throw on out-of-bounds
+ */
+export function safeSlice(buffer, start, end) {
+    const safeStart = Math.max(0, Math.min(start, buffer.length));
+    const safeEnd = end === undefined
+        ? buffer.length
+        : Math.max(safeStart, Math.min(end, buffer.length));
+    return buffer.slice(safeStart, safeEnd);
+}
+/**
+ * Check if buffer contains printable ASCII
+ */
+export function isPrintableAscii(buffer, length) {
+    // Delegate to protocol parser
+    return HttpParser.isPrintableAscii(buffer, length);
+}
+//# sourceMappingURL=data:application/json;base64,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

package/dist_ts/detection/utils/fragment-manager.d.ts

@@ -0,0 +1,31 @@
+/**
+ * Fragment Manager for Detection Module
+ *
+ * Manages fragmented protocol data using the shared fragment handler
+ */
+import { FragmentHandler } from '../../protocols/common/fragment-handler.js';
+import type { IConnectionContext } from '../../protocols/common/types.js';
+/**
+ * Detection-specific fragment manager
+ */
+export declare class DetectionFragmentManager {
+    private tlsFragments;
+    private httpFragments;
+    constructor();
+    /**
+     * Get fragment handler for protocol type
+     */
+    getHandler(protocol: 'tls' | 'http'): FragmentHandler;
+    /**
+     * Create connection ID from context
+     */
+    static createConnectionId(context: IConnectionContext): string;
+    /**
+     * Clean up all handlers
+     */
+    cleanup(): void;
+    /**
+     * Destroy all handlers
+     */
+    destroy(): void;
+}

package/dist_ts/detection/utils/fragment-manager.js

@@ -0,0 +1,53 @@
+/**
+ * Fragment Manager for Detection Module
+ *
+ * Manages fragmented protocol data using the shared fragment handler
+ */
+import { FragmentHandler } from '../../protocols/common/fragment-handler.js';
+/**
+ * Detection-specific fragment manager
+ */
+export class DetectionFragmentManager {
+    constructor() {
+        // Configure fragment handlers with appropriate limits
+        const tlsOptions = {
+            maxBufferSize: 16384, // TLS record max size
+            timeout: 5000,
+            cleanupInterval: 30000
+        };
+        const httpOptions = {
+            maxBufferSize: 8192, // HTTP header reasonable limit
+            timeout: 5000,
+            cleanupInterval: 30000
+        };
+        this.tlsFragments = new FragmentHandler(tlsOptions);
+        this.httpFragments = new FragmentHandler(httpOptions);
+    }
+    /**
+     * Get fragment handler for protocol type
+     */
+    getHandler(protocol) {
+        return protocol === 'tls' ? this.tlsFragments : this.httpFragments;
+    }
+    /**
+     * Create connection ID from context
+     */
+    static createConnectionId(context) {
+        return context.id || `${context.sourceIp}:${context.sourcePort}-${context.destIp}:${context.destPort}`;
+    }
+    /**
+     * Clean up all handlers
+     */
+    cleanup() {
+        this.tlsFragments.cleanup();
+        this.httpFragments.cleanup();
+    }
+    /**
+     * Destroy all handlers
+     */
+    destroy() {
+        this.tlsFragments.destroy();
+        this.httpFragments.destroy();
+    }
+}
+//# sourceMappingURL=data:application/json;base64,eyJ2ZXJzaW9uIjozLCJmaWxlIjoiZnJhZ21lbnQtbWFuYWdlci5qcyIsInNvdXJjZVJvb3QiOiIiLCJzb3VyY2VzIjpbIi4uLy4uLy4uL3RzL2RldGVjdGlvbi91dGlscy9mcmFnbWVudC1tYW5hZ2VyLnRzIl0sIm5hbWVzIjpbXSwibWFwcGluZ3MiOiJBQUFBOzs7O0dBSUc7QUFFSCxPQUFPLEVBQUUsZUFBZSxFQUF5QixNQUFNLDRDQUE0QyxDQUFDO0FBR3BHOztHQUVHO0FBQ0gsTUFBTSxPQUFPLHdCQUF3QjtJQUluQztRQUNFLHNEQUFzRDtRQUN0RCxNQUFNLFVBQVUsR0FBcUI7WUFDbkMsYUFBYSxFQUFFLEtBQUssRUFBRyxzQkFBc0I7WUFDN0MsT0FBTyxFQUFFLElBQUk7WUFDYixlQUFlLEVBQUUsS0FBSztTQUN2QixDQUFDO1FBRUYsTUFBTSxXQUFXLEdBQXFCO1lBQ3BDLGFBQWEsRUFBRSxJQUFJLEVBQUksK0JBQStCO1lBQ3RELE9BQU8sRUFBRSxJQUFJO1lBQ2IsZUFBZSxFQUFFLEtBQUs7U0FDdkIsQ0FBQztRQUVGLElBQUksQ0FBQyxZQUFZLEdBQUcsSUFBSSxlQUFlLENBQUMsVUFBVSxDQUFDLENBQUM7UUFDcEQsSUFBSSxDQUFDLGFBQWEsR0FBRyxJQUFJLGVBQWUsQ0FBQyxXQUFXLENBQUMsQ0FBQztJQUN4RCxDQUFDO0lBRUQ7O09BRUc7SUFDSCxVQUFVLENBQUMsUUFBd0I7UUFDakMsT0FBTyxRQUFRLEtBQUssS0FBSyxDQUFDLENBQUMsQ0FBQyxJQUFJLENBQUMsWUFBWSxDQUFDLENBQUMsQ0FBQyxJQUFJLENBQUMsYUFBYSxDQUFDO0lBQ3JFLENBQUM7SUFFRDs7T0FFRztJQUNILE1BQU0sQ0FBQyxrQkFBa0IsQ0FBQyxPQUEyQjtRQUNuRCxPQUFPLE9BQU8sQ0FBQyxFQUFFLElBQUksR0FBRyxPQUFPLENBQUMsUUFBUSxJQUFJLE9BQU8sQ0FBQyxVQUFVLElBQUksT0FBTyxDQUFDLE1BQU0sSUFBSSxPQUFPLENBQUMsUUFBUSxFQUFFLENBQUM7SUFDekcsQ0FBQztJQUVEOztPQUVHO0lBQ0gsT0FBTztRQUNMLElBQUksQ0FBQyxZQUFZLENBQUMsT0FBTyxFQUFFLENBQUM7UUFDNUIsSUFBSSxDQUFDLGFBQWEsQ0FBQyxPQUFPLEVBQUUsQ0FBQztJQUMvQixDQUFDO0lBRUQ7O09BRUc7SUFDSCxPQUFPO1FBQ0wsSUFBSSxDQUFDLFlBQVksQ0FBQyxPQUFPLEVBQUUsQ0FBQztRQUM1QixJQUFJLENBQUMsYUFBYSxDQUFDLE9BQU8sRUFBRSxDQUFDO0lBQy9CLENBQUM7Q0FDRiJ9

package/dist_ts/detection/utils/parser-utils.d.ts

@@ -0,0 +1,42 @@
+/**
+ * Parser utilities for protocol detection
+ * Now delegates to protocol modules for actual parsing
+ */
+import type { THttpMethod, TTlsVersion } from '../models/detection-types.js';
+import { HTTP_METHODS, HTTP_VERSIONS } from '../../protocols/http/index.js';
+export { HTTP_METHODS, HTTP_VERSIONS };
+/**
+ * Parse HTTP request line
+ */
+export declare function parseHttpRequestLine(line: string): {
+    method: THttpMethod;
+    path: string;
+    version: string;
+} | null;
+/**
+ * Parse HTTP header line
+ */
+export declare function parseHttpHeader(line: string): {
+    name: string;
+    value: string;
+} | null;
+/**
+ * Parse HTTP headers from lines
+ */
+export declare function parseHttpHeaders(lines: string[]): Record<string, string>;
+/**
+ * Convert TLS version bytes to version string
+ */
+export declare function tlsVersionToString(major: number, minor: number): TTlsVersion | null;
+/**
+ * Extract domain from Host header value
+ */
+export declare function extractDomainFromHost(hostHeader: string): string;
+/**
+ * Validate domain name
+ */
+export declare function isValidDomain(domain: string): boolean;
+/**
+ * Check if string is a valid HTTP method
+ */
+export declare function isHttpMethod(str: string): str is THttpMethod;

package/dist_ts/detection/utils/parser-utils.js

@@ -0,0 +1,63 @@
+/**
+ * Parser utilities for protocol detection
+ * Now delegates to protocol modules for actual parsing
+ */
+import { HttpParser, HTTP_METHODS, HTTP_VERSIONS } from '../../protocols/http/index.js';
+import { tlsVersionToString as protocolTlsVersionToString } from '../../protocols/tls/index.js';
+// Re-export constants for backward compatibility
+export { HTTP_METHODS, HTTP_VERSIONS };
+/**
+ * Parse HTTP request line
+ */
+export function parseHttpRequestLine(line) {
+    // Delegate to protocol parser
+    const result = HttpParser.parseRequestLine(line);
+    return result ? {
+        method: result.method,
+        path: result.path,
+        version: result.version
+    } : null;
+}
+/**
+ * Parse HTTP header line
+ */
+export function parseHttpHeader(line) {
+    // Delegate to protocol parser
+    return HttpParser.parseHeaderLine(line);
+}
+/**
+ * Parse HTTP headers from lines
+ */
+export function parseHttpHeaders(lines) {
+    // Delegate to protocol parser
+    return HttpParser.parseHeaders(lines);
+}
+/**
+ * Convert TLS version bytes to version string
+ */
+export function tlsVersionToString(major, minor) {
+    // Delegate to protocol parser
+    return protocolTlsVersionToString(major, minor);
+}
+/**
+ * Extract domain from Host header value
+ */
+export function extractDomainFromHost(hostHeader) {
+    // Delegate to protocol parser
+    return HttpParser.extractDomainFromHost(hostHeader);
+}
+/**
+ * Validate domain name
+ */
+export function isValidDomain(domain) {
+    // Delegate to protocol parser
+    return HttpParser.isValidDomain(domain);
+}
+/**
+ * Check if string is a valid HTTP method
+ */
+export function isHttpMethod(str) {
+    // Delegate to protocol parser
+    return HttpParser.isHttpMethod(str) && str !== undefined;
+}
+//# sourceMappingURL=data:application/json;base64,eyJ2ZXJzaW9uIjozLCJmaWxlIjoicGFyc2VyLXV0aWxzLmpzIiwic291cmNlUm9vdCI6IiIsInNvdXJjZXMiOlsiLi4vLi4vLi4vdHMvZGV0ZWN0aW9uL3V0aWxzL3BhcnNlci11dGlscy50cyJdLCJuYW1lcyI6W10sIm1hcHBpbmdzIjoiQUFBQTs7O0dBR0c7QUFHSCxPQUFPLEVBQUUsVUFBVSxFQUFFLFlBQVksRUFBRSxhQUFhLEVBQUUsTUFBTSwrQkFBK0IsQ0FBQztBQUN4RixPQUFPLEVBQUUsa0JBQWtCLElBQUksMEJBQTBCLEVBQUUsTUFBTSw4QkFBOEIsQ0FBQztBQUVoRyxpREFBaUQ7QUFDakQsT0FBTyxFQUFFLFlBQVksRUFBRSxhQUFhLEVBQUUsQ0FBQztBQUV2Qzs7R0FFRztBQUNILE1BQU0sVUFBVSxvQkFBb0IsQ0FBQyxJQUFZO0lBSy9DLDhCQUE4QjtJQUM5QixNQUFNLE1BQU0sR0FBRyxVQUFVLENBQUMsZ0JBQWdCLENBQUMsSUFBSSxDQUFDLENBQUM7SUFDakQsT0FBTyxNQUFNLENBQUMsQ0FBQyxDQUFDO1FBQ2QsTUFBTSxFQUFFLE1BQU0sQ0FBQyxNQUFxQjtRQUNwQyxJQUFJLEVBQUUsTUFBTSxDQUFDLElBQUk7UUFDakIsT0FBTyxFQUFFLE1BQU0sQ0FBQyxPQUFPO0tBQ3hCLENBQUMsQ0FBQyxDQUFDLElBQUksQ0FBQztBQUNYLENBQUM7QUFFRDs7R0FFRztBQUNILE1BQU0sVUFBVSxlQUFlLENBQUMsSUFBWTtJQUMxQyw4QkFBOEI7SUFDOUIsT0FBTyxVQUFVLENBQUMsZUFBZSxDQUFDLElBQUksQ0FBQyxDQUFDO0FBQzFDLENBQUM7QUFFRDs7R0FFRztBQUNILE1BQU0sVUFBVSxnQkFBZ0IsQ0FBQyxLQUFlO0lBQzlDLDhCQUE4QjtJQUM5QixPQUFPLFVBQVUsQ0FBQyxZQUFZLENBQUMsS0FBSyxDQUFDLENBQUM7QUFDeEMsQ0FBQztBQUVEOztHQUVHO0FBQ0gsTUFBTSxVQUFVLGtCQUFrQixDQUFDLEtBQWEsRUFBRSxLQUFhO0lBQzdELDhCQUE4QjtJQUM5QixPQUFPLDBCQUEwQixDQUFDLEtBQUssRUFBRSxLQUFLLENBQWdCLENBQUM7QUFDakUsQ0FBQztBQUVEOztHQUVHO0FBQ0gsTUFBTSxVQUFVLHFCQUFxQixDQUFDLFVBQWtCO0lBQ3RELDhCQUE4QjtJQUM5QixPQUFPLFVBQVUsQ0FBQyxxQkFBcUIsQ0FBQyxVQUFVLENBQUMsQ0FBQztBQUN0RCxDQUFDO0FBRUQ7O0dBRUc7QUFDSCxNQUFNLFVBQVUsYUFBYSxDQUFDLE1BQWM7SUFDMUMsOEJBQThCO0lBQzlCLE9BQU8sVUFBVSxDQUFDLGFBQWEsQ0FBQyxNQUFNLENBQUMsQ0FBQztBQUMxQyxDQUFDO0FBRUQ7O0dBRUc7QUFDSCxNQUFNLFVBQVUsWUFBWSxDQUFDLEdBQVc7SUFDdEMsOEJBQThCO0lBQzlCLE9BQU8sVUFBVSxDQUFDLFlBQVksQ0FBQyxHQUFHLENBQUMsSUFBSyxHQUFtQixLQUFLLFNBQVMsQ0FBQztBQUM1RSxDQUFDIn0=

package/dist_ts/index.d.ts

@@ -14,6 +14,7 @@ export * from './proxies/smart-proxy/utils/index.js';
 export { SniHandler } from './tls/sni/sni-handler.js';
 export * from './core/models/common-types.js';
 export type { IAcmeOptions } from './proxies/smart-proxy/models/interfaces.js';
-export * as forwarding from './forwarding/index.js';
 export * as tls from './tls/index.js';
 export * as routing from './routing/index.js';
+export * as detection from './detection/index.js';
+export * as protocols from './protocols/index.js';

package/dist_ts/index.js

@@ -18,8 +18,9 @@ export { SniHandler } from './tls/sni/sni-handler.js';
 // Core types and utilities
 export * from './core/models/common-types.js';
 // Modular exports for new architecture
-export * as forwarding from './forwarding/index.js';
 // Certificate module has been removed - use SmartCertManager instead
 export * as tls from './tls/index.js';
 export * as routing from './routing/index.js';
-//# sourceMappingURL=data:application/json;base64,eyJ2ZXJzaW9uIjozLCJmaWxlIjoiaW5kZXguanMiLCJzb3VyY2VSb290IjoiIiwic291cmNlcyI6WyIuLi90cy9pbmRleC50cyJdLCJuYW1lcyI6W10sIm1hcHBpbmdzIjoiQUFBQTs7R0FFRztBQUVILHlCQUF5QjtBQUN6QixjQUFjLG1DQUFtQyxDQUFDO0FBRWxELDRCQUE0QjtBQUM1QixPQUFPLEVBQUUsU0FBUyxFQUFFLGtCQUFrQixFQUFFLGNBQWMsRUFBRSxjQUFjLEVBQUUsZ0JBQWdCLEVBQUUsTUFBTSwrQkFBK0IsQ0FBQztBQUdoSSxPQUFPLEVBQUUsa0JBQWtCLElBQUkscUJBQXFCLEVBQUUsTUFBTSxpQ0FBaUMsQ0FBQztBQUU5Rix5RUFBeUU7QUFDekUsT0FBTyxFQUFFLFVBQVUsRUFBRSxpQkFBaUIsRUFBRSxlQUFlLEVBQUUsY0FBYyxFQUFFLFVBQVUsRUFBRSxlQUFlLEVBQUUsc0JBQXNCLEVBQUUsZ0JBQWdCLEVBQUUsTUFBTSxnQ0FBZ0MsQ0FBQztBQUN2TCxPQUFPLEVBQUUsa0JBQWtCLElBQUksWUFBWSxFQUFFLE1BQU0saUNBQWlDLENBQUM7QUFJckYsY0FBYyxzQ0FBc0MsQ0FBQztBQUVyRCxrRUFBa0U7QUFDbEUsb0NBQW9DO0FBQ3BDLE9BQU8sRUFBRSxVQUFVLEVBQUUsTUFBTSwwQkFBMEIsQ0FBQztBQUN0RCxrRUFBa0U7QUFDbEUscUVBQXFFO0FBRXJFLDJCQUEyQjtBQUMzQixjQUFjLCtCQUErQixDQUFDO0FBSzlDLHVDQUF1QztBQUN2QyxPQUFPLEtBQUssVUFBVSxNQUFNLHVCQUF1QixDQUFDO0FBQ3BELHFFQUFxRTtBQUNyRSxPQUFPLEtBQUssR0FBRyxNQUFNLGdCQUFnQixDQUFDO0FBQ3RDLE9BQU8sS0FBSyxPQUFPLE1BQU0sb0JBQW9CLENBQUMifQ==
+export * as detection from './detection/index.js';
+export * as protocols from './protocols/index.js';
+//# sourceMappingURL=data:application/json;base64,eyJ2ZXJzaW9uIjozLCJmaWxlIjoiaW5kZXguanMiLCJzb3VyY2VSb290IjoiIiwic291cmNlcyI6WyIuLi90cy9pbmRleC50cyJdLCJuYW1lcyI6W10sIm1hcHBpbmdzIjoiQUFBQTs7R0FFRztBQUVILHlCQUF5QjtBQUN6QixjQUFjLG1DQUFtQyxDQUFDO0FBRWxELDRCQUE0QjtBQUM1QixPQUFPLEVBQUUsU0FBUyxFQUFFLGtCQUFrQixFQUFFLGNBQWMsRUFBRSxjQUFjLEVBQUUsZ0JBQWdCLEVBQUUsTUFBTSwrQkFBK0IsQ0FBQztBQUdoSSxPQUFPLEVBQUUsa0JBQWtCLElBQUkscUJBQXFCLEVBQUUsTUFBTSxpQ0FBaUMsQ0FBQztBQUU5Rix5RUFBeUU7QUFDekUsT0FBTyxFQUFFLFVBQVUsRUFBRSxpQkFBaUIsRUFBRSxlQUFlLEVBQUUsY0FBYyxFQUFFLFVBQVUsRUFBRSxlQUFlLEVBQUUsc0JBQXNCLEVBQUUsZ0JBQWdCLEVBQUUsTUFBTSxnQ0FBZ0MsQ0FBQztBQUN2TCxPQUFPLEVBQUUsa0JBQWtCLElBQUksWUFBWSxFQUFFLE1BQU0saUNBQWlDLENBQUM7QUFJckYsY0FBYyxzQ0FBc0MsQ0FBQztBQUVyRCxrRUFBa0U7QUFDbEUsb0NBQW9DO0FBQ3BDLE9BQU8sRUFBRSxVQUFVLEVBQUUsTUFBTSwwQkFBMEIsQ0FBQztBQUN0RCxrRUFBa0U7QUFDbEUscUVBQXFFO0FBRXJFLDJCQUEyQjtBQUMzQixjQUFjLCtCQUErQixDQUFDO0FBSzlDLHVDQUF1QztBQUN2QyxxRUFBcUU7QUFDckUsT0FBTyxLQUFLLEdBQUcsTUFBTSxnQkFBZ0IsQ0FBQztBQUN0QyxPQUFPLEtBQUssT0FBTyxNQUFNLG9CQUFvQixDQUFDO0FBQzlDLE9BQU8sS0FBSyxTQUFTLE1BQU0sc0JBQXNCLENBQUM7QUFDbEQsT0FBTyxLQUFLLFNBQVMsTUFBTSxzQkFBc0IsQ0FBQyJ9

package/dist_ts/protocols/common/fragment-handler.d.ts

@@ -0,0 +1,73 @@
+/**
+ * Shared Fragment Handler for Protocol Detection
+ *
+ * Provides unified fragment buffering and reassembly for protocols
+ * that may span multiple TCP packets.
+ */
+import { Buffer } from 'buffer';
+/**
+ * Fragment tracking information
+ */
+export interface IFragmentInfo {
+    buffer: Buffer;
+    timestamp: number;
+    connectionId: string;
+}
+/**
+ * Options for fragment handling
+ */
+export interface IFragmentOptions {
+    maxBufferSize?: number;
+    timeout?: number;
+    cleanupInterval?: number;
+}
+/**
+ * Result of fragment processing
+ */
+export interface IFragmentResult {
+    isComplete: boolean;
+    buffer?: Buffer;
+    needsMoreData: boolean;
+    error?: string;
+}
+/**
+ * Shared fragment handler for protocol detection
+ */
+export declare class FragmentHandler {
+    private options;
+    private fragments;
+    private cleanupTimer?;
+    constructor(options?: IFragmentOptions);
+    /**
+     * Add a fragment for a connection
+     */
+    addFragment(connectionId: string, fragment: Buffer): IFragmentResult;
+    /**
+     * Get the current buffer for a connection
+     */
+    getBuffer(connectionId: string): Buffer | undefined;
+    /**
+     * Mark a connection as complete and clean up
+     */
+    complete(connectionId: string): void;
+    /**
+     * Check if we're tracking a connection
+     */
+    hasConnection(connectionId: string): boolean;
+    /**
+     * Clean up expired fragments
+     */
+    cleanup(): void;
+    /**
+     * Clear all fragments
+     */
+    clear(): void;
+    /**
+     * Destroy the handler and clean up resources
+     */
+    destroy(): void;
+    /**
+     * Get the number of tracked connections
+     */
+    get size(): number;
+}

package/dist_ts/protocols/common/fragment-handler.js

@@ -0,0 +1,117 @@
+/**
+ * Shared Fragment Handler for Protocol Detection
+ *
+ * Provides unified fragment buffering and reassembly for protocols
+ * that may span multiple TCP packets.
+ */
+import { Buffer } from 'buffer';
+/**
+ * Shared fragment handler for protocol detection
+ */
+export class FragmentHandler {
+    constructor(options = {}) {
+        this.options = options;
+        this.fragments = new Map();
+        // Start cleanup timer if not already running
+        if (options.cleanupInterval && !this.cleanupTimer) {
+            this.cleanupTimer = setInterval(() => this.cleanup(), options.cleanupInterval);
+        }
+    }
+    /**
+     * Add a fragment for a connection
+     */
+    addFragment(connectionId, fragment) {
+        const existing = this.fragments.get(connectionId);
+        if (existing) {
+            // Append to existing buffer
+            const newBuffer = Buffer.concat([existing.buffer, fragment]);
+            // Check size limit
+            const maxSize = this.options.maxBufferSize || 65536;
+            if (newBuffer.length > maxSize) {
+                this.fragments.delete(connectionId);
+                return {
+                    isComplete: false,
+                    needsMoreData: false,
+                    error: 'Buffer size exceeded maximum allowed'
+                };
+            }
+            // Update fragment info
+            this.fragments.set(connectionId, {
+                buffer: newBuffer,
+                timestamp: Date.now(),
+                connectionId
+            });
+            return {
+                isComplete: false,
+                buffer: newBuffer,
+                needsMoreData: true
+            };
+        }
+        else {
+            // New fragment
+            this.fragments.set(connectionId, {
+                buffer: fragment,
+                timestamp: Date.now(),
+                connectionId
+            });
+            return {
+                isComplete: false,
+                buffer: fragment,
+                needsMoreData: true
+            };
+        }
+    }
+    /**
+     * Get the current buffer for a connection
+     */
+    getBuffer(connectionId) {
+        return this.fragments.get(connectionId)?.buffer;
+    }
+    /**
+     * Mark a connection as complete and clean up
+     */
+    complete(connectionId) {
+        this.fragments.delete(connectionId);
+    }
+    /**
+     * Check if we're tracking a connection
+     */
+    hasConnection(connectionId) {
+        return this.fragments.has(connectionId);
+    }
+    /**
+     * Clean up expired fragments
+     */
+    cleanup() {
+        const now = Date.now();
+        const timeout = this.options.timeout || 5000;
+        for (const [connectionId, info] of this.fragments.entries()) {
+            if (now - info.timestamp > timeout) {
+                this.fragments.delete(connectionId);
+            }
+        }
+    }
+    /**
+     * Clear all fragments
+     */
+    clear() {
+        this.fragments.clear();
+    }
+    /**
+     * Destroy the handler and clean up resources
+     */
+    destroy() {
+        if (this.cleanupTimer) {
+            clearInterval(this.cleanupTimer);
+            this.cleanupTimer = undefined;
+        }
+        this.clear();
+    }
+    /**
+     * Get the number of tracked connections
+     */
+    get size() {
+        return this.fragments.size;
+    }
+}
+//# sourceMappingURL=data:application/json;base64,eyJ2ZXJzaW9uIjozLCJmaWxlIjoiZnJhZ21lbnQtaGFuZGxlci5qcyIsInNvdXJjZVJvb3QiOiIiLCJzb3VyY2VzIjpbIi4uLy4uLy4uL3RzL3Byb3RvY29scy9jb21tb24vZnJhZ21lbnQtaGFuZGxlci50cyJdLCJuYW1lcyI6W10sIm1hcHBpbmdzIjoiQUFBQTs7Ozs7R0FLRztBQUVILE9BQU8sRUFBRSxNQUFNLEVBQUUsTUFBTSxRQUFRLENBQUM7QUE4QmhDOztHQUVHO0FBQ0gsTUFBTSxPQUFPLGVBQWU7SUFJMUIsWUFBb0IsVUFBNEIsRUFBRTtRQUE5QixZQUFPLEdBQVAsT0FBTyxDQUF1QjtRQUgxQyxjQUFTLEdBQUcsSUFBSSxHQUFHLEVBQXlCLENBQUM7UUFJbkQsNkNBQTZDO1FBQzdDLElBQUksT0FBTyxDQUFDLGVBQWUsSUFBSSxDQUFDLElBQUksQ0FBQyxZQUFZLEVBQUUsQ0FBQztZQUNsRCxJQUFJLENBQUMsWUFBWSxHQUFHLFdBQVcsQ0FDN0IsR0FBRyxFQUFFLENBQUMsSUFBSSxDQUFDLE9BQU8sRUFBRSxFQUNwQixPQUFPLENBQUMsZUFBZSxDQUN4QixDQUFDO1FBQ0osQ0FBQztJQUNILENBQUM7SUFFRDs7T0FFRztJQUNILFdBQVcsQ0FBQyxZQUFvQixFQUFFLFFBQWdCO1FBQ2hELE1BQU0sUUFBUSxHQUFHLElBQUksQ0FBQyxTQUFTLENBQUMsR0FBRyxDQUFDLFlBQVksQ0FBQyxDQUFDO1FBRWxELElBQUksUUFBUSxFQUFFLENBQUM7WUFDYiw0QkFBNEI7WUFDNUIsTUFBTSxTQUFTLEdBQUcsTUFBTSxDQUFDLE1BQU0sQ0FBQyxDQUFDLFFBQVEsQ0FBQyxNQUFNLEVBQUUsUUFBUSxDQUFDLENBQUMsQ0FBQztZQUU3RCxtQkFBbUI7WUFDbkIsTUFBTSxPQUFPLEdBQUcsSUFBSSxDQUFDLE9BQU8sQ0FBQyxhQUFhLElBQUksS0FBSyxDQUFDO1lBQ3BELElBQUksU0FBUyxDQUFDLE1BQU0sR0FBRyxPQUFPLEVBQUUsQ0FBQztnQkFDL0IsSUFBSSxDQUFDLFNBQVMsQ0FBQyxNQUFNLENBQUMsWUFBWSxDQUFDLENBQUM7Z0JBQ3BDLE9BQU87b0JBQ0wsVUFBVSxFQUFFLEtBQUs7b0JBQ2pCLGFBQWEsRUFBRSxLQUFLO29CQUNwQixLQUFLLEVBQUUsc0NBQXNDO2lCQUM5QyxDQUFDO1lBQ0osQ0FBQztZQUVELHVCQUF1QjtZQUN2QixJQUFJLENBQUMsU0FBUyxDQUFDLEdBQUcsQ0FBQyxZQUFZLEVBQUU7Z0JBQy9CLE1BQU0sRUFBRSxTQUFTO2dCQUNqQixTQUFTLEVBQUUsSUFBSSxDQUFDLEdBQUcsRUFBRTtnQkFDckIsWUFBWTthQUNiLENBQUMsQ0FBQztZQUVILE9BQU87Z0JBQ0wsVUFBVSxFQUFFLEtBQUs7Z0JBQ2pCLE1BQU0sRUFBRSxTQUFTO2dCQUNqQixhQUFhLEVBQUUsSUFBSTthQUNwQixDQUFDO1FBQ0osQ0FBQzthQUFNLENBQUM7WUFDTixlQUFlO1lBQ2YsSUFBSSxDQUFDLFNBQVMsQ0FBQyxHQUFHLENBQUMsWUFBWSxFQUFFO2dCQUMvQixNQUFNLEVBQUUsUUFBUTtnQkFDaEIsU0FBUyxFQUFFLElBQUksQ0FBQyxHQUFHLEVBQUU7Z0JBQ3JCLFlBQVk7YUFDYixDQUFDLENBQUM7WUFFSCxPQUFPO2dCQUNMLFVBQVUsRUFBRSxLQUFLO2dCQUNqQixNQUFNLEVBQUUsUUFBUTtnQkFDaEIsYUFBYSxFQUFFLElBQUk7YUFDcEIsQ0FBQztRQUNKLENBQUM7SUFDSCxDQUFDO0lBRUQ7O09BRUc7SUFDSCxTQUFTLENBQUMsWUFBb0I7UUFDNUIsT0FBTyxJQUFJLENBQUMsU0FBUyxDQUFDLEdBQUcsQ0FBQyxZQUFZLENBQUMsRUFBRSxNQUFNLENBQUM7SUFDbEQsQ0FBQztJQUVEOztPQUVHO0lBQ0gsUUFBUSxDQUFDLFlBQW9CO1FBQzNCLElBQUksQ0FBQyxTQUFTLENBQUMsTUFBTSxDQUFDLFlBQVksQ0FBQyxDQUFDO0lBQ3RDLENBQUM7SUFFRDs7T0FFRztJQUNILGFBQWEsQ0FBQyxZQUFvQjtRQUNoQyxPQUFPLElBQUksQ0FBQyxTQUFTLENBQUMsR0FBRyxDQUFDLFlBQVksQ0FBQyxDQUFDO0lBQzFDLENBQUM7SUFFRDs7T0FFRztJQUNILE9BQU87UUFDTCxNQUFNLEdBQUcsR0FBRyxJQUFJLENBQUMsR0FBRyxFQUFFLENBQUM7UUFDdkIsTUFBTSxPQUFPLEdBQUcsSUFBSSxDQUFDLE9BQU8sQ0FBQyxPQUFPLElBQUksSUFBSSxDQUFDO1FBRTdDLEtBQUssTUFBTSxDQUFDLFlBQVksRUFBRSxJQUFJLENBQUMsSUFBSSxJQUFJLENBQUMsU0FBUyxDQUFDLE9BQU8sRUFBRSxFQUFFLENBQUM7WUFDNUQsSUFBSSxHQUFHLEdBQUcsSUFBSSxDQUFDLFNBQVMsR0FBRyxPQUFPLEVBQUUsQ0FBQztnQkFDbkMsSUFBSSxDQUFDLFNBQVMsQ0FBQyxNQUFNLENBQUMsWUFBWSxDQUFDLENBQUM7WUFDdEMsQ0FBQztRQUNILENBQUM7SUFDSCxDQUFDO0lBRUQ7O09BRUc7SUFDSCxLQUFLO1FBQ0gsSUFBSSxDQUFDLFNBQVMsQ0FBQyxLQUFLLEVBQUUsQ0FBQztJQUN6QixDQUFDO0lBRUQ7O09BRUc7SUFDSCxPQUFPO1FBQ0wsSUFBSSxJQUFJLENBQUMsWUFBWSxFQUFFLENBQUM7WUFDdEIsYUFBYSxDQUFDLElBQUksQ0FBQyxZQUFZLENBQUMsQ0FBQztZQUNqQyxJQUFJLENBQUMsWUFBWSxHQUFHLFNBQVMsQ0FBQztRQUNoQyxDQUFDO1FBQ0QsSUFBSSxDQUFDLEtBQUssRUFBRSxDQUFDO0lBQ2YsQ0FBQztJQUVEOztPQUVHO0lBQ0gsSUFBSSxJQUFJO1FBQ04sT0FBTyxJQUFJLENBQUMsU0FBUyxDQUFDLElBQUksQ0FBQztJQUM3QixDQUFDO0NBQ0YifQ==

package/dist_ts/protocols/common/index.d.ts

@@ -0,0 +1,7 @@
+/**
+ * Common Protocol Infrastructure
+ *
+ * Shared utilities and types for protocol handling
+ */
+export * from './fragment-handler.js';
+export * from './types.js';

package/dist_ts/protocols/common/index.js

@@ -0,0 +1,8 @@
+/**
+ * Common Protocol Infrastructure
+ *
+ * Shared utilities and types for protocol handling
+ */
+export * from './fragment-handler.js';
+export * from './types.js';
+//# sourceMappingURL=data:application/json;base64,eyJ2ZXJzaW9uIjozLCJmaWxlIjoiaW5kZXguanMiLCJzb3VyY2VSb290IjoiIiwic291cmNlcyI6WyIuLi8uLi8uLi90cy9wcm90b2NvbHMvY29tbW9uL2luZGV4LnRzIl0sIm5hbWVzIjpbXSwibWFwcGluZ3MiOiJBQUFBOzs7O0dBSUc7QUFFSCxjQUFjLHVCQUF1QixDQUFDO0FBQ3RDLGNBQWMsWUFBWSxDQUFDIn0=

package/dist_ts/protocols/common/types.d.ts

@@ -0,0 +1,68 @@
+/**
+ * Common Protocol Types
+ *
+ * Shared types used across different protocol implementations
+ */
+/**
+ * Supported protocol types
+ */
+export type TProtocolType = 'tls' | 'http' | 'https' | 'websocket' | 'unknown';
+/**
+ * Protocol detection result
+ */
+export interface IProtocolDetectionResult {
+    protocol: TProtocolType;
+    confidence: number;
+    requiresMoreData?: boolean;
+    metadata?: {
+        version?: string;
+        method?: string;
+        [key: string]: any;
+    };
+}
+/**
+ * Routing information extracted from protocols
+ */
+export interface IRoutingInfo {
+    domain?: string;
+    port?: number;
+    path?: string;
+    protocol: TProtocolType;
+}
+/**
+ * Connection context for protocol operations
+ */
+export interface IConnectionContext {
+    id: string;
+    sourceIp?: string;
+    sourcePort?: number;
+    destIp?: string;
+    destPort?: number;
+    timestamp?: number;
+}
+/**
+ * Protocol detection options
+ */
+export interface IProtocolDetectionOptions {
+    quickMode?: boolean;
+    extractRouting?: boolean;
+    maxWaitTime?: number;
+    maxBufferSize?: number;
+}
+/**
+ * Base interface for protocol detectors
+ */
+export interface IProtocolDetector {
+    /**
+     * Check if this detector can handle the data
+     */
+    canHandle(data: Buffer): boolean;
+    /**
+     * Perform quick detection (first few bytes only)
+     */
+    quickDetect(data: Buffer): IProtocolDetectionResult;
+    /**
+     * Extract routing information if possible
+     */
+    extractRouting?(data: Buffer, context?: IConnectionContext): IRoutingInfo | null;
+}

package/dist_ts/protocols/common/types.js

@@ -0,0 +1,7 @@
+/**
+ * Common Protocol Types
+ *
+ * Shared types used across different protocol implementations
+ */
+export {};
+//# sourceMappingURL=data:application/json;base64,eyJ2ZXJzaW9uIjozLCJmaWxlIjoidHlwZXMuanMiLCJzb3VyY2VSb290IjoiIiwic291cmNlcyI6WyIuLi8uLi8uLi90cy9wcm90b2NvbHMvY29tbW9uL3R5cGVzLnRzIl0sIm5hbWVzIjpbXSwibWFwcGluZ3MiOiJBQUFBOzs7O0dBSUcifQ==