@limrun/ui 0.9.0-rc.5 → 0.9.0-rc.6

package/src/core/device-install/operations/relay-client.ts

@@ -0,0 +1,255 @@
+import type { DeviceHello, DeviceInstallLog, PairRecordPayload } from '../types';
+import { decodeFrame, decodeJson, encodeFrame, encodeJson, RelayMessageType } from './relay-protocol';
+import {
+  openStream,
+  receiveStreamData,
+  sendStreamData,
+  type UsbmuxSession,
+  type UsbmuxStream,
+} from './usbmux';
+
+type OpenStreamPayload = {
+  port: number;
+};
+
+type ProgressPayload = {
+  message: string;
+};
+
+export class RelayClient {
+  private socket?: WebSocket;
+  private streams = new Map<number, UsbmuxStream>();
+  private frameQueue = Promise.resolve();
+  private closed = false;
+  private pairRecordWaiter?: {
+    resolve: (record: PairRecordPayload) => void;
+    reject: (error: Error) => void;
+  };
+
+  constructor(
+    private readonly webSocketUrl: string,
+    private readonly session: UsbmuxSession,
+    private readonly deviceHello: DeviceHello,
+    private readonly log: DeviceInstallLog,
+  ) {}
+
+  async connect() {
+    const socket = new WebSocket(this.webSocketUrl);
+    socket.binaryType = 'arraybuffer';
+    this.socket = socket;
+    socket.onclose = () => {
+      this.closed = true;
+      this.log('Relay socket closed');
+      if (this.pairRecordWaiter) {
+        this.pairRecordWaiter.reject(new Error('Relay socket closed'));
+        this.pairRecordWaiter = undefined;
+      }
+    };
+    await new Promise<void>((resolve, reject) => {
+      socket.onopen = () => resolve();
+      socket.onerror = () => reject(new Error('WebSocket connection failed'));
+    });
+    socket.onmessage = (event) => {
+      const data = event.data instanceof ArrayBuffer ? new Uint8Array(event.data) : new Uint8Array();
+      this.enqueueFrame(data);
+    };
+    await this.send({
+      type: RelayMessageType.DeviceHello,
+      requestId: 0,
+      streamId: 0,
+      payload: encodeJson(this.deviceHello),
+    });
+    this.log('Connected WebSocket relay');
+  }
+
+  async startPairing() {
+    const recordPromise = new Promise<PairRecordPayload>((resolve, reject) => {
+      this.pairRecordWaiter = { resolve, reject };
+    });
+    await this.send({
+      type: RelayMessageType.StartPairing,
+      requestId: 0,
+      streamId: 0,
+      payload: encodeJson({}),
+    });
+    this.log('Pairing requested');
+    return recordPromise;
+  }
+
+  async startInstall(pairRecord: PairRecordPayload) {
+    await this.send({
+      type: RelayMessageType.StartInstall,
+      requestId: 0,
+      streamId: 0,
+      payload: encodeJson(pairRecord),
+    });
+    this.log('Installation requested');
+  }
+
+  close() {
+    this.closed = true;
+    this.socket?.close();
+  }
+
+  private enqueueFrame(data: Uint8Array) {
+    this.frameQueue = this.frameQueue.then(() => this.handleFrame(decodeFrame(data))).catch((error) => {
+      this.log('Relay frame handling failed', error instanceof Error ? error.message : String(error));
+    });
+  }
+
+  private async handleFrame(frame: ReturnType<typeof decodeFrame>) {
+    switch (frame.type) {
+      case RelayMessageType.OpenStream:
+        await this.handleOpenStream(
+          frame.requestId,
+          frame.streamId,
+          decodeJson<OpenStreamPayload>(frame.payload).port,
+        );
+        break;
+      case RelayMessageType.StreamData: {
+        const stream = this.streams.get(frame.streamId);
+        if (!stream) throw new Error(`Unknown stream ${frame.streamId}`);
+        await sendStreamData(stream, frame.payload);
+        break;
+      }
+      case RelayMessageType.StreamClose:
+        this.streams.delete(frame.streamId);
+        break;
+      case RelayMessageType.InstallProgress:
+        this.log(formatInstallProgress(decodeJson<ProgressPayload>(frame.payload).message));
+        break;
+      case RelayMessageType.Error:
+        this.handleError(frame.payload);
+        break;
+      case RelayMessageType.PairRecordReady:
+        this.handlePairRecordReady(decodeJson<PairRecordPayload>(frame.payload));
+        break;
+      case RelayMessageType.Ping:
+        await this.send({
+          type: RelayMessageType.Pong,
+          requestId: frame.requestId,
+          streamId: 0,
+          payload: new Uint8Array(),
+        });
+        break;
+    }
+  }
+
+  private handleError(payload: Uint8Array) {
+    const message = decodeServerError(payload);
+    this.log('Server error', message);
+    if (this.pairRecordWaiter) {
+      this.pairRecordWaiter.reject(new Error(message));
+      this.pairRecordWaiter = undefined;
+    }
+  }
+
+  private handlePairRecordReady(record: PairRecordPayload) {
+    this.log('Pair record received', record.udid);
+    this.pairRecordWaiter?.resolve(record);
+    this.pairRecordWaiter = undefined;
+  }
+
+  private async handleOpenStream(requestId: number, streamId: number, port: number) {
+    try {
+      const stream = await openStream(this.session, port);
+      this.streams.set(streamId, stream);
+      await this.send({
+        type: RelayMessageType.OpenResult,
+        requestId,
+        streamId,
+        payload: encodeJson({ ok: true }),
+      });
+      this.log(`Opened device stream ${streamId} to port ${port}`);
+      void this.pumpDeviceToServer(streamId, stream);
+    } catch (error) {
+      this.log(`Open device stream ${streamId} failed`, error instanceof Error ? error.message : String(error));
+      await this.send({
+        type: RelayMessageType.OpenResult,
+        requestId,
+        streamId,
+        payload: encodeJson({
+          ok: false,
+          error: error instanceof Error ? error.message : String(error),
+        }),
+      });
+    }
+  }
+
+  private async pumpDeviceToServer(streamId: number, stream: UsbmuxStream) {
+    try {
+      for (;;) {
+        const data = await receiveStreamData(stream);
+        if (this.closed) return;
+        await this.send({
+          type: RelayMessageType.StreamData,
+          requestId: 0,
+          streamId,
+          payload: data,
+        });
+      }
+    } catch (error) {
+      this.log(`Device stream ${streamId} closed`, error instanceof Error ? error.message : String(error));
+      await this.send({
+        type: RelayMessageType.StreamClose,
+        requestId: 0,
+        streamId,
+        payload: encodeJson({
+          reason: error instanceof Error ? error.message : String(error),
+        }),
+      });
+    }
+  }
+
+  private async send(frame: Parameters<typeof encodeFrame>[0]) {
+    if (this.closed) return;
+    if (!this.socket || this.socket.readyState !== WebSocket.OPEN) {
+      this.closed = true;
+      return;
+    }
+    this.socket.send(encodeFrame(frame));
+  }
+}
+
+function decodeServerError(payload: Uint8Array) {
+  const text = new TextDecoder().decode(payload);
+  try {
+    const parsed = JSON.parse(text) as { error?: string };
+    return userFacingServerError(parsed.error ?? text);
+  } catch {
+    return userFacingServerError(text);
+  }
+}
+
+function userFacingServerError(message: string) {
+  return message.replace(/libimobiledevice/g, '').trim();
+}
+
+function formatInstallProgress(message: string) {
+  const prefix = 'install status: ';
+  if (!message.startsWith(prefix)) {
+    return message;
+  }
+  const xml = message.slice(prefix.length);
+  const doc = new DOMParser().parseFromString(xml, 'application/xml');
+  const dict = doc.querySelector('plist > dict');
+  if (!dict) {
+    return message;
+  }
+  const values = readPlistDict(dict);
+  const status = values.Status ?? 'Unknown';
+  const percent = values.PercentComplete ? `${values.PercentComplete}% ` : '';
+  return `Install progress: ${percent}${status}`;
+}
+
+function readPlistDict(dict: Element) {
+  const result: Record<string, string> = {};
+  const children = Array.from(dict.children);
+  for (let index = 0; index < children.length; index += 2) {
+    const key = children[index];
+    const value = children[index + 1];
+    if (!key || key.tagName !== 'key' || !value) continue;
+    result[key.textContent ?? ''] = value.textContent ?? '';
+  }
+  return result;
+}

