@opengeni/react 6.5.2-canary.41607687019001 → 6.7.0

package/dist/chunk-2KALVELR.js

@@ -0,0 +1,126 @@
+"use client";
+import {
+  Label
+} from "./chunk-YFHRNLOT.js";
+import {
+  SegmentedControl
+} from "./chunk-RGBI63KJ.js";
+import {
+  Input
+} from "./chunk-VPM3TXFC.js";
+import {
+  Dialog,
+  DialogContent,
+  DialogDescription,
+  DialogFooter,
+  DialogHeader,
+  DialogTitle
+} from "./chunk-ZQCND77P.js";
+import {
+  Field
+} from "./chunk-MVW6HNPI.js";
+import {
+  Button
+} from "./chunk-7QQN3KNP.js";
+
+// src/app/components/rail/channel-create-dialog.tsx
+import { Loader2Icon } from "lucide-react";
+import { jsx, jsxs } from "react/jsx-runtime";
+var CHANNEL_NAME_MAX_LENGTH = 80;
+var AUDIENCE_OPTIONS = [
+  { value: "workspace", label: "Workspace" },
+  { value: "private", label: "Only me" }
+];
+function ChannelCreateDialog(props) {
+  const audience = props.audience;
+  return /* @__PURE__ */ jsx(
+    Dialog,
+    {
+      open: props.open,
+      onOpenChange: (open) => {
+        if (!props.busy) props.onOpenChange(open);
+      },
+      children: /* @__PURE__ */ jsx(DialogContent, { className: "sm:max-w-sm", children: /* @__PURE__ */ jsxs(
+        "form",
+        {
+          autoComplete: "off",
+          onSubmit: (event) => {
+            event.preventDefault();
+            if (!props.busy && props.name.trim()) props.onSubmit();
+          },
+          children: [
+            /* @__PURE__ */ jsxs(DialogHeader, { children: [
+              /* @__PURE__ */ jsx(DialogTitle, { children: "New project" }),
+              /* @__PURE__ */ jsx(DialogDescription, { children: audience ? "Projects keep related sessions together." : "Projects keep related sessions together for everyone in this workspace." })
+            ] }),
+            /* @__PURE__ */ jsxs("div", { className: "grid gap-4 py-4", children: [
+              /* @__PURE__ */ jsxs("div", { className: "grid gap-2", children: [
+                /* @__PURE__ */ jsx(Label, { htmlFor: "channel-name", children: "Name" }),
+                /* @__PURE__ */ jsx(
+                  Input,
+                  {
+                    id: "channel-name",
+                    name: "project-name",
+                    type: "text",
+                    autoFocus: true,
+                    autoComplete: "off",
+                    autoCorrect: "off",
+                    spellCheck: false,
+                    "data-1p-ignore": true,
+                    "data-lpignore": "true",
+                    "data-protonpass-ignore": "true",
+                    value: props.name,
+                    disabled: props.busy,
+                    maxLength: CHANNEL_NAME_MAX_LENGTH,
+                    placeholder: "security",
+                    onChange: (event) => props.onNameChange(event.target.value)
+                  }
+                )
+              ] }),
+              audience ? /* @__PURE__ */ jsx(
+                Field,
+                {
+                  label: "Who can see it",
+                  hint: audience.value === "private" ? "Only you see it. It holds your Only me chats and Sites." : "Everyone in this workspace sees it.",
+                  children: /* @__PURE__ */ jsx(
+                    SegmentedControl,
+                    {
+                      size: "sm",
+                      "aria-label": "Who can see it",
+                      options: AUDIENCE_OPTIONS,
+                      value: audience.value,
+                      disabled: props.busy,
+                      onValueChange: audience.onChange
+                    }
+                  )
+                }
+              ) : null
+            ] }),
+            /* @__PURE__ */ jsxs(DialogFooter, { children: [
+              /* @__PURE__ */ jsx(
+                Button,
+                {
+                  type: "button",
+                  variant: "ghost",
+                  disabled: props.busy,
+                  onClick: () => props.onOpenChange(false),
+                  children: "Cancel"
+                }
+              ),
+              /* @__PURE__ */ jsxs(Button, { type: "submit", disabled: props.busy || !props.name.trim(), children: [
+                props.busy ? /* @__PURE__ */ jsx(Loader2Icon, { className: "size-4 animate-spin" }) : null,
+                "Create project"
+              ] })
+            ] })
+          ]
+        }
+      ) })
+    }
+  );
+}
+
+export {
+  CHANNEL_NAME_MAX_LENGTH,
+  ChannelCreateDialog
+};
+//# sourceMappingURL=chunk-2KALVELR.js.map

