@brimveyn/aimux 1.21.0 → 1.22.2

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

@@ -1,25 +1,27 @@
 import type { MutableRefObject } from 'react'
 
 import type { SessionBackend } from '../session-backend/types'
+import type { AppAction } from '../state/actions'
 import type {
-  AppAction,
-  SessionStatus,
+  ProjectStatus,
   TabActivity,
   TabSession,
   TerminalModeState,
-  WorktreeRecord,
+  WorkspaceRecord,
 } from '../state/types'
 import type { TabRuntimeTimeouts } from './tab-runtime-timeouts'
 
 import { logInputDebug } from '../debug/input-log'
 import { clearTabSyntaxState, highlightSnapshot } from '../integrations/claude-syntax-overlay'
 import { appStore } from '../state/app-store'
-import { loadSessionCatalog, saveSessionCatalog } from '../state/session-catalog'
+import { loadProjectCatalog, saveProjectCatalog } from '../state/project-catalog'
 import {
-  handleCreateSessionEffect,
-  handleDeleteSessionEffect,
-  handleSwitchSessionEffect,
-} from './session-actions'
+  handleCreateProjectEffect,
+  handleDeleteProjectEffect,
+  handleSwitchProjectEffect,
+} from './project-actions'
+import { recordSetupExit } from './setup-actions'
+import { forgetTabActivity, recordTabStatus, recordTurnComplete } from './workspace-activity'
 
 interface BindBackendRuntimeEventsOptions {
   backend: SessionBackend
@@ -35,6 +37,7 @@ function clearTabRuntimeState(
 ): void {
   timeouts.clearIdleTimer(tabId)
   timeouts.clearStartupGrace(tabId)
+  forgetTabActivity(tabId)
 }
 
 export function bindBackendRuntimeEvents({
@@ -76,6 +79,11 @@ export function bindBackendRuntimeEvents({
     logInputDebug('app.backend.event.exit', { exitCode, tabId })
     clearTabRuntimeState(timeouts, tabId)
     clearTabSyntaxState(tabId)
+    // A setup tab is never closed on exit. Closing it would erase the output at
+    // the exact moment it matters — a failed setup is what the user needs to
+    // read. Record the outcome and leave the dead tab holding its last frame;
+    // a re-run, a workspace removal, or a project switch clears it.
+    if (recordSetupExit(tabId, exitCode, dispatch)) return
     dispatch({ tabId, type: 'close-tab' })
   }
 
@@ -86,19 +94,27 @@ export function bindBackendRuntimeEvents({
     dispatch({ message, tabId, type: 'set-tab-error' })
   }
 
-  const handleSessionActivity = (sessionId: string, status: SessionStatus) => {
-    logInputDebug('app.backend.event.sessionActivity', { sessionId, status })
-    dispatch({ sessionId, status, type: 'set-session-status' })
+  const handleProjectActivity = (projectId: string, status: ProjectStatus) => {
+    logInputDebug('app.backend.event.projectActivity', { projectId, status })
+    dispatch({ projectId, status, type: 'set-project-status' })
   }
 
-  const handleTabActivity = (tabId: string, activity: TabActivity) => {
-    logInputDebug('app.backend.event.tabActivity', { activity, tabId })
+  const handleTabActivity = (tabId: string, activity: TabActivity, workspaceId?: string) => {
+    logInputDebug('app.backend.event.tabActivity', { activity, tabId, workspaceId })
+    // Every project's tabs land here, including ones this client doesn't hold —
+    // the workspace aggregation wants them, the store ignores them.
+    recordTabStatus(tabId, activity, workspaceId)
     dispatch({ activity, tabId, type: 'set-tab-activity' })
   }
 
-  // Serialise workspace lifecycle handlers behind a small FIFO so back-to-back
+  const handleTabTurnComplete = (tabId: string, projectId: string, workspaceId?: string) => {
+    logInputDebug('app.backend.event.tabTurnComplete', { projectId, tabId, workspaceId })
+    recordTurnComplete(tabId, workspaceId)
+  }
+
+  // Serialise project lifecycle handlers behind a small FIFO so back-to-back
   // switch/create/close broadcasts from multiple CLIs don't race the
-  // in-flight `handleSwitchSessionEffect`. Every lifecycle handler awaits the
+  // in-flight `handleSwitchProjectEffect`. Every lifecycle handler awaits the
   // previous chain link before running.
   let lifecycleChain: Promise<void> = Promise.resolve()
   const enqueueLifecycle = (fn: () => void | Promise<void>): void => {
@@ -115,130 +131,131 @@ export function bindBackendRuntimeEvents({
     })()
   }
 
-  const handleWorkspaceCreateRequested = (
+  const handleProjectCreateRequested = (
     name: string,
     projectPath: string | undefined,
     doSwitch: boolean
   ) => {
     enqueueLifecycle(() => {
-      logInputDebug('app.backend.event.workspaceCreateRequested', { doSwitch, name, projectPath })
+      logInputDebug('app.backend.event.projectCreateRequested', { doSwitch, name, projectPath })
       const state = appStore.getState()
-      handleCreateSessionEffect(state, dispatch, name, projectPath)
+      handleCreateProjectEffect(state, dispatch, name, projectPath)
       if (doSwitch) {
-        // The create dispatched `set-sessions`+`load-session`; the new session
+        // The create dispatched `set-projects`+`load-project`; the new project
         // is now in the catalog + current. Loading already ran, so the switch
         // is effectively done — just tell the daemon so any --wait CLI exits.
         const created = appStore
           .getState()
-          .sessions.find((s) => s.name === name && s.projectPath === projectPath)
-        if (created) backend.announceWorkspaceSwitched(created.id)
+          .projects.find((s) => s.name === name && s.projectPath === projectPath)
+        if (created) backend.announceProjectSwitched(created.id)
       }
     })
   }
 
-  const handleWorkspaceSwitchRequested = (targetSessionId: string) => {
+  const handleProjectSwitchRequested = (targetProjectId: string) => {
     enqueueLifecycle(async () => {
-      logInputDebug('app.backend.event.workspaceSwitchRequested', { targetSessionId })
+      logInputDebug('app.backend.event.projectSwitchRequested', { targetProjectId })
       let state = appStore.getState()
-      let target = state.sessions.find((s) => s.id === targetSessionId)
+      let target = state.projects.find((s) => s.id === targetProjectId)
       if (!target) {
-        // In-memory list is stale (e.g. daemon just added a session via the
+        // In-memory list is stale (e.g. daemon just added a project via the
         // headless path). Reload from disk and try once more before giving
         // up — the daemon already validated the catalog, so this should hit.
-        const fresh = loadSessionCatalog()
-        target = fresh.find((s) => s.id === targetSessionId)
+        const fresh = loadProjectCatalog()
+        target = fresh.find((s) => s.id === targetProjectId)
         if (target) {
-          dispatch({ sessions: fresh, type: 'set-sessions' })
+          dispatch({ projects: fresh, type: 'set-projects' })
           state = appStore.getState()
         }
       }
       if (!target) {
         // Announce anyway so any `--wait` CLI unblocks — better a spurious
         // exit than a 30s hang while the caller retries.
-        logInputDebug('app.backend.event.workspaceSwitchRequested.notFound', { targetSessionId })
-        backend.announceWorkspaceSwitched(targetSessionId)
+        logInputDebug('app.backend.event.projectSwitchRequested.notFound', { targetProjectId })
+        backend.announceProjectSwitched(targetProjectId)
         return
       }
-      handleSwitchSessionEffect(state, backend, dispatch, target)
+      handleSwitchProjectEffect(state, backend, dispatch, target)
       // Give the reducer a tick to settle before announcing — the switch
-      // fires `set-sessions`+`load-session` synchronously but the backend
+      // fires `set-projects`+`load-project` synchronously but the backend
       // re-attach happens async.
       await Promise.resolve()
-      backend.announceWorkspaceSwitched(targetSessionId)
+      backend.announceProjectSwitched(targetProjectId)
     })
   }
 
-  const handleWorkspaceCloseRequested = (targetSessionId: string) => {
+  const handleProjectCloseRequested = (targetProjectId: string) => {
     enqueueLifecycle(() => {
-      logInputDebug('app.backend.event.workspaceCloseRequested', { targetSessionId })
+      logInputDebug('app.backend.event.projectCloseRequested', { targetProjectId })
       const state = appStore.getState()
-      handleDeleteSessionEffect(state, backend, dispatch, targetSessionId)
+      handleDeleteProjectEffect(state, backend, dispatch, targetProjectId)
     })
   }
 
-  const handleWorkspaceSwitched = (sessionId: string) => {
+  const handleProjectSwitched = (projectId: string) => {
     // The daemon's own relay for --wait CLIs. UI side has no work to do —
     // logging is enough.
-    logInputDebug('app.backend.event.workspaceSwitched', { sessionId })
+    logInputDebug('app.backend.event.projectSwitched', { projectId })
   }
 
-  const handleWorktreeAdded = (sessionId: string, worktree: WorktreeRecord) => {
-    // Idempotent: skip if a duplicate id is already in the session (the CLI
-    // may have raced the UI's own worktree-add path).
+  const handleWorkspaceAdded = (projectId: string, workspace: WorkspaceRecord) => {
+    // Idempotent: skip if a duplicate id is already in the project (the CLI
+    // may have raced the UI's own workspace-add path).
     const current = appStore.getState()
-    const session = current.sessions.find((s) => s.id === sessionId)
-    const already = session?.worktrees?.some((w) => w.id === worktree.id) === true
+    const project = current.projects.find((s) => s.id === projectId)
+    const already = project?.workspaces?.some((w) => w.id === workspace.id) === true
     if (already) {
-      logInputDebug('app.backend.event.worktreeAdded.skipDuplicate', {
-        sessionId,
-        worktreeId: worktree.id,
+      logInputDebug('app.backend.event.workspaceAdded.skipDuplicate', {
+        projectId,
+        workspaceId: workspace.id,
       })
       return
     }
-    logInputDebug('app.backend.event.worktreeAdded', {
-      sessionId,
-      worktreeId: worktree.id,
+    logInputDebug('app.backend.event.workspaceAdded', {
+      projectId,
+      workspaceId: workspace.id,
     })
-    dispatch({ sessionId, type: 'add-worktree-record', worktree })
+    dispatch({ projectId, type: 'add-workspace-record', workspace })
     // Persist the catalog so the change survives restart even if no other
     // side-effect saves shortly after.
-    saveSessionCatalog(appStore.getState().sessions)
+    saveProjectCatalog(appStore.getState().projects)
   }
 
-  const handleWorktreeRemoved = (sessionId: string, worktreeId: string) => {
+  const handleWorkspaceRemoved = (projectId: string, workspaceId: string) => {
     const current = appStore.getState()
-    const session = current.sessions.find((s) => s.id === sessionId)
-    const present = session?.worktrees?.some((w) => w.id === worktreeId) === true
+    const project = current.projects.find((s) => s.id === projectId)
+    const present = project?.workspaces?.some((w) => w.id === workspaceId) === true
     if (!present) {
-      logInputDebug('app.backend.event.worktreeRemoved.skipMissing', { sessionId, worktreeId })
+      logInputDebug('app.backend.event.workspaceRemoved.skipMissing', { projectId, workspaceId })
       return
     }
-    logInputDebug('app.backend.event.worktreeRemoved', { sessionId, worktreeId })
-    // Build the updated sessions list and dispatch via `set-sessions` — this
-    // matches the pattern used by the existing worktree-delete side-effect
+    logInputDebug('app.backend.event.workspaceRemoved', { projectId, workspaceId })
+    // Build the updated projects list and dispatch via `set-projects` — this
+    // matches the pattern used by the existing workspace-delete side-effect
     // and centralises the write in one action rather than adding a new one.
-    const sessions = current.sessions.map((s) => {
-      if (s.id !== sessionId) return s
-      const remaining = (s.worktrees ?? []).filter((w) => w.id !== worktreeId)
+    const projects = current.projects.map((s) => {
+      if (s.id !== projectId) return s
+      const remaining = (s.workspaces ?? []).filter((w) => w.id !== workspaceId)
       return {
         ...s,
-        activeWorktreeId: s.activeWorktreeId === worktreeId ? remaining[0]?.id : s.activeWorktreeId,
+        activeWorkspaceId:
+          s.activeWorkspaceId === workspaceId ? remaining[0]?.id : s.activeWorkspaceId,
         updatedAt: new Date().toISOString(),
-        worktrees: remaining,
+        workspaces: remaining,
       }
     })
-    saveSessionCatalog(sessions)
-    dispatch({ sessions, type: 'set-sessions' })
+    saveProjectCatalog(projects)
+    dispatch({ projects, type: 'set-projects' })
   }
 
-  const handleTabAdded = (sessionId: string, tab: TabSession) => {
+  const handleTabAdded = (projectId: string, tab: TabSession) => {
     // Idempotent: the daemon broadcasts `tabAdded` for every createTab,
     // including the ones this UI process initiated (which already dispatched
     // `add-tab` locally). Skip the duplicate so we don't get two entries for
     // the same tab id.
     const current = appStore.getState()
     if (current.tabs.some((t) => t.id === tab.id)) {
-      logInputDebug('app.backend.event.tabAdded.skipDuplicate', { sessionId, tabId: tab.id })
+      logInputDebug('app.backend.event.tabAdded.skipDuplicate', { projectId, tabId: tab.id })
       dispatch({
         autoRenameStatus: tab.autoRenameStatus,
         tabId: tab.id,
@@ -246,56 +263,58 @@ export function bindBackendRuntimeEvents({
       })
       return
     }
-    if (current.currentSessionId !== sessionId) {
-      logInputDebug('app.backend.event.tabAdded.skipForeignSession', {
-        currentSessionId: current.currentSessionId,
-        sessionId,
+    if (current.currentProjectId !== projectId) {
+      logInputDebug('app.backend.event.tabAdded.skipForeignProject', {
+        currentProjectId: current.currentProjectId,
+        projectId,
         tabId: tab.id,
       })
       return
     }
-    logInputDebug('app.backend.event.tabAdded', { sessionId, tabId: tab.id })
+    logInputDebug('app.backend.event.tabAdded', { projectId, tabId: tab.id })
     dispatch({ tab, type: 'add-tab' })
   }
 
   const handleTabMetadataUpdated = (
-    sessionId: string,
+    projectId: string,
     tabId: string,
     patch: { title?: string; autoRenameStatus?: 'eligible' | 'attempted' }
   ) => {
-    if (appStore.getState().currentSessionId !== sessionId) return
+    if (appStore.getState().currentProjectId !== projectId) 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('projectActivity', handleProjectActivity)
   backend.on('tabActivity', handleTabActivity)
+  backend.on('tabTurnComplete', handleTabTurnComplete)
   backend.on('tabAdded', handleTabAdded)
   backend.on('tabMetadataUpdated', handleTabMetadataUpdated)
-  backend.on('workspaceCreateRequested', handleWorkspaceCreateRequested)
-  backend.on('workspaceSwitchRequested', handleWorkspaceSwitchRequested)
-  backend.on('workspaceCloseRequested', handleWorkspaceCloseRequested)
-  backend.on('workspaceSwitched', handleWorkspaceSwitched)
-  backend.on('worktreeAdded', handleWorktreeAdded)
-  backend.on('worktreeRemoved', handleWorktreeRemoved)
+  backend.on('projectCreateRequested', handleProjectCreateRequested)
+  backend.on('projectSwitchRequested', handleProjectSwitchRequested)
+  backend.on('projectCloseRequested', handleProjectCloseRequested)
+  backend.on('projectSwitched', handleProjectSwitched)
+  backend.on('workspaceAdded', handleWorkspaceAdded)
+  backend.on('workspaceRemoved', handleWorkspaceRemoved)
 
   return () => {
     timeouts.clearAllTimers()
     backend.off('render', handleRender)
     backend.off('exit', handleExit)
     backend.off('error', handleError)
-    backend.off('sessionActivity', handleSessionActivity)
+    backend.off('projectActivity', handleProjectActivity)
     backend.off('tabActivity', handleTabActivity)
+    backend.off('tabTurnComplete', handleTabTurnComplete)
     backend.off('tabAdded', handleTabAdded)
     backend.off('tabMetadataUpdated', handleTabMetadataUpdated)
-    backend.off('workspaceCreateRequested', handleWorkspaceCreateRequested)
-    backend.off('workspaceSwitchRequested', handleWorkspaceSwitchRequested)
-    backend.off('workspaceCloseRequested', handleWorkspaceCloseRequested)
-    backend.off('workspaceSwitched', handleWorkspaceSwitched)
-    backend.off('worktreeAdded', handleWorktreeAdded)
-    backend.off('worktreeRemoved', handleWorktreeRemoved)
+    backend.off('projectCreateRequested', handleProjectCreateRequested)
+    backend.off('projectSwitchRequested', handleProjectSwitchRequested)
+    backend.off('projectCloseRequested', handleProjectCloseRequested)
+    backend.off('projectSwitched', handleProjectSwitched)
+    backend.off('workspaceAdded', handleWorkspaceAdded)
+    backend.off('workspaceRemoved', handleWorkspaceRemoved)
     void backend.destroy(true)
   }
 }

package/src/app-runtime/editor-actions.ts

@@ -0,0 +1,201 @@
+import {
+  DEFAULT_EDITOR_ARGS,
+  getExternalEditorConfig,
+  KNOWN_GUI_EDITORS,
+} from '@brimveyn/aimux-config'
+import { existsSync } from 'node:fs'
+import { join as joinPath, resolve as resolvePath } from 'node:path'
+
+import type { SideEffectContext } from './side-effect-context'
+
+import { logInputDebug } from '../debug/input-log'
+import { getProfileConfigDir } from '../profile-paths'
+import { isCommandAvailable, shellQuote, shellSplit } from '../pty/command-registry'
+import { getSnippetsCatalogPath, isConfigSnippetId } from '../state/snippet-catalog'
+import { getSelectedSnippet } from './selection'
+
+/**
+ * Open the file backing the currently selected snippet in the user's editor.
+ * Config-pinned snippets (id starts with `config:`) live in `aimux.config.ts`
+ * (or `.js`); user-edited snippets live in `aimux-snippets.json`.
+ *
+ * On error (no editor, editor not in PATH) the failure is silent: there is no
+ * snippet-picker status line. The user can check the debug log.
+ */
+export function openSelectedSnippetSourceInEditor(ctx: SideEffectContext): void {
+  const snippet = getSelectedSnippet(ctx.state)
+  if (!snippet) return
+
+  const configDir = getProfileConfigDir()
+  let absolutePath: string
+
+  if (isConfigSnippetId(snippet.id)) {
+    const tsPath = joinPath(configDir, 'aimux.config.ts')
+    const jsPath = joinPath(configDir, 'aimux.config.js')
+    absolutePath = existsSync(jsPath) && !existsSync(tsPath) ? jsPath : tsPath
+  } else {
+    absolutePath = getSnippetsCatalogPath()
+  }
+
+  launchEditorOnFile(ctx, absolutePath, configDir, (message) => {
+    logInputDebug('snippets.openInEditor.error', { message, path: absolutePath })
+    ctx.dispatch({ message, type: 'snippet-picker-set-message' })
+  })
+}
+
+export function openFileInEditor(ctx: SideEffectContext, relPath: string): void {
+  const fileEntry = ctx.state.gitPanel.files.find((f) => f.path === relPath)
+  const cwd = fileEntry?.repoPath ?? ctx.getCurrentProjectProjectPath()
+  if (!(cwd != null && cwd !== '')) {
+    ctx.dispatch({ message: 'no working directory', type: 'git-mode-set-message' })
+    return
+  }
+  const absolutePath = resolvePath(cwd, relPath)
+  launchEditorOnFile(ctx, absolutePath, cwd, (message) =>
+    ctx.dispatch({ message, type: 'git-mode-set-message' })
+  )
+}
+
+export function launchEditorOnFile(
+  ctx: SideEffectContext,
+  absolutePath: string,
+  cwd: string,
+  onError: (message: string) => void
+): void {
+  const config = getExternalEditorConfig()
+  const rawCommand = config.command ?? process.env.VISUAL ?? process.env.EDITOR
+  if (rawCommand == null || rawCommand === '' || rawCommand.trim() === '') {
+    onError('no $EDITOR/$VISUAL set — configure externalEditor in aimux.config.ts')
+    return
+  }
+
+  const cmdParts = shellSplit(rawCommand)
+  const executable = cmdParts[0]
+  if (!(executable != null && executable !== '')) {
+    onError('invalid editor command')
+    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}']
+  // No line target — let substitution strip `{line}` placeholders so we don't
+  // defeat the editor's "restore last cursor position" feature.
+  const resolvedArgs = [...extraCmdArgs, ...substituteEditorArgs(templateArgs, absolutePath)]
+
+  if (!isCommandAvailable(executable)) {
+    onError(`editor not found in PATH: ${executable}`)
+    return
+  }
+
+  if (kind === 'gui') {
+    spawnDetached(ctx, [executable, ...resolvedArgs], cwd)
+    return
+  }
+
+  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.replaceAll(/[:+]\{line\}/g, '').replaceAll('{file}', file))
+  }
+  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 firstStderrLine = stderr.trim().split('\n')[0]
+        const firstLine =
+          firstStderrLine != null && firstStderrLine !== '' ? firstStderrLine : `exit ${code}`
+        ctx.dispatch({ message: `editor: ${firstLine}`, type: 'git-mode-set-message' })
+      }
+    })()
+    child.unref()
+  } catch (error) {
+    const msg = error instanceof Error ? error.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 (error) {
+    const msg = error instanceof Error ? error.message : 'failed to spawn editor'
+    ctx.dispatch({ message: `editor: ${msg}`, type: 'git-mode-set-message' })
+  } finally {
+    renderer.currentRenderBuffer.clear()
+    renderer.resume()
+    renderer.requestRender()
+  }
+}