@jmoyers/harness 0.1.11 → 0.1.20

package/src/terminal/snapshot-oracle.ts

@@ -1,5 +1,9 @@
 import { createHash } from 'node:crypto';
 import { StringDecoder } from 'node:string_decoder';
+import {
+  measureDisplayWidth as measureHarnessUiDisplayWidth,
+  wrapTextForColumns as wrapHarnessUiTextForColumns,
+} from '../../packages/harness-ui/src/text-layout.ts';
 
 type ParserMode =
   | 'normal'
@@ -119,11 +123,32 @@ interface InternalLine {
   snapshotCacheWrapped: boolean;
 }
 
-const DEFAULT_COLOR: TerminalColor = { kind: 'default' };
+const DEFAULT_COLOR: TerminalColor = Object.freeze({ kind: 'default' } as const);
 const DEFAULT_CURSOR_STYLE: TerminalCursorStyle = {
   shape: 'block',
   blinking: true,
 };
+const DEFAULT_CELL_STYLE: Readonly<TerminalCellStyle> = Object.freeze({
+  bold: false,
+  dim: false,
+  italic: false,
+  underline: false,
+  inverse: false,
+  fg: DEFAULT_COLOR,
+  bg: DEFAULT_COLOR,
+});
+const DEFAULT_BLANK_CELL: Readonly<TerminalCell> = Object.freeze({
+  glyph: ' ',
+  width: 1,
+  continued: false,
+  style: DEFAULT_CELL_STYLE,
+});
+const DEFAULT_CONTINUATION_CELL: Readonly<TerminalCell> = Object.freeze({
+  glyph: '',
+  width: 0,
+  continued: true,
+  style: DEFAULT_CELL_STYLE,
+});
 
 function cloneCursorStyle(style: TerminalCursorStyle): TerminalCursorStyle {
   return {
@@ -155,18 +180,26 @@ function cloneColor(color: TerminalColor): TerminalColor {
 }
 
 function defaultCellStyle(): TerminalCellStyle {
-  return {
-    bold: false,
-    dim: false,
-    italic: false,
-    underline: false,
-    inverse: false,
-    fg: DEFAULT_COLOR,
-    bg: DEFAULT_COLOR,
-  };
+  return DEFAULT_CELL_STYLE as TerminalCellStyle;
+}
+
+function isDefaultStyle(style: TerminalCellStyle): boolean {
+  return (
+    style === DEFAULT_CELL_STYLE ||
+    (!style.bold &&
+      !style.dim &&
+      !style.italic &&
+      !style.underline &&
+      !style.inverse &&
+      style.fg.kind === 'default' &&
+      style.bg.kind === 'default')
+  );
 }
 
 function cloneStyle(style: TerminalCellStyle): TerminalCellStyle {
+  if (isDefaultStyle(style)) {
+    return DEFAULT_CELL_STYLE as TerminalCellStyle;
+  }
   return {
     bold: style.bold,
     dim: style.dim,
@@ -179,6 +212,7 @@ function cloneStyle(style: TerminalCellStyle): TerminalCellStyle {
 }
 
 function styleEqual(left: TerminalCellStyle, right: TerminalCellStyle): boolean {
+  if (left === right) return true;
   return (
     left.bold === right.bold &&
     left.dim === right.dim &&
@@ -208,6 +242,9 @@ function colorEqual(left: TerminalColor, right: TerminalColor): boolean {
 }
 
 function blankCell(style: TerminalCellStyle): TerminalCell {
+  if (isDefaultStyle(style)) {
+    return DEFAULT_BLANK_CELL as TerminalCell;
+  }
   return {
     glyph: ' ',
     width: 1,
@@ -217,6 +254,9 @@ function blankCell(style: TerminalCellStyle): TerminalCell {
 }
 
 function continuationCell(style: TerminalCellStyle): TerminalCell {
+  if (isDefaultStyle(style)) {
+    return DEFAULT_CONTINUATION_CELL as TerminalCell;
+  }
   return {
     glyph: '',
     width: 0,
@@ -441,7 +481,16 @@ class ScreenBuffer {
     if (targetCell === undefined || targetCell.continued) {
       return;
     }
-    targetCell.glyph += combiningChar;
+    if (Object.isFrozen(targetCell)) {
+      line.cells[targetCol] = {
+        glyph: targetCell.glyph + combiningChar,
+        width: targetCell.width,
+        continued: targetCell.continued,
+        style: targetCell.style,
+      };
+    } else {
+      targetCell.glyph += combiningChar;
+    }
     this.touchLine(line);
   }
 
@@ -891,76 +940,12 @@ function parseOscRgbColor(value: string): { r: number; g: number; b: number } |
   return null;
 }
 
-function isWideCodePoint(codePoint: number): boolean {
-  const ranges: ReadonlyArray<readonly [number, number]> = [
-    [0x1100, 0x115f],
-    [0x2329, 0x232a],
-    [0x2e80, 0xa4cf],
-    [0xac00, 0xd7a3],
-    [0xf900, 0xfaff],
-    [0xfe10, 0xfe19],
-    [0xfe30, 0xfe6f],
-    [0xff00, 0xff60],
-    [0xffe0, 0xffe6],
-    [0x1f300, 0x1faff],
-  ];
-
-  for (const [start, end] of ranges) {
-    if (codePoint >= start && codePoint <= end) {
-      return true;
-    }
-  }
-  return false;
-}
-
 export function measureDisplayWidth(text: string): number {
-  let width = 0;
-  for (const char of text) {
-    const codePoint = char.codePointAt(0)!;
-
-    if (codePoint < 0x20 || (codePoint >= 0x7f && codePoint < 0xa0)) {
-      continue;
-    }
-
-    if (/\p{Mark}/u.test(char)) {
-      continue;
-    }
-
-    width += isWideCodePoint(codePoint) ? 2 : 1;
-  }
-  return width;
+  return measureHarnessUiDisplayWidth(text);
 }
 
 export function wrapTextForColumns(text: string, cols: number): string[] {
-  if (cols <= 0) {
-    return [''];
-  }
-
-  const lines: string[] = [];
-  let current = '';
-  let currentWidth = 0;
-
-  for (const char of text) {
-    if (char === '\n') {
-      lines.push(current);
-      current = '';
-      currentWidth = 0;
-      continue;
-    }
-
-    const charWidth = Math.max(1, measureDisplayWidth(char));
-    if (currentWidth + charWidth > cols) {
-      lines.push(current);
-      current = '';
-      currentWidth = 0;
-    }
-
-    current += char;
-    currentWidth += charWidth;
-  }
-
-  lines.push(current);
-  return lines;
+  return [...wrapHarnessUiTextForColumns(text, cols)];
 }
 
 function resolveIndexedColor(
@@ -982,19 +967,121 @@ function resolveIndexedColor(
   };
 }
 
+function mutableCloneStyle(style: TerminalCellStyle): TerminalCellStyle {
+  return {
+    bold: style.bold,
+    dim: style.dim,
+    italic: style.italic,
+    underline: style.underline,
+    inverse: style.inverse,
+    fg: cloneColor(style.fg),
+    bg: cloneColor(style.bg),
+  };
+}
+
+function parseCsiParamToken(rawParams: string, start: number, end: number): number {
+  if (start >= end) {
+    return Number.NaN;
+  }
+  let value = 0;
+  for (let index = start; index < end; index += 1) {
+    const code = rawParams.charCodeAt(index);
+    if (code < 0x30 || code > 0x39) {
+      return Number(rawParams.slice(start, end));
+    }
+    value = value * 10 + (code - 0x30);
+  }
+  return value;
+}
+
+function parseCsiParams(rawParams: string, startIndex = 0): number[] {
+  if (startIndex >= rawParams.length) {
+    return [];
+  }
+  const params: number[] = [];
+  let tokenStart = startIndex;
+  for (let index = startIndex; index <= rawParams.length; index += 1) {
+    if (index < rawParams.length && rawParams.charCodeAt(index) !== 0x3b) {
+      continue;
+    }
+    params.push(parseCsiParamToken(rawParams, tokenStart, index));
+    tokenStart = index + 1;
+  }
+  return params;
+}
+
+function isDigitsOnly(value: string): boolean {
+  for (let index = 0; index < value.length; index += 1) {
+    const code = value.charCodeAt(index);
+    if (code < 0x30 || code > 0x39) {
+      return false;
+    }
+  }
+  return true;
+}
+
+function isDigitsOrSemicolons(value: string): boolean {
+  for (let index = 0; index < value.length; index += 1) {
+    const code = value.charCodeAt(index);
+    if (code === 0x3b) {
+      continue;
+    }
+    if (code < 0x30 || code > 0x39) {
+      return false;
+    }
+  }
+  return true;
+}
+
+function shouldDispatchCsiHook(rawParams: string, finalByte: string): boolean {
+  if (finalByte === 'c') {
+    return rawParams === '' || rawParams === '0' || rawParams === '>' || rawParams === '>0';
+  }
+  if (finalByte === 'n') {
+    return isDigitsOnly(rawParams);
+  }
+  if (finalByte === 't') {
+    return rawParams === '14' || rawParams === '16' || rawParams === '18';
+  }
+  if (finalByte === 'p') {
+    return (
+      rawParams.length >= 2 &&
+      rawParams.charCodeAt(0) === 0x3f &&
+      rawParams.endsWith('$') &&
+      isDigitsOrSemicolons(rawParams.slice(1, -1))
+    );
+  }
+  if (finalByte === 'q') {
+    return rawParams === '>0';
+  }
+  if (finalByte === 'm') {
+    if (rawParams === '>4' || rawParams === '>4;?') {
+      return true;
+    }
+    return rawParams.startsWith('>4;') && isDigitsOnly(rawParams.slice(3));
+  }
+  if (finalByte === 'u') {
+    if (rawParams === '?') {
+      return true;
+    }
+    return rawParams.startsWith('>') && rawParams.length > 1 && isDigitsOnly(rawParams.slice(1));
+  }
+  return false;
+}
+
 function applySgrParams(
   style: TerminalCellStyle,
   params: number[],
   indexedPaletteOverrides: ReadonlyMap<number, { r: number; g: number; b: number }>,
 ): TerminalCellStyle {
-  let nextStyle = cloneStyle(style);
-  const queue = params.length === 0 ? [0] : [...params];
+  let nextStyle = mutableCloneStyle(style);
+  const queue = params.length === 0 ? [0] : params;
 
   for (let idx = 0; idx < queue.length; idx += 1) {
     const param = queue[idx]!;
 
     if (param === 0) {
-      nextStyle = defaultCellStyle();
+      nextStyle = mutableCloneStyle(DEFAULT_CELL_STYLE);
       continue;
     }
     if (param === 1) {
@@ -1150,8 +1237,19 @@ export class TerminalSnapshotOracle {
 
   ingest(chunk: string | Uint8Array): void {
     const text = typeof chunk === 'string' ? chunk : this.decoder.write(Buffer.from(chunk));
-    for (const char of text) {
-      this.processChar(char);
+    const len = text.length;
+    let i = 0;
+    while (i < len) {
+      const code = text.charCodeAt(i);
+      if (code < 0xd800 || code > 0xdfff) {
+        this.processChar(text[i]!);
+        i += 1;
+      } else if (code <= 0xdbff && i + 1 < len) {
+        this.processChar(text[i]! + text[i + 1]!);
+        i += 2;
+      } else {
+        i += 1;
+      }
     }
   }
 
@@ -1320,6 +1418,17 @@ export class TerminalSnapshotOracle {
       return;
     }
 
+    // ASCII printable: width is always 1, never a combining mark
+    if (codePoint >= 0x20 && codePoint < 0x7f) {
+      if (this.pendingWrap) {
+        this.currentScreen().lineFeed(this.cursor, this.style);
+        this.cursor.col = 0;
+        this.pendingWrap = false;
+      }
+      this.pendingWrap = this.currentScreen().putGlyph(this.cursor, char, 1, this.style);
+      return;
+    }
+
     if (this.pendingWrap) {
       this.currentScreen().lineFeed(this.cursor, this.style);
       this.cursor.col = 0;
@@ -1419,7 +1528,7 @@ export class TerminalSnapshotOracle {
       const rawParams = this.csiBuffer;
       this.mode = 'normal';
       this.csiBuffer = '';
-      this.emitCsiQuery(`${rawParams}${finalByte}`);
+      this.emitCsiQuery(rawParams, finalByte);
       this.applyCsi(rawParams, finalByte);
       return;
     }
@@ -1478,15 +1587,10 @@ export class TerminalSnapshotOracle {
   private applyCsi(rawParams: string, finalByte: string): void {
     const privateMode = rawParams.startsWith('?');
     const privateKeyboardMode = rawParams.startsWith('>');
-    const params = (privateMode ? rawParams.slice(1) : rawParams).split(';').map((part) => {
-      if (part.length === 0) {
-        return NaN;
-      }
-      return Number(part);
-    });
-    const first = Number.isFinite(params[0]) ? (params[0] as number) : 1;
+    const paramsStart = privateMode || privateKeyboardMode ? 1 : 0;
 
     if (privateMode) {
+      const params = parseCsiParams(rawParams, paramsStart);
       if (finalByte === 'h') {
         this.applyPrivateMode(params, true);
         return;
@@ -1510,9 +1614,11 @@ export class TerminalSnapshotOracle {
       return;
     }
 
+    const params = parseCsiParams(rawParams, paramsStart);
+    const first = Number.isFinite(params[0]) ? (params[0] as number) : 1;
+
     if (finalByte === 'm') {
-      const cleaned = params.filter((value) => Number.isFinite(value));
-      this.style = applySgrParams(this.style, cleaned, this.indexedPaletteOverrides);
+      this.style = applySgrParams(this.style, params, this.indexedPaletteOverrides);
       return;
     }
 
@@ -1626,8 +1732,15 @@ export class TerminalSnapshotOracle {
     }
   }
 
-  private emitCsiQuery(payload: string): void {
-    this.queryHooks?.onCsiQuery?.(payload, () => this.queryState());
+  private emitCsiQuery(rawParams: string, finalByte: string): void {
+    const onCsiQuery = this.queryHooks?.onCsiQuery;
+    if (onCsiQuery === undefined) {
+      return;
+    }
+    if (!shouldDispatchCsiHook(rawParams, finalByte)) {
+      return;
+    }
+    onCsiQuery(`${rawParams}${finalByte}`, () => this.queryState());
   }
 
   private emitOscQuery(useBellTerminator: boolean): void {

package/src/ui/mux-theme.ts

@@ -1,8 +1,8 @@
 import { readFileSync } from 'node:fs';
 import { resolve } from 'node:path';
 import type { HarnessMuxThemeConfig } from '../config/config-core.ts';
-import type { UiColor, UiStyle } from './surface.ts';
-import type { UiModalTheme } from './kit.ts';
+import type { UiModalTheme } from '../../packages/harness-ui/src/kit.ts';
+import type { UiColor, UiStyle } from '../../packages/harness-ui/src/surface.ts';
 import { BUILTIN_MUX_THEME_PRESETS } from './mux-theme-presets.ts';
 
 type OpenCodeThemeMode = 'dark' | 'light';
@@ -47,11 +47,28 @@ export interface MuxWorkspaceRailTheme {
   readonly statusColors: MuxWorkspaceRailStatusColors;
 }
 
+interface MuxConversationRailTheme {
+  readonly headerStyle: UiStyle;
+  readonly normalRowStyle: UiStyle;
+  readonly activeRowStyle: UiStyle;
+  readonly activeIndicatorStyle: UiStyle;
+  readonly normalTextStyle: UiStyle;
+  readonly activeTextStyle: UiStyle;
+  readonly deadTextStyle: UiStyle;
+  readonly statusBadgeStyles: {
+    readonly needsInput: UiStyle;
+    readonly running: UiStyle;
+    readonly completed: UiStyle;
+    readonly exited: UiStyle;
+  };
+}
+
 interface ActiveMuxTheme {
   readonly name: string;
   readonly mode: OpenCodeThemeMode;
   readonly modalTheme: UiModalTheme;
   readonly workspaceRail: MuxWorkspaceRailTheme;
+  readonly conversationRail: MuxConversationRailTheme;
   readonly terminalForegroundHex: string | null;
   readonly terminalBackgroundHex: string | null;
 }
@@ -170,6 +187,65 @@ const LEGACY_MUX_THEME: ActiveMuxTheme = {
       idle: { kind: 'indexed', index: 245 },
     },
   },
+  conversationRail: {
+    headerStyle: {
+      fg: { kind: 'indexed', index: 250 },
+      bg: { kind: 'indexed', index: 236 },
+      bold: false,
+    },
+    normalRowStyle: {
+      fg: { kind: 'default' },
+      bg: { kind: 'default' },
+      bold: false,
+    },
+    activeRowStyle: {
+      fg: { kind: 'indexed', index: 255 },
+      bg: { kind: 'indexed', index: 238 },
+      bold: false,
+    },
+    activeIndicatorStyle: {
+      fg: { kind: 'indexed', index: 231 },
+      bg: { kind: 'indexed', index: 238 },
+      bold: true,
+    },
+    normalTextStyle: {
+      fg: { kind: 'default' },
+      bg: { kind: 'default' },
+      bold: false,
+    },
+    activeTextStyle: {
+      fg: { kind: 'indexed', index: 255 },
+      bg: { kind: 'indexed', index: 238 },
+      bold: false,
+    },
+    deadTextStyle: {
+      fg: { kind: 'indexed', index: 245 },
+      bg: { kind: 'default' },
+      bold: false,
+    },
+    statusBadgeStyles: {
+      needsInput: {
+        fg: { kind: 'indexed', index: 231 },
+        bg: { kind: 'indexed', index: 166 },
+        bold: true,
+      },
+      running: {
+        fg: { kind: 'indexed', index: 231 },
+        bg: { kind: 'indexed', index: 24 },
+        bold: true,
+      },
+      completed: {
+        fg: { kind: 'indexed', index: 231 },
+        bg: { kind: 'indexed', index: 28 },
+        bold: true,
+      },
+      exited: {
+        fg: { kind: 'indexed', index: 250 },
+        bg: { kind: 'indexed', index: 239 },
+        bold: true,
+      },
+    },
+  },
   terminalForegroundHex: null,
   terminalBackgroundHex: null,
 };
@@ -290,6 +366,15 @@ function uiStyle(fgHex: string, bgHex: string | null, bold = false): UiStyle {
   };
 }
 
+function preferredForegroundHex(backgroundHex: string): string {
+  const normalized = normalizeHex(backgroundHex) ?? '#000000';
+  const red = Number.parseInt(normalized.slice(1, 3), 16);
+  const green = Number.parseInt(normalized.slice(3, 5), 16);
+  const blue = Number.parseInt(normalized.slice(5, 7), 16);
+  const luminance = 0.299 * red + 0.587 * green + 0.114 * blue;
+  return luminance > 150 ? '#111111' : '#f5f7fa';
+}
+
 function resolveThemeDocumentFromFile(
   path: string,
   readFile: (path: string) => string,
@@ -310,10 +395,12 @@ function resolveThemeDocumentFromFile(
 }
 
 function buildActiveTheme(name: string, input: OpenCodeThemeInput): ActiveMuxTheme {
+  const hasSelectedListItemText = input.document.theme['selectedListItemText'] !== undefined;
   const text = themeHex(input, 'text', FALLBACK_HEX.text);
   const textMuted = themeHex(input, 'textMuted', FALLBACK_HEX.textMuted);
   const conceal = themeHex(input, 'conceal', FALLBACK_HEX.conceal);
   const primary = themeHex(input, 'primary', FALLBACK_HEX.primary);
+  const accent = themeHex(input, 'accent', primary);
   const success = themeHex(input, 'success', FALLBACK_HEX.success);
   const error = themeHex(input, 'error', FALLBACK_HEX.error);
   const warning = themeHex(input, 'warning', FALLBACK_HEX.warning);
@@ -321,7 +408,9 @@ function buildActiveTheme(name: string, input: OpenCodeThemeInput): ActiveMuxThe
   const background = themeHex(input, 'background', FALLBACK_HEX.background);
   const backgroundPanel = themeHex(input, 'backgroundPanel', FALLBACK_HEX.backgroundPanel);
   const backgroundElement = themeHex(input, 'backgroundElement', FALLBACK_HEX.backgroundElement);
-  const syntaxFunction = themeHex(input, 'syntaxFunction', primary);
+  const selectedListItemText = themeHex(input, 'selectedListItemText', text);
+  const selectedForegroundFor = (backgroundHex: string): string =>
+    hasSelectedListItemText ? selectedListItemText : preferredForegroundHex(backgroundHex);
 
   return {
     name,
@@ -334,23 +423,38 @@ function buildActiveTheme(name: string, input: OpenCodeThemeInput): ActiveMuxThe
     },
     workspaceRail: {
       normalStyle: uiStyle(text, null, false),
-      headerStyle: uiStyle(primary, null, true),
+      headerStyle: uiStyle(text, null, true),
       activeRowStyle: uiStyle(text, backgroundElement, false),
       metaStyle: uiStyle(textMuted, null, false),
       conversationBodyStyle: uiStyle(textMuted, null, false),
-      processStyle: uiStyle(info, null, false),
-      repositoryRowStyle: uiStyle(syntaxFunction, null, false),
+      processStyle: uiStyle(textMuted, null, false),
+      repositoryRowStyle: uiStyle(text, null, false),
       mutedStyle: uiStyle(conceal, null, false),
       shortcutStyle: uiStyle(textMuted, null, false),
-      actionStyle: uiStyle(primary, backgroundElement, false),
+      actionStyle: uiStyle(accent, backgroundElement, false),
       statusColors: {
         working: hexToUiColor(success),
         exited: hexToUiColor(error),
         needsAction: hexToUiColor(warning),
-        starting: hexToUiColor(primary),
+        starting: hexToUiColor(info),
         idle: hexToUiColor(conceal),
       },
     },
+    conversationRail: {
+      headerStyle: uiStyle(textMuted, backgroundPanel, false),
+      normalRowStyle: uiStyle(text, null, false),
+      activeRowStyle: uiStyle(text, backgroundElement, false),
+      activeIndicatorStyle: uiStyle(accent, backgroundElement, true),
+      normalTextStyle: uiStyle(text, null, false),
+      activeTextStyle: uiStyle(text, backgroundElement, false),
+      deadTextStyle: uiStyle(conceal, null, false),
+      statusBadgeStyles: {
+        needsInput: uiStyle(selectedForegroundFor(warning), warning, true),
+        running: uiStyle(selectedForegroundFor(info), info, true),
+        completed: uiStyle(selectedForegroundFor(success), success, true),
+        exited: uiStyle(selectedForegroundFor(backgroundElement), backgroundElement, true),
+      },
+    },
     terminalForegroundHex: text.slice(1),
     terminalBackgroundHex: background.slice(1),
   };