appium-ios-remotexpc 0.0.3 → 0.0.4

package/build/src/lib/remote-xpc/xpc-protocol.js

@@ -0,0 +1,368 @@
+// Constants for XPC protocol.
+const BODY_VERSION = 0x00000005;
+const WRAPPER_MAGIC = 0x29b00b92;
+const OBJECT_MAGIC = 0x42133742;
+export const XPC_TYPES = {
+    null: 0x00001000,
+    bool: 0x00002000,
+    int64: 0x00003000,
+    uint64: 0x00004000,
+    double: 0x00005000,
+    date: 0x00007000,
+    data: 0x00008000,
+    string: 0x00009000,
+    uuid: 0x0000a000,
+    array: 0x0000e000,
+    dictionary: 0x0000f000,
+    fileTransfer: 0x0001a000,
+};
+// Helper: calculates padding bytes needed to align a length to a multiple of 4.
+function calcPadding(len) {
+    return (4 - (len % 4)) % 4;
+}
+// A simple binary writer that collects Buffer chunks.
+class Writer {
+    chunks = [];
+    writeBuffer(buf) {
+        this.chunks.push(buf);
+    }
+    writeUInt32LE(value) {
+        const buf = Buffer.alloc(4);
+        buf.writeUInt32LE(value, 0);
+        this.writeBuffer(buf);
+    }
+    writeBigUInt64LE(value) {
+        const buf = Buffer.alloc(8);
+        if (typeof value === 'bigint') {
+            buf.writeBigUInt64LE(value, 0);
+        }
+        else {
+            buf.writeBigUInt64LE(BigInt(value), 0);
+        }
+        this.writeBuffer(buf);
+    }
+    writeBigInt64LE(value) {
+        const buf = Buffer.alloc(8);
+        buf.writeBigInt64LE(value, 0);
+        this.writeBuffer(buf);
+    }
+    writeDoubleLE(value) {
+        const buf = Buffer.alloc(8);
+        buf.writeDoubleLE(value, 0);
+        this.writeBuffer(buf);
+    }
+    writeByte(value) {
+        const buf = Buffer.alloc(1);
+        buf.writeUInt8(value, 0);
+        this.writeBuffer(buf);
+    }
+    writePadding(len) {
+        if (len > 0) {
+            this.writeBuffer(Buffer.alloc(len));
+        }
+    }
+    concat() {
+        return Buffer.concat(this.chunks);
+    }
+}
+// A simple binary reader that uses an offset to traverse a Buffer.
+class Reader {
+    buffer;
+    offset = 0;
+    constructor(buffer) {
+        this.buffer = buffer;
+    }
+    readUInt32LE() {
+        const val = this.buffer.readUInt32LE(this.offset);
+        this.offset += 4;
+        return val;
+    }
+    readBigUInt64LE() {
+        const val = this.buffer.readBigUInt64LE(this.offset);
+        this.offset += 8;
+        return val;
+    }
+    readBigInt64LE() {
+        const val = this.buffer.readBigInt64LE(this.offset);
+        this.offset += 8;
+        return val;
+    }
+    readDoubleLE() {
+        const val = this.buffer.readDoubleLE(this.offset);
+        this.offset += 8;
+        return val;
+    }
+    readByte() {
+        const val = this.buffer.readUInt8(this.offset);
+        this.offset += 1;
+        return val;
+    }
+    readBytes(n) {
+        const buf = this.buffer.slice(this.offset, this.offset + n);
+        this.offset += n;
+        return buf;
+    }
+    skip(n) {
+        this.offset += n;
+    }
+}
+/**
+ * Encodes a message object into an XPC Buffer.
+ * A message is an object like:
+ *   { flags: Number, id: bigint, body: Object|null }
+ */
+export function encodeMessage(message) {
+    const writer = new Writer();
+    // Provide defaults if id or body is not provided.
+    const messageId = message.id ?? BigInt(0);
+    const body = message.body === undefined ? null : message.body;
+    // Write the wrapper magic number.
+    writer.writeUInt32LE(WRAPPER_MAGIC);
+    if (body === null) {
+        writer.writeUInt32LE(message.flags);
+        writer.writeBigUInt64LE(BigInt(0));
+        writer.writeBigUInt64LE(messageId);
+        return writer.concat();
+    }
+    // Encode the message body (a dictionary) into a temporary buffer.
+    const bodyWriter = new Writer();
+    encodeDictionary(bodyWriter, body);
+    const bodyBuffer = bodyWriter.concat();
+    // Write header: flags, BodyLen (payload length + 8 for the body header), msg id.
+    writer.writeUInt32LE(message.flags);
+    writer.writeBigUInt64LE(BigInt(bodyBuffer.length + 8));
+    writer.writeBigUInt64LE(messageId);
+    // Write body header: object magic number and version.
+    writer.writeUInt32LE(OBJECT_MAGIC);
+    writer.writeUInt32LE(BODY_VERSION);
+    // Write the actual body payload.
+    writer.writeBuffer(bodyBuffer);
+    return writer.concat();
+}
+/**
+ * Decodes an XPC Buffer into a message object.
+ * (Keep this function if you plan to handle incoming messages.)
+ */
+export function decodeMessage(buffer) {
+    const reader = new Reader(buffer);
+    const magic = reader.readUInt32LE();
+    if (magic !== WRAPPER_MAGIC) {
+        throw new Error(`Invalid wrapper magic: 0x${magic.toString(16)}`);
+    }
+    const flags = reader.readUInt32LE();
+    const bodyLen = reader.readBigUInt64LE();
+    const msgId = reader.readBigUInt64LE();
+    if (bodyLen === BigInt(0)) {
+        return { flags, id: msgId, body: null };
+    }
+    // Read body header.
+    const objMagic = reader.readUInt32LE();
+    const version = reader.readUInt32LE();
+    if (objMagic !== OBJECT_MAGIC) {
+        throw new Error(`Invalid object magic: 0x${objMagic.toString(16)}`);
+    }
+    if (version !== BODY_VERSION) {
+        throw new Error(`Unexpected body version: 0x${version.toString(16)}`);
+    }
+    // The remaining body is (bodyLen - 8) bytes.
+    const bodyPayloadLength = Number(bodyLen) - 8;
+    const bodyBuffer = reader.readBytes(bodyPayloadLength);
+    const decodedValue = decodeObject(new Reader(bodyBuffer));
+    // Ensure the decoded value is a dictionary
+    if (typeof decodedValue !== 'object' ||
+        decodedValue === null ||
+        Array.isArray(decodedValue)) {
+        throw new TypeError('Expected dictionary as message body');
+    }
+    return { flags, id: msgId, body: decodedValue };
+}
+/**
+ * Encodes a JavaScript object (dictionary) into XPC format.
+ */
+function encodeDictionary(writer, dict) {
+    const inner = new Writer();
+    const keys = Object.keys(dict);
+    // Write the number of dictionary entries (uint32).
+    inner.writeUInt32LE(keys.length);
+    for (const key of keys) {
+        encodeDictionaryKey(inner, key);
+        encodeObject(inner, dict[key]);
+    }
+    const payload = inner.concat();
+    // Write dictionary type.
+    writer.writeUInt32LE(XPC_TYPES.dictionary);
+    // Write payload length (uint32).
+    writer.writeUInt32LE(payload.length);
+    writer.writeBuffer(payload);
+}
+/**
+ * Encodes a dictionary key: writes the key string followed by a null terminator and padding.
+ */
+function encodeDictionaryKey(writer, key) {
+    const keyBuf = Buffer.from(key, 'utf8');
+    const len = keyBuf.length + 1; // +1 for null terminator.
+    writer.writeBuffer(keyBuf);
+    writer.writeByte(0); // null terminator.
+    const pad = calcPadding(len);
+    writer.writePadding(pad);
+}
+/**
+ * Encodes a JavaScript value into XPC format.
+ * Supports: null, booleans, numbers (as int64 or double), strings, Date, Buffer/Uint8Array, arrays, and objects.
+ */
+function encodeObject(writer, value) {
+    if (value === null || value === undefined) {
+        writer.writeUInt32LE(XPC_TYPES.null);
+        return;
+    }
+    if (typeof value === 'boolean') {
+        writer.writeUInt32LE(XPC_TYPES.bool);
+        writer.writeByte(value ? 1 : 0);
+        writer.writePadding(3); // 3 bytes padding.
+        return;
+    }
+    if (typeof value === 'number') {
+        if (Number.isInteger(value)) {
+            writer.writeUInt32LE(XPC_TYPES.int64);
+            writer.writeBigInt64LE(BigInt(value));
+        }
+        else {
+            writer.writeUInt32LE(XPC_TYPES.double);
+            writer.writeDoubleLE(value);
+        }
+        return;
+    }
+    if (typeof value === 'string') {
+        writer.writeUInt32LE(XPC_TYPES.string);
+        const strBuf = Buffer.from(value, 'utf8');
+        const len = strBuf.length + 1; // include null terminator.
+        writer.writeUInt32LE(len);
+        writer.writeBuffer(strBuf);
+        writer.writeByte(0);
+        const pad = calcPadding(len);
+        writer.writePadding(pad);
+        return;
+    }
+    if (value instanceof Date) {
+        writer.writeUInt32LE(XPC_TYPES.date);
+        // Encode time in nanoseconds (Date.getTime() gives milliseconds).
+        writer.writeBigInt64LE(BigInt(value.getTime()) * BigInt(1000000));
+        return;
+    }
+    if (Buffer.isBuffer(value) || value instanceof Uint8Array) {
+        const data = Buffer.isBuffer(value) ? value : Buffer.from(value);
+        writer.writeUInt32LE(XPC_TYPES.data);
+        writer.writeUInt32LE(data.length);
+        writer.writeBuffer(data);
+        const pad = calcPadding(data.length);
+        writer.writePadding(pad);
+        return;
+    }
+    if (Array.isArray(value)) {
+        const inner = new Writer();
+        for (let i = 0; i < value.length; i++) {
+            encodeObject(inner, value[i]);
+        }
+        const payload = inner.concat();
+        writer.writeUInt32LE(XPC_TYPES.array);
+        writer.writeUInt32LE(payload.length); // payload length.
+        writer.writeUInt32LE(value.length); // number of objects.
+        writer.writeBuffer(payload);
+        return;
+    }
+    if (typeof value === 'object') {
+        // Treat as a dictionary.
+        encodeDictionary(writer, value);
+        return;
+    }
+    throw new TypeError('Unsupported type: ' + typeof value);
+}
+/**
+ * Decodes an XPC object from the provided reader.
+ */
+function decodeObject(reader) {
+    const type = reader.readUInt32LE();
+    switch (type) {
+        case XPC_TYPES.null:
+            return null;
+        case XPC_TYPES.bool: {
+            const b = reader.readByte();
+            reader.skip(3);
+            return Boolean(b);
+        }
+        case XPC_TYPES.int64:
+            return Number(reader.readBigInt64LE());
+        case XPC_TYPES.uint64:
+            return Number(reader.readBigUInt64LE());
+        case XPC_TYPES.double:
+            return reader.readDoubleLE();
+        case XPC_TYPES.date: {
+            // Date is encoded as int64 nanoseconds.
+            const ns = reader.readBigInt64LE();
+            return new Date(Number(ns / BigInt(1000000)));
+        }
+        case XPC_TYPES.data: {
+            const dataLen = reader.readUInt32LE();
+            const data = reader.readBytes(dataLen);
+            const pad = calcPadding(dataLen);
+            reader.skip(pad);
+            return data;
+        }
+        case XPC_TYPES.string: {
+            const strLen = reader.readUInt32LE();
+            const strBuf = reader.readBytes(strLen);
+            // Remove the trailing null terminator.
+            const nullIndex = strBuf.indexOf(0);
+            const str = strBuf.slice(0, nullIndex).toString('utf8');
+            const pad = calcPadding(strLen);
+            reader.skip(pad);
+            return str;
+        }
+        case XPC_TYPES.uuid: {
+            const uuidBuf = reader.readBytes(16);
+            return uuidBuf.toString('hex'); // Return UUID as hex string.
+        }
+        case XPC_TYPES.array: {
+            const numElements = reader.readUInt32LE();
+            const arr = [];
+            for (let i = 0; i < numElements; i++) {
+                arr.push(decodeObject(reader));
+            }
+            return arr;
+        }
+        case XPC_TYPES.dictionary:
+            return decodeDictionary(reader);
+        // Note: fileTransfer type is not implemented here.
+        default:
+            throw new TypeError(`Unsupported xpc type: 0x${type.toString(16)}`);
+    }
+}
+/**
+ * Decodes a dictionary from the reader.
+ */
+function decodeDictionary(reader) {
+    const numEntries = reader.readUInt32LE();
+    const dict = {};
+    for (let i = 0; i < numEntries; i++) {
+        const key = readDictionaryKey(reader);
+        dict[key] = decodeObject(reader);
+    }
+    return dict;
+}
+/**
+ * Reads a dictionary key: reads bytes until a null terminator is encountered then skips padding.
+ */
+function readDictionaryKey(reader) {
+    const bytes = [];
+    while (true) {
+        const b = reader.readByte();
+        if (b === 0) {
+            break;
+        }
+        bytes.push(b);
+    }
+    const key = Buffer.from(bytes).toString('utf8');
+    const pad = calcPadding(key.length + 1);
+    reader.skip(pad);
+    return key;
+}

