@jmoyers/harness 0.1.0

package/src/mux/live-mux/startup-utils.ts

@@ -0,0 +1,187 @@
+import { appendFileSync, mkdirSync, truncateSync } from 'node:fs';
+import { dirname, resolve } from 'node:path';
+import { DISABLE_MUX_INPUT_MODES } from '../terminal-input-modes.ts';
+import { resolveWorkspacePath } from '../workspace-path.ts';
+
+const DEFAULT_STARTUP_TERMINAL_MIN_COLS = 40;
+const DEFAULT_STARTUP_TERMINAL_MIN_ROWS = 10;
+const DEFAULT_STARTUP_TERMINAL_PROBE_TIMEOUT_MS = 250;
+const DEFAULT_STARTUP_TERMINAL_PROBE_INTERVAL_MS = 10;
+
+interface FocusEventExtraction {
+  readonly sanitized: Buffer;
+  readonly focusInCount: number;
+  readonly focusOutCount: number;
+}
+
+interface StartupTerminalProbeOptions {
+  readonly terminalSizeReader?: () => { cols: number; rows: number };
+  readonly sleep?: (ms: number) => Promise<void>;
+  readonly now?: () => number;
+  readonly timeoutMs?: number;
+  readonly intervalMs?: number;
+}
+
+export function formatErrorMessage(error: unknown): string {
+  if (error instanceof Error) {
+    return error.stack ?? error.message;
+  }
+  return String(error);
+}
+
+export function restoreTerminalState(
+  newline: boolean,
+  restoreInputModes: (() => void) | null = null,
+  disableInputModes = DISABLE_MUX_INPUT_MODES,
+): void {
+  try {
+    if (restoreInputModes === null) {
+      process.stdout.write(disableInputModes);
+    } else {
+      restoreInputModes();
+    }
+    process.stdout.write(`\u001b[?25h\u001b[0m${newline ? '\n' : ''}`);
+  } catch {
+    // Best-effort restore only.
+  }
+
+  if (process.stdin.isTTY) {
+    try {
+      process.stdin.setRawMode(false);
+    } catch {
+      // Best-effort restore only.
+    }
+    try {
+      process.stdin.pause();
+    } catch {
+      // Best-effort restore only.
+    }
+  }
+}
+
+export function extractFocusEvents(chunk: Buffer): FocusEventExtraction {
+  const text = chunk.toString('utf8');
+  const focusInCount = text.split('\u001b[I').length - 1;
+  const focusOutCount = text.split('\u001b[O').length - 1;
+
+  if (focusInCount === 0 && focusOutCount === 0) {
+    return {
+      sanitized: chunk,
+      focusInCount: 0,
+      focusOutCount: 0,
+    };
+  }
+
+  const sanitizedText = text.replaceAll('\u001b[I', '').replaceAll('\u001b[O', '');
+  return {
+    sanitized: Buffer.from(sanitizedText, 'utf8'),
+    focusInCount,
+    focusOutCount,
+  };
+}
+
+export function prepareArtifactPath(path: string, overwriteOnStart: boolean): string {
+  const resolvedPath = resolve(path);
+  mkdirSync(dirname(resolvedPath), { recursive: true });
+  if (overwriteOnStart) {
+    try {
+      truncateSync(resolvedPath, 0);
+    } catch (error: unknown) {
+      const code = (error as { code?: unknown }).code;
+      if (code !== 'ENOENT') {
+        throw error;
+      }
+      appendFileSync(resolvedPath, '', 'utf8');
+    }
+  }
+  return resolvedPath;
+}
+
+export function sanitizeProcessEnv(env: NodeJS.ProcessEnv = process.env): Record<string, string> {
+  const sanitized: Record<string, string> = {};
+  for (const [key, value] of Object.entries(env)) {
+    if (typeof value === 'string') {
+      sanitized[key] = value;
+    }
+  }
+  return sanitized;
+}
+
+export function terminalSize(): { cols: number; rows: number } {
+  const cols = process.stdout.columns;
+  const rows = process.stdout.rows;
+  if (typeof cols === 'number' && cols > 0 && typeof rows === 'number' && rows > 0) {
+    return { cols, rows };
+  }
+  return { cols: 120, rows: 40 };
+}
+
+export function startupTerminalSizeLooksPlausible(size: { cols: number; rows: number }): boolean {
+  return (
+    size.cols >= DEFAULT_STARTUP_TERMINAL_MIN_COLS && size.rows >= DEFAULT_STARTUP_TERMINAL_MIN_ROWS
+  );
+}
+
+export async function readStartupTerminalSize(
+  options: StartupTerminalProbeOptions = {},
+): Promise<{ cols: number; rows: number }> {
+  const terminalSizeReader = options.terminalSizeReader ?? terminalSize;
+  const sleep =
+    options.sleep ??
+    (async (ms: number): Promise<void> => {
+      await new Promise((resolveTimer) => {
+        setTimeout(resolveTimer, ms);
+      });
+    });
+  const now = options.now ?? Date.now;
+  const timeoutMs = options.timeoutMs ?? DEFAULT_STARTUP_TERMINAL_PROBE_TIMEOUT_MS;
+  const intervalMs = options.intervalMs ?? DEFAULT_STARTUP_TERMINAL_PROBE_INTERVAL_MS;
+
+  let best = terminalSizeReader();
+  const startedAtMs = now();
+  while (!startupTerminalSizeLooksPlausible(best) && now() - startedAtMs < timeoutMs) {
+    await sleep(intervalMs);
+    const next = terminalSizeReader();
+    if (next.cols * next.rows > best.cols * best.rows) {
+      best = next;
+    }
+    if (startupTerminalSizeLooksPlausible(next)) {
+      return next;
+    }
+  }
+  return startupTerminalSizeLooksPlausible(best) ? best : { cols: 120, rows: 40 };
+}
+
+export function parsePositiveInt(value: string | undefined, fallback: number): number {
+  if (value === undefined) {
+    return fallback;
+  }
+  const parsed = Number.parseInt(value, 10);
+  if (!Number.isFinite(parsed) || parsed < 0) {
+    return fallback;
+  }
+  return parsed;
+}
+
+export function parseBooleanEnv(value: string | undefined, fallback: boolean): boolean {
+  if (value === undefined) {
+    return fallback;
+  }
+  const normalized = value.trim().toLowerCase();
+  if (normalized === '1' || normalized === 'true' || normalized === 'yes' || normalized === 'on') {
+    return true;
+  }
+  if (normalized === '0' || normalized === 'false' || normalized === 'no' || normalized === 'off') {
+    return false;
+  }
+  return fallback;
+}
+
+export function resolveWorkspacePathForMux(
+  invocationDirectory: string,
+  value: string,
+  home = process.env.HOME,
+): string {
+  const resolvedHome = typeof home === 'string' && home.length > 0 ? home : null;
+  return resolveWorkspacePath(invocationDirectory, value, resolvedHome);
+}

