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

package/src/app-store-relay/index.ts

@@ -0,0 +1,447 @@
+import {
+  createAdHocProfileRequest,
+  createBundleIDRequest,
+  createDevelopmentProfileRequest,
+  downloadCertificateRequest,
+  downloadDistributionCertificateRequest,
+  downloadProfileRequest,
+  findAdHocProfilesRequest,
+  findBundleIDRequest,
+  findDevelopmentCertificatesRequest,
+  findDevelopmentProfilesRequest,
+  findDeviceRequest,
+  findDistributionCertificatesRequest,
+  listTeamsRequest,
+  proxyProvisioningRequest,
+  registerDeviceRequest,
+  submitDevelopmentCSRRequest,
+  submitDistributionCSRRequest,
+  type AppleDeveloperPortalAppID,
+  type AppleDeveloperPortalDevice,
+  type AppleDeveloperPortalResponse,
+  type AppleDeveloperPortalTeam,
+  type AppleProvisioningRequest,
+  type AppleRelayResponse,
+} from '../core/device-install/apple';
+
+export * from '../core/device-install/apple/client';
+export * from '../core/device-install/apple/crypto';
+export * from '../core/device-install/apple/gsa-srp';
+export type {
+  AppleDeveloperPortalAppID,
+  AppleDeveloperPortalDevice,
+  AppleDeveloperPortalResponse,
+  AppleDeveloperPortalTeam,
+  AppleProvisioningRequest,
+  AppleRelayResponse,
+} from '../core/device-install/apple';
+export {
+  createAppleRelaySession,
+  deleteAppleRelaySession,
+  fetchAppleAccountSession,
+  proxyPhoneTwoFactorCode,
+  proxySrpComplete,
+  proxySrpInit,
+  proxyTwoFactorCode,
+  triggerPhoneTwoFactor,
+  triggerTrustedDeviceTwoFactor,
+} from '../core/device-install/apple';
+
+export type AppleRelayClientOptions = {
+  apiUrl: string;
+  token?: string;
+  appleSessionId: string;
+};
+
+export type AppleTeamScopedOptions = AppleRelayClientOptions & {
+  teamId?: string;
+};
+
+export type AppleCertificateKind = 'development' | 'distribution';
+
+export type AppleProfileKind = 'development' | 'adhoc';
+
+export type RequestAppleProvisioningOptions<T = unknown> = AppleRelayClientOptions & {
+  request: AppleProvisioningRequest;
+  label?: string;
+  validatePortalResponse?: boolean;
+  mapBody?: (body: AppleDeveloperPortalResponse | undefined, response: AppleRelayResponse<T>) => T;
+};
+
+export type MappedAppleProvisioningOptions<T> = RequestAppleProvisioningOptions<T> & {
+  mapBody: (body: AppleDeveloperPortalResponse | undefined, response: AppleRelayResponse<T>) => T;
+};
+
+export type ListAppleCertificatesOptions = AppleTeamScopedOptions & {
+  certificateKind?: AppleCertificateKind;
+};
+
+export type CreateAppleCertificateOptions = AppleTeamScopedOptions & {
+  certificateKind?: AppleCertificateKind;
+  csrPEM: string;
+};
+
+export type DownloadAppleCertificateOptions = AppleTeamScopedOptions & {
+  certificateKind?: AppleCertificateKind;
+  certificateId: string;
+};
+
+export type DeleteAppleCertificateOptions = DownloadAppleCertificateOptions;
+
+export type ListAppleBundleIDsOptions = AppleTeamScopedOptions & {
+  search?: string;
+};
+
+export type CreateAppleBundleIDOptions = AppleTeamScopedOptions & {
+  bundleId: string;
+  name?: string;
+};
+
+export type UpdateAppleBundleIDOptions = AppleTeamScopedOptions & {
+  appIdId: string;
+  bundleId?: string;
+  name?: string;
+};
+
+export type DeleteAppleBundleIDOptions = AppleTeamScopedOptions & {
+  appIdId: string;
+};
+
+export type ListAppleDevicesOptions = AppleTeamScopedOptions & {
+  deviceUDID?: string;
+};
+
+export type RegisterAppleDeviceOptions = AppleTeamScopedOptions & {
+  deviceUDID: string;
+  name?: string;
+};
+
+export type UpdateAppleDeviceOptions = AppleTeamScopedOptions & {
+  deviceId: string;
+  name?: string;
+};
+
+export type DeleteAppleDeviceOptions = AppleTeamScopedOptions & {
+  deviceId: string;
+};
+
+export type ListAppleProfilesOptions = AppleTeamScopedOptions & {
+  profileKind?: AppleProfileKind;
+  bundleId?: string;
+};
+
+export type CreateAppleProfileOptions = AppleTeamScopedOptions & {
+  profileKind?: AppleProfileKind;
+  bundleId: string;
+  appIdId: string;
+  certificateIds: string[];
+  deviceIds: string[];
+  name?: string;
+};
+
+export type DownloadAppleProfileOptions = AppleTeamScopedOptions & {
+  profileId: string;
+};
+
+export type DeleteAppleProfileOptions = DownloadAppleProfileOptions;
+
+export function requestAppleProvisioning<T>(options: MappedAppleProvisioningOptions<T>): Promise<T>;
+export function requestAppleProvisioning<T = AppleDeveloperPortalResponse>(
+  options: RequestAppleProvisioningOptions<T>,
+): Promise<AppleRelayResponse<T>>;
+export async function requestAppleProvisioning<T = AppleDeveloperPortalResponse>({
+  apiUrl,
+  token,
+  appleSessionId,
+  request,
+  label = 'Apple Developer Portal request',
+  validatePortalResponse = true,
+  mapBody,
+}: RequestAppleProvisioningOptions<T>) {
+  const response = await proxyProvisioningRequest<T>(apiUrl, appleSessionId, request, token);
+  if (validatePortalResponse) {
+    assertAppleDeveloperPortalResponseOK(response.body as AppleDeveloperPortalResponse | undefined, label);
+  }
+  return mapBody ? mapBody(response.body as AppleDeveloperPortalResponse | undefined, response) : response;
+}
+
+export async function listAppleTeams(options: AppleRelayClientOptions) {
+  return requestAppleProvisioning<AppleDeveloperPortalTeam[]>({
+    ...options,
+    request: listTeamsRequest(),
+    label: 'Apple Developer team list',
+    mapBody: (body) => uniqueAppleTeams([...(body?.teams ?? []), ...(body?.availableProviders ?? []), ...(body?.provider ? [body.provider] : [])]),
+  });
+}
+
+export async function listAppleCertificates({
+  certificateKind = 'development',
+  teamId = '',
+  ...options
+}: ListAppleCertificatesOptions) {
+  return requestAppleProvisioning<Array<Record<string, unknown>>>({
+    ...options,
+    request:
+      certificateKind === 'distribution'
+        ? findDistributionCertificatesRequest(teamId)
+        : findDevelopmentCertificatesRequest(teamId),
+    label: 'Apple Developer certificate list',
+    mapBody: (body) => body?.certRequests ?? [],
+  });
+}
+
+export async function createAppleCertificate({
+  certificateKind = 'development',
+  teamId = '',
+  csrPEM,
+  ...options
+}: CreateAppleCertificateOptions) {
+  return requestAppleProvisioning<Record<string, unknown> | undefined>({
+    ...options,
+    request:
+      certificateKind === 'distribution'
+        ? submitDistributionCSRRequest({ csrPEM, teamID: teamId })
+        : submitDevelopmentCSRRequest({ csrPEM, teamID: teamId }),
+    label: certificateKind === 'distribution' ? 'Apple Distribution certificate creation' : 'Apple Development certificate creation',
+    mapBody: (body) => body?.certRequest,
+  });
+}
+
+export async function downloadAppleCertificate({
+  certificateKind = 'development',
+  certificateId,
+  teamId = '',
+  ...options
+}: DownloadAppleCertificateOptions) {
+  return requestAppleProvisioning<AppleRelayResponse>({
+    ...options,
+    request:
+      certificateKind === 'distribution'
+        ? downloadDistributionCertificateRequest(certificateId, teamId)
+        : downloadCertificateRequest(certificateId, teamId),
+    label: 'Apple certificate download',
+    validatePortalResponse: false,
+    mapBody: (_body, response) => response,
+  });
+}
+
+export async function deleteAppleCertificate({
+  certificateKind = 'development',
+  certificateId,
+  teamId = '',
+  ...options
+}: DeleteAppleCertificateOptions) {
+  return requestAppleProvisioning<AppleDeveloperPortalResponse | undefined>({
+    ...options,
+    request: {
+      method: 'POST',
+      path: '/account/ios/certificate/revokeCertificate.action',
+      payload: {
+        teamId,
+        certificateId,
+        type: certificateKind === 'distribution' ? 'WXV89964HE' : '83Q87W3TGH',
+      },
+    },
+    label: 'Apple certificate deletion',
+    mapBody: (body) => body,
+  });
+}
+
+export async function listAppleBundleIDs({ teamId = '', search = '', ...options }: ListAppleBundleIDsOptions) {
+  return requestAppleProvisioning<AppleDeveloperPortalAppID[]>({
+    ...options,
+    request: findBundleIDRequest({ bundleID: search, teamID: teamId }),
+    label: 'Apple bundle ID list',
+    mapBody: (body) => body?.appIds ?? [],
+  });
+}
+
+export async function createAppleBundleID({ teamId = '', bundleId, name, ...options }: CreateAppleBundleIDOptions) {
+  return requestAppleProvisioning<Record<string, unknown> | undefined>({
+    ...options,
+    request: createBundleIDRequest({ bundleID: bundleId, teamID: teamId, name }),
+    label: 'Apple bundle ID creation',
+    mapBody: (body) => body?.appId,
+  });
+}
+
+export async function updateAppleBundleID({
+  teamId = '',
+  appIdId,
+  bundleId,
+  name,
+  ...options
+}: UpdateAppleBundleIDOptions) {
+  return requestAppleProvisioning<Record<string, unknown> | undefined>({
+    ...options,
+    request: {
+      method: 'POST',
+      path: '/account/ios/identifiers/updateAppId.action',
+      payload: {
+        teamId,
+        appIdId,
+        ...(bundleId ? { identifier: bundleId } : {}),
+        ...(name ? { name } : {}),
+      },
+    },
+    label: 'Apple bundle ID update',
+    mapBody: (body) => body?.appId,
+  });
+}
+
+export async function deleteAppleBundleID({ teamId = '', appIdId, ...options }: DeleteAppleBundleIDOptions) {
+  return requestAppleProvisioning<AppleDeveloperPortalResponse | undefined>({
+    ...options,
+    request: {
+      method: 'POST',
+      path: '/account/ios/identifiers/deleteAppId.action',
+      payload: { teamId, appIdId },
+    },
+    label: 'Apple bundle ID deletion',
+    mapBody: (body) => body,
+  });
+}
+
+export async function listAppleDevices({ teamId = '', deviceUDID = '', ...options }: ListAppleDevicesOptions) {
+  return requestAppleProvisioning<AppleDeveloperPortalDevice[]>({
+    ...options,
+    request: findDeviceRequest({ deviceUDID, teamID: teamId }),
+    label: 'Apple device list',
+    mapBody: (body) => body?.devices ?? [],
+  });
+}
+
+export async function registerAppleDevice({ teamId = '', deviceUDID, name, ...options }: RegisterAppleDeviceOptions) {
+  return requestAppleProvisioning<Record<string, unknown> | undefined>({
+    ...options,
+    request: registerDeviceRequest({ deviceUDID, teamID: teamId, name }),
+    label: 'Apple device registration',
+    mapBody: (body) => body?.device,
+  });
+}
+
+export async function updateAppleDevice({ teamId = '', deviceId, name, ...options }: UpdateAppleDeviceOptions) {
+  return requestAppleProvisioning<Record<string, unknown> | undefined>({
+    ...options,
+    request: {
+      method: 'POST',
+      path: '/account/ios/device/updateDevice.action',
+      payload: { teamId, deviceId, ...(name ? { name } : {}) },
+    },
+    label: 'Apple device update',
+    mapBody: (body) => body?.device,
+  });
+}
+
+export async function deleteAppleDevice({ teamId = '', deviceId, ...options }: DeleteAppleDeviceOptions) {
+  return requestAppleProvisioning<AppleDeveloperPortalResponse | undefined>({
+    ...options,
+    request: {
+      method: 'POST',
+      path: '/account/ios/device/deleteDevice.action',
+      payload: { teamId, deviceId },
+    },
+    label: 'Apple device deletion',
+    mapBody: (body) => body,
+  });
+}
+
+export async function listAppleProfiles({
+  profileKind = 'development',
+  teamId = '',
+  bundleId = '',
+  ...options
+}: ListAppleProfilesOptions) {
+  return requestAppleProvisioning<Array<Record<string, unknown>>>({
+    ...options,
+    request:
+      profileKind === 'adhoc'
+        ? findAdHocProfilesRequest({ bundleID: bundleId, teamID: teamId })
+        : findDevelopmentProfilesRequest({ bundleID: bundleId, teamID: teamId }),
+    label: 'Apple provisioning profile list',
+    mapBody: (body) => body?.provisioningProfiles ?? [],
+  });
+}
+
+export async function createAppleProfile({
+  profileKind = 'development',
+  teamId = '',
+  bundleId,
+  appIdId,
+  certificateIds,
+  deviceIds,
+  name,
+  ...options
+}: CreateAppleProfileOptions) {
+  const [certificateId] = certificateIds;
+  if (!certificateId) {
+    throw new Error('At least one certificate ID is required to create an Apple provisioning profile.');
+  }
+  return requestAppleProvisioning<Record<string, unknown> | undefined>({
+    ...options,
+    request:
+      profileKind === 'adhoc'
+        ? createAdHocProfileRequest({
+            bundleID: bundleId,
+            teamID: teamId,
+            appIDID: appIdId,
+            certificateID: certificateId,
+            deviceIDs: deviceIds,
+            name,
+          })
+        : createDevelopmentProfileRequest({
+            bundleID: bundleId,
+            teamID: teamId,
+            appIDID: appIdId,
+            certificateID: certificateId,
+            deviceIDs: deviceIds,
+            name,
+          }),
+    label: 'Apple provisioning profile creation',
+    mapBody: (body) => body?.provisioningProfile,
+  });
+}
+
+export async function downloadAppleProfile({ teamId = '', profileId, ...options }: DownloadAppleProfileOptions) {
+  return requestAppleProvisioning<AppleRelayResponse>({
+    ...options,
+    request: downloadProfileRequest(profileId, teamId),
+    label: 'Apple provisioning profile download',
+    validatePortalResponse: false,
+    mapBody: (_body, response) => response,
+  });
+}
+
+export async function deleteAppleProfile({ teamId = '', profileId, ...options }: DeleteAppleProfileOptions) {
+  return requestAppleProvisioning<AppleDeveloperPortalResponse | undefined>({
+    ...options,
+    request: {
+      method: 'POST',
+      path: '/account/ios/profile/deleteProvisioningProfile.action',
+      payload: { teamId, provisioningProfileId: profileId },
+    },
+    label: 'Apple provisioning profile deletion',
+    mapBody: (body) => body,
+  });
+}
+
+export function assertAppleDeveloperPortalResponseOK(response: AppleDeveloperPortalResponse | undefined, label: string) {
+  if (!response) {
+    throw new Error(`${label} returned an empty response.`);
+  }
+  if (response.resultCode !== undefined && response.resultCode !== 0) {
+    throw new Error(`${label} failed: ${response.userString ?? response.resultString ?? response.resultCode}`);
+  }
+}
+
+function uniqueAppleTeams(teams: AppleDeveloperPortalTeam[]) {
+  const seen = new Set<string>();
+  const result: AppleDeveloperPortalTeam[] = [];
+  for (const team of teams) {
+    const key = String(team.teamId ?? team.providerId ?? team.publicProviderId ?? team.name ?? JSON.stringify(team));
+    if (seen.has(key)) continue;
+    seen.add(key);
+    result.push(team);
+  }
+  return result;
+}

