@opengeni/react 0.11.0 → 0.13.0

package/src/hooks/use-machines.ts

@@ -21,7 +21,10 @@ import type { MachinesResponse, MachineView, MetricSample } from "../types/machi
  */
 export type MachinesClientLike = {
   /** GET /v1/workspaces/:ws/machines — the dashboard list + active pointer. */
-  listMachines: (workspaceId: string, options?: { sessionId?: string }) => Promise<MachinesResponse>;
+  listMachines: (
+    workspaceId: string,
+    options?: { sessionId?: string },
+  ) => Promise<MachinesResponse>;
   /** GET .../machines/:enrollmentId/metrics/series — the downsampled history. */
   machineMetricsSeries?: (
     workspaceId: string,
@@ -69,7 +72,10 @@ export type UseMachinesResult = {
   /** Whether the host wired an attach/swap path (drives the card affordance). */
   canAttach: boolean;
   /** Fetch a downsampled metric series for one enrolled machine. */
-  fetchSeries: (enrollmentId: string, window?: "15m" | "1h" | "6h" | "24h") => Promise<MetricSample[]>;
+  fetchSeries: (
+    enrollmentId: string,
+    window?: "15m" | "1h" | "6h" | "24h",
+  ) => Promise<MetricSample[]>;
   attaching: boolean;
   /** The sandbox id of the in-flight attach (for per-card spinner gating). */
   attachingSandboxId: string | null;
@@ -89,19 +95,28 @@ const EMPTY: MachinesResponse = { activeSandboxId: null, activeEpoch: 0, machine
  */
 export function useMachines(options: UseMachinesOptions = {}): UseMachinesResult {
   const { client, workspaceId } = useOpenGeni(options);
-  const machinesClient = (options.machinesClient ?? (client as unknown as MachinesClientLike)) satisfies MachinesClientLike;
+  const machinesClient = (options.machinesClient ??
+    (client as unknown as MachinesClientLike)) satisfies MachinesClientLike;
   const sessionId = options.sessionId;
 
   const load = useCallback(async () => {
     return await machinesClient.listMachines(workspaceId, sessionId ? { sessionId } : undefined);
   }, [machinesClient, workspaceId, sessionId]);
 
-  const state = usePolledValue(load, { pollIntervalMs: options.pollIntervalMs, enabled: options.enabled });
-  const mutation = useMutationRunner();
+  const {
+    data: loadedData,
+    loading,
+    error,
+    refresh,
+  } = usePolledValue(load, {
+    pollIntervalMs: options.pollIntervalMs,
+    enabled: options.enabled,
+  });
+  const { run, mutating, mutationError, clearMutationError } = useMutationRunner();
   // The sandbox id of the in-flight attach (drives the per-card spinner).
   const [attachingSandboxId, setAttachingSandboxId] = useState<string | null>(null);
 
-  const data = state.data ?? EMPTY;
+  const data = loadedData ?? EMPTY;
   // The swap is session-scoped: a host adapter (`attachMachine`) wins; otherwise
   // the default `swapActiveSandbox` path is wired whenever a sessionId is in
   // scope. Either way attach needs a sessionId to point at.
@@ -120,19 +135,22 @@ export function useMachines(options: UseMachinesOptions = {}): UseMachinesResult
           : null;
       if (!runSwap) return false;
       setAttachingSandboxId(sandboxId);
-      const result = await mutation.run(async () => {
+      const result = await run(async () => {
         await runSwap();
         return true;
       });
       setAttachingSandboxId(null);
-      if (result) await state.refresh();
+      if (result) await refresh();
       return result === true;
     },
-    [machinesClient, workspaceId, sessionId, mutation.run, state.refresh],
+    [machinesClient, workspaceId, sessionId, run, refresh],
   );
 
   const fetchSeries = useCallback(
-    async (enrollmentId: string, window: "15m" | "1h" | "6h" | "24h" = "1h"): Promise<MetricSample[]> => {
+    async (
+      enrollmentId: string,
+      window: "15m" | "1h" | "6h" | "24h" = "1h",
+    ): Promise<MetricSample[]> => {
       if (!machinesClient.machineMetricsSeries) return [];
       return await machinesClient.machineMetricsSeries(workspaceId, enrollmentId, { window });
     },
@@ -143,15 +161,15 @@ export function useMachines(options: UseMachinesOptions = {}): UseMachinesResult
     machines: data.machines,
     activeSandboxId: data.activeSandboxId,
     activeEpoch: data.activeEpoch,
-    loading: state.loading,
-    error: state.error,
-    refresh: state.refresh,
+    loading,
+    error,
+    refresh,
     attach,
     canAttach,
     fetchSeries,
-    attaching: mutation.mutating,
+    attaching: mutating,
     attachingSandboxId,
-    mutationError: mutation.mutationError,
-    clearMutationError: mutation.clearMutationError,
+    mutationError,
+    clearMutationError,
   };
 }

package/src/hooks/use-packs.ts

@@ -9,6 +9,8 @@ import { useCallback } from "react";
 import { useOpenGeni, type ClientOverride } from "../provider";
 import { useMutationRunner, usePolledValue } from "./internal";
 
+const EMPTY_INSTALLATIONS: PackInstallation[] = [];
+
 export type UsePacksOptions = ClientOverride & {
   pollIntervalMs?: number | undefined;
   enabled?: boolean | undefined;
@@ -38,46 +40,49 @@ export type UsePacksResult = {
 export function usePacks(options: UsePacksOptions = {}): UsePacksResult {
   const { client, workspaceId } = useOpenGeni(options);
   const load = useCallback(async () => await client.listPacks(workspaceId), [client, workspaceId]);
-  const state = usePolledValue(load, { pollIntervalMs: options.pollIntervalMs, enabled: options.enabled });
-  const mutation = useMutationRunner();
+  const { data, loading, error, refresh } = usePolledValue(load, {
+    pollIntervalMs: options.pollIntervalMs,
+    enabled: options.enabled,
+  });
+  const { run, mutating, mutationError, clearMutationError } = useMutationRunner();
 
   const register = useCallback(
     async (manifest: RegisterCapabilityPackRequest): Promise<WorkspaceRegisteredPack | null> => {
-      const result = await mutation.run(() => client.registerPack(workspaceId, manifest));
+      const result = await run(() => client.registerPack(workspaceId, manifest));
       if (result) {
-        await state.refresh();
+        await refresh();
       }
       return result;
     },
-    [client, workspaceId, mutation.run, state.refresh],
+    [client, workspaceId, run, refresh],
   );
 
   const enable = useCallback(
     async (packId: string, request: EnablePackRequest = {}): Promise<PackInstallation | null> => {
-      const result = await mutation.run(() => client.enablePack(workspaceId, packId, request));
+      const result = await run(() => client.enablePack(workspaceId, packId, request));
       if (result) {
-        await state.refresh();
+        await refresh();
       }
       return result;
     },
-    [client, workspaceId, mutation.run, state.refresh],
+    [client, workspaceId, run, refresh],
   );
 
   const remove = useCallback(
     async (packId: string): Promise<boolean> => {
-      const result = await mutation.run(async () => {
+      const result = await run(async () => {
         await client.deletePack(workspaceId, packId);
         return true;
       });
       if (result) {
-        await state.refresh();
+        await refresh();
       }
       return result === true;
     },
-    [client, workspaceId, mutation.run, state.refresh],
+    [client, workspaceId, run, refresh],
   );
 
-  const installations = state.data?.installations ?? [];
+  const installations = data?.installations ?? EMPTY_INSTALLATIONS;
   const installationFor = useCallback(
     (packId: string): PackInstallation | null =>
       installations.find((installation) => installation.packId === packId) ?? null,
@@ -85,17 +90,17 @@ export function usePacks(options: UsePacksOptions = {}): UsePacksResult {
   );
 
   return {
-    packs: state.data?.packs ?? [],
+    packs: data?.packs ?? [],
     installations,
     installationFor,
-    loading: state.loading,
-    error: state.error,
-    refresh: state.refresh,
+    loading,
+    error,
+    refresh,
     register,
     enable,
     remove,
-    mutating: mutation.mutating,
-    mutationError: mutation.mutationError,
-    clearMutationError: mutation.clearMutationError,
+    mutating,
+    mutationError,
+    clearMutationError,
   };
 }

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

@@ -85,7 +85,9 @@ function defaultWebSocketFactory(url: string): DesktopWebSocketLike {
  * decoded at a time; a frame arriving mid-decode replaces the pending one
  * (latest-wins), so a slow decode can never build an unbounded queue.
  */
-export function useRelayFrameStream(options: UseRelayFrameStreamOptions): UseRelayFrameStreamResult {
+export function useRelayFrameStream(
+  options: UseRelayFrameStreamOptions,
+): UseRelayFrameStreamResult {
   const { capability, containerRef, webSocketFactory } = options;
   const [state, setState] = useState<DesktopConnectionState>("idle");
   const [error, setError] = useState<Error | null>(null);
@@ -183,7 +185,8 @@ export function useRelayFrameStream(options: UseRelayFrameStreamOptions): UseRel
       if (decoding) return;
       decoding = true;
       try {
-        while (!disposed && pending) {
+        while (pending) {
+          if (disposed) break;
           const data = pending;
           pending = null;
           let bmp: ImageBitmap;

package/src/hooks/use-rigs.ts

@@ -0,0 +1,335 @@
+import type {
+  CreateRigRequest,
+  ProposeRigChangeRequest,
+  Rig,
+  RigChange,
+  RigVersion,
+  UpdateRigRequest,
+} from "@opengeni/sdk";
+import { useCallback } from "react";
+import { useOpenGeni, type ClientOverride } from "../provider";
+import { useMutationRunner, usePolledValue } from "./internal";
+
+export type UseRigsOptions = ClientOverride & {
+  pollIntervalMs?: number | undefined;
+  enabled?: boolean | undefined;
+};
+
+export type UseRigsResult = {
+  rigs: Rig[];
+  loading: boolean;
+  error: Error | null;
+  refresh: () => Promise<void>;
+  create: (request: CreateRigRequest) => Promise<Rig | null>;
+  update: (rigId: string, request: UpdateRigRequest) => Promise<Rig | null>;
+  remove: (rigId: string) => Promise<boolean>;
+  listVersions: (rigId: string) => Promise<RigVersion[] | null>;
+  activateVersion: (rigId: string, versionId: string) => Promise<RigVersion | null>;
+  listChanges: (rigId: string) => Promise<RigChange[] | null>;
+  proposeChange: (rigId: string, request: ProposeRigChangeRequest) => Promise<RigChange | null>;
+  mutating: boolean;
+  mutationError: Error | null;
+  clearMutationError: () => void;
+};
+
+/**
+ * Rigs (workspace-scoped, versioned sandbox machine definitions). The list
+ * polls; version/change reads are on-demand (they are per-rig detail, not part
+ * of the list surface).
+ */
+export function useRigs(options: UseRigsOptions = {}): UseRigsResult {
+  const { client, workspaceId } = useOpenGeni(options);
+  const load = useCallback(async () => await client.listRigs(workspaceId), [client, workspaceId]);
+  const { data, loading, error, refresh } = usePolledValue(load, {
+    pollIntervalMs: options.pollIntervalMs,
+    enabled: options.enabled,
+  });
+  const { run, mutating, mutationError, clearMutationError } = useMutationRunner();
+
+  const create = useCallback(
+    async (request: CreateRigRequest): Promise<Rig | null> => {
+      const result = await run(() => client.createRig(workspaceId, request));
+      if (result) {
+        await refresh();
+      }
+      return result;
+    },
+    [client, workspaceId, run, refresh],
+  );
+
+  const update = useCallback(
+    async (rigId: string, request: UpdateRigRequest): Promise<Rig | null> => {
+      const result = await run(() => client.updateRig(workspaceId, rigId, request));
+      if (result) {
+        await refresh();
+      }
+      return result;
+    },
+    [client, workspaceId, run, refresh],
+  );
+
+  const remove = useCallback(
+    async (rigId: string): Promise<boolean> => {
+      const result = await run(async () => {
+        await client.deleteRig(workspaceId, rigId);
+        return true;
+      });
+      if (result) {
+        await refresh();
+      }
+      return result === true;
+    },
+    [client, workspaceId, run, refresh],
+  );
+
+  const listVersions = useCallback(
+    async (rigId: string): Promise<RigVersion[] | null> => {
+      return await run(() => client.listRigVersions(workspaceId, rigId));
+    },
+    [client, workspaceId, run],
+  );
+
+  const activateVersion = useCallback(
+    async (rigId: string, versionId: string): Promise<RigVersion | null> => {
+      const result = await run(() => client.activateRigVersion(workspaceId, rigId, versionId));
+      if (result) {
+        await refresh();
+      }
+      return result;
+    },
+    [client, workspaceId, run, refresh],
+  );
+
+  const listChanges = useCallback(
+    async (rigId: string): Promise<RigChange[] | null> => {
+      return await run(() => client.listRigChanges(workspaceId, rigId));
+    },
+    [client, workspaceId, run],
+  );
+
+  const proposeChange = useCallback(
+    async (rigId: string, request: ProposeRigChangeRequest): Promise<RigChange | null> => {
+      const result = await run(() => client.proposeRigChange(workspaceId, rigId, request));
+      if (result) {
+        await refresh();
+      }
+      return result;
+    },
+    [client, workspaceId, run, refresh],
+  );
+
+  return {
+    rigs: data ?? [],
+    loading,
+    error,
+    refresh,
+    create,
+    update,
+    remove,
+    listVersions,
+    activateVersion,
+    listChanges,
+    proposeChange,
+    mutating,
+    mutationError,
+    clearMutationError,
+  };
+}
+
+export type UseRigOptions = ClientOverride & {
+  pollIntervalMs?: number | undefined;
+  enabled?: boolean | undefined;
+};
+
+export type UseRigResult = {
+  rig: Rig | null;
+  loading: boolean;
+  error: Error | null;
+  refresh: () => Promise<void>;
+  update: (request: UpdateRigRequest) => Promise<Rig | null>;
+  remove: () => Promise<boolean>;
+  activateVersion: (versionId: string) => Promise<RigVersion | null>;
+  proposeChange: (request: ProposeRigChangeRequest) => Promise<RigChange | null>;
+  /** Re-run verification for a change (asynchronous — poll for the outcome). */
+  verifyChange: (changeId: string) => Promise<RigChange | null>;
+  /** Promote a verified definition_edit into a new active version (rigs:manage). */
+  promoteChange: (changeId: string) => Promise<RigVersion | null>;
+  /** Re-verify the active version's checks in a clean throwaway sandbox. */
+  verify: () => Promise<{ ok: boolean; versionId: string } | null>;
+  mutating: boolean;
+  mutationError: Error | null;
+  clearMutationError: () => void;
+};
+
+/**
+ * A single rig (its active version + counts), polled so verification and
+ * promotion state stay live. Owns the rig's write actions; the versions and
+ * changes lists are separate polled reads (`useRigVersions`/`useRigChanges`).
+ */
+export function useRig(rigId: string, options: UseRigOptions = {}): UseRigResult {
+  const { client, workspaceId } = useOpenGeni(options);
+  const load = useCallback(
+    async () => await client.getRig(workspaceId, rigId),
+    [client, workspaceId, rigId],
+  );
+  const { data, loading, error, refresh } = usePolledValue(load, {
+    pollIntervalMs: options.pollIntervalMs,
+    enabled: options.enabled,
+  });
+  const { run, mutating, mutationError, clearMutationError } = useMutationRunner();
+
+  const update = useCallback(
+    async (request: UpdateRigRequest): Promise<Rig | null> => {
+      const result = await run(() => client.updateRig(workspaceId, rigId, request));
+      if (result) {
+        await refresh();
+      }
+      return result;
+    },
+    [client, workspaceId, rigId, run, refresh],
+  );
+
+  const remove = useCallback(async (): Promise<boolean> => {
+    const result = await run(async () => {
+      await client.deleteRig(workspaceId, rigId);
+      return true;
+    });
+    return result === true;
+  }, [client, workspaceId, rigId, run]);
+
+  const activateVersion = useCallback(
+    async (versionId: string): Promise<RigVersion | null> => {
+      const result = await run(() => client.activateRigVersion(workspaceId, rigId, versionId));
+      if (result) {
+        await refresh();
+      }
+      return result;
+    },
+    [client, workspaceId, rigId, run, refresh],
+  );
+
+  const proposeChange = useCallback(
+    async (request: ProposeRigChangeRequest): Promise<RigChange | null> => {
+      const result = await run(() => client.proposeRigChange(workspaceId, rigId, request));
+      if (result) {
+        await refresh();
+      }
+      return result;
+    },
+    [client, workspaceId, rigId, run, refresh],
+  );
+
+  const verifyChange = useCallback(
+    async (changeId: string): Promise<RigChange | null> => {
+      const result = await run(() => client.verifyRigChange(workspaceId, rigId, changeId));
+      if (result) {
+        await refresh();
+      }
+      return result;
+    },
+    [client, workspaceId, rigId, run, refresh],
+  );
+
+  const promoteChange = useCallback(
+    async (changeId: string): Promise<RigVersion | null> => {
+      const result = await run(() => client.promoteRigChange(workspaceId, rigId, changeId));
+      if (result) {
+        await refresh();
+      }
+      return result;
+    },
+    [client, workspaceId, rigId, run, refresh],
+  );
+
+  const verify = useCallback(async (): Promise<{ ok: boolean; versionId: string } | null> => {
+    return await run(() => client.verifyRig(workspaceId, rigId));
+  }, [client, workspaceId, rigId, run]);
+
+  return {
+    rig: data,
+    loading,
+    error,
+    refresh,
+    update,
+    remove,
+    activateVersion,
+    proposeChange,
+    verifyChange,
+    promoteChange,
+    verify,
+    mutating,
+    mutationError,
+    clearMutationError,
+  };
+}
+
+export type UseRigVersionsOptions = ClientOverride & {
+  pollIntervalMs?: number | undefined;
+  enabled?: boolean | undefined;
+};
+
+export type UseRigVersionsResult = {
+  versions: RigVersion[];
+  loading: boolean;
+  error: Error | null;
+  refresh: () => Promise<void>;
+};
+
+/** A rig's append-only version history, newest-first (polled). */
+export function useRigVersions(
+  rigId: string,
+  options: UseRigVersionsOptions = {},
+): UseRigVersionsResult {
+  const { client, workspaceId } = useOpenGeni(options);
+  const load = useCallback(
+    async () => await client.listRigVersions(workspaceId, rigId),
+    [client, workspaceId, rigId],
+  );
+  const state = usePolledValue(load, {
+    pollIntervalMs: options.pollIntervalMs,
+    enabled: options.enabled,
+  });
+  return {
+    versions: state.data ?? [],
+    loading: state.loading,
+    error: state.error,
+    refresh: state.refresh,
+  };
+}
+
+export type UseRigChangesOptions = ClientOverride & {
+  pollIntervalMs?: number | undefined;
+  enabled?: boolean | undefined;
+};
+
+export type UseRigChangesResult = {
+  changes: RigChange[];
+  loading: boolean;
+  error: Error | null;
+  refresh: () => Promise<void>;
+};
+
+/**
+ * A rig's change queue (polled). The default poll cadence lets a change move
+ * through verifying → merged/rejected without a manual refresh.
+ */
+export function useRigChanges(
+  rigId: string,
+  options: UseRigChangesOptions = {},
+): UseRigChangesResult {
+  const { client, workspaceId } = useOpenGeni(options);
+  const load = useCallback(
+    async () => await client.listRigChanges(workspaceId, rigId),
+    [client, workspaceId, rigId],
+  );
+  const state = usePolledValue(load, {
+    pollIntervalMs: options.pollIntervalMs,
+    enabled: options.enabled,
+  });
+  return {
+    changes: state.data ?? [],
+    loading: state.loading,
+    error: state.error,
+    refresh: state.refresh,
+  };
+}