@limrun/ui 0.9.0-rc.12 → 0.9.0-rc.14

package/README.md

@@ -4,6 +4,15 @@
 
 See [examples](../../examples/) to see how it can be used.
 
+## Real Device Installation
+
+`@limrun/ui` also includes a browser-based iPhone installation flow:
+
+- `@limrun/ui/device-install/react` exports the headless `useDeviceInstall` hook for clients that want to render their own UI.
+- `@limrun/ui/device-install` exports the guided `DeviceInstallDialog` UI, which walks users through a signed device build, USB access, browser pairing, and installation.
+
+WebUSB requires a Chromium browser and a secure context. Pair records and signing assets, including the `.p12` password, are stored in the browser's IndexedDB.
+
 ### Releasing
 
 This package is not part of generated SDK, hence you need to publish it manually in GitHub Actions.

package/dist/components/device-install/device-install-dialog.d.ts

@@ -0,0 +1,5 @@
+import { UseDeviceInstallOptions } from '../../hooks/use-device-install';
+export type DeviceInstallDialogProps = UseDeviceInstallOptions & {
+    disabled?: boolean;
+};
+export declare function DeviceInstallDialog({ disabled, ...hookOptions }: DeviceInstallDialogProps): import("react/jsx-runtime").JSX.Element;

package/dist/components/device-install/index.d.ts

@@ -0,0 +1,2 @@
+export { DeviceInstallDialog, DeviceInstallDialog as DeviceInstallRelay } from './device-install-dialog';
+export type { DeviceInstallDialogProps } from './device-install-dialog';

package/dist/components/remote-control.d.ts