package/src/app-store-relay/react.ts

@@ -0,0 +1,125 @@
+import { useCallback, useEffect, useRef, useState } from 'react';
+import {
+  startBrowserOwnedAppleIDLogin,
+  type AppleIDLoginInput,
+  type AppleIDLoginResult,
+  type AppleRelayResponse,
+} from './index';
+
+export type UseAppleIDLoginOptions = Pick<AppleIDLoginInput, 'limbuildApiUrl' | 'token'>;
+
+export type AppleIDLoginStatus =
+  | 'idle'
+  | 'authenticating'
+  | 'two-factor-required'
+  | 'authenticated'
+  | 'error';
+
+export type UseAppleIDLoginResult = {
+  status: AppleIDLoginStatus;
+  session?: AppleIDLoginResult;
+  completeResponse?: AppleRelayResponse;
+  twoFactorChallengeResponse?: AppleRelayResponse;
+  error?: string;
+  startLogin: (input: Pick<AppleIDLoginInput, 'accountName' | 'password'>) => Promise<AppleIDLoginResult | undefined>;
+  submitTwoFactorCode: (code: string) => Promise<AppleRelayResponse | undefined>;
+  finalize: () => Promise<AppleRelayResponse | undefined>;
+  close: () => Promise<void>;
+};
+
+export function useAppleIDLogin({ limbuildApiUrl, token }: UseAppleIDLoginOptions): UseAppleIDLoginResult {
+  const [status, setStatus] = useState<AppleIDLoginStatus>('idle');
+  const [session, setSession] = useState<AppleIDLoginResult | undefined>();
+  const [completeResponse, setCompleteResponse] = useState<AppleRelayResponse | undefined>();
+  const [twoFactorChallengeResponse, setTwoFactorChallengeResponse] = useState<AppleRelayResponse | undefined>();
+  const [error, setError] = useState<string | undefined>();
+  const sessionRef = useRef<AppleIDLoginResult | undefined>(undefined);
+
+  const close = useCallback(async () => {
+    await sessionRef.current?.close().catch(() => undefined);
+    sessionRef.current = undefined;
+    setSession(undefined);
+    setCompleteResponse(undefined);
+    setTwoFactorChallengeResponse(undefined);
+    setError(undefined);
+    setStatus('idle');
+  }, []);
+
+  useEffect(() => {
+    return () => {
+      void sessionRef.current?.close();
+      sessionRef.current = undefined;
+    };
+  }, []);
+
+  const startLogin = useCallback(
+    async ({ accountName, password }: Pick<AppleIDLoginInput, 'accountName' | 'password'>) => {
+      setStatus('authenticating');
+      setError(undefined);
+      await sessionRef.current?.close().catch(() => undefined);
+      try {
+        const next = await startBrowserOwnedAppleIDLogin({
+          limbuildApiUrl,
+          token,
+          accountName,
+          password,
+        });
+        sessionRef.current = next;
+        setSession(next);
+        setCompleteResponse(next.completeResponse);
+        setTwoFactorChallengeResponse(next.twoFactorChallengeResponse);
+        setStatus(next.requiresTwoFactor ? 'two-factor-required' : 'authenticated');
+        return next;
+      } catch (caught) {
+        setSession(undefined);
+        sessionRef.current = undefined;
+        setError(errorMessage(caught));
+        setStatus('error');
+        return undefined;
+      }
+    },
+    [limbuildApiUrl, token],
+  );
+
+  const submitTwoFactorCode = useCallback(async (code: string) => {
+    const current = sessionRef.current;
+    if (!current) {
+      throw new Error('Start Apple ID login before submitting a two-factor code.');
+    }
+    setStatus('authenticating');
+    setError(undefined);
+    try {
+      const response = await current.finishTwoFactor(code);
+      setStatus('authenticated');
+      return response;
+    } catch (caught) {
+      setError(errorMessage(caught));
+      setStatus('error');
+      return undefined;
+    }
+  }, []);
+
+  const finalize = useCallback(async () => {
+    const current = sessionRef.current;
+    if (!current) {
+      throw new Error('Start Apple ID login before finalizing the Apple session.');
+    }
+    return current.finalize();
+  }, []);
+
+  return {
+    status,
+    session,
+    completeResponse,
+    twoFactorChallengeResponse,
+    error,
+    startLogin,
+    submitTwoFactorCode,
+    finalize,
+    close,
+  };
+}
+
+function errorMessage(error: unknown) {
+  return error instanceof Error ? error.message : String(error);
+}

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

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

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

