Add configurable sidebar workspace font size

.github/workflows/ci.yml

@@ -678,7 +678,7 @@ jobs:
       - name: Build universal app (Release)
         run: |
           set -euo pipefail
-          xcodebuild -project cmux.xcodeproj -scheme cmux -configuration Release -derivedDataPath build-universal \
+          CMUX_SKIP_ZIG_BUILD=1 xcodebuild -project cmux.xcodeproj -scheme cmux -configuration Release -derivedDataPath build-universal \
             -destination 'generic/platform=macOS' \
             -clonedSourcePackagesDirPath .spm-cache \
             ARCHS="arm64 x86_64" \

CLI/CMUXCLI+Config.swift

@@ -20,6 +20,36 @@ extension CMUXCLI {
         switch subcommand {
         case "help":
             print(configUsage())
+        case "get":
+            guard args.count == 2, let key = canonicalFontSizeKey(args[1]) else {
+                throw CLIError(message: "Usage: cmux config get <sidebar-font-size|surface-tab-bar-font-size>")
+            }
+            try runConfigGetFontSize(forKey: key, jsonOutput: wantsJSON)
+        case "set":
+            guard args.count == 3, let key = canonicalFontSizeKey(args[1]) else {
+                throw CLIError(message: "Usage: cmux config set <sidebar-font-size|surface-tab-bar-font-size> <points>")
+            }
+            try runConfigSetFontSize(
+                forKey: key,
+                rawValue: args[2],
+                socketPath: socketPath,
+                explicitPassword: explicitPassword,
+                jsonOutput: wantsJSON
+            )
+        case CmuxGhosttyConfigSettingEditor.sidebarFontSizeKey, CmuxGhosttyConfigSettingEditor.surfaceTabBarFontSizeKey:
+            if args.count == 1 {
+                try runConfigGetFontSize(forKey: subcommand, jsonOutput: wantsJSON)
+            } else if args.count == 2 {
+                try runConfigSetFontSize(
+                    forKey: subcommand,
+                    rawValue: args[1],
+                    socketPath: socketPath,
+                    explicitPassword: explicitPassword,
+                    jsonOutput: wantsJSON
+                )
+            } else {
+                throw CLIError(message: "Usage: cmux config \(subcommand) [points]")
+            }
         case "path", "paths":
             guard args.count == 1 else {
                 throw CLIError(message: "Usage: cmux config path")
@@ -62,21 +92,32 @@ extension CMUXCLI {
     func configCommandDoesNotNeedSocket(_ commandArgs: [String]) -> Bool {
         let parsedArgs = docsSettingsArguments(commandArgs)
         let subcommand = parsedArgs.arguments.first?.lowercased() ?? "help"
+        if subcommand == "get" {
+            return true
+        }
+        if subcommand == CmuxGhosttyConfigSettingEditor.sidebarFontSizeKey
+            || subcommand == CmuxGhosttyConfigSettingEditor.surfaceTabBarFontSizeKey {
+            return parsedArgs.arguments.count == 1
+        }
         return hasHelpRequest(beforeSeparator: parsedArgs.head) ||
             ["help", "path", "paths", "docs", "documentation", "doctor", "check", "validate"].contains(subcommand)
     }
 
     func configUsage() -> String {
         return """
-        Usage: cmux config <doctor|check|validate|path|paths|docs|documentation|reload>
+        Usage: cmux config <doctor|check|validate|path|paths|docs|documentation|reload|get|set|sidebar-font-size|surface-tab-bar-font-size>
 
-        Inspect cmux.json, print configuration references, or reload the running app.
+        Inspect cmux.json, print configuration references, update selected Ghostty config keys, or reload the running app.
 
         Subcommands:
           doctor|check|validate [--path <path>]   Validate JSONC syntax for cmux config files.
           path|paths                              Print cmux.json paths, docs URL, and schema URL.
           docs|documentation                      Print the same output as `cmux docs settings`.
           reload                                  Reload Ghostty config + cmux.json and refresh terminals (alias for `cmux reload-config`).
+          get <key>                               Print sidebar-font-size or surface-tab-bar-font-size.
+          set <key> <points>                      Set sidebar-font-size (10-20 pt) or surface-tab-bar-font-size (8-24 pt), then reload if cmux is running.
+          sidebar-font-size [points]              Get or set the left sidebar text size.
+          surface-tab-bar-font-size [points]      Get or set the workspace tab bar text size.
 
         Config files:
           \(Self.primarySettingsDisplayPath)
@@ -89,6 +130,10 @@ extension CMUXCLI {
         Examples:
           cmux config doctor
           cmux config doctor --path .cmux/cmux.json
+          cmux config set sidebar-font-size 14
+          cmux config sidebar-font-size 12.5
+          cmux config set surface-tab-bar-font-size 13
+          cmux config surface-tab-bar-font-size 11
           cmux config reload
         """
     }
@@ -135,6 +180,191 @@ extension CMUXCLI {
         print("  cmux reload-config")
     }
 
+    /// Normalizes a user-supplied key to a supported editable font-size key, or nil if unsupported.
+    private func canonicalFontSizeKey(_ raw: String) -> String? {
+        switch raw.lowercased() {
+        case CmuxGhosttyConfigSettingEditor.sidebarFontSizeKey:
+            return CmuxGhosttyConfigSettingEditor.sidebarFontSizeKey
+        case CmuxGhosttyConfigSettingEditor.surfaceTabBarFontSizeKey:
+            return CmuxGhosttyConfigSettingEditor.surfaceTabBarFontSizeKey
+        default:
+            return nil
+        }
+    }
+
+    private func fontSizeConfig(
+        forKey key: String
+    ) -> (defaultValue: Double, clamp: (Double) -> Double, format: (Double) -> String, parse: (String) -> Double?)? {
+        switch key {
+        case CmuxGhosttyConfigSettingEditor.sidebarFontSizeKey:
+            return (
+                CmuxGhosttyConfigSettingEditor.defaultSidebarFontSize,
+                CmuxGhosttyConfigSettingEditor.clampedSidebarFontSize,
+                CmuxGhosttyConfigSettingEditor.formattedSidebarFontSize,
+                { CmuxGhosttyConfigSettingEditor.parsedSidebarFontSize(in: $0) }
+            )
+        case CmuxGhosttyConfigSettingEditor.surfaceTabBarFontSizeKey:
+            return (
+                CmuxGhosttyConfigSettingEditor.defaultSurfaceTabBarFontSize,
+                CmuxGhosttyConfigSettingEditor.clampedSurfaceTabBarFontSize,
+                CmuxGhosttyConfigSettingEditor.formattedSurfaceTabBarFontSize,
+                { CmuxGhosttyConfigSettingEditor.parsedSurfaceTabBarFontSize(in: $0) }
+            )
+        default:
+            return nil
+        }
+    }
+
+    private func runConfigGetFontSize(forKey key: String, jsonOutput: Bool) throws {
+        guard let descriptor = fontSizeConfig(forKey: key) else {
+            throw CLIError(message: "Unknown font size key '\(key)'")
+        }
+        let url = try cmuxGhosttyConfigURLForCLI()
+        let contents = (try? String(contentsOf: url, encoding: .utf8)) ?? ""
+        let configuredValue = descriptor.parse(contents)
+        let effectiveValue = configuredValue ?? descriptor.defaultValue
+        let formattedValue = descriptor.format(effectiveValue)
+
+        if jsonOutput {
+            var payload: [String: Any] = [
+                "key": key,
+                "value": effectiveValue,
+                "formatted": formattedValue,
+                "path": url.path,
+                "configured": configuredValue != nil,
+            ]
+            if let configuredValue {
+                payload["configured_value"] = configuredValue
+            }
+            print(jsonString(payload))
+            return
+        }
+
+        print("\(key) = \(formattedValue)")
+        print("path: \(Self.tildePath(url.path))")
+    }
+
+    private func runConfigSetFontSize(
+        forKey key: String,
+        rawValue: String,
+        socketPath: String?,
+        explicitPassword: String?,
+        jsonOutput: Bool
+    ) throws {
+        guard let descriptor = fontSizeConfig(forKey: key) else {
+            throw CLIError(message: "Unknown font size key '\(key)'")
+        }
+        guard let requestedValue = Double(rawValue), requestedValue.isFinite else {
+            throw CLIError(message: "\(key) requires a numeric point size")
+        }
+
+        let value = descriptor.clamp(requestedValue)
+        let formattedValue = descriptor.format(value)
+        let url = try cmuxGhosttyConfigURLForCLI()
+        try CmuxGhosttyConfigSettingEditor.writeSetting(
+            key: key,
+            value: formattedValue,
+            to: url
+        )
+
+        let reloadResult = reloadConfigAfterFontSizeSet(
+            socketPath: socketPath,
+            explicitPassword: explicitPassword
+        )
+
+        if jsonOutput {
+            var payload: [String: Any] = [
+                "ok": true,
+                "key": key,
+                "value": value,
+                "formatted": formattedValue,
+                "path": url.path,
+                "reload": reloadResult.status,
+                "clamped": value != requestedValue,
+            ]
+            if let message = reloadResult.message {
+                payload["reload_message"] = message
+            }
+            print(jsonString(payload))
+            return
+        }
+
+        switch reloadResult.status {
+        case "reloaded":
+            print("OK \(key) = \(formattedValue) (reloaded)")
+        case "failed":
+            print("OK \(key) = \(formattedValue) (saved; reload failed)")
+            if let message = reloadResult.message {
+                print("reload: \(message)")
+            }
+            print("Run `cmux config reload` after cmux is running to apply it.")
+        default:
+            print("OK \(key) = \(formattedValue) (saved)")
+            print("Run `cmux config reload` to apply it.")
+        }
+        print("path: \(Self.tildePath(url.path))")
+    }
+
+    private func cmuxGhosttyConfigURLForCLI() throws -> URL {
+        let environment = ProcessInfo.processInfo.environment
+        let fileManager = FileManager.default
+        let appSupportDirectories = CmuxApplicationSupportDirectories
+            .userDirectories(environment: environment, fileManager: fileManager)
+        guard let firstAppSupportDirectory = appSupportDirectories.first else {
+            throw CLIError(message: "Could not resolve the user Application Support directory")
+        }
+        let bundleIdentifier = normalizedConfigValue(environment["CMUX_BUNDLE_ID"])
+            ?? CLISocketPathResolver.currentAppBundleIdentifier()
+        // Prefer an existing config under any candidate root (the app loads config
+        // across all Application Support locations, including CFFIXED_USER_HOME),
+        // so `config get/set` touches the same file the app reads. Fall back to
+        // creating one under the first candidate when none exists yet.
+        for appSupportDirectory in appSupportDirectories {
+            if let existing = CmuxGhosttyConfigPathResolver.loadConfigURLs(
+                currentBundleIdentifier: bundleIdentifier,
+                appSupportDirectory: appSupportDirectory,
+                fileManager: fileManager
+            ).first {
+                return existing
+            }
+        }
+        return CmuxGhosttyConfigPathResolver.activeOrEditableConfigURL(
+            currentBundleIdentifier: bundleIdentifier,
+            appSupportDirectory: firstAppSupportDirectory,
+            fileManager: fileManager
+        )
+    }
+
+    private func reloadConfigAfterFontSizeSet(
+        socketPath: String?,
+        explicitPassword: String?
+    ) -> (status: String, message: String?) {
+        guard let socketPath else {
+            return ("skipped", nil)
+        }
+        do {
+            let client = try connectClient(
+                socketPath: socketPath,
+                explicitPassword: explicitPassword,
+                launchIfNeeded: false
+            )
+            defer { client.close() }
+            let response = try client.send(command: "reload_config")
+            if response.hasPrefix("ERROR:") {
+                return ("failed", response)
+            }
+            return ("reloaded", response)
+        } catch {
+            return ("failed", Self.configDoctorErrorMessage(error))
+        }
+    }
+
+    private func normalizedConfigValue(_ value: String?) -> String? {
+        guard let value else { return nil }
+        let trimmed = value.trimmingCharacters(in: .whitespacesAndNewlines)
+        return trimmed.isEmpty ? nil : trimmed
+    }
+
     private struct ConfigDoctorOptions {
         let paths: [String]
     }

Packages/CmuxSettingsUI/Sources/CmuxSettingsUI/Environment/SettingsFontSize.swift

@@ -0,0 +1,47 @@
+import Foundation
+
+/// A point size plus the range and default a font-size slider should use.
+///
+/// Font sizes (the left sidebar, the workspace tab bar) live in the Ghostty
+/// config file rather than `UserDefaults`, so the package can't read them
+/// through the catalog/``DefaultsValueModel`` path. Instead the host supplies
+/// the current value together with its bounds via ``SettingsHostActions``, and
+/// the settings UI renders a slider against this descriptor.
+///
+/// ```swift
+/// let font = hostActions.sidebarFontSize()
+/// Slider(value: $points, in: font.minimum...font.maximum, step: 0.5)
+/// ```
+public struct SettingsFontSize: Sendable, Equatable {
+    /// The current effective size, in points.
+    public var points: Double
+
+    /// The smallest size the slider allows.
+    public let minimum: Double
+
+    /// The largest size the slider allows.
+    public let maximum: Double
+
+    /// The size restored by the row's Reset button.
+    public let defaultValue: Double
+
+    /// Creates a font-size descriptor.
+    ///
+    /// - Parameters:
+    ///   - points: The current effective size, in points.
+    ///   - minimum: The smallest size the slider allows.
+    ///   - maximum: The largest size the slider allows.
+    ///   - defaultValue: The size restored by the row's Reset button.
+    public init(points: Double, minimum: Double, maximum: Double, defaultValue: Double) {
+        self.points = points
+        self.minimum = minimum
+        self.maximum = maximum
+        self.defaultValue = defaultValue
+    }
+
+    /// Whether ``points`` currently matches ``defaultValue`` (within a small
+    /// tolerance), used to disable the Reset control.
+    public var isDefault: Bool {
+        abs(points - defaultValue) < 0.001
+    }
+}

Packages/CmuxSettingsUI/Sources/CmuxSettingsUI/Environment/SettingsHostActions.swift

@@ -62,10 +62,67 @@ public protocol SettingsHostActions: AnyObject {
     /// Browser section uses this to render a dynamic "N saved pages"
     /// subtitle next to the Clear History button.
     func browserHistoryEntryCount() -> Int?
+
+    /// The current left-sidebar font size with the range + default the
+    /// slider should use. Backed by the Ghostty config file, not
+    /// `UserDefaults`, so it comes from the host rather than the catalog.
+    func sidebarFontSize() -> SettingsFontSize
+
+    /// Persists a new left-sidebar font size (in points) to the Ghostty
+    /// config and live-reloads open windows. The host clamps to the valid
+    /// range, so callers may pass any finite value.
+    ///
+    /// - Returns: `true` if the value was written and reloaded, `false` if
+    ///   persistence failed. Callers should surface a save-failed message to
+    ///   the user when this returns `false`, since the slider position no
+    ///   longer reflects what is stored on disk.
+    ///
+    ///   The implementation performs the disk write off the main actor, so this
+    ///   is `async`; call it from a `Task` in the slider/reset action.
+    @discardableResult
+    func setSidebarFontSize(_ points: Double) async -> Bool
+
+    /// The current workspace tab-bar font size with its range + default.
+    /// Backed by the Ghostty config file (`surface-tab-bar-font-size`).
+    func surfaceTabBarFontSize() -> SettingsFontSize
+
+    /// Persists a new workspace tab-bar font size (in points) and reloads.
+    /// The host clamps to the valid range.
+    ///
+    /// - Returns: `true` if the value was written and reloaded, `false` if
+    ///   persistence failed. See ``setSidebarFontSize(_:)`` for how callers
+    ///   should react to a `false` result and why this is `async`.
+    @discardableResult
+    func setSurfaceTabBarFontSize(_ points: Double) async -> Bool
+
+    /// Formats a point size for display next to a font-size slider
+    /// (e.g. `12`, `13.5`), trimming trailing zeros.
+    func formattedFontSize(_ points: Double) -> String
 }
 
 public extension SettingsHostActions {
     func browserHistoryEntryCount() -> Int? { nil }
+
+    func sidebarFontSize() -> SettingsFontSize {
+        SettingsFontSize(points: 12.5, minimum: 10, maximum: 20, defaultValue: 12.5)
+    }
+
+    func setSidebarFontSize(_ points: Double) async -> Bool { true }
+
+    func surfaceTabBarFontSize() -> SettingsFontSize {
+        SettingsFontSize(points: 11, minimum: 8, maximum: 24, defaultValue: 11)
+    }
+
+    func setSurfaceTabBarFontSize(_ points: Double) async -> Bool { true }
+
+    func formattedFontSize(_ points: Double) -> String {
+        let scaled = (points * 100).rounded()
+        let whole = Int(scaled / 100)
+        let fraction = abs(Int(scaled) % 100)
+        if fraction == 0 { return "\(whole)" }
+        if fraction % 10 == 0 { return "\(whole).\(fraction / 10)" }
+        return "\(whole).\(fraction < 10 ? "0" : "")\(fraction)"
+    }
 }
 
 /// No-op ``SettingsHostActions`` for previews, tests, and any context