@brimveyn/aimux 1.19.4 → 1.19.5

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@brimveyn/aimux",
-  "version": "1.19.4",
+  "version": "1.19.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",
@@ -64,7 +64,7 @@
     "bump:terminal_manager": "bun run scripts/bump-protocol.ts terminal-manager"
   },
   "dependencies": {
-    "@brimveyn/aimux-config": "0.8.2",
+    "@brimveyn/aimux-config": "0.8.3",
     "@opentui/core": "^0.1.90",
     "@opentui/react": "^0.1.90",
     "@resvg/resvg-wasm": "^2.6.2",

package/src/git/diff-limits.ts

@@ -0,0 +1,8 @@
+// Git plumbing and Bun's file API both hand a blob back as a single JS string. Past
+// JavaScriptCore's string cap the allocation does not throw — it aborts the process
+// with SIGTRAP, which no try/catch can intercept and which takes the whole TUI down
+// with it. Every read of file content in the git layer is gated on this.
+//
+// 5 MB covers source files and mid-sized CSVs. Anything past it is a build artefact
+// or a download, and nobody reviews those line-by-line.
+export const MAX_DIFF_BYTES = 5 * 1024 * 1024

package/src/git/git-diff.ts

@@ -2,6 +2,7 @@ import { $ } from 'bun'
 
 import type { DiffData, DiffFileStatus, GitFileEntry } from '../state/types'
 
+import { MAX_DIFF_BYTES } from './diff-limits'
 import { imageFormatLabel, imageMimeFromPath, isImagePath } from './image-detect'
 
 function resolveStatus(entry: GitFileEntry): { status: DiffFileStatus; oldPath?: string } {
@@ -15,19 +16,37 @@ function resolveStatus(entry: GitFileEntry): { status: DiffFileStatus; oldPath?:
   return { status: 'modified' }
 }
 
+// numstat marks a binary file by replacing both line counts with a dash.
+function numstatSaysBinary(text: string): boolean {
+  const first = text.trim().split('\n')[0] ?? ''
+  return first.startsWith('-\t-\t')
+}
+
 async function isBinary(cwd: string, ref: string, path: string): Promise<boolean> {
-  const result = await $`git -C ${cwd} diff ${ref} --numstat -- ${path}`.quiet().nothrow()
-  if (result.exitCode !== 0) return false
-  const text = result.text().trim()
+  const tracked = await $`git -C ${cwd} diff ${ref} --numstat -- ${path}`.quiet().nothrow()
+  if (tracked.exitCode === 0) {
+    const text = tracked.text().trim()
+    if (text) return numstatSaysBinary(text)
+  }
+  // An untracked path is absent from `git diff <ref>` altogether, so the probe above
+  // comes back empty and says nothing about it. Compare against /dev/null to classify
+  // it — without this, every untracked binary reads as text and gets slurped as one
+  // string.
+  const untracked = await $`git -C ${cwd} diff --no-index --numstat /dev/null -- ${path}`
+    .quiet()
+    .nothrow()
+  const text = untracked.text().trim()
   if (!text) return false
-  const first = text.split('\n')[0] ?? ''
-  return first.startsWith('-\t-\t')
+  return numstatSaysBinary(text)
 }
 
 async function readHeadSize(cwd: string, ref: string, path: string): Promise<number> {
-  const result = await $`git -C ${cwd} show ${ref}:${path}`.quiet().nothrow()
+  // `cat-file -s` reads the blob header only. `git show` would materialise the entire
+  // blob as a string just to measure it — the very thing MAX_DIFF_BYTES exists to stop.
+  const result = await $`git -C ${cwd} cat-file -s ${ref}:${path}`.quiet().nothrow()
   if (result.exitCode !== 0) return 0
-  return result.text().length
+  const size = Number.parseInt(result.text().trim(), 10)
+  return Number.isFinite(size) ? size : 0
 }
 
 async function readWorkingSize(cwd: string, path: string): Promise<number> {
@@ -91,6 +110,22 @@ function resolveCompareRef(headOffset: number, compareRef: string | undefined):
   return headOffset > 0 ? `HEAD~${headOffset}` : 'HEAD'
 }
 
+// Both sides are measured from metadata only (blob header + stat), never by reading
+// content — the sizes are what decide whether reading content is safe at all.
+async function diffSizes(
+  cwd: string,
+  ref: string,
+  path: string,
+  headPath: string,
+  status: DiffFileStatus
+): Promise<{ after: number; before: number }> {
+  const [before, after] = await Promise.all([
+    status === 'new' ? Promise.resolve(0) : readHeadSize(cwd, ref, headPath),
+    status === 'deleted' ? Promise.resolve(0) : readWorkingSize(cwd, path),
+  ])
+  return { after, before }
+}
+
 export async function fetchDiff(
   cwd: string,
   file: GitFileEntry,
@@ -99,9 +134,31 @@ export async function fetchDiff(
 ): Promise<DiffData> {
   const { oldPath, status } = resolveStatus(file)
   const ref = resolveCompareRef(headOffset, compareRef)
+  const headPath = oldPath ?? file.path
+
+  const { after: sizeAfter, before: sizeBefore } = await diffSizes(
+    cwd,
+    ref,
+    file.path,
+    headPath,
+    status
+  )
+
+  // Ahead of the image branch on purpose: a multi-gigabyte .png must not be read
+  // into memory either.
+  if (sizeBefore > MAX_DIFF_BYTES || sizeAfter > MAX_DIFF_BYTES) {
+    const data: DiffData = {
+      binarySizeAfter: sizeAfter,
+      binarySizeBefore: sizeBefore,
+      path: file.path,
+      rawDiff: '',
+      status: 'too-large',
+    }
+    if (oldPath != null && oldPath !== '') data.oldPath = oldPath
+    return data
+  }
 
   if (isImagePath(file.path)) {
-    const headPath = oldPath ?? file.path
     const wantsBefore = status !== 'new'
     const wantsAfter = status !== 'deleted'
     const [imageBytesBefore, imageBytesAfter] = await Promise.all([
@@ -124,13 +181,9 @@ export async function fetchDiff(
   }
 
   if (await isBinary(cwd, ref, file.path)) {
-    const [binarySizeBefore, binarySizeAfter] = await Promise.all([
-      readHeadSize(cwd, ref, file.path),
-      readWorkingSize(cwd, file.path),
-    ])
     return {
-      binarySizeAfter,
-      binarySizeBefore,
+      binarySizeAfter: sizeAfter,
+      binarySizeBefore: sizeBefore,
       path: file.path,
       rawDiff: '',
       status: 'binary',

package/src/git/git-status.ts

@@ -8,6 +8,8 @@ import type {
   GitRefreshPayload,
 } from '../state/types'
 
+import { MAX_DIFF_BYTES } from './diff-limits'
+
 interface NumstatRow {
   added: number | null
   removed: number | null
@@ -163,6 +165,11 @@ async function countUntrackedLines(cwd: string, path: string): Promise<number |
   try {
     const file = Bun.file(`${cwd}/${path}`)
     if (!(await file.exists())) return null
+    // Size gate before the read, not after: `.text()` aborts the process on an
+    // oversized blob rather than throwing, so the catch below would never run. Callers
+    // treat null as "no count available", which is the honest answer for a 3 GB
+    // download sitting untracked in the working tree.
+    if (file.size > MAX_DIFF_BYTES) return null
     const text = await file.text()
     if (text.length === 0) return 0
     let count = 0

package/src/state/types.ts

@@ -262,7 +262,14 @@ export interface GitPanelState {
   error: GitPanelError | null
 }
 
-export type DiffFileStatus = 'modified' | 'new' | 'deleted' | 'binary' | 'renamed' | 'image'
+export type DiffFileStatus =
+  | 'modified'
+  | 'new'
+  | 'deleted'
+  | 'binary'
+  | 'renamed'
+  | 'image'
+  | 'too-large'
 
 export interface DiffData {
   path: string

package/src/ui/components/git/git-view.tsx

@@ -7,6 +7,7 @@ import type { DiffData, GitDiffView } from '../../../state/types'
 import type { ThemeId } from '../../themes'
 
 import { diffHash } from '../../../git/diff-hash'
+import { MAX_DIFF_BYTES } from '../../../git/diff-limits'
 import { getMergeBase } from '../../../git/divergence'
 import { fetchDiff } from '../../../git/git-diff'
 import { useGitPanelPolling } from '../../../git/git-poller'
@@ -21,6 +22,7 @@ import { PierreDiff, type PierreDiffHandle } from './diff-renderer'
 import { useDiffPrefetch } from './diff-renderer/use-diff-prefetch'
 import { GitPanel } from './git-panel'
 import { ImageDiffView } from './image-diff'
+import { formatBytes } from './image-diff/dimensions'
 import { GitPaneHeader } from './pane/git-pane-header'
 
 interface DiffStageProps {
@@ -33,6 +35,12 @@ interface DiffStageProps {
 }
 
 function placeholderText(diff: DiffData): string | null {
+  if (diff.status === 'too-large') {
+    const before = diff.binarySizeBefore ?? 0
+    const after = diff.binarySizeAfter ?? 0
+    const largest = Math.max(before, after)
+    return `(file too large to diff — ${formatBytes(largest)}, limit ${formatBytes(MAX_DIFF_BYTES)})`
+  }
   if (diff.status === 'binary') {
     const before = diff.binarySizeBefore ?? 0
     const after = diff.binarySizeAfter ?? 0

package/src/ui/components/git/image-diff/dimensions.ts

@@ -92,5 +92,6 @@ export function readImageDimensions(bytes: Uint8Array): ImageDimensions | null {
 export function formatBytes(n: number): string {
   if (n < 1024) return `${n} B`
   if (n < 1024 * 1024) return `${(n / 1024).toFixed(1)} KB`
-  return `${(n / (1024 * 1024)).toFixed(2)} MB`
+  if (n < 1024 * 1024 * 1024) return `${(n / (1024 * 1024)).toFixed(2)} MB`
+  return `${(n / (1024 * 1024 * 1024)).toFixed(2)} GB`
 }