Fix tool bootstrap detection and macOS pane/fullscreen visuals

Author: tw93

assets/shell-integration/install_cli_tools.sh

@@ -43,26 +43,73 @@ ensure_homebrew_installation() {
 
 resolved_tool_path() {
 	local tool_name="$1"
-	command -v "$tool_name" 2>/dev/null || true
+	if command -v "$tool_name" >/dev/null 2>&1; then
+		command -v "$tool_name"
+		return 0
+	fi
+
+	for candidate in "/opt/homebrew/bin/$tool_name" "/usr/local/bin/$tool_name"; do
+		if [[ -x "$candidate" ]]; then
+			echo "$candidate"
+			return 0
+		fi
+	done
+
+	return 1
 }
 
 is_legacy_tool_active() {
 	local tool_name="$1"
 	local resolved
-	resolved="$(resolved_tool_path "$tool_name")"
+	resolved="$(resolved_tool_path "$tool_name" 2>/dev/null || true)"
 	[[ "$resolved" == "$USER_BIN_DIR/$tool_name" ]]
 }
 
+is_brew_formula_installed() {
+	local formula_name="$1"
+
+	if [[ -z "$BREW_BIN" ]]; then
+		BREW_BIN="$(resolve_brew_bin 2>/dev/null || true)"
+	fi
+
+	if [[ -z "$BREW_BIN" ]]; then
+		return 1
+	fi
+
+	"$BREW_BIN" list --formula --versions "$formula_name" >/dev/null 2>&1
+}
+
+should_install_formula() {
+	local tool_name="$1"
+	local formula_name="$2"
+	local allow_legacy="${3:-0}"
+
+	if resolved_tool_path "$tool_name" >/dev/null 2>&1; then
+		if [[ "$allow_legacy" == "1" ]] && is_legacy_tool_active "$tool_name"; then
+			return 0
+		fi
+		return 1
+	fi
+
+	# PATH can be minimal in non-interactive launch contexts.
+	# If brew already has this formula installed, skip reinstall.
+	if is_brew_formula_installed "$formula_name"; then
+		return 1
+	fi
+
+	return 0
+}
+
 collect_missing_tools() {
 	MISSING_TOOLS=()
 
-	if ! command -v starship >/dev/null 2>&1 || is_legacy_tool_active "starship"; then
+	if should_install_formula "starship" "starship" 1; then
 		MISSING_TOOLS+=("starship")
 	fi
-	if ! command -v delta >/dev/null 2>&1 || is_legacy_tool_active "delta"; then
+	if should_install_formula "delta" "git-delta" 1; then
 		MISSING_TOOLS+=("git-delta")
 	fi
-	if ! command -v lazygit >/dev/null 2>&1; then
+	if should_install_formula "lazygit" "lazygit" 0; then
 		MISSING_TOOLS+=("lazygit")
 	fi
 }

kaku-gui/src/termwindow/render/paint.rs

@@ -373,18 +373,19 @@ impl crate::TermWindow {
             if pos.is_active && num_panes > 1 {
                 let cell_width = self.render_metrics.cell_size.width as f32;
                 let cell_height = self.render_metrics.cell_size.height as f32;
-                let (padding_left, _padding_top) = self.padding_left_top();
+                let (padding_left, padding_top) = self.padding_left_top();
                 let border = self.get_os_border();
                 let tab_bar_height = if self.show_tab_bar {
                     self.tab_bar_pixel_height().unwrap_or(0.)
                 } else {
                     0.
                 };
-                let top_pixel_y = if self.config.tab_bar_at_bottom {
+                let top_bar_height = if self.config.tab_bar_at_bottom {
                     0.0
                 } else {
                     tab_bar_height
-                } + border.top.get() as f32;
+                };
+                let top_pixel_y = top_bar_height + padding_top + border.top.get() as f32;
 
                 let x = padding_left
                     + border.left.get() as f32
@@ -405,17 +406,22 @@ impl crate::TermWindow {
 
         // Draw dot indicator for the active pane when split
         if let Some((dot_x, dot_y, is_top_pane)) = active_pane_top_right {
-            let cell_height = self.render_metrics.cell_size.height as f32;
-            // Size and margin scale with the current font's cell height so the
-            // indicator looks consistent regardless of font size or display DPI.
-            let dot_size = (cell_height * 0.6).round();
+            const DOT_SIZE: f32 = 10.0;
             const DOT_ALPHA: f32 = 0.5;
-            // Top pane: 2.5 cells below the pane top (clears the tab bar).
-            // Lower panes: 3.5 cells below to stay clear of the split line.
+            const RIGHT_INSET: f32 = 3.0;
+            const TOP_PANE_MARGIN_WITH_TAB_BAR: f32 = 24.0;
+            const TOP_PANE_MARGIN_NO_TAB_BAR: f32 = 14.0;
+            const LOWER_PANE_MARGIN: f32 = 20.0;
+
+            let top_pane_margin = if self.show_tab_bar && !self.config.tab_bar_at_bottom {
+                TOP_PANE_MARGIN_WITH_TAB_BAR
+            } else {
+                TOP_PANE_MARGIN_NO_TAB_BAR
+            };
             let margin_top = if is_top_pane {
-                cell_height * 2.5
+                top_pane_margin
             } else {
-                cell_height * 3.5
+                LOWER_PANE_MARGIN
             };
             let dot_color = self.palette().cursor_bg.to_linear().mul_alpha(DOT_ALPHA);
 
@@ -431,10 +437,10 @@ impl crate::TermWindow {
             self.poly_quad(
                 &mut layers,
                 2,
-                euclid::point2(dot_x - dot_size, dot_y + margin_top),
+                euclid::point2(dot_x - DOT_SIZE - RIGHT_INSET, dot_y + margin_top),
                 CIRCLE_POLY,
                 1,
-                euclid::size2(dot_size, dot_size),
+                euclid::size2(DOT_SIZE, DOT_SIZE),
                 dot_color,
             )
             .context("active pane indicator")?;

window/src/os/macos/window.rs

@@ -64,8 +64,6 @@ const NSViewLayerContentsRedrawDuringViewResize: NSInteger = 2;
 const FULLSCREEN_ENTER_HIDE_CONTENT_MS: u64 = 30;
 const FULLSCREEN_EXIT_HIDE_CONTENT_MS: u64 = 20;
 const ZOOM_HIDE_CONTENT_MS: u64 = 20;
-const NATIVE_EXIT_HIDE_CONTENT_MS: u64 = 50;
-const NATIVE_EXIT_POST_HIDE_CONTENT_MS: u64 = 20;
 const MOVE_PERSIST_DELAY_SECS: f64 = 0.35;
 
 #[link(name = "CoreGraphics", kind = "framework")]
@@ -1343,15 +1341,9 @@ impl WindowOps for Window {
                     match view.native_fullscreen_target.get() {
                         // Enter fullscreen: keep hidden for whole transition to avoid text scale pop.
                         Some(true) => return true,
-                        // Exit fullscreen: reveal sooner so content comes back faster.
-                        Some(false) => {
-                            if let Some(until) = view.transition_hide_until.get() {
-                                if Instant::now() < until {
-                                    return true;
-                                }
-                                view.transition_hide_until.set(None);
-                            }
-                        }
+                        // Exit fullscreen: avoid showing a rectangular placeholder
+                        // during the restore animation.
+                        Some(false) => view.transition_hide_until.set(None),
                         None => return true,
                     }
                 }
@@ -1497,7 +1489,6 @@ impl WindowInner {
                     .native_fullscreen_transition_start
                     .set(Some(Instant::now()));
             }
-            self.arm_transition_content_hide(NATIVE_EXIT_HIDE_CONTENT_MS, "native_pre_exit", true);
             self.toggle_native_fullscreen();
             true
         } else {
@@ -2682,25 +2673,6 @@ impl WindowView {
         }
     }
 
-    fn schedule_transition_unhide_repaint(window_id: usize, duration_ms: u64) {
-        promise::spawn::spawn(async move {
-            async_io::Timer::after(Duration::from_millis(duration_ms)).await;
-            Connection::with_window_inner(window_id, move |inner| {
-                if let Some(window_view) = WindowView::get_this(unsafe { &**inner.view }) {
-                    let mut state = window_view.inner.borrow_mut();
-                    state.paint_throttled = false;
-                    state.invalidated = true;
-                    state.events.dispatch(WindowEvent::NeedRepaint);
-                }
-                unsafe {
-                    let _: () = msg_send![*inner.view, setNeedsDisplay: YES];
-                }
-                Ok(())
-            });
-        })
-        .detach();
-    }
-
     // Called by the inputContext manager when the IME processes events.
     // We need to translate the selector back into appropriate key
     // sequences
@@ -3814,21 +3786,9 @@ impl WindowView {
             this.native_fullscreen_transition_active.set(true);
             this.native_fullscreen_target.set(Some(false));
             this.native_fullscreen_transition_start.set(Some(now));
+            this.transition_hide_until.set(None);
             this.inner.borrow_mut().live_resizing = true;
 
-            // Native exit can be triggered by multiple entry points.
-            // Arm the same short hide window here so all paths stay consistent.
-            let should_arm_hide = this
-                .transition_hide_until
-                .get()
-                .map(|until| until <= now)
-                .unwrap_or(true);
-            if should_arm_hide {
-                this.transition_hide_until.set(Some(
-                    now + Duration::from_millis(NATIVE_EXIT_HIDE_CONTENT_MS),
-                ));
-            }
-
             if let Ok(mut inner) = this.inner.try_borrow_mut() {
                 inner.paint_throttled = false;
                 inner.invalidated = true;
@@ -3847,13 +3807,9 @@ impl WindowView {
     extern "C" fn did_exit_fullscreen(this: &mut Object, _sel: Sel, _notification: id) {
         let view_id = this as *mut Object;
         if let Some(this) = Self::get_this(this) {
-            let window_id = this.inner.borrow().window_id;
             this.native_fullscreen_transition_active.set(false);
             this.native_fullscreen_target.set(None);
-            this.transition_hide_until.set(Some(
-                Instant::now() + Duration::from_millis(NATIVE_EXIT_POST_HIDE_CONTENT_MS),
-            ));
-            Self::schedule_transition_unhide_repaint(window_id, NATIVE_EXIT_POST_HIDE_CONTENT_MS);
+            this.transition_hide_until.set(None);
             if let Ok(mut inner) = this.inner.try_borrow_mut() {
                 inner.live_resizing = true;
             }