@brimveyn/aimux 1.13.0 → 1.13.2

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@brimveyn/aimux",
-  "version": "1.13.0",
+  "version": "1.13.2",
   "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.0",
+    "@brimveyn/aimux-config": "0.6.2",
     "@opentui/core": "^0.1.90",
     "@opentui/react": "^0.1.90",
     "@resvg/resvg-wasm": "^2.6.2",

package/src/app-runtime/backend-attach-runtime.ts

@@ -109,14 +109,14 @@ export function attachCurrentSession({
   attachRequestIdRef.current = attachRequestId
   let cancelled = false
 
-  void backend
-    .attach({
-      cols: layoutRef.current.terminalCols,
-      rows: layoutRef.current.terminalRows,
-      sessionId: currentSessionId,
-      workspaceSnapshot: currentSessionWorkspaceSnapshot,
-    })
-    .then((result) => {
+  void (async () => {
+    try {
+      const result = await backend.attach({
+        cols: layoutRef.current.terminalCols,
+        rows: layoutRef.current.terminalRows,
+        sessionId: currentSessionId,
+        workspaceSnapshot: currentSessionWorkspaceSnapshot,
+      })
       if (cancelled || attachRequestIdRef.current !== attachRequestId) {
         return
       }
@@ -134,8 +134,7 @@ export function attachCurrentSession({
         layoutRef,
         backend
       )
-    })
-    .catch((error) => {
+    } catch (error) {
       if (cancelled || attachRequestIdRef.current !== attachRequestId) {
         return
       }
@@ -151,7 +150,8 @@ export function attachCurrentSession({
         layoutRef,
         backend
       )
-    })
+    }
+  })()
 
   return () => {
     cancelled = true

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

@@ -508,9 +508,21 @@ export function executeSideEffect(effect: SideEffect, ctx: SideEffectContext): v
         const worktreeName = state.modal.worktreeName
         const branchName = state.modal.branchName
         const sourceWorktreeId = getNewTabTargetWorktreeId(state)
-        void enqueueGitOp(async () =>
-          launchAssistantInNewWorktree(ctx, option.id, worktreeName, branchName, sourceWorktreeId)
-        ).catch((error) => toast.error(error instanceof Error ? error.message : String(error)))
+        void (async () => {
+          try {
+            await enqueueGitOp(async () =>
+              launchAssistantInNewWorktree(
+                ctx,
+                option.id,
+                worktreeName,
+                branchName,
+                sourceWorktreeId
+              )
+            )
+          } catch (error) {
+            toast.error(error instanceof Error ? error.message : String(error))
+          }
+        })()
         return
       }
       launchAssistant(ctx, option.id, getNewTabTargetWorktreeId(state))
@@ -534,44 +546,54 @@ export function executeSideEffect(effect: SideEffect, ctx: SideEffectContext): v
       return
     }
     case 'delete-worktree': {
-      void enqueueGitOp(async () =>
-        runDeleteWorktree(
-          { ...ctx, state: ctx.getState() },
-          effect.sessionId,
-          effect.worktreeId,
-          !!(effect.force === true)
-        )
-      ).catch((error) => {
-        const message = error instanceof Error ? error.message : String(error)
-        const forceable = isForceableWorktreeDeleteError(message)
-        const latest = ctx.getState()
-        if (latest.modal.type === 'new-tab' && latest.modal.step === 'worktree') {
-          const session = latest.sessions.find((entry) => entry.id === effect.sessionId)
-          const selected = session?.worktrees?.[latest.modal.selectedIndex]
-          if (selected && selected.id !== effect.worktreeId) {
-            ctx.dispatch({ message, type: 'git-mode-set-message' })
-            return
+      void (async () => {
+        try {
+          await enqueueGitOp(async () =>
+            runDeleteWorktree(
+              { ...ctx, state: ctx.getState() },
+              effect.sessionId,
+              effect.worktreeId,
+              !!(effect.force === true)
+            )
+          )
+        } catch (error) {
+          const message = error instanceof Error ? error.message : String(error)
+          const forceable = isForceableWorktreeDeleteError(message)
+          const latest = ctx.getState()
+          if (latest.modal.type === 'new-tab' && latest.modal.step === 'worktree') {
+            const session = latest.sessions.find((entry) => entry.id === effect.sessionId)
+            const selected = session?.worktrees?.[latest.modal.selectedIndex]
+            if (selected && selected.id !== effect.worktreeId) {
+              ctx.dispatch({ message, type: 'git-mode-set-message' })
+              return
+            }
           }
+          ctx.dispatch({
+            confirmWorktreeId: forceable ? effect.worktreeId : null,
+            message: forceable ? message : `Could not delete worktree: ${message}`,
+            type: 'set-new-tab-worktree-delete-state',
+          })
+          ctx.dispatch({ message, type: 'git-mode-set-message' })
         }
-        ctx.dispatch({
-          confirmWorktreeId: forceable ? effect.worktreeId : null,
-          message: forceable ? message : `Could not delete worktree: ${message}`,
-          type: 'set-new-tab-worktree-delete-state',
-        })
-        ctx.dispatch({ message, type: 'git-mode-set-message' })
-      })
+      })()
       return
     }
     case 'move-worktree': {
-      void enqueueGitOp(async () =>
-        runMoveWorktree(
-          { ...ctx, state: ctx.getState() },
-          effect.sessionId,
-          effect.sourceWorktreeId,
-          effect.targetWorktreeId,
-          effect.deleteSource === true
-        )
-      ).catch((error) => toast.error(error instanceof Error ? error.message : String(error)))
+      void (async () => {
+        try {
+          await enqueueGitOp(async () =>
+            runMoveWorktree(
+              { ...ctx, state: ctx.getState() },
+              effect.sessionId,
+              effect.sourceWorktreeId,
+              effect.targetWorktreeId,
+              effect.deleteSource === true
+            )
+          )
+        } catch (error) {
+          toast.error(error instanceof Error ? error.message : String(error))
+        }
+      })()
       return
     }
     case 'open-rename-selected-session': {
@@ -1364,14 +1386,15 @@ function runUpdateFromTui(ctx: SideEffectContext, latestVersion: string): void {
     stdin: 'inherit',
     stdout: 'inherit',
   })
-  void proc.exited.then((code) => {
+  void (async () => {
+    const code = await proc.exited
     if (code === 0) {
       process.stdout.write(`\nUpdated. Run \`aimux\` to start the new version.\n`)
     } else {
       process.stderr.write(`\nUpdate failed (exit code ${code}).\n`)
     }
     process.exit(code ?? 1)
-  })
+  })()
 }
 
 async function runGitAction(

package/src/daemon/daemon.ts

@@ -293,12 +293,16 @@ export async function runDaemon(): Promise<void> {
    * previous broadcast state, matching pre-fix behaviour).
    */
   const updateTmBroadcastForClientCount = (count: number): void => {
-    void manager.setBroadcastEnabled(count > 0).catch((error) => {
-      logDebug('daemon.setBroadcastEnabled.error', {
-        count,
-        error: error instanceof Error ? error.message : String(error),
-      })
-    })
+    void (async () => {
+      try {
+        await manager.setBroadcastEnabled(count > 0)
+      } catch (error) {
+        logDebug('daemon.setBroadcastEnabled.error', {
+          count,
+          error: error instanceof Error ? error.message : String(error),
+        })
+      }
+    })()
   }
 
   // Initial state: no clients yet, ask the TM to suspend broadcast.
@@ -317,7 +321,13 @@ export async function runDaemon(): Promise<void> {
     let processing: Promise<void> = Promise.resolve()
 
     socket.on('data', (chunk) => {
-      processing = processing.then(async () => {
+      const previous = processing
+      processing = (async () => {
+        try {
+          await previous
+        } catch {
+          // A prior chunk's failure shouldn't block later chunks on this socket.
+        }
         try {
           for (const message of decoder.push(chunk)) {
             try {
@@ -556,7 +566,7 @@ export async function runDaemon(): Promise<void> {
           decoder.reset()
           send(socket, { id: crypto.randomUUID(), payload: { message }, type: 'error' })
         }
-      })
+      })()
     })
 
     socket.on('close', () => {

package/src/git/command-queue.ts

@@ -1,7 +1,23 @@
 let tail: Promise<unknown> = Promise.resolve()
 
 export async function enqueueGitOp<T>(op: () => Promise<T>): Promise<T> {
-  const next = tail.then(op, op)
-  tail = next.catch(() => {})
+  const previous = tail
+  const run = async (): Promise<T> => {
+    try {
+      await previous
+    } catch {
+      // Previous op already surfaced its own failure; keep the queue moving.
+    }
+    return op()
+  }
+  const next = run()
+  // Advance the queue tail without letting this op's rejection break the chain.
+  tail = (async () => {
+    try {
+      await next
+    } catch {
+      // Swallow so the next enqueued op still runs.
+    }
+  })()
   return next
 }

package/src/session-backend/remote-session-backend.ts

@@ -144,6 +144,17 @@ export class RemoteSessionBackend
     }
   }
 
+  /** Fire-and-forget a command, reporting any failure via reportCommandError. */
+  private dispatchCommand(request: ClientRequest, context: string, tabId?: string): void {
+    void (async () => {
+      try {
+        await this.sendExpectOk(request)
+      } catch (error) {
+        this.reportCommandError(context, error, tabId)
+      }
+    })()
+  }
+
   private handleServerEvent(message: ServerEvent): void {
     logDebug('backend.remote.event', { type: message.type })
     switch (message.type) {
@@ -352,8 +363,10 @@ export class RemoteSessionBackend
       return
     }
 
-    void this.sendExpectOk({ id: crypto.randomUUID(), payload: options, type: 'createTab' }).catch(
-      (error) => this.reportCommandError('createTab', error, options.tabId)
+    this.dispatchCommand(
+      { id: crypto.randomUUID(), payload: options, type: 'createTab' },
+      'createTab',
+      options.tabId
     )
   }
 
@@ -362,55 +375,54 @@ export class RemoteSessionBackend
       logDebug('backend.remote.skipWriteBeforeAttach', { inputLength: input.length, tabId })
       return
     }
-    void this.sendExpectOk({
-      id: crypto.randomUUID(),
-      payload: { data: input, tabId },
-      type: 'write',
-    }).catch((error) => this.reportCommandError('write', error, tabId))
+    this.dispatchCommand(
+      { id: crypto.randomUUID(), payload: { data: input, tabId }, type: 'write' },
+      'write',
+      tabId
+    )
   }
 
   scrollViewport(tabId: string, deltaLines: number): void {
     if (!this.attached) {
       return
     }
-    void this.sendExpectOk({
-      id: crypto.randomUUID(),
-      payload: { deltaLines, tabId },
-      type: 'scroll',
-    }).catch((error) => this.reportCommandError('scroll', error, tabId))
+    this.dispatchCommand(
+      { id: crypto.randomUUID(), payload: { deltaLines, tabId }, type: 'scroll' },
+      'scroll',
+      tabId
+    )
   }
 
   scrollViewportToBottom(tabId: string): void {
     if (!this.attached) {
       return
     }
-    void this.sendExpectOk({
-      id: crypto.randomUUID(),
-      payload: { tabId },
-      type: 'scrollToBottom',
-    }).catch((error) => this.reportCommandError('scrollToBottom', error, tabId))
+    this.dispatchCommand(
+      { id: crypto.randomUUID(), payload: { tabId }, type: 'scrollToBottom' },
+      'scrollToBottom',
+      tabId
+    )
   }
 
   reapplyScrollIntent(tabId: string, intent: ScrollIntent): void {
     if (!this.attached) {
       return
     }
-    void this.sendExpectOk({
-      id: crypto.randomUUID(),
-      payload: { intent, tabId },
-      type: 'reapplyScrollIntent',
-    }).catch((error) => this.reportCommandError('reapplyScrollIntent', error, tabId))
+    this.dispatchCommand(
+      { id: crypto.randomUUID(), payload: { intent, tabId }, type: 'reapplyScrollIntent' },
+      'reapplyScrollIntent',
+      tabId
+    )
   }
 
   setActiveTab(tabId: string | null): void {
     if (!this.attached) {
       return
     }
-    void this.sendExpectOk({
-      id: crypto.randomUUID(),
-      payload: { tabId },
-      type: 'setActiveTab',
-    }).catch((error) => this.reportCommandError('setActiveTab', error))
+    this.dispatchCommand(
+      { id: crypto.randomUUID(), payload: { tabId }, type: 'setActiveTab' },
+      'setActiveTab'
+    )
   }
 
   resizeAll(
@@ -425,11 +437,14 @@ export class RemoteSessionBackend
     }
     logDebug('backend.remote.resize', { cols, rows, sessionId: this.currentSessionId })
     const intentsRecord = intents ? Object.fromEntries(intents.entries()) : undefined
-    void this.sendExpectOk({
-      id: crypto.randomUUID(),
-      payload: { cols, intents: intentsRecord, rows },
-      type: 'resizeClient',
-    }).catch((error) => this.reportCommandError('resizeClient', error))
+    this.dispatchCommand(
+      {
+        id: crypto.randomUUID(),
+        payload: { cols, intents: intentsRecord, rows },
+        type: 'resizeClient',
+      },
+      'resizeClient'
+    )
   }
 
   resizeTab(
@@ -442,19 +457,21 @@ export class RemoteSessionBackend
     if (!this.attached) {
       return
     }
-    void this.sendExpectOk({
-      id: crypto.randomUUID(),
-      payload: { cols, intent, rows, tabId },
-      type: 'resizeTab',
-    }).catch((error) => this.reportCommandError('resizeTab', error, tabId))
+    this.dispatchCommand(
+      { id: crypto.randomUUID(), payload: { cols, intent, rows, tabId }, type: 'resizeTab' },
+      'resizeTab',
+      tabId
+    )
   }
 
   disposeSession(tabId: string): void {
     if (!this.attached) {
       return
     }
-    void this.sendExpectOk({ id: crypto.randomUUID(), payload: { tabId }, type: 'closeTab' }).catch(
-      (error) => this.reportCommandError('closeTab', error, tabId)
+    this.dispatchCommand(
+      { id: crypto.randomUUID(), payload: { tabId }, type: 'closeTab' },
+      'closeTab',
+      tabId
     )
   }
 
@@ -462,9 +479,7 @@ export class RemoteSessionBackend
     if (!this.attached) {
       return
     }
-    void this.sendExpectOk({ id: crypto.randomUUID(), payload: {}, type: 'disposeAll' }).catch(
-      (error) => this.reportCommandError('disposeAll', error)
-    )
+    this.dispatchCommand({ id: crypto.randomUUID(), payload: {}, type: 'disposeAll' }, 'disposeAll')
   }
 
   async destroy(keepSessions = true): Promise<void> {

package/src/ui/components/git/diff-renderer/fold-strip.tsx

@@ -1,3 +1,5 @@
+import { memo, useCallback } from 'react'
+
 import type { FoldDispatch } from './pierre-diff'
 
 import { useTheme } from '../../../theme'
@@ -8,7 +10,7 @@ interface Props {
   dispatch: FoldDispatch
 }
 
-function Button({ label, onPress }: { label: string; onPress: () => void }) {
+const Button = memo(function Button({ label, onPress }: { label: string; onPress: () => void }) {
   const t = useTheme()
   const bg = t.diffContextBg
   return (
@@ -16,7 +18,7 @@ function Button({ label, onPress }: { label: string; onPress: () => void }) {
       <text fg={t.primary}>{label}</text>
     </box>
   )
-}
+})
 
 function Spacer() {
   return <text> </text>
@@ -31,42 +33,47 @@ export function FoldStrip({ dispatch, fold }: Props) {
   const shrinkUp = Math.min(FOLD_STEP, topExpanded)
   const shrinkDown = Math.min(FOLD_STEP, bottomExpanded)
 
+  const handleExpandTop = useCallback(
+    () => dispatch.adjust(foldId, 'top', stepUp),
+    [dispatch, foldId, stepUp]
+  )
+  const handleExpandBottom = useCallback(
+    () => dispatch.adjust(foldId, 'bottom', stepDown),
+    [dispatch, foldId, stepDown]
+  )
+  const handleExpandAll = useCallback(
+    () => dispatch.set(foldId, total, 0),
+    [dispatch, foldId, total]
+  )
+  const handleShrinkTop = useCallback(
+    () => dispatch.adjust(foldId, 'top', -shrinkUp),
+    [dispatch, foldId, shrinkUp]
+  )
+  const handleShrinkBottom = useCallback(
+    () => dispatch.adjust(foldId, 'bottom', -shrinkDown),
+    [dispatch, foldId, shrinkDown]
+  )
+
   const controls: React.ReactNode[] = []
   if (hidden > 0) {
     controls.push(
-      <Button
-        key="up"
-        label={`↑${stepUp}`}
-        onPress={() => dispatch.adjust(foldId, 'top', stepUp)}
-      />,
+      <Button key="up" label={`↑${stepUp}`} onPress={handleExpandTop} />,
       <Spacer key="sp1" />,
-      <Button
-        key="down"
-        label={`↓${stepDown}`}
-        onPress={() => dispatch.adjust(foldId, 'bottom', stepDown)}
-      />,
+      <Button key="down" label={`↓${stepDown}`} onPress={handleExpandBottom} />,
       <Spacer key="sp2" />,
-      <Button key="all" label="⇅ all" onPress={() => dispatch.set(foldId, total, 0)} />
+      <Button key="all" label="⇅ all" onPress={handleExpandAll} />
     )
   }
   if (shrinkUp > 0) {
     controls.push(
       <Spacer key="sp3" />,
-      <Button
-        key="shrinkUp"
-        label={`−↑${shrinkUp}`}
-        onPress={() => dispatch.adjust(foldId, 'top', -shrinkUp)}
-      />
+      <Button key="shrinkUp" label={`−↑${shrinkUp}`} onPress={handleShrinkTop} />
     )
   }
   if (shrinkDown > 0) {
     controls.push(
       <Spacer key="sp4" />,
-      <Button
-        key="shrinkDown"
-        label={`−↓${shrinkDown}`}
-        onPress={() => dispatch.adjust(foldId, 'bottom', -shrinkDown)}
-      />
+      <Button key="shrinkDown" label={`−↓${shrinkDown}`} onPress={handleShrinkBottom} />
     )
   }
 

package/src/ui/components/git/diff-renderer/split-view.tsx

@@ -34,6 +34,30 @@ import { tokenToSpan } from './highlight'
 import { useSegmentVirtualization } from './use-segment-virtualization'
 
 const OVERSCAN = 24
+const COLUMN_CONTENT_OPTIONS = { flexDirection: 'column' as const, gap: 0 }
+const HIDDEN_SCROLLBAR_OPTIONS = { visible: false }
+
+// Stable per-row key derived from the line identities in the row, so rows keep a
+// consistent identity across fold expand/collapse rather than relying on position.
+function splitCellKey(cell: SplitCell): string {
+  switch (cell.type) {
+    case 'context':
+      return `c${cell.lineNumber}`
+    case 'addition':
+      return `a${cell.lineNumber}`
+    case 'deletion':
+      return `d${cell.lineNumber}`
+    case 'fold':
+      return `f${cell.fold.foldId}`
+    case 'filler':
+      return 'x'
+  }
+}
+
+function splitRowKey(row: SplitRowOrHeader): string {
+  if (row.type === 'hunk-header') return `hh:${row.spec}`
+  return `${splitCellKey(row.left)}|${splitCellKey(row.right)}`
+}
 
 export interface SplitViewHandle {
   leftScroll: ScrollBoxRenderable | null
@@ -154,15 +178,15 @@ export const SplitView = forwardRef<SplitViewHandle, Props>(function SplitView(
         flexGrow={1}
         scrollY
         viewportCulling
-        contentOptions={{ flexDirection: 'column', gap: 0 }}
-        verticalScrollbarOptions={{ visible: false }}
+        contentOptions={COLUMN_CONTENT_OPTIONS}
+        verticalScrollbarOptions={HIDDEN_SCROLLBAR_OPTIONS}
         onMouseScroll={handleScroll}
       >
         {visibleWindow.topSpacer > 0 ? <box height={visibleWindow.topSpacer} /> : null}
         {renderedSegments.map((rendered) =>
-          rendered.rows.map((row, i) => (
+          rendered.rows.map((row) => (
             <SideRow
-              key={`${rendered.segment.id}:left:${i}`}
+              key={`${rendered.segment.id}:left:${splitRowKey(row)}`}
               cell={row.type === 'row' ? row.left : null}
               foldDispatch={foldDispatch}
               gw={gw}
@@ -180,14 +204,14 @@ export const SplitView = forwardRef<SplitViewHandle, Props>(function SplitView(
         flexGrow={1}
         scrollY
         viewportCulling
-        contentOptions={{ flexDirection: 'column', gap: 0 }}
+        contentOptions={COLUMN_CONTENT_OPTIONS}
         onMouseScroll={handleScroll}
       >
         {visibleWindow.topSpacer > 0 ? <box height={visibleWindow.topSpacer} /> : null}
         {renderedSegments.map((rendered) =>
-          rendered.rows.map((row, i) => (
+          rendered.rows.map((row) => (
             <SideRow
-              key={`${rendered.segment.id}:right:${i}`}
+              key={`${rendered.segment.id}:right:${splitRowKey(row)}`}
               cell={row.type === 'row' ? row.right : null}
               foldDispatch={foldDispatch}
               gw={gw}
@@ -291,6 +315,8 @@ function LineContent({ content, tokens }: { content: string; tokens: ThemedToken
         if (s.italic === true) attributes |= TextAttributes.ITALIC
         if (s.underline === true) attributes |= TextAttributes.UNDERLINE
         return (
+          // Syntax tokens are positional within a single line and never reorder.
+          // eslint-disable-next-line react/no-array-index-key
           <span key={i} fg={s.fg ?? t.text} attributes={attributes}>
             {s.text}
           </span>

package/src/ui/components/git/diff-renderer/stacked-view.tsx

@@ -33,6 +33,24 @@ import { tokenToSpan } from './highlight'
 import { useSegmentVirtualization } from './use-segment-virtualization'
 
 const OVERSCAN = 24
+const COLUMN_CONTENT_OPTIONS = { flexDirection: 'column' as const, gap: 0 }
+
+// Stable per-row key derived from the line identities in the row, so rows keep a
+// consistent identity across fold expand/collapse rather than relying on position.
+function unifiedRowKey(row: UnifiedRowOrHeader): string {
+  switch (row.type) {
+    case 'hunk-header':
+      return `hh:${row.spec}`
+    case 'fold':
+      return `f:${row.fold.foldId}`
+    case 'context':
+      return `c:${row.delLineNumber}:${row.addLineNumber}`
+    case 'addition':
+      return `a:${row.lineNumber}`
+    case 'deletion':
+      return `d:${row.lineNumber}`
+  }
+}
 
 export interface StackedViewHandle {
   scroll: ScrollBoxRenderable | null
@@ -148,14 +166,14 @@ export const StackedView = forwardRef<StackedViewHandle, Props>(function Stacked
       flexGrow={1}
       scrollY
       viewportCulling
-      contentOptions={{ flexDirection: 'column', gap: 0 }}
+      contentOptions={COLUMN_CONTENT_OPTIONS}
       onMouseScroll={handleScroll}
     >
       {visibleWindow.topSpacer > 0 ? <box height={visibleWindow.topSpacer} /> : null}
       {renderedSegments.map((rendered) =>
-        rendered.rows.map((row, i) => (
+        rendered.rows.map((row) => (
           <UnifiedRowRender
-            key={`${rendered.segment.id}:${i}`}
+            key={`${rendered.segment.id}:${unifiedRowKey(row)}`}
             foldDispatch={foldDispatch}
             gw={gw}
             highlights={highlights}
@@ -236,6 +254,8 @@ function LineContent({ content, tokens }: { content: string; tokens: ThemedToken
         if (s.italic === true) attributes |= TextAttributes.ITALIC
         if (s.underline === true) attributes |= TextAttributes.UNDERLINE
         return (
+          // Syntax tokens are positional within a single line and never reorder.
+          // eslint-disable-next-line react/no-array-index-key
           <span key={i} fg={s.fg ?? t.text} attributes={attributes}>
             {s.text}
           </span>