@limrun/ui 0.14.0-rc.4 → 0.14.0

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

@@ -1,71 +0,0 @@
-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

@@ -1,270 +0,0 @@
-/// <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

@@ -1,54 +0,0 @@
-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[]>;
-  };
-}

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

@@ -1,110 +0,0 @@
-/// <reference path="./webusb-dom.d.ts" />
-
-export type UsbEndpoint = {
-  endpointNumber: number;
-  direction: 'in' | 'out';
-  type: string;
-  packetSize: number;
-};
-
-export type UsbmuxCandidate = {
-  configurationValue: number;
-  interfaceNumber: number;
-  alternateSetting: number;
-  endpoints: UsbEndpoint[];
-};
-
-export async function requestAppleDevice() {
-  if (!navigator.usb) {
-    throw new Error('WebUSB is not available in this browser.');
-  }
-  return navigator.usb.requestDevice({ filters: [{ vendorId: 0x05ac }] });
-}
-
-export function findUsbmuxCandidates(device: USBDevice): UsbmuxCandidate[] {
-  const candidates: UsbmuxCandidate[] = [];
-  const activeConfigurationValue = device.configuration?.configurationValue;
-  const activeConfiguration = device.configurations.find(
-    (configuration) => configuration.configurationValue === activeConfigurationValue,
-  );
-  if (activeConfiguration) {
-    candidates.push(...findConfigurationUsbmuxCandidates(activeConfiguration));
-  }
-  for (const configuration of device.configurations) {
-    if (configuration.configurationValue === activeConfigurationValue) {
-      continue;
-    }
-    candidates.push(...findConfigurationUsbmuxCandidates(configuration));
-  }
-  return candidates;
-}
-
-function findConfigurationUsbmuxCandidates(
-  configuration: USBDevice['configurations'][number],
-): UsbmuxCandidate[] {
-  const candidates: UsbmuxCandidate[] = [];
-  for (const usbInterface of configuration.interfaces) {
-    for (const alternate of usbInterface.alternates) {
-      if (
-        alternate.interfaceClass === 0xff &&
-        alternate.interfaceSubclass === 0xfe &&
-        alternate.interfaceProtocol === 0x02
-      ) {
-        candidates.push({
-          configurationValue: configuration.configurationValue,
-          interfaceNumber: usbInterface.interfaceNumber,
-          alternateSetting: alternate.alternateSetting,
-          endpoints: alternate.endpoints,
-        });
-      }
-    }
-  }
-  return candidates;
-}
-
-export async function claimUsbmux(device: USBDevice, candidate: UsbmuxCandidate) {
-  if (!device.opened) {
-    await device.open();
-  }
-  if (!device.configuration || device.configuration.configurationValue !== candidate.configurationValue) {
-    await device.selectConfiguration(candidate.configurationValue);
-  }
-  await device.claimInterface(candidate.interfaceNumber);
-  // Always select the alternate (even alt 0). On macOS Chrome the
-  // interface's endpoints are not treated as active until the alternate
-  // is explicitly selected, which otherwise surfaces as
-  // "endpoint is not part of a claimed and selected alternate interface"
-  // on the first transferIn/transferOut.
-  await device.selectAlternateInterface(candidate.interfaceNumber, candidate.alternateSetting);
-}
-
-export function getBulkEndpoints(candidate: UsbmuxCandidate) {
-  const outEndpoint = candidate.endpoints.find(
-    (endpoint) => endpoint.direction === 'out' && endpoint.type === 'bulk',
-  );
-  const inEndpoint = candidate.endpoints.find(
-    (endpoint) => endpoint.direction === 'in' && endpoint.type === 'bulk',
-  );
-  if (!outEndpoint || !inEndpoint) {
-    throw new Error('Could not find usbmux bulk endpoints.');
-  }
-  return { outEndpoint, inEndpoint };
-}
-
-export async function transferOutWithZlp(device: USBDevice, endpoint: UsbEndpoint, bytes: Uint8Array) {
-  const result = await device.transferOut(endpoint.endpointNumber, bytes);
-  if (result.status !== 'ok') {
-    throw new Error(`USB transferOut failed: ${result.status}`);
-  }
-  if (bytes.byteLength % endpoint.packetSize === 0) {
-    await device.transferOut(endpoint.endpointNumber, new Uint8Array());
-  }
-}
-
-export async function transferIn(device: USBDevice, endpoint: UsbEndpoint, size = 16384) {
-  const result = await device.transferIn(endpoint.endpointNumber, size);
-  if (result.status !== 'ok' || !result.data) {
-    throw new Error(`USB transferIn failed: ${result.status}`);
-  }
-  return new Uint8Array(result.data.buffer, result.data.byteOffset, result.data.byteLength);
-}

