@opengeni/react 0.5.0 → 0.6.1

package/dist/machines-BD6h9P_s.d.ts

@@ -0,0 +1,329 @@
+import { OpenGeniClient, MachineState, MetricSample, MachineView, MachineKind, MachinesResponse } from '@opengeni/sdk';
+import * as react_jsx_runtime from 'react/jsx-runtime';
+import { ReactNode } from 'react';
+
+/**
+ * The slice of `OpenGeniClient` the hooks depend on. Structural, so apps can
+ * pass the real SDK client, a proxy-backed client that routes through their
+ * own API, or a scripted client in tests/demos.
+ */
+type SessionClientLike = Pick<OpenGeniClient, "getClientConfig" | "getSession" | "updateSession" | "listSessions" | "sendMessage" | "steerMessage" | "interrupt" | "sendApprovalDecision" | "streamEvents" | "listTurns" | "updateQueuedTurn" | "reorderQueuedTurns" | "deleteQueuedTurn" | "getGoal" | "updateGoal" | "clearSessionContext" | "compactSessionContext" | "listScheduledTasks" | "uploadFile" | "getFile" | "createFileDownloadUrl" | "listEnvironments" | "createEnvironment" | "updateEnvironment" | "deleteEnvironment" | "setEnvironmentVariable" | "deleteEnvironmentVariable" | "listPacks" | "registerPack" | "enablePack" | "deletePack" | "listWorkspaces" | "createWorkspace" | "updateWorkspace" | "getBillingUsage" | "getClientConfig" | "getStreamCapabilities" | "acknowledgeStream" | "attachViewer" | "heartbeatViewer" | "detachViewer" | "fsList" | "fsRead" | "fsWrite" | "fsDelete" | "fsMove" | "fsMkdir" | "gitStatus" | "gitDiff" | "terminalExec" | "terminalPtyOpen" | "terminalPtyWrite" | "terminalPtyResize" | "terminalPtyClose">;
+
+type OpenGeniContextValue = {
+    client: SessionClientLike;
+    workspaceId: string;
+};
+type OpenGeniProviderProps = {
+    client: SessionClientLike;
+    workspaceId: string;
+    children?: ReactNode;
+};
+/**
+ * Supplies the OpenGeni client + workspace to all hooks below it. Hooks also
+ * accept `{ client, workspaceId }` overrides per call for multi-workspace UIs.
+ */
+declare function OpenGeniProvider({ client, workspaceId, children }: OpenGeniProviderProps): react_jsx_runtime.JSX.Element;
+type ClientOverride = {
+    client?: SessionClientLike | undefined;
+    workspaceId?: string | undefined;
+};
+/** Resolve client + workspace from explicit overrides or the provider. */
+declare function useOpenGeni(override?: ClientOverride): OpenGeniContextValue;
+/**
+ * Resolve the client only — for hooks that are not workspace-scoped
+ * (`useWorkspaces`, `useBillingUsage`).
+ */
+declare function useOpenGeniClient(override?: Pick<ClientOverride, "client">): SessionClientLike;
+
+/**
+ * The three connection-status pill values the UI surfaces across the dashboard,
+ * the dock, and the timeline. `consent_required` / `display_unavailable` /
+ * `enrolling` are NOT connection states — they map onto a connection state for
+ * the pill and carry their own badge separately.
+ */
+type ConnectionStatus = "online" | "reconnecting" | "offline";
+/** Project a machine `state` onto its connection-status pill value. */
+declare function connectionStatusForState(state: MachineState): ConnectionStatus;
+
+type ConnectionStatusMeta = {
+    label: string;
+    dotClassName: string;
+    badgeClassName: string;
+    /** Live/transient states breathe; settled states hold still. */
+    pulse: boolean;
+};
+/** Token-backed meta for the three connection-status pill values. */
+declare const CONNECTION_STATUS_META: Record<ConnectionStatus, ConnectionStatusMeta>;
+type MachineStateBadgeMeta = {
+    label: string;
+    badgeClassName: string;
+};
+/**
+ * The non-connection state badges that ride ALONGSIDE the connection pill —
+ * `consent_required` / `display_unavailable` / `enrolling` describe a capability
+ * limitation, not reachability, so they render as their own tinted chip.
+ */
+declare const MACHINE_STATE_BADGE_META: Partial<Record<MachineState, MachineStateBadgeMeta>>;
+type ConnectionStatusPillProps = {
+    status: ConnectionStatus;
+    /** Override the label ("Online" -> "Connected", ...). */
+    label?: string | undefined;
+    size?: "sm" | "md" | undefined;
+    className?: string | undefined;
+};
+/**
+ * The connection-status pill (online / reconnecting / offline) surfaced across
+ * the Machines dashboard, the dock header, and the session timeline. Reconnecting
+ * breathes (the resiliency-as-headline blip), online/offline hold still.
+ */
+declare function ConnectionStatusPill({ status, label, size, className }: ConnectionStatusPillProps): react_jsx_runtime.JSX.Element;
+type ConnectionDotProps = {
+    status: ConnectionStatus;
+    className?: string | undefined;
+};
+/** Just the dot — for dense rows, the dock header, and timeline notices. */
+declare function ConnectionDot({ status, className }: ConnectionDotProps): react_jsx_runtime.JSX.Element;
+type MachineStatusPillProps = {
+    /** The machine's full state — drives the connection pill + any state badge. */
+    state: MachineState;
+    /** How many live sessions share this lease (renders a "Shared" chip when >1). */
+    sharedSessionCount?: number | undefined;
+    size?: "sm" | "md" | undefined;
+    className?: string | undefined;
+};
+/**
+ * The composite machine status surface: the connection pill PLUS any
+ * consent/display/enrolling badge PLUS a shared-in-use chip. One component the
+ * dashboard row, the dock header, and the timeline all reuse so the status
+ * language is identical everywhere.
+ */
+declare function MachineStatusPill({ state, sharedSessionCount, size, className }: MachineStatusPillProps): react_jsx_runtime.JSX.Element;
+
+type MachineMetricsProps = {
+    /** The latest metric sample, or null when the machine hasn't reported yet. */
+    metrics: MetricSample | null;
+    /** Compact (dashboard row) vs full (the dock detail). */
+    density?: "compact" | "full" | undefined;
+    className?: string | undefined;
+};
+/**
+ * Per-machine resource meters: CPU%, load average, memory, disk, and GPU when
+ * present. Renders the M2 `machine_metrics_latest` sample. When `metrics` is
+ * null the panel shows a quiet "no samples yet" placeholder (offline / just
+ * enrolled). GPU rows only render when `gpuUtilPct` is non-null.
+ */
+declare function MachineMetrics({ metrics, density, className }: MachineMetricsProps): react_jsx_runtime.JSX.Element;
+
+type MachineCardProps = {
+    machine: MachineView;
+    /** Attach/swap the session's active sandbox to this machine. */
+    onAttach?: ((machine: MachineView) => void) | undefined;
+    /** Whether an attach/swap is currently in flight (disables the affordance). */
+    attaching?: boolean | undefined;
+    className?: string | undefined;
+};
+/**
+ * One machine in the Machines dashboard: name + kind + OS/arch, the composite
+ * connection/state/shared status, latest resource meters, last-seen recency, and
+ * an attach/swap affordance. The session's currently-active sandbox carries an
+ * accent edge + an "Active" marker (never an attach button — it's already active).
+ */
+declare function MachineCard({ machine, onAttach, attaching, className }: MachineCardProps): react_jsx_runtime.JSX.Element;
+
+type MachinesDashboardProps = {
+    machines: MachineView[];
+    /** The session's active sandbox id (drives the per-card "Active" marker). */
+    activeSandboxId?: string | null | undefined;
+    loading?: boolean | undefined;
+    error?: Error | null | undefined;
+    /** Attach/swap the session's active sandbox to a machine. */
+    onAttach?: ((machine: MachineView) => void) | undefined;
+    /** The sandbox id currently being attached/swapped to (disables that card). */
+    attachingSandboxId?: string | null | undefined;
+    /** Open the enrollment flow (the "Enroll a machine" CTA). */
+    onEnroll?: (() => void) | undefined;
+    onRefresh?: (() => void) | undefined;
+    className?: string | undefined;
+};
+/**
+ * The workspace Machines dashboard: the fleet of selfhosted enrollments + the
+ * session's Modal sandbox, each with its connection-status pill, state badges,
+ * latest metrics, and an attach/swap affordance. Renders the empty state (no
+ * machines → enroll CTA), a load error, and the populated grid. The component
+ * is purely presentational — feed it `MachinesResponse` data via `useMachines`.
+ */
+declare function MachinesDashboard({ machines, activeSandboxId, loading, error, onAttach, attachingSandboxId, onEnroll, onRefresh, className, }: MachinesDashboardProps): react_jsx_runtime.JSX.Element;
+
+type MachineDockBarProps = {
+    /** The active machine's display name. */
+    name: string;
+    kind: MachineKind;
+    state: MachineState;
+    /** Live sessions sharing this whole-machine lease (>1 ⇒ shared disclosure). */
+    sharedSessionCount?: number | undefined;
+    className?: string | undefined;
+};
+/**
+ * A slim bar that surfaces WHICH machine the dock surfaces (Files/Terminal/
+ * Desktop) are bound to + its connection status. Mounted above the dock tabs so
+ * the user always knows whether they are looking at the Modal box or their own
+ * machine, and whether it is online / reconnecting / offline. The surfaces below
+ * render IDENTICALLY regardless of backend — this bar is the only backend-aware
+ * chrome (the dock-parity contract: selfhosted == Modal for the surfaces).
+ */
+declare function MachineDockBar({ name, kind, state, sharedSessionCount, className }: MachineDockBarProps): react_jsx_runtime.JSX.Element;
+type SharedMachineDisclosureProps = {
+    sharedSessionCount: number;
+    /** Compact (inline strip) vs full (a notice block). */
+    density?: "compact" | "full" | undefined;
+    className?: string | undefined;
+};
+/**
+ * The "shared — another session is on this machine" disclosure. Surfaced in the
+ * dock (and reused on the desktop take-control gate) so the user knows others are
+ * driving the same whole-machine lease. Render when `sharedSessionCount > 1`.
+ */
+declare function SharedMachineDisclosure({ sharedSessionCount, density, className }: SharedMachineDisclosureProps): react_jsx_runtime.JSX.Element;
+
+/** The poll state of an in-flight device-flow enrollment. */
+type DeviceFlowPhase = "pending" | "authorized" | "denied" | "expired" | "disabled";
+type EnrollmentDeviceFlowProps = {
+    /** The short user code the agent printed (shown big for the human to confirm). */
+    userCode: string;
+    /** Where the user approves — the same-origin device page. */
+    verificationUri: string;
+    /** The complete URI (code pre-filled) for a one-click / QR open. */
+    verificationUriComplete?: string | undefined;
+    /** The install one-liner the user ran (echoed for context). Optional. */
+    installCommand?: string | undefined;
+    phase?: DeviceFlowPhase | undefined;
+    /** Seconds remaining before the code expires (drives a quiet countdown). */
+    expiresInSeconds?: number | undefined;
+    onCopyCode?: (() => void) | undefined;
+    onCopyInstall?: (() => void) | undefined;
+    onOpenVerification?: (() => void) | undefined;
+    className?: string | undefined;
+};
+/**
+ * The IN-SESSION device-flow panel: the agent (after the install one-liner) prints
+ * a short `userCode` + a `verificationUri`; this surfaces them so the user can open
+ * the approve page and confirm the code. Polls in the caller; this renders the
+ * pending → authorized/denied/expired progression with a connection pill. This is
+ * the FIRST step of the IA flow (device-flow → Machines list → attach/swap).
+ */
+declare function EnrollmentDeviceFlow({ userCode, verificationUri, verificationUriComplete, installCommand, phase, expiresInSeconds, onCopyCode, onCopyInstall, onOpenVerification, className, }: EnrollmentDeviceFlowProps): react_jsx_runtime.JSX.Element;
+
+/** The machine identity surfaced to the approver, from the device-flow start. */
+type EnrollmentConsentMachine = {
+    /** Human-friendly name (hostname by default). */
+    machineName: string;
+    os: string;
+    arch: string;
+    /** The agent can offer a display (a real screen / Xvfb is available). */
+    canOfferDisplay: boolean;
+    /** The agent requests screen control (computer-use). */
+    requestsScreenControl: boolean;
+};
+/** The phase of the approve page (drives the rendered panel). */
+type EnrollmentConsentPhase = "review" | "approving" | "approved" | "denied" | "error";
+type EnrollmentConsentProps = {
+    /** The short code the user typed / scanned (echoed back for confirmation). */
+    userCode: string;
+    machine: EnrollmentConsentMachine;
+    phase?: EnrollmentConsentPhase | undefined;
+    /** Approve with the chosen screen-control consent. */
+    onApprove?: ((allowScreenControl: boolean) => void) | undefined;
+    onDeny?: (() => void) | undefined;
+    /** Error message when phase === "error". */
+    errorMessage?: string | undefined;
+    className?: string | undefined;
+};
+/**
+ * The user-facing APPROVE page for the device-flow enrollment: a LOUD,
+ * un-minimised whole-machine consent. Approving grants the agent FULL access to
+ * this machine — exec, files, terminal — and (when toggled) live screen control.
+ * The danger framing is deliberate (§18 hardening: whole-machine = loud consent),
+ * never buried. Renders review / approving / approved / denied / error phases.
+ */
+declare function EnrollmentConsent({ userCode, machine, phase, onApprove, onDeny, errorMessage, className, }: EnrollmentConsentProps): react_jsx_runtime.JSX.Element;
+
+/**
+ * The slice of the SDK client the Machines surface needs. The method NAMES +
+ * SIGNATURES match M10's `OpenGeniClient` (`listMachines`, `machineMetricsSeries`)
+ * so the real SDK client satisfies this surface DIRECTLY for the read paths — no
+ * adapter needed. It is declared structurally (not a hard `OpenGeniClient` Pick)
+ * so a test/demo/Geni-frontend client can stand in, keeping the hook dual-consumer
+ * safe (works in apps/web AND the separate Geni frontend).
+ *
+ * The active-sandbox SWAP is now a typed SDK call (`swapActiveSandbox`, the M7
+ * user-authenticated REST equivalent of the `sandbox_swap` MCP tool). The real
+ * SDK client satisfies it structurally, so the default attach path is wired
+ * WHENEVER a sessionId is in scope (the swap is session-scoped). `attachMachine`
+ * stays an OPTIONAL escape hatch for a host that wants to supply its own swap
+ * adapter; when neither it nor a sessionId is present, attach is a no-op and the
+ * card hides the button.
+ */
+type MachinesClientLike = {
+    /** GET /v1/workspaces/:ws/machines — the dashboard list + active pointer. */
+    listMachines: (workspaceId: string, options?: {
+        sessionId?: string;
+    }) => Promise<MachinesResponse>;
+    /** GET .../machines/:enrollmentId/metrics/series — the downsampled history. */
+    machineMetricsSeries?: (workspaceId: string, enrollmentId: string, options?: {
+        window?: "15m" | "1h" | "6h" | "24h";
+    }) => Promise<MetricSample[]>;
+    /**
+     * POST .../sessions/:sessionId/active-sandbox — swap the session's active
+     * sandbox to a machine. The default swap path; the real SDK client provides it.
+     */
+    swapActiveSandbox?: (workspaceId: string, sessionId: string, request: {
+        target: string;
+    }) => Promise<unknown>;
+    /**
+     * Host-supplied swap adapter (an escape hatch). When present it wins over the
+     * default `swapActiveSandbox` path. Session-scoped, like the swap it backs.
+     */
+    attachMachine?: (workspaceId: string, sessionId: string, sandboxId: string) => Promise<unknown>;
+};
+type UseMachinesOptions = ClientOverride & {
+    pollIntervalMs?: number | undefined;
+    enabled?: boolean | undefined;
+    /** Scope the list to a session (adds the synthetic Modal group box + pointer). */
+    sessionId?: string | undefined;
+    /**
+     * Override the client with one implementing `MachinesClientLike`. Defaults to
+     * the provider client cast to the surface (the real SDK client satisfies the
+     * read paths). An app supplies an adapter to wire `attachMachine` (the swap).
+     */
+    machinesClient?: MachinesClientLike | undefined;
+};
+type UseMachinesResult = {
+    machines: MachineView[];
+    activeSandboxId: string | null;
+    activeEpoch: number;
+    loading: boolean;
+    error: Error | null;
+    refresh: () => Promise<void>;
+    /** Attach/swap the session's active sandbox to a machine (returns the new pointer). */
+    attach: (sandboxId: string) => Promise<boolean>;
+    /** 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[]>;
+    attaching: boolean;
+    /** The sandbox id of the in-flight attach (for per-card spinner gating). */
+    attachingSandboxId: string | null;
+    mutationError: Error | null;
+    clearMutationError: () => void;
+};
+/**
+ * The workspace Machines fleet: the selfhosted enrollments + the session's Modal
+ * box, each with latest metrics + state, plus the active-sandbox pointer. Polls
+ * the M10 `GET /machines` endpoint and exposes attach/swap + a metric-series
+ * fetch. Renders via `<MachinesDashboard>`. Dual-consumer safe: it reads only the
+ * structural `MachinesClientLike` surface, so it works in apps/web AND the Geni
+ * frontend (each provides its own client/adapter).
+ */
+declare function useMachines(options?: UseMachinesOptions): UseMachinesResult;
+
+export { SharedMachineDisclosure as A, type SharedMachineDisclosureProps as B, type ClientOverride as C, type DeviceFlowPhase as D, EnrollmentConsent as E, type UseMachinesResult as F, connectionStatusForState as G, useMachines as H, useOpenGeni as I, useOpenGeniClient as J, MACHINE_STATE_BADGE_META as M, type OpenGeniContextValue as O, type SessionClientLike as S, type UseMachinesOptions as U, CONNECTION_STATUS_META as a, ConnectionDot as b, type ConnectionDotProps as c, type ConnectionStatus as d, type ConnectionStatusMeta as e, ConnectionStatusPill as f, type ConnectionStatusPillProps as g, type EnrollmentConsentMachine as h, type EnrollmentConsentPhase as i, type EnrollmentConsentProps as j, EnrollmentDeviceFlow as k, type EnrollmentDeviceFlowProps as l, MachineCard as m, type MachineCardProps as n, MachineDockBar as o, type MachineDockBarProps as p, MachineMetrics as q, type MachineMetricsProps as r, type MachineStateBadgeMeta as s, MachineStatusPill as t, type MachineStatusPillProps as u, type MachinesClientLike as v, MachinesDashboard as w, type MachinesDashboardProps as x, OpenGeniProvider as y, type OpenGeniProviderProps as z };

