@limrun/ui 0.9.0-rc.9 → 0.13.3

package/src/device-install/demo/index.html

@@ -0,0 +1,12 @@
+<!doctype html>
+<html lang="en">
+  <head>
+    <meta charset="UTF-8" />
+    <meta name="viewport" content="width=device-width, initial-scale=1.0" />
+    <title>Real Device Install Demo - @limrun/ui</title>
+  </head>
+  <body>
+    <div id="root"></div>
+    <script type="module" src="./demo.tsx"></script>
+  </body>
+</html>

package/src/device-install/index.ts

@@ -1,3 +1,49 @@
-export * from '../core/device-install';
-export { DeviceInstallDialog, DeviceInstallRelay } from '../components/device-install';
-export { useDeviceInstall } from '../hooks/use-device-install';
+import {
+  requestUSBAccess as requestCoreUSBAccess,
+  startInstallRelay,
+  startPairingRelay,
+  type RequestUSBAccessOptions as CoreRequestUSBAccessOptions,
+  type StartInstallRelayOptions,
+  type StartPairingRelayOptions,
+} from '../core/device-install/operations';
+import type { DeviceInstallLog } from '../core/device-install/types';
+
+export {
+  closeDeviceRelayTarget,
+  deviceRelayWebSocketUrl,
+  startInstallRelay as startDeviceInstallRelay,
+  startPairingRelay as startDevicePairingRelay,
+  type DeviceRelayTarget,
+  type StartInstallRelayOptions,
+  type StartPairingRelayOptions,
+} from '../core/device-install/operations';
+export { getPairRecord, normalizeUDID, putPairRecord } from '../core/device-install/storage';
+export type {
+  DeviceHello,
+  DeviceInstallLog,
+  PairRecordPayload,
+  StoredPairRecord,
+} from '../core/device-install/types';
+export { RelayClient } from '../core/device-install/operations';
+
+export type RequestUSBAccessOptions = Partial<CoreRequestUSBAccessOptions>;
+
+export async function requestUSBAccess(options: RequestUSBAccessOptions = {}) {
+  return requestCoreUSBAccess({ log: options.log ?? noopLog });
+}
+
+export async function pairDevice(
+  options: Omit<StartPairingRelayOptions, 'log'> & { log?: DeviceInstallLog },
+) {
+  return startPairingRelay({ ...options, log: options.log ?? noopLog });
+}
+
+export async function startDeviceInstall(
+  options: Omit<StartInstallRelayOptions, 'log'> & { log?: DeviceInstallLog },
+) {
+  return startInstallRelay({ ...options, log: options.log ?? noopLog });
+}
+
+function noopLog() {
+  // Intentionally empty. Consumers can pass a logger for progress messages.
+}

package/src/device-install/react.ts

