appium-ios-remotexpc 0.0.1

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

@@ -0,0 +1,185 @@
+import { logger } from '@appium/support';
+import { EventEmitter } from 'events';
+import { type Socket, createConnection } from 'net';
+import type { PacketConsumer, PacketData } from 'tuntap-bridge';
+
+const log = logger.getLogger('PacketStreamClient');
+
+/**
+ * Constants for packet stream protocol
+ */
+const PACKET_LENGTH_PREFIX_SIZE = 10;
+
+/**
+ * Client that connects to a PacketStreamServer to receive packet data
+ * Implements the PacketSource interface required by SyslogService
+ */
+export class PacketStreamClient extends EventEmitter {
+  private socket: Socket | null = null;
+  private readonly packetConsumers: Set<PacketConsumer> = new Set();
+  private buffer: Buffer = Buffer.alloc(0);
+  private connected = false;
+
+  constructor(
+    private readonly host: string,
+    private readonly port: number,
+  ) {
+    super();
+  }
+
+  async connect(): Promise<void> {
+    if (this.connected) {
+      log.info('Already connected');
+      return;
+    }
+
+    return new Promise((resolve, reject) => {
+      this.socket = createConnection(
+        { host: this.host, port: this.port },
+        () => {
+          log.info(
+            `Connected to packet stream server at ${this.host}:${this.port}`,
+          );
+          this.connected = true;
+          resolve();
+        },
+      );
+
+      this.socket.on('data', (data) => {
+        this.handleData(data);
+      });
+
+      this.socket.once('close', () => {
+        log.info('Disconnected from packet stream server');
+        this.connected = false;
+        this.emit('close');
+      });
+
+      this.socket.on('error', (err) => {
+        log.error(`Socket error: ${err}`);
+        this.connected = false;
+        if (!this.socket) {
+          reject(err);
+        } else {
+          this.emit('error', err);
+        }
+      });
+    });
+  }
+
+  isConnected(): boolean {
+    return this.connected;
+  }
+
+  async disconnect(): Promise<void> {
+    if (this.socket && !this.socket.destroyed) {
+      this.socket.destroy();
+      this.socket = null;
+    }
+    this.connected = false;
+    this.packetConsumers.clear();
+  }
+
+  addPacketConsumer(consumer: PacketConsumer): void {
+    this.packetConsumers.add(consumer);
+  }
+
+  removePacketConsumer(consumer: PacketConsumer): void {
+    this.packetConsumers.delete(consumer);
+  }
+
+  /**
+   * Handle incoming data from the socket
+   */
+  private handleData(data: Buffer): void {
+    this.buffer = Buffer.concat([this.buffer, data]);
+    this.processBuffer();
+  }
+
+  /**
+   * Process buffered data to extract complete messages
+   */
+  private processBuffer(): void {
+    while (this.buffer.length >= PACKET_LENGTH_PREFIX_SIZE) {
+      const messageLength = this.extractMessageLength();
+
+      if (messageLength === null) {
+        // Invalid length, reset buffer
+        this.buffer = Buffer.alloc(0);
+        break;
+      }
+
+      const totalMessageSize = PACKET_LENGTH_PREFIX_SIZE + messageLength;
+
+      if (this.buffer.length < totalMessageSize) {
+        // Wait for more data
+        break;
+      }
+
+      const messageData = this.buffer.slice(
+        PACKET_LENGTH_PREFIX_SIZE,
+        totalMessageSize,
+      );
+      this.buffer = this.buffer.slice(totalMessageSize);
+
+      this.processMessage(messageData);
+    }
+  }
+
+  /**
+   * Extract message length from buffer
+   * @returns Message length or null if invalid
+   */
+  private extractMessageLength(): number | null {
+    const lengthStr = this.buffer
+      .slice(0, PACKET_LENGTH_PREFIX_SIZE)
+      .toString();
+    const messageLength = parseInt(lengthStr, 10);
+
+    if (isNaN(messageLength)) {
+      log.error('Invalid message length, clearing buffer');
+      return null;
+    }
+
+    return messageLength;
+  }
+
+  /**
+   * Process a single message
+   */
+  private processMessage(messageData: Buffer): void {
+    try {
+      const packet = this.parsePacket(messageData);
+      this.notifyConsumers(packet);
+    } catch (err) {
+      log.error(`Error processing message: ${err}`);
+    }
+  }
+
+  /**
+   * Parse packet data from message buffer
+   */
+  private parsePacket(messageData: Buffer): PacketData {
+    const packet: PacketData = JSON.parse(messageData.toString());
+
+    // Reconstruct Buffer from JSON
+    if (packet.payload && typeof packet.payload === 'object') {
+      packet.payload = Buffer.from(packet.payload);
+    }
+
+    return packet;
+  }
+
+  /**
+   * Notify all packet consumers
+   */
+  private notifyConsumers(packet: PacketData): void {
+    for (const consumer of this.packetConsumers) {
+      try {
+        consumer.onPacket(packet);
+      } catch (err) {
+        log.error(`Error in packet consumer: ${err}`);
+      }
+    }
+  }
+}

