@limrun/ui 0.9.0-rc.9 → 0.13.3

package/dist/device-install/index.js

@@ -1,78 +1,585 @@
-import { A as a, O as t, N as i, R as n, P as r, a0 as o, L as l, Z as p, q as c, d, j as g, V as u, S as R, U as D, v as S, M as f, i as m, k as A, Q as v, T as P, e as y, D as C, F as I, f as q, b as B, c as x, a as T, ac as b, $ as h, g as w, a1 as E, a9 as L, aa as F, a6 as U, m as O, a8 as _, l as W, a5 as Y, a4 as k, W as z, af as G, ag as J, ah as M, ad as H, ae as K, C as N, E as V, x as Z, w as j, B as Q, p as X, a7 as $, ab as ee, Y as se, r as ae, _ as te, I as ie, o as ne, X as re, s as oe, K as le, J as pe, G as ce, n as de, h as ge, t as ue, a3 as Re, a2 as De, z as Se, y as fe, u as me, H as Ae } from "../use-device-install-H8dqqvbR.mjs";
-import { D as Pe, D as ye } from "../device-install-dialog-CqxDEH85.mjs";
+import { j as ge, n as be, k as Ue } from "../browser-storage-Cx9eW-bm.mjs";
+const v = 1, u = 16, s = {
+  DeviceHello: 1,
+  OpenStream: 2,
+  OpenResult: 3,
+  StreamData: 4,
+  StreamClose: 5,
+  InstallProgress: 6,
+  Error: 7,
+  Ping: 8,
+  Pong: 9,
+  StartPairing: 10,
+  StartInstall: 11,
+  PairRecordReady: 12
+};
+function D(e) {
+  const t = new Uint8Array(u + e.payload.byteLength), n = new DataView(t.buffer);
+  return n.setUint8(0, v), n.setUint8(1, e.type), n.setUint8(2, 0), n.setUint8(3, 0), n.setUint32(4, e.requestId), n.setUint32(8, e.streamId), n.setUint32(12, e.payload.byteLength), t.set(e.payload, u), t;
+}
+function V(e) {
+  if (e.byteLength < u)
+    throw new Error(`Relay frame too short: ${e.byteLength}`);
+  const t = new DataView(e.buffer, e.byteOffset, e.byteLength), n = t.getUint8(0);
+  if (n !== v)
+    throw new Error(`Unsupported relay protocol version ${n}`);
+  const r = t.getUint32(12);
+  if (e.byteLength !== u + r)
+    throw new Error(
+      `Relay frame length mismatch: got ${e.byteLength}, expected ${u + r}`
+    );
+  return {
+    type: t.getUint8(1),
+    requestId: t.getUint32(4),
+    streamId: t.getUint32(8),
+    payload: e.slice(u)
+  };
+}
+function c(e) {
+  return new TextEncoder().encode(JSON.stringify(e));
+}
+function h(e) {
+  return JSON.parse(new TextDecoder().decode(e));
+}
+async function A() {
+  if (!navigator.usb)
+    throw new Error("WebUSB is not available in this browser.");
+  return navigator.usb.requestDevice({ filters: [{ vendorId: 1452 }] });
+}
+function C(e) {
+  const t = [], n = e.configuration?.configurationValue, r = e.configurations.find(
+    (a) => a.configurationValue === n
+  );
+  r && t.push(...U(r));
+  for (const a of e.configurations)
+    a.configurationValue !== n && t.push(...U(a));
+  return t;
+}
+function U(e) {
+  const t = [];
+  for (const n of e.interfaces)
+    for (const r of n.alternates)
+      r.interfaceClass === 255 && r.interfaceSubclass === 254 && r.interfaceProtocol === 2 && t.push({
+        configurationValue: e.configurationValue,
+        interfaceNumber: n.interfaceNumber,
+        alternateSetting: r.alternateSetting,
+        endpoints: r.endpoints
+      });
+  return t;
+}
+async function L(e, t) {
+  e.opened || await e.open(), (!e.configuration || e.configuration.configurationValue !== t.configurationValue) && await e.selectConfiguration(t.configurationValue), await e.claimInterface(t.interfaceNumber), await e.selectAlternateInterface(t.interfaceNumber, t.alternateSetting);
+}
+function T(e) {
+  const t = e.endpoints.find(
+    (r) => r.direction === "out" && r.type === "bulk"
+  ), n = e.endpoints.find(
+    (r) => r.direction === "in" && r.type === "bulk"
+  );
+  if (!t || !n)
+    throw new Error("Could not find usbmux bulk endpoints.");
+  return { outEndpoint: t, inEndpoint: n };
+}
+async function R(e, t, n) {
+  const r = await e.transferOut(t.endpointNumber, n);
+  if (r.status !== "ok")
+    throw new Error(`USB transferOut failed: ${r.status}`);
+  n.byteLength % t.packetSize === 0 && await e.transferOut(t.endpointNumber, new Uint8Array());
+}
+async function W(e, t, n = 16384) {
+  const r = await e.transferIn(t.endpointNumber, n);
+  if (r.status !== "ok" || !r.data)
+    throw new Error(`USB transferIn failed: ${r.status}`);
+  return new Uint8Array(r.data.buffer, r.data.byteOffset, r.data.byteLength);
+}
+const E = 0, B = 2, k = 6, F = 4277009102, y = 2, _ = 4, l = 16, M = 49152;
+async function j(e, t) {
+  const { inEndpoint: n, outEndpoint: r } = T(t), a = new Uint8Array(12), i = new DataView(a.buffer);
+  i.setUint32(0, 2), i.setUint32(4, 0), i.setUint32(8, 0), await R(e, r, O(E, a));
+  const o = await P(e, n, 1), f = new DataView(o.payload.buffer, o.payload.byteOffset).getUint32(0), w = {
+    device: e,
+    candidate: t,
+    inEndpoint: n,
+    outEndpoint: r,
+    muxVersion: f,
+    txSeq: 0,
+    rxSeq: 65535,
+    nextSport: M,
+    streams: /* @__PURE__ */ new Map(),
+    writeChain: Promise.resolve(),
+    closed: !1
+  };
+  return f >= 2 && await x(w, B, new Uint8Array([7])), Q(w), w;
+}
+async function H(e, t) {
+  if (e.closed)
+    throw new Error("usbmux session is closed.");
+  let n, r;
+  const a = {
+    session: e,
+    sport: e.nextSport++,
+    dport: t,
+    seq: 0,
+    ack: 0,
+    queue: [],
+    waiters: [],
+    opened: new Promise((i, o) => {
+      n = i, r = o;
+    }),
+    resolveOpened: n,
+    rejectOpened: r
+  };
+  return e.streams.set(m(t, a.sport), a), await p(a, y, new Uint8Array()), await a.opened, a;
+}
+async function J(e, t) {
+  if (e.session.closed)
+    throw new Error("usbmux session is closed.");
+  await p(e, l, t), e.seq += t.byteLength;
+}
+async function G(e) {
+  if (e.queue.length > 0)
+    return e.queue.shift();
+  if (e.error)
+    throw e.error;
+  return new Promise((t) => {
+    e.waiters.push(t);
+  });
+}
+function I(e) {
+  e.closed = !0;
+  for (const t of e.streams.values())
+    for (t.error = new Error("usbmux session closed"), t.rejectOpened(t.error); t.waiters.length > 0; )
+      t.waiters.shift()(new Uint8Array());
+  e.streams.clear();
+}
+async function p(e, t, n) {
+  const r = new Uint8Array(20 + n.byteLength), a = new DataView(r.buffer);
+  a.setUint16(0, e.sport), a.setUint16(2, e.dport), a.setUint32(4, e.seq), a.setUint32(8, e.ack), a.setUint8(12, 80), a.setUint8(13, t), a.setUint16(14, 512), r.set(n, 20), await x(e.session, k, r);
+}
+async function x(e, t, n) {
+  if (e.closed)
+    throw new Error("usbmux session is closed.");
+  return e.writeChain = e.writeChain.then(async () => {
+    if (e.closed) return;
+    const r = e.muxVersion >= 2 ? Y(t, n, e.txSeq++, e.rxSeq) : O(t, n);
+    await R(e.device, e.outEndpoint, r);
+  }), e.writeChain;
+}
+async function Q(e) {
+  try {
+    for (; ; ) {
+      if (e.closed) return;
+      const t = await P(e.device, e.inEndpoint, e.muxVersion);
+      if (e.closed) return;
+      if (t.rxSeq !== void 0 && (e.rxSeq = t.rxSeq), t.protocol !== k)
+        continue;
+      const n = K(t.payload), r = e.streams.get(m(n.sport, n.dport));
+      if (r) {
+        if (n.flags & _) {
+          for (r.error = new Error(`Device reset stream ${r.dport}`), r.rejectOpened(r.error); r.waiters.length > 0; )
+            r.waiters.shift()(new Uint8Array());
+          e.streams.delete(m(r.dport, r.sport));
+          continue;
+        }
+        if ((n.flags & (y | l)) === (y | l)) {
+          r.seq += 1, r.ack = n.seq + 1, await p(r, l, new Uint8Array()), r.resolveOpened();
+          continue;
+        }
+        n.payload.byteLength !== 0 && (r.ack = n.seq + n.payload.byteLength, await p(r, l, new Uint8Array()), r.waiters.length > 0 ? r.waiters.shift()(n.payload) : r.queue.push(n.payload));
+      }
+    }
+  } catch {
+    e.closed || I(e);
+  }
+}
+async function P(e, t, n) {
+  for (; ; ) {
+    const r = await W(e, t), a = z(r, n);
+    if (!(n === 1 && a.protocol !== E))
+      return a;
+  }
+}
+function O(e, t) {
+  const n = new Uint8Array(8 + t.byteLength), r = new DataView(n.buffer);
+  return r.setUint32(0, e), r.setUint32(4, n.byteLength), n.set(t, 8), n;
+}
+function Y(e, t, n, r) {
+  const a = new Uint8Array(16 + t.byteLength), i = new DataView(a.buffer);
+  return i.setUint32(0, e), i.setUint32(4, a.byteLength), i.setUint32(8, F), i.setUint16(12, n), i.setUint16(14, r), a.set(t, 16), a;
+}
+function z(e, t) {
+  const n = new DataView(e.buffer, e.byteOffset, e.byteLength), r = n.getUint32(0), a = n.getUint32(4), i = t >= 2 ? 16 : 8;
+  return {
+    protocol: r,
+    length: a,
+    rxSeq: t >= 2 ? n.getUint16(14) : void 0,
+    payload: e.slice(i, a)
+  };
+}
+function K(e) {
+  const t = new DataView(e.buffer, e.byteOffset, e.byteLength), n = (t.getUint8(12) >> 4) * 4;
+  return {
+    sport: t.getUint16(0),
+    dport: t.getUint16(2),
+    seq: t.getUint32(4),
+    ack: t.getUint32(8),
+    flags: t.getUint8(13),
+    payload: e.slice(n)
+  };
+}
+function m(e, t) {
+  return `${e}:${t}`;
+}
+class X {
+  constructor(t, n, r, a) {
+    this.webSocketUrl = t, this.session = n, this.deviceHello = r, this.log = a;
+  }
+  socket;
+  streams = /* @__PURE__ */ new Map();
+  frameQueue = Promise.resolve();
+  closed = !1;
+  pairRecordWaiter;
+  async connect() {
+    const t = new WebSocket(this.webSocketUrl);
+    t.binaryType = "arraybuffer", this.socket = t, t.onclose = () => {
+      this.closed = !0, this.log("Relay socket closed"), this.frameQueue.finally(() => {
+        this.pairRecordWaiter && (this.pairRecordWaiter.reject(new Error("Relay socket closed")), this.pairRecordWaiter = void 0);
+      });
+    }, await new Promise((n, r) => {
+      t.onopen = () => n(), t.onerror = () => r(new Error("WebSocket connection failed"));
+    }), t.onmessage = (n) => {
+      const r = n.data instanceof ArrayBuffer ? new Uint8Array(n.data) : new Uint8Array();
+      this.enqueueFrame(r);
+    }, await this.send({
+      type: s.DeviceHello,
+      requestId: 0,
+      streamId: 0,
+      payload: c(this.deviceHello)
+    }), this.log("Connected WebSocket relay");
+  }
+  async startPairing() {
+    const t = new Promise((n, r) => {
+      this.pairRecordWaiter = { resolve: n, reject: r };
+    });
+    return await this.send({
+      type: s.StartPairing,
+      requestId: 0,
+      streamId: 0,
+      payload: c({})
+    }), this.log("Pairing requested"), t;
+  }
+  async startInstall(t) {
+    await this.send({
+      type: s.StartInstall,
+      requestId: 0,
+      streamId: 0,
+      payload: c(t)
+    }), this.log("Installation requested");
+  }
+  close() {
+    this.closed = !0, this.socket?.close();
+  }
+  enqueueFrame(t) {
+    this.frameQueue = this.frameQueue.then(() => this.handleFrame(V(t))).catch((n) => {
+      this.log("Relay frame handling failed", n instanceof Error ? n.message : String(n));
+    });
+  }
+  async handleFrame(t) {
+    switch (t.type) {
+      case s.OpenStream:
+        await this.handleOpenStream(
+          t.requestId,
+          t.streamId,
+          h(t.payload).port
+        );
+        break;
+      case s.StreamData: {
+        const n = this.streams.get(t.streamId);
+        if (!n) throw new Error(`Unknown stream ${t.streamId}`);
+        await J(n, t.payload);
+        break;
+      }
+      case s.StreamClose:
+        this.streams.delete(t.streamId);
+        break;
+      case s.InstallProgress:
+        this.log(ee(h(t.payload).message));
+        break;
+      case s.Error:
+        this.handleError(t.payload);
+        break;
+      case s.PairRecordReady:
+        this.handlePairRecordReady(h(t.payload));
+        break;
+      case s.Ping:
+        await this.send({
+          type: s.Pong,
+          requestId: t.requestId,
+          streamId: 0,
+          payload: new Uint8Array()
+        });
+        break;
+    }
+  }
+  handleError(t) {
+    const n = Z(t);
+    this.log("Server error", n), this.pairRecordWaiter && (this.pairRecordWaiter.reject(new Error(n)), this.pairRecordWaiter = void 0);
+  }
+  handlePairRecordReady(t) {
+    this.log("Pair record received", t.udid), this.pairRecordWaiter?.resolve(t), this.pairRecordWaiter = void 0;
+  }
+  async handleOpenStream(t, n, r) {
+    try {
+      const a = await H(this.session, r);
+      this.streams.set(n, a), await this.send({
+        type: s.OpenResult,
+        requestId: t,
+        streamId: n,
+        payload: c({ ok: !0 })
+      }), this.log(`Opened device stream ${n} to port ${r}`), this.pumpDeviceToServer(n, a);
+    } catch (a) {
+      this.log(
+        `Open device stream ${n} failed`,
+        a instanceof Error ? a.message : String(a)
+      ), await this.send({
+        type: s.OpenResult,
+        requestId: t,
+        streamId: n,
+        payload: c({
+          ok: !1,
+          error: a instanceof Error ? a.message : String(a)
+        })
+      });
+    }
+  }
+  async pumpDeviceToServer(t, n) {
+    try {
+      for (; ; ) {
+        const r = await G(n);
+        if (this.closed) return;
+        await this.send({
+          type: s.StreamData,
+          requestId: 0,
+          streamId: t,
+          payload: r
+        });
+      }
+    } catch (r) {
+      this.log(`Device stream ${t} closed`, r instanceof Error ? r.message : String(r)), await this.send({
+        type: s.StreamClose,
+        requestId: 0,
+        streamId: t,
+        payload: c({
+          reason: r instanceof Error ? r.message : String(r)
+        })
+      });
+    }
+  }
+  async send(t) {
+    if (!this.closed) {
+      if (!this.socket || this.socket.readyState !== WebSocket.OPEN) {
+        this.closed = !0;
+        return;
+      }
+      this.socket.send(D(t));
+    }
+  }
+}
+function Z(e) {
+  const t = new TextDecoder().decode(e);
+  try {
+    const n = JSON.parse(t);
+    return S(n.error ?? t);
+  } catch {
+    return S(t);
+  }
+}
+function S(e) {
+  return e.replace(/libimobiledevice/g, "").trim();
+}
+function ee(e) {
+  const t = "install status: ";
+  if (!e.startsWith(t))
+    return e;
+  const n = e.slice(t.length), r = d(n, "Error");
+  if (r) {
+    const o = d(n, "ErrorDescription");
+    return `Install error: ${r}${o ? ` — ${o}` : ""}`;
+  }
+  const a = d(n, "Status") ?? "Unknown", i = d(n, "PercentComplete");
+  return `Install progress: ${i ? `${i}% ` : ""}${a}`;
+}
+function d(e, t) {
+  const r = new RegExp(
+    `<key>\\s*${te(
+      t
+    )}\\s*</key>\\s*<(?:string|integer|real)>([\\s\\S]*?)</(?:string|integer|real)>`
+  ).exec(e);
+  return r ? ne(r[1].trim()) : void 0;
+}
+function te(e) {
+  return e.replace(/[.*+?^${}()|[\]\\]/g, "\\$&");
+}
+function ne(e) {
+  return e.replace(/&lt;/g, "<").replace(/&gt;/g, ">").replace(/&quot;/g, '"').replace(/&apos;/g, "'").replace(/&amp;/g, "&");
+}
+async function re({ log: e }) {
+  e("Selecting USB device");
+  const t = await A(), n = ce(t);
+  return e(
+    "Selected USB device",
+    `${t.manufacturerName ?? ""} ${t.productName ?? ""} ${t.serialNumber ?? ""}`.trim()
+  ), n;
+}
+async function ae({ limbuildApiUrl: e, token: t, log: n, target: r }) {
+  const a = N(e, t);
+  let i;
+  try {
+    i = await $(a, r, n);
+    const o = await i.startPairing();
+    return { relay: i, pairRecord: o, target: r };
+  } catch (o) {
+    throw i?.close(), o;
+  }
+}
+async function ie({
+  limbuildApiUrl: e,
+  token: t,
+  log: n,
+  target: r,
+  pairRecord: a
+}) {
+  const i = N(e, t);
+  let o;
+  try {
+    return o = await $(i, r, n), await o.startInstall(a), o;
+  } catch (f) {
+    throw o?.close(), f;
+  }
+}
+async function oe(e, t) {
+  if (e) {
+    if (e.session && (I(e.session), e.session = void 0), e.claimedInterfaceNumber !== void 0)
+      try {
+        await e.device.releaseInterface(e.claimedInterfaceNumber), t?.("Released usbmux interface");
+      } catch (n) {
+        t?.("USB interface release failed", g(n));
+      } finally {
+        e.claimedInterfaceNumber = void 0;
+      }
+    if (e.device.opened)
+      try {
+        await e.device.close(), t?.("Closed USB device");
+      } catch (n) {
+        t?.("USB device close failed", g(n));
+      }
+  }
+}
+async function $(e, t, n) {
+  await se(t, n);
+  const r = new X(e, t.session, t.hello, n);
+  return await r.connect(), r;
+}
+async function se(e, t) {
+  if (!e.session)
+    try {
+      e.candidate = await ue(e, t), e.session = await j(e.device, e.candidate), t("Created usbmux session");
+    } catch (n) {
+      throw await oe(e, t), n;
+    }
+}
+function ce(e) {
+  return {
+    device: e,
+    candidate: le(e),
+    hello: {
+      serialNumber: e.serialNumber,
+      productName: e.productName,
+      manufacturerName: e.manufacturerName,
+      productId: e.productId,
+      vendorId: e.vendorId
+    }
+  };
+}
+async function ue(e, t) {
+  const n = q(e.device);
+  if (n.length === 0) throw new Error("No Apple usbmux interface found.");
+  let r;
+  for (const a of n)
+    for (const i of [1, 2])
+      try {
+        return e.device.opened || await e.device.open(), t(
+          "Claiming usbmux interface",
+          `configuration ${a.configurationValue}, interface ${a.interfaceNumber}, alternate ${a.alternateSetting}, attempt ${i}`
+        ), await L(e.device, a), e.claimedInterfaceNumber = a.interfaceNumber, t(
+          "Claimed usbmux interface",
+          `configuration ${a.configurationValue}, interface ${a.interfaceNumber}`
+        ), a;
+      } catch (o) {
+        r = o, t(
+          "USB interface claim failed",
+          `configuration ${a.configurationValue}, interface ${a.interfaceNumber}: ${g(o)}`
+        ), await fe(e), await de(250);
+      }
+  throw r instanceof Error ? r : new Error("Unable to claim any Apple usbmux interface.");
+}
+function le(e) {
+  const t = q(e)[0];
+  if (!t) throw new Error("No Apple usbmux interface found.");
+  return t;
+}
+function q(e) {
+  const t = C(e), n = e.configuration?.configurationValue;
+  return [
+    ...t.filter((r) => r.configurationValue === n),
+    ...t.filter((r) => r.configurationValue !== n)
+  ];
+}
+function N(e, t) {
+  const n = new URL(e);
+  return n.protocol = n.protocol === "https:" ? "wss:" : "ws:", n.pathname = `${n.pathname.replace(/\/$/, "")}/device/ws`, t && n.searchParams.set("token", t), n.toString();
+}
+function g(e) {
+  return e instanceof Error ? e.message : String(e);
+}
+async function fe(e) {
+  if (e.claimedInterfaceNumber !== void 0) {
+    try {
+      await e.device.releaseInterface(e.claimedInterfaceNumber);
+    } catch {
+    }
+    e.claimedInterfaceNumber = void 0;
+  }
+  if (e.device.opened)
+    try {
+      await e.device.close();
+    } catch {
+    }
+}
+function de(e) {
+  return new Promise((t) => setTimeout(t, e));
+}
+async function pe(e = {}) {
+  return re({ log: e.log ?? b });
+}
+async function we(e) {
+  return ae({ ...e, log: e.log ?? b });
+}
+async function he(e) {
+  return ie({ ...e, log: e.log ?? b });
+}
+function b() {
+}
 export {
-  a as AppleGsaSrpClient,
-  Pe as DeviceInstallDialog,
-  ye as DeviceInstallRelay,
-  t as RELAY_HEADER_BYTES,
-  i as RELAY_PROTOCOL_VERSION,
-  n as RelayClient,
-  r as RelayMessageType,
-  o as claimUsbmux,
-  l as closeDeviceRelayTarget,
-  p as closeUsbmuxSession,
-  c as createAppleRelaySession,
-  d as createBundleIDRequest,
-  g as createDevelopmentProfileRequest,
-  u as createUsbmuxSession,
-  R as decodeFrame,
-  D as decodeJson,
-  S as deleteAppleRelaySession,
-  f as deviceRelayWebSocketUrl,
-  m as downloadCertificateRequest,
-  A as downloadProfileRequest,
-  v as encodeFrame,
-  P as encodeJson,
-  y as exportAppleCertificateP12,
-  C as fetchAppleAccountSession,
-  I as fetchLimbuildInfo,
-  q as findBundleIDRequest,
-  B as findDevelopmentCertificatesRequest,
-  x as findDevelopmentProfilesRequest,
-  T as findDeviceRequest,
-  b as findSigningAssetsForBundle,
-  h as findUsbmuxCandidates,
-  w as generateAppleSigningKeyAndCSR,
-  E as getBulkEndpoints,
-  L as getLatestSigningAssets,
-  F as getLatestSigningAssetsWithCertificate,
-  U as getPairRecord,
-  O as getReusableAppleSigningAssets,
-  _ as getSigningAssets,
-  W as listTeamsRequest,
-  Y as normalizeBundleID,
-  k as normalizeUDID,
-  z as openStream,
-  G as parseProvisioningProfile,
-  J as parseProvisioningProfileBase64,
-  M as parseProvisioningProfileBytes,
-  H as profileContainsDevice,
-  K as profileMatchesBundleID,
-  N as proxyPhoneTwoFactorCode,
-  V as proxyProvisioningRequest,
-  Z as proxySrpComplete,
-  j as proxySrpInit,
-  Q as proxyTwoFactorCode,
-  X as putAppleGeneratedSigningAssets,
-  $ as putPairRecord,
-  ee as putSigningAssets,
-  se as receiveStreamData,
-  ae as registerDeviceRequest,
-  te as requestAppleDevice,
-  ie as requestUSBAccess,
-  ne as selectDeveloperPortalTeam,
-  re as sendStreamData,
-  oe as startBrowserOwnedAppleIDLogin,
-  le as startInstallRelay,
-  pe as startPairingRelay,
-  ce as startSignedDeviceBuild,
-  de as storedSigningAssetsReusable,
-  ge as submitDevelopmentCSRRequest,
-  ue as teamIDCandidates,
-  Re as transferIn,
-  De as transferOutWithZlp,
-  Se as triggerPhoneTwoFactor,
-  fe as triggerTrustedDeviceTwoFactor,
-  me as useDeviceInstall,
-  Ae as watchBuildLogEvents
+  X as RelayClient,
+  oe as closeDeviceRelayTarget,
+  N as deviceRelayWebSocketUrl,
+  ge as getPairRecord,
+  be as normalizeUDID,
+  we as pairDevice,
+  Ue as putPairRecord,
+  pe as requestUSBAccess,
+  he as startDeviceInstall,
+  ie as startDeviceInstallRelay,
+  ae as startDevicePairingRelay
 };