package/build/src/lib/tunnel/index.d.ts

@@ -0,0 +1,69 @@
+import type { TLSSocket } from 'tls';
+import { type TunnelConnection } from 'tuntap-bridge';
+/**
+ * A wrapper around the tunnel connection that
+ * maintains a registry of active tunnels that can be reused.
+ */
+declare class TunnelManagerService {
+    private tunnelRegistry;
+    /**
+     * Checks if a tunnel is already open for the given address
+     *
+     * @param address - The tunnel address to check
+     * @returns True if a tunnel is open for the address, false otherwise
+     */
+    isTunnelOpen(address: string): boolean;
+    /**
+     * Gets all active tunnels
+     *
+     * @returns Array of active tunnel addresses
+     */
+    getActiveTunnels(): string[];
+    /**
+     * Creates a RemoteXPC connection for the specified device.
+     *
+     * @param address - The address of the tunnel
+     * @param rsdPort - The RSD port of the tunnel
+     * @returns A promise that resolves to the RemoteXPC connection
+     */
+    createRemoteXPCConnection(address: string, rsdPort: number): Promise<any>;
+    /**
+     * Establishes a tunnel connection if not already connected.
+     * If a tunnel is already open for the same address, it will be reused.
+     *
+     * @param secureServiceSocket - The secure service socket used to create the tunnel.
+     * @returns A promise that resolves to the tunnel connection instance.
+     */
+    getTunnel(secureServiceSocket: TLSSocket): Promise<TunnelConnection>;
+    /**
+     * Gets an existing tunnel by address if available
+     *
+     * @param address - The tunnel address
+     * @returns The tunnel if found and active, null otherwise
+     */
+    getTunnelByAddress(address: string): TunnelConnection | null;
+    /**
+     * Closes a specific tunnel connection by address.
+     *
+     * @param address - The address of the tunnel to close
+     * @returns A promise that resolves when the tunnel is closed.
+     */
+    closeTunnelByAddress(address: string): Promise<void>;
+    /**
+     * Closes all tunnel connections and resets the registry.
+     *
+     * @returns A promise that resolves when all tunnels are closed.
+     */
+    closeAllTunnels(): Promise<void>;
+    /**
+     * Closes the tunnel connection for backward compatibility.
+     * This method is kept for backward compatibility with existing code.
+     *
+     * @returns A promise that resolves when all tunnels are closed.
+     */
+    closeTunnel(): Promise<void>;
+}
+export declare const TunnelManager: TunnelManagerService;
+export { PacketStreamServer } from './packet-stream-server.js';
+export { PacketStreamClient } from './packet-stream-client.js';
+//# sourceMappingURL=index.d.ts.map