@@ -1 +1,189 @@
-export { useDeviceInstall } from '../hooks/use-device-install';
+import { useCallback, useEffect, useRef, useState } from 'react';
+import {
+  closeDeviceRelayTarget,
+  getPairRecord,
+  pairDevice,
+  putPairRecord,
+  requestUSBAccess,
+  startDeviceInstall,
+  type DeviceInstallLog,
+  type DeviceRelayTarget,
+  type RelayClient,
+  type StoredPairRecord,
+} from './index';
+
+export type DeviceInstallRelayBusyAction = 'usb' | 'pair' | 'install';
+
+export type UseDeviceInstallRelayOptions = {
+  apiUrl?: string;
+  token?: string;
+  log?: DeviceInstallLog;
+};
+
+export type UseDeviceInstallRelayResult = {
+  device?: DeviceRelayTarget;
+  pairRecord?: StoredPairRecord;
+  busyAction?: DeviceInstallRelayBusyAction;
+  error?: string;
+  pairConfirmationRequired: boolean;
+  hasPairRecord: boolean;
+  canPair: boolean;
+  canInstall: boolean;
+  requestUSBAccess: () => Promise<DeviceRelayTarget | undefined>;
+  pairBrowser: () => Promise<StoredPairRecord | undefined>;
+  startInstallation: () => Promise<RelayClient | undefined>;
+  stopRelay: () => void;
+  clearError: () => void;
+};
+
+export function useDeviceInstallRelay({
+  apiUrl,
+  token,
+  log = noopLog,
+}: UseDeviceInstallRelayOptions): UseDeviceInstallRelayResult {
+  const [device, setDevice] = useState<DeviceRelayTarget | undefined>();
+  const [pairRecord, setPairRecord] = useState<StoredPairRecord | undefined>();
+  const [busyAction, setBusyAction] = useState<DeviceInstallRelayBusyAction | undefined>();
+  const [error, setError] = useState<string | undefined>();
+  const [pairConfirmationRequired, setPairConfirmationRequired] = useState(false);
+  const relayRef = useRef<RelayClient | undefined>(undefined);
+  const deviceRef = useRef<DeviceRelayTarget | undefined>(undefined);
+  // Keep the logger in a ref so callbacks below don't change identity when the
+  // consumer passes an unmemoized `log`. Otherwise every render would recreate
+  // cleanupDeviceAccess, re-run the unmount effect, and close the USB device
+  // mid-claim (surfacing as "Unable to claim interface" / "operation in progress").
+  const logRef = useRef(log);
+  logRef.current = log;
+
+  const cleanupDeviceAccess = useCallback(async () => {
+    relayRef.current?.close();
+    relayRef.current = undefined;
+    await closeDeviceRelayTarget(deviceRef.current, logRef.current);
+  }, []);
+
+  useEffect(() => {
+    deviceRef.current = device;
+  }, [device]);
+
+  useEffect(() => {
+    return () => {
+      void cleanupDeviceAccess();
+    };
+  }, [cleanupDeviceAccess]);
+
+  const selectUSBDevice = useCallback(async () => {
+    setBusyAction('usb');
+    setError(undefined);
+    setPairConfirmationRequired(false);
+    let target: DeviceRelayTarget | undefined;
+    try {
+      await cleanupDeviceAccess();
+      target = await requestUSBAccess({ log: logRef.current });
+      const storedPairRecord = await getPairRecord(target.hello.serialNumber);
+      setDevice(target);
+      setPairRecord(storedPairRecord);
+      logRef.current(
+        storedPairRecord ? 'Pair record found' : 'No pair record found',
+        target.hello.serialNumber,
+      );
+      return target;
+    } catch (caught) {
+      await closeDeviceRelayTarget(target, logRef.current);
+      setDevice(undefined);
+      setPairRecord(undefined);
+      setError(errorMessage(caught));
+      return undefined;
+    } finally {
+      setBusyAction(undefined);
+    }
+  }, [cleanupDeviceAccess]);
+
+  const pairBrowser = useCallback(async () => {
+    if (!apiUrl || !device) {
+      throw new Error('Select a USB device before pairing.');
+    }
+    setBusyAction('pair');
+    setError(undefined);
+    setPairConfirmationRequired(false);
+    try {
+      await cleanupDeviceAccess();
+      const result = await pairDevice({
+        limbuildApiUrl: apiUrl,
+        token,
+        log: logRef.current,
+        target: device,
+      });
+      const stored = await putPairRecord(result.pairRecord, {
+        productName: device.hello.productName,
+      });
+      result.relay.close();
+      await closeDeviceRelayTarget(device, logRef.current);
+      setPairRecord(stored);
+      setPairConfirmationRequired(false);
+      logRef.current('Device paired', 'The pair record was stored locally in this browser.');
+      return stored;
+    } catch (caught) {
+      await closeDeviceRelayTarget(device, logRef.current);
+      setPairConfirmationRequired(true);
+      setError(errorMessage(caught));
+      return undefined;
+    } finally {
+      setBusyAction(undefined);
+    }
+  }, [apiUrl, cleanupDeviceAccess, device, token]);
+
+  const startInstallation = useCallback(async () => {
+    if (!apiUrl || !device || !pairRecord) {
+      throw new Error('Select and pair a USB device before starting installation.');
+    }
+    setBusyAction('install');
+    setError(undefined);
+    try {
+      await cleanupDeviceAccess();
+      relayRef.current = await startDeviceInstall({
+        limbuildApiUrl: apiUrl,
+        token,
+        log: logRef.current,
+        target: device,
+        pairRecord,
+      });
+      logRef.current('Device install started', 'Installation will continue through the connected iPhone.');
+      return relayRef.current;
+    } catch (caught) {
+      await closeDeviceRelayTarget(device, logRef.current);
+      setError(errorMessage(caught));
+      return undefined;
+    } finally {
+      setBusyAction(undefined);
+    }
+  }, [apiUrl, cleanupDeviceAccess, device, pairRecord, token]);
+
+  const stopRelay = useCallback(() => {
+    void cleanupDeviceAccess();
+    logRef.current('Device relay stopped');
+  }, [cleanupDeviceAccess]);
+
+  return {
+    device,
+    pairRecord,
+    busyAction,
+    error,
+    pairConfirmationRequired,
+    hasPairRecord: !!pairRecord,
+    canPair: !!apiUrl && !busyAction && !!device,
+    canInstall: !!apiUrl && !busyAction && !!device && !!pairRecord,
+    requestUSBAccess: selectUSBDevice,
+    pairBrowser,
+    startInstallation,
+    stopRelay,
+    clearError: () => setError(undefined),
+  };
+}
+
+function noopLog() {
+  // Intentionally empty. Consumers can pass a logger for progress messages.
+}
+
+function errorMessage(error: unknown) {
+  return error instanceof Error ? error.message : String(error);
+}

package/src/hooks/index.ts

@@ -1 +1 @@
-export * from './use-device-install';
+export {};

package/src/index.ts

@@ -17,6 +17,3 @@ export {
   normalizeIosTree,
   AX_UNAVAILABLE_ERROR,
 } from './core/ax-tree';
-
-export { DeviceInstallDialog, DeviceInstallRelay } from './components/device-install';
-export { useDeviceInstall } from './hooks/use-device-install';

package/vite.config.ts

@@ -11,6 +11,10 @@ export default defineConfig({
     lib: {
       entry: {
         index: resolve(__dirname, 'src/index.ts'),
+        'app-store-relay/index': resolve(__dirname, 'src/app-store-relay/index.ts'),
+        'app-store-relay/react': resolve(__dirname, 'src/app-store-relay/react.ts'),
+        'device-build/index': resolve(__dirname, 'src/device-build/index.ts'),
+        'device-build/react': resolve(__dirname, 'src/device-build/react.ts'),
         'device-install/index': resolve(__dirname, 'src/device-install/index.ts'),
         'device-install/react': resolve(__dirname, 'src/device-install/react.ts'),
       },

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

@@ -1,5 +0,0 @@
-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;