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

package/src/core/device-install/apple/relay.ts

@@ -0,0 +1,221 @@
+import type { AppleSRPCompleteProof, AppleSRPInitRequest, AppleSRPInitResponse } from './gsa-srp';
+
+export type AppleRelayResponse<T = unknown> = {
+  status: number;
+  statusText: string;
+  headers?: Record<string, string>;
+  body?: T;
+  rawBody?: string;
+  rawBodyBase64?: string;
+};
+
+export type AppleProvisioningRequest = {
+  method?: 'GET' | 'POST';
+  path: string;
+  payload?: unknown;
+};
+
+export async function createAppleRelaySession(limbuildApiUrl: string, token?: string) {
+  const response = await fetch(limbuildURL(limbuildApiUrl, '/apple/auth/session', token), {
+    method: 'POST',
+    headers: authHeaders(token),
+  });
+  if (!response.ok) {
+    throw new Error(`Apple relay session failed: HTTP ${response.status} ${await response.text()}`);
+  }
+  return (await response.json()) as { appleSessionId: string };
+}
+
+export async function deleteAppleRelaySession(limbuildApiUrl: string, appleSessionId: string, token?: string) {
+  const response = await fetch(limbuildURL(limbuildApiUrl, '/apple/auth/session/delete', token), {
+    method: 'POST',
+    headers: jsonHeaders(token),
+    body: JSON.stringify({ appleSessionId }),
+  });
+  if (!response.ok) {
+    throw new Error(`Apple relay session delete failed: HTTP ${response.status} ${await response.text()}`);
+  }
+}
+
+export async function proxySrpInit(
+  limbuildApiUrl: string,
+  appleSessionId: string,
+  payload: AppleSRPInitRequest,
+  token?: string,
+) {
+  return postAppleProxy<AppleSRPInitResponse>(
+    limbuildApiUrl,
+    '/apple/auth/srp/init',
+    appleSessionId,
+    payload,
+    token,
+  );
+}
+
+export async function proxySrpComplete(
+  limbuildApiUrl: string,
+  appleSessionId: string,
+  payload: AppleSRPCompleteProof & {
+    rememberMe: boolean;
+    trustTokens: string[];
+  },
+  token?: string,
+) {
+  return postAppleProxy(limbuildApiUrl, '/apple/auth/srp/complete', appleSessionId, payload, token);
+}
+
+export async function triggerTrustedDeviceTwoFactor(
+  limbuildApiUrl: string,
+  appleSessionId: string,
+  token?: string,
+) {
+  const response = await fetch(limbuildURL(limbuildApiUrl, '/apple/auth/2fa/trigger', token), {
+    method: 'POST',
+    headers: jsonHeaders(token),
+    body: JSON.stringify({ appleSessionId }),
+  });
+  if (!response.ok) {
+    throw new Error(`Apple 2FA trigger failed: HTTP ${response.status} ${await response.text()}`);
+  }
+  return (await response.json()) as AppleRelayResponse;
+}
+
+export async function triggerPhoneTwoFactor(
+  limbuildApiUrl: string,
+  appleSessionId: string,
+  phoneNumberId: number,
+  mode = 'sms',
+  token?: string,
+) {
+  const response = await fetch(limbuildURL(limbuildApiUrl, '/apple/auth/2fa/phone/trigger', token), {
+    method: 'POST',
+    headers: jsonHeaders(token),
+    body: JSON.stringify({ appleSessionId, phoneNumberId, mode }),
+  });
+  if (!response.ok) {
+    throw new Error(`Apple phone 2FA trigger failed: HTTP ${response.status} ${await response.text()}`);
+  }
+  return (await response.json()) as AppleRelayResponse;
+}
+
+export async function proxyTwoFactorCode(
+  limbuildApiUrl: string,
+  appleSessionId: string,
+  code: string,
+  token?: string,
+) {
+  const response = await fetch(limbuildURL(limbuildApiUrl, '/apple/auth/2fa', token), {
+    method: 'POST',
+    headers: jsonHeaders(token),
+    body: JSON.stringify({ appleSessionId, code }),
+  });
+  if (!response.ok) {
+    throw new Error(`Apple 2FA proxy failed: HTTP ${response.status} ${await response.text()}`);
+  }
+  return (await response.json()) as AppleRelayResponse;
+}
+
+export async function proxyPhoneTwoFactorCode(
+  limbuildApiUrl: string,
+  appleSessionId: string,
+  phoneNumberId: number,
+  code: string,
+  mode = 'sms',
+  token?: string,
+) {
+  const response = await fetch(limbuildURL(limbuildApiUrl, '/apple/auth/2fa/phone', token), {
+    method: 'POST',
+    headers: jsonHeaders(token),
+    body: JSON.stringify({ appleSessionId, phoneNumberId, mode, code }),
+  });
+  if (!response.ok) {
+    throw new Error(`Apple phone 2FA proxy failed: HTTP ${response.status} ${await response.text()}`);
+  }
+  return (await response.json()) as AppleRelayResponse;
+}
+
+export async function fetchAppleAccountSession(
+  limbuildApiUrl: string,
+  appleSessionId: string,
+  token?: string,
+) {
+  const response = await fetch(limbuildURL(limbuildApiUrl, '/apple/auth/finalize', token), {
+    method: 'POST',
+    headers: jsonHeaders(token),
+    body: JSON.stringify({ appleSessionId }),
+  });
+  if (!response.ok) {
+    throw new Error(`Apple session finalization failed: HTTP ${response.status} ${await response.text()}`);
+  }
+  return (await response.json()) as AppleRelayResponse;
+}
+
+export async function proxyProvisioningRequest<T = unknown>(
+  limbuildApiUrl: string,
+  appleSessionId: string,
+  request: AppleProvisioningRequest,
+  token?: string,
+) {
+  const response = await fetch(limbuildURL(limbuildApiUrl, '/apple/provisioning', token), {
+    method: 'POST',
+    headers: jsonHeaders(token),
+    body: JSON.stringify({ appleSessionId, ...request }),
+  });
+  if (!response.ok) {
+    throw new Error(`Apple provisioning proxy failed: HTTP ${response.status} ${await response.text()}`);
+  }
+  return normalizeAppleProxyResponse<T>((await response.json()) as AppleRelayResponse<T>);
+}
+
+async function postAppleProxy<T>(
+  limbuildApiUrl: string,
+  path: string,
+  appleSessionId: string,
+  payload: unknown,
+  token?: string,
+) {
+  const response = await fetch(limbuildURL(limbuildApiUrl, path, token), {
+    method: 'POST',
+    headers: jsonHeaders(token),
+    body: JSON.stringify({ appleSessionId, payload }),
+  });
+  if (!response.ok) {
+    throw new Error(`Apple proxy ${path} failed: HTTP ${response.status} ${await response.text()}`);
+  }
+  return normalizeAppleProxyResponse<T>((await response.json()) as AppleRelayResponse<T>);
+}
+
+function normalizeAppleProxyResponse<T>(response: AppleRelayResponse<T>) {
+  if (response.body !== undefined || !response.rawBody) {
+    return response;
+  }
+  try {
+    return {
+      ...response,
+      body: JSON.parse(response.rawBody) as T,
+    };
+  } catch {
+    return response;
+  }
+}
+
+function limbuildURL(limbuildApiUrl: string, path: string, token?: string) {
+  const base = limbuildApiUrl.replace(/\/$/, '');
+  const suffix = path.startsWith('/') ? path : `/${path}`;
+  const url = new URL(`${base}${suffix}`);
+  if (token) {
+    url.searchParams.set('token', token);
+  }
+  return url;
+}
+
+function jsonHeaders(token?: string): Record<string, string> {
+  return {
+    'Content-Type': 'application/json',
+    ...authHeaders(token),
+  };
+}
+
+function authHeaders(token?: string): Record<string, string> {
+  return token ? { Authorization: `Bearer ${token}` } : {};
+}