package/build/src/lib/tunnel/index.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"index.d.ts","sourceRoot":"","sources":["../../../../src/lib/tunnel/index.ts"],"names":[],"mappings":"AACA,OAAO,KAAK,EAAE,SAAS,EAAE,MAAM,KAAK,CAAC;AACrC,OAAO,EAAE,KAAK,gBAAgB,EAA2B,MAAM,eAAe,CAAC;AAwB/E;;;GAGG;AACH,cAAM,oBAAoB;IAExB,OAAO,CAAC,cAAc,CAA+C;IAErE;;;;;OAKG;IACH,YAAY,CAAC,OAAO,EAAE,MAAM,GAAG,OAAO;IAKtC;;;;OAIG;IACH,gBAAgB,IAAI,MAAM,EAAE;IAM5B;;;;;;OAMG;IACG,yBAAyB,CAC7B,OAAO,EAAE,MAAM,EACf,OAAO,EAAE,MAAM,GACd,OAAO,CAAC,GAAG,CAAC;IAyCf;;;;;;OAMG;IACG,SAAS,CAAC,mBAAmB,EAAE,SAAS,GAAG,OAAO,CAAC,gBAAgB,CAAC;IAmD1E;;;;;OAKG;IACH,kBAAkB,CAAC,OAAO,EAAE,MAAM,GAAG,gBAAgB,GAAG,IAAI;IAU5D;;;;;OAKG;IACG,oBAAoB,CAAC,OAAO,EAAE,MAAM,GAAG,OAAO,CAAC,IAAI,CAAC;IAgC1D;;;;OAIG;IACG,eAAe,IAAI,OAAO,CAAC,IAAI,CAAC;IAatC;;;;;OAKG;IACG,WAAW,IAAI,OAAO,CAAC,IAAI,CAAC;CAGnC;AAGD,eAAO,MAAM,aAAa,sBAA6B,CAAC;AAExD,OAAO,EAAE,kBAAkB,EAAE,MAAM,2BAA2B,CAAC;AAC/D,OAAO,EAAE,kBAAkB,EAAE,MAAM,2BAA2B,CAAC"}

