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

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',
+    });
+  });
+});

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) {
@@ -62,7 +77,7 @@ export async function startSignedDeviceBuild({
       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;