@jmoyers/harness 0.1.10 → 0.1.20

package/src/services/runtime-conversation-title-edit.ts

@@ -20,100 +20,44 @@ export interface RuntimeConversationTitleEditServiceOptions<
   readonly clearDebounceTimer?: (timer: NodeJS.Timeout) => void;
 }
 
-export class RuntimeConversationTitleEditService<
-  TConversation extends ConversationTitleRecordLike,
-> {
-  private readonly setDebounceTimer: (callback: () => void, ms: number) => NodeJS.Timeout;
-  private readonly clearDebounceTimer: (timer: NodeJS.Timeout) => void;
-
-  constructor(private readonly options: RuntimeConversationTitleEditServiceOptions<TConversation>) {
-    this.setDebounceTimer = options.setDebounceTimer ?? setTimeout;
-    this.clearDebounceTimer = options.clearDebounceTimer ?? clearTimeout;
-  }
-
-  clearCurrentTimer(): void {
-    const edit = this.options.workspace.conversationTitleEdit;
-    if (edit === null) {
-      return;
-    }
-    this.clearTimer(edit);
-  }
-
-  schedulePersist(): void {
-    const edit = this.options.workspace.conversationTitleEdit;
-    if (edit === null) {
-      return;
-    }
-    this.clearTimer(edit);
-    edit.debounceTimer = this.setDebounceTimer(() => {
-      const latestEdit = this.options.workspace.conversationTitleEdit;
-      if (latestEdit === null || latestEdit.conversationId !== edit.conversationId) {
-        return;
-      }
-      latestEdit.debounceTimer = null;
-      this.queuePersist(latestEdit, 'debounced');
-    }, this.options.debounceMs);
-    edit.debounceTimer.unref?.();
-  }
-
-  stop(persistPending: boolean): void {
-    const edit = this.options.workspace.conversationTitleEdit;
-    if (edit === null) {
-      return;
-    }
-    this.clearTimer(edit);
-    if (persistPending) {
-      this.queuePersist(edit, 'flush');
-    }
-    this.options.workspace.conversationTitleEdit = null;
-    this.options.markDirty();
-  }
+export interface RuntimeConversationTitleEditService {
+  clearCurrentTimer(): void;
+  schedulePersist(): void;
+  stop(persistPending: boolean): void;
+  begin(conversationId: string): void;
+}
 
-  begin(conversationId: string): void {
-    const target = this.options.conversationById(conversationId);
-    if (target === undefined) {
-      return;
-    }
-    if (this.options.workspace.conversationTitleEdit?.conversationId === conversationId) {
-      return;
-    }
-    if (this.options.workspace.conversationTitleEdit !== null) {
-      this.stop(true);
-    }
-    this.options.workspace.conversationTitleEdit = {
-      conversationId,
-      value: target.title,
-      lastSavedValue: target.title,
-      error: null,
-      persistInFlight: false,
-      debounceTimer: null,
-    };
-    this.options.markDirty();
-  }
+export function createRuntimeConversationTitleEditService<
+  TConversation extends ConversationTitleRecordLike,
+>(
+  options: RuntimeConversationTitleEditServiceOptions<TConversation>,
+): RuntimeConversationTitleEditService {
+  const setDebounceTimer = options.setDebounceTimer ?? setTimeout;
+  const clearDebounceTimer = options.clearDebounceTimer ?? clearTimeout;
 
-  private clearTimer(edit: ConversationTitleEditState): void {
+  function clearTimer(edit: ConversationTitleEditState): void {
     if (edit.debounceTimer !== null) {
-      this.clearDebounceTimer(edit.debounceTimer);
+      clearDebounceTimer(edit.debounceTimer);
       edit.debounceTimer = null;
     }
   }
 
-  private queuePersist(edit: ConversationTitleEditState, reason: 'debounced' | 'flush'): void {
+  function queuePersist(edit: ConversationTitleEditState, reason: 'debounced' | 'flush'): void {
     const titleToPersist = edit.value;
     if (titleToPersist === edit.lastSavedValue) {
       return;
     }
     edit.persistInFlight = true;
-    this.options.markDirty();
-    this.options.queueControlPlaneOp(async () => {
+    options.markDirty();
+    options.queueControlPlaneOp(async () => {
       try {
-        const parsed = await this.options.updateConversationTitle({
+        const parsed = await options.updateConversationTitle({
           conversationId: edit.conversationId,
           title: titleToPersist,
         });
         const persistedTitle = parsed?.title ?? titleToPersist;
-        const latestConversation = this.options.conversationById(edit.conversationId);
-        const latestEdit = this.options.workspace.conversationTitleEdit;
+        const latestConversation = options.conversationById(edit.conversationId);
+        const latestEdit = options.workspace.conversationTitleEdit;
         const shouldApplyToConversation =
           latestEdit === null ||
           latestEdit.conversationId !== edit.conversationId ||
@@ -128,7 +72,7 @@ export class RuntimeConversationTitleEditService<
           }
         }
       } catch (error: unknown) {
-        const latestEdit = this.options.workspace.conversationTitleEdit;
+        const latestEdit = options.workspace.conversationTitleEdit;
         if (
           latestEdit !== null &&
           latestEdit.conversationId === edit.conversationId &&
@@ -138,12 +82,79 @@ export class RuntimeConversationTitleEditService<
         }
         throw error;
       } finally {
-        const latestEdit = this.options.workspace.conversationTitleEdit;
+        const latestEdit = options.workspace.conversationTitleEdit;
         if (latestEdit !== null && latestEdit.conversationId === edit.conversationId) {
           latestEdit.persistInFlight = false;
         }
-        this.options.markDirty();
+        options.markDirty();
       }
     }, `title-edit-${reason}:${edit.conversationId}`);
   }
+
+  function clearCurrentTimer(): void {
+    const edit = options.workspace.conversationTitleEdit;
+    if (edit === null) {
+      return;
+    }
+    clearTimer(edit);
+  }
+
+  function schedulePersist(): void {
+    const edit = options.workspace.conversationTitleEdit;
+    if (edit === null) {
+      return;
+    }
+    clearTimer(edit);
+    edit.debounceTimer = setDebounceTimer(() => {
+      const latestEdit = options.workspace.conversationTitleEdit;
+      if (latestEdit === null || latestEdit.conversationId !== edit.conversationId) {
+        return;
+      }
+      latestEdit.debounceTimer = null;
+      queuePersist(latestEdit, 'debounced');
+    }, options.debounceMs);
+    edit.debounceTimer.unref?.();
+  }
+
+  function stop(persistPending: boolean): void {
+    const edit = options.workspace.conversationTitleEdit;
+    if (edit === null) {
+      return;
+    }
+    clearTimer(edit);
+    if (persistPending) {
+      queuePersist(edit, 'flush');
+    }
+    options.workspace.conversationTitleEdit = null;
+    options.markDirty();
+  }
+
+  function begin(conversationId: string): void {
+    const target = options.conversationById(conversationId);
+    if (target === undefined) {
+      return;
+    }
+    if (options.workspace.conversationTitleEdit?.conversationId === conversationId) {
+      return;
+    }
+    if (options.workspace.conversationTitleEdit !== null) {
+      stop(true);
+    }
+    options.workspace.conversationTitleEdit = {
+      conversationId,
+      value: target.title,
+      lastSavedValue: target.title,
+      error: null,
+      persistInFlight: false,
+      debounceTimer: null,
+    };
+    options.markDirty();
+  }
+
+  return {
+    clearCurrentTimer,
+    schedulePersist,
+    stop,
+    begin,
+  };
 }

package/src/services/runtime-envelope-handler.ts

@@ -18,7 +18,13 @@ interface RuntimeEnvelopeOutputIngestResult<TConversation extends RuntimeEnvelop
   readonly previousCursor: number;
 }
 
-interface RuntimeEnvelopeHandlerOptions<
+interface RuntimeObservedEventEnvelopeInput {
+  readonly subscriptionId: string;
+  readonly cursor: number;
+  readonly event: StreamObservedEvent;
+}
+
+export interface RuntimeEnvelopeHandlerOptions<
   TConversation extends RuntimeEnvelopeConversationLike,
   TNormalizedEvent extends { ts: string },
 > {
@@ -73,126 +79,122 @@ interface RuntimeEnvelopeHandlerOptions<
   readonly nowIso: () => string;
   readonly recordOutputHandled: (durationMs: number) => void;
   readonly conversationById: (sessionId: string) => TConversation | undefined;
-  readonly applyObservedWorkspaceEvent: (event: StreamObservedEvent) => void;
-  readonly applyObservedGitStatusEvent: (event: StreamObservedEvent) => void;
-  readonly applyObservedTaskPlanningEvent: (event: StreamObservedEvent) => void;
+  readonly applyObservedEvent: (input: RuntimeObservedEventEnvelopeInput) => void;
   readonly idFactory: () => string;
 }
 
-export class RuntimeEnvelopeHandler<
+export function handleRuntimeEnvelope<
   TConversation extends RuntimeEnvelopeConversationLike,
   TNormalizedEvent extends { ts: string },
-> {
-  constructor(
-    private readonly options: RuntimeEnvelopeHandlerOptions<TConversation, TNormalizedEvent>,
-  ) {}
-
-  handleEnvelope(envelope: StreamServerEnvelope): void {
-    if (envelope.kind === 'pty.output') {
-      const outputHandledStartedAtNs = this.options.perfNowNs();
-      if (this.options.isRemoved(envelope.sessionId)) {
-        return;
-      }
-      const chunk = Buffer.from(envelope.chunkBase64, 'base64');
-      const outputIngest = this.options.ingestOutputChunk({
+>(
+  options: RuntimeEnvelopeHandlerOptions<TConversation, TNormalizedEvent>,
+  envelope: StreamServerEnvelope,
+): void {
+  if (envelope.kind === 'pty.output') {
+    const outputHandledStartedAtNs = options.perfNowNs();
+    if (options.isRemoved(envelope.sessionId)) {
+      return;
+    }
+    const chunk = Buffer.from(envelope.chunkBase64, 'base64');
+    const outputIngest = options.ingestOutputChunk({
+      sessionId: envelope.sessionId,
+      cursor: envelope.cursor,
+      chunk,
+      ensureConversation: options.ensureConversation,
+    });
+    const conversation = outputIngest.conversation;
+    options.noteGitActivity(conversation.directoryId);
+    options.recordOutputChunk({
+      sessionId: envelope.sessionId,
+      chunkLength: chunk.length,
+      active: options.activeConversationId() === envelope.sessionId,
+    });
+    options.startupOutputChunk(envelope.sessionId, chunk.length);
+    options.startupPaintOutputChunk(envelope.sessionId);
+    if (outputIngest.cursorRegressed) {
+      options.recordPerfEvent('mux.output.cursor-regression', {
         sessionId: envelope.sessionId,
+        previousCursor: outputIngest.previousCursor,
         cursor: envelope.cursor,
-        chunk,
-        ensureConversation: this.options.ensureConversation,
       });
-      const conversation = outputIngest.conversation;
-      this.options.noteGitActivity(conversation.directoryId);
-      this.options.recordOutputChunk({
-        sessionId: envelope.sessionId,
-        chunkLength: chunk.length,
-        active: this.options.activeConversationId() === envelope.sessionId,
-      });
-      this.options.startupOutputChunk(envelope.sessionId, chunk.length);
-      this.options.startupPaintOutputChunk(envelope.sessionId);
-      if (outputIngest.cursorRegressed) {
-        this.options.recordPerfEvent('mux.output.cursor-regression', {
-          sessionId: envelope.sessionId,
-          previousCursor: outputIngest.previousCursor,
-          cursor: envelope.cursor,
-        });
-      }
+    }
 
-      const normalized = this.options.mapTerminalOutputToNormalizedEvent(
-        chunk,
-        conversation.scope,
-        this.options.idFactory,
-      );
-      this.options.enqueueEvent(normalized);
-      conversation.lastEventAt = normalized.ts;
-      if (this.options.activeConversationId() === envelope.sessionId) {
-        this.options.markDirty();
-      }
-      const outputHandledDurationMs =
-        Number(this.options.perfNowNs() - outputHandledStartedAtNs) / 1e6;
-      this.options.recordOutputHandled(outputHandledDurationMs);
-      return;
+    const normalized = options.mapTerminalOutputToNormalizedEvent(
+      chunk,
+      conversation.scope,
+      options.idFactory,
+    );
+    options.enqueueEvent(normalized);
+    conversation.lastEventAt = normalized.ts;
+    if (options.activeConversationId() === envelope.sessionId) {
+      options.markDirty();
     }
+    const outputHandledDurationMs = Number(options.perfNowNs() - outputHandledStartedAtNs) / 1e6;
+    options.recordOutputHandled(outputHandledDurationMs);
+    return;
+  }
 
-    if (envelope.kind === 'pty.event') {
-      if (this.options.isRemoved(envelope.sessionId)) {
-        return;
-      }
-      const conversation = this.options.ensureConversation(envelope.sessionId);
-      this.options.noteGitActivity(conversation.directoryId);
-      const observedAt = this.options.observedAtFromSessionEvent(envelope.event);
-      const updatedAdapterState = this.options.mergeAdapterStateFromSessionEvent(
-        conversation.agentType,
-        conversation.adapterState,
-        envelope.event,
-        observedAt,
-      );
-      if (updatedAdapterState !== null) {
-        conversation.adapterState = updatedAdapterState;
-      }
-      const normalized = this.options.mapSessionEventToNormalizedEvent(
-        envelope.event,
-        conversation.scope,
-        this.options.idFactory,
-      );
-      if (normalized !== null) {
-        this.options.enqueueEvent(normalized);
-      }
-      if (envelope.event.type === 'session-exit') {
-        this.options.setExit(envelope.event.exit);
-        this.options.markSessionExited({
-          sessionId: envelope.sessionId,
-          exit: envelope.event.exit,
-          exitedAt: this.options.nowIso(),
-        });
-        this.options.deletePtySize(envelope.sessionId);
-      }
-      this.options.markDirty();
+  if (envelope.kind === 'pty.event') {
+    if (options.isRemoved(envelope.sessionId)) {
       return;
     }
+    const conversation = options.ensureConversation(envelope.sessionId);
+    options.noteGitActivity(conversation.directoryId);
+    const observedAt = options.observedAtFromSessionEvent(envelope.event);
+    const updatedAdapterState = options.mergeAdapterStateFromSessionEvent(
+      conversation.agentType,
+      conversation.adapterState,
+      envelope.event,
+      observedAt,
+    );
+    if (updatedAdapterState !== null) {
+      conversation.adapterState = updatedAdapterState;
+    }
+    const normalized = options.mapSessionEventToNormalizedEvent(
+      envelope.event,
+      conversation.scope,
+      options.idFactory,
+    );
+    if (normalized !== null) {
+      options.enqueueEvent(normalized);
+    }
+    if (envelope.event.type === 'session-exit') {
+      options.setExit(envelope.event.exit);
+      options.markSessionExited({
+        sessionId: envelope.sessionId,
+        exit: envelope.event.exit,
+        exitedAt: options.nowIso(),
+      });
+      options.deletePtySize(envelope.sessionId);
+    }
+    options.markDirty();
+    return;
+  }
 
-    if (envelope.kind === 'pty.exit') {
-      if (this.options.isRemoved(envelope.sessionId)) {
-        return;
-      }
-      const conversation = this.options.conversationById(envelope.sessionId);
-      if (conversation !== undefined) {
-        this.options.noteGitActivity(conversation.directoryId);
-        this.options.setExit(envelope.exit);
-        this.options.markSessionExited({
-          sessionId: envelope.sessionId,
-          exit: envelope.exit,
-          exitedAt: this.options.nowIso(),
-        });
-        this.options.deletePtySize(envelope.sessionId);
-      }
-      this.options.markDirty();
+  if (envelope.kind === 'pty.exit') {
+    if (options.isRemoved(envelope.sessionId)) {
       return;
     }
-
-    if (envelope.kind === 'stream.event') {
-      this.options.applyObservedWorkspaceEvent(envelope.event);
-      this.options.applyObservedGitStatusEvent(envelope.event);
-      this.options.applyObservedTaskPlanningEvent(envelope.event);
+    const conversation = options.conversationById(envelope.sessionId);
+    if (conversation !== undefined) {
+      options.noteGitActivity(conversation.directoryId);
+      options.setExit(envelope.exit);
+      options.markSessionExited({
+        sessionId: envelope.sessionId,
+        exit: envelope.exit,
+        exitedAt: options.nowIso(),
+      });
+      options.deletePtySize(envelope.sessionId);
     }
+    options.markDirty();
+    return;
+  }
+
+  if (envelope.kind === 'stream.event') {
+    options.applyObservedEvent({
+      subscriptionId: envelope.subscriptionId,
+      cursor: envelope.cursor,
+      event: envelope.event,
+    });
   }
 }

package/src/services/runtime-git-state.ts

@@ -35,42 +35,48 @@ interface RuntimeGitStateOptions<TRepositoryRecord extends RepositoryRecordShape
   readonly markDirty: () => void;
 }
 
-export class RuntimeGitState<TRepositoryRecord extends RepositoryRecordShape> {
-  constructor(private readonly options: RuntimeGitStateOptions<TRepositoryRecord>) {}
+export interface RuntimeGitState {
+  deleteDirectoryGitState(directoryId: string): void;
+  syncGitStateWithDirectories(): void;
+  noteGitActivity(directoryId: string | null): void;
+  applyObservedGitStatusEvent(observed: StreamObservedEvent): void;
+}
 
-  deleteDirectoryGitState(directoryId: string): void {
+export function createRuntimeGitState<TRepositoryRecord extends RepositoryRecordShape>(
+  options: RuntimeGitStateOptions<TRepositoryRecord>,
+): RuntimeGitState {
+  const deleteDirectoryGitState = (directoryId: string): void => {
     deleteDirectoryGitStateFn(
       directoryId,
-      this.options.directoryManager.mutableGitSummaries(),
-      this.options.directoryRepositorySnapshotByDirectoryId,
-      this.options.repositoryAssociationByDirectoryId,
+      options.directoryManager.mutableGitSummaries(),
+      options.directoryRepositorySnapshotByDirectoryId,
+      options.repositoryAssociationByDirectoryId,
     );
-  }
+  };
 
-  syncGitStateWithDirectories(): void {
-    this.options.directoryManager.syncGitSummariesWithDirectories(this.options.loadingSummary);
-    this.options.syncRepositoryAssociationsWithDirectorySnapshots();
-  }
+  const syncGitStateWithDirectories = (): void => {
+    options.directoryManager.syncGitSummariesWithDirectories(options.loadingSummary);
+    options.syncRepositoryAssociationsWithDirectorySnapshots();
+  };
 
-  noteGitActivity(directoryId: string | null): void {
-    if (directoryId === null || !this.options.directoryManager.hasDirectory(directoryId)) {
+  const noteGitActivity = (directoryId: string | null): void => {
+    if (directoryId === null || !options.directoryManager.hasDirectory(directoryId)) {
       return;
     }
-    this.options.directoryManager.ensureGitSummary(directoryId, this.options.loadingSummary);
-  }
+    options.directoryManager.ensureGitSummary(directoryId, options.loadingSummary);
+  };
 
-  applyObservedGitStatusEvent(observed: StreamObservedEvent): void {
+  const applyObservedGitStatusEvent = (observed: StreamObservedEvent): void => {
     const reduced = applyObservedGitStatusEventFn({
-      enabled: this.options.enabled,
+      enabled: options.enabled,
       observed,
-      gitSummaryByDirectoryId: this.options.directoryManager.mutableGitSummaries(),
-      loadingSummary: this.options.loadingSummary,
-      directoryRepositorySnapshotByDirectoryId:
-        this.options.directoryRepositorySnapshotByDirectoryId,
-      emptyRepositorySnapshot: this.options.emptyRepositorySnapshot,
-      repositoryAssociationByDirectoryId: this.options.repositoryAssociationByDirectoryId,
-      repositories: this.options.repositories,
-      parseRepositoryRecord: this.options.parseRepositoryRecord,
+      gitSummaryByDirectoryId: options.directoryManager.mutableGitSummaries(),
+      loadingSummary: options.loadingSummary,
+      directoryRepositorySnapshotByDirectoryId: options.directoryRepositorySnapshotByDirectoryId,
+      emptyRepositorySnapshot: options.emptyRepositorySnapshot,
+      repositoryAssociationByDirectoryId: options.repositoryAssociationByDirectoryId,
+      repositories: options.repositories,
+      parseRepositoryRecord: options.parseRepositoryRecord,
       repositoryRecordChanged: (previous, repository) =>
         previous === undefined ||
         previous.name !== repository.name ||
@@ -82,11 +88,18 @@ export class RuntimeGitState<TRepositoryRecord extends RepositoryRecordShape> {
       return;
     }
     if (reduced.repositoryRecordChanged) {
-      this.options.syncRepositoryAssociationsWithDirectorySnapshots();
-      this.options.syncTaskPaneRepositorySelection();
+      options.syncRepositoryAssociationsWithDirectorySnapshots();
+      options.syncTaskPaneRepositorySelection();
     }
     if (reduced.changed) {
-      this.options.markDirty();
+      options.markDirty();
     }
-  }
+  };
+
+  return {
+    deleteDirectoryGitState,
+    syncGitStateWithDirectories,
+    noteGitActivity,
+    applyObservedGitStatusEvent,
+  };
 }

package/src/services/runtime-layout-resize.ts

@@ -44,7 +44,9 @@ interface RuntimeLayoutResizeOptions<TConversation extends RuntimeLayoutResizeCo
   readonly clearTimeoutFn?: (timer: ReturnType<typeof setTimeout>) => void;
 }
 
-export class RuntimeLayoutResize<TConversation extends RuntimeLayoutResizeConversationRecord> {
+export class RuntimeLayoutResizeEngine<
+  TConversation extends RuntimeLayoutResizeConversationRecord,
+> {
   private resizeTimer: ReturnType<typeof setTimeout> | null = null;
   private pendingSize: RuntimeLayoutResizeSize | null = null;
   private lastResizeApplyAtMs = 0;