package/build/src/lib/tunnel/index.js

@@ -0,0 +1,205 @@
+import { logger } from '@appium/support';
+import { connectToTunnelLockdown } from 'tuntap-bridge';
+import RemoteXpcConnection from '../remote-xpc/remote-xpc-connection.js';
+const log = logger.getLogger('TunnelManager');
+/**
+ * A wrapper around the tunnel connection that
+ * maintains a registry of active tunnels that can be reused.
+ */
+class TunnelManagerService {
+    // Map of tunnel address to tunnel registry entry
+    tunnelRegistry = new Map();
+    /**
+     * Checks if a tunnel is already open for the given address
+     *
+     * @param address - The tunnel address to check
+     * @returns True if a tunnel is open for the address, false otherwise
+     */
+    isTunnelOpen(address) {
+        const entry = this.tunnelRegistry.get(address);
+        return Boolean(entry?.isActive);
+    }
+    /**
+     * Gets all active tunnels
+     *
+     * @returns Array of active tunnel addresses
+     */
+    getActiveTunnels() {
+        return Array.from(this.tunnelRegistry.entries())
+            .filter(([, entry]) => entry.isActive)
+            .map(([address]) => address);
+    }
+    /**
+     * Creates a RemoteXPC connection for the specified device.
+     *
+     * @param address - The address of the tunnel
+     * @param rsdPort - The RSD port of the tunnel
+     * @returns A promise that resolves to the RemoteXPC connection
+     */
+    async createRemoteXPCConnection(address, rsdPort) {
+        try {
+            const remoteXPC = new RemoteXpcConnection([address, rsdPort]);
+            // Connect to RemoteXPC with delay between retries
+            let retries = 3;
+            let lastError;
+            while (retries > 0) {
+                try {
+                    await remoteXPC.connect();
+                    // Update the registry entry with the RemoteXPC connection
+                    const entry = this.tunnelRegistry.get(address);
+                    if (entry) {
+                        entry.remoteXPC = remoteXPC;
+                    }
+                    return remoteXPC;
+                }
+                catch (error) {
+                    lastError = error;
+                    log.warn(`RemoteXPC connection attempt failed (${retries} retries left): ${error}`);
+                    retries--;
+                    // Wait before retrying
+                    if (retries > 0) {
+                        await new Promise((resolve) => setTimeout(resolve, 500));
+                    }
+                }
+            }
+            // All retries failed
+            throw lastError || new Error('Failed to connect to RemoteXPC');
+        }
+        catch (error) {
+            log.error(`Error for device ${address}: ${error}`);
+            throw error;
+        }
+    }
+    /**
+     * Establishes a tunnel connection if not already connected.
+     * If a tunnel is already open for the same address, it will be reused.
+     *
+     * @param secureServiceSocket - The secure service socket used to create the tunnel.
+     * @returns A promise that resolves to the tunnel connection instance.
+     */
+    async getTunnel(secureServiceSocket) {
+        // Create a new tunnel
+        const tunnel = await connectToTunnelLockdown(secureServiceSocket);
+        // Check if we already have an active tunnel for this address
+        const existingTunnel = this.tunnelRegistry.get(tunnel.Address);
+        if (existingTunnel?.isActive) {
+            log.info(`Reusing existing tunnel for address: ${tunnel.Address}`);
+            // Verify the tunnel is still functional
+            try {
+                // A simple check to see if the tunnel is still functional
+                if (tunnel.tunnelManager?.emit instanceof Function) {
+                    // Close the new tunnel since we're reusing an existing one
+                    try {
+                        await tunnel.closer();
+                    }
+                    catch (error) {
+                        log.warn(`Error closing redundant tunnel: ${error}`);
+                    }
+                    // Update the last used timestamp
+                    existingTunnel.lastUsed = Date.now();
+                    return existingTunnel.tunnel;
+                }
+                else {
+                    log.warn('Existing tunnel appears to be non-functional, creating a new one');
+                    // Mark the existing tunnel as inactive
+                    existingTunnel.isActive = false;
+                }
+            }
+            catch (error) {
+                log.warn(`Error checking tunnel functionality: ${error}, creating a new one`);
+                // Mark the existing tunnel as inactive
+                existingTunnel.isActive = false;
+            }
+        }
+        // Register the new tunnel
+        log.info(`Creating new tunnel for address: ${tunnel.Address}`);
+        this.tunnelRegistry.set(tunnel.Address, {
+            tunnel,
+            lastUsed: Date.now(),
+            isActive: true,
+        });
+        return tunnel;
+    }
+    /**
+     * Gets an existing tunnel by address if available
+     *
+     * @param address - The tunnel address
+     * @returns The tunnel if found and active, null otherwise
+     */
+    getTunnelByAddress(address) {
+        const entry = this.tunnelRegistry.get(address);
+        if (entry?.isActive) {
+            // Update the last used timestamp
+            entry.lastUsed = Date.now();
+            return entry.tunnel;
+        }
+        return null;
+    }
+    /**
+     * Closes a specific tunnel connection by address.
+     *
+     * @param address - The address of the tunnel to close
+     * @returns A promise that resolves when the tunnel is closed.
+     */
+    async closeTunnelByAddress(address) {
+        const entry = this.tunnelRegistry.get(address);
+        if (entry?.isActive) {
+            try {
+                // Close RemoteXPC connection if it exists
+                if (entry.remoteXPC) {
+                    try {
+                        await entry.remoteXPC.close();
+                        log.info(`Closed RemoteXPC connection for address: ${address}`);
+                    }
+                    catch (error) {
+                        log.error(`Error closing RemoteXPC connection for address ${address}: ${error}`);
+                    }
+                }
+                // Close the tunnel
+                try {
+                    await entry.tunnel.closer();
+                    log.info(`Closed tunnel for address: ${address}`);
+                }
+                catch (error) {
+                    log.error(`Error closing tunnel for address ${address}: ${error}`);
+                }
+                finally {
+                    entry.isActive = false;
+                    log.info(`Marked tunnel for address ${address} as inactive`);
+                }
+            }
+            catch (error) {
+                log.error(`Error closing tunnel for address ${address}: ${error}`);
+            }
+        }
+    }
+    /**
+     * Closes all tunnel connections and resets the registry.
+     *
+     * @returns A promise that resolves when all tunnels are closed.
+     */
+    async closeAllTunnels() {
+        const closePromises = Array.from(this.tunnelRegistry.entries())
+            .filter(([, entry]) => entry.isActive)
+            .map(([address]) => this.closeTunnelByAddress(address));
+        if (closePromises.length > 0) {
+            await Promise.all(closePromises);
+        }
+        this.tunnelRegistry.clear();
+        log.info('All tunnels closed');
+    }
+    /**
+     * Closes the tunnel connection for backward compatibility.
+     * This method is kept for backward compatibility with existing code.
+     *
+     * @returns A promise that resolves when all tunnels are closed.
+     */
+    async closeTunnel() {
+        return this.closeAllTunnels();
+    }
+}
+// Create and export the singleton instance
+export const TunnelManager = new TunnelManagerService();
+// Export packet streaming IPC functionality
+export { PacketStreamServer } from './packet-stream-server.js';
+export { PacketStreamClient } from './packet-stream-client.js';

