@limrun/ui 0.14.0-rc.5 → 0.14.0

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

@@ -1,69 +0,0 @@
-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';
-
-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[];
-  /**
-   * Serial numbers (uppercase hex, no leading zeros) of the developer
-   * certificates embedded in the profile; the profile is only usable for
-   * signing with one of these certificates.
-   */
-  certificateSerialNumbers: string[];
-  getTaskAllow?: boolean;
-  expirationDate?: string;
-};
-
-export type StoredSigningAssets = {
-  id: string;
-  deviceUDID?: string;
-  teamID?: string;
-  signingMode?: DeviceInstallSigningMode;
-  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/src/core/errors.ts

@@ -1,3 +0,0 @@
-export function errorMessage(error: unknown): string {
-  return error instanceof Error ? error.message : String(error);
-}

package/src/core/play-publish/google.ts

@@ -1,113 +0,0 @@
-const GSI_SRC = 'https://accounts.google.com/gsi/client';
-
-export const ANDROID_PUBLISHER_SCOPE = 'https://www.googleapis.com/auth/androidpublisher';
-
-type TokenResponse = { access_token?: string; error?: string; error_description?: string };
-type TokenClient = { requestAccessToken: () => void };
-type GoogleOAuth2 = {
-  initTokenClient: (config: {
-    client_id: string;
-    scope: string;
-    callback: (response: TokenResponse) => void;
-    error_callback?: (error: { type?: string; message?: string }) => void;
-  }) => TokenClient;
-};
-
-function googleOAuth2(): GoogleOAuth2 | undefined {
-  return (globalThis as { google?: { accounts?: { oauth2?: GoogleOAuth2 } } }).google?.accounts?.oauth2;
-}
-
-let gsiLoad: Promise<void> | undefined;
-
-export function loadGoogleIdentityServices(): Promise<void> {
-  if (googleOAuth2()) {
-    return Promise.resolve();
-  }
-  if (typeof document === 'undefined') {
-    return Promise.reject(new Error('Google sign-in requires a browser environment.'));
-  }
-  if (!gsiLoad) {
-    gsiLoad = new Promise<void>((resolve, reject) => {
-      const script = document.createElement('script');
-      script.src = GSI_SRC;
-      script.async = true;
-      script.addEventListener(
-        'load',
-        () => {
-          if (googleOAuth2()) {
-            resolve();
-          } else {
-            reject(new Error('Google sign-in script loaded without the OAuth client.'));
-          }
-        },
-        { once: true },
-      );
-      script.addEventListener(
-        'error',
-        () => {
-          script.remove();
-          reject(new Error('Failed to load the Google sign-in script.'));
-        },
-        { once: true },
-      );
-      document.head.appendChild(script);
-    });
-    // A failed load (offline, blocked CDN) must not poison retries.
-    gsiLoad.catch(() => {
-      gsiLoad = undefined;
-    });
-  }
-  return gsiLoad;
-}
-
-export type RequestGoogleAccessTokenInput = {
-  clientId: string;
-  scope?: string;
-};
-
-/**
- * Opens the Google consent popup and resolves with a short-lived OAuth
- * access token. Call from a user gesture so popup blockers allow it, and
- * call loadGoogleIdentityServices beforehand (e.g. when the surrounding
- * dialog opens) to keep this call synchronous with the click.
- */
-export function requestGoogleAccessToken(input: RequestGoogleAccessTokenInput): Promise<string> {
-  // When GSI is already loaded the popup must open inside the caller's
-  // click turn: even an await of a resolved promise yields a microtask,
-  // which the strictest popup blockers treat as leaving the gesture.
-  if (googleOAuth2()) {
-    return openTokenPopup(input);
-  }
-  return loadGoogleIdentityServices().then(() => openTokenPopup(input));
-}
-
-function openTokenPopup({
-  clientId,
-  scope = ANDROID_PUBLISHER_SCOPE,
-}: RequestGoogleAccessTokenInput): Promise<string> {
-  return new Promise<string>((resolve, reject) => {
-    const client = googleOAuth2()!.initTokenClient({
-      client_id: clientId,
-      scope,
-      callback: (response) => {
-        if (response.error) {
-          reject(new Error(response.error_description || response.error));
-          return;
-        }
-        if (!response.access_token) {
-          reject(new Error('Google returned no access token.'));
-          return;
-        }
-        resolve(response.access_token);
-      },
-      error_callback: (error) => {
-        const fallback =
-          error?.type === 'popup_failed_to_open' ?
-            'Google sign-in popup was blocked by the browser.'
-          : 'Google sign-in was cancelled.';
-        reject(new Error(error?.message || fallback));
-      },
-    });
-    client.requestAccessToken();
-  });
-}

package/src/core/play-publish/publish.test.ts

@@ -1,68 +0,0 @@
-import { afterEach, describe, expect, it, vi } from 'vitest';
-import { PlaystorePublishError, publishToPlaystore } from './publish';
-
-function mockFetch(status: number, body: string) {
-  const fetchMock = vi.fn(async () => new Response(body, { status }));
-  vi.stubGlobal('fetch', fetchMock);
-  return fetchMock;
-}
-
-afterEach(() => {
-  vi.unstubAllGlobals();
-});
-
-describe('publishToPlaystore', () => {
-  it('posts to the publish path with auth and org headers and returns the versionCode', async () => {
-    const fetchMock = mockFetch(200, JSON.stringify({ versionCode: 42 }));
-    const result = await publishToPlaystore({
-      registryApiUrl: 'https://registry-staging.limrun.dev',
-      token: 'limrun-token',
-      organizationId: 'org_x',
-      accessToken: 'google-token',
-      packageName: 'com.example.app',
-      assetName: 'app-release.aab',
-    });
-    expect(result.versionCode).toBe(42);
-    const [url, init] = fetchMock.mock.calls[0] as unknown as [string, RequestInit];
-    expect(url).toBe('https://registry-staging.limrun.dev/android/playstore/publish');
-    const headers = init.headers as Record<string, string>;
-    expect(headers.Authorization).toBe('Bearer limrun-token');
-    expect(headers['X-Limrun-Organization']).toBe('org_x');
-    const body = JSON.parse(init.body as string) as Record<string, unknown>;
-    expect(body).toEqual({
-      accessToken: 'google-token',
-      packageName: 'com.example.app',
-      assetName: 'app-release.aab',
-    });
-  });
-
-  it('surfaces the registry error message and code', async () => {
-    mockFetch(
-      409,
-      JSON.stringify({ message: 'Version code 2 has already been used', code: 'versionCodeExists' }),
-    );
-    const error = await publishToPlaystore({
-      registryApiUrl: 'https://registry-staging.limrun.dev',
-      accessToken: 'google-token',
-      packageName: 'com.example.app',
-      assetName: 'app-release.aab',
-    }).catch((caught: unknown) => caught);
-    expect(error).toBeInstanceOf(PlaystorePublishError);
-    const publishError = error as PlaystorePublishError;
-    expect(publishError.code).toBe('versionCodeExists');
-    expect(publishError.status).toBe(409);
-    expect(publishError.message).toContain('already been used');
-  });
-
-  it('handles non-JSON error bodies', async () => {
-    mockFetch(502, '<html>bad gateway</html>');
-    const error = await publishToPlaystore({
-      registryApiUrl: 'https://registry-staging.limrun.dev',
-      accessToken: 'google-token',
-      packageName: 'com.example.app',
-      assetId: 'asset_1',
-    }).catch((caught: unknown) => caught);
-    expect(error).toBeInstanceOf(PlaystorePublishError);
-    expect((error as PlaystorePublishError).message).toContain('HTTP 502');
-  });
-});

package/src/core/play-publish/publish.ts

@@ -1,89 +0,0 @@
-export type PlaystorePublishInput = {
-  registryApiUrl: string;
-  /** Limrun API token authenticating the registry call. */
-  token?: string;
-  /** Organization tid; required when it differs from the token's default organization. */
-  organizationId?: string;
-  /** Google OAuth access token with the androidpublisher scope. Sent per request, never stored. */
-  accessToken: string;
-  packageName: string;
-  assetId?: string;
-  assetName?: string;
-  /** Play track ID, defaults to internal on the server. */
-  track?: string;
-  /** Required by the server when track is production. */
-  releaseStatus?: 'draft' | 'completed';
-};
-
-export type PlaystorePublishResult = {
-  versionCode: number;
-};
-
-/**
- * Registry publish failure. `code` carries the registry's machine-readable
- * error code when available: invalidRequest, assetNotFound, internal, busy,
- * listingNotFound, permissionDenied, versionCodeExists, uploadKeyMismatch
- * or unknown; the set grows additively.
- */
-export class PlaystorePublishError extends Error {
-  readonly code?: string;
-  readonly status?: number;
-
-  constructor(message: string, options: { code?: string; status?: number } = {}) {
-    super(message);
-    this.name = 'PlaystorePublishError';
-    this.code = options.code;
-    this.status = options.status;
-  }
-}
-
-export async function publishToPlaystore(input: PlaystorePublishInput): Promise<PlaystorePublishResult> {
-  const { registryApiUrl, token, organizationId, ...body } = input;
-  let url: URL;
-  try {
-    url = new URL(registryApiUrl);
-  } catch {
-    throw new PlaystorePublishError(`Invalid registry URL: ${registryApiUrl}`);
-  }
-  url.pathname = `${url.pathname.replace(/\/$/, '')}/android/playstore/publish`;
-  url.search = '';
-  url.hash = '';
-  const headers: Record<string, string> = { 'Content-Type': 'application/json' };
-  if (token) {
-    headers.Authorization = `Bearer ${token}`;
-  }
-  if (organizationId) {
-    headers['X-Limrun-Organization'] = organizationId;
-  }
-  let response: Response;
-  try {
-    response = await fetch(url.toString(), {
-      method: 'POST',
-      headers,
-      body: JSON.stringify(body),
-    });
-  } catch (caught) {
-    throw new PlaystorePublishError(
-      `Cannot reach the registry: ${caught instanceof Error ? caught.message : String(caught)}`,
-    );
-  }
-  const raw = await response.text();
-  let parsed: { versionCode?: number; message?: string; code?: string } | undefined;
-  try {
-    parsed = raw ? (JSON.parse(raw) as typeof parsed) : undefined;
-  } catch {
-    parsed = undefined;
-  }
-  if (!response.ok) {
-    throw new PlaystorePublishError(parsed?.message || `Play publish failed with HTTP ${response.status}`, {
-      code: parsed?.code,
-      status: response.status,
-    });
-  }
-  if (typeof parsed?.versionCode !== 'number') {
-    throw new PlaystorePublishError('Play publish response is missing versionCode.', {
-      status: response.status,
-    });
-  }
-  return { versionCode: parsed.versionCode };
-}

package/src/device-build/index.ts

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

package/src/device-build/react.ts

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

package/src/device-build/signing.ts

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