@nimbus-sh/core 0.1.0

package/dist/substrate/lifo/kernel/network/tunnel/VETHPair.d.ts

@@ -0,0 +1,71 @@
+import type { Packet } from '../types.js';
+import { NetworkInterface } from '../NetworkInterface.js';
+import type { NetworkStack } from '../NetworkStack.js';
+/**
+ * VETH Pair - Virtual Ethernet Device Pair
+ *
+ * Creates two virtual network interfaces that are directly connected.
+ * Packets sent to one end appear immediately on the other end.
+ * Like a virtual Ethernet cable connecting two namespaces.
+ *
+ * Example:
+ *   ip link add veth0 type veth peer name veth1
+ *   ip link set veth1 netns container1
+ */
+export declare class VETHPair {
+    id: string;
+    veth0: NetworkInterface;
+    veth1: NetworkInterface;
+    state: 'up' | 'down';
+    private networkStack;
+    private queue0;
+    private queue1;
+    private waiters0;
+    private waiters1;
+    constructor(id: string, name0: string, name1: string, networkStack: NetworkStack, namespace0?: string, namespace1?: string);
+    /**
+     * Bring both interfaces up
+     */
+    up(): Promise<void>;
+    /**
+     * Bring both interfaces down
+     */
+    down(): Promise<void>;
+    /**
+     * Send packet from veth0 to veth1
+     */
+    send0to1(packet: Packet): Promise<void>;
+    /**
+     * Send packet from veth1 to veth0
+     */
+    send1to0(packet: Packet): Promise<void>;
+    /**
+     * Receive packet on veth0 (sent from veth1)
+     */
+    recv0(): Promise<Packet>;
+    /**
+     * Receive packet on veth1 (sent from veth0)
+     */
+    recv1(): Promise<Packet>;
+    /**
+     * Move one end of the VETH pair to a different namespace
+     */
+    moveToNamespace(which: 0 | 1, namespace: string): Promise<void>;
+    /**
+     * Generate MAC address for VETH interface
+     */
+    private generateMAC;
+    /**
+     * Get VETH pair status string
+     */
+    toString(): string;
+    /**
+     * Get interface by name
+     */
+    getInterface(name: string): NetworkInterface | null;
+    /**
+     * Get peer interface
+     */
+    getPeer(name: string): NetworkInterface | null;
+}
+//# sourceMappingURL=VETHPair.d.ts.map

package/dist/substrate/lifo/kernel/network/tunnel/VETHPair.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"VETHPair.d.ts","sourceRoot":"","sources":["../../../../../../src/substrate/lifo/kernel/network/tunnel/VETHPair.ts"],"names":[],"mappings":"AAAA,OAAO,KAAK,EAAE,MAAM,EAAE,MAAM,aAAa,CAAC;AAC1C,OAAO,EAAE,gBAAgB,EAAE,MAAM,wBAAwB,CAAC;AAC1D,OAAO,KAAK,EAAE,YAAY,EAAE,MAAM,oBAAoB,CAAC;AAEvD;;;;;;;;;;GAUG;AACH,qBAAa,QAAQ;IACnB,EAAE,EAAE,MAAM,CAAC;IACX,KAAK,EAAE,gBAAgB,CAAC;IACxB,KAAK,EAAE,gBAAgB,CAAC;IACxB,KAAK,EAAE,IAAI,GAAG,MAAM,CAAU;IAE9B,OAAO,CAAC,YAAY,CAAe;IAGnC,OAAO,CAAC,MAAM,CAAgB;IAC9B,OAAO,CAAC,MAAM,CAAgB;IAC9B,OAAO,CAAC,QAAQ,CAAuC;IACvD,OAAO,CAAC,QAAQ,CAAuC;gBAGrD,EAAE,EAAE,MAAM,EACV,KAAK,EAAE,MAAM,EACb,KAAK,EAAE,MAAM,EACb,YAAY,EAAE,YAAY,EAC1B,UAAU,SAAY,EACtB,UAAU,SAAY;IAcxB;;OAEG;IACG,EAAE,IAAI,OAAO,CAAC,IAAI,CAAC;IAUzB;;OAEG;IACG,IAAI,IAAI,OAAO,CAAC,IAAI,CAAC;IAU3B;;OAEG;IACG,QAAQ,CAAC,MAAM,EAAE,MAAM,GAAG,OAAO,CAAC,IAAI,CAAC;IAwB7C;;OAEG;IACG,QAAQ,CAAC,MAAM,EAAE,MAAM,GAAG,OAAO,CAAC,IAAI,CAAC;IAwB7C;;OAEG;IACG,KAAK,IAAI,OAAO,CAAC,MAAM,CAAC;IAc9B;;OAEG;IACG,KAAK,IAAI,OAAO,CAAC,MAAM,CAAC;IAc9B;;OAEG;IACG,eAAe,CAAC,KAAK,EAAE,CAAC,GAAG,CAAC,EAAE,SAAS,EAAE,MAAM,GAAG,OAAO,CAAC,IAAI,CAAC;IAmBrE;;OAEG;IACH,OAAO,CAAC,WAAW;IAQnB;;OAEG;IACH,QAAQ,IAAI,MAAM;IAUlB;;OAEG;IACH,YAAY,CAAC,IAAI,EAAE,MAAM,GAAG,gBAAgB,GAAG,IAAI;IAMnD;;OAEG;IACH,OAAO,CAAC,IAAI,EAAE,MAAM,GAAG,gBAAgB,GAAG,IAAI;CAK/C"}

