@pellux/goodvibes-tui 1.1.0 → 1.9.0

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

@@ -1,6 +1,7 @@
 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 type { ConfigModal } from './config-modal.ts';
 import { openTtsProviderPicker, openTtsVoicePicker } from './tts-settings-actions.ts';
 import { isTextBackspace } from './delete-key-policy.ts';
 import { summarizeError } from '@pellux/goodvibes-sdk/platform/utils';
@@ -93,16 +94,26 @@ export function handleSelectionModalToken(state: SelectionRouteState, token: Inp
         if (selected) {
           dispatchSelectionAction(action, selected);
         }
+      } else if (state.selectionModal.allowSearch) {
+        // UX-C instant filter: an unclaimed keystroke arms search AND starts
+        // the query immediately, instead of silently doing nothing until the
+        // user discovers '/' first (the "help search needs '/' arming while
+        // the palette filters instantly" evaluator finding — /help has no
+        // customActions, so every letter used to be swallowed here). '/'
+        // above still works too; this is additive, not a replacement, and
+        // never fires for a claimed hotkey letter (checked first, above).
+        state.selectionModal.focusSearch();
+        state.selectionModal.setQuery(token.value);
       }
     }
   } 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;
-      }
+      // UX-C: ONE Escape always closes the modal, regardless of search state.
+      // Clearing an in-progress query is Backspace's job, not Esc's — the old
+      // two-stage contract (1st Esc clears query, 2nd blurs search, 3rd
+      // finally closes) was the "help modal took 3 Escapes after searching"
+      // evaluator finding (searchFocused is not modal-specific — every
+      // SelectionModal-based picker had the same multi-Esc pattern).
       state.handleEscape();
       return true;
     }
@@ -533,3 +544,122 @@ export function handleProfilePickerToken(state: ProfilePickerRouteState, token:
   state.requestRender();
   return true;
 }
+
+type ConfigModalRouteState = {
+  configModal: ConfigModal;
+  commandContext?: CommandContext;
+  requestRender: () => void;
+  handleEscape: () => void;
+};
+
+/**
+ * Route a key to the generic config-modal host (W6.1 MIGRATE-TO-MODAL
+ * surfaces). The host owns the reserved navigation keys (Esc, up/down/j/k tab
+ * left/right, and now '/' — DEBT-5 item 1's type-to-filter, armed the same
+ * way as scrollable-list-panel.ts's opt-in filter and SettingsModal's own
+ * '/'-armed search); every other key is offered to the active surface's
+ * declarative action table (fireAction handles the two-press confirm for
+ * destructive actions). Any unrecognised key is absorbed so the modal stays
+ * modal — this is the same "active modal captures all keys" shape as the
+ * other modal routers.
+ *
+ * While the filter is armed (`configModal.isFilterActive()`), printable text
+ * tokens go to the query instead of nav/action dispatch — this is WHY 'j'/'k'
+ * lose their vim-nav meaning mid-filter (you're typing, not navigating) but
+ * Escape, Backspace, and the arrow/tab nav keys keep their ordinary meaning
+ * (arrows navigate the FILTERED list; Enter still acts on the selected row).
+ */
+export function handleConfigModalToken(state: ConfigModalRouteState, token: InputToken): boolean {
+  if (!state.configModal.active) return false;
+
+  // Every token that reaches the modal is a user interaction — after the
+  // first one, structure freezes to interaction boundaries (liveness rule).
+  // Before it, renders may sync structure so async onOpen loads appear
+  // without a keypress (batch refutation finding 3).
+  state.configModal.noteInteraction();
+
+  const filtering = state.configModal.isFilterActive();
+
+  if (token.type === 'key') {
+    if (token.logicalName === 'escape') {
+      // Two-stage Esc, but ONLY while there is a query to clear (the one
+      // documented exception to single-Esc-close): clearFilterOrFallthrough
+      // returns false on an empty query, so an armed-but-empty filter (or no
+      // filter at all) closes the modal in one press, same as every other
+      // modal here.
+      if (state.configModal.clearFilterOrFallthrough()) {
+        state.requestRender();
+        return true;
+      }
+      state.handleEscape();
+      return true;
+    }
+    if (filtering && isTextBackspace(token.logicalName ?? '')) {
+      state.configModal.backspaceFilter();
+      state.requestRender();
+      return true;
+    }
+    if (!filtering && token.logicalName === '/') {
+      state.configModal.activateFilter();
+      state.requestRender();
+      return true;
+    }
+    switch (token.logicalName) {
+      case 'up':
+        state.configModal.moveUp();
+        state.requestRender();
+        return true;
+      case 'down':
+        state.configModal.moveDown();
+        state.requestRender();
+        return true;
+      case 'left':
+        state.configModal.prevTab();
+        state.requestRender();
+        return true;
+      case 'right':
+      case 'tab':
+        state.configModal.nextTab();
+        state.requestRender();
+        return true;
+    }
+    // Any other 'key' token (e.g. 'enter') falls through to the action table
+    // below even while filtering — only printable TEXT tokens are captured
+    // by the filter (below), so Enter still fires on the current selection.
+  } else if (token.type === 'text') {
+    if (!filtering && token.value === '/') {
+      state.configModal.activateFilter();
+      state.requestRender();
+      return true;
+    }
+    if (filtering) {
+      // The WHOLE token value lands in the filter in one call — including a
+      // multi-char paste token — never split into per-char nav/action
+      // dispatch (the text-capture invariant this item's brief calls out).
+      state.configModal.appendFilterText(token.value);
+      state.requestRender();
+      return true;
+    }
+    if (token.value === 'j') { state.configModal.moveDown(); state.requestRender(); return true; }
+    if (token.value === 'k') { state.configModal.moveUp(); state.requestRender(); return true; }
+  }
+
+  const actionKey = token.type === 'key' ? (token.logicalName ?? '') : token.type === 'text' ? token.value : '';
+  const submitInput = state.commandContext?.submitInput;
+  const fired = actionKey.length > 0 && state.configModal.fireAction(actionKey, {
+    print: (message: string) => state.commandContext?.print(message),
+    executeCommand: state.commandContext?.executeCommand,
+    openModal: state.commandContext?.openModal,
+    ...(submitInput ? { submitInput: (text: string) => submitInput(text) } : {}),
+  });
+  if (fired) {
+    state.requestRender();
+    return true;
+  }
+
+  // Unhandled key while a config modal is open: drop any pending confirm and
+  // absorb the key (the modal owns the keyboard while it is active).
+  state.configModal.clearConfirmOnMiss();
+  state.requestRender();
+  return true;
+}

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

