@jmoyers/harness 0.1.0

package/src/mux/live-mux/modal-task-editor-handler.ts

@@ -0,0 +1,156 @@
+import {
+  reduceTaskEditorPromptInput,
+  type TaskEditorPromptInputState,
+} from './modal-input-reducers.ts';
+
+interface TaskEditorPromptState extends TaskEditorPromptInputState {
+  mode: 'create' | 'edit';
+  taskId: string | null;
+  error: string | null;
+}
+
+interface TaskEditorSubmitPayload {
+  mode: 'create' | 'edit';
+  taskId: string | null;
+  repositoryId: string;
+  title: string;
+  description: string;
+  commandLabel: string;
+}
+
+interface HandleTaskEditorPromptInputResult {
+  handled: boolean;
+  nextPrompt?: TaskEditorPromptState | null;
+  markDirty: boolean;
+  submitPayload?: TaskEditorSubmitPayload;
+}
+
+interface HandleTaskEditorPromptInputOptions {
+  input: Buffer;
+  prompt: TaskEditorPromptState | null;
+  isQuitShortcut: (input: Buffer) => boolean;
+  dismissOnOutsideClick: (input: Buffer, dismiss: () => void) => boolean;
+}
+
+export function handleTaskEditorPromptInput(
+  options: HandleTaskEditorPromptInputOptions,
+): HandleTaskEditorPromptInputResult {
+  const { input, prompt, isQuitShortcut, dismissOnOutsideClick } = options;
+  if (prompt === null) {
+    return {
+      handled: false,
+      markDirty: false,
+    };
+  }
+  if (input.length === 1 && input[0] === 0x03) {
+    return {
+      handled: false,
+      markDirty: false,
+    };
+  }
+  if (isQuitShortcut(input)) {
+    return {
+      handled: true,
+      nextPrompt: null,
+      markDirty: true,
+    };
+  }
+
+  let dismissed = false;
+  if (
+    dismissOnOutsideClick(input, () => {
+      dismissed = true;
+    })
+  ) {
+    return {
+      handled: true,
+      ...(dismissed
+        ? {
+            nextPrompt: null,
+            markDirty: true,
+          }
+        : {
+            markDirty: false,
+          }),
+    };
+  }
+
+  const reduced = reduceTaskEditorPromptInput(prompt, input);
+  const nextTitle = reduced.title;
+  const nextDescription = reduced.description;
+  const nextFieldIndex = reduced.fieldIndex;
+  const nextRepositoryIndex = reduced.repositoryIndex;
+  const submit = reduced.submit;
+  const changed =
+    nextTitle !== prompt.title ||
+    nextDescription !== prompt.description ||
+    nextFieldIndex !== prompt.fieldIndex ||
+    nextRepositoryIndex !== prompt.repositoryIndex;
+
+  const changedPrompt = changed
+    ? {
+        ...prompt,
+        title: nextTitle,
+        description: nextDescription,
+        fieldIndex: nextFieldIndex,
+        repositoryIndex: nextRepositoryIndex,
+        error: null,
+      }
+    : prompt;
+
+  if (!submit) {
+    return {
+      handled: true,
+      ...(changed
+        ? {
+            nextPrompt: changedPrompt,
+            markDirty: true,
+          }
+        : {
+            markDirty: false,
+          }),
+    };
+  }
+
+  const repositoryId = prompt.repositoryIds[nextRepositoryIndex] ?? null;
+  const title = nextTitle.trim();
+  if (title.length === 0) {
+    return {
+      handled: true,
+      nextPrompt: {
+        ...changedPrompt,
+        error: 'title required',
+      },
+      markDirty: true,
+    };
+  }
+  if (repositoryId === null) {
+    return {
+      handled: true,
+      nextPrompt: {
+        ...changedPrompt,
+        error: 'repository required',
+      },
+      markDirty: true,
+    };
+  }
+  return {
+    handled: true,
+    ...(changed
+      ? {
+          nextPrompt: changedPrompt,
+          markDirty: true,
+        }
+      : {
+          markDirty: false,
+        }),
+    submitPayload: {
+      mode: prompt.mode,
+      taskId: prompt.taskId,
+      repositoryId,
+      title,
+      description: nextDescription,
+      commandLabel: prompt.mode === 'create' ? 'tasks-create' : 'tasks-edit',
+    },
+  };
+}

package/src/mux/live-mux/observed-stream.ts

