@brimveyn/aimux 1.9.9 → 1.10.1

package/src/terminal-manager/manager-client.ts

@@ -12,6 +12,7 @@ import { getTerminalManagerSocketPath } from '../daemon/runtime-paths'
 import { logDebug } from '../debug/input-log'
 import {
   encodeManagerMessage,
+  MANAGER_PROTOCOL_BROADCAST_GATE_VERSION,
   MANAGER_PROTOCOL_MIN_VERSION,
   MANAGER_PROTOCOL_VERSION,
   type ManagerAttachResult,
@@ -378,6 +379,30 @@ export class TerminalManagerClient extends EventEmitter<ManagerClientEvents> {
     })
   }
 
+  /**
+   * Tell the TM whether to bother snapshotting and broadcasting renders.
+   * No-ops on TMs that negotiated a protocol version without the feature
+   * (older builds): the worst case is the daemon keeps receiving renders it
+   * doesn't strictly need, which matches the pre-fix behaviour.
+   */
+  async setBroadcastEnabled(enabled: boolean): Promise<void> {
+    if (
+      this.selectedProtocolVersion === null ||
+      this.selectedProtocolVersion < MANAGER_PROTOCOL_BROADCAST_GATE_VERSION
+    ) {
+      logDebug('managerClient.setBroadcastEnabled.skipped', {
+        enabled,
+        selectedVersion: this.selectedProtocolVersion,
+      })
+      return
+    }
+    await this.sendExpectOk({
+      id: crypto.randomUUID(),
+      payload: { enabled },
+      type: 'setBroadcastEnabled',
+    })
+  }
+
   destroy(): void {
     this.resetConnection('Terminal manager client destroyed')
   }

package/src/terminal-manager/terminal-manager.ts

@@ -52,6 +52,49 @@ export async function runTerminalManager(): Promise<void> {
   const sockets = new Set<Socket>()
   const negotiatedVersions = new Map<Socket, number>()
 
+  /**
+   * Auto-exit when fully idle: no clients connected AND no live PTY sessions.
+   * Prevents the "zombie TM" pattern where a stale terminal-manager from an
+   * older install keeps consuming CPU after the user has closed everything.
+   * The grace window allows brief reconnects (e.g. daemon restart during
+   * `aimux update`) without killing the process.
+   *
+   * Set AIMUX_TM_IDLE_EXIT_MS=0 to disable.
+   */
+  const idleExitMs = (() => {
+    const raw = process.env.AIMUX_TM_IDLE_EXIT_MS
+    if (raw === undefined) return 60_000
+    const parsed = Number(raw)
+    return Number.isFinite(parsed) && parsed >= 0 ? parsed : 60_000
+  })()
+  let idleExitTimer: ReturnType<typeof setTimeout> | null = null
+  const scheduleIdleExitIfApplicable = (): void => {
+    if (idleExitMs === 0) return
+    if (idleExitTimer !== null) return
+    if (sockets.size > 0) return
+    if (sessionManager.hasAnySessions()) return
+    logDebug('terminalManager.idleExit.schedule', { idleExitMs })
+    idleExitTimer = setTimeout(() => {
+      idleExitTimer = null
+      if (sockets.size > 0 || sessionManager.hasAnySessions()) {
+        logDebug('terminalManager.idleExit.cancelled')
+        return
+      }
+      logDebug('terminalManager.idleExit.fire')
+      sessionManager.disposeAll()
+      // Graceful: drop the listening socket so the file is unlinked, matching
+      // SIGTERM/SIGINT shutdown. Bail-out timer guards against close() hanging
+      // on a bad socket.
+      server.close(() => process.exit(0))
+      setTimeout(() => process.exit(0), 1_000).unref?.()
+    }, idleExitMs)
+    idleExitTimer.unref?.()
+  }
+
+  // A session can exit naturally (PTY child finishes) while no client is
+  // attached — re-evaluate idle state in that case too.
+  sessionManager.on('exit', () => scheduleIdleExitIfApplicable())
+
   sessionManager.on('render', (sessionId, tabId, viewport, terminalModes) => {
     const event: ManagerEvent = {
       payload: { sessionId, tabId, terminalModes, viewport },
@@ -233,6 +276,11 @@ export async function runTerminalManager(): Promise<void> {
               case 'ping':
                 sendOk(socket, message.id)
                 break
+              case 'setBroadcastEnabled':
+                requireNegotiatedVersion(socket, negotiatedVersions)
+                sessionManager.setBroadcastEnabled(message.payload.enabled)
+                sendOk(socket, message.id)
+                break
             }
           } catch (error) {
             const errorMessage = error instanceof Error ? error.message : String(error)
@@ -256,11 +304,13 @@ export async function runTerminalManager(): Promise<void> {
       logDebug('terminalManager.client.close')
       sockets.delete(socket)
       negotiatedVersions.delete(socket)
+      scheduleIdleExitIfApplicable()
     })
     socket.on('error', () => {
       logDebug('terminalManager.client.error')
       sockets.delete(socket)
       negotiatedVersions.delete(socket)
+      scheduleIdleExitIfApplicable()
     })
   })
 
@@ -270,8 +320,12 @@ export async function runTerminalManager(): Promise<void> {
   })
   tightenSocketPermissions(socketPath)
 
