@jmoyers/harness 0.1.11 → 0.1.20

package/src/mux/control-plane-op-queue.ts

@@ -1,11 +1,27 @@
 export type ControlPlaneOpPriority = 'interactive' | 'background';
 
+type ControlPlaneOpSupersedeMode = 'none' | 'pending' | 'pending-and-running';
+
+interface ControlPlaneOpTaskOptions {
+  readonly signal: AbortSignal;
+}
+
+type ControlPlaneOpTask = (options: ControlPlaneOpTaskOptions) => Promise<void>;
+
+interface ControlPlaneOpEnqueueOptions {
+  readonly key?: string;
+  readonly supersede?: ControlPlaneOpSupersedeMode;
+}
+
 interface QueuedControlPlaneOp {
   readonly id: number;
   readonly priority: ControlPlaneOpPriority;
   readonly label: string;
   readonly enqueuedAtMs: number;
-  readonly task: () => Promise<void>;
+  readonly key: string | null;
+  readonly supersede: ControlPlaneOpSupersedeMode;
+  readonly controller: AbortController;
+  readonly task: ControlPlaneOpTask;
 }
 
 interface ControlPlaneOpQueueMetrics {
@@ -45,6 +61,11 @@ interface ControlPlaneOpQueueOptions {
     metrics: ControlPlaneOpQueueMetrics,
     error: unknown,
   ) => void;
+  readonly onCanceled?: (
+    event: ControlPlaneOpQueueStartEvent,
+    metrics: ControlPlaneOpQueueMetrics,
+    reason: 'pre-start-abort' | 'running-abort',
+  ) => void;
   readonly onFatal?: (error: unknown) => void;
 }
 