@@ -0,0 +1,87 @@
+import { randomUUID } from 'node:crypto';
+import type { StreamCommand } from '../../control-plane/stream-protocol.ts';
+
+interface ControlPlaneCommandClient {
+  sendCommand(command: StreamCommand): Promise<Record<string, unknown>>;
+}
+
+interface StreamScope {
+  readonly tenantId: string;
+  readonly userId: string;
+  readonly workspaceId: string;
+}
+
+export async function readObservedStreamCursorBaseline(
+  streamClient: ControlPlaneCommandClient,
+  scope: StreamScope,
+): Promise<number | null> {
+  const subscribed = await streamClient.sendCommand({
+    type: 'stream.subscribe',
+    tenantId: scope.tenantId,
+    userId: scope.userId,
+    workspaceId: scope.workspaceId,
+    conversationId: `cursor-probe-${randomUUID()}`,
+  });
+  const subscriptionId = subscribed['subscriptionId'];
+  if (typeof subscriptionId !== 'string' || subscriptionId.length === 0) {
+    throw new Error('control-plane stream.subscribe returned malformed subscription id');
+  }
+  try {
+    const cursor = subscribed['cursor'];
+    if (typeof cursor !== 'number' || !Number.isInteger(cursor) || cursor < 0) {
+      return null;
+    }
+    return cursor;
+  } finally {
+    try {
+      await streamClient.sendCommand({
+        type: 'stream.unsubscribe',
+        subscriptionId,
+      });
+    } catch {
+      // Best-effort unsubscribe only.
+    }
+  }
+}
+
+export async function subscribeObservedStream(
+  streamClient: ControlPlaneCommandClient,
+  scope: StreamScope,
+  afterCursor: number | null,
+): Promise<string> {
+  const command: {
+    type: 'stream.subscribe';
+    tenantId: string;
+    userId: string;
+    workspaceId: string;
+    afterCursor?: number;
+  } = {
+    type: 'stream.subscribe',
+    tenantId: scope.tenantId,
+    userId: scope.userId,
+    workspaceId: scope.workspaceId,
+  };
+  if (afterCursor !== null) {
+    command.afterCursor = afterCursor;
+  }
+  const subscribed = await streamClient.sendCommand(command);
+  const subscriptionId = subscribed['subscriptionId'];
+  if (typeof subscriptionId !== 'string') {
+    throw new Error('control-plane stream.subscribe returned malformed subscription id');
+  }
+  return subscriptionId;
+}
+
+export async function unsubscribeObservedStream(
+  streamClient: ControlPlaneCommandClient,
+  subscriptionId: string,
+): Promise<void> {
+  try {
+    await streamClient.sendCommand({
+      type: 'stream.unsubscribe',
+      subscriptionId,
+    });
+  } catch {
+    // Best-effort unsubscribe only.
+  }
+}

package/src/mux/live-mux/palette-parsing.ts

@@ -0,0 +1,128 @@
+export function parseOscRgbHex(value: string): string | null {
+  if (!value.startsWith('rgb:')) {
+    return null;
+  }
+
+  const components = value.slice(4).split('/');
+  if (components.length !== 3) {
+    return null;
+  }
+
+  const bytes: string[] = [];
+  for (const component of components) {
+    const normalized = component.trim();
+    if (normalized.length < 1 || normalized.length > 4) {
+      return null;
+    }
+    if (!/^[0-9a-fA-F]+$/.test(normalized)) {
+      return null;
+    }
+
+    const raw = Number.parseInt(normalized, 16);
+    const max = (1 << (normalized.length * 4)) - 1;
+    const scaled = Math.round((raw * 255) / max);
+    bytes.push(scaled.toString(16).padStart(2, '0'));
+  }
+
+  return `${bytes[0]}${bytes[1]}${bytes[2]}`;
+}
+
+export function extractOscColorReplies(buffer: string): {
+  readonly remainder: string;
+  readonly foregroundHex?: string;
+  readonly backgroundHex?: string;
+  readonly indexedHexByCode: Record<number, string>;
+} {
+  let remainder = buffer;
+  let foregroundHex: string | undefined;
+  let backgroundHex: string | undefined;
+  const indexedHexByCode: Record<number, string> = {};
+
+  while (true) {
+    const start = remainder.indexOf('\u001b]');
+    if (start < 0) {
+      break;
+    }
+    if (start > 0) {
+      remainder = remainder.slice(start);
+    }
+
+    const bellTerminator = remainder.indexOf('\u0007', 2);
+    const stTerminator = remainder.indexOf('\u001b\\', 2);
+    let end = -1;
+    let terminatorLength = 0;
+
+    if (bellTerminator >= 0 && (stTerminator < 0 || bellTerminator < stTerminator)) {
+      end = bellTerminator;
+      terminatorLength = 1;
+    } else if (stTerminator >= 0) {
+      end = stTerminator;
+      terminatorLength = 2;
+    }
+
+    if (end < 0) {
+      break;
+    }
+
+    const payload = remainder.slice(2, end);
+    remainder = remainder.slice(end + terminatorLength);
+    const separator = payload.indexOf(';');
+    if (separator < 0) {
+      continue;
+    }
+
+    const code = payload.slice(0, separator);
+    if (code === '10') {
+      const hex = parseOscRgbHex(payload.slice(separator + 1));
+      if (hex !== null) {
+        foregroundHex = hex;
+      }
+      continue;
+    }
+
+    if (code === '11') {
+      const hex = parseOscRgbHex(payload.slice(separator + 1));
+      if (hex !== null) {
+        backgroundHex = hex;
+      }
+      continue;
+    }
+
+    if (code === '4') {
+      const value = payload.slice(separator + 1);
+      const paletteSeparator = value.indexOf(';');
+      if (paletteSeparator < 0) {
+        continue;
+      }
+      const paletteIndexRaw = value.slice(0, paletteSeparator).trim();
+      const paletteValueRaw = value.slice(paletteSeparator + 1);
+      const parsedIndex = Number.parseInt(paletteIndexRaw, 10);
+      if (!Number.isInteger(parsedIndex) || parsedIndex < 0 || parsedIndex > 255) {
+        continue;
+      }
+      const hex = parseOscRgbHex(paletteValueRaw);
+      if (hex !== null) {
+        indexedHexByCode[parsedIndex] = hex;
+      }
+    }
+  }
+
+  if (remainder.length > 512) {
+    remainder = remainder.slice(-512);
+  }
+
+  return {
+    remainder,
+    ...(foregroundHex !== undefined
+      ? {
+          foregroundHex,
+        }
+      : {}),
+    ...(backgroundHex !== undefined
+      ? {
+          backgroundHex,
+        }
+      : {}),
+    indexedHexByCode,
+  };
+}