@@ -94,33 +94,25 @@ interface RemoteControlProps {
      */
     axMaxBackoffMs?: number;
     /**
-     * Optional outbound camera input.
+     * Fires whenever the iOS simulator's camera demand state changes —
+     * i.e. an app inside the sim called
+     * `[AVCaptureSession startRunning]` or `[stopRunning]`. The
+     * component handles the `navigator.mediaDevices.getUserMedia` prompt
+     * and SDP plumbing internally; this callback is purely so the host
+     * UI can render a status indicator ("simulator is using your
+     * camera", etc.).
      *
-     * When provided, every video track on this `MediaStream` is forwarded
-     * up the same `RTCPeerConnection` that already carries the device
-     * screen downstream. On iOS instances, the limulator-side injector
-     * splices those frames into apps that use AVFoundation, so the user's
-     * browser camera becomes the iOS camera (`AVCaptureDevice.default(for:
-     * .video)`).
+     * `active` reflects whether the sim is currently asking for
+     * frames. `granted` is set only on the call that follows a
+     * `getUserMedia` attempt: `true` when the user accepted the
+     * browser prompt, `false` when they denied or the call failed
+     * (in which case the limulator side switches to a black-frame
+     * fallback so the app keeps ticking).
      *
-     * Today this is only honored by iOS instances launched with the
-     * camera runtime; Android instances ignore it.
-     *
-     * Lifecycle expectations:
-     * - Pass `null`/`undefined` to skip outbound camera (default).
-     * - Pass a `MediaStream` obtained from
-     *   `navigator.mediaDevices.getUserMedia({ video: true })` (or any
-     *   other source — screen capture, virtual camera, etc.).
-     * - Changing the `MediaStream.id` triggers a connection restart so
-     *   the new track is included in the SDP offer. The reference itself
-     *   is allowed to be unstable across renders — we key the reconnect
-     *   on `id`, not object identity, so memoization isn't required.
-     * - Stopping the tracks (e.g. `track.stop()`) on the parent side is
-     *   sufficient to cut the outbound feed without restarting; the peer
-     *   connection just stops getting frames on that track. To fully
-     *   detach the track from the SDP, swap the prop to `null`.
+     * Only iOS instances ever fire this callback; Android instances
+     * have no camera-injector path and stay silent.
      */
-    cameraStream?: MediaStream | null;
+    onCameraDemandChange?: (active: boolean, granted?: boolean) => void;
 }
 interface ScreenshotData {
     dataUri: string;

package/dist/core/device-install/apple/client.d.ts

@@ -0,0 +1,17 @@
+import { AppleRelayResponse } from './relay';
+export type AppleIDLoginInput = {
+    limbuildApiUrl: string;
+    accountName: string;
+    password: string;
+    token?: string;
+};
+export type AppleIDLoginResult = {
+    appleSessionId: string;
+    completeResponse: AppleRelayResponse;
+    twoFactorChallengeResponse?: AppleRelayResponse;
+    requiresTwoFactor: boolean;
+    finishTwoFactor: (code: string) => Promise<AppleRelayResponse>;
+    finalize: () => Promise<AppleRelayResponse>;
+    close: () => Promise<void>;
+};
+export declare function startBrowserOwnedAppleIDLogin({ limbuildApiUrl, accountName, password, token, }: AppleIDLoginInput): Promise<AppleIDLoginResult>;

package/dist/core/device-install/apple/crypto.d.ts

@@ -0,0 +1,20 @@
+export type AppleSigningKeyMaterial = {
+    privateKey: CryptoKey;
+    privateKeyPKCS8Base64: string;
+    publicKeySPKIBase64: string;
+    csrPEM: string;
+    csrBase64: string;
+};
+export type AppleCSRInput = {
+    commonName: string;
+    emailAddress?: string;
+};
+export type ExportP12Input = {
+    privateKeyPKCS8Base64: string;
+    certificateBase64?: string;
+    certificatePEM?: string;
+    password: string;
+    friendlyName?: string;
+};
+export declare function generateAppleSigningKeyAndCSR(input: AppleCSRInput): Promise<AppleSigningKeyMaterial>;
+export declare function exportAppleCertificateP12(input: ExportP12Input): string;

package/dist/core/device-install/apple/gsa-srp.d.ts

@@ -0,0 +1,26 @@
+export type AppleSRPProtocol = 's2k' | 's2k_fo';
+export type AppleSRPInitRequest = {
+    a: string;
+    accountName: string;
+    protocols: AppleSRPProtocol[];
+};
+export type AppleSRPInitResponse = {
+    iteration: number;
+    salt: string;
+    protocol: AppleSRPProtocol;
+    b: string;
+    c: string;
+};
+export type AppleSRPCompleteProof = {
+    accountName: string;
+    m1: string;
+    m2: string;
+    c: string;
+};
+export declare class AppleGsaSrpClient {
+    private readonly accountName;
+    private srpClient?;
+    constructor(accountName: string);
+    init(): Promise<AppleSRPInitRequest>;
+    complete(password: string, serverData: AppleSRPInitResponse): Promise<AppleSRPCompleteProof>;
+}

package/dist/core/device-install/apple/index.d.ts

@@ -0,0 +1,5 @@
+export * from './client';
+export * from './crypto';
+export * from './gsa-srp';
+export * from './provisioning';
+export * from './relay';

package/dist/core/device-install/apple/provisioning.d.ts

@@ -0,0 +1,161 @@
+import { ProvisioningProfileInfo, StoredSigningAssets } from '../types';
+import { AppleProvisioningRequest } from './relay';
+export type AppleDeveloperPortalTeam = {
+    name?: string;
+    teamId?: string;
+    providerId?: string | number;
+    publicProviderId?: string;
+    type?: string;
+    subType?: string;
+};
+export type AppleDeveloperPortalDevice = {
+    deviceId?: string;
+    name?: string;
+    deviceNumber?: string;
+    deviceClass?: string;
+    model?: string;
+    status?: string;
+};
+export type AppleDeveloperPortalAppID = {
+    appId?: string;
+    appIdId?: string;
+    identifier?: string;
+    bundleId?: string;
+    name?: string;
+    prefix?: string;
+    platform?: string;
+};
+export type AppleDeveloperPortalResponse = {
+    resultCode?: number;
+    resultString?: string;
+    userString?: string;
+    teams?: AppleDeveloperPortalTeam[];
+    provider?: AppleDeveloperPortalTeam;
+    availableProviders?: AppleDeveloperPortalTeam[];
+    appIds?: AppleDeveloperPortalAppID[];
+    devices?: AppleDeveloperPortalDevice[];
+    certRequests?: Array<Record<string, unknown>>;
+    certRequest?: Record<string, unknown>;
+    appId?: Record<string, unknown>;
+    device?: Record<string, unknown>;
+    provisioningProfile?: Record<string, unknown>;
+    provisioningProfiles?: Array<Record<string, unknown>>;
+};
+export type AppleProvisioningContext = {
+    bundleID: string;
+    deviceUDID: string;
+    teamID?: string;
+};
+export type AppleSigningAssetCacheInput = {
+    bundleID: string;
+    deviceUDID?: string;
+    teamID?: string;
+};
+export type PutAppleGeneratedSigningAssetsInput = {
+    bundleID: string;
+    deviceUDID?: string;
+    teamID?: string;
+    certificateID?: string;
+    certificateP12Base64: string;
+    certificatePassword: string;
+    provisioningProfileBase64: string;
+    profile: ProvisioningProfileInfo;
+};
+export declare function listTeamsRequest(): AppleProvisioningRequest;
+export declare function findBundleIDRequest({ bundleID, teamID }: Pick<AppleProvisioningContext, 'bundleID' | 'teamID'>): {
+    method: "POST";
+    path: string;
+    payload: Record<string, unknown>;
+};
+export declare function findDeviceRequest({ deviceUDID, teamID }: Pick<AppleProvisioningContext, 'deviceUDID' | 'teamID'>): {
+    method: "POST";
+    path: string;
+    payload: Record<string, unknown>;
+};
+export declare function findDevelopmentCertificatesRequest(teamID?: string): {
+    method: "POST";
+    path: string;
+    payload: Record<string, unknown>;
+};
+export declare function findDevelopmentProfilesRequest({ bundleID, teamID, }: Pick<AppleProvisioningContext, 'bundleID' | 'teamID'>): {
+    method: "POST";
+    path: string;
+    payload: Record<string, unknown>;
+};
+export declare function registerDeviceRequest({ deviceUDID, teamID, name, }: Pick<AppleProvisioningContext, 'deviceUDID' | 'teamID'> & {
+    name?: string;
+}): {
+    method: "POST";
+    path: string;
+    payload: {
+        teamId: string;
+        deviceNames: string;
+        deviceNumbers: string;
+        deviceClasses: string;
+        register: string;
+    };
+};
+export declare function createBundleIDRequest({ bundleID, teamID, name, }: Pick<AppleProvisioningContext, 'bundleID' | 'teamID'> & {
+    name?: string;
+}): {
+    method: "POST";
+    path: string;
+    payload: {
+        teamId: string;
+        name: string;
+        identifier: string;
+        type: string;
+    };
+};
+export declare function submitDevelopmentCSRRequest({ csrPEM, teamID, }: {
+    csrPEM: string;
+    teamID?: string;
+}): {
+    method: "POST";
+    path: string;
+    payload: {
+        teamId: string;
+        type: string;
+        csrContent: string;
+    };
+};
+export declare function downloadCertificateRequest(certificateID: string, teamID?: string): {
+    method: "GET";
+    path: string;
+    payload: {
+        teamId: string;
+        certificateId: string;
+        type: string;
+    };
+};
+export declare function createDevelopmentProfileRequest({ bundleID, teamID, appIDID, certificateID, deviceIDs, name, }: Pick<AppleProvisioningContext, 'bundleID' | 'teamID'> & {
+    appIDID: string;
+    certificateID: string;
+    deviceIDs: string[];
+    name?: string;
+}): {
+    method: "POST";
+    path: string;
+    payload: {
+        teamId: string;
+        provisioningProfileName: string;
+        certificateIds: string[];
+        appIdId: string;
+        deviceIds: string[];
+        distributionType: string;
+        subPlatform: string;
+    };
+};
+export declare function downloadProfileRequest(profileID: string, teamID?: string): {
+    method: "GET";
+    path: string;
+    payload: {
+        teamId: string;
+        provisioningProfileId: string;
+    };
+};
+export declare function getReusableAppleSigningAssets({ bundleID, deviceUDID, teamID, }: AppleSigningAssetCacheInput): Promise<StoredSigningAssets | undefined>;
+export declare function putAppleGeneratedSigningAssets(input: PutAppleGeneratedSigningAssetsInput): Promise<StoredSigningAssets>;
+export declare function storedSigningAssetsReusable(stored: StoredSigningAssets, { bundleID, deviceUDID, teamID }: AppleSigningAssetCacheInput): boolean;
+export declare function selectDeveloperPortalTeam(body: unknown): AppleDeveloperPortalTeam | undefined;
+export declare function teamIDCandidates(body: unknown): string[];

package/dist/core/device-install/apple/relay.d.ts

@@ -0,0 +1,29 @@
+import { 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 declare function createAppleRelaySession(limbuildApiUrl: string, token?: string): Promise<{
+    appleSessionId: string;
+}>;
+export declare function deleteAppleRelaySession(limbuildApiUrl: string, appleSessionId: string, token?: string): Promise<void>;
+export declare function proxySrpInit(limbuildApiUrl: string, appleSessionId: string, payload: AppleSRPInitRequest, token?: string): Promise<AppleRelayResponse<AppleSRPInitResponse>>;
+export declare function proxySrpComplete(limbuildApiUrl: string, appleSessionId: string, payload: AppleSRPCompleteProof & {
+    rememberMe: boolean;
+    trustTokens: string[];
+}, token?: string): Promise<AppleRelayResponse<unknown>>;
+export declare function triggerTrustedDeviceTwoFactor(limbuildApiUrl: string, appleSessionId: string, token?: string): Promise<AppleRelayResponse<unknown>>;
+export declare function triggerPhoneTwoFactor(limbuildApiUrl: string, appleSessionId: string, phoneNumberId: number, mode?: string, token?: string): Promise<AppleRelayResponse<unknown>>;
+export declare function proxyTwoFactorCode(limbuildApiUrl: string, appleSessionId: string, code: string, token?: string): Promise<AppleRelayResponse<unknown>>;
+export declare function proxyPhoneTwoFactorCode(limbuildApiUrl: string, appleSessionId: string, phoneNumberId: number, code: string, mode?: string, token?: string): Promise<AppleRelayResponse<unknown>>;
+export declare function fetchAppleAccountSession(limbuildApiUrl: string, appleSessionId: string, token?: string): Promise<AppleRelayResponse<unknown>>;
+export declare function proxyProvisioningRequest<T = unknown>(limbuildApiUrl: string, appleSessionId: string, request: AppleProvisioningRequest, token?: string): Promise<AppleRelayResponse<T>>;

package/dist/core/device-install/index.d.ts

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

package/dist/core/device-install/operations/index.d.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/dist/core/device-install/operations/limbuild-client.d.ts

@@ -0,0 +1,28 @@
+import { 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 declare function fetchLimbuildInfo(limbuildApiUrl: string, token?: string): Promise<LimbuildInfo>;
+export declare function startSignedDeviceBuild({ limbuildApiUrl, token, certificateP12Base64, certificatePassword, provisioningProfileBase64, }: StartSignedDeviceBuildOptions): Promise<{
+    execId?: string;
+}>;
+export declare function watchBuildLogEvents({ limbuildApiUrl, execId, token, onLine, onStatus, onError, }: BuildLogEventsOptions): () => void;

package/dist/core/device-install/operations/operations.d.ts

@@ -0,0 +1,32 @@
+import { DeviceHello, DeviceInstallLog, PairRecordPayload } from '../types';
+import { RelayClient } from './relay-client';
+import { UsbmuxSession } from './usbmux';
+import { 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 declare function requestUSBAccess({ log }: RequestUSBAccessOptions): Promise<DeviceRelayTarget>;
+export declare function startPairingRelay({ limbuildApiUrl, token, log, target }: StartPairingRelayOptions): Promise<{
+    relay: RelayClient;
+    pairRecord: PairRecordPayload;
+    target: DeviceRelayTarget;
+}>;
+export declare function startInstallRelay({ limbuildApiUrl, token, log, target, pairRecord, }: StartInstallRelayOptions): Promise<RelayClient>;
+export declare function closeDeviceRelayTarget(target: DeviceRelayTarget | undefined, log?: DeviceInstallLog): Promise<void>;
+export declare function deviceRelayWebSocketUrl(limbuildApiUrl: string, token?: string): string;

package/dist/core/device-install/operations/relay-client.d.ts

@@ -0,0 +1,25 @@
+import { DeviceHello, DeviceInstallLog, PairRecordPayload } from '../types';
+import { UsbmuxSession } from './usbmux';
+export declare class RelayClient {
+    private readonly webSocketUrl;
+    private readonly session;
+    private readonly deviceHello;
+    private readonly log;
+    private socket?;
+    private streams;
+    private frameQueue;
+    private closed;
+    private pairRecordWaiter?;
+    constructor(webSocketUrl: string, session: UsbmuxSession, deviceHello: DeviceHello, log: DeviceInstallLog);
+    connect(): Promise<void>;
+    startPairing(): Promise<PairRecordPayload>;
+    startInstall(pairRecord: PairRecordPayload): Promise<void>;
+    close(): void;
+    private enqueueFrame;
+    private handleFrame;
+    private handleError;
+    private handlePairRecordReady;
+    private handleOpenStream;
+    private pumpDeviceToServer;
+    private send;
+}

package/dist/core/device-install/operations/relay-protocol.d.ts

@@ -0,0 +1,27 @@
+export declare const RELAY_PROTOCOL_VERSION = 1;
+export declare const RELAY_HEADER_BYTES = 16;
+export declare const RelayMessageType: {
+    readonly DeviceHello: 1;
+    readonly OpenStream: 2;
+    readonly OpenResult: 3;
+    readonly StreamData: 4;
+    readonly StreamClose: 5;
+    readonly InstallProgress: 6;
+    readonly Error: 7;
+    readonly Ping: 8;
+    readonly Pong: 9;
+    readonly StartPairing: 10;
+    readonly StartInstall: 11;
+    readonly PairRecordReady: 12;
+};
+export type RelayMessageType = (typeof RelayMessageType)[keyof typeof RelayMessageType];
+export type RelayFrame = {
+    type: RelayMessageType;
+    requestId: number;
+    streamId: number;
+    payload: Uint8Array;
+};
+export declare function encodeFrame(frame: RelayFrame): Uint8Array<ArrayBuffer>;
+export declare function decodeFrame(data: Uint8Array): RelayFrame;
+export declare function encodeJson(value: unknown): Uint8Array<ArrayBufferLike>;
+export declare function decodeJson<T>(payload: Uint8Array): T;

package/dist/core/device-install/operations/usbmux.d.ts

@@ -0,0 +1,32 @@
+import { UsbmuxCandidate, getBulkEndpoints } from './webusb';
+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 declare function createUsbmuxSession(device: USBDevice, candidate: UsbmuxCandidate): Promise<UsbmuxSession>;
+export declare function openStream(session: UsbmuxSession, port: number): Promise<UsbmuxStream>;
+export declare function sendStreamData(stream: UsbmuxStream, bytes: Uint8Array): Promise<void>;
+export declare function receiveStreamData(stream: UsbmuxStream): Promise<Uint8Array<ArrayBufferLike>>;
+export declare function closeUsbmuxSession(session: UsbmuxSession): void;

package/dist/core/device-install/operations/webusb.d.ts

@@ -0,0 +1,21 @@
+export type UsbEndpoint = {
+    endpointNumber: number;
+    direction: 'in' | 'out';
+    type: string;
+    packetSize: number;
+};
+export type UsbmuxCandidate = {
+    configurationValue: number;
+    interfaceNumber: number;
+    alternateSetting: number;
+    endpoints: UsbEndpoint[];
+};
+export declare function requestAppleDevice(): Promise<USBDevice>;
+export declare function findUsbmuxCandidates(device: USBDevice): UsbmuxCandidate[];
+export declare function claimUsbmux(device: USBDevice, candidate: UsbmuxCandidate): Promise<void>;
+export declare function getBulkEndpoints(candidate: UsbmuxCandidate): {
+    outEndpoint: UsbEndpoint;
+    inEndpoint: UsbEndpoint;
+};
+export declare function transferOutWithZlp(device: USBDevice, endpoint: UsbEndpoint, bytes: Uint8Array): Promise<void>;
+export declare function transferIn(device: USBDevice, endpoint: UsbEndpoint, size?: number): Promise<Uint8Array<ArrayBufferLike>>;

package/dist/core/device-install/storage/browser-storage.d.ts

@@ -0,0 +1,44 @@
+import { ProvisioningProfileInfo, PutSigningAssetsInput, StoredPairRecord, StoredSigningAssets, PairRecordPayload } from '../types';
+export declare function normalizeUDID(udid?: string): string;
+export declare function normalizeBundleID(bundleID?: string): string;
+export declare function getPairRecord(udid?: string): Promise<StoredPairRecord | undefined>;
+export declare function putPairRecord(record: PairRecordPayload, metadata?: {
+    productName?: string;
+}): Promise<StoredPairRecord>;
+export declare function getSigningAssets({ deviceUDID, bundleID, }: {
+    deviceUDID?: string;
+    bundleID?: string;
+}): Promise<StoredSigningAssets | undefined>;
+export declare function getLatestSigningAssets(): Promise<StoredSigningAssets>;
+export declare function getLatestSigningAssetsWithCertificate(teamID?: string): Promise<StoredSigningAssets>;
+export declare function putSigningAssets(input: PutSigningAssetsInput): Promise<StoredSigningAssets>;
+export declare function findSigningAssetsForBundle(bundleID?: string): Promise<StoredSigningAssets[]>;
+export declare function profileContainsDevice(profile: ProvisioningProfileInfo, deviceUDID?: string): boolean;
+export declare function profileMatchesBundleID(profile: ProvisioningProfileInfo, bundleID?: string): boolean;
+export declare function parseProvisioningProfile(file: File): Promise<{
+    name: string | undefined;
+    uuid: string | undefined;
+    teamID: string;
+    applicationIdentifier: string | undefined;
+    bundleID: string | undefined;
+    provisionedDevices: string[];
+    expirationDate: string | undefined;
+}>;
+export declare function parseProvisioningProfileBase64(base64: string): {
+    name: string | undefined;
+    uuid: string | undefined;
+    teamID: string;
+    applicationIdentifier: string | undefined;
+    bundleID: string | undefined;
+    provisionedDevices: string[];
+    expirationDate: string | undefined;
+};
+export declare function parseProvisioningProfileBytes(bytes: Uint8Array): {
+    name: string | undefined;
+    uuid: string | undefined;
+    teamID: string;
+    applicationIdentifier: string | undefined;
+    bundleID: string | undefined;
+    provisionedDevices: string[];
+    expirationDate: string | undefined;
+};

package/dist/core/device-install/storage/index.d.ts

@@ -0,0 +1 @@
+export * from './browser-storage';

package/dist/core/device-install/types.d.ts

@@ -0,0 +1,48 @@
+export type DeviceInstallLog = (message: string, detail?: string) => void;
+export type DeviceInstallStep = 'signing' | 'connect' | 'build' | 'install';
+export type DeviceInstallStepStatus = 'idle' | 'active' | 'complete' | 'error';
+export type DeviceInstallBusyAction = 'signing' | 'usb' | 'pair' | 'build' | 'install';
+export type DeviceInstallBuildStatus = 'idle' | 'queued' | 'running' | 'succeeded' | 'failed' | 'cancelled';
+export type BuildLogLine = {
+    type: 'command' | 'stdout' | 'stderr' | 'meta';
+    data: string;
+};
+export type DeviceHello = {
+    serialNumber?: string;
+    productName?: string;
+    manufacturerName?: string;
+    productId: number;
+    vendorId: number;
+};
+export type PairRecordPayload = {
+    udid: string;
+    pairRecordBase64: string;
+};
+export type StoredPairRecord = PairRecordPayload & {
+    productName?: string;
+    updatedAt: string;
+};
+export type ProvisioningProfileInfo = {
+    name?: string;
+    uuid?: string;
+    teamID?: string;
+    applicationIdentifier?: string;
+    bundleID?: string;
+    provisionedDevices: string[];
+    expirationDate?: string;
+};
+export type StoredSigningAssets = {
+    id: string;
+    deviceUDID?: string;
+    teamID?: string;
+    bundleID: string;
+    certificateID?: string;
+    certificateP12Base64: string;
+    certificateFileName?: string;
+    certificatePassword: string;
+    provisioningProfileBase64: string;
+    profileFileName?: string;
+    profile: ProvisioningProfileInfo;
+    updatedAt: string;
+};
+export type PutSigningAssetsInput = Omit<StoredSigningAssets, 'id' | 'updatedAt'>;

package/dist/device-install/index.cjs

@@ -0,0 +1 @@
+"use strict";Object.defineProperty(exports,Symbol.toStringTag,{value:"Module"});const e=require("../use-device-install-Y1u6vIBB.js"),t=require("../device-install-dialog-CjH25hnN.js");exports.AppleGsaSrpClient=e.AppleGsaSrpClient;exports.RELAY_HEADER_BYTES=e.RELAY_HEADER_BYTES;exports.RELAY_PROTOCOL_VERSION=e.RELAY_PROTOCOL_VERSION;exports.RelayClient=e.RelayClient;exports.RelayMessageType=e.RelayMessageType;exports.claimUsbmux=e.claimUsbmux;exports.closeDeviceRelayTarget=e.closeDeviceRelayTarget;exports.closeUsbmuxSession=e.closeUsbmuxSession;exports.createAppleRelaySession=e.createAppleRelaySession;exports.createBundleIDRequest=e.createBundleIDRequest;exports.createDevelopmentProfileRequest=e.createDevelopmentProfileRequest;exports.createUsbmuxSession=e.createUsbmuxSession;exports.decodeFrame=e.decodeFrame;exports.decodeJson=e.decodeJson;exports.deleteAppleRelaySession=e.deleteAppleRelaySession;exports.deviceRelayWebSocketUrl=e.deviceRelayWebSocketUrl;exports.downloadCertificateRequest=e.downloadCertificateRequest;exports.downloadProfileRequest=e.downloadProfileRequest;exports.encodeFrame=e.encodeFrame;exports.encodeJson=e.encodeJson;exports.exportAppleCertificateP12=e.exportAppleCertificateP12;exports.fetchAppleAccountSession=e.fetchAppleAccountSession;exports.fetchLimbuildInfo=e.fetchLimbuildInfo;exports.findBundleIDRequest=e.findBundleIDRequest;exports.findDevelopmentCertificatesRequest=e.findDevelopmentCertificatesRequest;exports.findDevelopmentProfilesRequest=e.findDevelopmentProfilesRequest;exports.findDeviceRequest=e.findDeviceRequest;exports.findSigningAssetsForBundle=e.findSigningAssetsForBundle;exports.findUsbmuxCandidates=e.findUsbmuxCandidates;exports.generateAppleSigningKeyAndCSR=e.generateAppleSigningKeyAndCSR;exports.getBulkEndpoints=e.getBulkEndpoints;exports.getLatestSigningAssets=e.getLatestSigningAssets;exports.getLatestSigningAssetsWithCertificate=e.getLatestSigningAssetsWithCertificate;exports.getPairRecord=e.getPairRecord;exports.getReusableAppleSigningAssets=e.getReusableAppleSigningAssets;exports.getSigningAssets=e.getSigningAssets;exports.listTeamsRequest=e.listTeamsRequest;exports.normalizeBundleID=e.normalizeBundleID;exports.normalizeUDID=e.normalizeUDID;exports.openStream=e.openStream;exports.parseProvisioningProfile=e.parseProvisioningProfile;exports.parseProvisioningProfileBase64=e.parseProvisioningProfileBase64;exports.parseProvisioningProfileBytes=e.parseProvisioningProfileBytes;exports.profileContainsDevice=e.profileContainsDevice;exports.profileMatchesBundleID=e.profileMatchesBundleID;exports.proxyPhoneTwoFactorCode=e.proxyPhoneTwoFactorCode;exports.proxyProvisioningRequest=e.proxyProvisioningRequest;exports.proxySrpComplete=e.proxySrpComplete;exports.proxySrpInit=e.proxySrpInit;exports.proxyTwoFactorCode=e.proxyTwoFactorCode;exports.putAppleGeneratedSigningAssets=e.putAppleGeneratedSigningAssets;exports.putPairRecord=e.putPairRecord;exports.putSigningAssets=e.putSigningAssets;exports.receiveStreamData=e.receiveStreamData;exports.registerDeviceRequest=e.registerDeviceRequest;exports.requestAppleDevice=e.requestAppleDevice;exports.requestUSBAccess=e.requestUSBAccess;exports.selectDeveloperPortalTeam=e.selectDeveloperPortalTeam;exports.sendStreamData=e.sendStreamData;exports.startBrowserOwnedAppleIDLogin=e.startBrowserOwnedAppleIDLogin;exports.startInstallRelay=e.startInstallRelay;exports.startPairingRelay=e.startPairingRelay;exports.startSignedDeviceBuild=e.startSignedDeviceBuild;exports.storedSigningAssetsReusable=e.storedSigningAssetsReusable;exports.submitDevelopmentCSRRequest=e.submitDevelopmentCSRRequest;exports.teamIDCandidates=e.teamIDCandidates;exports.transferIn=e.transferIn;exports.transferOutWithZlp=e.transferOutWithZlp;exports.triggerPhoneTwoFactor=e.triggerPhoneTwoFactor;exports.triggerTrustedDeviceTwoFactor=e.triggerTrustedDeviceTwoFactor;exports.useDeviceInstall=e.useDeviceInstall;exports.watchBuildLogEvents=e.watchBuildLogEvents;exports.DeviceInstallDialog=t.DeviceInstallDialog;exports.DeviceInstallRelay=t.DeviceInstallDialog;

package/dist/device-install/index.d.ts

@@ -0,0 +1,3 @@
+export * from '../core/device-install';
+export { DeviceInstallDialog, DeviceInstallRelay } from '../components/device-install';
+export { useDeviceInstall } from '../hooks/use-device-install';