ompchamber 3.2.0 → 3.3.0

package/src/shared/lib/workspace/terminal/keys.test.ts

@@ -0,0 +1,189 @@
+/**
+ * @license
+ * SPDX-License-Identifier: Apache-2.0
+ */
+
+/**
+ * The bytes the terminal key bar sends.
+ *
+ * Every expectation here is copied from xterm's own `evaluateKeyboardEvent`
+ * (`@xterm/xterm/src/common/input/Keyboard.ts`), because the shell cannot tell a
+ * bar button from a physical key: a sequence that merely looks plausible works
+ * in bash and breaks in vim. Three of those rules are the ones this file exists
+ * to pin — a modifier is a CSI PARAMETER and not an ESC prefix, application
+ * cursor mode swaps in the SS3 spelling, and Ctrl on a literal key is a latch
+ * for typed text rather than a byte to fold.
+ */
+
+import { describe, expect, test } from 'bun:test';
+
+import {
+  NO_MODIFIERS,
+  TERMINAL_KEYS,
+  TERMINAL_SYMBOLS,
+  applyModifiers,
+  ctrlCharacter,
+  resolveKeySequence,
+  type TerminalModifiers,
+} from '@/shared/lib/workspace/terminal/keys';
+
+const CTRL: TerminalModifiers = { ctrl: true, alt: false };
+const ALT: TerminalModifiers = { ctrl: false, alt: true };
+
+describe('resolveKeySequence — cursor keys', () => {
+  test('unmodified arrows use CSI', () => {
+    expect(resolveKeySequence('up')).toBe('\x1b[A');
+    expect(resolveKeySequence('down')).toBe('\x1b[B');
+    expect(resolveKeySequence('right')).toBe('\x1b[C');
+    expect(resolveKeySequence('left')).toBe('\x1b[D');
+  });
+
+  test('application cursor mode swaps in the SS3 spelling', () => {
+    const options = { applicationCursorKeys: true };
+    expect(resolveKeySequence('up', options)).toBe('\x1bOA');
+    expect(resolveKeySequence('left', options)).toBe('\x1bOD');
+  });
+
+  test('Home and End always use the terminfo spelling, DECCKM or not', () => {
+    // `TERM=xterm-256color` declares khome/kend as SS3, so the CSI form is a
+    // sequence the shell does not bind: zsh rings the bell and ignores it.
+    expect(resolveKeySequence('home')).toBe('\x1bOH');
+    expect(resolveKeySequence('end')).toBe('\x1bOF');
+    expect(resolveKeySequence('home', { applicationCursorKeys: true })).toBe('\x1bOH');
+    expect(resolveKeySequence('end', { applicationCursorKeys: true })).toBe('\x1bOF');
+  });
+
+  test('a modifier beats application cursor mode, as xterm does', () => {
+    const options = { applicationCursorKeys: true, modifiers: CTRL };
+    expect(resolveKeySequence('up', options)).toBe('\x1b[1;5A');
+  });
+
+  test('a modifier is a CSI parameter, never an ESC prefix', () => {
+    expect(resolveKeySequence('up', { modifiers: CTRL })).toBe('\x1b[1;5A');
+    expect(resolveKeySequence('up', { modifiers: ALT })).toBe('\x1b[1;3A');
+    expect(resolveKeySequence('up', { modifiers: { ctrl: true, alt: true } })).toBe('\x1b[1;7A');
+  });
+});
+
+describe('resolveKeySequence — keys with a fixed spelling', () => {
+  test('an unmodified page/delete key drops its leading 1', () => {
+    expect(resolveKeySequence('delete')).toBe('\x1b[3~');
+    expect(resolveKeySequence('pageUp')).toBe('\x1b[5~');
+    expect(resolveKeySequence('pageDown')).toBe('\x1b[6~');
+  });
+
+  test('page keys carry their prefix once modified', () => {
+    expect(resolveKeySequence('pageUp', { modifiers: CTRL })).toBe('\x1b[5;5~');
+    expect(resolveKeySequence('delete', { modifiers: ALT })).toBe('\x1b[3;3~');
+  });
+
+  test('a page key has no SS3 form, so DECCKM does not touch it', () => {
+    expect(resolveKeySequence('pageUp', { applicationCursorKeys: true })).toBe('\x1b[5~');
+  });
+
+  test('escape, tab and shift-tab are literal', () => {
+    expect(resolveKeySequence('escape')).toBe('\x1b');
+    expect(resolveKeySequence('tab')).toBe('\t');
+    expect(resolveKeySequence('shiftTab')).toBe('\x1b[Z');
+  });
+});
+
+describe('resolveKeySequence — modifiers on a literal key', () => {
+  test('Ctrl does NOT fold a literal key into a control byte', () => {
+    // The `^C` button is the only Ctrl+C. A tapped `|` stays a pipe: folding it
+    // would send FS (0x1c), which is not a pipe and not a signal.
+    expect(resolveKeySequence('pipe', { modifiers: CTRL })).toBe('|');
+    expect(resolveKeySequence('underscore', { modifiers: CTRL })).toBe('_');
+  });
+
+  test('Alt on a literal key is the ESC prefix', () => {
+    expect(resolveKeySequence('pipe', { modifiers: ALT })).toBe('\x1b|');
+    expect(resolveKeySequence('escape', { modifiers: ALT })).toBe('\x1b\x1b');
+  });
+
+  test('the dedicated control keys are already the folded byte', () => {
+    expect(resolveKeySequence('interrupt')).toBe('\x03');
+    expect(resolveKeySequence('eof')).toBe('\x04');
+    expect(resolveKeySequence('clear')).toBe('\x0c');
+  });
+});
+
+describe('resolveKeySequence — defaults and coverage', () => {
+  test('no options means no modifier and no application mode', () => {
+    // `pageUp` is the plain CSI default; Home/End carry a terminfo spelling.
+    expect(resolveKeySequence('pageUp')).toBe('\x1b[5~');
+    expect(NO_MODIFIERS).toEqual({ ctrl: false, alt: false });
+  });
+
+  test('every control key resolves to bytes', () => {
+    for (const def of TERMINAL_KEYS) {
+      expect(resolveKeySequence(def.id).length, def.id).toBeGreaterThan(0);
+    }
+  });
+
+  test('every symbol resolves to its own literal', () => {
+    for (const def of TERMINAL_SYMBOLS) {
+      expect(resolveKeySequence(def.id), def.id).toBe(def.sequence);
+    }
+  });
+
+  test('the symbol layer covers the characters a phone buries', () => {
+    const labels = new Set(TERMINAL_SYMBOLS.map((def) => def.label));
+    for (const required of ['|', '~', '\\', '$', '*', '?', '&', '<', '>', '`', '{', '}', '[', ']', '"', "'"]) {
+      expect(labels.has(required), required).toBe(true);
+    }
+  });
+
+  test('a symbol under a latched Alt is an ESC prefix, like any literal', () => {
+    expect(resolveKeySequence('dollar', { modifiers: ALT })).toBe('\x1b$');
+  });
+
+  test('an unknown id sends nothing rather than a guess', () => {
+    expect(resolveKeySequence('nope' as never)).toBe('');
+  });
+});
+
+describe('ctrlCharacter', () => {
+  test('letters fold case-insensitively onto C0', () => {
+    expect(ctrlCharacter('c')).toBe('\x03');
+    expect(ctrlCharacter('C')).toBe('\x03');
+    expect(ctrlCharacter('a')).toBe('\x01');
+    expect(ctrlCharacter('z')).toBe('\x1a');
+  });
+
+  test('the symbol set matches the terminal, not the ASCII table', () => {
+    expect(ctrlCharacter('@')).toBe('\x00');
+    expect(ctrlCharacter(' ')).toBe('\x00');
+    expect(ctrlCharacter('[')).toBe('\x1b');
+    expect(ctrlCharacter('_')).toBe('\x1f');
+    expect(ctrlCharacter('?')).toBe('\x7f');
+    expect(ctrlCharacter('!')).toBeNull();
+    expect(ctrlCharacter('ab')).toBeNull();
+  });
+});
+
+describe('applyModifiers', () => {
+  test('a latched Ctrl folds a typed letter', () => {
+    expect(applyModifiers('c', CTRL)).toBe('\x03');
+    expect(applyModifiers('r', CTRL)).toBe('\x12');
+  });
+
+  test('a latched Alt prefixes ESC', () => {
+    expect(applyModifiers('b', ALT)).toBe('\x1bb');
+    expect(applyModifiers('f', { ctrl: true, alt: true })).toBe('\x1b\x06');
+  });
+
+  test('no modifier is the identity', () => {
+    expect(applyModifiers('c', NO_MODIFIERS)).toBe('c');
+  });
+
+  test('a paste is left intact — the latch does not corrupt it', () => {
+    const pasted = 'bun run build\n';
+    expect(applyModifiers(pasted, CTRL)).toBe(pasted);
+    expect(applyModifiers(pasted, ALT)).toBe(pasted);
+  });
+
+  test('a character with no control code passes through', () => {
+    expect(applyModifiers('!', CTRL)).toBe('!');
+  });
+});

