@pellux/goodvibes-agent 0.1.0

package/src/input/handler-modal-routes.ts

@@ -0,0 +1,418 @@
+import type { InputToken } from '@pellux/goodvibes-sdk/platform/core';
+import type { SelectionResult, SelectionAction } from './selection-modal.ts';
+import type { CommandContext } from './command-registry.ts';
+import { openTtsProviderPicker, openTtsVoicePicker } from './tts-settings-actions.ts';
+
+type SelectionRouteState = {
+  selectionModal: {
+    active: boolean;
+    query: string;
+    searchFocused: boolean;
+    allowSearch: boolean;
+    customActions: Map<string, SelectionAction>;
+    selectedIndex: number;
+    getSelected: () => SelectionResult['item'] | null | undefined;
+    setQuery: (query: string) => void;
+    focusSearch: () => void;
+    blurSearch: () => void;
+    moveUp: () => void;
+    moveDown: () => void;
+    close: () => void;
+  };
+  selectionCallback: ((result: SelectionResult | null) => void) | null;
+  getSelectionCallback?: () => ((result: SelectionResult | null) => void) | null;
+  setSelectionCallback?: (callback: ((result: SelectionResult | null) => void) | null) => void;
+  modalStack: string[];
+  requestRender: () => void;
+  handleEscape: () => void;
+};
+
+export function handleSelectionModalToken(state: SelectionRouteState, token: InputToken): boolean {
+  if (!state.selectionModal.active) return false;
+
+  const getPrimaryAction = (selected: NonNullable<ReturnType<typeof state.selectionModal.getSelected>> | null | undefined): SelectionAction | null => {
+    if (selected?.primaryAction) return selected.primaryAction;
+    const enterAction = state.selectionModal.customActions.get('enter');
+    return enterAction ?? null;
+  };
+
+  const getSpaceAction = (selected: NonNullable<ReturnType<typeof state.selectionModal.getSelected>> | null | undefined): SelectionAction | null => {
+    if (selected?.primaryAction === 'toggle') return 'toggle';
+    const direct = state.selectionModal.customActions.get(' ');
+    if (direct) return direct;
+    const enterAction = getPrimaryAction(selected);
+    if (enterAction === 'toggle') return enterAction;
+    return null;
+  };
+
+  const dispatchSelectionAction = (
+    action: SelectionAction,
+    selected: NonNullable<ReturnType<typeof state.selectionModal.getSelected>>,
+    step?: number,
+  ): void => {
+    if (action === 'toggle' || action === 'increment' || action === 'decrement') {
+      state.selectionCallback?.({ item: selected, action, step });
+      return;
+    }
+    const cb = state.selectionCallback;
+    state.selectionCallback = null;
+    state.setSelectionCallback?.(null);
+    state.selectionModal.close();
+    if (state.modalStack.length > 0 && state.modalStack[state.modalStack.length - 1] === 'selection') {
+      state.modalStack.pop();
+    }
+    cb?.({ item: selected, action, step });
+    state.selectionCallback = state.getSelectionCallback?.() ?? state.selectionCallback;
+  };
+
+  const getAdjustmentStep = (
+    selected: NonNullable<ReturnType<typeof state.selectionModal.getSelected>> | null | undefined,
+    shift: boolean,
+  ): number => {
+    const baseStep = selected?.adjustStep ?? 1;
+    return shift ? baseStep * 10 : baseStep;
+  };
+
+  if (token.type === 'text') {
+    if (state.selectionModal.allowSearch && !state.selectionModal.searchFocused && token.value === '/') {
+      state.selectionModal.focusSearch();
+    } else if (state.selectionModal.allowSearch && state.selectionModal.searchFocused) {
+      state.selectionModal.setQuery(state.selectionModal.query + token.value);
+    } else if (token.value === ' ') {
+      const selected = state.selectionModal.getSelected();
+      const action = getSpaceAction(selected);
+      if (action && selected && state.selectionCallback) {
+        state.selectionCallback({ item: selected, action });
+      }
+    } else {
+      const action = state.selectionModal.customActions.get(token.value);
+      if (action) {
+        const selected = state.selectionModal.getSelected();
+        if (selected) {
+          dispatchSelectionAction(action, selected);
+        }
+      }
+    }
+  } else if (token.type === 'key') {
+    if (token.logicalName === 'escape') {
+      if (state.selectionModal.allowSearch && state.selectionModal.searchFocused) {
+        if (state.selectionModal.query.length > 0) state.selectionModal.setQuery('');
+        else state.selectionModal.blurSearch();
+        state.requestRender();
+        return true;
+      }
+      state.handleEscape();
+      return true;
+    }
+    if (token.logicalName === 'enter') {
+      const selected = state.selectionModal.getSelected();
+      if (selected) {
+        dispatchSelectionAction(getPrimaryAction(selected) ?? 'select', selected);
+      }
+    } else if (token.logicalName === 'space') {
+      const selected = state.selectionModal.getSelected();
+      const action = getSpaceAction(selected);
+      if (action && selected && state.selectionCallback) {
+        state.selectionCallback({ item: selected, action });
+      }
+    } else if (token.logicalName === 'up') {
+      if (state.selectionModal.allowSearch && !state.selectionModal.searchFocused && state.selectionModal.selectedIndex === 0) {
+        state.selectionModal.focusSearch();
+      } else {
+        state.selectionModal.moveUp();
+      }
+    } else if (token.logicalName === 'down') {
+      if (state.selectionModal.allowSearch && state.selectionModal.searchFocused) {
+        state.selectionModal.blurSearch();
+      } else {
+        state.selectionModal.moveDown();
+      }
+    } else if ((token.logicalName === 'left' || token.logicalName === 'right') && !state.selectionModal.searchFocused) {
+      const selected = state.selectionModal.getSelected();
+      if (selected?.adjustable) {
+        dispatchSelectionAction(
+          token.logicalName === 'right' ? 'increment' : 'decrement',
+          selected,
+          getAdjustmentStep(selected, token.shift),
+        );
+      }
+    } else if (token.logicalName === 'backspace') {
+      if (state.selectionModal.allowSearch && state.selectionModal.searchFocused && state.selectionModal.query.length > 0) {
+        state.selectionModal.setQuery(state.selectionModal.query.slice(0, -1));
+      }
+    } else if (state.selectionModal.allowSearch && !state.selectionModal.searchFocused && token.logicalName === '/') {
+      state.selectionModal.focusSearch();
+    } else if (!state.selectionModal.searchFocused && token.logicalName && token.logicalName.length === 1) {
+      const action = state.selectionModal.customActions.get(token.logicalName);
+      if (action) {
+        const selected = state.selectionModal.getSelected();
+        if (selected) {
+          dispatchSelectionAction(action, selected);
+        }
+      }
+    }
+  }
+
+  state.requestRender();
+  return true;
+}
+
+type BookmarkRouteState = {
+  bookmarkModal: {
+    active: boolean;
+    entries: Array<unknown>;
+    moveUp: () => void;
+    moveDown: () => void;
+    getSelected: () => { key: string } | null;
+    close: () => void;
+    removeSelected: () => void;
+    openSelectedFile: () => void;
+  };
+  commandContext?: CommandContext;
+  requestRender: () => void;
+  handleEscape: () => void;
+};
+
+export function handleBookmarkModalToken(state: BookmarkRouteState, token: InputToken): boolean {
+  if (!state.bookmarkModal.active) return false;
+
+  if (token.type === 'key') {
+    if (token.logicalName === 'escape') {
+      state.handleEscape();
+      return true;
+    }
+    if (token.logicalName === 'up') state.bookmarkModal.moveUp();
+    else if (token.logicalName === 'down') state.bookmarkModal.moveDown();
+    else if (token.logicalName === 'enter') {
+      const entry = state.bookmarkModal.getSelected();
+      if (entry) state.commandContext?.jumpToBookmark?.(entry.key);
+      state.bookmarkModal.close();
+    } else if (token.logicalName === 'd') {
+      state.bookmarkModal.removeSelected();
+      if (state.bookmarkModal.entries.length === 0) state.bookmarkModal.close();
+    } else if (token.logicalName === 'o') {
+      state.bookmarkModal.openSelectedFile();
+    }
+  } else if (token.type === 'text') {
+    if (token.value === 'd') {
+      state.bookmarkModal.removeSelected();
+      if (state.bookmarkModal.entries.length === 0) state.bookmarkModal.close();
+    } else if (token.value === 'o') {
+      state.bookmarkModal.openSelectedFile();
+    }
+  }
+
+  state.requestRender();
+  return true;
+}
+
+type SettingsRouteState = {
+  settingsModal: {
+    active: boolean;
+    editingMode: boolean;
+    currentCategory: string;
+    focusPane?: 'categories' | 'settings';
+    commitEdit: () => void;
+    toggleSelectedFlag: () => void;
+    activateSelected: () => void;
+    adjustSelected: (direction: 'left' | 'right', step?: number) => void;
+    moveFocusedUp?: () => void;
+    moveFocusedDown?: () => void;
+    moveUp?: () => void;
+    moveDown?: () => void;
+    focusCategories?: () => void;
+    focusSettings?: () => void;
+    toggleFocusPane?: () => void;
+    nextCategory: () => void;
+    prevCategory?: () => void;
+    editBackspace: () => void;
+    editChar: (char: string) => void;
+    pendingModelPickerTarget: import('./model-picker.ts').ModelPickerTarget | null;
+    pendingProviderModelPickerTarget?: import('./model-picker.ts').ModelPickerTarget | null;
+    pendingSettingsPickerAction?: 'tts-provider' | 'tts-voice' | null;
+    resetSelected?: () => { key: string; value: unknown } | null;
+  };
+  commandContext?: CommandContext;
+  /** Called when the settings modal requests the model picker for a non-main target. */
+  openModelPickerWithTarget?: (target: import('./model-picker.ts').ModelPickerTarget) => void;
+  /** Called when the settings modal requests provider selection before model selection. */
+  openProviderModelPickerWithTarget?: (target: import('./model-picker.ts').ModelPickerTarget) => void;
+  requestRender: () => void;
+  handleEscape: () => void;
+};
+
+function syncRuntimeAfterSettingReset(ctx: CommandContext | undefined, key: string, value: unknown): void {
+  if (!ctx) return;
+  if (key === 'provider.model') ctx.session.runtime.model = String(value);
+  if (key === 'provider.reasoningEffort') ctx.session.runtime.reasoningEffort = String(value);
+}
+
+function consumeSettingsPickerRequest(state: SettingsRouteState): void {
+  const settingsAction = state.settingsModal.pendingSettingsPickerAction ?? null;
+  if (settingsAction !== null) {
+    state.settingsModal.pendingSettingsPickerAction = null;
+    if (!state.commandContext) return;
+    if (settingsAction === 'tts-provider') {
+      openTtsProviderPicker(state.commandContext);
+      return;
+    }
+    void openTtsVoicePicker(state.commandContext).catch((error: unknown) => {
+      state.commandContext?.print(`Unable to list TTS voices: ${error instanceof Error ? error.message : String(error)}`);
+      state.requestRender();
+    });
+    return;
+  }
+
+  const providerModelTarget = state.settingsModal.pendingProviderModelPickerTarget ?? null;
+  if (providerModelTarget !== null) {
+    state.settingsModal.pendingProviderModelPickerTarget = null;
+    state.openProviderModelPickerWithTarget?.(providerModelTarget);
+    return;
+  }
+  const pickerTarget = state.settingsModal.pendingModelPickerTarget;
+  if (pickerTarget !== null) {
+    state.settingsModal.pendingModelPickerTarget = null;
+    state.openModelPickerWithTarget?.(pickerTarget);
+  }
+}
+
+export function handleSettingsModalToken(state: SettingsRouteState, token: InputToken): boolean {
+  if (!state.settingsModal.active) return false;
+
+  if (token.type === 'key') {
+    const focusPane = state.settingsModal.focusPane ?? 'settings';
+    if (token.logicalName === 'escape') {
+      state.handleEscape();
+      return true;
+    }
+    if (token.logicalName === 'enter' || (token.logicalName === 'space' && !state.settingsModal.editingMode)) {
+      if (state.settingsModal.editingMode) state.settingsModal.commitEdit();
+      else if (focusPane === 'categories') state.settingsModal.focusSettings?.();
+      else if (state.settingsModal.currentCategory === 'flags') state.settingsModal.toggleSelectedFlag();
+      else {
+        state.settingsModal.activateSelected();
+        consumeSettingsPickerRequest(state);
+      }
+    } else if ((token.logicalName === 'left' || token.logicalName === 'right') && !state.settingsModal.editingMode) {
+      if (token.logicalName === 'left') state.settingsModal.focusCategories?.();
+      else state.settingsModal.focusSettings?.();
+    } else if (token.logicalName === 'up') {
+      if (state.settingsModal.moveFocusedUp) state.settingsModal.moveFocusedUp();
+      else state.settingsModal.moveUp?.();
+    } else if (token.logicalName === 'down') {
+      if (state.settingsModal.moveFocusedDown) state.settingsModal.moveFocusedDown();
+      else state.settingsModal.moveDown?.();
+    }
+    else if (token.logicalName === 'r' && !state.settingsModal.editingMode) {
+      const reset = state.settingsModal.resetSelected?.();
+      if (reset) syncRuntimeAfterSettingReset(state.commandContext, reset.key, reset.value);
+    }
+    else if (token.logicalName === 'tab') {
+      if (state.settingsModal.toggleFocusPane) state.settingsModal.toggleFocusPane();
+      else if (focusPane === 'categories') state.settingsModal.focusSettings?.();
+      else state.settingsModal.focusCategories?.();
+    }
+    else if (token.logicalName === 'backspace' && state.settingsModal.editingMode) state.settingsModal.editBackspace();
+  } else if (token.type === 'text') {
+    if (token.value === ' ' && !state.settingsModal.editingMode) {
+      const focusPane = state.settingsModal.focusPane ?? 'settings';
+      if (focusPane === 'categories') state.settingsModal.focusSettings?.();
+      else if (state.settingsModal.currentCategory === 'flags') state.settingsModal.toggleSelectedFlag();
+      else {
+        state.settingsModal.activateSelected();
+        consumeSettingsPickerRequest(state);
+      }
+    } else if (state.settingsModal.editingMode) {
+      state.settingsModal.editChar(token.value);
+    } else if (token.value === 'r') {
+      const reset = state.settingsModal.resetSelected?.();
+      if (reset) syncRuntimeAfterSettingReset(state.commandContext, reset.key, reset.value);
+    }
+  }
+
+  state.requestRender();
+  return true;
+}
+
+type SessionPickerRouteState = {
+  sessionPickerModal: {
+    active: boolean;
+    loadSelected: (conversationManager: CommandContext['session']['conversationManager']) => void;
+    moveUp: () => void;
+    moveDown: () => void;
+    deleteSelected: () => void;
+  };
+  commandContext?: CommandContext;
+  requestRender: () => void;
+  handleEscape: () => void;
+};
+
+export function handleSessionPickerToken(state: SessionPickerRouteState, token: InputToken): boolean {
+  if (!state.sessionPickerModal.active) return false;
+
+  if (token.type === 'key') {
+    if (token.logicalName === 'escape') {
+      state.handleEscape();
+      return true;
+    }
+    if (token.logicalName === 'enter') {
+      const conversationManager = state.commandContext?.session.conversationManager;
+      if (conversationManager) {
+        state.sessionPickerModal.loadSelected(conversationManager);
+      }
+    } else if (token.logicalName === 'up') state.sessionPickerModal.moveUp();
+    else if (token.logicalName === 'down') state.sessionPickerModal.moveDown();
+    else if (token.logicalName === 'd') state.sessionPickerModal.deleteSelected();
+  } else if (token.type === 'text' && token.value === 'd') {
+    state.sessionPickerModal.deleteSelected();
+  }
+
+  state.requestRender();
+  return true;
+}
+
+type ProfilePickerRouteState = {
+  profilePickerModal: {
+    active: boolean;
+    loadSelected: (configManager: CommandContext['platform']['configManager']) => void;
+    moveUp: () => void;
+    moveDown: () => void;
+    deleteSelected: () => void;
+    saveCurrentAs: (name: string, configManager: CommandContext['platform']['configManager']) => void;
+  };
+  commandContext?: CommandContext;
+  requestRender: () => void;
+  handleEscape: () => void;
+};
+
+export function handleProfilePickerToken(state: ProfilePickerRouteState, token: InputToken): boolean {
+  if (!state.profilePickerModal.active) return false;
+
+  const saveCurrent = (): void => {
+    if (state.commandContext?.platform.configManager) {
+      const name = `profile-${Date.now()}`;
+      state.profilePickerModal.saveCurrentAs(name, state.commandContext.platform.configManager);
+    }
+  };
+
+  if (token.type === 'key') {
+    if (token.logicalName === 'escape') {
+      state.handleEscape();
+      return true;
+    }
+    if (token.logicalName === 'enter') {
+      if (state.commandContext?.platform.configManager) {
+        state.profilePickerModal.loadSelected(state.commandContext.platform.configManager);
+      }
+    } else if (token.logicalName === 'up') state.profilePickerModal.moveUp();
+    else if (token.logicalName === 'down') state.profilePickerModal.moveDown();
+    else if (token.logicalName === 'd') state.profilePickerModal.deleteSelected();
+    else if (token.logicalName === 's') saveCurrent();
+  } else if (token.type === 'text') {
+    if (token.value === 'd') state.profilePickerModal.deleteSelected();
+    else if (token.value === 's') saveCurrent();
+  }
+
+  state.requestRender();
+  return true;
+}

