@jmoyers/harness 0.1.10 → 0.1.20

package/src/services/startup-background-resume.ts

@@ -12,24 +12,25 @@ interface StartupBackgroundResumeOptions {
   readonly clearTimeoutFn?: (handle: TimeoutHandle) => void;
 }
 
-export class StartupBackgroundResumeService {
-  private readonly setTimeoutFn: (handler: () => void, ms: number) => TimeoutHandle;
-  private readonly clearTimeoutFn: (handle: TimeoutHandle) => void;
+export interface StartupBackgroundResumeService {
+  run(initialActiveId: string | null): Promise<void>;
+}
 
-  constructor(private readonly options: StartupBackgroundResumeOptions) {
-    this.setTimeoutFn = options.setTimeoutFn ?? setTimeout;
-    this.clearTimeoutFn = options.clearTimeoutFn ?? clearTimeout;
-  }
+export function createStartupBackgroundResumeService(
+  options: StartupBackgroundResumeOptions,
+): StartupBackgroundResumeService {
+  const setTimeoutFn = options.setTimeoutFn ?? setTimeout;
+  const clearTimeoutFn = options.clearTimeoutFn ?? clearTimeout;
 
-  async run(initialActiveId: string | null): Promise<void> {
+  async function run(initialActiveId: string | null): Promise<void> {
     const sessionId = initialActiveId ?? 'none';
-    this.options.recordPerfEvent('mux.startup.background-start.wait', {
+    options.recordPerfEvent('mux.startup.background-start.wait', {
       sessionId,
-      maxWaitMs: this.options.maxWaitMs,
-      enabled: this.options.enabled ? 1 : 0,
+      maxWaitMs: options.maxWaitMs,
+      enabled: options.enabled ? 1 : 0,
     });
-    if (!this.options.enabled) {
-      this.options.recordPerfEvent('mux.startup.background-start.skipped', {
+    if (!options.enabled) {
+      options.recordPerfEvent('mux.startup.background-start.skipped', {
         sessionId,
         reason: 'disabled',
       });
@@ -39,27 +40,31 @@ export class StartupBackgroundResumeService {
     let timedOut = false;
     let timeoutHandle: TimeoutHandle | null = null;
     await Promise.race([
-      this.options.waitForSettled(),
+      options.waitForSettled(),
       new Promise<void>((resolve) => {
-        timeoutHandle = this.setTimeoutFn(() => {
+        timeoutHandle = setTimeoutFn(() => {
           timedOut = true;
           resolve();
-        }, this.options.maxWaitMs);
+        }, options.maxWaitMs);
       }),
     ]);
     if (timeoutHandle !== null) {
-      this.clearTimeoutFn(timeoutHandle);
+      clearTimeoutFn(timeoutHandle);
     }
 
-    this.options.recordPerfEvent('mux.startup.background-start.begin', {
+    options.recordPerfEvent('mux.startup.background-start.begin', {
       sessionId,
       timedOut,
-      settledObserved: this.options.settledObserved(),
+      settledObserved: options.settledObserved(),
     });
-    const queued = this.options.queuePersistedConversationsInBackground(initialActiveId);
-    this.options.recordPerfEvent('mux.startup.background-start.queued', {
+    const queued = options.queuePersistedConversationsInBackground(initialActiveId);
+    options.recordPerfEvent('mux.startup.background-start.queued', {
       sessionId,
       queued,
     });
   }
+
+  return {
+    run,
+  };
 }

package/src/services/startup-orchestrator.ts

@@ -1,13 +1,16 @@
 import type { ConversationState } from '../mux/live-mux/conversation-state.ts';
 import { StartupSequencer } from '../mux/startup-sequencer.ts';
 import { StartupBackgroundProbeService } from './startup-background-probe.ts';
-import { StartupBackgroundResumeService } from './startup-background-resume.ts';
+import {
+  createStartupBackgroundResumeService,
+  type StartupBackgroundResumeService,
+} from './startup-background-resume.ts';
 import { StartupOutputTracker } from './startup-output-tracker.ts';
-import { StartupPaintTracker } from './startup-paint-tracker.ts';
-import { StartupSettledGate } from './startup-settled-gate.ts';
-import { StartupShutdownService } from './startup-shutdown.ts';
+import { createStartupPaintTracker, type StartupPaintTracker } from './startup-paint-tracker.ts';
+import { createStartupSettledGate } from './startup-settled-gate.ts';
+import { finalizeStartupShutdown, type StartupShutdownServiceOptions } from './startup-shutdown.ts';
 import { StartupSpanTracker } from './startup-span-tracker.ts';
-import { StartupVisibility } from './startup-visibility.ts';
+import { createStartupVisibility } from './startup-visibility.ts';
 
 type PerfAttrs = Record<string, boolean | number | string>;
 
@@ -47,7 +50,7 @@ export class StartupOrchestrator {
   private readonly startupPaintTracker: StartupPaintTracker;
   private readonly startupBackgroundProbeService: StartupBackgroundProbeService;
   private readonly startupBackgroundResumeService: StartupBackgroundResumeService;
-  private readonly startupShutdownService: StartupShutdownService;
+  private readonly startupShutdownOptions: StartupShutdownServiceOptions;
 
   constructor(private readonly options: StartupOrchestratorOptions) {
     this.startupSequencer = new StartupSequencer({
@@ -58,8 +61,8 @@ export class StartupOrchestrator {
       options.startPerfSpan,
       options.startupSettleQuietMs,
     );
-    const startupVisibility = new StartupVisibility();
-    const startupSettledGate = new StartupSettledGate({
+    const startupVisibility = createStartupVisibility();
+    const startupSettledGate = createStartupSettledGate({
       startupSequencer: this.startupSequencer,
       startupSpanTracker: this.startupSpanTracker,
       getConversation: options.getConversation,
@@ -72,7 +75,7 @@ export class StartupOrchestrator {
       startupSpanTracker: this.startupSpanTracker,
       recordPerfEvent: options.recordPerfEvent,
     });
-    this.startupPaintTracker = new StartupPaintTracker({
+    this.startupPaintTracker = createStartupPaintTracker({
       startupSequencer: this.startupSequencer,
       startupSpanTracker: this.startupSpanTracker,
       startupVisibility,
@@ -88,7 +91,7 @@ export class StartupOrchestrator {
       refreshProcessUsage: options.refreshProcessUsage,
       recordPerfEvent: options.recordPerfEvent,
     });
-    this.startupBackgroundResumeService = new StartupBackgroundResumeService({
+    this.startupBackgroundResumeService = createStartupBackgroundResumeService({
       enabled: options.backgroundResumeEnabled,
       maxWaitMs: options.backgroundWaitMaxMs,
       waitForSettled: () => this.startupSequencer.waitForSettled(),
@@ -96,11 +99,11 @@ export class StartupOrchestrator {
       queuePersistedConversationsInBackground: options.queuePersistedConversationsInBackground,
       recordPerfEvent: options.recordPerfEvent,
     });
-    this.startupShutdownService = new StartupShutdownService({
+    this.startupShutdownOptions = {
       startupSequencer: this.startupSequencer,
       startupSpanTracker: this.startupSpanTracker,
       startupSettledGate,
-    });
+    };
   }
 
   get firstPaintTargetSessionId(): string | null {
@@ -161,6 +164,6 @@ export class StartupOrchestrator {
   }
 
   finalize(): void {
-    this.startupShutdownService.finalize();
+    finalizeStartupShutdown(this.startupShutdownOptions);
   }
 }

package/src/services/startup-paint-tracker.ts

@@ -26,7 +26,7 @@ interface StartupSettledGateLike {
   scheduleProbe(sessionId: string): void;
 }
 
-interface StartupPaintTrackerOptions {
+export interface StartupPaintTrackerOptions {
   readonly startupSequencer: StartupSequencerLike;
   readonly startupSpanTracker: StartupSpanTrackerLike;
   readonly startupVisibility: StartupVisibilityLike;
@@ -41,11 +41,16 @@ interface StartupRenderFlushInput {
   readonly changedRowCount: number;
 }
 
-export class StartupPaintTracker {
-  constructor(private readonly options: StartupPaintTrackerOptions) {}
+export interface StartupPaintTracker {
+  onRenderFlush(input: StartupRenderFlushInput): void;
+  onOutputChunk(sessionId: string): void;
+}
 
-  onRenderFlush(input: StartupRenderFlushInput): void {
-    const targetSessionId = this.options.startupSpanTracker.firstPaintTargetSessionId;
+export function createStartupPaintTracker(
+  options: StartupPaintTrackerOptions,
+): StartupPaintTracker {
+  function onRenderFlush(input: StartupRenderFlushInput): void {
+    const targetSessionId = options.startupSpanTracker.firstPaintTargetSessionId;
     if (targetSessionId === null) {
       return;
     }
@@ -56,24 +61,22 @@ export class StartupPaintTracker {
     ) {
       return;
     }
-    const startupSnapshot = this.options.startupSequencer.snapshot();
+    const startupSnapshot = options.startupSequencer.snapshot();
     if (!startupSnapshot.firstOutputObserved) {
       return;
     }
 
-    const glyphCells = this.options.startupVisibility.visibleGlyphCellCount(
-      input.activeConversation,
-    );
+    const glyphCells = options.startupVisibility.visibleGlyphCellCount(input.activeConversation);
     if (
       !startupSnapshot.firstPaintObserved &&
-      this.options.startupSequencer.markFirstPaintVisible(targetSessionId, glyphCells)
+      options.startupSequencer.markFirstPaintVisible(targetSessionId, glyphCells)
     ) {
-      this.options.recordPerfEvent('mux.startup.active-first-visible-paint', {
+      options.recordPerfEvent('mux.startup.active-first-visible-paint', {
         sessionId: targetSessionId,
         changedRows: input.changedRowCount,
         glyphCells,
       });
-      this.options.startupSpanTracker.endFirstPaintSpan({
+      options.startupSpanTracker.endFirstPaintSpan({
         observed: true,
         changedRows: input.changedRowCount,
         glyphCells,
@@ -81,35 +84,40 @@ export class StartupPaintTracker {
     }
 
     if (
-      this.options.startupSequencer.markHeaderVisible(
+      options.startupSequencer.markHeaderVisible(
         targetSessionId,
-        this.options.startupVisibility.codexHeaderVisible(input.activeConversation),
+        options.startupVisibility.codexHeaderVisible(input.activeConversation),
       )
     ) {
-      this.options.recordPerfEvent('mux.startup.active-header-visible', {
+      options.recordPerfEvent('mux.startup.active-header-visible', {
         sessionId: targetSessionId,
         glyphCells,
       });
     }
-    const selectedGate = this.options.startupSequencer.maybeSelectSettleGate(
+    const selectedGate = options.startupSequencer.maybeSelectSettleGate(
       targetSessionId,
       glyphCells,
     );
     if (selectedGate !== null) {
-      this.options.recordPerfEvent('mux.startup.active-settle-gate', {
+      options.recordPerfEvent('mux.startup.active-settle-gate', {
         sessionId: targetSessionId,
         gate: selectedGate,
         glyphCells,
       });
     }
-    this.options.startupSettledGate.scheduleProbe(targetSessionId);
+    options.startupSettledGate.scheduleProbe(targetSessionId);
   }
 
-  onOutputChunk(sessionId: string): void {
-    const targetSessionId = this.options.startupSpanTracker.firstPaintTargetSessionId;
+  function onOutputChunk(sessionId: string): void {
+    const targetSessionId = options.startupSpanTracker.firstPaintTargetSessionId;
     if (targetSessionId === null || sessionId !== targetSessionId) {
       return;
     }
-    this.options.startupSettledGate.scheduleProbe(sessionId);
+    options.startupSettledGate.scheduleProbe(sessionId);
   }
+
+  return {
+    onRenderFlush,
+    onOutputChunk,
+  };
 }

package/src/services/startup-persisted-conversation-queue.ts

@@ -12,34 +12,40 @@ export interface StartupPersistedConversationQueueServiceOptions<
   readonly markDirty: () => void;
 }
 
-export class StartupPersistedConversationQueueService<
-  TConversation extends StartupQueueConversationRecord,
-> {
-  constructor(
-    private readonly options: StartupPersistedConversationQueueServiceOptions<TConversation>,
-  ) {}
+export interface StartupPersistedConversationQueueService {
+  queuePersistedConversationsInBackground(activeSessionId: string | null): number;
+}
 
-  queuePersistedConversationsInBackground(activeSessionId: string | null): number {
-    const ordered = this.options.orderedConversationIds();
+export function createStartupPersistedConversationQueueService<
+  TConversation extends StartupQueueConversationRecord,
+>(
+  options: StartupPersistedConversationQueueServiceOptions<TConversation>,
+): StartupPersistedConversationQueueService {
+  function queuePersistedConversationsInBackground(activeSessionId: string | null): number {
+    const ordered = options.orderedConversationIds();
     let queued = 0;
     for (const sessionId of ordered) {
       if (activeSessionId !== null && sessionId === activeSessionId) {
         continue;
       }
-      const conversation = this.options.conversationById(sessionId);
+      const conversation = options.conversationById(sessionId);
       if (conversation === undefined || conversation.live) {
         continue;
       }
-      this.options.queueBackgroundOp(async () => {
-        const latest = this.options.conversationById(sessionId);
+      options.queueBackgroundOp(async () => {
+        const latest = options.conversationById(sessionId);
         if (latest === undefined || latest.live) {
           return;
         }
-        await this.options.startConversation(sessionId);
-        this.options.markDirty();
+        await options.startConversation(sessionId);
+        options.markDirty();
       }, `background-start:${sessionId}`);
       queued += 1;
     }
     return queued;
   }
+
+  return {
+    queuePersistedConversationsInBackground,
+  };
 }

package/src/services/startup-settled-gate.ts

@@ -22,7 +22,7 @@ interface StartupSpanTrackerLike {
   endSettledSpan(attrs: PerfAttrs): void;
 }
 
-interface StartupSettledGateOptions {
+export interface StartupSettledGateOptions {
   readonly startupSequencer: StartupSequencerLike;
   readonly startupSpanTracker: StartupSpanTrackerLike;
   readonly getConversation: (sessionId: string) => ConversationState | undefined;
@@ -30,38 +30,48 @@ interface StartupSettledGateOptions {
   readonly recordPerfEvent: (name: string, attrs: PerfAttrs) => void;
 }
 
-export class StartupSettledGate {
-  constructor(private readonly options: StartupSettledGateOptions) {}
+export interface StartupSettledGate {
+  clearTimer(): void;
+  signalSettled(): void;
+  scheduleProbe(sessionId: string): void;
+}
 
-  clearTimer(): void {
-    this.options.startupSequencer.clearSettledTimer();
+export function createStartupSettledGate(options: StartupSettledGateOptions): StartupSettledGate {
+  function clearTimer(): void {
+    options.startupSequencer.clearSettledTimer();
   }
 
-  signalSettled(): void {
-    this.options.startupSequencer.signalSettled();
+  function signalSettled(): void {
+    options.startupSequencer.signalSettled();
   }
 
-  scheduleProbe(sessionId: string): void {
-    this.options.startupSequencer.scheduleSettledProbe(sessionId, (event) => {
-      if (this.options.startupSpanTracker.firstPaintTargetSessionId !== event.sessionId) {
+  function scheduleProbe(sessionId: string): void {
+    options.startupSequencer.scheduleSettledProbe(sessionId, (event) => {
+      if (options.startupSpanTracker.firstPaintTargetSessionId !== event.sessionId) {
         return;
       }
-      const conversation = this.options.getConversation(event.sessionId);
+      const conversation = options.getConversation(event.sessionId);
       const glyphCells =
-        conversation === undefined ? 0 : this.options.visibleGlyphCellCount(conversation);
-      this.options.recordPerfEvent('mux.startup.active-settled', {
+        conversation === undefined ? 0 : options.visibleGlyphCellCount(conversation);
+      options.recordPerfEvent('mux.startup.active-settled', {
         sessionId: event.sessionId,
         gate: event.gate,
         quietMs: event.quietMs,
         glyphCells,
       });
-      this.options.startupSpanTracker.endSettledSpan({
+      options.startupSpanTracker.endSettledSpan({
         observed: true,
         gate: event.gate,
         quietMs: event.quietMs,
         glyphCells,
       });
-      this.options.startupSequencer.signalSettled();
+      options.startupSequencer.signalSettled();
     });
   }
+
+  return {
+    clearTimer,
+    signalSettled,
+    scheduleProbe,
+  };
 }

package/src/services/startup-shutdown.ts

@@ -23,31 +23,27 @@ interface StartupSettledGateLike {
   signalSettled(): void;
 }
 
-interface StartupShutdownServiceOptions {
+export interface StartupShutdownServiceOptions {
   readonly startupSequencer: StartupSequencerLike;
   readonly startupSpanTracker: StartupSpanTrackerLike;
   readonly startupSettledGate: StartupSettledGateLike;
 }
 
-export class StartupShutdownService {
-  constructor(private readonly options: StartupShutdownServiceOptions) {}
-
-  finalize(): void {
-    this.options.startupSpanTracker.endStartCommandSpan({
-      observed: false,
-    });
-    const startupSnapshot = this.options.startupSequencer.snapshot();
-    this.options.startupSpanTracker.endFirstOutputSpan({
-      observed: startupSnapshot.firstOutputObserved,
-    });
-    this.options.startupSpanTracker.endFirstPaintSpan({
-      observed: startupSnapshot.firstPaintObserved,
-    });
-    this.options.startupSettledGate.clearTimer();
-    this.options.startupSpanTracker.endSettledSpan({
-      observed: startupSnapshot.settledObserved,
-      gate: startupSnapshot.settleGate ?? 'none',
-    });
-    this.options.startupSettledGate.signalSettled();
-  }
+export function finalizeStartupShutdown(options: StartupShutdownServiceOptions): void {
+  options.startupSpanTracker.endStartCommandSpan({
+    observed: false,
+  });
+  const startupSnapshot = options.startupSequencer.snapshot();
+  options.startupSpanTracker.endFirstOutputSpan({
+    observed: startupSnapshot.firstOutputObserved,
+  });
+  options.startupSpanTracker.endFirstPaintSpan({
+    observed: startupSnapshot.firstPaintObserved,
+  });
+  options.startupSettledGate.clearTimer();
+  options.startupSpanTracker.endSettledSpan({
+    observed: startupSnapshot.settledObserved,
+    gate: startupSnapshot.settleGate ?? 'none',
+  });
+  options.startupSettledGate.signalSettled();
 }

package/src/services/startup-state-hydration.ts

@@ -10,7 +10,7 @@ interface DirectoryGitStatusLike<TRepository, TSummary, TSnapshot> {
   readonly repository: TRepository | null;
 }
 
-interface StartupStateHydrationServiceOptions<
+export interface StartupStateHydrationServiceOptions<
   TRepository extends RepositoryRecordLike,
   TSummary,
   TSnapshot,
@@ -34,56 +34,66 @@ interface StartupStateHydrationServiceOptions<
   readonly ensureActiveConversationId: () => void;
   readonly activeConversationId: () => string | null;
   readonly selectLeftNavConversation: (sessionId: string) => void;
-  readonly enterHomePane: () => void;
+  readonly enterStartupPane: () => void;
 }
 
-export class StartupStateHydrationService<
+export interface StartupStateHydrationService {
+  hydrateRepositoryList(): Promise<void>;
+  hydrateDirectoryGitStatus(): Promise<void>;
+  hydrateStartupState(afterCursor: number | null): Promise<void>;
+}
+
+export function createStartupStateHydrationService<
   TRepository extends RepositoryRecordLike,
   TSummary,
   TSnapshot,
   TDirectoryGitStatus extends DirectoryGitStatusLike<TRepository, TSummary, TSnapshot>,
-> {
-  constructor(
-    private readonly options: StartupStateHydrationServiceOptions<
-      TRepository,
-      TSummary,
-      TSnapshot,
-      TDirectoryGitStatus
-    >,
-  ) {}
-
-  async hydrateRepositoryList(): Promise<void> {
-    const rows = await this.options.listRepositories();
-    this.options.clearRepositories();
+>(
+  options: StartupStateHydrationServiceOptions<
+    TRepository,
+    TSummary,
+    TSnapshot,
+    TDirectoryGitStatus
+  >,
+): StartupStateHydrationService {
+  async function hydrateRepositoryList(): Promise<void> {
+    const rows = await options.listRepositories();
+    options.clearRepositories();
     for (const record of rows) {
-      this.options.setRepository(record.repositoryId, record);
+      options.setRepository(record.repositoryId, record);
     }
-    this.options.syncRepositoryAssociationsWithDirectorySnapshots();
+    options.syncRepositoryAssociationsWithDirectorySnapshots();
   }
 
-  async hydrateDirectoryGitStatus(): Promise<void> {
-    if (!this.options.gitHydrationEnabled) {
+  async function hydrateDirectoryGitStatus(): Promise<void> {
+    if (!options.gitHydrationEnabled) {
       return;
     }
-    const rows = await this.options.listDirectoryGitStatuses();
+    const rows = await options.listDirectoryGitStatuses();
     for (const record of rows) {
-      this.options.setDirectoryGitSummary(record.directoryId, record.summary);
-      this.options.setDirectoryRepositorySnapshot(record.directoryId, record.repositorySnapshot);
-      this.options.setDirectoryRepositoryAssociation(record.directoryId, record.repositoryId);
+      options.setDirectoryGitSummary(record.directoryId, record.summary);
+      options.setDirectoryRepositorySnapshot(record.directoryId, record.repositorySnapshot);
+      options.setDirectoryRepositoryAssociation(record.directoryId, record.repositoryId);
       if (record.repository !== null) {
-        this.options.setRepository(record.repository.repositoryId, record.repository);
+        options.setRepository(record.repository.repositoryId, record.repository);
       }
     }
-    this.options.syncRepositoryAssociationsWithDirectorySnapshots();
+    options.syncRepositoryAssociationsWithDirectorySnapshots();
   }
 
-  async hydrateStartupState(afterCursor: number | null): Promise<void> {
-    await this.options.hydrateConversationList();
-    await this.hydrateRepositoryList();
-    await this.options.hydrateTaskPlanningState();
-    await this.hydrateDirectoryGitStatus();
-    await this.options.subscribeTaskPlanningEvents(afterCursor);
-    this.options.ensureActiveConversationId();
-    this.options.enterHomePane();
+  async function hydrateStartupState(afterCursor: number | null): Promise<void> {
+    await options.hydrateConversationList();
+    await hydrateRepositoryList();
+    await options.hydrateTaskPlanningState();
+    await hydrateDirectoryGitStatus();
+    await options.subscribeTaskPlanningEvents(afterCursor);
+    options.ensureActiveConversationId();
+    options.enterStartupPane();
   }
+
+  return {
+    hydrateRepositoryList,
+    hydrateDirectoryGitStatus,
+    hydrateStartupState,
+  };
 }

package/src/services/startup-visibility.ts

@@ -1,9 +1,12 @@
 import type { ConversationState } from '../mux/live-mux/conversation-state.ts';
 
-export class StartupVisibility {
-  constructor() {}
+export interface StartupVisibility {
+  visibleGlyphCellCount(conversation: ConversationState): number;
+  codexHeaderVisible(conversation: ConversationState): boolean;
+}
 
-  visibleGlyphCellCount(conversation: ConversationState): number {
+export function createStartupVisibility(): StartupVisibility {
+  function visibleGlyphCellCount(conversation: ConversationState): number {
     const frame = conversation.oracle.snapshotWithoutHash();
     let count = 0;
     for (const line of frame.richLines) {
@@ -16,7 +19,7 @@ export class StartupVisibility {
     return count;
   }
 
-  codexHeaderVisible(conversation: ConversationState): boolean {
+  function codexHeaderVisible(conversation: ConversationState): boolean {
     const frame = conversation.oracle.snapshotWithoutHash();
     const rows: string[] = [];
     for (const line of frame.richLines) {
@@ -32,4 +35,9 @@ export class StartupVisibility {
     const text = rows.join('\n');
     return text.includes('OpenAI Codex') && text.includes('model:') && text.includes('directory:');
   }
+
+  return {
+    visibleGlyphCellCount,
+    codexHeaderVisible,
+  };
 }