@opengeni/react 3.1.0 → 3.1.3-canary.38890816741001

package/src/hooks/use-computer-frame-stream.ts

@@ -57,7 +57,12 @@ export type UseComputerFrameStreamResult = {
   frame: ComputerFrame | null;
   attachment: Pick<
     ComputerSessionAttachment,
-    "computerSessionId" | "controllerGeneration" | "targetId" | "stream" | "expiresAt"
+    | "computerSessionId"
+    | "controllerGeneration"
+    | "targetId"
+    | "inputAllowed"
+    | "stream"
+    | "expiresAt"
   > | null;
   error: Error | null;
   reconnect: () => void;
@@ -159,9 +164,19 @@ export function useComputerFrameStream(
       pendingFrame = null;
     };
 
+    const clearRecoveryTimers = () => {
+      if (reconnectTimer) clearTimeout(reconnectTimer);
+      if (expiryTimer) clearTimeout(expiryTimer);
+      reconnectTimer = null;
+      expiryTimer = null;
+    };
+
     const scheduleReconnect = () => {
       if (disposed || reconnectTimer) return;
-      if (failures >= MAX_AUTOMATIC_RECONNECTS_WITHOUT_A_FRAME) return;
+      if (failures >= MAX_AUTOMATIC_RECONNECTS_WITHOUT_A_FRAME) {
+        clearRecoveryTimers();
+        return;
+      }
       const delay = Math.min(5_000, 250 * 2 ** Math.min(failures, 5));
       failures += 1;
       setResult((current) => ({ ...current, state: "reconnecting" }));
@@ -177,6 +192,7 @@ export function useComputerFrameStream(
       setResult((current) => ({ ...current, state: "error", error }));
       clearSocket();
       if (reconnectAutomatically) scheduleReconnect();
+      else clearRecoveryTimers();
     };
 
     const onOpen = (source: ComputerFrameWebSocket) => {
@@ -295,8 +311,7 @@ export function useComputerFrameStream(
 
     const onClose = (source: ComputerFrameWebSocket) => {
       if (disposed || source !== socket) return;
-      clearSocket();
-      scheduleReconnect();
+      fail(new Error("Desktop view lost connection."));
     };
 
     const connectSocket = () => {
@@ -356,7 +371,7 @@ export function useComputerFrameStream(
             expiresInSeconds: 120,
             ...(streamRef.current ? { stream: streamRef.current } : {}),
           },
-          { signal: attachmentAbort.signal },
+          { signal: attachmentAbort.signal, timeoutMs: 15_000 },
         );
         if (disposed) return;
         if (
@@ -366,6 +381,9 @@ export function useComputerFrameStream(
           throw new Error("desktop attachment does not match the requested resource");
         }
         controllerGeneration = attachment.controllerGeneration;
+        // A fresh attachment owns a new producer whose sequence can restart.
+        // Transport reconnects reuse the attachment and retain their sequence fence.
+        latestRef.current = { key: "", sequence: -1 };
         activeAttachment = attachment;
         activeStream = attachment.stream;
         attachmentExpiresAt = Date.parse(attachment.expiresAt);
@@ -378,6 +396,7 @@ export function useComputerFrameStream(
             computerSessionId: attachment.computerSessionId,
             controllerGeneration: attachment.controllerGeneration,
             targetId: attachment.targetId,
+            inputAllowed: attachment.inputAllowed,
             stream: attachment.stream,
             expiresAt: attachment.expiresAt,
           },
@@ -406,8 +425,7 @@ export function useComputerFrameStream(
       disposed = true;
       pendingFrame = null;
       attachmentAbort.abort();
-      if (reconnectTimer) clearTimeout(reconnectTimer);
-      if (expiryTimer) clearTimeout(expiryTimer);
+      clearRecoveryTimers();
       clearSocket(true);
     };
   }, [client, enabled, nonce, options.computerSessionId, options.targetId, workspaceId]);

package/src/hooks/use-computer-input-posture.ts

@@ -0,0 +1,94 @@
+import { useCallback, useEffect, useRef, useState } from "react";
+import {
+  type EmbeddedComputerInteractionClientOverride,
+  useEmbeddedComputerInteraction,
+} from "../session-context";
+
+type PostureSource = {
+  client: ReturnType<typeof useEmbeddedComputerInteraction>["client"];
+  key: string;
+};
+
+type PostureState = {
+  source: PostureSource;
+  nonce: number;
+  inputAllowed: boolean | null;
+  pending: boolean;
+  error: Error | null;
+};
+
+/** Semantic-only targets need caller authority without opening a pixel stream.
+ * A source change synchronously discards the previous posture. */
+export function useComputerInputPosture(
+  options: EmbeddedComputerInteractionClientOverride & {
+    computerSessionId: string | null;
+    controllerGeneration: string | null;
+    enabled: boolean;
+  },
+) {
+  const { client, workspaceId } = useEmbeddedComputerInteraction(options);
+  const { computerSessionId, controllerGeneration, enabled } = options;
+  const [nonce, setNonce] = useState(0);
+  const [state, setState] = useState<PostureState | null>(null);
+  const key = JSON.stringify([workspaceId, computerSessionId, controllerGeneration, enabled]);
+  const sourceRef = useRef<PostureSource>({ client, key });
+  if (sourceRef.current.client !== client || sourceRef.current.key !== key) {
+    sourceRef.current = { client, key };
+  }
+  const source = sourceRef.current;
+  const visible = state?.source === source && state.nonce === nonce ? state : null;
+  const refresh = useCallback(() => setNonce((value) => value + 1), []);
+
+  useEffect(() => {
+    if (!enabled || !computerSessionId || !controllerGeneration) return;
+    const controller = new AbortController();
+    let disposed = false;
+    setState({ source, nonce, inputAllowed: null, pending: true, error: null });
+    void (async () => {
+      try {
+        if (!client.getComputerInputPosture) {
+          throw new Error("Desktop input availability could not be verified.");
+        }
+        const posture = await client.getComputerInputPosture(workspaceId, computerSessionId, {
+          signal: controller.signal,
+          timeoutMs: 15_000,
+        });
+        if (disposed || sourceRef.current !== source) return;
+        if (
+          posture.computerSessionId !== computerSessionId ||
+          posture.controllerGeneration !== controllerGeneration ||
+          typeof posture.inputAllowed !== "boolean"
+        ) {
+          throw new Error("Desktop input availability belongs to a different controller.");
+        }
+        setState({
+          source,
+          nonce,
+          inputAllowed: posture.inputAllowed,
+          pending: false,
+          error: null,
+        });
+      } catch (cause) {
+        if (disposed || controller.signal.aborted || sourceRef.current !== source) return;
+        setState({
+          source,
+          nonce,
+          inputAllowed: null,
+          pending: false,
+          error: cause instanceof Error ? cause : new Error(String(cause)),
+        });
+      }
+    })();
+    return () => {
+      disposed = true;
+      controller.abort();
+    };
+  }, [client, computerSessionId, controllerGeneration, enabled, nonce, source, workspaceId]);
+
+  return {
+    inputAllowed: visible?.inputAllowed ?? null,
+    pending: enabled && (visible?.pending ?? true),
+    error: visible?.error ?? null,
+    refresh,
+  };
+}