package/src/mux/live-mux/pointer-routing.ts

@@ -0,0 +1,108 @@
+interface HandlePaneDividerDragInputOptions {
+  paneDividerDragActive: boolean;
+  isMouseRelease: boolean;
+  isWheelMouseCode: boolean;
+  mouseCol: number;
+  setPaneDividerDragActive: (active: boolean) => void;
+  applyPaneDividerAtCol: (col: number) => void;
+  markDirty: () => void;
+}
+
+export function handlePaneDividerDragInput(options: HandlePaneDividerDragInputOptions): boolean {
+  if (!options.paneDividerDragActive) {
+    return false;
+  }
+  if (options.isMouseRelease) {
+    options.setPaneDividerDragActive(false);
+    options.markDirty();
+    return true;
+  }
+  if (!options.isWheelMouseCode) {
+    options.applyPaneDividerAtCol(options.mouseCol);
+    return true;
+  }
+  return false;
+}
+
+interface HandleSeparatorPointerPressOptions {
+  target: string;
+  isLeftButtonPress: boolean;
+  hasAltModifier: boolean;
+  mouseCol: number;
+  setPaneDividerDragActive: (active: boolean) => void;
+  applyPaneDividerAtCol: (col: number) => void;
+}
+
+export function handleSeparatorPointerPress(options: HandleSeparatorPointerPressOptions): boolean {
+  if (options.target !== 'separator' || !options.isLeftButtonPress || options.hasAltModifier) {
+    return false;
+  }
+  options.setPaneDividerDragActive(true);
+  options.applyPaneDividerAtCol(options.mouseCol);
+  return true;
+}
+
+interface HandleMainPaneWheelInputOptions {
+  target: string;
+  wheelDelta: number | null;
+  mainPaneMode: 'conversation' | 'project' | 'home';
+  onProjectWheel: (delta: number) => void;
+  onHomeWheel: (delta: number) => void;
+  onConversationWheel: (delta: number) => void;
+  markDirty: () => void;
+}
+
+export function handleMainPaneWheelInput(options: HandleMainPaneWheelInputOptions): boolean {
+  if (options.wheelDelta === null || options.target !== 'right') {
+    return false;
+  }
+  if (options.mainPaneMode === 'project') {
+    options.onProjectWheel(options.wheelDelta);
+  } else if (options.mainPaneMode === 'home') {
+    options.onHomeWheel(options.wheelDelta);
+  } else {
+    options.onConversationWheel(options.wheelDelta);
+  }
+  options.markDirty();
+  return true;
+}
+
+interface HomePaneDragState {
+  readonly kind: 'task' | 'repository';
+  readonly itemId: string;
+  readonly startedRowIndex: number;
+  readonly latestRowIndex: number;
+  readonly hasDragged: boolean;
+}
+
+interface HandleHomePaneDragMoveOptions {
+  homePaneDragState: HomePaneDragState | null;
+  mainPaneMode: 'conversation' | 'project' | 'home';
+  target: string;
+  isSelectionDrag: boolean;
+  hasAltModifier: boolean;
+  rowIndex: number;
+  setHomePaneDragState: (next: HomePaneDragState) => void;
+  markDirty: () => void;
+}
+
+export function handleHomePaneDragMove(options: HandleHomePaneDragMoveOptions): boolean {
+  if (
+    options.homePaneDragState === null ||
+    options.mainPaneMode !== 'home' ||
+    options.target !== 'right' ||
+    !options.isSelectionDrag ||
+    options.hasAltModifier
+  ) {
+    return false;
+  }
+  options.setHomePaneDragState({
+    ...options.homePaneDragState,
+    latestRowIndex: options.rowIndex,
+    hasDragged:
+      options.homePaneDragState.hasDragged ||
+      options.rowIndex !== options.homePaneDragState.startedRowIndex,
+  });
+  options.markDirty();
+  return true;
+}

