@opengeni/react 6.5.2-canary.41607687019001 → 6.7.0

package/dist/chunk-NC55IFN3.js

@@ -0,0 +1,781 @@
+"use client";
+import {
+  ConnectMachineDialog,
+  connectScopeFor
+} from "./chunk-JQL7ZH6C.js";
+import {
+  isPersonalMachine,
+  moveChatToMachine
+} from "./chunk-NCYMNCJO.js";
+import {
+  useWorkspaceMachines
+} from "./chunk-KRDR5RJD.js";
+import {
+  useDesktopThisComputer
+} from "./chunk-T2QX3FDP.js";
+import {
+  useAppApi
+} from "./chunk-XIQPI2NM.js";
+import {
+  t
+} from "./chunk-HSOXMJOT.js";
+import {
+  hasWorkspacePermission
+} from "./chunk-H2ALCTWC.js";
+import {
+  useAppContext
+} from "./chunk-JDFDPMKX.js";
+import {
+  thisComputerNeedsPermissions,
+  thisComputerReady
+} from "./chunk-3IK6UYO6.js";
+import {
+  RowButton
+} from "./chunk-JGQRVEOL.js";
+import {
+  ListRow,
+  RowList
+} from "./chunk-54YW6SZZ.js";
+import {
+  userErrorText
+} from "./chunk-O4OOG3D6.js";
+import {
+  LogoTile
+} from "./chunk-K4DHWGCT.js";
+import {
+  Notice
+} from "./chunk-FSOQDUCG.js";
+import {
+  SessionCapabilityFrame
+} from "./chunk-FO4LYKJL.js";
+import {
+  isMachineComputeSelectable
+} from "./chunk-JWKGPA6Q.js";
+import {
+  useClientConfigFlags
+} from "./chunk-XESA3B7W.js";
+import {
+  machineDisplayName,
+  machineScopeLabel
+} from "./chunk-ZY2Z2IU3.js";
+import {
+  MACHINES_SESSION_POLL_MS
+} from "./chunk-2M3J7ZWQ.js";
+import {
+  Button
+} from "./chunk-7QQN3KNP.js";
+
+// src/app/components/capabilities/session-machine-card.tsx
+import { OPENGENI_BROWSER_EXTENSION_URL } from "@opengeni/contracts";
+import { OpenGeniApiError } from "@opengeni/sdk";
+import {
+  ArrowUpRightIcon,
+  CheckIcon,
+  ChevronRightIcon,
+  LaptopIcon,
+  Loader2Icon,
+  MonitorIcon,
+  PlusIcon,
+  PuzzleIcon,
+  ServerIcon
+} from "lucide-react";
+import { useCallback, useEffect, useMemo, useRef, useState } from "react";
+import { Fragment, jsx, jsxs } from "react/jsx-runtime";
+var WATCH_POLL_MS = 3e3;
+var CHROME_POLL_MS = 5e3;
+var CHROME_POLL_LIMIT_MS = 10 * 6e4;
+var CHROME_REFRESH_POLL_LIMIT_MS = 6e4;
+var CONNECTED_MACHINE_LOGO = "data:image/svg+xml;utf8," + encodeURIComponent(
+  '<svg xmlns="http://www.w3.org/2000/svg" viewBox="-2 -2 28 28" fill="none" stroke="#71717a" stroke-width="1.75" stroke-linecap="round" stroke-linejoin="round"><path d="M18 5a2 2 0 0 1 2 2v8.526a2 2 0 0 0 .212.897l1.068 2.127a1 1 0 0 1-.9 1.45H3.62a1 1 0 0 1-.9-1.45l1.068-2.127A2 2 0 0 0 4 15.526V7a2 2 0 0 1 2-2z"/><path d="M20.054 15.987H3.946"/></svg>'
+);
+function stateLabel(machine) {
+  switch (machine.state) {
+    case "online":
+    case "consent_required":
+      return "Online";
+    case "display_unavailable":
+      return "Online \xB7 no display";
+    case "reconnecting":
+      return "Reconnecting";
+    case "enrolling":
+      return "Connecting";
+    default:
+      return "Offline";
+  }
+}
+function focusIfIdle(card, target = card) {
+  requestAnimationFrame(() => {
+    const active = document.activeElement;
+    const idle = !active || active === document.body || (card?.contains(active) ?? false);
+    if (idle && target?.isConnected) target.focus();
+    else if (idle && card?.isConnected) card.focus();
+  });
+}
+function SessionMachineCapabilityCard({
+  item,
+  workspaceId,
+  sessionId,
+  sendContext,
+  onConfigured
+}) {
+  const context = useAppContext();
+  const { apiBaseUrl } = useAppApi();
+  const recommendation = item.capability;
+  const accessKnown = context.accessContext !== null && context.accessContext !== void 0;
+  const canMessage = !accessKnown || hasWorkspacePermission(context.accessContext, workspaceId, "sessions:control");
+  const [setupOpen, setSetupOpen] = useState(false);
+  const [setupScreenControl, setSetupScreenControl] = useState(false);
+  const [setupScope, setSetupScope] = useState("user");
+  const [justConnected, setJustConnected] = useState(null);
+  const [using, setUsing] = useState(null);
+  const [useError, setUseError] = useState(null);
+  const [outcome, setOutcome] = useState(null);
+  const [announcement, setAnnouncement] = useState("");
+  const [othersOpen, setOthersOpen] = useState(false);
+  const [settingsOpen, setSettingsOpen] = useState(false);
+  const settingsOpener = useRef(null);
+  const cardRef = useRef(null);
+  const opener = useRef(null);
+  const setupOpener = useRef(null);
+  const alive = useRef(true);
+  useEffect(() => {
+    alive.current = true;
+    return () => {
+      alive.current = false;
+    };
+  }, []);
+  const fleet = useWorkspaceMachines({
+    workspaceId,
+    sessionId,
+    pollIntervalMs: setupOpen ? WATCH_POLL_MS : MACHINES_SESSION_POLL_MS
+  });
+  const unavailableOnDeployment = fleet.error instanceof OpenGeniApiError && fleet.error.status === 404;
+  const machines = useMemo(
+    () => fleet.machines.filter((machine) => !machine.isSessionGroup && machine.enrollmentId),
+    [fleet.machines]
+  );
+  const activeMachine = machines.find((machine) => machine.active) ?? null;
+  const reachable = machines.filter((machine) => isMachineComputeSelectable(machine.state));
+  const requested = (item.requestedSandboxId ? machines.find((machine) => machine.sandboxId === item.requestedSandboxId) : void 0) ?? null;
+  const asking = requested !== null && !requested.active;
+  const requestedName = requested ? machineDisplayName(t, requested) : "";
+  const allowHere = asking && fleet.canAttach && isMachineComputeSelectable(requested.state) ? requested : null;
+  const allowOwnMachine = allowHere !== null && isPersonalMachine(allowHere);
+  const sharedChat = sendContext?.().personalMachineIntent?.workspaceSharedAcknowledged === true;
+  const personalWorkspace = context.workspaces?.find((workspace) => workspace.id === workspaceId)?.kind === "personal";
+  const openSetup = (reconnect) => {
+    const active = document.activeElement;
+    setupOpener.current = active instanceof HTMLElement ? active : null;
+    setJustConnected(null);
+    setSetupScreenControl(reconnect !== void 0);
+    setSetupScope(reconnect ? connectScopeFor(reconnect) : "user");
+    setSetupOpen(true);
+  };
+  const closeSetup = () => {
+    setSetupOpen(false);
+    const back = setupOpener.current?.isConnected ? setupOpener.current : opener.current;
+    focusIfIdle(cardRef.current, back);
+  };
+  const ordered = useMemo(() => {
+    const rank = (machine) => machine.sandboxId === justConnected ? 0 : machine.active ? 1 : isMachineComputeSelectable(machine.state) ? 2 : 3;
+    return [...machines].filter((machine) => machine.sandboxId !== allowHere?.sandboxId).sort(
+      (left, right) => rank(left) - rank(right) || machineDisplayName(t, left).localeCompare(machineDisplayName(t, right))
+    );
+  }, [allowHere?.sandboxId, justConnected, machines]);
+  const use = useCallback(
+    async (machine) => {
+      if (using !== null) return;
+      const name = machineDisplayName(t, machine);
+      setUseError(null);
+      setOutcome(null);
+      const chat = sendContext?.() ?? { blocked: null, awaitingHuman: false, extras: {} };
+      if (chat.blocked) {
+        setUseError({ name, reason: chat.blocked });
+        return;
+      }
+      setUsing(machine.sandboxId);
+      const result = await moveChatToMachine({
+        machine,
+        chat,
+        canMessage,
+        previousSandboxId: fleet.machines.find((candidate) => candidate.active)?.sandboxId ?? null,
+        attach: fleet.attach,
+        sendMessage: (message) => context.client.sendMessage(workspaceId, sessionId, message)
+      });
+      if (!alive.current) return;
+      if (!result.moved) {
+        setUsing(null);
+        setUseError({ name, reason: result.reason });
+        return;
+      }
+      const text = result.text;
+      setUsing(null);
+      setOutcome({ sandboxId: machine.sandboxId, text });
+      setAnnouncement(text);
+      setSettingsOpen(false);
+      requestAnimationFrame(() => focusIfIdle(cardRef.current, settingsOpener.current));
+      await onConfigured?.().catch(() => {
+      });
+    },
+    [canMessage, context.client, fleet, onConfigured, sendContext, sessionId, using, workspaceId]
+  );
+  const chromeMachine = activeMachine?.hasDisplay && isMachineComputeSelectable(activeMachine.state) ? activeMachine : null;
+  const chrome = useAttachedChrome(
+    workspaceId,
+    fleet.canRead && chromeMachine?.enrollmentId ? { enrollmentId: chromeMachine.enrollmentId } : null
+  );
+  const fresh = justConnected ? machines.find((machine) => machine.sandboxId === justConnected) ?? null : null;
+  const origin = apiBaseUrl || (typeof window !== "undefined" ? window.location.origin : "");
+  const connectAnother = fleet.canConnect && (reachable.length > 0 || activeMachine !== null);
+  const actionUnavailable = unavailableOnDeployment ? "Connected Machines aren't available on this deployment." : asking && !isMachineComputeSelectable(requested.state) ? `Turn on ${requestedName} to allow it here.` : !fleet.canRead ? "You don't have access to this workspace's machines." : fresh && fleet.canAttach && !fresh.active ? `${machineDisplayName(t, fresh)} connected. Choose it below to use it here.` : reachable.length > 0 && fleet.canAttach ? connectAnother ? "Choose where this chat runs, or connect another computer." : "Choose where this chat runs." : reachable.length > 0 ? "You can't change where this chat runs." : fleet.canConnect ? null : machines.length > 0 ? "Turn on one of the machines below to use it here." : "Ask a workspace admin to connect a machine.";
+  const desktop = useDesktopThisComputer();
+  const desktopReady = thisComputerReady(desktop?.computer.status ?? null) && !desktop?.computer.status?.reconnecting;
+  const offerThisComputer = desktop !== null && desktop.computer.status !== null && desktop.computer.status.state !== "unavailable" && !thisComputerReady(desktop.computer.status) && !unavailableOnDeployment && fleet.canRead;
+  const visibleDetails = useError !== null || ordered.length > 0 || chromeMachine !== null || connectAnother;
+  const folded = allowHere !== null && !othersOpen;
+  const foldable = allowHere !== null && (ordered.length > 0 || chromeMachine !== null || connectAnother);
+  const complete = !asking && (activeMachine !== null || desktopReady);
+  const completeLabel = activeMachine ? outcome?.sandboxId === activeMachine.sandboxId ? outcome.text : `This chat runs on ${machineDisplayName(t, activeMachine)}` : desktopReady ? `Your agents can use ${desktop?.computer.status?.machineName || "this computer"}.` : void 0;
+  const compact = complete && !settingsOpen && using === null && useError === null;
+  const confirmationLabel = activeMachine && (outcome?.sandboxId !== activeMachine.sandboxId || outcome.text === `This chat now runs on ${machineDisplayName(t, activeMachine)}.`) ? `Using ${machineDisplayName(t, activeMachine)}` : completeLabel;
+  return /* @__PURE__ */ jsxs(Fragment, { children: [
+    /* @__PURE__ */ jsx("span", { className: "sr-only", role: "status", "aria-live": "polite", children: announcement }),
+    complete ? /* @__PURE__ */ jsxs(
+      "div",
+      {
+        "data-machine-confirmation": "",
+        className: "flex max-w-[540px] items-start gap-2 text-sm text-fg-muted",
+        children: [
+          /* @__PURE__ */ jsx(CheckIcon, { "aria-hidden": true, className: "mt-3.5 size-4 shrink-0" }),
+          /* @__PURE__ */ jsx("p", { className: "min-w-0 flex-1 py-3 [overflow-wrap:anywhere]", children: confirmationLabel }),
+          /* @__PURE__ */ jsxs(
+            Button,
+            {
+              ref: settingsOpener,
+              variant: "ghost",
+              size: "sm",
+              className: "min-h-11 shrink-0",
+              "aria-label": "Machine settings",
+              "aria-expanded": !compact,
+              onClick: () => setSettingsOpen((open) => !open),
+              children: [
+                "Settings",
+                /* @__PURE__ */ jsx(ChevronRightIcon, { "aria-hidden": true, className: compact ? "" : "rotate-90" })
+              ]
+            }
+          )
+        ]
+      }
+    ) : null,
+    /* @__PURE__ */ jsx("div", { hidden: compact, "data-machine-setup": "", children: /* @__PURE__ */ jsx(
+      SessionCapabilityFrame,
+      {
+        name: asking ? requestedName : recommendation.name || "Connected Machine",
+        subtitle: asking ? `${stateLabel(requested)} \xB7 ${machineScopeLabel(t, requested.scope)}` : "Your computer or server",
+        logo: CONNECTED_MACHINE_LOGO,
+        typeLabel: "Machine",
+        description: allowOwnMachine ? "The agent asked to use this machine. Allowing it lets your agents use it in this workspace from now on, and moves this chat here." : allowHere ? "The agent asked to use this machine. Allowing it moves this chat here, and the agent continues on it." : asking ? `The agent asked to use ${requestedName}.` : recommendation.rationale,
+        skill: false,
+        expanded: false,
+        complete,
+        completeLabel,
+        actionLabel: allowHere ? using === allowHere.sandboxId ? "Allowing\u2026" : "Allow" : offerThisComputer ? desktop.computer.acting ? "Turning on\u2026" : "Use this computer" : "Connect a computer",
+        busy: allowHere ? using !== null : offerThisComputer && desktop.computer.acting,
+        actionUnavailable: allowHere || offerThisComputer ? null : actionUnavailable,
+        opensDialog: false,
+        note: allowHere ? allowOwnMachine && sharedChat ? "Only your own messages run on it. This chat is shared, so people in this workspace see what the agent does there." : allowOwnMachine ? "Only your own messages run on it." : "" : offerThisComputer ? "Only you can use this computer. Your agents can work with files and use the screen after you allow system permissions. Turn it off anytime in the app." : fleet.canConnect ? "You can remove a connected machine anytime from Machines." : "",
+        onOpen: () => {
+          if (allowHere) return void use(allowHere);
+          if (!offerThisComputer) return openSetup();
+          if (desktop.computer.acting) return;
+          if (thisComputerNeedsPermissions(desktop.computer.status))
+            return desktop.allowPermissions();
+          void desktop.computer.turnOn().then(() => void fleet.refresh());
+        },
+        onClose: closeSetup,
+        opener,
+        cardRef,
+        details: unavailableOnDeployment || !fleet.canRead ? null : /* @__PURE__ */ jsxs(Fragment, { children: [
+          desktop?.computer.actionError !== null && desktop?.computer.actionError !== void 0 ? /* @__PURE__ */ jsxs(Notice, { tone: "failed", live: "assertive", className: "mx-4 mb-3 text-xs", children: [
+            "Computer use couldn't turn on. ",
+            desktop.computer.actionError || "Try again."
+          ] }) : null,
+          visibleDetails ? /* @__PURE__ */ jsxs(
+            "div",
+            {
+              "data-slot": "connected-machines",
+              className: "space-y-3 border-t border-border px-[19px] pt-3 pb-4 max-[480px]:px-3.5",
+              children: [
+                useError ? /* @__PURE__ */ jsx(Notice, { tone: "failed", live: "assertive", className: "text-xs", children: `Couldn't move this chat to ${useError.name}. ${useError.reason ?? (fleet.mutationError ? userErrorText(fleet.mutationError, "Try again.") : "Try again.")}` }) : null,
+                foldable ? /* @__PURE__ */ jsxs(
+                  Button,
+                  {
+                    type: "button",
+                    variant: "ghost",
+                    size: "sm",
+                    className: "-ml-2 text-fg-muted",
+                    "aria-expanded": othersOpen,
+                    onClick: () => setOthersOpen((open) => !open),
+                    children: [
+                      /* @__PURE__ */ jsx(
+                        ChevronRightIcon,
+                        {
+                          "aria-hidden": true,
+                          className: othersOpen ? "rotate-90 transition-transform" : "transition-transform"
+                        }
+                      ),
+                      "Use a different machine"
+                    ]
+                  }
+                ) : null,
+                !folded && ordered.length > 0 ? /* @__PURE__ */ jsx(RowList, { label: "Connected machines", flush: true, children: ordered.map((machine) => /* @__PURE__ */ jsx(
+                  MachineRow,
+                  {
+                    machine,
+                    primary: machine.sandboxId === justConnected,
+                    canUse: fleet.canAttach,
+                    busy: using === machine.sandboxId,
+                    locked: using !== null || fleet.attaching,
+                    onUse: () => void use(machine)
+                  },
+                  machine.sandboxId
+                )) }) : null,
+                !folded && chromeMachine ? /* @__PURE__ */ jsx(
+                  ScreenControlStep,
+                  {
+                    machine: chromeMachine,
+                    workspaceId,
+                    canManage: fleet.canManageMachine(chromeMachine),
+                    refresh: fleet.refresh,
+                    onReconnect: () => openSetup(chromeMachine)
+                  },
+                  chromeMachine.sandboxId
+                ) : null,
+                !folded && chromeMachine ? /* @__PURE__ */ jsx(
+                  ChromeStep,
+                  {
+                    chrome,
+                    machineName: machineDisplayName(t, chromeMachine)
+                  }
+                ) : null,
+                !folded && connectAnother ? (
+                  // Its own list after the machines and their steps: it is
+                  // not a connected machine, and it shouldn't split the chat
+                  // machine from its screen control and Chrome rows.
+                  /* @__PURE__ */ jsx(RowList, { label: "Connect another computer", flush: true, children: /* @__PURE__ */ jsx(
+                    ListRow,
+                    {
+                      leading: /* @__PURE__ */ jsx(LogoTile, { icon: /* @__PURE__ */ jsx(PlusIcon, {}) }),
+                      title: "Another computer",
+                      description: "Not connected yet",
+                      control: /* @__PURE__ */ jsx(
+                        RowButton,
+                        {
+                          "aria-label": "Connect another computer",
+                          "aria-haspopup": "dialog",
+                          onClick: () => openSetup(),
+                          children: "Connect"
+                        }
+                      )
+                    }
+                  ) })
+                ) : null
+              ]
+            }
+          ) : null
+        ] })
+      }
+    ) }),
+    fleet.canConnect && !unavailableOnDeployment ? /* @__PURE__ */ jsx(
+      ConnectMachineDialog,
+      {
+        open: setupOpen,
+        onOpenChange: (open) => {
+          if (!open) closeSetup();
+        },
+        workspaceId,
+        sessionId,
+        origin,
+        machines: fleet.machines,
+        machinesLoading: fleet.loading,
+        machinesError: fleet.error,
+        personalWorkspace,
+        canShareWithWorkspace: fleet.canManage,
+        canConnectOwnMachine: fleet.canConnectOwnMachine,
+        defaultScope: setupScope,
+        defaultAllowScreenControl: setupScreenControl,
+        onConnected: (machine) => {
+          setJustConnected(machine.sandboxId);
+          setAnnouncement(`${machineDisplayName(t, machine)} connected.`);
+        },
+        useInChat: { canUse: fleet.canAttach, onUse: (machine) => void use(machine) }
+      }
+    ) : null
+  ] });
+}
+function RepeatedMachineRequestNote({ chrome = false }) {
+  return /* @__PURE__ */ jsxs("p", { className: "flex items-center gap-2 text-xs text-fg-muted", children: [
+    /* @__PURE__ */ jsx(LaptopIcon, { "aria-hidden": true, className: "size-3.5 shrink-0" }),
+    chrome ? "The agent asked to connect Chrome. It asked again below." : "The agent asked to use a machine. It asked again below."
+  ] });
+}
+function MachineRow({
+  machine,
+  primary,
+  canUse,
+  busy,
+  locked,
+  onUse
+}) {
+  const name = machineDisplayName(t, machine);
+  const selectable = isMachineComputeSelectable(machine.state);
+  const Icon = machine.os === "linux" && !machine.hasDisplay ? ServerIcon : LaptopIcon;
+  const common = {
+    leading: /* @__PURE__ */ jsx(LogoTile, { icon: /* @__PURE__ */ jsx(Icon, {}) }),
+    title: name,
+    meta: [stateLabel(machine), machineScopeLabel(t, machine.scope)]
+  };
+  if (machine.active) {
+    return /* @__PURE__ */ jsx(
+      ListRow,
+      {
+        ...common,
+        control: /* @__PURE__ */ jsxs("span", { className: "inline-flex items-center gap-1 text-xs font-medium text-status-idle", children: [
+          /* @__PURE__ */ jsx(CheckIcon, { "aria-hidden": true, className: "size-3.5" }),
+          "In this chat"
+        ] })
+      }
+    );
+  }
+  if (!selectable) return /* @__PURE__ */ jsx(ListRow, { ...common, disabled: true });
+  if (!canUse) return /* @__PURE__ */ jsx(ListRow, { ...common });
+  const label = busy ? `Moving this chat to ${name}` : `Use ${name} in this chat`;
+  return /* @__PURE__ */ jsx(
+    ListRow,
+    {
+      ...common,
+      control: primary ? /* @__PURE__ */ jsxs(
+        Button,
+        {
+          type: "button",
+          size: "sm",
+          "aria-label": label,
+          "aria-disabled": locked || void 0,
+          className: "rounded-[10px] pointer-coarse:h-11",
+          onClick: () => {
+            if (!locked) onUse();
+          },
+          children: [
+            busy ? /* @__PURE__ */ jsx(Loader2Icon, { "aria-hidden": true, className: "animate-spin" }) : null,
+            busy ? "Moving\u2026" : "Use in this chat"
+          ]
+        }
+      ) : /* @__PURE__ */ jsxs(
+        RowButton,
+        {
+          "aria-label": label,
+          "aria-disabled": locked || void 0,
+          onClick: () => {
+            if (!locked) onUse();
+          },
+          children: [
+            busy ? /* @__PURE__ */ jsx(Loader2Icon, { "aria-hidden": true, className: "animate-spin" }) : null,
+            busy ? "Moving\u2026" : "Use"
+          ]
+        }
+      )
+    }
+  );
+}
+function useAttachedChrome(workspaceId, scope, refreshKey = null) {
+  const { client } = useAppContext();
+  const clientRef = useRef(client);
+  clientRef.current = client;
+  const [connected, setConnected] = useState(null);
+  const [checked, setChecked] = useState(false);
+  const [watchSince, setWatchSince] = useState(null);
+  const [refreshSince, setRefreshSince] = useState(null);
+  const [expired, setExpired] = useState(false);
+  const [denied, setDenied] = useState(false);
+  const linked = connected !== null;
+  const enrollmentId = scope === null ? null : scope === "any" ? "*" : scope.enrollmentId;
+  useEffect(() => {
+    setConnected(null);
+    setChecked(false);
+    setDenied(false);
+  }, [enrollmentId]);
+  useEffect(() => {
+    setRefreshSince(refreshKey === null ? null : Date.now());
+  }, [refreshKey]);
+  useEffect(() => {
+    if (!enrollmentId || denied) return;
+    let cancelled = false;
+    const read = async () => {
+      try {
+        const result = await clientRef.current.listAttachedBrowsers(workspaceId);
+        if (cancelled) return;
+        const device = result.devices.find(
+          (candidate) => candidate.state === "connected" && candidate.capabilities.debuggerAttachment && (enrollmentId === "*" || candidate.enrollmentId === enrollmentId)
+        );
+        setConnected(device ? { name: device.profileLabel ?? device.browserName } : null);
+        setChecked(true);
+      } catch (failure) {
+        if (!cancelled && failure instanceof OpenGeniApiError && failure.status >= 400 && failure.status < 500) {
+          setDenied(true);
+        }
+      }
+    };
+    void read();
+    if (linked || watchSince === null && refreshSince === null) {
+      return () => void (cancelled = true);
+    }
+    const timer = window.setInterval(() => {
+      const now = Date.now();
+      const watching = watchSince !== null && now - watchSince <= CHROME_POLL_LIMIT_MS;
+      const refreshing = refreshSince !== null && now - refreshSince <= CHROME_REFRESH_POLL_LIMIT_MS;
+      if (!watching && !refreshing) {
+        window.clearInterval(timer);
+        if (watchSince !== null) setExpired(true);
+        return;
+      }
+      if (document.visibilityState !== "hidden") void read();
+    }, CHROME_POLL_MS);
+    return () => {
+      cancelled = true;
+      window.clearInterval(timer);
+    };
+  }, [denied, enrollmentId, linked, refreshSince, watchSince, workspaceId]);
+  const watch = useCallback(() => {
+    setExpired(false);
+    setWatchSince(Date.now());
+  }, []);
+  return {
+    connected,
+    checked,
+    watch,
+    watching: watchSince !== null && !linked && !expired && !denied
+  };
+}
+var SCREEN_CONTROL_WATCH_MS = 9e4;
+var MAC_PERMISSION_WATCH_MS = 3 * 6e4;
+var SCREEN_CONTROL_POLL_MS = 3e3;
+var MAC_PERMISSIONS = [
+  { pane: "screen_recording", key: "screenRecording", label: "Screen Recording" },
+  { pane: "accessibility", key: "accessibility", label: "Accessibility" },
+  { pane: "input_monitoring", key: "inputMonitoring", label: "Input Monitoring" }
+];
+function isOnline(machine) {
+  return machine.state === "online" || machine.state === "consent_required" || machine.state === "display_unavailable";
+}
+function ScreenControlStep({
+  machine,
+  workspaceId,
+  canManage,
+  refresh,
+  onReconnect
+}) {
+  const { client } = useAppContext();
+  const stepRef = useRef(null);
+  const refreshRef = useRef(refresh);
+  refreshRef.current = refresh;
+  const [busy, setBusy] = useState(false);
+  const [note, setNote] = useState(null);
+  const [opened, setOpened] = useState(null);
+  const [watchUntil, setWatchUntil] = useState(0);
+  const [stalled, setStalled] = useState(false);
+  const [reconnect, setReconnect] = useState(false);
+  const online = isOnline(machine);
+  const runtime = machine.runtime;
+  const allowed = machine.allowScreenControl;
+  const applied = allowed && (runtime?.capabilities.screenControl ?? true);
+  const renewable = runtime?.capabilities.credentialRenew === true;
+  const mac = machine.os === "macos";
+  const permissions = mac ? runtime?.macPermissions ?? null : null;
+  const reason = machine.desktopUnavailableReason?.trim() || null;
+  const missing = permissions ? MAC_PERMISSIONS.find((step) => !permissions[step.key]) ?? null : mac && reason !== null && /screen recording/i.test(reason) ? MAC_PERMISSIONS[0] : null;
+  const updating = runtime?.versionState === "updating";
+  const waiting = allowed && !applied && online && (renewable || updating) && !reconnect || opened !== null;
+  useEffect(() => {
+    if (waiting && watchUntil === 0) setWatchUntil(Date.now() + SCREEN_CONTROL_WATCH_MS);
+  }, [waiting, watchUntil]);
+  useEffect(() => {
+    if (!waiting || watchUntil === 0) return;
+    const timer = window.setInterval(() => {
+      if (Date.now() > watchUntil) {
+        window.clearInterval(timer);
+        setStalled(true);
+        return;
+      }
+      void refreshRef.current().catch(() => {
+      });
+    }, SCREEN_CONTROL_POLL_MS);
+    return () => window.clearInterval(timer);
+  }, [waiting, watchUntil]);
+  async function turnOn() {
+    if (busy || !machine.enrollmentId) return;
+    setBusy(true);
+    setNote(null);
+    setStalled(false);
+    try {
+      const result = await client.enableMachineScreenControl(workspaceId, machine.enrollmentId);
+      if (result.reason === "renewal_failed") setNote(result.message);
+      setReconnect(result.reason === "reconnect_required");
+      setWatchUntil(Date.now() + SCREEN_CONTROL_WATCH_MS);
+      await refreshRef.current().catch(() => {
+      });
+    } catch (failure) {
+      setNote(
+        failure instanceof OpenGeniApiError && failure.status === 403 ? "Only an organization admin can turn this on." : userErrorText(failure, "Try again.")
+      );
+    } finally {
+      setBusy(false);
+      focusIfIdle(stepRef.current);
+    }
+  }
+  async function updateAgent() {
+    if (busy || !machine.enrollmentId) return;
+    setBusy(true);
+    setNote(null);
+    try {
+      await client.updateMachineAgent(workspaceId, machine.enrollmentId);
+      setStalled(false);
+      setWatchUntil(Date.now() + MAC_PERMISSION_WATCH_MS);
+      await refreshRef.current().catch(() => {
+      });
+    } catch (failure) {
+      setNote(userErrorText(failure, "Try again."));
+    } finally {
+      setBusy(false);
+    }
+  }
+  async function openPane(pane) {
+    if (busy || !machine.enrollmentId) return;
+    setBusy(true);
+    setNote(null);
+    try {
+      const result = await client.openMachinePrivacySettings(workspaceId, machine.enrollmentId, {
+        pane
+      });
+      if (result.opened) {
+        setOpened(pane);
+        setStalled(false);
+        setWatchUntil(Date.now() + MAC_PERMISSION_WATCH_MS);
+      } else {
+        setNote(result.message);
+      }
+    } catch (failure) {
+      setNote(userErrorText(failure, "Try again."));
+    } finally {
+      setBusy(false);
+    }
+  }
+  const button = (label, onClick) => /* @__PURE__ */ jsxs(RowButton, { "aria-disabled": busy || void 0, "aria-busy": busy || void 0, onClick, children: [
+    busy ? /* @__PURE__ */ jsx(Loader2Icon, { "aria-hidden": true, className: "animate-spin" }) : null,
+    label
+  ] });
+  const done = /* @__PURE__ */ jsxs("span", { className: "inline-flex items-center gap-1 text-xs font-medium text-status-idle", children: [
+    /* @__PURE__ */ jsx(CheckIcon, { "aria-hidden": true, className: "size-3.5" }),
+    "On"
+  ] });
+  let description;
+  let hint = null;
+  let control = null;
+  if (!allowed) {
+    description = canManage ? "Let agents see and use this screen" : "Ask a workspace admin to turn it on";
+    if (canManage) control = button(busy ? "Turning on\u2026" : "Turn on", () => void turnOn());
+  } else if (!applied) {
+    if (reconnect) {
+      description = "Needs a fresh connection";
+      hint = "Run the connect command on this machine again, with screen control on.";
+      if (canManage) control = button("Connect again", onReconnect);
+    } else if (updating) {
+      description = "Updating the agent\u2026";
+    } else if (!renewable) {
+      description = "Waiting for an agent update";
+      hint = "It turns on by itself once this machine's agent is updated.";
+      if (canManage && !runtime?.updateBlockedReason) {
+        control = button(busy ? "Updating\u2026" : "Update agent", () => void updateAgent());
+      }
+    } else if (stalled || note) {
+      description = "Not on yet";
+      if (canManage) control = button(busy ? "Trying\u2026" : "Try again", () => void turnOn());
+    } else {
+      description = "Turning on\u2026";
+    }
+  } else if (missing) {
+    const shown = opened === missing.pane;
+    description = "Mac permission needed";
+    hint = shown ? `On the Mac, switch on Opengeni under ${missing.label}.${missing.pane === "screen_recording" ? " Choose Quit & Reopen if macOS asks." : ""}` : `Allow ${missing.label} for Opengeni on this Mac.`;
+    if (canManage && online) {
+      control = button(shown ? "Open again" : "Open settings", () => void openPane(missing.pane));
+    }
+  } else if (reason) {
+    description = reason;
+  } else {
+    description = "Agents can see and use this screen";
+    control = done;
+  }
+  const notice = note ?? hint;
+  return /* @__PURE__ */ jsxs(
+    "div",
+    {
+      "data-slot": "screen-control",
+      ref: stepRef,
+      tabIndex: -1,
+      className: "space-y-2 outline-hidden",
+      children: [
+        /* @__PURE__ */ jsx(RowList, { label: "Screen control", flush: true, children: /* @__PURE__ */ jsx(
+          ListRow,
+          {
+            leading: /* @__PURE__ */ jsx(LogoTile, { icon: /* @__PURE__ */ jsx(MonitorIcon, {}) }),
+            title: "Screen control",
+            description,
+            control
+          }
+        ) }),
+        /* @__PURE__ */ jsx("span", { className: "sr-only", "aria-live": "polite", children: notice ? `${description}. ${notice}` : description }),
+        notice ? /* @__PURE__ */ jsx(Notice, { tone: "waiting", className: "text-xs", children: notice }) : null
+      ]
+    }
+  );
+}
+function ChromeStep({ chrome, machineName }) {
+  const { client } = useAppContext();
+  const extension = useClientConfigFlags(client).browserExtension ?? {
+    name: "Opengeni Browser",
+    installUrl: OPENGENI_BROWSER_EXTENSION_URL
+  };
+  return /* @__PURE__ */ jsx("div", { "data-slot": "chrome-extension", children: /* @__PURE__ */ jsx(RowList, { label: "Chrome", flush: true, children: /* @__PURE__ */ jsx(
+    ListRow,
+    {
+      leading: /* @__PURE__ */ jsx(LogoTile, { icon: /* @__PURE__ */ jsx(PuzzleIcon, {}) }),
+      title: "Chrome",
+      description: chrome.connected ? `${chrome.connected.name} on ${machineName}` : `Add ${extension.name} on ${machineName}`,
+      control: chrome.connected ? /* @__PURE__ */ jsxs("span", { className: "inline-flex items-center gap-1 text-xs font-medium text-status-idle", children: [
+        /* @__PURE__ */ jsx(CheckIcon, { "aria-hidden": true, className: "size-3.5" }),
+        "Connected"
+      ] }) : /* @__PURE__ */ jsx(Button, { asChild: true, size: "sm", variant: "outline", className: "rounded-[10px]", children: /* @__PURE__ */ jsxs(
+        "a",
+        {
+          href: extension.installUrl,
+          target: "_blank",
+          rel: "noreferrer",
+          onClick: chrome.watch,
+          children: [
+            "Add to Chrome",
+            /* @__PURE__ */ jsx(ArrowUpRightIcon, { "aria-hidden": true }),
+            /* @__PURE__ */ jsx("span", { className: "sr-only", children: " (opens the Chrome Web Store in a new tab)" })
+          ]
+        }
+      ) })
+    }
+  ) }) });
+}
+
+export {
+  CONNECTED_MACHINE_LOGO,
+  SessionMachineCapabilityCard,
+  RepeatedMachineRequestNote,
+  useAttachedChrome
+};
+//# sourceMappingURL=chunk-NC55IFN3.js.map