@iblai/iblai-js 2.3.2 → 2.3.4

package/dist/web-containers/source/next/index.esm.js

@@ -98253,7 +98253,11 @@ var chatInputFormInsideButtons$3 = {
 	cowork: "Cowork",
 	coworkNeedsBackend: "Enable a large local model or sign in to a workspace to use Cowork.",
 	coworkModelTooSmall: "Your local model is too small for Cowork. Pick a model of at least 14GB in Local Models.",
-	moreOptions: "More options"
+	moreOptions: "More options",
+	coworkUnsupportedKde: "Cowork isn’t supported on KDE Plasma yet.",
+	coworkUnsupportedGnomeHelper: "Cowork on GNOME needs the WinRects helper installed, then a session restart.",
+	coworkUnsupportedOs: "Cowork isn’t supported on this operating system.",
+	coworkUnsupportedSession: "Cowork isn’t supported on this desktop session."
 };
 var chatInputFormMemoryMenu$3 = {
 	title: "Your Memory",
@@ -104581,7 +104585,11 @@ var chatInputFormInsideButtons$2 = {
 	cowork: "Cowork",
 	coworkNeedsBackend: "Activez un grand modèle local ou connectez-vous à un espace de travail pour utiliser Cowork.",
 	coworkModelTooSmall: "Votre modèle local est trop petit pour Cowork. Choisissez un modèle d’au moins 14 Go dans Modèles Locaux.",
-	moreOptions: "Plus d'options"
+	moreOptions: "Plus d'options",
+	coworkUnsupportedKde: "Cowork n’est pas encore pris en charge sur KDE Plasma.",
+	coworkUnsupportedGnomeHelper: "Cowork sur GNOME nécessite l’extension WinRects, puis un redémarrage de la session.",
+	coworkUnsupportedOs: "Cowork n’est pas pris en charge sur ce système d’exploitation.",
+	coworkUnsupportedSession: "Cowork n’est pas pris en charge sur cette session de bureau."
 };
 var chatInputFormMemoryMenu$2 = {
 	title: "Votre mémoire",
@@ -110797,7 +110805,11 @@ var chatInputFormInsideButtons$1 = {
 	cowork: "Cowork",
 	coworkNeedsBackend: "Activa un modelo local grande o inicia sesión en un espacio de trabajo para usar Cowork.",
 	coworkModelTooSmall: "Tu modelo local es demasiado pequeño para Cowork. Elige un modelo de al menos 14 GB en Modelos Locales.",
-	moreOptions: "Más opciones"
+	moreOptions: "Más opciones",
+	coworkUnsupportedKde: "Cowork aún no es compatible con KDE Plasma.",
+	coworkUnsupportedGnomeHelper: "Cowork en GNOME necesita la extensión WinRects instalada y reiniciar la sesión.",
+	coworkUnsupportedOs: "Cowork no es compatible con este sistema operativo.",
+	coworkUnsupportedSession: "Cowork no es compatible con esta sesión de escritorio."
 };
 var chatInputFormMemoryMenu$1 = {
 	title: "Tu memoria",
@@ -117013,7 +117025,11 @@ var chatInputFormInsideButtons = {
 	cowork: "Cowork",
 	coworkNeedsBackend: "启用大型本地模型或登录工作区即可使用 Cowork。",
 	coworkModelTooSmall: "您的本地模型太小，无法用于 Cowork。请在“本地模型”中选择至少 14GB 的模型。",
-	moreOptions: "更多选项"
+	moreOptions: "更多选项",
+	coworkUnsupportedKde: "Cowork 尚不支持 KDE Plasma。",
+	coworkUnsupportedGnomeHelper: "在 GNOME 上使用 Cowork 需要安装 WinRects 扩展，然后重启会话。",
+	coworkUnsupportedOs: "Cowork 不支持此操作系统。",
+	coworkUnsupportedSession: "Cowork 不支持此桌面会话。"
 };
 var chatInputFormMemoryMenu = {
 	title: "您的记忆",
@@ -204436,7 +204452,7 @@ var joinTextblockForward = () => ({ state, dispatch }) => {
 };
 
 // src/utilities/isMacOS.ts
-function isMacOS$1() {
+function isMacOS() {
   return typeof navigator !== "undefined" ? /Mac/.test(navigator.platform) : false;
 }
 
@@ -204462,7 +204478,7 @@ function normalizeKeyName(name) {
     } else if (/^s(hift)?$/i.test(mod)) {
       shift = true;
     } else if (/^mod$/i.test(mod)) {
-      if (isiOS() || isMacOS$1()) {
+      if (isiOS() || isMacOS()) {
         meta = true;
       } else {
         ctrl = true;
@@ -207439,7 +207455,7 @@ var Keymap = Extension.create({
       "Ctrl-a": () => this.editor.commands.selectTextblockStart(),
       "Ctrl-e": () => this.editor.commands.selectTextblockEnd()
     };
-    if (isiOS() || isMacOS$1()) {
+    if (isiOS() || isMacOS()) {
       return macKeymap;
     }
     return pcKeymap;
@@ -254795,7 +254811,7 @@ const TAURI_COMMANDS = {
 /**
  * Initial state for the Cowork install flow.
  */
-const initialGhostOsInstallState = {
+const initialCuaDriverInstallState = {
     status: 'idle',
     progress: 0,
     message: '',
@@ -254803,24 +254819,27 @@ const initialGhostOsInstallState = {
     lastUpdated: new Date().toISOString(),
 };
 /**
- * Tauri event names emitted by the host during GhostOS install/setup.
+ * Tauri event names emitted by the host during Cua Driver install.
  */
-const GHOST_OS_TAURI_EVENTS = {
-    INSTALL_PROGRESS: 'ghost-os:install-progress',
-    INSTALLATION_LOG: 'ghost-os:installation-log',
-    STATUS: 'ghost-os:status',
+const CUA_DRIVER_TAURI_EVENTS = {
+    INSTALL_PROGRESS: 'cua-driver:install-progress',
+    INSTALLATION_LOG: 'cua-driver:installation-log',
+    STATUS: 'cua-driver:status',
 };
 /**
- * Tauri command names the host implements for GhostOS install/setup. The web
- * layer invokes these; the native side performs the clone + setup.
+ * Tauri command names the host implements for the Cua Driver. The web layer
+ * invokes these; the native side downloads the pinned per-platform binary and
+ * owns the MCP process.
  */
-const GHOST_OS_TAURI_COMMANDS = {
-    /** Install and set up GhostOS (clone repo + run setup). */
-    INSTALL_GHOST_OS: 'install_ghost_os',
-    /** Stop the running GhostOS manager. */
-    STOP_GHOST_OS: 'stop_ghost_os',
-    /** Report current {@link GhostOsStatus}. */
-    CHECK_GHOST_OS_STATUS: 'check_ghost_os_status',
+const CUA_DRIVER_TAURI_COMMANDS = {
+    /** Download + install the pinned Cua Driver binary. */
+    INSTALL: 'install_cua_driver',
+    /** Report current {@link CuaDriverStatus}. */
+    CHECK_STATUS: 'check_cua_driver_status',
+    /** Whether Cowork can run on this desktop session, and why not if it can't. */
+    SUPPORT: 'cua_driver_support',
+    /** Stop the driver's MCP process. */
+    STOP: 'cua_driver_stop',
 };
 /**
  * Tauri command strings exposed by `tauri-plugin-macos-permissions`
@@ -254835,12 +254854,7 @@ const MACOS_PERMISSIONS_COMMANDS = {
     CHECK_ACCESSIBILITY: 'plugin:macos-permissions|check_accessibility_permission',
     REQUEST_ACCESSIBILITY: 'plugin:macos-permissions|request_accessibility_permission',
     CHECK_SCREEN_RECORDING: 'plugin:macos-permissions|check_screen_recording_permission',
-    REQUEST_SCREEN_RECORDING: 'plugin:macos-permissions|request_screen_recording_permission',
-    CHECK_INPUT_MONITORING: 'plugin:macos-permissions|check_input_monitoring_permission',
-    REQUEST_INPUT_MONITORING: 'plugin:macos-permissions|request_input_monitoring_permission',
-    CHECK_FULL_DISK_ACCESS: 'plugin:macos-permissions|check_full_disk_access_permission',
-    REQUEST_FULL_DISK_ACCESS: 'plugin:macos-permissions|request_full_disk_access_permission',
-};
+    REQUEST_SCREEN_RECORDING: 'plugin:macos-permissions|request_screen_recording_permission'};
 
 /**
  * Dynamically import Tauri APIs to avoid SSR issues
@@ -254907,16 +254921,26 @@ function useTauri() {
     };
 }
 
-const IS_SERVER = typeof window === 'undefined';
+// Evaluated per call, not once at module load. A module-level constant is
+// captured before any test can influence it, which left every server-side guard
+// below permanently unreachable — and therefore unverifiable — in a jsdom runner.
+const isServer = () => typeof window === 'undefined';
 /**
  * A simplified useLocalStorage hook for persisting state to localStorage
  * with SSR safety.
  */
 function useLocalStorage(key, initialValue) {
+    // The initial value is captured, not tracked. Depending on its identity meant
+    // an inline literal — `useLocalStorage('k', { n: 0 })`, the ordinary React
+    // idiom — gave `getInitialValue` a new identity every render, which re-ran the
+    // key-change effect below, which called `setStoredValue` with a fresh object,
+    // which re-rendered… an infinite loop that ends in an out-of-memory crash.
+    // Existing callers only escaped it by happening to pass module constants.
+    const initialRef = useRef(initialValue);
     // Get the initial value
     const getInitialValue = useCallback(() => {
-        const initial = initialValue instanceof Function ? initialValue() : initialValue;
-        if (IS_SERVER) {
+        const initial = initialRef.current instanceof Function ? initialRef.current() : initialRef.current;
+        if (isServer()) {
             return initial;
         }
         try {
@@ -254930,118 +254954,204 @@ function useLocalStorage(key, initialValue) {
             console.warn(`Error reading localStorage key "${key}":`, error);
             return initial;
         }
-    }, [key, initialValue]);
+    }, [key]);
     const [storedValue, setStoredValue] = useState(getInitialValue);
     // Update stored value when key changes
     useEffect(() => {
         setStoredValue(getInitialValue());
     }, [key, getInitialValue]);
-    // Persist to localStorage
+    // Latest value, readable synchronously. Two writes in the same tick would
+    // otherwise both resolve their updater against the render's snapshot, so the
+    // second silently reverts the first (a status change followed by a log append
+    // losing the status, for instance).
+    const storedRef = useRef(storedValue);
+    storedRef.current = storedValue;
+    // Persist to localStorage.
+    //
+    // Depends on `key` ALONE, deliberately. This used to close over `storedValue`,
+    // which gave the setter a new identity on every value change — and anything
+    // built on it (a `useCallback` logger, say) churned too. An effect listing
+    // those in its dependencies then re-ran on every state change; where such an
+    // effect subscribes asynchronously, its cleanup runs before the subscription
+    // resolves and unregisters nothing, so each pass leaks another live listener
+    // and one event fans out into two, four, eight… until the webview locks up.
     const setValue = useCallback((value) => {
-        if (IS_SERVER) {
+        if (isServer()) {
             console.warn(`Tried setting localStorage key "${key}" even though environment is not a client`);
             return;
         }
         try {
-            const valueToStore = value instanceof Function ? value(storedValue) : value;
+            const valueToStore = value instanceof Function ? value(storedRef.current) : value;
+            storedRef.current = valueToStore;
             setStoredValue(valueToStore);
             window.localStorage.setItem(key, JSON.stringify(valueToStore));
         }
         catch (error) {
             console.warn(`Error setting localStorage key "${key}":`, error);
         }
-    }, [key, storedValue]);
+    }, [key]);
     // Remove from localStorage
     const removeValue = useCallback(() => {
-        if (IS_SERVER) {
+        if (isServer()) {
             console.warn(`Tried removing localStorage key "${key}" even though environment is not a client`);
             return;
         }
         try {
-            const initial = initialValue instanceof Function ? initialValue() : initialValue;
+            const initial = initialRef.current instanceof Function ? initialRef.current() : initialRef.current;
             window.localStorage.removeItem(key);
             setStoredValue(initial);
         }
         catch (error) {
             console.warn(`Error removing localStorage key "${key}":`, error);
         }
-    }, [key, initialValue]);
+        // `[key]` alone, for the same reason as getInitialValue above — otherwise an
+        // inline initial value churns this callback's identity on every render.
+    }, [key]);
     return [storedValue, setValue, removeValue];
 }
 
-const LOCAL_STORAGE_KEY$1 = 'ghost_os_install_state';
+const LOCAL_STORAGE_KEY$1 = 'cua_driver_install_state';
 /**
- * Manage installing & setting up GhostOS (https://github.com/ghostwright/ghost-os)
- * via the Tauri host. This is the self-contained backing hook for the System
- * Control card and deliberately mirrors `useModelDownload`:
+ * Manage installing the Cua Driver (https://github.com/trycua/cua) via the Tauri
+ * host. This is the self-contained backing hook for the Cowork card and
+ * deliberately mirrors `useModelDownload`:
  *
- * - checks GhostOS install/run status through the host
- * - installs/sets up GhostOS with real-time progress + logs
+ * - checks driver install status AND whether this desktop session is supported
+ * - downloads/installs the pinned driver with real-time progress + logs
  * - persists state across app restarts
  *
  * Outside the desktop (Tauri) app every action is a no-op and `isAvailable` is
- * false, so the card hides itself.
+ * false, so the card hides itself. Inside it, `isSupported` is what gates the
+ * Cowork toggle — the driver has no proven behaviour on every Linux session.
+ *
+ * **Consent is the host application's job, not this hook's.** Enabling Cowork
+ * hands an LLM synthetic input, screen capture, and — through the driver's
+ * `--grant existing-profile` — the user's logged-in browser sessions. The driver
+ * renders no consent UI of its own, and neither does the `InsideButtons` toggle
+ * in this package. A host must explain that and get consent before calling
+ * `requestDriverPermissions()`.
  */
-function useGhostOs() {
+function useCuaDriver() {
     const { isAvailable, invoke, listen } = useTauri();
-    const [state, setState] = useLocalStorage(LOCAL_STORAGE_KEY$1, initialGhostOsInstallState);
+    const [state, setState] = useLocalStorage(LOCAL_STORAGE_KEY$1, initialCuaDriverInstallState);
     const [status, setStatus] = useState(null);
-    // macOS Accessibility permission, which GhostOS needs to control the device.
-    // null = unknown/not-yet-checked or unsupported (non-macOS / plugin absent).
+    // The two macOS grants the driver needs: Accessibility to post synthetic input,
+    // Screen Recording because get_window_state always captures alongside the tree.
+    //
+    // `null` is a third state and a meaningful one: the commands exist only on
+    // macOS, so elsewhere the invoke throws and the answer is "not applicable"
+    // rather than "denied". Callers must branch on `=== false`, never on falsy —
+    // treating null as denied would make Cowork unusable on Linux and Windows.
     const [accessibilityPermission, setAccessibilityPermission] = useState(null);
-    const unlistenRefs = useRef([]);
+    const [screenRecordingPermission, setScreenRecordingPermission] = useState(null);
     const hasCheckedStatus = useRef(false);
     /**
-     * Refresh the macOS Accessibility permission via tauri-plugin-macos-permissions.
-     * Independent of the GhostOS status check so a missing host command for one
-     * doesn't suppress the other. Stays null where unsupported.
+     * Read one permission. Checking never prompts (`AXIsProcessTrusted` /
+     * `CGPreflightScreenCaptureAccess`), which is what makes it safe to do on mount.
      */
-    const refreshAccessibilityPermission = useCallback(async () => {
-        if (!isAvailable)
-            return;
+    const checkPermission = useCallback(async (command) => {
         try {
-            const granted = await invoke(MACOS_PERMISSIONS_COMMANDS.CHECK_ACCESSIBILITY);
-            setAccessibilityPermission(granted);
+            return await invoke(command);
         }
         catch (error) {
-            // Plugin not registered or non-macOS host — leave permission unknown.
-            console.warn('[useGhostOs] Accessibility permission check unavailable:', error);
-            setAccessibilityPermission(null);
+            // Plugin not registered or non-macOS host — not applicable, not denied.
+            console.warn(`[useCuaDriver] ${command} unavailable:`, error);
+            return null;
         }
-    }, [isAvailable, invoke]);
+    }, [invoke]);
     /**
-     * Open the Accessibility pane / prompt so the user can grant permission, then
-     * re-check (the grant happens in System Settings, so we refresh after).
+     * Refresh both permissions. Independent of the driver status check so a missing
+     * host command for one doesn't suppress the other.
      */
-    const requestAccessibilityPermission = useCallback(async () => {
+    const refreshPermissions = useCallback(async () => {
         if (!isAvailable)
             return;
-        try {
-            await invoke(MACOS_PERMISSIONS_COMMANDS.REQUEST_ACCESSIBILITY);
-        }
-        catch (error) {
-            console.error('[useGhostOs] Failed to request accessibility permission:', error);
+        const [accessibility, screenRecording] = await Promise.all([
+            checkPermission(MACOS_PERMISSIONS_COMMANDS.CHECK_ACCESSIBILITY),
+            checkPermission(MACOS_PERMISSIONS_COMMANDS.CHECK_SCREEN_RECORDING),
+        ]);
+        setAccessibilityPermission(accessibility);
+        setScreenRecordingPermission(screenRecording);
+    }, [isAvailable, checkPermission]);
+    /**
+     * Ask for whichever grants are missing, then report what is actually held.
+     *
+     * **Prompts the user, so never call this from an effect** — it belongs to an
+     * explicit action (switching Cowork on), not to mounting a component. The OS
+     * prompt is not a consent step: it asks for a macOS grant, not for permission
+     * to read the screen and act as the user. Explain that first (see the hook
+     * docblock) — this package does not.
+     *
+     * Returns the post-request values rather than leaving the caller to read state:
+     * a `setState` in this tick is not visible to the caller that awaited us, and
+     * that caller has to decide right now whether to proceed.
+     *
+     * Note the values can still be `false` immediately after a successful grant —
+     * `CGRequestScreenCaptureAccess` returns before the grant takes effect, which
+     * on macOS usually needs an app restart. Copy shown to the user must say so.
+     */
+    const requestDriverPermissions = useCallback(async () => {
+        if (!isAvailable)
+            return { accessibility: null, screenRecording: null };
+        const pairs = [
+            [
+                MACOS_PERMISSIONS_COMMANDS.CHECK_ACCESSIBILITY,
+                MACOS_PERMISSIONS_COMMANDS.REQUEST_ACCESSIBILITY,
+            ],
+            [
+                MACOS_PERMISSIONS_COMMANDS.CHECK_SCREEN_RECORDING,
+                MACOS_PERMISSIONS_COMMANDS.REQUEST_SCREEN_RECORDING,
+            ],
+        ];
+        for (const [check, request] of pairs) {
+            // Only prompt for what is actually missing — re-requesting a held grant
+            // just reopens System Settings for no reason.
+            if ((await checkPermission(check)) !== false)
+                continue;
+            try {
+                await invoke(request);
+            }
+            catch (error) {
+                console.error(`[useCuaDriver] ${request} failed:`, error);
+            }
         }
-        await refreshAccessibilityPermission();
-    }, [isAvailable, invoke, refreshAccessibilityPermission]);
-    const addLog = useCallback((log) => {
+        const [accessibility, screenRecording] = await Promise.all([
+            checkPermission(MACOS_PERMISSIONS_COMMANDS.CHECK_ACCESSIBILITY),
+            checkPermission(MACOS_PERMISSIONS_COMMANDS.CHECK_SCREEN_RECORDING),
+        ]);
+        setAccessibilityPermission(accessibility);
+        setScreenRecordingPermission(screenRecording);
+        return { accessibility, screenRecording };
+    }, [isAvailable, invoke, checkPermission]);
+    /**
+     * Append a log line, optionally in the SAME update as other state changes.
+     *
+     * The `patch` argument is not a convenience: `setState` here is backed by
+     * `useLocalStorage`, whose write + re-read means a log appended straight after
+     * a status change can be computed from the pre-change snapshot and silently
+     * revert it. That is how a failed install used to end up displayed as
+     * "completed" with the error only visible down in the log pane. Anything that
+     * sets status AND logs must do both in one update.
+     */
+    const addLog = useCallback((log, patch) => {
         setState((prev) => ({
             ...prev,
+            ...patch,
             logs: [...prev.logs.slice(-99), log],
             lastUpdated: new Date().toISOString(),
         }));
     }, [setState]);
     /**
-     * Query GhostOS status from the host.
+     * Query driver install status + session support from the host.
      */
     const checkStatus = useCallback(async () => {
         if (!isAvailable)
             return;
-        // Refresh the accessibility permission alongside install status (independent).
-        refreshAccessibilityPermission();
+        // Refresh both permissions alongside install status (independent, no prompt).
+        refreshPermissions();
         try {
             setState((prev) => ({ ...prev, status: 'checking' }));
-            const result = await invoke(GHOST_OS_TAURI_COMMANDS.CHECK_GHOST_OS_STATUS);
+            const result = await invoke(CUA_DRIVER_TAURI_COMMANDS.CHECK_STATUS);
             setStatus(result);
             setState((prev) => ({
                 ...prev,
@@ -255051,13 +255161,13 @@ function useGhostOs() {
             }));
         }
         catch (error) {
-            console.error('[useGhostOs] Failed to check status:', error);
+            console.error('[useCuaDriver] Failed to check status:', error);
             setState((prev) => ({ ...prev, status: 'idle' }));
         }
-    }, [isAvailable, invoke, setState, refreshAccessibilityPermission]);
+    }, [isAvailable, invoke, setState, refreshPermissions]);
     /**
-     * Install and set up GhostOS. The host clones the repo + runs setup and emits
-     * progress/log/status events along the way.
+     * Download + install the pinned driver. The host emits progress/log events
+     * along the way, and refuses up front on an unsupported desktop session.
      */
     const install = useCallback(async () => {
         if (!isAvailable)
@@ -255076,64 +255186,73 @@ function useGhostOs() {
                 level: 'info',
                 message: 'Starting setup…',
             });
-            const result = await invoke(GHOST_OS_TAURI_COMMANDS.INSTALL_GHOST_OS);
+            const result = await invoke(CUA_DRIVER_TAURI_COMMANDS.INSTALL);
             addLog({
                 timestamp: new Date().toISOString(),
                 level: 'info',
                 message: typeof result === 'string' && result ? result : 'Setup complete',
-            });
-            setState((prev) => ({
-                ...prev,
+            }, {
                 status: 'completed',
                 progress: 100,
                 message: 'Your assistant is ready',
-                lastUpdated: new Date().toISOString(),
-            }));
+            });
             await checkStatus();
         }
         catch (error) {
             const message = error instanceof Error ? error.message : String(error);
-            setState((prev) => ({
-                ...prev,
-                status: 'error',
-                error: message,
-                message: 'Setup didn’t finish',
-                lastUpdated: new Date().toISOString(),
-            }));
             addLog({
                 timestamp: new Date().toISOString(),
                 level: 'error',
                 message: `Install failed: ${message}`,
-            });
+            }, { status: 'error', error: message, message: 'Setup didn’t finish' });
         }
     }, [isAvailable, invoke, addLog, checkStatus, setState]);
     /**
-     * Stop the running GhostOS manager.
+     * Stop the driver's MCP process. The host announces the exit, which makes the
+     * chat layer drop its cached MCP session and reconnect on the next turn.
      */
     const stop = useCallback(async () => {
         if (!isAvailable)
             return;
         try {
-            await invoke(GHOST_OS_TAURI_COMMANDS.STOP_GHOST_OS);
+            await invoke(CUA_DRIVER_TAURI_COMMANDS.STOP);
             await checkStatus();
         }
         catch (error) {
-            console.error('[useGhostOs] Failed to stop GhostOS:', error);
+            console.error('[useCuaDriver] Failed to stop the driver:', error);
         }
     }, [isAvailable, invoke, checkStatus]);
     /**
      * Reset the install state (for retrying after an error).
      */
     const resetState = useCallback(() => {
-        setState(initialGhostOsInstallState);
+        setState(initialCuaDriverInstallState);
     }, [setState]);
+    // Latest handlers, read at event time. Keeping them OUT of the effect's
+    // dependencies is the point: anything derived from `setState` can change
+    // identity as state moves, and re-subscribing per state change is what turned
+    // a handful of install events into a runaway cascade.
+    const handlersRef = useRef({ addLog, setState });
+    handlersRef.current = { addLog, setState };
     // Wire up host event listeners (progress / logs / status).
     useEffect(() => {
         if (!isAvailable)
             return;
+        // `listen()` is async, so a teardown can land before the subscription
+        // resolves. Registering the handle unconditionally would leave a live
+        // listener behind with nothing holding its unsubscribe — the leak that made
+        // one install log event fan out and freeze the webview for good.
+        let cancelled = false;
+        const handles = [];
+        const track = (unlisten) => {
+            if (cancelled)
+                unlisten();
+            else
+                handles.push(unlisten);
+        };
         const setupListeners = async () => {
             try {
-                const unlistenProgress = await listen(GHOST_OS_TAURI_EVENTS.INSTALL_PROGRESS, (payload) => {
+                track(await listen(CUA_DRIVER_TAURI_EVENTS.INSTALL_PROGRESS, (payload) => {
                     const nextStatus = payload.status === 'completed'
                         ? 'completed'
                         : payload.status === 'cancelled'
@@ -255141,30 +255260,28 @@ function useGhostOs() {
                             : payload.status === 'error'
                                 ? 'error'
                                 : 'installing';
-                    setState((prev) => ({
+                    handlersRef.current.setState((prev) => ({
                         ...prev,
                         status: nextStatus,
                         progress: payload.percentage,
                         message: payload.message,
                         lastUpdated: new Date().toISOString(),
                     }));
-                });
-                unlistenRefs.current.push(unlistenProgress);
-                const unlistenLogs = await listen(GHOST_OS_TAURI_EVENTS.INSTALLATION_LOG, addLog);
-                unlistenRefs.current.push(unlistenLogs);
-                const unlistenStatus = await listen(GHOST_OS_TAURI_EVENTS.STATUS, setStatus);
-                unlistenRefs.current.push(unlistenStatus);
+                }));
+                track(await listen(CUA_DRIVER_TAURI_EVENTS.INSTALLATION_LOG, (log) => handlersRef.current.addLog(log)));
+                track(await listen(CUA_DRIVER_TAURI_EVENTS.STATUS, setStatus));
             }
             catch (error) {
-                console.error('[useGhostOs] Failed to setup event listeners:', error);
+                console.error('[useCuaDriver] Failed to setup event listeners:', error);
             }
         };
         setupListeners();
         return () => {
-            unlistenRefs.current.forEach((unlisten) => unlisten());
-            unlistenRefs.current = [];
+            cancelled = true;
+            handles.splice(0).forEach((unlisten) => unlisten());
         };
-    }, [isAvailable, listen, setState, addLog]);
+        // Only re-subscribe if the host itself changes — never on state.
+    }, [isAvailable, listen]);
     // Check status once on mount (in the desktop app).
     useEffect(() => {
         if (!isAvailable || hasCheckedStatus.current)
@@ -255174,40 +255291,65 @@ function useGhostOs() {
     }, [isAvailable, checkStatus]);
     // Only expose the feature as available inside the desktop (Tauri) app.
     const finalIsAvailable = isAvailable && isTauriApp$1();
+    // Deliberately `=== true`, not `?? true`: until the first status check lands
+    // we do not know whether this desktop session is one the driver can drive, and
+    // offering Cowork optimistically would show the toggle to (say) a KDE user for
+    // a beat before snatching it away. One IPC round-trip on mount is cheaper than
+    // that flicker, and errs towards not promising what we cannot deliver.
+    const isSupported = (status === null || status === void 0 ? void 0 : status.supported) === true;
+    const unsupportedReason = (status === null || status === void 0 ? void 0 : status.supported) === false ? status.reason : undefined;
     return {
         isAvailable: finalIsAvailable,
+        /** Session support — gate the Cowork toggle on this, not on `isAvailable`. */
+        isSupported,
+        /** Machine-readable code the UI maps to a translated explanation. */
+        unsupportedReason,
         state,
         status,
         accessibilityPermission,
+        screenRecordingPermission,
         install,
         stop,
         checkStatus,
         resetState,
-        requestAccessibilityPermission,
+        requestDriverPermissions,
     };
 }
 
-// Cowork is macOS-only in prod; the env flag bypasses the OS check so the
-// toggle can be exercised on Linux/Windows desktop builds during testing.
-const isMacOS = () => {
-    if (typeof navigator === 'undefined')
-        return false;
-    return /mac/i.test(navigator.userAgent || '');
-};
-const allowNonMacOSCowork = () => process.env.NEXT_PUBLIC_ALLOW_NON_MACOS_COMPUTER_USE_TOGGLE === 'true';
 // 14GB floor per spec; modelSupportsCowork gates size > gb, so a model of
 // exactly 14GB is also off (no 14.0GB model in the catalog). Only the local-model
 // backend needs this; the remote AI has no size requirement.
 const COWORK_MIN_MODEL_GB = 14;
 const InsideButtons = ({ activeOptions, onOptionClick, deepResearch, studyMode, artifactsEnabled, containerWidth, disabled = false, onOpenPromptGallery, embedMode = false, promptsIsEnabled = false, memoryEnabled = false, mentorId, tenantKey, username, }) => {
     const t = useT();
-    // Cowork = the Tauri GhostOS assistant. GhostOS runs the tools on-device;
+    // Cowork = the Tauri cua-driver assistant. The driver runs the tools on-device;
     // the "brain" is EITHER a large local model (Local Models / Ollama) OR the
-    // remote AI (DM OpenAI-compatible endpoint), whichever is set up. useGhostOs
+    // remote AI (DM OpenAI-compatible endpoint), whichever is set up. useCuaDriver
     // handles install/stop; the localStorage pref (isCoworkEnabled) is read
     // by the chat hook to route the turn. Reads the pref on mount.
     // Local state is `coworkOn` so it doesn't shadow the imported setCoworkEnabled.
-    const ghostOs = useGhostOs();
+    //
+    // NOTE — this toggle is deliberately UNGATED: it explains nothing and requests
+    // no OS permission. Enabling Cowork gives an LLM synthetic input, screen
+    // capture, and the user's logged-in browser sessions (the driver is spawned
+    // with `--grant existing-profile`). A host that wants a consent step and the
+    // macOS grants must build them and call `useCuaDriver().requestDriverPermissions()`
+    // itself — the OS app's fork of this component does exactly that. See the
+    // useCuaDriver docblock.
+    // The host reports a machine-readable code; never render it raw.
+    const unsupportedCoworkReason = (reason) => {
+        switch (reason) {
+            case 'kde_unproven':
+                return t('chatInputFormInsideButtons.coworkUnsupportedKde');
+            case 'gnome_helper_missing':
+                return t('chatInputFormInsideButtons.coworkUnsupportedGnomeHelper');
+            case 'unsupported_os':
+                return t('chatInputFormInsideButtons.coworkUnsupportedOs');
+            default:
+                return t('chatInputFormInsideButtons.coworkUnsupportedSession');
+        }
+    };
+    const ghostOs = useCuaDriver();
     const [coworkOn, setCoworkOn] = useState(isCoworkEnabled);
     const toggleCowork = () => {
         const next = !coworkOn;
@@ -255218,8 +255360,7 @@ const InsideButtons = ({ activeOptions, onOptionClick, deepResearch, studyMode,
         // `disabled` when the user lacks the mentor `#chat` permission — see
         // chat-input-form's isChatDisabledByRbac.)
         if (next) {
-            const localReady = isLocalLLMEnabled() &&
-                modelSupportsCowork(getLocalLLMModel(), COWORK_MIN_MODEL_GB);
+            const localReady = isLocalLLMEnabled() && modelSupportsCowork(getLocalLLMModel(), COWORK_MIN_MODEL_GB);
             if (!localReady && !hasRemoteAiConfig()) {
                 toast.warning(isLocalLLMEnabled()
                     ? t('chatInputFormInsideButtons.coworkModelTooSmall')
@@ -255283,7 +255424,15 @@ const InsideButtons = ({ activeOptions, onOptionClick, deepResearch, studyMode,
             icon: jsx(Monitor, { className: "h-4 w-4" }),
             isActive: coworkOn,
             action: toggleCowork,
-            isEnabled: ghostOs.isAvailable && (isMacOS() || allowNonMacOSCowork()),
+            // Cowork used to be macOS-only because GhostOS was. The Cua Driver runs
+            // on Windows, macOS and Linux — but not on every Linux session, so an
+            // unsupported one renders the pill DISABLED with the reason rather than
+            // hiding it. The chatbox is Cowork's only surface: hide it and a KDE user
+            // is left with no way to find out why the feature is missing.
+            isEnabled: ghostOs.isAvailable,
+            disabledReason: ghostOs.isSupported
+                ? undefined
+                : unsupportedCoworkReason(ghostOs.unsupportedReason),
         },
     ].filter((item) => item.isEnabled);
     // Get visible inside buttons based on screen size
@@ -255321,7 +255470,7 @@ const InsideButtons = ({ activeOptions, onOptionClick, deepResearch, studyMode,
                 if (button.name === 'Memory') {
                     return (jsx(MemoryButton, { mentorId: mentorId, tenantKey: tenantKey, username: username }, button.name));
                 }
-                return (jsx("div", { className: "relative", children: jsxs(Button$1, { variant: "ghost", size: "sm", type: "button", disabled: disabled, className: `flex h-8 items-center gap-1.5 rounded-lg px-2 text-sm transition-all duration-200 disabled:cursor-not-allowed disabled:opacity-50 ${button.isActive
+                return (jsx("div", { className: "relative", children: jsxs(Button$1, { variant: "ghost", size: "sm", type: "button", disabled: disabled || !!button.disabledReason, title: button.disabledReason, className: `flex h-8 items-center gap-1.5 rounded-lg px-2 text-sm transition-all duration-200 disabled:cursor-not-allowed disabled:opacity-50 ${button.isActive
                             ? 'border border-[#D0E0FF] bg-[#F5F8FF] text-[#38A1E5]'
                             : 'text-gray-600 hover:border hover:border-[#D0E0FF] hover:bg-[#F5F8FF]'}`, onClick: (e) => {
                             e.preventDefault();