@limrun/ui 0.13.8 → 0.14.0-rc.1

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

@@ -15,178 +15,146 @@ export type AppleProvisioningRequest = {
   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()}`);
+type AppleRelayWebSocketMessage<T = unknown> = {
+  id: string;
+  ok: boolean;
+  response?: AppleRelayResponse<T>;
+  error?: string;
+};
+
+export class AppleRelayWebSocketClient {
+  private socket?: WebSocket;
+  private nextId = 1;
+  private readonly pending = new Map<
+    string,
+    {
+      resolve: (response: AppleRelayResponse) => void;
+      reject: (error: Error) => void;
+    }
+  >();
+
+  constructor(
+    private readonly apiUrl: string,
+    private readonly token?: string,
+    private readonly organizationId?: string,
+  ) {}
+
+  async connect() {
+    if (this.socket && this.socket.readyState === WebSocket.OPEN) return;
+    const socket = new WebSocket(appleRelayWebSocketURL(this.apiUrl, this.token, this.organizationId));
+    this.socket = socket;
+    socket.onmessage = (event) => this.handleMessage(event);
+    socket.onclose = () => this.rejectPending(new Error('Apple relay WebSocket closed'));
+    socket.onerror = () => this.rejectPending(new Error('Apple relay WebSocket failed'));
+    await new Promise<void>((resolve, reject) => {
+      socket.onopen = () => resolve();
+      socket.onerror = () => reject(new Error('Apple relay WebSocket connection failed'));
+    });
   }
-  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()}`);
+  request<T = unknown>(type: string, payload?: unknown) {
+    const socket = this.socket;
+    if (!socket || socket.readyState !== WebSocket.OPEN) {
+      throw new Error('Apple relay WebSocket is not connected.');
+    }
+    const id = String(this.nextId++);
+    const response = new Promise<AppleRelayResponse<T>>((resolve, reject) => {
+      this.pending.set(id, {
+        resolve: (value) => resolve(normalizeAppleProxyResponse<T>(value as AppleRelayResponse<T>)),
+        reject,
+      });
+    });
+    socket.send(JSON.stringify({ id, type, ...(payload === undefined ? {} : { payload }) }));
+    return response;
+  }
+
+  close() {
+    this.rejectPending(new Error('Apple relay WebSocket closed'));
+    this.socket?.close();
+    this.socket = undefined;
+  }
+
+  private handleMessage(event: MessageEvent) {
+    const message = JSON.parse(String(event.data)) as AppleRelayWebSocketMessage;
+    const waiter = this.pending.get(message.id);
+    if (!waiter) return;
+    this.pending.delete(message.id);
+    if (!message.ok) {
+      waiter.reject(new Error(message.error || 'Apple relay request failed'));
+      return;
+    }
+    if (!message.response) {
+      waiter.reject(new Error('Apple relay response was empty.'));
+      return;
+    }
+    waiter.resolve(message.response);
+  }
+
+  private rejectPending(error: Error) {
+    for (const waiter of this.pending.values()) {
+      waiter.reject(error);
+    }
+    this.pending.clear();
   }
 }
 
+export async function openAppleRelayWebSocket(apiUrl: string, token?: string, organizationId?: string) {
+  const client = new AppleRelayWebSocketClient(apiUrl, token, organizationId);
+  await client.connect();
+  return client;
+}
+
 export async function proxySrpInit(
-  limbuildApiUrl: string,
-  appleSessionId: string,
+  relay: AppleRelayWebSocketClient,
   payload: AppleSRPInitRequest,
-  token?: string,
 ) {
-  return postAppleProxy<AppleSRPInitResponse>(
-    limbuildApiUrl,
-    '/apple/auth/srp/init',
-    appleSessionId,
-    payload,
-    token,
-  );
+  return relay.request<AppleSRPInitResponse>('srpInit', payload);
 }
 
 export async function proxySrpComplete(
-  limbuildApiUrl: string,
-  appleSessionId: string,
+  relay: AppleRelayWebSocketClient,
   payload: AppleSRPCompleteProof & {
     rememberMe: boolean;
     trustTokens: string[];
   },
-  token?: string,
 ) {
-  return postAppleProxy(limbuildApiUrl, '/apple/auth/srp/complete', appleSessionId, payload, token);
+  return relay.request('srpComplete', payload);
 }
 
