@jmoyers/harness 0.1.11 → 0.1.20

package/packages/harness-ui/src/index.ts

@@ -0,0 +1,18 @@
+export * from './text-layout.ts';
+export * from './surface.ts';
+export * from './kit.ts';
+export * from './frame-primitives.ts';
+export * from './screen.ts';
+export * from './modal-manager.ts';
+export * from './layout.ts';
+export * from './interaction/conversation-input-forwarder.ts';
+export * from './interaction/conversation-selection-input.ts';
+export * from './interaction/global-shortcut-input.ts';
+export * from './interaction/input-preflight.ts';
+export * from './interaction/input-token-router.ts';
+export * from './interaction/input.ts';
+export * from './interaction/left-nav-input.ts';
+export * from './interaction/rail-pointer-input.ts';
+export * from './interaction/main-pane-pointer-input.ts';
+export * from './interaction/pointer-routing-input.ts';
+export * from './interaction/repository-fold-input.ts';

package/packages/harness-ui/src/interaction/conversation-input-forwarder.ts

@@ -0,0 +1,221 @@
+type MainPaneMode = 'conversation' | 'project' | 'home' | 'nim';
+
+interface ConversationSnapshotViewport {
+  readonly top: number;
+  readonly totalRows: number;
+  readonly followOutput: boolean;
+}
+
+export interface ConversationSnapshotFrame {
+  readonly activeScreen: 'primary' | 'alternate';
+  readonly viewport: ConversationSnapshotViewport;
+  readonly lines: readonly string[];
+}
+
+interface ConversationInputOracle<TSnapshotForInput extends ConversationSnapshotFrame> {
+  snapshotWithoutHash: () => TSnapshotForInput;
+  isMouseTrackingEnabled: () => boolean;
+  scrollViewport: (deltaRows: number) => void;
+}
+
+export interface ConversationInputState<
+  TSnapshotForInput extends ConversationSnapshotFrame = ConversationSnapshotFrame,
+> {
+  readonly sessionId: string;
+  readonly directoryId: string | null;
+  readonly controller: unknown | null;
+  readonly oracle: ConversationInputOracle<TSnapshotForInput>;
+}
+
+interface ConversationInputLayout {
+  readonly cols: number;
+  readonly rows: number;
+  readonly paneRows: number;
+  readonly statusRow: number;
+  readonly leftCols: number;
+  readonly rightCols: number;
+  readonly separatorCol: number;
+  readonly rightStartCol: number;
+}
+
+type ConversationInputToken =
+  | {
+      readonly kind: 'passthrough';
+      readonly text: string;
+    }
+  | {
+      readonly kind: 'mouse';
+      readonly event: {
+        readonly sequence: string;
+        readonly code: number;
+        readonly col: number;
+        readonly row: number;
+        readonly final: 'M' | 'm';
+      };
+    };
+
+interface ParsedConversationInputChunk {
+  readonly tokens: readonly ConversationInputToken[];
+  readonly remainder: string;
+}
+
+interface InputTokenRouterLike<
+  TConversation extends ConversationInputState<TSnapshotForInput>,
+  TSnapshotForInput extends ConversationSnapshotFrame,
+> {
+  routeTokens(input: {
+    readonly tokens: readonly ConversationInputToken[];
+    readonly layout: ConversationInputLayout;
+    readonly conversation: TConversation | null;
+    readonly snapshotForInput: TSnapshotForInput | null;
+  }): {
+    readonly routedTokens: readonly ConversationInputToken[];
+    readonly snapshotForInput: TSnapshotForInput | null;
+  };
+}
+
+interface RouteConversationTokensOptions<TSnapshotForInput extends ConversationSnapshotFrame> {
+  readonly tokens: readonly ConversationInputToken[];
+  readonly mainPaneMode: MainPaneMode;
+  readonly normalizeMuxKeyboardInputForPty: (input: Buffer) => Buffer;
+  readonly classifyPaneAt: (col: number, row: number) => string;
+  readonly wheelDeltaRowsFromCode: (code: number) => number | null;
+  readonly hasShiftModifier: (code: number) => boolean;
+  readonly layout: {
+    readonly paneRows: number;
+    readonly rightCols: number;
+    readonly rightStartCol: number;
+  };
+  readonly snapshotForInput: TSnapshotForInput | null;
+  readonly appMouseTrackingEnabled: boolean;
+}
+
+interface RouteConversationTokensResult {
+  readonly mainPaneScrollRows: number;
+  readonly forwardToSession: readonly Buffer[];
+}
+
+function hasShiftModifier(code: number): boolean {
+  return (code & 0b0000_0100) !== 0;
+}
+
+function wheelDeltaRowsFromCode(code: number): number | null {
+  if ((code & 0b0100_0000) === 0) {
+    return null;
+  }
+  return (code & 0b0000_0001) === 0 ? -1 : 1;
+}
+
+export interface ConversationInputForwarderOptions<
+  TSnapshotForInput extends ConversationSnapshotFrame = ConversationSnapshotFrame,
+  TConversation extends ConversationInputState<TSnapshotForInput> =
+    ConversationInputState<TSnapshotForInput>,
+> {
+  readonly getInputRemainder: () => string;
+  readonly setInputRemainder: (next: string) => void;
+  readonly getMainPaneMode: () => MainPaneMode;
+  readonly getLayout: () => ConversationInputLayout;
+  readonly inputTokenRouter: InputTokenRouterLike<TConversation, TSnapshotForInput>;
+  readonly getActiveConversation: () => TConversation | null;
+  readonly markDirty: () => void;
+  isControlledByLocalHuman(input: {
+    readonly conversation: TConversation;
+    readonly controllerId: string;
+  }): boolean;
+  readonly controllerId: string;
+  readonly sendInputToSession: (sessionId: string, chunk: Buffer) => void;
+  readonly noteGitActivity: (directoryId: string | null) => void;
+  parseMuxInputChunk(previousRemainder: string, chunk: Buffer): ParsedConversationInputChunk;
+  routeInputTokensForConversation(
+    options: RouteConversationTokensOptions<TSnapshotForInput>,
+  ): RouteConversationTokensResult;
+  classifyPaneAt(layout: ConversationInputLayout, col: number, row: number): string;
+  normalizeMuxKeyboardInputForPty(input: Buffer): Buffer;
+  handlePassthroughTextInMainPaneMode?: (input: {
+    readonly mainPaneMode: Exclude<MainPaneMode, 'conversation'>;
+    readonly text: string;
+  }) => void;
+}
+
+export class ConversationInputForwarder<
+  TSnapshotForInput extends ConversationSnapshotFrame = ConversationSnapshotFrame,
+  TConversation extends ConversationInputState<TSnapshotForInput> =
+    ConversationInputState<TSnapshotForInput>,
+> {
+  constructor(
+    private readonly options: ConversationInputForwarderOptions<TSnapshotForInput, TConversation>,
+  ) {}
+
+  handleInput(input: Buffer): void {
+    const mainPaneMode = this.options.getMainPaneMode();
+    const parsed = this.options.parseMuxInputChunk(this.options.getInputRemainder(), input);
+    this.options.setInputRemainder(parsed.remainder);
+
+    const layout = this.options.getLayout();
+    const inputConversation = this.options.getActiveConversation();
+    const { routedTokens, snapshotForInput } = this.options.inputTokenRouter.routeTokens({
+      tokens: parsed.tokens,
+      layout,
+      conversation: inputConversation,
+      snapshotForInput:
+        inputConversation === null ? null : inputConversation.oracle.snapshotWithoutHash(),
+    });
+
+    const { mainPaneScrollRows, forwardToSession } = this.options.routeInputTokensForConversation({
+      tokens: routedTokens,
+      mainPaneMode,
+      normalizeMuxKeyboardInputForPty: this.options.normalizeMuxKeyboardInputForPty,
+      classifyPaneAt: (col, row) => this.options.classifyPaneAt(layout, col, row),
+      wheelDeltaRowsFromCode,
+      hasShiftModifier,
+      layout: {
+        paneRows: layout.paneRows,
+        rightCols: layout.rightCols,
+        rightStartCol: layout.rightStartCol,
+      },
+      snapshotForInput,
+      appMouseTrackingEnabled:
+        inputConversation === null ? false : inputConversation.oracle.isMouseTrackingEnabled(),
+    });
+
+    if (
+      mainPaneMode !== 'conversation' &&
+      this.options.handlePassthroughTextInMainPaneMode !== undefined
+    ) {
+      for (const token of routedTokens) {
+        if (token.kind !== 'passthrough' || token.text.length === 0) {
+          continue;
+        }
+        this.options.handlePassthroughTextInMainPaneMode({
+          mainPaneMode,
+          text: token.text,
+        });
+      }
+    }
+
+    if (mainPaneScrollRows !== 0 && inputConversation !== null) {
+      inputConversation.oracle.scrollViewport(mainPaneScrollRows);
+      this.options.markDirty();
+    }
+
+    if (inputConversation === null) {
+      return;
+    }
+    if (
+      inputConversation.controller !== null &&
+      !this.options.isControlledByLocalHuman({
+        conversation: inputConversation,
+        controllerId: this.options.controllerId,
+      })
+    ) {
+      return;
+    }
+
+    for (const forwardChunk of forwardToSession) {
+      this.options.sendInputToSession(inputConversation.sessionId, forwardChunk);
+    }
+    if (forwardToSession.length > 0) {
+      this.options.noteGitActivity(inputConversation.directoryId);
+    }
+  }
+}

