uidex 0.6.0 → 0.7.0

package/dist/cloud/index.js

@@ -1,91 +1,46 @@
-// src/cloud/client.ts
-import { createClient as createClient2, createConfig as createConfig2 } from "@hey-api/client-fetch";
-
-// ../api-client/src/client.gen.ts
-import {
-  createClient,
-  createConfig
-} from "@hey-api/client-fetch";
-var client = createClient(
-  createConfig({
-    baseUrl: "https://app.uidex.dev"
-  })
-);
-
-// ../api-client/src/sdk.gen.ts
-var submitReport = (options) => {
-  return (options.client ?? client).post({
-    security: [
-      {
-        scheme: "bearer",
-        type: "http"
-      }
-    ],
-    url: "/api/ingest",
-    ...options,
-    headers: {
-      "Content-Type": "application/json",
-      ...options?.headers
-    }
-  });
-};
-var getIngestConfig = (options) => {
-  return (options?.client ?? client).get({
-    security: [
-      {
-        scheme: "bearer",
-        type: "http"
-      }
-    ],
-    url: "/api/ingest/config",
-    ...options
-  });
-};
-var listIngestReports = (options) => {
-  return (options?.client ?? client).get({
-    security: [
-      {
-        scheme: "bearer",
-        type: "http"
-      }
-    ],
-    url: "/api/ingest/reports",
-    ...options
-  });
-};
-var listPins = (options) => {
-  return (options?.client ?? client).get({
-    security: [
-      {
-        scheme: "bearer",
-        type: "http"
-      }
-    ],
-    url: "/api/ingest/pins",
-    ...options
-  });
-};
-var archivePin = (options) => {
-  return (options.client ?? client).post({
-    security: [
-      {
-        scheme: "bearer",
-        type: "http"
-      }
-    ],
-    url: "/api/ingest/pins/archive",
-    ...options,
-    headers: {
-      "Content-Type": "application/json",
-      ...options?.headers
-    }
-  });
-};
+// src/cloud/protocol.ts
+var RPC_METHODS = [
+  "reports.submit",
+  "reports.list",
+  "config.get",
+  "pins.list",
+  "pins.screenshot",
+  "pins.archive",
+  "screenshot.chunk"
+];
+var SCREENSHOT_INLINE_MAX_BYTES = 20 * 1024 * 1024;
+var SCREENSHOT_CHUNK_BYTES = 8 * 1024 * 1024;
+function isRpcMethod(value) {
+  return typeof value === "string" && RPC_METHODS.includes(value);
+}
+function parseRpcResponseFrame(msg) {
+  if (!msg || typeof msg !== "object") return null;
+  const m = msg;
+  if (m.type !== "rpc:res" || typeof m.id !== "string") return null;
+  if (m.ok === true) {
+    return { type: "rpc:res", id: m.id, ok: true, data: m.data };
+  }
+  if (m.ok === false) {
+    if (typeof m.status !== "number" || typeof m.error !== "string") return null;
+    return {
+      type: "rpc:res",
+      id: m.id,
+      ok: false,
+      status: m.status,
+      error: m.error,
+      retryAfter: typeof m.retryAfter === "number" ? m.retryAfter : void 0,
+      details: m.details
+    };
+  }
+  return null;
+}
 
 // src/cloud/realtime.ts
 var RECONNECT_INITIAL_MS = 1e3;
 var RECONNECT_MAX_MS = 3e4;
+var MAX_RECONNECT_ATTEMPTS = 10;
 var CLOSE_CODE_AUTH_FAILED = 4001;