package/src/core/device-install/storage/browser-storage.test.ts

@@ -1,65 +0,0 @@
-import forge from 'node-forge';
-import { describe, expect, test } from 'vitest';
-import { normalizeCertificateSerial, parseProvisioningProfileBase64 } from './browser-storage';
-
-function selfSignedCertificateBase64(serialNumber: string) {
-  const keys = forge.pki.rsa.generateKeyPair(1024);
-  const cert = forge.pki.createCertificate();
-  cert.publicKey = keys.publicKey;
-  cert.serialNumber = serialNumber;
-  cert.validity.notBefore = new Date();
-  cert.validity.notAfter = new Date(Date.now() + 24 * 60 * 60 * 1000);
-  const attrs = [{ name: 'commonName', value: 'Apple Development Test' }];
-  cert.setSubject(attrs);
-  cert.setIssuer(attrs);
-  cert.sign(keys.privateKey);
-  return forge.util.encode64(forge.asn1.toDer(forge.pki.certificateToAsn1(cert)).getBytes());
-}
-
-function profileBase64(certificatesBase64: string[]) {
-  const xml = `<?xml version="1.0" encoding="UTF-8"?>
-<plist version="1.0">
-<dict>
-  <key>Name</key><string>Limrun Dev</string>
-  <key>UUID</key><string>11111111-2222-3333-4444-555555555555</string>
-  <key>TeamIdentifier</key><array><string>TEAM123</string></array>
-  <key>ProvisionedDevices</key><array><string>00008030-000A</string></array>
-  <key>DeveloperCertificates</key>
-  <array>${certificatesBase64.map((c) => `<data>${c}</data>`).join('')}</array>
-  <key>Entitlements</key>
-  <dict>
-    <key>application-identifier</key><string>TEAM123.com.example.app</string>
-    <key>com.apple.developer.team-identifier</key><string>TEAM123</string>
-  </dict>
-</dict>
-</plist>`;
-  return btoa(xml);
-}
-
-describe('parseProvisioningProfileBase64', () => {
-  test('extracts embedded certificate serial numbers in normalized form', () => {
-    const parsed = parseProvisioningProfileBase64(
-      profileBase64([selfSignedCertificateBase64('00ab12cd'), selfSignedCertificateBase64('7f')]),
-    );
-    expect(parsed.certificateSerialNumbers).toEqual(['AB12CD', '7F']);
-    expect(parsed.bundleID).toBe('com.example.app');
-    expect(parsed.teamID).toBe('TEAM123');
-    expect(parsed.provisionedDevices).toEqual(['00008030-000A']);
-  });
-
-  test('skips unparseable certificates instead of failing the profile', () => {
-    const parsed = parseProvisioningProfileBase64(
-      profileBase64([btoa('not a certificate'), selfSignedCertificateBase64('1a')]),
-    );
-    expect(parsed.certificateSerialNumbers).toEqual(['1A']);
-  });
-});
-
-describe('normalizeCertificateSerial', () => {
-  test('uppercases and strips leading zeros', () => {
-    expect(normalizeCertificateSerial('00ab12')).toBe('AB12');
-    expect(normalizeCertificateSerial('AB12')).toBe('AB12');
-    expect(normalizeCertificateSerial('')).toBeUndefined();
-    expect(normalizeCertificateSerial(undefined)).toBeUndefined();
-  });
-});