package/dist/substrate/lifo/kernel/network/tunnel/VETHPair.js

@@ -0,0 +1,191 @@
+import { NetworkInterface } from '../NetworkInterface.js';
+/**
+ * VETH Pair - Virtual Ethernet Device Pair
+ *
+ * Creates two virtual network interfaces that are directly connected.
+ * Packets sent to one end appear immediately on the other end.
+ * Like a virtual Ethernet cable connecting two namespaces.
+ *
+ * Example:
+ *   ip link add veth0 type veth peer name veth1
+ *   ip link set veth1 netns container1
+ */
+export class VETHPair {
+    id;
+    veth0;
+    veth1;
+    state = 'down';
+    networkStack;
+    // Packet queues for each end
+    queue0 = [];
+    queue1 = [];
+    waiters0 = [];
+    waiters1 = [];
+    constructor(id, name0, name1, networkStack, namespace0 = 'default', namespace1 = 'default') {
+        this.id = id;
+        this.networkStack = networkStack;
+        // Create the two peer interfaces
+        this.veth0 = new NetworkInterface(name0, 'ethernet', namespace0);
+        this.veth1 = new NetworkInterface(name1, 'ethernet', namespace1);
+        // Generate unique MAC addresses for each end
+        this.veth0.mac = this.generateMAC(0);
+        this.veth1.mac = this.generateMAC(1);
+    }
+    /**
+     * Bring both interfaces up
+     */
+    async up() {
+        if (this.state === 'up') {
+            return;
+        }
+        this.veth0.up();
+        this.veth1.up();
+        this.state = 'up';
+    }
+    /**
+     * Bring both interfaces down
+     */
+    async down() {
+        if (this.state === 'down') {
+            return;
+        }
+        this.veth0.down();
+        this.veth1.down();
+        this.state = 'down';
+    }
+    /**
+     * Send packet from veth0 to veth1
+     */
+    async send0to1(packet) {
+        if (this.state === 'down' || this.veth1.state === 'down') {
+            throw new Error('VETH peer is down');
+        }
+        // Update TX stats on veth0
+        const stats0 = this.veth0.getStats();
+        stats0.txPackets++;
+        stats0.txBytes += packet.data.length;
+        // Update RX stats on veth1
+        const stats1 = this.veth1.getStats();
+        stats1.rxPackets++;
+        stats1.rxBytes += packet.data.length;
+        // Deliver to veth1
+        if (this.waiters1.length > 0) {
+            const waiter = this.waiters1.shift();
+            waiter(packet);
+        }
+        else {
+            this.queue1.push(packet);
+        }
+    }
+    /**
+     * Send packet from veth1 to veth0
+     */
+    async send1to0(packet) {
+        if (this.state === 'down' || this.veth0.state === 'down') {
+            throw new Error('VETH peer is down');
+        }
+        // Update TX stats on veth1
+        const stats1 = this.veth1.getStats();
+        stats1.txPackets++;
+        stats1.txBytes += packet.data.length;
+        // Update RX stats on veth0
+        const stats0 = this.veth0.getStats();
+        stats0.rxPackets++;
+        stats0.rxBytes += packet.data.length;
+        // Deliver to veth0
+        if (this.waiters0.length > 0) {
+            const waiter = this.waiters0.shift();
+            waiter(packet);
+        }
+        else {
+            this.queue0.push(packet);
+        }
+    }
+    /**
+     * Receive packet on veth0 (sent from veth1)
+     */
+    async recv0() {
+        if (this.state === 'down') {
+            throw new Error('VETH pair is down');
+        }
+        if (this.queue0.length > 0) {
+            return this.queue0.shift();
+        }
+        return new Promise((resolve) => {
+            this.waiters0.push(resolve);
+        });
+    }
+    /**
+     * Receive packet on veth1 (sent from veth0)
+     */
+    async recv1() {
+        if (this.state === 'down') {
+            throw new Error('VETH pair is down');
+        }
+        if (this.queue1.length > 0) {
+            return this.queue1.shift();
+        }
+        return new Promise((resolve) => {
+            this.waiters1.push(resolve);
+        });
+    }
+    /**
+     * Move one end of the VETH pair to a different namespace
+     */
+    async moveToNamespace(which, namespace) {
+        const iface = which === 0 ? this.veth0 : this.veth1;
+        // Remove from old namespace
+        const oldNs = this.networkStack.getNamespace(iface.namespace);
+        if (oldNs) {
+            oldNs.removeInterface(iface.name);
+        }
+        // Update namespace
+        iface.namespace = namespace;
+        // Add to new namespace
+        const newNs = this.networkStack.getNamespace(namespace);
+        if (newNs) {
+            newNs.addInterface(iface);
+        }
+    }
+    /**
+     * Generate MAC address for VETH interface
+     */
+    generateMAC(index) {
+        // Use local-admin bit (02:) to indicate virtual interface
+        const prefix = '02:00:00:00';
+        const idHex = this.id.padStart(4, '0').slice(0, 4);
+        const suffix = index === 0 ? '00' : '01';
+        return `${prefix}:${idHex.slice(0, 2)}:${suffix}`;
+    }
+    /**
+     * Get VETH pair status string
+     */
+    toString() {
+        const name0 = this.veth0.name.padEnd(10);
+        const name1 = this.veth1.name.padEnd(10);
+        const state = this.state.toUpperCase();
+        const ns0 = `ns=${this.veth0.namespace}`;
+        const ns1 = `ns=${this.veth1.namespace}`;
+        return `${name0} <-> ${name1} [${state}] ${ns0} <-> ${ns1}`;
+    }
+    /**
+     * Get interface by name
+     */
+    getInterface(name) {
+        if (this.veth0.name === name)
+            return this.veth0;
+        if (this.veth1.name === name)
+            return this.veth1;
+        return null;
+    }
+    /**
+     * Get peer interface
+     */
+    getPeer(name) {
+        if (this.veth0.name === name)
+            return this.veth1;
+        if (this.veth1.name === name)
+            return this.veth0;
+        return null;
+    }
+}

