@jmoyers/harness 0.1.0

package/src/mux/live-mux/args.ts

@@ -0,0 +1,142 @@
+import { randomUUID } from 'node:crypto';
+import { basename, join, resolve } from 'node:path';
+import type { EventScope } from '../../events/normalized-events.ts';
+
+const DEFAULT_RECORDING_FPS = 30;
+const RECORDINGS_DIR_RELATIVE_PATH = '.harness/recordings';
+
+interface MuxOptions {
+  codexArgs: string[];
+  storePath: string;
+  initialConversationId: string;
+  invocationDirectory: string;
+  controlPlaneHost: string | null;
+  controlPlanePort: number | null;
+  controlPlaneAuthToken: string | null;
+  recordingPath: string | null;
+  recordingGifOutputPath: string | null;
+  recordingFps: number;
+  scope: EventScope;
+}
+
+interface ParseMuxArgsOptions {
+  readonly env?: NodeJS.ProcessEnv;
+  readonly cwd?: string;
+  readonly randomId?: () => string;
+  readonly nowIso?: () => string;
+}
+
+function sanitizeFileToken(value: string): string {
+  const trimmed = value.trim();
+  if (trimmed.length === 0) {
+    return 'recording';
+  }
+  const normalized = trimmed.replace(/[^A-Za-z0-9._-]/g, '-');
+  return normalized.length > 0 ? normalized : 'recording';
+}
+
+export function parseMuxArgs(argv: string[], options: ParseMuxArgsOptions = {}): MuxOptions {
+  const env = options.env ?? process.env;
+  const cwd = options.cwd ?? process.cwd();
+  const randomId = options.randomId ?? randomUUID;
+  const nowIso = options.nowIso ?? (() => new Date().toISOString());
+
+  const codexArgs: string[] = [];
+  let controlPlaneHost = env.HARNESS_CONTROL_PLANE_HOST ?? null;
+  let controlPlanePortRaw = env.HARNESS_CONTROL_PLANE_PORT ?? null;
+  let controlPlaneAuthToken = env.HARNESS_CONTROL_PLANE_AUTH_TOKEN ?? null;
+  let recordEnabled = false;
+  const invocationDirectory = env.HARNESS_INVOKE_CWD ?? env.INIT_CWD ?? cwd;
+
+  for (let idx = 0; idx < argv.length; idx += 1) {
+    const arg = argv[idx]!;
+    if (arg === '--harness-server-host') {
+      const value = argv[idx + 1];
+      if (value === undefined) {
+        throw new Error('missing value for --harness-server-host');
+      }
+      controlPlaneHost = value;
+      idx += 1;
+      continue;
+    }
+
+    if (arg === '--harness-server-port') {
+      const value = argv[idx + 1];
+      if (value === undefined) {
+        throw new Error('missing value for --harness-server-port');
+      }
+      controlPlanePortRaw = value;
+      idx += 1;
+      continue;
+    }
+
+    if (arg === '--harness-server-token') {
+      const value = argv[idx + 1];
+      if (value === undefined) {
+        throw new Error('missing value for --harness-server-token');
+      }
+      controlPlaneAuthToken = value;
+      idx += 1;
+      continue;
+    }
+
+    if (arg === '--record') {
+      recordEnabled = true;
+      continue;
+    }
+
+    if (arg === '--record-path' || arg === '--record-output' || arg === '--record-fps') {
+      throw new Error(`${arg} is no longer supported; use --record`);
+    }
+
+    codexArgs.push(arg);
+  }
+
+  let controlPlanePort: number | null = null;
+  if (controlPlanePortRaw !== null) {
+    const parsed = Number.parseInt(controlPlanePortRaw, 10);
+    if (!Number.isFinite(parsed) || parsed <= 0 || parsed > 65535) {
+      throw new Error(`invalid --harness-server-port value: ${controlPlanePortRaw}`);
+    }
+    controlPlanePort = parsed;
+  }
+
+  if ((controlPlaneHost === null) !== (controlPlanePort === null)) {
+    throw new Error('both control-plane host and port must be set together');
+  }
+
+  let recordingPath: string | null = null;
+  let recordingGifOutputPath: string | null = null;
+  if (recordEnabled) {
+    const recordingsDirectoryPath = resolve(invocationDirectory, RECORDINGS_DIR_RELATIVE_PATH);
+    const nowToken = sanitizeFileToken(nowIso().replaceAll(':', '-').replaceAll('.', '-'));
+    const randomToken = sanitizeFileToken(randomId());
+    const stem = `${nowToken}-${randomToken}`;
+    recordingGifOutputPath = join(recordingsDirectoryPath, `${stem}.gif`);
+    recordingPath = join(recordingsDirectoryPath, `${stem}.jsonl`);
+  }
+
+  const initialConversationId = env.HARNESS_CONVERSATION_ID ?? `conversation-${randomId()}`;
+  const turnId = env.HARNESS_TURN_ID ?? `turn-${randomId()}`;
+
+  return {
+    codexArgs,
+    storePath: env.HARNESS_EVENTS_DB_PATH ?? '.harness/events.sqlite',
+    initialConversationId,
+    invocationDirectory,
+    controlPlaneHost,
+    controlPlanePort,
+    controlPlaneAuthToken,
+    recordingPath,
+    recordingGifOutputPath,
+    recordingFps: DEFAULT_RECORDING_FPS,
+    scope: {
+      tenantId: env.HARNESS_TENANT_ID ?? 'tenant-local',
+      userId: env.HARNESS_USER_ID ?? 'user-local',
+      workspaceId: env.HARNESS_WORKSPACE_ID ?? basename(cwd),
+      worktreeId: env.HARNESS_WORKTREE_ID ?? 'worktree-local',
+      conversationId: initialConversationId,
+      turnId,
+    },
+  };
+}