package/src/mux/live-mux/status-timeline-state.ts

@@ -0,0 +1,82 @@
+import { resolve } from 'node:path';
+
+const STATUS_TIMELINE_STATE_FILE_NAME = 'active-status-timeline.json';
+export const STATUS_TIMELINE_STATE_VERSION = 1;
+export const STATUS_TIMELINE_MODE = 'live-mux-status-timeline';
+export const DEFAULT_STATUS_TIMELINE_ROOT_PATH = '.harness/status-timelines';
+export const STATUS_TIMELINE_FILE_NAME = 'status-timeline.log';
+
+export interface ActiveStatusTimelineState {
+  version: typeof STATUS_TIMELINE_STATE_VERSION;
+  mode: typeof STATUS_TIMELINE_MODE;
+  outputPath: string;
+  sessionName: string | null;
+  startedAt: string;
+}
+
+export function resolveStatusTimelineStatePath(
+  invocationDirectory: string,
+  sessionName: string | null,
+): string {
+  if (sessionName === null) {
+    return resolve(invocationDirectory, '.harness', STATUS_TIMELINE_STATE_FILE_NAME);
+  }
+  return resolve(
+    invocationDirectory,
+    '.harness',
+    'sessions',
+    sessionName,
+    STATUS_TIMELINE_STATE_FILE_NAME,
+  );
+}
+
+export function resolveDefaultStatusTimelineOutputPath(
+  invocationDirectory: string,
+  sessionName: string | null,
+): string {
+  if (sessionName === null) {
+    return resolve(
+      invocationDirectory,
+      DEFAULT_STATUS_TIMELINE_ROOT_PATH,
+      STATUS_TIMELINE_FILE_NAME,
+    );
+  }
+  return resolve(
+    invocationDirectory,
+    DEFAULT_STATUS_TIMELINE_ROOT_PATH,
+    sessionName,
+    STATUS_TIMELINE_FILE_NAME,
+  );
+}
+
+export function parseActiveStatusTimelineState(raw: unknown): ActiveStatusTimelineState | null {
+  if (typeof raw !== 'object' || raw === null) {
+    return null;
+  }
+  const candidate = raw as Record<string, unknown>;
+  if (candidate['version'] !== STATUS_TIMELINE_STATE_VERSION) {
+    return null;
+  }
+  if (candidate['mode'] !== STATUS_TIMELINE_MODE) {
+    return null;
+  }
+  const outputPath = candidate['outputPath'];
+  const sessionName = candidate['sessionName'];
+  const startedAt = candidate['startedAt'];
+  if (typeof outputPath !== 'string' || outputPath.length === 0) {
+    return null;
+  }
+  if (sessionName !== null && typeof sessionName !== 'string') {
+    return null;
+  }
+  if (typeof startedAt !== 'string' || startedAt.length === 0) {
+    return null;
+  }
+  return {
+    version: STATUS_TIMELINE_STATE_VERSION,
+    mode: STATUS_TIMELINE_MODE,
+    outputPath,
+    sessionName,
+    startedAt,
+  };
+}