package/packages/harness-ui/src/interaction/conversation-selection-input.ts

@@ -0,0 +1,213 @@
+export interface SelectionPoint {
+  readonly rowAbs: number;
+  readonly col: number;
+}
+
+export interface PaneSelection {
+  readonly anchor: SelectionPoint;
+  readonly focus: SelectionPoint;
+  readonly text: string;
+}
+
+export interface PaneSelectionDrag {
+  readonly anchor: SelectionPoint;
+  readonly focus: SelectionPoint;
+  readonly hasDragged: boolean;
+}
+
+export interface SelectionLayout {
+  readonly paneRows: number;
+  readonly rightCols: number;
+  readonly rightStartCol: number;
+}
+
+export interface ConversationSelectionSnapshotFrame {
+  readonly colorKind?: 'default' | 'indexed' | 'rgb';
+  readonly rows: number;
+  readonly cols: number;
+  readonly activeScreen: 'primary' | 'alternate';
+  readonly modes: {
+    readonly bracketedPaste: boolean;
+    readonly decMouseX10: boolean;
+    readonly decMouseButtonEvent: boolean;
+    readonly decMouseAnyEvent: boolean;
+    readonly decFocusTracking: boolean;
+    readonly decMouseSgrEncoding: boolean;
+  };
+  readonly cursor: {
+    readonly row: number;
+    readonly col: number;
+    readonly visible: boolean;
+    readonly style: {
+      readonly shape: 'block' | 'bar' | 'underline';
+      readonly blinking: boolean;
+    };
+  };
+  readonly viewport: {
+    readonly top: number;
+    readonly totalRows: number;
+    readonly followOutput: boolean;
+  };
+  readonly lines: string[];
+  readonly richLines: Array<{
+    readonly wrapped: boolean;
+    readonly text: string;
+    readonly cells: Array<{
+      readonly glyph: string;
+      readonly width: number;
+      readonly continued: boolean;
+      readonly style: {
+        readonly bold: boolean;
+        readonly dim: boolean;
+        readonly italic: boolean;
+        readonly underline: boolean;
+        readonly inverse: boolean;
+        readonly fg:
+          | { readonly kind: 'default' }
+          | { readonly kind: 'indexed'; readonly index: number }
+          | { readonly kind: 'rgb'; readonly r: number; readonly g: number; readonly b: number };
+        readonly bg:
+          | { readonly kind: 'default' }
+          | { readonly kind: 'indexed'; readonly index: number }
+          | { readonly kind: 'rgb'; readonly r: number; readonly g: number; readonly b: number };
+      };
+    }>;
+  }>;
+}
+
+function isWheelMouseCode(code: number): boolean {
+  return (code & 0b0100_0000) !== 0;
+}
+
+function hasAltModifier(code: number): boolean {
+  return (code & 0b0000_1000) !== 0;
+}
+
+function isMotionMouseCode(code: number): boolean {
+  return (code & 0b0010_0000) !== 0;
+}
+
+function isLeftButtonPress(code: number, final: 'M' | 'm'): boolean {
+  if (final !== 'M') {
+    return false;
+  }
+  if (isWheelMouseCode(code) || isMotionMouseCode(code)) {
+    return false;
+  }
+  return (code & 0b0000_0011) === 0;
+}
+
+function isMouseRelease(final: 'M' | 'm'): boolean {
+  return final === 'm';
+}
+
+function isSelectionDrag(code: number, final: 'M' | 'm'): boolean {
+  return final === 'M' && isMotionMouseCode(code);
+}
+
+export interface ConversationSelectionInputOptions {
+  readonly getSelection: () => PaneSelection | null;
+  readonly setSelection: (next: PaneSelection | null) => void;
+  readonly getSelectionDrag: () => PaneSelectionDrag | null;
+  readonly setSelectionDrag: (next: PaneSelectionDrag | null) => void;
+  readonly pinViewportForSelection: () => void;
+  readonly releaseViewportPinForSelection: () => void;
+  readonly markDirty: () => void;
+}
+
+export interface ReduceConversationMouseSelectionInput {
+  readonly selection: PaneSelection | null;
+  readonly selectionDrag: PaneSelectionDrag | null;
+  readonly point: SelectionPoint;
+  readonly isMainPaneTarget: boolean;
+  readonly isLeftButtonPress: boolean;
+  readonly isSelectionDrag: boolean;
+  readonly isMouseRelease: boolean;
+  readonly isWheelMouseCode: boolean;
+  readonly selectionTextForPane: (selection: PaneSelection) => string;
+}
+
+export interface ReduceConversationMouseSelectionResult {
+  readonly selection: PaneSelection | null;
+  readonly selectionDrag: PaneSelectionDrag | null;
+  readonly pinViewport: boolean;
+  readonly releaseViewportPin: boolean;
+  readonly markDirty: boolean;
+  readonly consumed: boolean;
+}
+
+export interface ConversationSelectionStrategies {
+  pointFromMouseEvent(
+    layout: SelectionLayout,
+    frame: ConversationSelectionSnapshotFrame,
+    event: { col: number; row: number },
+  ): SelectionPoint;
+  reduceConversationMouseSelection(
+    options: ReduceConversationMouseSelectionInput,
+  ): ReduceConversationMouseSelectionResult;
+  selectionText(frame: ConversationSelectionSnapshotFrame, selection: PaneSelection | null): string;
+}
+
+interface MouseSelectionInput {
+  readonly layout: SelectionLayout;
+  readonly frame: ConversationSelectionSnapshotFrame;
+  readonly isMainPaneTarget: boolean;
+  readonly resolveSelectionText?: (selection: PaneSelection) => string;
+  readonly event: {
+    readonly col: number;
+    readonly row: number;
+    readonly code: number;
+    readonly final: 'M' | 'm';
+  };
+}
+
+export class ConversationSelectionInput {
+  constructor(
+    private readonly options: ConversationSelectionInputOptions,
+    private readonly strategies: ConversationSelectionStrategies,
+  ) {}
+
+  clearSelectionOnTextToken(textLength: number): boolean {
+    const hasSelection =
+      this.options.getSelection() !== null || this.options.getSelectionDrag() !== null;
+    if (textLength <= 0 || !hasSelection) {
+      return false;
+    }
+    this.options.setSelection(null);
+    this.options.setSelectionDrag(null);
+    this.options.releaseViewportPinForSelection();
+    this.options.markDirty();
+    return true;
+  }
+
+  handleMouseSelection(input: MouseSelectionInput): boolean {
+    const reduced = this.strategies.reduceConversationMouseSelection({
+      selection: this.options.getSelection(),
+      selectionDrag: this.options.getSelectionDrag(),
+      point: this.strategies.pointFromMouseEvent(input.layout, input.frame, input.event),
+      isMainPaneTarget: input.isMainPaneTarget,
+      isLeftButtonPress:
+        isLeftButtonPress(input.event.code, input.event.final) && !hasAltModifier(input.event.code),
+      isSelectionDrag:
+        isSelectionDrag(input.event.code, input.event.final) && !hasAltModifier(input.event.code),
+      isMouseRelease: isMouseRelease(input.event.final),
+      isWheelMouseCode: isWheelMouseCode(input.event.code),
+      selectionTextForPane: (nextSelection) =>
+        input.resolveSelectionText === undefined
+          ? this.strategies.selectionText(input.frame, nextSelection)
+          : input.resolveSelectionText(nextSelection),
+    });
+    this.options.setSelection(reduced.selection);
+    this.options.setSelectionDrag(reduced.selectionDrag);
+    if (reduced.pinViewport) {
+      this.options.pinViewportForSelection();
+    }
+    if (reduced.releaseViewportPin) {
+      this.options.releaseViewportPinForSelection();
+    }
+    if (reduced.markDirty) {
+      this.options.markDirty();
+    }
+    return reduced.consumed;
+  }
+}