@@ -59,6 +80,7 @@ export class ControlPlaneOpQueue {
   private readonly onStart: ControlPlaneOpQueueOptions['onStart'];
   private readonly onSuccess: ControlPlaneOpQueueOptions['onSuccess'];
   private readonly onError: ControlPlaneOpQueueOptions['onError'];
+  private readonly onCanceled: ControlPlaneOpQueueOptions['onCanceled'];
   private readonly onFatal: ControlPlaneOpQueueOptions['onFatal'];
 
   private readonly interactiveQueue: QueuedControlPlaneOp[] = [];
@@ -67,6 +89,7 @@ export class ControlPlaneOpQueue {
   private nextId = 1;
   private running = false;
   private pumpScheduled = false;
+  private runningOp: QueuedControlPlaneOp | null = null;
 
   constructor(options: ControlPlaneOpQueueOptions = {}) {
     this.nowMs = options.nowMs ?? Date.now;
@@ -75,15 +98,24 @@ export class ControlPlaneOpQueue {
     this.onStart = options.onStart;
     this.onSuccess = options.onSuccess;
     this.onError = options.onError;
+    this.onCanceled = options.onCanceled;
     this.onFatal = options.onFatal;
   }
 
-  enqueueInteractive(task: () => Promise<void>, label = 'interactive-op'): void {
-    this.enqueue(task, 'interactive', label);
+  enqueueInteractive(
+    task: ControlPlaneOpTask,
+    label = 'interactive-op',
+    options: ControlPlaneOpEnqueueOptions = {},
+  ): void {
+    this.enqueue(task, 'interactive', label, options);
   }
 
-  enqueueBackground(task: () => Promise<void>, label = 'background-op'): void {
-    this.enqueue(task, 'background', label);
+  enqueueBackground(
+    task: ControlPlaneOpTask,
+    label = 'background-op',
+    options: ControlPlaneOpEnqueueOptions = {},
+  ): void {
+    this.enqueue(task, 'background', label, options);
   }
 
   async waitForDrain(): Promise<void> {
@@ -104,15 +136,33 @@ export class ControlPlaneOpQueue {
   }
 
   private enqueue(
-    task: () => Promise<void>,
+    task: ControlPlaneOpTask,
     priority: ControlPlaneOpPriority,
     label: string,
+    options: ControlPlaneOpEnqueueOptions,
   ): void {
+    const key = options.key?.trim() ?? null;
+    const supersede = options.supersede ?? 'none';
+    if (key !== null && (supersede === 'pending' || supersede === 'pending-and-running')) {
+      this.abortPendingByKey(key);
+    }
+    if (
+      key !== null &&
+      supersede === 'pending-and-running' &&
+      this.runningOp !== null &&
+      this.runningOp.key === key
+    ) {
+      this.runningOp.controller.abort();
+    }
+
     const op: QueuedControlPlaneOp = {
       id: this.nextId,
       priority,
       label,
       enqueuedAtMs: this.nowMs(),
+      key,
+      supersede,
+      controller: new AbortController(),
       task,
     };
     this.nextId += 1;
@@ -135,6 +185,26 @@ export class ControlPlaneOpQueue {
     this.schedulePump();
   }
 
+  private abortPendingByKey(key: string): void {
+    const filterPending = (queue: QueuedControlPlaneOp[]): QueuedControlPlaneOp[] => {
+      const kept: QueuedControlPlaneOp[] = [];
+      for (const entry of queue) {
+        if (entry.key === key) {
+          entry.controller.abort();
+          continue;
+        }
+        kept.push(entry);
+      }
+      return kept;
+    };
+    const nextInteractive = filterPending(this.interactiveQueue);
+    const nextBackground = filterPending(this.backgroundQueue);
+    this.interactiveQueue.length = 0;
+    this.backgroundQueue.length = 0;
+    this.interactiveQueue.push(...nextInteractive);
+    this.backgroundQueue.push(...nextBackground);
+  }
+
   private metricsSnapshot(): ControlPlaneOpQueueMetrics {
     return {
       interactiveQueued: this.interactiveQueue.length,
@@ -197,13 +267,29 @@ export class ControlPlaneOpQueue {
 
     try {
       this.onStart?.(startEvent, this.metricsSnapshot());
+      if (next.controller.signal.aborted) {
+        this.onCanceled?.(startEvent, this.metricsSnapshot(), 'pre-start-abort');
+        return;
+      }
+      this.runningOp = next;
       try {
-        await next.task();
+        await next.task({
+          signal: next.controller.signal,
+        });
+        if (next.controller.signal.aborted) {
+          this.onCanceled?.(startEvent, this.metricsSnapshot(), 'running-abort');
+          return;
+        }
         this.onSuccess?.(startEvent, this.metricsSnapshot());
       } catch (error: unknown) {
+        if (next.controller.signal.aborted) {
+          this.onCanceled?.(startEvent, this.metricsSnapshot(), 'running-abort');
+          return;
+        }
         this.onError?.(startEvent, this.metricsSnapshot(), error);
       }
     } finally {
+      this.runningOp = null;
       this.running = false;
       this.resolveDrainIfIdle();
       this.schedulePump();

package/src/mux/conversation-rail.ts

@@ -4,14 +4,11 @@ import type {
   StreamSessionStatusModel,
 } from '../control-plane/stream-protocol.ts';
 import { padOrTrimDisplay } from './dual-pane-core.ts';
-import {
-  createUiSurface,
-  DEFAULT_UI_STYLE,
-  drawUiText,
-  fillUiRow,
-  renderUiSurfaceAnsiRows,
-} from '../ui/surface.ts';
-import { paintUiRow } from '../ui/kit.ts';
+import { UiKit } from '../../packages/harness-ui/src/kit.ts';
+import { DEFAULT_UI_STYLE, SurfaceBuffer } from '../../packages/harness-ui/src/surface.ts';
+import { getActiveMuxTheme } from '../ui/mux-theme.ts';
+
+const UI_KIT = new UiKit();
 
 export interface ConversationRailSessionSummary {
   readonly sessionId: string;
@@ -194,56 +191,6 @@ export function buildConversationRailLines(
   return rows.map((row) => padOrTrimDisplay(row.text, safeWidth));
 }
 
-const HEADER_ROW_STYLE = {
-  fg: { kind: 'indexed', index: 250 } as const,
-  bg: { kind: 'indexed', index: 236 } as const,
-  bold: false,
-};
-const NORMAL_ROW_STYLE = DEFAULT_UI_STYLE;
-const ACTIVE_ROW_STYLE = {
-  fg: { kind: 'indexed', index: 255 } as const,
-  bg: { kind: 'indexed', index: 238 } as const,
-  bold: false,
-};
-const ACTIVE_INDICATOR_STYLE = {
-  fg: { kind: 'indexed', index: 231 } as const,
-  bg: { kind: 'indexed', index: 238 } as const,
-  bold: true,
-};
-const BADGE_STYLES = {
-  'needs-input': {
-    fg: { kind: 'indexed', index: 231 } as const,
-    bg: { kind: 'indexed', index: 166 } as const,
-    bold: true,
-  },
-  running: {
-    fg: { kind: 'indexed', index: 231 } as const,
-    bg: { kind: 'indexed', index: 24 } as const,
-    bold: true,
-  },
-  completed: {
-    fg: { kind: 'indexed', index: 231 } as const,
-    bg: { kind: 'indexed', index: 28 } as const,
-    bold: true,
-  },
-  exited: {
-    fg: { kind: 'indexed', index: 250 } as const,
-    bg: { kind: 'indexed', index: 239 } as const,
-    bold: true,
-  },
-} as const;
-const ACTIVE_TEXT_STYLE = {
-  fg: { kind: 'indexed', index: 255 } as const,
-  bg: { kind: 'indexed', index: 238 } as const,
-  bold: false,
-};
-const NORMAL_TEXT_STYLE = DEFAULT_UI_STYLE;
-const MUTED_TEXT_STYLE = {
-  fg: { kind: 'indexed', index: 245 } as const,
-  bg: { kind: 'default' } as const,
-  bold: false,
-};
-
 function badgeLabel(status: StreamSessionRuntimeStatus): string {
   if (status === 'needs-input') {
     return 'NEED';
@@ -276,45 +223,55 @@ export function renderConversationRailAnsiRows(
 ): readonly string[] {
   const safeWidth = Math.max(1, width);
   const rows = buildConversationRailRows(sessions, activeSessionId, maxRows, order);
-  const surface = createUiSurface(safeWidth, rows.length, DEFAULT_UI_STYLE);
+  const surface = new SurfaceBuffer(safeWidth, rows.length, DEFAULT_UI_STYLE);
+  const theme = getActiveMuxTheme().conversationRail;
 
   for (let rowIndex = 0; rowIndex < rows.length; rowIndex += 1) {
     const row = rows[rowIndex]!;
     if (row.kind === 'header') {
-      paintUiRow(surface, rowIndex, row.text, HEADER_ROW_STYLE, HEADER_ROW_STYLE, 1);
+      UI_KIT.paintRow(surface, rowIndex, row.text, theme.headerStyle, theme.headerStyle, 1);
       continue;
     }
 
     if (row.kind === 'empty') {
-      paintUiRow(surface, rowIndex, '', NORMAL_ROW_STYLE, NORMAL_ROW_STYLE);
+      UI_KIT.paintRow(surface, rowIndex, '', theme.normalRowStyle, theme.normalRowStyle);
       continue;
     }
 
     const session = row.session!;
     const active = row.active === true;
-    fillUiRow(surface, rowIndex, active ? ACTIVE_ROW_STYLE : NORMAL_ROW_STYLE);
-    drawUiText(
-      surface,
+    surface.fillRow(rowIndex, active ? theme.activeRowStyle : theme.normalRowStyle);
+    surface.drawText(
       0,
       rowIndex,
       active ? '>' : ' ',
-      active ? ACTIVE_INDICATOR_STYLE : NORMAL_TEXT_STYLE,
+      active ? theme.activeIndicatorStyle : theme.normalTextStyle,
+    );
+    surface.drawText(
+      2,
+      rowIndex,
+      badgeLabel(session.status),
+      session.status === 'needs-input'
+        ? theme.statusBadgeStyles.needsInput
+        : session.status === 'running'
+          ? theme.statusBadgeStyles.running
+          : session.status === 'completed'
+            ? theme.statusBadgeStyles.completed
+            : theme.statusBadgeStyles.exited,
     );
-    drawUiText(surface, 2, rowIndex, badgeLabel(session.status), BADGE_STYLES[session.status]);
-    drawUiText(
-      surface,
+    surface.drawText(
       7,
       rowIndex,
       rowBodyText(session),
-      active ? ACTIVE_TEXT_STYLE : NORMAL_TEXT_STYLE,
+      active ? theme.activeTextStyle : theme.normalTextStyle,
     );
 
     if (!session.live && session.attentionReason === null) {
-      drawUiText(surface, 7, rowIndex, rowBodyText(session), MUTED_TEXT_STYLE);
+      surface.drawText(7, rowIndex, rowBodyText(session), theme.deadTextStyle);
     }
   }
 
-  return renderUiSurfaceAnsiRows(surface);
+  return surface.renderAnsiRows();
 }
 
 export function cycleConversationId(

package/src/mux/dual-pane-core.ts

@@ -1,4 +1,5 @@
 import { measureDisplayWidth, wrapTextForColumns } from '../terminal/snapshot-oracle.ts';
+import { computeDualPaneLayoutWithLayers } from '../../packages/harness-ui/src/layout.ts';
 
 const MIN_LEFT_PANE_COLS = 28;
 const MIN_RIGHT_PANE_COLS = 20;
@@ -92,22 +93,21 @@ export function computeDualPaneLayout(
 ): DualPaneLayout {
   const normalizedCols = Math.max(3, cols);
   const normalizedRows = Math.max(2, rows);
-  const paneRows = Math.max(1, normalizedRows - 1);
-  const statusRow = paneRows + 1;
-
-  const availablePaneCols = normalizedCols - 1;
   const leftCols = resolveLeftPaneCols(normalizedCols, options.leftCols ?? null);
-  const rightCols = availablePaneCols - leftCols;
+  const layout = computeDualPaneLayoutWithLayers(normalizedCols, normalizedRows, {
+    leftCols,
+    statusRows: 1,
+  });
 
   return {
-    cols: normalizedCols,
-    rows: normalizedRows,
-    paneRows,
-    statusRow,
-    leftCols,
-    rightCols,
-    separatorCol: leftCols + 1,
-    rightStartCol: leftCols + 2,
+    cols: layout.cols,
+    rows: layout.rows,
+    paneRows: layout.paneRows,
+    statusRow: layout.statusRow,
+    leftCols: layout.leftCols,
+    rightCols: layout.rightCols,
+    separatorCol: layout.separatorCol,
+    rightStartCol: layout.rightStartCol,
   };
 }