package/src/lib/tunnel/packet-stream-server.ts

@@ -0,0 +1,133 @@
+import { logger } from '@appium/support';
+import { EventEmitter } from 'events';
+import { type Server, type Socket, createServer } from 'net';
+import type { PacketConsumer, PacketData } from 'tuntap-bridge';
+
+const log = logger.getLogger('PacketStreamServer');
+
+/**
+ * Interface for serialized packet message
+ */
+interface SerializedPacketMessage {
+  length: string;
+  data: string;
+}
+
+/**
+ * Server that exposes packet streaming from a tunnel over TCP
+ * This allows cross-process access to tunnel packet streams
+ */
+export class PacketStreamServer extends EventEmitter {
+  private server: Server | null = null;
+  private readonly clients: Set<Socket> = new Set();
+  private packetConsumer: PacketConsumer | null = null;
+
+  constructor(private readonly port: number) {
+    super();
+  }
+
+  /**
+   * Start the packet stream server
+   * @throws {Error} If server is already started
+   */
+  async start(): Promise<void> {
+    if (this.server) {
+      throw new Error('Server already started');
+    }
+
+    this.server = createServer((client) => {
+      this.handleClientConnection(client);
+    });
+
+    this.packetConsumer = this.createPacketConsumer();
+
+    return new Promise((resolve, reject) => {
+      this.server!.listen(this.port, () => {
+        log.info(`Packet stream server listening on port ${this.port}`);
+        resolve();
+      });
+
+      this.server!.on('error', reject);
+    });
+  }
+
+  async stop(): Promise<void> {
+    for (const client of this.clients) {
+      client.destroy();
+    }
+    this.clients.clear();
+
+    if (this.server) {
+      return new Promise((resolve) => {
+        this.server?.close(() => {
+          this.server = null;
+          resolve();
+        });
+      });
+    }
+  }
+
+  getPacketConsumer(): PacketConsumer | null {
+    return this.packetConsumer;
+  }
+
+  /**
+   * Handle new client connection
+   */
+  private handleClientConnection(client: Socket): void {
+    log.info(`Client connected from ${client.remoteAddress}`);
+    this.clients.add(client);
+
+    client.on('close', () => {
+      log.info(`Client disconnected from ${client.remoteAddress}`);
+      this.clients.delete(client);
+    });
+
+    client.on('error', (err) => {
+      log.error(`Client error: ${err}`);
+      this.clients.delete(client);
+    });
+  }
+
+  /**
+   * Create packet consumer that broadcasts packets to all connected clients
+   */
+  private createPacketConsumer(): PacketConsumer {
+    return {
+      onPacket: (packet: PacketData) => {
+        this.broadcastPacket(packet);
+      },
+    };
+  }
+
+  /**
+   * Broadcast packet to all connected clients
+   */
+  private broadcastPacket(packet: PacketData): void {
+    try {
+      const serialized = JSON.stringify(packet);
+      const message = this.createMessage(serialized);
+
+      for (const client of this.clients) {
+        if (!client.destroyed) {
+          client.write(message, (err) => {
+            if (err) {
+              log.error(`Failed to write to client: ${err}`);
+              this.clients.delete(client);
+            }
+          });
+        }
+      }
+    } catch (err) {
+      log.error(`Failed to broadcast packet: ${err}`);
+    }
+  }
+
+  /**
+   * Create a message buffer with length prefix
+   */
+  private createMessage(data: string): Buffer {
+    const lengthPrefix = data.length.toString().padStart(10, '0');
+    return Buffer.concat([Buffer.from(lengthPrefix), Buffer.from(data)]);
+  }
+}