package/dist/chunk-2M3J7ZWQ.js

@@ -0,0 +1,418 @@
+"use client";
+import {
+  useMutationRunner,
+  usePageLiveActivity
+} from "./chunk-RV3O5OCQ.js";
+import {
+  useOpenGeni
+} from "./chunk-TVQCDDSZ.js";
+import {
+  useOpenGeniText
+} from "./chunk-7T2ZE3VT.js";
+
+// src/hooks/use-machines.ts
+import { useCallback as useCallback2, useRef, useState as useState2 } from "react";
+
+// src/hooks/shared-machines-list.ts
+import { useCallback, useEffect, useState } from "react";
+var EMPTY_MACHINES = {
+  activeSandboxId: null,
+  activeEpoch: 0,
+  machines: []
+};
+var shares = /* @__PURE__ */ new Map();
+function isMachinesAccessRefusal(cause) {
+  if (!cause || typeof cause !== "object" || !("status" in cause)) return false;
+  const status = cause.status;
+  return status === 401 || status === 403 || status === 404;
+}
+function emit(share) {
+  for (const subscriber of share.subscribers) {
+    subscriber.onChange();
+  }
+}
+function effective(share) {
+  let enabled = false;
+  let pollIntervalMs;
+  for (const subscriber of share.subscribers) {
+    if (!subscriber.enabled || !subscriber.pageLive) continue;
+    enabled = true;
+    if (subscriber.pollIntervalMs !== void 0 && subscriber.pollIntervalMs > 0) {
+      pollIntervalMs = pollIntervalMs === void 0 ? subscriber.pollIntervalMs : Math.min(pollIntervalMs, subscriber.pollIntervalMs);
+    }
+  }
+  return { enabled, pollIntervalMs };
+}
+function latestLoad(share) {
+  let load = null;
+  for (const subscriber of share.subscribers) {
+    if (subscriber.enabled && subscriber.pageLive) load = subscriber.load;
+  }
+  return load;
+}
+function stopTimer(share) {
+  if (share.timer !== null) {
+    clearTimeout(share.timer);
+    share.timer = null;
+  }
+}
+function cancelDispose(share) {
+  if (share.disposeTimer !== null) {
+    clearTimeout(share.disposeTimer);
+    share.disposeTimer = null;
+  }
+}
+function arm(share) {
+  stopTimer(share);
+  if (share.halted) return;
+  const { enabled, pollIntervalMs } = effective(share);
+  if (!enabled || pollIntervalMs === void 0) return;
+  share.timer = setTimeout(() => {
+    share.timer = null;
+    void run(share).finally(() => arm(share));
+  }, pollIntervalMs);
+}
+async function runFresh(share) {
+  const load = latestLoad(share);
+  if (!load) return;
+  const ticket = ++share.generation;
+  const abort = new AbortController();
+  share.abort = abort;
+  try {
+    const data = await load(abort.signal);
+    if (ticket !== share.generation || abort.signal.aborted) return;
+    share.halted = false;
+    share.snapshot = { data, loading: false, error: null };
+    emit(share);
+  } catch (cause) {
+    if (ticket !== share.generation || abort.signal.aborted) return;
+    if (isMachinesAccessRefusal(cause)) {
+      share.halted = true;
+      stopTimer(share);
+    }
+    share.snapshot = {
+      data: share.snapshot.data,
+      loading: false,
+      error: cause instanceof Error ? cause : new Error(String(cause))
+    };
+    emit(share);
+  } finally {
+    if (share.abort === abort) share.abort = null;
+  }
+}
+function run(share, force = false) {
+  if (!force && share.inFlight) return share.inFlight;
+  if (force && share.inFlight) {
+    if (share.trailing) return share.trailing;
+    let trailing;
+    trailing = share.inFlight.then(async () => {
+      if (!effective(share).enabled || share.halted) return;
+      await run(share);
+    }).finally(() => {
+      if (share.trailing === trailing) share.trailing = null;
+    });
+    share.trailing = trailing;
+    return trailing;
+  }
+  let promise;
+  promise = runFresh(share).finally(() => {
+    if (share.inFlight === promise) share.inFlight = null;
+  });
+  share.inFlight = promise;
+  return promise;
+}
+function reconcile(share) {
+  const { enabled } = effective(share);
+  if (!enabled) {
+    share.generation += 1;
+    share.abort?.abort();
+    share.abort = null;
+    share.inFlight = null;
+    stopTimer(share);
+    if (share.halted) {
+      share.halted = false;
+      share.snapshot = { data: share.snapshot.data, loading: false, error: null };
+      emit(share);
+      return;
+    }
+    if (share.snapshot.loading) {
+      share.snapshot = { ...share.snapshot, loading: false };
+      emit(share);
+    }
+    return;
+  }
+  if (share.halted) return;
+  if (share.snapshot.data !== null || share.snapshot.error) {
+    arm(share);
+    return;
+  }
+  share.snapshot = { ...share.snapshot, loading: true };
+  emit(share);
+  void run(share).finally(() => arm(share));
+}
+function getOrCreate(shareKey) {
+  const existing = shares.get(shareKey);
+  if (existing) {
+    cancelDispose(existing);
+    return existing;
+  }
+  const created = {
+    snapshot: { data: null, loading: true, error: null },
+    subscribers: /* @__PURE__ */ new Set(),
+    timer: null,
+    disposeTimer: null,
+    abort: null,
+    inFlight: null,
+    trailing: null,
+    generation: 0,
+    halted: false
+  };
+  shares.set(shareKey, created);
+  return created;
+}
+async function refreshSharedMachinesList(shareKey) {
+  const share = shares.get(shareKey);
+  if (!share) return;
+  const wasHalted = share.halted;
+  share.halted = false;
+  await run(share, true);
+  if (wasHalted) arm(share);
+}
+function useSharedMachinesList(shareKey, load, options = {}) {
+  const enabled = options.enabled ?? true;
+  const pageLive = usePageLiveActivity();
+  const [, setRevision] = useState(0);
+  const live = shares.get(shareKey)?.snapshot;
+  const view = live ?? { data: null, loading: enabled && pageLive, error: null };
+  useEffect(() => {
+    const share = getOrCreate(shareKey);
+    const subscriber = {
+      load,
+      pollIntervalMs: options.pollIntervalMs,
+      enabled,
+      pageLive,
+      onChange: () => setRevision((revision) => revision + 1)
+    };
+    share.subscribers.add(subscriber);
+    setRevision((revision) => revision + 1);
+    reconcile(share);
+    return () => {
+      share.subscribers.delete(subscriber);
+      if (share.subscribers.size > 0) {
+        reconcile(share);
+        return;
+      }
+      share.generation += 1;
+      share.abort?.abort();
+      share.abort = null;
+      share.inFlight = null;
+      share.trailing = null;
+      stopTimer(share);
+      cancelDispose(share);
+      share.disposeTimer = setTimeout(() => {
+        share.disposeTimer = null;
+        if (share.subscribers.size === 0 && shares.get(shareKey) === share) {
+          shares.delete(shareKey);
+        }
+      }, 0);
+    };
+  }, [shareKey, load, options.pollIntervalMs, enabled, pageLive]);
+  const refresh = useCallback(() => refreshSharedMachinesList(shareKey), [shareKey]);
+  return { ...view, refresh };
+}
+
+// src/hooks/use-machines.ts
+var MACHINES_DASHBOARD_POLL_MS = 1e4;
+var MACHINES_SESSION_POLL_MS = 15e3;
+var MACHINES_COMPOSER_POLL_MS = 3e4;
+var machinesClientIds = /* @__PURE__ */ new WeakMap();
+var nextMachinesClientId = 1;
+function machinesClientId(client) {
+  const existing = machinesClientIds.get(client);
+  if (existing !== void 0) return existing;
+  const id = nextMachinesClientId++;
+  machinesClientIds.set(client, id);
+  return id;
+}
+function swapFailureMessage(t, result) {
+  switch (result.code) {
+    case "recovery_in_progress":
+      return t("hooks.useMachines.itsComputerIsStillStarting");
+    case "recovery_degraded":
+      return t("hooks.useMachines.itsComputerIsntWorking");
+    case "recovery_unrecoverable":
+      return t("hooks.useMachines.itsComputerCouldntBeRestored");
+    case "offline_enrollment":
+      return t("hooks.useMachines.thatMachineIsOffline");
+    case "stale_pointer":
+      return t("hooks.useMachines.thatMachineIsNoLonger");
+    case "unsupported_backend_context":
+    case "transient_establishment":
+      return t("hooks.useMachines.thatMachineCouldntBeReached");
+    case "concurrent_swap":
+      return t("hooks.useMachines.itWasMovedSomewhere");
+    case "personal_machine_permission_required":
+      return t("hooks.useMachines.theMachineSOwnerHas");
+    case "personal_machine_not_permitted":
+      return t("hooks.useMachines.onlyTheMachineSOwner");
+    // Neither is fixed by trying again: say what to do instead.
+    case "workspace_root_unavailable":
+      return t("hooks.useMachines.thatMachineHasntReported");
+    case "invalid_working_directory":
+      return t("hooks.useMachines.thisChatSWorkingFolder");
+    default:
+      return t("hooks.useMachines.tryAgain");
+  }
+}
+function useMachines(options = {}) {
+  const t = useOpenGeniText();
+  const { client, workspaceId } = useOpenGeni(options);
+  const machinesClient = options.machinesClient ?? client;
+  const sessionId = options.sessionId;
+  const identityKey = `${workspaceId}\0${sessionId ?? ""}\0${machinesClientId(machinesClient)}`;
+  const identityRef = useRef(identityKey);
+  identityRef.current = identityKey;
+  const load = useCallback2(
+    async (signal) => {
+      return await machinesClient.listMachines(workspaceId, {
+        ...sessionId ? { sessionId } : {},
+        ...signal ? { signal } : {}
+      });
+    },
+    [machinesClient, workspaceId, sessionId]
+  );
+  const {
+    data: loadedData,
+    loading,
+    error,
+    refresh
+  } = useSharedMachinesList(identityKey, load, {
+    pollIntervalMs: options.pollIntervalMs,
+    enabled: options.enabled
+  });
+  const { run: run2, mutating, mutationError, clearMutationError } = useMutationRunner(identityKey);
+  const [attachState, setAttachState] = useState2(() => ({ identity: identityKey, sandboxId: null }));
+  const attachingSandboxId = attachState.identity === identityKey ? attachState.sandboxId : null;
+  const [removeState, setRemoveState] = useState2(() => ({ identity: identityKey, enrollmentId: null }));
+  const removingEnrollmentId = removeState.identity === identityKey ? removeState.enrollmentId : null;
+  const [updateState, setUpdateState] = useState2(() => ({ identity: identityKey, enrollmentId: null }));
+  const updatingEnrollmentId = updateState.identity === identityKey ? updateState.enrollmentId : null;
+  const [operationPolicyState, setOperationPolicyState] = useState2(() => ({ identity: identityKey, enrollmentId: null }));
+  const updatingOperationPolicyEnrollmentId = operationPolicyState.identity === identityKey ? operationPolicyState.enrollmentId : null;
+  const data = loadedData ?? EMPTY_MACHINES;
+  const canAttach = sessionId !== void 0 && (typeof machinesClient.attachMachine === "function" || typeof machinesClient.swapActiveSandbox === "function");
+  const canRemove = typeof machinesClient.removeEnrollment === "function";
+  const canUpdateAgent = typeof machinesClient.updateMachineAgent === "function";
+  const canUpdateOperationPolicy = typeof machinesClient.updateMachineOperationPolicy === "function";
+  const attach = useCallback2(
+    async (sandboxId) => {
+      if (sessionId === void 0) return false;
+      const runSwap = machinesClient.attachMachine ? () => machinesClient.attachMachine(workspaceId, sessionId, sandboxId) : machinesClient.swapActiveSandbox ? () => machinesClient.swapActiveSandbox(workspaceId, sessionId, { target: sandboxId }) : null;
+      if (!runSwap) return false;
+      const ownedIdentity = identityKey;
+      setAttachState({ identity: ownedIdentity, sandboxId });
+      const result = await run2(async () => {
+        const response = await runSwap();
+        if (response && typeof response === "object" && "swapped" in response && response.swapped === false) {
+          throw new Error(swapFailureMessage(t, response));
+        }
+        return true;
+      });
+      if (identityRef.current === ownedIdentity) {
+        setAttachState({ identity: ownedIdentity, sandboxId: null });
+        if (result) await refresh();
+      }
+      return result === true;
+    },
+    [machinesClient, workspaceId, sessionId, identityKey, run2, refresh, t]
+  );
+  const fetchSeries = useCallback2(
+    async (enrollmentId, window = "1h") => {
+      if (!machinesClient.machineMetricsSeries) return [];
+      return await machinesClient.machineMetricsSeries(workspaceId, enrollmentId, { window });
+    },
+    [machinesClient, workspaceId]
+  );
+  const remove = useCallback2(
+    async (enrollmentId, request = {}) => {
+      if (!machinesClient.removeEnrollment) return null;
+      const ownedIdentity = identityKey;
+      setRemoveState({ identity: ownedIdentity, enrollmentId });
+      const result = await run2(
+        () => machinesClient.removeEnrollment(workspaceId, enrollmentId, request)
+      );
+      if (identityRef.current === ownedIdentity) {
+        setRemoveState({ identity: ownedIdentity, enrollmentId: null });
+        if (result?.outcome === "removed" || result?.outcome === "already_removed") {
+          await refresh();
+        }
+      }
+      return result;
+    },
+    [machinesClient, workspaceId, identityKey, run2, refresh]
+  );
+  const updateAgent = useCallback2(
+    async (enrollmentId) => {
+      if (!machinesClient.updateMachineAgent) return null;
+      const ownedIdentity = identityKey;
+      setUpdateState({ identity: ownedIdentity, enrollmentId });
+      const result = await run2(() => machinesClient.updateMachineAgent(workspaceId, enrollmentId));
+      if (identityRef.current === ownedIdentity) {
+        setUpdateState({ identity: ownedIdentity, enrollmentId: null });
+        await refresh();
+      }
+      return result;
+    },
+    [machinesClient, workspaceId, identityKey, run2, refresh]
+  );
+  const updateOperationPolicy = useCallback2(
+    async (enrollmentId, request) => {
+      if (!machinesClient.updateMachineOperationPolicy) return null;
+      const ownedIdentity = identityKey;
+      setOperationPolicyState({ identity: ownedIdentity, enrollmentId });
+      const result = await run2(
+        () => machinesClient.updateMachineOperationPolicy(workspaceId, enrollmentId, request)
+      );
+      if (identityRef.current === ownedIdentity) {
+        setOperationPolicyState({ identity: ownedIdentity, enrollmentId: null });
+        if (result) await refresh();
+      }
+      return result;
+    },
+    [machinesClient, workspaceId, identityKey, run2, refresh]
+  );
+  return {
+    machines: data.machines,
+    activeSandboxId: data.activeSandboxId,
+    sessionMachineAccess: data.sessionMachineAccess ?? null,
+    canConnectOwnMachine: data.canConnectOwnMachine !== false,
+    activeEpoch: data.activeEpoch,
+    loading,
+    error,
+    refresh,
+    attach,
+    canAttach,
+    fetchSeries,
+    attaching: mutating && attachingSandboxId !== null,
+    attachingSandboxId,
+    remove,
+    canRemove,
+    removingEnrollmentId,
+    updateAgent,
+    canUpdateAgent,
+    updatingEnrollmentId,
+    updateOperationPolicy,
+    canUpdateOperationPolicy,
+    updatingOperationPolicyEnrollmentId,
+    mutationError,
+    clearMutationError
+  };
+}
+
+export {
+  MACHINES_DASHBOARD_POLL_MS,
+  MACHINES_SESSION_POLL_MS,
+  MACHINES_COMPOSER_POLL_MS,
+  useMachines
+};
+//# sourceMappingURL=chunk-2M3J7ZWQ.js.map