package/dist/machines.d.ts

@@ -0,0 +1,4 @@
+export { a as CONNECTION_STATUS_META, b as ConnectionDot, c as ConnectionDotProps, d as ConnectionStatus, e as ConnectionStatusMeta, f as ConnectionStatusPill, g as ConnectionStatusPillProps, D as DeviceFlowPhase, E as EnrollmentConsent, h as EnrollmentConsentMachine, i as EnrollmentConsentPhase, j as EnrollmentConsentProps, k as EnrollmentDeviceFlow, l as EnrollmentDeviceFlowProps, M as MACHINE_STATE_BADGE_META, m as MachineCard, n as MachineCardProps, o as MachineDockBar, p as MachineDockBarProps, q as MachineMetrics, r as MachineMetricsProps, s as MachineStateBadgeMeta, t as MachineStatusPill, u as MachineStatusPillProps, v as MachinesClientLike, w as MachinesDashboard, x as MachinesDashboardProps, A as SharedMachineDisclosure, B as SharedMachineDisclosureProps, U as UseMachinesOptions, F as UseMachinesResult, G as connectionStatusForState, H as useMachines } from './machines-BD6h9P_s.js';
+export { MachineKind, MachineMetricsSeriesResponse, MachineState, MachineView, MachinesResponse, MetricSample } from '@opengeni/sdk';
+import 'react/jsx-runtime';
+import 'react';

