@brimveyn/aimux 1.19.5 → 1.19.7

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.5",
-  "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.7",
+  "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.3",
+    "@brimveyn/aimux-config": "0.8.4",
     "@opentui/core": "^0.1.90",
     "@opentui/react": "^0.1.90",
     "@resvg/resvg-wasm": "^2.6.2",

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

@@ -239,6 +239,11 @@ export function bindBackendRuntimeEvents({
     const current = appStore.getState()
     if (current.tabs.some((t) => t.id === tab.id)) {
       logInputDebug('app.backend.event.tabAdded.skipDuplicate', { sessionId, tabId: tab.id })
+      dispatch({
+        autoRenameStatus: tab.autoRenameStatus,
+        tabId: tab.id,
+        type: 'update-tab-metadata',
+      })
       return
     }
     if (current.currentSessionId !== sessionId) {
@@ -253,12 +258,22 @@ export function bindBackendRuntimeEvents({
     dispatch({ tab, type: 'add-tab' })
   }
 
+  const handleTabMetadataUpdated = (
+    sessionId: string,
+    tabId: string,
+    patch: { title?: string; autoRenameStatus?: 'eligible' | 'attempted' }
+  ) => {
+    if (appStore.getState().currentSessionId !== sessionId) return
+    dispatch({ ...patch, tabId, type: 'update-tab-metadata' })
+  }
+
   backend.on('render', handleRender)
   backend.on('exit', handleExit)
   backend.on('error', handleError)
   backend.on('sessionActivity', handleSessionActivity)
   backend.on('tabActivity', handleTabActivity)
   backend.on('tabAdded', handleTabAdded)
+  backend.on('tabMetadataUpdated', handleTabMetadataUpdated)
   backend.on('workspaceCreateRequested', handleWorkspaceCreateRequested)
   backend.on('workspaceSwitchRequested', handleWorkspaceSwitchRequested)
   backend.on('workspaceCloseRequested', handleWorkspaceCloseRequested)
@@ -274,6 +289,7 @@ export function bindBackendRuntimeEvents({
     backend.off('sessionActivity', handleSessionActivity)
     backend.off('tabActivity', handleTabActivity)
     backend.off('tabAdded', handleTabAdded)
+    backend.off('tabMetadataUpdated', handleTabMetadataUpdated)
     backend.off('workspaceCreateRequested', handleWorkspaceCreateRequested)
     backend.off('workspaceSwitchRequested', handleWorkspaceSwitchRequested)
     backend.off('workspaceCloseRequested', handleWorkspaceCloseRequested)

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

@@ -329,7 +329,8 @@ export function startTabSession(
   tab: Pick<TabSession, 'id' | 'assistant' | 'title' | 'command' | 'worktreeId'>,
   cols: number,
   rows: number,
-  cwd?: string
+  cwd?: string,
+  autoRenameCandidate = true
 ): void {
   logInputDebug('app.tab.start.request', {
     cols,
@@ -357,6 +358,7 @@ export function startTabSession(
   backend.createSession({
     args,
     assistant: tab.assistant,
+    autoRenameCandidate,
     cols,
     command: executable,
     cwd,
@@ -613,7 +615,8 @@ function startExistingTab(ctx: SideEffectContext, tab: TabSession): void {
     tab,
     state.layout.terminalCols,
     state.layout.terminalRows,
-    getTabProjectPath(ctx, tab)
+    getTabProjectPath(ctx, tab),
+    false
   )
 }
 
@@ -874,6 +877,16 @@ export function executeSideEffect(effect: SideEffect, ctx: SideEffectContext): v
       handleRenameSessionEffect(state.sessions, dispatch, effect.sessionId, effect.name)
       return
     }
+    case 'rename-tab': {
+      dispatch({
+        autoRenameStatus: 'attempted',
+        tabId: effect.tabId,
+        title: effect.title,
+        type: 'rename-tab',
+      })
+      backend.renameTab(effect.tabId, effect.title)
+      return
+    }
     case 'split-pane': {
       const sourceTab =
         effect.sourceTabId != null && effect.sourceTabId !== ''

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/auto-rename/coordinator.ts

@@ -0,0 +1,97 @@
+import type { AssistantId } from '../state/types'
+
+import { isSupportedProvider } from '../auto-commit/headless-commands'
+import { PromptCapture } from './prompt-capture'
+import { generateTabTitle, type TitleSpawnFn } from './title-runner'
+
+export interface AutoRenameConfigSnapshot {
+  enabled: boolean
+  timeoutMs: number
+  models: Partial<Record<string, string>>
+}
+
+export interface AutoRenameTab {
+  id: string
+  assistant: AssistantId
+  title: string
+  autoRenameStatus?: 'eligible' | 'attempted'
+}
+
+export interface AutoRenameCoordinatorOptions {
+  config: AutoRenameConfigSnapshot
+  getTab: (tabId: string) => AutoRenameTab | undefined
+  updateTab: (
+    tabId: string,
+    patch: { title?: string; autoRenameStatus?: 'eligible' | 'attempted' }
+  ) => void
+  spawn?: TitleSpawnFn
+}
+
+export function initialAutoRenameStatus(
+  config: AutoRenameConfigSnapshot,
+  assistant: AssistantId,
+  candidate: boolean
+): 'eligible' | undefined {
+  return config.enabled && candidate && isSupportedProvider(assistant) ? 'eligible' : undefined
+}
+
+export class AutoRenameCoordinator {
+  private readonly captures = new Map<string, PromptCapture>()
+  private readonly controllers = new Map<string, AbortController>()
+
+  constructor(private readonly options: AutoRenameCoordinatorOptions) {}
+
+  register(tab: AutoRenameTab): void {
+    if (tab.autoRenameStatus === 'eligible' && !this.captures.has(tab.id)) {
+      this.captures.set(tab.id, new PromptCapture())
+    }
+  }
+
+  unregister(tabId: string): void {
+    this.controllers.get(tabId)?.abort()
+    this.controllers.delete(tabId)
+    this.captures.delete(tabId)
+  }
+
+  manualRename(tabId: string): void {
+    this.unregister(tabId)
+  }
+
+  observeWrite(tabId: string, input: string): void {
+    const tab = this.options.getTab(tabId)
+    if (!tab || tab.autoRenameStatus !== 'eligible') return
+    let capture = this.captures.get(tabId)
+    if (!capture) {
+      capture = new PromptCapture()
+      this.captures.set(tabId, capture)
+    }
+    const result = capture.feed(input)
+    if (result.type === 'pending') return
+
+    this.captures.delete(tabId)
+    this.options.updateTab(tabId, { autoRenameStatus: 'attempted' })
+    const prompt = result.prompt
+    if (prompt === null) return
+    const controller = new AbortController()
+    this.controllers.set(tabId, controller)
+    const originalTitle = tab.title
+
+    void (async () => {
+      const title = await generateTabTitle({
+        firstPrompt: prompt,
+        model: this.options.config.models[tab.assistant],
+        provider: tab.assistant,
+        signal: controller.signal,
+        spawn: this.options.spawn,
+        timeoutMs: this.options.config.timeoutMs,
+      })
+      if (this.controllers.get(tabId) !== controller) return
+      this.controllers.delete(tabId)
+      if (title == null || title === '') return
+      const current = this.options.getTab(tabId)
+      if (!current || current.autoRenameStatus !== 'attempted' || current.title !== originalTitle)
+        return
+      this.options.updateTab(tabId, { autoRenameStatus: 'attempted', title })
+    })()
+  }
+}

package/src/auto-rename/prompt-capture.ts

@@ -0,0 +1,211 @@
+const MAX_PROMPT_LENGTH = 8_000
+
+export type PromptCaptureResult = { type: 'pending' } | { type: 'submitted'; prompt: string | null }
+
+export class PromptCapture {
+  private chars: string[] = []
+  private cursor = 0
+  private escapeBuffer = ''
+  private bracketedPaste = false
+  private unreliable = false
+
+  feed(input: string): PromptCaptureResult {
+    for (const char of input) {
+      if (this.escapeBuffer !== '') {
+        this.feedEscape(char)
+        continue
+      }
+
+      if (char === '\x1b') {
+        this.escapeBuffer = char
+        continue
+      }
+
+      if (this.bracketedPaste) {
+        this.insert(char === '\r' ? '\n' : char)
+        continue
+      }
+
+      if (char === '\r' || char === '\n') {
+        if (this.unreliable) {
+          this.reset()
+          return { prompt: null, type: 'submitted' }
+        }
+        const prompt = this.value().trim()
+        this.reset()
+        if (prompt !== '') return { prompt, type: 'submitted' }
+        continue
+      }
+
+      if (char === '\x7f' || char === '\b') {
+        this.backspace()
+        continue
+      }
+      if (char === '\x01') {
+        this.cursor = 0
+        continue
+      }
+      if (char === '\x05') {
+        this.cursor = this.chars.length
+        continue
+      }
+      if (char === '\x02') {
+        this.cursor = Math.max(0, this.cursor - 1)
+        continue
+      }
+      if (char === '\x06') {
+        this.cursor = Math.min(this.chars.length, this.cursor + 1)
+        continue
+      }
+      if (char === '\x04') {
+        if (this.cursor < this.chars.length) this.chars.splice(this.cursor, 1)
+        continue
+      }
+      if (char === '\x0b') {
+        this.chars.splice(this.cursor)
+        continue
+      }
+      if (char === '\x15') {
+        this.chars = []
+        this.cursor = 0
+        continue
+      }
+      if (char === '\x17') {
+        this.deleteWord()
+        continue
+      }
+      if (char === '\x03') {
+        this.reset()
+        continue
+      }
+      if (char === '\x0c') continue
+      if (char < ' ' || char === '\x7f') {
+        this.invalidateCurrentSubmission()
+        continue
+      }
+      this.insert(char)
+    }
+    return { type: 'pending' }
+  }
+
+  reset(): void {
+    this.chars = []
+    this.cursor = 0
+    this.escapeBuffer = ''
+    this.bracketedPaste = false
+    this.unreliable = false
+  }
+
+  private value(): string {
+    return this.chars.join('').slice(0, MAX_PROMPT_LENGTH)
+  }
+
+  private insert(char: string): void {
+    if (this.chars.length >= MAX_PROMPT_LENGTH) return
+    this.chars.splice(this.cursor, 0, char)
+    this.cursor++
+  }
+
+  private backspace(): void {
+    if (this.cursor === 0) return
+    this.chars.splice(this.cursor - 1, 1)
+    this.cursor--
+  }
+
+  private deleteWord(): void {
+    while (this.cursor > 0 && /\s/u.test(this.chars[this.cursor - 1] ?? '')) this.backspace()
+    while (this.cursor > 0 && !/\s/u.test(this.chars[this.cursor - 1] ?? '')) this.backspace()
+  }
+
+  private feedEscape(char: string): void {
+    this.escapeBuffer += char
+    const sequence = this.escapeBuffer
+
+    if (
+      sequence.length === 2 &&
+      sequence !== '\x1b[' &&
+      sequence !== '\x1b]' &&
+      sequence !== '\x1bO'
+    ) {
+      this.escapeBuffer = ''
+      this.invalidateCurrentSubmission()
+      return
+    }
+
+    if (sequence.startsWith('\x1b]')) {
+      if (char === '\x07' || sequence.endsWith('\x1b\\')) this.escapeBuffer = ''
+      return
+    }
+
+    if (sequence.startsWith('\x1bO')) {
+      if (sequence.length < 3) return
+      this.escapeBuffer = ''
+      this.applyCursorSequence(sequence.at(-1) ?? '')
+      return
+    }
+
+    if (!sequence.startsWith('\x1b[')) return
+    if (sequence.length <= 2) return
+    if (!/[\x40-\x7e]$/u.test(char)) return
+
+    this.escapeBuffer = ''
+    switch (sequence) {
+      case '\x1b[200~':
+        this.bracketedPaste = true
+        return
+      case '\x1b[201~':
+        this.bracketedPaste = false
+        return
+      case '\x1b[1~':
+        this.cursor = 0
+        return
+      case '\x1b[4~':
+        this.cursor = this.chars.length
+        return
+      case '\x1b[3~':
+        if (this.cursor < this.chars.length) this.chars.splice(this.cursor, 1)
+        return
+    }
+
+    const final = sequence.at(-1) ?? ''
+    const parameters = sequence.slice(2, -1)
+    if ((final === 'C' || final === 'D') && parameters.includes(';')) {
+      this.invalidateCurrentSubmission()
+      return
+    }
+    const primaryParameter = parameters.split(';')[0]
+    const parsedCount = Number.parseInt(primaryParameter ?? '', 10)
+    const count = Number.isFinite(parsedCount) ? Math.max(1, parsedCount) : 1
+    this.applyCursorSequence(final, count)
+  }
+
+  private applyCursorSequence(final: string, count = 1): void {
+    switch (final) {
+      case 'A':
+      case 'B':
+        // History navigation replaces the editor buffer with content that was
+        // never sent through this input stream. Skip this submission rather
+        // than generating a title from an inaccurate reconstruction.
+        this.invalidateCurrentSubmission()
+        return
+      case 'D':
+        this.cursor = Math.max(0, this.cursor - count)
+        return
+      case 'C':
+        this.cursor = Math.min(this.chars.length, this.cursor + count)
+        return
+      case 'H':
+        this.cursor = 0
+        return
+      case 'F':
+        this.cursor = this.chars.length
+        return
+    }
+  }
+
+  private invalidateCurrentSubmission(): void {
+    this.chars = []
+    this.cursor = 0
+    this.unreliable = true
+  }
+}

package/src/auto-rename/title-runner.ts

@@ -0,0 +1,96 @@
+import { buildHeadlessInvocation, type HeadlessInvocation } from '../auto-commit/headless-commands'
+
+export type TitleSpawnFn = (
+  invocation: HeadlessInvocation,
+  signal: AbortSignal
+) => Promise<{ stdout: string; exitCode: number } | null>
+
+export function buildTitlePrompt(firstPrompt: string): string {
+  return [
+    'Create a concise tab title for the user request below.',
+    'Return only the title: 2 to 6 words, at most 48 characters, in the same language as the request.',
+    'Do not use quotes, a label, markdown, or ending punctuation.',
+    '',
+    firstPrompt.slice(0, 8_000),
+  ].join('\n')
+}
+
+export function sanitizeGeneratedTitle(raw: string): string | null {
+  const first = raw
+    .split(/\r?\n/u)
+    .map((line) => line.trim())
+    .find(Boolean)
+  if (first == null || first === '') return null
+
+  const unlabelled = first.replace(/^TITLE\s*:\s*/iu, '').replaceAll(/^["'“”‘’]+|["'“”‘’]+$/gu, '')
+  const clean = unlabelled
+    .replaceAll(/\s+/gu, ' ')
+    .replace(/[.!?,;:…]+$/u, '')
+    .trim()
+  const words = clean.split(' ').filter(Boolean)
+  const usesUnspacedScript = /[\p{Script=Han}\p{Script=Hiragana}\p{Script=Katakana}]/u.test(clean)
+  if (words.length < 2 && !usesUnspacedScript) return null
+
+  let title = words.slice(0, 6).join(' ')
+  if (title.length > 48) {
+    title = title
+      .slice(0, 48)
+      .replace(/\s+\S*$/u, '')
+      .trim()
+  }
+  return title === '' || (title.split(' ').filter(Boolean).length < 2 && !usesUnspacedScript)
+    ? null
+    : title
+}
+
+export async function generateTabTitle(options: {
+  provider: string
+  model?: string
+  firstPrompt: string
+  timeoutMs: number
+  signal: AbortSignal
+  spawn?: TitleSpawnFn
+}): Promise<string | null> {
+  const invocation = buildHeadlessInvocation(
+    options.provider,
+    buildTitlePrompt(options.firstPrompt),
+    options.model
+  )
+  if (!invocation) return null
+
+  const signal = AbortSignal.any([options.signal, AbortSignal.timeout(options.timeoutMs)])
+  try {
+    const result = await (options.spawn ?? defaultSpawn)(invocation, signal)
+    if (!result || result.exitCode !== 0 || signal.aborted) return null
+    return sanitizeGeneratedTitle(result.stdout)
+  } catch {
+    return null
+  }
+}
+
+async function defaultSpawn(
+  invocation: HeadlessInvocation,
+  signal: AbortSignal
+): Promise<{ stdout: string; exitCode: number } | null> {
+  try {
+    const proc = Bun.spawn([invocation.executable, ...invocation.args], {
+      stderr: 'ignore',
+      stdin: 'ignore',
+      stdout: 'pipe',
+    })
+    const abort = () => {
+      try {
+        proc.kill()
+      } catch {
+        // Best effort: the process may already have exited.
+      }
+    }
+    signal.addEventListener('abort', abort, { once: true })
+    const [stdout, exitCode] = await Promise.all([new Response(proc.stdout).text(), proc.exited])
+    signal.removeEventListener('abort', abort)
+    if (signal.aborted) return null
+    return { exitCode: exitCode ?? 1, stdout }
+  } catch {
+    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',
     },
@@ -210,6 +210,7 @@ export const tabCreate: CliCommand = {
     await daemon.expectOk('createTab', {
       args,
       assistant: assistantId,
+      autoRenameCandidate: ctx.args.flags.title === undefined,
       cols: useFallback ? 0 : FALLBACK_COLS,
       command: executable,
       cwd,