package/dist/substrate/lifo/kernel/network/tunnel/WebSocketTunnel.d.ts

@@ -0,0 +1,89 @@
+import type { Packet } from '../types.js';
+import type { NetworkStack } from '../NetworkStack.js';
+import { BaseTunnel } from './BaseTunnel.js';
+/**
+ * WebSocket Tunnel - Bridge virtual network to external WebSocket server
+ *
+ * This tunnel connects Lifo's virtual network stack to an external WebSocket
+ * tunnel server, enabling host machine access to virtual servers.
+ *
+ * Example:
+ *   tunnel --server=ws://localhost:3005
+ *
+ * Access from host:
+ *   http://localhost:3005/3000/ → Port 3000 in virtual network
+ */
+export declare class WebSocketTunnel extends BaseTunnel {
+    type: 'ssh';
+    private wsUrl;
+    private ws;
+    private portRegistry?;
+    private defaultPort;
+    private reconnectTimer?;
+    private isReconnecting;
+    private packetQueue;
+    private waitingResolvers;
+    constructor(id: string, wsUrl: string, networkStack: NetworkStack, portRegistry?: Map<number, any>, namespace?: string, defaultPort?: number | null);
+    protected getTunnelPrefix(): string;
+    /**
+     * Bring tunnel up - connect to WebSocket server
+     */
+    up(): Promise<void>;
+    /**
+     * Bring tunnel down - disconnect from WebSocket server
+     */
+    down(): Promise<void>;
+    /**
+     * Send packet through WebSocket tunnel
+     */
+    send(packet: Packet): Promise<void>;
+    /**
+     * Receive packet from WebSocket tunnel
+     */
+    recv(): Promise<Packet>;
+    /**
+     * Connect to WebSocket server
+     */
+    private connect;
+    /**
+     * Schedule reconnection attempt
+     */
+    private scheduleReconnect;
+    /**
+     * Handle incoming WebSocket message
+     */
+    private handleMessage;
+    /**
+     * Handle HTTP request from tunnel server
+     */
+    private handleHttpRequest;
+    /**
+     * Handle HTTP response (for client-side requests)
+     */
+    private handleHttpResponse;
+    /**
+     * Send HTTP response through WebSocket
+     */
+    private sendResponse;
+    /**
+     * Send error response through WebSocket
+     */
+    private sendError;
+    /**
+     * Serialize packet to bytes
+     */
+    private serializePacket;
+    /**
+     * Get tunnel status string
+     */
+    toString(): string;
+    /**
+     * Get connection status
+     */
+    isConnected(): boolean;
+    /**
+     * Get active ports
+     */
+    getActivePorts(): number[];
+}
+//# sourceMappingURL=WebSocketTunnel.d.ts.map