package/packages/harness-ui/src/interaction/global-shortcut-input.ts

@@ -0,0 +1,172 @@
+type ShortcutCycleDirection = 'next' | 'previous';
+type MainPaneMode = 'conversation' | 'project' | 'home' | 'nim';
+
+function parseNumericPrefix(value: string): number | null {
+  const parsed = Number.parseInt(value, 10);
+  return Number.isNaN(parsed) ? null : parsed;
+}
+
+function isCtrlOnlyShortcutInput(input: Buffer): boolean {
+  if (input.length === 1) {
+    const byte = input[0]!;
+    return (
+      (byte >= 0x01 && byte <= 0x1a) ||
+      byte === 0x1c ||
+      byte === 0x1d ||
+      byte === 0x1e ||
+      byte === 0x1f
+    );
+  }
+
+  const text = input.toString('utf8');
+  if (text.startsWith('\u001b[') && text.endsWith('u')) {
+    const kittyMatch = text.slice(2, -1).match(/^(\d+)(?::\d+)?(?:;(\d+)(?::\d+)?)?$/u);
+    if (kittyMatch !== null) {
+      const modifierCode = parseNumericPrefix(kittyMatch[2] ?? '1');
+      return modifierCode === 5;
+    }
+  }
+
+  if (text.startsWith('\u001b[27;') && text.endsWith('~')) {
+    const modifyOtherKeysMatch = text.slice(2, -1).match(/^27;(\d+);(\d+)$/u);
+    if (modifyOtherKeysMatch !== null) {
+      const modifierCode = parseNumericPrefix(modifyOtherKeysMatch[1]!);
+      return modifierCode === 5;
+    }
+  }
+
+  return false;
+}
+
+function isTerminalAgentType(agentType: string | null): boolean {
+  return agentType !== null && agentType.trim().toLowerCase() === 'terminal';
+}
+
+function shouldBypassCtrlOnlyShortcutInTerminalConversation(shortcut: string | null): boolean {
+  if (
+    shortcut === 'mux.conversation.archive' ||
+    shortcut === 'mux.conversation.delete' ||
+    shortcut === 'mux.conversation.next' ||
+    shortcut === 'mux.conversation.previous'
+  ) {
+    return false;
+  }
+  return true;
+}
+
+export interface GlobalShortcutState {
+  readonly mainPaneMode: () => MainPaneMode;
+  readonly activeConversationId: () => string | null;
+  readonly activeConversationAgentType?: () => string | null;
+  readonly resolveConversationForAction?: () => string | null;
+  readonly conversationsHas: (sessionId: string) => boolean;
+  readonly activeDirectoryId: () => string | null;
+  readonly directoryExists: (directoryId: string) => boolean;
+}
+
+export interface GlobalShortcutActions {
+  readonly requestStop: () => void;
+  readonly resolveDirectoryForAction: () => string | null;
+  readonly openNewThreadPrompt: (directoryId: string) => void;
+  readonly toggleCommandMenu: () => void;
+  readonly openOrCreateCritiqueConversationInDirectory: (directoryId: string) => Promise<void>;
+  readonly toggleGatewayProfile: () => Promise<void>;
+  readonly toggleGatewayStatusTimeline: () => Promise<void>;
+  readonly toggleGatewayRenderTrace: (conversationId: string | null) => Promise<void>;
+  readonly queueControlPlaneOp: (task: () => Promise<void>, label: string) => void;
+  readonly archiveConversation: (sessionId: string) => Promise<void>;
+  readonly refreshAllConversationTitles: () => Promise<void>;
+  readonly interruptConversation: (sessionId: string) => Promise<void>;
+  readonly takeoverConversation: (sessionId: string) => Promise<void>;
+  readonly openAddDirectoryPrompt: () => void;
+  readonly closeDirectory: (directoryId: string) => Promise<void>;
+  readonly cycleLeftNavSelection: (direction: ShortcutCycleDirection) => void;
+}
+
+export interface GlobalShortcutHandlerInput {
+  readonly shortcut: string | null;
+  readonly requestStop: () => void;
+  readonly resolveDirectoryForAction: () => string | null;
+  readonly openNewThreadPrompt: (directoryId: string) => void;
+  readonly toggleCommandMenu: () => void;
+  readonly openOrCreateCritiqueConversationInDirectory: (directoryId: string) => Promise<void>;
+  readonly toggleGatewayProfile: () => Promise<void>;
+  readonly toggleGatewayStatusTimeline: () => Promise<void>;
+  readonly toggleGatewayRenderTrace: (conversationId: string | null) => Promise<void>;
+  readonly resolveConversationForAction: () => string | null;
+  readonly conversationsHas: (sessionId: string) => boolean;
+  readonly queueControlPlaneOp: (task: () => Promise<void>, label: string) => void;
+  readonly archiveConversation: (sessionId: string) => Promise<void>;
+  readonly refreshAllConversationTitles: () => Promise<void>;
+  readonly interruptConversation: (sessionId: string) => Promise<void>;
+  readonly takeoverConversation: (sessionId: string) => Promise<void>;
+  readonly openAddDirectoryPrompt: () => void;
+  readonly resolveClosableDirectoryId: () => string | null;
+  readonly closeDirectory: (directoryId: string) => Promise<void>;
+  readonly cycleLeftNavSelection: (direction: ShortcutCycleDirection) => void;
+}
+
+export interface GlobalShortcutStrategies<TShortcutBindings> {
+  detectShortcut(input: Buffer, bindings: TShortcutBindings): string | null;
+  handleShortcut(input: GlobalShortcutHandlerInput): boolean;
+}
+
+export class GlobalShortcutInput<TShortcutBindings> {
+  constructor(
+    private readonly shortcutBindings: TShortcutBindings,
+    private readonly state: GlobalShortcutState,
+    private readonly actions: GlobalShortcutActions,
+    private readonly strategies: GlobalShortcutStrategies<TShortcutBindings>,
+  ) {}
+
+  handleInput(input: Buffer): boolean {
+    const shortcut = this.strategies.detectShortcut(input, this.shortcutBindings);
+    if (
+      shortcut !== null &&
+      shouldBypassCtrlOnlyShortcutInTerminalConversation(shortcut) &&
+      this.state.mainPaneMode() === 'conversation' &&
+      isTerminalAgentType(
+        this.state.activeConversationAgentType === undefined
+          ? null
+          : this.state.activeConversationAgentType(),
+      ) &&
+      isCtrlOnlyShortcutInput(input)
+    ) {
+      return false;
+    }
+    return this.strategies.handleShortcut({
+      shortcut,
+      requestStop: this.actions.requestStop,
+      resolveDirectoryForAction: this.actions.resolveDirectoryForAction,
+      openNewThreadPrompt: this.actions.openNewThreadPrompt,
+      toggleCommandMenu: this.actions.toggleCommandMenu,
+      openOrCreateCritiqueConversationInDirectory:
+        this.actions.openOrCreateCritiqueConversationInDirectory,
+      toggleGatewayProfile: this.actions.toggleGatewayProfile,
+      toggleGatewayStatusTimeline: this.actions.toggleGatewayStatusTimeline,
+      toggleGatewayRenderTrace: this.actions.toggleGatewayRenderTrace,
+      resolveConversationForAction: () =>
+        this.state.resolveConversationForAction !== undefined
+          ? this.state.resolveConversationForAction()
+          : this.state.mainPaneMode() === 'conversation'
+            ? this.state.activeConversationId()
+            : null,
+      conversationsHas: this.state.conversationsHas,
+      queueControlPlaneOp: this.actions.queueControlPlaneOp,
+      archiveConversation: this.actions.archiveConversation,
+      refreshAllConversationTitles: this.actions.refreshAllConversationTitles,
+      interruptConversation: this.actions.interruptConversation,
+      takeoverConversation: this.actions.takeoverConversation,
+      openAddDirectoryPrompt: this.actions.openAddDirectoryPrompt,
+      resolveClosableDirectoryId: () => {
+        const activeDirectoryId = this.state.activeDirectoryId();
+        if (this.state.mainPaneMode() !== 'project' || activeDirectoryId === null) {
+          return null;
+        }
+        return this.state.directoryExists(activeDirectoryId) ? activeDirectoryId : null;
+      },
+      closeDirectory: this.actions.closeDirectory,
+      cycleLeftNavSelection: this.actions.cycleLeftNavSelection,
+    });
+  }
+}