package/src/mux/live-mux/process-usage.ts

@@ -0,0 +1,53 @@
+interface RefreshProcessUsageSnapshotsOptions<TConversation, TSample> {
+  conversations: ReadonlyMap<string, TConversation>;
+  processUsageBySessionId: Map<string, TSample>;
+  readProcessUsageSample: (processId: number | null) => Promise<TSample>;
+  processIdForConversation: (conversation: TConversation) => number | null;
+  processUsageEqual: (left: TSample, right: TSample) => boolean;
+}
+
+interface RefreshProcessUsageSnapshotsResult {
+  readonly samples: number;
+  readonly changed: boolean;
+}
+
+export async function refreshProcessUsageSnapshots<TConversation, TSample>(
+  options: RefreshProcessUsageSnapshotsOptions<TConversation, TSample>,
+): Promise<RefreshProcessUsageSnapshotsResult> {
+  const {
+    conversations,
+    processUsageBySessionId,
+    readProcessUsageSample,
+    processIdForConversation,
+    processUsageEqual,
+  } = options;
+  const entries = await Promise.all(
+    [...conversations.entries()].map(async ([sessionId, conversation]) => ({
+      sessionId,
+      sample: await readProcessUsageSample(processIdForConversation(conversation)),
+    })),
+  );
+
+  let changed = false;
+  const observedSessionIds = new Set<string>();
+  for (const entry of entries) {
+    observedSessionIds.add(entry.sessionId);
+    const previous = processUsageBySessionId.get(entry.sessionId);
+    if (previous === undefined || !processUsageEqual(previous, entry.sample)) {
+      processUsageBySessionId.set(entry.sessionId, entry.sample);
+      changed = true;
+    }
+  }
+  for (const sessionId of processUsageBySessionId.keys()) {
+    if (observedSessionIds.has(sessionId)) {
+      continue;
+    }
+    processUsageBySessionId.delete(sessionId);
+    changed = true;
+  }
+
+  return {
+    samples: entries.length,
+    changed,
+  };
+}

package/src/mux/live-mux/project-pane-pointer.ts

@@ -0,0 +1,44 @@
+interface HandleProjectPaneActionClickOptions<TSnapshot extends { directoryId: string }> {
+  clickEligible: boolean;
+  snapshot: TSnapshot | null;
+  rightCols: number;
+  paneRows: number;
+  projectPaneScrollTop: number;
+  rowIndex: number;
+  projectPaneActionAtRow: (
+    snapshot: TSnapshot,
+    rightCols: number,
+    paneRows: number,
+    projectPaneScrollTop: number,
+    rowIndex: number,
+  ) => string | null;
+  openNewThreadPrompt: (directoryId: string) => void;
+  queueCloseDirectory: (directoryId: string) => void;
+  markDirty: () => void;
+}
+
+export function handleProjectPaneActionClick<TSnapshot extends { directoryId: string }>(
+  options: HandleProjectPaneActionClickOptions<TSnapshot>,
+): boolean {
+  if (!options.clickEligible || options.snapshot === null) {
+    return false;
+  }
+  const action = options.projectPaneActionAtRow(
+    options.snapshot,
+    options.rightCols,
+    options.paneRows,
+    options.projectPaneScrollTop,
+    options.rowIndex,
+  );
+  if (action === 'conversation.new') {
+    options.openNewThreadPrompt(options.snapshot.directoryId);
+    options.markDirty();
+    return true;
+  }
+  if (action === 'project.close') {
+    options.queueCloseDirectory(options.snapshot.directoryId);
+    options.markDirty();
+    return true;
+  }
+  return false;
+}