package/src/core/device-install/operations/relay-protocol.ts

@@ -0,0 +1,71 @@
+export const RELAY_PROTOCOL_VERSION = 1;
+export const RELAY_HEADER_BYTES = 16;
+
+export const RelayMessageType = {
+  DeviceHello: 1,
+  OpenStream: 2,
+  OpenResult: 3,
+  StreamData: 4,
+  StreamClose: 5,
+  InstallProgress: 6,
+  Error: 7,
+  Ping: 8,
+  Pong: 9,
+  StartPairing: 10,
+  StartInstall: 11,
+  PairRecordReady: 12,
+} as const;
+
+export type RelayMessageType = (typeof RelayMessageType)[keyof typeof RelayMessageType];
+
+export type RelayFrame = {
+  type: RelayMessageType;
+  requestId: number;
+  streamId: number;
+  payload: Uint8Array;
+};
+
+export function encodeFrame(frame: RelayFrame) {
+  const result = new Uint8Array(RELAY_HEADER_BYTES + frame.payload.byteLength);
+  const view = new DataView(result.buffer);
+  view.setUint8(0, RELAY_PROTOCOL_VERSION);
+  view.setUint8(1, frame.type);
+  view.setUint8(2, 0);
+  view.setUint8(3, 0);
+  view.setUint32(4, frame.requestId);
+  view.setUint32(8, frame.streamId);
+  view.setUint32(12, frame.payload.byteLength);
+  result.set(frame.payload, RELAY_HEADER_BYTES);
+  return result;
+}
+
+export function decodeFrame(data: Uint8Array): RelayFrame {
+  if (data.byteLength < RELAY_HEADER_BYTES) {
+    throw new Error(`Relay frame too short: ${data.byteLength}`);
+  }
+  const view = new DataView(data.buffer, data.byteOffset, data.byteLength);
+  const version = view.getUint8(0);
+  if (version !== RELAY_PROTOCOL_VERSION) {
+    throw new Error(`Unsupported relay protocol version ${version}`);
+  }
+  const payloadLength = view.getUint32(12);
+  if (data.byteLength !== RELAY_HEADER_BYTES + payloadLength) {
+    throw new Error(
+      `Relay frame length mismatch: got ${data.byteLength}, expected ${RELAY_HEADER_BYTES + payloadLength}`,
+    );
+  }
+  return {
+    type: view.getUint8(1) as RelayMessageType,
+    requestId: view.getUint32(4),
+    streamId: view.getUint32(8),
+    payload: data.slice(RELAY_HEADER_BYTES),
+  };
+}
+
+export function encodeJson(value: unknown) {
+  return new TextEncoder().encode(JSON.stringify(value));
+}
+
+export function decodeJson<T>(payload: Uint8Array): T {
+  return JSON.parse(new TextDecoder().decode(payload)) as T;
+}