package/src/mux/live-mux/task-pane-shortcuts.ts

@@ -0,0 +1,206 @@
+import {
+  insertTaskComposerText,
+  taskComposerBackspace,
+  taskComposerDeleteForward,
+  taskComposerDeleteToLineEnd,
+  taskComposerDeleteToLineStart,
+  taskComposerDeleteWordLeft,
+  taskComposerMoveLeft,
+  taskComposerMoveLineEnd,
+  taskComposerMoveLineStart,
+  taskComposerMoveRight,
+  taskComposerMoveVertical,
+  taskComposerMoveWordLeft,
+  taskComposerMoveWordRight,
+  type TaskComposerBuffer,
+} from '../task-composer.ts';
+import { detectTaskScreenKeybindingAction } from '../task-screen-keybindings.ts';
+
+type TaskPaneActionShortcut =
+  | 'task.ready'
+  | 'task.draft'
+  | 'task.complete'
+  | 'task.reorder-up'
+  | 'task.reorder-down';
+
+interface TaskEditorTargetDraft {
+  kind: 'draft';
+}
+
+interface TaskEditorTargetTask {
+  kind: 'task';
+  taskId: string;
+}
+
+interface HandleTaskPaneShortcutInputOptions {
+  input: Buffer;
+  mainPaneMode: 'conversation' | 'project' | 'home';
+  taskScreenKeybindings: Parameters<typeof detectTaskScreenKeybindingAction>[1];
+  taskEditorTarget: TaskEditorTargetDraft | TaskEditorTargetTask;
+  homeEditorBuffer: () => TaskComposerBuffer;
+  updateHomeEditorBuffer: (next: TaskComposerBuffer) => void;
+  moveTaskEditorFocusUp: () => void;
+  focusDraftComposer: () => void;
+  submitDraftTaskFromComposer: () => void;
+  runTaskPaneAction: (action: TaskPaneActionShortcut) => void;
+  selectRepositoryByDirection: (direction: 1 | -1) => void;
+  getTaskRepositoryDropdownOpen: () => boolean;
+  setTaskRepositoryDropdownOpen: (open: boolean) => void;
+  markDirty: () => void;
+}
+
+export function handleTaskPaneShortcutInput(options: HandleTaskPaneShortcutInputOptions): boolean {
+  const {
+    input,
+    mainPaneMode,
+    taskScreenKeybindings,
+    taskEditorTarget,
+    homeEditorBuffer,
+    updateHomeEditorBuffer,
+    moveTaskEditorFocusUp,
+    focusDraftComposer,
+    submitDraftTaskFromComposer,
+    runTaskPaneAction,
+    selectRepositoryByDirection,
+    getTaskRepositoryDropdownOpen,
+    setTaskRepositoryDropdownOpen,
+    markDirty,
+  } = options;
+  if (mainPaneMode !== 'home') {
+    return false;
+  }
+  const action = detectTaskScreenKeybindingAction(input, taskScreenKeybindings);
+  if (action !== null) {
+    if (action === 'mux.home.repo.dropdown.toggle') {
+      setTaskRepositoryDropdownOpen(!getTaskRepositoryDropdownOpen());
+      markDirty();
+      return true;
+    }
+    if (action === 'mux.home.repo.next') {
+      setTaskRepositoryDropdownOpen(true);
+      selectRepositoryByDirection(1);
+      return true;
+    }
+    if (action === 'mux.home.repo.previous') {
+      setTaskRepositoryDropdownOpen(true);
+      selectRepositoryByDirection(-1);
+      return true;
+    }
+    if (action === 'mux.home.task.status.ready') {
+      runTaskPaneAction('task.ready');
+      return true;
+    }
+    if (action === 'mux.home.task.status.draft') {
+      runTaskPaneAction('task.draft');
+      return true;
+    }
+    if (action === 'mux.home.task.status.complete') {
+      runTaskPaneAction('task.complete');
+      return true;
+    }
+    if (action === 'mux.home.task.reorder.up') {
+      runTaskPaneAction('task.reorder-up');
+      return true;
+    }
+    if (action === 'mux.home.task.reorder.down') {
+      runTaskPaneAction('task.reorder-down');
+      return true;
+    }
+    if (action === 'mux.home.task.newline') {
+      updateHomeEditorBuffer(insertTaskComposerText(homeEditorBuffer(), '\n'));
+      return true;
+    }
+    if (action === 'mux.home.task.submit') {
+      if (taskEditorTarget.kind === 'draft') {
+        submitDraftTaskFromComposer();
+      } else {
+        focusDraftComposer();
+      }
+      return true;
+    }
+    if (action === 'mux.home.editor.cursor.left') {
+      updateHomeEditorBuffer(taskComposerMoveLeft(homeEditorBuffer()));
+      return true;
+    }
+    if (action === 'mux.home.editor.cursor.right') {
+      updateHomeEditorBuffer(taskComposerMoveRight(homeEditorBuffer()));
+      return true;
+    }
+    if (action === 'mux.home.editor.cursor.up') {
+      const vertical = taskComposerMoveVertical(homeEditorBuffer(), -1);
+      if (vertical.hitBoundary) {
+        moveTaskEditorFocusUp();
+      } else {
+        updateHomeEditorBuffer(vertical.next);
+      }
+      return true;
+    }
+    if (action === 'mux.home.editor.cursor.down') {
+      if (taskEditorTarget.kind === 'task') {
+        const vertical = taskComposerMoveVertical(homeEditorBuffer(), 1);
+        if (vertical.hitBoundary) {
+          focusDraftComposer();
+        } else {
+          updateHomeEditorBuffer(vertical.next);
+        }
+      } else {
+        updateHomeEditorBuffer(taskComposerMoveVertical(homeEditorBuffer(), 1).next);
+      }
+      return true;
+    }
+    if (action === 'mux.home.editor.line.start') {
+      updateHomeEditorBuffer(taskComposerMoveLineStart(homeEditorBuffer()));
+      return true;
+    }
+    if (action === 'mux.home.editor.line.end') {
+      updateHomeEditorBuffer(taskComposerMoveLineEnd(homeEditorBuffer()));
+      return true;
+    }
+    if (action === 'mux.home.editor.word.left') {
+      updateHomeEditorBuffer(taskComposerMoveWordLeft(homeEditorBuffer()));
+      return true;
+    }
+    if (action === 'mux.home.editor.word.right') {
+      updateHomeEditorBuffer(taskComposerMoveWordRight(homeEditorBuffer()));
+      return true;
+    }
+    if (action === 'mux.home.editor.delete.backward') {
+      updateHomeEditorBuffer(taskComposerBackspace(homeEditorBuffer()));
+      return true;
+    }
+    if (action === 'mux.home.editor.delete.forward') {
+      updateHomeEditorBuffer(taskComposerDeleteForward(homeEditorBuffer()));
+      return true;
+    }
+    if (action === 'mux.home.editor.delete.word.backward') {
+      updateHomeEditorBuffer(taskComposerDeleteWordLeft(homeEditorBuffer()));
+      return true;
+    }
+    if (action === 'mux.home.editor.delete.line.start') {
+      updateHomeEditorBuffer(taskComposerDeleteToLineStart(homeEditorBuffer()));
+      return true;
+    }
+    if (action === 'mux.home.editor.delete.line.end') {
+      updateHomeEditorBuffer(taskComposerDeleteToLineEnd(homeEditorBuffer()));
+      return true;
+    }
+  }
+
+  if (input.includes(0x1b)) {
+    return false;
+  }
+
+  let next = homeEditorBuffer();
+  let changed = false;
+  for (const byte of input) {
+    if (byte >= 32 && byte <= 126) {
+      next = insertTaskComposerText(next, String.fromCharCode(byte));
+      changed = true;
+    }
+  }
+  if (!changed) {
+    return false;
+  }
+  updateHomeEditorBuffer(next);
+  return true;
+}

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

