@brimveyn/aimux 1.10.3 → 1.10.4

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@brimveyn/aimux",
-  "version": "1.10.3",
+  "version": "1.10.4",
   "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.5.9",
+    "@brimveyn/aimux-config": "0.5.10",
     "@opentui/core": "^0.1.90",
     "@opentui/react": "^0.1.90",
     "@xterm/headless": "^6.0.0",

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

@@ -1,5 +1,12 @@
-import { isAutoCommitEnabled } from '@brimveyn/aimux-config'
+import {
+  DEFAULT_EDITOR_ARGS,
+  getExternalEditorConfig,
+  isAutoCommitEnabled,
+  KNOWN_GUI_EDITORS,
+} from '@brimveyn/aimux-config'
+import { type CliRenderer } from '@opentui/core'
 import { $ } from 'bun'
+import { resolve as resolvePath } from 'node:path'
 
 import type { SideEffect } from '../input/modes/types'
 import type { SessionBackend } from '../session-backend/types'
@@ -59,7 +66,7 @@ export interface SideEffectContext {
   state: AppState
   dispatch: (action: AppAction) => void
   backend: SessionBackend
-  renderer: { destroy(): void }
+  renderer: CliRenderer
   themeId: ThemeId
   setThemeId: (id: ThemeId) => void
   activeTab: TabSession | undefined
@@ -606,11 +613,211 @@ export function executeSideEffect(effect: SideEffect, ctx: SideEffectContext): v
       saveConfig({ ...loadConfig(), themeMode: next })
       return
     }
+    case 'open-file-in-editor': {
+      openFileInEditor(ctx, effect.path)
+      return
+    }
     default:
       effect satisfies never
   }
 }
 
