update reservation for traffic lights width on macos tahoe

wavetermdev · sawka · Mar 14, 2026 · Mar 13, 2026 · Mar 13, 2026 · Mar 13, 2026
commit ca8979b39655cfebe699d0769f93c1059d617541
diff --git a/frontend/app/store/wshclientapi.ts b/frontend/app/store/wshclientapi.ts
@@ -618,6 +618,12 @@ export class RpcApiType {
         return client.wshRpcCall("listalleditableapps", null, opts);
     }
 
+    // command "macosversion" [call]
+    MacOSVersionCommand(client: WshClient, opts?: RpcOpts): Promise<string> {
+        if (this.mockClient) return this.mockClient.mockWshRpcCall(client, "macosversion", null, opts);
+        return client.wshRpcCall("macosversion", null, opts);
+    }
+
     // command "makedraftfromlocal" [call]
     MakeDraftFromLocalCommand(client: WshClient, data: CommandMakeDraftFromLocalData, opts?: RpcOpts): Promise<CommandMakeDraftFromLocalRtnData> {
         if (this.mockClient) return this.mockClient.mockWshRpcCall(client, "makedraftfromlocal", data, opts);

diff --git a/frontend/app/tab/tabbar.tsx b/frontend/app/tab/tabbar.tsx
@@ -7,6 +7,7 @@ import { TabRpcClient } from "@/app/store/wshrpcutil";
 import { useWaveEnv } from "@/app/waveenv/waveenv";
 import { WorkspaceLayoutModel } from "@/app/workspace/workspace-layout-model";
 import { deleteLayoutModelForTab } from "@/layout/index";
+import { isMacOSTahoeOrLater } from "@/util/platformutil";
 import { fireAndForget } from "@/util/util";
 import { useAtomValue } from "jotai";
 import { OverlayScrollbars } from "overlayscrollbars";
@@ -20,6 +21,9 @@ import { WorkspaceSwitcher } from "./workspaceswitcher";
 
 const TabDefaultWidth = 130;
 const TabMinWidth = 100;
+const MacOSTrafficLightsWidth = 74;
+const MacOSTahoeTrafficLightsWidth = 80;
+
 const OSOptions = {
     overflow: {
         x: "scroll",
@@ -636,10 +640,13 @@ const TabBar = memo(({ workspace, noTabs }: TabBarProps) => {
     // Calculate window drag left width based on platform and state
     let windowDragLeftWidth = 10;
     if (env.isMacOS() && !isFullScreen) {
+        const trafficLightsWidth = isMacOSTahoeOrLater()
+            ? MacOSTahoeTrafficLightsWidth
+            : MacOSTrafficLightsWidth;
         if (zoomFactor > 0) {
-            windowDragLeftWidth = 74 / zoomFactor;
+            windowDragLeftWidth = trafficLightsWidth / zoomFactor;
         } else {
-            windowDragLeftWidth = 74;
+            windowDragLeftWidth = trafficLightsWidth;
         }
     }
 
@@ -684,28 +691,32 @@ const TabBar = memo(({ workspace, noTabs }: TabBarProps) => {
                 <div
                     className="tabs-wrapper"
                     ref={tabsWrapperRef}
-                    style={{ width: `${tabsWrapperWidth}px`, ...(noTabs ? ({ WebkitAppRegion: "drag" } as React.CSSProperties) : {}) }}
+                    style={{
+                        width: `${tabsWrapperWidth}px`,
+                        ...(noTabs ? ({ WebkitAppRegion: "drag" } as React.CSSProperties) : {}),
+                    }}
                 >
-                    {!noTabs && tabIds.map((tabId, index) => {
-                        const isActive = activeTabId === tabId;
-                        const showDivider = index !== 0 && !isActive && index !== activeTabIndex + 1;
-                        return (
-                            <Tab
-                                key={tabId}
-                                ref={tabRefs.current[index]}
-                                id={tabId}
-                                showDivider={showDivider}
-                                onSelect={() => handleSelectTab(tabId)}
-                                active={isActive}
-                                onDragStart={(event) => handleDragStart(event, tabId, tabRefs.current[index])}
-                                onClose={(event) => handleCloseTab(event, tabId)}
-                                onLoaded={() => handleTabLoaded(tabId)}
-                                isDragging={draggingTab === tabId}
-                                tabWidth={tabWidthRef.current}
-                                isNew={tabId === newTabId}
-                            />
-                        );
-                    })}
+                    {!noTabs &&
+                        tabIds.map((tabId, index) => {
+                            const isActive = activeTabId === tabId;
+                            const showDivider = index !== 0 && !isActive && index !== activeTabIndex + 1;
+                            return (
+                                <Tab
+                                    key={tabId}
+                                    ref={tabRefs.current[index]}
+                                    id={tabId}
+                                    showDivider={showDivider}
+                                    onSelect={() => handleSelectTab(tabId)}
+                                    active={isActive}
+                                    onDragStart={(event) => handleDragStart(event, tabId, tabRefs.current[index])}
+                                    onClose={(event) => handleCloseTab(event, tabId)}
+                                    onLoaded={() => handleTabLoaded(tabId)}
+                                    isDragging={draggingTab === tabId}
+                                    tabWidth={tabWidthRef.current}
+                                    isNew={tabId === newTabId}
+                                />
+                            );
+                        })}
                 </div>
             </div>
             <button

diff --git a/frontend/app/tab/tabbarenv.ts b/frontend/app/tab/tabbarenv.ts
@@ -12,6 +12,10 @@ export type TabBarEnv = WaveEnvSubset<{
         installAppUpdate: WaveEnv["electron"]["installAppUpdate"];
     };
     rpc: {
+        ActivityCommand: WaveEnv["rpc"]["ActivityCommand"];
+        SetConfigCommand: WaveEnv["rpc"]["SetConfigCommand"];
+        SetMetaCommand: WaveEnv["rpc"]["SetMetaCommand"];
+        UpdateTabNameCommand: WaveEnv["rpc"]["UpdateTabNameCommand"];
         UpdateWorkspaceTabIdsCommand: WaveEnv["rpc"]["UpdateWorkspaceTabIdsCommand"];
     };
     atoms: {
@@ -24,7 +28,8 @@ export type TabBarEnv = WaveEnvSubset<{
         updaterStatusAtom: WaveEnv["atoms"]["updaterStatusAtom"];
     };
     wos: WaveEnv["wos"];
-    getSettingsKeyAtom: SettingsKeyAtomFnType<"app:hideaibutton" | "tab:confirmclose" | "window:showmenubar">;
+    getSettingsKeyAtom: SettingsKeyAtomFnType<"app:hideaibutton" | "app:tabbar" | "tab:confirmclose" | "window:showmenubar">;
+    showContextMenu: WaveEnv["showContextMenu"];
     mockSetWaveObj: WaveEnv["mockSetWaveObj"];
     isWindows: WaveEnv["isWindows"];
     isMacOS: WaveEnv["isMacOS"];

diff --git a/frontend/util/platformutil.ts b/frontend/util/platformutil.ts
@@ -1,15 +1,28 @@
-// Copyright 2025, Command Line Inc.
+// Copyright 2026, Command Line Inc.
 // SPDX-License-Identifier: Apache-2.0
 
 export const PlatformMacOS = "darwin";
 export const PlatformWindows = "win32";
 export const PlatformLinux = "linux";
 export let PLATFORM: NodeJS.Platform = PlatformMacOS;
+export let MacOSVersion: string = null;
 
 export function setPlatform(platform: NodeJS.Platform) {
     PLATFORM = platform;
 }
 
+export function setMacOSVersion(version: string) {
+    MacOSVersion = version;
+}
+
+export function isMacOSTahoeOrLater(): boolean {
+    if (!isMacOS() || MacOSVersion == null) {
+        return false;
+    }
+    const major = parseInt(MacOSVersion.split(".")[0], 10);
+    return major >= 16;
+}
+
 export function isMacOS(): boolean {
     return PLATFORM == PlatformMacOS;
 }

diff --git a/frontend/wave.ts b/frontend/wave.ts
@@ -32,6 +32,7 @@ import { activeTabIdAtom } from "@/store/tab-model";
 import * as WOS from "@/store/wos";
 import { loadFonts } from "@/util/fontutil";
 import { setKeyUtilPlatform } from "@/util/keyutil";
+import { isMacOS, setMacOSVersion } from "@/util/platformutil";
 import { createElement } from "react";
 import { createRoot } from "react-dom/client";
 
@@ -163,6 +164,10 @@ async function initWave(initOpts: WaveInitOpts) {
     await loadBadges();
     initGlobalWaveEventSubs(initOpts);
     subscribeToConnEvents();
+    if (isMacOS()) {
+        const macOSVersion = await RpcApi.MacOSVersionCommand(TabRpcClient);
+        setMacOSVersion(macOSVersion);
+    }
 
     // ensures client/window/workspace are loaded into the cache before rendering
     try {

diff --git a/pkg/wshrpc/wshclient/wshclient.go b/pkg/wshrpc/wshclient/wshclient.go
@@ -615,6 +615,12 @@ func ListAllEditableAppsCommand(w *wshutil.WshRpc, opts *wshrpc.RpcOpts) ([]wshr
 	return resp, err
 }
 
+// command "macosversion", wshserver.MacOSVersionCommand
+func MacOSVersionCommand(w *wshutil.WshRpc, opts *wshrpc.RpcOpts) (string, error) {
+	resp, err := sendRpcRequestCallHelper[string](w, "macosversion", nil, opts)
+	return resp, err
+}
+
 // command "makedraftfromlocal", wshserver.MakeDraftFromLocalCommand
 func MakeDraftFromLocalCommand(w *wshutil.WshRpc, data wshrpc.CommandMakeDraftFromLocalData, opts *wshrpc.RpcOpts) (*wshrpc.CommandMakeDraftFromLocalRtnData, error) {
 	resp, err := sendRpcRequestCallHelper[*wshrpc.CommandMakeDraftFromLocalRtnData](w, "makedraftfromlocal", data, opts)

diff --git a/pkg/wshrpc/wshrpctypes.go b/pkg/wshrpc/wshrpctypes.go
@@ -83,6 +83,7 @@ type WshRpcInterface interface {
 	DebugTermCommand(ctx context.Context, data CommandDebugTermData) (*CommandDebugTermRtnData, error)
 	BlocksListCommand(ctx context.Context, data BlocksListRequest) ([]BlocksListEntry, error)
 	WaveInfoCommand(ctx context.Context) (*WaveInfoData, error)
+	MacOSVersionCommand(ctx context.Context) (string, error)
 	WshActivityCommand(ct context.Context, data map[string]int) error
 	ActivityCommand(ctx context.Context, data ActivityUpdate) error
 	RecordTEventCommand(ctx context.Context, data telemetrydata.TEvent) error

diff --git a/pkg/wshrpc/wshserver/wshserver.go b/pkg/wshrpc/wshserver/wshserver.go
@@ -878,6 +878,10 @@ func (ws *WshServer) WaveInfoCommand(ctx context.Context) (*wshrpc.WaveInfoData,
 	}, nil
 }
 
+func (ws *WshServer) MacOSVersionCommand(ctx context.Context) (string, error) {
+	return wavebase.ClientMacOSVersion(), nil
+}
+
 // BlocksListCommand returns every block visible in the requested
 // scope (current workspace by default).
 func (ws *WshServer) BlocksListCommand(