package/src/shared/lib/workspace/terminal/keys.ts

@@ -0,0 +1,225 @@
+/**
+ * @license
+ * SPDX-License-Identifier: Apache-2.0
+ */
+
+/**
+ * The keys a touch keyboard cannot produce, and the bytes they send.
+ *
+ * A phone's soft keyboard has no Ctrl, no Alt, no arrows, no Esc and no `|`, so
+ * a shell on a phone is unusable without a strip of buttons that emit the raw
+ * bytes those keys would. Every sequence here is what xterm's own
+ * `evaluateKeyboardEvent` sends for the same physical key
+ * (`@xterm/xterm/src/common/input/Keyboard.ts`) — the shell on the far end
+ * cannot tell the two apart, so a bar key that invented its own encoding would
+ * work in bash and break in vim.
+ *
+ * Three rules come straight out of that file:
+ *  - A CSI key carries its modifiers as a PARAMETER (`ESC [ 1 ; 5 A` is
+ *    Ctrl+Up), never as an ESC prefix; only a literal key gets the prefix.
+ *  - Application cursor mode (DECCKM, which vim and less set) swaps the arrows
+ *    and Home/End to their SS3 spelling (`ESC O A`), and a modifier wins over
+ *    it — xterm ignores the mode once a modifier is held.
+ *  - Ctrl has no literal spelling: it folds a typed character into a control
+ *    character (Ctrl+C is `0x03`), so a literal button keeps its own byte.
+ *
+ * There is deliberately no Cmd key. macOS reports it as `metaKey` and xterm
+ * discards it — `if (ev.metaKey) break;` in the cursor-key branches — because
+ * Cmd is the browser's modifier, not the terminal's: in a terminal Cmd+C and
+ * Cmd+V mean copy and paste, which is why those are actions in `KeyBar.tsx`
+ * rather than bytes here.
+ */
+
+export type TerminalModifier = 'ctrl' | 'alt';
+
+export interface TerminalModifiers {
+  ctrl: boolean;
+  alt: boolean;
+}
+
+/** Frozen, so clearing a latch is an identity change and re-renders nothing. */
+export const NO_MODIFIERS: TerminalModifiers = Object.freeze({ ctrl: false, alt: false });
+
+/** A CSI key: `ESC [ <prefix> <final>`, or `ESC O <final>` under DECCKM. */
+interface CsiSpec {
+  /** Leading parameter, dropped from the unmodified form when it is `1`. */
+  prefix: string;
+  final: string;
+  /** SS3 spelling, used only while the shell has DECCKM set. */
+  application?: string;
+  /**
+   * Spelling `terminfo` declares for the UNMODIFIED key, when it differs from
+   * the CSI default. This is not cosmetic: a line editor binds the sequences its
+   * terminfo entry names, so a key whose entry disagrees with what we send is
+   * simply not recognised — zsh answers Home with a bell and does nothing.
+   */
+  terminfo?: string;
+}
+
+export interface TerminalKeyDef<Id extends string = string> {
+  id: Id;
+  /** Printed on the button — a glyph where one exists. */
+  label: string;
+  /** Spoken name: the button's `title` and `aria-label`. */
+  name: string;
+  /** Literal bytes, for keys with no CSI form. */
+  sequence?: string;
+  csi?: CsiSpec;
+}
+
+/** A key that is always a literal byte — a symbol, with no CSI form. */
+export interface TerminalLiteralKeyDef<Id extends string = string> extends TerminalKeyDef<Id> {
+  sequence: string;
+}
+
+/**
+ * Control and cursor keys — the row that is always in reach.
+ *
+ * Ordered by how often a terminal needs it, because the bar wraps: the head
+ * stays on the first row and the tail lands on the last.
+ */
+export const TERMINAL_KEYS: readonly TerminalKeyDef[] = [
+  { id: 'escape', label: 'Esc', name: 'Escape', sequence: '\x1b' },
+  { id: 'tab', label: 'Tab', name: 'Tab', sequence: '\t' },
+  { id: 'interrupt', label: '^C', name: 'Ctrl+C — interrupt', sequence: '\x03' },
+  { id: 'left', label: '←', name: 'Left arrow', csi: { prefix: '1', final: 'D', application: 'OD' } },
+  { id: 'up', label: '↑', name: 'Up arrow', csi: { prefix: '1', final: 'A', application: 'OA' } },
+  { id: 'down', label: '↓', name: 'Down arrow', csi: { prefix: '1', final: 'B', application: 'OB' } },
+  { id: 'right', label: '→', name: 'Right arrow', csi: { prefix: '1', final: 'C', application: 'OC' } },
+  // Home/End carry `terminfo` because xterm's CSI default is not what the
+  // shell's terminfo entry names. `TERM=xterm-256color` declares khome/kend as
+  // SS3 (`\EOH`/`\EOF`) — `infocmp xterm-256color` prints exactly that — while
+  // xterm.js sends `ESC[H`/`ESC[F` whenever DECCKM is off, which is the state a
+  // shell prompt is in. Verified against the chamber's own zsh: the CSI form
+  // makes ZLE ring the bell and leave the cursor where it was, the SS3 form
+  // moves it.
+  { id: 'home', label: 'Home', name: 'Home', csi: { prefix: '1', final: 'H', application: 'OH', terminfo: '\x1bOH' } },
+  { id: 'end', label: 'End', name: 'End', csi: { prefix: '1', final: 'F', application: 'OF', terminfo: '\x1bOF' } },
+  { id: 'pageUp', label: 'PgUp', name: 'Page up', csi: { prefix: '5', final: '~' } },
+  { id: 'pageDown', label: 'PgDn', name: 'Page down', csi: { prefix: '6', final: '~' } },
+  { id: 'delete', label: 'Del', name: 'Delete', csi: { prefix: '3', final: '~' } },
+  { id: 'shiftTab', label: '⇧Tab', name: 'Shift+Tab', sequence: '\x1b[Z' },
+  { id: 'eof', label: '^D', name: 'Ctrl+D — end of input', sequence: '\x04' },
+  { id: 'clear', label: '^L', name: 'Ctrl+L — clear screen', sequence: '\x0c' },
+];
+
+/**
+ * Symbols a phone buries behind its "123" / "#+=" layer, plus the ones no layer
+ * has at all (`~`, `|`, `\`, backtick). Reaching `$` on an iOS keyboard is a
+ * mode switch per character, which is what makes a shell on a phone unusable —
+ * each of these is one tap.
+ */
+export const TERMINAL_SYMBOLS: readonly TerminalLiteralKeyDef[] = [
+  { id: 'pipe', label: '|', name: 'Pipe', sequence: '|' },
+  { id: 'tilde', label: '~', name: 'Tilde', sequence: '~' },
+  { id: 'dollar', label: '$', name: 'Dollar', sequence: '$' },
+  { id: 'asterisk', label: '*', name: 'Asterisk', sequence: '*' },
+  { id: 'question', label: '?', name: 'Question mark', sequence: '?' },
+  { id: 'underscore', label: '_', name: 'Underscore', sequence: '_' },
+  { id: 'backslash', label: '\\', name: 'Backslash', sequence: '\\' },
+  { id: 'slash', label: '/', name: 'Slash', sequence: '/' },
+  { id: 'minus', label: '-', name: 'Minus', sequence: '-' },
+  { id: 'equals', label: '=', name: 'Equals', sequence: '=' },
+  { id: 'plus', label: '+', name: 'Plus', sequence: '+' },
+  { id: 'ampersand', label: '&', name: 'Ampersand', sequence: '&' },
+  { id: 'semicolon', label: ';', name: 'Semicolon', sequence: ';' },
+  { id: 'colon', label: ':', name: 'Colon', sequence: ':' },
+  { id: 'comma', label: ',', name: 'Comma', sequence: ',' },
+  { id: 'dot', label: '.', name: 'Period', sequence: '.' },
+  { id: 'at', label: '@', name: 'At sign', sequence: '@' },
+  { id: 'percent', label: '%', name: 'Percent', sequence: '%' },
+  { id: 'caret', label: '^', name: 'Caret', sequence: '^' },
+  { id: 'hash', label: '#', name: 'Hash', sequence: '#' },
+  { id: 'bang', label: '!', name: 'Exclamation mark', sequence: '!' },
+  { id: 'parenOpen', label: '(', name: 'Open parenthesis', sequence: '(' },
+  { id: 'parenClose', label: ')', name: 'Close parenthesis', sequence: ')' },
+  { id: 'bracketOpen', label: '[', name: 'Open bracket', sequence: '[' },
+  { id: 'bracketClose', label: ']', name: 'Close bracket', sequence: ']' },
+  { id: 'braceOpen', label: '{', name: 'Open brace', sequence: '{' },
+  { id: 'braceClose', label: '}', name: 'Close brace', sequence: '}' },
+  { id: 'lessThan', label: '<', name: 'Less than', sequence: '<' },
+  { id: 'greaterThan', label: '>', name: 'Greater than', sequence: '>' },
+  { id: 'quote', label: "'", name: 'Single quote', sequence: "'" },
+  { id: 'doubleQuote', label: '"', name: 'Double quote', sequence: '"' },
+  { id: 'backtick', label: '`', name: 'Backtick', sequence: '`' },
+];
+
+export type TerminalKeyId = (typeof TERMINAL_KEYS)[number]['id'] | (typeof TERMINAL_SYMBOLS)[number]['id'];
+
+/** Every key the bar can send, indexed for lookup. An unknown id resolves to nothing. */
+const KEY_BY_ID: Partial<Record<TerminalKeyId, TerminalKeyDef>> = {};
+for (const def of [...TERMINAL_KEYS, ...TERMINAL_SYMBOLS]) KEY_BY_ID[def.id as TerminalKeyId] = def;
+
+export interface ResolveKeyOptions {
+  /** The shell's DECCKM state — xterm reports it as `term.modes`. */
+  applicationCursorKeys?: boolean;
+  modifiers?: TerminalModifiers;
+}
+
+/** The bytes one bar button sends. */
+export function resolveKeySequence(id: TerminalKeyId, options: ResolveKeyOptions = {}): string {
+  const def = KEY_BY_ID[id];
+  if (!def) return '';
+  const modifiers = options.modifiers ?? NO_MODIFIERS;
+  if (def.csi) return encodeCsi(def.csi, modifiers, options.applicationCursorKeys ?? false);
+  // A literal key keeps its own byte: Ctrl is a latch for typed text and a CSI
+  // parameter for a cursor key, so a tapped `|` is a pipe, not FS.
+  const sequence = def.sequence ?? '';
+  return modifiers.alt ? `\x1b${sequence}` : sequence;
+}
+
+function encodeCsi(spec: CsiSpec, modifiers: TerminalModifiers, applicationCursorKeys: boolean): string {
+  const parameter = modifierParameter(modifiers);
+  if (parameter !== null) return `\x1b[${spec.prefix};${parameter}${spec.final}`;
+  // Unmodified: `terminfo` first, then DECCKM, then xterm's CSI default. A line
+  // editor binds the sequences its terminfo entry names, so the entry is the
+  // authority — the DECCKM check below it is only for the keys whose entry and
+  // xterm's default already agree (the arrows).
+  if (spec.terminfo) return spec.terminfo;
+  if (applicationCursorKeys && spec.application) return `\x1b${spec.application}`;
+  return `\x1b[${spec.prefix === '1' ? '' : spec.prefix}${spec.final}`;
+}
+
+/** xterm's modifier parameter: 1 + shift(1) + alt(2) + ctrl(4). No modifier, no parameter. */
+function modifierParameter(modifiers: TerminalModifiers): number | null {
+  const bits = (modifiers.alt ? 2 : 0) | (modifiers.ctrl ? 4 : 0);
+  return bits === 0 ? null : bits + 1;
+}
+
+/**
+ * Fold a latched modifier into text typed on the soft keyboard — the path a
+ * phone has no other way to reach. Ctrl+C typed as `c` must arrive as `0x03`,
+ * and Alt as the ESC prefix (the meta behaviour every terminal has).
+ *
+ * Only a single character folds: a paste arrives through the same event, and
+ * prefixing an ESC to a whole pasted line (or folding its first character into
+ * a control code) would corrupt it.
+ */
+export function applyModifiers(data: string, modifiers: TerminalModifiers): string {
+  if (data.length !== 1) return data;
+  let out = data;
+  if (modifiers.ctrl) out = ctrlCharacter(out) ?? out;
+  if (modifiers.alt) out = `\x1b${out}`;
+  return out;
+}
+
+const CTRL_SYMBOLS: Record<string, string> = {
+  '@': '\x00',
+  ' ': '\x00',
+  '\x7f': '\x08',
+  '[': '\x1b',
+  '\\': '\x1c',
+  ']': '\x1d',
+  '^': '\x1e',
+  '_': '\x1f',
+  '?': '\x7f',
+};
+
+/** The control character a letter or symbol folds into, or null when it has none. */
+export function ctrlCharacter(character: string): string | null {
+  if (character.length !== 1) return null;
+  const code = character.charCodeAt(0);
+  if (code >= 0x61 && code <= 0x7a) return String.fromCharCode(code - 0x60);
+  if (code >= 0x41 && code <= 0x5a) return String.fromCharCode(code - 0x40);
+  return CTRL_SYMBOLS[character] ?? null;
+}

