Fix various Linux bugs around GNOME Shell, improve Linux doctor checks, misc fixes (#23)

Author: brandonskiser

apps/dashboard/src/App.tsx

@@ -240,20 +240,26 @@ const useNavData = () => {
 };
 
 function Layout() {
+  const [onboardingComplete] = useLocalStateZodDefault(
+    "desktop.completedOnboarding",
+    z.boolean(),
+    false,
+  );
   const platformInfo = usePlatformInfo();
   const [accessibilityCheck] = useAccessibilityCheck();
   const [dotfilesCheck] = useDotfilesCheck();
   const [gnomeExtensionCheck] = useGnomeExtensionCheck();
   const navData = useNavData();
   const error =
-    accessibilityCheck === false ||
-    dotfilesCheck === false ||
-    (platformInfo &&
-      matchesPlatformRestrictions(
-        platformInfo,
-        gnomeExtensionInstallCheck.platformRestrictions,
-      ) &&
-      gnomeExtensionCheck === false);
+    onboardingComplete &&
+    (accessibilityCheck === false ||
+      dotfilesCheck === false ||
+      (platformInfo &&
+        matchesPlatformRestrictions(
+          platformInfo,
+          gnomeExtensionInstallCheck.platformRestrictions,
+        ) &&
+        gnomeExtensionCheck === false));
 
   // eslint-disable-next-line
   const [notifCount, _] = useLocalStateZodDefault(

apps/dashboard/src/components/installs/modal/login/index.tsx

@@ -27,6 +27,14 @@ export default function LoginModal({ next }: { next: () => void }) {
 
   // used for pkce
   const [currAuthRequestId, setAuthRequestId] = useAuthRequest();
+  const [pkceTimedOut, setPkceTimedOut] = useState(false);
+  useEffect(() => {
+    if (pkceTimedOut) return;
+    if (loginMethod === "pkce" && loginState === "loading") {
+      const timer = setTimeout(() => setPkceTimedOut(true), 4000);
+      return () => clearTimeout(timer);
+    }
+  }, [loginMethod, loginState, pkceTimedOut]);
 
   // used for device code
   const [loginCode, setLoginCode] = useState<string | null>(null);
@@ -44,6 +52,12 @@ export default function LoginModal({ next }: { next: () => void }) {
   const auth = useAuth();
   const refreshAuth = useRefreshAuth();
 
+  useEffect(() => {
+    // Reset the auth request id so that we don't present the "OAuth cancelled" error
+    // to the user.
+    setAuthRequestId("");
+  }, [loginMethod]);
+
   async function handleLogin(startUrl?: string, region?: string) {
     if (loginMethod === "pkce") {
       handlePkceAuth(startUrl, region);
@@ -54,6 +68,7 @@ export default function LoginModal({ next }: { next: () => void }) {
 
   async function handlePkceAuth(issuerUrl?: string, region?: string) {
     setLoginState("loading");
+    setPkceTimedOut(false);
     setError(null);
     // We need to reset the auth request state before attempting, otherwise
     // an expected auth request cancellation will be presented to the user
@@ -72,9 +87,6 @@ export default function LoginModal({ next }: { next: () => void }) {
     setAuthRequestId(init.authRequestId);
 
     Native.open(init.url).catch((err) => {
-      // Reset the auth request id so that we don't present the "OAuth cancelled" error
-      // to the user.
-      setAuthRequestId("");
       console.error(err);
       setError(
         "Failed to open the browser. As an alternative, try logging in with device code.",
@@ -195,6 +207,21 @@ export default function LoginModal({ next }: { next: () => void }) {
             <p className="text-center w-80">
               Waiting for authentication in the browser to complete...
             </p>
+            {pkceTimedOut && (
+              <div className="text-center w-80">
+                <p>Browser not opening?</p>
+                <Button
+                  variant="ghost"
+                  className="h-auto p-1 px-2 hover:bg-white/20 hover:text-white italic"
+                  onClick={() => {
+                    setLoginMethod("deviceCode");
+                    setLoginState("not started");
+                  }}
+                >
+                  Try authenticating with device code
+                </Button>
+              </div>
+            )}
             <Button
               variant="glass"
               className="self-center w-32"

apps/dashboard/src/index.css

@@ -163,3 +163,10 @@
       #301673;
   }
 }
+
+/* Currently an issue with Linux webkit CSS variables */
+/* https://github.com/tailwindlabs/tailwindcss/issues/13844 */
+.backdrop-blur-lg {
+  backdrop-filter: blur(16px);
+  -webkit-backdrop-filter: blur(16px);
+}

build-config/buildspec-linux-ubuntu.yml

@@ -8,7 +8,7 @@ phases:
     run-as: root
     commands:
       - apt-get update
-      - apt-get install -y -qq build-essential pkg-config jq dpkg curl wget zsh zstd cmake clang libssl-dev libgtk-3-dev libayatana-appindicator3-dev librsvg2-dev libdbus-1-dev libwebkit2gtk-4.0-37 libwebkit2gtk-4.1-dev libjavascriptcoregtk-4.1-dev valac libibus-1.0-dev libglib2.0-dev sqlite3 libxdo-dev protobuf-compiler libfuse2 dpkg-sig
+      - apt-get install -y -qq build-essential pkg-config jq dpkg curl wget zsh zstd cmake clang libssl-dev libgtk-3-dev libayatana-appindicator3-dev librsvg2-dev libdbus-1-dev libwebkit2gtk-4.1-dev libjavascriptcoregtk-4.1-dev valac libibus-1.0-dev libglib2.0-dev sqlite3 libxdo-dev protobuf-compiler libfuse2 dpkg-sig
   pre_build:
     commands:
       - export HOME=/home/codebuild-user

crates/dbus/src/dbus/gnome_shell.rs

@@ -92,16 +92,29 @@ pub enum ExtensionState {
 
     /// The extension is loaded and in an error state.
     Errored,
+
+    // Unused
+    OutOfDate,
+    Downloading,
+    Initialized,
+    Deactivating,
+    Activating,
 }
 
 impl ExtensionState {
     fn from_u32(state: u32) -> Result<Self, ExtensionsError> {
         // This mapping is done just from observation, not sure if this is entirely correct in
         // practice.
+        // Reference: https://gitlab.gnome.org/GNOME/gnome-shell/-/blob/main/js/misc/extensionUtils.js?ref_type=heads#L15
         match state {
             1 => Ok(ExtensionState::Enabled),
             2 => Ok(ExtensionState::Disabled),
             3 => Ok(ExtensionState::Errored),
+            4 => Ok(ExtensionState::OutOfDate),
+            5 => Ok(ExtensionState::Downloading),
+            6 => Ok(ExtensionState::Initialized),
+            7 => Ok(ExtensionState::Deactivating),
+            8 => Ok(ExtensionState::Activating),
             _ => Err(ExtensionsError::UnknownState(state)),
         }
     }
@@ -112,6 +125,11 @@ impl ExtensionState {
             ExtensionState::Enabled => Some(1),
             ExtensionState::Disabled => Some(2),
             ExtensionState::Errored => Some(3),
+            ExtensionState::OutOfDate => Some(4),
+            ExtensionState::Downloading => Some(5),
+            ExtensionState::Initialized => Some(6),
+            ExtensionState::Deactivating => Some(7),
+            ExtensionState::Activating => Some(8),
         }
     }
 }
@@ -162,7 +180,6 @@ where
                 Ok(ExtensionInstallationStatus::Enabled)
             }
         },
-        ExtensionState::Errored => Ok(ExtensionInstallationStatus::Errored),
         ExtensionState::NotLoaded => {
             // This could mean the extension is *technically* installed but just not loaded into
             // gnome shell's js jit, or the extension literally is not installed.
@@ -199,6 +216,10 @@ where
 
             Ok(ExtensionInstallationStatus::NotInstalled)
         },
+        ExtensionState::Errored => Ok(ExtensionInstallationStatus::Errored),
+        // Currently not sure how to handle the other states as of yet, therefore default
+        // to assuming an error and requiring manual intervention by the user.
+        _ => Ok(ExtensionInstallationStatus::Errored),
     }
 }
 

crates/fig_desktop/src/install.rs

@@ -390,6 +390,7 @@ pub async fn initialize_fig_dir(env: &fig_os_shim::Env) -> anyhow::Result<()> {
 async fn run_linux_install(ctx: Arc<Context>, settings: Arc<fig_settings::Settings>, state: Arc<fig_settings::State>) {
     use dbus::gnome_shell::ShellExtensions;
     use fig_settings::State;
+    use fig_util::system_info::linux::get_display_server;
 
     // install binaries under home local bin
     if ctx.env().in_appimage() {
@@ -402,6 +403,24 @@ async fn run_linux_install(ctx: Arc<Context>, settings: Arc<fig_settings::Settin
         });
     }
 
+    // Important we log an error if we cannot detect the display server in use.
+    // If this isn't wayland or x11, the user will probably just see a blank screen.
+    match get_display_server(&ctx) {
+        Ok(_) => (),
+        Err(fig_util::Error::UnknownDisplayServer(server)) => {
+            error!(
+                "Unknown value set for XDG_SESSION_TYPE: {}. This must be set to x11 or wayland.",
+                server
+            );
+        },
+        Err(err) => {
+            error!(
+                "Unknown error occurred when detecting the display server: {:?}. Is XDG_SESSION_TYPE set to x11 or wayland?",
+                err
+            );
+        },
+    }
+
     // GNOME Shell Extension
     {
         let ctx_clone = Arc::clone(&ctx);
@@ -457,8 +476,21 @@ where
         bundled_gnome_extension_version_path,
         bundled_gnome_extension_zip_path,
     };
+    use fig_util::system_info::linux::{
+        DisplayServer,
+        get_display_server,
+    };
     use tracing::debug;
 
+    let display_server = get_display_server(ctx)?;
+    if display_server != DisplayServer::Wayland {
+        debug!(
+            "Detected non-Wayland display server: `{:?}`. Not installing the extension.",
+            display_server
+        );
+        return Ok(());
+    }
+
     if !state.get_bool_or("desktop.gnomeExtensionInstallationPermissionGranted", false) {
         debug!("Permission is not granted to install GNOME extension, doing nothing.");
         return Ok(());
@@ -961,6 +993,7 @@ echo "{binary_name} {version}"
                 .await
                 .unwrap()
                 .with_env_var("APPIMAGE", "1")
+                .with_env_var("XDG_SESSION_TYPE", "wayland")
                 .with_os(Os::Linux)
                 .with_running_processes(&[GNOME_SHELL_PROCESS_NAME])
                 .build_fake();
@@ -1017,6 +1050,38 @@ echo "{binary_name} {version}"
                 .unwrap();
             assert!(matches!(status, ExtensionInstallationStatus::NotInstalled));
         }
+
+        #[tokio::test]
+        async fn test_extension_not_installed_if_not_wayland() {
+            let ctx = Context::builder()
+                .with_test_home()
+                .await
+                .unwrap()
+                .with_env_var("APPIMAGE", "1")
+                .with_os(Os::Linux)
+                .with_running_processes(&[GNOME_SHELL_PROCESS_NAME])
+                .build_fake();
+            let shell_extensions = ShellExtensions::new_fake(Arc::downgrade(&ctx));
+            let extension_version = 1;
+            write_extension_bundle(
+                &ctx,
+                &shell_extensions.extension_uuid().await.unwrap(),
+                extension_version,
+            )
+            .await;
+            let state = State::from_slice(&[("desktop.gnomeExtensionInstallationPermissionGranted", true.into())]);
+
+            // When
+            install_gnome_shell_extension(&ctx, &shell_extensions, &state)
+                .await
+                .unwrap();
+
+            // Then
+            let status = get_extension_status(&ctx, &shell_extensions, Some(extension_version))
+                .await
+                .unwrap();
+            assert!(matches!(status, ExtensionInstallationStatus::NotInstalled));
+        }
     }
 
     #[cfg(target_os = "linux")]

crates/q_cli/src/cli/doctor/checks/linux.rs

@@ -66,6 +66,33 @@ pub async fn get_linux_context() -> eyre::Result<LinuxContext> {
     Ok(LinuxContext::new(ctx, shell_extensions))
 }
 
+pub struct DisplayServerCheck;
+
+#[async_trait]
+impl DoctorCheck<LinuxContext> for DisplayServerCheck {
+    fn name(&self) -> Cow<'static, str> {
+        "Display Server Check".into()
+    }
+
+    async fn get_type(&self, _: &LinuxContext, _: Platform) -> DoctorCheckType {
+        DoctorCheckType::NormalCheck
+    }
+
+    async fn check(&self, ctx: &LinuxContext) -> Result<(), DoctorError> {
+        match get_display_server(&ctx.ctx) {
+            Ok(_) => Ok(()),
+            Err(fig_util::Error::UnknownDisplayServer(server)) => Err(doctor_error!(
+                "Unknown value set for XDG_SESSION_TYPE: {}. This must be set to x11 or wayland.",
+                server
+            )),
+            Err(err) => Err(doctor_error!(
+                "Unknown error occurred when detecting the display server: {:?}. Is XDG_SESSION_TYPE set to x11 or wayland?",
+                err
+            )),
+        }
+    }
+}
+
 pub struct IBusEnvCheck;
 
 #[async_trait]
@@ -290,11 +317,19 @@ impl DoctorCheck<LinuxContext> for IBusRunningCheck {
                     // -r - replace current ibus-daemon, if running
                     // -x - execute XIM server
                     // -R - restarts other ibus subprocesses if they end
-                    let output = Command::new("ibus-daemon").arg("-drxR").output()?;
-                    if !output.status.success() {
-                        let stdout = String::from_utf8_lossy(&output.stdout);
-                        let stderr = String::from_utf8_lossy(&output.stderr);
-                        eyre::bail!("ibus-daemon launch failed:\nstdout: {stdout}\nstderr: {stderr}\n");
+                    match Command::new("ibus-daemon").arg("-drxR").output() {
+                        Ok(output) if !output.status.success() => {
+                            let stdout = String::from_utf8_lossy(&output.stdout);
+                            let stderr = String::from_utf8_lossy(&output.stderr);
+                            eyre::bail!("ibus-daemon launch failed:\nstdout: {stdout}\nstderr: {stderr}\n");
+                        },
+                        Err(err) if err.kind() == std::io::ErrorKind::NotFound => {
+                            eyre::bail!("Could not find ibus-daemon. Is ibus installed?");
+                        },
+                        Err(err) => {
+                            eyre::bail!("An unknown error occurred launching ibus-daemon: {:?}", err);
+                        }
+                        Ok(_) => ()
                     }
                     // Wait some time for ibus-daemon to launch.
                     std::thread::sleep(std::time::Duration::from_secs(1));

crates/q_cli/src/cli/doctor/mod.rs

@@ -2237,6 +2237,7 @@ pub async fn doctor_cli(all: bool, strict: bool) -> Result<ExitCode> {
         #[cfg(target_os = "linux")]
         {
             use checks::linux::{
+                DisplayServerCheck,
                 GnomeExtensionCheck,
                 IBusConnectionCheck,
                 IBusEnvCheck,
@@ -2249,6 +2250,7 @@ pub async fn doctor_cli(all: bool, strict: bool) -> Result<ExitCode> {
                 run_checks_with_context(
                     "Let's check Linux integrations",
                     vec![
+                        &DisplayServerCheck,
                         &IBusEnvCheck,
                         &GnomeExtensionCheck,
                         &IBusRunningCheck,