package/build/src/lib/tunnel/packet-stream-client.d.ts

@@ -0,0 +1,46 @@
+import { EventEmitter } from 'events';
+import type { PacketConsumer } from 'tuntap-bridge';
+/**
+ * Client that connects to a PacketStreamServer to receive packet data
+ * Implements the PacketSource interface required by SyslogService
+ */
+export declare class PacketStreamClient extends EventEmitter {
+    private readonly host;
+    private readonly port;
+    private socket;
+    private readonly packetConsumers;
+    private buffer;
+    private connected;
+    constructor(host: string, port: number);
+    connect(): Promise<void>;
+    isConnected(): boolean;
+    disconnect(): Promise<void>;
+    addPacketConsumer(consumer: PacketConsumer): void;
+    removePacketConsumer(consumer: PacketConsumer): void;
+    /**
+     * Handle incoming data from the socket
+     */
+    private handleData;
+    /**
+     * Process buffered data to extract complete messages
+     */
+    private processBuffer;
+    /**
+     * Extract message length from buffer
+     * @returns Message length or null if invalid
+     */
+    private extractMessageLength;
+    /**
+     * Process a single message
+     */
+    private processMessage;
+    /**
+     * Parse packet data from message buffer
+     */
+    private parsePacket;
+    /**
+     * Notify all packet consumers
+     */
+    private notifyConsumers;
+}
+//# sourceMappingURL=packet-stream-client.d.ts.map