package/dist/machines.js

@@ -0,0 +1,33 @@
+import {
+  CONNECTION_STATUS_META,
+  ConnectionDot,
+  ConnectionStatusPill,
+  EnrollmentConsent,
+  EnrollmentDeviceFlow,
+  MACHINE_STATE_BADGE_META,
+  MachineCard,
+  MachineDockBar,
+  MachineMetrics,
+  MachineStatusPill,
+  MachinesDashboard,
+  SharedMachineDisclosure,
+  connectionStatusForState,
+  useMachines
+} from "./chunk-DEW2ZNF2.js";
+export {
+  CONNECTION_STATUS_META,
+  ConnectionDot,
+  ConnectionStatusPill,
+  EnrollmentConsent,
+  EnrollmentDeviceFlow,
+  MACHINE_STATE_BADGE_META,
+  MachineCard,
+  MachineDockBar,
+  MachineMetrics,
+  MachineStatusPill,
+  MachinesDashboard,
+  SharedMachineDisclosure,
+  connectionStatusForState,
+  useMachines
+};
+//# sourceMappingURL=machines.js.map

package/dist/machines.js.map

@@ -0,0 +1 @@
+{"version":3,"sources":[],"sourcesContent":[],"mappings":"","names":[]}

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@opengeni/react",
-  "version": "0.5.0",
+  "version": "0.6.1",
   "description": "React hooks and styled components for OpenGeni: live session streaming, chat composer, message timeline, session status, and fleet views — token-themed (CSS variables), dark-first, built on Tailwind v4 + Radix + Motion.",
   "license": "Apache-2.0",
   "repository": {
@@ -18,6 +18,10 @@
       "types": "./dist/index.d.ts",
       "import": "./dist/index.js"
     },