+var CLOSE_CODE_SYNTHETIC = 1006;
 function emit(listeners, value) {
   for (const cb of listeners) {
     try {
@@ -104,14 +59,28 @@ function resolveWebSocket(override) {
   );
 }
 function createRealtimeChannel(options) {
-  const WS = resolveWebSocket(options.WebSocketImpl);
+  let WS = options.WebSocketImpl ?? null;
   const presenceListeners = /* @__PURE__ */ new Set();
   const pinListeners = /* @__PURE__ */ new Set();
+  const pinArchivedListeners = /* @__PURE__ */ new Set();
+  const openListeners = /* @__PURE__ */ new Set();
+  const closeListeners = /* @__PURE__ */ new Set();
+  const rpcListeners = /* @__PURE__ */ new Set();
   let ws = null;
   let state = "disconnected";
   let disposed = false;
   let reconnectAttempts = 0;
   let reconnectTimer = null;
+  let identity = null;
+  let route = null;
+  function emitClose(code, willReconnect) {
+    for (const cb of closeListeners) {
+      try {
+        cb(code, willReconnect);
+      } catch {
+      }
+    }
+  }
   function clearReconnectTimer() {
     if (reconnectTimer !== null) {
       clearTimeout(reconnectTimer);
@@ -142,6 +111,11 @@ function createRealtimeChannel(options) {
     }
     if (!parsed || typeof parsed !== "object") return;
     const msg = parsed;
+    if (msg.type === "rpc:res") {
+      const frame = parseRpcResponseFrame(parsed);
+      if (frame) emit(rpcListeners, frame);
+      return;
+    }
     if (msg.type === "presence") {
       const p = msg;
       if (!Array.isArray(p.users)) return;
@@ -159,15 +133,21 @@ function createRealtimeChannel(options) {
       emit(presenceListeners, users);
       return;
     }
+    if (msg.type === "pin:archived") {
+      const p = msg;
+      if (typeof p.reportId !== "string") return;
+      emit(pinArchivedListeners, p.reportId);
+      return;
+    }
     if (msg.type === "pin") {
       const p = msg;
-      if (typeof p.feedbackId !== "string" || !p.elementRef || typeof p.elementRef !== "object" || typeof p.elementRef.kind !== "string" || typeof p.elementRef.id !== "string" || !p.author || typeof p.author !== "object" || typeof p.body !== "string" || typeof p.reportType !== "string" || typeof p.reportSeverity !== "string" || typeof p.createdAt !== "string") {
+      if (typeof p.reportId !== "string" || !p.elementRef || typeof p.elementRef !== "object" || typeof p.elementRef.kind !== "string" || typeof p.elementRef.id !== "string" || !p.author || typeof p.author !== "object" || typeof p.body !== "string" || typeof p.reportType !== "string" || typeof p.reportSeverity !== "string" || typeof p.createdAt !== "string") {
         return;
       }
       const author = p.author;
       const elRef = p.elementRef;
       const pin = {
-        id: p.feedbackId,
+        id: p.reportId,
         entity: `${elRef.kind}:${elRef.id}`,
         reporter: {
           name: typeof author.name === "string" ? author.name : void 0,
@@ -184,20 +164,45 @@ function createRealtimeChannel(options) {
       return;
     }
   }
+  function sendRaw(frame) {
+    if (!ws || !WS || ws.readyState !== WS.OPEN) return false;
+    try {
+      ws.send(JSON.stringify(frame));
+      return true;
+    } catch {
+      return false;
+    }
+  }
   function openSocket() {
     if (disposed) return;
     state = "connecting";
+    if (!WS) {
+      try {
+        WS = resolveWebSocket(options.WebSocketImpl);
+      } catch {
+        state = "disconnected";
+        emitClose(CLOSE_CODE_SYNTHETIC, false);
+        return;
+      }
+    }
     let url;
     try {
       url = options.buildUrl();
     } catch {
       state = "disconnected";
+      emitClose(CLOSE_CODE_SYNTHETIC, false);
       return;
     }
     let socket;
     try {
       socket = new WS(url);
     } catch {
+      if (reconnectAttempts >= MAX_RECONNECT_ATTEMPTS) {
+        state = "disconnected";
+        emitClose(CLOSE_CODE_SYNTHETIC, false);
+        return;
+      }
+      emitClose(CLOSE_CODE_SYNTHETIC, true);
       scheduleReconnect();
       return;
     }
@@ -206,6 +211,18 @@ function createRealtimeChannel(options) {
       if (ws !== socket) return;
       state = "connected";
       reconnectAttempts = 0;
+      if (identity) {
+        sendRaw({
+          type: "identify",
+          userId: identity.id,
+          ...identity.name ? { name: identity.name } : {},
+          ...identity.avatar ? { avatar: identity.avatar } : {}
+        });
+      }
+      if (route !== null) {
+        sendRaw({ type: "join", route });
+      }
+      emit(openListeners, void 0);
     });
     socket.addEventListener("message", (event) => {
       if (ws !== socket) return;
@@ -215,10 +232,12 @@ function createRealtimeChannel(options) {
       if (ws !== socket) return;
       ws = null;
       const code = event.code;
-      if (disposed || code === CLOSE_CODE_AUTH_FAILED) {
+      if (disposed || code === CLOSE_CODE_AUTH_FAILED || reconnectAttempts >= MAX_RECONNECT_ATTEMPTS) {
         state = "disconnected";
+        emitClose(code, false);
         return;
       }
+      emitClose(code, true);
       scheduleReconnect();
     });
     socket.addEventListener("error", () => {
@@ -237,22 +256,35 @@ function createRealtimeChannel(options) {
     disposed = true;
     clearReconnectTimer();
     state = "disconnected";
+    identity = null;
+    route = null;
     if (ws) {
+      const socket = ws;
+      ws = null;
       try {
-        ws.close(1e3);
+        socket.close(1e3);
       } catch {
       }
-      ws = null;
     }
+    emitClose(CLOSE_CODE_SYNTHETIC, false);
   }
-  function joinRoute(route) {
+  function clearSession() {
+    identity = null;
+    route = null;
+  }
+  function identify(user) {
+    identity = user;
+    sendRaw({
+      type: "identify",
+      userId: user.id,
+      ...user.name ? { name: user.name } : {},
+      ...user.avatar ? { avatar: user.avatar } : {}
+    });
+  }
+  function joinRoute(nextRoute) {
+    route = nextRoute;
     emit(presenceListeners, []);
-    if (ws && ws.readyState === WS.OPEN) {
-      try {
-        ws.send(JSON.stringify({ type: "join", route }));
-      } catch {
-      }
-    }
+    sendRaw({ type: "join", route: nextRoute });
   }
   function onPresence(cb) {
     presenceListeners.add(cb);
@@ -266,15 +298,46 @@ function createRealtimeChannel(options) {
       pinListeners.delete(cb);
     };
   }
+  function onPinArchived(cb) {
+    pinArchivedListeners.add(cb);
+    return () => {
+      pinArchivedListeners.delete(cb);
+    };
+  }
+  function onOpen(cb) {
+    openListeners.add(cb);
+    return () => {
+      openListeners.delete(cb);
+    };
+  }
+  function onClose(cb) {
+    closeListeners.add(cb);
+    return () => {
+      closeListeners.delete(cb);
+    };
+  }
+  function onRpcResponse(cb) {
+    rpcListeners.add(cb);
+    return () => {
+      rpcListeners.delete(cb);
+    };
+  }
   return {
     get state() {
       return state;
     },
     connect,
     disconnect,
+    identify,
+    clearSession,
     joinRoute,
+    sendFrame: sendRaw,
     onPresence,
-    onPin
+    onPin,
+    onPinArchived,
+    onOpen,
+    onClose,
+    onRpcResponse
   };
 }
 
@@ -293,29 +356,111 @@ var CloudError = class extends Error {
   }
 };
 
+// src/cloud/rpc.ts
+var DEFAULT_RPC_TIMEOUT_MS = 3e4;
+var SUBMIT_RPC_TIMEOUT_MS = 12e4;
+function authFailedError() {
+  return new CloudError("WebSocket authentication failed", { status: 401 });
+}
+function createRpcClient(channel, options) {
+  const timeoutMs = options?.timeoutMs ?? DEFAULT_RPC_TIMEOUT_MS;
+  const idSuffix = Math.random().toString(36).slice(2, 8);
+  let idCounter = 0;
+  const pending = /* @__PURE__ */ new Map();
+  const queue = [];
+  let terminalError = null;
+  function settlePending(err) {
+    for (const entry of pending.values()) {
+      clearTimeout(entry.timer);
+      entry.reject(err);
+    }
+    pending.clear();
+  }
+  channel.onOpen(() => {
+    while (queue.length > 0) {
+      const next = queue[0];
+      if (!channel.sendFrame(next.frame)) return;
+      queue.shift();
+      pending.set(next.frame.id, next.entry);
+    }
+  });
+  function rejectQueue(err) {
+    for (const queued of queue) {
+      clearTimeout(queued.entry.timer);
+      queued.entry.reject(err);
+    }
+    queue.length = 0;
+  }
+  channel.onClose((code, willReconnect) => {
+    if (code === CLOSE_CODE_AUTH_FAILED) {
+      const err = authFailedError();
+      terminalError = err;
+      settlePending(err);
+      rejectQueue(err);
+      return;
+    }
+    settlePending(new CloudError("Connection lost", { status: 0 }));
+    if (!willReconnect) {
+      rejectQueue(new CloudError("Connection lost", { status: 0 }));
+    }
+  });
+  channel.onRpcResponse((frame) => {
+    const entry = pending.get(frame.id);
+    if (!entry) return;
+    pending.delete(frame.id);
+    clearTimeout(entry.timer);
+    if (frame.ok) {
+      entry.resolve(frame.data);
+    } else {
+      entry.reject(
+        new CloudError(frame.error, {
+          status: frame.status,
+          retryAfter: frame.retryAfter,
+          details: frame.details
+        })
+      );
+    }
+  });
+  function call(method, params, opts) {
+    if (terminalError) return Promise.reject(terminalError);
+    const callTimeoutMs = opts?.timeoutMs ?? timeoutMs;
+    return new Promise((resolve, reject) => {
+      idCounter += 1;
+      const id = `${idCounter.toString(36)}-${idSuffix}`;
+      const frame = {
+        type: "rpc",
+        id,
+        method,
+        ...params !== void 0 ? { params } : {}
+      };
+      const timer = setTimeout(() => {
+        pending.delete(id);
+        const queuedIndex = queue.findIndex((q) => q.frame.id === id);
+        if (queuedIndex !== -1) queue.splice(queuedIndex, 1);
+        reject(new CloudError("Request timed out", { status: 0 }));
+      }, callTimeoutMs);
+      const entry = {
+        resolve,
+        reject,
+        timer
+      };
+      if (channel.sendFrame(frame)) {
+        pending.set(id, entry);
+      } else {
+        queue.push({ frame, entry });
+        channel.connect();
+      }
+    });
+  }
+  return { call };
+}
+
 // src/cloud/client.ts
 function trimEndpoint(endpoint) {
   return endpoint.endsWith("/") ? endpoint.slice(0, -1) : endpoint;
 }
-function unwrap(result) {
-  if (result.error !== void 0 || !result.data) {
-    const status = result.response.status;
-    const retryAfter = status === 429 ? parseRetryAfter(result.response.headers.get("Retry-After")) : void 0;
-    const msg = result.error && typeof result.error === "object" && "error" in result.error && typeof result.error.error === "string" ? result.error.error : `Request failed (${status})`;
-    throw new CloudError(msg, { status, retryAfter, details: result.error });
-  }
-  return result.data;
-}
-function parseRetryAfter(header) {
-  if (!header) return void 0;
-  const seconds = Number(header);
-  if (Number.isFinite(seconds) && seconds >= 0) return seconds;
-  const date = Date.parse(header);
-  if (Number.isFinite(date)) {
-    const delta = Math.ceil((date - Date.now()) / 1e3);
-    return delta > 0 ? delta : 0;
-  }
-  return void 0;
+function nextUploadId() {
+  return `up-${crypto.randomUUID()}`;
 }
 function cloud(options) {
   let cachedConfig = null;
@@ -326,13 +471,18 @@ function cloud(options) {
   }
   const endpoint = trimEndpoint(options.endpoint ?? DEFAULT_CLOUD_ENDPOINT);
   const git = options.git;
-  const apiClient = createClient2(
-    createConfig2({
-      baseUrl: endpoint,
-      ...options.fetch ? { fetch: options.fetch } : {},
-      headers: { Authorization: `Bearer ${projectKey}` }
-    })
-  );
+  function buildWsUrl() {
+    const httpToWs = endpoint.replace(/^http:/, "ws:").replace(/^https:/, "wss:");
+    const params = new URLSearchParams();
+    params.set("key", projectKey);
+    return `${httpToWs}/ws?${params.toString()}`;
+  }
+  const channel = createRealtimeChannel({
+    buildUrl: buildWsUrl,
+    ...options.WebSocketImpl ? { WebSocketImpl: options.WebSocketImpl } : {}
+  });
+  const rpc = createRpcClient(channel);
+  const eagerConnect = options.WebSocketImpl !== void 0 || typeof window !== "undefined" && typeof WebSocket === "function";
   async function submit(payload) {
     const enriched = git?.branch || git?.commit ? {
       ...payload,
@@ -344,102 +494,152 @@ function cloud(options) {
         }
       }
     } : payload;
-    const result = await submitReport({
-      client: apiClient,
-      body: enriched
+    const screenshot = enriched.screenshot;
+    if (typeof screenshot === "string" && screenshot.length > SCREENSHOT_INLINE_MAX_BYTES) {
+      const uploadId = nextUploadId();
+      const total = Math.ceil(screenshot.length / SCREENSHOT_CHUNK_BYTES);
+      for (let seq = 0; seq < total; seq++) {
+        const data = screenshot.slice(
+          seq * SCREENSHOT_CHUNK_BYTES,
+          (seq + 1) * SCREENSHOT_CHUNK_BYTES
+        );
+        await rpc.call(
+          "screenshot.chunk",
+          { uploadId, seq, total, data },
+          { timeoutMs: SUBMIT_RPC_TIMEOUT_MS }
+        );
+      }
+      return rpc.call(
+        "reports.submit",
+        { ...enriched, screenshot: void 0, screenshotUploadId: uploadId },
+        { timeoutMs: SUBMIT_RPC_TIMEOUT_MS }
+      );
+    }
+    return rpc.call("reports.submit", enriched, {
+      timeoutMs: SUBMIT_RPC_TIMEOUT_MS
     });
-    return unwrap(result);
-  }
-  async function fetchConfig() {
-    const result = await getIngestConfig({ client: apiClient });
-    return unwrap(result);
   }
   function startFetch() {
-    const promise = fetchConfig();
+    const promise = rpc.call("config.get", void 0);
+    cachedConfig = promise;
     promise.then(
       (config) => {
         resolvedConfig = config;
       },
       () => {
+        if (cachedConfig === promise) cachedConfig = null;
       }
     );
     return promise;
   }
-  cachedConfig = startFetch();
+  if (eagerConnect) {
+    channel.connect();
+    startFetch();
+  }
   function getConfig() {
-    return cachedConfig ?? (cachedConfig = startFetch());
+    return cachedConfig ?? startFetch();
   }
   function getCachedConfig() {
     return resolvedConfig;
   }
-  function realtimeUrl(route, user) {
-    const httpToWs = endpoint.replace(/^http:/, "ws:").replace(/^https:/, "wss:");
-    const params = new URLSearchParams();
-    params.set("key", projectKey);
-    params.set("route", route);
-    params.set("userId", user.id);
-    if (user.name) params.set("name", user.name);
-    if (user.avatar) params.set("avatar", user.avatar);
-    return `${httpToWs}/ws?${params.toString()}`;
-  }
   function connectRealtime(opts) {
     if (!opts || !opts.user || typeof opts.user.id !== "string") {
       throw new TypeError("uidex/cloud: realtime.connect requires `user.id`");
     }
     let currentRoute = opts.route;
-    const channel = createRealtimeChannel({
-      buildUrl: () => realtimeUrl(currentRoute, opts.user)
-    });
-    const originalJoinRoute = channel.joinRoute;
-    const wrapped = {
+    let detached = false;
+    const registrations = /* @__PURE__ */ new Set();
+    function register(attach) {
+      const reg = { attach, detach: detached ? null : attach() };
+      registrations.add(reg);
+      return () => {
+        registrations.delete(reg);
+        reg.detach?.();
+        reg.detach = null;
+      };
+    }
+    function arm() {
+      channel.identify(opts.user);
+      channel.joinRoute(currentRoute);
+      channel.connect();
+    }
+    arm();
+    return {
       get state() {
-        return channel.state;
+        return detached ? "disconnected" : channel.state;
+      },
+      // Re-arms identity/route and re-attaches this facade's listeners so an
+      // explicit disconnect() -> connect() restores presence and pin events.
+      connect: () => {
+        if (detached) {
+          detached = false;
+          for (const reg of registrations) reg.detach ??= reg.attach();
+        }
+        arm();
+      },
+      // Soft leave: drop presence and the stored identity (so a later
+      // reopen/revival stays anonymous) but keep the adapter's shared socket
+      // alive — in-flight and future RPCs (reports.submit, pins.*) must
+      // survive a surface unmount. Socket teardown is reserved for
+      // CloudAdapter.dispose().
+      disconnect: () => {
+        detached = true;
+        channel.sendFrame({ type: "leave" });
+        channel.clearSession();
+        for (const reg of registrations) {
+          reg.detach?.();
+          reg.detach = null;
+        }
       },
-      connect: () => channel.connect(),
-      disconnect: () => channel.disconnect(),
       joinRoute: (route) => {
         currentRoute = route;
-        originalJoinRoute(route);
+        channel.joinRoute(route);
       },
-      onPresence: (cb) => channel.onPresence(cb),
-      onPin: (cb) => channel.onPin(cb)
+      onPresence: (cb) => register(() => channel.onPresence(cb)),
+      onPin: (cb) => register(() => channel.onPin(cb)),
+      onPinArchived: (cb) => register(() => channel.onPinArchived(cb))
     };
-    channel.connect();
-    return wrapped;
   }
-  async function listPins2(params) {
-    const result = await listPins({
-      client: apiClient,
-      query: params
+  async function listPins(params) {
+    const entities = params.entities ? params.entities.split(",").filter(Boolean) : void 0;
+    const result = await rpc.call("pins.list", {
+      ...params.route !== void 0 ? { route: params.route } : {},
+      ...entities ? { entities } : {}
     });
-    const data = unwrap(result);
-    return data.pins;
+    return result.pins;
   }
-  async function archivePin2(reportId, reason) {
-    const result = await archivePin({
-      client: apiClient,
-      body: { reportId, ...reason ? { reason } : {} }
-    });
-    unwrap(result);
+  async function getPinScreenshot(reportId) {
+    const result = await rpc.call("pins.screenshot", { reportId });
+    return result.screenshot;
   }
-  async function listReports(opts) {
-    const result = await listIngestReports({
-      client: apiClient,
-      query: opts
-    });
-    return unwrap(result);
+  async function closePin(reportId, reason) {
+    await rpc.call("pins.archive", { reportId, ...reason ? { reason } : {} });
+  }
+  function listReports(opts) {
+    return rpc.call("reports.list", opts ?? {});
+  }
+  function dispose() {
+    channel.disconnect();
   }
   return {
     reports: { submit, list: listReports },
     integrations: { getConfig, getCachedConfig },
     realtime: { connect: connectRealtime },
-    pins: { list: listPins2, archive: archivePin2 }
+    pins: { list: listPins, screenshot: getPinScreenshot, close: closePin },
+    dispose
   };
 }
 export {
   CloudError,
   DEFAULT_CLOUD_ENDPOINT,
+  DEFAULT_RPC_TIMEOUT_MS,
+  RPC_METHODS,
+  SCREENSHOT_CHUNK_BYTES,
+  SCREENSHOT_INLINE_MAX_BYTES,
   cloud,
-  createRealtimeChannel
+  createRealtimeChannel,
+  createRpcClient,
+  isRpcMethod,
+  parseRpcResponseFrame
 };
 //# sourceMappingURL=index.js.map