package/dist/substrate/lifo/kernel/network/tunnel/WebSocketTunnel.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"WebSocketTunnel.d.ts","sourceRoot":"","sources":["../../../../../../src/substrate/lifo/kernel/network/tunnel/WebSocketTunnel.ts"],"names":[],"mappings":"AAAA,OAAO,KAAK,EAAE,MAAM,EAAE,MAAM,aAAa,CAAC;AAC1C,OAAO,KAAK,EAAE,YAAY,EAAE,MAAM,oBAAoB,CAAC;AACvD,OAAO,EAAE,UAAU,EAAE,MAAM,iBAAiB,CAAC;AAI7C;;;;;;;;;;;GAWG;AACH,qBAAa,eAAgB,SAAQ,UAAU;IAC9C,IAAI,EAAE,KAAK,CAAS;IAEpB,OAAO,CAAC,KAAK,CAAS;IACtB,OAAO,CAAC,EAAE,CAA0B;IACpC,OAAO,CAAC,YAAY,CAAC,CAAmB;IACxC,OAAO,CAAC,WAAW,CAAuB;IAC1C,OAAO,CAAC,cAAc,CAAC,CAAM;IAC7B,OAAO,CAAC,cAAc,CAAS;IAG/B,OAAO,CAAC,WAAW,CAAgB;IACnC,OAAO,CAAC,gBAAgB,CAAuC;gBAG9D,EAAE,EAAE,MAAM,EACV,KAAK,EAAE,MAAM,EACb,YAAY,EAAE,YAAY,EAC1B,YAAY,CAAC,EAAE,GAAG,CAAC,MAAM,EAAE,GAAG,CAAC,EAC/B,SAAS,SAAY,EACrB,WAAW,GAAE,MAAM,GAAG,IAAW;IAgBlC,SAAS,CAAC,eAAe,IAAI,MAAM;IAInC;;OAEG;IACY,EAAE,IAAI,OAAO,CAAC,IAAI,CAAC;IAUlC;;OAEG;IACY,IAAI,IAAI,OAAO,CAAC,IAAI,CAAC;IAqBpC;;OAEG;IACG,IAAI,CAAC,MAAM,EAAE,MAAM,GAAG,OAAO,CAAC,IAAI,CAAC;IAoBzC;;OAEG;IACG,IAAI,IAAI,OAAO,CAAC,MAAM,CAAC;IAc7B;;OAEG;YACW,OAAO;IA4CrB;;OAEG;IACH,OAAO,CAAC,iBAAiB;IAezB;;OAEG;IACH,OAAO,CAAC,aAAa;IAgBrB;;OAEG;YACW,iBAAiB;IA2E/B;;OAEG;IACH,OAAO,CAAC,kBAAkB;IAK1B;;OAEG;IACH,OAAO,CAAC,YAAY;IAgBpB;;OAEG;IACH,OAAO,CAAC,SAAS;IAgBjB;;OAEG;IACH,OAAO,CAAC,eAAe;IAgBvB;;OAEG;IACM,QAAQ,IAAI,MAAM;IAQ3B;;OAEG;IACH,WAAW,IAAI,OAAO;IAItB;;OAEG;IACH,cAAc,IAAI,MAAM,EAAE;CAG1B"}