package/src/lib/tunnel/tunnel-api-client.ts

@@ -0,0 +1,234 @@
+import { logger } from '@appium/support';
+
+import type { TunnelRegistry, TunnelRegistryEntry } from '../types.js';
+
+const log = logger.getLogger('TunnelApiClient');
+
+/**
+ * API client for tunnel registry operations
+ * This client handles communication with the API server for tunnel data
+ */
+export class TunnelApiClient {
+  private apiBaseUrl: string;
+
+  /**
+   * Create a new TunnelApiClient
+   * @param apiBaseUrl - Base URL for the API server
+   */
+  constructor(apiBaseUrl: string = 'http://localhost:42314/remotexpc/tunnels') {
+    this.apiBaseUrl = apiBaseUrl;
+  }
+
+  /**
+   * Set the API base URL
+   * @param url - New base URL for the API server
+   */
+  setApiBaseUrl(url: string): void {
+    this.apiBaseUrl = url;
+  }
+
+  /**
+   * Get the API base URL
+   * @returns The current API base URL
+   */
+  getApiBaseUrl(): string {
+    return this.apiBaseUrl;
+  }
+
+  /**
+   * Fetch all tunnel registry data from the API server
+   * @returns The complete tunnel registry
+   */
+  async fetchRegistry(): Promise<TunnelRegistry> {
+    try {
+      const response = await fetch(this.apiBaseUrl);
+
+      if (!response.ok) {
+        throw new Error(`API request failed with status: ${response.status}`);
+      }
+
+      return (await response.json()) as TunnelRegistry;
+    } catch (error) {
+      log.warn(`Failed to fetch tunnel registry from API: ${error}`);
+      // Return empty registry as fallback
+      return {
+        tunnels: {},
+        metadata: {
+          lastUpdated: new Date().toISOString(),
+          totalTunnels: 0,
+          activeTunnels: 0,
+        },
+      };
+    }
+  }
+
+  /**
+   * Get a specific tunnel by UDID
+   * @param udid - Device UDID
+   * @returns Tunnel registry entry or null if not found
+   */
+  async getTunnelByUdid(udid: string): Promise<TunnelRegistryEntry | null> {
+    try {
+      const response = await fetch(`${this.apiBaseUrl}/${udid}`);
+
+      if (response.status === 404) {
+        return null;
+      }
+
+      if (!response.ok) {
+        throw new Error(`API request failed with status: ${response.status}`);
+      }
+
+      return (await response.json()) as TunnelRegistryEntry;
+    } catch (error) {
+      log.warn(`Failed to fetch tunnel for UDID ${udid}: ${error}`);
+      return null;
+    }
+  }
+
+  /**
+   * Get tunnel by device ID
+   * @param deviceId - Device ID
+   * @returns Tunnel registry entry or null if not found
+   */
+  async getTunnelByDeviceId(
+    deviceId: number,
+  ): Promise<TunnelRegistryEntry | null> {
+    try {
+      const response = await fetch(`${this.apiBaseUrl}/device/${deviceId}`);
+
+      if (response.status === 404) {
+        return null;
+      }
+
+      if (!response.ok) {
+        throw new Error(`API request failed with status: ${response.status}`);
+      }
+
+      return (await response.json()) as TunnelRegistryEntry;
+    } catch (error) {
+      log.warn(`Failed to fetch tunnel for device ID ${deviceId}: ${error}`);
+      return null;
+    }
+  }
+
+  /**
+   * Get all tunnels
+   * @returns Array of tunnel registry entries
+   */
+  async getAllTunnels(): Promise<TunnelRegistryEntry[]> {
+    try {
+      const registry = await this.fetchRegistry();
+      return Object.values(registry.tunnels);
+    } catch (error) {
+      log.warn(`Failed to fetch all tunnels: ${error}`);
+      return [];
+    }
+  }
+
+  /**
+   * Check if a tunnel exists for a specific UDID
+   * @param udid - Device UDID
+   * @returns True if tunnel exists, false otherwise
+   */
+  async hasTunnel(udid: string): Promise<boolean> {
+    const tunnel = await this.getTunnelByUdid(udid);
+    return tunnel !== null;
+  }
+
+  /**
+   * Get registry metadata
+   * @returns Registry metadata
+   */
+  async getMetadata(): Promise<TunnelRegistry['metadata']> {
+    try {
+      const registry = await this.fetchRegistry();
+      return registry.metadata;
+    } catch (error) {
+      log.warn(`Failed to fetch registry metadata: ${error}`);
+      return {
+        lastUpdated: new Date().toISOString(),
+        totalTunnels: 0,
+        activeTunnels: 0,
+      };
+    }
+  }
+
+  /**
+   * Get tunnel connection details formatted for easy use
+   * @param udid - Device UDID
+   * @returns Connection details or null if tunnel not found
+   */
+  async getTunnelConnection(udid: string): Promise<{
+    host: string;
+    port: number;
+    udid: string;
+    packetStreamPort: number;
+  } | null> {
+    const tunnel = await this.getTunnelByUdid(udid);
+    if (!tunnel) {
+      return null;
+    }
+
+    return {
+      host: tunnel.address,
+      port: tunnel.rsdPort,
+      udid: tunnel.udid,
+      packetStreamPort: tunnel.packetStreamPort,
+    };
+  }
+
+  /**
+   * List all available device UDIDs with tunnels
+   * @returns Array of device UDIDs
+   */
+  async getAvailableDevices(): Promise<string[]> {
+    try {
+      const registry = await this.fetchRegistry();
+      return Object.keys(registry.tunnels);
+    } catch (error) {
+      log.warn(`Failed to fetch available devices: ${error}`);
+      return [];
+    }
+  }
+
+  /**
+   * Update or create a tunnel entry
+   * @param entry - Tunnel registry entry to update or create
+   * @returns True if successful, false otherwise
+   */
+  async updateTunnel(entry: TunnelRegistryEntry): Promise<boolean> {
+    try {
+      const response = await fetch(`${this.apiBaseUrl}/${entry.udid}`, {
+        method: 'PUT',
+        headers: {
+          'Content-Type': 'application/json',
+        },
+        body: JSON.stringify(entry),
+      });
+
+      return response.ok;
+    } catch (error) {
+      log.error(`Failed to update tunnel for UDID ${entry.udid}: ${error}`);
+      return false;
+    }
+  }
+
+  /**
+   * Delete a tunnel entry
+   * @param udid - Device UDID
+   * @returns True if successful, false otherwise
+   */
+  async deleteTunnel(udid: string): Promise<boolean> {
+    try {
+      const response = await fetch(`${this.apiBaseUrl}/${udid}`, {
+        method: 'DELETE',
+      });
+
+      return response.ok;
+    } catch (error) {
+      log.error(`Failed to delete tunnel for UDID ${udid}: ${error}`);
+      return false;
+    }
+  }
+}