@@ -40,12 +40,12 @@ export type EscapeState = ModalStackState & {
   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'];
+  configModal: ModalStackState['configModal'] & { reopen: () => void };
   selectionModal: ModalStackState['selectionModal'];
   autocompleteReset: () => void;
   autocompleteUpdate?: (query: string) => void;
@@ -120,14 +120,12 @@ export function handleEscape(state: EscapeState): {
         shortcutsScrollOffset = 0;
       },
       closeBookmark: () => state.bookmarkModal.close(),
-      closeAgentDetail: () => state.agentDetailModal.close(),
-      closeLiveTail: () => state.liveTailModal.close(),
       closeSettings: () => state.settingsModal.close(),
       closeMcpWorkspace: () => state.mcpWorkspace?.close(),
       closeSessionPicker: () => state.sessionPickerModal.close(),
       closeProfilePicker: () => state.profilePickerModal.close(),
+      closeConfigModal: () => state.configModal.close(),
       closeContextInspector: () => state.contextInspectorModal.close(),
-      closeProcess: () => state.processModal.close(),
       closeModelPicker: () => {
         state.modelPicker.close();
         state.restoreOnboardingModelPickerCancelState?.();
@@ -150,8 +148,17 @@ export function handleEscape(state: EscapeState): {
           if (state.modalStack[i] === 'command') state.modalStack.splice(i, 1);
         }
         state.autocompleteReset();
-        prompt = '';
-        cursorPos = 0;
+        // Esc's palette-dismiss convention: a bare '/' with nothing typed
+        // after it IS the palette, so Esc clears it along with the slash
+        // (first Esc, one step, done — no lingering '/' to backspace out).
+        // Once the user has typed a command name (or anything else) past
+        // the slash, Esc's job is only to dismiss the ghost-suggestion
+        // overlay; the typed text is real composer content and stays put,
+        // just no longer treated as an in-progress command.
+        if (prompt === '/') {
+          prompt = '';
+          cursorPos = 0;
+        }
       },
     });
   };