-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 triggerTrustedDeviceTwoFactor(relay: AppleRelayWebSocketClient) {
+  return relay.request('triggerTrustedDevice2FA');
 }
 
 export async function triggerPhoneTwoFactor(
-  limbuildApiUrl: string,
-  appleSessionId: string,
+  relay: AppleRelayWebSocketClient,
   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;
+  return relay.request('triggerPhone2FA', { phoneNumberId, mode });
 }
 
-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 proxyTwoFactorCode(relay: AppleRelayWebSocketClient, code: string) {
+  return relay.request('submitTrustedDevice2FA', { code });
 }
 
 export async function proxyPhoneTwoFactorCode(
-  limbuildApiUrl: string,
-  appleSessionId: string,
+  relay: AppleRelayWebSocketClient,
   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;
+  return relay.request('submitPhone2FA', { phoneNumberId, mode, code });
 }
 
-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 fetchAppleAccountSession(relay: AppleRelayWebSocketClient) {
+  return relay.request('finalize');
 }
 
 export async function proxyProvisioningRequest<T = unknown>(
-  limbuildApiUrl: string,
-  appleSessionId: string,
+  relay: AppleRelayWebSocketClient,
   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>);
+  return relay.request<T>('provisioning', request);
 }
 
 function normalizeAppleProxyResponse<T>(response: AppleRelayResponse<T>) {
@@ -203,23 +171,15 @@ function normalizeAppleProxyResponse<T>(response: AppleRelayResponse<T>) {
   }
 }
 