package/src/core/device-install/operations/usbmux.ts

@@ -0,0 +1,270 @@
+/// <reference path="./webusb-dom.d.ts" />
+
+import type { UsbmuxCandidate } from './webusb';
+import { getBulkEndpoints, transferIn, transferOutWithZlp } from './webusb';
+
+const PROTO_VERSION = 0;
+const PROTO_SETUP = 2;
+const PROTO_TCP = 6;
+const MAGIC = 0xfeedface;
+const FLAG_SYN = 0x02;
+const FLAG_RST = 0x04;
+const FLAG_ACK = 0x10;
+const FIRST_SPORT = 49152;
+
+export type UsbmuxSession = {
+  device: USBDevice;
+  candidate: UsbmuxCandidate;
+  inEndpoint: ReturnType<typeof getBulkEndpoints>['inEndpoint'];
+  outEndpoint: ReturnType<typeof getBulkEndpoints>['outEndpoint'];
+  muxVersion: number;
+  txSeq: number;
+  rxSeq: number;
+  nextSport: number;
+  streams: Map<string, UsbmuxStream>;
+  writeChain: Promise<void>;
+  closed: boolean;
+};
+
+export type UsbmuxStream = {
+  session: UsbmuxSession;
+  sport: number;
+  dport: number;
+  seq: number;
+  ack: number;
+  queue: Uint8Array[];
+  waiters: Array<(value: Uint8Array) => void>;
+  error?: Error;
+  opened: Promise<void>;
+  resolveOpened: () => void;
+  rejectOpened: (error: Error) => void;
+};
+
+export async function createUsbmuxSession(device: USBDevice, candidate: UsbmuxCandidate) {
+  const { inEndpoint, outEndpoint } = getBulkEndpoints(candidate);
+  const versionPayload = new Uint8Array(12);
+  const versionView = new DataView(versionPayload.buffer);
+  versionView.setUint32(0, 2);
+  versionView.setUint32(4, 0);
+  versionView.setUint32(8, 0);
+  await transferOutWithZlp(device, outEndpoint, buildV1Packet(PROTO_VERSION, versionPayload));
+  const versionPacket = await readPacket(device, inEndpoint, 1);
+  const version = new DataView(versionPacket.payload.buffer, versionPacket.payload.byteOffset).getUint32(0);
+  const session: UsbmuxSession = {
+    device,
+    candidate,
+    inEndpoint,
+    outEndpoint,
+    muxVersion: version,
+    txSeq: 0,
+    rxSeq: 0xffff,
+    nextSport: FIRST_SPORT,
+    streams: new Map(),
+    writeChain: Promise.resolve(),
+    closed: false,
+  };
+  if (version >= 2) {
+    await sendMux(session, PROTO_SETUP, new Uint8Array([0x07]));
+  }
+  void readLoop(session);
+  return session;
+}
+
+export async function openStream(session: UsbmuxSession, port: number) {
+  if (session.closed) {
+    throw new Error('usbmux session is closed.');
+  }
+  let resolveOpened!: () => void;
+  let rejectOpened!: (error: Error) => void;
+  const stream: UsbmuxStream = {
+    session,
+    sport: session.nextSport++,
+    dport: port,
+    seq: 0,
+    ack: 0,
+    queue: [],
+    waiters: [],
+    opened: new Promise<void>((resolve, reject) => {
+      resolveOpened = resolve;
+      rejectOpened = reject;
+    }),
+    resolveOpened,
+    rejectOpened,
+  };
+  session.streams.set(streamKey(port, stream.sport), stream);
+  await sendTcp(stream, FLAG_SYN, new Uint8Array());
+  await stream.opened;
+  return stream;
+}
+
+export async function sendStreamData(stream: UsbmuxStream, bytes: Uint8Array) {
+  if (stream.session.closed) {
+    throw new Error('usbmux session is closed.');
+  }
+  await sendTcp(stream, FLAG_ACK, bytes);
+  stream.seq += bytes.byteLength;
+}
+
+export async function receiveStreamData(stream: UsbmuxStream) {
+  if (stream.queue.length > 0) {
+    return stream.queue.shift()!;
+  }
+  if (stream.error) {
+    throw stream.error;
+  }
+  return new Promise<Uint8Array>((resolve) => {
+    stream.waiters.push(resolve);
+  });
+}
+
+export function closeUsbmuxSession(session: UsbmuxSession) {
+  session.closed = true;
+  for (const stream of session.streams.values()) {
+    stream.error = new Error('usbmux session closed');
+    stream.rejectOpened(stream.error);
+    while (stream.waiters.length > 0) {
+      stream.waiters.shift()!(new Uint8Array());
+    }
+  }
+  session.streams.clear();
+}
+
+async function sendTcp(stream: UsbmuxStream, flags: number, payload: Uint8Array) {
+  const tcp = new Uint8Array(20 + payload.byteLength);
+  const view = new DataView(tcp.buffer);
+  view.setUint16(0, stream.sport);
+  view.setUint16(2, stream.dport);
+  view.setUint32(4, stream.seq);
+  view.setUint32(8, stream.ack);
+  view.setUint8(12, 0x50);
+  view.setUint8(13, flags);
+  view.setUint16(14, 512);
+  tcp.set(payload, 20);
+  await sendMux(stream.session, PROTO_TCP, tcp);
+}
+
+async function sendMux(session: UsbmuxSession, protocol: number, payload: Uint8Array) {
+  if (session.closed) {
+    throw new Error('usbmux session is closed.');
+  }
+  session.writeChain = session.writeChain.then(async () => {
+    if (session.closed) return;
+    const packet =
+      session.muxVersion >= 2
+        ? buildV2Packet(protocol, payload, session.txSeq++, session.rxSeq)
+        : buildV1Packet(protocol, payload);
+    await transferOutWithZlp(session.device, session.outEndpoint, packet);
+  });
+  return session.writeChain;
+}
+
+async function readLoop(session: UsbmuxSession) {
+  try {
+    for (;;) {
+      if (session.closed) return;
+      const packet = await readPacket(session.device, session.inEndpoint, session.muxVersion);
+      if (session.closed) return;
+      if (packet.rxSeq !== undefined) {
+        session.rxSeq = packet.rxSeq;
+      }
+      if (packet.protocol !== PROTO_TCP) {
+        continue;
+      }
+      const tcp = parseTcp(packet.payload);
+      const stream = session.streams.get(streamKey(tcp.sport, tcp.dport));
+      if (!stream) {
+        continue;
+      }
+      if (tcp.flags & FLAG_RST) {
+        stream.error = new Error(`Device reset stream ${stream.dport}`);
+        stream.rejectOpened(stream.error);
+        while (stream.waiters.length > 0) {
+          stream.waiters.shift()!(new Uint8Array());
+        }
+        session.streams.delete(streamKey(stream.dport, stream.sport));
+        continue;
+      }
+      if ((tcp.flags & (FLAG_SYN | FLAG_ACK)) === (FLAG_SYN | FLAG_ACK)) {
+        stream.seq += 1;
+        stream.ack = tcp.seq + 1;
+        await sendTcp(stream, FLAG_ACK, new Uint8Array());
+        stream.resolveOpened();
+        continue;
+      }
+      if (tcp.payload.byteLength === 0) {
+        continue;
+      }
+      stream.ack = tcp.seq + tcp.payload.byteLength;
+      await sendTcp(stream, FLAG_ACK, new Uint8Array());
+      if (stream.waiters.length > 0) {
+        stream.waiters.shift()!(tcp.payload);
+      } else {
+        stream.queue.push(tcp.payload);
+      }
+    }
+  } catch (error) {
+    if (!session.closed) {
+      closeUsbmuxSession(session);
+    }
+  }
+}
+
+async function readPacket(device: USBDevice, endpoint: UsbmuxSession['inEndpoint'], version: number) {
+  for (;;) {
+    const bytes = await transferIn(device, endpoint);
+    const packet = parseMux(bytes, version);
+    if (version === 1 && packet.protocol !== PROTO_VERSION) continue;
+    return packet;
+  }
+}
+
+function buildV1Packet(protocol: number, payload: Uint8Array) {
+  const bytes = new Uint8Array(8 + payload.byteLength);
+  const view = new DataView(bytes.buffer);
+  view.setUint32(0, protocol);
+  view.setUint32(4, bytes.byteLength);
+  bytes.set(payload, 8);
+  return bytes;
+}
+
+function buildV2Packet(protocol: number, payload: Uint8Array, txSeq: number, rxSeq: number) {
+  const bytes = new Uint8Array(16 + payload.byteLength);
+  const view = new DataView(bytes.buffer);
+  view.setUint32(0, protocol);
+  view.setUint32(4, bytes.byteLength);
+  view.setUint32(8, MAGIC);
+  view.setUint16(12, txSeq);
+  view.setUint16(14, rxSeq);
+  bytes.set(payload, 16);
+  return bytes;
+}
+
+function parseMux(bytes: Uint8Array, version: number) {
+  const view = new DataView(bytes.buffer, bytes.byteOffset, bytes.byteLength);
+  const protocol = view.getUint32(0);
+  const length = view.getUint32(4);
+  const headerSize = version >= 2 ? 16 : 8;
+  return {
+    protocol,
+    length,
+    rxSeq: version >= 2 ? view.getUint16(14) : undefined,
+    payload: bytes.slice(headerSize, length),
+  };
+}
+
+function parseTcp(bytes: Uint8Array) {
+  const view = new DataView(bytes.buffer, bytes.byteOffset, bytes.byteLength);
+  const dataOffset = (view.getUint8(12) >> 4) * 4;
+  return {
+    sport: view.getUint16(0),
+    dport: view.getUint16(2),
+    seq: view.getUint32(4),
+    ack: view.getUint32(8),
+    flags: view.getUint8(13),
+    payload: bytes.slice(dataOffset),
+  };
+}
+
+function streamKey(devicePort: number, hostPort: number) {
+  return `${devicePort}:${hostPort}`;
+}

