feat(terminal): add terminal emulator with bridge integration

Implement local and remote terminal session management via the bridge
connection manager. This adds client methods to start, resize, send input
to, and close terminal sessions, along with handlers for output and exit
notifications.

Also includes UI updates for the terminal emulator and fixes a typo in
the FirebaseAPIKey property list entry.

Author: tooury

.gitignore

@@ -740,3 +740,4 @@ Axon/Resources/MLXModels/google_gemma-4-E2B-it-MLX/config.json
 Axon/Resources/MLXModels/google_gemma-4-E2B-it-MLX/generation_config.json
 Axon/Resources/MLXModels/google_gemma-4-E2B-it-MLX/special_tokens_map.json
 Axon/Resources/MLXModels/google_gemma-4-E2B-it-MLX/README.md
+bridge_test_tmp.txt

Axon/DesignSystem/Chat/ChatVisualTokens.swift

@@ -10,7 +10,15 @@ import SwiftUI
 enum ChatVisualTokens {
     // MARK: - Message Layout
 
+    #if os(macOS)
+    static let chatRailMaxWidth: CGFloat = 940
+    static let chatRailHorizontalPadding: CGFloat = 24
+    static let messageMaxReadableWidth: CGFloat = 940
+    #else
+    static let chatRailMaxWidth: CGFloat = .infinity
+    static let chatRailHorizontalPadding: CGFloat = 0
     static let messageMaxReadableWidth: CGFloat = 520
+    #endif
     static let messageOuterHorizontalPadding: CGFloat = 12
     static let messageBubbleHorizontalPadding: CGFloat = 14
     static let messageBubbleVerticalPadding: CGFloat = 10

Axon/Info.plist

@@ -14,7 +14,7 @@
 		<string>com.axon.sync.memories</string>
 		<string>com.axon.sync.background</string>
 	</array>
-	<key>FIrebaseAPIKey</key>
+	<key>FirebaseAPIKey</key>
 	<string>$(FIREBASE_API_KEY)</string>
 	<key>FirebaseAppID</key>
 	<string>$(FIREBASE_APP_ID)</string>

Axon/Services/Bridge/BridgeClient.swift

@@ -248,6 +248,23 @@ class BridgeClient: ObservableObject {
         return try JSONDecoder().decode(TerminalRunResult.self, from: resultData)
     }
 
+    func startTerminalSession(_ params: TerminalSessionStartParams) async throws -> TerminalSessionStartResult {
+        let result = try await executeMethod(method: .terminalSessionStart, params: try params.bridgeAnyCodable())
+        return try result.decodeBridgeValue(TerminalSessionStartResult.self)
+    }
+
+    func sendTerminalInput(_ params: TerminalSessionInputParams) async throws {
+        _ = try await executeMethod(method: .terminalSessionInput, params: try params.bridgeAnyCodable())
+    }
+
+    func resizeTerminalSession(_ params: TerminalSessionResizeParams) async throws {
+        _ = try await executeMethod(method: .terminalSessionResize, params: try params.bridgeAnyCodable())
+    }
+
+    func closeTerminalSession(_ params: TerminalSessionCloseParams) async throws {
+        _ = try await executeMethod(method: .terminalSessionClose, params: try params.bridgeAnyCodable())
+    }
+
     /// Get workspace info from VS Code
     func getWorkspaceInfo() async throws -> WorkspaceInfoResult {
         let result = try await executeMethod(method: .workspaceInfo, params: .null)
@@ -486,7 +503,26 @@ class BridgeClient: ObservableObject {
 
     private func handleIncomingNotification(_ notification: BridgeNotification) {
         print("[BridgeClient] Received notification: \(notification.method)")
-        // Handle notifications from VS Code if needed
+        handleTerminalNotification(notification)
+    }
+
+    private func handleTerminalNotification(_ notification: BridgeNotification) {
+        guard let params = notification.params else { return }
+
+        do {
+            switch notification.method {
+            case TerminalBridgeMethod.output:
+                let output = try params.decodeBridgeValue(TerminalSessionOutputNotification.self)
+                NotificationCenter.default.post(name: .terminalSessionOutput, object: output)
+            case TerminalBridgeMethod.exited:
+                let exited = try params.decodeBridgeValue(TerminalSessionExitedNotification.self)
+                NotificationCenter.default.post(name: .terminalSessionExited, object: exited)
+            default:
+                break
+            }
+        } catch {
+            print("[BridgeClient] Failed to decode terminal notification: \(error)")
+        }
     }
 
     // MARK: - Reconnection

Axon/Services/Bridge/BridgeConnectionManager.swift

@@ -389,6 +389,54 @@ class BridgeConnectionManager: ObservableObject {
         }
     }
 
+    func startTerminalSession(_ params: TerminalSessionStartParams, sessionId: String? = nil) async throws -> TerminalSessionStartResult {
+        switch mode {
+        case .local:
+            return try await BridgeServer.shared.startTerminalSession(params)
+        case .remote:
+            guard let client = bridgeClient else {
+                throw BridgeError(code: .notConnected, message: "Not connected")
+            }
+            return try await client.startTerminalSession(params)
+        }
+    }
+
+    func sendTerminalInput(_ params: TerminalSessionInputParams, sessionId: String? = nil) async throws {
+        switch mode {
+        case .local:
+            try await BridgeServer.shared.sendTerminalInput(params)
+        case .remote:
+            guard let client = bridgeClient else {
+                throw BridgeError(code: .notConnected, message: "Not connected")
+            }
+            try await client.sendTerminalInput(params)
+        }
+    }
+
+    func resizeTerminalSession(_ params: TerminalSessionResizeParams, sessionId: String? = nil) async throws {
+        switch mode {
+        case .local:
+            try await BridgeServer.shared.resizeTerminalSession(params)
+        case .remote:
+            guard let client = bridgeClient else {
+                throw BridgeError(code: .notConnected, message: "Not connected")
+            }
+            try await client.resizeTerminalSession(params)
+        }
+    }
+
+    func closeTerminalSession(_ params: TerminalSessionCloseParams, sessionId: String? = nil) async throws {
+        switch mode {
+        case .local:
+            try await BridgeServer.shared.closeTerminalSession(params)
+        case .remote:
+            guard let client = bridgeClient else {
+                throw BridgeError(code: .notConnected, message: "Not connected")
+            }
+            try await client.closeTerminalSession(params)
+        }
+    }
+
     /// Get workspace info from VS Code
     func getWorkspaceInfo(sessionId: String? = nil) async throws -> WorkspaceInfoResult {
         switch mode {

Axon/Services/Bridge/BridgeProtocol.swift

@@ -772,6 +772,10 @@ enum BridgeMethod: String, CaseIterable {
 
     // Terminal operations
     case terminalRun = "terminal/run"
+    case terminalSessionStart = "terminal/sessionStart"
+    case terminalSessionInput = "terminal/sessionInput"
+    case terminalSessionResize = "terminal/sessionResize"
+    case terminalSessionClose = "terminal/sessionClose"
 
     // Workspace operations
     case workspaceInfo = "workspace/info"
@@ -808,6 +812,7 @@ enum BridgeMethod: String, CaseIterable {
     var requiresApproval: Bool {
         switch self {
         case .fileWrite, .terminalRun,
+             .terminalSessionStart, .terminalSessionInput, .terminalSessionResize, .terminalSessionClose,
              .clipboardWrite, .appLaunch, .shellExecute:
             return true
         case .hello,
@@ -846,7 +851,9 @@ enum BridgeMethod: String, CaseIterable {
         case .guestQueryMemories, .guestGetContext, .guestChatWithContext, .guestDisconnect, .hello:
             return true
         case .getPairingInfo, .chatListConversations, .chatGetMessages,
-             .fileRead, .fileWrite, .fileList, .terminalRun, .workspaceInfo,
+             .fileRead, .fileWrite, .fileList,
+             .terminalRun, .terminalSessionStart, .terminalSessionInput, .terminalSessionResize, .terminalSessionClose,
+             .workspaceInfo,
              .systemInfo, .systemProcesses, .systemDiskUsage,
              .clipboardRead, .clipboardWrite, .notificationSend,
              .spotlightSearch, .fileFind, .fileMetadata,
@@ -876,6 +883,14 @@ enum BridgeMethod: String, CaseIterable {
             return "List directory contents"
         case .terminalRun:
             return "Execute terminal command"
+        case .terminalSessionStart:
+            return "Start interactive terminal session"
+        case .terminalSessionInput:
+            return "Send input to interactive terminal session"
+        case .terminalSessionResize:
+            return "Resize interactive terminal session"
+        case .terminalSessionClose:
+            return "Close interactive terminal session"
         case .workspaceInfo:
             return "Get workspace information"
         case .guestQueryMemories:

Axon/Services/Bridge/BridgeServer.swift

@@ -383,6 +383,38 @@ class BridgeServer: ObservableObject {
         return try JSONDecoder().decode(TerminalRunResult.self, from: resultData)
     }
 
+    func startTerminalSession(_ params: TerminalSessionStartParams) async throws -> TerminalSessionStartResult {
+        let result = try await sendRequest(method: BridgeMethod.terminalSessionStart.rawValue, params: try params.bridgeAnyCodable())
+        if let error = result.error {
+            throw error
+        }
+        guard let payload = result.result else {
+            throw BridgeError(code: .terminalError, message: "Missing terminal session start result")
+        }
+        return try payload.decodeBridgeValue(TerminalSessionStartResult.self)
+    }
+
+    func sendTerminalInput(_ params: TerminalSessionInputParams) async throws {
+        let result = try await sendRequest(method: BridgeMethod.terminalSessionInput.rawValue, params: try params.bridgeAnyCodable())
+        if let error = result.error {
+            throw error
+        }
+    }
+
+    func resizeTerminalSession(_ params: TerminalSessionResizeParams) async throws {
+        let result = try await sendRequest(method: BridgeMethod.terminalSessionResize.rawValue, params: try params.bridgeAnyCodable())
+        if let error = result.error {
+            throw error
+        }
+    }
+
+    func closeTerminalSession(_ params: TerminalSessionCloseParams) async throws {
+        let result = try await sendRequest(method: BridgeMethod.terminalSessionClose.rawValue, params: try params.bridgeAnyCodable())
+        if let error = result.error {
+            throw error
+        }
+    }
+
     /// Get workspace info from VS Code
     func getWorkspaceInfo() async throws -> WorkspaceInfoResult {
         let result = try await executeMethod(method: .workspaceInfo, params: .null)
@@ -864,7 +896,26 @@ class BridgeServer: ObservableObject {
 
     private func handleIncomingNotification(_ notification: BridgeNotification, connectionId: String) {
         print("[BridgeServer] Received notification: \(notification.method) (connectionId: \(connectionId.prefix(8)))")
-        // Handle notifications from VS Code if needed (e.g., file changed events)
+        handleTerminalNotification(notification)
+    }
+
+    private func handleTerminalNotification(_ notification: BridgeNotification) {
+        guard let params = notification.params else { return }
+
+        do {
+            switch notification.method {
+            case TerminalBridgeMethod.output:
+                let output = try params.decodeBridgeValue(TerminalSessionOutputNotification.self)
+                NotificationCenter.default.post(name: .terminalSessionOutput, object: output)
+            case TerminalBridgeMethod.exited:
+                let exited = try params.decodeBridgeValue(TerminalSessionExitedNotification.self)
+                NotificationCenter.default.post(name: .terminalSessionExited, object: exited)
+            default:
+                break
+            }
+        } catch {
+            print("[BridgeServer] Failed to decode terminal notification: \(error)")
+        }
     }
 
     private func handleHello(_ request: BridgeRequest, on connection: NWConnection, connectionId: String) async {

Axon/Services/Bridge/BridgeSettings.swift

@@ -95,6 +95,18 @@ struct BridgeSettings: Codable, Equatable, Sendable {
     /// Terminal command timeout (seconds)
     var terminalTimeout: Int = 60
 
+    /// Prefer the active VS Code workspace as the terminal working directory.
+    var preferBridgeWorkspaceForTerminal: Bool = true
+
+    /// User-configured fallback directory for the bottom terminal drawer.
+    var terminalDefaultDirectory: String = ""
+
+    /// Persisted terminal drawer open state.
+    var terminalDrawerOpen: Bool = false
+
+    /// Persisted terminal drawer height.
+    var terminalDrawerHeight: Double = 280
+
     /// Optional pairing token required to accept VS Code connections.
     ///
     /// When set (non-empty), Axon will reject hello handshakes that do not present
@@ -533,6 +545,22 @@ class BridgeSettingsStorage: ObservableObject {
         settings.terminalTimeout = max(5, seconds)
     }
 
+    func setPreferBridgeWorkspaceForTerminal(_ enabled: Bool) {
+        settings.preferBridgeWorkspaceForTerminal = enabled
+    }
+
+    func setTerminalDefaultDirectory(_ path: String) {
+        settings.terminalDefaultDirectory = path.trimmingCharacters(in: .whitespacesAndNewlines)
+    }
+
+    func setTerminalDrawerOpen(_ open: Bool) {
+        settings.terminalDrawerOpen = open
+    }
+
+    func setTerminalDrawerHeight(_ height: Double) {
+        settings.terminalDrawerHeight = min(max(height, 180), 640)
+    }
+
     func setBlockedPatterns(_ patterns: [String]) {
         settings.blockedPatterns = patterns
     }

Axon/Services/Terminal/BridgeTerminalTransport.swift

@@ -0,0 +1,81 @@
+//
+//  BridgeTerminalTransport.swift
+//  Axon
+//
+//  Remote terminal transport that streams through the VS Code bridge.
+//
+
+import Foundation
+import Combine
+
+@MainActor
+final class BridgeTerminalTransport: TerminalTransport {
+    private let connectionManager: BridgeConnectionManager
+    private let outputSubject = PassthroughSubject<String, Never>()
+    private let exitSubject = PassthroughSubject<Int?, Never>()
+    private var cancellables = Set<AnyCancellable>()
+    private var sessionId: String?
+
+    var outputPublisher: AnyPublisher<String, Never> {
+        outputSubject.eraseToAnyPublisher()
+    }
+
+    var exitPublisher: AnyPublisher<Int?, Never> {
+        exitSubject.eraseToAnyPublisher()
+    }
+
+    init(connectionManager: BridgeConnectionManager) {
+        self.connectionManager = connectionManager
+
+        NotificationCenter.default.publisher(for: .terminalSessionOutput)
+            .compactMap { $0.object as? TerminalSessionOutputNotification }
+            .sink { [weak self] notification in
+                guard let self, notification.sessionId == self.sessionId else { return }
+                self.outputSubject.send(notification.data)
+            }
+            .store(in: &cancellables)
+
+        NotificationCenter.default.publisher(for: .terminalSessionExited)
+            .compactMap { $0.object as? TerminalSessionExitedNotification }
+            .sink { [weak self] notification in
+                guard let self, notification.sessionId == self.sessionId else { return }
+                self.exitSubject.send(notification.exitCode)
+            }
+            .store(in: &cancellables)
+    }
+
+    func start(cwd: String, cols: Int, rows: Int) async throws -> TerminalSessionStartResult {
+        guard connectionManager.isConnected else {
+            throw TerminalSessionError.bridgeNotConnected
+        }
+
+        let params = TerminalSessionStartParams(cwd: cwd, cols: cols, rows: rows, shell: nil)
+        let result = try await connectionManager.startTerminalSession(params)
+        sessionId = result.sessionId
+        return result
+    }
+
+    func sendInput(_ data: String) async throws {
+        guard let sessionId else {
+            throw TerminalSessionError.sessionNotStarted
+        }
+        try await connectionManager.sendTerminalInput(
+            TerminalSessionInputParams(sessionId: sessionId, data: data)
+        )
+    }
+
+    func resize(cols: Int, rows: Int) async throws {
+        guard let sessionId else {
+            throw TerminalSessionError.sessionNotStarted
+        }
+        try await connectionManager.resizeTerminalSession(
+            TerminalSessionResizeParams(sessionId: sessionId, cols: cols, rows: rows)
+        )
+    }
+
+    func close() async {
+        guard let sessionId else { return }
+        try? await connectionManager.closeTerminalSession(TerminalSessionCloseParams(sessionId: sessionId))
+        self.sessionId = nil
+    }
+}