-function limbuildURL(limbuildApiUrl: string, path: string, token?: string) {
-  const base = limbuildApiUrl.replace(/\/$/, '');
-  const suffix = path.startsWith('/') ? path : `/${path}`;
-  const url = new URL(`${base}${suffix}`);
+function appleRelayWebSocketURL(apiUrl: string, token?: string, organizationId?: string) {
+  const url = new URL(apiUrl);
+  url.protocol = url.protocol === 'https:' ? 'wss:' : 'ws:';
+  url.pathname = `${url.pathname.replace(/\/$/, '')}/ios/appstoreconnect/ws`;
   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}` } : {};
+  if (organizationId) {
+    url.searchParams.set('organization', organizationId);
+  }
+  return url.toString();
 }

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

@@ -14,6 +14,7 @@ export type StartSignedDeviceBuildOptions = {
   certificateP12Base64: string;
   certificatePassword?: string;
   provisioningProfileBase64: string;
+  signedUploadUrl?: string;
 };
 
 export type BuildLogEventsOptions = {
@@ -61,6 +62,7 @@ export async function startSignedDeviceBuild({
   certificateP12Base64,
   certificatePassword,
   provisioningProfileBase64,
+  signedUploadUrl,
 }: StartSignedDeviceBuildOptions) {
   const url = new URL(`${limbuildApiUrl}/exec`);
   if (token) {
@@ -75,6 +77,7 @@ export async function startSignedDeviceBuild({
     body: JSON.stringify({
       command: 'xcodebuild',
       xcodebuild: { sdk: 'iphoneos' },
+      ...(signedUploadUrl ? { signedUploadUrl } : {}),
       signing: {
         certificateP12Base64,
         ...(certificatePassword ? { certificatePassword } : {}),

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

@@ -18,14 +18,21 @@ export type RequestUSBAccessOptions = {
 };
 
 export type StartPairingRelayOptions = {
-  limbuildApiUrl: string;
+  registryApiUrl: string;
   token?: string;
+  organizationId?: string;
   log: DeviceInstallLog;
   target: DeviceRelayTarget;
 };
 
+export type InstallSource =
+  | { assetId: string; assetName?: never; downloadUrl?: never }
+  | { assetId?: never; assetName: string; downloadUrl?: never }
+  | { assetId?: never; assetName?: never; downloadUrl: string };
+
 export type StartInstallRelayOptions = StartPairingRelayOptions & {
   pairRecord: PairRecordPayload;
+  installSource: InstallSource;
 };
 
 export async function requestUSBAccess({ log }: RequestUSBAccessOptions) {
@@ -39,8 +46,8 @@ export async function requestUSBAccess({ log }: RequestUSBAccessOptions) {
   return target;
 }
 
-export async function startPairingRelay({ limbuildApiUrl, token, log, target }: StartPairingRelayOptions) {
-  const deviceRelayUrl = deviceRelayWebSocketUrl(limbuildApiUrl, token);
+export async function startPairingRelay({ registryApiUrl, token, organizationId, log, target }: StartPairingRelayOptions) {
+  const deviceRelayUrl = deviceRelayWebSocketUrl(registryApiUrl, token, organizationId);
   let relay: RelayClient | undefined;
   try {
     relay = await connectRelay(deviceRelayUrl, target, log);
@@ -53,17 +60,19 @@ export async function startPairingRelay({ limbuildApiUrl, token, log, target }:
 }
 
 export async function startInstallRelay({
-  limbuildApiUrl,
+  registryApiUrl,
   token,
+  organizationId,
   log,
   target,
   pairRecord,
+  installSource,
 }: StartInstallRelayOptions) {
-  const deviceRelayUrl = deviceRelayWebSocketUrl(limbuildApiUrl, token);
+  const deviceRelayUrl = deviceRelayWebSocketUrl(registryApiUrl, token, organizationId);
   let relay: RelayClient | undefined;
   try {
     relay = await connectRelay(deviceRelayUrl, target, log);
-    await relay.startInstall(pairRecord);
+    await relay.startInstall(pairRecord, installSource);
     return relay;
   } catch (error) {
     relay?.close();
@@ -182,13 +191,16 @@ function orderedUsbmuxCandidates(device: USBDevice) {
   ];
 }
 
-export function deviceRelayWebSocketUrl(limbuildApiUrl: string, token?: string) {
-  const url = new URL(limbuildApiUrl);
+export function deviceRelayWebSocketUrl(registryApiUrl: string, token?: string, organizationId?: string) {
+  const url = new URL(registryApiUrl);
   url.protocol = url.protocol === 'https:' ? 'wss:' : 'ws:';
-  url.pathname = `${url.pathname.replace(/\/$/, '')}/device/ws`;
+  url.pathname = `${url.pathname.replace(/\/$/, '')}/ios/device/ws`;
   if (token) {
     url.searchParams.set('token', token);
   }
+  if (organizationId) {
+    url.searchParams.set('organization', organizationId);
+  }
   return url.toString();
 }
 

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

@@ -1,5 +1,6 @@
 import type { DeviceHello, DeviceInstallLog, PairRecordPayload } from '../types';
 import { decodeFrame, decodeJson, encodeFrame, encodeJson, RelayMessageType } from './relay-protocol';
+import type { InstallSource } from './operations';
 import {
   openStream,
   receiveStreamData,
@@ -83,12 +84,12 @@ export class RelayClient {
     return recordPromise;
   }
 
-  async startInstall(pairRecord: PairRecordPayload) {
+  async startInstall(pairRecord: PairRecordPayload, installSource: InstallSource) {
     await this.send({
       type: RelayMessageType.StartInstall,
       requestId: 0,
       streamId: 0,
-      payload: encodeJson(pairRecord),
+      payload: encodeJson({ ...pairRecord, ...installSource }),
     });
     this.log('Installation requested');
   }

package/src/device-build/react.ts

@@ -18,6 +18,7 @@ export type UseDeviceBuildOptions = {
 
 export type StartDeviceBuildInput = {
   signingAssets?: StoredSigningAssets;
+  signedUploadUrl?: string;
 };
 
 export type UseDeviceBuildResult = {
@@ -82,6 +83,7 @@ export function useDeviceBuild({
           certificateP12Base64: activeSigningAssets.certificateP12Base64,
           certificatePassword: activeSigningAssets.certificatePassword,
           provisioningProfileBase64: activeSigningAssets.provisioningProfileBase64,
+          signedUploadUrl: input.signedUploadUrl,
         });
         if (!result.execId) {
           throw new Error('Build request did not return an exec ID.');

package/src/device-install/README.md

@@ -3,7 +3,7 @@
 Build a signed iOS app on Limrun and install it onto a physical iPhone that's
 plugged into the user's own computer — straight from the browser, no Mac and no
 Xcode on their machine. The browser talks to the iPhone over WebUSB; Limrun runs
-the native pairing and install (`libimobiledevice`) on its side and relays the
+the native pairing and install on its side and relays the
 USB traffic over a WebSocket.
 
 `@limrun/ui` ships the browser primitives and React hooks; your app owns the UI.
@@ -83,7 +83,7 @@ user only taps **Trust** once per device.
 ```tsx
 import { useDeviceInstallRelay } from '@limrun/ui/device-install/react';
 
-const install = useDeviceInstallRelay({ apiUrl, token, log: (m, d) => console.log(m, d) });
+const install = useDeviceInstallRelay({ apiUrl, token, organizationId, log: (m, d) => console.log(m, d) });
 
 // 1. Pick the iPhone (shows Chrome's WebUSB chooser).
 await install.requestUSBAccess();
@@ -156,13 +156,13 @@ import {
   putAppleGeneratedSigningAssets,
 } from '@limrun/ui/device-build';
 
-const appleLogin = useAppleIDLogin({ limbuildApiUrl: apiUrl, token });
+const appleLogin = useAppleIDLogin({ registryApiUrl: apiUrl, token, organizationId });
 const session = await appleLogin.startLogin({ accountName, password });
 if (session?.requiresTwoFactor) await appleLogin.submitTwoFactorCode(code);
 
 // Resolve the team id across all three fields Apple may use.
 const teamId = team.teamId ?? String(team.providerId ?? team.publicProviderId ?? '');
-const base = { apiUrl, token, appleSessionId: appleLogin.session!.appleSessionId, teamId };
+const base = { relay: appleLogin.session!.relay, teamId };
 
 // Register the paired iPhone (no-op if already registered).
 await registerAppleDevice({ ...base, deviceUDID, name: 'My iPhone' });
@@ -298,7 +298,7 @@ export function InstallToIPhone({
   const [log, setLog] = useState<string[]>([]);
   const append = (m: string, d?: string) => setLog((l) => [d ? `${m}: ${d}` : m, ...l]);
 
-  const install = useDeviceInstallRelay({ apiUrl, token, log: append });
+  const install = useDeviceInstallRelay({ apiUrl, token, organizationId, log: append });
   const build = useDeviceBuild({ apiUrl, token, signingAssets });
 
   async function prepare() {

package/src/device-install/demo/demo.tsx

@@ -64,6 +64,7 @@ const emptyAppleResources: AppleResourceState = {
 const storageKeys = {
   apiUrl: 'limrun-device-demo-api-url',
   token: 'limrun-device-demo-token',
+  ipaDownloadUrl: 'limrun-device-demo-ipa-download-url',
   bundleId: 'limrun-device-demo-bundle-id',
   certificatePassword: 'limrun-device-demo-certificate-password',
   appleAccount: 'limrun-device-demo-apple-account',
@@ -72,6 +73,7 @@ const storageKeys = {
 function App() {
   const [apiUrl, setApiUrl] = useLocalStorage(storageKeys.apiUrl, 'http://127.0.0.1:8080');
   const [token, setToken] = useLocalStorage(storageKeys.token, '');
+  const [ipaDownloadUrl, setIPADownloadUrl] = useLocalStorage(storageKeys.ipaDownloadUrl, '');
   const [bundleId, setBundleId] = useLocalStorage(storageKeys.bundleId, '');
   const [appleAccount, setAppleAccount] = useLocalStorage(storageKeys.appleAccount, '');
   const [certificatePassword, setCertificatePassword] = useLocalStorage(storageKeys.certificatePassword, '');
@@ -131,7 +133,7 @@ function App() {
   });
 
   const appleLogin = useAppleIDLogin({
-    limbuildApiUrl: apiUrl.trim(),
+    registryApiUrl: apiUrl.trim(),
     token: token.trim() || undefined,
   });
 
@@ -148,10 +150,10 @@ function App() {
   const selectedProfile = resources.profiles.find(
     (profile) => stringField(profile, 'provisioningProfileId') === selectedProfileId,
   );
-  const canUseApple = !!apiUrl.trim() && !!appleLogin.session?.appleSessionId && !!developerTeamId;
+  const canUseApple = !!apiUrl.trim() && !!appleLogin.session?.relay && !!developerTeamId;
   const canPrepareSigning = !!certificateFile && !!profileFile;
   const canStartBuild = !!signingAssets && build.status !== 'queued' && build.status !== 'running';
-  const canInstall = install.canInstall && build.status === 'succeeded';
+  const canInstall = install.canInstall && build.status === 'succeeded' && !!ipaDownloadUrl.trim();
 
   // Live per-step status used by the overview stepper and the section pills.
   const pairStep: StepView =
@@ -182,7 +184,7 @@ function App() {
 
   async function runInstall() {
     setInstallPhase('installing');
-    const relay = await install.startInstallation();
+    const relay = await install.startInstallation({ downloadUrl: ipaDownloadUrl.trim() });
     if (!relay) setInstallPhase('error');
   }
 
@@ -246,7 +248,7 @@ function App() {
       });
       setApplePassword('');
       if (session && !session.requiresTwoFactor) {
-        await loadAppleTeams(session.appleSessionId);
+        await loadAppleTeams(session.relay);
       }
     } catch (error) {
       setPrepareError(errorMessage(error));
@@ -262,7 +264,7 @@ function App() {
     try {
       await appleLogin.submitTwoFactorCode(twoFactorCode);
       setTwoFactorCode('');
-      await loadAppleTeams(appleLogin.session.appleSessionId);
+      await loadAppleTeams(appleLogin.session.relay);
     } catch (error) {
       setPrepareError(errorMessage(error));
     } finally {
@@ -270,17 +272,13 @@ function App() {
     }
   }
 
-  async function loadAppleTeams(appleSessionId = appleLogin.session?.appleSessionId) {
-    if (!apiUrl.trim() || !appleSessionId) return;
+  async function loadAppleTeams(relay = appleLogin.session?.relay) {
+    if (!apiUrl.trim() || !relay) return;
     setAppleBusy('teams');
     setPrepareError(undefined);
     try {
       await appleLogin.finalize().catch(() => undefined);
-      const teams = await listAppleTeams({
-        apiUrl: apiUrl.trim(),
-        token: token.trim() || undefined,
-        appleSessionId,
-      });
+      const teams = await listAppleTeams({ relay });
       setResources((current) => ({ ...current, teams }));
       const firstTeamId = teams.map(appleTeamSelectionId).find(Boolean) ?? '';
       setSelectedTeamId(firstTeamId);
@@ -288,7 +286,7 @@ function App() {
         teams.find((team) => appleTeamSelectionId(team) === firstTeamId),
       );
       if (firstDeveloperTeamId) {
-        await loadAppleResources(firstDeveloperTeamId, appleSessionId);
+        await loadAppleResources(firstDeveloperTeamId, relay);
       }
     } catch (error) {
       setPrepareError(errorMessage(error));
@@ -299,13 +297,11 @@ function App() {
 
   async function loadAppleResources(
     teamId = developerTeamId,
-    appleSessionId = appleLogin.session?.appleSessionId,
+    relay = appleLogin.session?.relay,
   ) {
-    if (!apiUrl.trim() || !appleSessionId || !teamId) return;
+    if (!apiUrl.trim() || !relay || !teamId) return;
     const base = {
-      apiUrl: apiUrl.trim(),
-      token: token.trim() || undefined,
-      appleSessionId,
+      relay,
       teamId,
     };
     const [appIds, devices, certificates, profiles] = await Promise.all([
@@ -336,9 +332,7 @@ function App() {
     setPrepareError(undefined);
     try {
       const app = await createAppleBundleID({
-        apiUrl: apiUrl.trim(),
-        token: token.trim() || undefined,
-        appleSessionId: appleLogin.session.appleSessionId,
+        relay: appleLogin.session.relay,
         teamId: developerTeamId,
         bundleId: bundleId.trim(),
       });
@@ -359,9 +353,7 @@ function App() {
     setPrepareError(undefined);
     try {
       await registerAppleDevice({
-        apiUrl: apiUrl.trim(),
-        token: token.trim() || undefined,
-        appleSessionId: appleLogin.session.appleSessionId,
+        relay: appleLogin.session.relay,
         teamId: developerTeamId,
         deviceUDID: selectedUDID,
         name: install.device?.hello.productName ?? 'Limrun iPhone',
@@ -393,9 +385,7 @@ function App() {
     setPrepareError(undefined);
     try {
       const base = {
-        apiUrl: apiUrl.trim(),
-        token: token.trim() || undefined,
-        appleSessionId: appleLogin.session.appleSessionId,
+        relay: appleLogin.session.relay,
         teamId: developerTeamId,
       };
       let certificateId = storedCertificate?.certificateID;
@@ -599,6 +589,14 @@ function App() {
         <p className="hint">
           Run this page on <code>localhost</code> or HTTPS. WebUSB is available in Chromium browsers only.
         </p>
+        <label>
+          IPA download URL
+          <input
+            value={ipaDownloadUrl}
+            onChange={(event) => setIPADownloadUrl(event.currentTarget.value)}
+            placeholder="https://asset-storage.example/app.ipa"
+          />
+        </label>
       </section>
 
       <section className="card">

package/src/device-install/index.ts

@@ -14,6 +14,7 @@ export {
   startInstallRelay as startDeviceInstallRelay,
   startPairingRelay as startDevicePairingRelay,
   type DeviceRelayTarget,
+  type InstallSource,
   type StartInstallRelayOptions,
   type StartPairingRelayOptions,
 } from '../core/device-install/operations';