package/src/input/handler-modal-stack.ts

@@ -0,0 +1,263 @@
+import {
+  closeModalByName,
+  getActiveModalName,
+  reopenModalByName,
+  type ActiveModalState,
+} from './handler-ui-state.ts';
+import type { SelectionResult } from './selection-modal.ts';
+
+export type ModalStackState = ActiveModalState & {
+  modalStack: string[];
+  modalReturnFocus?: 'prompt' | 'panel' | 'indicator';
+  panelFocused: boolean;
+  indicatorFocused: boolean;
+};
+
+export function modalOpened(state: ModalStackState, name: string): void {
+  if (getActiveModalName(state) === null && state.modalStack.length > 0) {
+    state.modalStack.length = 0;
+  }
+  if (state.modalStack[state.modalStack.length - 1] === name) return;
+  if (state.modalStack.includes(name)) return;
+  if (state.modalStack.length === 0) {
+    state.modalReturnFocus = state.indicatorFocused ? 'indicator' : state.panelFocused ? 'panel' : 'prompt';
+  }
+  state.modalStack.push(name);
+}
+
+export function clearModalStack(modalStack: string[]): void {
+  modalStack.length = 0;
+}
+
+export type EscapeState = ModalStackState & {
+  prompt: string;
+  cursorPos: number;
+  helpScrollOffset: number;
+  shortcutsScrollOffset: number;
+  requestRender: () => void;
+  saveUndoState: () => void;
+  cancelGeneration: (() => void) | undefined;
+  selectionCallback: ((result: SelectionResult | null) => void) | null;
+  bookmarkModal: ModalStackState['bookmarkModal'] & { open: () => void };
+  contextInspectorModal: ModalStackState['contextInspectorModal'] & { open: () => void };
+  processModal: ModalStackState['processModal'] & { open: () => void };
+  settingsModal: ModalStackState['settingsModal'] & {
+    editingMode: boolean;
+    cancelEdit: () => void;
+  };
+  mcpWorkspace?: ModalStackState['mcpWorkspace'];
+  agentWorkspace?: ModalStackState['agentWorkspace'];
+  selectionModal: ModalStackState['selectionModal'];
+  autocompleteReset: () => void;
+  autocompleteUpdate?: (query: string) => void;
+  clearOnboardingModelPickerCancelState?: () => void;
+  restoreOnboardingModelPickerCancelState?: () => void;
+};
+
+export function handleEscape(state: EscapeState): {
+  prompt: string;
+  cursorPos: number;
+  commandMode: boolean;
+  helpOverlayActive: boolean;
+  helpScrollOffset: number;
+  shortcutsOverlayActive: boolean;
+  shortcutsScrollOffset: number;
+  selectionCallback: ((result: SelectionResult | null) => void) | null;
+  panelFocused: boolean;
+  indicatorFocused: boolean;
+  modalReturnFocus: NonNullable<ModalStackState['modalReturnFocus']>;
+} {
+  let prompt = state.prompt;
+  let cursorPos = state.cursorPos;
+  let commandMode = state.commandMode;
+  let helpOverlayActive = state.helpOverlayActive;
+  let helpScrollOffset = state.helpScrollOffset;
+  let shortcutsOverlayActive = state.shortcutsOverlayActive;
+  let shortcutsScrollOffset = state.shortcutsScrollOffset;
+  let selectionCallback = state.selectionCallback;
+  let panelFocused = state.panelFocused;
+  let indicatorFocused = state.indicatorFocused;
+  let modalReturnFocus: NonNullable<ModalStackState['modalReturnFocus']> = state.modalReturnFocus ?? 'prompt';
+
+  const restoreFocus = (): void => {
+    if (state.modalStack.length > 0 || getActiveModalName({
+      ...state,
+      helpOverlayActive,
+      shortcutsOverlayActive,
+      commandMode,
+    }) !== null) return;
+    panelFocused = modalReturnFocus === 'panel';
+    indicatorFocused = modalReturnFocus === 'indicator';
+    modalReturnFocus = 'prompt';
+    state.modalReturnFocus = 'prompt';
+  };
+
+  if (state.settingsModal.active && state.settingsModal.editingMode) {
+    state.settingsModal.cancelEdit();
+    state.requestRender();
+    return {
+      prompt,
+      cursorPos,
+      commandMode,
+      helpOverlayActive,
+      helpScrollOffset,
+      shortcutsOverlayActive,
+      shortcutsScrollOffset,
+      selectionCallback,
+      panelFocused,
+      indicatorFocused,
+      modalReturnFocus,
+    };
+  }
+
+  const closeModal = (name: string): void => {
+    closeModalByName(name, {
+      resetHelp: () => {
+        helpOverlayActive = false;
+        helpScrollOffset = 0;
+      },
+      resetShortcuts: () => {
+        shortcutsOverlayActive = false;
+        shortcutsScrollOffset = 0;
+      },
+      closeBookmark: () => state.bookmarkModal.close(),
+      closeAgentDetail: () => state.agentDetailModal.close(),
+      closeLiveTail: () => state.liveTailModal.close(),
+      closeSettings: () => state.settingsModal.close(),
+      closeMcpWorkspace: () => state.mcpWorkspace?.close(),
+      closeAgentWorkspace: () => state.agentWorkspace?.close(),
+      closeSessionPicker: () => state.sessionPickerModal.close(),
+      closeProfilePicker: () => state.profilePickerModal.close(),
+      closeContextInspector: () => state.contextInspectorModal.close(),
+      closeProcess: () => state.processModal.close(),
+      closeModelPicker: () => {
+        state.modelPicker.close();
+        state.restoreOnboardingModelPickerCancelState?.();
+      },
+      closeFilePicker: () => state.filePicker.close(),
+      closeBlockActions: () => state.blockActionsMenu.close(),
+      closeSelection: () => {
+        const cb = selectionCallback;
+        selectionCallback = null;
+        state.selectionModal.close();
+        cb?.(null);
+      },
+      closeOnboarding: () => {
+        state.onboardingWizard?.close();
+        state.clearOnboardingModelPickerCancelState?.();
+      },
+      closeCommandMode: () => {
+        commandMode = false;
+        for (let i = state.modalStack.length - 1; i >= 0; i--) {
+          if (state.modalStack[i] === 'command') state.modalStack.splice(i, 1);
+        }
+        state.autocompleteReset();
+        prompt = '';
+        cursorPos = 0;
+      },
+    });
+  };
+
+  const reopenModal = (name: string): void => {
+    reopenModalByName(name, {
+      openHelp: () => { helpOverlayActive = true; },
+      openShortcuts: () => { shortcutsOverlayActive = true; },
+      openBookmark: () => state.bookmarkModal.open(),
+      openProcess: () => state.processModal.open(),
+      openContextInspector: () => state.contextInspectorModal.open(),
+      openMcpWorkspace: () => state.mcpWorkspace?.reopen(),
+      openAgentWorkspace: () => state.agentWorkspace?.reopen(),
+      openOnboarding: () => state.onboardingWizard?.reopen(),
+      openCommandMode: () => {
+        commandMode = true;
+        prompt = '/';
+        cursorPos = 1;
+        state.autocompleteUpdate?.('');
+      },
+    });
+  };
+
+  if (state.modalStack.length > 0) {
+    const current = state.modalStack.pop()!;
+    const previous = state.modalStack[state.modalStack.length - 1];
+    closeModal(current);
+    if (previous) {
+      reopenModal(previous);
+    } else {
+      restoreFocus();
+    }
+    state.requestRender();
+    return {
+      prompt,
+      cursorPos,
+      commandMode,
+      helpOverlayActive,
+      helpScrollOffset,
+      shortcutsOverlayActive,
+      shortcutsScrollOffset,
+      selectionCallback,
+      panelFocused,
+      indicatorFocused,
+      modalReturnFocus,
+    };
+  }
+
+  const active = getActiveModalName({
+    ...state,
+    helpOverlayActive,
+    shortcutsOverlayActive,
+    commandMode,
+  });
+  if (active) {
+    closeModal(active);
+    restoreFocus();
+    state.requestRender();
+    return {
+      prompt,
+      cursorPos,
+      commandMode,
+      helpOverlayActive,
+      helpScrollOffset,
+      shortcutsOverlayActive,
+      shortcutsScrollOffset,
+      selectionCallback,
+      panelFocused,
+      indicatorFocused,
+      modalReturnFocus,
+    };
+  }
+
+  if (prompt.length > 0) {
+    state.saveUndoState();
+    prompt = '';
+    cursorPos = 0;
+    return {
+      prompt,
+      cursorPos,
+      commandMode,
+      helpOverlayActive,
+      helpScrollOffset,
+      shortcutsOverlayActive,
+      shortcutsScrollOffset,
+      selectionCallback,
+      panelFocused,
+      indicatorFocused,
+      modalReturnFocus,
+    };
+  }
+
+  state.cancelGeneration?.();
+  return {
+    prompt,
+    cursorPos,
+    commandMode,
+    helpOverlayActive,
+    helpScrollOffset,
+    shortcutsOverlayActive,
+    shortcutsScrollOffset,
+    selectionCallback,
+    panelFocused,
+    indicatorFocused,
+    modalReturnFocus,
+  };
+}