package/src/mux/live-mux/command-menu.ts

@@ -0,0 +1,298 @@
+export const COMMAND_MENU_MAX_RESULTS = 8;
+
+export interface CommandMenuState {
+  readonly query: string;
+  readonly selectedIndex: number;
+}
+
+export interface CommandMenuActionDescriptor {
+  readonly id: string;
+  readonly title: string;
+  readonly aliases?: readonly string[];
+  readonly keywords?: readonly string[];
+  readonly detail?: string;
+}
+
+export interface RegisteredCommandMenuAction<TContext> extends CommandMenuActionDescriptor {
+  readonly when?: (context: TContext) => boolean;
+  readonly run: (context: TContext) => Promise<void> | void;
+}
+
+interface CommandMenuMatch<TAction extends CommandMenuActionDescriptor> {
+  readonly action: TAction;
+  readonly score: number;
+}
+
+type CommandMenuActionProvider<TContext> = (
+  context: TContext,
+) => readonly RegisteredCommandMenuAction<TContext>[];
+
+interface CommandMenuInputReduction {
+  readonly nextState: CommandMenuState;
+  readonly submit: boolean;
+}
+
+function normalizeQuery(value: string): string {
+  return value.trim().toLowerCase().replace(/\s+/g, ' ');
+}
+
+function normalizedTokens(query: string): readonly string[] {
+  const normalized = normalizeQuery(query);
+  if (normalized.length === 0) {
+    return [];
+  }
+  return normalized.split(' ');
+}
+
+function normalizedAliases(action: CommandMenuActionDescriptor): readonly string[] {
+  return (action.aliases ?? [])
+    .map((value) => value.trim().toLowerCase())
+    .filter((value) => value.length > 0);
+}
+
+function normalizedKeywords(action: CommandMenuActionDescriptor): readonly string[] {
+  return (action.keywords ?? [])
+    .map((value) => value.trim().toLowerCase())
+    .filter((value) => value.length > 0);
+}
+
+function searchableParts(action: CommandMenuActionDescriptor): readonly string[] {
+  const parts = [
+    action.title.trim().toLowerCase(),
+    ...normalizedAliases(action),
+    ...normalizedKeywords(action),
+  ].filter((value) => value.length > 0);
+  return parts;
+}
+
+function actionScore(action: CommandMenuActionDescriptor, query: string): number | null {
+  const tokens = normalizedTokens(query);
+  if (tokens.length === 0) {
+    return 0;
+  }
+  const title = action.title.trim().toLowerCase();
+  const aliases = normalizedAliases(action);
+  const keywords = normalizedKeywords(action);
+  const haystack = searchableParts(action).join(' ');
+
+  for (const token of tokens) {
+    if (!haystack.includes(token)) {
+      return null;
+    }
+  }
+
+  const normalizedQuery = tokens.join(' ');
+  if (title.startsWith(normalizedQuery)) {
+    return 0;
+  }
+  const aliasPrefix = aliases.findIndex((alias) => alias.startsWith(normalizedQuery));
+  if (aliasPrefix >= 0) {
+    return 10 + aliasPrefix;
+  }
+
+  const titleContains = title.indexOf(normalizedQuery);
+  if (titleContains >= 0) {
+    return 100 + titleContains;
+  }
+  const aliasContains = aliases
+    .map((alias) => alias.indexOf(normalizedQuery))
+    .find((index) => index >= 0);
+  if (aliasContains !== undefined) {
+    return 200 + aliasContains;
+  }
+  const keywordContains = keywords
+    .map((keyword) => keyword.indexOf(normalizedQuery))
+    .find((index) => index >= 0);
+  if (keywordContains !== undefined) {
+    return 300 + keywordContains;
+  }
+  return 1000;
+}
+
+function clampSelectedIndex(selectedIndex: number, resultCount: number): number {
+  if (resultCount <= 0) {
+    return 0;
+  }
+  if (selectedIndex < 0) {
+    return 0;
+  }
+  if (selectedIndex >= resultCount) {
+    return resultCount - 1;
+  }
+  return selectedIndex;
+}
+
+function moveSelectionByDelta(selectedIndex: number, resultCount: number, delta: number): number {
+  if (resultCount <= 0) {
+    return 0;
+  }
+  const normalized = (selectedIndex + delta + resultCount * 4) % resultCount;
+  return normalized;
+}
+
+function isCsiArrowSequence(text: string, final: 'A' | 'B'): boolean {
+  if (!text.startsWith('\u001b[') || !text.endsWith(final)) {
+    return false;
+  }
+  const payload = text.slice(2, -1);
+  for (const char of payload) {
+    const isDigit = char >= '0' && char <= '9';
+    if (!isDigit && char !== ';') {
+      return false;
+    }
+  }
+  return true;
+}
+
+function isUpArrowSequence(text: string): boolean {
+  return isCsiArrowSequence(text, 'A') || text === '\u001bOA';
+}
+
+function isDownArrowSequence(text: string): boolean {
+  return isCsiArrowSequence(text, 'B') || text === '\u001bOB';
+}
+
+export function createCommandMenuState(): CommandMenuState {
+  return {
+    query: '',
+    selectedIndex: 0,
+  };
+}
+
+export function resolveCommandMenuMatches<TAction extends CommandMenuActionDescriptor>(
+  actions: readonly TAction[],
+  query: string,
+  limit = COMMAND_MENU_MAX_RESULTS,
+): readonly CommandMenuMatch<TAction>[] {
+  const scored = actions
+    .flatMap((action) => {
+      const score = actionScore(action, query);
+      return score === null ? [] : [{ action, score }];
+    })
+    .sort((left, right) => {
+      if (left.score !== right.score) {
+        return left.score - right.score;
+      }
+      return left.action.title.localeCompare(right.action.title);
+    });
+  return scored.slice(0, Math.max(0, limit));
+}
+
+export function reduceCommandMenuInput(
+  state: CommandMenuState,
+  input: Buffer,
+  visibleResultCount: number,
+): CommandMenuInputReduction {
+  const text = input.toString('utf8');
+  if (isUpArrowSequence(text)) {
+    return {
+      nextState: {
+        query: state.query,
+        selectedIndex: moveSelectionByDelta(state.selectedIndex, visibleResultCount, -1),
+      },
+      submit: false,
+    };
+  }
+  if (isDownArrowSequence(text)) {
+    return {
+      nextState: {
+        query: state.query,
+        selectedIndex: moveSelectionByDelta(state.selectedIndex, visibleResultCount, 1),
+      },
+      submit: false,
+    };
+  }
+
+  let query = state.query;
+  let selectedIndex = clampSelectedIndex(state.selectedIndex, visibleResultCount);
+  let submit = false;
+  for (const byte of input) {
+    if (byte === 0x0d || byte === 0x0a) {
+      submit = true;
+      break;
+    }
+    if (byte === 0x09 || byte === 0x0e) {
+      selectedIndex = moveSelectionByDelta(selectedIndex, visibleResultCount, 1);
+      continue;
+    }
+    if (byte === 0x10) {
+      selectedIndex = moveSelectionByDelta(selectedIndex, visibleResultCount, -1);
+      continue;
+    }
+    if (byte === 0x7f || byte === 0x08) {
+      if (query.length > 0) {
+        query = query.slice(0, -1);
+        selectedIndex = 0;
+      }
+      continue;
+    }
+    if (byte >= 32 && byte <= 126) {
+      query += String.fromCharCode(byte);
+      selectedIndex = 0;
+    }
+  }
+
+  return {
+    nextState: {
+      query,
+      selectedIndex: clampSelectedIndex(selectedIndex, visibleResultCount),
+    },
+    submit,
+  };
+}
+
+export function clampCommandMenuState(
+  state: CommandMenuState,
+  visibleResultCount: number,
+): CommandMenuState {
+  return {
+    query: state.query,
+    selectedIndex: clampSelectedIndex(state.selectedIndex, visibleResultCount),
+  };
+}
+
+export class CommandMenuRegistry<TContext> {
+  private readonly staticActions = new Map<string, RegisteredCommandMenuAction<TContext>>();
+  private readonly providers = new Map<string, CommandMenuActionProvider<TContext>>();
+
+  constructor() {}
+
+  registerAction(action: RegisteredCommandMenuAction<TContext>): () => void {
+    this.staticActions.set(action.id, action);
+    return () => {
+      this.staticActions.delete(action.id);
+    };
+  }
+
+  registerProvider(providerId: string, provider: CommandMenuActionProvider<TContext>): () => void {
+    this.providers.set(providerId, provider);
+    return () => {
+      this.providers.delete(providerId);
+    };
+  }
+
+  resolveActions(context: TContext): readonly RegisteredCommandMenuAction<TContext>[] {
+    const resolved: RegisteredCommandMenuAction<TContext>[] = [];
+    const seenIds = new Set<string>();
+    for (const action of this.staticActions.values()) {
+      if (action.when !== undefined && !action.when(context)) {
+        continue;
+      }
+      resolved.push(action);
+      seenIds.add(action.id);
+    }
+    for (const provider of this.providers.values()) {
+      for (const action of provider(context)) {
+        if (seenIds.has(action.id)) {
+          continue;
+        }
+        if (action.when !== undefined && !action.when(context)) {
+          continue;
+        }
+        resolved.push(action);
+        seenIds.add(action.id);
+      }
+    }
+    return resolved;
+  }
+}