+    "./machines": {
+      "types": "./dist/machines.d.ts",
+      "import": "./dist/machines.js"
+    },
     "./styles.css": "./styles/index.css",
     "./tokens.css": "./styles/tokens.css"
   },
@@ -40,7 +44,8 @@
     "demo:build": "vite build demo"
   },
   "dependencies": {
-    "@opengeni/sdk": "^0.5.0",
+    "@bufbuild/protobuf": "^2.2.0",
+    "@opengeni/sdk": "^0.6.0",
     "clsx": "^2.1.1",
     "lucide-react": "^1.8.0",
     "motion": "^12.0.0",
@@ -106,6 +111,7 @@
   },
   "devDependencies": {
     "@codemirror/lang-css": "^6.3.1",
+    "@opengeni/agent-proto": "workspace:*",
     "@codemirror/lang-html": "^6.4.11",
     "@codemirror/lang-javascript": "^6.2.5",
     "@codemirror/lang-json": "^6.0.2",

package/src/components/desktop-viewer.tsx

@@ -3,6 +3,7 @@ import { LoaderCircleIcon, MonitorIcon, MousePointerClickIcon, WifiOffIcon } fro
 import { type ReactNode, useEffect, useRef, useState } from "react";
 import { cn } from "../lib/cn";
 import { useDesktopStream } from "../hooks/use-desktop-stream";
+import type { DesktopWebSocketFactory } from "../hooks/use-relay-frame-stream";
 
 export type DesktopViewerProps = {
   /** The desktop cell of the negotiated capabilities (`capabilities.DesktopStream`). */
@@ -19,6 +20,9 @@ export type DesktopViewerProps = {
   scaleViewport?: boolean | undefined;
   /** Custom RFB factory (tests / a WebRTC swap). Defaults to lazy @novnc/novnc. */
   rfbFactory?: DesktopRfbFactory | undefined;
+  /** Custom socket factory for the self-hosted `relay-frames` transport (tests).
+   *  Defaults to `new WebSocket(url)`. Mirrors `rfbFactory`. */
+  webSocketFactory?: DesktopWebSocketFactory | undefined;
   /**
    * Consent gate for the un-redacted (and possibly shared) pixel plane. Rendered
    * BEFORE connecting whenever the desktop requires acknowledgment that hasn't
@@ -121,6 +125,7 @@ export function DesktopViewer({
   showControlToggle = true,
   scaleViewport,
   rfbFactory,
+  webSocketFactory,
   renderConsentGate,
   onAcknowledge,
   watching,
@@ -213,6 +218,7 @@ export function DesktopViewer({
     interactive: inControl,
     ...(scaleViewport !== undefined ? { scaleViewport } : {}),
     ...(rfbFactory ? { rfbFactory } : {}),
+    ...(webSocketFactory ? { webSocketFactory } : {}),
   });
 
   const connected = stream.state === "connected";
@@ -429,7 +435,11 @@ export function DesktopViewer({
         <TakeControlCallToAction
           disabled={!serverAllowsControl}
           disabledReason={
-            !serverAllowsControl ? "This deployment streams the desktop read-only" : undefined
+            !serverAllowsControl
+              ? capability?.client === "frames"
+                ? "View-only — live control isn't available for this machine yet."
+                : "This deployment streams the desktop read-only"
+              : undefined
           }
           onTakeControl={() => setTakeControl(true)}
         />