@brimveyn/aimux 1.14.3 → 1.14.5

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@brimveyn/aimux",
-  "version": "1.14.3",
+  "version": "1.14.5",
   "description": "A terminal multiplexer for AI CLIs. Run Claude, Codex, OpenCode side-by-side with tabbed navigation, split panes, and persistent sessions.",
   "keywords": [
     "ai",
@@ -60,7 +60,7 @@
     "bump": "bun run scripts/bump.ts"
   },
   "dependencies": {
-    "@brimveyn/aimux-config": "0.6.5",
+    "@brimveyn/aimux-config": "0.6.6",
     "@opentui/core": "^0.1.90",
     "@opentui/react": "^0.1.90",
     "@resvg/resvg-wasm": "^2.6.2",

package/src/app-runtime/side-effects.ts

@@ -1059,7 +1059,13 @@ async function openEditorInline(
 }
 
 function handleSwitchSessionByIndex(ctx: SideEffectContext, index: number): void {
-  const { backend, dispatch, state } = ctx
+  const { backend, dispatch } = ctx
+  // Read fresh state. ctx.state is the snapshot from the previous render and
+  // lags behind dispatches that happened in the same JS turn (a worktree-row
+  // click first dispatches set-active-worktree then fires this side effect —
+  // we need to see that just-applied activeWorktreeId so the new session
+  // lands on the right worktree, not its last-saved one).
+  const state = ctx.getState()
   const ordered = [...state.sessions].sort(
     (a, b) => (a.order ?? Number.MAX_SAFE_INTEGER) - (b.order ?? Number.MAX_SAFE_INTEGER)
   )

package/src/app-runtime/use-terminal-resize.ts

@@ -44,21 +44,26 @@ function resizeSplitTabs(
   tabIds: string[],
   cols: number,
   rows: number,
-  options?: { sync?: boolean }
+  options?: { sync?: boolean },
+  skipTabId?: string | null
 ): void {
   const bounds = getTerminalBounds(cols, rows)
   const resizedTabIds = new Set<string>()
 
   forEachSplitPaneRect(Object.values(layoutTrees), bounds, (tabId, rect) => {
+    if (skipTabId != null && tabId === skipTabId) {
+      resizedTabIds.add(tabId)
+      return
+    }
     const size = toTerminalContentSize(rect)
     backend.resizeTab(tabId, size.cols, size.rows, options)
     resizedTabIds.add(tabId)
   })
 
   for (const id of tabIds) {
-    if (!resizedTabIds.has(id)) {
-      backend.resizeTab(id, cols, rows, options)
-    }
+    if (resizedTabIds.has(id)) continue
+    if (skipTabId != null && id === skipTabId) continue
+    backend.resizeTab(id, cols, rows, options)
   }
 }
 
@@ -81,6 +86,12 @@ interface RunResizeCascadeArgs {
   layoutTrees: AppState['layoutTrees']
   stableTabIds: string[]
   sync: boolean
+  /** Tab whose backend resize is owned exclusively by `usePaneSizeReport`. The
+   *  cascade still dispatches the global terminal-size update and resizes every
+   *  other tab, but the active pane is left to be sized by its measurement —
+   *  preventing the open-loop chrome estimate from competing with the closed
+   *  measurement loop and tearing the rendered viewport. */
+  skipTabId: string | null
 }
 
 function runResizeCascade({
@@ -91,6 +102,7 @@ function runResizeCascade({
   resizingRef,
   resizingTimerRef,
   rows,
+  skipTabId,
   stableTabIds,
   sync,
 }: RunResizeCascadeArgs): void {
@@ -104,9 +116,14 @@ function runResizeCascade({
       clearTimeout(resizingTimerRef.current)
     }
     if (hasSplits) {
-      resizeSplitTabs(backend, layoutTrees, stableTabIds, cols, rows, options)
-    } else {
+      resizeSplitTabs(backend, layoutTrees, stableTabIds, cols, rows, options, skipTabId)
+    } else if (skipTabId == null) {
       backend.resizeAll(cols, rows, options)
+    } else {
+      for (const id of stableTabIds) {
+        if (id === skipTabId) continue
+        backend.resizeTab(id, cols, rows, options)
+      }
     }
     resizingTimerRef.current = setTimeout(() => {
       resizingRef.current = false
@@ -162,11 +179,16 @@ export function useTerminalResize({
         contentOriginRef.current = { cols, rows, x: rect.x, y: rect.y }
       }
       const prev = measuredRef.current.get(tabId)
-      if (prev && prev.cols === cols && prev.rows === rows) {
+      if (prev !== undefined && prev.cols === cols && prev.rows === rows) {
         return
       }
+      // First measurement for this tab: even if it happens to match the
+      // open-loop bootstrap size, we still call resizeTab so the backend
+      // gate (snapshot suppression until measurement confirms the pane
+      // size) is lifted. confirmedFromMeasurement marks this call as the
+      // authoritative size for the rendered viewport.
       measuredRef.current.set(tabId, { cols, rows })
-      backend.resizeTab(tabId, cols, rows)
+      backend.resizeTab(tabId, cols, rows, { confirmedFromMeasurement: true })
     },
     [backend, contentOriginRef]
   )
@@ -222,6 +244,7 @@ export function useTerminalResize({
       resizingRef,
       resizingTimerRef,
       rows: terminalSize.rows,
+      skipTabId: activeTabIdRef.current ?? null,
       stableTabIds,
       sync: true,
     })
@@ -249,6 +272,7 @@ export function useTerminalResize({
       resizingRef,
       resizingTimerRef,
       rows: terminalSize.rows,
+      skipTabId: activeTabIdRef.current ?? null,
       stableTabIds,
       sync: false,
     })

package/src/app.tsx

@@ -27,6 +27,7 @@ import { setActiveKeymap } from './input/keymap/keymap-ref'
 import { deriveModeId } from './input/modes/bridge'
 import { registerAllModes } from './input/modes/handlers'
 import { getHandler, transitionTo } from './input/modes/registry'
+import { ensureClaudeSettingsHooks } from './integrations/claude-hooks-install'
 import { highlightSnapshot, warmClaudeSyntaxOverlay } from './integrations/claude-syntax-overlay'
 import { ensureClaudeSettingsThemePref, syncClaudeTheme } from './integrations/claude-theme-sync'
 import { getProfileConfigDir, getProfileName } from './profile-paths'
@@ -191,6 +192,16 @@ export function App({
     })
   }, [resolvedConfig.theme?.beta?.harmonizeClaudeTheme])
 
+  useEffect(() => {
+    // Opt-in via `integrations.claudeHooks` in aimux.config.ts. When enabled,
+    // idempotently patches ~/.claude/settings.json so Claude Code's hooks
+    // call back into the daemon for per-tab activity detection. Silent on
+    // failure; the visual PTY detector is the fallback either way.
+    if (resolvedConfig.integrations.claudeHooks) {
+      ensureClaudeSettingsHooks()
+    }
+  }, [resolvedConfig.integrations.claudeHooks])
+
   useEffect(() => {
     const aiUsage = resolvedConfig.statusBar?.aiUsage
     if (!(aiUsage?.enabled === true)) {
@@ -398,7 +409,11 @@ export function App({
       if (!(state.currentSessionId != null && state.currentSessionId !== '')) return
       return getSessionProjectPath(state.sessions.find((s) => s.id === state.currentSessionId))
     },
-    getState: () => stateRef.current,
+    // Read straight from the store, not stateRef. stateRef is only refreshed
+    // on render, so within a single JS turn (a click handler that dispatches
+    // then fires a side effect) it lags one step behind. appStore.getState
+    // reflects every dispatch synchronously.
+    getState: () => appStore.getState(),
     renderer,
     setThemeId,
     startStartupGrace,

package/src/daemon/daemon.ts

@@ -1,8 +1,10 @@
+import { existsSync, unlinkSync, writeFileSync } from 'node:fs'
 import { connect, createServer, type Socket } from 'node:net'
 
 import type { AssistantId, TerminalSnapshot } from '../state/types'
 
 import { logDebug } from '../debug/input-log'
+import { type ClaudeHookServer, startClaudeHookServer } from '../integrations/claude-hook-server'
 import {
   type ClientRequest,
   encodeMessage,
@@ -19,6 +21,7 @@ import { findSocketProcessPid, spawnDetachedTerminalManager } from '../platform/
 import { type LoopTabView, runStatusDetectionLoop } from '../pty/assistant-status-detection-loop'
 import { TerminalManagerClient } from '../terminal-manager/manager-client'
 import {
+  getClaudeHookUrlFilePath,
   getIpcDaemonSocketPath,
   getSocketSecurityIssue,
   getTerminalManagerSocketPath,
@@ -282,6 +285,39 @@ export async function runDaemon(): Promise<void> {
     },
   })
 
+  // Local HTTP server that receives Claude Code hook callbacks for every PTY
+  // spawned by this daemon. We publish its URL to a stable file path that the
+  // shipped shell bridge reads on every invocation, so PTYs spawned by a
+  // *previous* daemon transparently follow URL changes after a restart.
+  // Failure to start is non-fatal — detection falls back to the visual PTY scanner.
+  let hookServer: ClaudeHookServer | null = null
+  const hookUrlFilePath = getClaudeHookUrlFilePath()
+  try {
+    hookServer = startClaudeHookServer({
+      onEvent: (event) => {
+        statusLoop.recordHookEvent({
+          hookEventName: event.hookEventName,
+          paneId: event.paneId,
+          payload: event.payload,
+          receivedAt: event.receivedAt,
+        })
+      },
+    })
+    try {
+      writeFileSync(hookUrlFilePath, hookServer.url, { mode: 0o600 })
+      logDebug('daemon.hookServer.started', { path: hookUrlFilePath, url: hookServer.url })
+    } catch (error) {
+      logDebug('daemon.hookServer.urlFileWriteFailed', {
+        error: error instanceof Error ? error.message : String(error),
+        path: hookUrlFilePath,
+      })
+    }
+  } catch (error) {
+    logDebug('daemon.hookServer.startFailed', {
+      error: error instanceof Error ? error.message : String(error),
+    })
+  }
+
   /**
    * Tell the TM whether to bother snapshotting + broadcasting. Toggled on
    * 0↔1 transitions of the client socket count: when no UI is watching, the
@@ -454,7 +490,15 @@ export async function runDaemon(): Promise<void> {
                     message.payload.assistant,
                     [message.payload.command, ...(message.payload.args ?? [])].join(' ')
                   )
-                  await manager.createTab({ ...message.payload, sessionId })
+                  // Inject the hook bridge env so Claude Code's hooks can
+                  // call back into our status loop. Safe to add for every
+                  // assistant: non-Claude binaries simply ignore the vars.
+                  // We pass the URL *file path*, not the URL itself, so the
+                  // bridge can pick up a fresh URL after a daemon restart
+                  // even on PTYs that outlive this daemon process.
+                  const env: Record<string, string> = { AIMUX_PANE_ID: message.payload.tabId }
+                  if (hookServer) env.AIMUX_HOOK_URL_FILE = hookUrlFilePath
+                  await manager.createTab({ ...message.payload, env, sessionId })
                   sendOk(socket, message.id)
                   logDebug('daemon.request.createTab.success', {
                     sessionId,
@@ -577,6 +621,16 @@ export async function runDaemon(): Promise<void> {
   const gracefulShutdown = (signal: string) => {
     logDebug(`daemon.${signal}`)
     statusLoop.stop()
+    if (hookServer) {
+      void hookServer.stop()
+      try {
+        if (existsSync(hookUrlFilePath)) unlinkSync(hookUrlFilePath)
+      } catch (error) {
+        logDebug('daemon.hookServer.urlFileCleanupFailed', {
+          error: error instanceof Error ? error.message : String(error),
+        })
+      }
+    }
     manager.destroy()
     server.close()
     process.exit(0)

package/src/daemon/runtime-paths.ts

@@ -38,6 +38,15 @@ export function getTerminalManagerSocketPath(): string {
   return join(ensureRuntimeDir(), 'terminal-manager.sock')
 }
 
+/**
+ * File the daemon writes its current Claude hook server URL into. Stable path
+ * per profile, so PTYs spawned by a previous daemon can still resolve the
+ * URL of a freshly-restarted daemon by reading this file on every invocation.
+ */
+export function getClaudeHookUrlFilePath(): string {
+  return join(ensureRuntimeDir(), 'claude-hook.url')
+}
+
 export function ensureParentDir(filePath: string): void {
   mkdirSync(dirname(filePath), { recursive: true })
 }

package/src/daemon/session-registry.ts

@@ -129,6 +129,8 @@ export class SessionRegistry extends EventEmitter<SessionRegistryEvents> {
     cols: number
     rows: number
     cwd?: string
+    /** Extra env injected into the spawned shell. Passed through to the PTY. */
+    env?: Record<string, string>
   }): void {
     logDebug('daemon.registry.createSession', {
       args: options.args ?? [],

package/src/index.tsx

@@ -13,6 +13,7 @@ import { runRestartTerminalManager } from './restart-terminal-manager'
 import { createSessionBackend } from './session-backend/bootstrap'
 import { runTerminalManager } from './terminal-manager/terminal-manager'
 import { BreakingUpdateScreen } from './ui/breaking-update-screen'
+import { setHostPalette } from './ui/host-palette'
 import { runUpdate } from './update'
 
 const command = process.argv[2]
@@ -65,6 +66,19 @@ const renderer = await createCliRenderer({
   useMouse: true,
 })
 
+// Query the host terminal's actual ANSI palette (OSC 4) so PTY cells that
+// emit indexed colors render with the user's configured terminal theme
+// instead of hardcoded xterm defaults. Best-effort: terminals that don't
+// respond keep the fallback xterm palette.
+try {
+  const { palette } = await renderer.getPalette({ size: 256, timeout: 200 })
+  setHostPalette(palette)
+} catch (error) {
+  logDebug('index.paletteDetectFailed', {
+    message: error instanceof Error ? error.message : String(error),
+  })
+}
+
 const root = createRoot(renderer)
 
 const resolvedConfig = await loadUserConfig()

package/src/integrations/claude-hook-server.ts

@@ -0,0 +1,99 @@
+// Local HTTP server that receives Claude Code hook events from the shipped
+// shell bridge (assets/claude-hooks/aimux-agent-state.sh). Bound to 127.0.0.1
+// on an OS-assigned port; the URL is injected into each PTY via
+// `AIMUX_HOOK_URL` so the bridge knows where to POST.
+//
+// The body is the Claude hook payload (see https://code.claude.com/docs/en/hooks.md)
+// augmented with `aimuxPaneId` by the shell bridge. We forward minimal info
+// to the daemon's status loop, which performs the actual hook → activity
+// mapping in assistant-status-arbiter.
+
+import { logDebug } from '../debug/input-log'
+
+export interface ClaudeHookEvent {
+  paneId: string
+  hookEventName: string
+  /** Raw payload from Claude, keyed by hook event. */
+  payload: Record<string, unknown>
+  receivedAt: number
+}
+
+export interface ClaudeHookServer {
+  url: string
+  stop: () => Promise<void>
+}
+
+function pickString(value: unknown): string {
+  return typeof value === 'string' ? value : ''
+}
+
+/**
+ * Start the hook ingestion server. Throws if Bun.serve is unavailable (e.g.
+ * running under plain Node). The daemon catches that and logs — detection
+ * falls back to the visual PTY scanner.
+ */
+export function startClaudeHookServer(options: {
+  onEvent: (event: ClaudeHookEvent) => void
+}): ClaudeHookServer {
+  if (typeof Bun === 'undefined' || typeof Bun.serve !== 'function') {
+    throw new Error('claude-hook-server requires Bun.serve')
+  }
+
+  const handle = Bun.serve({
+    fetch: async (req) => {
+      const url = new URL(req.url)
+      if (req.method !== 'POST' || url.pathname !== '/hook/claude') {
+        return new Response('Not Found', { status: 404 })
+      }
+      let body: unknown
+      try {
+        body = await req.json()
+      } catch {
+        return new Response('Bad JSON', { status: 400 })
+      }
+      if (typeof body !== 'object' || body === null || Array.isArray(body)) {
+        return new Response('Body must be an object', { status: 400 })
+      }
+      const record = body as Record<string, unknown>
+      const paneId = pickString(record.aimuxPaneId)
+      const hookEventName = pickString(record.hook_event_name)
+      if (paneId === '' || hookEventName === '') {
+        return new Response('Missing aimuxPaneId or hook_event_name', { status: 400 })
+      }
+      try {
+        options.onEvent({
+          hookEventName,
+          paneId,
+          payload: record,
+          receivedAt: Date.now(),
+        })
+      } catch (error) {
+        logDebug('claudeHookServer.dispatchError', {
+          error: error instanceof Error ? error.message : String(error),
+          hookEventName,
+          paneId,
+        })
+      }
+      return new Response('ok', { status: 200 })
+    },
+    hostname: '127.0.0.1',
+    port: 0,
+  })
+
+  const port = handle.port
+  const url = `http://127.0.0.1:${port}/hook/claude`
+  logDebug('claudeHookServer.listening', { url })
+
+  return {
+    stop: async () => {
+      try {
+        await handle.stop(true)
+      } catch (error) {
+        logDebug('claudeHookServer.stopError', {
+          error: error instanceof Error ? error.message : String(error),
+        })
+      }
+    },
+    url,
+  }
+}

package/src/integrations/claude-hooks-install.ts

@@ -0,0 +1,199 @@
+// Patch `~/.claude/settings.json` so Claude Code invokes aimux's hook bridge
+// for the lifecycle events that drive per-tab activity detection. Idempotent:
+// existing aimux entries (marked via `__aimux: true`) are replaced; unrelated
+// hooks the user has configured are preserved.
+//
+// Hooks reference: https://code.claude.com/docs/en/hooks.md
+
+import { existsSync, mkdirSync, readFileSync, renameSync, unlinkSync, writeFileSync } from 'node:fs'
+import { homedir } from 'node:os'
+import { dirname, join, resolve } from 'node:path'
+import { fileURLToPath } from 'node:url'
+
+import { logDebug } from '../debug/input-log'
+
+const HOOK_EVENTS = [
+  'UserPromptSubmit',
+  'PreToolUse',
+  'PostToolUse',
+  'Stop',
+  'SubagentStop',
+  'Notification',
+] as const
+
+type HookEvent = (typeof HOOK_EVENTS)[number]
+
+interface HookCommandEntry {
+  type: 'command'
+  command: string
+  __aimux?: true
+}
+
+interface HookGroupEntry {
+  matcher?: string
+  hooks: HookCommandEntry[]
+}
+
+function claudeDir(): string {
+  return join(homedir(), '.claude')
+}
+
+function settingsFilePath(): string {
+  return join(claudeDir(), 'settings.json')
+}
+
+function writeAtomic(target: string, contents: string): void {
+  const tmp = `${target}.aimux.tmp`
+  writeFileSync(tmp, contents, 'utf8')
+  try {
+    renameSync(tmp, target)
+  } catch (error) {
+    try {
+      unlinkSync(tmp)
+    } catch {
+      /* ignore */
+    }
+    throw error
+  }
+}
+
+function logSyncWarn(reason: string, details?: Record<string, unknown>): void {
+  logDebug('claude-hooks-install:warn', { reason, ...details })
+}
+
+/**
+ * Absolute path to the shipped hook script. Resolved from this module's URL so
+ * it works from the install directory regardless of how aimux was launched.
+ * Walks up from `src/integrations` / built equivalent until it finds the
+ * `assets/claude-hooks` directory.
+ */
+export function resolveHookScriptPath(): string | null {
+  const here = dirname(fileURLToPath(import.meta.url))
+  const candidates = [
+    resolve(here, '..', '..', 'assets', 'claude-hooks', 'aimux-agent-state.sh'),
+    resolve(here, '..', '..', '..', 'assets', 'claude-hooks', 'aimux-agent-state.sh'),
+    resolve(here, '..', 'assets', 'claude-hooks', 'aimux-agent-state.sh'),
+  ]
+  for (const candidate of candidates) {
+    if (existsSync(candidate)) return candidate
+  }
+  logSyncWarn('hook-script-not-found', { candidates })
+  return null
+}
+
+function isHookCommandEntry(value: unknown): value is HookCommandEntry {
+  return (
+    typeof value === 'object' &&
+    value !== null &&
+    (value as { type?: unknown }).type === 'command' &&
+    typeof (value as { command?: unknown }).command === 'string'
+  )
+}
+
+function isHookGroupEntry(value: unknown): value is HookGroupEntry {
+  if (typeof value !== 'object' || value === null) return false
+  const hooks = (value as { hooks?: unknown }).hooks
+  return Array.isArray(hooks)
+}
+
+function isAimuxEntry(entry: HookGroupEntry): boolean {
+  return entry.hooks.some((hook) => {
+    if (!isHookCommandEntry(hook)) return false
+    if (hook.__aimux === true) return true
+    return hook.command.includes('aimux-agent-state')
+  })
+}
+
+function buildAimuxEntry(event: HookEvent, scriptPath: string): HookGroupEntry {
+  // PreToolUse / PostToolUse expect a tool matcher. `*` matches every tool.
+  // The other events ignore `matcher` entirely.
+  const needsMatcher = event === 'PreToolUse' || event === 'PostToolUse'
+  return {
+    ...(needsMatcher ? { matcher: '*' } : {}),
+    hooks: [{ __aimux: true, command: scriptPath, type: 'command' }],
+  }
+}
+
+/**
+ * Idempotently install aimux hook entries into `~/.claude/settings.json`.
+ * Returns true when settings were written (or already correct), false on a
+ * hard failure that should be logged. Errors never throw — a failed install
+ * just means activity detection falls back to the visual detector.
+ */
+export function ensureClaudeSettingsHooks(): boolean {
+  const scriptPath = resolveHookScriptPath()
+  if (scriptPath === null || scriptPath === '') return false
+
+  const target = settingsFilePath()
+
+  let parsed: Record<string, unknown> = {}
+  if (existsSync(target)) {
+    let raw: string
+    try {
+      raw = readFileSync(target, 'utf8')
+    } catch (error) {
+      logSyncWarn('settings-read-failed', { err: String(error), path: target })
+      return false
+    }
+    if (raw.trim().length > 0) {
+      try {
+        const json = JSON.parse(raw) as unknown
+        if (typeof json !== 'object' || json === null || Array.isArray(json)) {
+          logSyncWarn('settings-not-object', { path: target })
+          return false
+        }
+        parsed = json as Record<string, unknown>
+      } catch (error) {
+        logSyncWarn('settings-parse-failed', { err: String(error), path: target })
+        return false
+      }
+    }
+  }
+
+  const existingHooks = (
+    typeof parsed.hooks === 'object' && parsed.hooks !== null && !Array.isArray(parsed.hooks)
+      ? parsed.hooks
+      : {}
+  ) as Record<string, unknown>
+
+  const nextHooks: Record<string, HookGroupEntry[]> = {}
+  let changed = false
+
+  for (const event of HOOK_EVENTS) {
+    const raw = existingHooks[event]
+    const arr: HookGroupEntry[] = Array.isArray(raw) ? raw.filter(isHookGroupEntry) : []
+    const filtered = arr.filter((entry) => !isAimuxEntry(entry))
+    const desired = buildAimuxEntry(event, scriptPath)
+    const next = [...filtered, desired]
+    nextHooks[event] = next
+    if (!arraysShallowEqual(arr, next)) changed = true
+  }
+
+  // Preserve any non-aimux hook events the user already had.
+  for (const [event, value] of Object.entries(existingHooks)) {
+    if (HOOK_EVENTS.includes(event as HookEvent)) continue
+    if (Array.isArray(value)) nextHooks[event] = value as HookGroupEntry[]
+  }
+
+  if (!changed && parsed.hooks !== undefined) return true
+
+  parsed.hooks = nextHooks
+
+  try {
+    mkdirSync(claudeDir(), { recursive: true })
+    writeAtomic(target, `${JSON.stringify(parsed, null, 2)}\n`)
+    logDebug('claude-hooks-install:wrote', { events: HOOK_EVENTS, path: target, scriptPath })
+    return true
+  } catch (error) {
+    logSyncWarn('settings-write-failed', { err: String(error), path: target })
+    return false
+  }
+}
+
+function arraysShallowEqual<T>(a: T[], b: T[]): boolean {
+  if (a.length !== b.length) return false
+  for (let i = 0; i < a.length; i++) {
+    if (JSON.stringify(a[i]) !== JSON.stringify(b[i])) return false
+  }
+  return true
+}