@@ -0,0 +1,79 @@
+import { extractOscColorReplies } from './palette-parsing.ts';
+
+export async function probeTerminalPalette(timeoutMs = 80): Promise<{
+  foregroundHex?: string;
+  backgroundHex?: string;
+  indexedHexByCode?: Record<number, string>;
+}> {
+  return await new Promise((resolve) => {
+    let finished = false;
+    let buffer = '';
+    let foregroundHex: string | undefined;
+    let backgroundHex: string | undefined;
+    const indexedHexByCode: Record<number, string> = {};
+
+    const finish = (): void => {
+      if (finished) {
+        return;
+      }
+      finished = true;
+      clearTimeout(timer);
+      process.stdin.off('data', onData);
+      resolve({
+        ...(foregroundHex !== undefined
+          ? {
+              foregroundHex,
+            }
+          : {}),
+        ...(backgroundHex !== undefined
+          ? {
+              backgroundHex,
+            }
+          : {}),
+        ...(Object.keys(indexedHexByCode).length > 0
+          ? {
+              indexedHexByCode,
+            }
+          : {}),
+      });
+    };
+
+    const onData = (chunk: Buffer): void => {
+      buffer += chunk.toString('utf8');
+      const extracted = extractOscColorReplies(buffer);
+      buffer = extracted.remainder;
+
+      if (extracted.foregroundHex !== undefined) {
+        foregroundHex = extracted.foregroundHex;
+      }
+      if (extracted.backgroundHex !== undefined) {
+        backgroundHex = extracted.backgroundHex;
+      }
+      for (const [key, value] of Object.entries(extracted.indexedHexByCode)) {
+        const index = Number.parseInt(key, 10);
+        if (Number.isInteger(index)) {
+          indexedHexByCode[index] = value;
+        }
+      }
+
+      if (
+        foregroundHex !== undefined &&
+        backgroundHex !== undefined &&
+        Object.keys(indexedHexByCode).length >= 16
+      ) {
+        finish();
+      }
+    };
+
+    const timer = setTimeout(() => {
+      finish();
+    }, timeoutMs);
+
+    process.stdin.on('data', onData);
+    let probeSequence = '\u001b]10;?\u0007\u001b]11;?\u0007';
+    for (let idx = 0; idx < 16; idx += 1) {
+      probeSequence += `\u001b]4;${String(idx)};?\u0007`;
+    }
+    process.stdout.write(probeSequence);
+  });
+}