package/dist/substrate/lifo/kernel/network/tunnel/WebSocketTunnel.js

@@ -0,0 +1,324 @@
+import { BaseTunnel } from './BaseTunnel.js';
+import { Buffer } from '../../../node-compat/buffer.js';
+/**
+ * WebSocket Tunnel - Bridge virtual network to external WebSocket server
+ *
+ * This tunnel connects Lifo's virtual network stack to an external WebSocket
+ * tunnel server, enabling host machine access to virtual servers.
+ *
+ * Example:
+ *   tunnel --server=ws://localhost:3005
+ *
+ * Access from host:
+ *   http://localhost:3005/3000/ → Port 3000 in virtual network
+ */
+export class WebSocketTunnel extends BaseTunnel {
+    type = 'ssh'; // Using 'ssh' type for compatibility
+    wsUrl;
+    ws = null;
+    portRegistry;
+    defaultPort = null;
+    reconnectTimer;
+    isReconnecting = false;
+    // Packet queue
+    packetQueue = [];
+    waitingResolvers = [];
+    constructor(id, wsUrl, networkStack, portRegistry, namespace = 'default', defaultPort = null) {
+        super(id, networkStack, namespace, 1400); // WebSocket overhead
+        this.wsUrl = wsUrl;
+        this.portRegistry = portRegistry;
+        this.defaultPort = defaultPort;
+        this.config = {
+            mode: 'websocket',
+            server: wsUrl,
+            ports: portRegistry ? Array.from(portRegistry.keys()) : [],
+            defaultPort: defaultPort ?? undefined,
+        };
+    }
+    getTunnelPrefix() {
+        return 'wst';
+    }
+    /**
+     * Bring tunnel up - connect to WebSocket server
+     */
+    async up() {
+        if (this.state === 'up') {
+            return;
+        }
+        await this.connect();
+        this.state = 'up';
+        this.interface.up();
+    }
+    /**
+     * Bring tunnel down - disconnect from WebSocket server
+     */
+    async down() {
+        if (this.state === 'down') {
+            return;
+        }
+        this.isReconnecting = false;
+        if (this.reconnectTimer) {
+            clearTimeout(this.reconnectTimer);
+            this.reconnectTimer = undefined;
+        }
+        if (this.ws) {
+            this.ws.close();
+            this.ws = null;
+        }
+        this.state = 'down';
+        this.interface.down();
+    }
+    /**
+     * Send packet through WebSocket tunnel
+     */
+    async send(packet) {
+        if (this.state === 'down' || !this.ws || this.ws.readyState !== WebSocket.OPEN) {
+            throw new Error('WebSocket tunnel is not connected');
+        }
+        try {
+            // Serialize packet
+            const data = this.serializePacket(packet);
+            // Send through WebSocket
+            this.ws.send(data);
+            // Update stats
+            this.updateStats(data.byteLength, 'tx');
+        }
+        catch (error) {
+            this.updateStats(0, 'tx', true);
+            throw error;
+        }
+    }
+    /**
+     * Receive packet from WebSocket tunnel
+     */
+    async recv() {
+        if (this.state === 'down') {
+            throw new Error('WebSocket tunnel is down');
+        }
+        if (this.packetQueue.length > 0) {
+            return this.packetQueue.shift();
+        }
+        return new Promise((resolve) => {
+            this.waitingResolvers.push(resolve);
+        });
+    }
+    /**
+     * Connect to WebSocket server
+     */
+    async connect() {
+        return new Promise((resolve, reject) => {
+            try {
+                // Get WebSocket constructor
+                let WebSocketConstructor;
+                if (typeof globalThis.WebSocket !== 'undefined') {
+                    WebSocketConstructor = globalThis.WebSocket;
+                }
+                else {
+                    // Node.js - would need to import ws package
+                    reject(new Error('WebSocket not available'));
+                    return;
+                }
+                this.ws = new WebSocketConstructor(this.wsUrl);
+                this.ws.addEventListener('open', () => {
+                    this.isReconnecting = false;
+                    resolve();
+                });
+                this.ws.addEventListener('message', (event) => {
+                    this.handleMessage(event.data);
+                });
+                this.ws.addEventListener('close', () => {
+                    if (this.state === 'up' && !this.isReconnecting) {
+                        this.scheduleReconnect();
+                    }
+                });
+                this.ws.addEventListener('error', (error) => {
+                    console.error('WebSocket tunnel error:', error);
+                    if (this.state === 'down') {
+                        reject(error);
+                    }
+                });
+            }
+            catch (error) {
+                reject(error);
+            }
+        });
+    }
+    /**
+     * Schedule reconnection attempt
+     */
+    scheduleReconnect() {
+        if (this.isReconnecting)
+            return;
+        this.isReconnecting = true;
+        this.reconnectTimer = setTimeout(async () => {
+            if (this.state === 'up') {
+                try {
+                    await this.connect();
+                }
+                catch (error) {
+                    this.scheduleReconnect();
+                }
+            }
+        }, 5000);
+    }
+    /**
+     * Handle incoming WebSocket message
+     */
+    handleMessage(data) {
+        try {
+            const message = JSON.parse(data.toString());
+            if (message.type === 'request') {
+                // Handle HTTP request from tunnel server
+                this.handleHttpRequest(message);
+            }
+            else if (message.type === 'response') {
+                // Handle response (if we're acting as client)
+                this.handleHttpResponse(message);
+            }
+        }
+        catch (error) {
+            console.error('Error handling WebSocket message:', error);
+        }
+    }
+    /**
+     * Handle HTTP request from tunnel server
+     */
+    async handleHttpRequest(message) {
+        const { requestId, method, url, headers, body } = message;
+        let port;
+        let path;
+        if (this.defaultPort) {
+            // Default port mode: all requests go to the default port
+            port = this.defaultPort;
+            path = url || '/';
+        }
+        else {
+            // Path-based routing: /PORT/path
+            const match = url.match(/^\/(\d+)(\/.*)?$/);
+            if (!match) {
+                this.sendError(requestId, 400, 'Invalid URL format. Use /PORT/path or configure default port');
+                return;
+            }
+            port = parseInt(match[1], 10);
+            path = match[2] || '/';
+        }
+        // Check if port exists in registry
+        if (!this.portRegistry || !this.portRegistry.has(port)) {
+            this.sendError(requestId, 404, `No server listening on port ${port}`);
+            return;
+        }
+        // Get handler
+        const handler = this.portRegistry.get(port);
+        // Create virtual request/response
+        const vReq = {
+            method,
+            url: path,
+            headers,
+            body: Buffer.from(body || '', 'base64').toString(),
+        };
+        const vRes = {
+            statusCode: 200,
+            headers: {},
+            body: '',
+        };
+        try {
+            // Call handler
+            handler(vReq, vRes);
+            // Wait for async middleware to call res.end() (populates vRes)
+            // Add a 25s safety timeout so we respond before external timeout
+            if (vRes._donePromise) {
+                const timeout = new Promise((resolve) => setTimeout(() => resolve('timeout'), 25000));
+                const result = await Promise.race([vRes._donePromise.then(() => 'done'), timeout]);
+                if (result === 'timeout') {
+                    console.error(`[WebSocketTunnel] TIMEOUT waiting for response: ${method} ${path}`);
+                    this.sendError(requestId, 504, `Gateway timeout: server did not respond for ${path}`);
+                    return;
+                }
+            }
+            // Send response back through WebSocket
+            this.sendResponse(requestId, vRes.statusCode, vRes.headers, vRes.body);
+            // Update stats
+            this.updateStats(vRes.body.length, 'tx');
+        }
+        catch (error) {
+            const errorMessage = error instanceof Error ? error.message : String(error);
+            this.sendError(requestId, 500, `Internal server error: ${errorMessage}`);
+        }
+    }
+    /**
+     * Handle HTTP response (for client-side requests)
+     */
+    handleHttpResponse(_message) {
+        // For future client-side request support
+        // Not needed for current server-only implementation
+    }
+    /**
+     * Send HTTP response through WebSocket
+     */
+    sendResponse(requestId, statusCode, headers, body) {
+        if (!this.ws || this.ws.readyState !== WebSocket.OPEN) {
+            return;
+        }
+        const response = {
+            type: 'response',
+            requestId,
+            statusCode,
+            headers,
+            body: Buffer.from(body).toString('base64'),
+        };
+        this.ws.send(JSON.stringify(response));
+    }
+    /**
+     * Send error response through WebSocket
+     */
+    sendError(requestId, statusCode, message) {
+        if (!this.ws || this.ws.readyState !== WebSocket.OPEN) {
+            return;
+        }
+        const response = {
+            type: 'response',
+            requestId,
+            statusCode,
+            headers: { 'Content-Type': 'text/plain' },
+            body: Buffer.from(message).toString('base64'),
+        };
+        this.ws.send(JSON.stringify(response));
+    }
+    /**
+     * Serialize packet to bytes
+     */
+    serializePacket(packet) {
+        const header = new Uint8Array(9);
+        const view = new DataView(header.buffer);
+        view.setUint16(0, packet.source.port);
+        view.setUint16(2, packet.destination.port);
+        view.setUint8(4, packet.protocol === 'tcp' ? 6 : 17);
+        view.setUint32(5, packet.data.length);
+        const combined = new Uint8Array(header.length + packet.data.length);
+        combined.set(header);
+        combined.set(packet.data, header.length);
+        return combined.buffer;
+    }
+    /**
+     * Get tunnel status string
+     */
+    toString() {
+        const base = super.toString();
+        const server = this.wsUrl;
+        const connected = this.ws && this.ws.readyState === WebSocket.OPEN ? '✓' : '✗';
+        const ports = this.portRegistry ? Array.from(this.portRegistry.keys()).join(',') : 'none';
+        return `${base} ${server} [${connected}] ports=${ports}`;
+    }
+    /**
+     * Get connection status
+     */
+    isConnected() {
+        return this.ws !== null && this.ws.readyState === WebSocket.OPEN;
+    }
+    /**
+     * Get active ports
+     */
+    getActivePorts() {
+        return this.portRegistry ? Array.from(this.portRegistry.keys()).sort((a, b) => a - b) : [];
+    }
+}