package/dist/device-install/react.cjs

@@ -1 +1 @@
-"use strict";Object.defineProperty(exports,Symbol.toStringTag,{value:"Module"});const e=require("../use-device-install-CAPli9MR.js");exports.useDeviceInstall=e.useDeviceInstall;
+"use strict";Object.defineProperty(exports,Symbol.toStringTag,{value:"Module"});const r=require("react"),o=require("./index.cjs"),S=require("../browser-storage-jJaIht4K.js");function B({apiUrl:c,token:d,log:w=C}){const[e,h]=r.useState(),[l,y]=r.useState(),[g,u]=r.useState(),[p,s]=r.useState(),[D,v]=r.useState(!1),f=r.useRef(void 0),b=r.useRef(void 0),t=r.useRef(w);t.current=w;const i=r.useCallback(async()=>{f.current?.close(),f.current=void 0,await o.closeDeviceRelayTarget(b.current,t.current)},[]);r.useEffect(()=>{b.current=e},[e]),r.useEffect(()=>()=>{i()},[i]);const m=r.useCallback(async()=>{u("usb"),s(void 0),v(!1);let a;try{await i(),a=await o.requestUSBAccess({log:t.current});const n=await S.getPairRecord(a.hello.serialNumber);return h(a),y(n),t.current(n?"Pair record found":"No pair record found",a.hello.serialNumber),a}catch(n){await o.closeDeviceRelayTarget(a,t.current),h(void 0),y(void 0),s(R(n));return}finally{u(void 0)}},[i]),P=r.useCallback(async()=>{if(!c||!e)throw new Error("Select a USB device before pairing.");u("pair"),s(void 0),v(!1);try{await i();const a=await o.pairDevice({limbuildApiUrl:c,token:d,log:t.current,target:e}),n=await S.putPairRecord(a.pairRecord,{productName:e.hello.productName});return a.relay.close(),await o.closeDeviceRelayTarget(e,t.current),y(n),v(!1),t.current("Device paired","The pair record was stored locally in this browser."),n}catch(a){await o.closeDeviceRelayTarget(e,t.current),v(!0),s(R(a));return}finally{u(void 0)}},[c,i,e,d]),q=r.useCallback(async()=>{if(!c||!e||!l)throw new Error("Select and pair a USB device before starting installation.");u("install"),s(void 0);try{return await i(),f.current=await o.startDeviceInstall({limbuildApiUrl:c,token:d,log:t.current,target:e,pairRecord:l}),t.current("Device install started","Installation will continue through the connected iPhone."),f.current}catch(a){await o.closeDeviceRelayTarget(e,t.current),s(R(a));return}finally{u(void 0)}},[c,i,e,l,d]),A=r.useCallback(()=>{i(),t.current("Device relay stopped")},[i]);return{device:e,pairRecord:l,busyAction:g,error:p,pairConfirmationRequired:D,hasPairRecord:!!l,canPair:!!c&&!g&&!!e,canInstall:!!c&&!g&&!!e&&!!l,requestUSBAccess:m,pairBrowser:P,startInstallation:q,stopRelay:A,clearError:()=>s(void 0)}}function C(){}function R(c){return c instanceof Error?c.message:String(c)}exports.useDeviceInstallRelay=B;

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

@@ -1 +1,23 @@
-export { useDeviceInstall } from '../hooks/use-device-install';
+import { DeviceInstallLog, DeviceRelayTarget, RelayClient, 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 declare function useDeviceInstallRelay({ apiUrl, token, log, }: UseDeviceInstallRelayOptions): UseDeviceInstallRelayResult;