@brimveyn/aimux 1.19.4 → 1.19.6

package/README.md

@@ -13,7 +13,7 @@ snippets, themes, and fully configurable keymaps.
 ## Features
 
 - multi-workspace workflow with a dedicated workspace picker
-- tabs for `claude`, `codex`, `opencode`, `grok`, and `terminal`
+- tabs for `claude`, `codex`, `opencode`, `grok`, `kimi`, and `terminal`
 - split panes with pane focus and resize shortcuts
 - persistent workspaces with saved layout and tab state
 - profile-isolated config, catalogs, daemon sockets, and runtime state

package/package.json

@@ -1,7 +1,7 @@
 {
   "name": "@brimveyn/aimux",
-  "version": "1.19.4",
-  "description": "A terminal multiplexer for AI CLIs. Run Claude, Codex, OpenCode side-by-side with tabbed navigation, split panes, and persistent sessions.",
+  "version": "1.19.6",
+  "description": "A terminal multiplexer for AI CLIs. Run Claude, Codex, OpenCode, Kimi side-by-side with tabbed navigation, split panes, and persistent sessions.",
   "keywords": [
     "ai",
     "aimux",
@@ -9,6 +9,7 @@
     "claude",
     "cli",
     "codex",
+    "kimi",
     "multiplexer",
     "opencode",
     "pty",
@@ -64,7 +65,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/auto-commit/headless-commands.ts

@@ -3,13 +3,14 @@ export interface HeadlessInvocation {
   args: string[]
 }
 
-export type SupportedProvider = 'claude' | 'codex' | 'opencode' | 'grok'
+export type SupportedProvider = 'claude' | 'codex' | 'opencode' | 'grok' | 'kimi'
 
 const SUPPORTED: ReadonlySet<string> = new Set<SupportedProvider>([
   'claude',
   'codex',
   'opencode',
   'grok',
+  'kimi',
 ])
 
 export function isSupportedProvider(id: string): id is SupportedProvider {
@@ -44,6 +45,13 @@ export function buildHeadlessInvocation(
       if (model != null && model !== '') args.push('-m', model)
       return { args, executable: 'grok' }
     }
+    case 'kimi': {
+      // Headless: kimi -p "<prompt>" [--model <model>]. Non-interactive mode uses
+      // auto permission by default; --output-format text is the default.
+      const args: string[] = ['-p', prompt]
+      if (model != null && model !== '') args.push('--model', model)
+      return { args, executable: 'kimi' }
+    }
     default:
       return null
   }

package/src/cli/commands/tab/create.ts

@@ -55,7 +55,7 @@ export const tabCreate: CliCommand = {
   flags: [
     ...SHARED_FLAGS,
     {
-      description: 'assistant id (claude, codex, opencode, grok, terminal, ...)',
+      description: 'assistant id (claude, codex, opencode, grok, kimi, terminal, ...)',
       kind: 'string',
       name: 'assistant',
     },

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/index.tsx

@@ -83,7 +83,7 @@ if (command === '--help' || command === '-h' || command === 'help') {
       '',
       'Common CLI verbs at a glance',
       '  aimux tab list                                     Enumerate tabs (+ activeTabId)',
-      '  aimux tab create --assistant <id> [--title …]      Spawn claude / codex / opencode / grok / terminal / …',
+      '  aimux tab create --assistant <id> [--title …]      Spawn claude / codex / opencode / grok / kimi / terminal / …',
       '  aimux tab send <tabId> [text] [--enter|--keys|--stdin]  Type, chord, or paste into a tab',
       '  aimux tab focus <tabId>                            Bring a tab to the foreground',
       '  aimux tab close <tabId>                            Terminate a tab',

package/src/pty/assistant-question-extractor.ts

@@ -44,6 +44,13 @@ const PERMISSION_SIGNALS: readonly string[] = [
   'pprove', // Grok stylized plan approval "[ a ] pprove ..."
   'grant',
   'press enter to confirm',
+  // Kimi Code CLI approval panel titles
+  'run this command?',
+  'write this file?',
+  'apply these edits?',
+  'ready to build with this plan?',
+  'approve for session',
+  'stop this task?',
 ]
 
 /**

package/src/pty/assistant-status-detector.ts

@@ -6,10 +6,10 @@
  * `src/detect.rs` in that repo.
  *
  * The detector classifies a terminal session as `working`, `waiting-input`,
- * or `idle`. Built-in CLIs (claude, codex, opencode, grok) have dedicated classify* functions.
- * tables. Custom CLIs fall back to a generic heuristic that (a) recognises
- * common shells as always-idle and (b) uses pane-tail change velocity plus
- * generic y/n / confirm prompt patterns.
+ * or `idle`. Built-in CLIs (claude, codex, opencode, grok, kimi) have dedicated
+ * classify* functions. Custom CLIs fall back to a generic heuristic that
+ * (a) recognises common shells as always-idle and (b) uses pane-tail change
+ * velocity plus generic y/n / confirm prompt patterns.
  */
 import type { AssistantId, TabActivity, TerminalSnapshot } from '../state/types'
 
@@ -140,6 +140,8 @@ function classifyBuiltin(
       return classifyOpencode(haystack)
     case 'grok':
       return classifyGrok(haystack, rawTail)
+    case 'kimi':
+      return classifyKimi(haystack, rawTail)
     default:
       return null
   }
@@ -255,6 +257,68 @@ function classifyGrok(haystack: string, _rawTail: string): TabActivity {
   return 'idle'
 }
 
+/** Braille spinner frames used by Kimi Code CLI (`BRAILLE_SPINNER_FRAMES`). */
+const KIMI_BRAILLE_SPINNER = '⠋⠙⠹⠸⠼⠴⠦⠧⠇⠏'
+/** Moon-phase spinner frames used by Kimi Code CLI (`MOON_SPINNER_FRAMES`). */
+const KIMI_MOON_SPINNER = '🌑🌒🌓🌔🌕🌖🌗🌘'
+
+/**
+ * Kimi Code CLI status heuristics from the official TUI:
+ * - Approval panel titles/footers → waiting-input
+ * - Braille/moon spinners, `working...`, rotating tips → working
+ */
+function classifyKimi(haystack: string, rawTail: string): TabActivity {
+  // Tool / plan approval panel (apps/kimi-code approval-panel.ts headers + footer).
+  if (
+    haystack.includes('run this command?') ||
+    haystack.includes('write this file?') ||
+    haystack.includes('apply these edits?') ||
+    haystack.includes('stop this task?') ||
+    haystack.includes('ready to build with this plan?') ||
+    haystack.includes('approve for session') ||
+    haystack.includes('approve for this session') ||
+    haystack.includes('type feedback') ||
+    haystack.includes('waiting for authorization') ||
+    haystack.includes('sign in to kimi') ||
+    haystack.includes('do you want') ||
+    haystack.includes('would you like') ||
+    haystack.includes('permission required') ||
+    haystack.includes('permission to') ||
+    haystack.includes('approve?') ||
+    haystack.includes('allow?') ||
+    // Generic "Approve <Tool>?" header, e.g. "▶ Approve Bash?"
+    (haystack.includes('approve ') && haystack.includes('?')) ||
+    // Distinctive panel chrome: "↑/↓ select · 1/2 choose · ↵ confirm"
+    haystack.includes('↑/↓ select') ||
+    haystack.includes('↵ confirm')
+  ) {
+    return 'waiting-input'
+  }
+
+  // Agent actively streaming / calling tools.
+  // Anchor thinking on ellipsis so the footer model suffix "thinking" alone
+  // (e.g. "kimi-k2 thinking") does not mark an idle session as working.
+  if (
+    haystack.includes('working...') ||
+    haystack.includes('working…') ||
+    haystack.includes(' · tip:') ||
+    haystack.includes('thinking…') ||
+    haystack.includes('thinking...') ||
+    hasKimiSpinner(rawTail)
+  ) {
+    return 'working'
+  }
+
+  return 'idle'
+}
+
+function hasKimiSpinner(rawTail: string): boolean {
+  for (const ch of rawTail) {
+    if (KIMI_BRAILLE_SPINNER.includes(ch) || KIMI_MOON_SPINNER.includes(ch)) return true
+  }
+  return false
+}
+
 const GENERIC_WAITING_PATTERNS: string[] = [
   '[y/n]',
   '(y/n)',

package/src/pty/command-registry.ts

@@ -70,6 +70,16 @@ export const ASSISTANT_OPTIONS: AssistantOption[] = [
       buildModelArgs: (model) => ['-m', model],
     },
   },
+  {
+    command: 'kimi',
+    description: 'Moonshot Kimi Code CLI',
+    id: 'kimi',
+    label: 'Kimi',
+    // Kimi supports --model / -m; no reasoning-effort flag.
+    model: {
+      buildModelArgs: (model) => ['--model', model],
+    },
+  },
   {
     command: 'agy',
     description: 'Antigravity CLI',

package/src/state/types.ts

@@ -9,6 +9,7 @@ export type BuiltinAssistantId =
   | 'codex'
   | 'opencode'
   | 'grok'
+  | 'kimi'
   | 'terminal'
   | 'antigravity'
 
@@ -262,7 +263,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`
 }