package/src/core/device-install/index.ts

@@ -0,0 +1,4 @@
+export * from './types';
+export * from './apple';
+export * from './operations';
+export * from './storage';

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

@@ -0,0 +1,6 @@
+export * from './limbuild-client';
+export * from './operations';
+export * from './relay-client';
+export * from './relay-protocol';
+export * from './usbmux';
+export * from './webusb';

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

@@ -0,0 +1,104 @@
+import type { BuildLogLine, DeviceInstallBuildStatus } from '../types';
+
+export type LimbuildInfo = {
+  homeDir?: string;
+  lastBuildConfig?: {
+    bundleId?: string;
+    sdk?: string;
+  };
+};
+
+export type StartSignedDeviceBuildOptions = {
+  limbuildApiUrl: string;
+  token?: string;
+  certificateP12Base64: string;
+  certificatePassword: string;
+  provisioningProfileBase64: string;
+};
+
+export type BuildLogEventsOptions = {
+  limbuildApiUrl: string;
+  execId: string;
+  token?: string;
+  onLine: (line: BuildLogLine) => void;
+  onStatus: (status: DeviceInstallBuildStatus) => void;
+  onError?: (error: Error) => void;
+};
+
+export async function fetchLimbuildInfo(limbuildApiUrl: string, token?: string) {
+  const url = new URL(`${limbuildApiUrl}/info`);
+  if (token) {
+    url.searchParams.set('token', token);
+  }
+  const response = await fetch(url.toString(), {
+    headers: token ? { Authorization: `Bearer ${token}` } : undefined,
+  });
+  if (!response.ok) {
+    const body = await response.text();
+    throw new Error(`Info request failed: HTTP ${response.status} ${body}`);
+  }
+  return (await response.json()) as LimbuildInfo;
+}
+
+export async function startSignedDeviceBuild({
+  limbuildApiUrl,
+  token,
+  certificateP12Base64,
+  certificatePassword,
+  provisioningProfileBase64,
+}: StartSignedDeviceBuildOptions) {
+  const url = new URL(`${limbuildApiUrl}/exec`);
+  if (token) {
+    url.searchParams.set('token', token);
+  }
+  const response = await fetch(url.toString(), {
+    method: 'POST',
+    headers: {
+      'Content-Type': 'application/json',
+      ...(token ? { Authorization: `Bearer ${token}` } : {}),
+    },
+    body: JSON.stringify({
+      command: 'xcodebuild',
+      xcodebuild: { sdk: 'iphoneos' },
+      signing: {
+        certificateP12Base64,
+        certificatePassword,
+        provisioningProfileBase64,
+      },
+    }),
+  });
+  if (!response.ok) {
+    const body = await response.text();
+    throw new Error(`Build request failed: HTTP ${response.status} ${body}`);
+  }
+  return (await response.json()) as { execId?: string };
+}
+
+export function watchBuildLogEvents({
+  limbuildApiUrl,
+  execId,
+  token,
+  onLine,
+  onStatus,
+  onError,
+}: BuildLogEventsOptions) {
+  const url = new URL(`${limbuildApiUrl}/exec/${execId}/events`);
+  if (token) {
+    url.searchParams.set('token', token);
+  }
+  const events = new EventSource(url.toString());
+  onStatus('running');
+  events.addEventListener('command', (event) => onLine({ type: 'command', data: event.data }));
+  events.addEventListener('stdout', (event) => onLine({ type: 'stdout', data: event.data }));
+  events.addEventListener('stderr', (event) => onLine({ type: 'stderr', data: event.data }));
+  events.addEventListener('exitCode', (event) => {
+    const code = parseInt(event.data, 10);
+    onStatus(code === 0 ? 'succeeded' : code < 0 ? 'cancelled' : 'failed');
+    events.close();
+  });
+  events.onerror = () => {
+    events.close();
+    onError?.(new Error('Build log stream closed before completion.'));
+  };
+  return () => events.close();
+}

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

