@opengeni/react 1.0.1 → 1.0.2-canary.37191796234001

package/src/hooks/use-sandbox-git.ts

@@ -233,12 +233,14 @@ export function useSandboxGit(
   // survive renders, so they must be fenced/reset when that identity changes.
   const refreshGenerationRef = useRef(0);
   const refreshAbortRef = useRef<AbortController | null>(null);
+  const refreshInFlightRef = useRef<Promise<void> | null>(null);
+  const refreshPendingRef = useRef(false);
+  const refreshWorkerEpochRef = useRef(0);
   const lastChangeRef = useRef(0);
-  const commandRefreshTimerRef = useRef<ReturnType<typeof setTimeout> | null>(null);
+  const eventRefreshTimerRef = useRef<ReturnType<typeof setTimeout> | null>(null);
 
-  const refresh = useCallback(async () => {
+  const performRefresh = useCallback(async () => {
     if (!sessionId) return;
-    refreshAbortRef.current?.abort();
     const refreshAbort = new AbortController();
     refreshAbortRef.current = refreshAbort;
     const generation = (refreshGenerationRef.current += 1);
@@ -377,6 +379,32 @@ export function useSandboxGit(
     comparison,
   ]);
 
+  // Provider reads cannot be undispatched after they reach a remote sandbox.
+  // Keep exactly one refresh in flight and collapse any burst of invalidations
+  // into one trailing read. Aborting and replacing every tool-output refresh
+  // used to leave several Modal reads contending for the same provider lock.
+  const performRefreshRef = useRef(performRefresh);
+  performRefreshRef.current = performRefresh;
+  const refresh = useCallback(async () => {
+    refreshPendingRef.current = true;
+    const existing = refreshInFlightRef.current;
+    if (existing) return await existing;
+
+    const workerEpoch = refreshWorkerEpochRef.current;
+    const run = (async () => {
+      while (refreshPendingRef.current && refreshWorkerEpochRef.current === workerEpoch) {
+        refreshPendingRef.current = false;
+        await performRefreshRef.current();
+      }
+    })();
+    refreshInFlightRef.current = run;
+    try {
+      await run;
+    } finally {
+      if (refreshInFlightRef.current === run) refreshInFlightRef.current = null;
+    }
+  }, []);
+
   // Serve the requested review scope from a capture when that scope exists.
   const seedFromCapture = useCallback(
     (manifest: WorkspaceCaptureManifest) => {
@@ -432,9 +460,17 @@ export function useSandboxGit(
     // true data-identity change clears rendered state and the event high-water mark.
     refreshAbortRef.current?.abort();
     refreshAbortRef.current = null;
+    refreshPendingRef.current = false;
     refreshGenerationRef.current += 1;
     const identityChanged = previousIdentityRef.current !== identityKey;
     previousIdentityRef.current = identityKey;
+    if (identityChanged) {
+      // Different sessions target different provider identities. Fence the old
+      // worker and let the new session load immediately instead of waiting for a
+      // stuck request that has already been aborted.
+      refreshWorkerEpochRef.current += 1;
+      refreshInFlightRef.current = null;
+    }
     if (identityChanged || !enabled) {
       lastChangeRef.current = 0;
       setDiff([]);
@@ -466,6 +502,7 @@ export function useSandboxGit(
     return () => {
       refreshAbortRef.current?.abort();
       refreshAbortRef.current = null;
+      refreshPendingRef.current = false;
       refreshGenerationRef.current += 1;
     };
   }, [
@@ -479,15 +516,15 @@ export function useSandboxGit(
     seedFromCapture,
   ]);
 
-  // git.changed → re-fetch the LIVE diff. Agent tool completion is also an
-  // invalidation point because shell/apply-patch writes can bypass Channel-A and
-  // therefore emit no git.changed event. This is event-driven, never polling.
+  // Structured Git changes are debounced into one live reconcile. Generic
+  // command/tool output performs no provider reads: the canonical turn-end
+  // capture advances `captureRevision`, which refreshes after the burst settles.
   const events = options.events;
   useEffect(() => {
     if (!enabled || !events) {
-      if (commandRefreshTimerRef.current) {
-        clearTimeout(commandRefreshTimerRef.current);
-        commandRefreshTimerRef.current = null;
+      if (eventRefreshTimerRef.current) {
+        clearTimeout(eventRefreshTimerRef.current);
+        eventRefreshTimerRef.current = null;
       }
       return;
     }
@@ -498,43 +535,35 @@ export function useSandboxGit(
       for (const event of events) {
         if (event.sequence > lastChangeRef.current) lastChangeRef.current = event.sequence;
       }
-      if (commandRefreshTimerRef.current) {
-        clearTimeout(commandRefreshTimerRef.current);
-        commandRefreshTimerRef.current = null;
+      if (eventRefreshTimerRef.current) {
+        clearTimeout(eventRefreshTimerRef.current);
+        eventRefreshTimerRef.current = null;
       }
       return;
     }
     let latest = lastChangeRef.current;
-    let immediate = false;
-    let commandDelta = false;
+    let changed = false;
     for (const event of events) {
       if (event.sequence <= latest) continue;
-      if (event.type === "git.changed" || event.type === "agent.toolCall.output") {
-        latest = event.sequence;
-        immediate = true;
-      } else if (event.type === "sandbox.command.output.delta") {
+      if (event.type === "git.changed") {
         latest = event.sequence;
-        commandDelta = true;
+        changed = true;
       }
     }
     if (latest > lastChangeRef.current) {
       lastChangeRef.current = latest;
-      if (immediate) {
-        if (commandRefreshTimerRef.current) clearTimeout(commandRefreshTimerRef.current);
-        commandRefreshTimerRef.current = null;
+      if (!changed) return;
+      if (eventRefreshTimerRef.current) clearTimeout(eventRefreshTimerRef.current);
+      eventRefreshTimerRef.current = setTimeout(() => {
+        eventRefreshTimerRef.current = null;
         if (acceptsEventReadsRef.current) void refresh();
-      } else if (commandDelta && !commandRefreshTimerRef.current) {
-        commandRefreshTimerRef.current = setTimeout(() => {
-          commandRefreshTimerRef.current = null;
-          if (acceptsEventReadsRef.current) void refresh();
-        }, 1_000);
-      }
+      }, 150);
     }
   }, [enabled, active, acceptsEventReads, events, refresh]);
 
   useEffect(
     () => () => {
-      if (commandRefreshTimerRef.current) clearTimeout(commandRefreshTimerRef.current);
+      if (eventRefreshTimerRef.current) clearTimeout(eventRefreshTimerRef.current);
     },
     [],
   );

package/src/hooks/use-session-background-commands.ts

@@ -0,0 +1,67 @@
+import type { SessionBackgroundCommand } from "@opengeni/sdk";
+import { useCallback, useEffect, useRef } from "react";
+
+import { useOpenGeni, type ClientOverride } from "../provider";
+import { usePolledValue } from "./internal";
+
+export type UseSessionBackgroundCommandsOptions = ClientOverride & {
+  pollIntervalMs?: number | undefined;
+  enabled?: boolean | undefined;
+};
+
+export type UseSessionBackgroundCommandsResult = {
+  commands: SessionBackgroundCommand[];
+  loading: boolean;
+  error: Error | null;
+  refresh: () => Promise<void>;
+  cancel: (commandId: string) => Promise<void>;
+};
+
+export function useSessionBackgroundCommands(
+  sessionId: string | null | undefined,
+  options: UseSessionBackgroundCommandsOptions = {},
+): UseSessionBackgroundCommandsResult {
+  const { client, workspaceId } = useOpenGeni(options);
+  const enabled = (options.enabled ?? true) && Boolean(sessionId);
+  const load = useCallback(
+    async (signal?: AbortSignal) => {
+      if (!sessionId) return { commands: [] };
+      if (!client.listSessionBackgroundCommands) {
+        throw new Error("The configured OpenGeni client does not support background commands");
+      }
+      return await client.listSessionBackgroundCommands(workspaceId, sessionId, { signal });
+    },
+    [client, workspaceId, sessionId],
+  );
+  const state = usePolledValue(load, {
+    enabled,
+    pollIntervalMs: options.pollIntervalMs,
+  });
+  const refresh = state.refresh;
+  const generation = useRef(0);
+  useEffect(() => {
+    generation.current += 1;
+    return () => {
+      generation.current += 1;
+    };
+  }, [client, workspaceId, sessionId, enabled]);
+  const cancel = useCallback(
+    async (commandId: string): Promise<void> => {
+      if (!sessionId) return;
+      if (!client.cancelSessionBackgroundCommand) {
+        throw new Error("The configured OpenGeni client does not support background commands");
+      }
+      const ticket = generation.current;
+      await client.cancelSessionBackgroundCommand(workspaceId, sessionId, commandId);
+      if (enabled && ticket === generation.current) await refresh();
+    },
+    [client, workspaceId, sessionId, refresh, enabled],
+  );
+  return {
+    commands: state.data?.commands ?? [],
+    loading: state.loading,
+    error: state.error,
+    refresh,
+    cancel,
+  };
+}

package/src/hooks/use-session-capabilities.ts

@@ -9,6 +9,7 @@ import { useCallback, useEffect, useRef, useState } from "react";
 import { useOpenGeni, type ClientOverride } from "../provider";
 import { sandboxAcceptsLiveIo } from "../lib/sandbox-liveness";
 import { terminalCanAcquirePty } from "../lib/terminal-capability";
+import { normalizeError } from "../lib/error-message";
 import { usePageLiveActivity } from "./internal";
 
 // "on-demand" is the boxless-benign resting state: the lease is not currently
@@ -283,8 +284,13 @@ export function useSessionCapabilities(
           })
           .catch((cause) => {
             if (!cancelled) {
+              if (isSandboxOwnershipDisabledError(cause)) {
+                setState("on-demand");
+                setError(null);
+                return;
+              }
               setState("error");
-              setError(cause instanceof Error ? cause : new Error(String(cause)));
+              setError(normalizeError(cause));
             }
           });
       }, warmingPollMs);
@@ -453,13 +459,18 @@ export function useSessionCapabilities(
         }
       } catch (cause) {
         if (cancelled) return;
+        if (isSandboxOwnershipDisabledError(cause)) {
+          setState("on-demand");
+          setError(null);
+          return;
+        }
         if (cause instanceof OpenGeniApiError && cause.status === 403) {
           setState("error");
           setError(new Error("not permitted to view this session's sandbox"));
           return;
         }
         setState("error");
-        setError(cause instanceof Error ? cause : new Error(String(cause)));
+        setError(normalizeError(cause));
       }
     })();
 
@@ -524,3 +535,11 @@ export function useSessionCapabilities(
     renegotiate,
   };
 }
+
+function isSandboxOwnershipDisabledError(error: unknown): boolean {
+  return (
+    error instanceof OpenGeniApiError &&
+    error.status === 404 &&
+    error.message.includes("sandbox ownership is not enabled")
+  );
+}