@@ -0,0 +1,84 @@
+// @vitest-environment node
+
+import { describe, expect, test } from 'vitest';
+import {
+  createAdHocProfileRequest,
+  createDevelopmentProfileRequest,
+  downloadDistributionCertificateRequest,
+  findAdHocProfilesRequest,
+  findDevelopmentCertificatesRequest,
+  findDistributionCertificatesRequest,
+  submitDistributionCSRRequest,
+} from './provisioning';
+
+describe('Apple provisioning request helpers', () => {
+  test('keeps development certificate requests on Apple Development types', () => {
+    expect(findDevelopmentCertificatesRequest('TEAM').payload).toMatchObject({
+      teamId: 'TEAM',
+      types: '83Q87W3TGH,5QPB9NHCEI',
+    });
+  });
+
+  test('uses distribution certificate requests for Ad Hoc signing', () => {
+    expect(findDistributionCertificatesRequest('TEAM').payload).toMatchObject({
+      teamId: 'TEAM',
+      types: 'WXV89964HE,R58UK2EWSO',
+    });
+    expect(submitDistributionCSRRequest({ csrPEM: 'csr', teamID: 'TEAM' }).payload).toMatchObject({
+      teamId: 'TEAM',
+      type: 'WXV89964HE',
+      csrContent: 'csr',
+    });
+    expect(downloadDistributionCertificateRequest('CERT', 'TEAM').payload).toMatchObject({
+      teamId: 'TEAM',
+      certificateId: 'CERT',
+      type: 'WXV89964HE',
+    });
+  });
+
+  test('builds separate development and Ad Hoc profile payloads', () => {
+    expect(
+      createDevelopmentProfileRequest({
+        bundleID: 'com.example.app',
+        teamID: 'TEAM',
+        appIDID: 'APP',
+        certificateID: 'CERT',
+        deviceIDs: ['DEVICE'],
+      }).payload,
+    ).toMatchObject({
+      teamId: 'TEAM',
+      provisioningProfileName: 'Limrun com.example.app',
+      certificateIds: ['CERT'],
+      appIdId: 'APP',
+      deviceIds: ['DEVICE'],
+      distributionType: 'limited',
+      subPlatform: 'ios',
+    });
+
+    expect(
+      createAdHocProfileRequest({
+        bundleID: 'com.example.app',
+        teamID: 'TEAM',
+        appIDID: 'APP',
+        certificateID: 'CERT',
+        deviceIDs: ['DEVICE'],
+      }).payload,
+    ).toMatchObject({
+      teamId: 'TEAM',
+      provisioningProfileName: 'Limrun Ad Hoc com.example.app',
+      certificateIds: ['CERT'],
+      appIdId: 'APP',
+      deviceIds: ['DEVICE'],
+      distributionType: 'adhoc',
+      subPlatform: 'ios',
+    });
+  });
+
+  test('filters Ad Hoc profile list requests by Ad Hoc distribution type', () => {
+    expect(findAdHocProfilesRequest({ bundleID: 'com.example.app', teamID: 'TEAM' }).payload).toMatchObject({
+      teamId: 'TEAM',
+      search: 'com.example.app',
+      distributionType: 'adhoc',
+    });
+  });
+});