@limrun/ui 0.9.0-rc.9 → 0.13.3-rc.1

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

@@ -1,4 +1,4 @@
-import type { ProvisioningProfileInfo, StoredSigningAssets } from '../types';
+import type { DeviceInstallSigningMode, ProvisioningProfileInfo, StoredSigningAssets } from '../types';
 import {
   getSigningAssets,
   normalizeBundleID,
@@ -64,15 +64,17 @@ export type AppleSigningAssetCacheInput = {
   bundleID: string;
   deviceUDID?: string;
   teamID?: string;
+  signingMode?: DeviceInstallSigningMode;
 };
 
 export type PutAppleGeneratedSigningAssetsInput = {
   bundleID: string;
   deviceUDID?: string;
   teamID?: string;
+  signingMode?: DeviceInstallSigningMode;
   certificateID?: string;
   certificateP12Base64: string;
-  certificatePassword: string;
+  certificatePassword?: string;
   provisioningProfileBase64: string;
   profile: ProvisioningProfileInfo;
 };
@@ -105,6 +107,13 @@ export function findDevelopmentCertificatesRequest(teamID = '') {
   });
 }
 
+export function findDistributionCertificatesRequest(teamID = '') {
+  return pagedRequest('/account/ios/certificate/listCertRequests.action', teamID, {
+    sort: 'name=asc',
+    types: 'WXV89964HE,R58UK2EWSO',
+  });
+}
+
 export function findDevelopmentProfilesRequest({
   bundleID,
   teamID = '',
@@ -115,6 +124,17 @@ export function findDevelopmentProfilesRequest({
   });
 }
 
+export function findAdHocProfilesRequest({
+  bundleID,
+  teamID = '',
+}: Pick<AppleProvisioningContext, 'bundleID' | 'teamID'>) {
+  return pagedRequest('/account/ios/profile/listProvisioningProfiles.action', teamID, {
+    search: bundleID,
+    sort: 'name=asc',
+    distributionType: 'adhoc',
+  });
+}
+
 export function registerDeviceRequest({
   deviceUDID,
   teamID = '',
@@ -168,6 +188,24 @@ export function submitDevelopmentCSRRequest({
   } satisfies AppleProvisioningRequest;
 }
 
+export function submitDistributionCSRRequest({
+  csrPEM,
+  teamID = '',
+}: {
+  csrPEM: string;
+  teamID?: string;
+}) {
+  return {
+    method: 'POST',
+    path: '/account/ios/certificate/submitCertificateRequest.action',
+    payload: {
+      teamId: teamID,
+      type: 'WXV89964HE',
+      csrContent: csrPEM,
+    },
+  } satisfies AppleProvisioningRequest;
+}
+
 export function downloadCertificateRequest(certificateID: string, teamID = '') {
   return {
     method: 'GET',
@@ -180,6 +218,18 @@ export function downloadCertificateRequest(certificateID: string, teamID = '') {
   } satisfies AppleProvisioningRequest;
 }
 
+export function downloadDistributionCertificateRequest(certificateID: string, teamID = '') {
+  return {
+    method: 'GET',
+    path: '/account/ios/certificate/downloadCertificateContent.action',
+    payload: {
+      teamId: teamID,
+      certificateId: certificateID,
+      type: 'WXV89964HE',
+    },
+  } satisfies AppleProvisioningRequest;
+}
+
 export function createDevelopmentProfileRequest({
   bundleID,
   teamID = '',
@@ -208,6 +258,34 @@ export function createDevelopmentProfileRequest({
   } satisfies AppleProvisioningRequest;
 }
 
+export function createAdHocProfileRequest({
+  bundleID,
+  teamID = '',
+  appIDID,
+  certificateID,
+  deviceIDs,
+  name,
+}: Pick<AppleProvisioningContext, 'bundleID' | 'teamID'> & {
+  appIDID: string;
+  certificateID: string;
+  deviceIDs: string[];
+  name?: string;
+}) {
+  return {
+    method: 'POST',
+    path: '/account/ios/profile/createProvisioningProfile.action',
+    payload: {
+      teamId: teamID,
+      provisioningProfileName: name ?? `Limrun Ad Hoc ${bundleID}`,
+      certificateIds: [certificateID],
+      appIdId: appIDID,
+      deviceIds: deviceIDs,
+      distributionType: 'adhoc',
+      subPlatform: 'ios',
+    },
+  } satisfies AppleProvisioningRequest;
+}
+
 export function downloadProfileRequest(profileID: string, teamID = '') {
   return {
     method: 'GET',
@@ -223,9 +301,10 @@ export async function getReusableAppleSigningAssets({
   bundleID,
   deviceUDID,
   teamID,
+  signingMode,
 }: AppleSigningAssetCacheInput) {
-  const stored = await getSigningAssets({ bundleID, deviceUDID });
-  if (!stored || !storedSigningAssetsReusable(stored, { bundleID, deviceUDID, teamID })) {
+  const stored = await getSigningAssets({ bundleID, deviceUDID, signingMode });
+  if (!stored || !storedSigningAssetsReusable(stored, { bundleID, deviceUDID, teamID, signingMode })) {
     return undefined;
   }
   return stored;
@@ -234,15 +313,20 @@ export async function getReusableAppleSigningAssets({
 export async function putAppleGeneratedSigningAssets(input: PutAppleGeneratedSigningAssetsInput) {
   return putSigningAssets({
     ...input,
-    certificateFileName: input.certificateID ? `${input.certificateID}.p12` : 'apple-development.p12',
-    profileFileName: input.profile.uuid ? `${input.profile.uuid}.mobileprovision` : 'apple-development.mobileprovision',
+    certificateFileName: input.certificateID ? `${input.certificateID}.p12` : `apple-${input.signingMode ?? 'development'}.p12`,
+    certificatePassword: input.certificatePassword || undefined,
+    signingMode: input.signingMode,
+    profileFileName: input.profile.uuid ? `${input.profile.uuid}.mobileprovision` : `${input.signingMode ?? 'development'}.mobileprovision`,
   });
 }
 
 export function storedSigningAssetsReusable(
   stored: StoredSigningAssets,
-  { bundleID, deviceUDID, teamID }: AppleSigningAssetCacheInput,
+  { bundleID, deviceUDID, teamID, signingMode = 'development' }: AppleSigningAssetCacheInput,
 ) {
+  if ((stored.signingMode ?? 'development') !== signingMode) {
+    return false;
+  }
   if (!profileMatchesBundleID(stored.profile, bundleID)) {
     return false;
   }

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

@@ -12,7 +12,7 @@ export type StartSignedDeviceBuildOptions = {
   limbuildApiUrl: string;
   token?: string;
   certificateP12Base64: string;
-  certificatePassword: string;
+  certificatePassword?: string;
   provisioningProfileBase64: string;
 };
 
@@ -25,6 +25,21 @@ export type BuildLogEventsOptions = {
   onError?: (error: Error) => void;
 };
 
+export type IOSOTAInstall = {
+  installUrl: string;
+  landingUrl: string;
+  manifestUrl: string;
+  ipaUrl: string;
+  bundleId: string;
+  displayName: string;
+};
+
+export type GetIOSOTAInstallOptions = {
+  limbuildApiUrl: string;
+  execId: string;
+  token?: string;
+};
+
 export async function fetchLimbuildInfo(limbuildApiUrl: string, token?: string) {
   const url = new URL(`${limbuildApiUrl}/info`);
   if (token) {
@@ -59,10 +74,10 @@ export async function startSignedDeviceBuild({
     },
     body: JSON.stringify({
       command: 'xcodebuild',
-      xcodebuild: { sdk: 'iphoneos', configuration: 'Debug' },
+      xcodebuild: { sdk: 'iphoneos' },
       signing: {
         certificateP12Base64,
-        certificatePassword,
+        ...(certificatePassword ? { certificatePassword } : {}),
         provisioningProfileBase64,
       },
     }),
@@ -74,6 +89,21 @@ export async function startSignedDeviceBuild({
   return (await response.json()) as { execId?: string };
 }
 
+export async function getIOSOTAInstall({ limbuildApiUrl, execId, token }: GetIOSOTAInstallOptions) {
+  const url = new URL(`${limbuildApiUrl}/exec/${encodeURIComponent(execId)}/ios/ota`);
+  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(`OTA install metadata failed: HTTP ${response.status} ${body}`);
+  }
+  return (await response.json()) as IOSOTAInstall;
+}
+
 export function watchBuildLogEvents({
   limbuildApiUrl,
   execId,

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

@@ -1,4 +1,5 @@
 import type {
+  DeviceInstallSigningMode,
   ProvisioningProfileInfo,
   PutSigningAssetsInput,
   StoredPairRecord,
@@ -49,35 +50,42 @@ export async function putPairRecord(record: PairRecordPayload, metadata: { produ
 export async function getSigningAssets({
   deviceUDID,
   bundleID,
+  signingMode = 'development',
 }: {
   deviceUDID?: string;
   bundleID?: string;
+  signingMode?: DeviceInstallSigningMode;
 }) {
   const normalizedBundleID = normalizeBundleID(bundleID);
   if (!normalizedBundleID) return undefined;
   const normalizedUDID = normalizeUDID(deviceUDID);
-  const bundleScoped = await getSigningAssetsByID(signingAssetID('bundle', normalizedBundleID));
+  const bundleScoped = await getSigningAssetsByID(signingAssetID('bundle', normalizedBundleID, signingMode));
   if (bundleScoped) return bundleScoped;
   if (normalizedUDID) {
-    const exact = await getSigningAssetsByID(signingAssetID(normalizedUDID, normalizedBundleID));
+    const exact = await getSigningAssetsByID(signingAssetID(normalizedUDID, normalizedBundleID, signingMode));
     if (exact) return exact;
   }
-  const candidates = await findSigningAssetsForBundle(normalizedBundleID);
+  const candidates = await findSigningAssetsForBundle(normalizedBundleID, signingMode);
   return candidates[0];
 }
 
-export async function getLatestSigningAssets() {
+export async function getLatestSigningAssets(signingMode: DeviceInstallSigningMode = 'development') {
   const all = await getAllSigningAssets();
-  return all.sort(
-    (left, right) => new Date(right.updatedAt).getTime() - new Date(left.updatedAt).getTime(),
-  )[0];
+  return all
+    .filter((asset) => (asset.signingMode ?? 'development') === signingMode)
+    .sort(
+      (left, right) => new Date(right.updatedAt).getTime() - new Date(left.updatedAt).getTime(),
+    )[0];
 }
 
-export async function getLatestSigningAssetsWithCertificate(teamID?: string) {
+export async function getLatestSigningAssetsWithCertificate(teamID?: string, signingMode: DeviceInstallSigningMode = 'development') {
   const all = await getAllSigningAssets();
   return all
     .filter((asset) => {
-      if (!asset.certificateID || !asset.certificateP12Base64 || !asset.certificatePassword) {
+      if (!asset.certificateID || !asset.certificateP12Base64) {
+        return false;
+      }
+      if ((asset.signingMode ?? 'development') !== signingMode) {
         return false;
       }
       return !teamID || !asset.teamID || asset.teamID === teamID;
@@ -91,11 +99,13 @@ export async function putSigningAssets(input: PutSigningAssetsInput) {
     throw new Error('Cannot store signing assets without a bundle ID.');
   }
   const normalizedUDID = normalizeUDID(input.deviceUDID);
-  const id = signingAssetID('bundle', normalizedBundleID);
+  const signingMode = input.signingMode ?? 'development';
+  const id = signingAssetID('bundle', normalizedBundleID, signingMode);
   const stored: StoredSigningAssets = {
     ...input,
     id,
     deviceUDID: normalizedUDID || undefined,
+    signingMode,
     bundleID: normalizedBundleID,
     updatedAt: new Date().toISOString(),
   };
@@ -106,11 +116,11 @@ export async function putSigningAssets(input: PutSigningAssetsInput) {
   return stored;
 }
 
-export async function findSigningAssetsForBundle(bundleID?: string) {
+export async function findSigningAssetsForBundle(bundleID?: string, signingMode: DeviceInstallSigningMode = 'development') {
   const normalized = normalizeBundleID(bundleID);
   if (!normalized) return [];
   const all = await getAllSigningAssets();
-  return all.filter((asset) => asset.bundleID === normalized);
+  return all.filter((asset) => asset.bundleID === normalized && (asset.signingMode ?? 'development') === signingMode);
 }
 
 export function profileContainsDevice(profile: ProvisioningProfileInfo, deviceUDID?: string) {
@@ -174,6 +184,7 @@ export function parseProvisioningProfileBytes(bytes: Uint8Array) {
     applicationIdentifier,
     bundleID,
     provisionedDevices: stringArrayValue(value.ProvisionedDevices),
+    getTaskAllow: booleanValue(entitlements['get-task-allow']),
     expirationDate: stringValue(value.ExpirationDate),
   } satisfies ProvisioningProfileInfo;
 }
@@ -193,8 +204,8 @@ async function getAllSigningAssets() {
   );
 }
 
-function signingAssetID(deviceUDID: string, bundleID: string) {
-  return `${deviceUDID}:${bundleID}`;
+function signingAssetID(deviceUDID: string, bundleID: string, signingMode: DeviceInstallSigningMode) {
+  return `${signingMode}:${deviceUDID}:${bundleID}`;
 }
 
 function bundleIDFromApplicationIdentifier(applicationIdentifier?: string) {
@@ -237,6 +248,10 @@ function stringArrayValue(value: unknown) {
   return Array.isArray(value) ? value.filter((item): item is string => typeof item === 'string') : [];
 }
 
+function booleanValue(value: unknown) {
+  return typeof value === 'boolean' ? value : undefined;
+}
+
 function isRecord(value: unknown): value is Record<string, unknown> {
   return typeof value === 'object' && value !== null && !Array.isArray(value);
 }

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

@@ -1,5 +1,7 @@
 export type DeviceInstallLog = (message: string, detail?: string) => void;
 
+export type DeviceInstallSigningMode = 'development' | 'adhoc';
+
 export type DeviceInstallStep = 'signing' | 'connect' | 'build' | 'install';
 
 export type DeviceInstallStepStatus = 'idle' | 'active' | 'complete' | 'error';
@@ -44,6 +46,7 @@ export type ProvisioningProfileInfo = {
   applicationIdentifier?: string;
   bundleID?: string;
   provisionedDevices: string[];
+  getTaskAllow?: boolean;
   expirationDate?: string;
 };
 
@@ -51,11 +54,12 @@ export type StoredSigningAssets = {
   id: string;
   deviceUDID?: string;
   teamID?: string;
+  signingMode?: DeviceInstallSigningMode;
   bundleID: string;
   certificateID?: string;
   certificateP12Base64: string;
   certificateFileName?: string;
-  certificatePassword: string;
+  certificatePassword?: string;
   provisioningProfileBase64: string;
   profileFileName?: string;
   profile: ProvisioningProfileInfo;

package/src/device-build/index.ts

@@ -0,0 +1,42 @@
+export {
+  fetchLimbuildInfo,
+  getIOSOTAInstall,
+  startSignedDeviceBuild,
+  watchBuildLogEvents,
+  type BuildLogEventsOptions,
+  type GetIOSOTAInstallOptions,
+  type IOSOTAInstall,
+  type LimbuildInfo,
+  type StartSignedDeviceBuildOptions,
+} from '../core/device-install/operations/limbuild-client';
+export {
+  getLatestSigningAssets,
+  getLatestSigningAssetsWithCertificate,
+  getReusableAppleSigningAssets,
+  getSigningAssets,
+  parseProvisioningProfile,
+  parseProvisioningProfileBase64,
+  parseProvisioningProfileBytes,
+  profileContainsDevice,
+  profileMatchesBundleID,
+  putAppleGeneratedSigningAssets,
+  putSigningAssets,
+  type AppleSigningAssetCacheInput,
+  type PutAppleGeneratedSigningAssetsInput,
+} from '../core/device-install';
+export {
+  fileToBase64,
+  importSigningAssetsFromFiles,
+  validateProvisioningProfileForInstall,
+  validateSigningAssetsForInstall,
+  type ImportSigningAssetsFromFilesInput,
+  type ValidateSigningAssetsOptions,
+} from './signing';
+export type {
+  BuildLogLine,
+  DeviceInstallBuildStatus,
+  DeviceInstallSigningMode,
+  ProvisioningProfileInfo,
+  PutSigningAssetsInput,
+  StoredSigningAssets,
+} from '../core/device-install/types';

package/src/device-build/react.ts

@@ -0,0 +1,128 @@
+import { useCallback, useEffect, useRef, useState } from 'react';
+import {
+  getIOSOTAInstall,
+  startSignedDeviceBuild,
+  watchBuildLogEvents,
+  type BuildLogLine,
+  type DeviceInstallBuildStatus,
+  type IOSOTAInstall,
+  type StoredSigningAssets,
+} from './index';
+
+export type UseDeviceBuildOptions = {
+  apiUrl?: string;
+  token?: string;
+  signingAssets?: StoredSigningAssets;
+  loadOTAInstall?: boolean;
+};
+
+export type StartDeviceBuildInput = {
+  signingAssets?: StoredSigningAssets;
+};
+
+export type UseDeviceBuildResult = {
+  status: DeviceInstallBuildStatus;
+  logs: BuildLogLine[];
+  execId?: string;
+  otaInstall?: IOSOTAInstall;
+  error?: string;
+  startBuild: (input?: StartDeviceBuildInput) => Promise<string | undefined>;
+  reset: () => void;
+};
+
+export function useDeviceBuild({
+  apiUrl,
+  token,
+  signingAssets,
+  loadOTAInstall = false,
+}: UseDeviceBuildOptions): UseDeviceBuildResult {
+  const [status, setStatus] = useState<DeviceInstallBuildStatus>('idle');
+  const [logs, setLogs] = useState<BuildLogLine[]>([]);
+  const [execId, setExecId] = useState<string | undefined>();
+  const [otaInstall, setOTAInstall] = useState<IOSOTAInstall | undefined>();
+  const [error, setError] = useState<string | undefined>();
+  const stopWatcherRef = useRef<(() => void) | undefined>(undefined);
+
+  useEffect(() => {
+    return () => {
+      stopWatcherRef.current?.();
+      stopWatcherRef.current = undefined;
+    };
+  }, []);
+
+  const reset = useCallback(() => {
+    stopWatcherRef.current?.();
+    stopWatcherRef.current = undefined;
+    setStatus('idle');
+    setLogs([]);
+    setExecId(undefined);
+    setOTAInstall(undefined);
+    setError(undefined);
+  }, []);
+
+  const startBuild = useCallback(
+    async (input: StartDeviceBuildInput = {}) => {
+      if (!apiUrl) {
+        throw new Error('apiUrl is required to start a device build.');
+      }
+      const activeSigningAssets = input.signingAssets ?? signingAssets;
+      if (!activeSigningAssets) {
+        throw new Error('Signing assets are required to start a device build.');
+      }
+      stopWatcherRef.current?.();
+      setStatus('queued');
+      setLogs([]);
+      setExecId(undefined);
+      setOTAInstall(undefined);
+      setError(undefined);
+      try {
+        const result = await startSignedDeviceBuild({
+          limbuildApiUrl: apiUrl,
+          token,
+          certificateP12Base64: activeSigningAssets.certificateP12Base64,
+          certificatePassword: activeSigningAssets.certificatePassword,
+          provisioningProfileBase64: activeSigningAssets.provisioningProfileBase64,
+        });
+        if (!result.execId) {
+          throw new Error('Build request did not return an exec ID.');
+        }
+        setExecId(result.execId);
+        stopWatcherRef.current = watchBuildLogEvents({
+          limbuildApiUrl: apiUrl,
+          token,
+          execId: result.execId,
+          onLine: (line) => setLogs((current) => [...current, line]),
+          onStatus: (nextStatus) => {
+            setStatus(nextStatus);
+            if (nextStatus === 'succeeded' && loadOTAInstall) {
+              void getIOSOTAInstall({ limbuildApiUrl: apiUrl, token, execId: result.execId! })
+                .then(setOTAInstall)
+                .catch((caught) => setError(errorMessage(caught)));
+            }
+          },
+          onError: (caught) => setError(caught.message),
+        });
+        return result.execId;
+      } catch (caught) {
+        setStatus('failed');
+        setError(errorMessage(caught));
+        return undefined;
+      }
+    },
+    [apiUrl, loadOTAInstall, signingAssets, token],
+  );
+
+  return {
+    status,
+    logs,
+    execId,
+    otaInstall,
+    error,
+    startBuild,
+    reset,
+  };
+}
+
+function errorMessage(error: unknown) {
+  return error instanceof Error ? error.message : String(error);
+}

package/src/device-build/signing.ts

@@ -0,0 +1,94 @@
+import {
+  parseProvisioningProfile,
+  profileContainsDevice,
+  profileMatchesBundleID,
+  putSigningAssets,
+} from '../core/device-install/storage';
+import type { DeviceInstallSigningMode, StoredSigningAssets } from '../core/device-install/types';
+
+export type ImportSigningAssetsFromFilesInput = {
+  certificateFile: File;
+  provisioningProfileFile: File;
+  certificatePassword?: string;
+  bundleId?: string;
+  deviceUDID?: string;
+  teamId?: string;
+  signingMode?: DeviceInstallSigningMode;
+  certificateId?: string;
+};
+
+export type ValidateSigningAssetsOptions = {
+  bundleId?: string;
+  deviceUDID?: string;
+  signingMode?: DeviceInstallSigningMode;
+};
+
+export async function importSigningAssetsFromFiles({
+  certificateFile,
+  provisioningProfileFile,
+  certificatePassword,
+  bundleId,
+  deviceUDID,
+  teamId,
+  signingMode = 'development',
+  certificateId,
+}: ImportSigningAssetsFromFilesInput) {
+  const [certificateP12Base64, provisioningProfileBase64, profile] = await Promise.all([
+    fileToBase64(certificateFile),
+    fileToBase64(provisioningProfileFile),
+    parseProvisioningProfile(provisioningProfileFile),
+  ]);
+  validateProvisioningProfileForInstall({ profile, bundleId, deviceUDID, signingMode });
+  return putSigningAssets({
+    bundleID: bundleId ?? profile.bundleID ?? profile.applicationIdentifier ?? provisioningProfileFile.name,
+    deviceUDID,
+    teamID: teamId ?? profile.teamID,
+    signingMode,
+    certificateID: certificateId,
+    certificateP12Base64,
+    certificateFileName: certificateFile.name,
+    certificatePassword: certificatePassword || undefined,
+    provisioningProfileBase64,
+    profileFileName: provisioningProfileFile.name,
+    profile,
+  });
+}
+
+export function validateSigningAssetsForInstall(
+  assets: StoredSigningAssets,
+  options: ValidateSigningAssetsOptions = {},
+) {
+  validateProvisioningProfileForInstall({
+    profile: assets.profile,
+    bundleId: options.bundleId,
+    deviceUDID: options.deviceUDID,
+    signingMode: options.signingMode ?? assets.signingMode,
+  });
+}
+
+export function validateProvisioningProfileForInstall({
+  profile,
+  bundleId,
+  deviceUDID,
+  signingMode,
+}: Pick<StoredSigningAssets, 'profile'> & ValidateSigningAssetsOptions) {
+  if (bundleId && !profileMatchesBundleID(profile, bundleId)) {
+    throw new Error(`Provisioning profile does not match bundle ID ${bundleId}.`);
+  }
+  if (deviceUDID && !profileContainsDevice(profile, deviceUDID)) {
+    throw new Error('Provisioning profile does not include the selected iPhone.');
+  }
+  if (signingMode === 'adhoc' && profile.getTaskAllow) {
+    throw new Error('Ad Hoc mode requires an Ad Hoc provisioning profile, not a development profile.');
+  }
+}
+
+export async function fileToBase64(file: File) {
+  const buffer = await file.arrayBuffer();
+  let binary = '';
+  const bytes = new Uint8Array(buffer);
+  for (const byte of bytes) {
+    binary += String.fromCharCode(byte);
+  }
+  return btoa(binary);
+}

package/src/device-install/index.ts

@@ -1,3 +1,49 @@
-export * from '../core/device-install';
-export { DeviceInstallDialog, DeviceInstallRelay } from '../components/device-install';
-export { useDeviceInstall } from '../hooks/use-device-install';
+import {
+  requestUSBAccess as requestCoreUSBAccess,
+  startInstallRelay,
+  startPairingRelay,
+  type RequestUSBAccessOptions as CoreRequestUSBAccessOptions,
+  type StartInstallRelayOptions,
+  type StartPairingRelayOptions,
+} from '../core/device-install/operations';
+import type { DeviceInstallLog } from '../core/device-install/types';
+
+export {
+  closeDeviceRelayTarget,
+  deviceRelayWebSocketUrl,
+  startInstallRelay as startDeviceInstallRelay,
+  startPairingRelay as startDevicePairingRelay,
+  type DeviceRelayTarget,
+  type StartInstallRelayOptions,
+  type StartPairingRelayOptions,
+} from '../core/device-install/operations';
+export {
+  getPairRecord,
+  normalizeUDID,
+  putPairRecord,
+} from '../core/device-install/storage';
+export type {
+  DeviceHello,
+  DeviceInstallLog,
+  PairRecordPayload,
+  StoredPairRecord,
+} from '../core/device-install/types';
+export { RelayClient } from '../core/device-install/operations';
+
+export type RequestUSBAccessOptions = Partial<CoreRequestUSBAccessOptions>;
+
+export async function requestUSBAccess(options: RequestUSBAccessOptions = {}) {
+  return requestCoreUSBAccess({ log: options.log ?? noopLog });
+}
+
+export async function pairDevice(options: Omit<StartPairingRelayOptions, 'log'> & { log?: DeviceInstallLog }) {
+  return startPairingRelay({ ...options, log: options.log ?? noopLog });
+}
+
+export async function startDeviceInstall(options: Omit<StartInstallRelayOptions, 'log'> & { log?: DeviceInstallLog }) {
+  return startInstallRelay({ ...options, log: options.log ?? noopLog });
+}
+
+function noopLog() {
+  // Intentionally empty. Consumers can pass a logger for progress messages.
+}