package/src/core/device-install/operations/webusb-dom.d.ts

@@ -0,0 +1,54 @@
+type USBTransferStatus = 'ok' | 'stall' | 'babble';
+
+interface USBInTransferResult {
+  data?: DataView;
+  status: USBTransferStatus;
+}
+
+interface USBOutTransferResult {
+  bytesWritten: number;
+  status: USBTransferStatus;
+}
+
+interface USBDevice {
+  vendorId: number;
+  productId: number;
+  productName?: string;
+  manufacturerName?: string;
+  serialNumber?: string;
+  opened: boolean;
+  configuration: { configurationValue: number } | null;
+  configurations: Array<{
+    configurationValue: number;
+    interfaces: Array<{
+      interfaceNumber: number;
+      alternates: Array<{
+        alternateSetting: number;
+        interfaceClass: number;
+        interfaceSubclass: number;
+        interfaceProtocol: number;
+        endpoints: Array<{
+          endpointNumber: number;
+          direction: 'in' | 'out';
+          type: string;
+          packetSize: number;
+        }>;
+      }>;
+    }>;
+  }>;
+  open(): Promise<void>;
+  close(): Promise<void>;
+  selectConfiguration(configurationValue: number): Promise<void>;
+  claimInterface(interfaceNumber: number): Promise<void>;
+  releaseInterface(interfaceNumber: number): Promise<void>;
+  selectAlternateInterface(interfaceNumber: number, alternateSetting: number): Promise<void>;
+  transferIn(endpointNumber: number, length: number): Promise<USBInTransferResult>;
+  transferOut(endpointNumber: number, data: Uint8Array): Promise<USBOutTransferResult>;
+}
+
+interface Navigator {
+  usb?: {
+    requestDevice(options: { filters: Array<{ vendorId: number }> }): Promise<USBDevice>;
+    getDevices(): Promise<USBDevice[]>;
+  };
+}