package/src/shared/types/settings/state.ts

@@ -33,17 +33,18 @@ export interface SettingsCategoryItem {
 }
 
 export interface SettingsState {
-  binaryPath: string;
-  showUpdateNotifications: boolean;
-  agentControlTool: boolean;
-  ompChamberWebTool: boolean;
   /** Palette id from the theme catalog (`shared/lib/theme/catalog.ts`). Typed
    *  as the catalog's own id union, so a theme dropped from it breaks the build
    *  here rather than rendering unstyled at runtime. */
   theme: ThemeId;
-  fontSize: 'compact' | 'standard' | 'comfort';
+  /**
+   * Font family the code editors are set in (`EDITOR_FONT_FAMILIES` in
+   * `shared/lib/code/editor/typography.ts`). The value is a CSS family name the
+   * editor puts FIRST in its stack, so a face the device does not have falls
+   * through to the bundled Fira Code and then to the generic — a setting that
+   * cannot render a broken editor, only a different one.
+   */
   editorFont: string;
-  streamResponses: boolean;
   streamTransport: StreamTransport;
   /** Generate a session title from the first run. omp suppresses its
    *  own auto-titling under `--mode rpc-ui` (PI_NO_TITLE), so without this a
@@ -51,18 +52,8 @@ export interface SettingsState {
    *  once when the first user message settles, retried once at that run's end;
    *  a later run never re-titles it — and a user-set name is never overwritten. */
   autoSessionTitle: boolean;
-  expandedThinking: boolean;
-  detailedToolCalls: boolean;
-  notificationsEnabled: boolean;
-  buildFailureAlert: boolean;
   soundAlerts: boolean;
   chatCompletionSound: boolean;
-  defaultWorkspacePath: string;
-  tunnelEnabled: boolean;
-  tunnelSubdomain: string;
-  activeProvider: string;
-  autoApproveSafeCmds: boolean;
-  autoPatchErrors: boolean;
   followUpBehavior: 'queue' | 'steering';
   keybindingSend: 'Enter' | 'Shift + Enter' | 'Ctrl / Cmd + Enter';
   keybindingNewLine: 'Enter' | 'Shift + Enter' | 'Ctrl / Cmd + Enter';