+  // First idle eval: if no client connects within idleExitMs of startup, exit.
+  scheduleIdleExitIfApplicable()
+
   const gracefulShutdown = (signal: string) => {
     logDebug(`terminalManager.${signal}`)
+    if (idleExitTimer) clearTimeout(idleExitTimer)
     sessionManager.disposeAll()
     server.close()
     process.exit(0)

package/src/ui/components/layout/split-layout.tsx

@@ -26,6 +26,8 @@ interface SplitLayoutProps {
   onTerminalMouseEvent: (event: OtuiMouseEvent, origin: TerminalContentOrigin) => void
   onTerminalScrollEvent: (event: OtuiMouseEvent) => void
   onTerminalClick?: (event: OtuiMouseEvent, origin: TerminalContentOrigin, tabId?: string) => void
+  onTerminalDrag?: (event: OtuiMouseEvent, origin: TerminalContentOrigin, tabId?: string) => boolean
+  onTerminalMouseUp?: (event: OtuiMouseEvent) => boolean
   onPaneActivate?: (tabId: string) => void
   onSplitResize?: (tabId: string, ratio: number, axis: SplitDirection) => void
   onSeparatorDragStart?: (info: {
@@ -54,7 +56,9 @@ export function SplitLayout({
   onSeparatorDragStart,
   onSplitResize,
   onTerminalClick,
+  onTerminalDrag,
   onTerminalMouseEvent,
+  onTerminalMouseUp,
   onTerminalScrollEvent,
   tabs,
 }: SplitLayoutProps) {
@@ -92,6 +96,8 @@ export function SplitLayout({
         onTerminalMouseEvent={onTerminalMouseEvent}
         onTerminalScrollEvent={onTerminalScrollEvent}
         onTerminalClick={onTerminalClick}
+        onTerminalDrag={onTerminalDrag}
+        onTerminalMouseUp={onTerminalMouseUp}
         onPaneActivate={onPaneActivate}
         onSeparatorDrag={onSeparatorDrag}
         onSeparatorDragEnd={onSeparatorDragEnd}
@@ -123,6 +129,8 @@ export function SplitLayout({
           onTerminalMouseEvent={onTerminalMouseEvent}
           onTerminalScrollEvent={onTerminalScrollEvent}
           onTerminalClick={onTerminalClick}
+          onTerminalDrag={onTerminalDrag}
+          onTerminalMouseUp={onTerminalMouseUp}
           onPaneActivate={onPaneActivate}
           onSplitResize={onSplitResize}
           onSeparatorDragStart={onSeparatorDragStart}
@@ -163,6 +171,8 @@ export function SplitLayout({
           onTerminalMouseEvent={onTerminalMouseEvent}
           onTerminalScrollEvent={onTerminalScrollEvent}
           onTerminalClick={onTerminalClick}
+          onTerminalDrag={onTerminalDrag}
+          onTerminalMouseUp={onTerminalMouseUp}
           onPaneActivate={onPaneActivate}
           onSplitResize={onSplitResize}
           onSeparatorDragStart={onSeparatorDragStart}

package/src/ui/components/layout/terminal-pane.tsx

@@ -22,6 +22,8 @@ interface TerminalPaneProps {
   onTerminalMouseEvent: (event: OtuiMouseEvent, origin: TerminalContentOrigin) => void
   onTerminalScrollEvent: (event: OtuiMouseEvent) => void
   onTerminalClick?: (event: OtuiMouseEvent, origin: TerminalContentOrigin, tabId?: string) => void
+  onTerminalDrag?: (event: OtuiMouseEvent, origin: TerminalContentOrigin, tabId?: string) => boolean
+  onTerminalMouseUp?: (event: OtuiMouseEvent) => boolean
   onPaneActivate?: (tabId: string) => void
   onSeparatorDrag?: (event: OtuiMouseEvent) => boolean
   onSeparatorDragEnd?: () => void
@@ -47,9 +49,10 @@ function getTitle(
   return `${tab.title} · ${tab.status}`
 }
 
-function getBorderColor(isActive: boolean, _focusMode: TerminalPaneProps['focusMode']): string {
+function getBorderColor(isActive: boolean, focusMode: TerminalPaneProps['focusMode']): string {
   const t = getCurrentTheme()
-  return isActive ? t.borderActive : t.border
+  if (!isActive) return t.border
+  return focusMode === 'terminal-input' ? t.accent : t.primary
 }
 
 function renderSpan(span: TerminalSpan, key: string): ReactNode {
@@ -111,7 +114,9 @@ export function TerminalPane({
   onSeparatorDrag,
   onSeparatorDragEnd,
   onTerminalClick,
+  onTerminalDrag,
   onTerminalMouseEvent,
+  onTerminalMouseUp,
   onTerminalScrollEvent,
   tab,
   tabId,
@@ -168,11 +173,20 @@ export function TerminalPane({
         y: event.y,
       })
     }
-    if (event.type === 'drag' && onSeparatorDrag?.(event)) {
-      event.preventDefault()
-      return
+    if (event.type === 'drag') {
+      if (onTerminalDrag?.(event, contentOrigin, tabId)) {
+        event.preventDefault()
+        return
+      }
+      if (onSeparatorDrag?.(event)) {
+        event.preventDefault()
+        return
+      }
     }
     if (event.type === 'up') {
+      if (onTerminalMouseUp?.(event)) {
+        event.preventDefault()
+      }
       onSeparatorDragEnd?.()
     }
     if (tabId && onPaneActivate && event.type === 'down') {

package/src/ui/components/modals/themes/theme-picker-modal.tsx

@@ -4,7 +4,7 @@ import type { ThemeId } from '../../../themes'
 
 import { dispatchGlobal, runSideEffectGlobal } from '../../../../state/dispatch-ref'
 import { filterThemeIds, themeDisplayName } from '../../../filter-themes'
-import { useTheme, useTransparent } from '../../../theme'
+import { useMode, useTheme, useTransparent } from '../../../theme'
 import { uiTokens } from '../../../ui-tokens'
 import { Picker, type PickerItem } from '../shared/picker'
 
@@ -28,6 +28,7 @@ export function ThemePickerModal({
 }: ThemePickerModalProps) {
   const t = useTheme()
   const transparent = useTransparent()
+  const mode = useMode()
   const filtered = useMemo(() => filterThemeIds(filter), [filter])
 
   useLayoutEffect(() => {
@@ -63,6 +64,7 @@ export function ThemePickerModal({
             {filtered.length === 0 ? '' : ` ${effectiveIndex + 1} / ${filtered.length}`}
           </text>
           <text fg={t.textMuted}>{` transparent: ${transparent ? 'on' : 'off'} (ctrl-t)`}</text>
+          <text fg={t.textMuted}>{` mode: ${mode} (ctrl-l)`}</text>
         </box>
       }
       items={items}

package/src/ui/root.tsx

@@ -206,6 +206,8 @@ interface RootViewProps {
   onTerminalMouseEvent: (event: MouseEvent, origin: TerminalContentOrigin) => void
   onTerminalScrollEvent: (event: MouseEvent) => void
   onTerminalClick?: (event: MouseEvent, origin: TerminalContentOrigin, tabId?: string) => void
+  onTerminalDrag?: (event: MouseEvent, origin: TerminalContentOrigin, tabId?: string) => boolean
+  onTerminalMouseUp?: (event: MouseEvent) => boolean
   onPaneActivate?: (tabId: string) => void
   onSplitResize?: (tabId: string, ratio: number, axis: SplitDirection) => void
   onSidebarResizeStart?: (info: { initialWidth: number; screenStart: number }) => void
@@ -244,7 +246,9 @@ export function RootView({
   onSidebarResizeStart,
   onSplitResize,
   onTerminalClick,
+  onTerminalDrag,
   onTerminalMouseEvent,
+  onTerminalMouseUp,
   onTerminalScrollEvent,
   terminalCols,
   terminalRows,
@@ -312,7 +316,11 @@ export function RootView({
           event.stopPropagation()
         }
       }}
-      onMouseUp={() => {
+      onMouseUp={(event) => {
+        // Catch releases that land outside any TerminalPane (sidebar, gap,
+        // status bar, …) so an in-flight multi-click drag — and its
+        // auto-scroll interval — is always finalised.
+        onTerminalMouseUp?.(event)
         onSeparatorDragEnd?.()
       }}
     >
@@ -349,6 +357,8 @@ export function RootView({
             onTerminalMouseEvent={onTerminalMouseEvent}
             onTerminalScrollEvent={onTerminalScrollEvent}
             onTerminalClick={onTerminalClick}
+            onTerminalDrag={onTerminalDrag}
+            onTerminalMouseUp={onTerminalMouseUp}
             onPaneActivate={onPaneActivate}
             onSplitResize={onSplitResize}
             onSeparatorDragStart={onSeparatorDragStart}
@@ -373,6 +383,8 @@ export function RootView({
             onTerminalMouseEvent={onTerminalMouseEvent}
             onTerminalScrollEvent={onTerminalScrollEvent}
             onTerminalClick={onTerminalClick}
+            onTerminalDrag={onTerminalDrag}
+            onTerminalMouseUp={onTerminalMouseUp}
             onPaneActivate={onPaneActivate}
           />
         )}

package/src/ui/theme-store.ts

@@ -73,6 +73,10 @@ export function useTransparent(): boolean {
   return useStore(themeStore, (s) => s.transparent)
 }
 
+export function useMode(): ThemeMode {
+  return useStore(themeStore, (s) => s.mode)
+}
+
 export function getTransparent(): boolean {
   return themeStore.getState().transparent
 }
@@ -81,3 +85,17 @@ export function setTransparent(value: boolean): void {
   if (themeStore.getState().transparent === value) return
   themeStore.setState({ transparent: value })
 }
+
+/** Subscribe to theme id/mode changes for non-React side-effects. */
+export function subscribeThemeChanges(
+  listener: (resolved: ResolvedTuiTheme, mode: ThemeMode) => void
+): () => void {
+  let lastId: ThemeId | null = null
+  let lastMode: ThemeMode | null = null
+  return themeStore.subscribe((s) => {
+    if (s.id === lastId && s.mode === lastMode) return
+    lastId = s.id
+    lastMode = s.mode
+    listener(derive(s.id, s.mode), s.mode)
+  })
+}

package/src/ui/theme.ts

@@ -11,6 +11,8 @@ export {
   getTransparent,
   setMode,
   setTransparent,
+  subscribeThemeChanges,
+  useMode,
   useTheme,
   useTransparent,
 } from './theme-store'

package/src/update.ts

@@ -1,5 +1,5 @@
 import { getDaemonSocketPath } from './daemon/runtime-paths'
-import { findIpcDaemonPid } from './platform/daemon-control'
+import { findIpcDaemonPid, findTerminalManagerPid } from './platform/daemon-control'
 import { runRestartDaemon } from './restart-daemon'
 
 const REPO = 'BrimVeyn/aimux'
@@ -59,5 +59,25 @@ export async function runUpdate(): Promise<number> {
     await runRestartDaemon()
   }
 
+  // The terminal-manager is intentionally NOT restarted here: doing so kills
+  // live AI sessions. The flip side: the running TM keeps executing the
+  // previous version's code path, so any TM-side fix (perf, lifecycle) only
+  // takes effect after a manual restart. Surface that explicitly so users
+  // aren't silently stuck on stale behaviour.
+  const tmPid = await findTerminalManagerPid()
+  if (tmPid !== null) {
+    process.stdout.write(
+      [
+        '',
+        `Note: terminal-manager (pid ${tmPid}) is still running the previous version.`,
+        'TM-side fixes in this update apply to new TMs only — the running one',
+        'keeps its old behaviour until restarted.',
+        'Run `aimux restart-terminal-manager` when you can afford to lose your',
+        'current PTY sessions to upgrade it.',
+        '',
+      ].join('\n')
+    )
+  }
+
   return 0
 }