package/{src/ui → packages/harness-ui/src/interaction}/input-preflight.ts

@@ -1,6 +1,4 @@
-import { extractFocusEvents as extractFocusEventsFrame } from '../mux/live-mux/startup-utils.ts';
-
-interface InputPreflightOptions {
+export interface InputPreflightOptions {
   readonly isShuttingDown: () => boolean;
   readonly routeModalInput: (input: Buffer) => boolean;
   readonly handleEscapeInput: (input: Buffer) => void;
@@ -12,19 +10,19 @@ interface InputPreflightOptions {
   readonly handleCopyShortcutInput: (input: Buffer) => boolean;
 }
 
-interface InputPreflightDependencies {
-  readonly extractFocusEvents?: typeof extractFocusEventsFrame;
+export interface InputPreflightStrategies {
+  extractFocusEvents(input: Buffer): {
+    readonly sanitized: Buffer;
+    readonly focusInCount: number;
+    readonly focusOutCount: number;
+  };
 }
 
 export class InputPreflight {
-  private readonly extractFocusEvents: typeof extractFocusEventsFrame;
-
   constructor(
     private readonly options: InputPreflightOptions,
-    dependencies: InputPreflightDependencies = {},
-  ) {
-    this.extractFocusEvents = dependencies.extractFocusEvents ?? extractFocusEventsFrame;
-  }
+    private readonly strategies: InputPreflightStrategies,
+  ) {}
 
   nextInput(input: Buffer): Buffer | null {
     if (this.options.isShuttingDown()) {
@@ -39,7 +37,7 @@ export class InputPreflight {
       return null;
     }
 
-    const focusExtraction = this.extractFocusEvents(input);
+    const focusExtraction = this.strategies.extractFocusEvents(input);
     if (focusExtraction.focusInCount > 0) {
       this.options.onFocusIn();
     }