package/build/src/lib/tunnel/packet-stream-client.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"packet-stream-client.d.ts","sourceRoot":"","sources":["../../../../src/lib/tunnel/packet-stream-client.ts"],"names":[],"mappings":"AACA,OAAO,EAAE,YAAY,EAAE,MAAM,QAAQ,CAAC;AAEtC,OAAO,KAAK,EAAE,cAAc,EAAc,MAAM,eAAe,CAAC;AAShE;;;GAGG;AACH,qBAAa,kBAAmB,SAAQ,YAAY;IAOhD,OAAO,CAAC,QAAQ,CAAC,IAAI;IACrB,OAAO,CAAC,QAAQ,CAAC,IAAI;IAPvB,OAAO,CAAC,MAAM,CAAuB;IACrC,OAAO,CAAC,QAAQ,CAAC,eAAe,CAAkC;IAClE,OAAO,CAAC,MAAM,CAA2B;IACzC,OAAO,CAAC,SAAS,CAAS;gBAGP,IAAI,EAAE,MAAM,EACZ,IAAI,EAAE,MAAM;IAKzB,OAAO,IAAI,OAAO,CAAC,IAAI,CAAC;IAwC9B,WAAW,IAAI,OAAO;IAIhB,UAAU,IAAI,OAAO,CAAC,IAAI,CAAC;IASjC,iBAAiB,CAAC,QAAQ,EAAE,cAAc,GAAG,IAAI;IAIjD,oBAAoB,CAAC,QAAQ,EAAE,cAAc,GAAG,IAAI;IAIpD;;OAEG;IACH,OAAO,CAAC,UAAU;IAKlB;;OAEG;IACH,OAAO,CAAC,aAAa;IA2BrB;;;OAGG;IACH,OAAO,CAAC,oBAAoB;IAc5B;;OAEG;IACH,OAAO,CAAC,cAAc;IAStB;;OAEG;IACH,OAAO,CAAC,WAAW;IAWnB;;OAEG;IACH,OAAO,CAAC,eAAe;CASxB"}