+function openFileInEditor(ctx: SideEffectContext, relPath: string): void {
+  const config = getExternalEditorConfig()
+  const rawCommand = config.command ?? process.env.VISUAL ?? process.env.EDITOR
+  if (!rawCommand || rawCommand.trim() === '') {
+    ctx.dispatch({
+      message: 'no $EDITOR/$VISUAL set — configure externalEditor in aimux.config.ts',
+      type: 'git-mode-set-message',
+    })
+    return
+  }
+
+  const fileEntry = ctx.state.gitPanel.files.find((f) => f.path === relPath)
+  const cwd = fileEntry?.repoPath ?? ctx.getCurrentSessionProjectPath()
+  if (!cwd) {
+    ctx.dispatch({ message: 'no working directory', type: 'git-mode-set-message' })
+    return
+  }
+  const absolutePath = resolvePath(cwd, relPath)
+
+  const cmdParts = shellSplit(rawCommand)
+  const executable = cmdParts[0]
+  if (!executable) {
+    ctx.dispatch({ message: 'invalid editor command', type: 'git-mode-set-message' })
+    return
+  }
+  const baseName = executable.split('/').pop() ?? executable
+  const extraCmdArgs = cmdParts.slice(1)
+
+  const kind: 'gui' | 'tui' = config.kind ?? (KNOWN_GUI_EDITORS.has(baseName) ? 'gui' : 'tui')
+
+  const templateArgs = config.args ?? DEFAULT_EDITOR_ARGS[baseName] ?? ['{file}']
+  // git mode does not track a cursor line within the diff yet, so pass undefined
+  // and let the substitution strip `{line}` placeholders cleanly — preserves
+  // editor-side "restore last cursor position" behavior (e.g. vscode).
+  const resolvedArgs = [...extraCmdArgs, ...substituteEditorArgs(templateArgs, absolutePath)]
+
+  if (!isCommandAvailable(executable)) {
+    ctx.dispatch({
+      message: `editor not found in PATH: ${executable}`,
+      type: 'git-mode-set-message',
+    })
+    return
+  }
+
+  if (kind === 'gui') {
+    spawnDetached(ctx, [executable, ...resolvedArgs], cwd)
+    return
+  }
+
+  // TUI editor — if the user explicitly configured `terminal`, spawn a new
+  // terminal window with their template. Otherwise default to inline shellout:
+  // suspend the renderer, hand the TTY to the editor, resume on exit.
+  if (config.terminal && config.terminal.length > 0) {
+    const shellCmd = buildShellCmd(cwd, executable, resolvedArgs)
+    const argv = config.terminal.map((a) =>
+      a.replaceAll('{cmd}', shellCmd).replaceAll('{cwd}', cwd)
+    )
+    spawnDetached(ctx, argv, cwd)
+    return
+  }
+
+  void openEditorInline(ctx, executable, resolvedArgs, cwd)
+}
+
+/**
+ * Substitute `{file}` and `{line}` placeholders in an editor-arg template.
+ *
+ * When `line` is `undefined` we drop the line bits cleanly so we don't pass a
+ * misleading `:1` / `+1` that would defeat the editor's "restore last cursor
+ * position" feature:
+ *   `['--line', '{line}', '{file}']` → `['{file}']`
+ *   `['+{line}', '{file}']`          → `['{file}']`
+ *   `['-g', '{file}:{line}']`        → `['-g', '{file}']`
+ *   `['{file}:{line}']`              → `['{file}']`
+ */
+function substituteEditorArgs(template: string[], file: string, line?: string): string[] {
+  if (line !== undefined) {
+    return template.map((a) => a.replaceAll('{file}', file).replaceAll('{line}', line))
+  }
+  const out: string[] = []
+  for (let i = 0; i < template.length; i++) {
+    const arg = template[i] ?? ''
+    // Drop a flag immediately followed by a bare `{line}` arg (--line, -line, etc.).
+    if (template[i + 1] === '{line}') {
+      i++
+      continue
+    }
+    // Drop standalone line tokens like `{line}`, `+{line}`, `:{line}`.
+    if (/^[+:]?\{line\}$/.test(arg)) continue
+    // Strip trailing `:{line}` or `+{line}` from compound tokens like `{file}:{line}`.
+    out.push(arg.replace(/[:+]\{line\}/g, '').replaceAll('{file}', file))
+  }
+  return out
+}
+
+function shellQuote(s: string): string {
+  return `'${s.replaceAll("'", `'\\''`)}'`
+}
+
+/**
+ * Minimal POSIX shell-word splitter — respects single/double quotes and
+ * backslash escapes so values like `EDITOR='/Applications/My Editor/bin/code'`
+ * or `EDITOR="code --user-data-dir \"/tmp/foo bar\""` tokenize correctly.
+ * Does not expand variables or globs.
+ */
+function shellSplit(input: string): string[] {
+  const out: string[] = []
+  let current = ''
+  let inSingle = false
+  let inDouble = false
+  let hasToken = false
+  for (let i = 0; i < input.length; i++) {
+    const c = input[i] ?? ''
+    if (!inSingle && !inDouble && /\s/.test(c)) {
+      if (hasToken) {
+        out.push(current)
+        current = ''
+        hasToken = false
+      }
+      continue
+    }
+    hasToken = true
+    if (c === "'" && !inDouble) {
+      inSingle = !inSingle
+    } else if (c === '"' && !inSingle) {
+      inDouble = !inDouble
+    } else if (c === '\\' && !inSingle && i + 1 < input.length) {
+      current += input[++i]
+    } else {
+      current += c
+    }
+  }
+  if (hasToken) out.push(current)
+  return out
+}
+
+function buildShellCmd(cwd: string, executable: string, args: string[]): string {
+  const quoted = [executable, ...args].map(shellQuote).join(' ')
+  return `cd ${shellQuote(cwd)} && ${quoted}`
+}
+
+function spawnDetached(ctx: SideEffectContext, argv: string[], cwd?: string): void {
+  try {
+    const child = Bun.spawn(argv, {
+      cwd,
+      stderr: 'pipe',
+      stdin: 'ignore',
+      stdout: 'ignore',
+    })
+    void (async () => {
+      const stderr = await new Response(child.stderr).text()
+      const code = await child.exited
+      if (code !== 0) {
+        const firstLine = stderr.trim().split('\n')[0] || `exit ${code}`
+        ctx.dispatch({ message: `editor: ${firstLine}`, type: 'git-mode-set-message' })
+      }
+    })()
+    child.unref()
+  } catch (err) {
+    const msg = err instanceof Error ? err.message : 'failed to spawn'
+    ctx.dispatch({ message: `editor: ${msg}`, type: 'git-mode-set-message' })
+  }
+}
+
+/**
+ * Suspend the opentui renderer, hand the TTY to the editor (inheriting
+ * stdin/stdout/stderr), then resume and force a redraw on exit. Matches the
+ * shellout pattern used by opencode (packages/opencode/src/cli/cmd/tui/util/editor.ts).
+ */
+async function openEditorInline(
+  ctx: SideEffectContext,
+  executable: string,
+  args: string[],
+  cwd: string
+): Promise<void> {
+  const { renderer } = ctx
+  try {
+    renderer.suspend()
+    renderer.currentRenderBuffer.clear()
+    const proc = Bun.spawn([executable, ...args], {
+      cwd,
+      stderr: 'inherit',
+      stdin: 'inherit',
+      stdout: 'inherit',
+    })
+    await proc.exited
+  } catch (err) {
+    const msg = err instanceof Error ? err.message : 'failed to spawn editor'
+    ctx.dispatch({ message: `editor: ${msg}`, type: 'git-mode-set-message' })
+  } finally {
+    renderer.currentRenderBuffer.clear()
+    renderer.resume()
+    renderer.requestRender()
+  }
+}
+
 function handleSwitchSessionByIndex(ctx: SideEffectContext, index: number): void {
   const { backend, dispatch, state } = ctx
   const ordered = state.sessions

package/src/app.tsx

@@ -1,6 +1,7 @@
 import {
   type ResolvedConfig,
   setAutoCommitEnabled,
+  setExternalEditorConfig,
   setMultiRepoConfig,
 } from '@brimveyn/aimux-config'
 import { useKeyboard, useRenderer, useTerminalDimensions } from '@opentui/react'
@@ -65,6 +66,7 @@ export function App({
   // actions (which live outside React) can read it synchronously.
   setAutoCommitEnabled(resolvedConfig.autoCommit.enabled)
   setMultiRepoConfig(resolvedConfig.multiRepo)
+  setExternalEditorConfig(resolvedConfig.externalEditor)
 
   const keymapHandlers = useMemo(
     () => {

package/src/input/modes/types.ts

@@ -68,6 +68,7 @@ export type SideEffect =
   | { type: 'delete-session'; sessionId: string }
   | { type: 'toggle-transparent' }
   | { type: 'toggle-mode' }
+  | { type: 'open-file-in-editor'; path: string }
 
 export interface KeyResult {
   actions: AppAction[]