@@ -161,8 +168,8 @@ export function handleEscape(state: EscapeState): {
       openHelp: () => { helpOverlayActive = true; },
       openShortcuts: () => { shortcutsOverlayActive = true; },
       openBookmark: () => state.bookmarkModal.open(),
-      openProcess: () => state.processModal.open(),
       openContextInspector: () => state.contextInspectorModal.open(),
+      openConfigModal: () => state.configModal.reopen(),
       openMcpWorkspace: () => state.mcpWorkspace?.reopen(),
       openOnboarding: () => state.onboardingWizard?.reopen(),
       openCommandMode: () => {

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

@@ -5,13 +5,11 @@ import type { BookmarkModal } from './bookmark-modal.ts';
 import type { SettingsModal } from './settings-modal.ts';
 import type { SessionPickerModal } from './session-picker-modal.ts';
 import type { ProfilePickerModal } from './profile-picker-modal.ts';
+import type { ConfigModal } from './config-modal.ts';
 import type { HistorySearch } from './input-history.ts';
 import type { ModelPickerModal } from './model-picker.ts';
 import { handleMcpWorkspaceToken, type McpWorkspace } from './mcp-workspace.ts';
 import type { CommandContext } from './command-registry.ts';
-import type { LiveTailModal } from '../renderer/live-tail-modal.ts';
-import type { ProcessModal } from '../renderer/process-modal.ts';
-import type { AgentDetailModal } from '../renderer/agent-detail-modal.ts';
 import type { ContextInspectorModal } from '../renderer/context-inspector.ts';
 import type { FilePickerModal } from './file-picker.ts';
 import type { BlockActionsMenu, BlockActionId } from '../renderer/block-actions.ts';
@@ -21,6 +19,7 @@ import { handleHistorySearchToken, handleOverlayToken, handleSearchModeToken } f
 import { handleOnboardingWizardToken } from './onboarding/handler-onboarding-routes.ts';
 import {
   handleBookmarkModalToken,
+  handleConfigModalToken,
   handleProfilePickerToken,
   handleSelectionModalToken,
   handleSessionPickerToken,
@@ -30,9 +29,7 @@ import {
   handleBlockActionsToken,
   handleEscapeOnlyModalToken,
   handleFilePickerToken,
-  handleLiveTailToken,
   handleModelPickerToken,
-  handleProcessModalToken,
 } from './handler-picker-routes.ts';
 
 export type ModalTokenRouteState = {
@@ -47,6 +44,7 @@ export type ModalTokenRouteState = {
   mcpWorkspace: McpWorkspace;
   sessionPickerModal: SessionPickerModal;
   profilePickerModal: ProfilePickerModal;
+  configModal: ConfigModal;
   onboardingWizard: OnboardingWizardController;
   helpOverlayActive: boolean;
   helpScrollOffset: number;
@@ -61,9 +59,6 @@ export type ModalTokenRouteState = {
   getViewportHeight: () => number;
   requestRender: () => void;
   handleEscape: () => void;
-  liveTailModal: LiveTailModal;
-  processModal: ProcessModal;
-  agentDetailModal: AgentDetailModal;
   contextInspectorModal: ContextInspectorModal;
   modalOpened: (name: string) => void;
   filePicker: FilePickerModal;
@@ -177,6 +172,15 @@ export function handleModalTokenRoutes(state: ModalTokenRouteState, token: Input
     return withState(state, true);
   }
 
+  if (handleConfigModalToken({
+    configModal: state.configModal,
+    commandContext: state.commandContext,
+    requestRender: state.requestRender,
+    handleEscape: state.handleEscape,
+  }, token)) {
+    return withState(state, true);
+  }
+
   const overlayState = {
     helpOverlayActive: state.helpOverlayActive,
     helpScrollOffset: state.helpScrollOffset,
@@ -223,36 +227,10 @@ export function handleModalTokenRoutes(state: ModalTokenRouteState, token: Input
     return withState(state, true);
   }
 
-  if (handleLiveTailToken({
-    liveTailModal: state.liveTailModal,
-    processModal: state.processModal,
-    requestRender: state.requestRender,
-    handleEscape: state.handleEscape,
-  }, token)) {
-    return withState(state, true);
-  }
-
-  // Agent detail modal: route c + confirm keys before escape-close.
-  // handleKey() consumes confirm-flow keys (y, Enter, n, Esc) and the 'c'
-  // initiator; unhandled keys (including Esc when no confirm is pending)
-  // fall through to escape-close below.
-  if (state.agentDetailModal.active) {
-    const keyStr: string =
-      token.type === 'key' ? (token.logicalName ?? '') :
-      token.type === 'text' ? token.value : '';
-    if (keyStr && state.agentDetailModal.handleKey(keyStr)) {
-      state.requestRender();
-      return withState(state, true);
-    }
-    // 'c' was not consumed (non-cancellable), or any other key.
-    // Esc closes the modal; all other keys are absorbed by the active modal.
-    if (token.type === 'key' && token.logicalName === 'escape') {
-      state.handleEscape();
-      return withState(state, true);
-    }
-    state.requestRender();
-    return withState(state, true);
-  }
+  // W6.1 retirement: the live-tail, agent-detail, and process-modal token
+  // routes were removed with those modals (F2 now opens Fleet, which subsumes
+  // the live process tree; the three modals were structurally unreachable after
+  // the F2 repoint and were deleted).
 
   if (handleEscapeOnlyModalToken({
     active: state.contextInspectorModal.active,
@@ -262,17 +240,6 @@ export function handleModalTokenRoutes(state: ModalTokenRouteState, token: Input
     return withState(state, true);
   }
 
-  if (handleProcessModalToken({
-    processModal: state.processModal,
-    liveTailModal: state.liveTailModal,
-    agentDetailModal: state.agentDetailModal,
-    modalOpened: state.modalOpened,
-    requestRender: state.requestRender,
-    handleEscape: state.handleEscape,
-  }, token)) {
-    return withState(state, true);
-  }
-
   const filePickerState = {
     filePicker: state.filePicker,
     prompt: state.prompt,

package/src/input/handler-onboarding-daemon-adopt.ts

@@ -0,0 +1,149 @@
+/**
+ * F1 (One-Platform Wave 2 friction fix): the onboarding wizard's "Connect to
+ * this daemon now" action, wired from the Network step's `network.daemon-source`
+ * = 'adopt' fields. Extracted from handler-onboarding.ts to keep that file
+ * under the architecture line cap.
+ */
+import { join } from 'node:path';
+import { summarizeError } from '@pellux/goodvibes-sdk/platform/utils';
+import { resolveDaemonCompanionToken } from '../runtime/operator-token-cleanup.ts';
+import {
+  buildManagedDaemonServiceManager,
+  detectLegacyUnit,
+  resolveInstalledDaemonBinary,
+  runLegacyDaemonMigration,
+  MANAGED_SERVICE_NAME,
+} from '../runtime/legacy-daemon-migration.ts';
+import type { InputHandlerLike as InputHandler } from './handler-types.ts';
+import {
+  formatRuntimeActiveSuccessMessage,
+  getRuntimeEndpointStatus,
+  isRuntimeEndpointActive,
+  runtimePortDiagnostic,
+} from './onboarding/onboarding-runtime-status.ts';
+
+/**
+ * Immediately (not deferred to the final wizard Apply):
+ *   1. Installs the pasted token into <homeDirectory>/.goodvibes/daemon/operator-tokens.json
+ *      via `resolveDaemonCompanionToken` — the same durable-persistence logic
+ *      the `GOODVIBES_DAEMON_TOKEN` non-interactive override uses.
+ *   2. Points `controlPlane.host`/`controlPlane.port` at the pasted host/port.
+ *   3. Restarts the external-services controller and reports back, honestly,
+ *      whether the daemon at that host/port was actually adopted — reusing
+ *      the same `onboarding-runtime-status.ts` helpers the normal
+ *      start-a-new-daemon path uses to report success/failure after Apply.
+ *
+ * Feedback is printed to the conversation feed (matching the existing
+ * start-openai-subscription action's pattern) rather than stored as wizard
+ * field state, because a 'status' field's value is recomputed fresh from the
+ * step builder on every render and is not a place to durably stash an
+ * out-of-band result.
+ */
+export async function handleConnectExistingDaemonForHandler(handler: InputHandler): Promise<void> {
+  if (handler.onboardingApplyPending) return;
+  const host = handler.onboardingWizard.getStringFieldValue('network.adopt-daemon-host', '127.0.0.1').trim() || '127.0.0.1';
+  const port = handler.onboardingWizard.getPortFieldValue('network.adopt-daemon-port', 3421);
+  const token = handler.onboardingWizard.getStringFieldValue('network.adopt-daemon-token', '').trim();
+  if (token.length === 0) {
+    handler.commandContext?.print?.('Connect to existing daemon: paste that daemon\'s token first.');
+    return;
+  }
+
+  const externalServices = handler.uiServices.platform.externalServices;
+  if (!externalServices) {
+    handler.commandContext?.print?.('Connect to existing daemon: background service controller is unavailable in this build.');
+    return;
+  }
+
+  handler.onboardingApplyPending = true;
+  handler.requestRender();
+  try {
+    const daemonHomeDir = join(handler.uiServices.environment.homeDirectory, '.goodvibes', 'daemon');
+    resolveDaemonCompanionToken(daemonHomeDir, token);
+    handler.uiServices.platform.configManager.setDynamic('controlPlane.host', host);
+    handler.uiServices.platform.configManager.setDynamic('controlPlane.port', port);
+
+    const state = await externalServices.restart();
+    const binding = { label: 'GoodVibes daemon', host, port };
+    if (isRuntimeEndpointActive(state, 'daemon')) {
+      handler.commandContext?.print?.([
+        'Connect to existing daemon: succeeded.',
+        `  ${formatRuntimeActiveSuccessMessage('daemon', state)}`,
+        '  This host/port and token are applied now; Apply at the end of the wizard will persist them.',
+      ].join('\n'));
+    } else {
+      const status = getRuntimeEndpointStatus(state, 'daemon');
+      handler.commandContext?.print?.([
+        'Connect to existing daemon: could not verify a connection.',
+        `  ${runtimePortDiagnostic(binding, undefined, status)}`,
+        '  Check the host, port, and token, then try again.',
+      ].join('\n'));
+    }
+  } catch (error) {
+    handler.commandContext?.print?.(`Connect to existing daemon failed: ${summarizeError(error)}`);
+  } finally {
+    handler.onboardingApplyPending = false;
+    handler.requestRender();
+  }
+}
+
+/**
+ * W4-D1: the guided UX entry point for migrating a legacy
+ * `goodvibes-daemon.service` unit (Wave 3 shipped detect+disclose only; this
+ * closes that inheritance). This is a thin wrapper over
+ * `detectLegacyUnit` + `runLegacyDaemonMigration`
+ * (`../runtime/legacy-daemon-migration.ts`) — the actual migration mechanics
+ * (never auto-migrate, new-up-then-old-down with a health check before the
+ * legacy unit is touched, adopt-or-warn for an unrecognized process on the
+ * port) live there and are exercised against fakes in
+ * `src/test/daemon/service-commands.test.ts`; this function only builds the
+ * same `PlatformServiceManager` the daemon CLI's `migrate-service` subcommand
+ * builds (via the shared `buildManagedDaemonServiceManager`, so a migration
+ * triggered from either surface installs the identical unit) and prints the
+ * honest result lines to the conversation feed, mirroring
+ * `handleConnectExistingDaemonForHandler`'s pattern above.
+ *
+ * This lives in `src/input/` rather than importing
+ * `../daemon/service-commands.ts` directly because the architecture gate's
+ * `input-no-entrypoints` rule forbids `src/input/**` from depending on
+ * `src/daemon/**` (input must stay a pure event-handling layer) — the shared
+ * engine lives in the entrypoint-agnostic `src/runtime/` layer instead.
+ *
+ * `confirm` is caller-supplied rather than read from a fixed field name here
+ * so this stays reusable from any surface: the onboarding wizard's Network
+ * step (`onboarding-wizard-network-adopt.ts`'s `pushLegacyDaemonMigrationFields`,
+ * dispatched from `handler-onboarding.ts`'s `migrate-legacy-daemon-service`
+ * action) reads its own `network.migrate-legacy-daemon-confirm` checklist
+ * toggle and passes it through as this parameter — unchecked previews the
+ * dry-run plan (`confirm: false`), checked executes the real migration
+ * (`confirm: true`).
+ */
+export async function handleMigrateLegacyDaemonServiceForHandler(handler: InputHandler, confirm: boolean): Promise<void> {
+  if (handler.onboardingApplyPending) return;
+
+  handler.onboardingApplyPending = true;
+  handler.requestRender();
+  try {
+    const homeDirectory = handler.uiServices.environment.homeDirectory;
+    const configManager = handler.uiServices.platform.configManager;
+    const host = String(configManager.get('controlPlane.host') ?? '127.0.0.1');
+    const port = Number(configManager.get('controlPlane.port') ?? 3421);
+    const binaryPath = resolveInstalledDaemonBinary({ moduleUrl: import.meta.url });
+
+    const manager = buildManagedDaemonServiceManager({ binaryPath, homeDir: homeDirectory, host, port });
+    const legacy = detectLegacyUnit({ homeDir: homeDirectory });
+    const result = await runLegacyDaemonMigration(
+      { host, port, trackedServiceName: MANAGED_SERVICE_NAME, confirmMigration: confirm },
+      manager,
+      legacy,
+    );
+    handler.commandContext?.print?.(
+      ['Migrate legacy daemon service:', ...result.lines.map((line: string) => `  ${line}`)].join('\n'),
+    );
+  } catch (error) {
+    handler.commandContext?.print?.(`Migrate legacy daemon service failed: ${summarizeError(error)}`);
+  } finally {
+    handler.onboardingApplyPending = false;
+    handler.requestRender();
+  }
+}