@@ -0,0 +1,217 @@
+/// <reference path="./webusb-dom.d.ts" />
+
+import type { DeviceHello, DeviceInstallLog, PairRecordPayload } from '../types';
+import { RelayClient } from './relay-client';
+import { closeUsbmuxSession, createUsbmuxSession, type UsbmuxSession } from './usbmux';
+import { claimUsbmux, findUsbmuxCandidates, requestAppleDevice, type UsbmuxCandidate } from './webusb';
+
+export type DeviceRelayTarget = {
+  device: USBDevice;
+  candidate: UsbmuxCandidate;
+  session?: UsbmuxSession;
+  claimedInterfaceNumber?: number;
+  hello: DeviceHello;
+};
+
+export type RequestUSBAccessOptions = {
+  log: DeviceInstallLog;
+};
+
+export type StartPairingRelayOptions = {
+  limbuildApiUrl: string;
+  token?: string;
+  log: DeviceInstallLog;
+  target: DeviceRelayTarget;
+};
+
+export type StartInstallRelayOptions = StartPairingRelayOptions & {
+  pairRecord: PairRecordPayload;
+};
+
+export async function requestUSBAccess({ log }: RequestUSBAccessOptions) {
+  log('Selecting USB device');
+  const device = await requestAppleDevice();
+  const target = makeDeviceRelayTarget(device);
+  log(
+    'Selected USB device',
+    `${device.manufacturerName ?? ''} ${device.productName ?? ''} ${device.serialNumber ?? ''}`.trim(),
+  );
+  return target;
+}
+
+export async function startPairingRelay({ limbuildApiUrl, token, log, target }: StartPairingRelayOptions) {
+  const deviceRelayUrl = deviceRelayWebSocketUrl(limbuildApiUrl, token);
+  let relay: RelayClient | undefined;
+  try {
+    relay = await connectRelay(deviceRelayUrl, target, log);
+    const pairRecord = await relay.startPairing();
+    return { relay, pairRecord, target };
+  } catch (error) {
+    relay?.close();
+    throw error;
+  }
+}
+
+export async function startInstallRelay({
+  limbuildApiUrl,
+  token,
+  log,
+  target,
+  pairRecord,
+}: StartInstallRelayOptions) {
+  const deviceRelayUrl = deviceRelayWebSocketUrl(limbuildApiUrl, token);
+  let relay: RelayClient | undefined;
+  try {
+    relay = await connectRelay(deviceRelayUrl, target, log);
+    await relay.startInstall(pairRecord);
+    return relay;
+  } catch (error) {
+    relay?.close();
+    throw error;
+  }
+}
+
+export async function closeDeviceRelayTarget(target: DeviceRelayTarget | undefined, log?: DeviceInstallLog) {
+  if (!target) return;
+  if (target.session) {
+    closeUsbmuxSession(target.session);
+    target.session = undefined;
+  }
+  if (target.claimedInterfaceNumber !== undefined) {
+    try {
+      await target.device.releaseInterface(target.claimedInterfaceNumber);
+      log?.('Released usbmux interface');
+    } catch (error) {
+      log?.('USB interface release failed', errorMessage(error));
+    } finally {
+      target.claimedInterfaceNumber = undefined;
+    }
+  }
+  if (target.device.opened) {
+    try {
+      await target.device.close();
+      log?.('Closed USB device');
+    } catch (error) {
+      log?.('USB device close failed', errorMessage(error));
+    }
+  }
+}
+
+async function connectRelay(deviceRelayUrl: string, target: DeviceRelayTarget, log: DeviceInstallLog) {
+  await ensureUsbmuxSession(target, log);
+  const relay = new RelayClient(deviceRelayUrl, target.session!, target.hello, log);
+  await relay.connect();
+  return relay;
+}
+
+async function ensureUsbmuxSession(target: DeviceRelayTarget, log: DeviceInstallLog) {
+  if (target.session) return;
+  try {
+    target.candidate = await claimBestUsbmuxCandidate(target, log);
+    target.session = await createUsbmuxSession(target.device, target.candidate);
+    log('Created usbmux session');
+  } catch (error) {
+    await closeDeviceRelayTarget(target, log);
+    throw error;
+  }
+}
+
+function makeDeviceRelayTarget(device: USBDevice): DeviceRelayTarget {
+  return {
+    device,
+    candidate: pickUsbmuxCandidate(device),
+    hello: {
+      serialNumber: device.serialNumber,
+      productName: device.productName,
+      manufacturerName: device.manufacturerName,
+      productId: device.productId,
+      vendorId: device.vendorId,
+    },
+  };
+}
+
+async function claimBestUsbmuxCandidate(target: DeviceRelayTarget, log: DeviceInstallLog) {
+  const candidates = orderedUsbmuxCandidates(target.device);
+  if (candidates.length === 0) throw new Error('No Apple usbmux interface found.');
+  let lastError: unknown;
+  for (const candidate of candidates) {
+    for (const attempt of [1, 2]) {
+      try {
+        if (!target.device.opened) {
+          await target.device.open();
+        }
+        log(
+          'Claiming usbmux interface',
+          `configuration ${candidate.configurationValue}, interface ${candidate.interfaceNumber}, alternate ${candidate.alternateSetting}, attempt ${attempt}`,
+        );
+        await claimUsbmux(target.device, candidate);
+        target.claimedInterfaceNumber = candidate.interfaceNumber;
+        log(
+          'Claimed usbmux interface',
+          `configuration ${candidate.configurationValue}, interface ${candidate.interfaceNumber}`,
+        );
+        return candidate;
+      } catch (error) {
+        lastError = error;
+        log(
+          'USB interface claim failed',
+          `configuration ${candidate.configurationValue}, interface ${candidate.interfaceNumber}: ${errorMessage(error)}`,
+        );
+        await resetUSBDevice(target);
+        await sleep(250);
+      }
+    }
+  }
+  throw lastError instanceof Error ? lastError : new Error('Unable to claim any Apple usbmux interface.');
+}
+
+function pickUsbmuxCandidate(device: USBDevice) {
+  const candidate = orderedUsbmuxCandidates(device)[0];
+  if (!candidate) throw new Error('No Apple usbmux interface found.');
+  return candidate;
+}
+
+function orderedUsbmuxCandidates(device: USBDevice) {
+  const candidates = findUsbmuxCandidates(device);
+  const activeConfigurationValue = device.configuration?.configurationValue;
+  return [
+    ...candidates.filter((item) => item.configurationValue === activeConfigurationValue),
+    ...candidates.filter((item) => item.configurationValue !== activeConfigurationValue),
+  ];
+}
+
+export function deviceRelayWebSocketUrl(limbuildApiUrl: string, token?: string) {
+  const url = new URL(limbuildApiUrl);
+  url.protocol = url.protocol === 'https:' ? 'wss:' : 'ws:';
+  url.pathname = `${url.pathname.replace(/\/$/, '')}/device/ws`;
+  if (token) {
+    url.searchParams.set('token', token);
+  }
+  return url.toString();
+}
+
+function errorMessage(error: unknown) {
+  return error instanceof Error ? error.message : String(error);
+}
+
+async function resetUSBDevice(target: DeviceRelayTarget) {
+  if (target.claimedInterfaceNumber !== undefined) {
+    try {
+      await target.device.releaseInterface(target.claimedInterfaceNumber);
+    } catch {
+      // Best effort: claim failures often mean there is nothing we own to release.
+    }
+    target.claimedInterfaceNumber = undefined;
+  }
+  if (target.device.opened) {
+    try {
+      await target.device.close();
+    } catch {
+      // Best effort before reopening for the next candidate/attempt.
+    }
+  }
+}
+
+function sleep(ms: number) {
+  return new Promise((resolve) => setTimeout(resolve, ms));
+}